Linux 上 10 个最好的 Markdown 编辑器

haroopad是我用了这么多编辑气候感觉功能最全的

Atom下 Ctrl+Shift+M 可以显示makedown实时预览

原生态的Vi增加几个插件感觉牛牛的，弄那么花俏没用的，每一个人都有自己熟悉的编译器

smark 也不错呀

在用haroopad！很不错！

10个！标题是10个！<br />
个人绝对最好的3个，有颜值有功能：typora、remarkable和haroopad

# Linux 上 10 个最好的 Markdown 编辑器

在这篇文章中，我们会点评一些可以在 Linux 上安装使用的最好的 Markdown 编辑器。 你可以在 Linux 平台上找到非常多的 的 Markdown 编辑器，但是在这里我们将尽可能地为您推荐那些最好的。

*Best Linux Markdown Editors*

对于不了解 Markdown 的人做个简单介绍，Markdown 是由著名的 Aaron Swartz 和 John Gruber 发明的标记语言，其最初的解析器是一个用 Perl 写的简单、轻量的[同名工具](https://daringfireball.net/projects/markdown/)。它可以将用户写的纯文本转为可用的 HTML（或 XHTML）。它实际上是一门易读，易写的纯文本语言，以及一个用于将文本转为 HTML 的转换工具。

希望你先对 Markdown 有一个稍微的了解，接下来让我们逐一列出这些编辑器。

### 1. Atom

Atom 是一个现代的、跨平台、开源且强大的文本编辑器，它可以运行在 Linux、Windows 和 MAC OS X 等操作系统上。用户可以在它的基础上进行定制，删减修改任何配置文件。

它包含了一些非常杰出的特性：

* 内置软件包管理器
* 智能自动补全功能
* 提供多窗口操作
* 支持查找替换功能
* 包含一个文件系统浏览器
* 轻松自定义主题
* 开源、高度扩展性的软件包等

*Atom Markdown Editor for Linux*

访问主页: <https://atom.io/>

### 2. GNU Emacs

Emacs 是 Linux 平台上一款的流行文本编辑器。它是一个非常棒的、具备高扩展性和定制性的 Markdown 语言编辑器。

它综合了以下这些神奇的特性：

* 带有丰富的内置文档，包括适合初学者的教程
* 有完整的 Unicode 支持，可显示所有的人类符号
* 支持内容识别的文本编辑模式
* 包括多种文件类型的语法高亮
* 可用 Emacs Lisp 或 GUI 对其进行高度定制
* 提供了一个包系统可用来下载安装各种扩展等

*Emacs Markdown Editor for Linux*

访问主页: <https://www.gnu.org/software/emacs/>

### 3. Remarkable

Remarkable 可能是 Linux 上最好的 Markdown 编辑器了，它也适用于 Windows 操作系统。它的确是是一个卓越且功能齐全的 Markdown 编辑器，为用户提供了一些令人激动的特性。

一些卓越的特性：

* 支持实时预览
* 支持导出 PDF 和 HTML
* 支持 Github Markdown 语法
* 支持定制 CSS
* 支持语法高亮
* 提供键盘快捷键
* 高可定制性和其他

*Remarkable Markdown Editor for Linux*

访问主页: <https://remarkableapp.github.io>

### 4. Haroopad

Haroopad 是为 Linux，Windows 和 Mac OS X 构建的跨平台 Markdown 文档处理程序。用户可以用它来书写许多专家级格式的文档，包括电子邮件、报告、博客、演示文稿和博客文章等等。

功能齐全且具备以下的亮点：

* 轻松导入内容
* 支持导出多种格式
* 广泛支持博客和邮件
* 支持许多数学表达式
* 支持 Github Markdown 扩展
* 为用户提供了一些令人兴奋的主题、皮肤和 UI 组件等等

*Haroopad Markdown Editor for Linux*

访问主页: <http://pad.haroopress.com/>

### 5. ReText

ReText 是为 Linux 和其它几个 POSIX 兼容操作系统提供的简单、轻量、强大的 Markdown 编辑器。它还可以作为一个 reStructuredText 编辑器，并且具有以下的特性：

* 简单直观的 GUI
* 具备高定制性，用户可以自定义语法文件和配置选项
* 支持多种配色方案
* 支持使用多种数学公式
* 启用导出扩展等等

*ReText Markdown Editor for Linux*

访问主页: <https://github.com/retext-project/retext>

### 6. UberWriter

UberWriter 是一个简单、易用的 Linux Markdown 编辑器。它的开发受 Mac OS X 上的 iA writer 影响很大，同样它也具备这些卓越的特性：

* 使用 pandoc 进行所有的文本到 HTML 的转换
* 提供了一个简洁的 UI 界面
* 提供了一种<ruby> 专心 <rp>  （ </rp> <rt>  distraction free </rt> <rp>  ） </rp></ruby>模式，高亮用户最后的句子
* 支持拼写检查
* 支持全屏模式
* 支持用 pandoc 导出 PDF、HTML 和 RTF
* 启用语法高亮和数学函数等等

*UberWriter Markdown Editor for Linux*

访问主页: <http://uberwriter.wolfvollprecht.de/>

### 7. Mark My Words

Mark My Words 同样也是一个轻量、强大的 Markdown 编辑器。它是一个相对比较新的编辑器，因此提供了包含语法高亮在内的大量的功能，简单和直观的 UI。

下面是一些棒极了，但还未捆绑到应用中的功能：

* 实时预览
* Markdown 解析和文件 IO
* 状态管理
* 支持导出 PDF 和 HTML
* 监测文件的修改
* 支持首选项设置

*MarkMyWords Markdown Editor for-Linux*

访问主页: <https://github.com/voldyman/MarkMyWords>

### 8. Vim-Instant-Markdown 插件

Vim 是 Linux 上的一个久经考验的强大、流行而开源的文本编辑器。它用于编程极棒。它也高度支持插件功能，可以让用户为其增加一些其它功能，包括 Markdown 预览。

有好几种 Vim 的 Markdown 预览插件，但是 [Vim-Instant-Markdown](https://github.com/suan/vim-instant-markdown) 的表现最佳。

### 9. Bracket-MarkdownPreview 插件

Brackets 是一个现代、轻量、开源且跨平台的文本编辑器。它特别为 Web 设计和开发而构建。它的一些重要功能包括：支持内联编辑器、实时预览、预处理支持及更多。

它也是通过插件高度可扩展的，你可以使用 [Bracket-MarkdownPreview](https://github.com/gruehle/MarkdownPreview) 插件来编写和预览 Markdown 文档。

*Brackets Markdown Plugin Preview*

### 10. SublimeText-Markdown 插件

Sublime Text 是一个精心打造的、流行的、跨平台文本编辑器，用于代码、markdown 和普通文本。它的表现极佳，包括如下令人兴奋的功能：

* 简洁而美观的 GUI
* 支持多重选择
* 提供专心模式
* 支持窗体分割编辑
* 通过 Python 插件 API 支持高度插件化
* 完全可定制化，提供命令查找模式

[SublimeText-Markdown](https://github.com/SublimeText-Markdown/MarkdownEditing) 插件是一个支持格式高亮的软件包，带有一些漂亮的颜色方案。

*SublimeText Markdown Plugin Preview*

### 结论

通过上面的列表，你大概已经知道要为你的 Linux 桌面下载、安装什么样的 Markdown 编辑器和文档处理程序了。

请注意，这里提到的最好的 Markdown 编辑器可能对你来说并不是最好的选择。因此你可以通过下面的反馈部分，为我们展示你认为列表中未提及的，并且具备足够的资格的，令人兴奋的 Markdown 编辑器。

---

via: <http://www.tecmint.com/best-markdown-editors-for-linux/>

作者：[Aaron Kili](http://www.tecmint.com/author/aaronkili/) 译者：[Locez](https://github.com/locez) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


使用 Python 创建你自己的 Shell （上）

Summary: 我很想知道一个 shell （像 bash，csh 等）内部是如何工作的。于是为了满足自己的好奇心，我使用 Python 实现了一个名为 yosh （Your Own Shell）的 Shell。

最近有个类似的想法~

# 使用 Python 创建你自己的 Shell （上）

我很想知道一个 shell （像 bash，csh 等）内部是如何工作的。于是为了满足自己的好奇心，我使用 Python 实现了一个名为 **yosh** （Your Own Shell）的 Shell。本文章所介绍的概念也可以应用于其他编程语言。

<img src="content_image/album_201607_28_111101bqbl5of2qkz2b2ls.jpg" alt="" title="">

（提示：你可以在[这里](https://github.com/supasate/yosh)查找本博文使用的源代码，代码以 MIT 许可证发布。在 Mac OS X 10.11.5 上，我使用 Python 2.7.10 和 3.4.3 进行了测试。它应该可以运行在其他类 Unix 环境，比如 Linux 和 Windows 上的 Cygwin。）

让我们开始吧。

### 步骤 0：项目结构

对于此项目，我使用了以下的项目结构。

```
yosh_project
|-- yosh
   |-- __init__.py
   |-- shell.py

```

`yosh_project` 为项目根目录（你也可以把它简单命名为 `yosh`）。

`yosh` 为包目录，且 `__init__.py` 可以使它成为与包的目录名字相同的包（如果你不用 Python 编写的话，可以忽略它。）

`shell.py` 是我们主要的脚本文件。

### 步骤 1：Shell 循环

当启动一个 shell，它会显示一个命令提示符并等待你的命令输入。在接收了输入的命令并执行它之后（稍后文章会进行详细解释），你的 shell 会重新回到这里，并循环等待下一条指令。

在 `shell.py` 中，我们会以一个简单的 main 函数开始，该函数调用了 shell\_loop() 函数，如下：

```
def shell_loop():
    # Start the loop here

def main():
    shell_loop()

if __name__ == "__main__":
    main()

```

接着，在 `shell_loop()` 中，为了指示循环是否继续或停止，我们使用了一个状态标志。在循环的开始，我们的 shell 将显示一个命令提示符，并等待读取命令输入。

```
import sys

SHELL_STATUS_RUN = 1
SHELL_STATUS_STOP = 0

def shell_loop():
    status = SHELL_STATUS_RUN

    while status == SHELL_STATUS_RUN:
        ### 显示命令提示符
        sys.stdout.write('> ')
        sys.stdout.flush()

        ### 读取命令输入
        cmd = sys.stdin.readline()

```

之后，我们<ruby> 切分命令 <rp>  （ </rp> <rt>  tokenize </rt> <rp>  ） </rp></ruby>输入并进行<ruby> 执行 <rp>  （ </rp> <rt>  execute </rt> <rp>  ） </rp></ruby>（我们即将实现 `tokenize` 和 `execute` 函数）。

因此，我们的 shell\_loop() 会是如下这样：

```
import sys

SHELL_STATUS_RUN = 1
SHELL_STATUS_STOP = 0

def shell_loop():
    status = SHELL_STATUS_RUN

    while status == SHELL_STATUS_RUN:
        ### 显示命令提示符
        sys.stdout.write('> ')
        sys.stdout.flush()

        ### 读取命令输入
        cmd = sys.stdin.readline()

        ### 切分命令输入
        cmd_tokens = tokenize(cmd)

        ### 执行该命令并获取新的状态
        status = execute(cmd_tokens)

```

这就是我们整个 shell 循环。如果我们使用 `python shell.py` 启动我们的 shell，它会显示命令提示符。然而如果我们输入命令并按回车，它会抛出错误，因为我们还没定义 `tokenize` 函数。

为了退出 shell，可以尝试输入 ctrl-c。稍后我将解释如何以优雅的形式退出 shell。

### 步骤 2：<ruby> 命令切分 <rp>  （ </rp> <rt>  tokenize </rt> <rp>  ） </rp></ruby>

当用户在我们的 shell 中输入命令并按下回车键，该命令将会是一个包含命令名称及其参数的长字符串。因此，我们必须切分该字符串（分割一个字符串为多个元组）。

咋一看似乎很简单。我们或许可以使用 `cmd.split()`，以空格分割输入。它对类似 `ls -a my_folder` 的命令起作用，因为它能够将命令分割为一个列表 `['ls', '-a', 'my_folder']`，这样我们便能轻易处理它们了。

然而，也有一些类似 `echo "Hello World"` 或 `echo 'Hello World'` 以单引号或双引号引用参数的情况。如果我们使用 cmd.spilt，我们将会得到一个存有 3 个标记的列表 `['echo', '"Hello', 'World"']` 而不是 2 个标记的列表 `['echo', 'Hello World']`。

幸运的是，Python 提供了一个名为 `shlex` 的库，它能够帮助我们如魔法般地分割命令。（提示：我们也可以使用正则表达式，但它不是本文的重点。）

```
import sys
import shlex

...

def tokenize(string):
    return shlex.split(string)

...

```

然后我们将这些元组发送到执行进程。

### 步骤 3：执行

这是 shell 中核心而有趣的一部分。当 shell 执行 `mkdir test_dir` 时，到底发生了什么？（提示： `mkdir` 是一个带有 `test_dir` 参数的执行程序，用于创建一个名为 `test_dir` 的目录。）

`execvp` 是这一步的首先需要的函数。在我们解释 `execvp` 所做的事之前，让我们看看它的实际效果。

```
import os
...

def execute(cmd_tokens):
    ### 执行命令
    os.execvp(cmd_tokens[0], cmd_tokens)

    ### 返回状态以告知在 shell_loop 中等待下一个命令
    return SHELL_STATUS_RUN

...

```

再次尝试运行我们的 shell，并输入 `mkdir test_dir` 命令，接着按下回车键。

在我们敲下回车键之后，问题是我们的 shell 会直接退出而不是等待下一个命令。然而，目录正确地创建了。

因此，`execvp` 实际上做了什么？

`execvp` 是系统调用 `exec` 的一个变体。第一个参数是程序名字。`v` 表示第二个参数是一个程序参数列表（参数数量可变）。`p` 表示将会使用环境变量 `PATH` 搜索给定的程序名字。在我们上一次的尝试中，它将会基于我们的 `PATH` 环境变量查找`mkdir` 程序。

（还有其他 `exec` 变体，比如 execv、execvpe、execl、execlp、execlpe；你可以 google 它们获取更多的信息。）

`exec` 会用即将运行的新进程替换调用进程的当前内存。在我们的例子中，我们的 shell 进程内存会被替换为 `mkdir` 程序。接着，`mkdir` 成为主进程并创建 `test_dir` 目录。最后该进程退出。

这里的重点在于**我们的 shell 进程已经被 `mkdir` 进程所替换**。这就是我们的 shell 消失且不会等待下一条命令的原因。

因此，我们需要其他的系统调用来解决问题：`fork`。

`fork` 会分配新的内存并拷贝当前进程到一个新的进程。我们称这个新的进程为**子进程**，调用者进程为**父进程**。然后，子进程内存会被替换为被执行的程序。因此，我们的 shell，也就是父进程，可以免受内存替换的危险。

让我们看看修改的代码。

```
...

def execute(cmd_tokens):
    ### 分叉一个子 shell 进程
    ### 如果当前进程是子进程，其 `pid` 被设置为 `0`
    ### 否则当前进程是父进程的话，`pid` 的值
    ### 是其子进程的进程 ID。
    pid = os.fork()

    if pid == 0:
    ### 子进程
        ### 用被 exec 调用的程序替换该子进程
        os.execvp(cmd_tokens[0], cmd_tokens)
    elif pid > 0:
    ### 父进程
        while True:
            ### 等待其子进程的响应状态（以进程 ID 来查找）
            wpid, status = os.waitpid(pid, 0)

            ### 当其子进程正常退出时
            ### 或者其被信号中断时，结束等待状态
            if os.WIFEXITED(status) or os.WIFSIGNALED(status):
                break

    ### 返回状态以告知在 shell_loop 中等待下一个命令
    return SHELL_STATUS_RUN

...

```

当我们的父进程调用 `os.fork()` 时，你可以想象所有的源代码被拷贝到了新的子进程。此时此刻，父进程和子进程看到的是相同的代码，且并行运行着。

如果运行的代码属于子进程，`pid` 将为 `0`。否则，如果运行的代码属于父进程，`pid` 将会是子进程的进程 id。

当 `os.execvp` 在子进程中被调用时，你可以想象子进程的所有源代码被替换为正被调用程序的代码。然而父进程的代码不会被改变。

当父进程完成等待子进程退出或终止时，它会返回一个状态，指示继续 shell 循环。

### 运行

现在，你可以尝试运行我们的 shell 并输入 `mkdir test_dir2`。它应该可以正确执行。我们的主 shell 进程仍然存在并等待下一条命令。尝试执行 `ls`，你可以看到已创建的目录。

但是，这里仍有一些问题。

第一，尝试执行 `cd test_dir2`，接着执行 `ls`。它应该会进入到一个空的 `test_dir2` 目录。然而，你将会看到目录并没有变为 `test_dir2`。

第二，我们仍然没有办法优雅地退出我们的 shell。

我们将会在[下篇](https://hackercollider.com/articles/2016/07/06/create-your-own-shell-in-python-part-2/)解决诸如此类的问题。

---

via: <https://hackercollider.com/articles/2016/07/05/create-your-own-shell-in-python-part-1/>

作者：[Supasate Choochaisri](https://disqus.com/by/supasate_choochaisri/) 译者：[cposture](https://github.com/cposture) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


使用 Python 创建你自己的 Shell（下）

Summary: 在这部分，我们将会解决剩下的问题。首先，cd test_dir2 命令无法修改我们的当前目录。其次，我们仍无法优雅地从 shell 中退出。

做一个 Shell 是个浩大的工程，上面的只能练手笔。

# 使用 Python 创建你自己的 Shell（下）

在[上篇](/article-7624-1.html)中，我们已经创建了一个 shell 主循环、切分了命令输入，以及通过 `fork` 和 `exec` 执行命令。在这部分，我们将会解决剩下的问题。首先，`cd test_dir2` 命令无法修改我们的当前目录。其次，我们仍无法优雅地从 shell 中退出。

<img src="content_image/album_201607_28_114315mo436pl4wtna46wn.jpg" alt="" title="">

### 步骤 4：内置命令

“`cd test_dir2` 无法修改我们的当前目录” 这句话是对的，但在某种意义上也是错的。在执行完该命令之后，我们仍然处在同一目录，从这个意义上讲，它是对的。然而，目录实际上已经被修改，只不过它是在子进程中被修改。

还记得我们分叉（fork）了一个子进程，然后执行命令，执行命令的过程没有发生在父进程上。结果是我们只是改变了子进程的当前目录，而不是父进程的目录。

然后子进程退出，而父进程在原封不动的目录下继续运行。

因此，这类与 shell 自己相关的命令必须是内置命令。它必须在 shell 进程中执行而不是在分叉中（forking）。

#### cd

让我们从 `cd` 命令开始。

我们首先创建一个 `builtins` 目录。每一个内置命令都会被放进这个目录中。

```
yosh_project
|-- yosh
   |-- builtins
   |   |-- __init__.py
   |   |-- cd.py
   |-- __init__.py
   |-- shell.py

```

在 `cd.py` 中，我们通过使用系统调用 `os.chdir` 实现自己的 `cd` 命令。

```
import os
from yosh.constants import *

def cd(args):
    os.chdir(args[0])

    return SHELL_STATUS_RUN

```

注意，我们会从内置函数返回 shell 的运行状态。所以，为了能够在项目中继续使用常量，我们将它们移至 `yosh/constants.py`。

```
yosh_project
|-- yosh
   |-- builtins
   |   |-- __init__.py
   |   |-- cd.py
   |-- __init__.py
   |-- constants.py
   |-- shell.py

```

在 `constants.py` 中，我们将状态常量都放在这里。

```
SHELL_STATUS_STOP = 0
SHELL_STATUS_RUN = 1

```

现在，我们的内置 `cd` 已经准备好了。让我们修改 `shell.py` 来处理这些内置函数。

```
...
### 导入常量
from yosh.constants import *

### 使用哈希映射来存储内建的函数名及其引用
built_in_cmds = {}

def tokenize(string):
    return shlex.split(string)

def execute(cmd_tokens):
    ### 从元组中分拆命令名称与参数
    cmd_name = cmd_tokens[0]
    cmd_args = cmd_tokens[1:]

    ### 如果该命令是一个内建命令，使用参数调用该函数
    if cmd_name in built_in_cmds:
        return built_in_cmds[cmd_name](cmd_args)

    ...

```

我们使用一个 python 字典变量 `built_in_cmds` 作为<ruby> 哈希映射 <rp>  （ </rp> <rt>  hash map </rt> <rp>  ） </rp></ruby>，以存储我们的内置函数。我们在 `execute` 函数中提取命令的名字和参数。如果该命令在我们的哈希映射中，则调用对应的内置函数。

（提示：`built_in_cmds[cmd_name]` 返回能直接使用参数调用的函数引用。)

我们差不多准备好使用内置的 `cd` 函数了。最后一步是将 `cd` 函数添加到 `built_in_cmds` 映射中。

```
...
### 导入所有内建函数引用
from yosh.builtins import *

...

### 注册内建函数到内建命令的哈希映射中
def register_command(name, func):
    built_in_cmds[name] = func

### 在此注册所有的内建命令
def init():
    register_command("cd", cd)

def main():
    ###在开始主循环之前初始化 shell
    init()
    shell_loop()

```

我们定义了 `register_command` 函数，以添加一个内置函数到我们内置的命令哈希映射。接着，我们定义 `init` 函数并且在这里注册内置的 `cd` 函数。

注意这行 `register_command("cd", cd)` 。第一个参数为命令的名字。第二个参数为一个函数引用。为了能够让第二个参数 `cd` 引用到 `yosh/builtins/cd.py` 中的 `cd` 函数引用，我们必须将以下这行代码放在 `yosh/builtins/__init__.py` 文件中。

```
from yosh.builtins.cd import *

```

因此，在 `yosh/shell.py` 中，当我们从 `yosh.builtins` 导入 `*` 时，我们可以得到已经通过 `yosh.builtins` 导入的 `cd` 函数引用。

我们已经准备好了代码。让我们尝试在 `yosh` 同级目录下以模块形式运行我们的 shell，`python -m yosh.shell`。

现在，`cd` 命令可以正确修改我们的 shell 目录了，同时非内置命令仍然可以工作。非常好！

#### exit

最后一块终于来了：优雅地退出。

我们需要一个可以修改 shell 状态为 `SHELL_STATUS_STOP` 的函数。这样，shell 循环可以自然地结束，shell 将到达终点而退出。

和 `cd` 一样，如果我们在子进程中分叉并执行 `exit` 函数，其对父进程是不起作用的。因此，`exit` 函数需要成为一个 shell 内置函数。

让我们从这开始：在 `builtins` 目录下创建一个名为 `exit.py` 的新文件。

```
yosh_project
|-- yosh
   |-- builtins
   |   |-- __init__.py
   |   |-- cd.py
   |   |-- exit.py
   |-- __init__.py
   |-- constants.py
   |-- shell.py

```

`exit.py` 定义了一个 `exit` 函数，该函数仅仅返回一个可以退出主循环的状态。

```
from yosh.constants import *

def exit(args):
    return SHELL_STATUS_STOP

```

然后，我们导入位于 `yosh/builtins/__init__.py` 文件的 `exit` 函数引用。

```
from yosh.builtins.cd import *
from yosh.builtins.exit import *

```

最后，我们在 `shell.py` 中的 `init()` 函数注册 `exit` 命令。

```
...

### 在此注册所有的内建命令
def init():
    register_command("cd", cd)
    register_command("exit", exit)

...

```

到此为止！

尝试执行 `python -m yosh.shell`。现在你可以输入 `exit` 优雅地退出程序了。

### 最后的想法

我希望你能像我一样享受创建 `yosh` （**y**our **o**wn **sh**ell）的过程。但我的 `yosh` 版本仍处于早期阶段。我没有处理一些会使 shell 崩溃的极端状况。还有很多我没有覆盖的内置命令。为了提高性能，一些非内置命令也可以实现为内置命令（避免新进程创建时间）。同时，大量的功能还没有实现（请看 [公共特性](http://tldp.org/LDP/Bash-Beginners-Guide/html/x7243.html) 和 [不同特性](http://www.tldp.org/LDP/intro-linux/html/x12249.html)）。

我已经在 <https://github.com/supasate/yosh> 中提供了源代码。请随意 fork 和尝试。

现在该是创建你真正自己拥有的 Shell 的时候了。

Happy Coding!

---

via: <https://hackercollider.com/articles/2016/07/06/create-your-own-shell-in-python-part-2/>

作者：[Supasate Choochaisri](https://disqus.com/by/supasate_choochaisri/) 译者：[cposture](https://github.com/cposture) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


Fedora 中的容器技术：systemd-nspawn

Summary: systemd 项目认为应当将容器技术变成桌面的基础部分，并且应当和用户的其余系统集成在一起。为此，systemd 提供了 systemd-nspawn，这款工具能够使用多种 Linux 技术创建容器。它也提供了一些容器管理工具。

# Fedora 中的容器技术：systemd-nspawn

欢迎来到“Fedora 中的容器技术”系列！本文是该系列文章中的第一篇，它将说明你可以怎样使用 Fedora 中各种可用的容器技术。本文将学习 `systemd-nspawn` 的相关知识。

### 容器是什么？

一个容器就是一个用户空间实例，它能够在与托管容器的系统（叫做宿主系统）相隔离的环境中运行一个程序或者一个操作系统。这和 `chroot` 或 [虚拟机](https://en.wikipedia.org/wiki/Virtual_machine) 的思想非常类似。运行在容器中的进程是由与宿主操作系统相同的内核来管理的，但它们是与宿主文件系统以及其它进程隔离开的。

### 什么是 systemd-nspawn？

systemd 项目认为应当将容器技术变成桌面的基础部分，并且应当和用户的其余系统集成在一起。为此，systemd 提供了 `systemd-nspawn`，这款工具能够使用多种 Linux 技术创建容器。它也提供了一些容器管理工具。

`systemd-nspawn` 和 `chroot` 在许多方面都是类似的，但是前者更加强大。它虚拟化了文件系统、进程树以及客户系统中的进程间通信。它的吸引力在于它提供了很多用于管理容器的工具，例如用来管理容器的 `machinectl`。由 `systemd-nspawn` 运行的容器将会与 systemd 组件一同运行在宿主系统上。举例来说，一个容器的日志可以输出到宿主系统的日志中。

在 Fedora 24 上，`systemd-nspawn` 已经从 systemd 软件包分离出来了，所以你需要安装 `systemd-container` 软件包。一如往常，你可以使用 `dnf install systemd-container` 进行安装。

### 创建容器

使用 `systemd-nspawn` 创建一个容器是很容易的。假设你有一个专门为 Debian 创造的应用，并且无法在其它发行版中正常运行。那并不是一个问题，我们可以创造一个容器！为了设置容器使用最新版本的 Debian（现在是 Jessie），你需要挑选一个目录来放置你的系统。我暂时将使用目录 `~/DebianJessie`。

一旦你创建完目录，你需要运行 `debootstrap`，你可以从 Fedora 仓库中安装它。对于 Debian Jessie，你运行下面的命令来初始化一个 Debian 文件系统。

```
$ debootstrap --arch=amd64 stable ~/DebianJessie

```

以上默认你的架构是 x86\_64。如果不是的话，你必须将架构的名称改为 `amd64`。你可以使用 `uname -m` 得知你的机器架构。

一旦设置好你的根目录，你就可以使用下面的命令来启动你的容器。

```
$ systemd-nspawn -bD ~/DebianJessie

```

容器将会在数秒后准备好并运行，当你试图登录时就会注意到：你无法使用你的系统上任何账户。这是因为 `systemd-nspawn` 虚拟化了用户。修复的方法很简单：将之前的命令中的 `-b` 移除即可。你将直接进入容器的 root 用户的 shell。此时，你只能使用 `passwd` 命令为 root 设置密码，或者使用 `adduser` 命令添加一个新用户。一旦设置好密码或添加好用户，你就可以把 `-b` 标志添加回去然后继续了。你会进入到熟悉的登录控制台，然后你使用设置好的认证信息登录进去。

以上对于任意你想在容器中运行的发行版都适用，但前提是你需要使用正确的包管理器创建系统。对于 Fedora，你应使用 DNF 而非 `debootstrap`。想要设置一个最小化的 Fedora 系统，你可以运行下面的命令，要将“/absolute/path/”替换成任何你希望容器存放的位置。

```
$ sudo dnf --releasever=24 --installroot=/absolute/path/ install systemd passwd dnf fedora-release

```

### 设置网络

如果你尝试启动一个服务，但它绑定了你宿主机正在使用的端口，你将会注意到这个问题：你的容器正在使用和宿主机相同的网络接口。幸运的是，`systemd-nspawn` 提供了几种可以将网络从宿主机分开的方法。

#### 本地网络

第一种方法是使用 `--private-network` 标志，它默认仅创建一个回环设备。这对于你不需要使用网络的环境是非常理想的，例如构建系统和其它持续集成系统。

#### 多个网络接口

如果你有多个网络接口设备，你可以使用 `--network-interface` 标志给容器分配一个接口。想要给我的容器分配 `eno1`，我会添加选项 `--network-interface=eno1`。当某个接口分配给一个容器后，宿主机就不能同时使用那个接口了。只有当容器彻底关闭后，宿主机才可以使用那个接口。

#### 共享网络接口

对于我们中那些并没有额外的网络设备的人来说，还有其它方法可以访问容器。一种就是使用 `--port` 选项。这会将容器中的一个端口定向到宿主机。使用格式是 `协议:宿主机端口:容器端口`，这里的协议可以是 `tcp` 或者 `udp`，`宿主机端口` 是宿主机的一个合法端口，`容器端口` 则是容器中的一个合法端口。你可以省略协议，只指定 `宿主机端口:容器端口`。我通常的用法类似 `--port=2222:22`。

你可以使用 `--network-veth` 启用完全的、仅宿主机模式的网络，这会在宿主机和容器之间创建一个虚拟的网络接口。你也可以使用 `--network-bridge` 桥接二者的连接。

### 使用 systemd 组件

如果你容器中的系统含有 D-Bus，你可以使用 systemd 提供的实用工具来控制并监视你的容器。基础安装的 Debian 并不包含 `dbus`。如果你想在 Debian Jessie 中使用 `dbus`，你需要运行命令 `apt install dbus`。

#### machinectl

为了能够轻松地管理容器，systemd 提供了 `machinectl` 实用工具。使用 `machinectl`，你可以使用 `machinectl login name` 登录到一个容器中、使用 `machinectl status name`检查状态、使用 `machinectl reboot name` 启动容器或者使用 `machinectl poweroff name` 关闭容器。

### 其它 systemd 命令

多数 systemd 命令，例如 `journalctl`, `systemd-analyze` 和 `systemctl`，都支持使用 `--machine` 选项来指定容器。例如，如果你想查看一个名为 “foobar” 的容器的日志，你可以使用 `journalctl --machine=foobar`。你也可以使用 `systemctl --machine=foobar status service` 来查看运行在这个容器中的服务状态。

### 和 SELinux 一起工作

如果你要使用 SELinux 强制模式（Fedora 默认模式），你需要为你的容器设置 SELinux 环境。想要那样的话，你需要在宿主系统上运行下面两行命令。

```
$ semanage fcontext -a -t svirt_sandbox_file_t "/path/to/container(/.*)?"
$ restorecon -R /path/to/container/

```

确保使用你的容器路径替换 “/path/to/container”。对于我的容器 "DebianJessie"，我会运行下面的命令：

```
$ semanage fcontext -a -t svirt_sandbox_file_t "/home/johnmh/DebianJessie(/.*)?"
$ restorecon -R /home/johnmh/DebianJessie/

```

---

via: <https://fedoramagazine.org/container-technologies-fedora-systemd-nspawn/>

作者：[John M. Harris, Jr.](https://fedoramagazine.org/container-technologies-fedora-systemd-nspawn/) 译者：[ChrisLeeGit](https://github.com/chrisleegit) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


Fedora 内核是由什么构成的？

Summary: 每个 Fedora 内核都起始于一个来自于上游社区的基线版本——通常称之为 vanilla 内核。上游内核就是标准。

Fedora 的内核不是linux吗？怎么成vanilla 内核了

来自江苏南京的 Internet Explorer 11.0|Windows 7 用户

没看懂

没看懂

Each release of the Fedora kernel starts with a baseline release from the upstream community. This is often called a ‘vanilla’ kernel. --> https:||fedoramagazine.org|makes-fedora-kernel|

我也是一没有看懂！！！

vanilla javascript=原生javascript

vanilla kernel=原生kernel

文章说的是fedora用的内核基础就是原生内核，但是加上一大堆自己的补丁，然后维护这些补丁不容易。

标题可能不太合适，或者是我们理解的标题没翻译到位

Linux一叶 [Chrome Mobile iOS 52.0|iOS 9.3]

# Fedora 内核是由什么构成的？

<img src="content_image/album_201607_29_144036jyzsz1j1uu1g8auz.png" alt="" title="">

每个 Fedora 系统都运行着一个内核。许多代码片段组合在一起使之成为现实。

每个 Fedora 内核都起始于一个来自于[上游社区](http://www.kernel.org/)的基线版本——通常称之为 vanilla 内核。上游内核就是标准。（Fedora 的）目标是包含尽可能多的上游代码，这样使得 bug 修复和 API 更新更加容易，同时也会有更多的人审查代码。理想情况下，Fedora 能够直接获取 kernel.org 的内核，然后发送给所有用户。

现实情况是，使用 vanilla 内核并不能完全满足 Fedora。Vanilla 内核可能并不支持一些 Fedora 用户希望拥有的功能。用户接收的 [Fedora 内核] 是在 vanilla 内核之上打了很多补丁的内核。这些补丁被认为“<ruby> 不在树上 <rp>  （ </rp> <rt>  out of tree </rt> <rp>  ） </rp></ruby>”。许多这些位于补丁树之外的补丁都不会存在太久。如果某补丁能够修复一个问题，那么该补丁可能会被合并到 Fedora 树，以便用户能够更快地收到修复。当内核变基到一个新版本时，在新版本中的补丁都将被清除。

一些补丁会在 Fedora 内核树上存在很长时间。一个很好的例子是，安全启动补丁就是这类补丁。这些补丁提供了 Fedora 希望支持的功能，即使上游社区还没有接受它们。保持这些补丁更新是需要付出很多努力的，所以 Fedora 尝试减少不被上游内核维护者接受的补丁数量。

通常来说，想要在 Fedora 内核中获得一个补丁的最佳方法是先给 [Linux 内核邮件列表（LKML）](http://www.labbott.name/blog/2015/10/02/the-art-of-communicating-with-lkml/) 发送补丁，然后请求将该补丁包含到 Fedora 中。如果某个维护者接受了补丁，就意味着 Fedora 内核树中将来很有可能会包含该补丁。一些来自于 GitHub 等地方的还没有提交给 LKML 的补丁是不可能进入内核树的。首先向 LKML 发送补丁是非常重要的，它能确保 Fedora 内核树中携带的补丁是功能正常的。如果没有社区审查，Fedora 最终携带的补丁将会充满 bug 并会导致问题。

Fedora 内核中包含的代码来自许多地方。一切都需要提供最佳的体验。

---

via: <https://fedoramagazine.org/makes-fedora-kernel/>

作者：[Laura Abbott](https://fedoramagazine.org/makes-fedora-kernel/) 译者：[ChrisLeeGit](https://github.com/chrisleegit) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


开源新闻速递：ArchEX Build 160724 发布

Summary: openSUSE Tumbleweed采用了最新的 KDE Plasma 5.7。Ubuntu Budgie Remix 16.04.1 发布。

求问最后那张图里右边是什么软件？

# 开源新闻速递：ArchEX Build 160724 发布

### 今日关注

基于最新 Arch Linux 技术的 ArchEX Build 160724 发布，在这个发行版中包括了最新的软件包，比如Linux内核4.6.4。据该操作系统开发者 Arne Exton 称，这一版本在几乎所有机器上运行是最快的，鉴于Arch Linux是最轻量级、高度定制并且拥有一大批用户的操作系统，采用的LXDE桌面环境即便是在旧的PC机上也是运行最快的，我们有理由相信Arne Exton的话。

### 图文摘要

*openSUSE Tumbleweed 的用户目前已经可以使用最新的 KDE Plasma 5.7 桌面环境以及KDE应用16.04软件套件了，Linux内核也更新到了4.6.4。*

*Linux Kernel 4.4.16 LTS 发布，进行了150多处改动。Solus系统的用户已经可以优先进行更新了。*

*Ubuntu Budgie Remix 16.04.1 发布，在这一版本中，采用了最新的Solus' Budgie桌面环境，还可以对全部磁盘进行加密，也可以对Home文件夹进行加密。另外，也可以选择任何你熟悉的语言来进行安装。还有一个好消息，这一版本引入了对快照打包的支持。*


# 如何在 Ubuntu Linux 16.04上安装开源的 Discourse 论坛

Discourse 是一个开源的论坛，它可以以邮件列表、聊天室或者论坛等多种形式工作。它是一个广受欢迎的现代的论坛工具。在服务端，它使用 Ruby on Rails 和 Postgres 搭建, 并且使用 Redis 缓存来减少读取时间 , 在客户端，它使用支持 Java Script 的浏览器。它非常容易定制，结构良好，并且它提供了转换插件，可以对你现存的论坛、公告板进行转换，例如： vBulletin、phpBB、Drupal、SMF 等等。在这篇文章中，我们将学习在 Ubuntu 操作系统下安装 Discourse。

它以安全作为设计思想，所以发垃圾信息的人和黑客们不能轻易的实现其企图。它能很好的支持各种现代设备，并可以相应的调整以手机和平板的显示。

### 在 Ubuntu 16.04 上安装 Discourse

让我们开始吧 ! 最少需要 1G 的内存，并且官方支持的安装过程需要已经安装了 docker。 说到 docker，它还需要安装Git。要满足以上的两点要求我们只需要运行下面的命令：

```
wget -qO- https://get.docker.com/ | sh

```

用不了多久就安装好了 docker 和 Git，安装结束以后，在你的系统上的 /var 分区创建一个 Discourse 文件夹（当然你也可以选择其他的分区）。

```
mkdir /var/discourse

```

现在我们来克隆 Discourse 的 Github 仓库到这个新建的文件夹。

```
git clone https://github.com/discourse/discourse_docker.git /var/discourse

```

进入这个克隆的文件夹。

```
cd /var/discourse

```

你将看到“discourse-setup” 脚本文件，运行这个脚本文件进行 Discourse 的初始化。

```
./discourse-setup

```

**备注： 在安装 discourse 之前请确保你已经安装好了邮件服务器。**

安装向导将会问你以下六个问题：

```
Hostname for your Discourse?
Email address for admin account?
SMTP server address?
SMTP user name?
SMTP port [587]:
SMTP password? []:

```

当你提交了以上信息以后, 它会让你提交确认, 如果一切都很正常，点击回车以后安装开始。

现在“坐等放宽”，需要花费一些时间来完成安装，倒杯咖啡，看看有什么错误信息没有。

安装成功以后看起来应该像这样。

现在打开浏览器，如果已经做了域名解析，你可以使用你的域名来连接 Discourse 页面 ，否则你只能使用IP地址了。你将看到如下信息：

就是这个，点击 “Sign Up” 选项创建一个新的账户，然后进行你的 Discourse 设置。

### 结论

它安装简便，运行完美。 它拥有现代论坛所有必备功能。它以 GPL 发布，是完全开源的产品。简单、易用、以及特性丰富是它的最大特点。希望你喜欢这篇文章，如果有问题，你可以给我们留言。

---

via: <http://linuxpitstop.com/install-discourse-on-ubuntu-linux-16-04/>

作者：[Aun](http://linuxpitstop.com/author/aun/) 译者：[kokialoves](https://github.com/kokialoves) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


Summary: 更多：Wireshark 2.0.5 发布；Canonical也宣布不再对 Ubuntu 15.10 进行安全和软件更新。

二次元风格的系统

你懂的~组长也懂的~谢谢一叶支持

# 开源新闻速递：Parabola GNU/Linux-libre 2016.07.27 ISO 镜像发布

### 今日关注

基于 Arch Linux 的 Parabola GNU/Linux-libre 2016.07.27 ISO 镜像发布。这一最新版本中涵盖了所有最近的安全更新以及最新版本的软件。有 Main ，MATE 和 TalkingParabola这三个版本，可以支持32位和64位机。在该发布版本中，将LightDM作为默认的显示管理器，实现了对Home目录更好的读写控制权限。一部分wheel组用户默认拥有sudo权限可以执行任何命令。

### 图文摘要

*Wireshark 2.0.5 发布。作为全球最流行的网络协议分析工具，安全专家们可以使用Wireshark来分析并解决网络问题。最新版本修复了20多个问题，更新了对内置的802.11 Radiotap, BGP, CAN, CANopen, H.248 Q.1950, IPv4, IPv6等协议的支持。*

*Enlightenment 0.20 系列的最后一个版本 0.20.10 [发布](https://www.enlightenment.org/news/e-0.20.10-release)。不过希望用户能更新到最新、最稳定的Enlightenment 0.21.0 版本。*

*System76 PC 机用户需要立即更行到 Ubuntu 16.04.1 LTS 了。在7.28号，Canonical也宣布不再对 Ubuntu 15.10 进行安全和软件更新。因此，如果你在System76的机器上安装的是Ubuntu 15.10，那就需要尽快更新到Ubuntu 16.04.1 LTS了。*


JStock：Linux 上不错的股票投资组合管理软件

Summary: 对于我们这些 Linux 爱好者们，我也找到了一些好用的开源投资组合管理工具，用来在 Linux 上管理和跟踪股票的投资组合，这里高度推荐一个基于 java 编写的管理软件 JStock。

在国内不管用的软件，这是翻译任务呀？

命令行下有类似推荐的工具么？

我以为你们会去炒纳斯达克的 ;-/

哈哈，也许也会有炒纳斯达克的喜欢在linux下

现在不用HTTP代理了吗？？？

# JStock：Linux 上不错的股票投资组合管理软件

如果你在股票市场做投资，那么你可能非常清楚投资组合管理计划有多重要。管理投资组合的目标是依据你能承受的风险，时间层面的长短和资金盈利的目标去为你量身打造的一种投资计划。鉴于这类软件的重要性，因此从来不会缺乏商业性的 app 和股票行情检测软件，每一个都可以兜售复杂的投资组合以及跟踪报告功能。

对于我们这些 Linux 爱好者们，我也找到了一些**好用的开源投资组合管理工具**，用来在 Linux 上管理和跟踪股票的投资组合，这里高度推荐一个基于 java 编写的管理软件 [JStock](http://jstock.org/)。如果你不是一个 java 粉，也许你会放弃它，JStock 需要运行在沉重的 JVM 环境上。但同时，在每一个安装了 JRE 的环境中它都可以马上运行起来，在你的 Linux 环境中它会运行的很顺畅。

“开源”就意味着免费或标准低下的时代已经过去了。鉴于 JStock 只是一个个人完成的产物，作为一个投资组合管理软件它最令人印象深刻的是包含了非常多实用的功能，以上所有的荣誉属于它的作者 Yan Cheng Cheok！例如，JStock 支持通过监视列表去监控价格，多种投资组合，自选/内置的股票指标与相关监测，支持27个不同的股票市场和跨平台的云端备份/还原。JStock 支持多平台部署（Linux, OS X, Android 和 Windows），你可以通过云端保存你的 JStock 投资组合，并通过云平台无缝的备份/还原到其他的不同平台上面。

现在我将向你展示如何安装以及使用过程的一些具体细节。

### 在 Linux 上安装 JStock

因为 JStock 使用Java编写，所以必须[安装 JRE](http://ask.xmodulo.com/install-java-runtime-Linux.html)才能让它运行起来。小提示，JStock 需要 JRE1.7 或更高版本。如你的 JRE 版本不能满足这个需求，JStock 将会运行失败然后出现下面的报错。

```
Exception in thread "main" java.lang.UnsupportedClassVersionError: org/yccheok/jstock/gui/JStock : Unsupported major.minor version 51.0

```

在你的 Linux 上安装好了 JRE 之后，从其官网下载最新的发布的 JStock，然后加载启动它。

```
$ wget https://github.com/yccheok/jstock/releases/download/release_1-0-7-13/jstock-1.0.7.13-bin.zip
$ unzip jstock-1.0.7.13-bin.zip
$ cd jstock
$ chmod +x jstock.sh
$ ./jstock.sh

```

教程的其他部分，让我来给大家展示一些 JStock 的实用功能

### 监视监控列表中股票价格的波动

使用 JStock 你可以创建一个或多个监视列表，它可以自动的监视股票价格的波动并给你提供相应的通知。在每一个监视列表里面你可以添加多个感兴趣的股票进去。之后在“Fall Below”和“Rise Above”的表格里添加你的警戒值，分别设定该股票的最低价格和最高价格。

例如你设置了 AAPL 股票的最低/最高价格分别是 $102 和 $115.50，只要在价格低于 $102 或高于 $115.50 时你就得到桌面通知。

你也可以设置邮件通知，这样你将收到一些价格信息的邮件通知。设置邮件通知在“Options”菜单里，在“Alert”标签中国，打开“Send message to email(s)”，填入你的 Gmail 账户。一旦完成 Gmail 认证步骤，JStock 就会开始发送邮件通知到你的 Gmail 账户（也可以设置其他的第三方邮件地址）。

### 管理多个投资组合

JStock 允许你管理多个投资组合。这个功能对于你使用多个股票经纪人时是非常实用的。你可以为每个经纪人创建一个投资组合去管理你的“买入/卖出/红利”用来了解每一个经纪人的业务情况。你也可以在“Portfolio”菜单里面选择特定的投资组合来切换不同的组合项目。下面是一张截图用来展示一个假设的投资组合。

你也可以设置付给中介费，你可以为每个买卖交易设置中介费、印花税以及结算费。如果你比较懒，你也可以在选项菜单里面启用自动费用计算，并提前为每一家经济事务所设置费用方案。当你为你的投资组合增加交易之后，JStock 将自动的计算并计入费用。

### 使用内置/自选股票指标来监控

如果你要做一些股票的技术分析，你可能需要基于各种不同的标准来监控股票（这里叫做“股票指标”）。对于股票的跟踪，JStock提供多个[预设的技术指示器](http://jstock.org/ma_indicator.html) 去获得股票上涨/下跌/逆转指数的趋势。下面的列表里面是一些可用的指标。

* 平滑异同移动平均线（MACD）
* 相对强弱指标 (RSI)
* 资金流向指标 (MFI)
* 顺势指标 (CCI)
* 十字线
* 黄金交叉线，死亡交叉线
* 涨幅/跌幅

开启预设指示器能需要在 JStock 中点击“Stock Indicator Editor”标签。之后点击右侧面板中的安装按钮。选择“Install from JStock server”选项，之后安装你想要的指示器。

一旦安装了一个或多个指示器，你可以用他们来扫描股票。选择“Stock Indicator Scanner”标签，点击底部的“Scan”按钮，选择需要的指示器。

当你选择完需要扫描的股票（例如， NYSE, NASDAQ）以后，JStock 将执行该扫描，并将该指示器捕获的结果通过列表展现。

除了预设指示器以外，你也可以使用一个图形化的工具来定义自己的指示器。下面这张图例用于监控当前价格小于或等于60天平均价格的股票。

### 通过云在 Linux 和 Android JStock 之间备份/恢复

另一个非常棒的功能是 JStock 支持云备份恢复。Jstock 可以通过 Google Drive 把你的投资组合/监视列表在云上备份和恢复，这个功能可以实现在不同平台上无缝穿梭。如果你在两个不同的平台之间来回切换使用 Jstock，这种跨平台备份和还原非常有用。我在 Linux 桌面和 Android 手机上测试过我的 Jstock 投资组合，工作的非常漂亮。我在 Android 上将 Jstock 投资组合信息保存到 Google Drive 上，然后我可以在我的 Linux 版的 Jstock 上恢复它。如果能够自动同步到云上，而不用我手动地触发云备份/恢复就更好了，十分期望这个功能出现。

如果你在从 Google Drive 还原之后不能看到你的投资信息以及监视列表，请确认你的国家信息与“Country”菜单里面设置的保持一致。

JStock 的安卓免费版可以从 [Google Play Store](https://play.google.com/store/apps/details?id=org.yccheok.jstock.gui) 获取到。如果你需要完整的功能（比如云备份，通知，图表等），你需要一次性支付费用升级到高级版。我认为高级版物有所值。

写在最后，我应该说一下它的作者，Yan Cheng Cheok，他是一个十分活跃的开发者，有bug及时反馈给他。这一切都要感谢他！！！

关于 JStock 这个投资组合跟踪软件你有什么想法呢？

---

via: <http://xmodulo.com/stock-portfolio-management-software-Linux.html>

作者：[Dan Nanni](http://xmodulo.com/author/nanni) 译者：[ivo-wang](https://github.com/ivo-wang) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://Linux.cn/) 荣誉推出


在浏览器中体验 Ubuntu

Summary: 为了进一步推广 Ubuntu Linux，Canonical 把它放到了浏览器里，你可以在任何地方使用这个 Ubuntu 演示版。 它将帮你更好的体验 Ubuntu，以便让新人更容易决定是否使用它。

体验感觉极差，不如自己安装一个来玩

虽然体验度和真实的差距好大，但是还是挺好玩的。

# 在浏览器中体验 Ubuntu

[Ubuntu](http://www.ubuntu.com/) 的背后的公司 [Canonical](http://www.canonical.com/) 为 Linux 推广做了很多努力。无论你有多么不喜欢 Ubuntu，你必须承认它对 “Linux 易用性”的影响。Ubuntu 以及其衍生是使用最多的 Linux 版本。

为了进一步推广 Ubuntu Linux，Canonical 把它放到了浏览器里，你可以在任何地方使用这个 [Ubuntu 演示版](http://tour.ubuntu.com/en/)。 它将帮你更好的体验 Ubuntu，以便让新人更容易决定是否使用它。

你可能争辩说 USB 版的 Linux 更好。我同意，但是你要知道你要下载 ISO，创建 USB 启动盘，修改配置文件，然后才能使用这个 USB 启动盘来体验。这么乏味并不是每个人都乐意这么干的。 在线体验是一个更好的选择。

那么，你能在 Ubuntu 在线看到什么。实际上并不多。

你可以浏览文件，你可以使用 Unity Dash，浏览 Ubuntu 软件中心，甚至装几个应用（当然它们不会真的安装），看一看文件浏览器和其它一些东西。以上就是全部了。但是在我看来，这已经做的很好了，让你知道它是个什么，对这个流行的操作系统有个直接感受。

如果你的朋友或者家人对试试 Linux 抱有兴趣，但是想在安装前想体验一下 Linux 。你可以给他们以下链接：[Ubuntu 在线导览](http://tour.ubuntu.com/en/) 。

---

via: <https://itsfoss.com/ubuntu-online-demo/>

作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 译者：[kokialoves](https://github.com/kokialoves) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


GNU KHATA：开源的会计管理软件

Summary: GNU Khata 是一个会计工具。 或者，我应该说成是一系列的会计工具集合？它就像经济管理方面的 Evernote 一样。

阿三的东西不敢用

# GNU KHATA：开源的会计管理软件

作为一个活跃的 Linux 爱好者，我经常向我的朋友们介绍 Linux，帮助他们选择最适合他们的发行版本，同时也会帮助他们安装一些适用于他们工作的开源软件。

但是在这一次，我就变得很无奈。我的叔叔，他是一个自由职业的会计师。他会有一系列的为了会计工作的漂亮而成熟的付费软件。我不那么确定我能在在开源软件中找到这么一款可以替代的软件——直到昨天。

Abhishek 给我推荐了一些[很酷的软件](https://itsfoss.com/category/apps/)，而其中 GNU Khata 脱颖而出。

[GNU Khata](http://www.gnukhata.in/) 是一个会计工具。 或者，我应该说成是一系列的会计工具集合？它就像经济管理方面的 [Evernote](https://evernote.com/) 一样。它的应用是如此之广，以至于它不但可以用于个人的财务管理，也可以用于大型公司的管理，从店铺存货管理到税率计算，都可以有效处理。

有个有趣的地方，Khata 这个词在印度或者是其他的印度语国家中意味着账户，所以这个会计软件叫做 GNU Khata。

### 安装

互联网上有很多关于旧的 Web 版本的 Khata 安装介绍。现在，GNU Khata 只能用在 Debian/Ubuntu 和它们的衍生版本中。我建议你按照 GNU Khata 官网给出的如下步骤来安装。我们来快速过一下。

* 从[这里](https://cloud.openmailbox.org/index.php/s/L8ppsxtsFq1345E/download)下载安装器。
* 在下载目录打开终端。
* 粘贴复制以下的代码到终端，并且执行。

```
sudo chmod 755 GNUKhatasetup.run
sudo ./GNUKhatasetup.run

```

这就结束了，从你的 Dash 或者是应用菜单中启动 GNU Khata 吧。

### 第一次启动

GNU Khata 在浏览器中打开，并且展现以下的画面。

填写组织的名字、组织形式，财务年度并且点击 proceed 按钮进入管理设置页面。

仔细填写你的用户名、密码、安全问题及其答案，并且点击“create and login”。

你已经全部设置完成了。使用菜单栏来开始使用 GNU Khata 来管理你的财务吧。这很容易。

### 移除 GNU KHATA

如果你不想使用 GNU Khata 了，你可以执行如下命令移除：

```
sudo apt-get remove --auto-remove gnukhata-core-engine

```

你也可以通过新立得软件管理来删除它。

### GNU KHATA 真的是市面上付费会计应用的竞争对手吗？

首先，GNU Khata 以简化为设计原则。顶部的菜单栏组织的很方便，可以帮助你有效的进行工作。你可以选择管理不同的账户和项目，并且切换非常容易。[它们的官网](http://www.gnukhata.in/)表明，GNU Khata 可以“像说印度语一样方便”（LCTT 译注：原谅我，这个软件作者和本文作者是印度人……）。同时，你知道 GNU Khata 也可以在云端使用吗？

所有的主流的账户管理工具，比如分类账簿、项目报表、财务报表等等都用专业的方式整理，并且支持自定义格式和即时展示。这让会计和仓储管理看起来如此的简单。

这个项目正在积极的发展，正在寻求实操中的反馈以帮助这个软件更加进步。考虑到软件的成熟性、使用的便利性还有免费的情况，GNU Khata 可能会成为你最好的账簿助手。

请在评论框里留言吧，让我们知道你是如何看待 GNU Khata 的。

---

via: <https://itsfoss.com/using-gnu-khata/>

作者：[Aquil Roshan](https://itsfoss.com/author/aquil/) 译者：[MikeCoder](https://github.com/MikeCoder) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


为你的 Linux 桌面设置一张实时的地球照片

Summary: 厌倦了看同样的桌面背景了么？这里有一个（可能是）世界上最棒的东西。

不错, 很适合装逼用. 收下了

这个下载要多长时间才能好呀？我的电脑开了好几个小时了，一点反应都没有（就是到了sudo python3 setup.py install这一步后，光标就一直闪，没反应了。。。请教，谢谢！

install这步我这里压根没成功过，一直报错，找不到“Python.h”，我也很郁闷

你这就没安装成功啊。

安装几天了, 一直卡在 Downloading titles: 15/16 completed.<br />
就差一张就完成了, 为什么就这么掉我胃口?

弄个其他卫星多好，同步卫星好单调。

真不错

以前Ubuntu有張靜態的地球wallpaper，拍攝地點是在北美洲上空，路徑是/usr/share/backgrounds/cosmos/blue-marble-west.jpg

補充，我提到的這張wallpaper應該是gnome art，不是ubuntu獨有，而是來自gnome

请教一下，为什么我的安装到这一步就一直没反应了?

Reading: https://pypi.python.org/simple/pytz

是因为读取太慢，需要镜像源之类的吗？谢谢！

碧海潮生按玉箫 [Internet Explorer 8.0|Windows 7]

是的，我安装pip3后就可以了，多谢

好单调，抓bing的图片来换不是更好么

厌倦了看同样的桌面背景了么？这里有一个（可能是）世界上最棒的东西。

# 为你的 Linux 桌面设置一张实时的地球照片

厌倦了看同样的桌面背景了么？这里有一个（可能是）世界上最棒的东西。

‘[Himawaripy](https://github.com/boramalper/himawaripy)’ 是一个 Python 3 小脚本，它会抓取由[日本 Himawari 8 气象卫星](https://en.wikipedia.org/wiki/Himawari_8)拍摄的接近实时的地球照片，并将它设置成你的桌面背景。

安装完成后，你可以将它设置成每 10 分钟运行的定时任务（自然，它要在后台运行），这样它就可以实时地取回地球的照片并设置成背景了。

因为 Himawari-8 是一颗同步轨道卫星，你只能看到澳大利亚上空的地球的图片——但是它实时的天气形态、云团和光线仍使它很壮丽，对我而言要是看到英国上方的就更好了！

高级设置允许你配置从卫星取回的图片质量，但是要记住增加图片质量会增加文件大小及更长的下载等待！

最后，虽然这个脚本与其他我们提到过的其他脚本类似，它还仍保持更新及可用。

### 获取 Himawaripy

Himawaripy 已经在一系列的桌面环境中都测试过了，包括 Unity、LXDE、i3、MATE 和其他桌面环境。它是自由开源软件，但是整体来说安装及配置不太简单。

在该项目的 [Github 主页](https://github.com/boramalper/himawaripy)上可以找到安装和设置该应用程序的所有指导（提示：没有一键安装功能）。

* [实时地球壁纸脚本的 GitHub 主页](https://github.com/boramalper/himawaripy)

### 安装及使用

一些读者请我在本文中补充一下一步步安装该应用的步骤。以下所有步骤都在其 GitHub 主页上，这里再贴一遍。

1、下载及解压 Himawaripy

这是最容易的步骤。点击下面的下载链接，然后下载最新版本，并解压到你的下载目录里面。

* [下载 Himawaripy 主干文件（.zip 格式）](https://github.com/boramalper/himawaripy/archive/master.zip)

2、安装 python3-setuptools

你需要手工来安装主干软件包，Ubuntu 里面默认没有安装它：

```
sudo apt install python3-setuptools

```

3、安装 Himawaripy

在终端中，你需要切换到之前解压的目录中，并运行如下安装命令：

```
cd ~/Downloads/himawaripy-master
sudo python3 setup.py install

```

4、 看看它是否可以运行并下载最新的实时图片：

```
himawaripy

```

5、 设置定时任务

如果你希望该脚本可以在后台自动运行并更新（如果你需要手动更新，只需要运行 ‘himarwaripy’ 即可）

在终端中运行：

```
crontab -e

```

在其中新加一行（默认每10分钟运行一次）

```
*/10 * * * * /usr/local/bin/himawaripy

```

关于[配置定时任务](https://help.ubuntu.com/community/CronHowto)可以在 Ubuntu Wiki 上找到更多信息。

该脚本安装后你不需要不断运行它，它会自动的每十分钟在后台运行一次。

---

via: <http://www.omgubuntu.co.uk/2016/07/set-real-time-earth-wallpaper-ubuntu-desktop>

作者：[JOEY-ELIJAH SNEDDON](https://plus.google.com/117485690627814051450/?rel=author) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


开源新闻速递：GNOME Maps 重新恢复正常使用功能

Summary: 更多：私有云9.1社区版发布，Docker 1.12 正式发布。

三个短小新闻，不错

谢谢一叶支持

“这一版本引入了内置的编配管弦乐曲” 应该是"编排"

谢谢！已修改！

更多：私有云9.1社区版发布，Docker 1.12 正式发布。

# 开源新闻速递：GNOME Maps 重新恢复正常使用功能

### 今日关注

两周前，小编曾经报道过，MapQuest停服导致GNOME Maps这一免费应用下架。现在带来一个好消息，GNOME Maps又重新恢复正常使用功能了，这次是通过一个GNOME代理来获取Mapbox的接口，从而为GNOME Maps提供地图相关服务。GNOME Maps 3.21.4 也已经可以进行下载了。

### 图文摘要

*私有云9.1社区版发布，提供了对基于token的身份验证会话和可插入身份验证的支持。另外，9.1版本引入了一项新功能，可以列出所有连接了你个人用户页面的所有设备，你可以对一些特定的会话进行失效操作。当然，还有很多非常棒的功能，感兴趣的用户可以进行下载体验了。*

*Docker 1.12 正式发布。这一版本引入了内置的编排管弦乐曲，全新的Swarm模式，内置的路由网络以及大量的网络安全完善等。*

*科幻题材的太空大型多人联机角色扮演游戏 Vendetta Online 更新到了 1.8.381 版本，相比上一个版本，进行了许多完善，比如对VR的完善，对Oculus Rift 1.6 和 Touch 的支持。感兴趣的玩家可以更新体验了。*


Git 系列（一）：什么是 Git

Summary: 忘记你以前所知的 Git，让我们重新走进 Git 世界的大门。

写的真好。深入浅出，有概念了。谢谢。

忘记你以前所知的 Git，让我们重新走进 Git 世界的大门。

# Git 系列（一）：什么是 Git

欢迎阅读本系列关于如何使用 Git 版本控制系统的教程！通过本文的介绍，你将会了解到 Git 的用途及谁该使用 Git。

如果你刚步入开源的世界，你很有可能会遇到一些在 Git 上托管代码或者发布使用版本的开源软件。事实上，不管你知道与否，你都在使用基于 Git 进行版本管理的软件：Linux 内核（就算你没有在手机或者电脑上使用 Linux，你正在访问的网站也是运行在 Linux 系统上的），Firefox、Chrome 等其他很多项目都通过 Git 代码库和世界各地开发者共享他们的代码。

换个角度来说，你是否仅仅通过 Git 就可以和其他人共享你的代码？你是否可以在家里或者企业里私有化的使用 Git？你必须要通过一个 GitHub 账号来使用 Git 吗？为什么要使用 Git 呢？Git 的优势又是什么？Git 是我唯一的选择吗？这对 Git 所有的疑问都会把我们搞的一脑浆糊。

因此，忘记你以前所知的 Git，让我们重新走进 Git 世界的大门。

### 什么是版本控制系统？

Git 首先是一个版本控制系统。现在市面上有很多不同的版本控制系统：CVS、SVN、Mercurial、Fossil 当然还有 Git。

很多像 GitHub 和 GitLab 这样的服务是以 Git 为基础的，但是你也可以只使用 Git 而无需使用其他额外的服务。这意味着你可以以私有或者公有的方式来使用 Git。

如果你曾经和其他人有过任何电子文件方面的合作，你就会知道传统版本管理的工作流程。开始是很简单的：你有一个原始的版本，你把这个版本发送给你的同事，他们在接收到的版本上做了些修改，现在你们有两个版本了，然后他们把他们手上修改过的版本发回来给你。你把他们的修改合并到你手上的版本中，现在两个版本又合并成一个最新的版本了。

然后，你修改了你手上最新的版本，同时，你的同事也修改了他们手上合并前的版本。现在你们有 3 个不同的版本了，分别是合并后最新的版本，你修改后的版本，你同事手上继续修改过的版本。至此，你们的版本管理工作开始变得越来越混乱了。

正如 Jason van Gumster 在他的文章中指出 [即使是艺术家也需要版本控制](https://opensource.com/life/16/2/version-control-isnt-just-programmers)，而且已经在个别人那里发现了这种趋势变化。无论是艺术家还是科学家，开发一个某种实验版本是并不鲜见的；在你的项目中，可能有某个版本大获成功，把项目推向一个新的高度，也可能有某个版本惨遭失败。因此，最终你不可避免的会创建出一堆名为project\_justTesting.kdenlive、project\_betterVersion.kdenlive、project\_best\_FINAL.kdenlive、project\_FINAL-alternateVersion.kdenlive 等类似名称的文件。

不管你是修改一个 for 循环，还是一些简单的文本编辑，一个好的版本控制系统都会让我们的生活更加的轻松。

### Git 快照

Git 可以为项目创建快照，并且存储这些快照为唯一的版本。

如果你将项目带领到了一个错误的方向上，你可以回退到上一个正确的版本，并且开始尝试另一个可行的方向。

如果你是和别人合作开发，当有人向你发送他们的修改时，你可以将这些修改合并到你的工作分支中，然后你的同事就可以获取到合并后的最新版本，并在此基础上继续工作。

Git 并不是魔法，因此冲突还是会发生的（“你修改了某文件的最后一行，但是我把这行整行都删除了；我们怎样处理这些冲突呢？”），但是总体而言，Git 会为你保留了所有更改的历史版本，甚至允许并行版本。这为你保留了以任何方式处理冲突的能力。

### 分布式 Git

在不同的机器上为同一个项目工作是一件复杂的事情。因为在你开始工作时，你想要获得项目的最新版本，然后此基础上进行修改，最后向你的同事共享这些改动。传统的方法是通过笨重的在线文件共享服务或者老旧的电邮附件，但是这两种方式都是效率低下且容易出错。

Git 天生是为分布式工作设计的。如果你要参与到某个项目中，你可以<ruby> 克隆 <rp>  （ </rp> <rt>  clone </rt> <rp>  ） </rp></ruby>该项目的 Git 仓库，然后就像这个项目只有你本地一个版本一样对项目进行修改。最后使用一些简单的命令你就可以<ruby> 拉取 <rp>  （ </rp> <rt>  pull </rt> <rp>  ） </rp></ruby>其他开发者的修改，或者你可以把你的修改<ruby> 推送 <rp>  （ </rp> <rt>  push </rt> <rp>  ） </rp></ruby>给别人。现在不用担心谁手上的是最新的版本，或者谁的版本又存放在哪里等这些问题了。全部人都是在本地进行开发，然后向共同的目标推送或者拉取更新。（或者不是共同的目标，这取决于项目的开发方式）。

### Git 界面

最原始的 Git 是运行在 Linux 终端上的应用软件。然而，得益于 Git 是开源的，并且拥有良好的设计，世界各地的开发者都可以为 Git 设计不同的访问界面。

Git 完全是免费的，并且已经打包在 Linux，BSD，Illumos 和其他类 Unix 系统中，Git 命令看起来像这样：

```
$ git --version
git version 2.5.3

```

可能最著名的 Git 访问界面是基于网页的，像 GitHub、开源的 GitLab、Savannah、BitBucket 和 SourceForge 这些网站都是基于网页端的 Git 界面。这些站点为面向公众和面向社会的开源软件提供了最大限度的代码托管服务。在一定程度上，基于浏览器的图形界面（GUI）可以尽量的减缓 Git 的学习曲线。下面的 GitLab 界面的截图：

再者，第三方 Git 服务提供商或者独立开发者甚至可以在 Git 的基础上开发出不是基于 HTML 的定制化前端界面。此类界面让你可以不用打开浏览器就可以方便的使用 Git 进行版本管理。其中对用户最透明的方式是直接集成到文件管理器中。KDE 文件管理器 Dolphin 可以直接在目录中显示 Git 状态，甚至支持提交，推送和拉取更新操作。

[Sparkleshare](http://sparkleshare.org/) 使用 Git 作为其 Dropbox 式的文件共享界面的基础。

想了解更多的内容，可以查看 [Git wiki](https://git.wiki.kernel.org/index.php/InterfacesFrontendsAndTools#Graphical_Interfaces)，这个（长长的）页面中展示了很多 Git 的图形界面项目。

### 谁应该使用 Git？

就是你！我们更应该关心的问题是什么时候使用 Git？和用 Git 来干嘛？

### 我应该在什么时候使用 Git 呢？我要用 Git 来干嘛呢？

想更深入的学习 Git，我们必须比平常考虑更多关于文件格式的问题。

Git 是为了管理源代码而设计的，在大多数编程语言中，源代码就意味者一行行的文本。当然，Git 并不知道你把这些文本当成是源代码还是下一部伟大的美式小说。因此，只要文件内容是以文本构成的，使用 Git 来跟踪和管理其版本就是一个很好的选择了。

但是什么是文本呢？如果你在像 Libre Office 这类办公软件中编辑一些内容，通常并不会产生纯文本内容。因为通常复杂的应用软件都会对原始的文本内容进行一层封装，就如把原始文本内容用 XML 标记语言包装起来，然后封装在 Zip 包中。这种对原始文本内容进行一层封装的做法可以保证当你把文件发送给其他人时，他们可以看到你在办公软件中编辑的内容及特定的文本效果。奇怪的是，虽然，通常你的需求可能会很复杂，就像保存 [Kdenlive](https://opensource.com/life/11/11/introduction-kdenlive) 项目文件，或者保存从 [Inkscape](http://inkscape.org/) 导出的SVG文件，但是，事实上使用 Git 管理像 XML 文本这样的纯文本类容是最简单的。

如果你在使用 Unix 系统，你可以使用 `file` 命令来查看文件内容构成：

```
$ file ~/path/to/my-file.blah
my-file.blah: ASCII text
$ file ~/path/to/different-file.kra: Zip data (MIME type "application/x-krita")

```

如果还是不确定，你可以使用 `head` 命令来查看文件内容：

```
$ head ~/path/to/my-file.blah

```

如果输出的文本你基本能看懂，这个文件就很有可能是文本文件。如果你仅仅在一堆乱码中偶尔看到几个熟悉的字符，那么这个文件就可能不是文本文件了。

准确的说：Git 可以管理其他格式的文件，但是它会把这些文件当成二进制大对象（blob）。两者的区别是，在文本文件中，Git 可以明确的告诉你在这两个快照（或者说提交）间有 3 行是修改过的。但是如果你在两个<ruby> 提交 <rp>  （ </rp> <rt>  commit </rt> <rp>  ） </rp></ruby>之间对一张图片进行的编辑操作，Git 会怎么指出这种修改呢？实际上，因为图片并不是以某种可以增加或删除的有意义的文本构成，因此 Git 并不能明确的描述这种变化。当然我个人是非常希望图片的编辑可以像把文本“<sky>丑陋的蓝绿色</sky>”修改成“<sky>漂浮着蓬松白云的天蓝色</sky>”一样的简单，但是事实上图片的编辑并没有这么简单。

经常有人在 Git 上放入 png 图标、电子表格或者流程图这类二进制大型对象（blob）。尽管，我们知道在 Git 上管理此类大型文件并不直观，但是，如果你需要使用 Git 来管理此类文件，你也并不需要过多的担心。如果你参与的项目同时生成文本文件和二进制大文件对象（如视频游戏中常见的场景，这些和源代码同样重要的图像和音频材料），那么你有两条路可以走：要么开发出你自己的解决方案，就如使用指向共享网络驱动器的引用；要么使用 Git 插件，如 Joey Hess 开发的 [git annex](https://git-annex.branchable.com/)，以及 [Git-Media](https://github.com/alebedev/git-media) 项目。

你看，Git 真的是一个任何人都可以使用的工具。它是你进行文件版本管理的一个强大而且好用工具，同时它并没有你开始认为的那么可怕。

---

via: <https://opensource.com/resources/what-is-git>

作者：[Seth Kenlon](https://opensource.com/users/seth)  译者：[cvsher](https://github.com/cvsher) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


用 VeraCrypt 加密闪存盘

Summary: 要是你需要在 Windows 系统，苹果的 OS X 系统或者 Linux 系统上加密以及访问文件，开源软件 VeraCrypt 提供绝佳的选择。

結果TrueCrypt還是無疾而終，到底是因為什麼放棄維護到現任然是眾說紛紜。。。。

# 用 VeraCrypt 加密闪存盘

很多安全专家偏好像 VeraCrypt 这类能够用来加密闪存盘的开源软件，是因为可以获取到它的源代码。

保护 USB 闪存盘里的数据，加密是一个聪明的方法，正如我们在使用 Microsoft 的 BitLocker [加密闪存盘](http://www.esecurityplanet.com/views/article.php/3880616/How-to-Encrypt-a-USB-Flash-Drive.htm) 一文中提到的。

但是如果你不想用 BitLocker 呢？

你可能有顾虑，因为你不能够查看 Microsoft 的程序源码，那么它容易被植入用于政府或其它用途的“后门”。而由于开源软件的源码是公开的，很多安全专家认为开源软件很少藏有后门。

还好，有几个开源加密软件能作为 BitLocker 的替代。

要是你需要在 Windows 系统，苹果的 OS X 系统或者 Linux 系统上加密以及访问文件，开源软件 [VeraCrypt](http://www.esecurityplanet.com/open-source-security/veracrypt-a-worthy-truecrypt-alternative.html) 提供绝佳的选择。

VeraCrypt 源于 TrueCrypt。TrueCrypt 是一个备受好评的开源加密软件，尽管它现在已经停止维护了。但是 TrueCrypt 的代码通过了审核，没有发现什么重要的安全漏洞。另外，在 VeraCrypt 中对它进行了改善。

Windows，OS X 和 Linux 系统的版本都有。

用 VeraCrypt 加密 USB 闪存盘不像用 BitLocker 那么简单，但是它也只要几分钟就好了。

### 用 VeraCrypt 加密闪存盘的 8 个步骤

对应你的操作系统 [下载 VeraCrypt](https://veracrypt.codeplex.com/releases/view/619351) 之后：

打开 VeraCrypt，点击 Create Volume，进入 VeraCrypt 的<ruby> 创建卷向导程序 <rp>  （ </rp> <rt>  Volume Creation Wizard </rt> <rp>  ） </rp></ruby>。

VeraCrypt <ruby> 创建卷向导 <rp>  （ </rp> <rt>  Volume Creation Wizard </rt> <rp>  ） </rp></ruby>允许你在闪存盘里新建一个加密文件容器，这与其它未加密文件是独立的。或者你也可以选择加密整个闪存盘。这个时候你就选加密整个闪存盘就行。

然后选择<ruby> 标准模式 <rp>  （ </rp> <rt>  Standard VeraCrypt Volume </rt> <rp>  ） </rp></ruby>。

选择你想加密的闪存盘的驱动器卷标（这里是 O：）。

选择<ruby> 创建卷模式 <rp>  （ </rp> <rt>  Volume Creation Mode </rt> <rp>  ） </rp></ruby>。如果你的闪存盘是空的，或者你想要删除它里面的所有东西，选第一个。要么你想保持所有现存的文件，选第二个就好了。

这一步允许你选择加密选项。要是你不确定选哪个，就用默认的 AES 和 SHA-512 设置。

确定了卷容量后，输入并确认你想要用来加密数据密码。

要有效工作，VeraCrypt 要从一个熵或者“随机数”池中取出一个随机数。要初始化这个池，你将被要求随机地移动鼠标一分钟。一旦进度条变绿了，或者更方便的是等到进度条到了屏幕右边足够远的时候，点击 “<ruby> 格式化 <rp>  （ </rp> <rt>  Format </rt> <rp>  ） </rp></ruby>” 来结束创建加密盘。

### 用 VeraCrypt 使用加密过的闪存盘

当你想要使用一个加密了的闪存盘，先插入闪存盘到电脑上，启动 VeraCrypt。

然后选择一个没有用过的卷标（比如 Z:），点击<ruby> 自动挂载设备 <rp>  （ </rp> <rt>  Auto-Mount Devices </rt> <rp>  ） </rp></ruby>。

输入密码，点击确定。

挂载过程需要几分钟，这之后你的解密盘就能通过你先前选择的盘符进行访问了。

### VeraCrypt 移动硬盘安装步骤

如果你设置闪存盘的时候，选择的是加密过的容器而不是加密整个盘，你可以选择创建 VeraCrypt 称为<ruby> 移动硬盘 <rp>  （ </rp> <rt>  Traveler Disk </rt> <rp>  ） </rp></ruby>的设备。这会复制安装一个 VeraCrypt 到 USB 闪存盘。当你在别的 Windows 电脑上插入 U 盘时，就能从 U 盘自动运行 VeraCrypt；也就是说没必要在新电脑上安装 VeraCrypt。

你可以设置闪存盘作为一个<ruby> 移动硬盘 <rp>  （ </rp> <rt>  Traveler Disk </rt> <rp>  ） </rp></ruby>，在 VeraCrypt 的<ruby> 工具栏 <rp>  （ </rp> <rt>  Tools </rt> <rp>  ） </rp></ruby>菜单里选择<ruby> 移动硬盘设置 <rp>  （ </rp> <rt>  Traveler Disk SetUp </rt> <rp>  ） </rp></ruby>就行了。

要从<ruby> 移动硬盘 <rp>  （ </rp> <rt>  Traveler Disk </rt> <rp>  ） </rp></ruby>上运行 VeraCrypt，你必须要有那台电脑的管理员权限，这不足为奇。尽管这看起来是个限制，机密文件无法在不受控制的电脑上安全打开，比如在一个商务中心的电脑上。

>
> 本文作者 Paul Rubens 从事技术行业已经超过 20 年。这期间他为英国和国际主要的出版社，包括 《The Economist》《The Times》《Financial Times》《The BBC》《Computing》和《ServerWatch》等出版社写过文章，
>
>
>

---

via: <http://www.esecurityplanet.com/open-source-security/how-to-encrypt-flash-drive-using-veracrypt.html>

作者：[Paul Rubens](http://www.esecurityplanet.com/author/3700/Paul-Rubens)  译者：[GitFuture](https://github.com/GitFuture) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


Git 系列（二）：初步了解 Git

很有用

Git经常听说，但是不知道神马东东，看完两篇帖子，大概知道是个神马东东干嘛使的了。

# Git 系列（二）：初步了解 Git

在这个系列的[介绍篇](/article-7639-1.html)中，我们学习到了谁应该使用 Git，以及 Git 是用来做什么的。今天，我们将学习如何克隆公共 Git 仓库，以及如何提取出独立的文件而不用克隆整个仓库。

由于 Git 如此流行，因而如果你能够至少熟悉一些基础的 Git 知识也能为你的生活带来很多便捷。如果你可以掌握 Git 基础（你可以的，我发誓！），那么你将能够下载任何你需要的东西，甚至还可能做一些贡献作为回馈。毕竟，那就是开源的精髓所在：你拥有获取你使用的软件代码的权利，拥有和他人分享的自由，以及只要你愿意就可以修改它的权利。只要你熟悉了 Git，它就可以让这一切都变得很容易。

那么，让我们一起来熟悉 Git 吧。

### 读和写

一般来说，有两种方法可以和 Git 仓库交互：你可以从仓库中读取，或者你也能够向仓库中写入。它就像一个文件：有时候你打开一个文档只是为了阅读它，而其它时候你打开文档是因为你需要做些改动。

本文仅讲解如何从 Git 仓库读取。我们将会在后面的一篇文章中讲解如何向 Git 仓库写回的主题。

### Git 还是 GitHub？

一句话澄清：Git 不同于 GitHub（或 GitLab，或 Bitbucket）。Git 是一个命令行程序，所以它就像下面这样：

```
$ git
usage: Git [--version] [--help] [-C <path>]
  [-p | --paginate | --no-pager] [--bare]
  [--Git-dir=<path>] <command> [<args>]

```

由于 Git 是开源的，所以就有许多聪明人围绕它构建了基础软件；这些基础软件，包括在他们自己身边，都已经变得非常流行了。

我的文章系列将首先教你纯粹的 Git 知识，因为一旦你理解了 Git 在做什么，那么你就无需关心正在使用的前端工具是什么了。然而，我的文章系列也将涵盖通过流行的 Git 服务完成每项任务的常用方法，因为那些将可能是你首先会遇到的。

### 安装 Git

在 Linux 系统上，你可以从所使用的发行版软件仓库中获取并安装 Git。BSD 用户应当在 Ports 树的 devel 部分查找 Git。

对于闭源的操作系统，请前往其[项目官网](https://git-scm.com/download)，并根据说明安装。一旦安装后，在 Linux、BSD 和 Mac OS X 上的命令应当没有任何差别。Windows 用户需要调整 Git 命令，从而和 Windows 文件系统相匹配，或者安装 Cygwin 以原生的方式运行 Git，而不受 Windows 文件系统转换问题的羁绊。

### Git 下午茶

并非每个人都需要立刻将 Git 加入到我们的日常生活中。有些时候，你和 Git 最多的交互就是访问一个代码库，下载一两个文件，然后就不用它了。以这样的方式看待 Git，它更像是下午茶而非一次正式的宴会。你进行一些礼节性的交谈，获得了需要的信息，然后你就会离开，至少接下来的三个月你不再想这样说话。

当然，那是可以的。

一般来说，有两种方法访问 Git：使用命令行，或者使用一种神奇的因特网技术通过 web 浏览器快速轻松地访问。

假设你想要给终端安装一个回收站，因为你已经被 rm 命令毁掉太多次了。你可能听说过 Trashy ，它称自己为「理智的 rm 命令中间人」，也许你想在安装它之前阅读它的文档。幸运的是，[Trashy 公开地托管在 GitLab.com](https://gitlab.com/trashy/trashy)。

### Landgrab

我们工作的第一步是对这个 Git 仓库使用 landgrab 排序方法：我们会克隆这个完整的仓库，然后会根据内容排序。由于该仓库是托管在公共的 Git 服务平台上，所以有两种方式来完成工作：使用命令行，或者使用 web 界面。

要想使用 Git 获取整个仓库，就要使用 git clone 命令和 Git 仓库的 URL 作为参数。如果你不清楚正确的 URL 是什么，仓库应该会告诉你的。GitLab 为你提供了 [Trashy](https://gitlab.com/trashy/trashy.git) 仓库的用于拷贝粘贴的 URL。

你也许注意到了，在某些服务平台上，会同时提供 SSH 和 HTTPS 链接。只有当你拥有仓库的写权限时，你才可以使用 SSH。否则的话，你必须使用 HTTPS URL。

一旦你获得了正确的 URL，克隆仓库是非常容易的。就是 git clone 该 URL 即可，以及一个可选的指定要克隆到的目录。默认情况下会将 git 目录克隆到你当前所在的目录；例如，'trashy.git' 将会克隆到你当前位置的 'trashy' 目录。我使用 .clone 扩展名标记那些只读的仓库，而使用 .git 扩展名标记那些我可以读写的仓库，不过这并不是官方要求的。

```
$ git clone https://gitlab.com/trashy/trashy.git trashy.clone
Cloning into 'trashy.clone'...
remote: Counting objects: 142, done.
remote: Compressing objects: 100% (91/91), done.
remote: Total 142 (delta 70), reused 103 (delta 47)
Receiving objects: 100% (142/142), 25.99 KiB | 0 bytes/s, done.
Resolving deltas: 100% (70/70), done.
Checking connectivity... done.

```

一旦成功地克隆了仓库，你就可以像对待你电脑上任何其它目录那样浏览仓库中的文件。

另外一种获得仓库拷贝的方式是使用 web 界面。GitLab 和 GitHub 都会提供一个 .zip 格式的仓库快照文件。GitHub 有一个大大的绿色下载按钮，但是在 GitLab 中，可以在浏览器的右侧找到并不显眼的下载按钮。

### 仔细挑选

另外一种从 Git 仓库中获取文件的方法是找到你想要的文件，然后把它从仓库中拽出来。只有 web 界面才提供这种方法，本质上来说，你看到的是别人的仓库克隆；你可以把它想象成一个 HTTP 共享目录。

使用这种方法的问题是，你也许会发现某些文件并不存在于原始仓库中，因为完整形式的文件可能只有在执行 make 命令后才能构建，那只有你下载了完整的仓库，阅读了 README 或者 INSTALL 文件，然后运行相关命令之后才会产生。不过，假如你确信文件存在，而你只想进入仓库，获取那个文件，然后离开的话，你就可以那样做。

在 GitLab 和 GitHub 中，单击文件链接，并在 Raw 模式下查看，然后使用你的 web 浏览器的保存功能，例如：在 Firefox 中，“文件” > “保存页面为”。在一个 GitWeb 仓库中（这是一个某些更喜欢自己托管 git 的人使用的私有 git 仓库 web 查看器），Raw 查看链接在文件列表视图中。

### 最佳实践

通常认为，和 Git 交互的正确方式是克隆完整的 Git 仓库。这样认为是有几个原因的。首先，可以使用 git pull 命令轻松地使克隆仓库保持更新，这样你就不必在每次文件改变时就重回 web 站点获得一份全新的拷贝。第二，你碰巧需要做些改进，只要保持仓库整洁，那么你可以非常轻松地向原来的作者提交所做的变更。

现在，可能是时候练习查找感兴趣的 Git 仓库，然后将它们克隆到你的硬盘中了。只要你了解使用终端的基础知识，那就不会太难做到。还不知道基本的终端使用方式吗？那再给多我 5 分钟时间吧。

### 终端使用基础

首先要知道的是，所有的文件都有一个路径。这是有道理的；如果我让你在常规的非终端环境下为我打开一个文件，你就要导航到文件在你硬盘的位置，并且直到你找到那个文件，你要浏览一大堆窗口。例如，你也许要点击你的家目录 > 图片 > InktoberSketches > monkey.kra。

在那样的场景下，文件 monkeysketch.kra 的路径是：$HOME/图片/InktoberSketches/monkey.kra。

在终端中，除非你正在处理一些特殊的系统管理员任务，你的文件路径通常是以 $HOME 开头的（或者，如果你很懒，就使用 ~ 字符），后面紧跟着一些列的文件夹直到文件名自身。

这就和你在 GUI 中点击各种图标直到找到相关的文件或文件夹类似。

如果你想把 Git 仓库克隆到你的文档目录，那么你可以打开一个终端然后运行下面的命令：

```
$ git clone https://gitlab.com/foo/bar.git
$HOME/文档/bar.clone

```

一旦克隆完成，你可以打开一个文件管理器窗口，导航到你的文档文件夹，然后你就会发现 bar.clone 目录正在等待着你访问。

如果你想要更高级点，你或许会在以后再次访问那个仓库，可以尝试使用 git pull 命令来查看项目有没有更新：

```
$ cd $HOME/文档/bar.clone
$ pwd
bar.clone
$ git pull

```

到目前为止，你需要初步了解的所有终端命令就是那些了，那就去探索吧。你实践得越多，Git 掌握得就越好（熟能生巧），这是重点，也是事情的本质。

---

via: <https://opensource.com/life/16/7/stumbling-git>

作者：[Seth Kenlon](https://opensource.com/users/seth) 译者：[ChrisLeeGit](https://github.com/chrisleegit) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译，[Linux中国](https://linux.cn/) 荣誉推出


开源新闻速递：天文软件 Stellarium 0.15.0 发布

Summary: 更多：代号为"Eclectica"的LXLE 16.04.1正式发版；Endian Firewall Community 3.2.1版本提供了对64位处理器的支持。

速递的排版让人非常摸不着头脑

Stellarium这个好有趣，刚装上玩下，还有中文的

请问，有什么好的建议嘛？可以提出来，我们会考虑进行调整。

是挺有意思的呢

现在文字是灰色斜体放在图片下面，不容易看到。 用普通的markdown语法写都比这个排版要清晰。

正在下载，看看

好用，不过，中文支持好像不到50%

能不能通过它实时抓取的图片设为桌面背景?

# 开源新闻速递：天文软件 Stellarium 0.15.0 发布

### 今日关注

Stellarium 0.15.0 发布。这是一款全世界最棒的免费、开源、跨平台的天文软件应用，用户可以通过该软件来观看实时的星星、行星还有星云。最新版本进行了非常多的功能完善，修复了若干bug，新增了许多新特性。比如更新了AstroCalc工具，新增的Bookmarks工具，米勒圆柱投影，新的脚本，脚本引擎的新功能点，还增加了像华盛顿双星这样的星级分类。目前可以下载体验了。

### 图文摘要

*代号为"Eclectica"的LXLE 16.04.1正式发版，基于最新发布的 Lubuntu 16.04.1 LTS 操作系统。默认支持 Btrfs 文件系统，支持多项监控配置，搭载了轻量级的快速启动工具，以及Aero窗口快照功能。*

*Endian Firewall Community 3.2.1发布。这是一款专门用于路由器和网络防火墙设备上的基于CentOS的GNU/Linux操作系统。在最新版本中，提供了对64位处理器的支持，对扩展的3G调制解调器的支持，以及多项硬件组件相关驱动的更新，多个安全补丁，还有对 Python 2.7 动态编程语言的支持，搭载了 Linux 内核 4.1 版本。*

*代号为 "Sarah" 的 Linux Mint 18 Xfce 版本目前已经可以从官网进行下载了。这一版本中引入了对X系列app的支持，像Xed, Xviewer, Xreader, Xplayer等，还加入了炫丽的 Mint-Y 主题。*


Vim 起步的五个技巧

Summary: 我使用了这么多年的 Linux ，我会的只是 Vim 的最最基本的操作。我的技能水平只能让我在终端使用 Vim 修改文本，但是它并没有任何一个我想象中强大的文本处理功能。这样我完全无法用 Vim 发挥出胜出 Pico 和 Nano 的能力。

# Vim 起步的五个技巧

多年来，我一直想学 Vim。如今 Vim 是我最喜欢的 Linux 文本编辑器，也是开发者和系统管理者最喜爱的开源工具。我说的学习，指的是真正意义上的学习。想要精通确实很难，所以我只想要达到熟练的水平。我使用了这么多年的 Linux ，我会的也仅仅只是打开一个文件，使用上下左右箭头按键来移动光标，切换到插入模式，更改一些文本，保存，然后退出。

但那只是 Vim 的最最基本的操作。我的技能水平只能让我在终端使用 Vim 修改文本，但是它并没有任何一个我想象中强大的文本处理功能。这样我完全无法用 Vim 发挥出胜出 Pico 和 Nano 的能力。

所以到底为什么要学习 Vim？因为我花费了相当多的时间用于编辑文本，而且我知道还有很大的效率提升空间。为什么不选择 Emacs，或者是更为现代化的编辑器例如 Atom？因为 Vim 适合我，至少我有一丁点的使用经验。而且，很重要的一点就是，在我需要处理的系统上很少碰见没有装 Vim 或者它的弱化版（Vi）。如果你有强烈的欲望想学习对你来说更给力的 Emacs，我希望这些对于 Emacs 同类编辑器的建议能对你有所帮助。

花了几周的时间专注提高我的 Vim 使用技巧之后，我想分享的第一个建议就是必须使用它。虽然这看起来就是明知故问的回答，但事实上它比我所预想的计划要困难一些。我的大多数工作是在网页浏览器上进行的，而且每次我需要在浏览器之外打开并编辑一段文本时，就需要避免下意识地打开 Gedit。Gedit 已经放在了我的快速启动栏中，所以第一步就是移除这个快捷方式，然后替换成 Vim 的。

为了更好的学习 Vim，我尝试了很多。如果你也正想学习，以下列举了一些作为推荐。

### Vimtutor

通常如何开始学习最好就是使用应用本身。我找到一个小的应用叫 Vimtutor，当你在学习编辑一个文本时它能辅导你一些基础知识，它向我展示了很多我这些年都忽视的基础命令。Vimtutor 一般在有 Vim 的地方都能找到它，如果你的系统上没有 Vimtutor，Vimtutor 可以很容易从你的包管理器上安装。

### GVim

我知道并不是每个人都认同这个，但就是它让我从使用终端中的 Vim 转战到使用 GVim 来满足我基本编辑需求。反对者表示 GVim 鼓励使用鼠标，而 Vim 主要是为键盘党设计的。但是我能通过 GVim 的下拉菜单快速找到想找的指令，并且 GVim 可以提醒我正确的指令然后通过敲键盘执行它。努力学习一个新的编辑器然后陷入无法解决的困境，这种感觉并不好受。每隔几分钟读一下 man 出来的文字或者使用搜索引擎来提醒你该用的按键序列也并不是最好的学习新事物的方法。

### 键盘表

当我转战 GVim，我发现有一个键盘的“速查表”来提醒我最基础的按键很是便利。网上有很多这种可用的表，你可以下载、打印，然后贴在你身边的某一处地方。但是为了我的笔记本键盘，我选择买一沓便签纸。这些便签纸在美国不到 10 美元，当我使用键盘编辑文本，尝试新的命令的时候，可以随时提醒我。

### Vimium

上文提到，我工作都在浏览器上进行。其中一条我觉得很有帮助的建议就是，使用 [Vimium](https://github.com/philc/vimium) 来用增强使用 Vim 的体验。Vimium 是 Chrome 浏览器上的一个开源插件，能用 Vim 的指令快捷操作 Chrome。我发现我只用了几次使用快捷键切换上下文，就好像比之前更熟悉这些快捷键了。同样的扩展 Firefox 上也有，例如 [Vimerator](http://www.vimperator.org/)。

### 其它人

毫无疑问，最好的学习方法就是求助于在你之前探索过的人，让他给你建议、反馈和解决方法。

如果你住在一个大城市，那么附近可能会有一个 Vim meetup 小组，或者还有 Freenode IRC 上的 #vim 频道。#vim 频道是 Freenode 上最活跃的频道之一，那上面可以针对你个人的问题来提供帮助。听上面的人发发牢骚或者看看别人尝试解决自己没有遇到过的问题，仅仅是这样我都觉得很有趣。

---

那么，现在怎么样了？到现在为止还不错。为它所花的时间是否值得就在于之后它为你节省了多少时间。但是当我发现一个新的按键序列可以来跳过词，或者一些相似的小技巧，我经常会收获意外的惊喜与快乐。每天我至少可以看见，一点点的回报，正在逐渐配得上当初的付出。

学习 Vim 并不仅仅只有这些建议，还有很多。我很喜欢指引别人去 [Vim Advantures](http://vim-adventures.com/)，它是一种使用 Vim 按键方式进行移动的在线游戏。而在另外一天我在 [Vimgifts.com](http://vimgifs.com/) 发现了一个非常神奇的虚拟学习工具，那可能就是你真正想要的：用一个小小的 gif 动图来描述 Vim 操作。

你有花时间学习 Vim 吗？或者是任何需要大量键盘操作的程序？那些经过你努力后掌握的工具，你认为这些努力值得吗？效率的提高有没有达到你的预期？分享你们的故事在下面的评论区吧。

---

via: <https://opensource.com/life/16/7/tips-getting-started-vim>

作者：[Jason Baker](https://opensource.com/users/jason-baker) 译者：[maywanting](https://github.com/maywanting) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


额，翻译的时候就感觉结尾怪怪的。。。原来下面还没结束。应该看看原文的。。。

# 如何用 Python 和 Flask 建立部署一个 Facebook Messenger 机器人

这是我建立一个简单的 Facebook Messenger 机器人的记录。功能很简单，它是一个回显机器人，只是打印回用户写了什么。

回显服务器类似于服务器的“Hello World”例子。

这个项目的目的不是建立最好的 Messenger 机器人，而是让你了解如何建立一个小型机器人和每个事物是如何整合起来的。

### 技术栈

使用到的技术栈:

* [Heroku](https://www.heroku.com) 做后端主机。免费级足够这个等级的教程。回显机器人不需要任何种类的数据持久，所以不需要数据库。
* [Python](https://www.python.org) 是我们选择的语言。版本选择 2.7，虽然它移植到 Pyhton 3 很容易，只需要很少的改动。
* [Flask](http://flask.pocoo.org) 作为网站开发框架。它是非常轻量的框架，用在小型工程或微服务是非常完美的。
* 最后 [Git](https://git-scm.com) 版本控制系统用来维护代码和部署到 Heroku。
* 值得一提：[Virtualenv](https://virtualenv.pypa.io/en/stable)。这个 python 工具是用来创建清洁的 python 库“环境”的，这样你可以只安装必要的需求和最小化应用的大小。

### 机器人架构

Messenger 机器人是由一个响应两种请求的服务器组成的：

* GET 请求被用来认证。他们与你注册的 FaceBook 认证码一同被 Messenger 发出。
* POST 请求被用来实际的通信。典型的工作流是，机器人将通过用户发送带有消息数据的 POST 请求而建立通信，然后我们将处理这些数据，并发回我们的 POST 请求。如果这个请求完全成功（返回一个 200 OK 状态码），我们也将响应一个 200 OK 状态码给初始的 Messenger请求。

这个教程应用将托管到 Heroku，它提供了一个优雅而简单的部署应用的接口。如前所述，免费级可以满足这个教程。

在应用已经部署并且运行后，我们将创建一个 Facebook 应用然后连接它到我们的应用，以便 Messenger 知道发送请求到哪，这就是我们的机器人。

### 机器人服务器

基本的服务器代码可以在 Github 用户 [hult(Magnus Hult)](https://github.com/hult) 的 [Chatbot](https://github.com/hult/facebook-chatbot-python) 项目上获取，做了一些只回显消息的代码修改和修正了一些我遇到的错误。最终版本的服务器代码如下：

```
from flask import Flask, request
import json
import requests

app = Flask(__name__)

### 这需要填写被授予的页面通行令牌（PAT）
### 它由将要创建的 Facebook 应用提供。
PAT = ''

@app.route('/', methods=['GET'])
def handle_verification():
  print "Handling Verification."
  if request.args.get('hub.verify_token', '') == 'my_voice_is_my_password_verify_me':
    print "Verification successful!"
    return request.args.get('hub.challenge', '')
  else:
    print "Verification failed!"
    return 'Error, wrong validation token'

@app.route('/', methods=['POST'])
def handle_messages():
  print "Handling Messages"
  payload = request.get_data()
  print payload
  for sender, message in messaging_events(payload):
    print "Incoming from %s: %s" % (sender, message)
    send_message(PAT, sender, message)
  return "ok"

def messaging_events(payload):
  """Generate tuples of (sender_id, message_text) from the
  provided payload.
  """
  data = json.loads(payload)
  messaging_events = data["entry"][0]["messaging"]
  for event in messaging_events:
    if "message" in event and "text" in event["message"]:
      yield event["sender"]["id"], event["message"]["text"].encode('unicode_escape')
    else:
      yield event["sender"]["id"], "I can't echo this"

def send_message(token, recipient, text):
  """Send the message text to recipient with id recipient.
  """

  r = requests.post("https://graph.facebook.com/v2.6/me/messages",
    params={"access_token": token},
    data=json.dumps({
      "recipient": {"id": recipient},
      "message": {"text": text.decode('unicode_escape')}
    }),
    headers={'Content-type': 'application/json'})
  if r.status_code != requests.codes.ok:
    print r.text

if __name__ == '__main__':
  app.run()

```

让我们分解代码。第一部分是引入所需的依赖：

```
from flask import Flask, request
import json
import requests

```

接下来我们定义两个函数（使用 Flask 特定的 app.route 装饰器），用来处理到我们的机器人的 GET 和 POST 请求。

```
@app.route('/', methods=['GET'])
def handle_verification():
  print "Handling Verification."
  if request.args.get('hub.verify_token', '') == 'my_voice_is_my_password_verify_me':
    print "Verification successful!"
    return request.args.get('hub.challenge', '')
  else:
    print "Verification failed!"
    return 'Error, wrong validation token'

```

当我们创建 Facebook 应用时，verify\_token 对象将由我们声明的 Messenger 发送。我们必须自己来校验它。最后我们返回“hub.challenge”给 Messenger。

处理 POST 请求的函数更有意思一些：

```
@app.route('/', methods=['POST'])
def handle_messages():
  print "Handling Messages"
  payload = request.get_data()
  print payload
  for sender, message in messaging_events(payload):
    print "Incoming from %s: %s" % (sender, message)
    send_message(PAT, sender, message)
  return "ok"

```

当被调用时，我们抓取消息载荷，使用函数 messaging\_events 来拆解它，并且提取发件人身份和实际发送的消息，生成一个可以循环处理的 python 迭代器。请注意 Messenger 发送的每个请求有可能多于一个消息。

```
def messaging_events(payload):
  """Generate tuples of (sender_id, message_text) from the
  provided payload.
  """
  data = json.loads(payload)
  messaging_events = data["entry"][0]["messaging"]
  for event in messaging_events:
    if "message" in event and "text" in event["message"]:
      yield event["sender"]["id"], event["message"]["text"].encode('unicode_escape')
    else:
      yield event["sender"]["id"], "I can't echo this"

```

对每个消息迭代时，我们会调用 send\_message 函数，然后我们使用 Facebook Graph messages API 对 Messenger 发回 POST 请求。在这期间我们一直没有回应我们阻塞的原始 Messenger请求。这会导致超时和 5XX 错误。

上述情况是我在解决遇到错误时发现的，当用户发送表情时实际上是发送的 unicode 标识符，但是被 Python 错误的编码了，最终我们发回了一些乱码。

这个发回 Messenger 的 POST 请求将永远不会完成，这会导致给初始请求返回 5xx 状态码，显示服务不可用。

通过使用 `encode('unicode_escape')` 封装消息，然后在我们发送回消息前用 `decode('unicode_escape')` 解码消息就可以解决。

```
def send_message(token, recipient, text):
  """Send the message text to recipient with id recipient.
  """

  r = requests.post("https://graph.facebook.com/v2.6/me/messages",
    params={"access_token": token},
    data=json.dumps({
      "recipient": {"id": recipient},
      "message": {"text": text.decode('unicode_escape')}
    }),
    headers={'Content-type': 'application/json'})
  if r.status_code != requests.codes.ok:
    print r.text

```

### 部署到 Heroku

一旦代码已经建立成我想要的样子时就可以进行下一步。部署应用。

那么，该怎么做？

我之前在 Heroku 上部署过应用（主要是 Rails），然而我总是遵循某种教程做的，所用的配置是创建好了的。而在本文的情况下，我就需要从头开始。

幸运的是有官方 [Heroku 文档](https://devcenter.heroku.com/articles/python-gunicorn)来帮忙。这篇文档很好地说明了运行应用程序所需的最低限度。

长话短说，我们需要的除了我们的代码还有两个文件。第一个文件是“requirements.txt”，它列出了运行应用所依赖的库。

需要的第二个文件是“Procfile”。这个文件通知 Heroku 如何运行我们的服务。此外这个文件只需要一点点内容：

```
web: gunicorn echoserver:app

```

Heroku 对它的解读是，我们的应用通过运行 echoserver.py 启动，并且应用将使用 gunicorn 作为 Web 服务器。我们使用一个额外的网站服务器是因为与性能相关，在上面的 Heroku 文档里对此解释了：

>
> Web 应用程序并发处理传入的 HTTP 请求比一次只处理一个请求的 Web 应用程序会更有效利地用测试机的资源。由于这个原因，我们建议使用支持并发请求的 Web 服务器来部署和运行产品级服务。
>
>
> Django 和 Flask web 框架提供了一个方便的内建 Web 服务器，但是这些阻塞式服务器一个时刻只能处理一个请求。如果你部署这种服务到 Heroku 上，你的测试机就会资源利用率低下，应用会感觉反应迟钝。
>
>
> Gunicorn 是一个纯 Python 的 HTTP 服务器，用于 WSGI 应用。允许你在单独一个测试机内通过运行多 Python 进程的方式来并发的运行各种 Python 应用。它在性能、灵活性和配置简易性方面取得了完美的平衡。
>
>
>

回到我们之前提到过的“requirements.txt”文件，让我们看看它如何结合 Virtualenv 工具。

很多情况下，你的开发机器也许已经安装了很多 python 库。当部署应用时你不想全部加载那些库，但是辨认出你实际使用哪些库很困难。

Virtualenv 可以创建一个新的空白虚拟环境，以便你可以只安装你应用所需要的库。

你可以运行如下命令来检查当前安装了哪些库：

```
kostis@KostisMBP ~ $ pip freeze
cycler==0.10.0
Flask==0.10.1
gunicorn==19.6.0
itsdangerous==0.24
Jinja2==2.8
MarkupSafe==0.23
matplotlib==1.5.1
numpy==1.10.4
pyparsing==2.1.0
python-dateutil==2.5.0
pytz==2015.7
requests==2.10.0
scipy==0.17.0
six==1.10.0
virtualenv==15.0.1
Werkzeug==0.11.10

```

注意：pip 工具应该已经与 Python 一起安装在你的机器上。如果没有，查看[官方网站](https://pip.pypa.io/en/stable/installing)如何安装它。

现在让我们使用 Virtualenv 来创建一个新的空白环境。首先我们给我们的项目创建一个新文件夹，然后进到目录下：

```
kostis@KostisMBP projects $ mkdir echoserver
kostis@KostisMBP projects $ cd echoserver/
kostis@KostisMBP echoserver $

```

现在来创建一个叫做 echobot 的新环境。运行下面的 source 命令激活它，然后使用 pip freeze 检查，我们能看到现在是空的。

```
kostis@KostisMBP echoserver $ virtualenv echobot
kostis@KostisMBP echoserver $ source echobot/bin/activate
(echobot) kostis@KostisMBP echoserver $ pip freeze
(echobot) kostis@KostisMBP echoserver $

```

我们可以安装需要的库。我们需要是 flask、gunicorn 和 requests，它们被安装后我们就创建 requirements.txt 文件：

```
(echobot) kostis@KostisMBP echoserver $ pip install flask
(echobot) kostis@KostisMBP echoserver $ pip install gunicorn
(echobot) kostis@KostisMBP echoserver $ pip install requests
(echobot) kostis@KostisMBP echoserver $ pip freeze
click==6.6
Flask==0.11
gunicorn==19.6.0
itsdangerous==0.24
Jinja2==2.8
MarkupSafe==0.23
requests==2.10.0
Werkzeug==0.11.10
(echobot) kostis@KostisMBP echoserver $ pip freeze > requirements.txt

```

上述完成之后，我们用 python 代码创建 echoserver.py 文件，然后用之前提到的命令创建 Procfile，我们最终的文件/文件夹如下：

```
(echobot) kostis@KostisMBP echoserver $ ls
Procfile     echobot     echoserver.py   requirements.txt

```

我们现在准备上传到 Heroku。我们需要做两件事。第一是如果还没有安装 Heroku toolbet，就安装它（详见 [Heroku](https://toolbelt.heroku.com)）。第二是通过 Heroku [网页界面](https://dashboard.heroku.com/apps)创建一个新的 Heroku 应用。

点击右上的大加号然后选择“Create new app”。

为你的应用选择一个名字，然后点击“Create App”。

你将会重定向到你的应用的控制面板，在那里你可以找到如何部署你的应用到 Heroku 的细节说明。

```
(echobot) kostis@KostisMBP echoserver $ heroku login
(echobot) kostis@KostisMBP echoserver $ git init
(echobot) kostis@KostisMBP echoserver $ heroku git:remote -a <myappname>
(echobot) kostis@KostisMBP echoserver $ git add .
(echobot) kostis@KostisMBP echoserver $ git commit -m "Initial commit"
(echobot) kostis@KostisMBP echoserver (master) $ git push heroku master
...
remote:        https://<myappname>.herokuapp.com/ deployed to Heroku
...
(echobot) kostis@KostisMBP echoserver (master) $ heroku config:set WEB_CONCURRENCY=3

```

如上，当你推送你的修改到 Heroku 之后，你会得到一个用于公开访问你新创建的应用的 URL。保存该 URL，下一步需要它。

### 创建这个 Facebook 应用

让我们的机器人可以工作的最后一步是创建这个我们将连接到其上的 Facebook 应用。Facebook 通常要求每个应用都有一个相关页面，所以我们来[创建一个](https://www.facebook.com/pages/create)。

接下来我们去 [Facebook 开发者专页](https://developers.facebook.com/)，点击右上角的“My Apps”按钮并选择“Add a New App”。不要选择建议的那个，而是点击“basic setup”。填入需要的信息并点击“Create App Id”，然后你会重定向到新的应用页面。

在 “Products” 菜单之下，点击“+ Add Product” ，然后在“Messenger”下点击“Get Started”。跟随这些步骤设置 Messenger，当完成后你就可以设置你的 webhooks 了。Webhooks 简单的来说是你的服务所用的 URL 的名称。点击 “Setup Webhooks” 按钮，并添加该 Heroku 应用的 URL （你之前保存的那个）。在校验元组中写入 ‘my*voice*is*my*password*verify*me’。你可以写入任何你要的内容，但是不管你在这里写入的是什么内容，要确保同时修改代码中 handle\_verification 函数。然后勾选 “messages” 选项。

点击“Verify and Save” 就完成了。Facebook 将访问该 Heroku 应用并校验它。如果不工作，可以试试运行：

```
(echobot) kostis@KostisMBP heroku logs -t

```

然后看看日志中是否有错误。如果发现错误， Google 搜索一下可能是最快的解决方法。

最后一步是取得页面访问元组（PAT），它可以将该 Facebook 应用于你创建好的页面连接起来。

从下拉列表中选择你创建好的页面。这会在“Page Access Token”（PAT）下面生成一个字符串。点击复制它，然后编辑 echoserver.py 文件，将其贴入 PAT 变量中。然后在 Git 中添加、提交并推送该修改。

```
(echobot) kostis@KostisMBP echoserver (master) $ git add .
(echobot) kostis@KostisMBP echoserver (master) $ git commit -m "Initial commit"
(echobot) kostis@KostisMBP echoserver (master) $ git push heroku master

```

最后，在 Webhooks 菜单下再次选择你的页面并点击“Subscribe”。

现在去访问你的页面并建立会话：

成功了，机器人回显了！

注意：除非你要将这个机器人用在 Messenger 上测试，否则你就是机器人唯一响应的那个人。如果你想让其他人也试试它，到 [Facebook 开发者专页](https://developers.facebook.com/)中，选择你的应用、角色，然后添加你要添加的测试者。

### 总结

这对于我来说是一个非常有用的项目，希望它可以指引你找到开始的正确方向。[官方的 Facebook 指南](https://developers.facebook.com/docs/messenger-platform/implementation)有更多的资料可以帮你学到更多。

你可以在 [Github](https://github.com/kostistsaprailis/messenger-bot-tutorial) 上找到该项目的代码。

如果你有任何评论、勘误和建议，请随时联系我。

---

via: <http://tsaprailis.com/2016/06/02/How-to-build-and-deploy-a-Facebook-Messenger-bot-with-Python-and-Flask-a-tutorial/>

作者：[Konstantinos Tsaprailis](https://github.com/kostistsaprailis) 译者：[wyangsun](https://github.com/wyangsun) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译，[Linux中国](https://linux.cn/) 荣誉推出


开源新闻速递：OpenSSH 7.3不再支持小于1024位的RSA密钥

Summary: 更多：DragonFly BSD 4.6.0正式发布，首次提供了对UEFI的支持。

# 开源新闻速递：OpenSSH 7.3不再支持小于1024位的RSA密钥

### 今日关注

OpenSSH 7.3正式发布。OpenSSH是提供给GNU/Linux和类UNIX操作系统的100%全套免费开源的SSH2.0协议的实现，预安装在SFTP的客户端和服务器中，也支持对SSH 1.3 和 SSH 1.5 协议的过渡。在这一版本中，将不再支持小于1024位的RAS密钥。

### 图文摘要

*专为俄语用户设计的GNU/Linux操作系统ROSA Desktop Fresh R8发布，搭载了KDE 4, KDE Plasma 5, GNOME, 和 MATE 桌面环境，并进行为期两年的更新支持，一直到2018年。不过，采用的并不是最新版本的软件和GNU/Linux技术，而是Linux 4.1.25内核。*

*DragonFly BSD 4.6.0正式发布，比较显著的改进是首次提供了对UEFI的支持，对内置的NVMe SSD设备的支持，以及对SMP和网络的改进，对最新的显卡的支持等。*

*KDE Plasma 5.7.3桌面环境已经可以使用了。KDE Plasma 5.7系列的更新速度是比较快的，在这一版本中，改善了一些核心组件，比如Plasma Desktop, Plasma Discover等，对VPN连接存在的一些问题也进行了修复。KDE Plasma 5.7.4 版本预计8.23号发布，敬请期待。*

*炫丽的Arc GTK主题已经可以从Ubuntu 16.10 (Yakkety Yak)的仓库中下载了。Arc GTK是使用GTK+ GUI工具集写的一个平面桌面主题，有三种不同的风格可供选择，Arc, Arc-dark, 和 Arc-darker, 还有透明元素。*


Git 系列（三）：建立你的第一个 Git 仓库

# Git 系列（三）：建立你的第一个 Git 仓库

现在是时候学习怎样创建你自己的 Git 仓库了，还有怎样增加文件和完成提交。

在本系列[前面的文章](/article-7641-1.html)中，你已经学习了怎样作为一个最终用户与 Git 进行交互；你就像一个漫无目的的流浪者一样偶然发现了一个开源项目网站，克隆了仓库，然后你就可以继续钻研它了。你知道了和 Git 进行交互并不像你想的那样困难，或许你只是需要被说服现在去使用 Git 完成你的工作罢了。

虽然 Git 确实是被许多重要软件选作版本控制工具，但是并不是仅能用于这些重要软件；它也能管理你购物清单（如果它们对你来说很重要的话，当然可以了！）、你的配置文件、周报或日记、项目进展日志、甚至源代码！

使用 Git 是很有必要的，毕竟，你肯定有过因为一个备份文件不能够辨认出版本信息而抓狂的时候。

Git 无法帮助你，除非你开始使用它，而现在就是开始学习和使用它的最好时机。或者，用 Git 的话来说，“没有其他的 `push` 能像 `origin HEAD` 一样有帮助了”（千里之行始于足下的意思）。我保证，你很快就会理解这一点的。

### 类比于录音

我们经常用名词“快照”来指代计算机上的镜像，因为很多人都能够对插满了不同时光的照片的相册充满了感受。这很有用，不过，我认为 Git 更像是进行一场录音。

也许你不太熟悉传统的录音棚卡座式录音机，它包括几个部件：一个可以正转或反转的转轴、保存声音波形的磁带，可以通过拾音头在磁带上记录声音波形，或者检测到磁带上的声音波形并播放给听众。

除了往前播放磁带，你也可以把磁带倒回到之前的部分，或快进跳过后面的部分。

想象一下上世纪 70 年代乐队录制磁带的情形。你可以想象到他们一遍遍地练习歌曲，直到所有部分都非常完美，然后记录到音轨上。起初，你会录下鼓声，然后是低音，再然后是吉他声，最后是主唱。每次你录音时，录音棚工作人员都会把磁带倒带，然后进入循环模式，这样它就会播放你之前录制的部分。比如说如果你正在录制低音，你就会在背景音乐里听到鼓声，就像你自己在击鼓一样，然后吉他手在录制时会听到鼓声、低音（和牛铃声）等等。在每个循环中，你都会录制一部分，在接下来的循环中，工作人员就会按下录音按钮将其合并记录到磁带中。

你也可以拷贝或换下整个磁带，如果你要对你的作品重新混音的话。

现在我希望对于上述的上世纪 70 年代的录音工作的描述足够生动，这样我们就可以把 Git 的工作想象成一个录音工作了。

### 新建一个 Git 仓库

首先得为我们的虚拟的录音机买一些磁带。用 Git 的话说，这些磁带就是*仓库*；它是完成所有工作的基础，也就是说这里是存放 Git 文件的地方（即 Git 工作区）。

任何目录都可以成为一个 Git 仓库，但是让我们从一个新目录开始。这需要下面三个命令：

* 创建目录（如果你喜欢的话，你可以在你的图形化的文件管理器里面完成。）
* 在终端里切换到目录。
* 将其初始化成一个 Git 管理的目录。

也就是运行如下代码：

```
$ mkdir ~/jupiter  # 创建目录
$ cd ~/jupiter     # 进入目录
$ git init .       # 初始化你的新 Git 工作区

```

在这个例子中，文件夹 jupiter 是一个空的但是合法的 Git 仓库。

有了仓库接下来的事情就可以按部就班进行了。你可以克隆该仓库，你可以在一个历史点前后来回穿梭（前提是你有一个历史点），创建交替的时间线，以及做 Git 能做的其它任何事情。

在 Git 仓库里面工作和在任何目录里面工作都是一样的，可以在仓库中新建文件、复制文件、保存文件。你可以像平常一样做各种事情；Git 并不复杂，除非你把它想复杂了。

在本地的 Git 仓库中，一个文件可以有以下这三种状态：

* <ruby> 未跟踪文件 <rp>  （ </rp> <rt>  Untracked </rt> <rp>  ） </rp></ruby>：你在仓库里新建了一个文件，但是你没有把文件加入到 Git 的管理之中。
* <ruby> 已跟踪文件 <rp>  （ </rp> <rt>  Tracked </rt> <rp>  ） </rp></ruby>：已经加入到 Git 管理的文件。
* <ruby> 暂存区文件 <rp>  （ </rp> <rt>  Staged </rt> <rp>  ） </rp></ruby>：被修改了的已跟踪文件，并加入到 Git 的提交队列中。

任何你新加入到 Git 仓库中的文件都是未跟踪文件。这些文件保存在你的电脑硬盘上，但是你没有告诉 Git 这是需要管理的文件，用我们的录音机来类比，就是录音机还没打开；乐队就开始在录音棚里忙碌了，但是录音机并没有准备录音。

不用担心，Git 会在出现这种情况时告诉你：

```
$ echo "hello world" > foo
$ git status
On branch master
Untracked files:
(use "git add <file>..." to include in what will be committed)
    foo
nothing added but untracked files present (use "git add" to track)

```

你看到了，Git 会提醒你怎样把文件加入到提交任务中。

### 不使用 Git 命令进行 Git 操作

在 GitHub 或 GitLab 上创建一个仓库只需要用鼠标点几下即可。这并不难，你单击“New Repository”这个按钮然后跟着提示做就可以了。

在仓库中包括一个“README”文件是一个好习惯，这样人们在浏览你的仓库的时候就可以知道你的仓库是干什么的，更有用的是可以让你在克隆一个有东西的仓库前知道它有些什么。

克隆仓库通常很简单，但是在 GitHub 上获取仓库改动权限就稍微复杂一些，为了通过 GitHub 验证你必须有一个 SSH 密钥。如果你使用 Linux 系统，可以通过下面的命令生成：

```
$ ssh-keygen

```

然后复制你的新密钥的内容，它是纯文本文件，你可以使用一个文本编辑器打开它，也可以使用如下 cat 命令查看：

```
$ cat ~/.ssh/id_rsa.pub

```

现在把你的密钥粘贴到 [GitHub SSH 配置文件](https://github.com/settings/keys) 中，或者 [GitLab 配置文件](https://gitlab.com/profile/keys)。

如果你通过使用 SSH 模式克隆了你的项目，你就可以将修改写回到你的仓库了。

另外，如果你的系统上没有安装 Git 的话也可以使用 GitHub 的文件上传接口来添加文件。

### 跟踪文件

正如命令 `git status` 的输出告诉你的那样，如果你想让 git 跟踪一个文件，你必须使用命令 `git add` 把它加入到提交任务中。这个命令把文件存在了暂存区，这里存放的都是等待提交的文件，或者也可以用在快照中。在将文件包括到快照中，和添加要 Git 管理的新的或临时文件时，`git add` 命令的目的是不同的，不过至少现在，你不用为它们之间的不同之处而费神。

类比录音机，这个动作就像打开录音机开始准备录音一样。你可以想象为对已经在录音的录音机按下暂停按钮，或者倒回开头等着记录下个音轨。

当你把文件添加到 Git 管理中，它会标识其为已跟踪文件：

```
$ git add foo
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file:   foo

```

加入文件到提交任务中并不是“准备录音”。这仅仅是将该文件置于准备录音的状态。在你添加文件后，你仍然可以修改该文件；它只是被标记为**已跟踪**和**处于暂存区**，所以在它被写到“磁带”前你可以将它撤出或修改它（当然你也可以再次将它加入来做些修改）。但是请注意：你还没有在磁带中记录该文件，所以如果弄坏了一个之前还是好的文件，你是没有办法恢复的，因为你没有在“磁带”中记下那个文件还是好着的时刻。

如果你最后决定不把文件记录到 Git 历史列表中，那么你可以撤销提交任务，在 Git 中是这样做的：

```
$ git reset HEAD foo

```

这实际上就是解除了录音机的准备录音状态，你只是在录音棚中转了一圈而已。

### 大型提交

有时候，你想要提交一些内容到仓库；我们以录音机类比，这就好比按下录音键然后记录到磁带中一样。

在一个项目所经历的不同阶段中，你会按下这个“记录键”无数次。比如，如果你尝试了一个新的 Python 工具包并且最终实现了窗口呈现功能，然后你肯定要进行提交，以便你在实验新的显示选项时搞砸了可以回退到这个阶段。但是如果你在 Inkscape 中画了一些图形草样，在提交前你可能需要等到已经有了一些要开发的内容。尽管你可能提交了很多次，但是 Git 并不会浪费很多，也不会占用太多磁盘空间，所以在我看来，提交的越多越好。

`commit` 命令会“记录”仓库中所有的暂存区文件。Git 只“记录”已跟踪的文件，即，在过去某个时间点你使用 `git add` 命令加入到暂存区的所有文件，以及从上次提交后被改动的文件。如果之前没有过提交，那么所有跟踪的文件都包含在这次提交中，以 Git 的角度来看，这是一次非常重要的修改，因为它们从没放到仓库中变成了放进去。

完成一次提交需要运行下面的命令：

```
$ git commit -m 'My great project, first commit.'

```

这就保存了所有提交的文件，之后可以用于其它操作（或者，用英国电视剧《神秘博士》中时间领主所讲的 Gallifreyan 语说，它们成为了“固定的时间点” ）。这不仅是一个提交事件，也是一个你在 Git 日志中找到该提交的引用指针：

```
$ git log --oneline
55df4c2 My great project, first commit.

```

如果想浏览更多信息，只需要使用不带 `--oneline` 选项的 `git log` 命令。

在这个例子中提交时的引用号码是 55df4c2。它被叫做“<ruby> 提交哈希 <rp>  （ </rp> <rt>  commit hash </rt> <rp>  ） </rp></ruby>”（LCTT 译注：这是一个 SHA-1 算法生成的哈希码，用于表示一个 git 提交对象），它代表着刚才你的提交所包含的所有新改动，覆盖到了先前的记录上。如果你想要“倒回”到你的提交历史点上，就可以用这个哈希作为依据。

你可以把这个哈希想象成一个声音磁带上的 [SMPTE 时间码](http://slackermedia.ml/handbook/doku.php?id=timecode)，或者再形象一点，这就是好比一个黑胶唱片上两首不同的歌之间的空隙，或是一个 CD 上的音轨编号。

当你改动了文件之后并且把它们加入到提交任务中，最终完成提交，这就会生成新的提交哈希，它们每一个所标示的历史点都代表着你的产品不同的版本。

这就是 Charlie Brown 这样的音乐家们为什么用 Git 作为版本控制系统的原因。

在接下来的文章中，我们将会讨论关于 Git HEAD 的各个方面，我们会真正地向你揭示时间旅行的秘密。不用担心，你只需要继续读下去就行了（或许你已经在读了？）。

---

via: <https://opensource.com/life/16/7/creating-your-first-git-repository>

作者：[Seth Kenlon](https://opensource.com/users/seth) 译者：[vim-kakali](https://github.com/vim-kakali) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


开源新闻速递：Tor 0.2.8.6 发布，可以保护用户不被监控追踪

Summary: 更多：Fotoxx 16.08发布；Canonical启动了"netplan"计划，统一规范并清理Ubuntu Linux中的网络配置。

棣琦好棒！！！

虽然不怎么用Tor，但是还是很喜欢。

# 开源新闻速递：Tor 0.2.8.6 发布，可以保护用户不被监控追踪

### 今日关注

Tor 0.2.8.6 发布，改善了客户端引导的性能，以及Linux操作系统的安全性。Tor Project团队和Debian Project团队合作，为Debian GNU/Linux操作系统提供了Tor onion服务和Debian在线服务，比如Debian网站和wiki页面，能够确保用户在使用这些相应的服务或者进行Debian更新时不被任何的政府机构跟踪和定位，这就保证了用户的安全性。目前已经可以下载使用了。

### 图文摘要

*GNU/Linux操作系统上的图像编辑软件Fotoxx 16.08发布。在这一最新版本中，用户可以直接通过点击相册缩略图来删除多张图片，也可以直接从图片集或者文件管理器中拖拽缩略图到专辑的特定位置，还增加了一个滑块来调整颜色模式。想体验更多新功能的话就赶紧进行更新吧。*

*Canonical启动了一个"netplan"计划，统一规范并清理Ubuntu Linux中的网络配置。在Ubuntu 16.10 "Yakkety Yak"中已经开始施行了，"nplan"包在Ubuntu 16.10的软件仓库已经可以下载使用了。*

*Guix System Distribution 0.11发布。GuixSD是GNU系统的一个高级发行版，Linux-libre内核驱动，使用GNU Guix作为默认的包管理器。这一最新版本提供了对RAID设备的支持，以及对“guix 发布”功能的压缩支持。已经可以下载了。*


awk 系列：怎样使用 awk 变量、数值表达式以及赋值运算符

# awk 系列：怎样使用 awk 变量、数值表达式以及赋值运算符

我觉得 [awk 系列](/article-7586-1.html) 将会越来越好，在本系列的前七节我们讨论了在 Linux 中处理文件和筛选字符串所需要的一些 awk 命令基础。

在这一部分，我们将会进入 awk 更高级的部分，使用 awk 处理更复杂的文本和进行字符串过滤操作。因此，我们将会讲到 Awk 的一些特性，诸如变量、数值表达式和赋值运算符。

*学习 Awk 变量，数值表达式和赋值运算符*

你可能已经在很多编程语言中接触过它们，比如 shell，C，Python 等；这些概念在理解上和这些语言没有什么不同，所以在这一小节中你不用担心很难理解，我们将会简短的提及常用的一些 awk 特性。

这一小节可能是 awk 命令里最容易理解的部分，所以放松点，我们开始吧。

### 1. Awk 变量

在很多编程语言中，变量就是一个存储了值的占位符，当你在程序中新建一个变量的时候，程序一运行就会在内存中创建一些空间，你为变量赋的值会存储在这些内存空间上。

你可以像下面这样定义 shell 变量一样定义 awk 变量：

```
variable_name=value

```

上面的语法：

* `variable_name`: 为定义的变量的名字
* `value`: 为变量赋的值

再看下面的一些例子:

```
computer_name=”tecmint.com”
port_no=”22”
email=”admin@tecmint.com”
server=computer_name

```

观察上面的简单的例子，在定义第一个变量的时候，值 'tecmint.com' 被赋给了 'computer\_name' 变量。

此外，值 22 也被赋给了 port\_no 变量，把一个变量的值赋给另一个变量也是可以的，在最后的例子中我们把变量 computer\_name 的值赋给了变量 server。

你可以看看[本系列的第 2 节](/article-7587-1.html)中提到的字段编辑，我们讨论了 awk 怎样将输入的行分隔为若干字段并且使用标准字段访问操作符 `$` 来访问拆分出来的不同字段。我们也可以像下面这样使用变量为字段赋值。

```
first_name=$2
second_name=$3

```

在上面的例子中，变量 first\_name 的值设置为第二个字段，second\_name 的值设置为第三个字段。

再举个例子，有一个名为 names.txt 的文件，这个文件包含了一个应用程序的用户列表，这个用户列表包含了用户的名和姓以及性别。可以使用 [cat 命令](http://www.tecmint.com/13-basic-cat-command-examples-in-linux/) 查看文件内容：

```
$ cat names.txt

```

*使用 cat 命令查看列表文件内容*

然后，我们也可以使用下面的 awk 命令把列表中第一个用户的第一个和第二个名字分别存储到变量 first\_name 和 second\_name 上：

```
$ awk '/Aaron/{ first_name=$2 ; second_name=$3 ; print first_name, second_name ; }' names.txt

```

*使用 Awk 命令为变量赋值*

再看一个例子，当你在终端运行 'uname -a' 时，它可以打印出所有的系统信息。

第二个字段包含了你的主机名，因此，我们可以像下面这样把它赋给一个叫做 hostname 的变量并且用 awk 打印出来。

```
$ uname -a
$ uname -a | awk '{hostname=$2 ; print hostname ; }'

```

*使用 Awk 把命令的输出赋给变量*

### 2. 数值表达式

在 Awk 中，数值表达式使用下面的数值运算符组成：

* `*` : 乘法运算符
* `+` : 加法运算符
* `/` : 除法运算符
* `-` : 减法运算符
* `%` : 取模运算符
* `^` : 指数运算符

数值表达式的语法是：

```
$ operand1 operator operand2

```

上面的 operand1 和 operand2 可以是数值和变量，运算符可以是上面列出的任意一种。

下面是一些展示怎样使用数值表达式的例子：

```
counter=0
num1=5
num2=10
num3=num2-num1
counter=counter+1

```

要理解 Awk 中数值表达式的用法，我们可以看看下面的例子，文件 domians.txt 里包括了所有属于 Tecmint 的域名。

```
news.tecmint.com
tecmint.com
linuxsay.com
windows.tecmint.com
tecmint.com
news.tecmint.com
tecmint.com
linuxsay.com
tecmint.com
news.tecmint.com
tecmint.com
linuxsay.com
windows.tecmint.com
tecmint.com

```

可以使用下面的命令查看文件的内容：

```
$ cat domains.txt

```

*查看文件内容*

如果想要计算出域名 tecmint.com 在文件中出现的次数，我们就可以通过写一个简单的脚本实现这个功能：

```
#!/bin/bash
for file in $@; do
if [ -f $file ] ; then
#print out filename
echo "File is: $file"
#print a number incrementally for every line containing tecmint.com
awk  '/^tecmint.com/ { counter=counter+1 ; printf "%s\n", counter ; }'   $file
else
#print error info incase input is not a file
echo "$file is not a file, please specify a file." >&2 && exit 1
fi
done
#terminate script with exit code 0 in case of successful execution
exit 0

```

*计算一个字符串或文本在文件中出现次数的 shell 脚本*

写完脚本后保存并赋予执行权限，当我们使用文件运行脚本的时候，文件 domains.txt 作为脚本的输入，我们会得到下面的输出：

```
$ ./script.sh  ~/domains.txt

```

*计算字符串或文本出现次数的脚本*

从脚本执行后的输出中，可以看到在文件 domains.txt 中包含域名 tecmint.com 的地方有 6 行，你可以自己计算进行验证。

### 3. 赋值操作符

我们要说的最后的 Awk 特性是赋值操作符，下面列出的只是 awk 中的部分赋值运算符：

* `*=` : 乘法赋值操作符
* `+=` : 加法赋值操作符
* `/=` : 除法赋值操作符
* `-=` : 减法赋值操作符
* `%=` : 取模赋值操作符
* `^=` : 指数赋值操作符

下面是 Awk 中最简单的一个赋值操作的语法：

```
$ variable_name=variable_name operator operand

```

例子：

```
counter=0
counter=counter+1
num=20
num=num-1

```

你可以使用在 awk 中使用上面的赋值操作符使命令更简短，从先前的例子中，我们可以使用下面这种格式进行赋值操作：

```
variable_name operator=operand
counter=0
counter+=1
num=20
num-=1

```

因此，我们可以在 shell 脚本中改变 awk 命令，使用上面提到的 += 操作符:

```
#!/bin/bash
for file in $@; do
if [ -f $file ] ; then
#print out filename
echo "File is: $file"
#print a number incrementally for every line containing tecmint.com
awk  '/^tecmint.com/ { counter+=1 ; printf  "%s\n",  counter ; }'   $file
else
#print error info incase input is not a file
echo "$file is not a file, please specify a file." >&2 && exit 1
fi
done
#terminate script with exit code 0 in case of successful execution
exit 0

```

*修改了的 shell 脚本*

在 [awk 系列](/article-7586-1.html) 的这一部分，我们讨论了一些有用的 awk 特性，有变量，使用数值表达式和赋值运算符，还有一些使用它们的实例。

这些概念和其他的编程语言没有任何不同，但是可能在 awk 中有一些意义上的区别。

在本系列的第 9 节，我们会学习更多的 awk 特性，比如特殊格式： BEGIN 和 END。请继续关注。

---

via: <http://www.tecmint.com/learn-awk-variables-numeric-expressions-and-assignment-operators/>

作者：[Aaron Kili](http://www.tecmint.com/author/aaronkili/) 译者：[vim-kakali](https://github.com/vim-kakali) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


伴随 Linux 成长的职业生涯

不錯，我也最喜歡Debian，最安靜方便生心～

虽然你们都说好，还是觉得linux桌面比不上winxp，是我一个人的错觉么？

虽然你们都说好，还是觉得linux桌面比不上winxp，是我一个人的错觉么？

Debian 稳定版更新太慢。

不知是翻译的原因还是作者的原因，老是在说二十世纪前期中期后期，二十世纪的前期和中期微软linux都还没有吧.....写得很不严谨啊...........

那是因為你用debian stable。debian有三個releases：stable（jessie）、testing（stretch）、unstable（sid），還有一個repository：experimental

我正在用debian sid

没有看到回复里“稳定版”三个字吗？用不是稳定版仓库的包，还能叫稳定版吗？

抱歉，你说的对，是我们翻译错误。原文是 ： in the early and mid 2000's

还有一个地方:<br />
而在二十世纪中期的时候，那时我正在忙为那些在雷蒙德附近（微软公司所在地）的大一些的软件公司做咨询工作，为他们对比 Linux 解决方案及其自己的解决方案做分析和验证。

你要更新快？那可以试试Arch，手动滑稽

更新快慢与你何干？

谢谢您的细心！感谢！

# 伴随 Linux 成长的职业生涯

<img src="content_image/album_201608_05_145301g661zu63i7z8n936.jpg" alt="" title="">

我与 Linux 的故事开始于 1998 年，一直延续到今天。 当时我在 Gap 公司工作，管理着成千台运行着 [OS/2](https://en.wikipedia.org/wiki/OS/2) 系统的台式机 ( 在随后的几年里变成了 [Warp 3.0](https://archive.org/details/IBMOS2Warp3Collection))。 作为一个 OS/2 的粉丝，那时我非常喜欢那个时候。 随着这些台式机的嗡鸣，我们使用 Gap 开发的工具轻而易举地就能支撑起对成千的用户的服务支持。 然而，一切都将改变了。

在 1998 年的 11 月， 我收到邀请加入一个新成立的公司，这家公司将专注于企业级 Linux 上。 这就是后来非常出名的 [Linuxcare](https://archive.org/details/IBMOS2Warp3Collection)。

### 我在 Linuxcare 的时光

我曾经接触过一些 Linux ， 但我从未想过要把它提供给企业客户。仅仅几个月后 ( 从这里开始成为了空间和时间上的转折点 )， 我就在管理一整条线的业务，让企业获得他们的软件，硬件，甚至是证书认证等各种在当时非常盛行的 Linux 服务。

我支持的客户包括像 IBM ，Dell ，HP 这样的厂商以确保他们的硬件能够成功的运行 Linux 。 今天你们应该都听过许多关于在硬件上预装 Linux 的事， 但当时 Dell 邀请我去讨论为即将到来的贸易展上将 Linux 运行在认证的笔记本电脑上。 这是多么激动人心的时刻 ！同时我们在之后几年内也支持了 IBM 和 HP 等多项认证工作。

Linux 变化得非常快，并且它总是这样。 它也获得了更多的关键设备的支持，比如声音，网络和图形。在这段时间， 我把个人使用的系统从基于 RPM 的系统换成了 [Debian](https://en.wikipedia.org/wiki/Linuxcare) 。

### 使用 Linux 的这些年

几年前我在一些做 Linux 硬件设备、Linux 定制软件以及 Linux 数据中心的公司工作。而在二十一世纪第一个十年的中期的时候，那时我正在忙为那些在雷蒙德附近（微软公司所在地）的大一些的软件公司做咨询工作，为他们对比 Linux 解决方案及其自己的解决方案做分析和验证。 我个人使用的系统一直没有改变，我仍会在尽可能的情况下运行 Debian 测试系统。

我真的非常欣赏发行版的灵活性和永久更新状态。 Debian 是我所使用过的最有趣且拥有良好支持的发行版，并且它拥有最好的社区，而我是社区的一份子。

当我回首我使用 Linux 的这几年，我仍记得大约在二十一世纪第一个十年的前中期的时候在圣何塞，旧金山，波士顿和纽约召开的那些 Linux Expo 大会。在 Linuxcare 时我们总是会摆一些有趣而且时髦的展位，在那边逛的时候总会碰到一些老朋友。这一切工作都是需要付出代价的，所有的这一切都是在努力地强调使用 Linux 的乐趣。

随着虚拟化和云的崛起也让 Linux 变得更加有趣。 当我在 Linuxcare 的时候， 我们常和斯坦福大学附近的帕洛阿尔托的一个约 30 人左右的小公司在一块。我们会开车到他们的办公处，然后帮他们准备和我们一起参加展览的东西。 谁会想得到这个小小的初创公司会成就后来的 VMware ？

我还有许多的故事，能认识这些人并和他们一起工作我感到很幸运。 Linux 在各方面都不断发展且变得尤为重要。 并且甚至随着它重要性的提升，它使用起来仍然非常有趣。 我认为它的开放性和可定制能力给它带来了大量的新用户，这也是让我感到非常震惊的一点。

### 现在

在过去的五年里我的工作重心逐渐离开 Linux。 我所管理的大规模基础设施项目中包含着许多不同的操作系统 ( 包括非开源的和开源的 ), 但我的心一直以来都是和 Linux 在一起的。

在使用 Linux 过程中的乐趣和不断进步是在过去的 18 年里一直驱动我的动力。我从 Linux 2.0 内核开始看着它变成现在的这样。 Linux 是一个卓越的、生机勃勃的且非常酷的东西。

---

via: <https://opensource.com/life/16/3/my-linux-story-michael-perry>

作者：[Michael Perry](https://opensource.com/users/mpmilestogo) 译者：[chenxinlong](https://github.com/chenxinlong) 校对：[wxy](https://github.com/wxy)


在用户空间做我们会在内核空间做的事情

Summary: 我相信，Linux 最好也是最坏的事情，就是内核空间（kernel space）和用户空间（user space）之间的巨大差别。

自主身份？没明白什么意思，和网络有序有关系？

其實主要是GNU/Hurd不爭氣，最後用了Linux做kernel形成GNU/Linux，所以才會有kernel和user space的巨大分野，Linux kernel和GNU project的開發者不是同一群人。如果像BSD、Mac OS X、MS Windows之類kernel和user space由同一個組織開發，不會有巨大的分野

嗯，这个观点有意思！

# 在用户空间做我们会在内核空间做的事情

我相信，Linux 最好也是最坏的事情，就是<ruby> 内核空间 <rp>  （ </rp> <rt>  kernel space </rt> <rp>  ） </rp></ruby>和<ruby> 用户空间 <rp>  （ </rp> <rt>  user space </rt> <rp>  ） </rp></ruby>之间的巨大差别。

如果没有这个区别，Linux 可能也不会成为世界上影响力最大的操作系统。如今，Linux 的使用范围在世界上是最大的，而这些应用又有着世界上最大的用户群——尽管大多数用户并不知道，当他们进行谷歌搜索或者触摸安卓手机的时候，他们其实正在使用 Linux。如果不是 Linux 的巨大成功，Apple 公司也可能并不会成为现在这样（即在他们的电脑产品中使用 BSD 的技术）（LCTT 译注：Linux 获得成功后，Apple 曾与 Linus 协商使用 Linux 核心作为 Apple 电脑的操作系统并帮助开发的事宜，但遭到拒绝。因此，Apple 转向使用许可证更为宽松的 BSD 。）。

不（需要）关注用户空间是 Linux 内核开发中的一个特点而非缺陷。正如 Linus 在 2003 年的<ruby>   极客巡航  <rp>  （ </rp> <rt>  Geek Cruise </rt> <rp>  ） </rp></ruby>中提到的那样，“我只做内核相关的东西……我并不知道内核之外发生的事情，而且我也并不关心。我只关注内核部分发生的事情。” 多年之后的[另一次极客巡航](http://www.linuxjournal.com/article/8664)上， Andrew Morton 给我上了另外的一课，这之后我写道：

>
> 内核空间是Linux 所在的地方，而用户空间是 Linux 与其它的“自然材料”一起使用的地方。内核空间和用户空间的区别，和自然材料与人类用其生产的人造材料的区别很类似。
>
>
>

这个区别是自然而然的结果，就是尽管外面的世界一刻也离不开 Linux， 但是 Linux 社区还是保持相对较小。所以，为了增加哪怕一点我们社区团体的规模，我希望指出两件事情。第一件已经非常火了，另外一件可能会火起来。

第一件事情就是<ruby>   区块链  <rp>  （ </rp> <rt>  blockchain </rt> <rp>  ） </rp></ruby>，出自著名的分布式货币——比特币之手。当你正在阅读这篇文章的同时，人们对区块链的[关注度正在直线上升](https://www.google.com/trends/explore#q=blockchain)。

*图1. 区块链的谷歌搜索趋势*

第二件事就是<ruby> 自主身份 <rp>  （ </rp> <rt>  self-sovereign identity </rt> <rp>  ） </rp></ruby>。为了解释这个概念，让我先来问你：你是谁，你来自哪里？

如果你从你的老板、你的医生或者车管所，Facebook、Twitter 或者谷歌上得到答案，你就会发现它们都是<ruby> 行政身份 <rp>  （ </rp> <rt>  administrative identifiers </rt> <rp>  ） </rp></ruby>——这些机构完全以自己的便利为原因设置这些身份和职位。正如一家区块链技术公司 [Evernym](http://evernym.com/) 的 Timothy Ruff 所说，“你并不因组织而存在，但你的身份却因此存在。”身份是个因变量。自变量——即控制着身份的变量——是（你所在的）组织。

如果你的答案出自你自己，我们就有一个广大空间来发展一个新的领域，在这个领域中，我们完全自由。

据我所知，第一个解释这个的人是 [Devon Loffreto](https://twitter.com/nzn)。在 2012 年 2 月，他在博客 [Moxy Tongue](http://www.moxytongue.com/2012/02/what-is-sovereign-source-authority.html) 中写道：“什么是 'Sovereign Source Authority'？”。在发表于 2016 年 2 月的 “[Self-Sovereign Identity](http://www.moxytongue.com/2016/02/self-sovereign-identity.html)” 一文中，他写道：

>
> 自主身份必须是独立个人提出的，并且不包含社会因素……自主身份源于每个个体对其自身本源的认识。 一个自主身份可以为个体带来新的社会面貌。每个个体都可能为自己生成一个自主身份，并且这并不会改变固有的人权。使用自主身份机制是所有参与者参与的基石，并且依旧可以同各种形式的人类社会保持联系。
>
>
>

将这个概念放在 Linux 领域中，只有个人才能为他或她设定一个自己的开源社区身份。这在现实实践中，这只是一个非常正常的事件。举个例子，我自己的身份包括：

* David Allen Searls，我父母会这样叫我。
* David Searls，正式场合下我会这么称呼自己。
* Dave，我的亲戚和好朋友会这么叫我。
* Doc，大多数人会这么叫我。

作为承认以上称呼的自主身份来源，我可以在不同的情景中轻易的转换。但是，这只是在现实世界中。在虚拟世界中，这就变得非常困难。除了上述的身份之外，我还可以是 @dsearls （我的 twitter 账号） 和 dsearls （其他的网络账号）。然而为了记住成百上千的不同账号的登录名和密码，我已经不堪重负。

你可以在你的浏览器上感受到这个糟糕的体验。在火狐上，我有成百上千个用户名密码。很多已经废弃(很多都是从 Netscape 时代遗留下来的)，但是我想会有大量的工作账号需要处理。对于这些，我只是被动接受者。没有其他的解决方法。甚至一些安全较低的用户认证，已经成为了现实世界中不可缺少的一环。

现在，最简单的方式来联系账号，就是通过 “Log in with Facebook” 或者 “Login in with Twitter” 来进行身份认证。在这种情况下，我们中的每一个甚至并不是真正意义上的自己，甚至（如果我们希望被其他人认识的话）缺乏对其他实体如何认识我们的控制。

我们从一开始就需要的是一个可以实体化我们的自主身份和交流时选择如何保护和展示自身的个人系统。因为缺少这个能力，我们现在陷入混乱。Shoshana Zuboff 称之为 “监视资本主义”，她如此说道：

>
> ...难以想象，在见证了互联网和获得了的巨大成功的谷歌背后。世界因 Apple 和 FBI 的对决而紧密联系在一起。讲道理，热衷于监视的资本家开发的监视系统是每一个国家安全机构都渴望的。
>
>
>

然后，她问道，”我们怎样才能保护自己远离他人的影响？“

我建议使用自主身份。我相信这是我们唯一的既可以保证我们从监视中逃脱、又可以使我们有一个有序的世界的办法。以此为基础，我们才可以完全无顾忌地和社会，政治，商业上的人交流。

我在五月联合国举行的 [ID2020](http://www.id2020.org/) 会议中总结了这个临时的结论。很高兴，Devon Loffreto 也在那，他于 2013 年推动了自主身份的创立。这是[我那时写的一些文章](http://blogs.harvard.edu/doc/2013/10/14/iiw-challenge-1-sovereign-identity-in-the-great-silo-forest)，引用了 Devon 的早期博客(比如上面的原文)。

这有三篇这个领域的准则:

* "[Self-Sovereign Identity](http://www.moxytongue.com/2016/02/self-sovereign-identity.html)" - Devon Loffreto.
* "[System or Human First](http://www.moxytongue.com/2016/05/system-or-human.html)" - Devon Loffreto.
* "[The Path to Self-Sovereign Identity](http://www.lifewithalacrity.com/2016/04/the-path-to-self-soverereign-identity.html)" - Christopher Allen.

从 Evernym 的简要说明中，[digi.me](https://get.digi.me/)、 [iRespond](http://irespond.com/) 和 [Respect Network](https://www.respectnetwork.com/) 也被包括在内。自主身份和社会身份 (也被称为“<ruby> 当前模式 <rp>  （ </rp> <rt>  current model </rt> <rp>  ） </rp></ruby>”） 的对比结果，显示在图二中。

*图 2. 当前模式身份 vs. 自主身份*

Sovrin 就是为此而生的[平台](http://evernym.com/technology)，它阐述自己为一个“依托于先进、专用、经授权、分布式平台的，完全开源、基于标识的身份声明图平台”。同时，这也有一本[白皮书](http://evernym.com/assets/doc/Identity-System-Essentials.pdf?v=167284fd65)。它的代码名为 [plenum](https://github.com/evernym/plenum)，并且公开在 Github 上。

在这里——或者其他类似的地方——我们就可以在用户空间中重现我们在过去 25 年中在内核空间做过的事情。

---

via: <https://www.linuxjournal.com/content/doing-user-space-what-we-did-kernel-space>

作者：[Doc Searls](https://www.linuxjournal.com/users/doc-searls) 译者：[MikeCoder](https://github.com/MikeCoder) 校对：[PurlingNayuki](https://github.com/PurlingNayuki)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


bc : 一个命令行计算器

Summary: bc 工具可以为你提供的功能可以满足你对科学计算器、金融计算器或者是简单计算器的期望。另外，假如需要的话，它还可以从命令行中被脚本化。这使得当你需要做复杂的数学运算时，你可以在 shell 脚本中使用它。

还不如用python算好了,连软件都不用装

不用装是，因为已经集成了。bc 是专门用来计算的，而 python 不是，特别是还有新旧版本问题。

居然能把bc和python并在一起对比……

# bc : 一个命令行计算器

<img src="content_image/album_201608_06_182300kcj29vz3qmpjs9xm.jpg" alt="" title="">

假如你在一个图形桌面环境中需要一个计算器时，你可能只需要一路进行点击便可以找到一个计算器。例如，Fedora 工作站中就已经包含了一个名为 `Calculator` 的工具。它有着几种不同的操作模式，例如，你可以进行复杂的数学运算或者金融运算。但是，你知道吗，命令行也提供了一个与之相似的名为 `bc` 的工具？

`bc` 工具可以为你提供的功能可以满足你对科学计算器、金融计算器或者是简单计算器的期望。另外，假如需要的话，它还可以从命令行中被脚本化。这使得当你需要做复杂的数学运算时，你可以在 shell 脚本中使用它。

因为 bc 也被用于其他的系统软件，例如 CUPS 打印服务，所以它可能已经在你的 Fedora 系统中被安装了。你可以使用下面这个命令来进行检查：

```
dnf list installed bc

```

假如因为某些原因你没有在上面命令的输出中看到它，你可以使用下面的这个命令来安装它：

```
sudo dnf install bc

```

### 用 bc 做一些简单的数学运算

使用 bc 的一种方式是进入它自己的 shell。在那里你可以按行进行许多次计算。当你键入 bc 后，首先出现的是有关这个程序的警告：

```
$ bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.

```

现在你可以按照每行一个输入运算式或者命令了：

```
1+1

```

bc 会回答上面计算式的答案是：

```
2

```

在这里你还可以执行其他的命令。你可以使用 加（+）、减（-）、乘（\*）、除（/）、圆括号、指数符号（^） 等等。请注意 bc 同样也遵循所有约定俗成的运算规则，例如运算的先后顺序。你可以试试下面的例子：

```
(4+7)*2
4+7*2

```

若要退出 bc 可以通过按键组合 `Ctrl+D` 来发送 “输入结束”信号给 bc 。

使用 bc 的另一种方式是使用 `echo` 命令来传递运算式或命令。下面这个示例就是计算器中的 “Hello, world” 例子，使用 shell 的管道函数（|） 来将 `echo` 的输出传入 `bc` 中：

```
echo '1+1' | bc

```

使用 shell 的管道，你可以发送不止一个运算操作，你需要使用分号来分隔不同的运算。结果将在不同的行中返回。

```
echo '1+1; 2+2' | bc

```

### 精度

在某些计算中，bc 会使用精度的概念，即小数点后面的数字位数。默认的精度是 0。除法操作总是使用精度的设定。所以，如果你没有设置精度，有可能会带来意想不到的答案：

```
echo '3/2' | bc
echo 'scale=3; 3/2' | bc

```

乘法使用一个更复杂的精度选择机制：

```
echo '3*2' | bc
echo '3*2.0' | bc

```

同时，加法和减法的相关运算则与之相似：

```
echo '7-4.15' | bc

```

### 其他进制系统

bc 的另一个有用的功能是可以使用除了十进制以外的其他计数系统。例如，你可以轻松地做十六进制或二进制的数学运算。可以使用 `ibase` 和 `obase` 命令来分别设定输入和输出的进制系统。需要记住的是一旦你使用了 `ibase`，之后你输入的任何数字都将被认为是在新定义的进制系统中。

要做十六进制数到十进制数的转换或运算，你可以使用类似下面的命令。请注意大于 9 的十六进制数必须是大写的（A-F）：

```
echo 'ibase=16; A42F' | bc
echo 'ibase=16; 5F72+C39B' | bc

```

若要使得结果是十六进制数，则需要设定 `obase` ：

```
echo 'obase=16; ibase=16; 5F72+C39B' | bc

```

下面是一个小技巧。假如你在 shell 中做这些十六进制运算，怎样才能使得输入重新为十进制数呢？答案是使用 `ibase` 命令，但你必须设定它为在当前进制中与十进制中的 10 等价的值。例如，假如 `ibase` 被设定为十六进制，你需要输入：

```
ibase=A

```

一旦你执行了上面的命令，所有输入的数字都将是十进制的了，接着你便可以输入 `obase=10` 来重置输出的进制系统。

### 结论

上面所提到的只是 bc 所能做到的基础。它还允许你为某些复杂的运算和程序定义函数、变量和循环结构。你可以在你的系统中将这些程序保存为文本文件以便你在需要的时候使用。你还可以在网上找到更多的资源，它们提供了更多的例子以及额外的函数库。快乐地计算吧！

---

via: <https://fedoramagazine.org/bc-command-line-calculator/>

作者：[Paul W. Frields](https://fedoramagazine.org/author/pfrields/) 译者：[FSSlc](https://github.com/FSSlc) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


awk 系列：如何使用 awk 的特殊模式 BEGIN 和 END

# awk 系列：如何使用 awk 的特殊模式 BEGIN 和 END

在 awk 系列的第八节，我们介绍了一些强大的 awk 命令功能，它们是变量、数字表达式和赋值运算符。

本节我们将学习更多的 awk 功能，即 awk 的特殊模式：`BEGIN` 和 `END`。

*学习 awk 的模式 BEGIN 和 END*

随着我们逐渐展开，并探索出更多构建复杂 awk 操作的方法，将会证明 awk 的这些特殊功能的是多么强大。

开始前，先让我们回顾一下 awk 系列的介绍，记得当我们开始这个系列时，我就指出 awk 指令的通用语法是这样的：

```
# awk 'script' filenames

```

在上述语法中，awk 脚本拥有这样的形式：

```
/pattern/ { actions }

```

你通常会发现脚本中的模式（`/pattern/`）是一个正则表达式，此外，你也可以在这里用特殊模式 `BEGIN` 和 `END`。因此，我们也能按照下面的形式编写一条 awk 命令：

```
awk '
BEGIN { actions }
/pattern/ { actions }
/pattern/ { actions }
……….
END { actions }
' filenames

```

假如你在 awk 脚本中使用了特殊模式：`BEGIN` 和 `END`，以下则是它们对应的含义：

* `BEGIN` 模式：是指 awk 将在读取任何输入行之前立即执行 `BEGIN` 中指定的动作。
* `END` 模式：是指 awk 将在它正式退出前执行 `END` 中指定的动作。

含有这些特殊模式的 awk 命令脚本的执行流程如下：

1. 当在脚本中使用了 `BEGIN` 模式，则 `BEGIN` 中所有的动作都会在读取任何输入行之前执行。
2. 然后，读入一个输入行并解析成不同的段。
3. 接下来，每一条指定的非特殊模式都会和输入行进行比较匹配，当匹配成功后，就会执行模式对应的动作。对所有你指定的模式重复此执行该步骤。
4. 再接下来，对于所有输入行重复执行步骤 2 和 步骤 3。
5. 当读取并处理完所有输入行后，假如你指定了 `END` 模式，那么将会执行相应的动作。

当你使用特殊模式时，想要在 awk 操作中获得最好的结果，你应当记住上面的执行顺序。

为了便于理解，让我们使用第八节的例子进行演示，那个例子是关于 Tecmint 拥有的域名列表，并保存在一个叫做 domains.txt 的文件中。

```
news.tecmint.com
tecmint.com
linuxsay.com
windows.tecmint.com
tecmint.com
news.tecmint.com
tecmint.com
linuxsay.com
tecmint.com
news.tecmint.com
tecmint.com
linuxsay.com
windows.tecmint.com
tecmint.com

```

```
$ cat ~/domains.txt

```

*查看文件内容*

在这个例子中，我们希望统计出 domains.txt 文件中域名 `tecmint.com` 出现的次数。所以，我们编写了一个简单的 shell 脚本帮助我们完成任务，它使用了变量、数学表达式和赋值运算符的思想，脚本内容如下：

```
#!/bin/bash
for file in $@; do
if [ -f $file ] ; then
### 输出文件名
echo "File is: $file"
### 输出一个递增的数字记录包含 tecmint.com 的行数
awk '/^tecmint.com/ { counter+=1 ; printf "%s\n", counter ; }' $file
else
### 若输入不是文件，则输出错误信息
echo "$file 不是一个文件，请指定一个文件。" >&2 && exit 1
fi
done
### 成功执行后使用退出代码 0 终止脚本
exit 0

```

现在让我们像下面这样在上述脚本的 awk 命令中应用这两个特殊模式：`BEGIN` 和 `END`：

我们应当把脚本：

```
awk '/^tecmint.com/ { counter+=1 ; printf "%s\n", counter ; }' $file

```

改成：

```
awk ' BEGIN {  print "文件中出现 tecmint.com 的次数是：" ; }
/^tecmint.com/ {  counter+=1  ;  }
END {  printf "%s\n",  counter  ; }
'  $file

```

在修改了 awk 命令之后，现在完整的 shell 脚本就像下面这样：

```
#!/bin/bash
for file in $@; do
if [ -f $file ] ; then
### 输出文件名
echo "File is: $file"
### 输出文件中 tecmint.com 出现的总次数
awk ' BEGIN {  print "文件中出现 tecmint.com 的次数是：" ; }
/^tecmint.com/ {  counter+=1  ;  }
END {  printf "%s\n",  counter  ; }
'  $file
else
### 若输入不是文件，则输出错误信息
echo "$file 不是一个文件，请指定一个文件。" >&2 && exit 1
fi
done
### 成功执行后使用退出代码 0 终止脚本
exit 0

```

*awk 模式 BEGIN 和 END*

当我们运行上面的脚本时，它会首先输出 domains.txt 文件的位置，然后执行 awk 命令脚本，该命令脚本中的特殊模式 `BEGIN` 将会在从文件读取任何行之前帮助我们输出这样的消息“`文件中出现 tecmint.com 的次数是：`”。

接下来，我们的模式 `/^tecmint.com/` 会在每个输入行中进行比较，对应的动作 `{ counter+=1 ; }` 会在每个匹配成功的行上执行，它会统计出 `tecmint.com` 在文件中出现的次数。

最终，`END` 模式将会输出域名 `tecmint.com` 在文件中出现的总次数。

```
$ ./script.sh ~/domains.txt

```

*用于统计字符串出现次数的脚本*

最后总结一下，我们在本节中演示了更多的 awk 功能，并学习了特殊模式 `BEGIN` 和 `END` 的概念。

正如我之前所言，这些 awk 功能将会帮助我们构建出更复杂的文本过滤操作。第十节将会给出更多的 awk 功能，我们将会学习 awk 内置变量的思想，所以，请继续保持关注。

---

via: <http://www.tecmint.com/learn-use-awk-special-patterns-begin-and-end/>

作者：[Aaron Kili](http://www.tecmint.com/author/aaronkili/) 译者：[ChrisLeeGit](https://github.com/chrisleegit) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


apt-fast又有人维护了？！

# 如何在 Ubuntu Linux 16.04 LTS 中使用多个连接加速 apt-get/apt

我该如何加速在 Ubuntu Linux 16.04 或者 14.04 LTS 上从多个仓库中下载包的 apt-get 或者 apt 命令？

你需要使用到 apt-fast 这个 shell 封装器。它会通过多个连接同时下载一个包来加速 apt-get/apt 和 aptitude 命令。所有的包都会同时下载。它使用 aria2c 作为默认的下载加速器。

### 安装 apt-fast 工具

在 Ubuntu Linux 14.04 或者之后的版本尝试下面的命令：

```
$ sudo add-apt-repository ppa:saiarcot895/myppa

```

示例输出：

更新你的仓库：

```
$ sudo apt-get update

```

或者

```
$ sudo apt update

```

安装 apt-fast：

```
$ sudo apt-get -y install apt-fast

```

或者

```
$ sudo apt -y install apt-fast

```

示例输出：

```
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following additional packages will be installed:
  aria2 libc-ares2 libssh2-1
Suggested packages:
  aptitude
The following NEW packages will be installed:
  apt-fast aria2 libc-ares2 libssh2-1
0 upgraded, 4 newly installed, 0 to remove and 0 not upgraded.
Need to get 1,282 kB of archives.
After this operation, 4,786 kB of additional disk space will be used.
Do you want to continue? [Y/n] y
Get:1 http://01.archive.ubuntu.com/ubuntu xenial/universe amd64 libssh2-1 amd64 1.5.0-2 [70.3 kB]
Get:2 http://ppa.launchpad.net/saiarcot895/myppa/ubuntu xenial/main amd64 apt-fast all 1.8.3~137+git7b72bb7-0ubuntu1~ppa3~xenial1 [34.4 kB]
Get:3 http://01.archive.ubuntu.com/ubuntu xenial/main amd64 libc-ares2 amd64 1.10.0-3 [33.9 kB]
Get:4 http://01.archive.ubuntu.com/ubuntu xenial/universe amd64 aria2 amd64 1.19.0-1build1 [1,143 kB]
54% [4 aria2 486 kB/1,143 kB 42%]                                    20.4 kB/s 32s

```

### 配置 apt-fast

你将会得到下面的提示（必须输入一个5到16的数值）：

并且

你也可以直接编辑设置：

```
$ sudo vi /etc/apt-fast.conf

```

>
> **请注意这个工具并不是给慢速网络连接的，它是给快速网络连接的。如果你的网速慢，那么你将无法从这个工具中得到好处。**
>
>
>

### 我该怎么使用 apt-fast 命令？

语法是：

```
apt-fast command
apt-fast [options] command

```

#### 使用 apt-fast 取回新的包列表

```
sudo apt-fast update

```

#### 使用 apt-fast 执行升级

```
sudo apt-fast upgrade

```

#### 执行发行版升级（发布或者强制内核升级），输入：

```
$ sudo apt-fast dist-upgrade

```

#### 安装新的包

语法是：

```
sudo apt-fast install pkg

```

比如要安装 nginx，输入：

```
$ sudo apt-fast install nginx

```

示例输出：

#### 删除包

```
$ sudo apt-fast remove pkg
$ sudo apt-fast remove nginx

```

#### 删除包和它的配置文件

```
$ sudo apt-fast purge pkg
$ sudo apt-fast purge nginx

```

#### 删除所有未使用的包

```
$ sudo apt-fast autoremove

```

#### 下载源码包

```
$ sudo apt-fast source pkgNameHere

```

#### 清理下载的文件

```
$ sudo apt-fast clean

```

#### 清理旧的下载文件

```
$ sudo apt-fast autoclean

```

#### 验证没有破坏的依赖

```
$ sudo apt-fast check

```

#### 下载二进制包到当前目录

```
$ sudo apt-fast download pkgNameHere
$ sudo apt-fast download nginx

```

示例输出：

```
[#7bee0c 0B/0B CN:1 DL:0B]
07/26 15:35:42 [NOTICE] Verification finished successfully. file=/home/vivek/nginx_1.10.0-0ubuntu0.16.04.2_all.deb
07/26 15:35:42 [NOTICE] Download complete: /home/vivek/nginx_1.10.0-0ubuntu0.16.04.2_all.deb
Download Results:
gid   |stat|avg speed  |path/URI
======+====+===========+=======================================================
7bee0c|OK  |        n/a|/home/vivek/nginx_1.10.0-0ubuntu0.16.04.2_all.deb
Status Legend:
(OK):download completed.

```

#### 下载并显示指定包的 changelog

```
$ sudo apt-fast changelog pkgNameHere
$ sudo apt-fast changelog nginx

```

---

via: <http://www.cyberciti.biz/faq/how-to-speed-up-apt-get-apt-command-ubuntu-linux/>

作者：[VIVEK GITE](http://www.cyberciti.biz/tips/about-us) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


Linus Torvalds 谈及物联网、智能设备、安全连接等问题

# Linus Torvalds 谈及物联网、智能设备、安全连接等问题

*Dirk Hohndel 在嵌入式大会上采访 Linus Torvalds 。*

4 月 4 日到 6 日，在圣迭戈召开的[嵌入式 Linux 大会（Embedded Linux Conference）](http://events.linuxfoundation.org/events/embedded-linux-conference)(ELC) 从首次举办到现在已经有 11 年了，该会议包括了与 Linus Torvalds 的主题讨论。作为 Linux 内核的缔造者和最高决策者——用采访他的英特尔 Linux 和开源技术总监 Dirk Hohndel 的话说，“（他是）我们聚在一起的理由”——他对 Linux 在嵌入式和物联网应用程序领域的发展表示乐观。Torvalds 很明确地力挺了嵌入式 Linux，它被 Linux 桌面、服务器和云技术这些掩去光芒已经很多年了。

*Linus Torvalds 在嵌入式 Linux 大会上的演讲。*

物联网是嵌入式大会的主题，在 OpenIoT 峰会讲演中谈到了，在 Torvalds 的访谈中也是主要话题。

Torvalds 对 Hohndel 说到，“或许你不会在物联网末端设备上看到 Linux 的影子，但是在你有一个中心设备的时候，你就会需要它。尤其是物联网标准都有 23 个的时候，你就更需要智能设备了。如果你全部使用的是低级设备，它们没必要一定运行 Linux；如果它们采用的标准稍有差异，你就需要很多的智能设备。我们将来也不会有一个完全开放的标准来将这些物联网设备统一到一起，但是我们会有 3/4 的主要协议是一样的，然后那些智能的中心设备就可以对它们进行互相转换。”

当 Hohndel 问及在物联网的巨大安全漏洞的时候，Torvalds 神情如常。他说：“我不担心安全问题因为我们能做的不是很多，物联网（设备）是不能更新的，这是我们面对的事实。"

Linux 缔造者看起来更关心的是一次性嵌入式项目缺少对上游的及时贡献，尽管他注意到近年来这些有了一些显著改善，特别是在硬件整合方面。

“嵌入式领域历来就很难与开源开发者有所联系，但是我认为这些都在发生改变。”Torvalds 说：“ARM 社区变得越来越好了。内核维护者实际上现在也能跟上了一些硬件的更新换代。一切都在变好，但是还不够。”

Torvalds 承认他在家经常使用桌面系统而不是嵌入式系统，并且对硬件不是很熟悉。

“我已经用电烙铁弄坏了很多东西。”他说到。“我真的不适合搞硬件开发。”另一方面，Torvalds 设想如果他现在是个年轻人，他可能也在摆弄 Raspberry Pi 和 BeagleBone。“最棒的是你不需要精通焊接，你只需要买个新的板子就行。”

同时，Torvalds 也承诺他要为 Linux 桌面再奋斗一个 25 年。他笑着说：“我要为它工作一生。”

请看完整[视频](https://youtu.be/tQKUWkR-wtM)。

要获取关于嵌入式 Linux 和物联网的最新信息，请访问 2016 年嵌入式 Linux 大会 150+ 分钟的会议全程。[现在观看](http://go.linuxfoundation.org/elc-openiot-summit-2016-videos?utm_source=lf&utm_medium=blog&utm_campaign=linuxcom)。

---

via: <https://www.linux.com/news/linus-torvalds-talks-iot-smart-devices-security-concerns-and-more-video>

作者：[ERIC BROWN](https://www.linux.com/users/ericstephenbrown) 译者：[vim-kakali](https://github.com/vim-kakali) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


Drupal、IoT 和开源硬件之间的交集

# Drupal、IoT 和开源硬件之间的交集

来认识一下 [Amber Matz](https://www.drupal.org/u/amber-himes-matz)，她是来自 Lullabot Education 旗下的 [Drupalize.Me](https://events.drupal.org/neworleans2016/) 的产品经理以及培训师。当她没有倒腾 Arduino、Raspberry Pi 以及电子穿戴设备时，通常会在波特兰 Drupal 用户组里担任辩论主持人。

在即将举行的 [DrupalCon NOLA](https://events.drupal.org/neworleans2016/) 大会上，Amber 将主持一个关于 Drupal 和 IoT 的主题。如果你会去参加，也想了解下开源硬件，IoT 和 Drupal 之间的交集，那这个将很合适。如果你去不了新奥尔良的现场也没关系，Amber 还分享了许多很酷的事情。在这次采访中，她讲述了自己参与 Drupal 的原因，一些她自己喜欢的开源硬件项目，以及 IoT 和 Drupal 的未来。

**你是怎么加入 Drupal 社区的？**

在这之前，我在一家大型非盈利性机构市场部的“网站管理部”工作，飞快地批量生产出各种定制 PHP/MySQL 表单。最终我厌烦了这一切，并开始在网上寻找更好的方式。然后我找到了 Drupal 6 并开始沉迷进去。过了几年，在一次跳槽之后，我发现了波特兰 Drupal 用户组，然后在里面找了一份全职的 Drupal 开发者工作。我一直经常参加在波特兰的聚会，在那里我找到了大量的社区、朋友和专业方面的发展。一个偶然的机会，我在 Lullabot 找了一份培训师的工作，为 Drupalize.Me 提供内容。现在，我管理着 Drupalize.Me 的内容输出，负责编撰 Drupal 8 相关的内容，还很大程度地参与到波特兰 Drupal 社区中。我是今年的协调员，寻找并安排演讲者们。

**我们想知道：什么是 Arduino 原型，你是怎么找到它的，以及你用 Arduino 做过的最酷的事是什么？**

Arduino，Raspberry Pi，以及可穿戴电子设备，这些年到处都能听到这些术语。我在几年前通过 Becky Stern 的 YouTube 秀（最近由 Becky 继续主持，每周三播出）发现了 [Adafruit 的可穿戴电子设备](https://www.adafruit.com/beckystern)。我被那些可穿戴设备迷住了，还订了一套 LED 缝制工具，不过没做出任何东西。我不太适合它。我没有任何电子相关的背景，而且在我被那些项目吸引的时候，我根本不知道怎么做出那样的东西，它似乎看上去太遥远了。

后来，我在 Coursera 上找到了一个“物联网”专题。（很时髦，对吧？）我很快就喜欢上了。我最终找到了 Arduino 是什么的解释，以及所有这些其他的重要术语和概念。我订了一套推荐的 Arduino 初学者套件，还附带了一本如何上手的小册子。当我第一次让 LED 闪烁的时候，开心极了。我在圣诞节以及之后有两个星期的假期，然而我什么都没干，就一直根据初学者小册子给 Arduino 电路编程。很奇怪我觉得很放松！我太喜欢了。

在一月份的时候，我开始构思我自己的原型设备。在知道我需要主持公司培训的开场白时，我用五个 LED 灯和 Arduino 搭建了一个开场白视觉计时器的原型。

这是一次巨大的成功。我还做了我的第一个可穿戴项目，一件会发光的连帽衫，使用了和 Arduino IDE 兼容的 Gemma 微控制器，一个小的圆形可缝制部件，然后用可导电的线缝起来，将一个滑动可变电阻和衣服帽口的收缩绳连在一起，用来控制缝到帽子里的五个 NeoPixel 灯的颜色。这就是我对原型设计的看法：做一些很好玩也可能会有点实际用途的疯狂项目。

**Drupal 和 IoT 带来的最大机遇是什么？?**

IoT 与 Web Service 以及 Drupal 分层趋势实际并没有太大差别。就是将数据从一个东西传送到另一个东西，然后将数据转换成一些有用的东西。但数据是如何送达？能用来做点什么？你觉得现在就有一大堆现成的解决方案、应用、中间层，以及 API 吗？采用 IoT，这只会继续成几何指数级的增长。我觉得，给我任何一个设备或“东西”，总有办法来将它连接到互联网上，有很多办法。而且有大量现成的代码库来帮助创客们将他们的数据从一个东西传到另一个东西。

那么 Drupal 在这里处于什么位置？首先，Web services 将是第一个明显的地方。但作为一个创客，我不希望将时间花在编写 Drupal 的订制模块上。我想要的是即插即用！所以我很高兴出现这样的模块能连接 IoT 云端 API 和服务，比如 ThingSpeak，Adafruit.io，IFTTT，以及其他的。我觉得也有一个很好的商业机会，在 Drupal 里构建一套 IoT 云服务，允许用户发送和存储他们的传感器数据，并可以制成表格和图像，还可以写一些插件可以响应特定数据或阙值。每一个 IoT 云 API 服务都是一个细分的机会，所以能留下很大空间给其他人。

**这次 DrupalCon 你有哪些期待？**

我喜欢与 Drupal 上的朋友重逢，认识一些新的人，还能见到 Lullabot 和 Drupalize.Me 的同事（我们是分布式的公司）！Drupal 8 有太多东西可以去探索了，我们给我们的客户们提供了海量的培训资料。所以，我很期待参与一些 Drupal 8 相关的主题，以及跟上最新的开发进度。最后，我对新奥尔良也很感兴趣！我曾经在 2004 年去过，很期待将这次将看到哪些改变。

**谈一谈你这次 DrupalCon 上的演讲：“超越闪烁：将 Drupal 加到你的 IoT 游乐场中”。别人为什么要参加？他们最重要的收获会是什么？**

我的主题的标题是，“超越闪烁：将 Drupal 加到你的 IoT 游乐场中”，假设我们所有人都处在同一进度和层次，你不需要了解任何关于 Arduino、物联网、甚至是 Drupal，都能跟上。我将从用 Arduino 让 LED 灯闪烁开始，然后我会谈一下我自己在这里面的最大收获：玩、学、教和做。我会列出一些曾经激励过我的例子，它们也很有希望能激发和鼓励其他听众去尝试一下。然后，就是展示时间！

首先，第一个东西。它是一个建筑提醒信号灯。在这个展示里，我会说明如何将信号灯连到互联网上，以及如何响应从云 API 服务收到的数据。然后，第二个东西。它是一个蒸汽朋克风格 iPhone 外壳形式的“天气手表”。有一个小型 LED 矩阵用来显示我的天气的图标，一个气压和温度传感器，一个 GPS 模块，以及一个 Bluetooth LE 模块，都连接到一个 Adafruit Flora 微控制器上。第二个东西能通过蓝牙连接到我的 iPhone 上的一个应用，并将天气和位置数据通过 MQTT 协议发到 Adafruit.io 的服务器！然后，在 Drupal 这边，我会从云端下载这些数据，更新天气信息，然后更新地图。所以大家也能体验一下通过web service、地图和 Drupal 8 的功能块所能做的事情。

学习和制作这些展示原型是一次烧脑的探险，我也希望有人能参与这个主题并感染一点我对这种技术交叉的传染性热情！我很兴奋能分享一些我的发现。

---

via: <https://opensource.com/business/16/5/drupalcon-interview-amber-matz>

作者：[Jason Hibbets](https://opensource.com/users/jhibbets) 译者：[zpl1025](https://github.com/zpl1025) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创翻译，[Linux中国](https://linux.cn/) 荣誉推出


Linux 下的密码管理器：Keeweb

Summary: 我将在本文中介绍 Keeweb，它是一款 Linux 密码管理器，可以为你安全地存储所有的密码，无论是离线还是在线。

# Linux 下的密码管理器：Keeweb

如今，我们依赖于越来越多的线上服务。我们每注册一个线上服务，就要设置一个密码；如此，我们就不得不记住数以百计的密码。这样对于每个人来说，都很容易忘记密码。我将在本文中介绍 Keeweb，它是一款 Linux 密码管理器，可以为你离线或在线地安全存储所有的密码。

当谈及 Linux 密码管理器时，我们会发现有很多这样的软件。我们已经在 LinuxAndUbuntu 上讨论过像 [Keepass](http://www.linuxandubuntu.com/home/keepass-password-management-tool-creates-strong-passwords-and-keeps-them-secure) 和 [Encryptr，一个基于零知识系统的密码管理器](http://www.linuxandubuntu.com/home/encryptr-zero-knowledge-system-based-password-manager-for-linux) 这样的密码管理器。Keeweb 则是另外一款我们将在本文讲解的 Linux 密码管理器。

### Keeweb 可以离线或在线存储密码

Keeweb 是一款跨平台的密码管理器。它可以离线存储你所有的密码，并且能够同步到你自己的云存储服务上，例如 OneDrive、Google Drive、Dropbox 等。Keeweb 并没有它提供它自己的在线数据库来的同步你的密码。

要使用 Keeweb 连接你的线上存储服务，只需要点击界面中的“more”，然后再点击你想要使用的服务即可。

现在，Keeweb 会提示你登录到你的云盘。登录成功后，给 Keeweb 授权使用你的账户。

### 使用 Keeweb 存储密码

使用 Keeweb 存储你的密码是非常容易的。你可以使用一个复杂的密码加密你的密码文件。Keeweb 也允许你使用一个秘钥文件来锁定密码文件，但是我并不推荐这种方式。如果某个家伙拿到了你的秘钥文件，他只需要简单点击一下就可以解锁你的密码文件。

#### 创建密码

想要创建一个新的密码，你只需要简单地点击 `+` 号，然后你就会看到所有需要填充的输入框。根据你的需要创建更多的密码记录。

#### 搜索密码

Keeweb 拥有一个图标库，这样你就可以轻松地找到各种特定的密码记录。你可以改变图标的颜色、下载更多的图标，甚至可以直接从你的电脑中导入图标。这对于密码搜索来说，异常好使。

相似的服务的密码可以分组，这样你就可以在一个文件夹里找到它们。你也可以给密码打上标签并把它们存放在不同分类中。

### 主题

如果你喜欢类似于白色或者高对比度的亮色主题，你可以在“设置 > 通用 > 主题”中修改。（Keeweb）有四款可供选择的主题，其中两款为暗色，另外两款为亮色。

### 不喜欢 Linux 密码管理器？没问题！

我已经发表过文章介绍了另外两款 Linux 密码管理器，它们分别是 Keepass 和 Encryptr，在 Reddit 和其它社交媒体上有些关于它们的争论。有些人反对使用任何密码管理器，也有人持相反意见。在本文中，我想要澄清的是，存放密码文件是我们自己的责任。我认为像 keepass 和 Keeweb 这样的密码管理器是非常好用的，因为它们并没有自己的云来存放你的密码。这些密码管理器会创建一个文件，然后你可以将它存放在你的硬盘上，或者使用像 VeraCrypt 这样的应用给它加密。我个人不使用也不推荐使用那些将密码存储在它们自己数据库的服务。

---

via: <http://www.linuxandubuntu.com/home/keeweb-a-linux-password-manager>

译者：[ChrisLeeGit](https://github.com/chrisleegit) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


awk 系列：如何使用 awk 内置变量

Summary: 在本节中，我们将介绍 awk 内置（built-in）变量的概念。你可以在 awk 中使用两种类型的变量，它们是：用户自定义（user-defined）变量（我们在第八节中已经介绍了）和内置变量。

# awk 系列：如何使用 awk 内置变量

我们将逐渐揭开 awk 功能的神秘面纱，在本节中，我们将介绍 awk <ruby> 内置 <rp>  （ </rp> <rt>  built-in </rt> <rp>  ） </rp></ruby>变量的概念。你可以在 awk 中使用两种类型的变量，它们是：<ruby> 用户自定义 <rp>  （ </rp> <rt>  user-defined </rt> <rp>  ） </rp></ruby>变量（我们在[第八节](/article-7650-1.html)中已经介绍了）和内置变量。

*awk 内置变量示例*

awk 内置变量已经有预先定义的值了，但我们也可以谨慎地修改这些值，awk 内置变量包括：

* `FILENAME` : 当前输入文件名称
* `NR` : 当前输入行编号（是指输入行 1，2，3……等）
* `NF` : 当前输入行的字段编号
* `OFS` : 输出字段分隔符
* `FS` : 输入字段分隔符
* `ORS` : 输出记录分隔符
* `RS` : 输入记录分隔符

让我们继续演示一些使用上述 awk 内置变量的方法：

想要读取当前输入文件的名称，你可以使用 `FILENAME` 内置变量，如下：

```
$ awk ' { print FILENAME } ' ~/domains.txt

```

*awk FILENAME 变量*

你会看到，每一行都会对应输出一次文件名，那是你使用 `FILENAME` 内置变量时 awk 默认的行为。

我们可以使用 `NR` 来统计一个输入文件的行数（记录），谨记，它也会计算空行，正如我们将要在下面的例子中看到的那样。

当我们使用 cat 命令查看文件 domains.txt 时，会发现它有 14 行文本和 2 个空行：

```
$ cat ~/domains.txt

```

*输出文件内容*

```
$ awk ' END { print "Number of records in file is: ", NR } ' ~/domains.txt

```

*awk 统计行数*

想要统计一条记录或一行中的字段数，我们可以像下面那样使用 NR 内置变量：

```
$ cat ~/names.txt

```

*列出文件内容*

```
$ awk '{ "Record:",NR,"has",NF,"fields" ; }' ~/names.txt

```

*awk 统计文件中的字段数*

接下来，你也可以使用 FS 内置变量指定一个输入文件分隔符，它会定义 awk 如何将输入行划分成字段。

FS 默认值为“空格”和“制表符”，但我们也能将 FS 值修改为任何字符来让 awk 根据情况切分输入行。

有两种方法可以达到目的：

* 第一种方法是使用 FS 内置变量
* 第二种方法是使用 awk 的 -F 选项

来看 Linux 系统上的 `/etc/passwd` 文件，该文件中的各字段是使用 `:` 分隔的，因此，当我们想要过滤出某些字段时，可以将 `:` 指定为新的输入字段分隔符，示例如下：

我们可以使用 `-F` 选项，如下：

```
$ awk -F':' '{ print $1, $4 ;}' /etc/passwd

```

*awk 过滤密码文件中的各字段*

此外，我们也可以利用 FS 内置变量，如下：

```
$ awk ' BEGIN {  FS=“:” ; }  { print $1, $4  ; } ' /etc/passwd

```

*使用 awk 过滤文件中的各字段*

使用 OFS 内置变量来指定一个用于输出的字段分隔符，它会定义如何使用指定的字符分隔输出字段，示例如下：

```
$ awk -F':' ' BEGIN { OFS="==>" ;} { print $1, $4 ;}' /etc/passwd

```

*向文件中的字段添加分隔符*

在本节中，我们已经学习了使用含有预定义值的 awk 内置变量的理念。但我们也能够修改这些值，虽然并不推荐这样做，除非你明白自己在做什么，并且充分理解（这些变量值）。

此后，我们将继续学习如何在 awk 命令操作中使用 shell 变量，所以，请继续关注我们。

---

via: <http://www.tecmint.com/awk-built-in-variables-examples/>

作者：[Aaron Kili](http://www.tecmint.com/author/aaronkili/) 译者：[ChrisLeeGit](https://github.com/chrisleegit) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出