Merge pull request #5 from LCTT/master

2019-03-05 update from LCTT

published/20150616 Computer Laboratory - Raspberry Pi- Lesson 8 Screen03.md

@@ -1,34 +1,30 @@
 [#]: collector: (lujun9972)
 [#]: translator: (qhwdw)
-[#]: reviewer: ( )
-[#]: publisher: ( )
-[#]: url: ( )
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10585-1.html)
 [#]: subject: (Computer Laboratory – Raspberry Pi: Lesson 8 Screen03)
 [#]: via: (https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/screen03.html)
 [#]: author: (Alex Chadwick https://www.cl.cam.ac.uk)
 
-计算机实验室 – 树莓派：课程 8 屏幕03
+计算机实验室之树莓派：课程 8 屏幕03
 ======
 
 屏幕03 课程基于屏幕02 课程来构建，它教你如何绘制文本，和一个操作系统命令行参数上的一个小特性。假设你已经有了[课程 7：屏幕02][1] 的操作系统代码，我们将以它为基础来构建。
 
 ### 1、字符串的理论知识
 
-是的，我们的任务是为这个操作系统绘制文本。我们有几个问题需要去处理，最紧急的那个可能是如何去保存文本。令人难以置信的是，文本是迄今为止在计算机上最大的缺陷之一。原本应该是简单的数据类型却导致了操作系统的崩溃，破坏了完美的加密，并给使用不同字母表的用户带来了许多问题。尽管如此，它仍然是极其重要的数据类型，因为它将计算机和用户很好地连接起来。文本是计算机能够理解的非常好的结构，同时人类使用它时也有足够的可读性。
+是的，我们的任务是为这个操作系统绘制文本。我们有几个问题需要去处理，最紧急的那个可能是如何去保存文本。令人难以置信的是，文本是迄今为止在计算机上最大的缺陷之一。原本应该是简单的数据类型却导致了操作系统的崩溃，从而削弱其他方面的加密效果，并给使用其它字母表的用户带来了许多问题。尽管如此，它仍然是极其重要的数据类型，因为它将计算机和用户很好地连接起来。文本是计算机能够理解的非常好的结构，同时人类使用它时也有足够的可读性。
 
-```
-可变数据类型，比如文本要求能够进行很复杂的处理。
-```
+那么，文本是如何保存的呢？非常简单，我们使用一种方法，给每个字母分配一个唯一的编号，然后我们保存一系列的这种编号。看起来很容易吧。问题是，那个编号的数量是不固定的。一些文本段可能比其它的长。保存普通数字，我们有一些固有的限制，即：32 位，我们不能超过这个限制，我们要添加方法去使用该长度的数字等等。“文本”这个术语，我们经常也叫它“字符串”，我们希望能够写一个可用于可变长度字符串的函数，否则就需要写很多函数！对于一般的数字来说，这不是个问题，因为只有几种通用的数字格式（字节、字、半字节、双字节）。
 
-那么，文本是如何保存的呢？非常简单，我们使用一种方法，给每个字母分配一个唯一的编号，然后我们保存一系列的这种编号。看起来很容易吧。问题是，那个编号的数字是不固定的。一些文本片断可能比其它的长。与保存普通数字一样，我们有一些固有的限制，即：3 位，我们不能超过这个限制，我们添加方法去使用那种长数字等等。“文本”这个术语，我们经常也叫它“字符串”，我们希望能够写一个可用于变长字符串的函数，否则就需要写很多函数！对于一般的数字来说，这不是个问题，因为只有几种通用的数字格式（字节、字、半字节、双字节）。
+> 可变数据类型（比如文本）要求能够进行很复杂的处理。
 
-```
-缓冲区溢出攻击祸害计算机由来已久。最近，Wii、Xbox 和 Playstation 2、以及大型系统如 Microsoft 的 Web 和数据库服务器，都遭受到缓冲区溢出攻击。
-```
+因此，如何判断字符串长度？我想显而易见的答案是存储字符串的长度，然后去存储组成字符串的字符。这称为长度前缀，因为长度位于字符串的前面。不幸的是，计算机科学家的先驱们不同意这么做。他们认为使用一个称为空终止符（`NULL`）的特殊字符（用 `\0` 表示）来表示字符串结束更有意义。这样确定简化了许多字符串算法，因为你只需要持续操作直到遇到空终止符为止。不幸的是，这成为了许多安全问题的根源。如果一个恶意用户给你一个特别长的字符串会发生什么状况？如果没有足够的空间去保存这个特别长的字符串会发生什么状况？你可以使用一个字符串复制函数来做复制，直到遇到空终止符为止，但是因为字符串特别长，而覆写了你的程序，怎么办？这看上去似乎有些较真，但是，缓冲区溢出攻击还是经常发生。长度前缀可以很容易地缓解这种问题，因为它可以很容易地推算出保存这个字符串所需要的缓冲区的长度。作为一个操作系统开发者，我留下这个问题，由你去决定如何才能更好地存储文本。
 
-因此，如何判断字符串长度？我想显而易见的答案是存储多长的字符串，然后去存储组成字符串的字符。这称为长度前缀，因为长度位于字符串的前面。不幸的是，计算机科学家的先驱们不同意这么做。他们认为使用一个称为空终止符（NULL）的特殊字符（用 \0表示）来表示字符串结束更有意义。这样确定简化了许多字符串算法，因为你只需要持续操作直到遇到空终止符为止。不幸的是，这成为了许多安全问题的根源。如果一个恶意用户给你一个特别长的字符串会发生什么状况？如果没有足够的空间去保存这个特别长的字符串会发生什么状况？你可以使用一个字符串复制函数来做复制，直到遇到空终止符为止，但是因为字符串特别长，而覆写了你的程序，怎么办？这看上去似乎有些较真，但尽管如此，缓冲区溢出攻击还是经常发生。长度前缀可以很容易地缓解这种问题，因为它可以很容易地推算出保存这个字符串所需要的缓冲区的长度。作为一个操作系统开发者，我留下这个问题，由你去决定如何才能更好地存储文本。
+> 缓冲区溢出攻击祸害计算机由来已久。最近，Wii、Xbox 和 Playstation 2、以及大型系统如 Microsoft 的 Web 和数据库服务器，都遭受到缓冲区溢出攻击。
 
-接下来的事情是，我们需要去维护一个很好的从字符到数字的映射。幸运的是，这是高度标准化的，我们有两个主要的选择，Unicode 和 ASCII。Unicode 几乎将每个单个的有用的符号都映射为数字，作为交换，我们得到的是很多很多的数字，和一个更复杂的编码方法。ASCII 为每个字符使用一个字节，因此它仅保存拉丁字母、数字、少数符号和少数特殊字符。因此，ASCII 是非常易于实现的，与 Unicode 相比，它的每个字符占用的空间并不相同，这使得字符串算法更棘手。一般操作系统上字符使用 ASCII，并不是为了显示给最终用户的（开发者和专家用户除外），给终端用户显示信息使用 Unicode，因为 Unicode 能够支持像日语字符这样的东西，并且因此可以实现本地化。
+接下来的事情是，我们需要确定的是如何最好地将字符映射到数字。幸运的是，这是高度标准化的，我们有两个主要的选择，Unicode 和 ASCII。Unicode 几乎将每个有用的符号都映射为数字，作为代价，我们需要有很多很多的数字，和一个更复杂的编码方法。ASCII 为每个字符使用一个字节，因此它仅保存拉丁字母、数字、少数符号和少数特殊字符。因此，ASCII 是非常易于实现的，与之相比，Unicode 的每个字符占用的空间并不相同，这使得字符串算法更棘手。通常，操作系统上字符使用 ASCII，并不是为了显示给最终用户的（开发者和专家用户除外），给终端用户显示信息使用 Unicode，因为 Unicode 能够支持像日语字符这样的东西，并且因此可以实现本地化。
 
 幸运的是，在这里我们不需要去做选择，因为它们的前 128 个字符是完全相同的，并且编码也是完全一样的。
 
@@ -45,27 +41,27 @@
 | 60 | `   | a   | b   | c   | d   | e   | f   | g   | h   | i  | j   | k   | l  | m  | n  | o  |     |
 | 70 | p   | q   | r   | s   | t   | u   | v   | w   | x   | y  | z   | {   |    |    | }  | ~  | DEL |
 
-这个表显示了前 128 个符号。一个符号的十六进制表示是行的值加上列的值，比如 A 是 41~16~。你可以惊奇地发现前两行和最后的值。这 33 个特殊字符是不可打印字符。事实上，许多人都忽略了它们。它们之所以存在是因为 ASCII 最初设计是基于计算机网络来传输数据的一种方法。因此它要发送的信息不仅仅是符号。你应该学习的重要的特殊字符是 `NUL`，它就是我们前面提到的空终止符。`HT` 水平制表符就是我们经常说的 `tab`，而 `LF` 换行符用于生成一个新行。你可能想研究和使用其它特殊字符在你的操行系统中的意义。
+这个表显示了前 128 个符号。一个符号的十六进制表示是行的值加上列的值，比如 A 是 41<sub>16</sub>。你可以惊奇地发现前两行和最后的值。这 33 个特殊字符是不可打印字符。事实上，许多人都忽略了它们。它们之所以存在是因为 ASCII 最初设计是基于计算机网络来传输数据的一种方法。因此它要发送的信息不仅仅是符号。你应该学习的重要的特殊字符是 `NUL`，它就是我们前面提到的空终止符。`HT` 水平制表符就是我们经常说的 `tab`，而 `LF` 换行符用于生成一个新行。你可能想研究和使用其它特殊字符在你的操行系统中的意义。
 
 ### 2、字符
 
 到目前为止，我们已经知道了一些关于字符串的知识，我们可以开始想想它们是如何显示的。为了显示一个字符串，我们需要做的最基础的事情是能够显示一个字符。我们的第一个任务是编写一个 `DrawCharacter` 函数，给它一个要绘制的字符和一个位置，然后它将这个字符绘制出来。
 
-```markdown
-在许多操作系统中使用的 `truetype` 字体格式是很强大的，它内置有它自己的汇编语言，以确保在任何分辨率下字母看起来都是正确的。
-```
+这就很自然地引出关于字体的讨论。我们已经知道有许多方式去按照选定的字体去显示任何给定的字母。那么字体又是如何工作的呢？在计算机科学的早期阶段，字体就是所有字母的一系列小图片而已，这种字体称为位图字体，而所有的字符绘制方法就是将图片复制到屏幕上。当人们想去调整字体大小时就出问题了。有时我们需要大的字母，而有时我们需要的是小的字母。尽管我们可以为每个字体、每种大小、每个字符都绘制新图片，但这种作法过于单调乏味。所以，发明了矢量字体。矢量字体不包含字体的图像，它包含的是如何去绘制字符的描述，即：一个 `o` 可能是最大字母高度的一半为半径绘制的圆。现代操作系统都几乎仅使用这种字体，因为这种字体在任何分辨率下都很完美。
 
-这就很自然地引出关于字体的讨论。我们已经知道有许多方式去按照选定的字体去显示任何给定的字母。那么字体又是如何工作的呢？在计算机科学的早期阶段，一种字体就是所有字母的一系列小图片而已，这种字体称为位图字体，而所有的字符绘制方法就是将图片复制到屏幕上。当人们想去调整字体大小时就出问题了。有时我们需要大的字母，而有时我们需要的是小的字母。尽管我们可以为每个字体、每种大小、每个字符都绘制新图片，但这种作法过于单调乏味。所以，发明了矢量字体。矢量字体不包含字体的图像，它包含的是如何去绘制字符的描述，即：一个 `o` 可能是最大字母高度的一半为半径绘制的圆。现代操作系统都几乎仅使用这种字体，因为这种字体在任何分辨率下都很完美。
+> 在许多操作系统中使用的 TrueType 字体格式是很强大的，它内置有它自己的汇编语言，以确保在任何分辨率下字母看起来都是正确的。
 
-不幸的是，虽然我很想包含一个矢量字体的格式的实现，但它的内容太多了，将占用这个站点的剩余部分。所以，我们将去实现一个位图字体，可是，如果你想去做一个正宗的图形化的操作系统，那么矢量字体将是很有用的。
+不幸的是，虽然我很想包含一个矢量字体的格式的实现，但它的内容太多了，将占用这个网站的剩余部分。所以，我们将去实现一个位图字体，可是，如果你想去做一个像样的图形操作系统，那么矢量字体将是很有用的。
 
 在下载页面上的字体节中，我们提供了几个 `.bin` 文件。这些只是字体的原始二进制数据文件。为完成本教程，从等宽、单色、8x16 节中挑选你喜欢的字体。然后下载它并保存到 `source` 目录中并命名为 `font.bin` 文件。这些文件只是每个字母的单色图片，它们每个字母刚好是 8 x 16 个像素。所以，每个字母占用 16 字节，第一个字节是第一行，第二个字节是第二行，依此类推。
 
 ![bitmap](https://ws2.sinaimg.cn/large/006tNc79ly1fzzb2064agj305l0apt96.jpg)
 
-这个示意图展示了等宽、单色、8x16 的字符 A 的 `Bitstream Vera Sans Mono`。在这个文件中，我们可以找到，它从第 41~16~ × 10~16~ = 410~16~ 字节开始的十六进制序列：
+这个示意图展示了等宽、单色、8x16 的字符 A 的 “Bitstream Vera Sans Mono” 字体。在这个文件中，我们可以找到，它从第 41<sub>16</sub> × 10<sub>16</sub> = 410<sub>16</sub> 字节开始的十六进制序列：
 
+```
 00, 00, 00, 10, 28, 28, 28, 44, 44, 7C, C6, 82, 00, 00, 00, 00
+```
 
 在这里我们将使用等宽字体，因为等宽字体的每个字符大小是相同的。不幸的是，大多数字体的复杂之处就是因为它的宽度不同，从而导致它的显示代码更复杂。在下载页面上还包含有几个其它的字体，并包含了这种字体的存储格式介绍。
 
@@ -77,9 +73,7 @@ font:
 .incbin "font.bin"
 ```
 
-```assembly
-.incbin "file" 插入来自文件 “file” 中的二进制数据。
-```
+> `.incbin "file"` 插入来自文件 “file” 中的二进制数据。
 
 这段代码复制文件中的字体数据到标签为 `font` 的地址。我们在这里使用了一个 `.align 4` 去确保每个字符都是从 16 字节的倍数开始，这是一个以后经常用到的用于加快访问速度的技巧。
 
@@ -98,8 +92,8 @@ function drawCharacter(r0 is character, r1 is x, r2 is y)
   next
   return r0 = 8, r1 = 16
 end function
-
 ```
+
 如果直接去实现它，这显然不是个高效率的做法。像绘制字符这样的事情，效率是最重要的。因为我们要频繁使用它。我们来探索一些改善的方法，使其成为最优化的汇编代码。首先，因为我们有一个 `× 16`，你应该会马上想到它等价于逻辑左移 4 位。紧接着我们有一个变量 `row`，它只与 `charAddress` 和 `y` 相加。所以，我们可以通过增加替代变量来消除它。现在唯一的问题是如何判断我们何时完成。这时，一个很好用的 `.align 4` 上场了。我们知道，`charAddress` 将从包含 0 的低位半字节开始。这意味着我们可以通过检查低位半字节来看到进入字符数据的程度。
 
 虽然我们可以消除对 `bit` 的需求，但我们必须要引入新的变量才能实现，因此最好还是保留它。剩下唯一的改进就是去除嵌套的 `bits >> bit`。
@@ -189,7 +183,7 @@ pop {r4,r5,r6,r7,r8,pc}
 
 ### 3、字符串
 
-现在，我们可以绘制字符了，我们可以绘制文本了。我们需要去写一个方法，给它一个字符串为输入，它通过递增位置来绘制出每个字符。为了做的更好，我们应该去实现新的行和制表符。是时候决定关于空终止符的问题了，如果你想让你的操作系统使用它们，可以按需来修改下面的代码。为避免这个问题，我将给 `DrawString` 函数传递一个字符串长度，以及字符串的地址，和 x 和 y 的坐标作为参数。
+现在，我们可以绘制字符了，我们可以绘制文本了。我们需要去写一个方法，给它一个字符串为输入，它通过递增位置来绘制出每个字符。为了做的更好，我们应该去实现新的行和制表符。是时候决定关于空终止符的问题了，如果你想让你的操作系统使用它们，可以按需来修改下面的代码。为避免这个问题，我将给 `DrawString` 函数传递一个字符串长度，以及字符串的地址，和 `x` 和 `y` 的坐标作为参数。
 
 ```c
 function drawString(r0 is string, r1 is length, r2 is x, r3 is y)
@@ -215,7 +209,7 @@ end function
 
 同样，这个函数与汇编代码还有很大的差距。你可以随意去尝试实现它，即可以直接实现它，也可以简化它。我在下面给出了简化后的函数和汇编代码。
 
-很明显，写这个函数的人并不很有效率（感到奇怪吗？它就是我写的）。再说一次，我们有一个 `pos` 变量，它用于递增和与其它东西相加，这是完全没有必要的。我们可以去掉它，而同时进行长度递减，直到减到 0 为止，这样就少用了一个寄存器。除了那个烦人的乘以 5 以外，函数的其余部分还不错。在这里要做的一个重要事情是，将乘法移到循环外面；即便使用位移运算，乘法仍然是很慢的，由于我们总是加一个乘以 5 的相同的常数，因此没有必要重新计算它。实际上，在汇编代码中它可以在一个操作数中通过参数移位来实现，因此我将代码改变为下面这样。
+很明显，写这个函数的人并不很有效率（感到奇怪吗？它就是我写的）。再说一次，我们有一个 `pos` 变量，它用于递增及与其它东西相加，这是完全没有必要的。我们可以去掉它，而同时进行长度递减，直到减到 0 为止，这样就少用了一个寄存器。除了那个烦人的乘以 5 以外，函数的其余部分还不错。在这里要做的一个重要事情是，将乘法移到循环外面；即便使用位移运算，乘法仍然是很慢的，由于我们总是加一个乘以 5 的相同的常数，因此没有必要重新计算它。实际上，在汇编代码中它可以在一个操作数中通过参数移位来实现，因此我将代码改变为下面这样。
 
 ```c
 function drawString(r0 is string, r1 is length, r2 is x, r3 is y)
@@ -307,22 +301,20 @@ pop {r4,r5,r6,r7,r8,r9,pc}
 .unreq length
 ```
 
-```assembly
-subs reg,#val 从寄存器 reg 中减去 val，然后将结果与 0 进行比较。
-```
-
 这个代码中非常聪明地使用了一个新运算，`subs` 是从一个操作数中减去另一个数，保存结果，然后将结果与 0 进行比较。实现上，所有的比较都可以实现为减法后的结果与 0 进行比较，但是结果通常会丢弃。这意味着这个操作与 `cmp` 一样快。
 
-### 4、你的愿意是我的命令行
+> `subs reg,#val` 从寄存器 `reg` 中减去 `val`，然后将结果与 `0` 进行比较。
+
+### 4、你的意愿是我的命令行
 
 现在，我们可以输出字符串了，而挑战是找到一个有意思的字符串去绘制。一般在这样的教程中，人们都希望去绘制 “Hello World!”，但是到目前为止，虽然我们已经能做到了，我觉得这有点“君临天下”的感觉（如果喜欢这种感觉，请随意！）。因此，作为替代，我们去继续绘制我们的命令行。
 
 有一个限制是我们所做的操作系统是用在 ARM 架构的计算机上。最关键的是，在它们引导时，给它一些信息告诉它有哪些可用资源。几乎所有的处理器都有某些方式来确定这些信息，而在 ARM 上，它是通过位于地址 100<sub>16</sub> 处的数据来确定的，这个数据的格式如下：
 
     1. 数据是可分解的一系列的标签。
-    2. 这里有九种类型的标签：`core`，`mem`，`videotext`，`ramdisk`，`initrd2`，`serial`，`revision`，`videolfb`，`cmdline`。
-    3. 每个标签只能出现一次，除了 'core’ 标签是必不可少的之外，其它的都是可有可无的。
-    4. 所有标签都依次放置在地址 0x100 处。
+    2. 这里有九种类型的标签：`core`、`mem`、`videotext`、`ramdisk`、`initrd2`、`serial`、`revision`、`videolfb`、`cmdline`。
+    3. 每个标签只能出现一次，除了 `core` 标签是必不可少的之外，其它的都是可有可无的。
+    4. 所有标签都依次放置在地址 `0x100` 处。
     5. 标签列表的结束处总是有两个<ruby>字<rt>word</rt></ruby>，它们全为 0。
     6. 每个标签的字节数都是 4 的倍数。
     7. 每个标签都是以标签中（以字为单位）的标签大小开始（标签包含这个数字）。
@@ -334,11 +326,9 @@ subs reg,#val 从寄存器 reg 中减去 val，然后将结果与 0 进行比较
     13. 一个 `cmdline` 标签包含一个 `null` 终止符字符串，它是个内核参数。
 
 
-```markdown
-几乎所有的操作系统都支持一个`命令行`的程序。它的想法是为选择一个程序所期望的行为而提供一个通用的机制。
-```
+在目前的树莓派版本中，只提供了 `core`、`mem` 和 `cmdline` 标签。你可以在后面找到它们的用法，更全面的参考资料在树莓派的参考页面上。现在，我们感兴趣的是 `cmdline` 标签，因为它包含一个字符串。我们继续写一些搜索这个命令行（`cmdline`）标签的代码，如果找到了，以每个条目一个新行的形式输出它。命令行只是图形处理器或用户认为操作系统应该知道的东西的一个列表。在树莓派上，这包含了 MAC 地址、序列号和屏幕分辨率。字符串本身也是一个由空格隔开的表达式（像 `key.subkey=value` 这样的）的列表。
 
-在目前的树莓派版本中，只提供了 `core`、`mem` 和 `cmdline` 标签。你可以在后面找到它们的用法，更全面的参考资料在树莓派的参考页面上。现在，我们感兴趣的是 `cmdline` 标签，因为它包含一个字符串。我们继续写一些搜索命令行标签的代码，如果找到了，以每个条目一个新行的形式输出它。命令行只是为了让操作系统理解图形处理器或用户认为的很好的事情的一个列表。在树莓派上，这包含了 MAC 地址，序列号和屏幕分辨率。字符串本身也是一个像 `key.subkey=value` 这样的由空格隔开的表达式列表。
+> 几乎所有的操作系统都支持一个“命令行”的程序。它的想法是为选择一个程序所期望的行为而提供一个通用的机制。
 
 我们从查找 `cmdline` 标签开始。将下列的代码复制到一个名为 `tags.s` 的新文件中。
 
@@ -355,7 +345,7 @@ tag_videolfb: .int 0
 tag_cmdline: .int 0
 ```
 
-通过标签列表来查找是一个很慢的操作，因为这涉及到许多内存访问。因此，我们只是想实现它一次。代码创建一些数据，用于保存每个类型的第一个标签的内存地址。接下来，用下面的伪代码就可以找到一个标签了。
+通过标签列表来查找是一个很慢的操作，因为这涉及到许多内存访问。因此，我们只想做一次。代码创建一些数据，用于保存每个类型的第一个标签的内存地址。接下来，用下面的伪代码就可以找到一个标签了。
 
 ```c
 function FindTag(r0 is tag)
@@ -373,7 +363,8 @@ function FindTag(r0 is tag)
   end loop
 end function
 ```
-这段代码已经是优化过的，并且很接近汇编了。它尝试直接加载标签，第一次这样做是有些乐观的，但是除了第一次之外 的其它所有情况都是可以这样做的。如果失败了，它将去检查 `core` 标签是否有地址。因为 `core` 标签是必不可少的，如果它没有地址，唯一可能的原因就是它不存在。如果它有地址，那就是我们没有找到我们要找的标签。如果没有找到，那我们就需要查找所有标签的地址。这是通过读取标签编号来做的。如果标签编号为 0，意味着已经到了标签列表的结束位置。这意味着我们已经查找了目录中所有的标签。所以，如果我们再次运行我们的函数，现在它应该能够给出一个答案。如果标签编号不为 0，我们检查这个标签类型是否已经有一个地址。如果没有，我们在目录中保存这个标签的地址。然后增加这个标签的长度（以字节为单位）到标签地址中，然后去查找下一个标签。
+
+这段代码已经是优化过的，并且很接近汇编了。它尝试直接加载标签，第一次这样做是有些乐观的，但是除了第一次之外的其它所有情况都是可以这样做的。如果失败了，它将去检查 `core` 标签是否有地址。因为 `core` 标签是必不可少的，如果它没有地址，唯一可能的原因就是它不存在。如果它有地址，那就是我们没有找到我们要找的标签。如果没有找到，那我们就需要查找所有标签的地址。这是通过读取标签编号来做的。如果标签编号为 0，意味着已经到了标签列表的结束位置。这意味着我们已经查找了目录中所有的标签。所以，如果我们再次运行我们的函数，现在它应该能够给出一个答案。如果标签编号不为 0，我们检查这个标签类型是否已经有一个地址。如果没有，我们在目录中保存这个标签的地址。然后增加这个标签的长度（以字节为单位）到标签地址中，然后去查找下一个标签。
 
 尝试去用汇编实现这段代码。你将需要简化它。如果被卡住了，下面是我的答案。不要忘了 `.section .text`！
 
@@ -459,11 +450,11 @@ via: https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/screen03.html
 作者：[Alex Chadwick][a]
 选题：[lujun9972][b]
 译者：[qhwdw](https://github.com/qhwdw)
-校对：[校对者ID](https://github.com/校对者ID)
+校对：[wxy](https://github.com/wxy)
 
 本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
 
 [a]: https://www.cl.cam.ac.uk
 [b]: https://github.com/lujun9972
-[1]: https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/screen02.html
+[1]: https://linux.cn/article-10551-1.html
 [2]: https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/screen04.html

published/20170223 Use Emacs to create OAuth 2.0 UML sequence diagrams.md

@@ -0,0 +1,149 @@
+[#]: collector: (lujun9972)
+[#]: translator: (lujun9972)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10582-1.html)
+[#]: subject: (Use Emacs to create OAuth 2.0 UML sequence diagrams)
+[#]: via: (https://www.onwebsecurity.com/configuration/use-emacs-to-create-oauth-2-0-uml-sequence-diagrams.html)
+[#]: author: (Peter Mosmans https://www.onwebsecurity.com)
+
+使用 Emacs 创建 OAuth 2.0 的 UML 序列图
+======
+
+![OAuth 2.0 abstract protocol flow][6]
+
+看起来 [OAuth 2.0 框架][7] 已经越来越广泛地应用于 web (和 移动) 应用。太棒了！
+
+虽然协议本身并不复杂，但有很多的使用场景、流程和实现可供选择。正如生活中的大多数事物一样，魔鬼在于细节之中。
+
+在审查 OAuth 2.0 实现或编写渗透测试报告时我习惯画出 UML 图。这方便让人理解发生了什么事情，并发现潜在的问题。毕竟，一图抵千言。
+
+使用基于 GPL 开源协议 [Emacs][8] 编辑器来实现，再加上基于 GPL 开源协议的工具 [PlantUML][9] (也可以选择基于 Eclipse Public 协议的 [Graphviz][10]) 很容易做到这一点。
+
+Emacs 是世界上最万能的编辑器。在这种场景中，我们用它来编辑文本，并自动将文本转换成图片。PlantUML 是一个允许你用人类可读的文本来写 UML 并完成该转换的工具。Graphviz 是一个可视化的软件，这里我们可以用它来显示图片。
+
+下载 [预先编译好了的 PlantUML jar 文件 ][11]，[Emacs][12] 还可以选择下载并安装 [Graphviz][13]。
+
+安装并启动 Emacs，然后将下面 Lisp 代码（实际上是配置）写入你的启动文件中（`~/.emacs.d/init.d`），这段代码将会：
+
+  * 配置 org 模式（一种用来组织并编辑文本文件的模式）来使用 PlantUML
+  * 将 `plantuml` 添加到可识别的 “org-babel” 语言中（这让你可以在文本文件中执行源代码）
+  * 将 PlantUML 代码标注为安全的，从而允许执行
+  * 自动显示生成的结果图片
+
+```elisp
+;; tell org-mode where to find the plantuml JAR file (specify the JAR file)
+(setq org-plantuml-jar-path (expand-file-name "~/plantuml.jar"))
+
+;; use plantuml as org-babel language
+(org-babel-do-load-languages 'org-babel-load-languages '((plantuml . t)))
+
+;; helper function
+(defun my-org-confirm-babel-evaluate (lang body)
+"Do not ask for confirmation to evaluate code for specified languages."
+(member lang '("plantuml")))
+
+;; trust certain code as being safe
+(setq org-confirm-babel-evaluate 'my-org-confirm-babel-evaluate)
+
+;; automatically show the resulting image
+(add-hook 'org-babel-after-execute-hook 'org-display-inline-images)
+```
+
+如果你还没有启动文件，那么将该代码加入到 `~/.emacs.d/init.el` 文件中然后重启 Emacs。
+
+提示：`Control-c Control-f` 可以让你创建/打开（新）文件。`Control-x Control-s` 保存文件，而 `Control-x Control-c` 退出 Emacs。
+
+这就结了！
+
+要测试该配置，可以创建/打开（`Control-c Control-f`）后缀为 `.org` 的文件，例如 `test.org`。这会让 Emacs 切换到 org 模式并识别 “org-babel” 语法。
+
+输入下面代码，然后在代码中输入 `Control-c Control-c` 来测试是否安装正常：
+
+```
+#+BEGIN_SRC plantuml :file test.png
+@startuml
+version
+@enduml
+#+END_SRC
+```
+
+一切顺利的话，你会在 Emacs 中看到文本下面显示了一张图片。
+
+> **注意：**
+
+> 要快速插入类似 `#+BEGIN_SRC` 和 `#+END_SRC` 这样的代码片段，你可以使用内置的 Easy Templates 系统：输入 `<s` 然后按下 `TAB`，它就会自动为你插入模板。
+
+还有更复杂的例子，下面是生成上面图片的 UML 源代码：
+
+```
+#+BEGIN_SRC plantuml :file t:/oauth2-abstract-protocol-flow.png
+@startuml
+hide footbox
+title Oauth 2.0 Abstract protocol flow
+autonumber
+actor user as "resource owner (user)"
+box "token stays secure" #FAFAFA
+participant client as "client (application)"
+participant authorization as "authorization server"
+database resource as "resource server"
+end box
+
+group user authorizes client
+client -> user : request authorization
+note left
+**grant types**:
+# authorization code
+# implicit
+# password
+# client_credentials
+end note
+user --> client : authorization grant
+end
+
+group token is generated
+client -> authorization : request token\npresent authorization grant
+authorization --> client :var: access token
+note left
+**response types**:
+# code
+# token
+end note
+end group
+
+group resource can be accessed
+client -> resource : request resource\npresent token
+resource --> client : resource
+end group
+@enduml
+#+END_SRC
+```
+
+你难道会不喜欢 Emacs 和开源工具的多功能性吗？
+
+--------------------------------------------------------------------------------
+
+via: https://www.onwebsecurity.com/configuration/use-emacs-to-create-oauth-2-0-uml-sequence-diagrams.html
+
+作者：[Peter Mosmans][a]
+选题：[lujun9972][b]
+译者：[lujun9972](https://github.com/lujun9972)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://www.onwebsecurity.com
+[b]: https://github.com/lujun9972
+[1]: https://www.onwebsecurity.com/category/configuration.html
+[2]: https://www.onwebsecurity.com/tag/emacs.html
+[3]: https://www.onwebsecurity.com/tag/oauth2.html
+[4]: https://www.onwebsecurity.com/tag/pentesting.html
+[5]: https://www.onwebsecurity.com/tag/security.html
+[6]: https://www.onwebsecurity.com/images/oauth2-abstract-protocol-flow.png
+[7]: https://tools.ietf.org/html/rfc6749
+[8]: https://www.gnu.org/software/emacs/
+[9]: https://plantuml.com
+[10]: http://www.graphviz.org/
+[11]: http://plantuml.com/download
+[12]: https://www.gnu.org/software/emacs/download.html
+[13]: http://www.graphviz.org/Download.php

published/20170721 Firefox and org-protocol URL Capture.md

@@ -0,0 +1,121 @@
+[#]: collector: (lujun9972)
+[#]: translator: (lujun9972)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10586-1.html)
+[#]: subject: (Firefox and org-protocol URL Capture)
+[#]: via: (http://www.mediaonfire.com/blog/2017_07_21_org_protocol_firefox.html)
+[#]: author: (Andreas Viklund http://andreasviklund.com/)
+
+在 Firefox 上使用 Org 协议捕获 URL
+======
+
+### 介绍
+
+作为一名 Emacs 人，我尽可能让所有的工作流都在 <ruby>[Org 模式][1]<rt>Org-mode</rt></ruby> 上进行 —— 我比较喜欢文本。
+
+我倾向于将书签记录在 [Org 模式][1] 代办列表中，而 <ruby>[Org 协议][2]<rt>Org-protocol</rt></ruby> 则允许外部进程利用 [Org 模式][1] 的某些功能。然而，要做到这一点配置起来很麻烦。（[搜索引擎上][3]）有很多教程，Firefox 也有这类 [扩展][4]，然而我对它们都不太满意。
+
+因此我决定将我现在的配置记录在这篇博客中，方便其他有需要的人使用。
+
+### 配置 Emacs Org 模式
+
+启用 Org 协议：
+
+```
+(require 'org-protocol)
+```
+
+添加一个<ruby>捕获模板<rt>capture template</rt></ruby> —— 我的配置是这样的：
+
+```
+(setq org-capture-templates
+      (quote (...
+              ("w" "org-protocol" entry (file "~/org/refile.org")
+               "* TODO Review %a\n%U\n%:initial\n" :immediate-finish)
+               ...)))
+```
+
+你可以从 [Org 模式][1] 手册中 [捕获模板][5] 章节中获取帮助。
+
+设置默认使用的模板：
+
+```
+(setq org-protocol-default-template-key "w")
+```
+
+执行这些新增配置让它们在当前 Emacs 会话中生效。
+
+### 快速测试
+
+在下一步开始前，最好测试一下配置：
+
+```
+emacsclient -n "org-protocol:///capture?url=http%3a%2f%2fduckduckgo%2ecom&title=DuckDuckGo"
+```
+
+基于的配置的模板，可能会弹出一个捕获窗口。请确保正常工作，否则后面的操作没有任何意义。如果工作不正常，检查刚才的配置并且确保你执行了这些代码块。
+
+如果你的 [Org 模式][1] 版本比较老(老于 7 版本)，测试的格式会有点不同：这种 URL 编码后的格式需要改成用斜杠来分割 url 和标题。在网上搜一下很容易找出这两者的不同。
+
+### Firefox 协议
+
+现在开始设置 Firefox。浏览 `about:config`。右击配置项列表，选择 “New -> Boolean”，然后输入 `network.protocol-handler.expose.org-protocol` 作为名字并且将值设置为 `true`。
+
+有些教程说这一步是可以省略的 —— 配不配因人而异。
+
+### 添加 Desktop 文件
+
+大多数的教程都有这一步：
+
+增加一个文件 `~/.local/share/applications/org-protocol.desktop`：
+
+```
+[Desktop Entry]
+Name=org-protocol
+Exec=/path/to/emacsclient -n %u
+Type=Application
+Terminal=false
+Categories=System;
+MimeType=x-scheme-handler/org-protocol;
+```
+
+然后运行更新器。对于 i3 窗口管理器我使用下面命令(跟 gnome 一样)：
+
+```
+update-desktop-database ~/.local/share/applications/
+```
+
+KDE 的方法不太一样……你可以查询其他相关教程。
+
+### 在 FireFox 中设置捕获按钮
+
+创建一个书签（我是在工具栏上创建这个书签的），地址栏输入下面内容：
+
+```
+javascript:location.href="org-protocol:///capture?url="+encodeURIComponent(location.href)+"&title="+encodeURIComponent(document.title||"[untitled page]")
+```
+
+保存该书签后，再次编辑该书签，你应该会看到其中的所有空格都被替换成了 `%20` —— 也就是空格的 URL 编码形式。
+
+现在当你点击该书签，你就会在某个 Emacs 框架中，可能是一个任意的框架中，打开一个窗口，显示你预定的模板。
+
+
+--------------------------------------------------------------------------------
+
+via: http://www.mediaonfire.com/blog/2017_07_21_org_protocol_firefox.html
+
+作者：[Andreas Viklund][a]
+选题：[lujun9972][b]
+译者：[lujun9972](https://github.com/lujun9972)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: http://andreasviklund.com/
+[b]: https://github.com/lujun9972
+[1]: http://orgmode.org/
+[2]: http://orgmode.org/worg/org-contrib/org-protocol.html
+[3]: https://duckduckgo.com/?q=org-protocol+firefox&t=ffab&ia=qa
+[4]: https://addons.mozilla.org/en-US/firefox/search/?q=org-protocol&cat=1,0&appver=53.0&platform=linux
+[5]: http://orgmode.org/manual/Capture-templates.html

published/20180122 Ick- a continuous integration system.md

@@ -0,0 +1,67 @@
+ick：一个持续集成系统
+======
+
+> ick 是一个持续集成（CI）系统。访问 <http://ick.liw.fi/> 获取更多信息。
+
+更加详细的内容如下：
+
+### 首个公开版本发行
+
+这个世界可能并不需要又一个持续集成系统（CI），但是我需要。我对我尝试过或者看过的持续集成系统感到不满意。更重要的是，有几样我感兴趣的东西比我所听说过的持续集成系统要强大得多。因此我开始编写我自己的 CI 系统。
+
+我的新个人业余项目叫做 ick。它是一个 CI 系统，这意味着它可以运行自动化的步骤来构建、测试软件。它的主页是 <http://ick.liw.fi/>，[下载][1]页面有指向源代码、.deb 包和用来安装的 Ansible 脚本的链接。
+
+我现已发布了首个公开版本，绰号 ALPHA-1，版本号 0.23。（LCTT 译注：截止至本译文发布，已经更新到 ALPHA-6）它现在是 alpha 品质，这意味着它并没拥有期望的全部特性，如果任何一个它已有的特性工作的话，那真是运气好。
+
+### 诚邀贡献
+
+ick 目前是我的个人项目。我希望能让它不仅限于此，同时我也诚邀更多贡献。访问[治理][2]页面查看章程，[入门][3]页面查看如何开始贡献的的小建议，[联系][4]页面查看如何联络。
+
+### 架构
+
+ick 拥有一个由几个通过 HTTPS 协议通信使用 RESTful API 和 JSON 处理结构化数据的部分组成的架构。访问[架构][5]页面了解细节。
+
+### 宣告
+
+持续集成（CI）是用于软件开发的强大工具。它不应枯燥、易溃或恼人。它构建起来应简单快速，除非正在测试、构建的代码中有问题，不然它应在后台安静地工作。
+
+一个持续集成系统应该简单、易用、清楚、干净、可扩展、快速、综合、透明、可靠，并推动你的生产力。构建它不应花大力气、不应需要专门为 CI 而造的硬件、不应需要频繁留意以使其保持工作、开发者永远不必思考为什么某样东西不工作。
+
+一个持续集成系统应该足够灵活以适应你的构建、测试需求。只要 CPU 架构和操作系统版本没问题，它应该支持各种操作者。
+
+同时像所有软件一样，CI 应该彻彻底底的免费，你的 CI 应由你做主。
+
+（目前的 ick 仅稍具雏形，但是它会尝试着有朝一日变得完美 —— 在最理想的情况下。）
+
+### 未来的梦想
+
+长远来看，我希望 ick 拥有像下面所描述的特性。落实全部特性可能需要一些时间。
+
+* 各种事件都可以触发构建。时间是一个明显的事件，因为项目的源代码仓库改变了。更强大的是任何依赖的改变，不管依赖是来自于 ick 构建的另一个项目，或者是包（比如说来自 Debian）：ick 应当跟踪所有安装进一个项目构建环境中的包，如果任何一个包的版本改变，都应再次触发项目构建和测试。
+* ick 应该支持构建于（或针对）任何合理的目标平台，包括任何 Linux 发行版，任何自由的操作系统，以及任何一息尚存的不自由的操作系统。
+* ick 应该自己管理构建环境，并且能够执行与构建主机或网络隔离的构建。这部分工作：可以要求 ick 构建容器并在容器中运行构建。容器使用 systemd-nspawn 实现。 然而，这可以改进。（如果您认为 Docker 是唯一的出路，请为此提供支持。）
+* ick 应当不需要安装任何专门的代理，就能支持各种它能够通过 ssh 或者串口或者其它这种中性的交流管道控制的<ruby>操作者<rt>worker</rt></ruby>。ick 不应默认它可以有比如说一个完整的 Java Runtime，如此一来，操作者就可以是一个微控制器了。
+* ick 应当能轻松掌控一大批项目。我觉得不管一个新的 Debian 源包何时上传，ick 都应该要能够跟得上在 Debian 中构建所有东西的进度。（明显这可行与否取决于是否有足够的资源确实用在构建上，但是 ick 自己不应有瓶颈。）
+* 如果有需要的话 ick 应当有选择性地补给操作者。如果所有特定种类的操作者处于忙碌中，且 ick 被设置成允许使用更多资源的话，它就应该这么做。这看起来用虚拟机、容器、云提供商等做可能会简单一些。
+* ick 应当灵活提醒感兴趣的团体，特别是关于其失败的方面。它应允许感兴趣的团体通过 IRC、Matrix、Mastodon、Twitter、email、SMS 甚至电话和语音合成来接受通知。例如“您好，感兴趣的团体。现在是四点钟您想被通知 hello 包什么时候为 RISC-V 构建好。”
+
+### 请提供反馈
+
+如果你尝试过 ick 或者甚至你仅仅是读到这，请在上面分享你的想法。在[联系][4]页面查看如何发送反馈。相比私下反馈我更偏爱公开反馈。但如果你偏爱私下反馈，那也行。
+
+--------------------------------------------------------------------------------
+
+via: https://blog.liw.fi/posts/2018/01/22/ick_a_continuous_integration_system/
+
+作者：[Lars Wirzenius][a]
+译者：[tomjlw](https://github.com/tomjlw)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]:https://blog.liw.fi/
+[1]:http://ick.liw.fi/download/
+[2]:http://ick.liw.fi/governance/
+[3]:http://ick.liw.fi/getting-started/
+[4]:http://ick.liw.fi/contact/
+[5]:http://ick.liw.fi/architecture/

published/20180307 3 open source tools for scientific publishing.md

@@ -0,0 +1,80 @@
+3 款用于学术出版的开源工具
+======
+> 学术出版业每年的价值超过 260 亿美元。
+
+![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/LIFE_science.png?itok=WDKARWGV)
+
+有一个行业在采用数字化或开源工具方面已落后其它行业，那就是竞争与利润并存的学术出版业。根据 Stephen Buranyi 去年在 [卫报][1] 上发表的一份图表，这个估值超过 190 亿英镑（260 亿美元）的行业，即使是最重要的科学研究方面，至今其系统在选题、出版甚至分享方面仍受限于印刷媒介的诸多限制。全新的数字时代科技展现了一个巨大机遇，可以加速探索、推动科学协作而非竞争，以及将投入从基础建设导向有益于社会的研究。
+
+非盈利性的 [eLife 倡议][2] 是由研究资金赞助方建立，旨在通过使用数字或者开源技术来走出上述僵局。除了为生命科学和生物医疗方面的重大成就出版开放式获取的期刊，eLife 已将自己变成了一个在研究交流方面的实验和展示创新的平台 —— 而大部分的实验都是基于开源精神的。
+
+致力于开放出版基础设施项目给予我们加速接触、采用科学技术、提升用户体验的机会。我们认为这种机会对于推动学术出版行业是重要的。大而化之地说，开源产品的用户体验经常是有待开发的，而有时候这种情况会阻止其他人去使用它。作为我们在 OSS（开源软件）开发中投入的一部分，为了鼓励更多用户使用这些产品，我们十分注重用户体验。
+
+我们所有的代码都是开源的，并且我们也积极鼓励社区参与进我们的项目中。这对我们来说意味着更快的迭代、更多的实验、更大的透明度，同时也拓宽了我们工作的外延。
+
+我们现在参与的项目，例如 Libero （之前称作 [eLife Continuum][3]）和 <ruby>[可重现文档栈][4]<rt>Reproducible Document Stack</rt></ruby> 的开发，以及我们最近和 [Hypothesis][5] 的合作，展示了 OSS 是如何在评估、出版以及新发现的沟通方面带来正面影响的。
+
+### Libero
+
+Libero 是面向出版商的服务及应用套餐，它包括一个后期制作出版系统、整套前端用户界面样式套件、Libero 的镜头阅读器、一个 Open API 以及一个搜索及推荐引擎。
+
+去年我们采取了用户驱动的方式重新设计了 Libero 的前端，可以使用户较少地分心于网站的“陈设”，而是更多地集中关注于研究文章上。我们和 eLife 社区成员测试并迭代了该站点所有的核心功能，以确保给所有人最好的阅读体验。该网站的新 API 也为机器阅读能力提供了更简单的访问途径，其中包括文本挖掘、机器学习以及在线应用开发。
+
+我们网站上的内容以及引领新设计的样式都是开源的，以鼓励 eLife 和其它想要使用它的出版商后续的产品开发。
+
+### 可重现文档栈
+
+在与 [Substance][6] 和 [Stencila][7] 的合作下，eLife 也参与了一个项目来创建可重现文档栈（RDS）—— 一个开放式的创作、编纂以及在线出版可重现的计算型手稿的工具栈。
+
+今天越来越多的研究人员能够通过 [R Markdown][8] 和 [Python][9] 等语言记录他们的计算实验。这些可以作为实验记录的重要部分，但是尽管它们可以独立于最终的研究文章或与之一同分享，但传统出版流程经常将它们视为次级内容。为了发表论文，使用这些语言的研究人员除了将他们的计算结果用图片的形式“扁平化”提交外别无他法。但是这导致了许多实验价值和代码和计算数据可重复利用性的流失。诸如 [Jupyter][10] 这样的电子笔记本解决方案确实可以使研究员以一种可重复利用、可执行的简单形式发布，但是这种方案仍然是出版的手稿的补充，而不是不可或缺的一部分。
+
+[可重现文档栈][11] 项目旨在通过开发、发布一个可重现原稿的产品原型来解决这些挑战，该原型将代码和数据视为文档的组成部分，并展示了从创作到出版的完整端对端技术栈。它将最终允许用户以一种包含嵌入代码块和计算结果（统计结果、图表或图形）的形式提交他们的手稿，并在出版过程中保留这些可视、可执行的部分。那时出版商就可以将这些做为出版的在线文章的组成部分而保存。
+
+### 用 Hypothesis 进行开放式注解
+
+最近，我们与 [Hypothesis][12] 合作引进了开放式注解，使得我们网站的用户们可以写评语、高亮文章重要部分以及与在线阅读的群体互动。
+
+通过这样的合作，开源的 Hypothesis 软件被定制得更具有现代化的特性，如单次登录验证、用户界面定制，给予了出版商在他们自己网站上实现更多的控制。这些提升正引导着关于出版学术内容的高质量讨论。
+
+这个工具可以无缝集成到出版商的网站，学术出版平台 [PubFactory][13] 和内容解决方案供应商 [Ingenta][14] 已经利用了它优化后的特性集。[HighWire][15] 和 [Silverchair][16] 也为他们的出版商提供了实施这套方案的机会。
+
+### 其它产业和开源软件
+
+随着时间的推移，我们希望看到更多的出版商采用 Hypothesis、Libero 以及其它开源项目去帮助他们促进重要科学研究的发现以及循环利用。但是 eLife 的创新机遇也能被其它行业所利用，因为这些软件和其它 OSS 技术在其他行业也很普遍。
+
+数据科学的世界离不开高质量、良好支持的开源软件和围绕它们形成的社区；[TensorFlow][17] 就是这样一个好例子。感谢 OSS 以及其社区，AI 和机器学习的所有领域相比于计算机的其它领域的提升和发展更加迅猛。与之类似的是以 Linux 作为云端 Web 主机的爆炸性增长、接着是 Docker 容器、以及现在 GitHub 上最流行的开源项目之一的 Kubernetes 的增长。
+
+所有的这些技术使得机构们能够用更少的资源做更多的事情，并专注于创新而不是重新发明轮子上。最后，这就是 OSS 真正的好处：它使得我们从互相的失败中学习，在互相的成功中成长。
+
+我们总是在寻找与研究和科技界面方面最好的人才和想法交流的机会。你可以在 [eLife Labs][18] 上或者联系 [innovation@elifesciences.org][19] 找到更多这种交流的信息。
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/18/3/scientific-publishing-software
+
+作者：[Paul Shanno][a]
+译者：[tomjlw](https://github.com/tomjlw)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]:https://opensource.com/users/pshannon
+[1]:https://www.theguardian.com/science/2017/jun/27/profitable-business-scientific-publishing-bad-for-science
+[2]:https://elifesciences.org/about
+[3]:https://elifesciences.org/inside-elife/33e4127f/elife-introduces-continuum-a-new-open-source-tool-for-publishing
+[4]:https://elifesciences.org/for-the-press/e6038800/elife-supports-development-of-open-technology-stack-for-publishing-reproducible-manuscripts-online
+[5]:https://elifesciences.org/for-the-press/81d42f7d/elife-enhances-open-annotation-with-hypothesis-to-promote-scientific-discussion-online
+[6]:https://github.com/substance
+[7]:https://github.com/stencila/stencila
+[8]:https://rmarkdown.rstudio.com/
+[9]:https://www.python.org/
+[10]:http://jupyter.org/
+[11]:https://elifesciences.org/labs/7dbeb390/reproducible-document-stack-supporting-the-next-generation-research-article
+[12]:https://github.com/hypothesis
+[13]:http://www.pubfactory.com/
+[14]:http://www.ingenta.com/
+[15]:https://github.com/highwire
+[16]:https://www.silverchair.com/community/silverchair-universe/hypothesis/
+[17]:https://www.tensorflow.org/
+[18]:https://elifesciences.org/labs
+[19]:mailto:innovation@elifesciences.org

published/20181220 7 CI-CD tools for sysadmins.md

@@ -0,0 +1,166 @@
+[#]: collector: (lujun9972)
+[#]: translator: (jdh8383)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10578-1.html)
+[#]: subject: (7 CI/CD tools for sysadmins)
+[#]: via: (https://opensource.com/article/18/12/cicd-tools-sysadmins)
+[#]: author: (Dan Barker https://opensource.com/users/barkerd427)
+
+系统管理员的 7 个 CI/CD 工具
+======
+
+> 本文是一篇简单指南：介绍一些顶级的开源的持续集成、持续交付和持续部署（CI/CD）工具。
+
+![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/cicd_continuous_delivery_deployment_gears.png?itok=kVlhiEkc)
+
+虽然持续集成、持续交付和持续部署（CI/CD）在开发者社区里已经存在很多年，一些机构在其运维部门也有实施经验，但大多数公司并没有做这样的尝试。对于很多机构来说，让运维团队能够像他们的开发同行一样熟练操作 CI/CD 工具，已经变得十分必要了。
+
+无论是基础设施、第三方应用还是内部开发的应用，都可以开展 CI/CD 实践。尽管你会发现有很多不同的工具，但它们都有着相似的设计模型。而且可能最重要的一点是：通过带领你的公司进行这些实践，会让你在公司内部变得举足轻重，成为他人学习的榜样。
+
+一些机构在自己的基础设施上已有多年的 CI/CD 实践经验，常用的工具包括 [Ansible][1]、[Chef][2] 或者 [Puppet][3]。另一些工具，比如 [Test Kitchen][4]，允许在最终要部署应用的基础设施上运行测试。事实上，如果使用更高级的配置方法，你甚至可以将应用部署到有真实负载的仿真“生产环境”上，来运行应用级别的测试。然而，单单是能够测试基础设施就是一项了不起的成就了。配置管理工具 Terraform 可以通过 Test Kitchen 来快速创建更[短暂][5]和[冥等的][6]的基础设施配置，这比它的前辈要强不少。再加上 Linux 容器和 Kubernetes，在数小时内，你就可以创建一套类似于生产环境的配置参数和系统资源，来测试整个基础设施和其上部署的应用，这在以前可能需要花费几个月的时间。而且，删除和再次创建整个测试环境也非常容易。
+
+当然，作为初学者，你也可以把网络配置和 DDL（<ruby>数据定义语言<rt>data definition language</rt></ruby>）文件加入版本控制，然后开始尝试一些简单的 CI/CD 流程。虽然只能帮你检查一下语义语法或某些最佳实践，但实际上大多数开发的管道都是这样起步的。只要你把脚手架搭起来，建造就容易得多了。而一旦起步，你就会发现各种管道的使用场景。
+
+举个例子，我经常会在公司内部写新闻简报，我使用 [MJML][7] 制作邮件模板，然后把它加入版本控制。我一般会维护一个 web 版本，但是一些同事喜欢 PDF 版，于是我创建了一个[管道][8]。每当我写好一篇新闻稿，就在 Gitlab 上提交一个合并请求。这样做会自动创建一个 index.html 文件，生成这篇新闻稿的 HTML 和 PDF 版链接。HTML 和 PDF 文件也会在该管道里同时生成。除非有人来检查确认，这些文件不会被直接发布出去。使用 GitLab Pages 发布这个网站后，我就可以下载一份 HTML 版，用来发送新闻简报。未来，我会修改这个流程，当合并请求成功或者在某个审核步骤后，自动发出对应的新闻稿。这些处理逻辑并不复杂，但的确为我节省了不少时间。实际上这些工具最核心的用途就是替你节省时间。
+
+关键是要在抽象层创建出工具，这样稍加修改就可以处理不同的问题。值得留意的是，我创建的这套流程几乎不需要任何代码，除了一些[轻量级的 HTML 模板][9]，一些[把 HTML 文件转换成 PDF 的 nodejs 代码][10]，还有一些[生成索引页面的 nodejs 代码][11]。
+
+这其中一些东西可能看起来有点复杂，但其中大部分都源自我使用的不同工具的教学文档。而且很多开发人员也会乐意跟你合作，因为他们在完工时会发现这些东西也挺有用。上面我提供的那些代码链接是给 [DevOps KC][12]（LCTT 译注：一个地方性 DevOps 组织） 发送新闻简报用的，其中大部分用来创建网站的代码来自我在内部新闻简报项目上所作的工作。
+
+下面列出的大多数工具都可以提供这种类型的交互，但是有些工具提供的模型略有不同。这一领域新兴的模型是用声明式的方法例如 YAML 来描述一个管道，其中的每个阶段都是短暂而幂等的。许多系统还会创建[有向无环图（DAG）][13]，来确保管道上不同的阶段排序的正确性。
+
+这些阶段一般运行在 Linux 容器里，和普通的容器并没有区别。有一些工具，比如 [Spinnaker][14]，只关注部署组件，而且提供一些其他工具没有的操作特性。[Jenkins][15] 则通常把管道配置存成 XML 格式，大部分交互都可以在图形界面里完成，但最新的方案是使用[领域专用语言（DSL）][16]（如 [Groovy][17]）。并且，Jenkins 的任务（job）通常运行在各个节点里，这些节点上会装一个专门的 Java 代理，还有一堆混杂的插件和预装组件。
+
+Jenkins 在自己的工具里引入了管道的概念，但使用起来却并不轻松，甚至包含一些禁区。最近，Jenkins 的创始人决定带领社区向新的方向前进，希望能为这个项目注入新的活力，把 CI/CD 真正推广开（LCTT 译注：详见后面的 Jenkins 章节)。我认为其中最有意思的想法是构建一个云原生 Jenkins，能把 Kubernetes 集群转变成 Jenkins CI/CD 平台。
+
+当你更多地了解这些工具并把实践带入你的公司和运维部门，你很快就会有追随者，因为你有办法提升自己和别人的工作效率。我们都有多年积累下来的技术债要解决，如果你能给同事们提供足够的时间来处理这些积压的工作，他们该会有多感激呢？不止如此，你的客户也会开始看到应用变得越来越稳定，管理层会把你看作得力干将，你也会在下次谈薪资待遇或参加面试时更有底气。
+
+让我们开始深入了解这些工具吧，我们将对每个工具做简短的介绍，并分享一些有用的链接。
+
+### GitLab CI
+
+- [项目主页](https://about.gitlab.com/product/continuous-integration/)
+- [源代码](https://gitlab.com/gitlab-org/gitlab-ce/)
+- 许可证：MIT
+
+GitLab 可以说是 CI/CD 领域里新登场的玩家，但它却在权威调研机构 [Forrester 的 CI 集成工具的调查报告][20]中位列第一。在一个高水平、竞争充分的领域里，这是个了不起的成就。是什么让 GitLab CI 这么成功呢？它使用 YAML 文件来描述整个管道。另有一个功能叫做 Auto DevOps，可以为较简单的项目用多种内置的测试单元自动生成管道。这套系统使用 [Herokuish buildpacks][21] 来判断语言的种类以及如何构建应用。有些语言也可以管理数据库，它真正改变了构建新应用程序和从开发的开始将它们部署到生产环境的过程。它原生集成于 Kubernetes，可以根据不同的方案将你的应用自动部署到 Kubernetes 集群，比如灰度发布、蓝绿部署等。
+
+除了它的持续集成功能，GitLab 还提供了许多补充特性，比如：将 Prometheus 和你的应用一同部署，以提供操作监控功能；通过 GitLab 提供的 Issues、Epics 和 Milestones 功能来实现项目评估和管理；管道中集成了安全检测功能，多个项目的检测结果会聚合显示；你可以通过 GitLab 提供的网页版 IDE 在线编辑代码，还可以快速查看管道的预览或执行状态。
+
+### GoCD
+
+- [项目主页](https://www.gocd.org/)
+- [源代码](https://github.com/gocd/gocd)
+- 许可证：Apache 2.0
+
+GoCD 是由老牌软件公司 Thoughtworks 出品，这已经足够证明它的能力和效率。对我而言，GoCD 最具亮点的特性是它的[价值流视图（VSM）][22]。实际上，一个管道的输出可以变成下一个管道的输入，从而把管道串联起来。这样做有助于提高不同开发团队在整个开发流程中的独立性。比如在引入 CI/CD 系统时，有些成立较久的机构希望保持他们各个团队相互隔离，这时候 VSM 就很有用了：让每个人都使用相同的工具就很容易在 VSM 中发现工作流程上的瓶颈，然后可以按图索骥调整团队或者想办法提高工作效率。
+
+为公司的每个产品配置 VSM 是非常有价值的；GoCD 可以使用 [JSON 或 YAML 格式存储配置][23]，还能以可视化的方式展示数据等待时间，这让一个机构能有效减少学习它的成本。刚开始使用 GoCD 创建你自己的流程时，建议使用人工审核的方式。让每个团队也采用人工审核，这样你就可以开始收集数据并且找到可能的瓶颈点。
+
+### Travis CI
+
+- [项目主页](https://docs.travis-ci.com/)
+- [源代码](https://github.com/travis-ci/travis-ci)
+- 许可证：MIT
+
+我使用的第一个软件既服务（SaaS）类型的 CI 系统就是 Travis CI，体验很不错。管道配置以源码形式用 YAML 保存，它与 GitHub 等工具无缝整合。我印象中管道从来没有失效过，因为 Travis CI 的在线率很高。除了 SaaS 版之外，你也可以使用自行部署的版本。我还没有自行部署过，它的组件非常多，要全部安装的话，工作量就有点吓人了。我猜更简单的办法是把它部署到 Kubernetes 上，[Travis CI 提供了 Helm charts][26]，这些 charts 目前不包含所有要部署的组件，但我相信以后会越来越丰富的。如果你不想处理这些细枝末节的问题，还有一个企业版可以试试。
+
+假如你在开发一个开源项目，你就能免费使用 SaaS 版的 Travis CI，享受顶尖团队提供的优质服务！这样能省去很多麻烦，你可以在一个相对通用的平台上（如 GitHub）研发开源项目，而不用找服务器来运行任何东西。
+
+### Jenkins
+
+- [项目主页](https://jenkins.io/)
+- [源代码](https://github.com/jenkinsci/jenkins)
+- 许可证：MIT
+
+Jenkins 在 CI/CD 界绝对是元老级的存在，也是事实上的标准。我强烈建议你读一读这篇文章：“[Jenkins: Shifting Gears][27]”，作者 Kohsuke 是 Jenkins 的创始人兼 CloudBees 公司 CTO。这篇文章契合了我在过去十年里对 Jenkins 及其社区的感受。他在文中阐述了一些这几年呼声很高的需求，我很乐意看到 CloudBees 引领这场变革。长期以来，Jenkins 对于非开发人员来说有点难以接受，并且一直是其管理员的重担。还好，这些问题正是他们想要着手解决的。
+
+[Jenkins 配置既代码][28]（JCasC）应该可以帮助管理员解决困扰了他们多年的配置复杂性问题。与其他 CI/CD 系统类似，只需要修改一个简单的 YAML 文件就可以完成 Jenkins 主节点的配置工作。[Jenkins Evergreen][29] 的出现让配置工作变得更加轻松，它提供了很多预设的使用场景，你只管套用就可以了。这些发行版会比官方的标准版本 Jenkins 更容易维护和升级。
+
+Jenkins 2 引入了两种原生的管道功能，我在 LISA（LCTT 译注：一个系统架构和运维大会） 2017 年的研讨会上已经[讨论过了][30]。这两种功能都没有 YAML 简便，但在处理复杂任务时它们很好用。
+
+[Jenkins X][31] 是 Jenkins 的一个全新变种，用来实现云端原生 Jenkins（至少在用户看来是这样）。它会使用 JCasC 及 Evergreen，并且和 Kubernetes 整合的更加紧密。对于 Jenkins 来说这是个令人激动的时刻，我很乐意看到它在这一领域的创新，并且继续发挥领袖作用。
+
+### Concourse CI
+
+- [项目主页](https://concourse-ci.org/)
+- [源代码](https://github.com/concourse/concourse)
+- 许可证：Apache 2.0
+
+我第一次知道 Concourse 是通过 Pivotal Labs 的伙计们介绍的，当时它处于早期 beta 版本，而且那时候也很少有类似的工具。这套系统是基于微服务构建的，每个任务运行在一个容器里。它独有的一个优良特性是能够在你本地系统上运行任务，体现你本地的改动。这意味着你完全可以在本地开发（假设你已经连接到了 Concourse 的服务器），像在真实的管道构建流程一样从你本地构建项目。而且，你可以在修改过代码后从本地直接重新运行构建，来检验你的改动结果。
+
+Concourse 还有一个简单的扩展系统，它依赖于“资源”这一基础概念。基本上，你想给管道添加的每个新功能都可以用一个 Docker 镜像实现，并作为一个新的资源类型包含在你的配置中。这样可以保证每个功能都被封装在一个不可变的独立工件中，方便对其单独修改和升级，改变其中一个时不会影响其他构建。
+
+### Spinnaker
+
+- [项目主页](https://www.spinnaker.io/)
+- [源代码](https://github.com/spinnaker/spinnaker)
+- 许可证：Apache 2.0
+
+Spinnaker 出自 Netflix，它更关注持续部署而非持续集成。它可以与其他工具整合，比如 Travis 和 Jenkins，来启动测试和部署流程。它也能与 Prometheus、Datadog 这样的监控工具集成，参考它们提供的指标来决定如何部署。例如，在<ruby>金丝雀发布<rt>canary deployment</rt></ruby>里，我们可以根据收集到的相关监控指标来做出判断：最近的这次发布是否导致了服务降级，应该立刻回滚；还是说看起来一切 OK，应该继续执行部署。
+
+谈到持续部署，一些另类但却至关重要的问题往往被忽略掉了，说出来可能有点让人困惑：Spinnaker 可以帮助持续部署不那么“持续”。在整个应用部署流程期间，如果发生了重大问题，它可以让流程停止执行，以阻止可能发生的部署错误。但它也可以在最关键的时刻让人工审核强制通过，发布新版本上线，使整体收益最大化。实际上，CI/CD 的主要目的就是在商业模式需要调整时，能够让待更新的代码立即得到部署。
+
+### Screwdriver
+
+- [项目主页](http://screwdriver.cd/)
+- [源代码](https://github.com/screwdriver-cd/screwdriver)
+- 许可证：BSD
+
+Screwdriver 是个简单而又强大的软件。它采用微服务架构，依赖像 Nomad、Kubernetes 和 Docker 这样的工具作为执行引擎。官方有一篇很不错的[部署教学文档][34]，介绍了如何将它部署到 AWS 和 Kubernetes 上，但如果正在开发中的 [Helm chart][35] 也完成的话，就更完美了。
+
+Screwdriver 也使用 YAML 来描述它的管道，并且有很多合理的默认值，这样可以有效减少各个管道重复的配置项。用配置文件可以组织起高级的工作流，来描述各个任务间复杂的依赖关系。例如，一项任务可以在另一个任务开始前或结束后运行；各个任务可以并行也可以串行执行；更赞的是你可以预先定义一项任务，只在特定的拉取请求时被触发，而且与之有依赖关系的任务并不会被执行，这能让你的管道具有一定的隔离性：什么时候被构造的工件应该被部署到生产环境，什么时候应该被审核。
+
+---
+
+以上只是我对这些 CI/CD 工具的简单介绍，它们还有许多很酷的特性等待你深入探索。而且它们都是开源软件，可以自由使用，去部署一下看看吧，究竟哪个才是最适合你的那个。
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/18/12/cicd-tools-sysadmins
+
+作者：[Dan Barker][a]
+选题：[lujun9972][b]
+译者：[jdh8383](https://github.com/jdh8383)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/barkerd427
+[b]: https://github.com/lujun9972
+[1]: https://www.ansible.com/
+[2]: https://www.chef.io/
+[3]: https://puppet.com/
+[4]: https://github.com/test-kitchen/test-kitchen
+[5]: https://www.merriam-webster.com/dictionary/ephemeral
+[6]: https://en.wikipedia.org/wiki/Idempotence
+[7]: https://mjml.io/
+[8]: https://gitlab.com/devopskc/newsletter/blob/master/.gitlab-ci.yml
+[9]: https://gitlab.com/devopskc/newsletter/blob/master/index/index.html
+[10]: https://gitlab.com/devopskc/newsletter/blob/master/html-to-pdf.js
+[11]: https://gitlab.com/devopskc/newsletter/blob/master/populate-index.js
+[12]: https://devopskc.com/
+[13]: https://en.wikipedia.org/wiki/Directed_acyclic_graph
+[14]: https://www.spinnaker.io/
+[15]: https://jenkins.io/
+[16]: https://martinfowler.com/books/dsl.html
+[17]: http://groovy-lang.org/
+[18]: https://about.gitlab.com/product/continuous-integration/
+[19]: https://gitlab.com/gitlab-org/gitlab-ce/
+[20]: https://about.gitlab.com/2017/09/27/gitlab-leader-continuous-integration-forrester-wave/
+[21]: https://github.com/gliderlabs/herokuish
+[22]: https://www.gocd.org/getting-started/part-3/#value_stream_map
+[23]: https://docs.gocd.org/current/advanced_usage/pipelines_as_code.html
+[24]: https://docs.travis-ci.com/
+[25]: https://github.com/travis-ci/travis-ci
+[26]: https://github.com/travis-ci/kubernetes-config
+[27]: https://jenkins.io/blog/2018/08/31/shifting-gears/
+[28]: https://jenkins.io/projects/jcasc/
+[29]: https://github.com/jenkinsci/jep/blob/master/jep/300/README.adoc
+[30]: https://danbarker.codes/talk/lisa17-becoming-plumber-building-deployment-pipelines/
+[31]: https://jenkins-x.io/
+[32]: https://concourse-ci.org/
+[33]: https://github.com/concourse/concourse
+[34]: https://docs.screwdriver.cd/cluster-management/kubernetes
+[35]: https://github.com/screwdriver-cd/screwdriver-chart

published/20190123 Mind map yourself using FreeMind and Fedora.md

@@ -0,0 +1,84 @@
+[#]: collector: (lujun9972)
+[#]: translator: (geekpi)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10579-1.html)
+[#]: subject: (Mind map yourself using FreeMind and Fedora)
+[#]: via: (https://fedoramagazine.org/mind-map-yourself-using-freemind-and-fedora/)
+[#]: author: (Paul W. Frields https://fedoramagazine.org/author/pfrields/)
+
+在 Fedora 中使用 FreeMind 介绍你自己
+======
+
+![](https://fedoramagazine.org/wp-content/uploads/2019/01/freemind-816x345.jpg)
+
+介绍你自己的思维导图，一开始听起来有些牵强。它是关于神经通路么？还是心灵感应？完全不是。相反，自己的思维导图是一种在视觉上向他人描述自己的方式。它还展示了你拿来描述自己的特征之间的联系。这是一种以聪明又同时可控的与他人分享信息的有用方式。你可以使用任何思维导图应用来做到。本文向你展示如何使用 Fedora 中提供的 [FreeMind][1]。
+
+### 获取应用
+
+FreeMind 已经出现有一段时间了。虽然 UI 有点过时，应该做一些更新了，但它是一个功能强大的应用，提供了许多构建思维导图的选项。当然，它是 100％ 开源的。还有其他思维导图应用可供 Fedora 和 Linux 用户使用。查看[此前一篇涵盖多个思维导图选择的文章][2]。
+
+如果你运行的是 Fedora Workstation，请使用“软件”应用从 Fedora 仓库安装 FreeMind。或者在终端中使用这个 [sudo][3] 命令：
+
+```
+$ sudo dnf install freemind
+```
+
+你可以从 Fedora Workstation 中的 GNOME Shell Overview 启动应用。或者使用桌面环境提供的应用启动服务。默认情况下，FreeMind 会显示一个新的空白脑图：
+
+![][4]
+
+*FreeMind 初始（空白）思维导图*
+
+脑图由链接的项目或描述（节点）组成。当你想到与节点相关的内容时，只需创建一个与其连接的新节点即可。
+
+### 做你自己的脑图
+
+单击初始节点。编辑文本并按回车将其替换为你的姓名。你就能开始你的思维导图。
+
+如果你必须向某人充分描述自己，你会怎么想？可能会有很多东西。你平时做什么？你喜欢什么？你不喜欢什么？你有什么价值？你有家庭吗？所有这些都可以在节点中体现。
+
+要添加节点连接，请选择现有节点，然后单击“Insert”，或使用“灯泡”图标作为新的子节点。要在与新子级相同的层级添加另一个节点，请使用回车。
+
+如果你弄错了，别担心。你可以使用 `Delete` 键删除不需要的节点。内容上没有规则。但是最好是短节点。它们能让你在创建导图时思维更快。简洁的节点还能让其他浏览者更轻松地查看和理解。
+
+该示例使用节点规划了每个主要类别：
+
+![][5]
+
+*个人思维导图，第一级*
+
+你可以为这些区域中的每个区域另外迭代一次。让你的思想自由地连接想法以生成导图。不要担心“做得正确“。最好将所有内容从头脑中移到显示屏上。这是下一级导图的样子。
+
+![][6]
+
+*个人思维导图，第二级*
+
+你可以以相同的方式扩展任何这些节点。请注意你在示例中可以了解多少有关 “John Q. Public” 的信息。
+
+### 如何使用你的个人思维导图
+
+这是让团队或项目成员互相介绍的好方法。你可以将各种格式和颜色应用于导图以赋予其个性。当然，这些在纸上做很有趣。但是在 Fedora 中安装一个就意味着你可以随时修复错误，甚至可以在你改变的时候做出修改。
+
+祝你在探索个人思维导图上玩得开心！
+
+
+--------------------------------------------------------------------------------
+
+via: https://fedoramagazine.org/mind-map-yourself-using-freemind-and-fedora/
+
+作者：[Paul W. Frields][a]
+选题：[lujun9972][b]
+译者：[geekpi](https://github.com/geekpi)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://fedoramagazine.org/author/pfrields/
+[b]: https://github.com/lujun9972
+[1]: http://freemind.sourceforge.net/wiki/index.php/Main_Page
+[2]: https://fedoramagazine.org/three-mind-mapping-tools-fedora/
+[3]: https://fedoramagazine.org/howto-use-sudo/
+[4]: https://fedoramagazine.org/wp-content/uploads/2019/01/Screenshot-from-2019-01-19-15-17-04-1024x736.png
+[5]: https://fedoramagazine.org/wp-content/uploads/2019/01/Screenshot-from-2019-01-19-15-32-38-1024x736.png
+[6]: https://fedoramagazine.org/wp-content/uploads/2019/01/Screenshot-from-2019-01-19-15-38-00-1024x736.png

published/201902/20160922 Annoying Experiences Every Linux Gamer Never Wanted.md

@@ -0,0 +1,156 @@
+每个 Linux 游戏玩家都绝不想要的恼人体验
+===================
+
+[![Linux 平台上玩家的问题](https://itsfoss.com/wp-content/uploads/2016/09/Linux-Gaming-Problems.jpg)][10]
+
+（LCTT 译注：本文原文发表于 2016 年，可能有些信息已经过时。）
+
+[在 Linux 平台上玩游戏][12] 并不是什么新鲜事，现在甚至有专门的 [Linux 游戏发行版][13]，但是这不意味着在 Linux 上打游戏的体验和在 Windows 上一样顺畅。
+
+为了确保我们和 Windows 用户同样地享受游戏乐趣，哪些问题是我们应该考虑的呢？
+
+[Wine][14]、[PlayOnLinux][15] 和其它类似软件不总是能够让我们玩所有流行的 Windows 游戏。在这篇文章里，我想讨论一下为了拥有最好的 Linux 游戏体验所必须处理好的若干因素。 
+
+### #1 SteamOS 是开源平台，但 Steam for Linux 并不是 
+
+正如 [StemOS 主页][16]所说， 即便 SteamOS 是一个开源平台，但 Steam for Linux 仍然是专有的软件。如果 Steam for Linux 也开源，那么它从开源社区得到的支持将会是巨大的。既然它不是，那么 [Ascension 计划的诞生自然是不可避免的][17]：
+
+- [Destination: Project Ascension • UI Design Mockups Reveal](https://youtu.be/07UiS5iAknA)
+
+Ascension 是一个开源的游戏启动器，旨在能够启动从任何平台购买、下载的游戏。这些游戏可以是 Steam 平台的、[Origin 游戏][18]平台的、Uplay 平台的，以及直接从游戏开发者主页下载的，或者来自 DVD、CD-ROM 的。
+
+Ascension 计划的开端是这样：[某个观点的分享][19]激发了一场与游戏社区读者之间有趣的讨论，在这场讨论中读者们纷纷发表了自己的观点并给出建议。
+
+### #2 与 Windows 平台的性能比较
+
+在 Linux 平台上运行 Windows 游戏并不总是一件轻松的任务。但是得益于一个叫做 [CSMT][20]（多线程命令流）的特性，尽管离 Windows 级别的性能还有相当长的路要走，PlayOnLinux 现在依旧可以更好地解决这些性能方面的问题。
+
+Linux 对游戏的原生支持在过去发行的游戏中从未尽如人意。
+
+去年，有报道说 SteamOS 比 Windows 在游戏方面的表现要[差得多][21]。古墓丽影去年在 SteamOS 及 Steam for Linux 上发行，然而其基准测试的结果与 Windows 上的性能无法抗衡。
+
+- [Destination: Tomb Raider benchmark video comparison, Linux vs Windows 10](https://youtu.be/nkWUBRacBNE)
+
+这明显是因为游戏是基于 [DirectX][23] 而不是 [OpenGL][24] 开发的缘故。
+
+古墓丽影是[第一个使用 TressFX 的游戏][25]。下面这个视频包涵了 TressFX 的比较：
+
+- [Destination: Tomb Raider Benchmark  - Ubuntu 15.10 vs Windows 8.1 + Ubuntu 16.04 vs Windows 10](https://youtu.be/-IeY5ZS-LlA)
+
+下面是另一个有趣的比较，它显示出使用 Wine + CSMT 带来的游戏性能比 Steam 上原生的 Linux 版游戏带来的游戏性能要好得多！这就是开源的力量！ 
+
+- [Destination: [LinuxBenchmark] Tomb Raider Linux vs Wine comparison](https://youtu.be/sCJkC6oJ08A)
+
+以防 FPS 损失，TressFX 已经被关闭。
+
+以下是另一个有关在 Linux 上最新发布的 “[Life is Strange][27]” 在 Linux 与 Windows 上的比较：
+
+- [Destination: Life is Strange on radeonsi (Linux nine_csmt vs Windows 10)](https://youtu.be/Vlflu-pIgIY)
+
+[Steam for Linux][28] 开始在这个新游戏上展示出比 Windows 更好的游戏性能，这是一件好事。
+
+在发布任何 Linux 版的游戏前，开发者都应该考虑优化游戏，特别是基于 DirectX 并需要进行 OpenGL 转制的游戏。我们十分希望 Linux 上的<ruby>[杀出重围：人类分裂][29]<rt>Deus Ex: Mankind Divided</rt></ruby> 在正式发行时能有一个好的基准测试结果。由于它是基于 DirectX 的游戏，我们希望它能良好地移植到 Linux 上。[该游戏执行总监说过这样的话][30]。
+
+### #3 专有的 NVIDIA 驱动
+
+相比于 [NVIDIA][32]，[AMD 对于开源的支持][31]绝对是值得称赞的。尽管 [AMD][33] 因其更好的开源驱动在 Linux 上的驱动支持挺不错，而 NVIDIA 显卡用户由于开源版本的 NVIDIA 显卡驱动 “Nouveau” 有限的能力，仍不得不用专有的 NVIDIA 驱动。
+
+曾经，Linus Torvalds 大神也分享过他关于“来自 NVIDIA 的 Linux 支持完全不可接受”的想法。
+
+- [Destination: Linus Torvalds Publicly Attacks NVidia for lack of Linux & Android Support](https://youtu.be/O0r6Pr_mdio)
+
+你可以在这里观看完整的[谈话][35]，尽管 NVIDIA 回应 [承诺更好的 Linux 平台支持][36]，但其开源显卡驱动仍如之前一样毫无起色。
+
+### #4 需要 Linux 平台上的 Uplay 和 Origin 的 DRM 支持
+
+- [Destination: Uplay #1 Rayman Origins em Linux - como instalar - ago 2016](https://youtu.be/rc96NFwyxWU)
+
+以上的视频描述了如何在 Linux 上安装 [Uplay][37] DRM。视频上传者还建议说并不推荐使用 Wine 作为 Linux 上的主要的应用和游戏支持软件。相反，更鼓励使用原生的应用。
+
+以下视频是一个关于如何在 Linux 上安装 [Origin][38] DRM 的教程。
+
+- [Destination: Install EA Origin in Ubuntu with PlayOnLinux (Updated)](https://youtu.be/ga2lNM72-Kw)
+
+数字版权管理（DRM）软件给游戏运行又加了一层阻碍，使得在 Linux 上良好运行 Windows 游戏这一本就充满挑战性的任务更有难度。因此除了使游戏能够运行之外，W.I.N.E 不得不同时负责运行像 Uplay 或 Origin 之类的 DRM 软件。如果能像 Steam 一样，Linux 也能够有自己原生版本的 Uplay 和 Origin 那就好了。
+
+### #5 DirectX 11 对于 Linux 的支持
+
+尽管我们在 Linux 平台上有可以运行 Windows 应用的工具，每个游戏为了能在 Linux 上运行都带有自己的配套调整需求。尽管去年在 Code Weavers 有一篇关于 [DirectX 11 对于 Linux 的支持][40] 的公告，在 Linux 上畅玩新发大作仍是长路漫漫。
+
+现在你可以[从 Codweavers 购买 Crossover][41] 以获得可得到的最佳 DirectX 11 支持。这个在 Arch Linux 论坛上的[频道][42]清楚展现了将这个梦想成真需要多少的努力。以下是一个 [Reddit 频道][44] 上的有趣 [发现][43]。这个发现提到了[来自 Codeweavers 的 DirectX 11 补丁][45]，现在看来这无疑是好消息。 
+
+### #6 不是全部的 Steam 游戏都可跑在 Linux 上
+
+随着 Linux 游戏玩家一次次错过主要游戏的发行，这是需要考虑的一个重点，因为大部分主要游戏都在 Windows 上发行。这是[如何在 Linux 上安装 Windows 版的 Steam 的教程][46]。
+
+### #7 游戏发行商对 OpenGL 更好的支持
+
+目前开发者和发行商主要着眼于用 DirectX 而不是 OpenGL 来开发游戏。现在随着 Steam 正式登录 Linux，开发者应该同样考虑在 OpenGL 下开发。 
+
+[Direct3D][47] 仅仅是为 Windows 平台而打造。而 OpenGL API 拥有开放性标准，并且它不仅能在 Windows 上同样也能在其它各种各样的平台上实现。
+
+尽管是一篇很老的文章，但[这个很有价值的资源][48]分享了许多有关 OpenGL 和 DirectX 现状的很有想法的信息。其所提出的观点确实十分明智，基于按时间排序的事件也能给予读者启迪。
+
+在 Linux 平台上发布大作的发行商绝不应该忽视一个事实：在 OpenGL 下直接开发游戏要比从 DirectX 移植到 OpenGL 合算得多。如果必须进行平台转制，移植必须被仔细优化并谨慎研究。发布游戏可能会有延迟，但这绝对值得。
+
+有更多的烦恼要分享？务必在评论区让我们知道。
+
+--------------------------------------------------------------------------------
+
+via: https://itsfoss.com/linux-gaming-problems/
+
+作者：[Avimanyu Bandyopadhyay][a]
+译者：[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/avimanyu/
+[1]:https://itsfoss.com/author/avimanyu/
+[2]:https://itsfoss.com/linux-gaming-problems/#comments
+[3]:https://www.facebook.com/share.php?u=https%3A%2F%2Fitsfoss.com%2Flinux-gaming-problems%2F%3Futm_source%3Dfacebook%26utm_medium%3Dsocial%26utm_campaign%3DSocialWarfare
+[4]:https://twitter.com/share?original_referer=/&text=Annoying+Experiences+Every+Linux+Gamer+Never+Wanted%21&url=https://itsfoss.com/linux-gaming-problems/%3Futm_source%3Dtwitter%26utm_medium%3Dsocial%26utm_campaign%3DSocialWarfare&via=itsfoss2
+[5]:https://plus.google.com/share?url=https%3A%2F%2Fitsfoss.com%2Flinux-gaming-problems%2F%3Futm_source%3DgooglePlus%26utm_medium%3Dsocial%26utm_campaign%3DSocialWarfare
+[6]:https://www.linkedin.com/cws/share?url=https%3A%2F%2Fitsfoss.com%2Flinux-gaming-problems%2F%3Futm_source%3DlinkedIn%26utm_medium%3Dsocial%26utm_campaign%3DSocialWarfare
+[7]:http://www.stumbleupon.com/submit?url=https://itsfoss.com/linux-gaming-problems/&title=Annoying+Experiences+Every+Linux+Gamer+Never+Wanted%21
+[8]:https://www.reddit.com/submit?url=https://itsfoss.com/linux-gaming-problems/&title=Annoying+Experiences+Every+Linux+Gamer+Never+Wanted%21
+[9]:https://itsfoss.com/wp-content/uploads/2016/09/Linux-Gaming-Problems.jpg
+[10]:https://itsfoss.com/wp-content/uploads/2016/09/Linux-Gaming-Problems.jpg
+[11]:http://pinterest.com/pin/create/bookmarklet/?media=https://itsfoss.com/wp-content/uploads/2016/09/Linux-Gaming-Problems.jpg&url=https://itsfoss.com/linux-gaming-problems/&is_video=false&description=Linux%20gamer%27s%20problem
+[12]:https://itsfoss.com/linux-gaming-guide/
+[13]:https://itsfoss.com/linux-gaming-distributions/
+[14]:https://itsfoss.com/use-windows-applications-linux/
+[15]:https://www.playonlinux.com/en/
+[16]:http://store.steampowered.com/steamos/
+[17]:http://www.ibtimes.co.uk/reddit-users-want-replace-steam-open-source-game-launcher-project-ascension-1498999
+[18]:https://www.origin.com/
+[19]:https://www.reddit.com/r/pcmasterrace/comments/33xcvm/we_hate_valves_monopoly_over_pc_gaming_why/
+[20]:https://github.com/wine-compholio/wine-staging/wiki/CSMT
+[21]:http://arstechnica.com/gaming/2015/11/ars-benchmarks-show-significant-performance-hit-for-steamos-gaming/
+[22]:https://www.gamingonlinux.com/articles/tomb-raider-benchmark-video-comparison-linux-vs-windows-10.7138
+[23]:https://en.wikipedia.org/wiki/DirectX
+[24]:https://en.wikipedia.org/wiki/OpenGL
+[25]:https://www.gamingonlinux.com/articles/tomb-raider-released-for-linux-video-thoughts-port-report-included-the-first-linux-game-to-use-tresfx.7124
+[26]:https://itsfoss.com/osu-new-linux/
+[27]:http://lifeisstrange.com/
+[28]:https://itsfoss.com/install-steam-ubuntu-linux/
+[29]:https://itsfoss.com/deus-ex-mankind-divided-linux/
+[30]:http://wccftech.com/deus-ex-mankind-divided-director-console-ports-on-pc-is-disrespectful/
+[31]:http://developer.amd.com/tools-and-sdks/open-source/
+[32]:http://nvidia.com/
+[33]:http://amd.com/
+[34]:http://www.makeuseof.com/tag/open-source-amd-graphics-now-awesome-heres-get/
+[35]:https://youtu.be/MShbP3OpASA
+[36]:https://itsfoss.com/nvidia-optimus-support-linux/
+[37]:http://uplay.com/
+[38]:http://origin.com/
+[39]:https://itsfoss.com/linux-foundation-head-uses-macos/
+[40]:http://www.pcworld.com/article/2940470/hey-gamers-directx-11-is-coming-to-linux-thanks-to-codeweavers-and-wine.html
+[41]:https://itsfoss.com/deal-run-windows-software-and-games-on-linux-with-crossover-15-66-off/
+[42]:https://bbs.archlinux.org/viewtopic.php?id=214771
+[43]:https://ghostbin.com/paste/sy3e2
+[44]:https://www.reddit.com/r/linux_gaming/comments/3ap3uu/directx_11_support_coming_to_codeweavers/
+[45]:https://www.codeweavers.com/about/blogs/caron/2015/12/10/directx-11-really-james-didnt-lie
+[46]:https://itsfoss.com/linux-gaming-guide/
+[47]:https://en.wikipedia.org/wiki/Direct3D
+[48]:http://blog.wolfire.com/2010/01/Why-you-should-use-OpenGL-and-not-DirectX

published/201902/20180112 8 KDE Plasma Tips and Tricks to Improve Your Productivity.md

@@ -7,23 +7,23 @@
 
 你能够轻松地配置 Plasma 桌面并且使用它大量方便且节省时间的特性来加速你的工作，拥有一个能够帮助你而非阻碍你的桌面环境。
 
-这些提示并没有特定顺序，因此你无需按次序阅读。你只需要挑出最适合你的工作流的那几个即可。
+以下这些提示并没有特定顺序，因此你无需按次序阅读。你只需要挑出最适合你的工作流的那几个即可。
 
- **相关阅读** : [10 个你应该尝试的最佳 KDE Plasma 应用][1]
+**相关阅读**：[10 个你应该尝试的最佳 KDE Plasma 应用][1]
 
-### 1. 多媒体控制
+### 1、多媒体控制
 
-这点算不太上是一条提示，因为它是很容易被记在脑海里的。Plasma 可在各处进行多媒体控制。当你需要暂停、继续或跳过一首歌时，你不需要每次都打开你的媒体播放器。你能够通过将鼠标移至最小化窗口之上，甚至通过锁屏进行控制。当你需要切换歌曲或忘了暂停时，你也不必麻烦地登录再进行操作。
+这点不太算得上是一条提示，因为它是很容易被记在脑海里的。Plasma 可在各处进行多媒体控制。当你需要暂停、继续或跳过一首歌时，你不需要每次都打开你的媒体播放器。你能够通过将鼠标移至那个最小化窗口之上，甚至通过锁屏进行控制。当你需要切换歌曲或忘了暂停时，你也不必麻烦地登录再进行操作。
 
-### 2. KRunner
+### 2、KRunner
 
 ![KDE Plasma KRunner][2]
 
-KRunner 是 Plasma 桌面中一个经常受到赞誉的特性。大部分人习惯于深挖应用启动菜单来找到想要启动的程序。当你使用 KRunner 时就不需要这么做。
+KRunner 是 Plasma 桌面中一个经常受到赞誉的特性。大部分人习惯于穿过层层的应用启动菜单来找到想要启动的程序。当你使用 KRunner 时就不需要这么做。
 
-为了使用 KRunner，确保你当前的焦点在桌面本身（点击桌面而不是窗口）。然后开始输入你想要启动的应用名称，KRunner 将会带着建议项从你的屏幕顶部自动下拉。在你寻找的匹配项上点击或敲击 Enter 键。这比记住你每个应用所属的类别要更快。
+为了使用 KRunner，确保你当前的活动焦点在桌面本身（点击桌面而不是窗口）。然后开始输入你想要启动的应用名称，KRunner 将会带着建议项从你的屏幕顶部自动下拉。在你寻找的匹配项上点击或敲击回车键。这比记住你每个应用所属的类别要更快。
 
-### 3. 跳转列表
+### 3、跳转列表
 
 ![KDE Plasma 的跳转列表][3]
 
@@ -31,7 +31,7 @@ KRunner 是 Plasma 桌面中一个经常受到赞誉的特性。大部分人习
 
 因此如果你在菜单栏上有一个应用启动图标，你可以通过右键得到可跳转位置的列表。选择你想要跳转的位置，然后就可以“起飞”了。
 
-### 4. KDE Connect
+### 4、KDE Connect
 
 ![KDE Connect Android 客户端菜单][4]
 
@@ -41,15 +41,15 @@ KRunner 是 Plasma 桌面中一个经常受到赞誉的特性。大部分人习
 
 KDE Connect 也允许你在手机和电脑间发送文件或共享网页。你可以轻松地从一个设备转移至另一设备，而无需烦恼或打乱思绪。
 
-### 5. Plasma Vaults
+### 5、Plasma Vaults
 
 ![KDE Plasma Vault][7]
 
-Plasma Vaults 是 Plasma 桌面的另一个新功能。它的 KDE 为加密文件和文件夹提供的简单解决方案。如果你不使用加密文件，此项功能不会为你节省时间。如果你使用，Vaults是一个更简单的途径。
+Plasma Vaults 是 Plasma 桌面的另一个新功能。它的 KDE 为加密文件和文件夹提供的简单解决方案。如果你不使用加密文件，此项功能不会为你节省时间。如果你使用，Vaults 是一个更简单的途径。
 
 Plasma Vaults 允许你以无 root 权限的普通用户创建加密目录，并通过你的任务栏来管理它们。你能够快速地挂载或卸载目录，而无需外部程序或附加权限。
 
-### 6. Pager 控件
+### 6、Pager 控件
 
 ![KDE Plasma Pager][8]
 
@@ -57,19 +57,19 @@ Plasma Vaults 允许你以无 root 权限的普通用户创建加密目录，并
 
 将控件添加到你的菜单栏上，然后你就可以在多个工作区间滑动切换。每个工作区都与你原桌面的尺寸相同，因此你能够得到数倍于完整屏幕的空间。这就使你能够排布更多的窗口，而不必受到一堆混乱的最小化窗口的困扰。
 
-### 7. 创建一个 Dock
+### 7、创建一个 Dock
 
 ![KDE Plasma Dock][9]
 
 Plasma 以其灵活性和可配置性出名，同时也是它的优势。如果你有常用的程序，你可以考虑将常用程序设置为 OS X 风格的 dock。你能够通过单击启动，而不必深入菜单或输入它们的名字。
 
-### 8. 为 Dolphin 添加文件树
+### 8、为 Dolphin 添加文件树
 
 ![Plasma Dolphin 目录][10]
 
 通过目录树来浏览文件夹会更加简单。Dolphin 作为 Plasma 的默认文件管理器，具有在文件夹窗口一侧，以树的形式展示目录列表的内置功能。
 
-为了启用目录树，点击“控制”标签，然后“配置 Dolphin”，“显示模式”，“详细”，最后选择“可展开文件夹”。
+为了启用目录树，点击“控制”标签，然后“配置 Dolphin”、“显示模式”、“详细”，最后选择“可展开文件夹”。
 
 记住这些仅仅是提示，不要强迫自己做阻碍自己的事情。你可能讨厌在 Dolphin 中使用文件树，你也可能从不使用 Pager，这都没关系。当然也可能会有你喜欢但是此处没列举出来的功能。选择对你有用处的，也就是说，这些技巧中总有一些能帮助你度过日常工作中的艰难时刻。
 
@@ -79,7 +79,7 @@ via: https://www.maketecheasier.com/kde-plasma-tips-tricks-improve-productivity/
 
 作者：[Nick Congleton][a]
 译者：[cycoe](https://github.com/cycoe)
-校对：[校对者ID](https://github.com/校对者ID)
+校对：[wxy](https://github.com/wxy)
 
 本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
 

published/201902/20180128 Get started with Org mode without Emacs.md

@@ -0,0 +1,79 @@
+[#]: collector: (lujun9972)
+[#]: translator: (lujun9972)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10574-1.html)
+[#]: subject: (Get started with Org mode without Emacs)
+[#]: via: (https://opensource.com/article/19/1/productivity-tool-org-mode)
+[#]: author: (Kevin Sonney https://opensource.com/users/ksonney (Kevin Sonney))
+
+开始使用 Org 模式吧，在没有 Emacs 的情况下
+======
+
+> 不，你不需要 Emacs 也能用 Org，这是我开源工具系列的第 16 集，将会让你在 2019 年变得更加有生产率。
+
+![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/web_browser_desktop_devlopment_design_system_computer.jpg?itok=pfqRrJgh)
+
+每到年初似乎总有这么一个疯狂的冲动来寻找提高生产率的方法。新年决心，正确地开始一年的冲动，以及“向前看”的态度都是这种冲动的表现。软件推荐通常都会选择闭源和专利软件。但这不是必须的。
+
+这是我 2019 年改进生产率的 19 个新工具中的第 16 个。
+
+### Org (非 Emacs)
+
+[Org 模式][1] (或者就称为 Org) 并不是新鲜货，但依然有许多人没有用过。他们很乐意试用一下以体验 Org 是如何改善生产率的。但最大的障碍来自于 Org 是与 Emacs 相关联的，而且很多人都认为两者缺一不可。并不是这样的！一旦你理解了其基础，Org 就可以与各种其他工具和编辑器一起使用。
+
+![](https://opensource.com/sites/default/files/uploads/org-1.png)
+
+Org，本质上，是一个结构化的文本文件。它有标题、子标题，以及各种关键字，其他工具可以根据这些关键字将文件解析成日程表和代办列表。Org 文件可以被任何纯文本编辑器编辑（例如，[Vim][2]、[Atom][3] 或 [Visual Studio Code][4]），而且很多编辑器都有插件可以帮你创建和管理 Org 文件。
+
+一个基础的 Org 文件看起来是这样的：
+
+```
+* Task List
+** TODO Write Article for Day 16 - Org w/out emacs
+   DEADLINE: <2019-01-25 12:00>
+*** DONE Write sample org snippet for article
+    - Include at least one TODO and one DONE item
+    - Show notes
+    - Show SCHEDULED and DEADLINE
+*** TODO Take Screenshots
+** Dentist Appointment
+   SCHEDULED: <2019-01-31 13:30-14:30>
+```
+
+Org 是一种大纲格式，它使用 `*` 作为标识指明事项的级别。任何以 `TODO`（是的，全大些）开头的事项都是代办事项。标注为 `DONE` 的工作表示该工作已经完成。`SCHEDULED` 和 `DEADLINE` 标识与该事务相关的日期和时间。如何任何地方都没有时间，则该事务被视为全天活动。
+
+使用正确的插件，你喜欢的文本编辑器可以成为一个充满生产率和组织能力的强大工具。例如，[vim-orgmode][5] 插件包括创建 Org 文件、语法高亮的功能，以及各种用来生成跨文件的日程和综合代办事项列表的关键命令。
+
+![](https://opensource.com/sites/default/files/uploads/org-2.png)
+
+Atom 的 [Organized][6] 插件可以在屏幕右边添加一个侧边栏，用来显示 Org 文件中的日程和代办事项。默认情况下它从配置项中设置的路径中读取多个 Org 文件。Todo 侧边栏允许你通过点击未完事项来将其标记为已完成，它会自动更新源 Org 文件。
+
+![](https://opensource.com/sites/default/files/uploads/org-3.png)
+
+还有一大堆 Org 工具可以帮助你保持生产率。使用 Python、Perl、PHP、NodeJS 等库，你可以开发自己的脚本和工具。当然，少不了 [Emacs][7]，它的核心功能就包括支持 Org。
+
+![](https://opensource.com/sites/default/files/uploads/org-4.png)
+
+Org 模式是跟踪需要完成的工作和时间的最好工具之一。而且，与传闻相反，它无需 Emacs，任何一个文本编辑器都行。
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/19/1/productivity-tool-org-mode
+
+作者：[Kevin Sonney][a]
+选题：[lujun9972][b]
+译者：[lujun9972](https://github.com/lujun9972)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/ksonney (Kevin Sonney)
+[b]: https://github.com/lujun9972
+[1]: https://orgmode.org/
+[2]: https://www.vim.org/
+[3]: https://atom.io/
+[4]: https://code.visualstudio.com/
+[5]: https://github.com/jceb/vim-orgmode
+[6]: https://atom.io/packages/organized
+[7]: https://www.gnu.org/software/emacs/

published/201902/20180531 Qalculate- - The Best Calculator Application in The Entire Universe.md

@@ -0,0 +1,124 @@
+Qalculate! ：全宇宙最好的计算器软件
+======
+
+十多年来，我一直都是 GNU-Linux 以及 [Debian][1] 的用户。随着我越来越频繁的使用桌面环境，我发现对我来说除了少数基于 web 的服务以外我的大多数需求都可以通过 Debian 软件库里自带的[桌面应用][2]解决。
+
+我的需求之一就是进行单位换算。尽管有很多很多在线服务可以做这件事，但是我还是需要一个可以在桌面环境使用的应用。这主要是因为隐私问题以及我不想一而再再而三的寻找在线服务做事。为此我搜寻良久，直到找到 Qalculate!。
+
+### Qalculate! 最强多功能计算器应用
+
+![最佳计算器应用 Qalculator][3]
+
+这是 aptitude 上关于 [Qalculate!][4] 的介绍，我没法总结的比他们更好了：
+
+> 强大易用的桌面计算器 - GTK+ 版
+>
+> Qalculate! 是一款外表简单易用，内核强大且功能丰富的应用。其功能包含自定义函数、单位、高计算精度、作图以及可以输入一行表达式（有容错措施）的图形界面（也可以选择使用传统按钮）。
+
+这款应用也发行过 KDE 的界面，但是至少在 Debian Testing 软件库里，只出现了 GTK+ 版的界面，你也可以在 GitHub 上的这个[仓库][5]里面看到。
+
+不必多说，Qalculate! 在 Debian 的软件源内处于可用状态，因此可以使用 [apt][6] 命令或者是基于 Debian 的发行版比如 Ubuntu 提供的软件中心轻松安装。在 Windows 或者 macOS 上也可以使用这款软件。
+
+#### Qalculate! 特性一览
+
+列出全部的功能清单会有点长，请允许我只列出一部分功能并使用截图来展示极少数 Qalculate! 提供的功能。这么做是为了让你熟悉 Qalculate! 的基本功能，并在之后可以自由探索 Qalculate! 到底还能干什么。
+
+* 代数
+* 微积分
+* 组合数学
+* 复数
+* 数据集
+* 日期与时间
+* 经济学
+* 对数和指数
+* 几何
+* 逻辑学
+* 向量和矩阵
+* 杂项
+* 数论
+* 统计学
+* 三角学
+
+#### 使用 Qalculate!
+
+Qalculate! 的使用不是很难。你甚至可以在里面写简单的英文。但是我还是推荐先[阅读手册][7]以便充分发挥 Qalculate! 的潜能。
+
+![使用 Qalculate 进行字节到 GB 的换算][8]
+
+![摄氏度到华氏度的换算][9]
+
+#### qalc 是 Qalculate! 的命令行版
+
+你也可以使用 Qalculate! 的命令行版 `qalc`：
+
+```
+$ qalc 62499836 byte to gibibyte
+62499836 * byte = approx. 0.058207508 gibibyte
+
+$ qalc 40 degree celsius to fahrenheit
+(40 * degree) * celsius = 104 deg*oF
+```
+
+Qalculate! 的命令行界面可以让不喜欢 GUI 而是喜欢命令行界面（CLI）或者是使用无头结点（没有 GUI）的人可以使用 Qalculate!。这些人大多是在服务器环境下工作。
+
+如果你想要在脚本里使用这一软件的话，我想 libqalculate 是最好的解决方案。看一看 `qalc` 以及 qalculate-gtk 是如何依赖于它工作的就足以知晓如何使用了。
+
+再提一嘴，你还可以了解下如何根据一系列数据绘图，其他应用方式就留给你自己发掘了。不要忘记查看 `/usr/share/doc/qalculate/index.html` 以获取 Qalculate! 的全部功能。
+
+注释：注意 Debian 更喜欢 [gnuplot][10]，因为其输出的图片很精美。
+
+#### 附加技巧：你可以通过在 Debian 下通过命令行感谢开发者
+
+如果你使用 Debian 而且喜欢哪个包的话，你可以使用如下命令感谢 Debian 下这个软件包的开发者或者是维护者：
+
+```
+reportbug --kudos $PACKAGENAME
+```
+
+因为我喜欢 Qalculate!，我想要对 Debian 的开发者以及维护者 Vincent Legout 的卓越工作表示感谢：
+
+```
+reportbug --kudos qalculate
+```
+
+建议各位阅读我写的关于如何使用报错工具[在 Debian 中上报 BUG][11]的详细指南。
+
+#### 一位高分子化学家对 Qalculate! 的评价
+
+经由作者 [Philip Prado][12]，我们联系上了 Timothy Meyers 先生，他目前是在高分子实验室工作的高分子化学家。
+
+他对 Qaclulate! 的专业评价是：
+
+> 看起来几乎任何科学家都可以使用这个软件，因为如果你知道指令以及如何使其生效的话，几乎任何数据计算都可以使用这个软件计算。
+
+> 我觉得这个软件少了些物理常数，但我想不起来缺了哪些。我觉得它没有太多有关[流体动力学][13]的东西，再就是少了点部分化合物的[光吸收][14]系数，但这些东西只对我这个化学家来说比较重要，我不知道这些是不是对别人来说也是特别必要的。[自由能][15]可能也是。
+
+最后，我分享的关于 Qalculate! 的介绍十分简陋，其实际功能与你的需要以及你的想象力有关系。希望你能喜欢 Qalculate!
+
+--------------------------------------------------------------------------------
+
+via: https://itsfoss.com/qalculate/
+
+作者：[Shirish][a]
+选题：[lujun9972](https://github.com/lujun9972)
+译者：[name1e5s](https://github.com/name1e5s)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]:https://itsfoss.com/author/shirish/
+[1]:https://www.debian.org/
+[2]:https://itsfoss.com/essential-linux-applications/
+[3]:https://i2.wp.com/itsfoss.com/wp-content/uploads/2018/05/qalculate-app-featured-1.jpeg?w=800&ssl=1
+[4]:https://qalculate.github.io/
+[5]:https://github.com/Qalculate
+[6]:https://itsfoss.com/apt-command-guide/
+[7]:https://qalculate.github.io/manual/index.html
+[8]:https://i0.wp.com/itsfoss.com/wp-content/uploads/2018/04/qalculate-byte-conversion.png?zoom=2&ssl=1
+[9]:https://i0.wp.com/itsfoss.com/wp-content/uploads/2018/04/qalculate-gtk-weather-conversion.png?zoom=2&ssl=1
+[10]:http://www.gnuplot.info/
+[11]:https://itsfoss.com/bug-report-debian/
+[12]:https://itsfoss.com/author/phillip/
+[13]:https://en.wikipedia.org/wiki/Fluid_dynamics
+[14]:https://en.wikipedia.org/wiki/Absorption_(electromagnetic_radiation)
+[15]:https://en.wikipedia.org/wiki/Gibbs_free_energy

published/201902/20190116 The Evil-Twin Framework- A tool for improving WiFi security.md

@@ -1,69 +1,69 @@
 [#]: collector: (lujun9972)
 [#]: translator: (hopefully2333)
-[#]: reviewer: ( )
-[#]: publisher: ( )
-[#]: url: ( )
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10568-1.html)
 [#]: subject: (The Evil-Twin Framework: A tool for improving WiFi security)
 [#]: via: (https://opensource.com/article/19/1/evil-twin-framework)
 [#]: author: (André Esser https://opensource.com/users/andreesser)
 
 Evil-Twin 框架：一个用于提升 WiFi 安全性的工具
 ======
-了解一款用于对 WiFi 安全性进行手动测试的工具，这款工具可以通过不同类型安全威胁的漏洞点进行测试。
+
+> 了解一款用于对 WiFi 接入点安全进行渗透测试的工具。
+
 ![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/security-lock-cloud-safe.png?itok=yj2TFPzq)
 
-越来越多的设备通过无线传输的方式连接到互联网，以及，WiFi 接入点大范围的可用，这两者为攻击者攻击用户提供了很多机会。通过欺骗用户连接到虚假的 WiFi 接入点，攻击者可以完全控制用户的网络连接，这将使得攻击者可以嗅探和篡改用户通过无线连接进行发送和接收的数据包，将用户的连接重定向到一个恶意的网站，并通过网络发起其他的攻击。
+越来越多的设备通过无线传输的方式连接到互联网，以及，大范围可用的 WiFi 接入点为攻击者攻击用户提供了很多机会。通过欺骗用户连接到[虚假的 WiFi 接入点][1]，攻击者可以完全控制用户的网络连接，这将使得攻击者可以嗅探和篡改用户的数据包，将用户的连接重定向到一个恶意的网站，并通过网络发起其他的攻击。
 
 为了保护用户并告诉他们如何避免线上的危险操作，安全审计人员和安全研究员必须评估用户的安全实践能力，用户常常在没有确认该 WiFi 接入点为安全的情况下就连接上了该网络，安全审计人员和研究员需要去了解这背后的原因。有很多工具都可以对 WiFi 的安全性进行审计，但是没有一款工具可以测试大量不同的攻击场景，也没有能和其他工具集成得很好的工具。
 
-Evil-Twin Framework（ETF）用于在 WiFi 审计过程中解决这些问题。审计者能够使用 ETF 来集成多种工具并测试该 WiFi 在不同场景下的安全性。本文会介绍 ETF 的框架和功能，然后会提供一些案例来说明该如何使用这款工具。
+Evil-Twin Framework（ETF）用于解决 WiFi 审计过程中的这些问题。审计者能够使用 ETF 来集成多种工具并测试该 WiFi 在不同场景下的安全性。本文会介绍 ETF 的框架和功能，然后会提供一些案例来说明该如何使用这款工具。
 
 ### ETF 的架构
 
-ETF 的框架是用 python 写的，因为这门开发语言的代码读起来非常容易，也方便其他开发者向这个项目贡献代码。除此之外，很多 ETF 的库，比如 Scapy，都是为 python 开发的，很容易就能将它们用于 ETF。
+ETF 的框架是用 [Python][2] 写的，因为这门开发语言的代码非常易读，也方便其他开发者向这个项目贡献代码。除此之外，很多 ETF 的库，比如 [Scapy][3]，都是为 Python 开发的，很容易就能将它们用于 ETF。
 
-ETF 的架构（图1）分为不同的模块，模块之间相互作用。框架的设置都写在一个单独的配置文件里。用户可以通过 ConfigurationManager 类里的用户界面验证并修改这些配置。其他模块只能读取这些设置并根据这些设置进行运行。
+ETF 的架构（图 1）分为不同的彼此交互的模块。该框架的设置都写在一个单独的配置文件里。用户可以通过 `ConfigurationManager` 类里的用户界面来验证并修改这些配置。其他模块只能读取这些设置并根据这些设置进行运行。
 
 ![Evil-Twin Framework Architecture][5]
 
-图 1：Evil-Twin 的框架架构
+*图 1：Evil-Twin 的框架架构*
 
-ETF 支持多种用户界面来与框架交互，当前的默认界面是一个交互式控制台界面，类似于 Metasploit 那种。正在开发用于桌面/浏览器使用的图形用户界面（GUI）和命令行界面（CLI），移动端界面也是未来的一个备选项。用户可以使用交互式控制台界面来修改配置文件里的设置（最终会使用 GUI）。用户界面可以与框架里存在的每个模块进行交互。
+ETF 支持多种与框架交互的用户界面，当前的默认界面是一个交互式控制台界面，类似于 [Metasploit][6] 那种。正在开发用于桌面/浏览器使用的图形用户界面（GUI）和命令行界面（CLI），移动端界面也是未来的一个备选项。用户可以使用交互式控制台界面来修改配置文件里的设置（最终会使用 GUI）。用户界面可以与存在于这个框架里的每个模块进行交互。
 
-WiFi 模块（AirCommunicator）用于支持多种 WiFi 功能和攻击。该框架确定了 Wi-Fi 通信的三个基本支柱：数据包嗅探，自定义数据包注入和创建接入点。三个主要的 WiFi 通信模块是 AirScanner，AirInjector，和 AirHost，它们分别用于数据包嗅探，数据包注入，和接入点创建。这三个类包含在主 WiFi 模块 AirCommunicator 中，AirCommunicator 在启动这些服务之前会先读取这些服务的配置文件。使用这些核心功能的一个或多个就可以构造任意类型的 WiFi 攻击。
+WiFi 模块（AirCommunicator）用于支持多种 WiFi 功能和攻击类型。该框架确定了 Wi-Fi 通信的三个基本支柱：数据包嗅探、自定义数据包注入和创建接入点。三个主要的 WiFi 通信模块 AirScanner、AirInjector，和 AirHost，分别用于数据包嗅探、数据包注入，和接入点创建。这三个类被封装在主 WiFi 模块 AirCommunicator 中，AirCommunicator 在启动这些服务之前会先读取这些服务的配置文件。使用这些核心功能的一个或多个就可以构造任意类型的 WiFi 攻击。
 
-使用中间人（MITM）攻击，这是一种攻击 WiFi 客户端的常见手法。ETF 有一个叫做 ETFITM（Evil-Twin Framework-in-the-Middle）的集成模块，这个模块用于创建一个 web 代理，来拦截和修改经过的 HTTP/HTTPS 数据包。
+要使用中间人（MITM）攻击（这是一种攻击 WiFi 客户端的常见手法），ETF 有一个叫做 ETFITM（Evil-Twin Framework-in-the-Middle）的集成模块，这个模块用于创建一个 web 代理，来拦截和修改经过的 HTTP/HTTPS 数据包。
 
-许多其他的工具也可以使用 ETF 创建 MITM。通过它的可扩展性，ETF 能够支持它们，而不必单独地调用它们，你可以通过扩展 Spawner 类来将这些工具添加到框架里。这使得开发者和安全审计人员可以使用框架里预先配置好的参数字符来调用程序。
+许多其他的工具也可以利用 ETF 创建的 MITM。通过它的可扩展性，ETF 能够支持它们，而不必单独地调用它们，你可以通过扩展 Spawner 类来将这些工具添加到框架里。这使得开发者和安全审计人员可以使用框架里预先配置好的参数字符来调用程序。
 
-扩展 ETF 的另一种方法就是通过插件。有两类插件：WiFi 插件和 MITM 插件。MITM 插件是在 MITM 代理运行时可以执行的脚本。代理会将 HTTP（s）请求和响应传递给可以记录和处理它们的插件。WiFi 插件遵循一个更加复杂的执行流程，但仍然会给想参与开发并且使用自己插件的贡献者提供一个相对简单的 API。WiFi 插件还可以进一步地划分为三类，其中一类用于每个核心 WiFi 通信模块。
+扩展 ETF 的另一种方法就是通过插件。有两类插件：WiFi 插件和 MITM 插件。MITM 插件是在 MITM 代理运行时可以执行的脚本。代理会将 HTTP(s) 请求和响应传递给可以记录和处理它们的插件。WiFi 插件遵循一个更加复杂的执行流程，但仍然会给想参与开发并且使用自己插件的贡献者提供一个相对简单的 API。WiFi 插件还可以进一步地划分为三类，其中每个对应一个核心 WiFi 通信模块。
 
-每个核心模块都有一些事件能触发响应的插件的执行。举个栗子，AirScanner 有三个已定义的事件，可以对其进行编程。事件通常对应于服务开始运行之前的设置阶段，服务正在运行时的中间执行阶段，服务完成后的卸载或清理阶段。因为 python 允许多重继承，所以一个插件可以继承多个插件类。
+每个核心模块都有一些特定事件能触发响应的插件的执行。举个例子，AirScanner 有三个已定义的事件，可以对其响应进行编程处理。事件通常对应于服务开始运行之前的设置阶段、服务正在运行时的中间执行阶段、服务完成后的卸载或清理阶段。因为 Python 允许多重继承，所以一个插件可以继承多个插件类。
 
-图 1 是框架架构的摘要。指向远离 ConfigurationManager 的行意味着模块会从中读取信息，指向它的行意味着模块会编写/修改配置。
+上面的图 1 是框架架构的摘要。从 ConfigurationManager 指出的箭头意味着模块会从中读取信息，指向它的箭头意味着模块会写入/修改配置。
 
-### 使用 ETF 的实例
+### 使用 ETF 的例子
 
-ETF 可以通过多种方式对 WiFi 的网络安全或者终端用户的 WiFi 安全意识进行渗透测试。下面的例子描述了这个框架的一些手动测试的功能，例如接入点和客户端检测，对使用 WPA 和 WEP 类型协议的接入点进行攻击，和创建恶意的双接入点。
-
-这些例子是使用 ETF 设计的，WiFi 卡允许进行 WiFi 数据捕获。它们同样为 ETF 设置命令使用了下面这些缩写：
-
-  * **APS** access point SSID
-  * **APB** access point BSSID
-  * **APC** access point channel
-  * **CM** client MAC address
+ETF 可以通过多种方式对 WiFi 的网络安全或者终端用户的 WiFi 安全意识进行渗透测试。下面的例子描述了这个框架的一些渗透测试功能，例如接入点和客户端检测、对使用 WPA 和 WEP 类型协议的接入点进行攻击，和创建 evil twin 接入点。
 
+这些例子是使用 ETF 和允许进行 WiFi 数据捕获的 WiFi 卡设计的。它们也在 ETF 设置命令中使用了下面这些缩写：
 
+  * **APS** Access Point SSID
+  * **APB** Access Point BSSID
+  * **APC** Access Point Channel
+  * **CM** Client MAC address
 
 在实际的测试场景中，确保你使用了正确的信息来替换这些缩写。
 
 #### 在解除认证攻击后捕获 WPA 四次握手的数据包。
 
-这个场景（图 2）做了两个方面的考虑：解除认证攻击和捕获 WPA 四次握手数据包的可能性。这个场景从一个运行 WPA/WPA2 的接入点开始，这个接入点有一个已经连上的客户端设备（在本例中是一台智能手机）。目的是通过一般的解除认证攻击（译者注：类似于 DOS 攻击）来让客户端断开和 WiFi 的网络，然后在客户端尝试重连的时候捕获 WPA 的握手包。重连会在断开连接后马上手动完成。
+这个场景（图 2）做了两个方面的考虑：<ruby>解除认证攻击<rt>de-authentication attack</rt></ruby>和捕获 WPA 四次握手数据包的可能性。这个场景从一个启用了 WPA/WPA2 的接入点开始，这个接入点有一个已经连上的客户端设备（在本例中是一台智能手机）。目的是通过常规的解除认证攻击（LCTT 译注：类似于 DoS 攻击）来让客户端断开和 WiFi 的网络，然后在客户端尝试重连的时候捕获 WPA 的握手包。重连会在断开连接后马上手动完成。
 
 ![Scenario for capturing a WPA handshake after a de-authentication attack][8]
 
-图 2：在解除认证攻击后捕获 WPA 握手包的场景
+*图 2：在解除认证攻击后捕获 WPA 握手包的场景*
 
 在这个例子中需要考虑的是 ETF 的可靠性。目的是确认工具是否一直都能捕获 WPA 的握手数据包。每个工具都会用来多次复现这个场景，以此来检查它们在捕获 WPA 握手数据包时的可靠性。
 
@@ -71,14 +71,12 @@ ETF 可以通过多种方式对 WiFi 的网络安全或者终端用户的 WiFi
 
 ETF 启用了 AirScanner 模块并分析 IEEE 802.11 数据帧来发现 WPA 握手包。然后 AirInjecto 就可以使用解除认证攻击来强制客户端断开连接，以进行重连。必须在 ETF 上执行下面这些步骤才能完成上面的目标：
 
-  1. 进入 AirScanner 配置模式: **config airscanner**
-  2. 设置 AirScanner 不跳信道: **config airscanner**
-  3. 设置信道以嗅探经过 WiFi 接入点信道的数据（APC）: **set fixed_sniffing_channel = <APC>**
-  4. 使用 CredentialSniffer 插件来启动 AirScanner 模块: **start airscanner with credentialsniffer**
-  5. 从已嗅探的接入点列表中添加目标接入点的 BSSID（APS）: **add aps where ssid = <APS>**
-  6. 启用 AirInjector 模块，在默认情况下，它会启用解除认证攻击: **start airinjector**
-
-
+  1. 进入 AirScanner 配置模式：`config airscanner`
+  2. 设置 AirScanner 不跳信道：`config airscanner`
+  3. 设置信道以嗅探经过 WiFi 接入点信道的数据（APC）：`set fixed_sniffing_channel = <APC>`
+  4. 使用 CredentialSniffer 插件来启动 AirScanner 模块：`start airscanner with credentialsniffer`
+  5. 从已嗅探的接入点列表中添加目标接入点的 BSSID（APS）：`add aps where ssid = <APS>`
+  6. 启用 AirInjector 模块，在默认情况下，它会启用解除认证攻击：`start airinjector`
 
 这些简单的命令设置能让 ETF 在每次测试时执行成功且有效的解除认证攻击。ETF 也能在每次测试的时候捕获 WPA 的握手数据包。下面的代码能让我们看到 ETF 成功的执行情况。
 
@@ -120,26 +118,24 @@ ETF[etf/aircommunicator/airscanner]::> [+] Starting deauthentication attack
 
 #### 使用 ARP 重放攻击并破解 WEP 无线网络
 
-下面这个场景（图 3）将关注地址解析协议（ARP）重放攻击的效率和捕获包含初始化向量（IVs）的 WEP 数据包的速度。相同的网络可能需要破解不同数量的捕获的 IVs，所以这个场景的 IVs 上限是 50000。如果这个网络在首次测试期间，还未捕获到 50000IVs 就崩溃了，那么实际捕获到的 IVs 数量会成为这个网络在接下来的测试里的新的上限。我们使用 aircrack-ng 对数据包进行破解。
+下面这个场景（图 3）将关注[地址解析协议][9]（ARP）重放攻击的效率和捕获包含初始化向量（IVs）的 WEP 数据包的速度。相同的网络可能需要破解不同数量的捕获的 IVs，所以这个场景的 IVs 上限是 50000。如果这个网络在首次测试期间，还未捕获到 50000 IVs 就崩溃了，那么实际捕获到的 IVs 数量会成为这个网络在接下来的测试里的新的上限。我们使用 `aircrack-ng` 对数据包进行破解。
 
-测试场景从一个使用 WEP 协议进行加密的 WiFi 接入点和一台知道其密钥的离线客户端设备开始-为了测试密钥使用了 12345，但它可以是更长且更复杂的密钥。一旦客户端连接到了 WEP 接入点，它会发送一个 ARP 数据包；这是要捕获和重放的数据包。一旦被捕获的包含 IVs 的数据包数量达到了设置的上限，测试就结束了。
+测试场景从一个使用 WEP 协议进行加密的 WiFi 接入点和一台知道其密钥的离线客户端设备开始 —— 为了测试方便，密钥使用了 12345，但它可以是更长且更复杂的密钥。一旦客户端连接到了 WEP 接入点，它会发送一个不必要的 ARP 数据包；这是要捕获和重放的数据包。一旦被捕获的包含 IVs 的数据包数量达到了设置的上限，测试就结束了。
 
 ![Scenario for capturing a WPA handshake after a de-authentication attack][11]
 
-图 3：在进行解除认证攻击后捕获 WPA 握手包的场景
+*图 3：在进行解除认证攻击后捕获 WPA 握手包的场景*
 
-ETF 使用 Python 的 Scapy 库来进行包嗅探和包注入。为了最大限度地解决 Scapy 里的已知性能问题，ETF 微调了一些低级库，来大大加快包注入的速度。对于这个特定的场景，ETF 为了更有效率地嗅探，使用了 tcpdump 作为后台进程而不是 Scapy，Scapy 用于识别加密的 ARP 数据包。
+ETF 使用 Python 的 Scapy 库来进行包嗅探和包注入。为了最大限度地解决 Scapy 里的已知的性能问题，ETF 微调了一些低级库，来大大加快包注入的速度。对于这个特定的场景，ETF 为了更有效率地嗅探，使用了 `tcpdump` 作为后台进程而不是 Scapy，Scapy 用于识别加密的 ARP 数据包。
 
 这个场景需要在 ETF 上执行下面这些命令和操作：
 
-  1. 进入 AirScanner 设置模式: **config airscanner**
-  2. 设置 AirScanner 不跳信道: **set hop_channels = false**
-  3. 设置信道以嗅探经过接入点信道的数据（APC）: **set fixed_sniffing_channel = <APC>**
-  4. 进入 ARPReplayer 插件设置模式: **config arpreplayer**
-  5. 设置 WEP 网络目标接入点的 BSSID（APB）: **set target_ap_bssid <APB>**
-  6. 使用 ARPReplayer 插件启动 AirScanner 模块: **start airscanner with arpreplayer**
-
-
+  1. 进入 AirScanner 设置模式：`config airscanner`
+  2. 设置 AirScanner 不跳信道：`set hop_channels = false`
+  3. 设置信道以嗅探经过接入点信道的数据（APC）：`set fixed_sniffing_channel = <APC>`
+  4. 进入 ARPReplayer 插件设置模式：`config arpreplayer`
+  5. 设置 WEP 网络目标接入点的 BSSID（APB）：`set target_ap_bssid <APB>`
+  6. 使用 ARPReplayer 插件启动 AirScanner 模块：`start airscanner with arpreplayer`
 
 在执行完这些命令后，ETF 会正确地识别加密的 ARP 数据包，然后成功执行 ARP 重放攻击，以此破坏这个网络。
 
@@ -149,18 +145,16 @@ ETF 使用 Python 的 Scapy 库来进行包嗅探和包注入。为了最大限
 
 ![Scenario for capturing a WPA handshake after a de-authentication attack][13]
 
-图 4：在解除认证攻击后捕获 WPA 握手包数据。
+*图 4：在解除认证攻击后捕获 WPA 握手包数据。*
 
-使用 ETF，可以去设置 hostapd 配置文件，然后在后台启动该程序。Hostpad 支持在一张无线网卡上通过设置虚拟接口开启多个接入点，并且因为它支持所有类型的安全设置，因此可以设置完整的全能蜜罐。对于使用 WEP 和 WPA(2)-PSK 的网络，使用默认密码，和对于使用 WPA(2)-EAP 的网络，配置“全部接受”策略。
+使用 ETF，可以去设置 `hostapd` 配置文件，然后在后台启动该程序。`hostapd` 支持在一张无线网卡上通过设置虚拟接口开启多个接入点，并且因为它支持所有类型的安全设置，因此可以设置完整的全能蜜罐。对于使用 WEP 和 WPA(2)-PSK 的网络，使用默认密码，和对于使用 WPA(2)-EAP 的网络，配置“全部接受”策略。
 
 对于这个场景，必须在 ETF 上执行下面的命令和操作：
 
-  1. 进入 APLauncher 设置模式: **config aplauncher**
-  2. 设置目标接入点的 SSID(APS): **set ssid = <APS>**
-  3. 设置 APLauncher 为全部接收的蜜罐: **set catch_all_honeypot = true**
-  4. 启动 AirHost 模块: **start airhost**
-
-
+  1. 进入 APLauncher 设置模式：`config aplauncher`
+  2. 设置目标接入点的 SSID(APS)：`set ssid = <APS>`
+  3. 设置 APLauncher 为全部接收的蜜罐：`set catch_all_honeypot = true`
+  4. 启动 AirHost 模块：`start airhost`
 
 使用这些命令，ETF 可以启动一个包含所有类型安全配置的完整全能蜜罐。ETF 同样能自动启动 DHCP 和 DNS 服务器，从而让客户端能与互联网保持连接。ETF 提供了一个更好、更快、更完整的解决方案来创建全能蜜罐。下面的代码能够看到 ETF 的成功执行。
 
@@ -195,17 +189,17 @@ ETF[etf/aircommunicator/airhost/aplauncher]::> start airhost
 
 ### 结论和以后的工作
 
-这些场景使用常见和总所周知的攻击方式来帮助验证 ETF 测试 WIFI 网络和客户端的能力。这个结果同样证明了框架的架构能在平台现有功能的优势上开发新的攻击向量和功能。这会加快新的 WiFi 渗透测试工具的开发，因为很多的代码已经写好了。除此之外，将 WiFi 技术相关的东西都集成到一个单独的工具里，会使 WiFi 渗透测试更加简单高效。
+这些场景使用常见和众所周知的攻击方式来帮助验证 ETF 测试 WIFI 网络和客户端的能力。这个结果同样证明了该框架的架构能在平台现有功能的优势上开发新的攻击向量和功能。这会加快新的 WiFi 渗透测试工具的开发，因为很多的代码已经写好了。除此之外，将 WiFi 技术相关的东西都集成到一个单独的工具里，会使 WiFi 渗透测试更加简单高效。
 
-ETF 的目标不是取代现有的工具，而是为它们提供补充，并为安全审计人员在进行 WiFi 测试和提升用户安全意识时，提供一个更好的选择。
+ETF 的目标不是取代现有的工具，而是为它们提供补充，并为安全审计人员在进行 WiFi 渗透测试和提升用户安全意识时，提供一个更好的选择。
 
-ETF 是 GitHub 上的一个开源项目，欢迎社区为它的开发做出贡献。下面是一些您可以提供帮助的方法。
+ETF 是 [GitHub][14] 上的一个开源项目，欢迎社区为它的开发做出贡献。下面是一些您可以提供帮助的方法。
 
-当前 WiFi 手动测试的一个限制是无法在测试期间记录重要的事件。这使得报告已经识别到的漏洞更加困难且准确性更低。这个框架可以实现一个登陆器，每个类都可以来访问它并创建一个手动测试会话报告。
+当前 WiFi 渗透测试的一个限制是无法在测试期间记录重要的事件。这使得报告已经识别到的漏洞更加困难且准确性更低。这个框架可以实现一个记录器，每个类都可以来访问它并创建一个渗透测试会话报告。
 
-ETF 工具的功能涵盖了 WiFi 手动测试的方方面面。一方面，它让 WiFi 目标侦察，漏洞挖掘和攻击这些阶段变得更加容易。另一方面，它没有提供一个便于提交报告的功能。增加会话的概念和会话报告的功能，比如在一个会话期间记录重要的事件，会极大地增加这个工具对于真实手动测试场景的价值。
+ETF 工具的功能涵盖了 WiFi 渗透测试的方方面面。一方面，它让 WiFi 目标侦察、漏洞挖掘和攻击这些阶段变得更加容易。另一方面，它没有提供一个便于提交报告的功能。增加了会话的概念和会话报告的功能，比如在一个会话期间记录重要的事件，会极大地增加这个工具对于真实渗透测试场景的价值。
 
-另一个有价值的贡献是扩展框架来促进 WiFi 模糊测试。IEEE 802.11 协议非常的复杂，考虑到它在客户端和接入点两方面都会有多种实现方式。可以假设这些实现都包含 bug 甚至是安全漏洞。这些 bug 可以通过对 IEEE 802.11 协议的数据帧进行模糊测试来进行发现。因为 Scapy 允许自定义的数据包创建和数据包注入，可以通过它实现一个模糊测试器。
+另一个有价值的贡献是扩展该框架来促进 WiFi 模糊测试。IEEE 802.11 协议非常的复杂，考虑到它在客户端和接入点两方面都会有多种实现方式。可以假设这些实现都包含 bug 甚至是安全漏洞。这些 bug 可以通过对 IEEE 802.11 协议的数据帧进行模糊测试来进行发现。因为 Scapy 允许自定义的数据包创建和数据包注入，可以通过它实现一个模糊测试器。
 
 --------------------------------------------------------------------------------
 
@@ -214,7 +208,7 @@ via: https://opensource.com/article/19/1/evil-twin-framework
 作者：[André Esser][a]
 选题：[lujun9972][b]
 译者：[hopefully2333](https://github.com/hopefully2333)
-校对：[校对者ID](https://github.com/校对者ID)
+校对：[wxy](https://github.com/wxy)
 
 本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
 

published/201902/20190122 How To Copy A File-Folder From A Local System To Remote System In Linux.md

@@ -1,33 +1,35 @@
 [#]: collector: (lujun9972)
-[#]: translator: ( luming)
-[#]: reviewer: ( )
-[#]: publisher: ( )
-[#]: url: ( )
+[#]: translator: (luming)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10569-1.html)
 [#]: subject: (How To Copy A File/Folder From A Local System To Remote System In Linux?)
 [#]: via: (https://www.2daygeek.com/linux-scp-rsync-pscp-command-copy-files-folders-in-multiple-servers-using-shell-script/)
 [#]: author: (Prakash Subramanian https://www.2daygeek.com/author/prakash/)
 
-如何在 Linux 上拷贝文件/文件夹到远程系统？
+如何在 Linux 上复制文件/文件夹到远程系统？
 ======
 
-从一个服务器拷贝文件到另一个服务器，或是从本地到远程是 Linux 管理员的日常任务之一。
+从一个服务器复制文件到另一个服务器，或者从本地到远程复制是 Linux 管理员的日常任务之一。
+
+我觉得不会有人不同意，因为无论在哪里这都是你的日常操作之一。有很多办法都能处理这个任务，我们试着加以概括。你可以挑一个喜欢的方法。当然，看看其他命令也能在别的地方帮到你。
 
-如果有人说不，我不接受。因为无论去哪这都是你的日常操作之一。
-有很多办法都能解决，我们就试着加以概括。
-你可以挑一个喜欢的方法。当然，看看其他命令也能在别的地方帮到你。
 我已经在自己的环境下测试过所有的命令和脚本了，因此你可以直接用到日常工作当中。
-通常大家都倾向 `scp` ，因为它是文件拷贝的<ruby>原生命令<rt>native command</rt></ruby>之一。但本文所列出的其它命令也很好用，建议你尝试一下。
-文件拷贝可以轻易地用以下四种方法。
- **`SCP`**：`scp` 在网络上的两个主机之间拷贝文件，与 `ssh` 使用相同的认证方式，具有相同的安全性。
- **`RSYNC`**：`rsync`是一个即快速又出众的多功能文件拷贝工具。它能本地拷贝，通过远程 shell 在其它主机之间拷贝，或者远程 `rsync` <ruby>守护进程<rt>daemon</rt></ruby>。
-**`PSCP`**：`pscp` 是一个并行拷贝文件到多个主机上的程序。它提供了诸多特性，例如为 scp 配置免密传输，保存输出到 文件，统计时长。
-**`PRSYNC`**：`prsync` 也是一个并行拷贝文件到多个主机上的程序。它也提供了诸多特性，例如为 ssh 配置免密传输，保存输出到 文件，统计时长。
 
-### 方式1：如何在 Linux 上使用  scp 命令从本地系统向远程系统拷贝文件/文件夹？
+通常大家都倾向 `scp`，因为它是文件复制的<ruby>原生命令<rt>native command</rt></ruby>之一。但本文所列出的其它命令也很好用，建议你尝试一下。
 
-`scp` 命令可以让我们拷贝文件/文件夹到远程系统上。
+文件复制可以轻易地用以下四种方法。
 
-我会把 `output.txt` 文件从本地系统拷贝到 `2g.CentOS.com` 远程系统的 `/opt/backup` 文件夹下。
+- `scp`：在网络上的两个主机之间复制文件，它使用 `ssh` 做文件传输，并使用相同的认证方式，具有相同的安全性。
+- `rsync`：是一个既快速又出众的多功能文件复制工具。它能本地复制、通过远程 shell 在其它主机之间复制，或者与远程的 `rsync` <ruby>守护进程<rt>daemon</rt></ruby> 之间复制。
+- `pscp`：是一个并行复制文件到多个主机上的程序。它提供了诸多特性，例如为 `scp` 配置免密传输，保存输出到文件，以及超时控制。
+- `prsync`：也是一个并行复制文件到多个主机上的程序。它也提供了诸多特性，例如为 `ssh` 配置免密传输，保存输出到 文件，以及超时控制。
+
+### 方式 1：如何在 Linux 上使用 scp 命令从本地系统向远程系统复制文件/文件夹？
+
+`scp` 命令可以让我们从本地系统复制文件/文件夹到远程系统上。
+
+我会把 `output.txt` 文件从本地系统复制到 `2g.CentOS.com` 远程系统的 `/opt/backup` 文件夹下。
 
 ```
 # scp output.txt root@2g.CentOS.com:/opt/backup
@@ -35,7 +37,7 @@
 output.txt                                                                                              100% 2468     2.4KB/s   00:00
 ```
 
-拷贝两个文件 `output.txt` 和 `passwd-up.sh` 到远程系统 `2g.CentOs.com` 的 `/opt/backup` 文件夹下。
+从本地系统复制两个文件 `output.txt` 和 `passwd-up.sh` 到远程系统 `2g.CentOs.com` 的 `/opt/backup` 文件夹下。
 
 ```
 # scp output.txt passwd-up.sh root@2g.CentOS.com:/opt/backup
@@ -44,8 +46,9 @@ output.txt 100% 2468 2.4KB/s 00:00
 passwd-up.sh 100% 877 0.9KB/s 00:00
 ```
 
-拷贝 `shell-script` 文件夹到远程系统`2g.CentOs.com` 的  `/opt/back` 文件夹下。 
-这会连同`/opt/backup`文件夹下所有的文件一同拷贝进去。
+从本地系统复制 `shell-script` 文件夹到远程系统 `2g.CentOs.com` 的 `/opt/back` 文件夹下。 
+
+这会连同`shell-script` 文件夹下所有的文件一同复制到`/opt/back` 下。
 
 ```
 # scp -r /home/daygeek/2g/shell-script/ root@:/opt/backup/
@@ -57,29 +60,31 @@ passwd-up1.sh 100% 7 0.0KB/s 00:00
 server-list.txt 100% 23 0.0KB/s 00:00
 ```
 
-### 方式2：如何在 Linux 上使用 scp 命令和 Shell 脚本拷贝文件/文件夹到多个远程系统上？
+### 方式 2：如何在 Linux 上使用 scp 命令和 Shell 脚本复制文件/文件夹到多个远程系统上？
 
-如果你想拷贝同一个文件到多个远程服务器上，那就需要创建一个如下面那样的小 shell 脚本。
+如果你想复制同一个文件到多个远程服务器上，那就需要创建一个如下面那样的小 shell 脚本。
 
-并且，需要将服务器添加进 `server-list.txt` 文件。确保添加成功后，每个服务器之间应当空一行。
+并且，需要将服务器添加进 `server-list.txt` 文件。确保添加成功后，每个服务器应当单独一行。
 
 最终，你想要的脚本就像下面这样：
+
 ```
 # file-copy.sh
 
 #!/bin/sh
 for server in `more server-list.txt`
 do
- scp /home/daygeek/2g/shell-script/output.txt root@$server:/opt/backup
+  scp /home/daygeek/2g/shell-script/output.txt root@$server:/opt/backup
 done
 ```
 
 完成之后，给 `file-copy.sh` 文件设置可执行权限。
+
 ```
 # chmod +x file-copy.sh
 ```
 
-最后运行脚本完成拷贝。
+最后运行脚本完成复制。
 
 ```
 # ./file-copy.sh
@@ -88,7 +93,7 @@ output.txt 100% 2468 2.4KB/s 00:00
 output.txt 100% 2468 2.4KB/s 00:00
 ```
 
-使用下面的脚本可以拷贝多个文件到多个远程服务器上。
+使用下面的脚本可以复制多个文件到多个远程服务器上。
 
 ```
 # file-copy.sh
@@ -96,11 +101,12 @@ output.txt 100% 2468 2.4KB/s 00:00
 #!/bin/sh
 for server in `more server-list.txt`
 do
- scp /home/daygeek/2g/shell-script/output.txt passwd-up.sh root@$server:/opt/backup
+  scp /home/daygeek/2g/shell-script/output.txt passwd-up.sh root@$server:/opt/backup
 done
 ```
 
-下面结果显示所有的两个文件都拷贝到两个服务器上。
+下面结果显示所有的两个文件都复制到两个服务器上。
+
 ```
 # ./file-cp.sh
 
@@ -110,7 +116,7 @@ output.txt 100% 2468 2.4KB/s 00:00
 passwd-up.sh 100% 877 0.9KB/s 00:00
 ```
 
-使用下面的脚本递归地拷贝文件夹到多个远程服务器上。
+使用下面的脚本递归地复制文件夹到多个远程服务器上。
 
 ```
 # file-copy.sh
@@ -118,11 +124,12 @@ passwd-up.sh 100% 877 0.9KB/s 00:00
 #!/bin/sh
 for server in `more server-list.txt`
 do
- scp -r /home/daygeek/2g/shell-script/ root@$server:/opt/backup
+  scp -r /home/daygeek/2g/shell-script/ root@$server:/opt/backup
 done
 ```
 
-上面脚本的输出。
+上述脚本的输出。
+
 ```
 # ./file-cp.sh
 
@@ -139,11 +146,11 @@ passwd-up1.sh 100% 7 0.0KB/s 00:00
 server-list.txt 100% 23 0.0KB/s 00:00
 ```
 
-### 方式3：如何在 Linux 上使用 pscp 命令拷贝文件/文件夹到多个远程系统上？
+### 方式 3：如何在 Linux 上使用 pscp 命令复制文件/文件夹到多个远程系统上？
 
-`pscp` 命令可以直接让我们拷贝文件到多个远程服务器上。
+`pscp` 命令可以直接让我们复制文件到多个远程服务器上。
 
-使用下面的 `pscp` 命令拷贝单个文件到远程服务器。
+使用下面的 `pscp` 命令复制单个文件到远程服务器。
 
 ```
 # pscp.pssh -H 2g.CentOS.com /home/daygeek/2g/shell-script/output.txt /opt/backup
@@ -151,7 +158,7 @@ server-list.txt 100% 23 0.0KB/s 00:00
 [1] 18:46:11 [SUCCESS] 2g.CentOS.com
 ```
 
-使用下面的 `pscp` 命令拷贝多个文件到远程服务器。
+使用下面的 `pscp` 命令复制多个文件到远程服务器。
 
 ```
 # pscp.pssh -H 2g.CentOS.com /home/daygeek/2g/shell-script/output.txt ovh.sh /opt/backup
@@ -159,7 +166,7 @@ server-list.txt 100% 23 0.0KB/s 00:00
 [1] 18:47:48 [SUCCESS] 2g.CentOS.com
 ```
 
-递归地拷贝整个文件夹到远程服务器。
+使用下面的 `pscp` 命令递归地复制整个文件夹到远程服务器。
 
 ```
 # pscp.pssh -H 2g.CentOS.com -r /home/daygeek/2g/shell-script/ /opt/backup
@@ -167,7 +174,7 @@ server-list.txt 100% 23 0.0KB/s 00:00
 [1] 18:48:46 [SUCCESS] 2g.CentOS.com
 ```
 
-使用下面的命令拷贝单个文件到多个远程服务器。
+使用下面的 `pscp` 命令使用下面的命令复制单个文件到多个远程服务器。
 
 ```
 # pscp.pssh -h server-list.txt /home/daygeek/2g/shell-script/output.txt /opt/backup
@@ -176,7 +183,7 @@ server-list.txt 100% 23 0.0KB/s 00:00
 [2] 18:49:48 [SUCCESS] 2g.Debian.com
 ```
 
-使用下面的 `pscp` 命令拷贝多个文件到多个远程服务器。
+使用下面的 `pscp` 命令复制多个文件到多个远程服务器。
 
 ```
 # pscp.pssh -h server-list.txt /home/daygeek/2g/shell-script/output.txt passwd-up.sh /opt/backup
@@ -185,7 +192,7 @@ server-list.txt 100% 23 0.0KB/s 00:00
 [2] 18:50:30 [SUCCESS] 2g.CentOS.com
 ```
 
-使用下面的命令递归地拷贝文件夹到多个远程服务器。
+使用下面的命令递归地复制文件夹到多个远程服务器。
 
 ```
 # pscp.pssh -h server-list.txt -r /home/daygeek/2g/shell-script/ /opt/backup
@@ -194,14 +201,14 @@ server-list.txt 100% 23 0.0KB/s 00:00
 [2] 18:51:31 [SUCCESS] 2g.CentOS.com
 ```
 
-### 方式4：如何在 Linux 上使用 rsync 命令拷贝文件/文件夹到多个远程系统上？
+### 方式 4：如何在 Linux 上使用 rsync 命令复制文件/文件夹到多个远程系统上？
 
-`rsync`是一个即快速又出众的多功能文件拷贝工具。它能本地拷贝，通过远程 shell 在其它主机之间拷贝，或者远程 `rsync` <ruby>守护进程<rt>daemon</rt></ruby>。
+`rsync` 是一个即快速又出众的多功能文件复制工具。它能本地复制、通过远程 shell 在其它主机之间复制，或者在远程 `rsync` <ruby>守护进程<rt>daemon</rt></ruby> 之间复制。
 
-使用下面的 `rsync` 命令拷贝单个文件到远程服务器。
+使用下面的 `rsync` 命令复制单个文件到远程服务器。
 
 ```
-# rsync -avz /home/daygeek/2g/shell-script/output.txt root@:/opt/backup
+# rsync -avz /home/daygeek/2g/shell-script/output.txt root@2g.CentOS.com:/opt/backup
 
 sending incremental file list
 output.txt
@@ -210,7 +217,7 @@ sent 598 bytes received 31 bytes 1258.00 bytes/sec
 total size is 2468 speedup is 3.92
 ```
 
-使用下面的 `rsync` 命令拷贝多个文件到远程服务器。
+使用下面的 `rsync` 命令复制多个文件到远程服务器。
 
 ```
 # rsync -avz /home/daygeek/2g/shell-script/output.txt passwd-up.sh root@2g.CentOS.com:/opt/backup
@@ -223,7 +230,7 @@ sent 737 bytes received 50 bytes 1574.00 bytes/sec
 total size is 2537 speedup is 3.22
 ```
 
-使用下面的 `rsync` 命令通过 `ssh` 拷贝单个文件到远程服务器。
+使用下面的 `rsync` 命令通过 `ssh` 复制单个文件到远程服务器。
 
 ```
 # rsync -avzhe ssh /home/daygeek/2g/shell-script/output.txt root@2g.CentOS.com:/opt/backup
@@ -235,7 +242,7 @@ sent 598 bytes received 31 bytes 419.33 bytes/sec
 total size is 2.47K speedup is 3.92
 ```
 
-使用下面的 `rsync` 命令通过 `ssh` 递归地拷贝文件夹到远程服务器。这种方式只拷贝文件不包括文件夹。
+使用下面的 `rsync` 命令通过 `ssh` 递归地复制文件夹到远程服务器。这种方式只复制文件不包括文件夹。
 
 ```
 # rsync -avzhe ssh /home/daygeek/2g/shell-script/ root@2g.CentOS.com:/opt/backup
@@ -252,9 +259,9 @@ sent 3.85K bytes received 281 bytes 8.26K bytes/sec
 total size is 9.12K speedup is 2.21
 ```
 
-### 如何在 Linux 上使用 rsync 命令和 Shell 脚本拷贝文件/文件夹到多个远程系统上？
+### 方式 5：如何在 Linux 上使用 rsync 命令和 Shell 脚本复制文件/文件夹到多个远程系统上？
 
-如果你想拷贝同一个文件到多个远程服务器上，那也需要创建一个如下面那样的小 shell 脚本。
+如果你想复制同一个文件到多个远程服务器上，那也需要创建一个如下面那样的小 shell 脚本。
 
 ```
 # file-copy.sh
@@ -294,9 +301,9 @@ sent 3.86K bytes received 281 bytes 2.76K bytes/sec
 total size is 9.13K speedup is 2.21
 ```
 
-### 方式6：如何在 Linux 上使用  scp 命令和 Shell 脚本从本地系统向多个远程系统拷贝文件/文件夹？
+### 方式 6：如何在 Linux 上使用 scp 命令和 Shell 脚本从本地系统向多个远程系统复制文件/文件夹？
 
-在上面两个 shell 脚本中，我们需要事先指定好文件和文件夹的路径，这儿我做了些小修改，让脚本可以接收文件或文件夹的输入。当你每天需要多次执行拷贝时，这将会非常有用。
+在上面两个 shell 脚本中，我们需要事先指定好文件和文件夹的路径，这儿我做了些小修改，让脚本可以接收文件或文件夹作为输入参数。当你每天需要多次执行复制时，这将会非常有用。
 
 ```
 # file-copy.sh
@@ -317,11 +324,11 @@ output1.txt 100% 3558 3.5KB/s 00:00
 output1.txt 100% 3558 3.5KB/s 00:00
 ```
 
-### 方式7：如何在Linux 系统上用非标准端口拷贝文件/文件夹到远程系统？
+### 方式 7：如何在 Linux 系统上用非标准端口复制文件/文件夹到远程系统？
 
-如果你想使用非标准端口，使用下面的 shell 脚本拷贝文件或文件夹。
+如果你想使用非标准端口，使用下面的 shell 脚本复制文件或文件夹。
 
-如果你使用了<ruby>非标准<rt>Non-Standard</rt></ruby>端口，确保像下面 `SCP` 命令那样指定好了端口号。
+如果你使用了<ruby>非标准<rt>Non-Standard</rt></ruby>端口，确保像下面 `scp` 命令那样指定好了端口号。
 
 ```
 # file-copy-scp.sh
@@ -354,7 +361,7 @@ rsync -avzhe 'ssh -p 2222' $1 root@2g.CentOS.com$server:/opt/backup
 done
 ```
 
-运行脚本，输入文件名
+运行脚本，输入文件名。
 
 ```
 # ./file-copy-rsync.sh passwd-up.sh
@@ -370,6 +377,7 @@ passwd-up.sh
 sent 238 bytes received 35 bytes 26.00 bytes/sec
 total size is 159 speedup is 0.58
 ```
+
 --------------------------------------------------------------------------------
 
 via: https://www.2daygeek.com/linux-scp-rsync-pscp-command-copy-files-folders-in-multiple-servers-using-shell-script/
@@ -377,7 +385,7 @@ via: https://www.2daygeek.com/linux-scp-rsync-pscp-command-copy-files-folders-in
 作者：[Prakash Subramanian][a]
 选题：[lujun9972][b]
 译者：[LuuMing](https://github.com/LuuMing)
-校对：[校对者ID](https://github.com/校对者ID)
+校对：[wxy](https://github.com/wxy)
 
 本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
 

published/201902/20190129 Get started with gPodder, an open source podcast client.md

@@ -1,35 +1,36 @@
 [#]: collector: (lujun9972)
 [#]: translator: (geekpi)
-[#]: reviewer: ( )
-[#]: publisher: ( )
-[#]: url: ( )
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10567-1.html)
 [#]: subject: (Get started with gPodder, an open source podcast client)
 [#]: via: (https://opensource.com/article/19/1/productivity-tool-gpodder)
 [#]: author: (Kevin Sonney https://opensource.com/users/ksonney (Kevin Sonney))
 
-开始使用 gPodder，一个开源播客客户端
+开始使用 gPodder 吧，一个开源播客客户端
 ======
-使用 gPodder 将你的播客同步到你的设备上，gPodder 是我们开源工具系列中的第 17 个工具，它将在 2019 年提高你的工作效率。
+
+> 使用 gPodder 将你的播客同步到你的设备上，gPodder 是我们开源工具系列中的第 17 个工具，它将在 2019 年提高你的工作效率。
 
 ![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/podcast-record-microphone.png?itok=8yUDOywf)
 
-每年年初似乎都有疯狂的冲动，想方设法提高工作效率。新年的决议，开始一年的权利，当然，“与旧的，与新的”的态度都有助于实现这一目标。通常的一轮建议严重偏向封闭源和专有软件。它不一定是这样。
+每年年初似乎都有疯狂的冲动想提高工作效率。新年的决心，渴望开启新的一年，当然，“抛弃旧的，拥抱新的”的态度促成了这一切。通常这时的建议严重偏向闭源和专有软件，但事实上并不用这样。
 
 这是我挑选出的 19 个新的（或者对你而言新的）开源工具中的第 17 个工具来帮助你在 2019 年更有效率。
 
 ### gPodder
 
-我喜欢播客。哎呀，我非常喜欢他们，因此我录制了其中的三个（你可以在[我的个人资料][1]中找到它们的链接）。我从播客那里学到了很多东西，并在我工作时在后台播放它们。但是，在多台桌面和移动设备之间保持同步可能会带来一些挑战。
+我喜欢播客。哎呀，我非常喜欢它们，因此我录制了其中的三个（你可以在[我的个人资料][1]中找到它们的链接）。我从播客那里学到了很多东西，并在我工作时在后台播放它们。但是，如何在多台桌面和移动设备之间保持同步可能会有一些挑战。
 
-[gPodder][2] 是一个简单的跨平台播客下载器、播放器和同步工具。它支持 RSS feed、[FeedBurner][3]、[YouTube][4] 和 [SoundCloud][5]，它还有一个开源同步服务，你可以根据需要运行它。gPodder 不直接播放播客。相反, 它使用你选择的音频或视频播放器。
+[gPodder][2] 是一个简单的跨平台播客下载器、播放器和同步工具。它支持 RSS feed、[FeedBurner][3]、[YouTube][4] 和 [SoundCloud][5]，它还有一个开源的同步服务，你可以根据需要运行它。gPodder 不直接播放播客。相反，它会使用你选择的音频或视频播放器。
 
 ![](https://opensource.com/sites/default/files/uploads/gpodder-1.png)
 
-安装 gPodder 非常简单。安装程序适用于 Windows 和 MacOS，同时包可用于主要的 Linux 发行版。如果你的发行版中没有它，你可以直接从 Git 下载运行。通过 “Add Podcasts via URL” 菜单，你可以输入播客的 RSS 源 URL 或其他服务的“特殊” URL。gPodder 将获取节目列表并显示一个对话框，你可以在其中选择要下载的节目或在列表上标记旧节目。
+安装 gPodder 非常简单。安装程序适用于 Windows 和 MacOS，同时也有用于主要的 Linux 发行版的软件包。如果你的发行版中没有它，你可以直接从 Git 下载运行。通过 “Add Podcasts via URL” 菜单，你可以输入播客的 RSS 源 URL 或其他服务的 “特殊” URL。gPodder 将获取节目列表并显示一个对话框，你可以在其中选择要下载的节目或在列表上标记旧节目。
 
 ![](https://opensource.com/sites/default/files/uploads/gpodder-2.png)
 
-它一个更好的功能是，如果 URL 已经在你的剪贴板中，gPodder 会自动将它放入播放 URL 中，这样你就可以很容易地将新的播客添加到列表中。如果你已有播客 feed 的 OPML 文件，那么可以上传并导入它。还有一个发现选项，让你可搜索 [gPodder.net][6] 上的播客，这是由编写和维护 gPodder 的人员提供的免费和开源播客列表网站。
+它一个更好的功能是，如果 URL 已经在你的剪贴板中，gPodder 会自动将它放入播放 URL 中，这样你就可以很容易地将新的播客添加到列表中。如果你已有播客 feed 的 OPML 文件，那么可以上传并导入它。还有一个发现选项，让你可搜索 [gPodder.net][6] 上的播客，这是由编写和维护 gPodder 的人员提供的自由及开源的播客的列表网站。
 
 ![](https://opensource.com/sites/default/files/uploads/gpodder-3.png)
 
@@ -48,7 +49,7 @@ via: https://opensource.com/article/19/1/productivity-tool-gpodder
 作者：[Kevin Sonney][a]
 选题：[lujun9972][b]
 译者：[geekpi](https://github.com/geekpi)
-校对：[校对者ID](https://github.com/校对者ID)
+校对：[wxy](https://github.com/wxy)
 
 本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
 

published/201902/20190130 Olive is a new Open Source Video Editor Aiming to Take On Biggies Like Final Cut Pro.md

@@ -1,30 +1,32 @@
 [#]: collector: (lujun9972)
 [#]: translator: (geekpi)
-[#]: reviewer: ( )
-[#]: publisher: ( )
-[#]: url: ( )
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10577-1.html)
 [#]: subject: (Olive is a new Open Source Video Editor Aiming to Take On Biggies Like Final Cut Pro)
 [#]: via: (https://itsfoss.com/olive-video-editor)
 [#]: author: (Abhishek Prakash https://itsfoss.com/author/abhishek/)
 
-Olive 是一个新的开源视频编辑器，一款类似 Final Cut Pro 的工具
+Olive：一款以 Final Cut Pro 为目标的开源视频编辑器
 ======
 
-[Olive][1] 是一个正在开发的新开源视频编辑器。这个非线性视频编辑器旨在提供高端专业视频编辑软件的免费替代品。目标高么？我认为是的。
+[Olive][1] 是一个正在开发的新的开源视频编辑器。这个非线性视频编辑器旨在提供高端专业视频编辑软件的免费替代品。目标高么？我认为是的。
 
 如果你读过我们的 [Linux 中的最佳视频编辑器][2]这篇文章，你可能已经注意到大多数“专业级”视频编辑器（如 [Lightworks][3] 或 DaVinciResolve）既不免费也不开源。
 
-[Kdenlive][4] 和 Shotcut 也出现在了文章中，但它通常无法达到专业视频编辑的标准（这是许多 Linux 用户说的）。
+[Kdenlive][4] 和 Shotcut 也是此类，但它通常无法达到专业视频编辑的标准（这是许多 Linux 用户说的）。
 
-爱好者和专业视频编辑之间的这种差距促使 Olive 的开发人员启动了这个项目。
+爱好者级和专业级的视频编辑之间的这种差距促使 Olive 的开发人员启动了这个项目。
 
-![Olive Video Editor][5]Olive Video Editor Interface
+![Olive Video Editor][5]
 
-Libre Graphics World 中有一篇详细的[关于 Olive 的评论][6]。实际上，这是我第一次知道 Olive 的地方。如果你有兴趣了解更多信息，请阅读该文章。
+*Olive 视频编辑器界面*
+
+Libre Graphics World 中有一篇详细的[关于 Olive 的点评][6]。实际上，这是我第一次知道 Olive 的地方。如果你有兴趣了解更多信息，请阅读该文章。
 
 ### 在 Linux 中安装 Olive 视频编辑器
 
-提醒你一下。Olive 正处于发展的早期阶段。你会发现很多 bug 和缺失/不完整的功能。你不应该把它当作你的主要视频编辑器。
+> 提醒你一下。Olive 正处于发展的早期阶段。你会发现很多 bug 和缺失/不完整的功能。你不应该把它当作你的主要视频编辑器。
 
 如果你想测试 Olive，有几种方法可以在 Linux 上安装它。
 
@@ -50,11 +52,13 @@ sudo snap install --edge olive-editor
 
 如果你的 [Linux 发行版支持 Flatpak][7]，你可以通过 Flatpak 安装 Olive 视频编辑器。
 
+- [Flatpak 地址](https://flathub.org/apps/details/org.olivevideoeditor.Olive)
+
 #### 通过 AppImage 使用 Olive
 
-不想安装吗？下载 [AppImage][8] 文件，将其设置为可执行文件并运行它。
+不想安装吗？下载 [AppImage][8] 文件，将其设置为可执行文件并运行它。32 位和 64 位 AppImage 文件都有。你应该下载相应的文件。
 
-32 位和 64 位 AppImage 文件都有。你应该下载相应的文件。
+- [下载 Olive 的 AppImage](https://github.com/olive-editor/olive/releases/tag/continuous)
 
 Olive 也可用于 Windows 和 macOS。你可以从它的[下载页面][9]获得它。
 
@@ -64,10 +68,16 @@ Olive 也可用于 Windows 和 macOS。你可以从它的[下载页面][9]获得
 
 如果你在测试 Olive 时发现一些 bug，请到它们的 GitHub 仓库中报告。
 
+- [提交 bug 报告以帮助 Olive](https://github.com/olive-editor/olive/issues)
+
 如果你是程序员，请浏览 Olive 的源代码，看看你是否可以通过编码技巧帮助项目。
 
+- [Olive 的 GitHub 仓库](https://github.com/olive-editor/olive)
+
 在经济上为项目做贡献是另一种可以帮助开发开源软件的方法。你可以通过成为赞助人来支持 Olive。
 
+- [赞助 Olive](https://www.patreon.com/olivevideoeditor)
+
 如果你没有支持 Olive 的金钱或编码技能，你仍然可以帮助它。在社交媒体或你经常访问的 Linux/软件相关论坛和群组中分享这篇文章或 Olive 的网站。一点微小的口碑都能间接地帮助它。
 
 ### 你如何看待 Olive？
@@ -83,7 +93,7 @@ via: https://itsfoss.com/olive-video-editor
 作者：[Abhishek Prakash][a]
 选题：[lujun9972][b]
 译者：[geekpi](https://github.com/geekpi)
-校对：[校对者ID](https://github.com/校对者ID)
+校对：[wxy](https://github.com/wxy)
 
 本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
 

published/201902/20190207 How to determine how much memory is installed, used on Linux systems.md

@@ -1,39 +1,42 @@
 [#]: collector: (lujun9972)
 [#]: translator: (leommxj)
-[#]: reviewer: ( )
-[#]: publisher: ( )
-[#]: url: ( )
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10571-1.html)
 [#]: subject: (How to determine how much memory is installed, used on Linux systems)
 [#]: via: (https://www.networkworld.com/article/3336174/linux/how-much-memory-is-installed-and-being-used-on-your-linux-systems.html)
 [#]: author: (Sandra Henry-Stocker https://www.networkworld.com/author/Sandra-Henry_Stocker/)
 
-如何在Linux系统中判断安装、使用了多少内存
+如何在 Linux 系统中判断安装、使用了多少内存
 ======
+
+> 有几个命令可以报告在 Linux 系统上安装和使用了多少内存。根据你使用的命令，你可能会被细节淹没，也可能获得快速简单的答案。
+
 ![](https://images.idgesg.net/images/article/2019/02/memory-100787327-large.jpg)
 
-在Linux系统中有很多种方法获取有关安装了多少内存的信息及查看多少内存正在被使用。有些命令提供了大量的细节，而其他命令提供了简洁但不一定易于理解的答案。在这篇文章中，我们将介绍一些查看内存及其使用状态的有用的工具。
+在 Linux 系统中有很多种方法获取有关安装了多少内存的信息及查看多少内存正在被使用。有些命令提供了大量的细节，而其他命令提供了简洁但不一定易于理解的答案。在这篇文章中，我们将介绍一些查看内存及其使用状态的有用的工具。
 
-在我们开始之前，让我们先来回顾一些基础知识。物理内存和虚拟内存并不是一回事。后者包括配置为 swap 的磁盘空间。Swap 空间可能包括为此目的特意留出来的分区，以及在创建新的 swap 分区不可行时创建的用来增加可用 swap 空间的文件。有些Linux命令提供关于两者的信息。
+在我们开始之前，让我们先来回顾一些基础知识。物理内存和虚拟内存并不是一回事。后者包括配置为交换空间的磁盘空间。交换空间可能包括为此目的特意留出来的分区，以及在创建新的交换分区不可行时创建的用来增加可用交换空间的文件。有些 Linux 命令会提供关于两者的信息。
 
-Swap 通过提供当物理内存占满时可以用来存放内存中非活动页的磁盘空间来扩展内存。
+当物理内存占满时，交换空间通过提供可以用来存放内存中非活动页的磁盘空间来扩展内存。
 
-**/proc/kcore** 是在内存管理中起作用的一个文件。这个文件看上去是个普通文件（虽然非常大），但它并不占用任何空间。它就像其他 /proc 下的文件一样是个虚拟文件。
+`/proc/kcore` 是在内存管理中起作用的一个文件。这个文件看上去是个普通文件（虽然非常大），但它并不占用任何空间。它就像其他 `/proc` 下的文件一样是个虚拟文件。
 
 ```
 $ ls -l /proc/kcore
 -r--------. 1 root root 140737477881856 Jan 28 12:59 /proc/kcore
 ```
 
-有趣的是，下面查询的两个系统并没有安装相同大小的内存，但 /proc/kcore 的大小却是相同的。第一个系统安装了 4 GB 的内存，而第二个系统安装了 6 GB。
+有趣的是，下面查询的两个系统并没有安装相同大小的内存，但 `/proc/kcore` 的大小却是相同的。第一个系统安装了 4 GB 的内存，而第二个系统安装了 6 GB。
 
 ```
 system1$ ls -l /proc/kcore
 -r--------. 1 root root 140737477881856 Jan 28 12:59 /proc/kcore
 system2$ ls -l /proc/kcore
--r-------- 1 root root 140737477881856 Feb 5 13:00 /proc/kcore
+-r--------  1 root root 140737477881856 Feb  5 13:00 /proc/kcore
 ```
 
-一种不靠谱的解释说这个文件代表可用虚拟内存的大小（没准要加 4 KB），如果这样，这些系统的虚拟内存可就是 128TB 了！这个数字似乎代表了64位系统可以寻址多少内存，而不是当前系统有多少可用内存。在命令行中计算 128 TB 和这个文件大小加上 4 KB 很容易。
+一种不靠谱的解释说这个文件代表可用虚拟内存的大小（没准要加 4 KB），如果这样，这些系统的虚拟内存可就是 128TB 了！这个数字似乎代表了 64 位系统可以寻址多少内存，而不是当前系统有多少可用内存。在命令行中计算 128 TB 和这个文件大小加上 4 KB 很容易。
 
 ```
 $ expr 1024 \* 1024 \* 1024 \* 1024 \* 128
@@ -42,7 +45,7 @@ $ expr 1024 \* 1024 \* 1024 \* 1024 \* 128 + 4096
 140737488359424
 ```
 
-另一个用来检查内存的更人性化的命令是 **free**。它会给出一个易于理解的内存报告。
+另一个用来检查内存的更人性化的命令是 `free`。它会给出一个易于理解的内存报告。
 
 ```
 $ free
@@ -51,7 +54,7 @@ Mem:        6102476      812244     4090752       13112     1199480     4984140
 Swap:       2097148           0     2097148
 ```
 
-使用 **-g** 选项，free会以 GB 为单位返回结果。
+使用 `-g` 选项，`free` 会以 GB 为单位返回结果。
 
 ```
 $ free -g
@@ -60,7 +63,7 @@ Mem:              5           0           3           0           1           4
 Swap:             1           0           1
 ```
 
-使用 **-t** 选项，free 会显示与无附加选项时相同的值（不要把 -t 选项与 TB 搞混），并额外在输出的底部添加一行总计数据。
+使用 `-t` 选项，`free` 会显示与无附加选项时相同的值（不要把 `-t` 选项理解成 TB），并额外在输出的底部添加一行总计数据。
 
 ```
 $ free -t
@@ -82,7 +85,7 @@ Total:            7           0           5
 
 如果你尝试用这个报告来解释“这个系统安装了多少内存？”，你可能会感到失望。上面的报告就是在前文说的装有 6 GB 内存的系统上运行的结果。这并不是说这个结果是错的，这就是系统对其可使用的内存的看法。
 
-free 命令也提供了每隔 X 秒刷新显示的选项（下方示例中 X 为 10）。
+`free` 命令也提供了每隔 X 秒刷新显示的选项（下方示例中 X 为 10）。
 
 ```
 $ free -s 10
@@ -95,7 +98,7 @@ Mem:        6102476      812260     4090712       13112     1199504     4984120
 Swap:       2097148           0     2097148
 ```
 
-使用 **-l** 选项，free命令会提供高低内存使用信息。
+使用 `-l` 选项，`free` 命令会提供高低内存使用信息。
 
 ```
 $ free -l
@@ -106,7 +109,7 @@ High:             0           0           0
 Swap:       2097148           0     2097148
 ```
 
-查看内存的另一个选择是 **/proc/meminfo** 文件。像 /proc/kcore 一样，这也是一个虚拟文件，它可以提供关于安装/使用了多少内存以及可用内存的报告。显然，空闲内存和可用内存并不是同一回事。MemFree 看起来代表未使用的 RAM。MemAvailable则是对于启动新程序时可使用的内存的一个估计。
+查看内存的另一个选择是 `/proc/meminfo` 文件。像 `/proc/kcore` 一样，这也是一个虚拟文件，它可以提供关于安装或使用了多少内存以及可用内存的报告。显然，空闲内存和可用内存并不是同一回事。`MemFree` 看起来代表未使用的 RAM。`MemAvailable` 则是对于启动新程序时可使用的内存的一个估计。
 
 ```
 $ head -3 /proc/meminfo
@@ -124,7 +127,7 @@ $ grep MemTotal /proc/meminfo
 MemTotal: 6102476 kB
 ```
 
-**DirectMap** 将内存信息分为几类。
+`DirectMap` 将内存信息分为几类。
 
 ```
 $ grep DirectMap /proc/meminfo
@@ -132,9 +135,9 @@ DirectMap4k: 213568 kB
 DirectMap2M: 6076416 kB
 ```
 
-DirectMap4k 代表被映射成标准 4 k 页的内存大小，DirectMap2M 则显示了被映射为 2 MB 的页的内存大小。
+`DirectMap4k` 代表被映射成标准 4 k 页的内存大小，`DirectMap2M` 则显示了被映射为 2 MB 的页的内存大小。
 
-**getconf** 命令将会提供比我们大多数人想要看到的更多的信息。
+`getconf` 命令将会提供比我们大多数人想要看到的更多的信息。
 
 ```
 $ getconf -a | more
@@ -174,9 +177,9 @@ $ getconf -a | grep PAGES | awk 'BEGIN {total = 1} {if (NR == 1 || NR == 3) tota
 上面的命令通过将下方输出的第一行和最后一行的值相乘来计算内存。
 
 ```
-PAGESIZE 4096 <==
-_AVPHYS_PAGES 1022511
-_PHYS_PAGES 1525619 <==
+PAGESIZE                           4096    <==
+_AVPHYS_PAGES                      1022511
+_PHYS_PAGES                        1525619 <==
 ```
 
 自己动手计算一下，我们就知道这个值是怎么来的了。
@@ -186,9 +189,9 @@ $ expr 4096 \* 1525619 / 1024
 6102476
 ```
 
-显然值得为以上的指令之一设置个 alias。 
+显然值得为以上的指令之一设置个 `alias`。 
 
-另一个具有非常易于理解的输出的命令是 **top** 。在 top 输出的前五行，你可以看到一些数字显示多少内存正被使用。 
+另一个具有非常易于理解的输出的命令是 `top` 。在 `top` 输出的前五行，你可以看到一些数字显示多少内存正被使用。 
 
 ```
 $ top
@@ -206,9 +209,7 @@ $ sudo dmidecode -t 17 | grep "Size.*MB" | awk '{s+=$2} END {print s / 1024 "GB"
 6GB
 ```
 
-取决于你想要获取多少细节，Linux系统提供了许多用来查看系统安装内存以及使用/空闲内存的选择。
-
-在 [Facebook][1] 或 [LinkedIn][2] 上加入 Network World 社区，评论最重要的话题。
+取决于你想要获取多少细节，Linux 系统提供了许多用来查看系统安装内存以及使用/空闲内存的选择。
 
 --------------------------------------------------------------------------------
 
@@ -217,7 +218,7 @@ via: https://www.networkworld.com/article/3336174/linux/how-much-memory-is-insta
 作者：[Sandra Henry-Stocker][a]
 选题：[lujun9972][b]
 译者：[leommxj](https://github.com/leommxj)
-校对：[校对者ID](https://github.com/校对者ID)
+校对：[wxy](https://github.com/wxy)
 
 本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
 

published/201902/20190216 How To Grant And Remove Sudo Privileges To Users On Ubuntu.md

@@ -0,0 +1,103 @@
+[#]: collector: (lujun9972)
+[#]: translator: (geekpi)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10576-1.html)
+[#]: subject: (How To Grant And Remove Sudo Privileges To Users On Ubuntu)
+[#]: via: (https://www.ostechnix.com/how-to-grant-and-remove-sudo-privileges-to-users-on-ubuntu/)
+[#]: author: (SK https://www.ostechnix.com/author/sk/)
+
+如何在 Ubuntu 上为用户授予和移除 sudo 权限
+======
+
+![](https://www.ostechnix.com/wp-content/uploads/2019/02/sudo-privileges-720x340.png)
+
+如你所知，用户可以在 Ubuntu 系统上使用 sudo 权限执行任何管理任务。在 Linux 机器上创建新用户时，他们无法执行任何管理任务，直到你将其加入 `sudo` 组的成员。在这个简短的教程中，我们将介绍如何将普通用户添加到 `sudo` 组以及移除给定的权限，使其成为普通用户。
+
+### 在 Linux 上向普通用户授予 sudo 权限
+
+通常，我们使用 `adduser` 命令创建新用户，如下所示。
+
+```
+$ sudo adduser ostechnix
+```
+
+如果你希望新创建的用户使用 `sudo` 执行管理任务，只需使用以下命令将它添加到 `sudo` 组：
+
+```
+$ sudo usermod -a -G sudo hduser
+```
+
+上面的命令将使名为 `ostechnix` 的用户成为 `sudo` 组的成员。
+
+你也可以使用此命令将用户添加到 `sudo` 组。
+
+```
+$ sudo adduser ostechnix sudo
+```
+
+现在，注销并以新用户身份登录，以使此更改生效。此时用户已成为管理用户。
+
+要验证它，只需在任何命令中使用 `sudo` 作为前缀。
+
+```
+$ sudo mkdir /test
+[sudo] password for ostechnix:
+```
+
+### 移除用户的 sudo 权限
+
+有时，你可能希望移除特定用户的 `sudo` 权限，而不用在 Linux 中删除它。要将任何用户设为普通用户，只需将其从 `sudo` 组中删除即可。
+
+比如说如果要从 `sudo` 组中删除名为 `ostechnix` 的用户，只需运行：
+
+```
+$ sudo deluser ostechnix sudo
+```
+
+示例输出：
+
+```
+Removing user `ostechnix' from group `sudo' ...
+Done.
+```
+
+此命令仅从 `sudo` 组中删除用户 `ostechnix`，但不会永久地从系统中删除用户。现在，它成为了普通用户，无法像 `sudo` 用户那样执行任何管理任务。
+
+此外，你可以使用以下命令撤消用户的 `sudo` 访问权限：
+
+```
+$ sudo gpasswd -d ostechnix sudo
+```
+
+从 `sudo` 组中删除用户时请小心。不要从 `sudo` 组中删除真正的管理员。
+
+使用命令验证用户 `ostechnix` 是否已从 `sudo` 组中删除：
+
+```
+$ sudo -l -U ostechnix
+User ostechnix is not allowed to run sudo on ubuntuserver.
+```
+
+是的，用户 `ostechnix` 已从 `sudo` 组中删除，他无法执行任何管理任务。
+
+从 `sudo` 组中删除用户时请小心。如果你的系统上只有一个 `sudo` 用户，并且你将他从 `sudo` 组中删除了，那么就无法执行任何管理操作，例如在系统上安装、删除和更新程序。所以，请小心。在我们的下一篇教程中，我们将解释如何恢复用户的 `sudo` 权限。
+
+就是这些了。希望这篇文章有用。还有更多好东西。敬请期待！
+
+干杯!
+
+
+--------------------------------------------------------------------------------
+
+via: https://www.ostechnix.com/how-to-grant-and-remove-sudo-privileges-to-users-on-ubuntu/
+
+作者：[SK][a]
+选题：[lujun9972][b]
+译者：[geekpi](https://github.com/geekpi)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://www.ostechnix.com/author/sk/
+[b]: https://github.com/lujun9972

published/201902/20190219 3 tools for viewing files at the command line.md

@@ -0,0 +1,99 @@
+[#]: collector: (lujun9972)
+[#]: translator: (MjSeven)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10573-1.html)
+[#]: subject: (3 tools for viewing files at the command line)
+[#]: via: (https://opensource.com/article/19/2/view-files-command-line)
+[#]: author: (Scott Nesbitt https://opensource.com/users/scottnesbitt)
+
+在命令行查看文件的 3 个工具
+======
+
+> 看一下 `less`、Antiword 和 `odt2xt` 这三个实用程序，它们都可以在终端中查看文件。
+
+![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/command_line_prompt.png?itok=wbGiJ_yg)
+
+我常说，你不需要使用命令行也可以高效使用 Linux —— 我知道许多 Linux 用户从不打开终端窗口，并且也用的挺好。然而，即使我不认为自己是一名技术人员，我也会在命令行上花费大约 20% 的计算时间，包括操作文件、处理文本和使用实用程序。
+
+我经常在终端窗口中做的一件事是查看文件，无论是文本还是需要用到文字处理器的文件。有时使用命令行实用程序比启动文本编辑器或文字处理器更容易。
+
+下面是我在命令行中用来查看文件的三个实用程序。
+
+### less
+
+[less][1] 的美妙之处在于它易于使用，它将你正在查看的文件分解为块（或页面），这使得它们更易于阅读。你可以使用它在命令行查看文本文件，例如 README、HTML 文件、LaTeX 文件或其他任何纯文本文件。我在[上一篇文章][2]中介绍了 `less`。
+
+要使用 `less`，只需输入：
+
+```
+less file_name
+```
+
+![](https://opensource.com/sites/default/files/uploads/less.png)
+
+通过按键盘上的空格键或 `PgDn` 键向下滚动文件，按 `PgUp` 键向上移动文件。要停止查看文件，按键盘上的 `Q` 键。
+
+### Antiword
+
+[Antiword][3] 是一个很好地实用小程序，你可以使用它将 Word 文档转换为纯文本。只要你想，还可以将它们转换为 [PostScript][4] 或 [PDF][5]。在本文中，让我们继续使用文本转换。
+
+Antiword 可以读取和转换 Word 2.0 到 2003 版本创建的文件（LCTT 译注：此处疑为 Word 2000，因为 Word 2.0 for DOS 发布于 1984 年，而 WinWord 2.0 发布于 1991 年，都似乎太老了）。它不能读取 DOCX 文件 —— 如果你尝试这样做，Antiword 会显示一条错误消息，表明你尝试读取的是一个 ZIP 文件。这在技术上说是正确的，但仍然令人沮丧。
+
+要使用 Antiword 查看 Word 文档，输入以下命令：
+
+```
+antiword file_name.doc
+```
+
+Antiword 将文档转换为文本并显示在终端窗口中。不幸的是，它不能在终端中将文档分解成页面。不过，你可以将 Antiword 的输出重定向到 `less` 或 [more][6] 之类的实用程序，一遍对其进行分页。通过输入以下命令来执行此操作：
+
+```
+antiword file_name.doc | less
+```
+
+如果你是命令行的新手，那么我告诉你 `|` 称为管道。这就是重定向。
+
+![](https://opensource.com/sites/default/files/uploads/antiword.png)
+
+### odt2txt
+
+作为一个优秀的开源公民，你会希望尽可能多地使用开放格式。对于你的文字处理需求，你可能需要处理 [ODT][7] 文件（由诸如 LibreOffice Writer 和 AbiWord 等文字处理器使用）而不是 Word 文件。即使没有，也可能会遇到 ODT 文件。而且，即使你的计算机上没有安装 Writer 或 AbiWord，也很容易在命令行中查看它们。
+
+怎样做呢？用一个名叫 [odt2txt][8] 的实用小程序。正如你猜到的那样，`odt2txt` 将 ODT 文件转换为纯文本。要使用它，运行以下命令：
+
+```
+odt2txt file_name.odt
+```
+
+与 Antiword 一样，`odt2txt` 将文档转换为文本并在终端窗口中显示。和 Antiword 一样，它不会对文档进行分页。但是，你也可以使用以下命令将 `odt2txt` 的输出管道传输到 `less` 或 `more` 这样的实用程序中：
+
+```
+odt2txt file_name.odt | more
+```
+
+![](https://opensource.com/sites/default/files/uploads/odt2txt.png)
+
+你有一个最喜欢的在命令行中查看文件的实用程序吗？欢迎留下评论与社区分享。
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/19/2/view-files-command-line
+
+作者：[Scott Nesbitt][a]
+选题：[lujun9972][b]
+译者：[MjSeven](https://github.com/MjSeven)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/scottnesbitt
+[b]: https://github.com/lujun9972
+[1]: https://www.gnu.org/software/less/
+[2]: https://opensource.com/article/18/4/using-less-view-text-files-command-line
+[3]: http://www.winfield.demon.nl/
+[4]: http://en.wikipedia.org/wiki/PostScript
+[5]: http://en.wikipedia.org/wiki/Portable_Document_Format
+[6]: https://opensource.com/article/19/1/more-text-files-linux
+[7]: http://en.wikipedia.org/wiki/OpenDocument
+[8]: https://github.com/dstosberg/odt2txt

published/20190206 And, Ampersand, and - in Linux.md

@@ -0,0 +1,196 @@
+[#]: collector: (lujun9972)
+[#]: translator: (HankChow)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10587-1.html)
+[#]: subject: (And, Ampersand, and & in Linux)
+[#]: via: (https://www.linux.com/blog/learn/2019/2/and-ampersand-and-linux)
+[#]: author: (Paul Brown https://www.linux.com/users/bro66)
+
+Linux 中的 &
+======
+
+> 这篇文章将了解一下 & 符号及它在 Linux 命令行中的各种用法。
+
+![](https://www.linux.com/sites/lcom/files/styles/rendered_file/public/ampersand.png?itok=7GdFO36Y)
+
+如果阅读过我之前的三篇文章（[1][1]、[2][2]、[3][3]），你会觉得掌握连接各个命令之间的连接符号用法也是很重要的。实际上，命令的用法并不难，例如 `mkdir`、`touch` 和 `find` 也分别可以简单概括为“建立新目录”、“更新文件”和“在目录树中查找文件”而已。
+
+但如果要理解
+
+```
+mkdir test_dir 2>/dev/null || touch images.txt && find . -iname "*jpg" > backup/dir/images.txt &
+```
+
+这一串命令的目的，以及为什么要这样写，就没有这么简单了。
+
+关键之处就在于命令之间的连接符号。掌握了这些符号的用法，不仅可以让你更好理解整体的工作原理，还可以让你知道如何将不同的命令有效地结合起来，提高工作效率。
+
+在这一篇文章和接下来的文章中，我会介绍如何使用 `&` 号和管道符号（`|`）在不同场景下的使用方法。
+
+### 幕后工作
+
+我来举一个简单的例子，看看如何使用 `&` 号将下面这个命令放到后台运行：
+
+```
+cp -R original/dir/ backup/dir/
+```
+
+这个命令的目的是将 `original/dir/` 的内容递归地复制到 `backup/dir/` 中。虽然看起来很简单，但是如果原目录里面的文件太大，在执行过程中终端就会一直被卡住。
+
+所以，可以在命令的末尾加上一个 `&` 号，将这个任务放到后台去执行：
+
+```
+cp -R original/dir/ backup/dir/ &
+```
+
+任务被放到后台执行之后，就可以立即继续在同一个终端上工作了，甚至关闭终端也不影响这个任务的正常执行。需要注意的是，如果要求这个任务输出内容到标准输出中（例如 `echo` 或 `ls`），即使使用了 `&`，也会等待这些输出任务在前台运行完毕。
+
+当使用 `&` 将一个进程放置到后台运行的时候，Bash 会提示这个进程的进程 ID。在 Linux 系统中运行的每一个进程都有一个唯一的进程 ID，你可以使用进程 ID 来暂停、恢复或者终止对应的进程，因此进程 ID 是非常重要的。
+
+这个时候，只要你还停留在启动进程的终端当中，就可以使用以下几个命令来对管理后台进程：
+
+  * `jobs` 命令可以显示当前终端正在运行的进程，包括前台运行和后台运行的进程。它对每个正在执行中的进程任务分配了一个序号（这个序号不是进程 ID），可以使用这些序号来引用各个进程任务。
+
+    ```
+ $ jobs
+[1]- Running cp -i -R original/dir/* backup/dir/ &
+[2]+ Running find . -iname "*jpg" > backup/dir/images.txt &
+```
+  * `fg` 命令可以将后台运行的进程任务放到前台运行，这样可以比较方便地进行交互。根据 `jobs` 命令提供的进程任务序号，再在前面加上 `%` 符号，就可以把相应的进程任务放到前台运行。
+
+    ```
+ $ fg %1 # 将上面序号为 1 的 cp 任务放到前台运行
+cp -i -R original/dir/* backup/dir/
+```
+    如果这个进程任务是暂停状态，`fg` 命令会将它启动起来。
+  * 使用 `ctrl+z` 组合键可以将前台运行的任务暂停，仅仅是暂停，而不是将任务终止。当使用 `fg` 或者 `bg` 命令将任务重新启动起来的时候，任务会从被暂停的位置开始执行。但 [sleep][4] 命令是一个特例，`sleep` 任务被暂停的时间会计算在 `sleep` 时间之内。因为 `sleep` 命令依据的是系统时钟的时间，而不是实际运行的时间。也就是说，如果运行了 `sleep 30`，然后将任务暂停 30 秒以上，那么任务恢复执行的时候会立即终止并退出。
+  * `bg` 命令会将任务放置到后台执行，如果任务是暂停状态，也会被启动起来。
+
+    ```
+ $ bg %1
+[1]+ cp -i -R original/dir/* backup/dir/ &
+```
+
+如上所述，以上几个命令只能在同一个终端里才能使用。如果启动进程任务的终端被关闭了，或者切换到了另一个终端，以上几个命令就无法使用了。
+
+如果要在另一个终端管理后台进程，就需要其它工具了。例如可以使用 [kill][5] 命令从另一个终端终止某个进程：
+
+```
+kill -s STOP <PID>
+```
+
+这里的 PID 就是使用 `&` 将进程放到后台时 Bash 显示的那个进程 ID。如果你当时没有把进程 ID 记录下来，也可以使用 `ps` 命令（代表 process）来获取所有正在运行的进程的进程 ID，就像这样：
+
+```
+ps | grep cp
+```
+
+执行以后会显示出包含 `cp` 字符串的所有进程，例如上面例子中的 `cp` 进程。同时还会显示出对应的进程 ID：
+
+```
+$ ps | grep cp
+14444 pts/3 00:00:13 cp
+```
+
+在这个例子中，进程 ID 是 14444，因此可以使用以下命令来暂停这个后台进程：
+
+```
+kill -s STOP 14444
+```
+
+注意，这里的 `STOP` 等同于前面提到的 `ctrl+z` 组合键的效果，也就是仅仅把进程暂停掉。
+
+如果想要把暂停了的进程启动起来，可以对进程发出 `CONT` 信号：
+
+```
+kill -s CONT 14444
+```
+
+这个给出一个[可以向进程发出的常用信号][6]列表。如果想要终止一个进程，可以发送 `TERM` 信号：
+
+```
+kill -s TERM 14444
+```
+
+如果进程不响应 `TERM` 信号并拒绝退出，还可以发送 `KILL` 信号强制终止进程：
+
+```
+kill -s KILL 14444
+```
+
+强制终止进程可能会有一定的风险，但如果遇到进程无节制消耗资源的情况，这样的信号还是能够派上用场的。
+
+另外，如果你不确定进程 ID 是否正确，可以在 `ps` 命令中加上 `x` 参数：
+
+```
+$ ps x| grep cp
+14444 pts/3 D 0:14 cp -i -R original/dir/Hols_2014.mp4
+  original/dir/Hols_2015.mp4 original/dir/Hols_2016.mp4
+  original/dir/Hols_2017.mp4 original/dir/Hols_2018.mp4 backup/dir/
+```
+
+这样就可以看到是不是你需要的进程 ID 了。
+
+最后介绍一个将 `ps` 和 `grep` 结合到一起的命令：
+
+```
+$ pgrep cp
+8
+18
+19
+26
+33
+40
+47
+54
+61
+72
+88
+96
+136
+339
+6680
+13735
+14444
+```
+
+`pgrep` 可以直接将带有字符串 `cp` 的进程的进程 ID 显示出来。
+
+可以加上一些参数让它的输出更清晰：
+
+```
+$ pgrep -lx cp
+14444 cp
+```
+
+在这里，`-l` 参数会让 `pgrep` 将进程的名称显示出来，`-x` 参数则是让 `pgrep` 完全匹配 `cp` 这个命令。如果还想了解这个命令的更多细节，可以尝试运行 `pgrep -ax`。
+
+### 总结
+
+在命令的末尾加上 `&` 可以让我们理解前台进程和后台进程的概念，以及如何管理这些进程。
+
+在 UNIX/Linux 术语中，在后台运行的进程被称为<ruby>守护进程<rt>daemon</rt></ruby>。如果你曾经听说过这个词，那你现在应该知道它的意义了。
+
+和其它符号一样，`&` 在命令行中还有很多别的用法。在下一篇文章中，我会更详细地介绍。
+
+--------------------------------------------------------------------------------
+
+via: https://www.linux.com/blog/learn/2019/2/and-ampersand-and-linux
+
+作者：[Paul Brown][a]
+选题：[lujun9972][b]
+译者：[HankChow](https://github.com/HankChow)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://www.linux.com/users/bro66
+[b]: https://github.com/lujun9972
+[1]: https://linux.cn/article-10465-1.html
+[2]: https://linux.cn/article-10502-1.html
+[3]: https://linux.cn/article-10529-1.html
+[4]: https://ss64.com/bash/sleep.html
+[5]: https://bash.cyberciti.biz/guide/Sending_signal_to_Processes
+[6]: https://www.computerhope.com/unix/signals.htm
+

published/20190206 Getting started with Vim visual mode.md

@@ -0,0 +1,120 @@
+[#]: collector: (lujun9972)
+[#]: translator: (MjSeven)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10589-1.html)
+[#]: subject: (Getting started with Vim visual mode)
+[#]: via: (https://opensource.com/article/19/2/getting-started-vim-visual-mode)
+[#]: author: (Susan Lauber https://opensource.com/users/susanlauber)
+
+Vim 可视化模式入门
+======
+
+> 可视化模式使得在 Vim 中高亮显示和操作文本变得更加容易。
+
+![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/programming_code_keyboard_orange_hands.png?itok=G6tJ_64Y)
+
+Ansible 剧本文件是 YAML 格式的文本文件，经常与它们打交道的人通过他们偏爱的编辑器和扩展插件以使格式化更容易。
+
+当我使用大多数 Linux 发行版中提供的默认编辑器来教学 Ansible 时，我经常使用 Vim 的可视化模式。它可以让我在屏幕上高亮显示我的操作 —— 我要编辑什么以及我正在做的文本处理任务，以便使我的学生更容易学习。
+
+### Vim 的可视化模式
+
+使用 Vim 编辑文本时，可视化模式对于识别要操作的文本块非常有用。
+
+Vim 的可视模式有三个模式：字符、行和块。进入每种模式的按键是：
+
+  * 字符模式: `v` （小写）
+  * 行模式: `V` （大写）
+  * 块模式: `Ctrl+v`
+
+下面是使用每种模式简化工作的一些方法。
+
+### 字符模式
+
+字符模式可以高亮显示段落中的一个句子或句子中的一个短语，然后，可以使用任何 Vim 编辑命令删除、复制、更改/修改可视化模式识别的文本。
+
+#### 移动一个句子
+
+要将句子从一个地方移动到另一个地方，首先打开文件并将光标移动到要移动的句子的第一个字符。
+
+![](https://opensource.com/sites/default/files/uploads/vim-visual-char1.png)
+
+  * 按下 `v` 键进入可视化字符模式。单词 `VISUAL` 将出现在屏幕底部。
+  * 使用箭头来高亮显示所需的文本。你可以使用其他导航命令，例如 `w` 高亮显示至下一个单词的开头，`$` 来包含该行的其余部分。
+  * 在文本高亮显示后，按下 `d` 删除文本。
+  * 如果你删除得太多或不够，按下 `u` 撤销并重新开始。
+  * 将光标移动到新位置，然后按 `p` 粘贴文本。
+
+#### 改变一个短语
+
+你还可以高亮显示要替换的一段文本。
+
+![](https://opensource.com/sites/default/files/uploads/vim-visual-char2.png)
+
+  * 将光标放在要更改的第一个字符处。
+  * 按下 `v` 进入可视化字符模式。
+  * 使用导航命令（如箭头键）高亮显示该部分。
+  * 按下 `c` 可更改高亮显示的文本。
+  * 高亮显示的文本将消失，你将处于插入模式，你可以在其中添加新文本。
+  * 输入新文本后，按下 `Esc` 返回命令模式并保存你的工作。
+
+![](https://opensource.com/sites/default/files/uploads/vim-visual-char3.png)
+
+### 行模式
+
+使用 Ansible 剧本时，任务的顺序很重要。使用可视化行模式将 Ansible 任务移动到该剧本文件中的其他位置。
+
+#### 操纵多行文本
+
+![](https://opensource.com/sites/default/files/uploads/vim-visual-line1.png)
+
+  * 将光标放在要操作的文本的第一行或最后一行的任何位置。
+  * 按下 `Shift+V` 进入行模式。单词 `VISUAL LINE` 将出现在屏幕底部。
+  * 使用导航命令（如箭头键）高亮显示多行文本。
+  * 高亮显示所需文本后，使用命令来操作它。按下 `d` 删除，然后将光标移动到新位置，按下 `p` 粘贴文本。
+  * 如果要复制该 Ansible 任务，可以使用 `y`（yank）来代替 `d`（delete）。
+
+#### 缩进一组行
+
+使用 Ansible 剧本或 YAML 文件时，缩进很重要。高亮显示的块可以使用 `>` 和 `<` 键向右或向左移动。
+
+![](https://opensource.com/sites/default/files/uploads/vim-visual-line2.png)
+
+  * 按下 `>` 增加所有行的缩进。
+  * 按下 `<` 减少所有行的缩进。
+
+尝试其他 Vim 命令将它们应用于高亮显示的文本。
+
+### 块模式
+
+可视化块模式对于操作特定的表格数据文件非常有用，但它作为验证 Ansible 剧本文件缩进的工具也很有帮助。
+
+Ansible 任务是个项目列表，在 YAML 中，每个列表项都以一个破折号跟上一个空格开头。破折号必须在同一列中对齐，以达到相同的缩进级别。仅凭肉眼很难看出这一点。缩进 Ansible 任务中的其他行也很重要。
+
+#### 验证任务列表缩进相同
+
+![](https://opensource.com/sites/default/files/uploads/vim-visual-block1.png)
+
+  * 将光标放在列表项的第一个字符上。
+  * 按下 `Ctrl+v` 进入可视化块模式。单词 `VISUAL BLOCK` 将出现在屏幕底部。
+  * 使用箭头键高亮显示单个字符列。你可以验证每个任务的缩进量是否相同。
+  * 使用箭头键向右或向左展开块，以检查其它缩进是否正确。
+
+![](https://opensource.com/sites/default/files/uploads/vim-visual-block2.png)
+
+尽管我对其它 Vim 编辑快捷方式很熟悉，但我仍然喜欢使用可视化模式来整理我想要出来处理的文本。当我在讲演过程中演示其它概念时，我的学生将会在这个“对他们而言很新”的文本编辑器中看到一个可以高亮文本并可以点击删除的工具。
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/19/2/getting-started-vim-visual-mode
+
+作者：[Susan Lauber][a]
+选题：[lujun9972][b]
+译者：[MjSeven](https://github.com/MjSeven)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/susanlauber
+[b]: https://github.com/lujun9972

published/20190212 Ampersands and File Descriptors in Bash.md

@@ -0,0 +1,164 @@
+[#]: collector: (lujun9972)
+[#]: translator: (zero-mk)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10591-1.html)
+[#]: subject: (Ampersands and File Descriptors in Bash)
+[#]: via: (https://www.linux.com/blog/learn/2019/2/ampersands-and-file-descriptors-bash)
+[#]: author: (Paul Brown https://www.linux.com/users/bro66)
+
+Bash 中的 ＆ 符号和文件描述符
+======
+
+> 了解如何将 “＆” 与尖括号结合使用，并从命令行中获得更多信息。
+
+![](https://www.linux.com/sites/lcom/files/styles/rendered_file/public/ampersand-coffee.png?itok=yChaT-47)
+
+在我们探究大多数链式 Bash 命令中出现的所有的杂项符号（`&`、`|`、`;`、`>`、`<`、`{`、`[`、`(`、`)`、`]`、`}` 等等）的任务中，[我们一直在仔细研究 & 符号][1]。
+
+[上次，我们看到了如何使用 & 把可能需要很长时间运行的进程放到后台运行][1]。但是，`＆` 与尖括号 `<` 结合使用，也可用于将输出或输出通过管道导向其他地方。
+
+在 [前面的][2] [尖括号教程中][3]，你看到了如何使用 `>`，如下：
+
+```
+ls > list.txt
+```
+
+将 `ls` 输出传递给 `list.txt` 文件。
+
+现在我们看到的是简写：
+
+```
+ls 1> list.txt
+```
+
+在这种情况下，`1` 是一个文件描述符，指向标准输出（`stdout`）。
+
+以类似的方式，`2` 指向标准错误输出（`stderr`）：
+
+```
+ls 2> error.log
+```
+
+所有错误消息都通过管道传递给 `error.log` 文件。
+
+回顾一下：`1>` 是标准输出（`stdout`），`2>` 是标准错误输出（`stderr`）。
+
+第三个标准文件描述符，`0<` 是标准输入（`stdin`）。你可以看到它是一个输入，因为箭头（`<`）指向`0`，而对于 `1` 和 `2`，箭头（`>`）是指向外部的。
+
+### 标准文件描述符有什么用？
+
+如果你在阅读本系列以后，你已经多次使用标准输出（`1>`）的简写形式：`>`。
+
+例如，当（假如）你知道你的命令会抛出一个错误时，像 `stderr`（`2`）这样的东西也很方便，但是 Bash 告诉你的东西是没有用的，你不需要看到它。如果要在 `home/` 目录中创建目录，例如：
+
+```
+mkdir newdir
+```
+
+如果 `newdir/` 已经存在，`mkdir` 将显示错误。但你为什么要关心这些呢？（好吧，在某些情况下你可能会关心，但并非总是如此。）在一天结束时，`newdir` 会以某种方式让你填入一些东西。你可以通过将错误消息推入虚空（即 ``/dev/null`）来抑制错误消息：
+
+```
+mkdir newdir 2> /dev/null
+```
+
+这不仅仅是 “让我们不要看到丑陋和无关的错误消息，因为它们很烦人”，因为在某些情况下，错误消息可能会在其他地方引起一连串错误。比如说，你想找到 `/etc` 下所有的 `.service` 文件。你可以这样做：
+
+```
+find /etc -iname "*.service"
+```
+
+但事实证明，在大多数系统中，`find` 显示的错误会有许多行，因为普通用户对 `/etc` 下的某些文件夹没有读取访问权限。它使读取正确的输出变得很麻烦，如果 `find` 是更大的脚本的一部分，它可能会导致行中的下一个命令排队。
+
+相反，你可以这样做：
+
+```
+find /etc -iname "*.service" 2> /dev/null
+```
+
+而且你只得到你想要的结果。
+
+### 文件描述符入门
+
+单独的文件描述符 `stdout` 和 `stderr` 还有一些注意事项。如果要将输出存储在文件中，请执行以下操作：
+
+```
+find /etc -iname "*.service" 1> services.txt
+```
+
+工作正常，因为 `1>` 意味着 “发送标准输出且自身标准输出（非标准错误）到某个地方”。
+
+但这里存在一个问题：如果你想把命令抛出的错误信息记录到文件，而结果中没有错误信息你该怎么**做**？上面的命令并不会这样做，因为它只写入 `find` 正确的结果，而：
+
+```
+find /etc -iname "*.service" 2> services.txt
+```
+
+只会写入命令抛出的错误信息。
+
+我们如何得到两者？请尝试以下命令：
+
+```
+find /etc -iname "*.service" &> services.txt
+```
+
+…… 再次和 `&` 打个招呼！
+
+我们一直在说 `stdin`（`0`）、`stdout`（`1`）和 `stderr`（`2`）是“文件描述符”。文件描述符是一种特殊构造，是指向文件的通道，用于读取或写入，或两者兼而有之。这来自于将所有内容都视为文件的旧 UNIX 理念。想写一个设备？将其视为文件。想写入套接字并通过网络发送数据？将其视为文件。想要读取和写入文件？嗯，显然，将其视为文件。
+
+因此，在管理命令的输出和错误的位置时，将目标视为文件。因此，当你打开它们来读取和写入它们时，它们都会获得文件描述符。
+
+这是一个有趣的效果。例如，你可以将内容从一个文件描述符传递到另一个文件描述符：
+
+```
+find /etc -iname "*.service" 1> services.txt 2>&1
+```
+
+这会将 `stderr` 导向到 `stdout`，而 `stdout` 通过管道被导向到一个文件中 `services.txt` 中。
+
+它再次出现：`&` 发信号通知 Bash `1` 是目标文件描述符。
+
+标准文件描述符的另一个问题是，当你从一个管道传输到另一个时，你执行此操作的顺序有点违反直觉。例如，按照上面的命令。它看起来像是错误的方式。你也行像这样阅读它：“将输出导向到文件，然后将错误导向到标准输出。” 看起来错误输出会在后面，并且在输出到标准输出（`1`）已经完成时才发送。
+
+但这不是文件描述符的工作方式。文件描述符不是文件的占位符，而是文件的输入和（或）输出通道。在这种情况下，当你做 `1> services.txt` 时，你的意思是 “打开一个写管道到 `services.txt` 并保持打开状态”。`1` 是你要使用的管道的名称，它将保持打开状态直到该行的结尾。
+
+如果你仍然认为这是错误的方法，试试这个：
+
+```
+find /etc -iname "*.service" 2>&1 1>services.txt
+```
+
+并注意它是如何不工作的；注意错误是如何被导向到终端的，而只有非错误的输出（即 `stdout`）被推送到 `services.txt`。
+
+这是因为 Bash 从左到右处理 `find` 的每个结果。这样想：当 Bash 到达 `2>&1` 时，`stdout` （`1`）仍然是指向终端的通道。如果 `find` 给 Bash 的结果包含一个错误，它将被弹出到 `2`，转移到 `1`，然后留在终端！
+
+然后在命令结束时，Bash 看到你要打开 `stdout`（`1`） 作为到 `services.txt` 文件的通道。如果没有发生错误，结果将通过通道 `1` 进入文件。
+
+相比之下，在：
+
+```
+find /etc -iname "*.service" 1>services.txt 2>&1
+```
+
+`1` 从一开始就指向 `services.txt`，因此任何弹出到 `2` 的内容都会导向到 `1` ，而 `1` 已经指向最终去的位置 `services.txt`，这就是它工作的原因。
+
+在任何情况下，如上所述 `&>` 都是“标准输出和标准错误”的缩写，即 `2>&1`。
+
+这可能有点多，但不用担心。重新导向文件描述符在 Bash 命令行和脚本中是司空见惯的事。随着本系列的深入，你将了解更多关于文件描述符的知识。下周见!
+
+--------------------------------------------------------------------------------
+
+via: https://www.linux.com/blog/learn/2019/2/ampersands-and-file-descriptors-bash
+
+作者：[Paul Brown][a]
+选题：[lujun9972][b]
+译者：[zero-mk](https://github.com/zero-mk)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://www.linux.com/users/bro66
+[b]: https://github.com/lujun9972
+[1]: https://linux.cn/article-10587-1.html
+[2]: https://linux.cn/article-10502-1.html
+[3]: https://linux.cn/article-10529-1.html

published/20190212 Two graphical tools for manipulating PDFs on the Linux desktop.md

@@ -0,0 +1,97 @@
+[#]: collector: (lujun9972)
+[#]: translator: (geekpi)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10584-1.html)
+[#]: subject: (Two graphical tools for manipulating PDFs on the Linux desktop)
+[#]: via: (https://opensource.com/article/19/2/manipulating-pdfs-linux)
+[#]: author: (Scott Nesbitt https://opensource.com/users/scottnesbitt)
+
+两款 Linux 桌面中的图形化操作 PDF 的工具
+======
+
+> PDF-Shuffler 和 PDF Chain 是在 Linux 中修改 PDF 的绝佳工具。
+
+![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/tools_osyearbook2016_sysadmin_cc.png?itok=Y1AHCKI4)
+
+由于我谈论和写作了些 PDF 及使用它们的工具的文章，有些人认为我喜欢这种格式。其实我并不是，由于各种原因，我不会深入它。
+
+我不会说 PDF 是我个人和职业生活中的一个躲不开的坏事 - 而实际上它们不是那么好。通常即使有更好的替代方案来交付文档，通常我也必须使用 PDF。
+
+当我使用 PDF 时，通常是在白天工作时在其他的操作系统上使用，我使用 Adobe Acrobat 进行操作。但是当我必须在 Linux 桌面上使用 PDF 时呢？我们来看看我用来操作 PDF 的两个图形工具。
+
+### PDF-Shuffler
+
+顾名思义，你可以使用 [PDF-Shuffler][1] 在 PDF 文件中移动页面。它可以做得更多，但该软件的功能是有限的。这并不意味着 PDF-Shuffler 没用。它有用，很有用。
+
+你可以将 PDF-Shuffler 用来：
+
+  * 从 PDF 文件中提取页面
+  * 将页面添加到文件中
+  * 重新排列文件中的页面
+
+请注意，PDF-Shuffler 有一些依赖项，如 pyPDF 和 python-gtk。通常，通过包管理器安装它是最快且最不令人沮丧的途径。
+
+假设你想从 PDF 中提取页面，也许是作为你书中的样本章节。选择 “File > Add”打开 PDF 文件。
+
+![](https://opensource.com/sites/default/files/uploads/pdfshuffler-book.png)
+
+要提取第 7 页到第 9 页，请按住 `Ctrl` 并单击选择页面。然后，右键单击并选择 “Export selection”。
+
+![](https://opensource.com/sites/default/files/uploads/pdfshuffler-export.png)
+
+选择要保存文件的目录，为其命名，然后单击 “Save”。
+
+要添加文件 —— 例如，要添加封面或重新插入已扫描的且已签名的合同或者应用 - 打开 PDF 文件，然后选择 “File > Add” 并找到要添加的 PDF 文件。单击 “Open”。
+
+PDF-Shuffler 有个不好的地方就是添加页面到你正在处理的 PDF 文件末尾。单击并将添加的页面拖动到文件中的所需位置。你一次只能在文件中单击并拖动一个页面。
+
+![](https://opensource.com/sites/default/files/uploads/pdfshuffler-move.png)
+
+### PDF Chain
+
+我是 [PDFtk][2] 的忠实粉丝，它是一个可以对 PDF 做一些有趣操作的命令行工具。由于我不经常使用它，我不记得所有 PDFtk 的命令和选项。
+
+[PDF Chain][3] 是 PDFtk 命令行的一个很好的替代品。它可以让你一键使用 PDFtk 最常用的命令。无需使用菜单，你可以：
+
+* 合并 PDF（包括旋转一个或多个文件的页面）
+* 从 PDF 中提取页面并将其保存到单个文件中
+* 为 PDF 添加背景或水印
+* 将附件添加到文件
+
+![](https://opensource.com/sites/default/files/uploads/pdfchain1.png)
+
+你也可以做得更多。点击 “Tools” 菜单，你可以：
+
+* 从 PDF 中提取附件
+* 压缩或解压缩文件
+* 从文件中提取元数据
+* 用外部[数据][4]填充 PDF 表格
+* [扁平化][5] PDF
+* 从 PDF 表单中删除 [XML 表格结构][6]（XFA）数据
+
+老实说，我只使用 PDF Chain 或 PDFtk 提取附件、压缩或解压缩 PDF。其余的对我来说基本没听说。
+
+### 总结
+
+Linux 上用于处理 PDF 的工具数量一直让我感到吃惊。它们的特性和功能的广度和深度也是如此。无论是命令行还是图形，我总能找到一个能做我需要的。在大多数情况下，PDF Mod 和 PDF Chain 对我来说效果很好。
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/19/2/manipulating-pdfs-linux
+
+作者：[Scott Nesbitt][a]
+选题：[lujun9972][b]
+译者：[geekpi](https://github.com/geekpi)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/scottnesbitt
+[b]: https://github.com/lujun9972
+[1]: https://savannah.nongnu.org/projects/pdfshuffler/
+[2]: https://en.wikipedia.org/wiki/PDFtk
+[3]: http://pdfchain.sourceforge.net/
+[4]: http://www.verypdf.com/pdfform/fdf.htm
+[5]: http://pdf-tips-tricks.blogspot.com/2009/03/flattening-pdf-layers.html
+[6]: http://en.wikipedia.org/wiki/XFA

published/20190213 How to use Linux Cockpit to manage system performance.md

@@ -0,0 +1,83 @@
+[#]: collector: (lujun9972)
+[#]: translator: (geekpi)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10583-1.html)
+[#]: subject: (How to use Linux Cockpit to manage system performance)
+[#]: via: (https://www.networkworld.com/article/3340038/linux/sitting-in-the-linux-cockpit.html)
+[#]: author: (Sandra Henry-Stocker https://www.networkworld.com/author/Sandra-Henry_Stocker/)
+
+如何使用 Linux Cockpit 来管理系统性能
+======
+
+> Linux Cockpit 是一个基于 Web 界面的应用，它提供了对系统的图形化管理。看下它能够控制哪些。
+
+![](https://images.idgesg.net/images/article/2019/02/cockpit_airline_airplane_control_pilot-by-southerlycourse-getty-100787904-large.jpg)
+
+如果你还没有尝试过相对较新的 Linux Cockpit，你可能会对它所能做的一切感到惊讶。它是一个用户友好的基于 web 的控制台，提供了一些非常简单的方法来管理 Linux 系统 —— 通过 web。你可以通过一个非常简单的 web 来监控系统资源、添加或删除帐户、监控系统使用情况、关闭系统以及执行其他一些其他任务。它的设置和使用也非常简单。
+
+虽然许多 Linux 系统管理员将大部分时间花在命令行上，但使用 PuTTY 等工具访问远程系统并不总能提供最有用的命令输出。Linux Cockpit 提供了图形和易于使用的表单，来查看性能情况并对系统进行更改。
+
+Linux Cockpit 能让你查看系统性能的许多方面并进行配置更改，但任务列表可能取决于你使用的特定 Linux。任务分类包括以下内容：
+
+* 监控系统活动（CPU、内存、磁盘 IO 和网络流量） —— **系统**
+* 查看系统日志条目 ——  **日志**
+* 查看磁盘分区的容量 ——  **存储**
+* 查看网络活动（发送和接收） ——  **网络**
+* 查看用户帐户 ——  **帐户**
+* 检查系统服务的状态 ——  **服务**
+* 提取已安装应用的信息 ——  **应用**
+* 查看和安装可用更新（如果以 root 身份登录）并在需要时重新启动系统 ——  **软件更新**
+* 打开并使用终端窗口 ——  **终端**
+
+某些 Linux Cockpit 安装还允许你运行诊断报告、转储内核、检查 SELinux（安全）设置和列出订阅。
+
+以下是 Linux Cockpit 显示的系统活动示例：
+
+![cockpit activity][1]
+
+*Linux Cockpit 显示系统活动*
+
+### 如何设置 Linux Cockpit
+
+在某些 Linux 发行版（例如，最新的 RHEL）中，Linux Cockpit 可能已经安装并可以使用。在其他情况下，你可能需要采取一些简单的步骤来安装它并使其可使用。
+
+例如，在 Ubuntu 上，这些命令应该可用：
+
+```
+$ sudo apt-get install cockpit
+$ man cockpit    <== just checking
+$ sudo systemctl enable --now cockpit.socket
+$ netstat -a | grep 9090
+tcp6 0 0 [::]:9090 [::]:* LISTEN
+$ sudo systemctl enable --now cockpit.socket
+$ sudo ufw allow 9090
+```
+
+启用 Linux Cockpit 后，在浏览器中打开 `https://<system-name-or-IP>:9090`
+
+可以在 [Cockpit 项目][2] 中找到可以使用 Cockpit 的发行版列表以及安装说明。
+
+没有额外的配置，Linux Cockpit 将无法识别 `sudo` 权限。如果你被禁止使用 Cockpit 进行更改，你将会在你点击的按钮上看到一个红色的通用禁止标志。
+
+要使 `sudo` 权限有效，你需要确保用户位于 `/etc/group` 文件中的 `wheel`（RHEL）或 `adm` （Debian）组中，即服务器当以 root 用户身份登录 Cockpit 并且用户在登录 Cockpit 时选择“重用我的密码”时，已勾选了 “Server Administrator”。
+
+在你管理的系统位在千里之外或者没有控制台时，能使用图形界面控制也不错。虽然我喜欢在控制台上工作，但我偶然也乐于见到图形或者按钮。Linux Cockpit 为日常管理任务提供了非常有用的界面。
+
+--------------------------------------------------------------------------------
+
+via: https://www.networkworld.com/article/3340038/linux/sitting-in-the-linux-cockpit.html
+
+作者：[Sandra Henry-Stocker][a]
+选题：[lujun9972][b]
+译者：[geekpi](https://github.com/geekpi)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://www.networkworld.com/author/Sandra-Henry_Stocker/
+[b]: https://github.com/lujun9972
+[1]: https://images.idgesg.net/images/article/2019/02/cockpit-activity-100787994-large.jpg
+[2]: https://cockpit-project.org/running.html
+[3]: https://www.facebook.com/NetworkWorld/
+[4]: https://www.linkedin.com/company/network-world

published/20190216 FinalCrypt - An Open Source File Encryption Application.md

@@ -0,0 +1,119 @@
+[#]: collector: (lujun9972)
+[#]: translator: (geekpi)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10588-1.html)
+[#]: subject: (FinalCrypt – An Open Source File Encryption Application)
+[#]: via: (https://itsfoss.com/finalcrypt/)
+[#]: author: (Ankush Das https://itsfoss.com/author/ankush/)
+
+FinalCrypt：一个开源文件加密应用
+======
+
+我通常不会加密文件，但如果我打算整理我的重要文件或凭证，加密程序就会派上用场。
+
+你可能已经在使用像 [GnuPG][1] 这样的程序来帮助你加密/解密 Linux 上的文件。还有 [EncryptPad][2] 也可以加密你的笔记。
+
+但是，我看到了一个名为 FinalCrypt 的新的免费开源加密工具。你可以在 [GitHub 页面][3]上查看其最新的版本和源码。
+
+在本文中，我将分享使用此工具的经验。请注意，我不会将它与其他程序进行比较 —— 因此，如果你想要多个程序之间的详细比较，请在评论中告诉我们。
+
+![FinalCrypt][4]
+
+### 使用 FinalCrypt 加密文件
+
+FinalCrypt 使用[一次性密码本][5]密钥生成密码来加密文件。换句话说，它会生成一个 OTP 密钥，你将使用该密钥加密或解密你的文件。
+
+根据你指定的密钥大小，密钥是完全随机的。因此，没有密钥文件就无法解密文件。
+
+虽然 OTP 密钥用于加密/解密简单而有效，但管理或保护密钥文件对某些人来说可能是不方便的。
+
+如果要使用 FinalCrypt，可以从它的网站下载 DEB/RPM 文件。FinalCrypt 也可用于 Windows 和 macOS。
+
+- [下载 FinalCrypt](https://sites.google.com/site/ronuitholland/home/finalcrypt)
+
+下载后，只需双击该 [deb][6] 或 rpm 文件就能安装。如果需要，你还可以从源码编译。
+
+### 使用 FileCrypt
+
+该视频演示了如何使用FinalCrypt：
+
+<https://youtu.be/6Ir8VcZ26E4>
+
+如果你喜欢 Linux 相关的视频，请[订阅我们的 YouTube 频道][7]。
+
+安装 FinalCrypt 后，你将在已安装的应用列表中找到它。从这里启动它。
+
+启动后，你将看到（分割的）两栏，一个进行加密/解密，另一个选择 OTP 文件。
+
+![Using FinalCrypt for encrypting files in Linux][8]
+
+首先，你必须生成 OTP 密钥。下面是做法：
+
+![finalcrypt otp][9]
+
+请注意你的文件名可以是任何内容 —— 但你需要确保密钥文件的大小大于或等于要加密的文件。我觉得这很荒谬，但事实就是如此。
+
+![][10]
+
+生成文件后，选择窗口右侧的密钥，然后选择要在窗口左侧加密的文件。
+
+生成 OTP 后，你会看到高亮显示的校验和、密钥文件大小和有效状态：
+
+![][11]
+
+选择之后，你只需要点击 “Encrypt” 来加密这些文件，如果已经加密，那么点击 “Decrypt” 来解密这些文件。
+
+![][12]
+
+你还可以在命令行中使用 FinalCrypt 来自动执行加密作业。
+
+#### 如何保护你的 OTP 密钥？
+
+加密/解密你想要保护的文件很容易。但是，你应该在哪里保存你的 OTP 密钥？
+
+如果你未能将 OTP 密钥保存在安全的地方，那么它几乎没用。
+
+嗯，最好的方法之一是使用专门的 USB 盘保存你的密钥。只需要在解密文件时将它插入即可。
+
+除此之外，如果你认为足够安全，你可以将密钥保存在[云服务][13]中。
+
+有关 FinalCrypt 的更多信息，请访问它的网站。
+
+[FinalCrypt](https://sites.google.com/site/ronuitholland/home/finalcrypt)
+
+### 总结
+
+它开始时看上去有点复杂，但它实际上是 Linux 中一个简单且用户友好的加密程序。如果你想看看其他的，还有一些其他的[加密保护文件夹][14]的程序。
+
+你如何看待 FinalCrypt？你还知道其他类似可能更好的程序么？请在评论区告诉我们，我们将会查看的！
+
+
+--------------------------------------------------------------------------------
+
+via: https://itsfoss.com/finalcrypt/
+
+作者：[Ankush Das][a]
+选题：[lujun9972][b]
+译者：[geekpi](https://github.com/geekpi)
+校对：[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://www.gnupg.org/
+[2]: https://itsfoss.com/encryptpad-encrypted-text-editor-linux/
+[3]: https://github.com/ron-from-nl/FinalCrypt
+[4]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/finalcrypt.png?resize=800%2C450&ssl=1
+[5]: https://en.wikipedia.org/wiki/One-time_pad
+[6]: https://itsfoss.com/install-deb-files-ubuntu/
+[7]: https://www.youtube.com/c/itsfoss?sub_confirmation=1
+[8]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/finalcrypt.jpg?fit=800%2C439&ssl=1
+[9]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/02/finalcrypt-otp-key.jpg?resize=800%2C443&ssl=1
+[10]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/02/finalcrypt-otp-generate.jpg?ssl=1
+[11]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/finalcrypt-key.jpg?fit=800%2C420&ssl=1
+[12]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/02/finalcrypt-encrypt.jpg?ssl=1
+[13]: https://itsfoss.com/cloud-services-linux/
+[14]: https://itsfoss.com/password-protect-folder-linux/
+[15]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/finalcrypt.png?fit=800%2C450&ssl=1

published/20190217 How to Change User Password in Ubuntu -Beginner-s Tutorial.md

@@ -0,0 +1,124 @@
+[#]: collector: (lujun9972)
+[#]: translator: (An-DJ)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-10580-1.html)
+[#]: subject: (How to Change User Password in Ubuntu [Beginner’s Tutorial])
+[#]: via: (https://itsfoss.com/change-password-ubuntu)
+[#]: author: (Abhishek Prakash https://itsfoss.com/author/abhishek/)
+
+新手教程：Ubuntu 下如何修改用户密码
+======
+
+> 想要在 Ubuntu 下修改 root 用户的密码？那我们来学习下如何在 Ubuntu Linux 下修改任意用户的密码。我们会讨论在终端下修改和在图形界面（GUI）修改两种做法。
+
+那么，在 Ubuntu 下什么时候会需要修改密码呢？这里我给出如下两种场景。
+
+- 当你刚安装 [Ubuntu][1] 系统时，你会创建一个用户并且为之设置一个密码。这个初始密码可能安全性较弱或者太过于复杂，你会想要对它做出修改。
+- 如果你是系统管理员，你可能需要去修改在你管理的系统内其他用户的密码。
+
+当然，你可能会有其他的一些原因做这样的一件事。不过现在问题来了，我们到底如何在 Ubuntu 或其它 Linux 系统下修改单个用户的密码呢？
+
+在这个快速教程中，我将会展示给你在 Ubuntu 中如何使用命令行和图形界面（GUI）两种方式修改密码。
+
+### 在 Ubuntu 中修改用户密码 —— 通过命令行
+
+![如何在 Ubuntu Linux 下修改用户密码][2]
+
+在 Ubuntu 下修改用户密码其实非常简单。事实上，在任何 Linux 发行版上修改的方式都是一样的，因为你要使用的是叫做 `passwd` 的普通 Linux 命令来达到此目的。
+
+如果你想要修改你的当前密码，只需要简单地在终端执行此命令：
+
+```
+passwd
+```
+
+系统会要求你输入当前密码和两次新的密码。
+
+在键入密码时，你不会从屏幕上看到任何东西。这在 UNIX 和 Linux 系统中是非常正常的表现。
+
+```
+passwd
+Changing password for abhishek.
+(current) UNIX password:
+Enter new UNIX password:
+Retype new UNIX password:
+passwd: password updated successfully
+```
+
+由于这是你的管理员账户，你刚刚修改了 Ubuntu 下 sudo 密码，但你甚至没有意识到这个操作。（LCTT 译注：执行 sudo 操作时，输入的是的用户自身的密码，此处修改的就是自身的密码。而所说的“管理员账户”指的是该用户处于可以执行 `sudo` 命令的用户组中。本文此处描述易引起误会，特注明。）
+
+![在 Linux 命令行中修改用户密码][3]
+
+如果你想要修改其他用户的密码，你也可以使用 `passwd` 命令来做。但是在这种情况下，你将不得不使用`sudo`。（LCTT 译注：此处执行 `sudo`，要先输入你的 sudo 密码 —— 如上提示已经修改，再输入给其它用户设置的新密码 —— 两次。）
+
+```
+sudo passwd <user_name>
+```
+
+如果你对密码已经做出了修改，不过之后忘记了，不要担心。你可以[很容易地在Ubuntu下重置密码][4].
+
+### 修改 Ubuntu 下 root 用户密码
+
+默认情况下，Ubuntu 中 root 用户是没有密码的。不必惊讶，你并不是在 Ubuntu 下一直使用 root 用户。不太懂？让我快速地给你解释下。
+
+当[安装 Ubuntu][5] 时，你会被强制创建一个用户。这个用户拥有管理员访问权限。这个管理员用户可以通过 `sudo` 命令获得 root 访问权限。但是，该用户使用的是自身的密码，而不是 root 账户的密码（因为就没有）。
+
+你可以使用 `passwd` 命令来设置或修改 root 用户的密码。然而，在大多数情况下，你并不需要它，而且你不应该去做这样的事。
+
+你将必须使用 `sudo` 命令（对于拥有管理员权限的账户）。~~如果 root 用户的密码之前没有被设置，它会要求你设置。另外，你可以使用已有的 root 密码对它进行修改。~~（LCTT 译注：此处描述有误，使用 `sudo` 或直接以 root 用户执行 `passwd` 命令时，不需要输入该被改变密码的用户的当前密码。）
+
+```
+sudo password root
+```
+
+### 在 Ubuntu 下使用图形界面（GUI）修改密码
+
+我这里使用的是 GNOME 桌面环境，Ubuntu 版本为 18.04。这些步骤对于其他的桌面环境和 Ubuntu 版本应该差别不大。
+
+打开菜单（按下 `Windows`/`Super` 键）并搜索 “Settings”（设置）。
+
+在 “Settings” 中，向下滚动一段距离打开进入 “Details”。
+
+![在 Ubuntu GNOME Settings 中进入 Details][6]
+
+在这里，点击 “Users” 获取系统下可见的所有用户。
+
+![Ubuntu 下用户设置][7]
+
+你可以选择任一你想要的用户，包括你的主要管理员账户。你需要先解锁用户并点击 “Password” 区域。
+
+![Ubuntu 下修改用户密码][8]
+
+你会被要求设置密码。如果你正在修改的是你自己的密码，你将必须也输入当前使用的密码。
+
+![Ubuntu 下修改用户密码][9]
+
+做好这些后，点击上面的 “Change” 按钮，这样就完成了。你已经成功地在 Ubuntu 下修改了用户密码。
+
+我希望这篇快速精简的小教程能够帮助你在 Ubuntu 下修改用户密码。如果你对此还有一些问题或建议，请在下方留下评论。
+
+
+--------------------------------------------------------------------------------
+
+via: https://itsfoss.com/change-password-ubuntu
+
+作者：[Abhishek Prakash][a]
+选题：[lujun9972][b]
+译者：[An-DJ](https://github.com/An-DJ)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://itsfoss.com/author/abhishek/
+[b]: https://github.com/lujun9972
+[1]: https://www.ubuntu.com/
+[2]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/change-password-ubuntu-linux.png?resize=800%2C450&ssl=1
+[3]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/change-user-password-linux-1.jpg?resize=800%2C253&ssl=1
+[4]: https://itsfoss.com/how-to-hack-ubuntu-password/
+[5]: https://itsfoss.com/install-ubuntu-1404-dual-boot-mode-windows-8-81-uefi/
+[6]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/02/change-user-password-ubuntu-gui-2.jpg?resize=800%2C484&ssl=1
+[7]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/02/change-user-password-ubuntu-gui-3.jpg?resize=800%2C488&ssl=1
+[8]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/change-user-password-ubuntu-gui-4.jpg?resize=800%2C555&ssl=1
+[9]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/02/change-user-password-ubuntu-gui-1.jpg?ssl=1
+[10]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/change-password-ubuntu-linux.png?fit=800%2C450&ssl=1

sources/talk/20180916 The Rise and Demise of RSS.md

@@ -1,3 +1,4 @@
+name1e5s translating
 The Rise and Demise of RSS
 ======
 There are two stories here. The first is a story about a vision of the web’s future that never quite came to fruition. The second is a story about how a collaborative effort to improve a popular standard devolved into one of the most contentious forks in the history of open-source software development.

sources/talk/20180930 A Short History of Chaosnet.md

@@ -1,3 +1,4 @@
+acyanbird translating
 A Short History of Chaosnet
 ======
 If you fire up `dig` and run a DNS query for `google.com`, you will get a response somewhat like the following:

sources/talk/20181220 7 CI-CD tools for sysadmins.md

@@ -1,136 +0,0 @@
-[#]: collector: (lujun9972)
-[#]: translator: (jdh8383)
-[#]: reviewer: ( )
-[#]: publisher: ( )
-[#]: url: ( )
-[#]: subject: (7 CI/CD tools for sysadmins)
-[#]: via: (https://opensource.com/article/18/12/cicd-tools-sysadmins)
-[#]: author: (Dan Barker https://opensource.com/users/barkerd427)
-
-7 CI/CD tools for sysadmins
-======
-An easy guide to the top open source continuous integration, continuous delivery, and continuous deployment tools.
-![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/cicd_continuous_delivery_deployment_gears.png?itok=kVlhiEkc)
-
-Continuous integration, continuous delivery, and continuous deployment (CI/CD) have all existed in the developer community for many years. Some organizations have involved their operations counterparts, but many haven't. For most organizations, it's imperative for their operations teams to become just as familiar with CI/CD tools and practices as their development compatriots are.
-
-CI/CD practices can equally apply to infrastructure and third-party applications and internally developed applications. Also, there are many different tools but all use similar models. And possibly most importantly, leading your company into this new practice will put you in a strong position within your company, and you'll be a beacon for others to follow.
-
-Some organizations have been using CI/CD practices on infrastructure, with tools like [Ansible][1], [Chef][2], or [Puppet][3], for several years. Other tools, like [Test Kitchen][4], allow tests to be performed on infrastructure that will eventually host applications. In fact, those tests can even deploy the application into a production-like environment and execute application-level tests with production loads in more advanced configurations. However, just getting to the point of being able to test the infrastructure individually is a huge feat. Terraform can also use Test Kitchen for even more [ephemeral][5] and [idempotent][6] infrastructure configurations than some of the original configuration-management tools. Add in Linux containers and Kubernetes, and you can now test full infrastructure and application deployments with prod-like specs and resources that come and go in hours rather than months or years. Everything is wiped out before being deployed and tested again.
-
-However, you can also focus on getting your network configurations or database data definition language (DDL) files into version control and start running small CI/CD pipelines on them. Maybe it just checks syntax or semantics or some best practices. Actually, this is how most development pipelines started. Once you get the scaffolding down, it will be easier to build on. You'll start to find all kinds of use cases for pipelines once you get started.
-
-For example, I regularly write a newsletter within my company, and I maintain it in version control using [MJML][7]. I needed to be able to host a web version, and some folks liked being able to get a PDF, so I built a [pipeline][8]. Now when I create a new newsletter, I submit it for a merge request in GitLab. This automatically creates an index.html with links to HTML and PDF versions of the newsletter. The HTML and PDF files are also created in the pipeline. None of this is published until someone comes and reviews these artifacts. Then, GitLab Pages publishes the website and I can pull down the HTML to send as a newsletter. In the future, I'll automatically send the newsletter when the merge request is merged or after a special approval step. This seems simple, but it has saved me a lot of time. This is really at the core of what these tools can do for you. They will save you time.
-
-The key is creating tools to work in the abstract so that they can apply to multiple problems with little change. I should also note that what I created required almost no code except [some light HTML templating][9], some [node to loop through the HTML files][10], and some more [node to populate the index page with all the HTML pages and PDFs][11].
-
-Some of this might look a little complex, but most of it was taken from the tutorials of the different tools I'm using. And many developers are happy to work with you on these types of things, as they might also find them useful when they're done. The links I've provided are to a newsletter we plan to start for [DevOps KC][12], and all the code for creating the site comes from the work I did on our internal newsletter.
-
-Many of the tools listed below can offer this type of interaction, but some offer a slightly different model. The emerging model in this space is that of a declarative description of a pipeline in something like YAML with each stage being ephemeral and idempotent. Many of these systems also ensure correct sequencing by creating a [directed acyclic graph][13] (DAG) over the different stages of the pipeline.
-
-These stages are often run in Linux containers and can do anything you can do in a container. Some tools, like [Spinnaker][14], focus only on the deployment component and offer some operational features that others don't normally include. [Jenkins][15] has generally kept pipelines in an XML format and most interactions occur within the GUI, but more recent implementations have used a [domain specific language][16] (DSL) using [Groovy][17]. Further, Jenkins jobs normally execute on nodes with a special Java agent installed and consist of a mix of plugins and pre-installed components.
-
-Jenkins introduced pipelines in its tool, but they were a bit challenging to use and contained several caveats. Recently, the creator of Jenkins decided to move the community toward a couple different initiatives that will hopefully breathe new life into the project—which is the one that really brought CI/CD to the masses. I think its most interesting initiative is creating a Cloud Native Jenkins that can turn a Kubernetes cluster into a Jenkins CI/CD platform.
-
-As you learn more about these tools and start bringing these practices into your company or your operations division, you'll quickly gain followers. You will increase your own productivity as well as that of others. We all have years of backlog to get to—how much would your co-workers love if you could give them enough time to start tackling that backlog? Not only that, but your customers will start to see increased application reliability, and your management will see you as a force multiplier. That certainly can't hurt during your next salary negotiation or when interviewing with all your new skills.
-
-Let's dig into the tools a bit more. We'll briefly cover each one and share links to more information.
-
-### GitLab CI
-
-GitLab is a fairly new entrant to the CI/CD space, but it's already achieved the top spot in the [Forrester Wave for Continuous Integration Tools][20]. That's a huge achievement in such a crowded and highly qualified field. What makes GitLab CI so great? It uses a YAML file to describe the entire pipeline. It also has a functionality called Auto DevOps that allows for simpler projects to have a pipeline built automatically with multiple tests built-in. This system uses [Herokuish buildpacks][21] to determine the language and how to build the application. Some languages can also manage databases, which is a real game-changer for building new applications and getting them deployed to production from the beginning of the development process. The system has native integrations into Kubernetes and will deploy your application automatically into a Kubernetes cluster using one of several different deployment methodologies, like percentage-based rollouts and blue-green deployments.
-
-In addition to its CI functionality, GitLab offers many complementary features like operations and monitoring with Prometheus deployed automatically with your application; portfolio and project management using GitLab Issues, Epics, and Milestones; security checks built into the pipeline with the results provided as an aggregate across multiple projects; and the ability to edit code right in GitLab using the WebIDE, which can even provide a preview or execute part of a pipeline for faster feedback.
-
-### GoCD
-
-GoCD comes from the great minds at Thoughtworks, which is testimony enough for its capabilities and efficiency. To me, GoCD's main differentiator from the rest of the pack is its [Value Stream Map][22] (VSM) feature. In fact, pipelines can be chained together with one pipeline providing the "material" for the next pipeline. This allows for increased independence for different teams with different responsibilities in the deployment process. This may be a useful feature when introducing this type of system in older organizations that intend to keep these teams separate—but having everyone using the same tool will make it easier later to find bottlenecks in the VSM and reorganize the teams or work to increase efficiencies.
-
-It's incredibly valuable to have a VSM for each product in a company; that GoCD allows this to be [described in JSON or YAML][23] in version control and presented visually with all the data around wait times makes this tool even more valuable to an organization trying to understand itself better. Start by installing GoCD and mapping out your process with only manual approval gates. Then have each team use the manual approvals so you can start collecting data on where bottlenecks might exist.
-
-### Travis CI
-
-Travis CI was my first experience with a Software as a Service (SaaS) CI system, and it's pretty awesome. The pipelines are stored as YAML with your source code, and it integrates seamlessly with tools like GitHub. I don't remember the last time a pipeline failed because of Travis CI or the integration—Travis CI has a very high uptime. Not only can it be used as SaaS, but it also has a version that can be hosted. I haven't run that version—there were a lot of components, and it looked a bit daunting to install all of it. I'm guessing it would be much easier to deploy it all to Kubernetes with [Helm charts provided by Travis CI][26]. Those charts don't deploy everything yet, but I'm sure it will grow even more in the future. There is also an enterprise version if you don't want to deal with the hassle.
-
-However, if you're developing open source code, you can use the SaaS version of Travis CI for free. That is an awesome service provided by an awesome team! This alleviates a lot of overhead and allows you to use a fairly common platform for developing open source code without having to run anything.
-
-### Jenkins
-
-Jenkins is the original, the venerable, de facto standard in CI/CD. If you haven't already, you need to read "[Jenkins: Shifting Gears][27]" from Kohsuke, the creator of Jenkins and CTO of CloudBees. It sums up all of my feelings about Jenkins and the community from the last decade. What he describes is something that has been needed for several years, and I'm happy CloudBees is taking the lead on this transformation. Jenkins will be a bit overwhelming to most non-developers and has long been a burden on its administrators. However, these are items they're aiming to fix.
-
-[Jenkins Configuration as Code][28] (JCasC) should help fix the complex configuration issues that have plagued admins for years. This will allow for a zero-touch configuration of Jenkins masters through a YAML file, similar to other CI/CD systems. [Jenkins Evergreen][29] aims to make this process even easier by providing predefined Jenkins configurations based on different use cases. These distributions should be easier to maintain and upgrade than the normal Jenkins distribution.
-
-Jenkins 2 introduced native pipeline functionality with two types of pipelines, which [I discuss][30] in a LISA17 presentation. Neither is as easy to navigate as YAML when you're doing something simple, but they're quite nice for doing more complex tasks.
-
-[Jenkins X][31] is the full transformation of Jenkins and will likely be the implementation of Cloud Native Jenkins (or at least the thing most users see when using Cloud Native Jenkins). It will take JCasC and Evergreen and use them at their best natively on Kubernetes. These are exciting times for Jenkins, and I look forward to its innovation and continued leadership in this space.
-
-### Concourse CI
-
-I was first introduced to Concourse through folks at Pivotal Labs when it was an early beta version—there weren't many tools like it at the time. The system is made of microservices, and each job runs within a container. One of its most useful features that other tools don't have is the ability to run a job from your local system with your local changes. This means you can develop locally (assuming you have a connection to the Concourse server) and run your builds just as they'll run in the real build pipeline. Also, you can rerun failed builds from your local system and inject specific changes to test your fixes.
-
-Concourse also has a simple extension system that relies on the fundamental concept of resources. Basically, each new feature you want to provide to your pipeline can be implemented in a Docker image and included as a new resource type in your configuration. This keeps all functionality encapsulated in a single, immutable artifact that can be upgraded and modified independently, and breaking changes don't necessarily have to break all your builds at the same time.
-
-### Spinnaker
-
-Spinnaker comes from Netflix and is more focused on continuous deployment than continuous integration. It can integrate with other tools, including Travis and Jenkins, to kick off test and deployment pipelines. It also has integrations with monitoring tools like Prometheus and Datadog to make decisions about deployments based on metrics provided by these systems. For example, the canary deployment uses a judge concept and the metrics being collected to determine if the latest canary deployment has caused any degradation in pertinent metrics and should be rolled back or if deployment can continue.
-
-A couple of additional, unique features related to deployments cover an area that is often overlooked when discussing continuous deployment, and might even seem antithetical, but is critical to success: Spinnaker helps make continuous deployment a little less continuous. It will prevent a stage from running during certain times to prevent a deployment from occurring during a critical time in the application lifecycle. It can also enforce manual approvals to ensure the release occurs when the business will benefit the most from the change. In fact, the whole point of continuous integration and continuous deployment is to be ready to deploy changes as quickly as the business needs to change.
-
-### Screwdriver
-
-Screwdriver is an impressively simple piece of engineering. It uses a microservices approach and relies on tools like Nomad, Kubernetes, and Docker to act as its execution engine. There is a pretty good [deployment tutorial][34] for deploying to AWS and Kubernetes, but it could be improved once the in-progress [Helm chart][35] is completed.
-
-Screwdriver also uses YAML for its pipeline descriptions and includes a lot of sensible defaults, so there's less boilerplate configuration for each pipeline. The configuration describes an advanced workflow that can have complex dependencies among jobs. For example, a job can be guaranteed to run after or before another job. Jobs can run in parallel and be joined afterward. You can also use logical operators to run a job, for example, if any of its dependencies are successful or only if all are successful. Even better is that you can specify certain jobs to be triggered from a pull request. Also, dependent jobs won't run when this occurs, which allows easy segregation of your pipeline for when an artifact should go to production and when it still needs to be reviewed.
-
-This is only a brief description of these CI/CD tools—each has even more cool features and differentiators you can investigate. They are all open source and free to use, so go deploy them and see which one fits your needs best.
-
-### What to read next
-
---------------------------------------------------------------------------------
-
-via: https://opensource.com/article/18/12/cicd-tools-sysadmins
-
-作者：[Dan Barker][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/barkerd427
-[b]: https://github.com/lujun9972
-[1]: https://www.ansible.com/
-[2]: https://www.chef.io/
-[3]: https://puppet.com/
-[4]: https://github.com/test-kitchen/test-kitchen
-[5]: https://www.merriam-webster.com/dictionary/ephemeral
-[6]: https://en.wikipedia.org/wiki/Idempotence
-[7]: https://mjml.io/
-[8]: https://gitlab.com/devopskc/newsletter/blob/master/.gitlab-ci.yml
-[9]: https://gitlab.com/devopskc/newsletter/blob/master/index/index.html
-[10]: https://gitlab.com/devopskc/newsletter/blob/master/html-to-pdf.js
-[11]: https://gitlab.com/devopskc/newsletter/blob/master/populate-index.js
-[12]: https://devopskc.com/
-[13]: https://en.wikipedia.org/wiki/Directed_acyclic_graph
-[14]: https://www.spinnaker.io/
-[15]: https://jenkins.io/
-[16]: https://martinfowler.com/books/dsl.html
-[17]: http://groovy-lang.org/
-[18]: https://about.gitlab.com/product/continuous-integration/
-[19]: https://gitlab.com/gitlab-org/gitlab-ce/
-[20]: https://about.gitlab.com/2017/09/27/gitlab-leader-continuous-integration-forrester-wave/
-[21]: https://github.com/gliderlabs/herokuish
-[22]: https://www.gocd.org/getting-started/part-3/#value_stream_map
-[23]: https://docs.gocd.org/current/advanced_usage/pipelines_as_code.html
-[24]: https://docs.travis-ci.com/
-[25]: https://github.com/travis-ci/travis-ci
-[26]: https://github.com/travis-ci/kubernetes-config
-[27]: https://jenkins.io/blog/2018/08/31/shifting-gears/
-[28]: https://jenkins.io/projects/jcasc/
-[29]: https://github.com/jenkinsci/jep/blob/master/jep/300/README.adoc
-[30]: https://danbarker.codes/talk/lisa17-becoming-plumber-building-deployment-pipelines/
-[31]: https://jenkins-x.io/
-[32]: https://concourse-ci.org/
-[33]: https://github.com/concourse/concourse
-[34]: https://docs.screwdriver.cd/cluster-management/kubernetes
-[35]: https://github.com/screwdriver-cd/screwdriver-chart

sources/talk/20190121 Booting Linux faster.md

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

sources/talk/20190211 Introducing kids to computational thinking with Python.md

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

sources/talk/20190219 How Linux testing has changed and what matters today.md

@@ -0,0 +1,99 @@
+[#]: collector: (lujun9972)
+[#]: translator: ( )
+[#]: reviewer: ( )
+[#]: publisher: ( )
+[#]: url: ( )
+[#]: subject: (How Linux testing has changed and what matters today)
+[#]: via: (https://opensource.com/article/19/2/phoronix-michael-larabel)
+[#]: author: (Don Watkins https://opensource.com/users/don-watkins)
+
+How Linux testing has changed and what matters today
+======
+Michael Larabel, the founder of Phoronix, shares his insights on the evolution of Linux and open hardware.
+![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/mistake_bug_fix_find_error.png?itok=PZaz3dga)
+
+If you've ever wondered how your Linux computer stacks up against other Linux, Windows, and MacOS machines or searched for reviews of Linux-compatible hardware, you're probably familiar with [Phoronix][1]. Along with its website, which attracts more than 250 million visitors a year to its Linux reviews and news, the company also offers the [Phoronix Test Suite][2], an open source hardware benchmarking tool, and [OpenBenchmarking.org][3], where test result data is stored.
+
+According to [Michael Larabel][4], who started Phoronix in 2004, the site "is frequently cited as being the leading source for those interested in computer hardware and Linux. It offers insights regarding the development of the Linux kernel, product reviews, interviews, and news regarding free and open source software."
+
+I recently had the opportunity to interview Michael about Phoronix and his work.
+
+The questions and answers have been edited for length and clarity.
+
+**Don Watkins:** What inspired you to start Phoronix?
+
+**Michael Larabel:** When I started [Phoronix.com][5] in June 2004, it was still challenging to get a mouse or other USB peripherals working on the popular distributions of the time, like Mandrake, Yoper, MEPIS, and others. So, I set out to work on reviewing different hardware components and their compatibility with Linux. Over time, that shifted more from "does the basic device work?" to how well they perform and what features are supported or unsupported under Linux.
+
+It's been interesting to see the evolution and the importance of Linux on hardware rise. Linux was very common to LAMP/web servers, but Linux has also become synonymous with high-performance computing (HPC), Android smartphones, cloud software, autonomous vehicles, edge computing, digital signage, and related areas. While Linux hasn't quite dominated the desktop, it's doing great practically everywhere else.
+
+I also developed the Phoronix Test Suite, with its initial 1.0 public release in 2008, to increase the viability of testing on Linux, engage with more hardware and software vendors on best practices for testing, and just get more test cases running on Linux. At the time, there weren't any really shiny benchmarks on Linux like there were on Windows.
+
+**DW:** Who are your website's readers?
+
+**ML:** Phoronix's audience is as diverse as the content. Initially, it was quite desktop/gamer/enthusiast oriented, but as Linux's dominance has grown in HPC, cloud, embedded, etc., my testing has expanded in those areas and thus so has the readership. Readers tend to be interested in open source/Linux ecosystem advancements, performance, and a slight bent towards graphics processor and hardware driver interests.
+
+**DW:** How important is testing in the Linux world and how has it changed from when you started?
+
+**ML:** Testing has changed radically since 2004. Back then, many open source projects weren't carrying out any continuous integration (CI) or testing for regressions—both functional issues and performance problems. The hardware vendors supporting Linux were mostly trying to get things working and maintained while being less concerned about performance or scratching away at catching up to Mac, Solaris, and Windows. With time, we've seen the desktop reach close parity with (or exceed, depending upon your views) alternative operating systems. Most PC hardware now works out-of-the-box on Linux, most open source projects engage in some form of CI or testing, and more time and resources are afforded to advancing Linux performance. With high-frequency trading and cloud platforms relying on Linux, performance has become of utmost importance.
+
+Most of my testing at Phoronix.com is focused on benchmarking processors, graphics cards, storage devices, and other areas of interest to gamers and enthusiasts, but also interesting server platforms. Readers are also quite interested in testing of software components like the Linux kernel, code compilers, and filesystems. But in terms of the Phoronix Test Suite, its scope is rather limitless, with a framework in which new tests can be easily added and automated. There are currently more than 1,000 different profiles/suites, and new ones are routinely added—from machine learning tests to traditional benchmarks.
+
+**DW:** How important is open source hardware? Where do you see it going?
+
+**ML:** Open hardware is of increasing importance, especially in light of all the security vulnerabilities and disclosures in recent years. Facebook's work on the [Open Compute Project][6] can be commended, as can Google leveraging [Coreboot][7] in its Chromebook devices, and [Raptor Computing Systems][8]' successful, high-performance, open source POWER9 desktops/workstations/servers. [Intel][9] potentially open sourcing its firmware support package this year is also incredibly tantalizing and will hopefully spur more efforts in this space.
+
+Outside of that, open source hardware has had a really tough time cracking the consumer space due to the sheer amount of capital necessary and the complexities of designing a modern chip, etc., not to mention competing with the established hardware vendors' marketing budgets and other resources. So, while I would love for 100% open source hardware to dominate—or even compete in features and performance with proprietary hardware—in most segments, that is sadly unlikely to happen, especially with open hardware generally being much more expensive due to economies of scale.
+
+Software efforts like [OpenBMC][10], Coreboot/[Libreboot][11], and [LinuxBoot][12] are opening up hardware much more. Those efforts at liberating hardware have proven successful and will hopefully continue to be endorsed by more organizations.
+
+As for [OSHWA][13], I certainly applaud their efforts and the enthusiasm they bring to open source hardware. Certainly, for niche and smaller-scale devices, open source hardware can be a great fit. It will certainly be interesting to see what comes about with OSHWA and some of its partners like Lulzbot, Adafruit, and System76.
+
+**DW:** Can people install Phoronix Test Suite on their own computers?
+
+ML: The Phoronix Test Suite benchmarking software is open source under the GPL and can be downloaded from [Phoronix-Test-Suite.com][2] and [GitHub][14]. The benchmarking software works on not only Linux systems but also MacOS, Solaris, BSD, and Windows 10/Windows Server. The Phoronix Test Suite works on x86/x86_64, ARM/AArch64, POWER, RISC-V, and other architectures.
+
+**DW:** How does [OpenBenchmarking.org][15] work with the Phoronix Test Suite?
+
+**ML:** OpenBenchmarking.org is, in essence, the "cloud" component to the Phoronix Test Suite. It stores test profiles/test suites in a package manager-like fashion, allows users to upload their own benchmarking results, and offers related functionality around our benchmarking software.
+
+OpenBenchmarking.org is seamlessly integrated into the Phoronix Test Suite, but from the web interface, it is also where anyone can see the public benchmark results, inspect the open source test profiles to understand their methodology, research hardware and software data, and use similar functionality.
+
+Another component developed as part of the Phoronix Test Suite is [Phoromatic][16], which effectively allows anyone to deploy their own OpenBenchmarking-like environment within their own private intranet/LAN. This allows organizations to archive their benchmark results locally (and privately), orchestrate benchmarks automatically against groups of systems, manage the benchmark systems, and develop new test cases.
+
+**DW:** How can people stay up to date on Phoronix?
+
+**ML:** You can follow [me][17], [Phoronix][18], [Phoronix Test Suite][19], and [OpenBenchMarking.org][20] on Twitter.
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/19/2/phoronix-michael-larabel
+
+作者：[Don Watkins][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/don-watkins
+[b]: https://github.com/lujun9972
+[1]: https://www.phoronix.com/
+[2]: https://www.phoronix-test-suite.com/
+[3]: https://openbenchmarking.org/
+[4]: https://www.michaellarabel.com/
+[5]: http://Phoronix.com
+[6]: https://www.opencompute.org/
+[7]: https://www.coreboot.org/
+[8]: https://www.raptorcs.com/
+[9]: https://www.phoronix.com/scan.php?page=news_item&px=Intel-Open-Source-FSP-Likely
+[10]: https://en.wikipedia.org/wiki/OpenBMC
+[11]: https://libreboot.org/
+[12]: https://linuxboot.org/
+[13]: https://www.oshwa.org/
+[14]: https://github.com/phoronix-test-suite/
+[15]: http://OpenBenchmarking.org
+[16]: http://www.phoronix-test-suite.com/index.php?k=phoromatic
+[17]: https://twitter.com/michaellarabel
+[18]: https://twitter.com/phoronix
+[19]: https://twitter.com/Phoromatic
+[20]: https://twitter.com/OpenBenchmark

sources/talk/20190220 Do Linux distributions still matter with containers.md

@@ -0,0 +1,87 @@
+[#]: collector: (lujun9972)
+[#]: translator: ( )
+[#]: reviewer: ( )
+[#]: publisher: ( )
+[#]: url: ( )
+[#]: subject: (Do Linux distributions still matter with containers?)
+[#]: via: (https://opensource.com/article/19/2/linux-distributions-still-matter-containers)
+[#]: author: (Scott McCarty https://opensource.com/users/fatherlinux)
+
+Do Linux distributions still matter with containers?
+======
+There are two major trends in container builds: using a base image and building from scratch. Each has engineering tradeoffs.
+![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/cube_innovation_process_block_container.png?itok=vkPYmSRQ)
+
+Some people say Linux distributions no longer matter with containers. Alternative approaches, like distroless and scratch containers, seem to be all the rage. It appears we are considering and making technology decisions based more on fashion sense and immediate emotional gratification than thinking through the secondary effects of our choices. We should be asking questions like: How will these choices affect maintenance six months down the road? What are the engineering tradeoffs? How does this paradigm shift affect our build systems at scale?
+
+It's frustrating to watch. If we forget that engineering is a zero-sum game with measurable tradeoffs—advantages and disadvantages, with costs and benefits of different approaches— we do ourselves a disservice, we do our employers a disservice, and we do our colleagues who will eventually maintain our code a disservice. Finally, we do all of the maintainers ([hail the maintainers!][1]) a disservice by not appreciating the work they do.
+
+### Understanding the problem
+
+To understand the problem, we have to investigate why we started using Linux distributions in the first place. I would group the reasons into two major buckets: kernels and other packages. Compiling kernels is actually fairly easy. Slackware and Gentoo (I still have a soft spot in my heart) taught us that.
+
+On the other hand, the tremendous amount of development and runtime software that needs to be packaged for a usable Linux system can be daunting. Furthermore, the only way you can ensure that millions of permutations of packages can be installed and work together is by using the old paradigm: compile it and ship it together as a thing (i.e., a Linux distribution). So, why do Linux distributions compile kernels and all the packages together? Simple: to make sure things work together.
+
+First, let's talk about kernels. The kernel is special. Booting a Linux system without a compiled kernel is a bit of a challenge. It's the core of a Linux operating system, and it's the first thing we rely on when a system boots. Kernels have a lot of different configuration options when they're being compiled that can have a tremendous effect on how hardware and software run on one. A secondary problem in this bucket is that system software, like compilers, C libraries, and interpreters, must be tuned for the options you built into the kernel. Gentoo taught us this in a visceral way, which turned everyone into a miniature distribution maintainer.
+
+Embarrassingly (because I have worked with containers for the last five years), I must admit that I have compiled kernels quite recently. I had to get nested KVM working on RHEL 7 so that I could run [OpenShift on OpenStack][2] virtual machines, in a KVM virtual machine on my laptop, as well as [our Container Development Kit (CDK][3]). #justsayin Suffice to say, I fired RHEL7 up on a brand new 4.X kernel at the time. Like any good sysadmin, I was a little worried that I missed some important configuration options and patches. And, of course, I had missed some things. Sleep mode stopped working right, my docking station stopped working right, and there were numerous other small, random errors. But it did work well enough for a live demo of OpenShift on OpenStack, in a single KVM virtual machine on my laptop. Come on, that's kinda' fun, right? But I digress…
+
+Now, let's talk about all the other packages. While the kernel and associated system software can be tricky to compile, the much, much bigger problem from a workload perspective is compiling thousands and thousands of packages to give us a useable Linux system. Each package requires subject matter expertise. Some pieces of software require running only three commands: **./configure** , **make** , and **make install**. Others require a lot of subject matter expertise ranging from adding users and configuring specific defaults in **etc** to running post-install scripts and adding systemd unit files. The set of skills necessary for the thousands of different pieces of software you might use is daunting for any single person. But, if you want a usable system with the ability to try new software whenever you want, you have to learn how to compile and install the new software before you can even begin to learn to use it. That's Linux without a Linux distribution. That's the engineering problem you are agreeing to when you forgo a Linux distribution.
+
+The point is that you have to build everything together to ensure it works together with any sane level of reliability, and it takes a ton of knowledge to build a usable cohort of packages. This is more knowledge than any single developer or sysadmin is ever going to reasonably learn and retain. Every problem I described applies to your [container host][4] (kernel and system software) and [container image][5] (system software and all other packages)—notice the overlap; there are compilers, C libraries, interpreters, and JVMs in the container image, too.
+
+### The solution
+
+You already know this, but Linux distributions are the solution. Stop reading and send your nearest package maintainer (again, hail the maintainers!) an e-card (wait, did I just give my age away?). Seriously though, these people do a ton of work, and it's really underappreciated. Kubernetes, Istio, Prometheus, and Knative: I am looking at you. Your time is coming too, when you will be in maintenance mode, overused, and underappreciated. I will be writing this same article again, probably about Kubernetes, in about seven to 10 years.
+
+### First principles with container builds
+
+There are tradeoffs to building from scratch and building from base images.
+
+#### Building from base images
+
+Building from base images has the advantage that most build operations are nothing more than a package install or update. It relies on a ton of work done by package maintainers in a Linux distribution. It also has the advantage that a patching event six months—or even 10 years—from now (with RHEL) is an operations/systems administrator event (yum update), not a developer event (that requires picking through code to figure out why some function argument no longer works).
+
+Let's double-click on that a bit. Application code relies on a lot of libraries ranging from JSON munging libraries to object-relational mappers. Unlike the Linux kernel and Glibc, these types of libraries change with very little regard to breaking API compatibility. That means that three years from now your patching event likely becomes a code-changing event, not a yum update event. Got it, let that sink in. Developers, you are getting paged at 2 AM if the security team can't find a firewall hack to block the exploit.
+
+Building from a base image is not perfect; there are disadvantages, like the size of all the dependencies that get dragged in. This will almost always make your container images larger than building from scratch. Another disadvantage is you will not always have access to the latest upstream code. This can be frustrating for developers, especially when you just want to get something out the door, but not as frustrating as being paged to look at a library you haven't thought about in three years that the upstream maintainers have been changing the whole time.
+
+If you are a web developer and rolling your eyes at me, I have one word for you: DevOps. That means you are carrying a pager, my friend.
+
+#### Building from scratch
+
+Scratch builds have the advantage of being really small. When you don't rely on a Linux distribution in the container, you have a lot of control, which means you can customize everything for your needs. This is a best-of-breed model, and it's valid in certain use cases. Another advantage is you have access to the latest packages. You don't have to wait for a Linux distro to update anything. You are in control, so you choose when to spend the engineering work to incorporate new software.
+
+Remember, there is a cost to controlling everything. Often, updating to new libraries with new features drags in unwanted API changes, which means fixing incompatibilities in code (in other words, [shaving yaks][6]). Shaving yaks at 2 AM when the application doesn't work is not fun. Luckily, with containers, you can roll back and shave the yaks the next business day, but it will still eat into your time for delivering new value to the business, new features to your applications. Welcome to the life of a sysadmin.
+
+OK, that said, there are times that building from scratch makes sense. I will completely concede that statically compiled Golang programs and C programs are two decent candidates for scratch/distroless builds. With these types of programs, every container build is a compile event. You still have to worry about API breakage three years from now, but if you are a Golang shop, you should have the skillset to fix things over time.
+
+### Conclusion
+
+Basically, Linux distributions do a ton of work to save you time—on a regular Linux system or with containers. The knowledge that maintainers have is tremendous and leveraged so much without really being appreciated. The adoption of containers has made the problem even worse because it's even further abstracted.
+
+With container hosts, a Linux distribution offers you access to a wide hardware ecosystem, ranging from tiny ARM systems, to giant 128 CPU x86 boxes, to cloud-provider VMs. They offer working container engines and container runtimes out of the box, so you can just fire up your containers and let somebody else worry about making things work.
+
+For container images, Linux distributions offer you easy access to a ton of software for your projects. Even when you build from scratch, you will likely look at how a package maintainer built and shipped things—a good artist is a good thief—so, don't undervalue this work.
+
+So, thank you to all of the maintainers in Fedora, RHEL (Frantisek, you are my hero), Debian, Gentoo, and every other Linux distribution. I appreciate the work you do, even though I am a "container guy."
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/19/2/linux-distributions-still-matter-containers
+
+作者：[Scott McCarty][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/fatherlinux
+[b]: https://github.com/lujun9972
+[1]: https://aeon.co/essays/innovation-is-overvalued-maintenance-often-matters-more
+[2]: https://blog.openshift.com/openshift-on-openstack-delivering-applications-better-together/
+[3]: https://developers.redhat.com/blog/2018/02/13/red-hat-cdk-nested-kvm/
+[4]: https://developers.redhat.com/blog/2018/02/22/container-terminology-practical-introduction/#h.8tyd9p17othl
+[5]: https://developers.redhat.com/blog/2018/02/22/container-terminology-practical-introduction/#h.dqlu6589ootw
+[6]: https://en.wiktionary.org/wiki/yak_shaving

sources/tech/20170519 zsh shell inside Emacs on Windows.md

@@ -0,0 +1,121 @@
+[#]: collector: (lujun9972)
+[#]: translator: (lujun9972)
+[#]: reviewer: ( )
+[#]: publisher: ( )
+[#]: url: ( )
+[#]: subject: (zsh shell inside Emacs on Windows)
+[#]: via: (https://www.onwebsecurity.com/configuration/zsh-shell-inside-emacs-on-windows.html)
+[#]: author: (Peter Mosmans https://www.onwebsecurity.com/)
+
+zsh shell inside Emacs on Windows
+======
+
+![zsh shell inside Emacs on Windows][5]
+
+The most obvious advantage of running a cross-platform shell (for example Bash or zsh) is that you can use the same syntax and scripts on multiple platforms. Setting up (alternative) shells on Windows can be pretty tricky, but the small investment is well worth the reward.
+
+The MSYS2 subsystem allows you to run shells like Bash or zsh on Windows. An important part of MSYS2 is making sure that the search paths are all pointing to the MSYS2 subsystem: There are a lot of dependencies.
+
+Bash is the default shell once MSYS2 is installed; zsh can be installed using the package manager:
+
+```
+pacman -Sy zsh
+```
+
+Setting zsh as default shell can be done by modifying the ` /etc/passwd` file, for instance:
+
+```
+mkpasswd -c | sed -e 's/bash/zsh/' | tee -a /etc/passwd
+```
+
+This will change the default shell from bash to zsh.
+
+Running zsh under Emacs on Windows can be done by modifying the ` shell-file-name` variable, and pointing it to the zsh binary from the MSYS2 subsystem. The shell binary has to be somewhere in the Emacs ` exec-path` variable.
+
+```
+(setq shell-file-name (executable-find "zsh.exe"))
+```
+
+Don't forget to modify the PATH environment variable for Emacs, as the MSYS2 paths should be resolved before Windows paths. Using the same example, where MSYS2 is installed under
+
+```
+c:\programs\msys2
+```
+
+:
+
+```
+(setenv "PATH" "C:\\programs\\msys2\\mingw64\\bin;C:\\programs\\msys2\\usr\\local\\bin;C:\\programs\\msys2\\usr\\bin;C:\\Windows\\System32;C:\\Windows")
+```
+
+After setting these two variables in the Emacs configuration file, running
+
+```
+M-x shell
+```
+
+in Emacs should bring up the familiar zsh prompt.
+
+Emacs' terminal settings (eterm) are different than MSYS2' standard terminal settings (xterm-256color). This means that some plugins or themes (prompts) might not work - especially when using oh-my-zsh.
+
+Detecting whether zsh is started under Emacs is easy, using the variable
+
+```
+$INSIDE_EMACS
+```
+
+. This codesnippet in
+
+```
+.zshrc
+```
+
+(which will be sourced for interactive shells) only enables the git plugin when being run in Emacs, and changes the theme
+
+```
+# Disable some plugins while running in Emacs
+if [[ -n "$INSIDE_EMACS" ]]; then
+ plugins=(git)
+ ZSH_THEME="simple"
+else
+ ZSH_THEME="compact-grey"
+fi
+```
+
+. This codesnippet in(which will be sourced for interactive shells) only enables the git plugin when being run in Emacs, and changes the theme
+
+By adding the ` INSIDE_EMACS` variable to the local ` ~/.ssh/config` as ` SendEnv` variable...
+
+```
+Host myhost
+SendEnv INSIDE_EMACS
+```
+
+... and to a ssh server as ` AcceptEnv` variable in ` /etc/ssh/sshd_config` ...
+
+```
+AcceptEnv LANG LC_* INSIDE_EMACS
+```
+
+... this even works when ssh'ing inside an Emacs shell session to another ssh server, running zsh. When ssh'ing in the zsh shell inside Emacs on Windows, using the parameters ` -t -t` forces pseudo-tty allocation (which is necessary, as Emacs on Windows don't have a true tty).
+
+Cross-platform, open-source goodyness...
+
+--------------------------------------------------------------------------------
+
+via: https://www.onwebsecurity.com/configuration/zsh-shell-inside-emacs-on-windows.html
+
+作者：[Peter Mosmans][a]
+选题：[lujun9972][b]
+译者：[lujun9972](https://github.com/lujun9972)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://www.onwebsecurity.com/
+[b]: https://github.com/lujun9972
+[1]: https://www.onwebsecurity.com/category/configuration.html
+[2]: https://www.onwebsecurity.com/tag/emacs.html
+[3]: https://www.onwebsecurity.com/tag/msys2.html
+[4]: https://www.onwebsecurity.com/tag/zsh.html
+[5]: https://www.onwebsecurity.com//images/zsh-shell-inside-emacs-on-windows.png

sources/tech/20171212 Toplip – A Very Strong File Encryption And Decryption CLI Utility.md

@@ -1,3 +1,4 @@
+tomjlw is translatting
 Toplip – A Very Strong File Encryption And Decryption CLI Utility
 ======
 There are numerous file encryption tools available on the market to protect
@@ -260,7 +261,7 @@ Cheers!
 via: https://www.ostechnix.com/toplip-strong-file-encryption-decryption-cli-utility/
 
 作者：[SK][a]
-译者：[译者ID](https://github.com/译者ID)
+译者：[tomjlw](https://github.com/tomjlw)
 校对：[校对者ID](https://github.com/校对者ID)
 
 本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

sources/tech/20180122 Ick- a continuous integration system.md

@@ -1,75 +0,0 @@
-Ick: a continuous integration system
-======
-**TL;DR:** Ick is a continuous integration or CI system. See <http://ick.liw.fi/> for more information.
-
-More verbose version follows.
-
-### First public version released
-
-The world may not need yet another continuous integration system (CI), but I do. I've been unsatisfied with the ones I've tried or looked at. More importantly, I am interested in a few things that are more powerful than what I've ever even heard of. So I've started writing my own.
-
-My new personal hobby project is called ick. It is a CI system, which means it can run automated steps for building and testing software. The home page is at <http://ick.liw.fi/>, and the [download][1] page has links to the source code and .deb packages and an Ansible playbook for installing it.
-
-I have now made the first publicly advertised release, dubbed ALPHA-1, version number 0.23. It is of alpha quality, and that means it doesn't have all the intended features and if any of the features it does have work, you should consider yourself lucky.
-
-### Invitation to contribute
-
-Ick has so far been my personal project. I am hoping to make it more than that, and invite contributions. See the [governance][2] page for the constitution, the [getting started][3] page for tips on how to start contributing, and the [contact][4] page for how to get in touch.
-
-### Architecture
-
-Ick has an architecture consisting of several components that communicate over HTTPS using RESTful APIs and JSON for structured data. See the [architecture][5] page for details.
-
-### Manifesto
-
-Continuous integration (CI) is a powerful tool for software development. It should not be tedious, fragile, or annoying. It should be quick and simple to set up, and work quietly in the background unless there's a problem in the code being built and tested.
-
-A CI system should be simple, easy, clear, clean, scalable, fast, comprehensible, transparent, reliable, and boost your productivity to get things done. It should not be a lot of effort to set up, require a lot of hardware just for the CI, need frequent attention for it to keep working, and developers should never have to wonder why something isn't working.
-
-A CI system should be flexible to suit your build and test needs. It should support multiple types of workers, as far as CPU architecture and operating system version are concerned.
-
-Also, like all software, CI should be fully and completely free software and your instance should be under your control.
-
-(Ick is little of this yet, but it will try to become all of it. In the best possible taste.)
-
-### Dreams of the future
-
-In the long run, I would ick to have features like ones described below. It may take a while to get all of them implemented.
-
-  * A build may be triggered by a variety of events. Time is an obvious event, as is source code repository for the project changing. More powerfully, any build dependency changing, regardless of whether the dependency comes from another project built by ick, or a package from, say, Debian: ick should keep track of all the packages that get installed into the build environment of a project, and if any of their versions change, it should trigger the project build and tests again.
-
-  * Ick should support building in (or against) any reasonable target, including any Linux distribution, any free operating system, and any non-free operating system that isn't brain-dead.
-
-  * Ick should manage the build environment itself, and be able to do builds that are isolated from the build host or the network. This partially works: one can ask ick to build a container and run a build in the container. The container is implemented using systemd-nspawn. This can be improved upon, however. (If you think Docker is the only way to go, please contribute support for that.)
-
-  * Ick should support any workers that it can control over ssh or a serial port or other such neutral communication channel, without having to install an agent of any kind on them. Ick won't assume that it can have, say, a full Java run time, so that the worker can be, say, a micro controller.
-
-  * Ick should be able to effortlessly handle very large numbers of projects. I'm thinking here that it should be able to keep up with building everything in Debian, whenever a new Debian source package is uploaded. (Obviously whether that is feasible depends on whether there are enough resources to actually build things, but ick itself should not be the bottleneck.)
-
-  * Ick should optionally provision workers as needed. If all workers of a certain type are busy, and ick's been configured to allow using more resources, it should do so. This seems like it would be easy to do with virtual machines, containers, cloud providers, etc.
-
-  * Ick should be flexible in how it can notify interested parties, particularly about failures. It should allow an interested party to ask to be notified over IRC, Matrix, Mastodon, Twitter, email, SMS, or even by a phone call and speech syntethiser. "Hello, interested party. It is 04:00 and you wanted to be told when the hello package has been built for RISC-V."
-
-
-
-
-### Please give feedback
-
-If you try ick, or even if you've just read this far, please share your thoughts on it. See the [contact][4] page for where to send it. Public feedback is preferred over private, but if you prefer private, that's OK too.
-
---------------------------------------------------------------------------------
-
-via: https://blog.liw.fi/posts/2018/01/22/ick_a_continuous_integration_system/
-
-作者：[Lars Wirzenius][a]
-译者：[译者ID](https://github.com/译者ID)
-校对：[校对者ID](https://github.com/校对者ID)
-
-本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
-
-[a]:https://blog.liw.fi/
-[1]:http://ick.liw.fi/download/
-[2]:http://ick.liw.fi/governance/
-[3]:http://ick.liw.fi/getting-started/
-[4]:http://ick.liw.fi/contact/
-[5]:http://ick.liw.fi/architecture/

sources/tech/20180202 Tips for success when getting started with Ansible.md

@@ -1,3 +1,5 @@
+jdh8383 is translating.
+
 Tips for success when getting started with Ansible
 ======
 

sources/tech/20180307 3 open source tools for scientific publishing.md

@@ -1,79 +0,0 @@
-tomjlw is translating
-3 open source tools for scientific publishing
-======
-
-![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/LIFE_science.png?itok=WDKARWGV)
-One industry that lags behind others in the adoption of digital or open source tools is the competitive and lucrative world of scientific publishing. Worth over £19B ($26B) annually, according to figures published by Stephen Buranyi in [The Guardian][1] last year, the system for selecting, publishing, and sharing even the most important scientific research today still bears many of the constraints of print media. New digital-era technologies present a huge opportunity to accelerate discovery, make science collaborative instead of competitive, and redirect investments from infrastructure development into research that benefits society.
-
-The non-profit [eLife initiative][2] was established by the funders of research, in part to encourage the use of these technologies to this end. In addition to publishing an open-access journal for important advances in life science and biomedical research, eLife has made itself into a platform for experimentation and showcasing innovation in research communication—with most of this experimentation based around the open source ethos.
-
-Working on open publishing infrastructure projects gives us the opportunity to accelerate the reach and adoption of the types of technology and user experience (UX) best practices that we consider important to the advancement of the academic publishing industry. Speaking very generally, the UX of open source products is often left undeveloped, which can in some cases dissuade people from using it. As part of our investment in OSS development, we place a strong emphasis on UX in order to encourage users to adopt these products.
-
-All of our code is open source, and we actively encourage community involvement in our projects, which to us means faster iteration, more experimentation, greater transparency, and increased reach for our work.
-
-The projects that we are involved in, such as the development of Libero (formerly known as [eLife Continuum][3]) and the [Reproducible Document Stack][4], along with our recent collaboration with [Hypothesis][5], show how OSS can be used to bring about positive changes in the assessment, publication, and communication of new discoveries.
-
-### Libero
-
-Libero is a suite of services and applications available to publishers that includes a post-production publishing system, a full front-end user interface pattern suite, Libero's Lens Reader, an open API, and search and recommendation engines.
-
-Last year, we took a user-driven approach to redesigning the front end of Libero, resulting in less distracting site “furniture” and a greater focus on research articles. We tested and iterated all the key functional areas of the site with members of the eLife community to ensure the best possible reading experience for everyone. The site’s new API also provides simpler access to content for machine readability, including text mining, machine learning, and online application development.
-
-The content on our website and the patterns that drive the new design are all open source to encourage future product development for both eLife and other publishers that wish to use it.
-
-### The Reproducible Document Stack
-
-In collaboration with [Substance][6] and [Stencila][7], eLife is also engaged in a project to create a Reproducible Document Stack (RDS)—an open stack of tools for authoring, compiling, and publishing computationally reproducible manuscripts online.
-
-Today, an increasing number of researchers are able to document their computational experiments through languages such as [R Markdown][8] and [Python][9]. These can serve as important parts of the experimental record, and while they can be shared independently from or alongside the resulting research article, traditional publishing workflows tend to relegate these assets as a secondary class of content. To publish papers, researchers using these languages often have little option but to submit their computational results as “flattened” outputs in the form of figures, losing much of the value and reusability of the code and data references used in the computation. And while electronic notebook solutions such as [Jupyter][10] can enable researchers to publish their code in an easily reusable and executable form, that’s still in addition to, rather than as an integral part of, the published manuscript.
-
-The [Reproducible Document Stack][11] project aims to address these challenges through development and publication of a working prototype of a reproducible manuscript that treats code and data as integral parts of the document, demonstrating a complete end-to-end technology stack from authoring through to publication. It will ultimately allow authors to submit their manuscripts in a format that includes embedded code blocks and computed outputs (statistical results, tables, or graphs), and have those assets remain both visible and executable throughout the publication process. Publishers will then be able to preserve these assets directly as integral parts of the published online article.
-
-### Open annotation with Hypothesis
-
-Most recently, we introduced open annotation in collaboration with [Hypothesis][12] to enable users of our website to make comments, highlight important sections of articles, and engage with the reading public online.
-
-Through this collaboration, the open source Hypothesis software was customized with new moderation features, single sign-on authentication, and user-interface customization options, giving publishers more control over its implementation on their sites. These enhancements are already driving higher-quality discussions around published scholarly content.
-
-The tool can be integrated seamlessly into publishers’ websites, with the scholarly publishing platform [PubFactory][13] and content solutions provider [Ingenta][14] already taking advantage of its improved feature set. [HighWire][15] and [Silverchair][16] are also offering their publishers the opportunity to implement the service.
-
-### Other industries and open source
-
-Over time, we hope to see more publishers adopt Hypothesis, Libero, and other projects to help them foster the discovery and reuse of important scientific research. But the opportunities for innovation eLife has been able to leverage because of these and other OSS technologies are also prevalent in other industries.
-
-The world of data science would be nowhere without the high-quality, well-supported open source software and the communities built around it; [TensorFlow][17] is a leading example of this. Thanks to OSS and its communities, all areas of AI and machine learning have seen rapid acceleration and advancement compared to other areas of computing. Similar is the explosion in usage of Linux as a cloud web host, followed by containerization with Docker, and now the growth of Kubernetes, one of the most popular open source projects on GitHub.
-
-All of these technologies enable organizations to do more with less and focus on innovation instead of reinventing the wheel. And in the end, that’s the real benefit of OSS: It lets us all learn from each other’s failures while building on each other's successes.
-
-We are always on the lookout for opportunities to engage with the best emerging talent and ideas at the interface of research and technology. Find out more about some of these engagements on [eLife Labs][18], or contact [innovation@elifesciences.org][19] for more information.
-
---------------------------------------------------------------------------------
-
-via: https://opensource.com/article/18/3/scientific-publishing-software
-
-作者：[Paul Shanno][a]
-译者：[tomjlw](https://github.com/tomjlw)
-校对：[校对者ID](https://github.com/校对者ID)
-
-本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
-
-[a]:https://opensource.com/users/pshannon
-[1]:https://www.theguardian.com/science/2017/jun/27/profitable-business-scientific-publishing-bad-for-science
-[2]:https://elifesciences.org/about
-[3]:https://elifesciences.org/inside-elife/33e4127f/elife-introduces-continuum-a-new-open-source-tool-for-publishing
-[4]:https://elifesciences.org/for-the-press/e6038800/elife-supports-development-of-open-technology-stack-for-publishing-reproducible-manuscripts-online
-[5]:https://elifesciences.org/for-the-press/81d42f7d/elife-enhances-open-annotation-with-hypothesis-to-promote-scientific-discussion-online
-[6]:https://github.com/substance
-[7]:https://github.com/stencila/stencila
-[8]:https://rmarkdown.rstudio.com/
-[9]:https://www.python.org/
-[10]:http://jupyter.org/
-[11]:https://elifesciences.org/labs/7dbeb390/reproducible-document-stack-supporting-the-next-generation-research-article
-[12]:https://github.com/hypothesis
-[13]:http://www.pubfactory.com/
-[14]:http://www.ingenta.com/
-[15]:https://github.com/highwire
-[16]:https://www.silverchair.com/community/silverchair-universe/hypothesis/
-[17]:https://www.tensorflow.org/
-[18]:https://elifesciences.org/labs
-[19]:mailto:innovation@elifesciences.org

sources/tech/20180507 Modularity in Fedora 28 Server Edition.md

@@ -0,0 +1,76 @@
+[#]: collector: (lujun9972)
+[#]: translator: ( )
+[#]: reviewer: ( )
+[#]: publisher: ( )
+[#]: url: ( )
+[#]: subject: (Modularity in Fedora 28 Server Edition)
+[#]: via: (https://fedoramagazine.org/wp-content/uploads/2018/05/f28-server-modularity-816x345.jpg)
+[#]: author: (Stephen Gallagher https://fedoramagazine.org/author/sgallagh/)
+
+Modularity in Fedora 28 Server Edition
+======
+
+![](https://fedoramagazine.org/wp-content/uploads/2018/05/f28-server-modularity-816x345.jpg)
+
+### What is Modularity?
+
+A classic conundrum that all open-source distributions have faced is the “too fast/too slow” problem. Users install an operating system in order to enable the use of their applications. A comprehensive distribution like Fedora has an advantage and a disadvantage to the large amount of available software. While the package the user wants may be available, it might not be available in the version needed. Here’s how Modularity can help solve that problem.
+
+Fedora sometimes moves too fast for some users. Its rapid release cycle and desire to carry the latest stable software can result in breaking compatibility with applications. If a user can’t run a web application because Fedora upgraded a web framework to an incompatible version, it can be very frustrating. The classic answer to the “too fast” problem has been “Fedora should have an LTS release.” However, this approach only solves half the problem and makes the flip side of this conundrum worse.
+
+There are also times when Fedora moves too slowly for some of its users. For example, a Fedora release may be poorly-timed alongside the release of other desirable software. Once a Fedora release is declared stable, packagers must abide by the [Stable Updates Policy][1] and not introduce incompatible changes into the system.
+
+Fedora Modularity addresses both sides of this problem. Fedora will still ship a standard release under its traditional policy. However, it will also ship a set of modules that define alternative versions of popular software. Those in the “too fast” camp still have the benefit of Fedora’s newer kernel and other general platform enhancements. In addition, they still have access to older frameworks or toolchains that support their applications.
+
+In addition, those users who like to live closer to the edge can access newer software than was available at release time.
+
+### What is Modularity not?
+
+Modularity is not a drop-in replacement for [Software Collections][2]. These two technologies try to solve many of the same problems, but have distinct differences.
+
+Software Collections install different versions of packages in parallel on the system. However, their downside is that each installation exists in its own namespaced portion of the filesystem. Furthermore, each application that relies on them needs to be told where to find them.
+
+With Modularity, only one version of a package exists on the system, but the user can choose which one. The advantage is that this version lives in a standard location on the system. The package requires no special changes to applications that rely on it. Feedback from user studies shows most users don’t actually rely on parallel installation. Containerization and virtualization solve that problem.
+
+### Why not just use containers?
+
+This is another common question. Why would a user want modules when they could just use containers? The answer is, someone still has to maintain the software in the containers. Modules provide pre-packaged content for those containers that users don’t need to maintain, update and patch on their own. This is how Fedora takes the traditional value of a distribution and moves it into the new, containerized world.
+
+Here’s an example of how Modularity solves problems for users of Node.js and Review Board.
+
+### Node.js
+
+Many readers may be familiar with Node.js, a popular server-side JavaScript runtime. Node.js has an even/odd release policy. Its community supports even-numbered releases (6.x, 8.x, 10.x, etc.) for around 30 months. Meanwhile, they support odd-numbered releases that are essentially developer previews for 9 months.
+
+Due to this cycle, Fedora carried only the most recent even-numbered version of Node.js in its stable repositories. It avoided the odd-numbered versions entirely since their lifecycle was shorter than Fedora, and generally not aligned with a Fedora release. This didn’t sit well with some Fedora users, who wanted access to the latest and greatest enhancements.
+
+Thanks to Modularity, Fedora 28 shipped with not just one, but three versions of Node.js to satisfy both developers and stable deployments. Fedora 28’s traditional repository shipped with Node.js 8.x. This version was the most recent long-term stable version at release time. The Modular repositories (available by default on Fedora 28 Server edition) also made the older Node.js 6.x release and the newer Node.js 9.x development release available.
+
+Additionally, Node.js released 10.x upstream just days after Fedora 28\. In the past, users who wanted to deploy that version had to wait until Fedora 29, or use sources from outside Fedora. However, thanks again to Modularity, Node.js 10.x is already [available][3] in the Modular Updates-Testing repository for Fedora 28.
+
+### Review Board
+
+Review Board is a popular Django application for performing code reviews. Fedora included Review Board from Fedora 13 all the way until Fedora 21\. At that point, Fedora moved to Django 1.7\. Review Board was unable to keep up, due to backwards-incompatible changes in Django’s database support. It remained alive in EPEL for RHEL/CentOS 7, simply because those releases had fortunately frozen on Django 1.6\. Nevertheless, its time in Fedora was apparently over.
+
+However, with the advent of Modularity, Fedora could again ship the older Django as a non-default module stream. As a result, Review Board has been restored to Fedora as a module. Fedora carries both supported releases from upstream: 2.5.x and 3.0.x.
+
+### Putting the pieces together
+
+Fedora has always provided users with a wide range of software to use. Fedora Modularity now provides them with deeper choices for which versions of the software they need. The next few years will be very exciting for Fedora, as developers and users start putting together their software in new and exciting (or old and exciting) ways.
+
+--------------------------------------------------------------------------------
+
+via: https://fedoramagazine.org/wp-content/uploads/2018/05/f28-server-modularity-816x345.jpg
+
+作者：[Stephen Gallagher][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://fedoramagazine.org/author/sgallagh/
+[b]: https://github.com/lujun9972
+[1]: https://fedoraproject.org/wiki/Updates_Policy#Stable_Releases
+[2]: https://www.softwarecollections.org
+[3]: https://bodhi.fedoraproject.org/updates/FEDORA-MODULAR-2018-2b0846cb86

sources/tech/20180514 An introduction to the Pyramid web framework for Python.md

@@ -1,5 +1,5 @@
 [#]: collector: (lujun9972)
-[#]: translator: (Flowsnow)
+[#]: translator: ( )
 [#]: reviewer: ( )
 [#]: publisher: ( )
 [#]: subject: (An introduction to the Pyramid web framework for Python)

sources/tech/20180518 What-s a hero without a villain- How to add one to your Python game.md

@@ -1,3 +1,5 @@
+Translating by cycoe
+Cycoe 翻译中
 What's a hero without a villain? How to add one to your Python game
 ======
 ![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/game-dogs-chess-play-lead.png?itok=NAuhav4Z)