diff --git a/translated/tech/20170926 Managing users on Linux systems.md b/published/20170926 Managing users on Linux systems.md
similarity index 55%
rename from translated/tech/20170926 Managing users on Linux systems.md
rename to published/20170926 Managing users on Linux systems.md
index 719b0575b6..aeb6e2904b 100644
--- a/translated/tech/20170926 Managing users on Linux systems.md
+++ b/published/20170926 Managing users on Linux systems.md
@@ -1,10 +1,13 @@
-# 管理 Linux 系统中的用户
+管理 Linux 系统中的用户
+======
+
也许你的 Lniux 用户并不是愤怒的公牛，但是当涉及管理他们的账户的时候，能让他们一直开心也是一种挑战。监控他们当前正在访问的东西，追踪他们他们遇到问题时的解决方案，并且保证能把他们在使用系统时出现的重要变动记录下来。这里有一些方法和工具可以使这份工作轻松一点。
### 配置账户
-添加和移除账户是管理用户中最简单的一项，但是这里面仍然有很多需要考虑的选项。无论你是用桌面工具或是命令行选项，这都是一个非常自动化的过程。你可以使用命令添加一个新用户，像是 **adduser jdoe**，这同时会触发一系列的事情。使用下一个可用的 UID 可以创建 John 的账户，或许还会被许多用以配置账户的文件所填充。当你运行 adduser 命令加一个新的用户名的时候，它将会提示一些额外的信息，同时解释这是在干什么。
+添加和移除账户是管理用户中最简单的一项，但是这里面仍然有很多需要考虑的选项。无论你是用桌面工具或是命令行选项，这都是一个非常自动化的过程。你可以使用命令添加一个新用户，像是 `adduser jdoe`，这同时会触发一系列的事情。使用下一个可用的 UID 可以创建 John 的账户，或许还会被许多用以配置账户的文件所填充。当你运行 `adduser` 命令加一个新的用户名的时候，它将会提示一些额外的信息，同时解释这是在干什么。
+
```
$ sudo adduser jdoe
Adding user 'jdoe' ...
@@ -23,14 +26,14 @@ Enter the new value, or press ENTER for the default
Home Phone []:
Other []:
Is the information correct? [Y/n] Y
-
```
-像你看到的那样，adduser 将添加用户的信息（到 /etc/passwd 和 /etc/shadow 文件中），创建新的家目录，并用 /etc/skel 里设置的文件填充家目录，提示你分配初始密码和认定信息，然后确认这些信息都是正确的，如果你在最后的提示 “Is the information correct” 处的答案是 “n”，它将回溯你之前所有的回答，允许修改任何你想要修改的地方。
+像你看到的那样，`adduser` 将添加用户的信息（到 `/etc/passwd` 和 `/etc/shadow` 文件中），创建新的家目录，并用 `/etc/skel` 里设置的文件填充家目录，提示你分配初始密码和认定信息，然后确认这些信息都是正确的，如果你在最后的提示 “Is the information correct” 处的答案是 “n”，它将回溯你之前所有的回答，允许修改任何你想要修改的地方。
-创建好一个用户后，你可能会想要确认一下它是否是你期望的样子，更好的方法是确保在添加第一个帐户**之前**，“自动”选择与您想要查看的内容相匹配。默认有默认的好处，它对于你想知道他们定义在哪里有所用处，以防你想作出一些变动 —— 例如，你不想家目录在 /home 里，你不想用户 UIDs 从 1000 开始，或是你不想家目录下的文件被系统上的**每个人**都可读。
+创建好一个用户后，你可能会想要确认一下它是否是你期望的样子，更好的方法是确保在添加第一个帐户**之前**，“自动”选择与您想要查看的内容相匹配。默认有默认的好处，它对于你想知道他们定义在哪里有所用处，以防你想作出一些变动 —— 例如，你不想家目录在 `/home` 里，你不想用户 UID 从 1000 开始，或是你不想家目录下的文件被系统上的**每个人**都可读。
+
+`adduser` 如何工作的一些细节设置在 `/etc/adduser.conf` 文件里。这个文件包含的一些设置决定了一个新的账户如何配置，以及它之后的样子。注意，注释和空白行将会在输出中被忽略，因此我们可以更加集中注意在设置上面。
-adduser 如何工作的一些细节设置在 /etc/adduser.conf 文件里。这个文件包含的一些设置决定了一个新的账户如何配置，以及它之后的样子。注意，注释和空白行将会在输出中被忽略，因此我们可以更加集中注意在设置上面。
```
$ cat /etc/adduser.conf | grep -v "^#" | grep -v "^$"
DSHELL=/bin/bash
@@ -52,78 +55,78 @@ DIR_MODE=0755
SETGID_HOME=no
QUOTAUSER=""
SKEL_IGNORE_REGEX="dpkg-(old|new|dist|save)"
-
```
-可以看到，我们有了一个默认的 shell（DSHELL），UIDs（FIRST_UID）的开始数值，家目录（DHOME）的位置，以及启动文件（SKEL）的来源位置。这个文件也会指定分配给家目录（DIR_HOME）的权限。
+可以看到，我们有了一个默认的 shell（`DSHELL`），UID（`FIRST_UID`）的开始数值，家目录（`DHOME`）的位置，以及启动文件（`SKEL`）的来源位置。这个文件也会指定分配给家目录（`DIR_HOME`）的权限。
-其中 DIR_HOME 是最重要的设置，它决定了每个家目录被使用的权限。这个设置分配给用户创建的目录权限是 755,家目录的权限将会设置为 rwxr-xr-x。用户可以读其他用户的文件，但是不能修改和移除他们。如果你想要更多的限制，你可以更改这个设置为 750（用户组外的任何人都不可访问）甚至是 700（除用户自己外的人都不可访问）。
+其中 `DIR_HOME` 是最重要的设置，它决定了每个家目录被使用的权限。这个设置分配给用户创建的目录权限是 `755`,家目录的权限将会设置为 `rwxr-xr-x`。用户可以读其他用户的文件，但是不能修改和移除他们。如果你想要更多的限制，你可以更改这个设置为 `750`（用户组外的任何人都不可访问）甚至是 `700`（除用户自己外的人都不可访问）。
-任何用户账号在创建之前都可以进行手动修改。例如，你可以编辑 /etc/passwd 或者修改家目录的权限，开始在新服务器上添加用户之前配置 /etc/adduser.conf 可以确保一定的一致性，从长远来看可以节省时间和避免一些麻烦。
+任何用户账号在创建之前都可以进行手动修改。例如，你可以编辑 `/etc/passwd` 或者修改家目录的权限，开始在新服务器上添加用户之前配置 `/etc/adduser.conf` 可以确保一定的一致性，从长远来看可以节省时间和避免一些麻烦。
-/etc/adduser.conf 的修改将会在之后创建的用户上生效。如果你想以不同的方式设置某个特定账户，除了用户名之外，你还可以选择使用 adduser 命令提供账户配置选项。或许你想为某些账户分配不同的 shell，请求特殊的 UID，完全禁用登录。adduser 的帮助页将会为你显示一些配置个人账户的选择。
+`/etc/adduser.conf` 的修改将会在之后创建的用户上生效。如果你想以不同的方式设置某个特定账户，除了用户名之外，你还可以选择使用 `adduser` 命令提供账户配置选项。或许你想为某些账户分配不同的 shell，请求特殊的 UID，完全禁用登录。`adduser` 的帮助页将会为你显示一些配置个人账户的选择。
```
adduser [options] [--home DIR] [--shell SHELL] [--no-create-home]
[--uid ID] [--firstuid ID] [--lastuid ID] [--ingroup GROUP | --gid ID]
[--disabled-password] [--disabled-login] [--gecos GECOS]
[--add_extra_groups] [--encrypt-home] user
-
```
-每个 Linux 系统现在都会默认把每个用户放入对应的组中。作为一个管理员，你可能会选择以不同的方式去做事。你也许会发现把用户放在一个共享组中可以让你的站点工作的更好，这时，选择使用 adduser 的 --gid 选项去选择一个特定的组。当然，用户总是许多组的成员，因此也有一些选项去管理主要和次要的组。
+每个 Linux 系统现在都会默认把每个用户放入对应的组中。作为一个管理员，你可能会选择以不同的方式去做事。你也许会发现把用户放在一个共享组中可以让你的站点工作的更好，这时，选择使用 `adduser` 的 `--gid` 选项去选择一个特定的组。当然，用户总是许多组的成员，因此也有一些选项去管理主要和次要的组。
### 处理用户密码
一直以来，知道其他人的密码都是一个不好的念头，在设置账户时，管理员通常使用一个临时的密码，然后在用户第一次登录时会运行一条命令强制他修改密码。这里是一个例子：
+
```
$ sudo chage -d 0 jdoe
```
当用户第一次登录的时候，会看到像这样的事情：
+
```
WARNING: Your password has expired.
You must change your password now and login again!
Changing password for jdoe.
(current) UNIX password:
-
```
### 添加用户到副组
-添加用户到副组中，你可能会用如下所示的 usermod 命令 —— 添加用户到组中并确认已经做出变动。
+添加用户到副组中，你可能会用如下所示的 `usermod` 命令 —— 添加用户到组中并确认已经做出变动。
+
```
$ sudo usermod -a -G sudo jdoe
$ sudo grep sudo /etc/group
sudo:x:27:shs,jdoe
-
```
-记住在一些组，像是 sudo 或者 wheel 组中，意味着包含特权，一定要特别注意这一点。
+记住在一些组，像是 `sudo` 或者 `wheel` 组中，意味着包含特权，一定要特别注意这一点。
### 移除用户，添加组等
-Linux 系统也提供了命令去移除账户，添加新的组，移除组等。例如，**deluser** 命令，将会从 /etc/passwd 和 /etc/shadow 中移除用户登录入口，但是会完整保留他的家目录，除非你添加了 --remove-home 或者 --remove-all-files 选项。**addgroup** 命令会添加一个组，按目前组的次序给他下一个 id（在用户组范围内），除非你使用 --gid 选项指定 id。
+Linux 系统也提供了命令去移除账户、添加新的组、移除组等。例如，`deluser` 命令，将会从 `/etc/passwd` 和 `/etc/shadow` 中移除用户登录入口，但是会完整保留他的家目录，除非你添加了 `--remove-home` 或者 `--remove-all-files` 选项。`addgroup` 命令会添加一个组，按目前组的次序给他下一个 ID（在用户组范围内），除非你使用 `--gid` 选项指定 ID。
+
```
$ sudo addgroup testgroup --gid=131
Adding group `testgroup' (GID 131) ...
Done.
-
```
### 管理特权账户
-一些 Linux 系统中有一个 wheel 组，它给组中成员赋予了像 root 一样运行命令的能力。在这种情况下，/etc/sudoers 将会引用该组。在 Debian 系统中，这个组被叫做 sudo，但是以相同的方式工作，你在 /etc/sudoers 中可以看到像这样的引用：
+一些 Linux 系统中有一个 wheel 组，它给组中成员赋予了像 root 一样运行命令的能力。在这种情况下，`/etc/sudoers` 将会引用该组。在 Debian 系统中，这个组被叫做 `sudo`，但是以相同的方式工作，你在 `/etc/sudoers` 中可以看到像这样的引用：
+
```
%sudo ALL=(ALL:ALL) ALL
-
```
-这个基础的设定意味着，任何在 wheel 或者 sudo 组中的成员，只要在他们运行的命令之前添加 sudo，就可以以 root 的权限去运行命令。
+这个基础的设定意味着，任何在 wheel 或者 sudo 组中的成员，只要在他们运行的命令之前添加 `sudo`，就可以以 root 的权限去运行命令。
-你可以向 sudoers 文件中添加更多有限的特权 —— 也许给特定用户运行一两个 root 的命令。如果这样做，您还应定期查看 /etc/sudoers 文件以评估用户拥有的权限，以及仍然需要提供的权限。
+你可以向 `sudoers` 文件中添加更多有限的特权 —— 也许给特定用户运行一两个 root 的命令。如果这样做，您还应定期查看 `/etc/sudoers` 文件以评估用户拥有的权限，以及仍然需要提供的权限。
+
+在下面显示的命令中，我们看到在 `/etc/sudoers` 中匹配到的行。在这个文件中最有趣的行是，包含能使用 `sudo` 运行命令的路径设置，以及两个允许通过 `sudo` 运行命令的组。像刚才提到的那样，单个用户可以通过包含在 `sudoers` 文件中来获得权限，但是更有实际意义的方法是通过组成员来定义各自的权限。
-在下面显示的命令中，我们看到在 /etc/sudoers 中匹配到的行。在这个文件中最有趣的行是，包含能使用 sudo 运行命令的路径设置，以及两个允许通过 sudo 运行命令的组。像刚才提到的那样，单个用户可以通过包含在 sudoers 文件中来获得权限，但是更有实际意义的方法是通过组成员来定义各自的权限。
```
# cat /etc/sudoers | grep -v "^#" | grep -v "^$"
Defaults env_reset
@@ -132,21 +135,21 @@ Defaults secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/b
root ALL=(ALL:ALL) ALL
%admin ALL=(ALL) ALL <== admin group
%sudo ALL=(ALL:ALL) ALL <== sudo group
-
```
### 登录检查
你可以通过以下命令查看用户的上一次登录：
+
```
# last jdoe
jdoe pts/18 192.168.0.11 Thu Sep 14 08:44 - 11:48 (00:04)
jdoe pts/18 192.168.0.11 Thu Sep 14 13:43 - 18:44 (00:00)
jdoe pts/18 192.168.0.11 Thu Sep 14 19:42 - 19:43 (00:00)
-
```
-如果你想查看每一个用户上一次的登录情况，你可以通过一个像这样的循环来运行 last 命令：
+如果你想查看每一个用户上一次的登录情况，你可以通过一个像这样的循环来运行 `last` 命令：
+
```
$ for user in `ls /home`; do last $user | head -1; done
@@ -154,11 +157,10 @@ jdoe pts/18 192.168.0.11 Thu Sep 14 19:42 - 19:43 (00:03)
rocket pts/18 192.168.0.11 Thu Sep 14 13:02 - 13:02 (00:00)
shs pts/17 192.168.0.11 Thu Sep 14 12:45 still logged in
-
-
```
-此命令仅显示自当前 wtmp 文件变为活跃状态以来已登录的用户。空白行表示用户自那以后从未登录过，但没有将其调出。一个更好的命令是过滤掉在这期间从未登录过的用户的显示：
+此命令仅显示自当前 `wtmp` 文件变为活跃状态以来已登录的用户。空白行表示用户自那以后从未登录过，但没有将其调出。一个更好的命令是过滤掉在这期间从未登录过的用户的显示：
+
```
$ for user in `ls /home`; do echo -n "$user ";last $user | head -1 | awk '{print substr($0,40)}'; done
dhayes
@@ -167,39 +169,38 @@ peanut pts/19 192.168.0.29 Mon Sep 11 09:15 - 17:11
rocket pts/18 192.168.0.11 Thu Sep 14 13:02 - 13:02
shs pts/17 192.168.0.11 Thu Sep 14 12:45 still logged
tsmith
-
```
这个命令会打印很多，但是可以通过一个脚本使它更加清晰易用。
+
```
#!/bin/bash
for user in `ls /home`
do
- echo -n "$user ";last $user | head -1 | awk '{print substr($0,40)}'
+ echo -n "$user ";last $user | head -1 | awk '{print substr($0,40)}'
done
-
```
有时，此类信息可以提醒您用户角色的变动，表明他们可能不再需要相关帐户。
### 与用户沟通
-Linux 提供了许多方法和用户沟通。你可以向 /etc/motd 文件中添加信息，当用户从终端登录到服务器时，将会显示这些信息。你也可以通过例如 write（通知单个用户）或者 wall（write 给所有已登录的用户）命令发送通知。
+Linux 提供了许多方法和用户沟通。你可以向 `/etc/motd` 文件中添加信息，当用户从终端登录到服务器时，将会显示这些信息。你也可以通过例如 `write`（通知单个用户）或者 `wall`（`write` 给所有已登录的用户）命令发送通知。
+
```
$ wall System will go down in one hour
Broadcast message from shs@stinkbug (pts/17) (Thu Sep 14 14:04:16 2017):
System will go down in one hour
-
```
-重要的通知应该通过多个管道传递，因为很难预测用户实际会注意到什么。mesage-of-the-day（motd），wall 和 email 通知可以吸引用户大部分的注意力。
+重要的通知应该通过多个管道传递，因为很难预测用户实际会注意到什么。mesage-of-the-day（motd），`wall` 和 email 通知可以吸引用户大部分的注意力。
### 注意日志文件
-更多地注意日志文件上也可以帮你理解用户活动。事实上，/var/log/auth.log 文件将会为你显示用户的登录和注销活动，组的创建等。/var/log/message 或者 /var/log/syslog 文件将会告诉你更多有关系统活动的事情。
+更多地注意日志文件上也可以帮你理解用户活动。事实上，`/var/log/auth.log` 文件将会为你显示用户的登录和注销活动，组的创建等。`/var/log/message` 或者 `/var/log/syslog` 文件将会告诉你更多有关系统活动的事情。
### 追踪问题和请求
@@ -215,7 +216,7 @@ via: https://www.networkworld.com/article/3225109/linux/managing-users-on-linux-
作者：[Sandra Henry-Stocker][a]
译者：[dianbanjiu](https://github.com/dianbanjiu)
-校对：[校对者ID](https://github.com/校对者ID)
+校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
diff --git a/translated/tech/20180413 The df Command Tutorial With Examples For Beginners.md b/published/20180413 The df Command Tutorial With Examples For Beginners.md
similarity index 66%
rename from translated/tech/20180413 The df Command Tutorial With Examples For Beginners.md
rename to published/20180413 The df Command Tutorial With Examples For Beginners.md
index 08f3860661..7a46f07032 100644
--- a/translated/tech/20180413 The df Command Tutorial With Examples For Beginners.md
+++ b/published/20180413 The df Command Tutorial With Examples For Beginners.md
@@ -1,21 +1,21 @@
-df 命令的新手教程
+df 命令新手教程
======
-在本指南中，我们将学习如何使用 **df** 命令。df 命令是 `Disk Free` 的首字母组合，它报告文件系统磁盘空间的使用情况。它显示一个 Linux 系统中文件系统上可用磁盘空间的数量。df 命令很容易与 **du** 命令混淆。它们的用途不同。df 命令报告 **我们拥有多少磁盘空间**（空闲磁盘空间），而 du 命令报告 **被文件和目录占用了多少磁盘空间**。希望我这样的解释你能更清楚。在继续之前，我们来看一些 df 命令的实例，以便于你更好地理解它。
+在本指南中，我们将学习如何使用 `df` 命令。df 命令是 “Disk Free” 的首字母组合，它报告文件系统磁盘空间的使用情况。它显示一个 Linux 系统中文件系统上可用磁盘空间的数量。`df` 命令很容易与 `du` 命令混淆。它们的用途不同。`df` 命令报告我们拥有多少磁盘空间（空闲磁盘空间），而 `du` 命令报告被文件和目录占用了多少磁盘空间。希望我这样的解释你能更清楚。在继续之前，我们来看一些 `df` 命令的实例，以便于你更好地理解它。
### df 命令使用举例
-**1、查看整个文件系统磁盘空间使用情况**
+#### 1、查看整个文件系统磁盘空间使用情况
+
+无需任何参数来运行 `df` 命令，以显示整个文件系统磁盘空间使用情况。
-无需任何参数来运行 df 命令，以显示整个文件系统磁盘空间使用情况。
```
$ df
-
```
-**示例输出：**
+示例输出：
```
Filesystem 1K-blocks Used Available Use% Mounted on
@@ -28,25 +28,23 @@ tmpfs 4038880 11636 4027244 1% /tmp
/dev/loop0 84096 84096 0 100% /var/lib/snapd/snap/core/4327
/dev/sda1 95054 55724 32162 64% /boot
tmpfs 807776 28 807748 1% /run/user/1000
-
```
![][2]
正如你所见，输出结果分为六列。我们来看一下每一列的含义。
- * **Filesystem** – Linux 系统中的文件系统
- * **1K-blocks** – 文件系统的大小，用 1K 大小的块来表示。
- * **Used** – 以 1K 大小的块所表示的已使用数量。
- * **Available** – 以 1K 大小的块所表示的可用空间的数量。
- * **Use%** – 文件系统中已使用的百分比。
- * **Mounted on** – 已挂载的文件系统的挂载点。
+ * `Filesystem` – Linux 系统中的文件系统
+ * `1K-blocks` – 文件系统的大小，用 1K 大小的块来表示。
+ * `Used` – 以 1K 大小的块所表示的已使用数量。
+ * `Available` – 以 1K 大小的块所表示的可用空间的数量。
+ * `Use%` – 文件系统中已使用的百分比。
+ * `Mounted on` – 已挂载的文件系统的挂载点。
+#### 2、以人类友好格式显示文件系统硬盘空间使用情况
+在上面的示例中你可能已经注意到了，它使用 1K 大小的块为单位来表示使用情况，如果你以人类友好格式来显示它们，可以使用 `-h` 标志。
-**2、以人类友好格式显示文件系统硬盘空间使用情况**
-
-在上面的示例中你可能已经注意到了，它使用 1K 大小的块为单位来表示使用情况，如果你以人类友好格式来显示它们，可以使用 **-h** 标志。
```
$ df -h
Filesystem Size Used Avail Use% Mounted on
@@ -62,11 +60,12 @@ tmpfs 789M 28K 789M 1% /run/user/1000
```
-现在，在 **Size** 列和 **Avail** 列，使用情况是以 GB 和 MB 为单位来显示的。
+现在，在 `Size` 列和 `Avail` 列，使用情况是以 GB 和 MB 为单位来显示的。
-**3\. Display disk space usage only in MB**
+#### 3、仅以 MB 为单位来显示文件系统磁盘空间使用情况
+
+如果仅以 MB 为单位来显示文件系统磁盘空间使用情况，使用 `-m` 标志。
-如果仅以 MB 为单位来显示文件系统磁盘空间使用情况，使用 **-m** 标志。
```
$ df -m
Filesystem 1M-blocks Used Available Use% Mounted on
@@ -79,12 +78,12 @@ tmpfs 3945 12 3933 1% /tmp
/dev/loop0 83 83 0 100% /var/lib/snapd/snap/core/4327
/dev/sda1 93 55 32 64% /boot
tmpfs 789 1 789 1% /run/user/1000
-
```
-**4、列出节点而不是块的使用情况**
+#### 4、列出节点而不是块的使用情况
+
+如下所示，我们可以通过使用 `-i` 标记来列出节点而不是块的使用情况。
-如下所示，我们可以通过使用 **-i** 标记来列出节点而不是块的使用情况。
```
$ df -i
Filesystem Inodes IUsed IFree IUse% Mounted on
@@ -97,12 +96,12 @@ tmpfs 1009720 3008 1006712 1% /tmp
/dev/loop0 12829 12829 0 100% /var/lib/snapd/snap/core/4327
/dev/sda1 25688 390 25298 2% /boot
tmpfs 1009720 29 1009691 1% /run/user/1000
-
```
-**5、显示文件系统类型**
+#### 5、显示文件系统类型
+
+使用 `-T` 标志显示文件系统类型。
-使用 **-T** 标志显示文件系统类型。
```
$ df -T
Filesystem Type 1K-blocks Used Available Use% Mounted on
@@ -115,27 +114,27 @@ tmpfs tmpfs 4038880 11984 4026896 1% /tmp
/dev/loop0 squashfs 84096 84096 0 100% /var/lib/snapd/snap/core/4327
/dev/sda1 ext4 95054 55724 32162 64% /boot
tmpfs tmpfs 807776 28 807748 1% /run/user/1000
-
```
正如你所见，现在出现了显示文件系统类型的额外的列（从左数的第二列）。
-**6、仅显示指定类型的文件系统**
+#### 6、仅显示指定类型的文件系统
+
+我们可以限制仅列出某些文件系统。比如，只列出 ext4 文件系统。我们使用 `-t` 标志。
-我们可以限制仅列出某些文件系统。比如，只列出 **ext4** 文件系统。我们使用 **-t** 标志。
```
$ df -t ext4
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sda2 478425016 428790896 25308436 95% /
/dev/sda1 95054 55724 32162 64% /boot
-
```
看到了吗？这个命令仅显示了 ext4 文件系统的磁盘空间使用情况。
-**7、不列出指定类型的文件系统**
+#### 7、不列出指定类型的文件系统
+
+有时，我们可能需要从结果中去排除指定类型的文件系统。我们可以使用 `-x` 标记达到我们的目的。
-有时，我们可能需要从结果中去排除指定类型的文件系统。我们可以使用 **-x** 标记达到我们的目的。
```
$ df -x ext4
Filesystem 1K-blocks Used Available Use% Mounted on
@@ -146,30 +145,28 @@ tmpfs 4038880 0 4038880 0% /sys/fs/cgroup
tmpfs 4038880 11984 4026896 1% /tmp
/dev/loop0 84096 84096 0 100% /var/lib/snapd/snap/core/4327
tmpfs 807776 28 807748 1% /run/user/1000
-
```
-上面的命令列出了除 **ext4** 类型以外的全部文件系统。
+上面的命令列出了除 ext4 类型以外的全部文件系统。
-**8、显示一个目录的磁盘使用情况**
+#### 8、显示一个目录的磁盘使用情况
+
+去显示某个目录的硬盘空间使用情况以及它的挂载点，例如 `/home/sk/` 目录，可以使用如下的命令：
-去显示某个目录的硬盘空间使用情况以及它的挂载点，例如 **/home/sk/** 目录，可以使用如下的命令：
```
$ df -hT /home/sk/
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda2 ext4 457G 409G 25G 95% /
-
```
-这个命令显示文件系统类型、以人类友好格式显示已使用和可用磁盘空间、以及它的挂载点。如果你不想去显示文件系统类型，只需要忽略 **-t** 标志即可。
+这个命令显示文件系统类型、以人类友好格式显示已使用和可用磁盘空间、以及它的挂载点。如果你不想去显示文件系统类型，只需要忽略 `-t` 标志即可。
更详细的使用情况，请参阅 man 手册页。
+
```
$ man df
-
```
-**建议阅读：**
今天就到此这止！我希望对你有用。还有更多更好玩的东西即将奉上。请继续关注！
@@ -182,9 +179,9 @@ $ man df
via: https://www.ostechnix.com/the-df-command-tutorial-with-examples-for-beginners/
作者：[SK][a]
-译者：[qhwdw](https://github.com/qhwdw)
-校对：[校对者ID](https://github.com/校对者ID)
选题：[lujun9972](https://github.com/lujun9972)
+译者：[qhwdw](https://github.com/qhwdw)
+校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
diff --git a/translated/tech/20180724 75 Most Used Essential Linux Applications of 2018.md b/published/20180724 75 Most Used Essential Linux Applications of 2018.md
similarity index 84%
rename from translated/tech/20180724 75 Most Used Essential Linux Applications of 2018.md
rename to published/20180724 75 Most Used Essential Linux Applications of 2018.md
index 96ca929009..7d0b586129 100644
--- a/translated/tech/20180724 75 Most Used Essential Linux Applications of 2018.md
+++ b/published/20180724 75 Most Used Essential Linux Applications of 2018.md
@@ -1,7 +1,9 @@
-2018 年 75 个最常用的 Linux 应用程序
+75 个最常用的 Linux 应用程序（2018 年）
======
-对于许多应用程序来说，2018年是非常好的一年，尤其是免费开源的应用程序。尽管各种 Linux 发行版都自带了很多默认的应用程序，但用户也可以自由地选择使用它们或者其它任何免费或付费替代方案。
+
+
+对于许多应用程序来说，2018 年是非常好的一年，尤其是自由开源的应用程序。尽管各种 Linux 发行版都自带了很多默认的应用程序，但用户也可以自由地选择使用它们或者其它任何免费或付费替代方案。
下面汇总了[一系列的 Linux 应用程序][3]，这些应用程序都能够在 Linux 系统上安装，尽管还有很多其它选择。以下汇总中的任何应用程序都属于其类别中最常用的应用程序，如果你还没有用过，欢迎试用一下！
@@ -9,10 +11,10 @@
#### Rsync
-[Rsync][4] 是一个开源的、带宽友好的工具，它用于执行快速的增量文件传输，而且它也是一个免费工具。
+[Rsync][4] 是一个开源的、节约带宽的工具，它用于执行快速的增量文件传输，而且它也是一个免费工具。
+
```
$ rsync [OPTION...] SRC... [DEST]
-
```
想要了解更多示例和用法，可以参考《[10 个使用 Rsync 命令的实际例子][5]》。
@@ -31,36 +33,36 @@ $ rsync [OPTION...] SRC... [DEST]
[Deluge][7] 是一个漂亮的跨平台 BT 客户端，旨在优化 μTorrent 体验，并向用户免费提供服务。
-使用以下命令在 Ubuntu 和 Debian 安装 `Deluge`。
+使用以下命令在 Ubuntu 和 Debian 安装 Deluge。
+
```
$ sudo add-apt-repository ppa:deluge-team/ppa
$ sudo apt-get update
$ sudo apt-get install deluge
-
```
#### qBittorent
[qBittorent][8] 是一个开源的 BT 客户端，旨在提供类似 μTorrent 的免费替代方案。
-使用以下命令在 Ubuntu 和 Debian 安装 `qBittorent`。
+使用以下命令在 Ubuntu 和 Debian 安装 qBittorent。
+
```
$ sudo add-apt-repository ppa:qbittorrent-team/qbittorrent-stable
$ sudo apt-get update
$ sudo apt-get install qbittorrent
-
```
#### Transmission
[Transmission][9] 是一个强大的 BT 客户端，它主要关注速度和易用性，一般在很多 Linux 发行版上都有预装。
-使用以下命令在 Ubuntu 和 Debian 安装 `Transmission`。
+使用以下命令在 Ubuntu 和 Debian 安装 Transmission。
+
```
$ sudo add-apt-repository ppa:transmissionbt/ppa
$ sudo apt-get update
$ sudo apt-get install transmission-gtk transmission-cli transmission-common transmission-daemon
-
```
### 云存储
@@ -71,12 +73,12 @@ $ sudo apt-get install transmission-gtk transmission-cli transmission-common tra
[Dropbox][10] 团队在今年早些时候给他们的云服务换了一个名字，也为客户提供了更好的性能和集成了更多应用程序。Dropbox 会向用户免费提供 2 GB 存储空间。
-使用以下命令在 Ubuntu 和 Debian 安装 `Dropbox`。
+使用以下命令在 Ubuntu 和 Debian 安装 Dropbox。
+
```
$ cd ~ && wget -O - "https://www.dropbox.com/download?plat=lnx.x86" | tar xzf - [On 32-Bit]
$ cd ~ && wget -O - "https://www.dropbox.com/download?plat=lnx.x86_64" | tar xzf - [On 64-Bit]
$ ~/.dropbox-dist/dropboxd
-
```
#### Google Drive
@@ -99,36 +101,36 @@ $ ~/.dropbox-dist/dropboxd
[Vim][15] 是 vi 文本编辑器的开源克隆版本，它的主要目的是可以高度定制化并能够处理任何类型的文本。
-使用以下命令在 Ubuntu 和 Debian 安装 `Vim`。
+使用以下命令在 Ubuntu 和 Debian 安装 Vim。
+
```
$ sudo add-apt-repository ppa:jonathonf/vim
$ sudo apt update
$ sudo apt install vim
-
```
#### Emacs
[Emacs][16] 是一个高度可配置的文本编辑器，最流行的一个分支 GNU Emacs 是用 Lisp 和 C 编写的，它的最大特点是可以自文档化、可扩展和可自定义。
-使用以下命令在 Ubuntu 和 Debian 安装 `Emacs`。
+使用以下命令在 Ubuntu 和 Debian 安装 Emacs。
+
```
$ sudo add-apt-repository ppa:kelleyk/emacs
$ sudo apt update
$ sudo apt install emacs25
-
```
#### Nano
[Nano][17] 是一款功能丰富的命令行文本编辑器，比较适合高级用户。它可以通过多个终端进行不同功能的操作。
-使用以下命令在 Ubuntu 和 Debian 安装 `Nano`。
+使用以下命令在 Ubuntu 和 Debian 安装 Nano。
+
```
$ sudo add-apt-repository ppa:n-muench/programs-ppa
$ sudo apt-get update
$ sudo apt-get install nano
-
```
### 下载器
@@ -137,36 +139,36 @@ $ sudo apt-get install nano
#### Aria2
-[Aria2][18] 是一个开源的、轻量级的、多软件源和多协议的命令行下载器，它支持 Metalinks、torrents、HTTP/HTTPS、SFTP 等多种协议。
+[Aria2][18] 是一个开源的、轻量级的、多软件源和多协议的命令行下载器，它支持 Metalink、torrent、HTTP/HTTPS、SFTP 等多种协议。
+
+使用以下命令在 Ubuntu 和 Debian 安装 Aria2。
-使用以下命令在 Ubuntu 和 Debian 安装 `Aria2`。
```
$ sudo apt-get install aria2
-
```
#### uGet
[uGet][19] 已经成为 Linux 各种发行版中排名第一的开源下载器，它可以处理任何下载任务，包括多连接、队列、类目等。
-使用以下命令在 Ubuntu 和 Debian 安装 `uGet`。
+使用以下命令在 Ubuntu 和 Debian 安装 uGet。
+
```
$ sudo add-apt-repository ppa:plushuang-tw/uget-stable
$ sudo apt update
$ sudo apt install uget
-
```
#### XDM
[XDM][20]（Xtreme Download Manager）是一个使用 Java 编写的开源下载软件。和其它下载器一样，它可以结合队列、种子、浏览器使用，而且还带有视频采集器和智能调度器。
-使用以下命令在 Ubuntu 和 Debian 安装 `XDM`。
+使用以下命令在 Ubuntu 和 Debian 安装 XDM。
+
```
$ sudo add-apt-repository ppa:noobslab/apps
$ sudo apt-get update
$ sudo apt-get install xdman
-
```
### 电子邮件客户端
@@ -177,36 +179,36 @@ $ sudo apt-get install xdman
[Thunderbird][21] 是最受欢迎的电子邮件客户端之一。它的优点包括免费、开源、可定制、功能丰富，而且最重要的是安装过程也很简便。
-使用以下命令在 Ubuntu 和 Debian 安装 `Thunderbird`。
+使用以下命令在 Ubuntu 和 Debian 安装 Thunderbird。
+
```
$ sudo add-apt-repository ppa:ubuntu-mozilla-security/ppa
$ sudo apt-get update
$ sudo apt-get install thunderbird
-
```
#### Geary
[Geary][22] 是一个基于 WebKitGTK+ 的开源电子邮件客户端。它是一个免费开源的功能丰富的软件，并被 GNOME 项目收录。
-使用以下命令在 Ubuntu 和 Debian 安装 `Geary`。
+使用以下命令在 Ubuntu 和 Debian 安装 Geary。
+
```
$ sudo add-apt-repository ppa:geary-team/releases
$ sudo apt-get update
$ sudo apt-get install geary
-
```
#### Evolution
[Evolution][23] 是一个免费开源的电子邮件客户端，可以用于电子邮件、会议日程、备忘录和联系人的管理。
-使用以下命令在 Ubuntu 和 Debian 安装 `Evolution`。
+使用以下命令在 Ubuntu 和 Debian 安装 Evolution。
+
```
$ sudo add-apt-repository ppa:gnome3-team/gnome3-staging
$ sudo apt-get update
$ sudo apt-get install evolution
-
```
### 财务软件
@@ -217,27 +219,27 @@ $ sudo apt-get install evolution
[GnuCash][24] 是一款免费的跨平台开源软件，它适用于个人和中小型企业的财务任务。
-使用以下命令在 Ubuntu 和 Debian 安装 `GnuCash`。
+使用以下命令在 Ubuntu 和 Debian 安装 GnuCash。
+
```
$ sudo sh -c 'echo "deb http://archive.getdeb.net/ubuntu $(lsb_release -sc)-getdeb apps" >> /etc/apt/sources.list.d/getdeb.list'
$ sudo apt-get update
$ sudo apt-get install gnucash
-
```
#### KMyMoney
[KMyMoney][25] 是一个财务管理软件，它可以提供商用或个人理财所需的大部分主要功能。
-使用以下命令在 Ubuntu 和 Debian 安装 `KmyMoney`。
+使用以下命令在 Ubuntu 和 Debian 安装 KmyMoney。
+
```
$ sudo add-apt-repository ppa:claydoh/kmymoney2-kde4
$ sudo apt-get update
$ sudo apt-get install kmymoney
-
```
-### IDE 和编辑器
+### IDE
@@ -257,35 +259,35 @@ $ sudo apt-get install kmymoney
[Brackets][30] 是由 Adobe 开发的高级文本编辑器，它带有可视化工具，支持预处理程序，以及用于 web 开发的以设计为中心的用户流程。对于熟悉它的用户，它可以发挥 IDE 的作用。
-使用以下命令在 Ubuntu 和 Debian 安装 `Brackets`。
+使用以下命令在 Ubuntu 和 Debian 安装 Brackets。
+
```
$ sudo add-apt-repository ppa:webupd8team/brackets
$ sudo apt-get update
$ sudo apt-get install brackets
-
```
#### Atom IDE
[Atom IDE][31] 是一个加强版的 Atom 编辑器，它添加了大量扩展和库以提高性能和增加功能。总之，它是各方面都变得更强大了的 Atom 。
-使用以下命令在 Ubuntu 和 Debian 安装 `Atom`。
+使用以下命令在 Ubuntu 和 Debian 安装 Atom。
+
```
$ sudo apt-get install snapd
$ sudo snap install atom --classic
-
```
#### Light Table
[Light Table][32] 号称下一代的 IDE，它提供了数据流量统计和协作编程等的强大功能。
-使用以下命令在 Ubuntu 和 Debian 安装 `Light Table`。
+使用以下命令在 Ubuntu 和 Debian 安装 Light Table。
+
```
$ sudo add-apt-repository ppa:dr-akulavich/lighttable
$ sudo apt-get update
$ sudo apt-get install lighttable-installer
-
```
#### Visual Studio Code
@@ -302,33 +304,33 @@ $ sudo apt-get install lighttable-installer
[Pidgin][35] 是一个开源的即时通信工具，它几乎支持所有聊天平台，还支持额外扩展功能。
-使用以下命令在 Ubuntu 和 Debian 安装 `Pidgin`。
+使用以下命令在 Ubuntu 和 Debian 安装 Pidgin。
+
```
$ sudo add-apt-repository ppa:jonathonf/backports
$ sudo apt-get update
$ sudo apt-get install pidgin
-
```
#### Skype
[Skype][36] 也是一个广为人知的软件了，任何感兴趣的用户都可以在 Linux 上使用。
-使用以下命令在 Ubuntu 和 Debian 安装 `Skype`。
+使用以下命令在 Ubuntu 和 Debian 安装 Skype。
+
```
$ sudo apt install snapd
$ sudo snap install skype --classic
-
```
#### Empathy
[Empathy][37] 是一个支持多协议语音、视频聊天、文本和文件传输的即时通信工具。它还允许用户添加多个服务的帐户，并用其与所有服务的帐户进行交互。
-使用以下命令在 Ubuntu 和 Debian 安装 `Empathy`。
+使用以下命令在 Ubuntu 和 Debian 安装 Empathy。
+
```
$ sudo apt-get install empathy
-
```
### Linux 防病毒工具
@@ -337,61 +339,61 @@ $ sudo apt-get install empathy
[ClamAV][38] 是一个开源的跨平台命令行防病毒工具，用于检测木马、病毒和其他恶意代码。而 [ClamTk][39] 则是它的前端 GUI。
-使用以下命令在 Ubuntu 和 Debian 安装 `ClamAV` 和 `ClamTk`。
+使用以下命令在 Ubuntu 和 Debian 安装 ClamAV 和 ClamTk。
+
```
$ sudo apt-get install clamav
$ sudo apt-get install clamtk
-
```
### Linux 桌面环境
#### Cinnamon
-[Cinnamon][40] 是 GNOME 3 的免费开源衍生产品，它遵循传统的 桌面比拟 约定。
+[Cinnamon][40] 是 GNOME 3 的自由开源衍生产品，它遵循传统的 桌面比拟 约定。
+
+使用以下命令在 Ubuntu 和 Debian 安装 Cinnamon。
-使用以下命令在 Ubuntu 和 Debian 安装 `Cinnamon`。
```
$ sudo add-apt-repository ppa:embrosyn/cinnamon
$ sudo apt update
$ sudo apt install cinnamon-desktop-environment lightdm
-
```
#### Mate
[Mate][41] 桌面环境是 GNOME 2 的衍生和延续，目的是在 Linux 上通过使用传统的桌面比拟提供有一个吸引力的 UI。
-使用以下命令在 Ubuntu 和 Debian 安装 `Mate`。
+使用以下命令在 Ubuntu 和 Debian 安装 Mate。
+
```
$ sudo apt install tasksel
$ sudo apt update
$ sudo tasksel install ubuntu-mate-desktop
-
```
#### GNOME
[GNOME][42] 是由一些免费和开源应用程序组成的桌面环境，它可以运行在任何 Linux 发行版和大多数 BSD 衍生版本上。
-使用以下命令在 Ubuntu 和 Debian 安装 `Gnome`。
+使用以下命令在 Ubuntu 和 Debian 安装 Gnome。
+
```
$ sudo apt install tasksel
$ sudo apt update
$ sudo tasksel install ubuntu-desktop
-
```
#### KDE
[KDE][43] 由 KDE 社区开发，它为用户提供图形解决方案以控制操作系统并执行不同的计算任务。
-使用以下命令在 Ubuntu 和 Debian 安装 `KDE`。
+使用以下命令在 Ubuntu 和 Debian 安装 KDE。
+
```
$ sudo apt install tasksel
$ sudo apt update
$ sudo tasksel install kubuntu-desktop
-
```
### Linux 维护工具
@@ -400,22 +402,22 @@ $ sudo tasksel install kubuntu-desktop
[GNOME Tweak Tool][44] 是用于自定义和调整 GNOME 3 和 GNOME Shell 设置的流行工具。
-使用以下命令在 Ubuntu 和 Debian 安装 `GNOME Tweak Tool`。
+使用以下命令在 Ubuntu 和 Debian 安装 GNOME Tweak Tool。
+
```
$ sudo apt install gnome-tweak-tool
-
```
#### Stacer
[Stacer][45] 是一款用于监控和优化 Linux 系统的免费开源应用程序。
-使用以下命令在 Ubuntu 和 Debian 安装 `Stacer`。
+使用以下命令在 Ubuntu 和 Debian 安装 Stacer。
+
```
$ sudo add-apt-repository ppa:oguzhaninan/stacer
$ sudo apt-get update
$ sudo apt-get install stacer
-
```
#### BleachBit
@@ -430,40 +432,40 @@ $ sudo apt-get install stacer
[GNOME 终端][48] 是 GNOME 的默认终端模拟器。
-使用以下命令在 Ubuntu 和 Debian 安装 `Gnome Terminal`。
+使用以下命令在 Ubuntu 和 Debian 安装 Gnome 终端。
+
```
$ sudo apt-get install gnome-terminal
-
```
#### Konsole
[Konsole][49] 是 KDE 的一个终端模拟器。
-使用以下命令在 Ubuntu 和 Debian 安装 `Konsole`。
+使用以下命令在 Ubuntu 和 Debian 安装 Konsole。
+
```
$ sudo apt-get install konsole
-
```
#### Terminator
[Terminator][50] 是一个功能丰富的终端程序，它基于 GNOME 终端，并且专注于整理终端功能。
-使用以下命令在 Ubuntu 和 Debian 安装 `Terminator`。
+使用以下命令在 Ubuntu 和 Debian 安装 Terminator。
+
```
$ sudo apt-get install terminator
-
```
#### Guake
[Guake][51] 是 GNOME 桌面环境下一个轻量级的可下拉式终端。
-使用以下命令在 Ubuntu 和 Debian 安装 `Guake`。
+使用以下命令在 Ubuntu 和 Debian 安装 Guake。
+
```
$ sudo apt-get install guake
-
```
### 多媒体编辑工具
@@ -472,48 +474,48 @@ $ sudo apt-get install guake
[Ardour][52] 是一款漂亮的的数字音频工作站，可以完成专业的录制、编辑和混音工作。
-使用以下命令在 Ubuntu 和 Debian 安装 `Ardour`。
+使用以下命令在 Ubuntu 和 Debian 安装 Ardour。
+
```
$ sudo add-apt-repository ppa:dobey/audiotools
$ sudo apt-get update
$ sudo apt-get install ardour
-
```
#### Audacity
[Audacity][53] 是最著名的音频编辑软件之一，它是一款跨平台的开源多轨音频编辑器。
-使用以下命令在 Ubuntu 和 Debian 安装 `Audacity`。
+使用以下命令在 Ubuntu 和 Debian 安装 Audacity。
+
```
$ sudo add-apt-repository ppa:ubuntuhandbook1/audacity
$ sudo apt-get update
$ sudo apt-get install audacity
-
```
#### GIMP
[GIMP][54] 是 Photoshop 的开源替代品中最受欢迎的。这是因为它有多种可自定义的选项、第三方插件以及活跃的用户社区。
-使用以下命令在 Ubuntu 和 Debian 安装 `Gimp`。
+使用以下命令在 Ubuntu 和 Debian 安装 Gimp。
+
```
$ sudo add-apt-repository ppa:otto-kesselgulasch/gimp
$ sudo apt update
$ sudo apt install gimp
-
```
#### Krita
[Krita][55] 是一款开源的绘画程序，它具有美观的 UI 和可靠的性能，也可以用作图像处理工具。
-使用以下命令在 Ubuntu 和 Debian 安装 `Krita`。
+使用以下命令在 Ubuntu 和 Debian 安装 Krita。
+
```
$ sudo add-apt-repository ppa:kritalime/ppa
$ sudo apt update
$ sudo apt install krita
-
```
#### Lightworks
@@ -526,24 +528,24 @@ $ sudo apt install krita
[OpenShot][58] 是一款屡获殊荣的免费开源视频编辑器，这主要得益于其出色的性能和强大的功能。
-使用以下命令在 Ubuntu 和 Debian 安装 `Openshot`。
+使用以下命令在 Ubuntu 和 Debian 安装 `Openshot。
+
```
$ sudo add-apt-repository ppa:openshot.developers/ppa
$ sudo apt update
$ sudo apt install openshot-qt
-
```
#### PiTiV
[Pitivi][59] 也是一个美观的视频编辑器，它有优美的代码库、优质的社区，还支持优秀的协作编辑功能。
-使用以下命令在 Ubuntu 和 Debian 安装 `PiTiV`。
+使用以下命令在 Ubuntu 和 Debian 安装 PiTiV。
+
```
$ flatpak install --user https://flathub.org/repo/appstream/org.pitivi.Pitivi.flatpakref
$ flatpak install --user http://flatpak.pitivi.org/pitivi.flatpakref
$ flatpak run org.pitivi.Pitivi//stable
-
```
### 音乐播放器
@@ -552,31 +554,32 @@ $ flatpak run org.pitivi.Pitivi//stable
[Rhythmbox][60] 支持海量种类的音乐，目前被认为是最可靠的音乐播放器，并由 Ubuntu 自带。
-使用以下命令在 Ubuntu 和 Debian 安装 `Rhythmbox`。
+使用以下命令在 Ubuntu 和 Debian 安装 Rhythmbox。
+
```
$ sudo add-apt-repository ppa:fossfreedom/rhythmbox
$ sudo apt-get update
$ sudo apt-get install rhythmbox
-
```
#### Lollypop
[Lollypop][61] 是一款较为年轻的开源音乐播放器，它有很多高级选项，包括网络电台，滑动播放和派对模式。尽管功能繁多，它仍然尽量做到简单易管理。
-使用以下命令在 Ubuntu 和 Debian 安装 `Lollypop`。
+使用以下命令在 Ubuntu 和 Debian 安装 Lollypop。
+
```
$ sudo add-apt-repository ppa:gnumdk/lollypop
$ sudo apt-get update
$ sudo apt-get install lollypop
-
```
#### Amarok
[Amarok][62] 是一款功能强大的音乐播放器，它有一个直观的 UI 和大量的高级功能，而且允许用户根据自己的偏好去发现新音乐。
-使用以下命令在 Ubuntu 和 Debian 安装 `Amarok`。
+使用以下命令在 Ubuntu 和 Debian 安装 Amarok。
+
```
$ sudo apt-get update
$ sudo apt-get install amarok
@@ -587,48 +590,48 @@ $ sudo apt-get install amarok
[Clementine][63] 是一款 Amarok 风格的音乐播放器，因此和 Amarok 相似，也有直观的用户界面、先进的控制模块，以及让用户搜索和发现新音乐的功能。
-使用以下命令在 Ubuntu 和 Debian 安装 `Clementine`。
+使用以下命令在 Ubuntu 和 Debian 安装 Clementine。
+
```
$ sudo add-apt-repository ppa:me-davidsansome/clementine
$ sudo apt-get update
$ sudo apt-get install clementine
-
```
#### Cmus
[Cmus][64] 可以说是最高效的的命令行界面音乐播放器了，它具有快速可靠的特点，也支持使用扩展。
-使用以下命令在 Ubuntu 和 Debian 安装 `Cmus`。
+使用以下命令在 Ubuntu 和 Debian 安装 Cmus。
+
```
$ sudo add-apt-repository ppa:jmuc/cmus
$ sudo apt-get update
$ sudo apt-get install cmus
-
```
### 办公软件
#### Calligra 套件
-Calligra 套件为用户提供了一套总共 8 个应用程序，涵盖办公、管理、图表等各个范畴。
+[Calligra 套件][65]为用户提供了一套总共 8 个应用程序，涵盖办公、管理、图表等各个范畴。
+
+使用以下命令在 Ubuntu 和 Debian 安装 Calligra 套件。
-使用以下命令在 Ubuntu 和 Debian 安装 `Calligra` 套件。
```
$ sudo apt-get install calligra
-
```
#### LibreOffice
[LibreOffice][66] 是开源社区中开发过程最活跃的办公套件，它以可靠性著称，也可以通过扩展来添加功能。
-使用以下命令在 Ubuntu 和 Debian 安装 `LibreOffice`。
+使用以下命令在 Ubuntu 和 Debian 安装 LibreOffice。
+
```
$ sudo add-apt-repository ppa:libreoffice/ppa
$ sudo apt update
$ sudo apt install libreoffice
-
```
#### WPS Office
@@ -643,35 +646,35 @@ $ sudo apt install libreoffice
[Shutter][69] 允许用户截取桌面的屏幕截图，然后使用一些效果进行编辑，还支持上传和在线共享。
-使用以下命令在 Ubuntu 和 Debian 安装 `Shutter`。
+使用以下命令在 Ubuntu 和 Debian 安装 Shutter。
+
```
$ sudo add-apt-repository -y ppa:shutter/ppa
$ sudo apt update
$ sudo apt install shutter
-
```
#### Kazam
[Kazam][70] 可以用于捕获屏幕截图，它的输出对于任何支持 VP8/WebM 和 PulseAudio 视频播放器都可用。
-使用以下命令在 Ubuntu 和 Debian 安装 `Kazam`。
+使用以下命令在 Ubuntu 和 Debian 安装 Kazam。
+
```
$ sudo add-apt-repository ppa:kazam-team/unstable-series
$ sudo apt update
$ sudo apt install kazam python3-cairo python3-xlib
-
```
#### Gnome Screenshot
[Gnome Screenshot][71] 过去曾经和 Gnome 一起捆绑，但现在已经独立出来。它以易于共享的格式进行截屏。
-使用以下命令在 Ubuntu 和 Debian 安装 `Gnome Screenshot`。
+使用以下命令在 Ubuntu 和 Debian 安装 Gnome Screenshot。
+
```
$ sudo apt-get update
$ sudo apt-get install gnome-screenshot
-
```
### 录屏工具
@@ -680,69 +683,69 @@ $ sudo apt-get install gnome-screenshot
[SimpleScreenRecorder][72] 面世时已经是录屏工具中的佼佼者，现在已成为 Linux 各个发行版中最有效、最易用的录屏工具之一。
-使用以下命令在 Ubuntu 和 Debian 安装 `SimpleScreenRecorder`。
+使用以下命令在 Ubuntu 和 Debian 安装 SimpleScreenRecorder。
+
```
$ sudo add-apt-repository ppa:maarten-baert/simplescreenrecorder
$ sudo apt-get update
$ sudo apt-get install simplescreenrecorder
-
```
#### recordMyDesktop
[recordMyDesktop][73] 是一个开源的会话记录器，它也能记录桌面会话的音频。
-使用以下命令在 Ubuntu 和 Debian 安装 `recordMyDesktop`。
+使用以下命令在 Ubuntu 和 Debian 安装 recordMyDesktop。
+
```
$ sudo apt-get update
$ sudo apt-get install gtk-recordmydesktop
-
```
-### Text Editors
+### 文本编辑器
#### Atom
[Atom][74] 是由 GitHub 开发和维护的可定制文本编辑器。它是开箱即用的，但也可以使用扩展和主题自定义 UI 来增强其功能。
-使用以下命令在 Ubuntu 和 Debian 安装 `Atom`。
+使用以下命令在 Ubuntu 和 Debian 安装 Atom。
+
```
$ sudo apt-get install snapd
$ sudo snap install atom --classic
-
```
#### Sublime Text
[Sublime Text][75] 已经成为目前最棒的文本编辑器。它可定制、轻量灵活（即使打开了大量数据文件和加入了大量扩展），最重要的是可以永久免费使用。
-使用以下命令在 Ubuntu 和 Debian 安装 `Sublime Text`。
+使用以下命令在 Ubuntu 和 Debian 安装 Sublime Text。
+
```
$ sudo apt-get install snapd
$ sudo snap install sublime-text
-
```
#### Geany
[Geany][76] 是一个内存友好的文本编辑器，它具有基本的IDE功能，可以显示加载时间、扩展库函数等。
-使用以下命令在 Ubuntu 和 Debian 安装 `Geany`。
+使用以下命令在 Ubuntu 和 Debian 安装 Geany。
+
```
$ sudo apt-get update
$ sudo apt-get install geany
-
```
#### Gedit
[Gedit][77] 以其简单著称，在很多 Linux 发行版都有预装，它具有文本编辑器都具有的优秀的功能。
-使用以下命令在 Ubuntu 和 Debian 安装 `Gedit`。
+使用以下命令在 Ubuntu 和 Debian 安装 Gedit。
+
```
$ sudo apt-get update
$ sudo apt-get install gedit
-
```
### 备忘录软件
@@ -763,11 +766,11 @@ Evernote 在 Linux 上没有官方提供的软件，但可以参考 [Linux 上
[Taskwarrior][81] 是一个用于管理个人任务的开源跨平台命令行应用，它的速度和无干扰的环境是它的两大特点。
-使用以下命令在 Ubuntu 和 Debian 安装 `Taskwarrior`。
+使用以下命令在 Ubuntu 和 Debian 安装 Taskwarrior。
+
```
$ sudo apt-get update
$ sudo apt-get install taskwarrior
-
```
### 视频播放器
@@ -776,49 +779,49 @@ $ sudo apt-get install taskwarrior
[Banshee][82] 是一个开源的支持多格式的媒体播放器，于 2005 年开始开发并逐渐成长。
-使用以下命令在 Ubuntu 和 Debian 安装 `Banshee`。
+使用以下命令在 Ubuntu 和 Debian 安装 Banshee。
+
```
$ sudo add-apt-repository ppa:banshee-team/ppa
$ sudo apt-get update
$ sudo apt-get install banshee
-
```
#### VLC
[VLC][83] 是我最喜欢的视频播放器，它几乎可以播放任何格式的音频和视频，它还可以播放网络电台、录制桌面会话以及在线播放电影。
-使用以下命令在 Ubuntu 和 Debian 安装 `VLC`。
+使用以下命令在 Ubuntu 和 Debian 安装 VLC。
+
```
$ sudo add-apt-repository ppa:videolan/stable-daily
$ sudo apt-get update
$ sudo apt-get install vlc
-
```
#### Kodi
[Kodi][84] 是世界上最着名的媒体播放器之一，它有一个成熟的媒体中心，可以播放本地和远程的多媒体文件。
-使用以下命令在 Ubuntu 和 Debian 安装 `Kodi`。
+使用以下命令在 Ubuntu 和 Debian 安装 Kodi。
+
```
$ sudo apt-get install software-properties-common
$ sudo add-apt-repository ppa:team-xbmc/ppa
$ sudo apt-get update
$ sudo apt-get install kodi
-
```
#### SMPlayer
[SMPlayer][85] 是 MPlayer 的 GUI 版本，所有流行的媒体格式它都能够处理，并且它还有从 YouTube 和 Chromcast 和下载字幕的功能。
-使用以下命令在 Ubuntu 和 Debian 安装 `SMPlayer`。
+使用以下命令在 Ubuntu 和 Debian 安装 SMPlayer。
+
```
$ sudo add-apt-repository ppa:rvm/smplayer
$ sudo apt-get update
$ sudo apt-get install smplayer
-
```
### 虚拟化工具
@@ -827,14 +830,14 @@ $ sudo apt-get install smplayer
[VirtualBox][86] 是一个用于操作系统虚拟化的开源应用程序，在服务器、台式机和嵌入式系统上都可以运行。
-使用以下命令在 Ubuntu 和 Debian 安装 `VirtualBox`。
+使用以下命令在 Ubuntu 和 Debian 安装 VirtualBox。
+
```
$ wget -q https://www.virtualbox.org/download/oracle_vbox_2016.asc -O- | sudo apt-key add -
$ wget -q https://www.virtualbox.org/download/oracle_vbox.asc -O- | sudo apt-key add -
$ sudo apt-get update
$ sudo apt-get install virtualbox-5.2
$ virtualbox
-
```
#### VMWare
@@ -849,34 +852,33 @@ $ virtualbox
[Google Chrome][89] 无疑是最受欢迎的浏览器。Chrome 以其速度、简洁、安全、美观而受人喜爱，它遵循了 Google 的界面设计风格，是 web 开发人员不可缺少的浏览器，同时它也是免费开源的。
-使用以下命令在 Ubuntu 和 Debian 安装 `Google Chrome`。
+使用以下命令在 Ubuntu 和 Debian 安装 Google Chrome。
+
```
$ wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
$ sudo sh -c 'echo "deb http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list'
$ sudo apt-get update
$ sudo apt-get install google-chrome-stable
-
```
#### Firefox
-[Firefox Quantum][90] 是一款漂亮、快速、完善并且可自定义的浏览器。它也是免费开源的，包含有开发人员所需要的工具，对于初学者也没有任何使用门槛。
+[Firefox Quantum][90] 是一款漂亮、快速、完善并且可自定义的浏览器。它也是自由开源的，包含有开发人员所需要的工具，对于初学者也没有任何使用门槛。
+
+使用以下命令在 Ubuntu 和 Debian 安装 Firefox Quantum。
-使用以下命令在 Ubuntu 和 Debian 安装 `Firefox Quantum`。
```
$ sudo add-apt-repository ppa:mozillateam/firefox-next
$ sudo apt update && sudo apt upgrade
$ sudo apt install firefox
-
```
#### Vivaldi
-[Vivaldi][91] 是一个基于 Chrome 的免费开源项目，旨在通过添加扩展来使 Chrome 的功能更加完善。色彩丰富的界面，性能良好、灵活性强是它的几大特点。
+[Vivaldi][91] 是一个基于 Chrome 的自由开源项目，旨在通过添加扩展来使 Chrome 的功能更加完善。色彩丰富的界面，性能良好、灵活性强是它的几大特点。
参考阅读：[在 Ubuntu 下载 Vivaldi][91]
-That concludes our list for today. Did I skip a famous title? Tell me about it in the comments section below.
以上就是我的推荐，你还有更好的软件向大家分享吗？欢迎评论。
--------------------------------------------------------------------------------
@@ -886,7 +888,7 @@ via: https://www.fossmint.com/most-used-linux-applications/
作者：[Martins D. Okoi][a]
选题：[lujun9972](https://github.com/lujun9972)
译者：[HankChow](https://github.com/HankChow)
-校对：[校对者ID](https://github.com/校对者ID)
+校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
diff --git a/translated/tech/20180928 10 handy Bash aliases for Linux.md b/published/20180928 10 handy Bash aliases for Linux.md
similarity index 57%
rename from translated/tech/20180928 10 handy Bash aliases for Linux.md
rename to published/20180928 10 handy Bash aliases for Linux.md
index 8706e56e8a..fe1c5098a1 100644
--- a/translated/tech/20180928 10 handy Bash aliases for Linux.md
+++ b/published/20180928 10 handy Bash aliases for Linux.md
@@ -1,102 +1,72 @@
10 个 Linux 中方便的 Bash 别名
======
-对 Bash 长命令使用压缩的版本来更有效率。
+> 对 Bash 长命令使用压缩的版本来更有效率。
你有多少次在命令行上输入一个长命令，并希望有一种方法可以保存它以供日后使用？这就是 Bash 别名派上用场的地方。它们允许你将长而神秘的命令压缩为易于记忆和使用的东西。需要一些例子来帮助你入门吗？没问题！
-要使用你创建的 Bash 别名，你需要将其添加到 .bash_profile 中，该文件位于你的主文件夹中。请注意，此文件是隐藏的，并只能从命令行访问。编辑此文件的最简单方法是使用 Vi 或 Nano 之类的东西。
+要使用你创建的 Bash 别名，你需要将其添加到 `.bash_profile` 中，该文件位于你的家目录中。请注意，此文件是隐藏的，并只能从命令行访问。编辑此文件的最简单方法是使用 Vi 或 Nano 之类的东西。
### 10 个方便的 Bash 别名
- 1. 你有几次遇到需要解压 .tar 文件但无法记住所需的确切参数？别名可以帮助你！只需将以下内容添加到 .bash_profile 中，然后使用 **untar FileName** 解压缩任何 .tar 文件。
-
+1、 你有几次遇到需要解压 .tar 文件但无法记住所需的确切参数？别名可以帮助你！只需将以下内容添加到 `.bash_profile` 中，然后使用 `untar FileName` 解压缩任何 .tar 文件。
```
alias untar='tar -zxvf '
-
```
-
- 2. 想要下载的东西，但如果出现问题可以恢复吗？
-
-
+2、 想要下载的东西，但如果出现问题可以恢复吗？
```
alias wget='wget -c '
-
```
- 3. 是否需要为新的网络帐户生成随机的 20 个字符的密码？没问题。
-
-
+3、 是否需要为新的网络帐户生成随机的 20 个字符的密码？没问题。
```
alias getpass="openssl rand -base64 20"
-
```
- 4. 下载文件并需要测试校验和？我们也可做到。
-
-
+4、 下载文件并需要测试校验和？我们也可做到。
```
alias sha='shasum -a 256 '
-
```
- 5. 普通的 ping 将永远持续下去。我们不希望这样。相反，让我们将其限制在五个 ping。
-
-
+5、 普通的 `ping` 将永远持续下去。我们不希望这样。相反，让我们将其限制在五个 `ping`。
```
alias ping='ping -c 5'
-
```
- 6. 在任何你想要的文件夹中启动 Web 服务器。
-
-
+6、 在任何你想要的文件夹中启动 Web 服务器。
```
alias www='python -m SimpleHTTPServer 8000'
-
```
- 7. 想知道你的网络有多快？只需下载 Speedtest-cli 并使用此别名即可。你可以使用 **speedtest-cli --list** 命令选择离你所在位置更近的服务器。
-
-
+7、 想知道你的网络有多快？只需下载 Speedtest-cli 并使用此别名即可。你可以使用 `speedtest-cli --list` 命令选择离你所在位置更近的服务器。
```
alias speed='speedtest-cli --server 2406 --simple'
-
```
- 8. 你有多少次需要知道你的外部 IP 地址，但是不知道如何获取？我也是。
-
-
+8、 你有多少次需要知道你的外部 IP 地址，但是不知道如何获取？我也是。
```
alias ipe='curl ipinfo.io/ip'
-
```
- 9. 需要知道你的本地 IP 地址？
-
-
+9、 需要知道你的本地 IP 地址？
```
alias ipi='ipconfig getifaddr en0'
-
```
- 10. 最后，让我们清空屏幕。
-
-
+10、 最后，让我们清空屏幕。
```
alias c='clear'
-
```
如你所见，Bash 别名是一种在命令行上简化生活的超级简便方法。想了解更多信息？我建议你 Google 搜索“Bash 别名”或在 Github 中看下。
@@ -108,7 +78,7 @@ via: https://opensource.com/article/18/9/handy-bash-aliases
作者：[Patrick H.Mullins][a]
选题：[lujun9972](https://github.com/lujun9972)
译者：[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/) 荣誉推出
diff --git a/sources/tech/20180201 Rock Solid React.js Foundations A Beginners Guide.md b/sources/tech/20180201 Rock Solid React.js Foundations A Beginners Guide.md
deleted file mode 100644
index 98a1a8f392..0000000000
--- a/sources/tech/20180201 Rock Solid React.js Foundations A Beginners Guide.md
+++ /dev/null
@@ -1,292 +0,0 @@
-GraveAccent翻译中 Rock Solid React.js Foundations: A Beginner’s Guide
-============================================================
- ** 此处有Canvas,请手动处理 **
-
-
-React.js crash course
-
-I’ve been working with React and React-Native for the last couple of months. I have already released two apps in production, [Kiven Aa][1] (React) and [Pollen Chat][2] (React Native). When I started learning React, I was searching for something (a blog, a video, a course, whatever) that didn’t only teach me how to write apps in React. I also wanted it to prepare me for interviews.
-
-Most of the material I found, concentrated on one or the other. So, this post is aimed towards the audience who is looking for a perfect mix of theory and hands-on. I will give you a little bit of theory so that you understand what is happening under the hood and then I will show you how to write some React.js code.
-
-If you prefer video, I have this entire course up on YouTube as well. Please check that out.
-
-
-Let’s dive in…
-
-> React.js is a JavaScript library for building user interfaces
-
-You can build all sorts of single page applications. For example, chat messengers and e-commerce portals where you want to show changes on the user interface in real-time.
-
-### Everything’s a component
-
-A React app is comprised of components, _a lot of them_ , nested into one another. _But what are components, you may ask?_
-
-A component is a reusable piece of code, which defines how certain features should look and behave on the UI. For example, a button is a component.
-
-Let’s look at the following calculator, which you see on Google when you try to calculate something like 2+2 = 4 –1 = 3 (quick maths!)
-
-
-
-Red markers denote components
-
-As you can see in the image above, the calculator has many areas — like the _result display window_ and the _numpad_ . All of these can be separate components or one giant component. It depends on how comfortable one is in breaking down and abstracting away things in React
-
-You write code for all such components separately. Then combine those under one container, which in turn is a React component itself. This way you can create reusable components and your final app will be a collection of separate components working together.
-
-The following is one such way you can write the calculator, shown above, in React.
-
-```
-
-
-
-
-
- .
- .
- .
-
-
-
-
-```
-
-Yes! It looks like HTML code, but it isn’t. We will explore more about it in the later sections.
-
-### Setting up our Playground
-
-This tutorial focuses on React’s fundamentals. It is not primarily geared towards React for Web or [React Native][3] (for building mobile apps). So, we will use an online editor so as to avoid web or native specific configurations before even learning what React can do.
-
-I’ve already set up an environment for you on [codepen.io][4]. Just follow the link and read all the comments in HTML and JavaScript (JS) tabs.
-
-### Controlling Components
-
-We’ve learned that a React app is a collection of various components, structured as a nested tree. Thus, we require some sort of mechanism to pass data from one component to other.
-
-#### Enter “props”
-
-We can pass arbitrary data to our component using a `props` object. Every component in React gets this `props` object.
-
-Before learning how to use this `props` object, let’s learn about functional components.
-
-#### a) Functional component
-
-A functional component in React consumes arbitrary data that you pass to it using `props` object. It returns an object which describes what UI React should render. Functional components are also known as Stateless components.
-
-Let’s write our first functional component.
-
-```
-function Hello(props) {
- return
{props.name}
-}
-```
-
-It’s that simple. We just passed `props` as an argument to a plain JavaScript function and returned, _umm, well, what was that? That _ `_
{props.name}
_` _thing!_ It’s JSX (JavaScript Extended). We will learn more about it in a later section.
-
-This above function will render the following HTML in the browser.
-
-```
-
-
- rajat
-
-```
-
-
-> Read the section below about JSX, where I have explained how did we get this HTML from our JSX code.
-
-How can you use this functional component in your React app? Glad you asked! It’s as simple as the following.
-
-```
-
-```
-
-The attribute `name` in the above code becomes `props.name` inside our `Hello`component. The attribute `age` becomes `props.age` and so on.
-
-> Remember! You can nest one React component inside other React components.
-
-Let’s use this `Hello` component in our codepen playground. Replace the `div`inside `ReactDOM.render()` with our `Hello` component, as follows, and see the changes in the bottom window.
-
-```
-function Hello(props) {
- return
{props.name}
-}
-
-ReactDOM.render(, document.getElementById('root'));
-```
-
-
-> But what if your component has some internal state. For instance, like the following counter component, which has an internal count variable, which changes on + and — key presses.
-
-A React component with an internal state
-
-#### b) Class-based component
-
-The class-based component has an additional property `state` , which you can use to hold a component’s private data. We can rewrite our `Hello` component using class notation as follows. Since these components have a state, these are also known as Stateful components.
-
-```
-class Counter extends React.Component {
- // this method should be present in your component
- render() {
- return (
-
- {this.props.name}
-
- );
- }
-}
-```
-
-We extend `React.Component` class of React library to make class-based components in React. Learn more about JavaScript classes [here][5].
-
-The `render()` method must be present in your class as React looks for this method in order to know what UI it should render on screen.
-
-To use this sort of internal state, we first have to initialize the `state` object in the constructor of the component class, in the following way.
-
-```
-class Counter extends React.Component {
- constructor() {
- super();
-
- // define the internal state of the component
- this.state = {name: 'rajat'}
- }
-
- render() {
- return (
-
- {this.state.name}
-
- );
- }
-}
-
-// Usage:
-// In your react app:
-```
-
-Similarly, the `props` can be accessed inside our class-based component using `this.props` object.
-
-To set the state, you use `React.Component`'s `setState()`. We will see an example of this, in the last part of this tutorial.
-
-> Tip: Never call `setState()` inside `render()` function, as `setState()` causes component to re-render and this will result in endless loop.
-
-
-
-A class-based component has an optional property “state”.
-
- _Apart from _ `_state_` _, a class-based component has some life-cycle methods like _ `_componentWillMount()._` _ These you can use to do stuff, like initializing the _ `_state_` _and all but that is out of the scope of this post._
-
-### JSX
-
-JSX is a short form of _JavaScript Extended_ and it is a way to write `React`components. Using JSX, you get the full power of JavaScript inside XML like tags.
-
-You put JavaScript expressions inside `{}`. The following are some valid JSX examples.
-
- ```
-
-
- ;
-
-
-
- ```
-
-The way it works is you write JSX to describe what your UI should look like. A [transpiler][6] like `Babel` converts that code into a bunch of `React.createElement()` calls. The React library then uses those `React.createElement()` calls to construct a tree-like structure of DOM elements. In case of React for Web or Native views in case of React Native. It keeps it in the memory.
-
-React then calculates how it can effectively mimic this tree in the memory of the UI displayed to the user. This process is known as [reconciliation][7]. After that calculation is done, React makes the changes to the actual UI on the screen.
-
- ** 此处有Canvas,请手动处理 **
-
-
-How React converts your JSX into a tree which describes your app’s UI
-
-You can use [Babel’s online REPL][8] to see what React actually outputs when you write some JSX.
-
-
-
-Use Babel REPL to transform JSX into plain JavaScript
-
-> Since JSX is just a syntactic sugar over plain `React.createElement()` calls, React can be used without JSX.
-
-Now we have every concept in place, so we are well positioned to write a `counter` component that we saw earlier as a GIF.
-
-The code is as follows and I hope that you already know how to render that in our playground.
-
-```
-class Counter extends React.Component {
- constructor(props) {
- super(props);
-
- this.state = {count: this.props.start || 0}
-
- // the following bindings are necessary to make `this` work in the callback
- this.inc = this.inc.bind(this);
- this.dec = this.dec.bind(this);
- }
-
- inc() {
- this.setState({
- count: this.state.count + 1
- });
- }
-
- dec() {
- this.setState({
- count: this.state.count - 1
- });
- }
-
- render() {
- return (
-
-
-
-
{this.state.count}
-
- );
- }
-}
-```
-
-The following are some salient points about the above code.
-
-1. JSX uses `camelCasing` hence `button`'s attribute is `onClick`, not `onclick`, as we use in HTML.
-
-2. Binding is necessary for `this` to work on callbacks. See line #8 and 9 in the code above.
-
-The final interactive code is located [here][9].
-
-With that, we’ve reached the conclusion of our React crash course. I hope I have shed some light on how React works and how you can use React to build bigger apps, using smaller and reusable components.
-
-* * *
-
-If you have any queries or doubts, hit me up on Twitter [@rajat1saxena][10] or write to me at [rajat@raynstudios.com][11].
-
-* * *
-
-#### Please recommend this post, if you liked it and share it with your network. Follow me for more tech related posts and consider subscribing to my channel [Rayn Studios][12] on YouTube. Thanks a lot.
-
---------------------------------------------------------------------------------
-
-via: https://medium.freecodecamp.org/rock-solid-react-js-foundations-a-beginners-guide-c45c93f5a923
-
-作者：[Rajat Saxena ][a]
-译者：[译者ID](https://github.com/译者ID)
-校对：[校对者ID](https://github.com/校对者ID)
-
-本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
-
-[a]:https://medium.freecodecamp.org/@rajat1saxena
-[1]:https://kivenaa.com/
-[2]:https://play.google.com/store/apps/details?id=com.pollenchat.android
-[3]:https://facebook.github.io/react-native/
-[4]:https://codepen.io/raynesax/pen/MrNmBM
-[5]:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes
-[6]:https://en.wikipedia.org/wiki/Source-to-source_compiler
-[7]:https://reactjs.org/docs/reconciliation.html
-[8]:https://babeljs.io/repl
-[9]:https://codepen.io/raynesax/pen/QaROqK
-[10]:https://twitter.com/rajat1saxena
-[11]:mailto:rajat@raynstudios.com
-[12]:https://www.youtube.com/channel/UCUmQhjjF9bsIaVDJUHSIIKw
diff --git a/sources/tech/20180703 Install Oracle VirtualBox On Ubuntu 18.04 LTS Headless Server.md b/sources/tech/20180703 Install Oracle VirtualBox On Ubuntu 18.04 LTS Headless Server.md
deleted file mode 100644
index 20ce979026..0000000000
--- a/sources/tech/20180703 Install Oracle VirtualBox On Ubuntu 18.04 LTS Headless Server.md
+++ /dev/null
@@ -1,321 +0,0 @@
-Translating by qhwdw
-Install Oracle VirtualBox On Ubuntu 18.04 LTS Headless Server
-======
-
-
-
-This step by step tutorial walk you through how to install **Oracle VirtualBox** on Ubuntu 18.04 LTS headless server. And, this guide also describes how to manage the VirtualBox headless instances using **phpVirtualBox** , a web-based front-end tool for VirtualBox. The steps described below might also work on Debian, and other Ubuntu derivatives such as Linux Mint. Let us get started.
-
-### Prerequisites
-
-Before installing Oracle VirtualBox, we need to do the following prerequisites in our Ubuntu 18.04 LTS server.
-
-First of all, update the Ubuntu server by running the following commands one by one.
-```
-$ sudo apt update
-
-$ sudo apt upgrade
-
-$ sudo apt dist-upgrade
-
-```
-
-Next, install the following necessary packages:
-```
-$ sudo apt install build-essential dkms unzip wget
-
-```
-
-After installing all updates and necessary prerequisites, restart the Ubuntu server.
-```
-$ sudo reboot
-
-```
-
-### Install Oracle VirtualBox on Ubuntu 18.04 LTS server
-
-Add Oracle VirtualBox official repository. To do so, edit **/etc/apt/sources.list** file:
-```
-$ sudo nano /etc/apt/sources.list
-
-```
-
-Add the following lines.
-
-Here, I will be using Ubuntu 18.04 LTS, so I have added the following repository.
-```
-deb http://download.virtualbox.org/virtualbox/debian bionic contrib
-
-```
-
-![][2]
-
-Replace the word **‘bionic’** with your Ubuntu distribution’s code name, such as ‘xenial’, ‘vivid’, ‘utopic’, ‘trusty’, ‘raring’, ‘quantal’, ‘precise’, ‘lucid’, ‘jessie’, ‘wheezy’, or ‘squeeze**‘.**
-
-Then, run the following command to add the Oracle public key:
-```
-$ wget -q https://www.virtualbox.org/download/oracle_vbox_2016.asc -O- | sudo apt-key add -
-
-```
-
-For VirtualBox older versions, add the following key:
-```
-$ wget -q https://www.virtualbox.org/download/oracle_vbox.asc -O- | sudo apt-key add -
-
-```
-
-Next, update the software sources using command:
-```
-$ sudo apt update
-
-```
-
-Finally, install latest Oracle VirtualBox latest version using command:
-```
-$ sudo apt install virtualbox-5.2
-
-```
-
-### Adding users to VirtualBox group
-
-We need to create and add our system user to the **vboxusers** group. You can either create a separate user and assign it to vboxusers group or use the existing user. I don’t want to create a new user, so I added my existing user to this group. Please note that if you use a separate user for virtualbox, you must log out and log in to that particular user and do the rest of the steps.
-
-I am going to use my username named **sk** , so, I ran the following command to add it to the vboxusers group.
-```
-$ sudo usermod -aG vboxusers sk
-
-```
-
-Now, run the following command to check if virtualbox kernel modules are loaded or not.
-```
-$ sudo systemctl status vboxdrv
-
-```
-
-![][3]
-
-As you can see in the above screenshot, the vboxdrv module is loaded and running!
-
-For older Ubuntu versions, run:
-```
-$ sudo /etc/init.d/vboxdrv status
-
-```
-
-If the virtualbox module doesn’t start, run the following command to start it.
-```
-$ sudo /etc/init.d/vboxdrv setup
-
-```
-
-Great! We have successfully installed VirtualBox and started virtualbox module. Now, let us go ahead and install Oracle VirtualBox extension pack.
-
-### Install VirtualBox Extension pack
-
-The VirtualBox Extension pack provides the following functionalities to the VirtualBox guests.
-
- * The virtual USB 2.0 (EHCI) device
- * VirtualBox Remote Desktop Protocol (VRDP) support
- * Host webcam passthrough
- * Intel PXE boot ROM
- * Experimental support for PCI passthrough on Linux hosts
-
-
-
-Download the latest Extension pack for VirtualBox 5.2.x from [**here**][4].
-```
-$ wget https://download.virtualbox.org/virtualbox/5.2.14/Oracle_VM_VirtualBox_Extension_Pack-5.2.14.vbox-extpack
-
-```
-
-Install Extension pack using command:
-```
-$ sudo VBoxManage extpack install Oracle_VM_VirtualBox_Extension_Pack-5.2.14.vbox-extpack
-
-```
-
-Congratulations! We have successfully installed Oracle VirtualBox with extension pack in Ubuntu 16.04 LTS server. It is time to deploy virtual machines. Refer the [**virtualbox official guide**][5] to start creating and managing virtual machines in command line.
-
-Not everyone is command line expert. Some of you might want to create and use virtual machines graphically. No worries! Here is where **phpVirtualBox** comes in handy!!
-
-### About phpVirtualBox
-
-**phpVirtualBox** is a free, web-based front-end to Oracle VirtualBox. It is written using PHP language. Using phpVirtualBox, we can easily create, delete, manage and administer virtual machines via a web browser from any remote system on the network.
-
-### Install phpVirtualBox in Ubuntu 18.04 LTS
-
-Since it is a web-based tool, we need to install Apache web server, PHP and some php modules.
-
-To do so, run:
-```
-$ sudo apt install apache2 php php-mysql libapache2-mod-php php-soap php-xml
-
-```
-
-Then, Download the phpVirtualBox 5.2.x version from the [**releases page**][6]. Please note that we have installed VirtualBox 5.2, so we must install phpVirtualBox version 5.2 as well.
-
-To download it, run:
-```
-$ wget https://github.com/phpvirtualbox/phpvirtualbox/archive/5.2-0.zip
-
-```
-
-Extract the downloaded archive with command:
-```
-$ unzip 5.2-0.zip
-
-```
-
-This command will extract the contents of 5.2.0.zip file into a folder named “phpvirtualbox-5.2-0”. Now, copy or move the contents of this folder to your apache web server root folder.
-```
-$ sudo mv phpvirtualbox-5.2-0/ /var/www/html/phpvirtualbox
-
-```
-
-Assign the proper permissions to the phpvirtualbox folder.
-```
-$ sudo chmod 777 /var/www/html/phpvirtualbox/
-
-```
-
-Next, let us configure phpVirtualBox.
-
-Copy the sample config file as shown below.
-```
-$ sudo cp /var/www/html/phpvirtualbox/config.php-example /var/www/html/phpvirtualbox/config.php
-
-```
-
-Edit phpVirtualBox **config.php** file:
-```
-$ sudo nano /var/www/html/phpvirtualbox/config.php
-
-```
-
-Find the following lines and replace the username and password with your system user (The same username that we used in “Adding users to VirtualBox group” section).
-
-In my case, my Ubuntu system username is **sk** , and its password is **ubuntu**.
-```
-var $username = 'sk';
-var $password = 'ubuntu';
-
-```
-
-![][7]
-
-Save and close the file.
-
-Next, create a new file called **/etc/default/virtualbox** :
-```
-$ sudo nano /etc/default/virtualbox
-
-```
-
-Add the following line. Replace ‘sk’ with your own username.
-```
-VBOXWEB_USER=sk
-
-```
-
-Finally, Reboot your system or simply restart the following services to complete the configuration.
-```
-$ sudo systemctl restart vboxweb-service
-
-$ sudo systemctl restart vboxdrv
-
-$ sudo systemctl restart apache2
-
-```
-
-### Adjust firewall to allow Apache web server
-
-By default, the apache web browser can’t be accessed from remote systems if you have enabled the UFW firewall in Ubuntu 18.04 LTS. You must allow the http and https traffic via UFW by following the below steps.
-
-First, let us view which applications have installed a profile using command:
-```
-$ sudo ufw app list
-Available applications:
-Apache
-Apache Full
-Apache Secure
-OpenSSH
-
-```
-
-As you can see, Apache and OpenSSH applications have installed UFW profiles.
-
-If you look into the **“Apache Full”** profile, you will see that it enables traffic to the ports **80** and **443** :
-```
-$ sudo ufw app info "Apache Full"
-Profile: Apache Full
-Title: Web Server (HTTP,HTTPS)
-Description: Apache v2 is the next generation of the omnipresent Apache web
-server.
-
-Ports:
-80,443/tcp
-
-```
-
-Now, run the following command to allow incoming HTTP and HTTPS traffic for this profile:
-```
-$ sudo ufw allow in "Apache Full"
-Rules updated
-Rules updated (v6)
-
-```
-
-If you want to allow https traffic, but only http (80) traffic, run:
-```
-$ sudo ufw app info "Apache"
-
-```
-
-### Access phpVirtualBox Web console
-
-Now, go to any remote system that has graphical web browser.
-
-In the address bar, type: ****.
-
-In my case, I navigated to this link – ****
-
-You should see the following screen. Enter the phpVirtualBox administrative user credentials.
-
-The default username and phpVirtualBox is **admin** / **admin**.
-
-![][8]
-
-Congratulations! You will now be greeted with phpVirtualBox dashboard.
-
-![][9]
-
-Now, start creating your VMs and manage them from phpvirtualbox dashboard. As I mentioned earlier, You can access the phpVirtualBox from any system in the same network. All you need is a web browser and the username and password of phpVirtualBox.
-
-If you haven’t enabled virtualization support in the BISO of host system (not the guest), phpVirtualBox allows you to create 32-bit guests only. To install 64-bit guest systems, you must enable virtualization in your host system’s BIOS. Look for an option that is something like “virtualization” or “hypervisor” in your bios and make sure it is enabled.
-
-That’s it. Hope this helps. If you find this guide useful, please share it on your social networks and support us.
-
-More good stuffs to come. Stay tuned!
-
-
---------------------------------------------------------------------------------
-
-via: https://www.ostechnix.com/install-oracle-virtualbox-ubuntu-16-04-headless-server/
-
-作者：[SK][a]
-选题：[lujun9972](https://github.com/lujun9972)
-译者：[译者ID](https://github.com/译者ID)
-校对：[校对者ID](https://github.com/校对者ID)
-
-本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
-
-[a]:https://www.ostechnix.com/author/sk/
-[1]:data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7
-[2]:http://www.ostechnix.com/wp-content/uploads/2016/07/Add-VirtualBox-repository.png
-[3]:http://www.ostechnix.com/wp-content/uploads/2016/07/vboxdrv-service.png
-[4]:https://www.virtualbox.org/wiki/Downloads
-[5]:http://www.virtualbox.org/manual/ch08.html
-[6]:https://github.com/phpvirtualbox/phpvirtualbox/releases
-[7]:http://www.ostechnix.com/wp-content/uploads/2016/07/phpvirtualbox-config.png
-[8]:http://www.ostechnix.com/wp-content/uploads/2016/07/phpvirtualbox-1.png
-[9]:http://www.ostechnix.com/wp-content/uploads/2016/07/phpvirtualbox-2.png
diff --git a/sources/tech/20180704 Setup Headless Virtualization Server Using KVM In Ubuntu 18.04 LTS.md b/sources/tech/20180704 Setup Headless Virtualization Server Using KVM In Ubuntu 18.04 LTS.md
deleted file mode 100644
index 3125a1a4ee..0000000000
--- a/sources/tech/20180704 Setup Headless Virtualization Server Using KVM In Ubuntu 18.04 LTS.md
+++ /dev/null
@@ -1,333 +0,0 @@
-Translating by qhwdw
-Setup Headless Virtualization Server Using KVM In Ubuntu 18.04 LTS
-======
-
-
-
-We already have covered [**setting up Oracle VirtualBox on Ubuntu 18.04**][1] headless server. In this tutorial, we will be discussing how to setup headless virtualization server using **KVM** and how to manage the guest machines from a remote client. As you may know already, KVM ( **K** ernel-based **v** irtual **m** achine) is an open source, full virtualization for Linux. Using KVM, we can easily turn any Linux server in to a complete virtualization environment in minutes and deploy different kind of VMs such as GNU/Linux, *BSD, Windows etc.
-
-### Setup Headless Virtualization Server Using KVM
-
-I tested this guide on Ubuntu 18.04 LTS server, however this tutorial will work on other Linux distributions such as Debian, CentOS, RHEL and Scientific Linux. This method will be perfectly suitable for those who wants to setup a simple virtualization environment in a Linux server that doesn’t have any graphical environment.
-
-For the purpose of this guide, I will be using two systems.
-
-**KVM virtualization server:**
-
- * **Host OS** – Ubuntu 18.04 LTS minimal server (No GUI)
- * **IP Address of Host OS** : 192.168.225.22/24
- * **Guest OS** (Which we are going to host on Ubuntu 18.04) : Ubuntu 16.04 LTS server
-
-
-
-**Remote desktop client :**
-
- * **OS** – Arch Linux
-
-
-
-### Install KVM
-
-First, let us check if our system supports hardware virtualization. To do so, run the following command from the Terminal:
-```
-$ egrep -c '(vmx|svm)' /proc/cpuinfo
-
-```
-
-If the result is **zero (0)** , the system doesn’t support hardware virtualization or the virtualization is disabled in the Bios. Go to your bios and check for the virtualization option and enable it.
-
-if the result is **1** or **more** , the system will support hardware virtualization. However, you still need to enable the virtualization option in Bios before running the above commands.
-
-Alternatively, you can use the following command to verify it. You need to install kvm first as described below, in order to use this command.
-```
-$ kvm-ok
-
-```
-
-**Sample output:**
-```
-INFO: /dev/kvm exists
-KVM acceleration can be used
-
-```
-
-If you got the following error instead, you still can run guest machines in KVM, but the performance will be very poor.
-```
-INFO: Your CPU does not support KVM extensions
-INFO: For more detailed results, you should run this as root
-HINT: sudo /usr/sbin/kvm-ok
-
-```
-
-Also, there are other ways to find out if your CPU supports Virtualization or not. Refer the following guide for more details.
-
-Next, Install KVM and other required packages to setup a virtualization environment in Linux.
-
-On Ubuntu and other DEB based systems, run:
-```
-$ sudo apt-get install qemu-kvm libvirt-bin virtinst bridge-utils cpu-checker
-
-```
-
-Once KVM installed, start libvertd service (If it is not started already):
-```
-$ sudo systemctl enable libvirtd
-
-$ sudo systemctl start libvirtd
-
-```
-
-### Create Virtual machines
-
-All virtual machine files and other related files will be stored under **/var/lib/libvirt/**. The default path of ISO images is **/var/lib/libvirt/boot/**.
-
-First, let us see if there is any virtual machines. To view the list of available virtual machines, run:
-```
-$ sudo virsh list --all
-
-```
-
-**Sample output:**
-```
-Id Name State
-----------------------------------------------------
-
-```
-
-![][3]
-
-As you see above, there is no virtual machine available right now.
-
-Now, let us crate one.
-
-For example, let us create Ubuntu 16.04 Virtual machine with 512 MB RAM, 1 CPU core, 8 GB Hdd.
-```
-$ sudo virt-install --name Ubuntu-16.04 --ram=512 --vcpus=1 --cpu host --hvm --disk path=/var/lib/libvirt/images/ubuntu-16.04-vm1,size=8 --cdrom /var/lib/libvirt/boot/ubuntu-16.04-server-amd64.iso --graphics vnc
-
-```
-
-Please make sure you have Ubuntu 16.04 ISO image in path **/var/lib/libvirt/boot/** or any other path you have given in the above command.
-
-**Sample output:**
-```
-WARNING Graphics requested but DISPLAY is not set. Not running virt-viewer.
-WARNING No console to launch for the guest, defaulting to --wait -1
-
-Starting install...
-Creating domain... | 0 B 00:00:01
-Domain installation still in progress. Waiting for installation to complete.
-Domain has shutdown. Continuing.
-Domain creation completed.
-Restarting guest.
-
-```
-
-![][4]
-
-Let us break down the above command and see what each option do.
-
- * **–name** : This option defines the name of the virtual name. In our case, the name of VM is **Ubuntu-16.04**.
- * **–ram=512** : Allocates 512MB RAM to the VM.
- * **–vcpus=1** : Indicates the number of CPU cores in the VM.
- * **–cpu host** : Optimizes the CPU properties for the VM by exposing the host’s CPU’s configuration to the guest.
- * **–hvm** : Request the full hardware virtualization.
- * **–disk path** : The location to save VM’s hdd and it’s size. In our example, I have allocated 8GB hdd size.
- * **–cdrom** : The location of installer ISO image. Please note that you must have the actual ISO image in this location.
- * **–graphics vnc** : Allows VNC access to the VM from a remote client.
-
-
-
-### Access Virtual machines using VNC client
-
-Now, go to the remote Desktop system. SSH to the Ubuntu server(Virtualization server) as shown below.
-
-Here, **sk** is my Ubuntu server’s user name and **192.168.225.22** is its IP address.
-
-Run the following command to find out the VNC port number. We need this to access the Vm from a remote system.
-```
-$ sudo virsh dumpxml Ubuntu-16.04 | grep vnc
-
-```
-
-**Sample output:**
-```
-
-
-```
-
-![][5]
-
-Note down the port number **5900**. Install any VNC client application. For this guide, I will be using TigerVnc. TigerVNC is available in the Arch Linux default repositories. To install it on Arch based systems, run:
-```
-$ sudo pacman -S tigervnc
-
-```
-
-Type the following SSH port forwarding command from your remote client system that has VNC client application installed.
-
-Again, **192.168.225.22** is my Ubuntu server’s (virtualization server) IP address.
-
-Then, open the VNC client from your Arch Linux (client).
-
-Type **localhost:5900** in the VNC server field and click **Connect** button.
-
-![][6]
-
-Then start installing the Ubuntu VM as the way you do in the physical system.
-
-![][7]
-
-![][8]
-
-Similarly, you can setup as many as virtual machines depending upon server hardware specifications.
-
-Alternatively, you can use **virt-viewer** utility in order to install operating system in the guest machines. virt-viewer is available in the most Linux distribution’s default repositories. After installing virt-viewer, run the following command to establish VNC access to the VM.
-```
-$ sudo virt-viewer --connect=qemu+ssh://192.168.225.22/system --name Ubuntu-16.04
-
-```
-
-### Manage virtual machines
-
-Managing VMs from the command-line using virsh management user interface is very interesting and fun. The commands are very easy to remember. Let us see some examples.
-
-To view the list of running VMs, run:
-```
-$ sudo virsh list
-
-```
-
-Or,
-```
-$ sudo virsh list --all
-
-```
-
-**Sample output:**
-```
- Id Name State
-----------------------------------------------------
- 2 Ubuntu-16.04 running
-
-```
-
-![][9]
-
-To start a VM, run:
-```
-$ sudo virsh start Ubuntu-16.04
-
-```
-
-Alternatively, you can use the VM id to start it.
-
-![][10]
-
-As you see in the above output, Ubuntu 16.04 virtual machine’s Id is 2. So, in order to start it, just specify its Id like below.
-```
-$ sudo virsh start 2
-
-```
-
-To restart a VM, run:
-```
-$ sudo virsh reboot Ubuntu-16.04
-
-```
-
-**Sample output:**
-```
-Domain Ubuntu-16.04 is being rebooted
-
-```
-
-![][11]
-
-To pause a running VM, run:
-```
-$ sudo virsh suspend Ubuntu-16.04
-
-```
-
-**Sample output:**
-```
-Domain Ubuntu-16.04 suspended
-
-```
-
-To resume the suspended VM, run:
-```
-$ sudo virsh resume Ubuntu-16.04
-
-```
-
-**Sample output:**
-```
-Domain Ubuntu-16.04 resumed
-
-```
-
-To shutdown a VM, run:
-```
-$ sudo virsh shutdown Ubuntu-16.04
-
-```
-
-**Sample output:**
-```
-Domain Ubuntu-16.04 is being shutdown
-
-```
-
-To completely remove a VM, run:
-```
-$ sudo virsh undefine Ubuntu-16.04
-
-$ sudo virsh destroy Ubuntu-16.04
-
-```
-
-**Sample output:**
-```
-Domain Ubuntu-16.04 destroyed
-
-```
-
-![][12]
-
-For more options, I recommend you to look into the man pages.
-```
-$ man virsh
-
-```
-
-That’s all for now folks. Start playing with your new virtualization environment. KVM virtualization will be opt for research & development and testing purposes, but not limited to. If you have sufficient hardware, you can use it for large production environments. Have fun and don’t forget to leave your valuable comments in the comment section below.
-
-Cheers!
-
-
-
---------------------------------------------------------------------------------
-
-via: https://www.ostechnix.com/setup-headless-virtualization-server-using-kvm-ubuntu/
-
-作者：[SK][a]
-选题：[lujun9972](https://github.com/lujun9972)
-译者：[译者ID](https://github.com/译者ID)
-校对：[校对者ID](https://github.com/校对者ID)
-
-本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
-
-[a]:https://www.ostechnix.com/author/sk/
-[1]:https://www.ostechnix.com/install-oracle-virtualbox-ubuntu-16-04-headless-server/
-[2]:data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7
-[3]:http://www.ostechnix.com/wp-content/uploads/2016/11/sk@ubuntuserver-_001.png
-[4]:http://www.ostechnix.com/wp-content/uploads/2016/11/sk@ubuntuserver-_008-1.png
-[5]:http://www.ostechnix.com/wp-content/uploads/2016/11/sk@ubuntuserver-_002.png
-[6]:http://www.ostechnix.com/wp-content/uploads/2016/11/VNC-Viewer-Connection-Details_005.png
-[7]:http://www.ostechnix.com/wp-content/uploads/2016/11/QEMU-Ubuntu-16.04-TigerVNC_006.png
-[8]:http://www.ostechnix.com/wp-content/uploads/2016/11/QEMU-Ubuntu-16.04-TigerVNC_007.png
-[9]:http://www.ostechnix.com/wp-content/uploads/2016/11/sk@ubuntuserver-_010-1.png
-[10]:http://www.ostechnix.com/wp-content/uploads/2016/11/sk@ubuntuserver-_010-2.png
-[11]:http://www.ostechnix.com/wp-content/uploads/2016/11/sk@ubuntuserver-_011-1.png
-[12]:http://www.ostechnix.com/wp-content/uploads/2016/11/sk@ubuntuserver-_012.png
diff --git a/sources/tech/20180824 What Stable Kernel Should I Use.md b/sources/tech/20180824 What Stable Kernel Should I Use.md
deleted file mode 100644
index 52b77498c5..0000000000
--- a/sources/tech/20180824 What Stable Kernel Should I Use.md
+++ /dev/null
@@ -1,140 +0,0 @@
-Translating by qhwdw
-What Stable Kernel Should I Use?
-======
-I get a lot of questions about people asking me about what stable kernel should they be using for their product/device/laptop/server/etc. all the time. Especially given the now-extended length of time that some kernels are being supported by me and others, this isn’t always a very obvious thing to determine. So this post is an attempt to write down my opinions on the matter. Of course, you are free to use what ever kernel version you want, but here’s what I recommend.
-
-As always, the opinions written here are my own, I speak for no one but myself.
-
-### What kernel to pick
-
-Here’s the my short list of what kernel you should use, raked from best to worst options. I’ll go into the details of all of these below, but if you just want the summary of all of this, here it is:
-
-Hierarchy of what kernel to use, from best solution to worst:
-
- * Supported kernel from your favorite Linux distribution
- * Latest stable release
- * Latest LTS release
- * Older LTS release that is still being maintained
-
-
-
-What kernel to never use:
-
- * Unmaintained kernel release
-
-
-
-To give numbers to the above, today, as of August 24, 2018, the front page of kernel.org looks like this:
-
-![][1]
-
-So, based on the above list that would mean that:
-
- * 4.18.5 is the latest stable release
- * 4.14.67 is the latest LTS release
- * 4.9.124, 4.4.152, and 3.16.57 are the older LTS releases that are still being maintained
- * 4.17.19 and 3.18.119 are “End of Life” kernels that have had a release in the past 60 days, and as such stick around on the kernel.org site for those who still might want to use them.
-
-
-
-Quite easy, right?
-
-Ok, now for some justification for all of this:
-
-### Distribution kernels
-
-The best solution for almost all Linux users is to just use the kernel from your favorite Linux distribution. Personally, I prefer the community based Linux distributions that constantly roll along with the latest updated kernel and it is supported by that developer community. Distributions in this category are Fedora, openSUSE, Arch, Gentoo, CoreOS, and others.
-
-All of these distributions use the latest stable upstream kernel release and make sure that any needed bugfixes are applied on a regular basis. That is the one of the most solid and best kernel that you can use when it comes to having the latest fixes ([remember all fixes are security fixes][2]) in it.
-
-There are some community distributions that take a bit longer to move to a new kernel release, but eventually get there and support the kernel they currently have quite well. Those are also great to use, and examples of these are Debian and Ubuntu.
-
-Just because I did not list your favorite distro here does not mean its kernel is not good. Look on the web site for the distro and make sure that the kernel package is constantly updated with the latest security patches, and all should be well.
-
-Lots of people seem to like the old, “traditional” model of a distribution and use RHEL, SLES, CentOS or the “LTS” Ubuntu release. Those distros pick a specific kernel version and then camp out on it for years, if not decades. They do loads of work backporting the latest bugfixes and sometimes new features to these kernels, all in a Quixote quest to keep the version number from never being changed, despite having many thousands of changes on top of that older kernel version. This work is a truly thankless job, and the developers assigned to these tasks do some wonderful work in order to achieve these goals. If you like never seeing your kernel version number change, then use these distributions. They usually cost some money to use, but the support you get from these companies is worth it when something goes wrong.
-
-So again, the best kernel you can use is one that someone else supports, and you can turn to for help. Use that support, usually you are already paying for it (for the enterprise distributions), and those companies know what they are doing.
-
-But, if you do not want to trust someone else to manage your kernel for you, or you have hardware that a distribution does not support, then you want to run the Latest stable release:
-
-### Latest stable release
-
-This kernel is the latest one from the Linux kernel developer community that they declare as “stable”. About every three months, the community releases a new stable kernel that contains all of the newest hardware support, the latest performance improvements, as well as the latest bugfixes for all parts of the kernel. Over the next 3 months, bugfixes that go into the next kernel release to be made are backported into this stable release, so that any users of this kernel are sure to get them as soon as possible.
-
-This is usually the kernel that most community distributions use as well, so you can be sure it is tested and has a large audience of users. Also, the kernel community (all 4000+ developers) are willing to help support users of this release, as it is the latest one that they made.
-
-After 3 months, a new kernel is released and you should move to it to ensure that you stay up to date, as support for this kernel is usually dropped a few weeks after the newer release happens.
-
-If you have new hardware that is purchased after the last LTS release came out, you almost are guaranteed to have to run this kernel in order to have it supported. So for desktops or new servers, this is usually the recommended kernel to be running.
-
-### Latest LTS release
-
-If your hardware relies on a vendors out-of-tree patch in order to make it work properly (like almost all embedded devices these days), then the next best kernel to be using is the latest LTS release. That release gets all of the latest kernel fixes that goes into the stable releases where applicable, and lots of users test and use it.
-
-Note, no new features and almost no new hardware support is ever added to these kernels, so if you need to use a new device, it is better to use the latest stable release, not this release.
-
-Also this release is common for users that do not like to worry about “major” upgrades happening on them every 3 months. So they stick to this release and upgrade every year instead, which is a fine practice to follow.
-
-The downsides of using this release is that you do not get the performance improvements that happen in newer kernels, except when you update to the next LTS kernel, potentially a year in the future. That could be significant for some workloads, so be very aware of this.
-
-Also, if you have problems with this kernel release, the first thing that any developer whom you report the issue to is going to ask you to do is, “does the latest stable release have this problem?” So you will need to be aware that support might not be as easy to get as with the latest stable releases.
-
-Now if you are stuck with a large patchset and can not update to a new LTS kernel once a year, perhaps you want the older LTS releases:
-
-### Older LTS release
-
-These releases have traditionally been supported by the community for 2 years, sometimes longer for when a major distribution relies on this (like Debian or SLES). However in the past year, thanks to a lot of suport and investment in testing and infrastructure from Google, Linaro, Linaro member companies, [kernelci.org][3], and others, these kernels are starting to be supported for much longer.
-
-Here’s the latest LTS releases and how long they will be supported for, as shown at [kernel.org/category/releases.html][4] on August 24, 2018:
-
-![][5]
-
-The reason that Google and other companies want to have these kernels live longer is due to the crazy (some will say broken) development model of almost all SoC chips these days. Those devices start their development lifecycle a few years before the chip is released, however that code is never merged upstream, resulting in a brand new chip being released based on a 2 year old kernel. These SoC trees usually have over 2 million lines added to them, making them something that I have started calling “Linux-like” kernels.
-
-If the LTS releases stop happening after 2 years, then support from the community instantly stops, and no one ends up doing bugfixes for them. This results in millions of very insecure devices floating around in the world, not something that is good for any ecosystem.
-
-Because of this dependency, these companies now require new devices to constantly update to the latest LTS releases as they happen for their specific release version (i.e. every 4.9.y release that happens). An example of this is the Android kernel requirements for new devices shipping for the “O” and now “P” releases specified the minimum kernel version allowed, and Android security releases might start to require those “.y” releases to happen more frequently on devices.
-
-I will note that some manufacturers are already doing this today. Sony is one great example of this, updating to the latest 4.4.y release on many of their new phones for their quarterly security release. Another good example is the small company Essential which has been tracking the 4.4.y releases faster than anyone that I know of.
-
-There is one huge caveat when using a kernel like this. The number of security fixes that get backported are not as great as with the latest LTS release, because the traditional model of the devices that use these older LTS kernels is a much more reduced user model. These kernels are not to be used in any type of “general computing” model where you have untrusted users or virtual machines, as the ability to do some of the recent Spectre-type fixes for older releases is greatly reduced, if present at all in some branches.
-
-So again, only use older LTS releases in a device that you fully control, or lock down with a very strong security model (like Android enforces using SELinux and application isolation). Never use these releases on a server with untrusted users, programs, or virtual machines.
-
-Also, support from the community for these older LTS releases is greatly reduced even from the normal LTS releases, if available at all. If you use these kernels, you really are on your own, and need to be able to support the kernel yourself, or rely on you SoC vendor to provide that support for you (note that almost none of them do provide that support, so beware…)
-
-### Unmaintained kernel release
-
-Surprisingly, many companies do just grab a random kernel release, slap it into their product and proceed to ship it in hundreds of thousands of units without a second thought. One crazy example of this would be the Lego Mindstorm systems that shipped a random -rc release of a kernel in their device for some unknown reason. A -rc release is a development release that not even the Linux kernel developers feel is ready for everyone to use just yet, let alone millions of users.
-
-You are of course free to do this if you want, but note that you really are on your own here. The community can not support you as no one is watching all kernel versions for specific issues, so you will have to rely on in-house support for everything that could go wrong. Which for some companies and systems, could be just fine, but be aware of the “hidden” cost this might cause if you do not plan for this up front.
-
-### Summary
-
-So, here’s a short list of different types of devices, and what I would recommend for their kernels:
-
- * Laptop / Desktop: Latest stable release
- * Server: Latest stable release or latest LTS release
- * Embedded device: Latest LTS release or older LTS release if the security model used is very strong and tight.
-
-
-
-And as for me, what do I run on my machines? My laptops run the latest development kernel (i.e. Linus’s development tree) plus whatever kernel changes I am currently working on and my servers run the latest stable release. So despite being in charge of the LTS releases, I don’t run them myself, except in testing systems. I rely on the development and latest stable releases to ensure that my machines are running the fastest and most secure releases that we know how to create at this point in time.
-
---------------------------------------------------------------------------------
-
-via: http://kroah.com/log/blog/2018/08/24/what-stable-kernel-should-i-use/
-
-作者：[Greg Kroah-Hartman][a]
-选题：[lujun9972](https://github.com/lujun9972)
-译者：[译者ID](https://github.com/译者ID)
-校对：[校对者ID](https://github.com/校对者ID)
-
-本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
-
-[a]:http://kroah.com
-[1]:https://s3.amazonaws.com/kroah.com/images/kernel.org_2018_08_24.png
-[2]:http://kroah.com/log/blog/2018/02/05/linux-kernel-release-model/
-[3]:https://kernelci.org/
-[4]:https://www.kernel.org/category/releases.html
-[5]:https://s3.amazonaws.com/kroah.com/images/kernel.org_releases_2018_08_24.png
diff --git a/sources/tech/20180926 3 open source distributed tracing tools.md b/sources/tech/20180926 3 open source distributed tracing tools.md
deleted file mode 100644
index 9879302d38..0000000000
--- a/sources/tech/20180926 3 open source distributed tracing tools.md
+++ /dev/null
@@ -1,90 +0,0 @@
-translating by belitex
-
-3 open source distributed tracing tools
-======
-
-Find performance issues quickly with these tools, which provide a graphical view of what's happening across complex software systems.
-
-
-
-Distributed tracing systems enable users to track a request through a software system that is distributed across multiple applications, services, and databases as well as intermediaries like proxies. This allows for a deeper understanding of what is happening within the software system. These systems produce graphical representations that show how much time the request took on each step and list each known step.
-
-A user reviewing this content can determine where the system is experiencing latencies or blockages. Instead of testing the system like a binary search tree when requests start failing, operators and developers can see exactly where the issues begin. This can also reveal where performance changes might be occurring from deployment to deployment. It’s always better to catch regressions automatically by alerting to the anomalous behavior than to have your customers tell you.
-
-How does this tracing thing work? Well, each request gets a special ID that’s usually injected into the headers. This ID uniquely identifies that transaction. This transaction is normally called a trace. The trace is the overall abstract idea of the entire transaction. Each trace is made up of spans. These spans are the actual work being performed, like a service call or a database request. Each span also has a unique ID. Spans can create subsequent spans called child spans, and child spans can have multiple parents.
-
-Once a transaction (or trace) has run its course, it can be searched in a presentation layer. There are several tools in this space that we’ll discuss later, but the picture below shows [Jaeger][1] from my [Istio walkthrough][2]. It shows multiple spans of a single trace. The power of this is immediately clear as you can better understand the transaction’s story at a glance.
-
-
-
-This demo uses Istio’s built-in OpenTracing implementation, so I can get tracing without even modifying my application. It also uses Jaeger, which is OpenTracing-compatible.
-
-So what is OpenTracing? Let’s find out.
-
-### OpenTracing API
-
-[OpenTracing][3] is a spec that grew out of [Zipkin][4] to provide cross-platform compatibility. It offers a vendor-neutral API for adding tracing to applications and delivering that data into distributed tracing systems. A library written for the OpenTracing spec can be used with any system that is OpenTracing-compliant. Zipkin, Jaeger, and Appdash are examples of open source tools that have adopted the open standard, but even proprietary tools like [Datadog][5] and [Instana][6] are adopting it. This is expected to continue as OpenTracing reaches ubiquitous status.
-
-### OpenCensus
-
-Okay, we have OpenTracing, but what is this [OpenCensus][7] thing that keeps popping up in my searches? Is it a competing standard, something completely different, or something complementary?
-
-The answer depends on who you ask. I will do my best to explain the difference (as I understand it): OpenCensus takes a more holistic or all-inclusive approach. OpenTracing is focused on establishing an open API and spec and not on open implementations for each language and tracing system. OpenCensus provides not only the specification but also the language implementations and wire protocol. It also goes beyond tracing by including additional metrics that are normally outside the scope of distributed tracing systems.
-
-OpenCensus allows viewing data on the host where the application is running, but it also has a pluggable exporter system for exporting data to central aggregators. The current exporters produced by the OpenCensus team include Zipkin, Prometheus, Jaeger, Stackdriver, Datadog, and SignalFx, but anyone can create an exporter.
-
-From my perspective, there’s a lot of overlap. One isn’t necessarily better than the other, but it’s important to know what each does and doesn’t do. OpenTracing is primarily a spec, with others doing the implementation and opinionation. OpenCensus provides a holistic approach for the local component with more opinionation but still requires other systems for remote aggregation.
-
-### Tool options
-
-#### Zipkin
-
-Zipkin was one of the first systems of this kind. It was developed by Twitter based on the [Google Dapper paper][8] about the internal system Google uses. Zipkin was written using Java, and it can use Cassandra or ElasticSearch as a scalable backend. Most companies should be satisfied with one of those options. The lowest supported Java version is Java 6. It also uses the [Thrift][9] binary communication protocol, which is popular in the Twitter stack and is hosted as an Apache project.
-
-The system consists of reporters (clients), collectors, a query service, and a web UI. Zipkin is meant to be safe in production by transmitting only a trace ID within the context of a transaction to inform receivers that a trace is in process. The data collected in each reporter is then transmitted asynchronously to the collectors. The collectors store these spans in the database, and the web UI presents this data to the end user in a consumable format. The delivery of data to the collectors can occur in three different methods: HTTP, Kafka, and Scribe.
-
-The [Zipkin community][10] has also created [Brave][11], a Java client implementation compatible with Zipkin. It has no dependencies, so it won’t drag your projects down or clutter them with libraries that are incompatible with your corporate standards. There are many other implementations, and Zipkin is compatible with the OpenTracing standard, so these implementations should also work with other distributed tracing systems. The popular Spring framework has a component called [Spring Cloud Sleuth][12] that is compatible with Zipkin.
-
-#### Jaeger
-
-[Jaeger][1] is a newer project from Uber Technologies that the [CNCF][13] has since adopted as an Incubating project. It is written in Golang, so you don’t have to worry about having dependencies installed on the host or any overhead of interpreters or language virtual machines. Similar to Zipkin, Jaeger also supports Cassandra and ElasticSearch as scalable storage backends. Jaeger is also fully compatible with the OpenTracing standard.
-
-Jaeger’s architecture is similar to Zipkin, with clients (reporters), collectors, a query service, and a web UI, but it also has an agent on each host that locally aggregates the data. The agent receives data over a UDP connection, which it batches and sends to a collector. The collector receives that data in the form of the [Thrift][14] protocol and stores that data in Cassandra or ElasticSearch. The query service can access the data store directly and provide that information to the web UI.
-
-By default, a user won’t get all the traces from the Jaeger clients. The system samples 0.1% (1 in 1,000) of traces that pass through each client. Keeping and transmitting all traces would be a bit overwhelming to most systems. However, this can be increased or decreased by configuring the agents, which the client consults with for its configuration. This sampling isn’t completely random, though, and it’s getting better. Jaeger uses probabilistic sampling, which tries to make an educated guess at whether a new trace should be sampled or not. [Adaptive sampling is on its roadmap][15], which will improve the sampling algorithm by adding additional context for making decisions.
-
-#### Appdash
-
-[Appdash][16] is a distributed tracing system written in Golang, like Jaeger. It was created by [Sourcegraph][17] based on Google’s Dapper and Twitter’s Zipkin. Similar to Jaeger and Zipkin, Appdash supports the OpenTracing standard; this was a later addition and requires a component that is different from the default component. This adds risk and complexity.
-
-At a high level, Appdash’s architecture consists mostly of three components: a client, a local collector, and a remote collector. There’s not a lot of documentation, so this description comes from testing the system and reviewing the code. The client in Appdash gets added to your code. Appdash provides Python, Golang, and Ruby implementations, but OpenTracing libraries can be used with Appdash’s OpenTracing implementation. The client collects the spans and sends them to the local collector. The local collector then sends the data to a centralized Appdash server running its own local collector, which is the remote collector for all other nodes in the system.
-
---------------------------------------------------------------------------------
-
-via: https://opensource.com/article/18/9/distributed-tracing-tools
-
-作者：[Dan Barker][a]
-选题：[lujun9972](https://github.com/lujun9972)
-译者：[译者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
-[1]: https://www.jaegertracing.io/
-[2]: https://www.youtube.com/watch?v=T8BbeqZ0Rls
-[3]: http://opentracing.io/
-[4]: https://zipkin.io/
-[5]: https://www.datadoghq.com/
-[6]: https://www.instana.com/
-[7]: https://opencensus.io/
-[8]: https://research.google.com/archive/papers/dapper-2010-1.pdf
-[9]: https://thrift.apache.org/
-[10]: https://zipkin.io/pages/community.html
-[11]: https://github.com/openzipkin/brave
-[12]: https://cloud.spring.io/spring-cloud-sleuth/
-[13]: https://www.cncf.io/
-[14]: https://en.wikipedia.org/wiki/Apache_Thrift
-[15]: https://www.jaegertracing.io/docs/roadmap/#adaptive-sampling
-[16]: https://github.com/sourcegraph/appdash
-[17]: https://about.sourcegraph.com/
diff --git a/sources/tech/20181002 How to use the SSH and SFTP protocols on your home network.md b/sources/tech/20181002 How to use the SSH and SFTP protocols on your home network.md
index 5c24e87901..a58aa55ffd 100644
--- a/sources/tech/20181002 How to use the SSH and SFTP protocols on your home network.md
+++ b/sources/tech/20181002 How to use the SSH and SFTP protocols on your home network.md
@@ -1,3 +1,5 @@
+translating by singledo
+
How to use the SSH and SFTP protocols on your home network
======
diff --git a/sources/tech/20181003 Introducing Swift on Fedora.md b/sources/tech/20181003 Introducing Swift on Fedora.md
index 6b975be8f6..186117cd7c 100644
--- a/sources/tech/20181003 Introducing Swift on Fedora.md
+++ b/sources/tech/20181003 Introducing Swift on Fedora.md
@@ -1,3 +1,5 @@
+translating---geekpi
+
Introducing Swift on Fedora
======
diff --git a/sources/tech/20181004 Functional programming in Python- Immutable data structures.md b/sources/tech/20181004 Functional programming in Python- Immutable data structures.md
index b831ff726f..e6050d52f9 100644
--- a/sources/tech/20181004 Functional programming in Python- Immutable data structures.md
+++ b/sources/tech/20181004 Functional programming in Python- Immutable data structures.md
@@ -1,3 +1,4 @@
+Translating by Ryze-Borgia
Functional programming in Python: Immutable data structures
======
Immutability can help us better understand our code. Here's how to achieve it without sacrificing performance.
diff --git a/translated/tech/20180201 Rock Solid React.js Foundations A Beginners Guide.md b/translated/tech/20180201 Rock Solid React.js Foundations A Beginners Guide.md
new file mode 100644
index 0000000000..bdb2abca36
--- /dev/null
+++ b/translated/tech/20180201 Rock Solid React.js Foundations A Beginners Guide.md
@@ -0,0 +1,281 @@
+坚实的 React 基础：初学者指南
+============================================================
+
+React.js crash course
+
+在过去的几个月里，我一直在使用 React 和 React-Native。我已经发布了两个作为产品的应用， [Kiven Aa][1]（React）和 [Pollen Chat][2]（React Native）。当我开始学习 React 时，我找了一些不仅仅是教我如何用 React 写应用的东西（一个博客，一个视频，一个课程，等等），我也想让它帮我做好面试准备。
+
+我发现的大部分资料都集中在某一单一方面上。所以，这篇文章针对的是那些希望理论与实践完美结合的观众。我会告诉你一些理论，以便你了解幕后发生的事情，然后我会向你展示如何编写一些 React.js 代码。
+
+如果你更喜欢视频形式，我在YouTube上传了整个课程，请去看看。
+
+
+让我们开始......
+
+> React.js 是一个用于构建用户界面的 JavaScript 库
+
+你可以构建各种单页应用程序。例如，你希望在用户界面上实时显示更改的聊天软件和电子商务门户。
+
+### 一切都是组件
+
+React 应用由组件组成，数量多且互相嵌套。你或许会问：”可什么是组件呢？“
+
+组件是可重用的代码段，它定义了某些功能在 UI 上的外观和行为。 比如，按钮就是一个组件。
+
+让我们看看下面的计算器，当你尝试计算2 + 2 = 4 -1 = 3（简单的数学题）时，你会在Google上看到这个计算器。
+
+
+红色标记表示组件
+
+
+
+如上图所示，这个计算器有很多区域，比如展示窗口和数字键盘。所有这些都可以是许多单独的组件或一个巨大的组件。这取决于在 React 中分解和抽象出事物的程度。你为所有这些组件分别编写代码，然后合并这些组件到一个容器中，而这个容器又是一个 React 组件。这样你就可以创建可重用的组件，最终的应用将是一组协同工作的单独组件。
+
+
+
+以下是一个你践行了以上原则并可以用 React 编写计算器的方法。
+
+```
+
+
+
+
+
+ .
+ .
+ .
+
+
+
+
+```
+
+没错！它看起来像HTML代码，然而并不是。我们将在后面的部分中详细探讨它。
+
+### 设置我们的 Playground
+
+这篇教程专注于 React 的基础部分。它没有偏向 Web 或 React Native（开发移动应用）。所以，我们会用一个在线编辑器，这样可以在学习 React 能做什么之前避免 web 或 native 的具体配置。
+
+我已经为读者在 [codepen.io][4] 设置好了开发环境。只需点开这个链接并且阅读所有 HTML 和 JavaScript 注释。
+
+### 控制组件
+
+我们已经了解到 React 应用是各种组件的集合，结构为嵌套树。因此，我们需要某种机制来将数据从一个组件传递到另一个组件。
+
+#### 进入 “props”
+
+我们可以使用 `props` 对象将任意数据传递给我们的组件。 React 中的每个组件都会获取 `props` 对象。在学习如何使用 `props` 之前，让我们学习函数式组件。
+
+#### a) 函数式组件
+
+在 React 中，一个函数式组件通过 `props` 对象使用你传递给它的任意数据。它返回一个对象，该对象描述了 React 应渲染的 UI。函数式组件也称为无状态组件。
+
+
+
+让我们编写第一个函数式组件。
+
+```
+function Hello(props) {
+ return