document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2024-12-26 21:30:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'LCTT/master'

Browse Source
This commit is contained in:
Xingyu Wang 2020-09-12 20:19:30 +08:00
commit 4d7430c05f
4 changed files with 370 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
sources/talk/20200911 How open source legal teams can get to yes.md Normal file
View File

@ -0,0 +1,77 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (How open source legal teams can get to yes)
[#]: via: (https://opensource.com/article/20/9/advice-open-source-lawyer)
[#]: author: (Jeffrey Robert Kaufman https://opensource.com/users/jkaufman)
How open source legal teams can get to yes
======
Open source law has unusual requirements for success. Learn ways lawyers
can help their organizations find a path to open.
![whiteboard collaboration with the team][1]
As I shared in the [first part][2] of this two-part series, I am an open source lawyer for Red Hat. One important part of my job is to provide information to other companies, including their in-house counsel, about how Red Hat builds enterprise-class products with a completely open source development model and to answer their questions about open source licensing in general. After hearing about Red Hat's success, these conversations often turn to discussions about how their organization can evolve to be more open source-aware and capable, and lawyers at these meetings regularly ask how they can modify their practices to be more skilled in providing open source counsel to their employees. In these two articles, I'll share what I normally tell in-house counsel on these topics.
### Always find a path to open
My employer, Red Hat, is unique in its use of open source software in that our development model begins in the open source community with thousands of contributors and results in finished products that are tried, tested, and trusted. More specifically, through our unique development model, we start with community-created open source software and build upon each project to harden security, fix bugs, patch vulnerabilities, and add new features. We then contribute these improvements back to each project, so the entire open source community can benefit. The utilities to this approach are significant, including:
1. Leveraging innovation from others outside your organization by collaborating outside your internal teams
2. Avoiding the cost and inefficiency of developing and maintaining an open source solution by yourself when there are existing or potential communities working on the same problem with which you could collaborate
3. Through productive collaboration with partners and upstream project communities, avoiding the costly consequences of maintaining a downstream fork of the main project
1. Some companies find it tempting to create non-public forks of upstream code as a quick way to address a specific use case or because they are not inclined to collaborate in a community. However, the long-term maintenance burdens of such forks can be prohibitive because of increased development costs, loss of interoperability, and other reasons. By contrast, concentrating development in the original upstream community enables sharing development costs among all participants.
With few exceptions (such as Red Hat), most organizations that may use open source software have a proprietary licensing model (or the equivalent concept for software-as-a-service companies) and license proprietary software as part of their business. Such organizations feel that they have software components that provide some competitive advantage and do not wish to see those become available to others under open source terms. That is understandable. I would, however, encourage any open source lawyers counseling such companies to urge their clients towards an open source development model, especially for any software bits that are non-differentiating and common.
For example, if your company develops applications for mobile phones and you need a software module to read and write PNG image files, it would be much less expensive to use one of the popular open source PNG software modules available on GitHub. Encoding and decoding PNG images is likely a non-differentiating element to your business, so why spend precious engineering time to write your own version? Furthermore, writing your own module for this function may also lead to compatibility issues with other software that uses a commonly used open source module. Why? Although your module and the open source module may have been written to encode and decode to the published PNG specifications, oftentimes, there may be different interpretations of the specifications or errors in implementation. Everyone using the same module for this function ensures compatibility for most users and lowers the cost of development and maintenance.
It must also be appreciated that certain software may be required to remain proprietary and not subject to open source terms. Depending on the software architecture of your system and the open source software licenses in use, software bits that are intended to remain proprietary may become subject to open source license terms unless certain actions are taken (beyond the scope of this article). This is where some counseling to clients about license choice and architecture will become useful.
### Develop scalable solutions
For organizations that primarily license proprietary software grow and increase their use of open source software, review and approval requirements may grow (even exponentially in my experience). As such, such an organization may find itself in a difficult situation due to resource constraints. Scalable solutions that must be put into place are described below.
#### Empower and delegate to others
Lawyers cannot and should not be gatekeepers. It is inefficient and will most certainly cause bottlenecks in development and release times, producing frustration and lost revenue. Instead, explore delegating authority to capable individuals in product or project management and engineering. This allows an organization to scale efficiently and effectively. Educating your clients (see the next section) is vitally important for this to succeed.
One approach I have taken is to provide open source training to entire engineering organizations so that they can make basic licensing and architecture choices, while providing more specialized training to software leads to enable them to provide more complex guidance and decisions. Consider providing clear limits on authority at each level, including what types of issues and decisions must be escalated to you as their open source legal attorney. The specific levels of delegation for your organization will be a function of your team's experience with open source and sensitivities to certain open source concerns.
#### Educate clients
I have found that training is one of the most effective tools to migrate your organization to be more open source-aware. Training your software engineers and product managers is crucially important. Let me elaborate.
Although your software engineers are on the frontlines and may be quite knowledgeable about open source issues and licensing in general, it is still important to train them on your organization's particular requirements. For example, your company may permit only permissive open source licenses to be used and may have certain requirements for its copyright notices and source availability. To avoid problems in development that must be corrected later (a costly and time-consuming exercise), it is best to train engineers to minimize the likelihood of improper behavior, especially at the beginning of any development process (see the next section).
Product managers must also be trained. In many companies, a product manager is responsible for the classic four P's of marketing—Product, Price, Position, and Promotion—and is accountable for the full lifecycle of a product from cradle to death. All these aspects of a product manager's job may be impacted by the use of open source software. Understanding the requirements when using open source software is useful to them for the same reasons mentioned above. In addition and more importantly, product managers' significant influence in an organization means they are often able to effectuate any required change to process and policy. Product managers may become one of your strongest advocates for instituting process changes towards "open".
#### Early detection
It is very difficult and costly to resolve open source licensing issues near the end of the development process. As software approaches its release date, the architecture and the open source software modules have already been chosen. If an issue is detected, such as a copyleft software embedded in a proprietary software module (when that proprietary module is intended to not be subject to open source terms), modifying the architecture or modules at that development phase could be very difficult and expensive. Instead, work on developing processes that analyze architecture and choice of open source modules early in the process so that less costly and more effective course corrections may be made.
### Open source law's rewards
Practicing open source law is a rewarding profession due to the ability to influence an organization towards "open," which has significant benefits. Success depends on your ability to develop solutions for your organization that are workable and scalable as your organization grows and matures.
Find out what it takes to become an open source lawyer.
--------------------------------------------------------------------------------
via: https://opensource.com/article/20/9/advice-open-source-lawyer
作者：[Jeffrey Robert Kaufman][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/jkaufman
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/whiteboard-collaboration-team.png?itok=0A3WcgxZ (whiteboard collaboration with the team)
[2]: https://opensource.com/article/20/7/transitioning-open-source-part-1

78
sources/talk/20200911 Lenovo introduces four new HCI solutions.md Normal file
View File

@ -0,0 +1,78 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Lenovo introduces four new HCI solutions)
[#]: via: (https://www.networkworld.com/article/3573787/lenovo-introduces-four-new-hci-solutions.html)
[#]: author: (Andy Patrizio https://www.networkworld.com/author/Andy-Patrizio/)
Lenovo introduces four new HCI solutions
======
Hyperconverged infrastructure from Lenovo targets workloads including VDI, SAP HANA, Microsoft Azure, and Kubernetes.
Martyn Williams
Lenovo Data Center Group on Thursday introduced four new [hyperconverged infrastructure][1] (HCI) products aimed at a variety of workloads, including virtual desktop infrastructure (VDI), SAP HANA, Microsoft Azure, and Kubernetes.
HCI products have grown in popularity because they are easily deployed and can get a variety of workloads up and running quickly. HCI is available either in hardware/appliance form or as software. HCI hardware vendors are the usual suspects – HP Enterprise, Dell, Lenovo – while the software vendors include Nutanix and VMware.
Lenovo is focused on ready-to-deploy HCI solutions from both software firms. It boasts that its hardware is easy to deploy and manage with simple updates, automatic scalability and a consumption-based use model.
**READ MORE:** [Making the right hyperconvergence choice: HCI hardware or software?][2]
"This new normal is forcing many companies of different sizes and scale to think different. They are looking to figure out, 'how do I drive more resiliency to be able to be more efficient? How do I drive more agility to pivot based on my end customer needs and the way they are going to consume my services or my resources?'" said Kamran Amini, vice president and general manager of server, storage and software defined infrastructure, Lenovo Data Center Group, on a conference call briefing with reporters.
Here are the four products Lenovo announced.
### ThinkAgile HX
ThinkAgile HX is a new device powered by AMD EPYC processors and Nutanix software targeted at VDI and virtualization consolidation. With two CPUs and two GPUs in a 1U chassis, Lenovo customers can run their virtual desktop workloads with consistent performance with up to 50% fewer servers.
ThinkAgile HX is preloaded, factory-integrated and configured with Nutanix Enterprise Cloud software. Lenovo's ThinkAgile Network Orchestrator software is integrated with Nutanix Prism to reduce human error and downtime by automating virtualization configuration changes.
Availability is planned in late November as an appliance or a certified node.
### ThinkAgile MX And Microsoft Azure Stack
Lenovo and Microsoft have partnered to create the Lenovo ThinkAgile MX Azure Stack HCI Edge and Data Center line. [Azure Stack][3] is Microsoft's on-premises cloud software that allows an enterprise to replicate an Azure environment in their own data center and move workloads back and forth between on-prem and Azure.
The new ThinkAgile MX series of appliances provides a one-stop-shop for the Azure Stack HCI to give businesses an easy way to deploy, manage and scale Azure services from edge to core to cloud. The ThinkAgile MX is designed to enable customers to rapidly deploy a hybrid cloud infrastructure.
ThinkAgile MX will offer consumption-based, pay-as-you-go pricing of Azue Stack HCI and Azure Stack Hub. Lenovo did not say when it would be available.
### ThinkAgile VX and VMware
VMware and Lenovo have partnered to create a new series, the ThinkAgile VX HCI, which runs VMware's vSAN and ESXi and is designed specifically for SAP HANA databases. Lenovo said its new ThinkAgile VX 4S solution offers double the SAP HANA database memory and has direct connect NVMe to accelerate response times, speed business insights and improve total cost of ownership.
Lenovo ThinkAgile VX HCI are S/4HANA certified nodes that enable customers to modernize their infrastructure and improve performance of vSAN environments via the integration of Lenovo XClarity Management software and the new vSphere Lifecycle Manager (vLCM) tools.
The ThinkAgile VX will be generally available later in September.
### Diamanti SR360
Lenovo has also partnered with Diamanti, maker of Kubernetes management software, to create the Diamanti SR630 solution based on a ThinkSystem server. Diamanti specializes in enabling fast Kubernetes deployments and allowing organizations to run containerized applications across hybrid cloud environments.
The SR630 is a purpose-built application platform that combines Diamanti's Spektra Kubernetes platform with acceleration cards and Lenovo servers. The Diamanti SR630 enables customers to rapidly deploy a complete container and Kubernetes solution through plug-and-play networking and persistent storage.
The Diamanti SR630 is available now.
Join the Network World communities on [Facebook][4] and [LinkedIn][5] to comment on topics that are top of mind.
--------------------------------------------------------------------------------
via: https://www.networkworld.com/article/3573787/lenovo-introduces-four-new-hci-solutions.html
作者：[Andy Patrizio][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.networkworld.com/author/Andy-Patrizio/
[b]: https://github.com/lujun9972
[1]: https://www.networkworld.com/article/3207567/what-is-hyperconvergence.html
[2]: https://www.networkworld.com/article/3318683/making-the-right-hyperconvergence-choice-hci-hardware-or-software.html
[3]: https://www.networkworld.com/article/3385078/microsoft-introduces-azure-stack-for-hci.html
[4]: https://www.facebook.com/NetworkWorld/
[5]: https://www.linkedin.com/company/network-world

80
sources/talk/20200911 Why the future of IoT depends on open source.md Normal file
View File

@ -0,0 +1,80 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Why the future of IoT depends on open source)
[#]: via: (https://opensource.com/article/20/9/open-source-ai-iot)
[#]: author: (Pin Xue https://opensource.com/users/pinxue)
Why the future of IoT depends on open source
======
We're quickly moving from the Internet of Things (IoT) to the Artificial
Intelligence of Things (AIoT).
![Brain on a computer screen][1]
Most people are familiar with the [Internet of Things (IoT)][2], which refers to smart objects in a connected network, as this diagram shows.
![IoT diagram][3]
(PinXue, [CC BY-SA 4.0][4])
A "smart" object has a sense of its environment, and it makes decisions (locally or together with peers and a cloud server), then puts those decisions into action.
To be smart, the object must have a brain to carry intelligence. So far, the way to do this is to embed a computer in the object. For example, you can put a Cortex-M CPU with Bluetooth 5.1 in a chip smaller than 2x2mm and embed it into almost anything. This tiny device is more powerful than my first desktop PC.
A developer can write software for this tiny computer that uses the device's ability to gather input from all kinds of sensors (e.g., heat, light, moisture, and so on) and share and act on it using the device's screen, speaker, actuators (step motors, servos, and so on), and network.
### AI + IoT = AIoT
We often associate IoT with small programmable objects, like a smart lightbulb or door lock. While those are good uses of IoT, IoT is bigger than this. IoT is driving the next stage of our information-centric society.
Information systems have become a natural part of our everyday lives. You no longer have to sit in front of a computer to surf the internet because a smartphone can bring the whole world into the palm of your hand. Soon, you won't even need a phone—the popularization of smartwatches and other wearables is proving that. The convenience of these information systems encourages us to collect and use more data from everything. For instance, why couldn't a red light tell your car it will turn
green in 5 seconds, so it is not a smart move to release the brake
just yet.
![Relationships between computers, people, and things][5]
(PinXue, [CC BY-SA 4.0][4])
In a few years, humans won't be the major data producers and consumers. "Things" will be.
The abundance of data these things will create means we can no longer expect people to be able to analyze all the patterns and contents or even to write parsers to process the data. Based on the sheer amount of data, we need artificial intelligence (AI) to deal with it. AI will be applied to the entire data-processing process, and AI can transmit results instead of raw data. This will also reduce network traffic. Ideally, an AI will be able to drive smart objects to make decisions based on analyzed data on the spot.
Eventually, the goal is for smart objects to be able to live on their own, as you can see in _[This one owns itself][6]_, a story about a drone earning money to pay its recharging bill by making deliveries for a coffee company. The focus of this story is about the smart contract powered by blockchain, but in my opinion, it's achievable with the artificial intelligence of things (AIoT), the most fundamental element in smart devices.
### Open source AIoT operating systems
In the past, smart objects were programmed on bare metal. Now the scenario is a lot more complex. When creating a real-life AIoT system, there are too many details to account for on your own—all of the types of Systems on a Chip (SoC), sensors, actuators, network protocols, AI modeling, performance optimization, reliability, power management, firmware over the air (FOTA), security, and more. However, using an AIoT operating system enables all of this hard work to be accumulated and reused instead of starting over for each hardware or project.
AIoT is an open world, by its nature. The diversity of smart objects means no one can dominate the entire market, and we must work together to make things talk to each other. There are many levels of openness, such as file formats, protocol stacks, and APIs. These are all dependent upon the openness of the interface and the implementation of the source code.
Open source makes it possible to customize, reuse, and improve our code. This flexibility is important. The original author of an AIoT operating system cannot be an expert on everything. Other developers have different types of expertise they can use to build upon an open foundation.
If an operating system is well-designed and has an active community, it can provide reusable drivers, protocols, libraries, frameworks, middleware, and all manner of tools. All these components can speed product development dramatically. Without an open source platform, people have to build those parts again and again.
The [RT-Thread project][7] has been working toward this goal. RT-Thread is an open source IoT OS that started in 2006 and currently powers 600 million devices. Its IoTOS project is part of the general AIoT blueprint. It also comes with more than 200 open source packages and some commercial packages—and the number of each keeps increasing—that make it easier to develop for the AIoT.
If you're interested in building the IoT and working toward a better, smarter, and open future of AIoT, visit the [RT-Thread website][8] and see how you can lend a hand.
--------------------------------------------------------------------------------
via: https://opensource.com/article/20/9/open-source-ai-iot
作者：[Pin Xue][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/pinxue
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/brain_computer_solve_fix_tool.png?itok=okq8joti (Brain on a computer screen)
[2]: https://opensource.com/resources/internet-of-things
[3]: https://opensource.com/sites/default/files/uploads/iot-diagram.png (IoT diagram)
[4]: https://creativecommons.org/licenses/by-sa/4.0/
[5]: https://opensource.com/sites/default/files/uploads/computer-people-things.png (Relationships between computers, people, and things)
[6]: https://medium.com/@creole/6-this-one-owns-itself-9f6a3aa4382d
[7]: https://github.com/RT-Thread/rt-thread
[8]: https://www.rt-thread.io/

135
sources/tech/20200912 Shutdown Taking Too Long- Here-s How to Investigate and Fix Long Shutdown Time in Linux.md Normal file
View File

@ -0,0 +1,135 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Shutdown Taking Too Long? Here’s How to Investigate and Fix Long Shutdown Time in Linux)
[#]: via: (https://itsfoss.com/long-shutdown-linux/)
[#]: author: (Abhishek Prakash https://itsfoss.com/author/abhishek/)
Shutdown Taking Too Long? Here’s How to Investigate and Fix Long Shutdown Time in Linux
======
_**Your Linux system is taking too long to shut down? Here are the steps you can take to find out what is causing the delayed shutdown and fix the issue.**_
I hope you are a tad bit familiar with the [sigterm and sigkill][1] concept.
When you [shut down your Linux system][2], it sends the sigterm and politely asks the running processes to stop. Some processes misbehave and they ignore the sigterm and keep on running.
This could cause a delay to the shutdown process as your system will wait for the running processes to stop for a predefined time period. After this time period, it sends the kill signal to force stop all the remaining running processes and shuts down the system.
In fact, in some cases, you would see a message like ‘a stop job is running’ on the black screen.
If your system is taking too long in shutting down, you can do the following:
* Check which process/service is taking too long and if you can remove or reconfigure it to behave properly.
* Change the default waiting period before your system force stops the running processes. [Quick and dirty fix]
I am using Ubuntu here which uses systemd. The commands and steps here are valid for any Linux distribution that uses systemd (most of them do).
![][3]
### Check which processes are causing long shutdown in Linux
If you want to figure out what’s wrong, you should check what happened at the last shutdown. Use this command to get the power of ‘I know what you did last session’ (pun intended):
```
journalctl -rb -1
```
The [journalctl command][4] allows you to read system logs. With options ‘-b -1’ you filter the logs for the last boot session. With option ‘-r’, the logs are shown in reverse chronological order.
In other words, the ‘journalctl -rb -1’ command will show the system logs just before your Linux system was shutdown the last time. This is what you need to analyze the long shutdown problem in Linux.
No journal logs? Here’s what you should do
If there are no journal logs, please make sure that your distribution uses systemd.
Even on some Linux distributions with systemd, the journal logs are not activated by default.
Make sure that /var/log/journal exists. If it doesn’t, create it:
```
sudo mkdir /var/log/journal
```
You should also check the content of /etc/systemd/journald.conf file and make sure that the value of Storage is set to either auto or persistent.
Do you find something suspicious in the logs? Is there a process/service refusing to stop? If yes, investigate if you could remove it without side effects or if you could reconfigure it. Don’t go blindly removing stuff here, please. You should have knowledge of the process.
### Speed up shutdown in Linux by reducing default stop timeout [Quick fix]
The default wait period for the shut down is usually set at 90 seconds. Your system tries to force stop the services after this time period.
If you want your Linux system to shut down quickly, you can change this waiting period.
You’ll find all the systemd settings in the config file located at /etc/systemd/system.conf. This file should be filled with lots of line starting with #. They represent the default values of the entries in the file.
Before you do anything, it will be a good idea to make a copy of the original file.
```
sudo cp /etc/systemd/system.conf /etc/systemd/system.conf.orig
```
Look for DefaultTimeoutStopSec here. It should probably be set to 90 sec.
```
#DefaultTimeoutStopSec=90s
```
You have to change this value to something more convenient like 5 or 10 seconds.
```
DefaultTimeoutStopSec=5s
```
If you don’t know how to edit the config file in terminal, use this command to open the file for editing in your system’s default text editor (like Gedit):
```
sudo xdg-open /etc/systemd/system.conf
```
![Change Shutdown Time Settings Ubuntu][5]
Don’t forget to **remove the # before DefaultTimeoutStopSec**. Save the file and reboot your system.
This should help you reduce the shutdown delay for your Linux system.
Watchdog issue!
Linux has a module named watchdog that is used for monitoring whether certain services are running or not. It could be configured to automatically reboot systems if they are hanged due to software error.
It is unusual to use Watchdog on desktop systems because you can manually shutdown or reboot the system. It is often used on remote servers.
First check watchdog is running:
```
ps -af | grep watch*
```
If watchdog is running on your system, you can change the ShutdownWatchdogSec value from 10 minutes to something lower in the systemd config file /etc/systemd/system.conf.
**Were you able to fix the lengthy shutdown?**
I hope this tutorial helped you in investigating and fixing the long shutdown issue on your system. Do let me know in the comments if you managed to fix it.
--------------------------------------------------------------------------------
via: https://itsfoss.com/long-shutdown-linux/
作者：[Abhishek Prakash][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://itsfoss.com/author/abhishek/
[b]: https://github.com/lujun9972
[1]: https://linuxhandbook.com/sigterm-vs-sigkill/
[2]: https://itsfoss.com/schedule-shutdown-ubuntu/
[3]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2020/09/troubleshoot-long-shutdown-linux.gif?resize=800%2C450&ssl=1
[4]: https://linuxhandbook.com/journalctl-command/
[5]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2020/09/change-shutdown-time-settings-ubuntu.png?resize=797%2C322&ssl=1