document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2025-02-25 00:50:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'LCTT/master'

Browse Source
This commit is contained in:
Xingyu Wang 2019-10-17 08:30:10 +08:00
commit 2680f52114
11 changed files with 1162 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

134
published/20190301 Guide to Install VMware Tools on Linux.md Normal file
View File

@ -0,0 +1,134 @@
[#]: collector: (lujun9972)
[#]: translator: (tomjlw)
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-11467-1.html)
[#]: subject: (Guide to Install VMware Tools on Linux)
[#]: via: (https://itsfoss.com/install-vmware-tools-linux)
[#]: author: (Ankush Das https://itsfoss.com/author/ankush/)
在 Linux 上安装 VMware 工具
======
> VMware 工具通过允许你共享剪贴板和文件夹以及其他东西来提升你的虚拟机体验。了解如何在 Ubuntu 和其它 Linux 发行版上安装 VMware 工具。
![如何在 Linux 上安装 VMware 工具][4]
在先前的教程中，你学习了[在 Ubuntu 上安装 VMware 工作站][1]。你还可以通过安装 VMware 工具进一步提升你的虚拟机功能。
如果你已经在 VMware 上安装了一个访客机系统，你必须要注意 [VMware 工具][2]的要求 —— 尽管并不完全清楚到底有什么要求。
在本文中，我们将要强调 VMware 工具的重要性、所提供的特性，以及在 Ubuntu 和其它 Linux 发行版上安装 VMware 工具的方法。
### VMware 工具：概览及特性
![在 Ubuntu 上安装 VMware 工具][3]
出于显而易见的理由，虚拟机（你的访客机系统）并不能做到与宿主机上的表现完全一致。在其性能和操作上会有特定的限制。那就是为什么引入 VMware 工具的原因。
VMware 工具以一种高效的形式在提升了其性能的同时，也可以帮助管理访客机系统。
#### VMware 工具到底负责什么？
你大致知道它可以做什么，但让我们探讨一下细节：
* 同步访客机系统与宿主机系统间的时间以简化操作
* 提供从宿主机系统向访客机系统传递消息的能力。比如说，你可以复制文字到剪贴板，并将它轻松粘贴到你的访客机系统
* 在访客机系统上启用声音
* 提升访客机视频分辨率
* 修正错误的网络速度数据
* 减少不合适的色深
在访客机系统上安装了 VMware 工具会给它带来显著改变，但是它到底包含了什么特性才解锁或提升这些功能的呢？让我们来看看……
#### VMware 工具：核心特性细节
![用 VMware 工具在宿主机系统与访客机系统间共享剪切板][5]
如果你不想知道它包含什么来启用这些功能的话，你可以跳过这部分。但是为了好奇的读者，让我们简短地讨论它一下：
**VMware 设备驱动：** 它具体取决于操作系统。大多数主流操作系统都默认包含了设备驱动，因此你不必另外安装它。这主要涉及到内存控制驱动、鼠标驱动、音频驱动、网卡驱动、VGA 驱动以及其它。
**VMware 用户进程：** 这是这里真正有意思的地方。通过它你获得了在访客机和宿主机间复制粘贴和拖拽的能力。基本上，你可以从宿主机复制粘贴文本到虚拟机，反之亦然。
你同样也可以拖拽文件。此外，在你未安装 SVGA 驱动时它会启用鼠标指针的释放/锁定。
**VMware 工具生命周期管理：** 嗯，我们会在下面看看如何安装 VMware 工具，但是这个特性帮你在虚拟机中轻松安装/升级 VMware 工具。
**共享文件夹**：除了这些。VMware 工具同样允许你在访客机与宿主机系统间共享文件夹。
![使用 VMware 工具在访客机与宿机系统间共享文件][6]
当然，它的效果同样取决于访客机系统。例如在 Windows 上你通过 Unity 模式运行虚拟机上的程序并从宿主机系统上操作它。
### 如何在 Ubuntu 和其它 Linux 发行版上安装 VMware 工具
**注意：** 对于 Linux 操作系统，你应该已经安装好了“Open VM 工具”，大多数情况下免除了额外安装 VMware 工具的需要。
大部分时候，当你安装了访客机系统时，如果操作系统支持 [Easy Install][7] 的话你会收到软件更新或弹窗告诉你要安装 VMware 工具。
Windows 和 Ubuntu 不支持 Esay Install。因此即使你使用 Windows 作为你的宿主机或尝试在 Ubuntu 上安装 VMware 工具，你应该会看到一个和弹窗消息差不多的选项来轻松安装 VMware 工具。这是它应该看起来的样子：
![安装 VMware 工具的弹窗][8]
这是搞定它最简便的办法。因此当你配置虚拟机时确保你有一个通畅的网络连接。
如果你没收到任何弹窗或者选项来轻松安装 VMware 工具。你需要手动安装它。以下是如何去做：
1. 运行 VMware Workstation Player。
2. 从菜单导航至 “Virtual Machine -> Install VMware tools”。如果你已经安装了它并想修复安装，你会看到 “Re-install VMware tools” 这一选项出现。
3. 一旦你点击了，你就会看到一个虚拟 CD/DVD 挂载在访客机系统上。
4. 打开该 CD/DVD，并复制粘贴那个 tar.gz 文件到任何你选择的区域并解压，这里我们选择“桌面”作为解压目的地。
![][9]
5. 在解压后，运行终端并通过输入以下命令导航至里面的文件夹：
```
cd Desktop/VMwareTools-10.3.2-9925305/vmware-tools-distrib
```
你需要检查文件夹与路径名，这取决于版本与解压目的地，名字可能会改变。
![][10]
用你的存储位置（如“下载”）替换“桌面”，如果你安装的也是 10.3.2 版本，其它的保持一样即可。
6. 现在仅需输入以下命令开始安装：
```
sudo ./vmware-install.pl -d
```
![][11]
你会被询问密码以获得安装权限，输入密码然后应当一切都搞定了。
到此为止了，你搞定了。这系列步骤应当适用于几乎大部分基于 Ubuntu 的访客机系统。如果你想要在 Ubuntu 服务器上或其它系统安装 VMware 工具，步骤应该类似。
### 总结
在 Ubuntu Linux 上安装 VMware 工具应该挺简单。除了简单办法，我们也详述了手动安装的方法。如果你仍需帮助或者对安装有任何建议，在评论区评论让我们知道。
--------------------------------------------------------------------------------
via: https://itsfoss.com/install-vmware-tools-linux
作者：[Ankush Das][a]
选题：[lujun9972][b]
译者：[tomjlw](https://github.com/tomjlw)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://itsfoss.com/author/ankush/
[b]: https://github.com/lujun9972
[1]: https://itsfoss.com/install-vmware-player-ubuntu-1310/
[2]: https://kb.vmware.com/s/article/340
[3]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools-downloading.jpg?fit=800%2C531&ssl=1
[4]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/install-vmware-tools-linux.png?resize=800%2C450&ssl=1
[5]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools-features.gif?resize=800%2C500&ssl=1
[6]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools-shared-folder.jpg?fit=800%2C660&ssl=1
[7]: https://docs.vmware.com/en/VMware-Workstation-Player-for-Linux/15.0/com.vmware.player.linux.using.doc/GUID-3F6B9D0E-6CFC-4627-B80B-9A68A5960F60.html
[8]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools.jpg?fit=800%2C481&ssl=1
[9]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools-extraction.jpg?fit=800%2C564&ssl=1
[10]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools-folder.jpg?fit=800%2C487&ssl=1
[11]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools-installation-ubuntu.jpg?fit=800%2C492&ssl=1

55
sources/talk/20191012 How the oil and gas industry exploits IoT.md Normal file
View File

@ -0,0 +1,55 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (How the oil and gas industry exploits IoT)
[#]: via: (https://www.networkworld.com/article/3445204/how-the-oil-and-gas-industry-exploits-iot.html)
[#]: author: (Jon Gold https://www.networkworld.com/author/Jon-Gold/)
How the oil and gas industry exploits IoT
======
The energy industry has embraced IoT technology in its operations, from monitoring well production to predicting when its gear will need maintenance.
Like many traditional industries that have long-standing, tried-and-true methods of operation, the oil-and-gas sector hasn’t been the quickest to embrace [IoT][1] technology – despite having had instrumentation on drilling rigs, pipelines and refining facilities for decades, the extraction industry has only recently begun to work with modern IoT.
Part of the issue has been interoperability, according to Mark Carrier, oil-and-gas development director for RTI, which produces connectivity software for industrial companies. Energy companies are most comfortable working with the same vendors they’ve worked with before, but that tendency means there isn’t a strong impetus toward sharing data across platforms.
[[Get regularly scheduled insights by signing up for Network World newsletters.]][2]
“On a very low level, things are pretty well-connected, at the connectivity to the back-end they’re well-connected, but there’s a huge expense in understanding what that data is,” he said.
Christine Boles, a vice president in Intel’s IoT group, said that the older systems still being used by the industry have been tough to displace.
“The biggest challenge they’re facing is aging infrastructrure, and how they get to a more standardized, interoperable version,” she said.
Changes are coming, however, in part because energy prices have taken a hit in recent years. Oil companies have been looking to cut costs, and one of the easiest places to do that is in integration and automation. On a typical oil well, said Carrier, a driller will have up to 70 different companies’ products working – sensors covering everything from flow rates to temperature and pressure to azimuth and incline, different components of the drill itself – but until fairly recently, these all had to be independently monitored.
An IoT solution that can tie all these various threads of data together, of late, has become an attractive option for companies looking to minimize human error and glean real-time insights from the wide range of instrumentation present on the average oil rig.
Those threads are numerous, with a lot of vertically unique sensor and endpoint types. Mud pulse telemetry uses a module in a drill head to create slight fluctuations in the pressure of drilling fluid to pulse information to a receiver on the surface. Temperature and pressure sensors operating in the extreme environmental conditions of an active borehole might use heavily ruggedized serial cable to push data back aboveground.
Andre Kindness, a principal analyst at Forrester Research, said that the wide range of technologies, manufacturers and standards in use at any given oil-and-gas facility is the product of cutthroat competition
To continue reading this article register now
[Get Free Access][3]
[Learn More][4]   Existing Users [Sign In][3]
--------------------------------------------------------------------------------
via: https://www.networkworld.com/article/3445204/how-the-oil-and-gas-industry-exploits-iot.html
作者：[Jon Gold][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/Jon-Gold/
[b]: https://github.com/lujun9972
[1]: https://www.networkworld.com/article/3207535/what-is-iot-how-the-internet-of-things-works.html
[2]: https://www.networkworld.com/newsletters/signup.html
[3]: javascript://
[4]: https://www.networkworld.com/learn-about-insider/

170
sources/talk/20191012 The Role of Open Source Tools and Concepts in IoT Security.md Normal file
View File

@ -0,0 +1,170 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (The Role of Open Source Tools and Concepts in IoT Security)
[#]: via: (https://opensourceforu.com/2019/10/the-role-of-open-source-tools-and-concepts-in-iot-security/)
[#]: author: (Shashidhar Soppin https://opensourceforu.com/author/shashidhar-soppin/)
The Role of Open Source Tools and Concepts in IoT Security
======
[![][1]][2]
_With IoT devices permeating the commercial and personal space, their security becomes important. Hackers and malicious agents are always trying to exploit vulnerabilities in order to control these devices. The advantages of using open source rather than proprietary software needs no elaboration. Here is a selection of open source tools popular in the IoT field._
Security is one of the key factors to consider while choosing any IoT platform. The IoT market is very large and is growing constantly. Scary hacks and security breaches are happening to IoT related devices on a regular basis. These could be DoS (Denial of Service) attacks or may completely wipe out the firmware sitting on top of the device. Early detection and prevention of these attacks is a major concern for any enterprise or organisation. Many companies are adopting open source security tools and solutions and laying out predefined best practices for IoT security.
![Figure 1: The Mirai botnet][3]
**Recent security attacks**
As explained earlier, many attacks and threats targeting IoT systems have happened during the last few years. Let’s look at some of the major ones.
_**The Silex malware attack**_: In 2019, a 14-year-old hacker bricked at least around 4,000 IoT devices with a new strain of malware called Silex, which was used to abruptly shut down command and control servers. Larry Cashdollar, who is a senior security intelligence response engineer at Akamai, first discovered this malware on his honeypot. Like the BrickerBot malware in 2017, Silex too targeted insecure IoT devices and made them unusable.
Silex trashes an IoT device’s storage, dropping firewall rules, removing the network configuration and then halting the device completely. It is as destructive as it can get without actually frying the IoT device’s circuits. To recover, victims must manually reinstall the device’s firmware, a task too complicated for most device owners. (_<https://www.bleepingcomputer.com/news/security/new-silex-malware-trashes-iot-devices-using-default-passwords/>_)
_**The BrickerBot attack**_: The BrickerBot malware attack took place in 2017 and its author has claimed that 60,000 modems and routers across India lost Internet connectivity. The incident affected modems and routers belonging to two Indian state-owned telecommunications service providers, Bharat Sanchar Nigam Limited (BSNL) and Mahanagar Telephone Nigam Limited (MTNL). The attack was so intensive that from July 25 and up to July 29, users reported losing Internet connectivity as routers and modems became stuck with their red LED remaining always on. The main purpose of this bot is to brick devices so they will not be usable once attacked. (_<https://www.bleepingcomputer.com/news/security/brickerbot-author-retires-claiming-to-have-bricked-over-10-million-iot-devices/>_)
![Figure 2: Princeton IoT Icon][4]
**Note:** _Bricking is the process of changing the code of the device so that the hardware can no longer be used, thereby turning the device essentially into a brick (totally unusable)._
**The Mirai botnet attack:** The Mirai botnet attack took place in 2016. This was a major malware/virus attack. Mirai is a self-propagating botnet virus. The source code for it was made publicly available by the author after a successful and well-publicised attack on the Krebbs website. Since then, the source code has been built and used by many others to launch attacks on Internet infrastructure, causing major damage. The Mirai botnet code infects poorly protected Internet devices by using telnet to find those that are still using their factory default usernames and passwords. The effectiveness of Mirai is due to its ability to infect tens of thousands of these insecure devices and co-ordinate them to mount a DDoS attack against a chosen victim. (_<https://www.corero.com/resources/ddos-attack-types/mirai-botnet-ddos-attack>_)
**Detection and prevention of security attacks**
The major cause of concern in IoT devices is the use of the Linux OS by the device vendors instead of developing a custom OS, which is time consuming and expensive. Most of the attackers/hackers know this and so target these devices.
Some time back, Symantec came up with a solution for this by using a router called Norton Core (_<https://us.norton.com/core>_). This was not a success as it was expensive and had a monthly maintenance cost. In addition, people felt that it was too early to use such a router that came with a monthly subscription, since most homes still do not have enough IoT enabled devices to make such an investment worthwhile.
**Open source security tools**
Subsequently, many state-of-art security tools with multiple security features have been launched. Some of the most used and popular open source security tools are featured below.
**Princeton IoT-Inspector**
This is an open source desktop tool with a one-click, easy-to-install process. It has many built-in security validation features:
* Automatically discovers IoT devices and analyses their network traffic.
* Helps one to identify security and privacy issues with graphs and tables.
* Requires minimal technical skills and no special hardware.
This tool can be configured on Linux/Mac (Windows support is still under discussion).
**What data does IoT Inspector collect?** For each IoT device in the network, IoT Inspector collects the following information and sends it to identified secure servers at the Princeton University:
* Device manufacturers, based on the first six characters of the MAC address of each device on the network
* DNS requests and responses
* Destination IP addresses and ports contacted — but not the public-facing IP address (i.e., the one that your ISP assigns to you)
* Scrambled MAC addresses (i.e., those with a salted hash)
* Aggregate traffic statistics, i.e., the number of bytes sent and received over a period of time
* The names of devices on the identified network
By collecting the above types of data, there are some risks involved, such as:
* Performance degradation
* Data breaches
* Best-effort support
![Figure 3: OWASP IoT][5]
_**How the security validation is done:**_ Princeton releases its findings in a journal/conference publication. When consumers are unsure about whether to buy a new IoT device or not, they can read the relevant papers before making a decision, checking if the device of interest features in the Princeton data. Otherwise, the consumer can always buy the product, analyse it with IoT Inspector, and return it if the results are unsatisfactory.
**Open Web Application Security Project (OWASP) set of standards**
OWASP is an open community dedicated to enabling organisations to conceive, develop, acquire, operate and maintain applications that can be trusted.
_**Testing an IoT device for poor authentication/authorisation (OWASP I2):**_ When we think of weak authentication, we might think of passwords that are not changed on a regular basis, six-to-eight character passwords that are nonetheless easy to guess, or of systems without multi-factor authentication mechanisms. Unfortunately, with many smart devices, weak authentication causes major havoc.
Many of the IoT devices are secured with default passwords like ‘1234’, ‘password’, or ‘ABCD’. Users put their password checks in client-side Java code, send credentials without using HTTPS or other encrypted transport protocols, or require no passwords at all. This kind of mismanagement of passwords causes a lot of damage to devices.
Many OWASP l2 to I10 standards provide different levels of security, which are listed in Figure 3.
* I1 – Insecure Web interface
* I2 – Insufficient authentication/authorisation
* I3 – Insecure network services
* I4 – Lack of transport encryption
* I5 – Privacy concerns
* I6 – Insecure cloud interface
* I7 – Insecure mobile interface
* I8 – Insufficient security configurability
* I9 – Insecure software/firmware
* I10 – Poor physical security
**Mainflux platform: For authentication and authorisation**
Mainflux is an open source IoT platform providing features like edge computing and consulting services. Mainflux Labs is a technology company offering an end-to-end, open source patent-free IoT platform, an LF EdgeX Foundry compliant IoT edge gateway with an interoperable ecosystem of plug-and-play components, and consulting services for the software and hardware layers of the IoT technology. It provides enhanced and fine-grained security via the deployment-ready Mainflux authentication and authorisation server, with an access control scheme based on customisable API keys and scoped JWT. It also offers mutual TLS (mTLS) authentication using X.509 certificates, NGINX reverse proxy for security, load balancing and termination of TLS and DTLS connections, etc. Many of these features can be explored and used according to the need of the hour.
**Best practices for building a secure IoT framework**
To prevent/avoid attacks on any IoT device, environment or ecosystem, the following best practices need to be applied:
* Always use strong passwords for device accounts and Wi-Fi networks.
* It is a best practice to always change default passwords.
* Use stronger and most recent encryption methods when setting up Wi-Fi networks such as WPA2.
* Develop the habit of disabling or protecting the remote access to IoT devices when not needed.
* Use wired connections instead of wireless, where possible.
* Be careful when buying used IoT devices, as they could have been tampered with. It is better to consult a genuine authority and confirm the device’s validation or buy from a certified authority.
* Research the vendor’s device security measures as well as the features that they support.
* Modify the privacy and security settings of the device to meet your needs immediately after buying the device.
* It is better to disable features that are not used frequently.
* Install updates regularly, when they become available. It is a best practice to use the latest firmware updates.
* Ensure that an outage due to jamming or a network failure does not result in an insecure state of the installation.
* Verify if the smart features are required or if a normal device suffices for the purpose.
**Best practices for designers of IoT frameworks and device manufacturers**
* Always use SSL/TLS-encrypted connections for communication purposes.
* Check the SSL certificate and the certificate revocation list.
* Allow and encourage the use of strong passwords and change default passwords immediately.
* Provide a simple and secure update process with a chain of trust.
* Provide a standalone option that works without Internet and cloud connections.
* Prevent brute-force attacks at the login stage through account lockout measures or with multi-factor types of authentication mechanisms.
* Implement a smart fail-safe mechanism when the connection or power is lost or jammed.
* Remove unused tools and allow only trusted applications and software.
* Where applicable, security analytics features should be provided in the device management strategy.
IoT developers and designers should include security at the start of the device development process, irrespective of whether the device is for the consumer market, the enterprise or industry. Incorporating security at the design phase always helps. Enabling security by default is very critical, as is providing the most recent operating systems and using secure hardware with the latest firmware versions.
**Enabling PKI and digital certificates**
Public key infrastructure (PKI) and 509 digital certificates play important and critical roles in the development of secure IoT devices. It is always a best practice to provide the trust and control needed to distribute and identify public encryption keys, secure data exchanges over networks and verify the identity.
**API (application performance indicator) security**
For any IoT environment, API security is essential to protect the integrity of data. As this data is being sent from IoT devices to back-end systems, we always have to make sure only authorised devices, developers and apps communicate with these APIs.
**Patch management/continuous software updates**
This is one crucial aspect in IoT security management. Providing the means of updating devices and software either over network connections or through automation is critical. Having a coordinated disclosure of vulnerabilities is also important to updating devices as soon as possible. Consider end-of-life strategies as well.
Always remember that hard coded credentials should never be used nor be part of the design process. If there are any default credentials, users should immediately update them using strong passwords as described earlier, or follow multi-factor or biometric authentication mechanisms.
**Hardware security**
It is absolutely essential to make devices tamper-proof or tamper-evident, and this can be achieved by endpoint hardening.
Strong encryption is critical to securing communication between devices. It is always a best practice to encrypt data at rest and in transit using cryptographic algorithms.
IoT and operating system security are new to many security teams. It is critical to keep security staff up to date with new or unknown systems, enabling them to learn new architectures and programming languages to be ready for new security challenges. C-level and cyber security teams should receive regular training to keep up with modern threats and security measures.
--------------------------------------------------------------------------------
via: https://opensourceforu.com/2019/10/the-role-of-open-source-tools-and-concepts-in-iot-security/
作者：[Shashidhar Soppin][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://opensourceforu.com/author/shashidhar-soppin/
[b]: https://github.com/lujun9972
[1]: https://i0.wp.com/opensourceforu.com/wp-content/uploads/2019/10/Security-of-IoT-devices.jpg?resize=696%2C550&ssl=1 (Security of IoT devices)
[2]: https://i0.wp.com/opensourceforu.com/wp-content/uploads/2019/10/Security-of-IoT-devices.jpg?fit=900%2C711&ssl=1
[3]: https://i2.wp.com/opensourceforu.com/wp-content/uploads/2019/10/Figure-1-The-Mirai-botnet.jpg?resize=350%2C188&ssl=1
[4]: https://i2.wp.com/opensourceforu.com/wp-content/uploads/2019/10/Figure-2-Princeton-IoT-Icon.jpg?resize=350%2C329&ssl=1
[5]: https://i0.wp.com/opensourceforu.com/wp-content/uploads/2019/10/Figure-3-OWASP-IoT.jpg?resize=350%2C147&ssl=1

148
sources/talk/20191014 A Primer on Open Source IoT Middleware for the Integration of Enterprise Applications.md Normal file
View File

@ -0,0 +1,148 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (A Primer on Open Source IoT Middleware for the Integration of Enterprise Applications)
[#]: via: (https://opensourceforu.com/2019/10/a-primer-on-open-source-iot-middleware-for-the-integration-of-enterprise-applications/)
[#]: author: (Gopala Krishna Behara https://opensourceforu.com/author/gopalakrishna-behara/)
A Primer on Open Source IoT Middleware for the Integration of Enterprise Applications
======
[![][1]][2]
_The Internet of Things (IoT) integrates a virtual world of information to the real world of devices through a layered architecture. IoT middleware is an interface between the physical world (hardware layer) of devices with the virtual world (application layer), which is responsible for interacting with devices and information management systems. This article discusses IoT middleware, the characteristics of open source IoT middleware, IoT middleware platform architecture and key open source IoT middleware platforms._
With billions of devices generating trillions of bytes of data, there is a need for heterogeneous IoT device management and application enablement. This requires a revamp of existing architectures. There is a need to identify industry agnostic application middleware to address the complexity of IoT solutions, future changes, the integration of IoT with mobile devices, various types of machinery, equipment and tablets, among other devices.
According to Statista, the total installed base of IoT connected devices is projected to be 75.44 billion worldwide by 2025.
Most of the IoT applications are heterogeneous, and domain specific. Deciding on the appropriate IoT middleware for app development is the major challenge faced by developers today. The functionalities provided by different middleware vendors are almost similar but differ mainly in their underlying technologies. Middleware services provided by different IoT vendors include data acquisition, device management, data storage, security and analytics. Selecting the right middleware platform is one of the critical steps in application development.
The important parameters for choosing the right middleware for an IoT application are scalability, availability, the ability to handle huge amounts of data, a high processing speed, flexibility, integration with varied analytical tools, security and cost.
**Industry adoption of open source middleware in IoT**
The market for IoT middleware was valued at US$ 6.44 billion in 2018 and is expected to reach a value of US$ 18.68 billion by 2024 at a CAGR of 19.72 per cent, over the forecast period 2019-2024 (_<https://www.mordorintelligence.com/industry-reports/iot-middle-ware-market>_).
According to an Ericsson forecast (_<https://www.ericsson.com/en/mobility-report/internet-of-things-forecast>_), there will be around 29 billion connected devices in use by 2022, of which around 18 billion will be related to IoT. Gartner forecasts that 14.2 billion connected things will be in use in 2019, and that the total will reach 25 billion by 2021, producing immense volume of data.
**IoT middleware and its features**
Middleware acts as an agent between the service providers (IoT devices) and service consumers (enterprise applications). It is a software layer that sits in between applications and objects. It is a mediator interface that enables the interaction between the Internet and ‘things’. It hides the heterogeneity among the devices, components and technology of an IoT system. Middleware provides solutions to frequently encountered problems, such as interoperability, security and dependability. The following are the important features of middleware, which improve the performance of devices.
**Flexibility:** This feature helps in establishing better connectivity, which improves the communication between applications and things. There are different kinds of flexibility (e.g., response time, faster to evolve and change).
**Transparency:** Middleware hides many complexities and architectural information details from both the application and the object sides, so that the two can communicate with minimum knowledge of either side.
**Interoperability:** This functionality allows two sets of applications on interconnected networks to exchange data and services meaningfully with different assumptions on protocols, data models, and configurations.
**Platform portability:** An IoT platform should be able to communicate from everywhere, anytime with any device. Middleware runs on the user side and can provide independence from network protocols, programming languages, OSs and others.
**Re-usability:** This feature makes designing and developing easier by modifying system components and assets for specific requirements, which results in cost efficiency.
**Maintainability:** Maintainability has a fault tolerance approximation. Middleware performs maintainability efficiently and extends the network.
**Security:** Middleware should provide different security measures for ubiquitous applications and pervasive environments. Authentication, authorisation and access control helps in verification and accountability.
**Characteristics of open source IoT middleware**
An open source IoT middleware platform should be fault-tolerant and highly available. It has the following characteristics:
* No vendor lock-in, and it comes with the surety of seamless integration of enterprise-wide tools, applications, products and systems developed and deployed by different organisations and vendors.
* Open source middleware increases the productivity, speeds up time to market, reduces risk and increases quality.
* Adoption of open source middleware enhances the interoperability with other enterprise applications because of the ability to reuse recommended software stacks, libraries and components.
* IoT middleware platforms should support open APIs, deployment models of the cloud, and be highly available.
* It should support open data formats like RestAPI, JSON, XML and Java, and be freely available
* An IoT middleware platform should support multi-service and heterogeneous devices, and be compatible with the hardware for sensing environmental information.
* Migration to any new platform or system should be seamless. It should be possible to adopt or integrate with any solution.
* The information data model should be distributed and extensible, providing availability and scalability to the system.
* An IoT middleware platform should support major communication protocols like MQTT, CoAP, HTTP, WebSockets, etc.
* An IoT middleware platform should support different security features like encryption, authentication, authorisation and auditing.
* It should support technologies such as M2M applications, real-time analytics, machine learning, artificial intelligence, analytics, visualisation and event reporting.
**IoT middleware architecture**
The middleware mediates between IoT data producers and the consumers. APIs for interactions with the middleware are based on standard application protocols.
API endpoints for accessing the data and services should be searchable via an open catalogue, and should contain linked metadata about the resources.
The device manager communicates messages to the devices. The database needs to access and deliver messages to the devices with minimum latency.
Data processing involves data translation, aggregation and data filtering on the incoming data, which enables real-time decision making at the edge. The database needs to support high-speed reads and writes with sub-millisecond latency. It helps in performing complex analytical computations on the data.
The IoT data stream normalises the data to a common format and sends it to enterprise systems. The database needs to perform the data transformation operations efficiently.
Middleware supports the authentication of users, organisations, applications and devices. It supports functionalities like certificates, password credentials, API keys, tokens, etc. It should also support single sign-on, time based credentials, application authentication (via signatures) and device authentication (via certificates).
Logging is necessary for both system debugging as well as auditing. Middleware manages the logging of system debugging and auditing details. It helps to track the status of the various services, APIs, etc, and administers them.
**Key open source IoT middleware platforms**
Holistically, an IoT implementation covers data collection and insertion through sensors as well as giving control back to devices. The different types of IoT middleware are categorised as:
* Application-centric (application and data management)
* Platform-centric (application enablement, device management and connectivity management)
* Industry-specific (manufacturing, healthcare, energy and utilities, transportation and logistics, agriculture, etc)
![Figure 1: IoT middleware architecture][3]
Selecting the right middleware during various stages of IoT implementation depends on multiple factors like the size of the enterprise, the nature of the business, the development and operational perspectives, etc.The following are some of the top open source middleware platforms for IoT based applications.
**Kaa** is platform-centric middleware. It manages an unlimited number of connected devices with cross-device interoperability. It performs real-time device monitoring, remote device provisioning and configuration, collection and analysis of sensor data. It has microservices based portability, horizontal scalability and a highly available IoT platform. It supports on premise, public cloud and hybrid models of deployment. Kaa is built on open components like Kafka, Cassandra, MongoDB, Redis, NATS, Spring, React, etc.
**SiteWhere** is platform-centric middleware. It provides ingestion, storage, processing and integration of device data. It supports multi-tenancy, MQTT, AMQP, Stomp, CoAP and WebSocket. It seamlessly integrates with Android, iOS, and multiple SDKs. It is built on open source technology stacks like MongoDB, Eclipse Californium, InfluxDB, HBase and many others.
**IoTSyS** is platform-centric and industry-specific middleware. It uses IPv6 for non-IP IoT devices and systems. It is used in smart city and smart grid projects to make the automation infrastructure smart. IoTSyS provides interoperable Web technologies for sensors and actuator networks.
**DeviceHive** is cloud agnostic, microservices based, platform-centric middleware used for device connectivity and management. It has the ability to connect to any device via MQTT, REST or WebSockets. It supports Big Data solutions like ElasticSearch, Apache Spark, Cassandra and Kafka for real-time and batch processing.
**EclipseIoT (Kura)** provides device connectivity, data transformation and business logic with intelligent routing, edge processing/analytics and real-time decisions.
**Zetta** is application-centric middleware. It is a service-oriented open source IoT platform built on Node.js combining REST API, WebSockets and reactive programming. It can run on cloud platforms like Heroku to create geo-distributed networks and stream data into machine analytics systems like Splunk.
**MainFlux** is application-centric middleware providing solutions based on the cloud. It has been developed as microservices, containerised by Docker and orchestrated with Kubernetes. The architecture is flexible and allows seamless integration with enterprise systems like ERP, BI and CRM. It can also integrate with databases, analytics, backend systems and cloud services easily. In addition, it supports REST, MQTT, WebSocket and CoAP.
**Distributed Services Architecture (DSA)** facilitates decentralised device inter-communication, allowing protocol translation and data integration to and from third party data sources.
**OpenRemote** is application-centric middleware used to connect any device regardless of vendor or protocol, to create meaningful connections by converting data points into smart applications. It finds use in home automation, commercial buildings, public space and healthcare. Data visualisation is integrated with devices and sensors, and turns data into smart applications.
**OpenIoT** is application-centric open source middleware for pulling information from sensors. It incorporates Sensing-as-a-Service for deploying and providing services in cloud environments.
**ThingsBoard** is an open source IoT platform for data collection, processing, data visualisation and device management. It supports IoT protocols like MQTT, CoA, and HTTP with on-premise and cloud deployment. It is horizontally scalable, stores data in Cassandra DB, HSQLDB and PostgreSQL.
**NATS.io** is a simple, secure and high performance open source messaging system for cloud native solutions. It is developed as microservices architecture with high performance, secure and resilient capabilities.
**Benefits of open source IoT middleware**
Open source middleware for the IoT has the following advantages over proprietary options:
* It is easy to upgrade to new technologies with open source middleware.
* It has the ability to connect with upcoming device protocols and backend applications.
* Open source middleware ensures lower overall software costs, and is easier to use when changing technology and open source APIs for integration.
* It has a microservices based architecture and is built using open source technologies, resulting in high performance, scalability and fault-tolerance.
* It provides multi-protocol support and is hardware-agnostic. It supports connectivity for any device and any application.
* It has the flexibility to allow the cloud service provider to be changed.
* It is very important to choose the right set of open source middleware for an IoT solution. This is a big challenge as the market offers a vast choice.
Analyse the business problem and arrive at the solution as a first step. Break the solution into services and understand the middleware needs of these services. This will help to narrow down the middleware choices.
IoT middleware helps overcome the problems associated with the heterogeneity of the entire Internet of Things by enabling smooth communication among devices and components from different vendors and based on different technologies.
--------------------------------------------------------------------------------
via: https://opensourceforu.com/2019/10/a-primer-on-open-source-iot-middleware-for-the-integration-of-enterprise-applications/
作者：[Gopala Krishna Behara][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://opensourceforu.com/author/gopalakrishna-behara/
[b]: https://github.com/lujun9972
[1]: https://i1.wp.com/opensourceforu.com/wp-content/uploads/2019/10/Middle-were-architecture-illustration.jpg?resize=696%2C426&ssl=1 (Middle were architecture illustration)
[2]: https://i1.wp.com/opensourceforu.com/wp-content/uploads/2019/10/Middle-were-architecture-illustration.jpg?fit=800%2C490&ssl=1
[3]: https://i1.wp.com/opensourceforu.com/wp-content/uploads/2019/10/Figure-1-IoT-middleware-architecture.jpg?resize=350%2C162&ssl=1

106
sources/talk/20191015 Beamforming explained- How it makes wireless communication faster.md Normal file
View File

@ -0,0 +1,106 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Beamforming explained: How it makes wireless communication faster)
[#]: via: (https://www.networkworld.com/article/3445039/beamforming-explained-how-it-makes-wireless-communication-faster.html)
[#]: author: (Josh Fruhlinger https://www.networkworld.com/author/Josh-Fruhlinger/)
Beamforming explained: How it makes wireless communication faster
======
Beamforming uses the science of electromagnetic interference to make Wi-Fi and 5G connections more precise.
Thinkstock
Beamforming is a technique that focuses a wireless signal towards a specific receiving device, rather than having the signal spread in all directions from a broadcast antenna, as it normally would. The resulting more direct connection is faster and more reliable than it would be without beamforming.
Although the principles of beamforming have been known since the 1940s, in recent years beamforming technologies have introduced incremental improvements in Wi-Fi networking. Today, beamforming is crucial to the [5G networks][1] that are just beginning to roll out.
[5G versus 4G: How speed, latency and application support differ][1]
### How beamforming works
A single antenna broadcasting a wireless signal radiates that signal in all directions (unless it's blocked by some physical object). That's the nature of how electromagnetic waves work. But what if you wanted to focus that signal in a specific direction, to form a targeted beam of electromagnetic energy? One technique for doing this involves having multiple antennas in close proximity, all broadcasting the same signal at slightly different times. The overlapping waves will produce interference that in some areas is _constructive_ (it makes the signal stronger) and in other areas is _destructive_ (it makes the signal weaker, or undetectable). If executed correctly, this beamforming process can focus your signal where you want it to go.
[][2]
BrandPost Sponsored by HPE
[Take the Intelligent Route with Consumption-Based Storage][2]
Combine the agility and economics of HPE storage with HPE GreenLake and run your IT department with efficiency.
[][3] ojogabonitoo / Getty Images
The mathematics behind beamforming is very complex (the [Math Encounters blog][4] has an introduction, if you want a taste), but the application of beamforming techniques is not new. Any form of energy that travels in waves, including sound, can benefit from beamforming techniques; they were first developed to [improve sonar during World War II][5] and are [still important to audio engineering][6]. But we're going to limit our discussion here to wireless networking and communications.  
### Beamforming benefits and limitations
By focusing a signal in a specific direction, beamforming allows you deliver higher signal quality to your receiver — which in practice means faster information transfer and fewer errors — without needing to boost broadcast power. That's basically the holy grail of wireless networking and the goal of most techniques for improving wireless communication. As an added benefit, because you aren't broadcasting your signal in directions where it's not needed, beamforming can reduce interference experienced by people trying to pick up other signals.
The limitations of beamforming mostly involve the computing resources it requires; there are many scenarios where the time and power resources required by beamforming calculations end up negating its advantages. But continuing improvements in processor power and efficiency have made beamforming techniques affordable enough to build into consumer networking equipment.
### Wi-Fi beamforming routers: 802.11n vs. 802.11ac
Beamforming began to appear in routers back in 2008, with the advent of the [802.11n Wi-Fi standard][7]. 802.11n was the first version of Wi-Fi to support multiple-input multiple-output, or MIMO, technology, which beamforming needs in order to send out multiple overlapping signals. Beamforming with 802.11n equipment never really took off, however, because the spec doesn't lay out how beamforming should be implemented. A few vendors put out proprietary implementations that required purchasing matching routers and wireless cards to work, and they were not popular.
With the emergence of the [802.11ac standard][8] in 2016, that all changed. There's now a set of specified beamforming techniques for Wi-Fi gear, and while 802.11ac routers aren't required by the specification to implement beamforming, if they do (and almost all on the market now do) they do so in a vendor-neutral and interoperable way. While some offerings might tout branded names, such as D-Link's AC Smart Beam, these are all implementations of the same standard. (The even newer [802.11ax standard][9] continues to support ac-style beamforming.)
### Beamforming and MU-MIMO
Beamforming is key for the support of multiuser MIMO, or [MU-MIMO][10], which is becoming more popular as 802.11ax routers roll out. As the name implies, MU-MIMO involves multiple users that can each communicate to multiple antennas on the router. MU-MIMO [uses beamforming][11] to make sure communication from the router is efficiently targeted to each connected client.
### Explicit beamforming vs. implicit beamforming
There are a couple of ways that Wi-Fi beamforming can work. If both the router and the endpoint support 802.11ac-compliant beamforming, they'll begin their communication session with a little "handshake" that helps both parties establish their respective locations and the channel on which they'll communicate; this improves the quality of the connection and is known as _explicit_ beamforming. But there are still plenty of network cards in use that only support 802.11n or even older versions of Wi-Fi. A beamforming router can still attempt to target these devices, but without help from the endpoint, it won't be able to zero in as precisely. This is known as _implicit_ beamforming, or sometimes as _universal_ beamforming, because it works in theory with any Wi-Fi device.
In many routers, implicit beamforming is a feature you can turn on and off. Is enabling implicit beamforming worth it? The [Router Guide suggests][12] that you test how your network operates with it on and off to see if you get a boost from it. It's possible that devices such as phones that you carry around your house can see dropped connections with implicit beamforming.
### 5G beamforming
To date, local Wi-Fi networks is where the average person is most likely to encounter beamforming in the wild. But with the rollout of wide-area 5G networks now under way, that's about to change. 5G uses radio frequencies between 30 and 300 GHz, which can transmit data much more quickly but are also much more prone to interference and encounter more difficulty passing through physical objects. A host of technologies are required to overcome these problems, including smaller cells, massive MIMO — basically cramming tons of antennas onto 5G base stations — and, yes, [beamforming][13]. If 5G takes off in the way that vendors are counting on, the time will come soon enough when we'll all be using beamforming (behind the scenes) every day.
**Learn more about wireless networking**
* [How to determine if Wi-Fi 6 is right for you][14]
* [What is 5G? How is it better than 4G?][13]
* [Cisco exec details how Wi-Fi 6 and 5G will fire-up enterprises][15]
* [Wi-Fi 6 is coming to a router near you][16]
* [Wi-Fi analytics get real][17]
Join the Network World communities on [Facebook][18] and [LinkedIn][19] to comment on topics that are top of mind.
--------------------------------------------------------------------------------
via: https://www.networkworld.com/article/3445039/beamforming-explained-how-it-makes-wireless-communication-faster.html
作者：[Josh Fruhlinger][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/Josh-Fruhlinger/
[b]: https://github.com/lujun9972
[1]: https://www.networkworld.com/article/3330603/5g-versus-4g-how-speed-latency-and-application-support-differ.html
[2]: https://www.networkworld.com/article/3440100/take-the-intelligent-route-with-consumption-based-storage.html?utm_source=IDG&utm_medium=promotions&utm_campaign=HPE20773&utm_content=sidebar ( Take the Intelligent Route with Consumption-Based Storage)
[3]: https://images.idgesg.net/images/article/2019/10/nw_wifi_router_traditional-and-beamformer_foundational_networking_internet-100814037-orig.jpg
[4]: https://www.mathscinotes.com/2012/01/beamforming-math/
[5]: https://apps.dtic.mil/dtic/tr/fulltext/u2/a250189.pdf
[6]: https://www.mathworks.com/company/newsletters/articles/making-all-the-right-noises-shaping-sound-with-audio-beamforming.html
[7]: https://www.networkworld.com/article/2270718/the-role-of-beam-forming-in-11n.html
[8]: https://www.networkworld.com/article/3067702/mu-mimo-makes-wi-fi-better.html
[9]: https://www.networkworld.com/article/3258807/what-is-802-11ax-wi-fi-and-what-will-it-mean-for-802-11ac.html
[10]: https://www.networkworld.com/article/3250268/what-is-mu-mimo-and-why-you-need-it-in-your-wireless-routers.html
[11]: https://www.networkworld.com/article/3256905/13-things-you-need-to-know-about-mu-mimo-wi-fi.html
[12]: https://routerguide.net/enable-beamforming-on-or-off/
[13]: https://www.networkworld.com/article/3203489/what-is-5g-how-is-it-better-than-4g.html
[14]: https://www.networkworld.com/article/3356838/how-to-determine-if-wi-fi-6-is-right-for-you.html
[15]: https://www.networkworld.com/article/3342158/cisco-exec-details-how-wi-fi-6-and-5g-will-fire-up-enterprises-in-2019-and-beyond.html
[16]: https://www.networkworld.com/article/3311921/mobile-wireless/wi-fi-6-is-coming-to-a-router-near-you.html
[17]: https://www.networkworld.com/article/3305583/wi-fi/wi-fi-analytics-get-real.html
[18]: https://www.facebook.com/NetworkWorld/
[19]: https://www.linkedin.com/company/network-world

60
sources/talk/20191015 How GNOME uses Git.md Normal file
View File

@ -0,0 +1,60 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (How GNOME uses Git)
[#]: via: (https://opensource.com/article/19/10/how-gnome-uses-git)
[#]: author: (Molly de Blanc https://opensource.com/users/mollydb)
How GNOME uses Git
======
The GNOME project's decision to centralize on GitLab is creating
benefits across the community—even beyond the developers.
![red panda][1]
“What’s your GitLab?” is one of the first questions I was asked on my first day working for the [GNOME Foundation][2]—the nonprofit that supports GNOME projects, including the [desktop environment][3], [GTK][4], and [GStreamer][5]. The person was referring to my username on [GNOME’s GitLab instance][6]. In my time with GNOME, I’ve been asked for my GitLab a lot.
We use GitLab for basically everything. In a typical day, I get several issues and reference bug reports, and I occasionally need to modify a file. I don’t do this in the capacity of being a developer or a sysadmin. I’m involved with the Engagement and Inclusion &amp; Diversity (I&amp;D) teams. I write newsletters for Friends of GNOME and interview contributors to the project. I work on sponsorships for GNOME events. I don’t write code, and I use GitLab every day.
The GNOME project has been managed a lot of ways over the past two decades. Different parts of the project used different systems to track changes to code, collaborate, and share information both as a project and as a social space. However, the project made the decision that it needed to become more integrated and it took about a year from conception to completion.
There were a number of reasons GNOME wanted to switch to a single tool for use across the community. External projects touch GNOME, and providing them an easier way to interact with resources was important for the project, both to support the community and to grow the ecosystem. We also wanted to better track metrics for GNOME—the number of contributors, the type and number of contributions, and the developmental progress of different parts of the project.
When it came time to pick a collaboration tool, we considered what we needed. One of the most important requirements was that it must be hosted by the GNOME community; being hosted by a third party didn’t feel like an option, so that discounted services like GitHub and Atlassian. And, of course, it had to be free software. It quickly became obvious that the only real contender was GitLab. We wanted to make sure contribution would be easy. GitLab has features like single sign-on, which allows people to use GitHub, Google, GitLab.com, and GNOME accounts.
We agreed that GitLab was the way to go, and we began to migrate from many tools to a single tool. GNOME board member [Carlos Soriano][7] led the charge. With lots of support from GitLab and the GNOME community, we completed the process in May 2018.
There was a lot of hope that moving to GitLab would help grow the community and make contributing easier. Because GNOME previously used so many different tools, including Bugzilla and CGit, it’s hard to quantitatively measure how the switch has impacted the number of contributions. We can more clearly track some statistics though, such as the nearly 10,000 issues closed and 7,085 merge requests merged between June and November 2018. People feel that the community has grown and become more welcoming and that contribution is, in fact, easier.
People come to free software from all sorts of different starting points, and it’s important to try to even out the playing field by providing better resources and extra support for people who need them. Git, as a tool, is widely used, and more people are coming to participate in free software with those skills ready to go. Self-hosting GitLab provides the perfect opportunity to combine the familiarity of Git with the feature-rich, user-friendly environment provided by GitLab.
It’s been a little over a year, and the change is really noticeable. Continuous integration (CI) has been a huge benefit for development, and it has been completely integrated into nearly every part of GNOME. Teams that aren’t doing code development have also switched to using the GitLab ecosystem for their work. Whether it’s using issue tracking to manage assigned tasks or version control to share and manage assets, even teams like Engagement and I&amp;D have taken up using GitLab.
It can be hard for a community, even one developing free software, to adapt to a new technology or tool. It is especially hard in a case like GNOME, a project that [recently turned 22][8]. After more than two decades of building a project like GNOME, with so many parts used by so many people and organizations, the migration was an endeavor that was only possible thanks to the hard work of the GNOME community and generous assistance from GitLab.
I find a lot of convenience in working for a project that uses Git for version control. It’s a system that feels comfortable and is familiar—it’s a tool that is consistent across workplaces and hobby projects. As a new member of the GNOME community, it was great to be able to jump in and just use GitLab. As a community builder, it’s inspiring to see the results: more associated projects coming on board and entering the ecosystem; new contributors and community members making their first contributions to the project; and increased ability to measure the work we’re doing to know it’s effective and successful.
It’s great that so many teams doing completely different things (such as what they’re working on and what skills they’re using) agree to centralize on any tool—especially one that is considered a standard across open source. As a contributor to GNOME, I really appreciate that we’re using GitLab.
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/10/how-gnome-uses-git
作者：[Molly de Blanc][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/mollydb
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/redpanda_firefox_pet_animal.jpg?itok=aSpKsyna (red panda)
[2]: https://www.gnome.org/foundation/
[3]: https://gnome.org/
[4]: https://www.gtk.org/
[5]: https://gstreamer.freedesktop.org/
[6]: https://gitlab.gnome.org/
[7]: https://twitter.com/csoriano1618?lang=en
[8]: https://opensource.com/article/19/8/poll-favorite-gnome-version

93
sources/talk/20191015 The Emergence of Edge Analytics in the IoT Ecosystem.md Normal file
View File

@ -0,0 +1,93 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (The Emergence of Edge Analytics in the IoT Ecosystem)
[#]: via: (https://opensourceforu.com/2019/10/the-emergence-of-edge-analytics-in-the-iot-ecosystem/)
[#]: author: (Shashidhar Soppin https://opensourceforu.com/author/shashidhar-soppin/)
The Emergence of Edge Analytics in the IoT Ecosystem
======
[![][1]][2]
_Edge analytics involves processing, collecting and analysing data near its source so that not all of it is sent to the cloud. This is crucial when massive volumes of data are generated by numerous devices. It saves a lot of time and reduces latency._
The exponential proliferation of IoT devices and IoT based platforms is leading to multiple complex scenarios. Such sudden growth and scalability need a lot of analytics to be done for better predictions and choices. IoT analytics will become more complex and challenging when the number of IoT devices grows even further. A good analytics system will become crucial for any IoT environment to succeed and be more robust.
Making any sense out of IoT data needs good and efficient analytics. This may not always be Big Data (volume, velocity and variety of data). There are many other categories of analytics, like simple past event review, or more advanced analytics using historical data to make predictions about outcomes, etc.
**What is analytics?**
Analytics (for IoT) is the science and art of trying to find matching patterns in the huge quantity of data (it could be Big Data, or otherwise) generated by connected and smart devices. In layman’s terms, this can be defined as simply as monitoring trends and finding any abnormalities.
Listed below are some of the well-known analytics methodologies or types:
* Descriptive analytics tells us what is happening
* Diagnostics analytics tells us why it happened
* Predictive analytics tells us what is likely to happen
* Prescriptive analytics tells us what should be done to prevent something from happening
Today, there are various tools and technologies available for analytics. Many of the enterprises now expect to have intelligence or analytics sit on the platform itself for better monitoring and live streaming capabilities. Processing historical data from the cloud or any other outside means takes time and adds latency to the entire response time. Analytics using microservices based technologies is also one trend observed recently.
Each of the existing IoT solutions may not need analytics to be done. Listed below are some types of analytics that can be performed:
* Generating basic reports
* Real-time stream analytics
* Long-term data analytics
* Large-scale data analytics
* Advanced data analytics
Once the data is acquired from any selected source, it has to be pre-processed to identify missing values and for the purpose of scaling the data. Once the pre-processing is done,‘feature extraction’ needs to be carried out. From feature extraction, we can identify any significant information that helps in improving subsequent steps.
**Basic analysis**
This analysis typically involves Big Data and will, most of the time, involve descriptive and diagnostic kinds of analytics.
This is the era of edge analytics. Many of the industries that work on IoT based solutions and frameworks use it, and it is expected to become ‘the next big thing’ in the coming days. At present, there are many tools and technologies that deal with edge analytics.
**Edge analytics and the IoT tools**
This is an analysis done at the source, by processing, collecting and analysing the data instead of sending it to the cloud or server for processing and analysis. This saves a lot of time and avoids latency. By using edge analytics, most problems in today’s world can be solved.
According to Gartner’s predictions, by 2020, more than half the major new business processes and systems will incorporate some element of IoT. Analytics will become one of the key aspects of any of these IoT systems/sub-systems. It will support the decision-making process in related operations and help in business transformation.
A brief introduction of some of the well-known open source IoT tools for edge analytics follows.
**EdgeX Foundry:** This is an open source project that is hosted by the Linux Foundation. It provides interoperability, can be hosted within the hardware and is an OS-agnostic software platform. The EdgeX ecosystem can be used as plug-and-play with support for multiple components, and this can be easily deployed as an IoT solution with edge analytics. EdgeX Foundry can be deployed using microservices as well.
**Website:** _<https://github.com/edgexfoundry/edgex-go>_
**Eclipse Kura:** Eclipse Kura is one more popular open source IoT edge framework. It is based on Java/OSGi and offers API based access to the underlying hardware interface of IoT gateways (for serial ports, watchdog, GPS, I2C, etc). The Kura architecture can be found at _<http://eclipse.github.io/kura/intro/intro.html>_.
Kura components are designed as configurable OSGi based and declarative services, which are exposed service APIs. Most of the Kura components are purely Java based, while others can be invoked through JNI, and generally have a dependency on the Linux operating system.
**Eclipse Kapua:** Eclipse Kapua is a modular IoT cloud platform that is mainly used to manage and integrate devices and their data. Kapua comes loaded with the following features.
* **Connect:** Many of the IoT devices can be connected to Kapua using MQTT and other protocols.
* **Manage:** The management of a device’s applications, configurations and resources can be easily done.
* **Store and analyse:** Kapua helps in storing and indexing the data published by IoT devices for quick and easy analysis, and later visualisation in the dashboard.
* **Integrate:** Kapua services can be easily integrated with various IT applications through flexible message routing and ReST based APIs.
**Website:** _<https://www.eclipse.org/kapua/>_
As mentioned earlier and based on Gartner analysis, edge analytics will become one of the leading tech trends in the coming months. The more analysis that is done at the edge, the more sophisticated and advanced the whole IoT ecosystem will become. There will come a day where M2M communication may happen independently, without much human intervention.
--------------------------------------------------------------------------------
via: https://opensourceforu.com/2019/10/the-emergence-of-edge-analytics-in-the-iot-ecosystem/
作者：[Shashidhar Soppin][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://opensourceforu.com/author/shashidhar-soppin/
[b]: https://github.com/lujun9972
[1]: https://i1.wp.com/opensourceforu.com/wp-content/uploads/2019/10/Graph-Analytics-1.jpg?resize=696%2C464&ssl=1 (Graph Analytics)
[2]: https://i1.wp.com/opensourceforu.com/wp-content/uploads/2019/10/Graph-Analytics-1.jpg?fit=800%2C533&ssl=1

102
sources/talk/20191015 The software-defined data center drives agility.md Normal file
View File

@ -0,0 +1,102 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (The software-defined data center drives agility)
[#]: via: (https://www.networkworld.com/article/3446040/the-software-defined-data-center-drives-agility.html)
[#]: author: (Matt Conran https://www.networkworld.com/author/Matt-Conran/)
The software-defined data center drives agility
======
The value of SDN is doing as much as possible in the software so you don’t depend on the delivery of new features to come from a new generation of the hardware.
monsitj / Getty Images
In this day and age, demands on networks are coming from a variety of sources, internal end-users, external customers and via changes in the application architecture. Such demands put pressure on traditional architectures.
To deal effectively with these demands requires the network domain to become more dynamic. For this, we must embrace digital transformation. However, current methods are delaying this much-needed transition. One major pain point that networks suffer from is the necessity to dispense with manual working, which lacks fabric wide automation. This must be addressed if organizations are to implement new products and services ahead of the competition.
So, to evolve, to be in line with the current times and use technology as an effective tool, one must drive the entire organization to become a digital enterprise. The network components do play a key role, but the digital transformation process is an enterprise-wide initiative.
[][1]
BrandPost Sponsored by HPE
[Take the Intelligent Route with Consumption-Based Storage][1]
Combine the agility and economics of HPE storage with HPE GreenLake and run your IT department with efficiency.
### Digital transformation and network visibility
As a part of this transformation, the network is no longer considered a black box. Now the network is a source for deep visibility that can aid a large set of use cases like network performance, monitoring, security and capacity planning, to name a few. However, in spite of such critical importance visibility is often overlooked.
We need the ability to provide deep visibility for the application at a flow level. Rationally, today if you want anything comparable, you would deploy a redundant monitoring network. Such a network would consist of probes, packet brokers and various tools to process the packet for metadata.
A more viable solution would integrate the network visibility into the fabric and therefore would not need a bunch of components. This enables us to do more with the data and aids with agility for ongoing network operations. There will always be some kind of requirement for application optimization or a security breach. And this is where visibility can help you iron out such issues quickly.
### Gaining agility with SDN
When increasing agility, what is useful is the building of a complete network overlay. An overlay is a solution that is abstracted from the underlying physical infrastructure in a certain way.
**[ Related: [MPLS explained – What you need to know about multi-protocol label switching][2]**
What this means is that we are separating and disaggregating the customer applications or services from the network infrastructure. This is more like a sandbox or private network for each application that is on an existing network. This way we are empowered with both the SDN controller and controllerless options. Both [data center architectures][3] _[Disclaimer: The author is employed by Network Insight]_ have their advantages and disadvantages.
Traditionally, the deployment of an application to the network involves propagating the policy to work through the entire infrastructure. Why? Because the network simply acts as an underlay and the segmentation rules configured on this underlay are needed to separate different applications and services. This, ultimately, creates a very rigid architecture that is unable to react quickly and adapt to the changes, therefore lacking agility. In essence, the applications and the physical network are tightly coupled.
[Virtual networks][4] are mostly built from either the servers or ToR switches. Either way, the underlying network transports the traffic and doesn’t need to be configured to accommodate the customer application. That is all carried in the overlay. By and large, everything happens in the overlay network which is most efficient when done in a fully distributed manner.
Now the application and service deployment occur without touching the network. Once the tight coupling between the application and network is removed, increased agility and simplicity of deploying applications and services are created.
### Where do your features live?
Some vendors build into the hardware the differentiator of the offering. With different hardware, you can accelerate the services. With this design, the hardware level is manipulated, but it does not use the standard Open Networking protocols. The result is that you are 100% locked, unable to move as the cost of moving is too much.
You could have numerous generations: for example, line cards, all the line cards have different capabilities, resulting in a complex feature matrix. When the Cisco Nexus platform first came out, I was onsite as a TDA trying to bring in some redundancy into the edge/access layer.
When the virtual PortChannel (vPC) came out they were several topologies and some of these topologies were only available on certain hardware. As it’s just a topology, it would have been useful to have it across all line cards. This is the world of closed networking, which has been accepted as the norm until now.
### Open networking
Traditionally, networking products were a combination of the hardware and software that had to be purchased together as an integrated solution. Open Networking, on the other hand, is the disaggregation of hardware from the software. This basically allows IT to mix and match at will.
With Open Networking, you are not reinventing the way packets are forwarded, or the way routers communicate with each other. Why? Because, with Open Networking, you are never alone and never the only vendor. You need to adapt and fit, and for this, you need to use open protocols.
The value of SDN is doing as much as possible in the software so you don’t depend on the delivery of new features to come from a new generation of the hardware. You want to put as much intelligence as possible into the software, thus removing the intelligence from the physical layer.
You don’t want to build the hardware features; instead, you want to use the software to provide the new features. This is an important philosophy and is the essence of Open Networking. From the customer's point of view, they get more agility as they can move from generation to generation of services without having hardware dependency. They don’t have to incur the operational costs of swapping out the hardware constantly.
### First steps
It is agreed that agility is a necessity. So, what is the prime step? One of the key steps is to create a software-defined data center that will allow the rapid deployment of compute and storage for the workloads. In addition to software-defined compute and storage, the network must be automated and not be an impediment.
Many organizations assume that to achieve agility, we must move everything to the cloud. Migrating workloads to the cloud indeed allow organizations to be competitive and equipped with the capabilities of a much larger organization.
Only a small proportion can adopt a fully cloud-native design. More often than not, there will always be some kind of application that needs to stay on-premise. In this case, the agility in the cloud needs to be matched by the on-premise infrastructure. This requires the virtualization of the on-premise compute, storage and network components.
Compute and storage, affordable software control, and virtualization have progressed dramatically. However, the network can cause a lag. Solutions do exist but they are complex, expensive and return on investment (ROI) is a stretch. Therefore, such solutions are workable only for the largest enterprises. This creates a challenge for mid-sized businesses that want to virtualize the network components.
**This article is published as part of the IDG Contributor Network. [Want to Join?][5]**
Join the Network World communities on [Facebook][6] and [LinkedIn][7] to comment on topics that are top of mind.
--------------------------------------------------------------------------------
via: https://www.networkworld.com/article/3446040/the-software-defined-data-center-drives-agility.html
作者：[Matt Conran][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/Matt-Conran/
[b]: https://github.com/lujun9972
[1]: https://www.networkworld.com/article/3440100/take-the-intelligent-route-with-consumption-based-storage.html?utm_source=IDG&utm_medium=promotions&utm_campaign=HPE20773&utm_content=sidebar ( Take the Intelligent Route with Consumption-Based Storage)
[2]: https://www.networkworld.com/article/2297171/sd-wan/network-security-mpls-explained.html
[3]: https://network-insight.net/2014/08/data-center-topologies/
[4]: https://youtu.be/-Yjk0GiysLI
[5]: https://www.networkworld.com/contributor-network/signup.html
[6]: https://www.facebook.com/NetworkWorld/
[7]: https://www.linkedin.com/company/network-world

59
sources/tech/20191013 Sugarizer- The Taste of Sugar on Any Device.md Normal file
View File

@ -0,0 +1,59 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Sugarizer: The Taste of Sugar on Any Device)
[#]: via: (https://opensourceforu.com/2019/10/sugarizer-the-taste-of-sugar-on-any-device/)
[#]: author: (Dr Anil Seth https://opensourceforu.com/author/anil-seth/)
Sugarizer: The Taste of Sugar on Any Device
======
[![][1]][2]
_Sugar is a learning platform that was initially developed for the OLPC project. The Sugar Learning Environment can be downloaded and installed on any Linux-compatible hardware. Sugarizer mimics the UI of Sugar using HTML5 and CSS3._
The One Laptop Per Child (OLPC) project was launched less than 12 years ago. The goal of bringing down the cost of a laptop to US$ 100 was never really achieved. The project also did not turn out to be as much of a success as anticipated. However, the goal was not really about the laptop, but to educate as many children as possible.
The interactive learning environment of the OLPC project was equally critical. This became a separate project under Sugar Labs, [_https://wiki.sugarlabs.org/_][3], and continues to be active. The Sugar Learning Environment is available as a Fedora spin, and can be downloaded and installed on any Linux-compatible hardware. It would be a good option to install it on an old system, which could then be donated. The US$ 90 Pinebook, [_https://www.pine64.org/,_][4] with Sugar installed on it would also make a memorable and useful gift.
The Sugar Environment can happily coexist with other desktop environments on Linux. So, the computer does not have to be dedicated to Sugar. On Fedora, you may add it to your existing desktop as follows:
```
$ sudo dnf group install ‘Sugar Desktop Environment’
```
I have not tried it on Ubuntu. However, the following command should work:
```
$ sudo apt install sucrose
```
However, Sugar remains, by and large, an unknown entity. This is especially disappointing considering that the need to _learn to learn_ has never been greater.
Hence, the release of Sugarizer is a pleasant surprise. It allows you to use the Sugar environment on any device, with the help of Web technologies. Sugarizer mimics the UI of Sugar using HTML5 and CSS3. It runs activities that have been written in HTML5/JavaScript. The current release includes a number of Sugar activities written initially in Python, which have been ported to HTML5/JavaScript.
You may try the new release at _sugarizer.org_. Better still, install it from Google Play on your Android tablet or from App Store on an Apple device. It works well even on a two-year-old, low-end tablet. Hence, you may easily put your old tablet to good use by gifting it to a child after installing Sugarizer on it. In this way, you could even rationalise your desire to buy the replacement tablet you have been eyeing.
**Does it work?**
My children are too old and grandchildren too young. Reason tells me that it should work. Experience also tells me that it will most likely NOT improve school grades. I did not like school. I was bored most of the time. If I was studying in today’s schools, I would have had ulcers or a nervous breakdown!
When I think of schools, I recall the frustration of a child long ago (just 20 years) who got an answer wrong. The book and the teacher said that a mouse has two buttons. The mouse he used at home had three!
So, can you risk leaving the education of children you care about to the schools? Think about the skills you may be using today. Could these have been taught at schools a mere five years ago?
I never took JavaScript seriously and never made an effort to learn it. Today, I see Sugarizer and Snap! (a clone of Scratch in JavaScript) and am acutely aware of my foolishness. However, having learnt programming outside the classroom, I am confident that I can learn to program in JavaScript, should the need arise.
The intention at the start was to write about the activities in Sugarizer and, maybe, explore the source code. My favourite activities include TamTam, Turtle Blocks, Maze, etc. From the food chain activity, I discovered that some animals that I had believed to be carnivores, were not. I have also seen children get excited by the Speak activity.
However, once I started writing after the heading ‘Does it work?’, my mind took a radical turn. Now, I am convinced that Sugarizer will work only if you try it out.
--------------------------------------------------------------------------------
via: https://opensourceforu.com/2019/10/sugarizer-the-taste-of-sugar-on-any-device/
作者：[Dr Anil Seth][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://opensourceforu.com/author/anil-seth/
[b]: https://github.com/lujun9972
[1]: https://i0.wp.com/opensourceforu.com/wp-content/uploads/2017/05/Technology-Development-in-Computers-Innovation-eLearning-1.jpg?resize=696%2C696&ssl=1 (Technology Development in Computers (Innovation), eLearning)
[2]: https://i0.wp.com/opensourceforu.com/wp-content/uploads/2017/05/Technology-Development-in-Computers-Innovation-eLearning-1.jpg?fit=900%2C900&ssl=1
[3]: https://wiki.sugarlabs.org/
[4]: https://www.pine64.org/,

235
sources/tech/20191015 Formatting NFL data for doing data science with Python.md Normal file
View File

@ -0,0 +1,235 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Formatting NFL data for doing data science with Python)
[#]: via: (https://opensource.com/article/19/10/formatting-nfl-data-python)
[#]: author: (Christa Hayes https://opensource.com/users/cdhayes2)
Formatting NFL data for doing data science with Python
======
In part 1 of this series on machine learning with Python, learn how to
prepare a National Football League dataset for training.
![A football field.][1]
No matter what medium of content you consume these days (podcasts, articles, tweets, etc.), you'll probably come across some reference to data. Whether it's to back up a talking point or put a meta-view on how data is everywhere, data and its analysis are in high demand.
As a programmer, I've found data science to be more comparable to wizardry than an exact science. I've coveted the ability to get ahold of raw data and glean something useful and concrete from it. What a useful talent!
This got me thinking about the difference between data scientists and programmers. Aren't data scientists just statisticians who can code? Look around and you'll see any number of tools aimed at helping developers become data scientists. AWS has a full-on [machine learning course][2] geared specifically towards turning developers into experts. [Visual Studio][3] has built-in Python projects that—with the click of a button—will create an entire template for classification problems. And scores of programmers are writing tools designed to make data science easier for anyone to pick up.
I thought I'd lean into the clear message of recruiting programmers to the data (or dark) side and give it a shot with a fun project: training a machine learning model to predict plays using a National Football League (NFL) dataset.
### Set up the environment
Before I can dig into the data, I need to set up my [virtual environment][4]. This is important because, without an environment, I'll have nowhere to work. Fortunately, Opensource.com has [some great resources][5] for installing and configuring the setup.
Any of the code you see here, I was able to look up through existing documentation. If there is one thing programmers are familiar with, it's navigating foreign (and sometimes very sparse) documentation.
### Get the data
As with any modern problem, the first step is to make sure you have quality data. Luckily, I came across a set of [NFL tracking data][6] from 2017 that was used for the NFL Big Data Bowl. Even the NFL is trying its best to attract the brightest stars in the data realm.
Everything I need to know about the schema is in the README. This exercise will train a machine learning model to predict run (in which the ball carrier keeps the football and runs downfield) and pass (in which the ball is passed to a receiving player) plays using the plays.csv [data file][7]. I won't use player tracking data in this exercise, but it could be fun to explore later.
First things first, I need to get access to my data by importing it into a dataframe. The [Pandas][8] library is an open source Python library that provides algorithms for easy analysis of data structures. The structure in the sample NFL data happens to be a two-dimensional array (or in simpler terms, a table), which data scientists often refer to as a dataframe. The Pandas function dealing with dataframes is [pandas.DataFrame][9]. I'll also import several other libraries that I will use later.
```
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import xgboost as xgb
from sklearn import metrics
df = pd.read_csv('data/plays.csv')
print(len(df))
print(df.head())
```
### Format the data
The NFL data dump does not explicitly indicate which plays are runs (also called rushes) and which are passes. Therefore, I have to classify the offensive play types through some football savvy and reasoning.
Right away, I can get rid of special teams plays in the **isSTPLAY** column. Special teams are neither offense nor defense, so they are irrelevant to my objective.
```
#drop st plays
df = df[~df['isSTPlay']]
print(len(df))
```
Skimming the **playDescription** column, I see some plays where the quarterback kneels, which effectively ends a play. This is usually called a "victory formation" because the intent is to run out the clock. These are significantly different than normal running plays, so I can drop them as well.
```
#drop kneels
df = df[~df['playDescription'].str.contains("kneels")]
print (len(df))
```
The data reports time in terms of the quarters in which a game is normally played (as well as the time on the game clock in each quarter). Is this the most intuitive in terms of trying to predict a sequence? One way to answer this is to consider how gameplay differs between time splits.
When a team has the ball with a minute left in the first quarter, will it act the same as if it has the ball with a minute left in the second quarter? Probably not. Will it act the same with a minute to go at the end of both halves? All else remaining equal, the answer is likely yes in most scenarios.
I'll convert the **quarter** and **GameClock** columns from quarters to halves, denoted in seconds rather than minutes. I'll also create a **half** column from the **quarter** values. There are some fifth quarter values, which I take to be overtime. Since overtime rules are different than normal gameplay, I can drop them.
```
#drop overtime
df = df[~(df['quarter'] == 5)]
print(len(df))
#convert time/quarters
def translate_game_clock(row):
    raw_game_clock = row['GameClock']
    quarter = row['quarter']
    minutes, seconds_raw = raw_game_clock.partition(':')[::2]
    seconds = seconds_raw.partition(':')[0]
    total_seconds_left_in_quarter = int(seconds) + (int(minutes) * 60)
    if quarter == 3 or quarter == 1:
        return total_seconds_left_in_quarter + 900
    elif quarter == 4 or quarter == 2:
        return total_seconds_left_in_quarter
if 'GameClock' in list (df.columns):
    df['secondsLeftInHalf'] = df.apply(translate_game_clock, axis=1)
if 'quarter' in list(df.columns):
    df['half'] = df['quarter'].map(lambda q: 2 if q &gt; 2 else 1)
```
The **yardlineNumber** column also needs to be transformed. The data currently lists the yard line as a value from one to 50. Again, this is unhelpful because a team would not act the same on its own 20-yard line vs. its opponent's 20-yard line. I will convert it to represent a value from one to 99, where the one-yard line is nearest the possession team's endzone, and the 99-yard line is nearest the opponent's end zone.
```
def yards_to_endzone(row):
    if row['possessionTeam'] == row['yardlineSide']:
        return 100 - row['yardlineNumber']
    else :
        return row['yardlineNumber']
df['yardsToEndzone'] = df.apply(yards_to_endzone, axis = 1)
```
The personnel data would be extremely useful if I could get it into a format for the machine learning algorithm to take in. Personnel identifies the different types of skill positions on the field at a given time. The string value currently shown in **personnel.offense** is not conducive to input, so I'll convert each personnel position to its own column to indicate the number present on the field during the play. Defense personnel might be interesting to include later to see if it has any outcome on prediction. For now, I'll just stick with offense.
```
def transform_off_personnel(row):
   rb_count = 0
   te_count = 0
   wr_count = 0
   ol_count = 0
   dl_count = 0
   db_count = 0
   if not pd.isna(row['personnel.offense']):
       personnel = row['personnel.offense'].split(', ')
       for p in personnel:
           if p[2:4] == 'RB':
               rb_count = int(p[0])
           elif p[2:4] == 'TE':
                te_count = int(p[0])
           elif p[2:4] == 'WR':
                wr_count = int(p[0])
           elif p[2:4] == 'OL':
                ol_count = int(p[0])
           elif p[2:4] == 'DL':
                dl_count = int(p[0])
           elif p[2:4] == 'DB':
               db_count = int(p[0])
   return pd.Series([rb_count,te_count,wr_count,ol_count,dl_count, db_count])
df[['rb_count','te_count','wr_count','ol_count','dl_count', 'db_count']] = df.apply(transform_off_personnel, axis=1)
```
Now the offense personnel values are represented by individual columns.
![Result of reformatting offense personnel][10]
Formations describe how players are positioned on the field, and this is also something that would seemingly have value in predicting play outcomes. Once again, I'll convert the string values into integers.
```
df['offenseFormation'] = df['offenseFormation'].map(lambda f : 'EMPTY' if pd.isna(f) else f)
def formation(row):
    form = row['offenseFormation'].strip()
    if form == 'SHOTGUN':
        return 0
    elif form == 'SINGLEBACK':
        return 1
    elif form == 'EMPTY':
        return 2
    elif form == 'I_FORM':
        return 3
    elif form == 'PISTOL':
        return 4
    elif form == 'JUMBO':
        return 5
    elif form == 'WILDCAT':
        return 6
    elif form=='ACE':
        return 7
    else:
        return -1
df['numericFormation'] = df.apply(formation, axis=1)
print(df.yardlineNumber.unique())
```
Finally, it's time to classify the play types. The **PassResult** column has four distinct values: I, C, S, and null, which represent Incomplete passing plays, Complete passing plays, Sacks (classified as passing plays), and a null value. Since I've already eliminated all special teams plays, I can assume the null values are running plays. So I'll convert the play outcome into a single column called **play_type** represented by either a 0 for running or a 1 for passing. This will be the column (or _label_, as the data scientists say) I want my algorithm to predict.
```
def play_type(row):
    if row['PassResult'] == 'I' or row['PassResult'] == 'C' or row['PassResult'] == 'S':
        return 'Passing'
    else:
        return 'Rushing'
df['play_type'] = df.apply(play_type, axis = 1)
df['numericPlayType'] = df['play_type'].map(lambda p: 1 if p == 'Passing' else 0)
```
### Take a break
Is it time to start predicting things yet? Most of my work so far has been trying to understand the data and what format it needs to be in—before I even get started on predicting anything. Anyone else need a minute?
In part two, I'll do some analysis and visualization of the data before feeding it into a machine learning algorithm, and then I'll score the model's results to see how accurate they are. Stay tuned!
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/10/formatting-nfl-data-python
作者：[Christa Hayes][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/cdhayes2
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/OSDC_LIFE_football__520x292.png?itok=5hPbxQF8 (A football field.)
[2]: https://aws.amazon.com/training/learning-paths/machine-learning/developer/
[3]: https://docs.microsoft.com/en-us/visualstudio/python/overview-of-python-tools-for-visual-studio?view=vs-2019
[4]: https://opensource.com/article/19/9/get-started-data-science-python
[5]: https://opensource.com/article/17/10/python-101
[6]: https://github.com/nfl-football-ops/Big-Data-Bowl
[7]: https://github.com/nfl-football-ops/Big-Data-Bowl/tree/master/Data
[8]: https://pandas.pydata.org/
[9]: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html
[10]: https://opensource.com/sites/default/files/uploads/nfl-python-7_personneloffense.png (Result of reformatting offense personnel)

141
translated/tech/20190301 Guide to Install VMware Tools on Linux.md
View File

@ -1,141 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: (tomjlw)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Guide to Install VMware Tools on Linux)
[#]: via: (https://itsfoss.com/install-vmware-tools-linux)
[#]: author: (Ankush Das https://itsfoss.com/author/ankush/)
在 Linux 上安装 VMware 工具的教程
======
**VMware 工具通过允许你分享剪贴板和文件夹以及其他东西来提升你的虚拟机体验。了解如何在 Ubuntu 和其它 Linux 发行版上安装 VMware 工具**
在先前的教程中，你学习了[在 Ubuntu 上安装 VMware 工作站][1]。你可以通过安装 VMware 工具进一步提升你的虚拟机功能。
如果你已经在 VMware 上安装了一个访客系统，你必须要注意 [VMware 工具][2]的要求-尽管并不完全清楚到底有什么要求。
在本文中，我们将要强调 VMware 工具的重要性，所提供的特性，以及在 Ubuntu 和其它 Linux 发行版上安装 VMware 工具的方法。
### VMware 工具：概览及特性
![在 Ubuntu 上安装 VMware 工具][3]在 Ubuntu 上安装 VMware 工具
出于显而易见的的理由，虚拟机（你的客机系统）将不会与主机上的表现完全一致。在其性能和操作上会有特定的限制。而那是为什么工具箱（VMware 工具）被引入的原因。
VMware 工具以一种高效的形式在提升了其性能的同时，帮助管理访客系统。
#### VMware 工具到底负责什么？
![如何在在 Linux 上安装 VMware 工具][4]
你已大致了解它做什么了-但让我们探讨一下细节：
* 同步访客系统与主机系统间的时间以简化事务
* 解锁从主机系统向客机系统传递消息的能力。比如说，你可以复制文字到剪贴板并将它轻松粘贴到你的客机系统。
* 在客机系统启用声音
* 提升视频分辨率
* 修正错误网络速度数据
* 减少不合适的色深
当你在客机系统上安装 VMware 工具时有重大改变。但是它到底包含什么特性以解锁/提升这些功能呢？然让我们来看看。。
#### VMware 工具：核心特性细节
![用 VMware 工具在主机系统与客机系统间分享剪切板][5]用 VMware 工具在主机系统与客机系统间分享剪切板
如果你不想知道它包含什么来启用这些功能的话，你可以跳过这部分。但是为了好奇的读者，让我们简短地讨论它一下：
**VMware 设备驱动：** 它真的取决于系统。大多数主流操作系统确实默认包括设备驱动。因此你不必另外安装它。这主要涉及-内存控制驱动，鼠标驱动，音频驱动，NIC 驱动，VGA 驱动以及其它。
**VMware 用户处理：** 这是事情变得十分有趣的地方。通过它你获得了在客机和主机间复制粘贴和拖拽的能力。你基本上可以从主机复制粘贴到虚拟机，反之亦然。
你同样也可以拖拽文件。此外，在你未安装 SVGA 驱动时它会启用指针释放/锁定。
**VMware工具生命周期管理：** 嗯我们会在下面看看如何安装 VMware 工具，但是这个特性帮你在虚拟机中轻松安装/升级 VMware 工具。
**分享文件夹**：除了这些。VMware 工具同样允许你在客机与主机系统间分享文件夹。
![使用 VMware 工具在客机与主机系统间分享文件][6]使用 VMware 工具在客机与主机系统间分享文件
当然，它的效果同样取决于客机系统。例如在 Windows 上你通过 Unity 模式在虚拟机上运行程序并从主机系统上操作它。
### 如何在 Ubuntu 和其它 Linux 发行版上安装 VMware 工具
**注意：** 对于 Linux 操作系统，你应该已经安装好了“Open VM 工具”，大多数情况下移除了额外安装 VMware 工具的需求。
大部分时候，当你安装了客机系统时，如果操纵系统支持 [Easy Install][7] 的话你会收到软件更新弹窗告诉你安装 VMware 工具。
Windows 和 Ubuntu 不支持 Esay Install。因此即使你使用 Windows 作为你的主机或尝试在 Ubuntu 上安装 VMware 工具，你应该有一个和弹窗消息差不多的选项来轻松安装 VMware 工具。这是它应该看起来的样子：
![安装 VMware 工具的弹窗][8]安装 VMware 工具的弹窗
这是搞定它最简便的办法。因此当你配置虚拟机时确保你有一个通畅的网络连接。
如果你没收到任何弹窗-或者选项来轻松安装VMware 工具。你需要手动安装它。以下是如何去做：
1\. 运行工作站播放器。
2\. 从菜单导航至**虚拟机->安装 VMware 工具**。如果你已经安装了它并想修复安装，你会看到“**重新安装 VMware 工具**”这一选项出现。
3\. 一旦你点击了，你就会看到一个虚拟 CD/DVD 挂载在客户系统上。
4\. 打开并复制粘贴 **tar.gz** 文件到任何你选择的区域并解压，这里我们选择**桌面**。
![][9]
5\. 在解压后运行终端并通过输入以下命令导航至里面的文件夹：
```
cd Desktop/VMwareTools-10.3.2-9925305/vmware-tools-distrib
```
你需要检查文件夹与路径名-取决于版本与解压目的地-名字可能会改变。
![][10]
Replace **Desktop** with your storage location (such as cd Downloads) and the rest should remain the same if you are installing **10.3.2 version**.
6\. 现在仅需输入以下命令开始安装：
```
sudo ./vmware-install.pl -d
```
![][11]
你会被询问密码以获得安装权限，输入密码然后应当一切都搞定了。
到此为止了，你搞定了。这系列步骤应当适用于几乎大部分基于 Ubuntu 的客机系统。如果你想要在 Ubuntu 服务器上或其它系统安装 VMware 工具，步骤应该类似。
**总结**
在 Ubuntu Linux 上安装 VMware 工具应该挺简单。除了简单办法，我们也详述了手动安装的方法。如果你仍需帮助或者对安装有任何建议，在评论区评论让我们知道。
--------------------------------------------------------------------------------
via: https://itsfoss.com/install-vmware-tools-linux
作者：[Ankush Das][a]
选题：[lujun9972][b]
译者：[tomjlw](https://github.com/tomjlw)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://itsfoss.com/author/ankush/
[b]: https://github.com/lujun9972
[1]: https://itsfoss.com/install-vmware-player-ubuntu-1310/
[2]: https://kb.vmware.com/s/article/340
[3]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools-downloading.jpg?fit=800%2C531&ssl=1
[4]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/install-vmware-tools-linux.png?resize=800%2C450&ssl=1
[5]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools-features.gif?resize=800%2C500&ssl=1
[6]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools-shared-folder.jpg?fit=800%2C660&ssl=1
[7]: https://docs.vmware.com/en/VMware-Workstation-Player-for-Linux/15.0/com.vmware.player.linux.using.doc/GUID-3F6B9D0E-6CFC-4627-B80B-9A68A5960F60.html
[8]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools.jpg?fit=800%2C481&ssl=1
[9]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools-extraction.jpg?fit=800%2C564&ssl=1
[10]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools-folder.jpg?fit=800%2C487&ssl=1
[11]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/02/vmware-tools-installation-ubuntu.jpg?fit=800%2C492&ssl=1