document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2025-01-28 23:20:10 +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-02-01 17:58:53 +08:00
commit 7fe7630d1c
6 changed files with 459 additions and 440 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
translated/tech/20181212 Top 5 configuration management tools.md → published/20181212 Top 5 configuration management tools.md
View File

@ -1,15 +1,17 @@
[#]: collector: (lujun9972)
[#]: translator: (HankChow)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-10497-1.html)
[#]: subject: (Top 5 configuration management tools)
[#]: via: (https://opensource.com/article/18/12/configuration-management-tools)
[#]: author: (Marco Bravo https://opensource.com/users/marcobravo)
五大最流行的配置管理工具
======
在寻找合适的 DevOps 工具之前，你最好要对配置管理工具有一定的了解。
> 了解一下配置管理工具，以找出哪个最适合你的 DevOps 组织。
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/innovation_lightbulb_gears_devops_ansible.png?itok=TSbmp3_M)
DevOps 正因为有提高产品质量、缩短产品开发时间等优势，目前备受业界关注，同时也在长足发展当中。
@ -21,13 +23,11 @@ DevOps 正因为有提高产品质量、缩短产品开发时间等优势，目
* **评估**保证了及时的改进；
* **分享**让 CAMS 成为一个完整的循环过程。
DevOps 的另一个思想是任何东西，包括服务器、数据库、网络、日志文件、应用配置、文档、自动化测试、部署流程等，都可以通过代码来管理。
在本文中，我主要介绍配置管理的自动化。配置管理工具作为[<ruby>基础架构即代码<rt>Infrastructure as Code</rt></ruby>][2]（IaC）的一部分，支持使用软件进行开发实践，以及通过明文定义的文件来管理数据中心。
在本文中，我主要介绍配置管理的自动化。配置管理工具作为[<ruby>基础架构即代码<rt>Infrastructure as Code</rt></ruby>][2]（IaC）的一部分，支持使用经过测试和验证的软件开发实践，通过明文定义文件管理和配置数据中心。
DevOps 团队只需要通过操作简单的配置文件，就可以实现应用开发中包括版本控制、测试、小型部署、设计模式这些最佳实践。总而言是，配置管理工具实现了通过编写代码来使基础架构管理变得自动化。
DevOps 团队只需要通过操作简单的配置文件，就可以实现应用开发中包括版本控制、测试、小型部署、设计模式在内的这些最佳实践。总而言之，配置管理工具实现了通过编写代码来使基础架构的配置和管理变得自动化。
### 为什么要使用配置管理工具？
@ -37,29 +37,37 @@ DevOps 团队只需要通过操作简单的配置文件，就可以实现应用
* 让代码遵守编码规范，提高代码可读性；
* 具有<ruby>幂等性<rt>Idempotency</rt></ruby>，也就是说，无论执行多少次重复的配置管理操作，得到的结果都是一致的；
* 可以方便地管理分布式系统和大量的远程服务器。
* 分布式的设计可以方便地管理大量的远程服务器。
配置管理工具主要分为<ruby>拉取<rt>pull</rt></ruby>模式和<ruby>推送<rt>push</rt></ruby>模式。拉取模式是指安装在各台服务器上的<ruby>代理<rt>agent</rt></ruby>定期从<ruby>中央存储库<rt>central repository</rt></ruby>拉取最新的配置并应用到对应的服务器上；而推送模式则由<ruby>中央服务器<rt>central server</rt></ruby>主动向其它服务器推送更新的配置。
配置管理工具主要分为<ruby>拉取<rt>pull</rt></ruby>模式和<ruby>推送<rt>push</rt></ruby>模式。拉取模式是指安装在各台服务器上的<ruby>代理<rt>agent</rt></ruby>定期从<ruby>中央存储库<rt>central repository</rt></ruby>拉取最新的配置并应用到对应的服务器上；而推送模式则由<ruby>中央服务器<rt>central server</rt></ruby>的中央服务器会触发其它受管服务器的更新。
### 五大最流行的配置管理工具
目前配置管理工具有很多，不同的配置管理工具都有自己最适合的使用场景。而对于下面五个我按照字母顺序列出的配置管理工具，都对 DevOps 有明显的帮助：具有开源许可证、使用外部配置文件、支持无人值守运行、可以通过脚本自定义运行。下面对它们的介绍都来源于它们的软件库和官网内容。
目前配置管理工具有很多，不同的配置管理工具都有自己最适合的使用场景。而对于下面五个我按照字母顺序列出的配置管理工具，都对 DevOps 有明显的帮助：全都具有开源许可证、使用外部配置文件、支持无人值守运行、可以通过脚本自定义运行。下面对它们的介绍都来源于它们的软件库和官网内容。
#### Ansible
“Ansible 是一个极其简洁的 IT 自动化平台，可以让你的应用和系统以更简单的方式部署。不需要安装任何代理，只需要使用 SSH 的方式和简单的语言，就可以免去脚本或代码部署应用的过程。”——[GitHub Ansible 代码库][3]
Ansible 是我最喜欢的工具之一，我在几年前就开始使用了。你可以使用 Ansible 在命令行中让多个服务器执行同一个命令，也可以使用 YAML 格式的 playbook 来让它自动执行特定的操作，这让技术团队和非技术团队之间的沟通变得更加明确。简洁、无代理、配置文件对非技术人员友好是它的几个主要优点。
- [官网](https://www.ansible.com/)
- [文档](https://docs.ansible.com/ansible/)
- [社区](https://www.ansible.com/community)
由于 Ansible 不需要代理，因此对服务器的资源消耗会很少。在默认情况下，Ansible 使用的推送模式需要借助 SSH 连接，但 Ansible 也支持拉取模式。[playbook][4] 可以使用最少的命令集编写，当然也可以扩展为更加精细的自动化任务，包括引入其它角色、变量和模块。
Ansible 是我最喜欢的工具之一，我在几年前就开始使用了。你可以使用 Ansible 在命令行中让多个服务器执行同一个命令，也可以使用 YAML 格式的<ruby>剧本<rt>playbook</rt></ruby>来让它自动执行特定的操作，这促进了技术团队和非技术团队之间的沟通。简洁、无代理、配置文件对非技术人员友好是它的几个主要优点。
你可以将 Ansible 和其它工具（包括 Ansible Works、Jenkins、RunDeck、[ARA][5] 等）结合起来使用，因为这些工具支持 [playbook 的回溯功能][6]，这样就可以很方便地控制整个开发周期中的不同流程。
由于 Ansible 不需要代理，因此对服务器的资源消耗会很少。Ansible 默认使用的推送模式需要借助 SSH 连接，但 Ansible 也支持拉取模式。[剧本][4] 可以使用最少的命令集编写，当然也可以扩展为更加精细的自动化任务，包括引入角色、变量和其它人写的模块。
你可以将 Ansible 和其它工具（包括 Ansible Works、Jenkins、RunDeck、[ARA][5] 等）结合起来使用，因为这些工具 [提供了运行剧本时的可追溯性][6]，这样就可以创建控制流程的中央控制台。
### CFEngine
“CFEngine 3 是一个流行的开源配置管理系统，它可以为大规模的系统提供自动化配置和维护。”——[GitHub CFEngine 代码库][7]
“CFEngine 3 是一个流行的开源配置管理系统，它主要用于为大规模的系统提供自动化配置和维护。”——[GitHub CFEngine 代码库][7]
CFEngine 最早在 1993 年由 Mark Burgess 以自动配置管理的科学方法提出，目的是降低计算机系统配置中的熵，最终收敛到期望的配置状态，同时还阐述了幂等性是让系统达到期望状态的能力。Burgess 在 2004 年又提出了<ruby>承诺理论<rt>Promise Theory</rt></ruby>，这个理论描述了代理之间自发合作的模型。
- [官网](https://cfengine.com/)
- [文档](https://docs.cfengine.com/docs/3.12/)
- [社区](https://cfengine.com/community/)
CFEngine 最早在 1993 年由 Mark Burgess 作为自动配置管理的科学方法提出，目的是降低计算机系统配置中的熵，最终收敛到期望的配置状态，同时还阐述了幂等性是让系统达到期望状态的能力。Burgess 在 2004 年又提出了<ruby>[承诺理论][8]<rt>Promise Theory</rt></ruby>，这个理论描述了代理之间自发合作的模型。
CFEngine 的最新版本已经用到了承诺理论，在各个服务器上的代理程序会从中央存储库拉取配置。CFEngine 的配置对专业技能要求较高，因此它比较适合技术团队使用。
@ -67,13 +75,21 @@ CFEngine 的最新版本已经用到了承诺理论，在各个服务器上的
“为整个基础架构在配置管理上带来便利的一个系统集成框架。”——[GitHub Chef 代码库][9]
Chef 通过由 Ruby 编写的“<ruby>菜谱<rt>recipe</rt></ruby>”来让你的基础架构保持在最新、最兼容的状态，这些“菜谱”描述了一系列资源的某种状态。Chef 既可以通过客户端-服务端的模式运行，也可以在 [chef-solo][10] 这种独立配置的模式下运行。大部分云提供商都很好地集成了 Chef，因此可以使用它为新机器做自动配置。
- [官网](http://www.chef.io/chef/)
- [文档](https://docs.chef.io/)
- [社区](https://www.chef.io/community/)
Chef 通过由 Ruby 编写的“<ruby>菜谱<rt>recipe</rt></ruby>”来让你的基础架构保持在最新、最兼容的状态，这些“菜谱”描述了一系列应处于某种状态的资源。Chef 既可以通过客户端-服务端的模式运行，也可以在 [chef-solo][10] 这种独立配置的模式下运行。大部分云提供商都很好地集成了 Chef，因此可以使用它为新机器做自动配置。
Chef 有广泛的用户基础，同时也提供了完备的工具包，让不同技术背景的团队可以通过“菜谱”进行沟通。尽管如此，它仍然算是一个技术导向的工具。
### Puppet
“Puppet 是可以在 Linux、Unix 和 Windows 系统上运行的自动化管理引擎，它可以根据集中的规范来执行诸如添加用户、安装软件包、更新服务器配置等等管理任务。”——[GitHub Puppet 代码库][11]
“Puppet 是一个可以在 Linux、Unix 和 Windows 系统上运行的自动化管理引擎，它可以根据集中的规范来执行诸如添加用户、安装软件包、更新服务器配置等等管理任务。”——[GitHub Puppet 代码库][11]
- [官网](https://puppet.com/)
- [文档](https://puppet.com/docs)
- [社区](https://puppet.com/community)
Puppet 作为一款面向运维工程师和系统管理员的工具，在更多情况下是作为配置管理工具来使用。它通过客户端-服务端的模式工作，使用代理从主服务器获取配置指令。
@ -83,6 +99,10 @@ Puppet 使用<ruby>声明式语言<rt>declarative language</rt></ruby>或 Ruby
“为大规模基础结构或应用程序实现自动化管理的软件。”——[GitHub Salt 代码库][12]
- [官网](https://www.saltstack.com/)
- [文档](https://docs.saltstack.com/en/latest/contents.html)
- [社区](https://www.saltstack.com/resources/community/)
Salt 的专长就是快速收集数据，即使是上万台服务器也能够轻松完成任务。它使用 Python 模块来管理配置信息和执行特定的操作，这些模块可以让 Salt 实现所有远程操作和状态管理。但配置 Salt 模块对技术水平有一定的要求。
Salt 使用客户端-服务端的结构（Salt minions 是客户端，而 Salt master 是服务端），并以 Salt 状态文件记录需要达到的目标状态。
@ -98,7 +118,7 @@ via: https://opensource.com/article/18/12/configuration-management-tools
作者：[Marco Bravo][a]
选题：[lujun9972][b]
译者：[HankChow](https://github.com/HankChow)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

142
sources/tech/20091104 Linux-Unix App For Prevention Of RSI (Repetitive Strain Injury).md
View File

@ -1,142 +0,0 @@
Translating By Guevaraya
Linux/Unix App For Prevention Of RSI (Repetitive Strain Injury)
======
![workrave-image][1]
[A repetitive strain injury][2] (RSI) is occupational overuse syndrome, non-specific arm pain or work related upper limb disorder. RSI caused from overusing the hands to perform a repetitive task, such as typing, writing, or clicking a mouse. Unfortunately, most people do not understand what RSI is or how dangerous it can be. You can easily prevent RSI using open source software called Workrave.
### What are the symptoms of RSI?
I'm quoting from this [page][3]. Do you experience:
1. Fatigue or lack of endurance?
2. Weakness in the hands or forearms?
3. Tingling, numbness, or loss of sensation?
4. Heaviness: Do your hands feel like dead weight?
5. Clumsiness: Do you keep dropping things?
6. Lack of strength in your hands? Is it harder to open jars? Cut vegetables?
7. Lack of control or coordination?
8. Chronically cold hands?
9. Heightened awareness? Just being slightly more aware of a body part can be a clue that something is wrong.
10. Hypersensitivity?
11. Frequent self-massage (subconsciously)?
12. Sympathy pains? Do your hands hurt when someone else talks about their hand pain?
### How to reduce your risk of Developing RSI
* Take breaks, when using your computer, every 30 minutes or so. Use software such as workrave to prevent RSI.
* Regular exercise can prevent all sort of injuries including RSI.
* Use good posture. Adjust your computer desk and chair to support muscles necessary for good posture.
### Workrave
Workrave is a free open source software application intended to prevent computer users from developing RSI or myopia. The software periodically locks the screen while an animated character, "Miss Workrave," walks the user through various stretching exercises and urges them to take a coffee break. The program frequently alerts you to take micro-pauses, rest breaks and restricts you to your daily limit. The program works under MS-Windows and Linux, UNIX-like operating systems.
#### Install workrave
Type the following [apt command][4]/[apt-get command][5] under a Debian / Ubuntu Linux:
`$ sudo apt-get install workrave`
Fedora Linux user should type the following dnf command:
`$ sudo dnf install workrave`
RHEL/CentOS Linux user should enable EPEL repo and install it using [yum command][6]:
```
### [ **tested on a CentOS/RHEL 7.x and clones** ] ###
$ sudo yum install epel-release
$ sudo yum install https://rpms.remirepo.net/enterprise/remi-release-7.rpm
$ sudo yum install workrave
```
Arch Linux user type the following pacman command to install it:
`$ sudo pacman -S workrave`
FreeBSD user can install it using the following pkg command:
`# pkg install workrave`
OpenBSD user can install it using the following pkg_add command
```
$ doas pkg_add workrave
```
#### How to configure workrave
Workrave works as an applet which is a small application whose user interface resides within a panel. You need to add workrave to panel to control behavior and appearance of the software.
##### Adding a New Workrave Object To Panel
* Right-click on a vacant space on a panel to open the panel popup menu.
* Choose Add to Panel.
* The Add to Panel dialog opens.The available panel objects are listed alphabetically, with launchers at the top. Select workrave applet and click on Add button.
![Fig.01: Adding an Object \(Workrave\) to a Panel][7]
Fig.01: Adding an Object (Workrave) to a Panel
##### How Do I Modify Properties Of Workrave Software?
To modify the properties of an object workrave, perform the following steps:
* Right-click on the workrave object to open the panel object popup.
* Choose Preference. Use the Properties dialog to modify the properties as required.
![](https://www.cyberciti.biz/media/new/tips/2009/11/linux-gnome-workwave-preferences-.png)
Fig.02: Modifying the Properties of The Workrave Software
#### Workrave in Action
The main window shows the time remaining until it suggests a pause. The windows can be closed and you will the time remaining on the panel itself:
![Fig.03: Time reaming counter ][8]
Fig.03: Time reaming counter
![Fig.04: Miss Workrave - an animated character walks you through various stretching exercises][9]
Fig.04: Miss Workrave - an animated character walks you through various stretching exercises
The break prelude window, bugging you to take a micro-pause:
![Fig.05: Time for a micro-pause remainder ][10]
Fig.05: Time for a micro-pause remainder
![Fig.06: You can skip Micro-break ][11]
Fig.06: You can skip Micro-break
##### References:
1. [Workrave project][12] home page.
2. [pokoy][13] lightweight daemon that helps prevent RSI and other computer related stress.
3. [A Pomodoro][14] timer for GNOME 3.
4. [RSI][2] from the wikipedia.
### about the author
The author is the creator of nixCraft and a seasoned sysadmin and a trainer for the Linux operating system/Unix shell scripting. He has worked with global clients and in various industries, including IT, education, defense and space research, and the nonprofit sector. Follow him on [Twitter][15], [Facebook][16], [Google+][17].
--------------------------------------------------------------------------------
via: https://www.cyberciti.biz/tips/repetitive-strain-injury-prevention-software.html
作者：[Vivek Gite][a]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]:https://www.cyberciti.biz/
[1]:https://www.cyberciti.biz/media/new/tips/2009/11/workrave-image.jpg (workrave-image)
[2]:https://en.wikipedia.org/wiki/Repetitive_strain_injury
[3]:https://web.eecs.umich.edu/~cscott/rsi.html##symptoms
[4]:https://www.cyberciti.biz/faq/ubuntu-lts-debian-linux-apt-command-examples/ (See Linux/Unix apt command examples for more info)
[5]:https://www.cyberciti.biz/tips/linux-debian-package-management-cheat-sheet.html (See Linux/Unix apt-get command examples for more info)
[6]:https://www.cyberciti.biz/faq/rhel-centos-fedora-linux-yum-command-howto/ (See Linux/Unix yum command examples for more info)
[7]:https://www.cyberciti.biz/media/new/tips/2009/11/add-workwave-to-panel.png (Adding an Object (Workrave) to a Gnome Panel)
[8]:https://www.cyberciti.biz/media/new/tips/2009/11/screenshot-workrave.png (Workrave main window shows the time remaining until it suggests a pause.)
[9]:https://www.cyberciti.biz/media/new/tips/2009/11/miss-workrave.png (Miss Workrave Sofrware character walks you through various RSI stretching exercises )
[10]:https://www.cyberciti.biz/media/new/tips/2009/11/time-for-micro-pause.gif (Workrave RSI Software Time for a micro-pause remainder )
[11]:https://www.cyberciti.biz/media/new/tips/2009/11/Micro-break.png (Workrave RSI Software Micro-break )
[12]:http://www.workrave.org/
[13]:https://github.com/ttygde/pokoy
[14]:http://gnomepomodoro.org
[15]:https://twitter.com/nixcraft
[16]:https://facebook.com/nixcraft
[17]:https://plus.google.com/+CybercitiBiz

278
sources/tech/20181224 An Introduction to Go.md
View File

@ -1,278 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: (LazyWolfLin)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (An Introduction to Go)
[#]: via: (https://blog.jak-linux.org/2018/12/24/introduction-to-go/)
[#]: author: (Julian Andres Klode https://blog.jak-linux.org/)
An Introduction to Go
======
(What follows is an excerpt from my master’s thesis, almost all of section 2.1, quickly introducing Go to people familiar with CS)
Go is an imperative programming language for concurrent programming created at and mainly developed by Google, initially mostly by Robert Griesemer, Rob Pike, and Ken Thompson. Design of the language started in 2007, and an initial version was released in 2009; with the first stable version, 1.0 released in 2012 .
Go has a C-like syntax (without a preprocessor), garbage collection, and, like its predecessors devloped at Bell Labs – Newsqueak (Rob Pike), Alef (Phil Winterbottom), and Inferno (Pike, Ritchie, et al.) – provides built-in support for concurrency using so-called goroutines and channels, a form of co-routines, based on the idea of Hoare’s ‘Communicating Sequential Processes’ .
Go programs are organised in packages. A package is essentially a directory containing Go files. All files in a package share the same namespace, and there are two visibilities for symbols in a package: Symbols starting with an upper case character are visible to other packages, others are private to the package:
```
func PublicFunction() {
fmt.Println("Hello world")
}
func privateFunction() {
fmt.Println("Hello package")
}
```
### Types
Go has a fairly simple type system: There is no subtyping (but there are conversions), no generics, no polymorphic functions, and there are only a few basic categories of types:
1. base types: `int`, `int64`, `int8`, `uint`, `float32`, `float64`, etc.
2. `struct`
3. `interface` \- a set of methods
4. `map[K, V]` \- a map from a key type to a value type
5. `[number]Type` \- an array of some element type
6. `[]Type` \- a slice (pointer to array with length and capability) of some type
7. `chan Type` \- a thread-safe queue
8. pointer `*T` to some other type
9. functions
10. named type - aliases for other types that may have associated methods:
```
type T struct { foo int }
type T *T
type T OtherNamedType
```
Named types are mostly distinct from their underlying types, so you cannot assign them to each other, but some operators like `+` do work on objects of named types with an underlying numerical type (so you could add two `T` in the example above).
Maps, slices, and channels are reference-like types - they essentially are structs containing pointers. Other types are passed by value (copied), including arrays (which have a fixed length and are copied).
#### Conversions
Conversions are the similar to casts in C and other languages. They are written like this:
```
TypeName(value)
```
#### Constants
Go has “untyped” literals and constants.
```
1 // untyped integer literal
const foo = 1 // untyped integer constant
const foo int = 1 // int constant
```
Untyped values are classified into the following categories: `UntypedBool`, `UntypedInt`, `UntypedRune`, `UntypedFloat`, `UntypedComplex`, `UntypedString`, and `UntypedNil` (Go calls them basic kinds, other basic kinds are available for the concrete types like `uint8`). An untyped value can be assigned to a named type derived from a base type; for example:
```
type someType int
const untyped = 2 // UntypedInt
const bar someType = untyped // OK: untyped can be assigned to someType
const typed int = 2 // int
const bar2 someType = typed // error: int cannot be assigned to someType
```
### Interfaces and ‘objects’
As mentioned before, interfaces are a set of methods. Go is not an object-oriented language per se, but it has some support for associating methods with named types: When declaring a function, a receiver can be provided - a receiver is an additional function argument that is passed before the function and involved in the function lookup, like this:
```
type SomeType struct { ... }
func (s *SomeType) MyMethod() {
}
func main() {
var s SomeType
s.MyMethod()
}
```
An object implements an interface if it implements all methods; for example, the following interface `MyMethoder` is implemented by `*SomeType` (note the pointer), and values of `*SomeType` can thus be used as values of `MyMethoder`. The most basic interface is `interface{}`, that is an interface with an empty method set - any object satisfies that interface.
```
type MyMethoder interface {
MyMethod()
}
```
There are some restrictions on valid receiver types; for example, while a named type could be a pointer (for example, `type MyIntPointer *int`), such a type is not a valid receiver type.
### Control flow
Go provides three primary statements for control flow: `if`, `switch`, and `for`. The statements are fairly similar to their equivalent in other C-like languages, with some exceptions:
* There are no parentheses around conditions, so it is `if a == b {}`, not `if (a == b) {}`. The braces are mandatory.
* All of them can have initialisers, like this
`if result, err := someFunction(); err == nil { // use result }`
* The `switch` statement can use arbitrary expressions in cases
* The `switch` statement can switch over nothing (equals switching over true)
* Cases do not fall through by default (no `break` needed), use `fallthrough` at the end of a block to fall through.
* The `for` loop can loop over ranges: `for key, val := range map { do something }`
### Goroutines
The keyword `go` spawns a new goroutine, a concurrently executed function. It can be used with any function call, even a function literal:
```
func main() {
...
go func() {
...
}()
go some_function(some_argument)
}
```
### Channels
Goroutines are often combined with channels to provide an extended form of Communicating Sequential Processes . A channel is a concurrent-safe queue, and can be buffered or unbuffered:
```
var unbuffered = make(chan int) // sending blocks until value has been read
var buffered = make(chan int, 5) // may have up to 5 unread values queued
```
The `<-` operator is used to communicate with a single channel.
```
valueReadFromChannel := <- channel
otherChannel <- valueToSend
```
The `select` statement allows communication with multiple channels:
```
select {
case incoming := <- inboundChannel:
// A new message for me
case outgoingChannel <- outgoing:
// Could send a message, yay!
}
```
### The `defer` statement
Go provides a `defer` statement that allows a function call to be scheduled for execution when the function exits. It can be used for resource clean-up, for example:
```
func myFunc(someFile io.ReadCloser) {
defer someFile.close()
/bin /boot /dev /etc /home /lib /lib64 /lost+found /media /mnt /opt /proc /root /run /sbin /srv /sys /tmp /usr /var Do stuff with file */
}
```
It is of course possible to use function literals as the function to call, and any variables can be used as usual when writing the call.
### Error handling
Go does not provide exceptions or structured error handling. Instead, it handles errors by returning them in a second or later return value:
```
func Read(p []byte) (n int, err error)
// Built-in type:
type error interface {
Error() string
}
```
Errors have to be checked in the code, or can be assigned to `_`:
```
n0, _ := Read(Buffer) // ignore error
n, err := Read(buffer)
if err != nil {
return err
}
```
There are two functions to quickly unwind and recover the call stack, though: `panic()` and `recover()`. When `panic()` is called, the call stack is unwound, and any deferred functions are run as usual. When a deferred function invokes `recover()`, the unwinding stops, and the value given to `panic()` is returned. If we are unwinding normally and not due to a panic, `recover()` simply returns `nil`. In the example below, a function is deferred and any `error` value that is given to `panic()` will be recovered and stored in an error return value. Libraries sometimes use that approach to make highly recursive code like parsers more readable, while still maintaining the usual error return value for public functions.
```
func Function() (err error) {
defer func() {
s := recover()
switch s := s.(type) { // type switch
case error:
err = s // s has type error now
default:
panic(s)
}
}
}
```
### Arrays and slices
As mentioned before, an array is a value type and a slice is a pointer into an array, created either by slicing an existing array or by using `make()` to create a slice, which will create an anonymous array to hold the elements.
```
slice1 := make([]int, 2, 5) // 5 elements allocated, 2 initialized to 0
slice2 := array[:] // sliced entire array
slice3 := array[1:] // slice of array without first element
```
There are some more possible combinations for the slicing operator than mentioned above, but this should give a good first impression.
A slice can be used as a dynamically growing array, using the `append()` function.
```
slice = append(slice, value1, value2)
slice = append(slice, arrayOrSlice...)
```
Slices are also used internally to represent variable parameters in variable length functions.
### Maps
Maps are simple key-value stores and support indexing and assigning. They are not thread-safe.
```
someValue := someMap[someKey]
someValue, ok := someMap[someKey] // ok is false if key not in someMap
someMap[someKey] = someValue
```
--------------------------------------------------------------------------------
via: https://blog.jak-linux.org/2018/12/24/introduction-to-go/
作者：[Julian Andres Klode][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://blog.jak-linux.org/
[b]: https://github.com/lujun9972

2
sources/tech/20190129 More About Angle Brackets in Bash.md
View File

@ -1,5 +1,5 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: translator: (HankChow)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )

145
translated/tech/20091104 Linux-Unix App For Prevention Of RSI (Repetitive Strain Injury).md Normal file
View File

@ -0,0 +1,145 @@
如何在Linux下开发避免重复性压迫损伤
======
![workrave-image][1]
[重复性压迫损伤][2] （RSI）是职业性损伤综合征, 非特异性手臂疼痛或工作引起的上肢障碍。重复性压迫损伤 (RSI) 是由于过度使用双手从事重复性任务，如打字，写和使用鼠标. 不幸的是，大部分人不了解什么是重复性压迫损伤 (RSI)以及它的危害有多大。你可以使用名叫Workrave的开源软件轻松的预防重复性压迫损伤 (RSI)。
### 重复性压迫损伤 (RSI)有哪些症状？
我从[page][3]引用过来的, 看看哪些你被说中了：
1. 疲惫缺乏忍耐力？
2. 手掌及上肢乏力
3. 疼痛麻木甚至失去知觉？
4. 沉重：你有没有感觉手很沉？
5. 笨拙: 你有没有感觉抓不紧东西？
6. 你有没有感觉手上无力？很难打开罐子或切菜无力？
7. 缺乏协调和控制？
8. 手总是冰凉的？
9. 健康意识有待提高？稍不注意身体就发现有毛病了。
10. 是否过敏？
11. 频繁的自我按摩(潜意识的)？
12. 共鸣的疼痛？ 当别人在谈论手痛的时候，你是否也感觉到了手疼？
### 如何减少开发者的重复性压迫损伤风险（RSI）
* 使用计算机的时候每个30分钟间隔休息一下。借助软件如 workrave 预防重复性压迫损伤风险（RSI）。
* 有规律的锻炼可以预防各种损伤，包括重复性压迫损伤
* 使用合理的姿势。调整你的电脑桌和椅子使身体保持一个肌肉放松状态
### Workrave
Workrave 是一款预防计算机用户患重复性损伤（RSI）或近视。软件会定期锁屏为一个动画： "Workrave 小姐" 引导用户做各种伸展运动并敦促其休息一下。这个软件经常提醒你暂停休息一下并限制你每天的活动。程序可以运行在 MS-Window ， Linux以及类UNIX操作系统下。
#### 安装 workrave
在Debian/Ubuntu Linux系统运行以下 [apt 命令][4]/[apt-get 命令][5]：
`$ sudo apt-get install workrave`
Fedora Linux 发行版用户运行一下dnf命令：
`$ sudo dnf install workrave`
RHEL/CentOS Linux 用户可以启动EPEL repo并用[yum 命令][6]安装：
```
### [ **在CentOS/RHEL 7.x 及衍生版本上测试** ] ###
$ sudo yum install epel-release
$ sudo yum install https://rpms.remirepo.net/enterprise/remi-release-7.rpm
$ sudo yum install workrave
```
Arch Linux用户运行以下pacman命令来安装：
`$ sudo pacman -S workrave`
FreeBSD 用户可用一下pkg命令安装：
`# pkg install workrave`
OpenBSD 用户可用一下pkg_add命令安装：
```
$ doas pkg_add workrave
```
#### 如何配置 workrave
Workrave 以一个小程序运行，他的用户界面位于面板中。你可以为 workrave 增加一个面板来控制软件的动作和外观。
##### 增加一个新workrave对象到面板
* 在面板空白区域右键，打开面板弹出菜单
* 选择新增到面板
* 新增面板对话框打开，在加载器顶部，可以看到可用的面板对象按照字母排列。选中 workrave 程序并单击新增。
![Fig.01: 添加workrave对象到面板][7]
Fig.01: 新增workrave对象到面板
##### 如何设置 Workrave 属性?
如果修改 workrave 对象的属性，执行以下步骤：
* 右键 workrave 对象打开面板对象弹出
* 选中偏好。使用属性对话框修改对应属性
![](https://www.cyberciti.biz/media/new/tips/2009/11/linux-gnome-workwave-preferences-.png)
Fig.02: 修改 Workrave 对象属性
#### Workrave 运行展示
主窗口显示下一次提醒休息的剩余时间，这个窗口可以关闭，时间提示窗口会在面板上。
![Fig.03: 时间计数器 ][8]
Fig.03:时间计数器
![Fig.04: Workrave 小姐- 引导你做伸展运动的动画][9]
Fig.04: Workrave 小姐- 引导你做伸展运动的动画
休息提示窗口，请求你暂停一下工作
![Fig.05: 休息提示倒计时 ][10]
Fig.05: 休息提示倒计时
![Fig.06: 你可以跳过休息按钮 ][11]
Fig.06: 你可以跳过休息按钮
##### 参考链接:
1. [Workrave 项目][12] 主页
2. [pokoy][13] 轻量级防止重复性压迫损伤（RSI）和其他计算机压力的程序
3. GNOME3下的[Pomodoro][14] 计数器 .
4. [RSI][2] 的维基百科
### 关于作者
作者是nixCraft创始人，经验丰富的系统管理员，同时也是一个Linux/Unix系统下的shell脚本培训师。他曾服务于全球客户，并与多个行业合作包括IT，教育，国防和航天研究，以及非盈利机构。可以[Twitter][15], [Facebook][16], [Google+][17]关注他。
--------------------------------------------------------------------------------
via: https://www.cyberciti.biz/tips/repetitive-strain-injury-prevention-software.html
作者：[Vivek Gite][a]
译者：[guevaraya](https://github.com/guevaraya)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]:https://www.cyberciti.biz/
[1]:https://www.cyberciti.biz/media/new/tips/2009/11/workrave-image.jpg
[2]:https://en.wikipedia.org/wiki/Repetitive_strain_injury
[3]:https://web.eecs.umich.edu/~cscott/rsi.html##symptoms
[4]:https://www.cyberciti.biz/faq/ubuntu-lts-debian-linux-apt-command-examples/
[5]:https://www.cyberciti.biz/tips/linux-debian-package-management-cheat-sheet.html
[6]:https://www.cyberciti.biz/faq/rhel-centos-fedora-linux-yum-command-howto/
[7]:https://www.cyberciti.biz/media/new/tips/2009/11/add-workwave-to-panel.png
[8]:https://www.cyberciti.biz/media/new/tips/2009/11/screenshot-workrave.png
[9]:https://www.cyberciti.biz/media/new/tips/2009/11/miss-workrave.png
[10]:https://www.cyberciti.biz/media/new/tips/2009/11/time-for-micro-pause.gif
[11]:https://www.cyberciti.biz/media/new/tips/2009/11/Micro-break.png
[12]:http://www.workrave.org/
[13]:https://github.com/ttygde/pokoy
[14]:http://gnomepomodoro.org
[15]:https://twitter.com/nixcraft
[16]:https://facebook.com/nixcraft
[17]:https://plus.google.com/+CybercitiBiz

274
translated/tech/20181224 An Introduction to Go.md Normal file
View File

@ -0,0 +1,274 @@
[#]: collector: (lujun9972)
[#]: translator: (LazyWolfLin)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (An Introduction to Go)
[#]: via: (https://blog.jak-linux.org/2018/12/24/introduction-to-go/)
[#]: author: (Julian Andres Klode https://blog.jak-linux.org/)
Go 简介
======
（以下内容是我的硕士论文的摘录，几乎整个 2.1 章节，向具有 CS 背景的人快速介绍 Go）
Go 是一门用于并发编程的命令式编程语言，它主要由创造者 Google 进行开发，最初主要由 Robert Griesemer、Rob Pike 和 Ken Thompson开发。这门语言的设计起始于 2017 年，并在 2019 年推出最初版本；而第一个稳定版本是 2012 年发布的 1.0 版本。
Go 有 C 风格的语法（没有预处理器），垃圾回收机制，而且类似它在贝尔实验室里被开发出来的前辈们：Newsqueak (Rob Pike)、Alef (Phil Winterbottom) 和 Inferno (Pike, Ritchie, et al.)，使用所谓的 goroutines 和信道（一种基于 Hoare 的“通信顺序进程”理论的协程）提供内建的并发支持。
Go 程序以包的形式组织。包本质是一个包含 Go 文件的文件夹。包内的所有文件共享相同的命名空间，而包内的符号有两种可见性：以大写字母开头的符号对于其他包是可见，而其他符号则是该包私有的：
```
func PublicFunction() {
fmt.Println("Hello world")
}
func privateFunction() {
fmt.Println("Hello package")
}
```
### 类型
Go 有一个相当简单的类型系统：没有子类型（但有类型转换），没有泛型，没有多态函数，只有一些基本的类型：
1. 基本类型：`int`、`int64`、`int8`、`uint`、`float32`、`float64` 等。
2. `struct`
3. `interface` \- 一组方法的集合
4. `map[K, V]` \- 一个从键类型到值类型的映射
5. `[number]Type` \- 一些 Type 类型的元素组成的数组
6. `[]Type` \- 某种类型的切片（指向具有长度和功能的数组）
7. `chan Type` \- 一个线程安全的队列
8. 指针 `*T` 指向其他类型
9. 函数
10. 具名类型 - 可能具有关联方法的其他类型的别名（译者注：这里的别名并非指 Go 1.9 中的新特性“类型别名”）：
```
type T struct { foo int }
type T *T
type T OtherNamedType
```
具名类型完全不同于他们的底层类型，所以你不能让他们互相赋值，但一些运输符，例如 `+`，能够处理同一底层数值类型的具名类型对象们（所以你可以在上面的示例中把两个 `T` 加起来）。
Maps、slices 和 channels 是类似于引用的类型——他们实际上是包含指针的结构。包括数组（具有固定长度并可被拷贝）在内的其他类型则是值（拷贝）传递。
#### 类型转换
类型转换类似于 C 或其他语言中的类型转换。它们写成这样子：
```
TypeName(value)
```
#### 常量
Go 有“无类型”字面量和常量。
```
1 // 无类型整数字面量
const foo = 1 // 无类型整数常量
const foo int = 1 // int 类型常量
```
无类型值可以分为以下几类：`UntypedBool`、`UntypedInt`、`UntypedRune`、`UntypedFloat`、`UntypedComplex`、`UntypedString` 以及 `UntypedNil`（Go 称它们为基础类型，其他基础种类可用于具体类型，如 `uint8`）。一个无类型值可以赋值给一个从基础类型中派生的具名类型；例如：
```
type someType int
const untyped = 2 // UntypedInt
const bar someType = untyped // OK: untyped 可以被赋值给 someType
const typed int = 2 // int
const bar2 someType = typed // error: int 不能被赋值给 someType
```
### 接口和对象
正如上面所说的，接口是一组方法的集合。Go 本身不是一种面向对象的语言，但它支持将方法关联到命名类型上：当声明一个函数时，可以提供一个接收者。接收者是函数的一个额外参数，可以在函数之前传递并参与函数查找，就像这样：
```
type SomeType struct { ... }
func (s *SomeType) MyMethod() {
}
func main() {
var s SomeType
s.MyMethod()
}
```
如果对象实现了所有方法，那么它就实现了接口；例如，`*SomeType`（注意指针）实现了下面的接口 `MyMethoder`，因此 `*SomeType` 类型的值就能作为 `MyMethoder` 类型的值使用。最基本的接口类型是 `interface{}`，它是一个带空方法集的接口——任何对象都满足该接口。
```
type MyMethoder interface {
MyMethod()
}
```
合法的接收者类型是有些限制的；例如，命名类型可以是指针类型（例如，`type MyIntPointer *int`），但这种类型不是合法的接收者类型。
### 控制流
Go 提供了三个主要的控制了语句：`if`、`switch` 和 `for`。这些语句同其他 C 风格语言内的语句非常类似，但有一些不同：
* 条件语句没有括号，所以条件语句是 `if a == b {}` 而不是 `if (a == b) {}`。大括号是必须的。
* 所有的语句都可以有初始化，比如这个
`if result, err := someFunction(); err == nil { // use result }`
* `switch` 语句在 cases 里可以使用任何表达式
* `switch` 语句可以处理空的表达式（等于 true）
* 默认情况下，Go 不会从一个 case 进入下一个 case（不需要 `break`语句），在程序块的末尾使用 `fallthrough` 则会进入下一个 case。
* 循环语句 `for` 不仅能循环值域：`for key, val := range map { do something }`
### Goroutines
关键词 `go` 会产生一个新的 goroutine，一个可以并行执行的函数。它可以用于任何函数调用，甚至一个匿名函数：
```
func main() {
...
go func() {
...
}()
go some_function(some_argument)
}
```
### 信道
Goroutines 通常和信道结合，用来提供一种通信顺序进程的扩展。信道是一个并发安全的队列，而且可以选择是否缓冲数据：
```
var unbuffered = make(chan int) // 直到数据被读取时完成数据块发送
var buffered = make(chan int, 5) // 最多有 5 个未读取的数据块
```
运算符 `<-` 用于和单个信道进行通信。
```
valueReadFromChannel := <- channel
otherChannel <- valueToSend
```
语句 `select` 允许多个信道进行通信：
```
select {
case incoming := <- inboundChannel:
// 一条新消息
case outgoingChannel <- outgoing:
// 可以发送消息
}
```
### `defer` 声明
Go 提供语句 `defer` 允许函数退出时调用执行预定的函数。它可以用于进行资源释放操作，例如：
```
func myFunc(someFile io.ReadCloser) {
defer someFile.close()
/* 文件相关操作 */
}
```
当然，它允许使用匿名函数作为被调函数，而且编写被调函数时可以像平常一样使用任何变量。
### 错误处理
Go 没有提供异常类或者结构化的错误处理。然而，它通过第二个及后续的返回值来返回错误从而处理错误：
```
func Read(p []byte) (n int, err error)
// 内建类型：
type error interface {
Error() string
}
```
必须在代码中检查错误或者赋值给 `_`：
```
n0, _ := Read(Buffer) // 忽略错误
n, err := Read(buffer)
if err != nil {
return err
}
```
有两个函数可以快速跳出和恢复调用栈：`panic()` 和 `recover()`。当 `panic()` 被调用时，调用栈开始弹出，同时每个 `defer` 函数都会正常运行。当一个 `defer` 函数调用 `recover()`时，调用栈停止弹出，同时返回函数 `panic()` 给出的值。如果我们让调用栈正常弹出而不是由于调用 `panic()` 函数，`recover()` 将只返回 `nil`。在下面的例子中，`defer` 函数将捕获 `panic()` 抛出的任何 `error` 类型的值并储存在错误返回值中。第三方库中有时会使用这个方法增强递归代码的可读性，如解析器，同时保持公有函数仍使用普通错误返回值。
```
func Function() (err error) {
defer func() {
s := recover()
switch s := s.(type) { // type switch
case error:
err = s // s has type error now
default:
panic(s)
}
}
}
```
### 数组和切片
正如前边说的，数组是值类型而切片是指向数组的指针。切片可以由现有的数组切片产生，也可以使用 `make()` 创建切片，这会创建一个匿名数组以保存元素。
```
slice1 := make([]int, 2, 5) // 分配 5 个元素，其中 2 个初始化为0
slice2 := array[:] // 整个数组的切片
slice3 := array[1:] // 除了首元素的切片
```
除了上述例子，还有更多可行的切片运算组合，但需要明了直观。
使用 `append()` 函数，切片可以作为一个变长数组使用。
```
slice = append(slice, value1, value2)
slice = append(slice, arrayOrSlice...)
```
切片也可以用于函数的变长参数。
### Maps
Maps 是简单的键值对储存容器并支持索引和分配。但它们不是线程安全的。
```
someValue := someMap[someKey]
someValue, ok := someMap[someKey] // 如果键值不在 someMap 中，变量 ok 会赋值为 `false`
someMap[someKey] = someValue
```
--------------------------------------------------------------------------------
via: https://blog.jak-linux.org/2018/12/24/introduction-to-go/
作者：[Julian Andres Klode][a]
选题：[lujun9972][b]
译者：[LazyWolfLin](https://github.com/LazyWolfLin)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://blog.jak-linux.org/
[b]: https://github.com/lujun9972