title
stringlengths 5
75
| author
stringlengths 0
48
| fromurl
stringlengths 0
185
| summary
stringlengths 4
460
| pic
stringlengths 32
70
| largepic
stringlengths 0
69
| titlepic
bool 2
classes | thumb
bool 2
classes | islctt
bool 2
classes | selector
stringclasses 14
values | translator
stringlengths 0
45
| reviewer
stringclasses 27
values | editorchoice
bool 2
classes | tags
list | category
stringclasses 20
values | count
dict | comments_data
list | related
list | excerpt
stringlengths 4
460
| date
timestamp[s] | updated
timestamp[s] | id
int64 1
16.6k
| permalink
stringlengths 17
21
| content
stringlengths 116
82.2k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
极客漫画：TCP 兄弟
|
Daniel Stori
|
https://turnoff.us/geek/tcp-buddies/
|
TCP 协议规定，在传输数据之前，要进行三次“握手”，来保证数据传输的可靠性。
|
/data/attachment/album/201812/18/111345ick2lec5j5je2avj.png.thumb.jpg
|
/data/attachment/album/201812/18/111345ick2lec5j5je2avj.png.large.jpg
| false | false | true |
bestony
|
wxy
| false |
[
"TCP",
"漫画"
] |
极客漫画
|
{
"viewnum": 14113,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
TCP 协议规定，在传输数据之前，要进行三次“握手”，来保证数据传输的可靠性。
| 2018-12-18T11:15:20 | 2018-12-18T11:15:20 | 10,360 |
/article-10360-1.html
|
这幅漫画展示了 TCP 协议的沟通过程。首先是构建一个层（TCP 工作于传输层），然后向要通信的人发送建立联系的信号（SYN），接受到信息的人回复确认信息（ACK），确认已经收到，同时，发送建立联系的信息（SYN），这时，它发送的信息就是（SYN-ACK），当最初发送信息的人收到信息后，再回复了确认信息（ACK）。在回复了确认信息后，他们可以正常的交流，就开始说话了。
TCP 协议规定，在传输数据之前，要进行三次“握手”，来保证数据传输的可靠性。上面这幅漫画就展示了这样的内容。
如果你有兴趣查看更多信息，可以参看 [https://zh.wikipedia.org/wiki/传输控制协议](https://zh.wikipedia.org/wiki/%E4%BC%A0%E8%BE%93%E6%8E%A7%E5%88%B6%E5%8D%8F%E8%AE%AE)。
---
via: <https://turnoff.us/geek/tcp-buddies/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者：[Bestony](https://github.com/bestony) 校对：[wxy](https://github.com/wxy) 合成&点评：[Bestony](https://github.com/Bestony)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
使用 lolcat 为你的 Linux 终端带来彩虹
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-lolcat
|
使用这个简单的工具，你可以为所需的任何程序的输出变成七彩。
|
/data/attachment/album/201812/18/160350ezquzucc15yuw4ru.png.thumb.jpg
|
/data/attachment/album/201812/18/160350ezquzucc15yuw4ru.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"颜色",
"彩虹"
] |
分享
|
{
"viewnum": 4567,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
使用这个简单的工具，你可以为所需的任何程序的输出变成七彩。
| 2018-12-18T16:03:47 | 2018-12-18T16:03:47 | 10,361 |
/article-10361-1.html
|
>
> 使用这个简单的工具，你可以为所需的任何程序的输出变成七彩。
>
>
>
今天是 Linux 命令行玩具日历的第五天。如果这是你第一次访问该系列，你可能会问自己，什么是命令行玩具。即使我不太确定，但一般来说，它可能是一个游戏，或任何简单的可以帮助你在终端玩得开心的东西。
很可能你们中的一些人之前已经看过我们日历中的各种玩具，但我们希望每个人至少见到一件新事物。
今日的选择，`lolcat`，是我选择的第一个没有在我的 Linux 发行版中打包的程序，但它安装仍然很简单。它是一个 Ruby 程序，你应该可以使用下面的命令轻松地添加到系统中。
```
$ gem install lolcat
```
之后，只需将一些文本传送给它，就可以看到彩色的输出。例如，尝试几个之前在我们的日历中出现的程序，使用以下命令：
```
$ fortune | boxes -a c -d parchment | lolcat
```
根据你的运气，你可能会看到这样：
你可以传递给 `lolcat` 一些参数。这里不再赘述，我建议你访问 `lolcat` 的 [GitHub 页面](https://github.com/busyloop/lolcat) 或者在终端输入 `lolcat --help` 了解。但一般来说，它们能设置彩虹的传递和频率，以及我个人最喜欢的动画。谁不喜欢终端的彩色动画输出呢？让我们再试一次，用一个不同的边框（当然是以猫为主题）和一句在我的格言列表中的适合猫的句子。
```
fortune -m "nine tails" | boxes -a c -d cat | lolcat -a
```
`lolcat` 是一个 BSD 许可下的开源软件。
你有特别喜欢的命令行小玩具需要我介绍的吗？这个系列要介绍的小玩具大部分已经有了落实，但还预留了几个空位置。如果你有特别想了解的可以评论留言，我会查看的。如果还有空位置，我会考虑介绍它的。如果没有，但如果我得到了一些很好的意见，我会在最后做一些有价值的提及。
了解一下昨天的玩具，[在 Linux 命令行中拥有一头牛](https://opensource.com/article/18/12/linux-toy-cowsay)，还有记得明天再来！
---
via: <https://opensource.com/article/18/12/linux-toy-lolcat>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
搜索 Linux 中的文件和文件夹的四种简单方法
|
Prakash Subramanian
|
https://www.2daygeek.com/four-easy-ways-to-search-or-find-files-and-folders-in-linux/
|
Linux 管理员一天都不能离开搜索文件，因为这是他们的日常活动。
|
/data/attachment/album/201812/18/232341e4bbp764944p7aan.jpg.thumb.jpg
|
/data/attachment/album/201812/18/232341e4bbp764944p7aan.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"find",
"搜索"
] |
技术
|
{
"viewnum": 24936,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Linux 管理员一天都不能离开搜索文件，因为这是他们的日常活动。
| 2018-12-18T23:23:56 | 2018-12-18T23:23:56 | 10,362 |
/article-10362-1.html
|
Linux 管理员一天都不能离开搜索文件，因为这是他们的日常活动。了解一些搜索的东西是不错的，因为这能帮助你在命令行服务器中工作。这些命令记忆起来不复杂，因为它们使用的是标准语法。
可以通过四个 Linux 命令啦执行此操作，每个命令都有自己独特的功能。
### 方法 1：使用 find 命令在 Linux 中搜索文件和文件夹
`find` 命令被广泛使用，并且是在 Linux 中搜索文件和文件夹的著名命令。它搜索当前目录中的给定文件，并根据搜索条件递归遍历其子目录。
它允许用户根据大小、名称、所有者、组、类型、权限、日期和其他条件执行所有类型的文件搜索。
运行以下命令以在系统中查找给定文件。
```
# find / -iname "sshd_config"
/etc/ssh/sshd_config
```
运行以下命令以查找系统中的给定文件夹。要在 Linux 中搜索文件夹，我们需要使用 `-type` 参数。
```
# find / -type d -iname "ssh"
/usr/lib/ssh
/usr/lib/go/src/cmd/vendor/golang.org/x/crypto/ssh
/usr/lib/go/pkg/linux_amd64/cmd/vendor/golang.org/x/crypto/ssh
/etc/ssh
```
使用通配符搜索系统上的所有文件。我们将搜索系统中所有以 `.config` 为扩展名的文件。
```
# find / -name "*.config"
/usr/lib/mono/gac/avahi-sharp/1.0.0.0__4d116c78973743f5/avahi-sharp.dll.config
/usr/lib/mono/gac/avahi-ui-sharp/0.0.0.0__4d116c78973743f5/avahi-ui-sharp.dll.config
/usr/lib/python2.7/config/Setup.config
/usr/share/git/mw-to-git/t/test.config
/var/lib/lightdm/.config
/home/daygeek/.config
/root/.config
/etc/skel/.config
```
使用以下命令格式在系统中查找空文件和文件夹。
```
# find / -empty
```
使用以下命令组合查找 Linux 上包含特定文本的所有文件。
```
# find / -type f -exec grep "Port 22" '{}' \; -print
# find / -type f -print | xargs grep "Port 22"
# find / -type f | xargs grep 'Port 22'
# find / -type f -exec grep -H 'Port 22' {} \;
```
### 方法 2：使用 locate 命令在 Linux 中搜索文件和文件夹
`locate` 命令比 `find` 命令运行得更快，因为它使用 `updatedb` 数据库，而 `find` 命令在真实系统中搜索。
它使用数据库而不是搜索单个目录路径来获取给定文件。
`locate` 命令未在大多数发行版中预安装，因此，请使用你的包管理器进行安装。
数据库通过 cron 任务定期更新，但我们可以通过运行以下命令手动更新它。
```
$ sudo updatedb
```
只需运行以下命令即可列出给定的文件或文件夹。在 `locate` 命令中不需要指定特定选项来打印文件或文件夹。
在系统中搜索 `ssh` 文件夹。
```
# locate --basename '\ssh'
/etc/ssh
/usr/bin/ssh
/usr/lib/ssh
/usr/lib/go/pkg/linux_amd64/cmd/vendor/golang.org/x/crypto/ssh
/usr/lib/go/src/cmd/go/testdata/failssh/ssh
/usr/lib/go/src/cmd/vendor/golang.org/x/crypto/ssh
```
在系统中搜索 `ssh_config` 文件。
```
# locate --basename '\sshd_config'
/etc/ssh/sshd_config
```
### 方法 3：在 Linux 中搜索文件使用 which 命令
`which` 返回在终端输入命令时执行的可执行文件的完整路径。
当你想要为可执行文件创建桌面快捷方式或符号链接时，它非常有用。
`which` 命令搜索当前用户而不是所有用户的 `$PATH` 环境变量中列出的目录。我的意思是，当你登录自己的帐户时，你无法搜索 root 用户文件或目录。
运行以下命令以打印 `vim` 可执行文件的完整路径。
```
# which vi
/usr/bin/vi
```
或者，它允许用户一次执行多个文件搜索。
```
# which -a vi sudo
/usr/bin/vi
/bin/vi
/usr/bin/sudo
/bin/sudo
```
### 方法 4：使用 whereis 命令在 Linux 中搜索文件
`whereis` 命令用于搜索给定命令的二进制、源码和手册页文件。
```
# whereis vi
vi: /usr/bin/vi /usr/share/man/man1/vi.1p.gz /usr/share/man/man1/vi.1.gz
```
---
via: <https://www.2daygeek.com/four-easy-ways-to-search-or-find-files-and-folders-in-linux/>
作者：[Prakash Subramanian](https://www.2daygeek.com/author/prakash/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
迁移到 Linux：网络和系统设置
|
John Bonesio
|
https://www.linux.com/blog/learn/2018/4/migrating-linux-network-and-system-settings
|
这个系列我们提供了基础知识的概述，以帮助您成功地从另一个操作系统过渡到 Linux；这篇中我们涉及到 Linux 桌面系统上的一些常见设置。
|
/data/attachment/album/201812/19/004424z4994gs0ys9hsdt5.jpg.thumb.jpg
|
/data/attachment/album/201812/19/004424z4994gs0ys9hsdt5.jpg
| true | false | true |
lujun9972
|
ScarboroughCoral
|
wxy
| false |
[
"迁移"
] |
技术
|
{
"viewnum": 5574,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 9823,
"displayorder": 0
}
] |
这个系列我们提供了基础知识的概述，以帮助您成功地从另一个操作系统过渡到 Linux；这篇中我们涉及到 Linux 桌面系统上的一些常见设置。
| 2018-12-19T00:44:19 | 2018-12-19T00:44:19 | 10,363 |
/article-10363-1.html
|
>
> 这个系列我们提供了基础知识的概述，以帮助您成功地从另一个操作系统过渡到 Linux；这篇中我们涉及到 Linux 桌面系统上的一些常见设置。
>
>
>
在这个系列中，我们提供了基础知识的概述，以帮助您成功地从另一个操作系统过渡到 Linux。如果你错过了以前的文章，可以从这访问：
* [第1部分 - 入门介绍](/article-9212-1.html)
* [第2部分 - 磁盘、文件和文件系统](/article-9213-1.html)
* [第3部分 - 图形操作环境](/article-9293-1.html)
* [第4部分 - 命令行](/article-9565-1.html)
* [第5部分 - 使用 sudo](/article-9819-1.html)
* [第5部分 - 安装软件](/article-9823-1.html)
Linux 提供了一系列网络和系统设置。在你的桌面计算机上，Linux 允许您调整系统上的任何内容。大多数这些设置都出现在 `/etc` 目录下的纯文本文件中。这里我将介绍你使用桌面 Linux 操作系统的过程中最常用的设置。
大多数设置都能够在“设置”程序里面找到，这些设置可能对于不同的 Linux 发行版有所不同。通常来说，你可以修改背景、调整音量、连接打印机、进行显示设置等。对于这些设置尽管我不会全部谈论，但你可以自己探索。
### 连接互联网
在 Linux 中连接到互联网通常非常简单。如果您通过以太网电缆连接，Linux 通常会在插入电缆时或启动时（如果电缆已连接）获得 IP 地址并自动连接。
如果您使用无线网络，则在大多数发行版中都有一个菜单，可以在指示器面板中或在“设置”中（取决于您的发行版），您可以在其中选择无线网络的 SSID。如果网络受密码保护，它通常会提示您输入密码。然后连接，这个过程相当顺利。
在图形界面您可以通过进入设置来调整网络设置。通常称为“系统设置”或者是“设置”。通常可以轻松找到设置程序，因为它的图标是齿轮或工具图片（图1）。
*图1： Gnome 桌面网络设置指示器图标。*
### 网络接口名称
在 Linux 下，网络设备有名称。 从历史上看，它们的名称分别为 eth0 和 wlan0 —— 或“以太网”和“无线网络”。 较新的 Linux 系统一直使用看起来更深奥的不同名称，如 enp4s0 和 wlp5s0 。 如果名称以 en 开头，则它是有线以太网接口。 如果它以 wl 开头，那么它就是一个无线接口。 其余的字母和数字反映了设备如何连接到硬件。
### 通过命令行进行网络管理
如果您希望更好地控制网络设置，或者如果您在没有图形桌面的情况下管理网络连接，则还可以从命令行管理网络。
请注意，用于在图形桌面中管理网络的最常用服务是“<ruby> 网络管理器 <rt> Network Manager </rt></ruby>”，而网络管理器通常会覆盖在命令行上进行的设置更改。如果您正在使用网络管理器，最好在其界面中更改您的设置，以防止撤消您从命令行或其他位置所做的更改。
在图形环境中的更改设置与在网络管理器中很类似，您还可以使用名为 `nmtui` 的工具从命令行更改网络管理器设置。`nmtui` 工具提供了您在图形环境中找到的所有设置，但是是在基于文本的半图形界面中提供了该设置，该界面可在命令行上运行（图 2）。
*图 2：nmtui 界面*
在命令行上，有一个名为 `ifconfig` 的旧工具来管理网络，还有一个名为 `ip` 的新工具。在某些发行版中，`ifconfig` 被认为是不推荐使用的，默认情况下甚至没有安装。在其他发行版上，`ifconfig` 仍可以使用。
以下是一些允许您显示和更改网络设置的命令：
### 进程和系统信息
在 Windows 系统中，你可以使用任务管理器来查看所有正在运行的程序和服务的列表。你可以停止运行中的程序，并且可以在其中显示的某些选项卡中查看系统性能。
在 Linux 系统下你可以使用命令行或者图形界面中做同样的事情。Linux 系统中根据你的发行版本会有不同的几个可用的图形工具。大多数所共有的工具是“系统监视器”和 KSysGuard。在这些工具中，你可以查看系统性能，查看进程列表甚至是杀死进程（图 3）。
*图 3：NetHogs 截图*
在这些工具中，你也可以查看系统全局网络流量（图 4）。
*图 4：Gnome System Monitor 的截图*
### 管理进程和系统使用
您还可以从命令行使用相当多的工具。使用 `ps` 命令可以查看系统中的进程列表。默认情况下，这个命令的结果是显示当前终端会话下的所有进程列表。但是你也可以通过使用各种命令行参数显示其他进程。如果 `ps` 命令不会使用，可以使用命令 `info ps` 或者 `man ps` 获取帮助。
大多数人都希望得到一个进程列表，因为他们想要停止占用过多内存或 CPU 时间的进程。这种情况下有两个非常简单的命令，分别是 `top` 和 `htop` 命令（图 5）。
*图 5：top 截屏*
`top` 和 `htop` 工具使用效果非常相似。两个命令每秒或者两秒会更新重新排序，这样会把占用 CPU 资源最多的放置在列表顶部。你也可以根据其他资源的使用情况比如内存使用情况来排序。
使用这两个命令时（`top` 和 `htop`），你可以输入 `?` 来获取使用帮助，输入 `q` 来退出程序。使用 `top` 命令你可以按 `k` 键然后输入进程 ID 来杀死某个进程。
使用 `htop` 命令时你可以使用 `↑` `↓` 键来将列表中的一条记录进行高亮显示，按下 `F9` 键会杀死进程（需要回车确认）。
本系列中提供的信息和工具将帮助您开始使用 Linux。 只需一点时间和耐心，您就会感到这非常舒服。
想学习更多 Linux 内容可访问免费的 [Linux 简介](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)课程，此课程来自 Linux 基金会和 edx。
---
via: <https://www.linux.com/blog/learn/2018/4/migrating-linux-network-and-system-settings>
作者：[John Bonesio](https://www.linux.com/users/johnbonesio) 选题：[lujun9972](https://github.com/lujun9972) 译者：[ScarboroughCoral](https://github.com/ScarboroughCoral) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
认识存储：块、文件和对象
|
Swapnil Bhartiya
|
https://www.linux.com/blog/2018/9/know-your-storage-block-file-object
|
今天产生的大量数据带来了新的存储挑战。在本文中了解各种存储类型以及它们的使用方式。
|
/data/attachment/album/201812/19/154519p172q219w9nf2row.jpg.thumb.jpg
|
/data/attachment/album/201812/19/154519p172q219w9nf2row.jpg
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"存储"
] |
技术
|
{
"viewnum": 7789,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
今天产生的大量数据带来了新的存储挑战。在本文中了解各种存储类型以及它们的使用方式。
| 2018-12-19T15:45:17 | 2018-12-19T15:45:17 | 10,364 |
/article-10364-1.html
|
>
> 今天产生的大量数据带来了新的存储挑战。在本文中了解各种存储类型以及它们的使用方式。
>
>
>
现在，对于那些创建或消费数据的公司来说，处理数量巨大的生成数据是个非常大的挑战。而对于那些解决存储相关问题的科技公司来说，也是一个挑战。
Red Hat 存储首席产品营销经理 Michael St. Jean 说，“数据每年呈几何级增长，而我们发现数据大量增长的主要原因是由于消费增长和为拓展价值而进行的产业转型，毫无疑问，物联网对数据增长的贡献很大，但对软件定义存储来说最重要的挑战是，如何处理用户场景相关的数据增长。“
任何挑战都意味着机遇。Azure 存储、介质和边缘计算总经理 Tad Brockway 说，“今天，新旧数据源产生的海量数据为我们满足客户在规模、性能、灵活性、治理方面急剧增长的需求提供了一个机遇。”
### 现代软件定义存储的三种类型
这里有三个不同类型的存储解决方案 —— 块、文件、和对象 —— 虽然它们每个都可以与其它的共同工作，但它们每个都有不同的用途。
块存储是数据存储的最古老形式，数据都存储在固定长度的块或多个块中。块存储适用于企业存储环境，并且通常使用光纤通道或 iSCSI 接口。根据 SUSE 的软件定义存储高级产品经理 Larry Morris 的说法，“块存储要求一个应用去映射存储设备上存储数据块的位置。”
块存储在存储区域网和软件定义存储系统中是虚拟的，它是处于一个共享的硬件基础设施上的抽象逻辑设备，其创建和存在于服务器、虚拟服务器、或运行在基于像 SCSI、SATA、SAS、FCP、FCoE、或 iSCSI 这样的协议的系统管理程序上。
St. Jean 说“块存储将单个的存储卷（如一个虚拟或云存储节点、或一个老式硬盘）分割成单独的被称为块的实体。”
每个块独立存在，并且能够用它自己的数据传输协议和操作系统格式化 —— 给用户完全的配置自主权。由于块存储系统并不负责像文件存储系统那样的文件查找职责，所以，块存储是一个非常快的存储系统。由于同时具备速度和配置灵活性，使得块存储非常适合原始服务器存储或富媒体数据库。
块存储适合于宿主机操作系统、应用程序、数据库、完整虚拟机和容器。传统上，块存储仅能够被独立的机器访问，或呈现给集群中的机器访问。
### 基于文件的存储
基于文件的存储使用一个文件系统去映射存储设备上数据的存储位置。这种技术在直连或网络附加存储系统应用领域中处于支配地位。它需要做两件事情：组织数据并呈现给用户。St. Jean 说，”使用文件存储时，数据在服务器侧的存储方式与客户端用户所看到的是完全相同的。这就允许用户通过一些唯一标识符（像文件名、位置、或 URL）去请求一个文件，使用特定的数据传输协议与存储系统沟通。
其结果就是一种能够从上到下进行浏览的分层的文件结构。文件存储处于块存储之上，允许用户去查看和访问文件、文件夹这样的数据，但是被限制访问处于这些文件和文件夹之下的数据块。
Brockway 解释说，“文件存储一般用于像 NFS 和 CIFS/SMB 这种很多服务器基于 IP 网络进行访问的共享文件系统上。访问控制通过用户和组的权限实现在文件、目录和导出级别上。基于文件的存储可用于被多个用户和机器、二进制应用程序、数据库、虚拟机所需要的文件的存储上，以及容器上。“
### 对象存储
对象存储是最新的数据存储形式，它为非结构化数据提供一个仓库，它将内容从索引中分离出来，并允许多个文件连接到一个对象上。一个对象就是与任何相关元数据配对的一个数据块，这些元数据提供对象中包含的字节的上下文（比如数据创建时间和数据大小等）。也就是说这两样东西 —— 数据和元数据 —— 构成了一个对象。
对象存储的一个好处是每个数据块都关联了一个唯一标识符。访问数据需要唯一标识符，并且不需要应用程序或用户知道数据的真实存储位置。对象数据是通过 API 来访问的。
St. Jean 说，“对象中存储的数据是没有压缩和加密的，对象本身被组织在对象存储（一个填满其它对象的中心库）中或容器（包含应用程序运行所需要的所有文件的一个包）中。与文件存储系统的层次结构相比，对象、对象存储和容器在本质上是平面的 —— 这使得它们在存储规模巨大时访问速度很快。”
对象存储可以扩展到很多 PB 字节大小，以适应巨大的数据集，因此它是图像、音频、视频、日志、备份、和分析服务所使用的数据存储的最佳选择。
### 结论
现在你已经知道了各种类型的存储以及它们的用处。后面我们将继续研究这个主题的更多内容，敬请关注。
---
via: <https://www.linux.com/blog/2018/9/know-your-storage-block-file-object>
作者：[Swapnil Bhartiya](https://www.linux.com/users/arnieswap) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
SMPlayer：增强版的媒体播放器
|
Aquil Roshan, Abhishek Prakash
|
https://itsfoss.com/smplayer/
|
SMPlayer 是一款自由开源媒体播放器，它基于强大的 MPlayer 媒体引擎。
|
/data/attachment/album/201812/19/174457nffi8ffybh111wuu.jpg.thumb.jpg
|
/data/attachment/album/201812/19/174457nffi8ffybh111wuu.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"媒体播放器"
] |
分享
|
{
"viewnum": 7820,
"commentnum": 4,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "210.30.193.134",
"message": "VLC做得太好了，以至于对其他播放器没有需求。不过这个SMPlayer看起来也不错，赞！",
"username": "来自210.30.193.134的 Chrome 71.0|GNU/Linux 用户",
"date": "2018-12-19T20:59:12"
},
{
"postip": "125.85.248.59",
"message": "VLC虽然好，但是很难找到完美的皮肤<br />\r\nlinux下面VLC的皮肤总是有各种各样的问题",
"username": "龙尘飘 [Chrome 73.0|Windows 10]",
"date": "2018-12-20T01:18:27"
},
{
"postip": "120.32.104.82",
"message": "gnome自带的totem装了解码器足够我用了@_@",
"username": "来自福建福州的 Firefox 64.0|Fedora 用户",
"date": "2018-12-20T14:04:59"
},
{
"postip": "180.140.0.167",
"message": "win版的VLC全屏看某些视频会频繁出现变色",
"username": "来自广西贵港的 Opera 58.0|Windows 10 用户",
"date": "2019-03-13T12:57:13"
}
] |
[] |
SMPlayer 是一款自由开源媒体播放器，它基于强大的 MPlayer 媒体引擎。
| 2018-12-19T17:44:55 | 2018-12-19T17:44:55 | 10,365 |
/article-10365-1.html
|
当你要播放视频时，你会在[全新安装的 Ubuntu](https://itsfoss.com/things-to-do-after-installing-ubuntu-18-04/)，或其他许多发行版中，会注意到一个消息：
*默认媒体播放器没有适合的编解码器*
这意味着系统上没有安装播放媒体的[所需编解码器](https://packages.ubuntu.com/trusty/ubuntu-restricted-extras)。现在，由于某些版权问题，某些基于 Linux 的操作系统无法在安装介质中预先打包编解码器。但是它们能让你只需点击即可下载和安装编解码器，或者你可以安装拥有所有媒体编解码器的媒体播放器。让我们了解一下 [SMPlayer](https://www.smplayer.info/)。
### 认识 SMPlayer：适用于 Linux 的更好的媒体播放器
SMPlayer 是一款自由开源媒体播放器，它基于强大的 [MPlayer](http://www.mplayerhq.hu/design7/news.html) 媒体引擎。SMPlayer 能够播放 avi、mp4、mkv、mpeg、mov、divx、h.264 以及其他任何主要媒体格式。锦上添花的是，它也可以播放 [YouTube](https://www.youtube.com/) 视频，并且无广告。
SMPlayer 是一个完整的媒体解决方案。它是跨平台的，因此可在所有操作系统上使用。如果你是双启动系统，则可以将其安装在 Windows 和 Linux 操作系统上，以便在两个系统上获得统一的体验。它还支持带触摸的可变形笔记本。
你也可以在 SMPlayer 上播放 YouTube。我知道每次复制粘贴视频 URL 并在外部播放器上播放是不切实际的。但是当你观看相对较长的视频时，SMPlayer 特别有用。SMPlayer 以相当好的质量播放 YouTube 视频，我觉得比在浏览器中播放得更好。通过在 SMPlayer 上播放较长的视频，你可以远离视频中间弹出的插播广告。
如果你在观看没有字幕的电影，你可以直接通过 SMPlayer 下载字幕。它集成了 [opensubtitles.org](https://www.opensubtitles.org/en/search)。所以，打开浏览器，搜索字幕，下载相应的字幕，解压缩，将它们放在视频文件夹中并将字幕连接到电影，这些都不需要！SMPlayer 会为你服务。
SMPlayer 支持 30 多种语言，并可高度自定义。它还有应用主题和大量的图标集。
如果你觉得 SMPlayer 的默认界面看起来不太好，只需点击几下，它就可以看起来像这样：
SMPlayer 为高级用户提供了许多工具和功能。它有均衡器、视频速度控制、宽高比和缩放控制、视频过滤器、屏幕截图等等。
总而言之，我真的很喜欢 SMPlayer。它在一个小巧轻量级的安装包中提供了很多功能。我认为它是 Linux PC 上必备的视频播放器。除了轻松播放所有媒体格式外，它还提供了大量的控制。
### 在 Linux 上安装 SMPlayer
SMPlayer 应该可在所有主要 Linux 发行版的软件中心获取。你可以搜索它并从那里安装它。
在 Ubuntu/ Linux Mint/ Elementary OS 上，你还可以通过在终端中运行以下命令来安装 SMPlayer
```
sudo apt install smplayer
```
或者，你可以在[这里](https://software.opensuse.org/download.html?project=home%3Asmplayerdev&package=smplayer)下载 Fedora、Arch Linux、OpenSUSE 和 Debian 的软件包。
### 总结
有很多像 VLC 媒体播放器那样成熟的播放器。SMPlayer 是拥有完整功能和插件优势的最佳产品之一。我认为它是[必备 Linux 应用](https://itsfoss.com/essential-linux-applications/)之一。
请尝试一下并在下面的评论栏与我们分享你的想法。
---
via: <https://itsfoss.com/smplayer/>
作者：[Aquil Roshan;Abhishek Prakash](https://itsfoss.com/author/aquil/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
极客漫画：聊天机器人
|
Daniel Stori
|
http://turnoff.us/geek/chatbot/
|
对面和你聊天的甚至不是一条狗，而是一段代码。
|
/data/attachment/album/201812/19/182712jtecc8s8cq7l4lot.png.thumb.jpg
|
/data/attachment/album/201812/19/182712jtecc8s8cq7l4lot.png.large.jpg
| false | false | true |
wxy
|
wxy
| false |
[
"漫画",
"聊天机器人"
] |
极客漫画
|
{
"viewnum": 13745,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
对面和你聊天的甚至不是一条狗，而是一段代码。
| 2018-12-19T18:27:50 | 2018-12-19T18:27:50 | 10,366 |
/article-10366-1.html
|
现在聊天机器人技术使用的越来越多了，无论是 Slack 机器人还是 QQ 机器人，甚至还有图灵式的，比如 Siri、微软小冰。很多时候，群里面突然跑来一个机器人，那笨拙而无聊的话术，让人看了令人发噱。有时候，昨天我朋友表示，他的机器人被另外一个机器人搭讪了，然后由于本方的机器人太笨，对方色诱失败，哈哈。
前段时间听说，现在你接到的广告电话都不是人打的了，是自动语音机器人程序了 —— 而在几年前，国外就有一个人开发了一个语音对答机器人，以一个老人的角色和无数的电话销售人员（真人）聊得十分投入，有人到最后也没发现对方是个对答机器人。
所以，对面和你聊天的甚至不是一条狗，而是一段代码。
---
via: <http://turnoff.us/geek/chatbot/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者&点评：[wxy](https://github.com/wxy) 校对&合成：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
如何不重装修复损坏的 Ubuntu 系统
|
Sk
|
https://www.ostechnix.com/how-to-fix-broken-ubuntu-os-without-reinstalling-it/
|
这个简短的教程描述了如何在不丢失数据的情况下轻松修复损坏的 Ubuntu 系统，而无需重新安装。
|
/data/attachment/album/201812/20/221412drfzewj3oj9z5mrb.jpg.thumb.jpg
|
/data/attachment/album/201812/20/221412drfzewj3oj9z5mrb.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Ubuntu"
] |
技术
|
{
"viewnum": 42444,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "203.207.224.110",
"message": "真真是一个坑爹的解答，按照这个文章输入命令之后，我的系统被彻底搞坏了",
"username": "来自北京的 Chrome 73.0|Mac 10.12 用户",
"date": "2019-04-29T09:58:25"
},
{
"postip": "171.15.195.214",
"message": "thx 我的问题解决了 ：之前 /etc/ssh/sshd_config这个文件不存在 现在找回来了！",
"username": "来自河南郑州的 Firefox 68.0|Ubuntu 用户",
"date": "2019-07-21T22:29:01"
}
] |
[] |
这个简短的教程描述了如何在不丢失数据的情况下轻松修复损坏的 Ubuntu 系统，而无需重新安装。
| 2018-12-20T22:14:02 | 2018-12-20T22:14:02 | 10,367 |
/article-10367-1.html
|
今天，我在升级我的 Ubuntu 18.04 LTS 系统。不幸的是，在更新 Ubuntu 时中途断电，系统关机。电源恢复后，我再次启动系统。在登录页面输入密码后，它变成空白并且没有响应。键盘和鼠标也没有作用。我只看到一个空白的屏幕！值得庆幸的是，它只是一台测试机，并且没有重要的数据。我可以直接擦除整个系统然后重新安装。但是，我不想这样做。由于我没有什么可失去的，我只是想不重装修复我损坏的 Ubuntu 系统，并且我成功了！如果你发现自己处于像我这样的境地，不要惊慌。这个简短的教程描述了如何在不丢失数据的情况下轻松修复损坏的 Ubuntu 系统，而无需重新安装。
### 修复损坏的 Ubuntu 系统
首先，尝试使用 live cd 登录并**在外部驱动器中备份数据**。以防这个方法没用，你仍然可以获取数据并重新安装系统！
在登录页上，按下 `CTRL+ALT+F1` 切换到 tty1。你可以在[此处](https://www.ostechnix.com/how-to-switch-between-ttys-without-using-function-keys-in-linux/)了解有关在 TTY 之间切换的更多信息。
现在，逐个输入以下命令来修复损坏的 Ubuntu Linux。
```
$ sudo rm /var/lib/apt/lists/lock
$ sudo rm /var/lib/dpkg/lock
$ sudo rm /var/lib/dpkg/lock-frontend
$ sudo dpkg --configure -a
$ sudo apt clean
$ sudo apt update --fix-missing
$ sudo apt install -f
$ sudo dpkg --configure -a
$ sudo apt upgrade
$ sudo apt dist-upgrade
```
最后，使用命令重启系统：
```
$ sudo reboot
```
你现在可以像往常一样登录到你的 Ubuntu 系统。
我做完这些步骤后，我 Ubuntu 18.04 测试系统中的所有数据都还在，一切都之前的一样。此方法可能不适用于所有人。但是，这个小小的技巧对我有用，并且比重装节省了一些时间。如果你了解其他更好的方法，请在评论区告诉我。我也会在本指南中添加它们。
这是这些了。希望这篇文章有用。
还有更多好东西。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/how-to-fix-broken-ubuntu-os-without-reinstalling-it/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在命令行中步入黑客帝国
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-cmatrix
|
使用 cmatrix 重建每个人都喜欢的 20 世纪 90 年代科幻电影中滚动代码的经典外观。
|
/data/attachment/album/201812/20/222508ds2z288zes8k28s7.png.thumb.jpg
|
/data/attachment/album/201812/20/222508ds2z288zes8k28s7.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"黑客帝国"
] |
分享
|
{
"viewnum": 6676,
"commentnum": 4,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "175.167.136.38",
"message": "没有dnf命令",
"username": "来自辽宁沈阳的 Chrome Mobile 57.0|Android 8.1 用户",
"date": "2018-12-22T19:43:29"
},
{
"postip": "210.30.193.134",
"message": "换成apt试试",
"username": "来自210.30.193.134的 Chrome 71.0|GNU/Linux 用户",
"date": "2018-12-23T13:14:23"
},
{
"postip": "210.30.193.134",
"message": "换成apt试试",
"username": "来自210.30.193.134的 Chrome 71.0|GNU/Linux 用户",
"date": "2018-12-23T13:14:26"
},
{
"postip": "113.90.38.172",
"message": "到底啥卵用？",
"username": "来自广东深圳的 Chrome 54.0|GNU/Linux 用户",
"date": "2019-04-28T13:14:03"
}
] |
[] |
使用 cmatrix 重建每个人都喜欢的 20 世纪 90 年代科幻电影中滚动代码的经典外观。
| 2018-12-20T22:25:05 | 2018-12-20T22:25:05 | 10,368 |
/article-10368-1.html
|
>
> 使用 cmatrix 重建每个人都喜欢的 20 世纪 90 年代科幻电影中滚动代码的经典外观。
>
>
>
这是今天的命令行玩具日历推荐项目。如果这是你第一次访问该系列，你可能想知道什么是命令行玩具？它可以是在命令行中任何可以娱乐的东西，可以是一个游戏，一个有趣的工具，或者一个消遣的东西。
其中一些是经典，有些是全新的（至少对我而言），但我希望你们所有人都能在这个系列中找到你喜欢的东西。
在我们在接近下一年的时候，现在是回顾和期待的好时机。2019 年会为你带来什么？2019 年意味着什么？
我想起 2019 年将是我青少年时期最喜欢的科幻电影之一[黑客帝国](https://en.wikipedia.org/wiki/The_Matrix)的二十周年纪念日，它当时让我思考了未来将会发生什么。对于像我这样的痴迷计算机小孩来说，这是一个电脑程序员通过利用自己思维的力量崛起并成为虚拟宇宙中的动作英雄的终极故事。
当时，对我来说没有比这部电影更具未来感了。无论是故事本身，还是迷人的特效。即使意识到它是在二十多年前拍摄的也并没有改变我的想法。
今天将它带回我们的命令行玩具，让我们在终端用 `cmatrix` 重建黑客帝国中那向下滚动的代码流。 `cmatrix` 很容易安装，它在 Fedora 中被打包了，所以安装它只需：
```
$ dnf install cmatrix
```
接着，只需在你的终端输入 `cmatrix` 即可运行。
你可以在 [GitHub](https://github.com/abishekvashok/cmatrix) 上找到使用 GPL 许可的 `cmatrix` 的源代码。
你有特别喜欢的命令行小玩具需要我介绍的吗？这个系列要介绍的小玩具大部分已经有了落实，但还预留了几个空位置。评论留言让我知道，我会查看的。如果还有空位置，我会考虑介绍它的。如果没有，但如果我得到了一些很好的意见，我会在最后做一些有价值的提及。
了解一下昨天的玩具，[在 Linux 中让 Bash 提示符变得像冬天](https://github.com/abishekvashok/cmatrix)，还有记得明天再来！
---
via: <https://opensource.com/article/18/12/linux-toy-cmatrix>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
我的个人电子邮件系统设置：notmuch、mbsync、Postfix 和 dovecot
|
Copyninja
|
https://copyninja.info/blog/email_setup.html
|
我使用个人电子邮件系统已经相当长的时间了，但是一直没有记录过文档。最近我换了我的笔记本电脑（职业变更导致的变动），我在试图重新创建本地邮件系统时迷茫了。
|
/data/attachment/album/201812/21/071228kqaqj6khjq48k727.jpg.thumb.jpg
|
/data/attachment/album/201812/21/071228kqaqj6khjq48k727.jpg
| true | false | true |
lixinyuxx
|
wxy
| false |
[
"邮件服务",
"邮件"
] |
技术
|
{
"viewnum": 23497,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 2,
"likes": 0
}
|
[] |
[] |
我使用个人电子邮件系统已经相当长的时间了，但是一直没有记录过文档。最近我换了我的笔记本电脑（职业变更导致的变动），我在试图重新创建本地邮件系统时迷茫了。
| 2018-12-21T07:12:41 | 2018-12-21T07:12:41 | 10,369 |
/article-10369-1.html
|
我使用个人电子邮件系统已经相当长的时间了，但是一直没有记录过文档。最近我换了我的笔记本电脑（职业变更导致的变动），我在试图重新创建本地邮件系统时迷茫了。所以这篇文章是一个给自己看的文档，这样我不用费劲就能再次搭建出来。
### 服务器端
我运行自己的邮件服务器，并使用 Postfix 作为 SMTP 服务器，用 Dovecot 实现 IMAP。我不打算详细介绍如何配置这些设置，因为我的设置主要是通过使用 Jonas 为 Redpill 基础架构创建的脚本完成的。什么是 Redpill？（用 Jonas 自己的话说）：
>
> <jonas> Redpill 是一个概念：一种设置 Debian hosts 去跨组织协作的方式
>
>
> <jonas> 我发展了这个概念，并将其首次用于 Redpill 网中网：redpill.dk，其中涉及到了我自己的网络（jones.dk），我的主要客户的网络（homebase.dk），一个包括 Skolelinux Germany（free-owl.de）的在德国的网络，和 Vasudev 的网络（copyninja.info）
>
>
>
除此之外， 我还有一个 dovecot sieve 过滤，根据邮件的来源，对邮件进行高级分类，将其放到各种文件夹中。所有的规则都存在于每个有邮件地址的账户下的 `~/dovecot.sieve` 文件中。
再次，我不会详细介绍如何设置这些东西，因为这不是我这个帖子的目标。
### 在我的笔记本电脑上
在我的笔记本电脑上，我已经按照 4 个部分设置
1. 邮件同步：使用 `mbsync` 命令完成
2. 分类：使用 notmuch 完成
3. 阅读：使用 notmuch-emacs 完成
4. 邮件发送：使用作为中继服务器和 SMTP 客户端运行的 Postfix 完成。
### 邮件同步
邮件同步是使用 `mbsync` 工具完成的， 我以前是 OfflineIMAP 的用户，最近切换到 `mbsync`，因为我觉得它比 OfflineIMAP 的配置更轻量、更简单。该命令是由 isync 包提供的。
配置文件是 `~/.mbsyncrc`。下面是我的例子与一些个人设置。
```
IMAPAccount copyninja
Host imap.copyninja.info
User vasudev
PassCmd "gpg -q --for-your-eyes-only --no-tty --exit-on-status-write-error --batch --passphrase-file ~/path/to/passphrase.txt -d ~/path/to/mailpass.gpg"
SSLType IMAPS
SSLVersion TLSv1.2
CertificateFile /etc/ssl/certs/ca-certificates.crt
IMAPAccount gmail-kamathvasudev
Host imap.gmail.com
User kamathvasudev@gmail.com
PassCmd "gpg -q --for-your-eyes-only --no-tty --exit-on-status-write-error --batch --passphrase-file ~/path/to/passphrase.txt -d ~/path/to/mailpass.gpg"
SSLType IMAPS
SSLVersion TLSv1.2
CertificateFile /etc/ssl/certs/ca-certificates.crt
IMAPStore copyninja-remote
Account copyninja
IMAPStore gmail-kamathvasudev-remote
Account gmail-kamathvasudev
MaildirStore copyninja-local
Path ~/Mail/vasudev-copyninja.info/
Inbox ~/Mail/vasudev-copyninja.info/INBOX
MaildirStore gmail-kamathvasudev-local
Path ~/Mail/Gmail-1/
Inbox ~/Mail/Gmail-1/INBOX
Channel copyninja
Master :copyninja-remote:
Slave :copyninja-local:
Patterns *
Create Both
SyncState *
Sync All
Channel gmail-kamathvasudev
Master :gmail-kamathvasudev-remote:
Slave :gmail-kamathvasudev-local:
# Exclude everything under the internal [Gmail] folder, except the interesting folders
Patterns * ![Gmail]*
Create Both
SyncState *
Sync All
```
对上述配置中的一些有趣部分进行一下说明。一个是 PassCmd，它允许你提供 shell 命令来获取帐户的密码。这样可以避免在配置文件中填写密码。我使用 gpg 的对称加密，并在我的磁盘上存储密码。这当然是由 Unix ACL 保护安全的。
实际上，我想使用我的公钥来加密文件，但当脚本在后台或通过 systemd 运行时，解锁文件看起来很困难 （或者说几乎不可能）。如果你有更好的建议，我洗耳恭听:-)。
下一个指令部分是 Patterns。这使你可以有选择地同步来自邮件服务器的邮件。这对我来说真的很有帮助，可以排除所有的 “[Gmail]/ folders” 垃圾目录。
### 邮件分类
一旦邮件到达你的本地设备，我们需要一种方法来轻松地在邮件读取器中读取邮件。我最初的设置使用本地 dovecot 实例提供同步的 Maildir，并在 Gnus 中阅读。这种设置相比于设置所有的服务器软件是有点大题小作，但 Gnus 无法很好地应付 Maildir 格式，这是最好的方法。这个设置也有一个缺点，那就是在你快速搜索邮件时，要搜索大量邮件。而这就是 notmuch 的用武之地。
notmuch 允许我轻松索引上千兆字节的邮件档案而找到我需要的东西。我已经创建了一个小脚本，它结合了执行 `mbsync` 和 `notmuch`。我使用 dovecot sieve 来基于实际上创建在服务器端的 Maildirs 标记邮件。下面是我的完整 shell 脚本，它执行同步分类和删除垃圾邮件的任务。
```
#!/bin/sh
MBSYNC=$(pgrep mbsync)
NOTMUCH=$(pgrep notmuch)
if [ -n "$MBSYNC" -o -n "$NOTMUCH" ]; then
echo "Already running one instance of mail-sync. Exiting..."
exit 0
fi
echo "Deleting messages tagged as *deleted*"
notmuch search --format=text0 --output=files tag:deleted |xargs -0 --no-run-if-empty rm -v
echo "Moving spam to Spam folder"
notmuch search --format=text0 --output=files tag:Spam and \
to:vasudev@copyninja.info | \
xargs -0 -I {} --no-run-if-empty mv -v {} ~/Mail/vasudev-copyninja.info/Spam/cur
notmuch search --format=text0 --output=files tag:Spam and
to:vasudev-debian@copyninja.info | \
xargs -0 -I {} --no-run-if-empty mv -v {} ~/Mail/vasudev-copyninja.info/Spam/cur
MDIR="vasudev-copyninja.info vasudev-debian Gmail-1"
mbsync -Va
notmuch new
for mdir in $MDIR; do
echo "Processing $mdir"
for fdir in $(ls -d /home/vasudev/Mail/$mdir/*); do
if [ $(basename $fdir) != "INBOX" ]; then
echo "Tagging for $(basename $fdir)"
notmuch tag +$(basename $fdir) -inbox -- folder:$mdir/$(basename $fdir)
fi
done
done
```
因此，在运行 `mbsync` 之前，我搜索所有标记为“deleted”的邮件，并将其从系统中删除。接下来，我在我的帐户上查找标记为“Spam”的邮件，并将其移动到“Spam”文件夹。你没看错，这些邮件逃脱了垃圾邮件过滤器进入到我的收件箱，并被我亲自标记为垃圾邮件。
运行 `mbsync` 后，我基于它们的文件夹标记邮件（搜索字符串 `folder:`）。这让我可以很容易地得到一个邮件列表的内容，而不需要记住列表地址。
### 阅读邮件
现在，我们已经实现同步和分类邮件，是时候来设置阅读部分。我使用 notmuch-emacs 界面来阅读邮件。我使用 emacs 的 Spacemacs 风格，所以我花了一些时间写了一个私有层，它将我所有的快捷键和分类集中在一个地方，而不会扰乱我的整个 `.spacemacs` 文件。你可以在 [notmuch-emacs-layer 仓库](https://source.copyninja.info/notmuch-emacs-layer.git/) 找到我的私有层的代码。
### 发送邮件
能阅读邮件这还不够，我们也需要能够回复邮件。而这是最近是我感到迷茫的一个略显棘手的部分，以至于不得不写这篇文章，这样我就不会再忘记了。（当然也不必在网络上参考一些过时的帖子。）
我的系统发送邮件使用 Postfix 作为 SMTP 客户端，使用我自己的 SMTP 服务器作为它的中继主机。中继的问题是，它不能是具有动态 IP 的主机。有两种方法可以允许具有动态 IP 的主机使用中继服务器， 一种是将邮件来源的 IP 地址放入 `my_network` 或第二个使用 SASL 身份验证。
我的首选方法是使用 SASL 身份验证。为此，我首先要为每台机器创建一个单独的账户，它将把邮件中继到我的主服务器上。想法是不使用我的主帐户 SASL 进行身份验证。（最初我使用的是主账户，但 Jonas 给出了可行的按账户的想法）
```
adduser <hostname>_relay
```
这里替换 `<hostname>` 为你的笔记本电脑的名称或任何你正在使用的设备。现在我们需要调整 Postfix 作为中继服务器。因此，在 Postfix 配置中添加以下行：
```
# SASL authentication
smtp_sasl_auth_enable = yes
smtp_tls_security_level = encrypt
smtp_sasl_tls_security_options = noanonymous
relayhost = [smtp.copyninja.info]:submission
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
```
因此， 这里的 `relayhost` 是用于将邮件转发到互联网的 Postfix 实例的服务器名称。`submission` 的部分 Postfix 将邮件转发到端口 587（安全端口）。`smtp_sasl_tls_security_options` 设置为不允许匿名连接。这是必须的，以便中继服务器信任你的移动主机，并同意为你转发邮件。
`/etc/postfix/sasl_passwd` 是你需要存储用于服务器 SASL 身份验证的帐户密码的文件。将以下内容放入其中。
```
[smtp.example.com]:submission user:password
```
用你已放入 `relayhost` 配置的 SMTP 服务器名称替换 `smtp.example.com`。用你创建的 `<hostname>_relay` 用户及其密码替换 `user` 和 `passwd`。
若要保护 `sasl_passwd` 文件，并为 Postfix 创建它的哈希文件，使用以下命令。
```
chown root:root /etc/postfix/sasl_passwd
chmod 0600 /etc/postfix/sasl_passwd
postmap /etc/postfix/sasl_passwd
```
最后一条命令将创建 `/etc/postfix/sasl_passwd.db` 文件，它是你的文件的 `/etc/postfix/sasl_passwd` 的哈希文件，具有相同的所有者和权限。现在重新加载 Postfix，并使用 `mail` 命令检查邮件是否从你的系统中发出。
### Bonus 的部分
好吧，因为我有一个脚本创建以上结合了邮件的同步和分类。我继续创建了一个 systemd 计时器，以定期同步后台的邮件。就我而言，每 10 分钟一次。下面是 `mailsync.timer` 文件。
```
[Unit]
Description=Check Mail Every 10 minutes
RefuseManualStart=no
RefuseManualStop=no
[Timer]
Persistent=false
OnBootSec=5min
OnUnitActiveSec=10min
Unit=mailsync.service
[Install]
WantedBy=default.target
```
下面是 mailsync.service 服务，这是 mailsync.timer 执行我们的脚本所需要的。
```
[Unit]
Description=Check Mail
RefuseManualStart=no
RefuseManualStop=yes
[Service]
Type=oneshot
ExecStart=/usr/local/bin/mail-sync
StandardOutput=syslog
StandardError=syslog
```
将这些文件置于 `/etc/systemd/user` 目录下并运行以下代码去开启它们：
```
systemctl enable --user mailsync.timer
systemctl enable --user mailsync.service
systemctl start --user mailsync.timer
```
这就是我从系统同步和发送邮件的方式。我从 Jonas Smedegaard 那里了解到了 afew，他审阅了这篇帖子。因此， 下一步， 我将尝试使用 afew 改进我的 notmuch 配置，当然还会有一个后续的帖子:-)。
---
via: <https://copyninja.info/blog/email_setup.html>
作者：[copyninja](https://copyninja.info) 译者：[lixinyuxx](https://github.com/lixinyuxx) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
用户、组及其它 Linux 特性
|
Paul Brown
|
https://www.linux.com/learn/intro-to-linux/2018/7/users-groups-and-other-linux-beasts
|
Linux 和其他类 Unix 操作系统依赖于用户组，而不是逐个为用户分配权限和特权。一个组就是你想象的那样：一群在某种程度上相关的用户。
|
/data/attachment/album/201812/22/002103hsp4ilq194sllpz6.jpg.thumb.jpg
|
/data/attachment/album/201812/22/002103hsp4ilq194sllpz6.jpg
| true | false | true |
lujun9972
|
MjSeven
|
wxy
| false |
[
"用户",
"用户组"
] |
技术
|
{
"viewnum": 5854,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10066,
"displayorder": 0
},
{
"raid": 10399,
"displayorder": 0
}
] |
Linux 和其他类 Unix 操作系统依赖于用户组，而不是逐个为用户分配权限和特权。一个组就是你想象的那样：一群在某种程度上相关的用户。
| 2018-12-22T00:20:52 | 2018-12-22T00:20:52 | 10,370 |
/article-10370-1.html
|
>
> Linux 和其他类 Unix 操作系统依赖于用户组，而不是逐个为用户分配权限和特权。一个组就是你想象的那样：一群在某种程度上相关的用户。
>
>
>
到这个阶段，[在看到如何操作目录或文件夹之后](/article-10066-1.html)，但在让自己一头扎进文件之前，我们必须重新审视 权限、用户 和 组。幸运的是，[有一个网站上已经有了一个优秀而全面的教程，讲到了权限](https://www.linux.com/learn/understanding-linux-file-permissions)，所以你应该去立刻阅读它。简而言之，你使用权限来确定谁可以对文件和目录执行操作，以及他们可以对每个文件和目录执行什么操作 —— 从中读取、写入、移动、擦除等等。
要尝试本教程涵盖的所有内容，你需要在系统上创建新用户。让我们实践起来，为每一个需要借用你电脑的人创建一个用户，我们称之为 `guest` 账户。
**警告：** 例如，如果你错误地删除了自己的用户和目录，那么创建用户，特别是删除用户以及主目录会严重损坏系统。你可能不想在你日常的工作机中练习，那么请在另一台机器或者虚拟机上练习。无论你是否想要安全地练习，经常备份你的东西总是一个好主意。检查备份是否正常工作，为你自己以后避免很多咬牙切齿的事情。
### 一个新用户
你可以使用 `useradd` 命令来创建一个新用户。使用超级用户或 root 权限运行 `useradd`，即使用 `sudo` 或 `su`，这具体取决于你的系统，你可以：
```
sudo useradd -m guest
```
然后输入你的密码。或者也可以这样：
```
su -c "useradd -m guest"
```
然后输入 root 或超级用户的密码。
（ 为了简洁起见，我们将从现在开始假设你使用 `sudo` 获得超级用户或 root 权限。 ）
通过使用 `-m` 参数，`useradd` 将为新用户创建一个主目录。你可以通过列出 `/home/guest` 来查看其内容。
然后你可以使用以下命令来为新用户设置密码：
```
sudo passwd guest
```
或者你也可以使用 `adduser`，这是一个交互式的命令，它会询问你一些问题，包括你要为用户分配的 shell（是的，shell 有不止一种），你希望其主目录在哪里，你希望他们属于哪些组（有关这点稍后会讲到）等等。在运行 `adduser` 结束时，你可以设置密码。注意，默认情况下，在许多发行版中都没有安装 `adduser`，但安装了 `useradd`。
顺便说一下，你可以使用 `userdel` 来移除一个用户：
```
sudo userdel -r guest
```
使用 `-r` 选项，`userdel` 不仅删除了 `guest` 用户，还删除了他们的主目录和邮件中的条目（如果有的话）。
### 主目录中的内容
谈到用户的主目录，它依赖于你所使用的发行版。你可能已经注意到，当你使用 `-m` 选项时，`useradd` 使用子目录填充用户的目录，包括音乐、文档和诸如此类的内容以及各种各样的隐藏文件。要查看 `guest` 主目录中的所有内容，运行 `sudo ls -la /home/guest`。
进入新用户目录的内容通常是由 `/etc/skel` 架构目录确定的。有时它可能是一个不同的目录。要检查正在使用的目录，运行：
```
useradd -D
GROUP=100
HOME=/home
INACTIVE=-1
EXPIRE=
SHELL=/bin/bash
SKEL=/etc/skel
CREATE_MAIL_SPOOL=no
```
这会给你一些额外的有趣信息，但你现在感兴趣的是 `SKEL=/etc/skel` 这一行，在这种情况下，按照惯例，它指向 `/etc/skel/`。
由于 Linux 中的所有东西都是可定制的，因此你可以更改那些放入新创建的用户目录的内容。试试这样做：在 `/etc/skel/` 中创建一个新目录：
```
sudo mkdir /etc/skel/Documents
```
然后创建一个包含欢迎消息的文件，并将其复制过来：
```
sudo cp welcome.txt /etc/skel/Documents
```
现在删除 `guest` 账户:
```
sudo userdel -r guest
```
再次创建：
```
sudo useradd -m guest
```
嘿！你的 `Documents/` 目录和 `welcome.txt` 文件神奇地出现在了 `guest` 的主目录中。
你还可以在创建用户时通过编辑 `/etc/default/useradd` 来修改其他内容。我的看起来像这样：
```
GROUP=users
HOME=/home
INACTIVE=-1
EXPIRE=
SHELL=/bin/bash
SKEL=/etc/skel
CREATE_MAIL_SPOOL=no
```
这些选项大多数都是不言自明的，但让我们仔细看看 `GROUP` 选项。
### 群组心态
Linux 和其他类 Unix 操作系统依赖于用户组，而不是逐个为用户分配权限和特权。一个组就是你想象的那样：一群在某种程度上相关的用户。在你的系统上可能有一组允许使用打印机的用户，他们属于 `lp`（即 “line printer”）组。传统上 `wheel` 组的成员是唯一可以通过使用 `su` 成为超级用户或 root 的成员。`network` 用户组可以启动或关闭网络。还有许多诸如此类的。
不同的发行版有不同的组，具有相同或相似名称的组具有不同的权限，这也取决于你使用的发行版。因此，如果你在前一段中读到的内容与你系统中的内容不匹配，不要感到惊讶。
不管怎样，要查看系统中有哪些组，你可以使用：
```
getent group
```
`getent` 命令列出了某些系统数据库的内容。
要查找当前用户所属的组，尝试：
```
groups
```
当你使用 `useradd` 创建新用户时，除非你另行指定，否则用户将只属于一个组：他们自己。`guest` 用户属于 `guest` 组。组使用户有权管理自己的东西，仅此而已。
你可以使用 `groupadd` 命令创建新组，然后添加用户：
```
sudo groupadd photos
```
例如，这将创建 `photos` 组。下一次，我们将使用它来构建一个共享目录，该组的所有成员都可以读取和写入，我们将更多地了解权限和特权。敬请关注！
---
via: <https://www.linux.com/learn/intro-to-linux/2018/7/users-groups-and-other-linux-beasts>
作者：[Paul Brown](https://www.linux.com/users/bro66) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
持续集成与部署的 3 个最佳实践
|
Austin Dewey
|
https://opensource.com/article/18/11/best-practices-cicd
|
了解自动化，使用 Git 存储库以及参数化 Jenkins 管道。
|
/data/attachment/album/201812/22/095139y6ur04x8c4mx3e6r.png.thumb.jpg
|
/data/attachment/album/201812/22/095139y6ur04x8c4mx3e6r.png
| true | false | true |
lujun9972
|
ChiZelin
|
wxy
| false |
[
"CI",
"CD"
] |
系统运维
|
{
"viewnum": 8478,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
了解自动化，使用 Git 存储库以及参数化 Jenkins 管道。
| 2018-12-22T09:51:35 | 2018-12-22T09:51:35 | 10,371 |
/article-10371-1.html
|
>
> 了解自动化，使用 Git 存储库以及参数化 Jenkins 管道。
>
>
>
本文涵盖了三个关键主题：自动化 CI/CD 配置、使用 Git 存储库处理常见的 CI/CD 工件、参数化 Jenkins 管道。
### 术语
首先，我们定义一些术语。**CI/CD** 是允许团队快速自动化测试、打包、部署其应用程序的实践。它通常通过利用名为 [Jenkins](https://jenkins.io/) 的服务器来实现，该服务器充当 CI/CD 协调器。Jenkins 侦听特定输入（通常是代码签入后的 Git 挂钩），并在触发时启动一个管道。
<ruby> 管道 <rt> pipeline </rt></ruby> 由开发和/或运营团队编写的代码组成，这些代码指导 Jenkins 在 CI/CD 过程中采取哪些操作。这个流水线通常类似于“构建我的代码，然后测试我的代码，如果这些测试通过，则把我的应用程序部署到下一个最高环境（通常是开发、测试或生产环境）”。组织通常具有更复杂的管道，并入了诸如工件存储库和代码分析器之类的工具，这里提供了一个高级示例。
现在我们了解了关键术语，让我们深入研究一些最佳实践。
### 1、自动化是关键
要在 PaaS 上运行 CI/CD，需要在集群上配置适当的基础设施。在这个例子中，我将使用 [OpenShift](https://www.openshift.com/)。
“Hello, World” 的实现很容易实现。简单地运行 `oc new-app jenkins-<persistent/ephemeral>`，然后，你就有了一个已经就绪的运行中的 Jenkins 服务器了。然而，在企业中的使用要复杂得多。除了 Jenkins 服务器之外，管理员通常还需要部署代码分析工具（如 SonarQube）和工件库（如 Nexus）。然后，它们必须创建管道来执行 CI/CD 和 Jenkins 从服务器，以减少主服务器的负载。这些实体中的大多数都由 OpenShift 资源支持，需要创建这些资源来部署所需的 CI/CD 基础设施。
最后，部署 CI/CD 组件所需要的手动步骤可能是需要重复进行的，而且你可能不想成为执行那些重复步骤的人。为了确保结果能够像以前一样快速、无错误和准确地产生，应该在创建基础设施的方式中结合自动化方法。这可以是一个 Ansible 剧本、一个 Bash 脚本，或者任何您希望自动化 CI/CD 基础设施部署的其它方式。我已经使用 [Ansible](https://docs.ansible.com/) 和 [OpenShift-Applier](https://github.com/redhat-cop/openshift-applier) 角色来自动化我的实现。您可能会发现这些工具很有价值，或者您可能会发现其他一些对您和组织更有效的工具。无论哪种方式，您都将发现自动化显著地减少了重新创建 CI/CD 组件所需的工作量。
#### 配置 Jenkins 主服务器
除了一般的“自动化”之外，我想单独介绍一下 Jenkins 主服务器，并讨论管理员如何利用 OpenShift 来自动化配置 Jenkins。来自 [Red Hat Container Catalog](https://access.redhat.com/containers/?tab=overview#/registry.access.redhat.com/openshift3/jenkins-2-rhel7) 的 Jenkins 镜像已经安装了 [OpenShift-Sync plugin](https://github.com/openshift/jenkins-sync-plugin)。在 [该视频](https://www.youtube.com/watch?v=zlL7AFWqzfw) 中，我们将讨论如何使用这个插件来创建 Jenkins 管道和从设备。
要创建 Jenkins 管道，请创建一个类似于下面的 OpenShift BuildConfig：
```
apiVersion: v1
kind: BuildConfig
...
spec:
source:
git:
ref: master
uri: <repository-uri>
...
strategy:
jenkinsPipelineStrategy:
jenkinsfilePath: Jenkinsfile
type: JenkinsPipeline
```
OpenShift-Sync 插件将注意到已经创建了带有 `jenkinsPipelineStrategy` 策略的 BuildConfig，并将其转换为 Jenkins 管道，从 Git 源指定的 Jenkinsfile 中提取。也可以使用内联 Jenkinsfile，而不是从 Git 存储库中提取。有关更多信息，请参阅[文档](https://docs.openshift.com/container-platform/3.11/dev_guide/dev_tutorials/openshift_pipeline.html#the-pipeline-build-config)。
要创建 Jenkins 从站，请创建一个 OpenShift ImageStream，它从以下定义开始：
```
apiVersion: v1
kind: ImageStream
metadata:
annotations:
slave-label: jenkins-slave
labels:
role: jenkins-slave
...
```
注意在这个 ImageStream 中定义的元数据。OpenShift-Sync 插件将把带有标签 `role: jenkins-slave` 的任何 ImageStream 转换为 Jenkins 从站。Jenkins 从站将以 `slave-label` 注释中的值命名。
ImageStreams 对于简单的 Jenkins 从属配置工作得很好，但是一些团队会发现有必要配置一些细节详情，比如资源限制、准备就绪和活动性探测，以及实例上限。这就是 ConfigMap 发挥作用的地方：
```
apiVersion: v1
kind: ConfigMap
metadata:
labels:
role: jenkins-slave
...
data:
template1: |-
<Kubernetes pod template>
```
注意，仍然需要角色：`jenkins-slave` 标签来将 ConfigMap 转换为 Jenkins 从站。Kubernetes pod 模板由一长段 XML 组成，它将根据组织的喜好配置每个细节。要查看此 XML，以及有关将 ImageStreams 和 ConfigMaps 转换为 Jenkins 从站的更多信息，请参阅[文档](https://docs.openshift.com/container-platform/3.11/using_images/other_images/jenkins.html#configuring-the-jenkins-kubernetes-plug-in)。
请注意上面所示的三个示例，其中没有一个操作需要管理员对 Jenkins 控制台进行手动更改。通过使用 OpenShift 资源，可以简单的自动化方式配置 Jenkins。
### 2、分享就是关爱
第二个最佳实践是维护一个公共 CI/CD 工件的 Git 存储库。主要思想是防止团队重新发明轮子。假设您的团队需要执行到 OpenShift 环境的蓝/绿部署，作为管道 CD 阶段的一部分。负责编写管道的团队成员可能不是 OpenShift 专家，也不可能具有从头开始编写此功能的能力。幸运的是，有人已经编写了一个将此功能合并到一个公共 CI/CD 存储库中的函数，因此您的团队可以使用该函数而不是花时间编写一个函数。
为了更进一步，您的组织可能决定维护整个管道。您可能会发现团队正在编写具有相似功能的管道。对于那些团队来说，使用来自公共存储库的参数化管道要比从头开始编写自己的管道更有效。
### 3、少即是多
正如我在前一节中提到的，第三个也是最后一个最佳实践是参数化您的 CI/CD 管道。参数化将防止过多的管道，使您的 CI/CD 系统更容易维护。假设我有多个区域可以部署应用程序。如果没有参数化，我需要为每个区域设置单独的管道。
要参数化一个作为 OpenShift 构建配置编写的管道，请将 `env` 节添加到配置：
```
...
spec:
...
strategy:
jenkinsPipelineStrategy:
env:
- name: REGION
value: US-West
jenkinsfilePath: Jenkinsfile
type: JenkinsPipeline
```
使用此配置，我可以传递 `REGION` 参数给管道以将我的应用程序部署到指定区域。
这有一个[视频](https://www.youtube.com/watch?v=zlL7AFWqzfw)提供了一个更实质性的情况，其中参数化是必须的。一些组织决定把他们的 CI/CD 管道分割成单独的 CI 和 CD 管道，通常是因为在部署之前有一些审批过程。假设我有四个镜像和三个不同的环境要部署。如果没有参数化，我需要 12 个 CD 管道来允许所有部署可能性。这会很快失去控制。为了使 CD 流水线的维护更容易，组织会发现将镜像和环境参数化以便允许一个流水线执行多个流水线的工作会更好。
### 总结
企业级的 CI/CD 往往比许多组织预期的更加复杂。幸运的是，对于 Jenkins，有很多方法可以无缝地提供设置的自动化。维护一个公共 CI/CD 工件的 Git 存储库也会减轻工作量，因为团队可以从维护的依赖项中提取而不是从头开始编写自己的依赖项。最后，CI/CD 管道的参数化将减少必须维护的管道的数量。
如果您找到了其他不可或缺的做法，请在评论中分享。
---
via: <https://opensource.com/article/18/11/best-practices-cicd>
作者：[Austin Dewey](https://opensource.com/users/adewey) 选题：[lujun9972](https://github.com/lujun9972) 译者：[ChiZelin](https://github.com/ChiZelin) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
极客漫画：密室逃脱
|
Daniel Stori
|
http://turnoff.us/geek/escape-room/
|
“密室逃脱”是近年来流行的益智解密游戏。我们的主人公就进入了这样的一个游戏，然而，发现谜题是——如何退出 Vim！！！
|
/data/attachment/album/201812/22/095500lrn0rk05n9889cck.png.thumb.jpg
|
/data/attachment/album/201812/22/095500lrn0rk05n9889cck.png.large.jpg
| false | false | true |
wxy
|
wxy
| false |
[
"Vim",
"漫画"
] |
极客漫画
|
{
"viewnum": 17852,
"commentnum": 5,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "124.160.212.59",
"message": "How do I exit the Vim editor?<br />\r\n到目前为止，取得的成绩如下<br />\r\nAsked 7 years, 1 month ago<br />\r\nActive 26 days ago<br />\r\nViewed 2.0m times",
"username": "来自浙江杭州的 Chrome 76.0|Windows 10 用户",
"date": "2019-09-17T16:16:54"
},
{
"postip": "111.14.14.149",
"message": "Asked 7 years, 8 months ago<br />\r\nActive yesterday<br />\r\nViewed 2.1m times",
"username": "来自山东临沂的 Firefox 75.0|Windows 10 用户",
"date": "2020-04-09T13:12:19"
},
{
"postip": "103.112.78.75",
"message": "Asked 10 years ago<br />\r\nModified today<br />\r\nViewed 2.7m times",
"username": "来自亚太地区的 Chrome 104.0|Mac 10.15 用户",
"date": "2022-08-26T11:32:35"
},
{
"postip": "120.229.64.140",
"message": "Asked 11 years, 6 months ago<br />\r\nModified 1 month ago<br />\r\nViewed 3.0m times",
"username": "来自120.229.64.140的 Chrome 121.0|Windows 10 用户",
"date": "2024-02-02T18:20:46"
},
{
"postip": "120.229.64.140",
"message": "Asked 11 years, 6 months ago<br />\r\nModified 1 month ago<br />\r\nViewed 3.0m times",
"username": "来自120.229.64.140的 Chrome 121.0|Windows 10 用户",
"date": "2024-02-02T18:20:48"
}
] |
[] |
“密室逃脱”是近年来流行的益智解密游戏。我们的主人公就进入了这样的一个游戏，然而，发现谜题是——如何退出 Vim！！！
| 2018-12-22T09:55:24 | 2018-12-22T09:55:24 | 10,372 |
/article-10372-1.html
|
“密室逃脱”是近年来流行的益智解密游戏。我们的主人公就进入了这样的一个游戏，然而，发现谜题是——如何退出 Vim！！！
“如何退出 Vim”这个话题，已经成了众多 Linux 初学者经常听说的一个梗了，比如说，“如何制造乱码？——新手退出 Vim”。
甚至在国外著名的问答网站 Stack Overflow 上，从 2012 年 8 月 6 日，jclancy 发了“[如何退出 Vim 编辑器](https://stackoverflow.com/questions/11828270/how-to-exit-the-vim-editor)”求救。6 年过去了，这个帖子已经有 170 万的阅读了。（2017 年 5 月 24 日，Stack Overflow 官方博客还专门发文纪念了该贴阅读量突破 100 百万次）
---
via: <http://turnoff.us/geek/escape-room/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者 & 点评：[wxy](https://github.com/wxy) 校对 & 合成：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
如何在 Ubuntu 和其他 Linux 发行版上安装 Putty
|
Abhishek Prakash
|
https://itsfoss.com/putty-linux/
|
Putty 不是限定于 Windows 的。你也可以在 Linux 和 macOS 上使用此开源软件。
|
/data/attachment/album/201812/22/181610el1fv5kt7lzee3bd.png.thumb.jpg
|
/data/attachment/album/201812/22/181610el1fv5kt7lzee3bd.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"putty",
"ssh"
] |
分享
|
{
"viewnum": 8749,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "119.97.214.138",
"message": "感觉你说这些的时候肯定没有用过.ssh下的config",
"username": "来自湖北武汉的 Chromium 71.0|Ubuntu 用户",
"date": "2019-02-21T12:04:21"
}
] |
[] |
Putty 不是限定于 Windows 的。你也可以在 Linux 和 macOS 上使用此开源软件。
| 2018-12-22T18:16:07 | 2018-12-22T18:16:07 | 10,373 |
/article-10373-1.html
|
如果我没弄错，[Putty](https://www.putty.org/) 可能是 Windows 最受欢迎的 SSH 客户端。
在 IT 公司中，开发环境通常在远程 Linux 系统上，而开发人员则使用 Windows 作为本地系统。Putty 用于从 Windows 机器连接到远程 Linux 系统。
Putty 不是限定于 Windows 的。你也可以在 Linux 和 macOS 上使用此开源软件。
但是等等！当你已经拥有“真正的” Linux 终端时，为什么要在 Linux 上使用单独的 SSH 客户端？这有几个想在 Linux 上使用 Putty 的原因。
* 你在 Windows 上使用 Putty 已经很久了，你觉得它更舒服。
* 你发现很难手动编辑 SSH 配置文件以保存各种 SSH 会话。你更喜欢 Putty 图形化保存 SSH 连接的方式。
* 你想通过连接到原始套接字和串口进行调试。
无论是什么原因，如果你想在 Ubuntu 或任何其他 Linux 上使用 Putty，你当然可以这样做。让我告诉你如何做到。
### 在 Ubuntu Linux 上安装 Putty
对于 Ubuntu 用户来说，好消息是 Putty 可以在 Ubuntu 的 universe 仓库中找到。
要在 Ubuntu上安装 Putty，首先应确保已启用 universe 仓库。
```
sudo add-apt-repository universe
```
启用 universe 仓库后，应使用以下命令更新 Ubuntu：
```
sudo apt update
```
之后，你可以使用以下命令安装 Putty：
```
sudo apt install putty
```
安装后，你可以在菜单中找到它来启动 Putty。
正如你在下面的截图中看到的，Putty 的 Linux 版本看起来与 Windows 版本相同。这让你松了一口气, 因为你不必再尝试新的设置。
当你输入远程系统的[主机名](https://itsfoss.com/change-hostname-ubuntu/)或 IP 地址并连接到它时，Putty 将使用你已保存在主目录中的 SSH 密钥。
### 在其他 Linux 发行版上安装 Putty
[Putty 可用于 Debian](https://packages.debian.org/jessie/putty)，所以你只需要使用 `apt-get` 或 `aptitude` 来安装它。
```
sudo apt-get install putty
```
Putty 也适用于 Fedora/Red Hat，并可以使用默认的包管理器进行安装。
```
sudo dnf install putty
```
你还可以在基于 Arch Linux 的发行版中轻松安装 Putty。
```
sudo pacman -S putty
```
请记住，Putty 是一款开源软件。如果你真的想要，你也可以通过源代码安装它。你可以从下面的链接获取 Putty 的源代码。
* [下载 Putty 源代码](https://www.chiark.greenend.org.uk/%7Esgtatham/putty/latest.html)
我一直喜欢原生 Linux 终端而不是像 Putty 这样的 SSH 客户端。我觉得 GNOME 终端或 [Terminator](https://launchpad.net/terminator) 更有家的感觉。但是，在 Linux 中使用默认终端或 Putty 是个人选择。
你在 Linux 上管理多个 SSH 连接时使用了什么？
---
via: <https://itsfoss.com/putty-linux/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Bash 环境变量的那些事
|
Paul Brown
|
https://www.linux.com/blog/learn/2018/12/bash-variables-environmental-and-otherwise
|
初学者可以在此教程中了解环境变量。
|
/data/attachment/album/201812/23/151252vyyprdr6bdrioqgy.jpg.thumb.jpg
|
/data/attachment/album/201812/23/151252vyyprdr6bdrioqgy.jpg
| true | false | true |
lujun9972
|
HankChow
|
wxy
| false |
[
"环境变量",
"Bash",
"shell"
] |
技术
|
{
"viewnum": 9221,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
初学者可以在此教程中了解环境变量。
| 2018-12-23T15:12:49 | 2018-12-23T15:12:49 | 10,374 |
/article-10374-1.html
|
>
> 初学者可以在此教程中了解环境变量。
>
>
>
bash 变量，尤其是讨厌的*环境变量*，已经是一个老生常谈的话题了。我们也更应该对它有一个详细的了解，让它为我们所用。
下面就打开终端，开始吧。
### 环境变量
`HOME` （LCTT 译注：双关语）除了是你脱下帽子惬意休息的地方，同时也是 Linux 中的一个变量，它是当前用户主目录的路径：
```
echo $HOME
```
以上这个命令会显示当前用户的主目录路径，通常都在 `/home/<your username>` 下。
顾名思义，变量的值是可以根据上下文变化的。实际上，Linux 系统中每一个用户的 `HOME` 变量都是不一样的，当然你也可以这样自行更改 `HOME` 变量的值：
```
HOME=/home/<your username>/Documents
```
以上这个命令将会把 `HOME` 变量设置为你的 `Documents` 目录。
其中有三点需要留意：
1. `=` 符号和其两侧的内容之间不加空格。空格在 shell 中有专门的意义，不能随意地在任何地方添加空格。
2. 如果你需要对变量进行赋值，只需要使用变量名称就可以了。但如果需要读取或者使用变量的值，需要在变量前面加上一个 `$` 号。
3. 更改 `HOME` 变量具有一定的风险。有很多程序是依赖于 `HOME` 变量的，更改 `HOME` 变量可能会导致一些不可预见的结果。例如，如果按照上面的方式更改了 `HOME` 变量，然后执行不带有任何参数的 `cd` 命令，在通常情况下，会跳转到用户的主目录下，但在这个时候，会跳转到 `HOME` 变量指定的目录下。
上面第 3 点中环境变量的更改并不是持久有效的，在终端关闭后重新打开终端，又或者是新建一个终端，执行 `echo $HOME` 命令输出的仍然会是初始的值，而不是重新自定义的值。
在讨论如何持久地更改一个环境变量之前，我们先来看一下另一个比较重要的环境变量。
### PATH 变量
在 `PATH` 变量中存放了一系列目录，而且是放置了可执行程序的目录。正是由于 `PATH` 变量的存在，让你不需要知道应用程序具体安装到了什么目录，而 shell 却可以正确地找到这些应用程序。
如果你查看 `PATH` 变量的值，大概会是以下这样：
```
$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/bin:/sbin
```
每两个目录之间使用冒号 `:` 分隔。如果某个应用程序的所在目录不在 `PATH` 变量中，那么运行的时候就需要声明应用程序的目录让 shell 能够找到。
```
/home/<user name>/bin/my_program.sh
```
例如以上命令就会执行当前用户 `bin/` 目录下的 `my_program.sh` 文件。
有一个常见的问题：如果你不希望弄乱系统的 `bin/` 目录，同时也不希望你自己的文件被其它人运行，还不想每次运行的时候都要输入完整的路径，那么，你可以在你的主目录中创建一个独立的 `bin/` 目录：
```
mkdir $HOME/bin
```
然后将这个目录添加到 `PATH` 变量中：
```
PATH=$PATH:$HOME/bin
```
然后 `/home/<user name>/bin/` 目录就会出现在 `PATH` 变量中了。但正如之前所说，这个变更只会在当前的 shell 生效，当前的 shell 一旦关闭，环境变量的值就又恢复原状了。
如果要让变更对当前用户持续生效，就不能在 shell 中直接执行对应的变更，而是应该将这些变更操作写在每次启动 shell 时都会运行的文件当中。这个文件就是当前用户主目录中的 `.bashrc` 文件。文件名前面的点号表明这是一个隐藏文件，执行普通的 `ls` 命令是不会将这个文件显示出来的，但只要在 `ls` 命令中加入 `-a` 参数就可以看到这个文件了。
你可以使用诸如 [kate](https://www.kde.org/applications/utilities/kate/)、[gedit](https://help.gnome.org/users/gedit/stable/)、[nano](https://www.nano-editor.org/) 或者 [vim](https://www.vim.org/) 这些文本编辑器来打开 `.bashrc` 文件（但不要用 LibreOffice Writer，它是一个文字处理软件，跟前面几个文字编辑器完全不同）。打开 `.bashrc` 文件之后，你会看见里面放置了一些 shell 命令，是用于为当前用户设置环境的。
在文件的末尾添加新行并输入以下内容：
```
export PATH=$PATH:$HOME/bin
```
保存并关闭 `.bashrc` 文件，接下来你就会看到 `export` 语句的效果。执行以下的命令让刚才的修改立即生效：
```
source .bashrc
```
刚才执行的 `source` 命令让 `.bashrc` 文件在当前的 shell 立即生效，并且对于之后打开的 shell 都会有效。因此另一个等效的方法是退出并重新进入 shell，但这样也太麻烦了。
现在，你的 shell 就能自动寻找到 `/home/<user name>/bin/` 下的程序了，执行这个目录下的程序也不需要完整地写出程序的路径。
### 自定义变量
当然，你也可以定义自己的变量。刚才我们看到的变量名称都是全大写的，实际上[变量名称的定义还是比较灵活的](https://bash.cyberciti.biz/guide/Rules_for_Naming_variable_name)。
定义新变量的过程非常直观，直接对它赋值就可以了：
```
new_variable="Hello"
```
然后可以用以下的方式读取到已定义变量的值：
```
echo $new_variable
```
程序的正常工作离不开各种变量，例如要将某个选项设置为打开，又或者让程序找到所需的代码库，都需要使用变量。在 bash 中运行程序的时候会生成一个子 shell，这个子 shell 和执行原程序的父 shell 并不是完全一样的，只是继承了父 shell 的部分内容，而且默认是不继承父 shell 中的变量的。因为变量默认情况下是局部变量，出于安全原因，一个 shell 中的局部变量不会被另一个 shell 读取到，即使是子 shell 也不可以。
下面举一个例子。首先定义一个变量：
```
robots="R2D2 & C3PO"
```
然后执行：
```
bash
```
现在是在 bash shell 中创建了一个子 shell。
执行这个命令看看还能不能读取到刚才定义的变量：
```
echo $robots
```
你会发现读取不到。
还是在这个子 shell 中，为 `robots` 变量赋一个不同的值：
```
robots="These aren't the ones you are looking for"
```
再读取一次：
```
$ echo $robots
These aren't the ones you are looking for
```
退出这个子 shell：
```
exit
```
然后再看一下现在 `robots` 变量的值：
```
$ echo $robots
R2D2 & C3P0
```
这一个特性可以有效避免配置过程中产生混乱，同时也会导致一个问题：如果程序中需要设置变量，但却由于子 shell 的原因无法正常访问到这个变量，该如何解决呢？这个时候就需要用到 `export` 了。
重复一次刚才的过程，但这一次不是通过 `robots="R2D2 & C3PO"` 方式来设置变量，而是使用 `export` 命令：
```
export robots="R2D2 & C3PO"
```
现在你会发现，在进入子 shell 之后，`robots` 变量的值仍然是最初赋予的值。
要注意的是，尽管子 shell 会继承通过 `export` 导出的变量，但如果在子 shell 中对这个变量重新赋值，是不会影响到父 shell 中对应变量的。
如果要查看所有通过 `export` 导出的变量，可以执行以下命令：
```
export -p
```
自定义的变量会显示在这个列表的末尾。这个列表中还有一些常见的变量：例如 `USER` 的值是当前用户的用户名，`PWD` 的值是当前用户当前所在的目录，而 `OLDPWD` 的值则是当前用户上一个访问过的目录。因此如果执行：
```
cd -
```
就会切换到上一个访问过的目录，那是因为 `cd` 命令读取到了 `OLDPWD` 变量的值。
你也可以使用 `env` 命令查看所有环境变量。
如果要取消导出一个变量，可以加上 `-n` 参数：
```
export -n robots
```
### 接下来
了解过环境变量的知识之后，你已经到达了可能对自己和他人造成危险的水平，接下来就需要了解如何通过使用别名来让环境变得更安全、更友好以保护自己了。
---
via: <https://www.linux.com/blog/learn/2018/12/bash-variables-environmental-and-otherwise>
作者：[Paul Brown](https://www.linux.com/users/bro66) 选题：[lujun9972](https://github.com/lujun9972) 译者：[HankChow](https://github.com/HankChow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
树莓派在办公室的 11 种用法
|
James Mawson
|
https://blog.dxmtechsupport.com.au/11-uses-for-a-raspberry-pi-around-the-office/
|
它电路板便宜、功耗很小、小到几乎适合任何地方、无限灵活 —— 这实际上是处理办公室一些基本任务的好方法。
|
/data/attachment/album/201812/23/153615u7gylclg77ospl3s.jpg.thumb.jpg
|
/data/attachment/album/201812/23/153615u7gylclg77ospl3s.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"树莓派",
"办公室"
] |
树莓派
|
{
"viewnum": 13811,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
它电路板便宜、功耗很小、小到几乎适合任何地方、无限灵活 —— 这实际上是处理办公室一些基本任务的好方法。
| 2018-12-23T15:36:36 | 2018-12-23T15:36:36 | 10,375 |
/article-10375-1.html
|
我知道你在想什么：树莓派只能用在修修补补、原型设计和个人爱好中。它实际不能用在业务中。
毫无疑问，这台电脑的处理能力相对较低、易损坏的 SD 卡、缺乏电池备份以及支持的 DIY 性质，这意味着它不会是一个能在任何时候执行最关键的操作的[专业的、已安装好、配置好的商业服务器](https://dxmtechsupport.com.au/server-configuration)的可行替代品。
但是它电路板便宜、功耗很小、小到几乎适合任何地方、无限灵活 —— 这实际上是处理办公室一些基本任务的好方法。
而且，更好的是，已经有一些人完成了这些项目并很乐意分享他们是如何做到的。
### DNS 服务器
每次在浏览器中输入网站地址或者点击链接时，都需要将域名转换为数字 IP 地址，然后才能显示内容。
通常这意味着向互联网上某处 DNS 服务器发出请求 —— 但你可以通过本地处理来加快浏览速度。
你还可以分配自己的子域，以便本地访问办公室中的计算机。
[这里了解它是如何工作的。](https://www.1and1.com/digitalguide/server/configuration/how-to-make-your-raspberry-pi-into-a-dns-server/)
### 厕所占用标志
在厕所排过队吗？
这对于那些等待的人来说很烦人，花在处理它上面的时间会耗费你在办公室的工作效率。
我想你希望在办公室里也悬挂飞机上那个厕所有人的标志。
[Occu-pi](https://blog.usejournal.com/occu-pi-the-bathroom-of-the-future-ed69b84e21d5) 是一个非常简单的解决方案，使用磁性开关和树莓派来判断螺栓何时关闭，并在 Slack 频道中更新“厕所在使用中” —— 这意味着整个办公室的人都可以看一眼电脑或者移动设备知道是否有空闲的隔间。
### 针对黑客的蜜罐陷阱
黑客破坏了网络的第一个线索是一些事情变得糟糕，这应该会吓到大多数企业主。
这就是可以用到蜜罐的地方：一台没有任何服务的计算机位于你的网络，将特定端口打开，伪装成黑客喜欢的目标。
安全研究人员经常在网络外部部署蜜罐，以收集攻击者正在做的事情的数据。
但对于普通的小型企业来说，这些作为一种绊脚石部署在内部更有用。因为普通用户没有真正的理由想要连接到蜜罐，所以任何发生的登录尝试都是正在进行捣乱的非常好的指示。
这可以提供对外部人员入侵的预警，并且也可以提供对值得信赖的内部人员的预警。
在较大的客户端/服务器网络中，将它作为虚拟机运行可能更为实用。但是在无线路由器上运行的点对点的小型办公室/家庭办公网络中，[HoneyPi](https://trustfoundry.net/honeypi-easy-honeypot-raspberry-pi/) 之类的东西是一个很小的防盗报警器。
### 打印服务器
联网打印机更方便。
但更换所有打印机可能会很昂贵 —— 特别是如果你对现有的打印机感到满意的话。
[将树莓派设置为打印服务器](https://opensource.com/article/18/3/print-server-raspberry-pi)可能会更有意义。
### 网络附加存储（NAS）
将硬盘变为 NAS 是树莓派最早的实际应用之一，并且它仍然是最好的之一。
[这是如何使用树莓派创建 NAS。](https://howtoraspberrypi.com/create-a-nas-with-your-raspberry-pi-and-samba/)
### 工单服务器
想要在预算不足的情况下在服务台中支持工单？
有一个名为 osTicket 的完全开源的工单程序，它可以安装在你的树莓派上，它甚至还有[随时可用的 SD 卡镜像](https://everyday-tech.com/a-raspberry-pi-ticketing-system-image-with-osticket/)。
### 数字标牌
无论是用于活动、广告、菜单还是其他任何东西，许多企业都需要一种显示数字标牌的方式 —— 而树莓派的廉价和省电使其成为一个非常有吸引力的选择。
[这有很多可供选择的选项。](https://blog.capterra.com/7-free-and-open-source-digital-signage-software-options-for-your-next-event/)
### 目录和信息亭
[FullPageOS](https://github.com/guysoft/FullPageOS) 是一个基于 Raspbian 的 Linux 发行版，它直接引导到 Chromium 的全屏版本 —— 这非常适合导购、图书馆目录等。
### 基本的内联网 Web 服务器
对于托管一个面向公众的网站，你最好有一个托管帐户。树莓派不适合面对真正的网络流量。
但对于小型办公室，它可以托管内部业务维基或基本的公司内网。它还可以用作沙箱环境，用于试验代码和服务器配置。
[这里是如何在树莓派上运行 Apache、MySQL 和 PHP。](https://maker.pro/raspberry-pi/projects/raspberry-pi-web-server)
### 渗透测试器
Kali Linux 是专为探测网络安全漏洞而构建的操作系统。通过将其安装在树莓派上，你就拥有了一个超便携式穿透测试器，其中包含 600 多种工具。
[你可以在这里找到树莓派镜像的种子链接。](https://www.offensive-security.com/kali-linux-arm-images/)
绝对要小心只在你自己的网络或你有权对它安全审计的网络中使用它 —— 使用此方法来破解其他网络是严重的犯罪行为。
### VPN 服务器
当你外出时，依靠的是公共无线互联网，你无法控制还有谁在网络中、谁在窥探你的所有流量。这就是为什么通过 VPN 连接加密所有内容可以让人放心。
你可以订阅任意数量的商业 VPN 服务，并且你可以在云中安装自己的服务，但是在办公室运行一个 VPN，这样你也可以从任何地方访问本地网络。
对于轻度使用 —— 比如偶尔的商务旅行 —— 树莓派是一种强大的，节约能源的设置 VPN 服务器的方式。（首先要检查一下你的路由器是不是不支持这个功能，许多路由器是支持的。）
[这是如何在树莓派上安装 OpenVPN。](https://medium.freecodecamp.org/running-your-own-openvpn-server-on-a-raspberry-pi-8b78043ccdea)
### 无线咖啡机
啊，美味：好喝的饮料是神赐之物，也是公司内工作效率的支柱。
那么，为什么不[将办公室的咖啡机变成可以精确控制温度和无线连接的智能咖啡机呢？](https://www.techradar.com/au/how-to/how-to-build-your-own-smart-coffee-machine)
---
via: <https://blog.dxmtechsupport.com.au/11-uses-for-a-raspberry-pi-around-the-office/>
作者：[James Mawson](https://blog.dxmtechsupport.com.au/author/james-mawson/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
量子计算的开源框架 Cirq 介绍
|
Avimanyu Bandyopadhyay
|
https://itsfoss.com/qunatum-computing-cirq-framework/
|
本文通过使用 Cirq 的一个开源视角，尝试去了解我们已经在量子计算领域取得多大的成就，和该领域的发展方向，以加快科学和技术研究。
|
/data/attachment/album/201812/24/123112eddhzdhpuedhwvhz.jpg.thumb.jpg
|
/data/attachment/album/201812/24/123112eddhzdhpuedhwvhz.jpg
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"量子计算",
"Cirq"
] |
技术
|
{
"viewnum": 8144,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "171.83.52.214",
"message": "aaaa",
"username": "来自湖北武汉的 Chrome 53.0|GNU/Linux 用户",
"date": "2018-12-30T08:49:25"
}
] |
[] |
本文通过使用 Cirq 的一个开源视角，尝试去了解我们已经在量子计算领域取得多大的成就，和该领域的发展方向，以加快科学和技术研究。
| 2018-12-24T12:34:00 | 2018-12-24T12:34:00 | 10,376 |
/article-10376-1.html
|
我们即将讨论的内容正如标题所示，本文通过使用 Cirq 的一个开源视角，尝试去了解我们已经在量子计算领域取得多大的成就，和该领域的发展方向，以加快科学和技术研究。
首先，我们将引领你进入量子计算的世界。在我们深入了解 Cirq 在未来的量子计算中扮演什么样的重要角色之前，我们将尽量向你解释其背后的基本概念。你最近可能听说过，在这个领域中有件重大新闻，就是 Cirq。在这篇开放科学栏目的文章中，我们将去尝试找出答案。
在我们开始了解量子计算之前，必须先去了解“量子”这个术语，量子是已知的 [亚原子粒子](https://en.wikipedia.org/wiki/Subatomic_particle) 中最小的物质。<ruby> <a href="https://en.wikipedia.org/wiki/Quantum"> 量子 </a> <rt> Quantum </rt></ruby> 这个词来自拉丁语 Quantus，意思是 “有多小”，在下面的短视频链接中有描述：
为了易于我们理解量子计算，我们将<ruby> 量子计算 <rt> Quantum Computing </rt></ruby>与<ruby> 经典计算 <rt> Classical Computing </rt></ruby>（LCTT 译注：也有译做“传统计算”）进行比较。经典计算是指今天的传统计算机如何设计工作的，正如你现在用于阅读本文的设备，就是我们所谓的经典计算设备。
### 经典计算
经典计算只是描述计算机如何工作的另一种方式。它们通过一个二进制系统工作，即信息使用 1 或 0 来存储。经典计算机不会理解除 1 或 0 之外的任何其它东西。
直白来说，在计算机内部一个晶体管只能是开（1）或关（0）。我们输入的任何信息都被转换为无数个 1 和 0，以便计算机能理解和存储。所有的东西都只能用无数个 1 和 0 的组合来表示。
### 量子计算
然而，量子计算不再像经典计算那样遵循 “开或关” 的模式。而是，借助量子的名为 [叠加和纠缠](https://www.clerro.com/guide/491/quantum-superposition-and-entanglement-explained) 的两个现象，能同时处理信息的多个状态，因此能以更快的速率加速计算，并且在信息存储方面效率更高。
请注意，叠加和纠缠 [不是同一个现象](https://physics.stackexchange.com/questions/148131/can-quantum-entanglement-and-quantum-superposition-be-considered-the-same-phenom)。
就像在经典计算中，我们有<ruby> 比特 <rt> bit </rt></ruby>，在量子计算中，我们相应也有<ruby> 量子比特 <rt> qubit </rt></ruby>（即 Quantum bit）。想了解它们二者之间的巨大差异之处，请查看这个 [页面](http://www.rfwireless-world.com/Terminology/Difference-between-Bit-and-Qubit.html)，从那里的图片中可以得到答案。
量子计算机并不是来替代我们的经典计算机的。但是，有一些非常巨大的任务用我们的经典计算机是无法完成的，而那些正是量子计算机大显身手的好机会。下面链接的视频详细描述了上述情况，同时也描述了量子计算机的原理。
下面的视频全面描述了量子计算领域到目前为止的最新进展：
### 嘈杂中型量子
根据最新更新的（2018 年 7 月 31 日）研究论文，术语 “<ruby> 嘈杂 <rt> Noisy </rt></ruby>” 是指由于对量子比特未能完全控制所产生的不准确性。正是这种不准确性在短期内严重制约了量子设备实现其目标。
“中型” 指的是在接下来的几年中，量子计算机将要实现的量子规模大小，届时，量子比特的数目将可能从 50 到几百个不等。50 个量子比特是一个重大的量程碑，因为它将超越现有的最强大的 [超级计算机](https://www.explainthatstuff.com/how-supercomputers-work.html) 的 [暴力破解](https://en.wikipedia.org/wiki/Proof_by_exhaustion) 所能比拟的计算能力。更多信息请阅读 [这里的](https://arxiv.org/abs/1801.00862) 论文。
随着 Cirq 出现，许多事情将会发生变化。
### Cirq 是什么？
Cirq 是一个 Python 框架，它用于创建、编辑和调用我们前面讨论的嘈杂中型量子（NISQ）。换句话说，Cirq 能够解决挑战，去改善精确度和降低量子计算中的噪声。
Cirq 并不需要必须有一台真实的量子计算机。Cirq 能够使用一个类似模拟器的界面去执行量子电路模拟。
Cirq 的前进步伐越来越快了，[Zapata](https://www.xconomy.com/san-francisco/2018/07/19/google-partners-with-zapata-on-open-source-quantum-computing-effort/) 是使用它的首批用户之一，Zapata 是由来自哈佛大学的专注于量子计算的[一群科学家](https://www.zapatacomputing.com/about/)在去年成立的。
### Linux 上使用 Cirq 入门
开源的 [Cirq 库](https://github.com/quantumlib/Cirq) 开发者建议将它安装在像 [virtualenv](https://virtualenv.pypa.io) 这样的一个 [虚拟 Python 环境](https://itsfoss.com/python-setup-linux/) 中。在 Linux 上的开发者安装指南可以在 [这里](https://cirq.readthedocs.io/en/latest/install.html#installing-on-linux) 找到。
但我们在 Ubuntu 16.04 的系统上成功地安装和测试了 Python3 的 Cirq 库，安装步骤如下：
#### 在 Ubuntu 上安装 Cirq
首先，我们需要 `pip` 或 `pip3` 去安装 Cirq。[Pip](https://pypi.org/project/pip/) 是推荐用于安装和管理 Python 包的工具。
对于 Python 3.x 版本，Pip 能够用如下的命令来安装：
```
sudo apt-get install python3-pip
```
Python3 包能够通过如下的命令来安装：
```
pip3 install <package-name>
```
我们继续去使用 Pip3 为 Python3 安装 Cirq 库：
```
pip3 install cirq
```
#### 启用 Plot 和 PDF 生成（可选）
可选系统的依赖没有被 Pip 安装的，可以使用如下命令去安装它：
```
sudo apt-get install python3-tk texlive-latex-base latexmk
```
* python3-tk 是 Python 自有的启用了绘图功能的图形库
* texlive-latex-base 和 latexmk 启动了 PDF 输出功能。
最后，我们使用如下的命令和代码成功测试了 Cirq：
```
python3 -c 'import cirq; print(cirq.google.Foxtail)'
```
我们得到的输出如下图：
#### 为 Cirq 配置 Pycharm IDE
我们也配置了一个 Python IDE [PyCharm](https://itsfoss.com/install-pycharm-ubuntu/) 去测试同样的结果：
因为在我们的 Linux 系统上为 Python3 安装了 Cirq，我们在 IDE 中配置项目解释器路径为：
```
/usr/bin/python3
```
在上面的输出中，你可能注意到我们刚设置的项目解释器路径与测试程序文件（`test.py`）的路径显示在一起。退出代码 0 表示程序已经成功退出，没有错误。
因此，那是一个已经就绪的 IDE 环境，你可以导入 Cirq 库去开始使用 Python 去编程和模拟量子电路。
#### Cirq 使用入门
Criq 入门的一个好的开端就是它 GitHub 页面上的 [示例](https://github.com/quantumlib/Cirq/tree/master/examples)。
Cirq 的开发者在 GitHub 上已经放置了学习 [教程](https://github.com/quantumlib/Cirq/blob/master/docs/tutorial.md)。如果你想认真地学习量子计算，他们推荐你去看一本非常好的书，它是[由 Nielsen 和 Chuang 写的名为 《量子计算和量子信息》](http://mmrc.amss.cas.cn/tlb/201702/W020170224608149940643.pdf)。
#### OpenFermion-Cirq
[OpenFermion](http://openfermion.org) 是一个开源库，它是为了在量子计算机上模拟获取和操纵代表的费米系统（包含量子化学）。根据 [粒子物理学](https://en.wikipedia.org/wiki/Particle_physics) 理论，按照 [费米—狄拉克统计](https://en.wikipedia.org/wiki/Fermi-Dirac_statistics)，费米系统与 [费米子](https://en.wikipedia.org/wiki/Fermion) 的产生相关。
OpenFermion 被称为从事 [量子化学](https://en.wikipedia.org/wiki/Quantum_chemistry) 的化学家和研究人员的 [一个极好的实践工具](https://phys.org/news/2018-03-openfermion-tool-quantum-coding.html)。量子化学主要专注于 [量子力学](https://en.wikipedia.org/wiki/Quantum_mechanics) 在物理模型和化学系统实验中的应用。量子化学也被称为 [分子量子力学](https://ocw.mit.edu/courses/chemical-engineering/10-675j-computational-quantum-mechanics-of-molecular-and-extended-systems-fall-2004/lecture-notes/)。
Cirq 的出现使 OpenFermion 通过提供程序和工具去扩展功能成为了可能，通过使用 Cirq 可以去编译和构造仿真量子电路。
#### Google Bristlecone
2018 年 3 月 5 日，在洛杉矶举行的一年一度的 [美国物理学会会议](http://meetings.aps.org/Meeting/MAR18/Content/3475) 上，Google 发布了 [Bristlecone](https://techcrunch.com/2018/03/05/googles-new-bristlecone-processor-brings-it-one-step-closer-to-quantum-supremacy/)，这是他们的最新的量子处理器。这个 [基于门的超导系统](https://en.wikipedia.org/wiki/Superconducting_quantum_computing) 为 Google 提供了一个测试平台，用以研究 [量子比特技术](https://research.googleblog.com/2015/03/a-step-closer-to-quantum-computation.html) 的 [系统错误率](https://en.wikipedia.org/wiki/Quantum_error_correction) 和 [扩展性](https://en.wikipedia.org/wiki/Scalability) ，以及在量子 [仿真](https://research.googleblog.com/2017/10/announcing-openfermion-open-source.html)、[优化](https://research.googleblog.com/2016/06/quantum-annealing-with-digital-twist.html) 和 [机器学习](https://arxiv.org/abs/1802.06002) 方面的应用。
Google 希望在不久的将来，能够制造出它的 [云可访问](https://www.computerworld.com.au/article/644051/google-launches-quantum-framework-cirq-plans-bristlecone-cloud-move/) 的 72 个量子比特的 Bristlecone 量子处理器。Bristlecone 将越来越有能力完成一个经典超级计算机无法在合理时间内完成的任务。
Cirq 将让研究人员直接在云上为 Bristlecone 写程序变得很容易，它提供了一个非常方便的、实时的、量子编程和测试的接口。
Cirq 将允许我们去：
* 量子电路的微调管理
* 使用原生门去指定 [门](https://en.wikipedia.org/wiki/Logic_gate) 行为
* 在设备上放置适当的门
* 并调度这个门的时刻
### 开放科学关于 Cirq 的观点
我们知道 Cirq 是在 GitHub 上开源的，在开源科学社区之外，特别是那些专注于量子研究的人们，都可以通过高效率地合作，通过开发新方法，去降低现有量子模型中的错误率和提升精确度，以解决目前在量子计算中所面临的挑战。
如果 Cirq 不走开源模型的路线，事情可能变得更具挑战。一个伟大的创举可能就此错过，我们可能在量子计算领域止步不前。
### 总结
最后我们总结一下，我们首先通过与经典计算相比较，介绍了量子计算的概念，然后是一个非常重要的视频来介绍了自去年以来量子计算的最新发展。接着我们简单讨论了嘈杂中型量子，也就是为什么要特意构建 Cirq 的原因所在。
我们看了如何在一个 Ubuntu 系统上安装和测试 Cirq。我们也在一个更好用的 IDE 环境中做了安装测试，并使用一些资源去开始学习有关概念。
最后，我们看了两个示例 OpenFermion 和 Bristlecone，介绍了在量子计算中，Cirq 在开发研究中具有什么样的基本优势。最后我们以 Open Science 社区的视角对 Cirq 进行了一些精彩的思考，结束了我们的话题。
我们希望能以一种易于理解的方式向你介绍量子计算框架 Cirq 的使用。如果你有与此相关的任何反馈，请在下面的评论区告诉我们。感谢阅读，希望我们能在开放科学栏目的下一篇文章中再见。
---
via: <https://itsfoss.com/qunatum-computing-cirq-framework/>
作者：[Avimanyu Bandyopadhyay](https://itsfoss.com/author/avimanyu/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
命令别名：定义自己的命令
|
Paul Brown
|
https://www.linux.com/blog/learn/2018/12/aliases-diy-shell-commands
|
学习如何创建别名：你可以将太长或难以记忆的命令打包成你自己构建的命令。
|
/data/attachment/album/201812/24/125355ud71kkwkk54w4oe5.jpg.thumb.jpg
|
/data/attachment/album/201812/24/125355ud71kkwkk54w4oe5.jpg
| true | false | true |
lujun9972
|
HankChow
|
wxy
| false |
[
"别名",
"alias"
] |
技术
|
{
"viewnum": 4665,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10918,
"displayorder": 0
}
] |
学习如何创建别名：你可以将太长或难以记忆的命令打包成你自己构建的命令。
| 2018-12-24T12:53:53 | 2018-12-24T12:53:53 | 10,377 |
/article-10377-1.html
|
>
> 学习如何创建别名：你可以将太长或难以记忆的命令打包成你自己构建的命令。
>
>
>
<ruby> 命令别名 <rt> Alias </rt></ruby>在 Linux shell 中指的是将一些太长或者太难记的多个命令组合起来，成为一个由用户自己构建的命令。
可以通过 `alias` 命令来创建命令别名。在 `alias` 后面跟上想要创建的别名名称、一个等号（`=`），以及希望使用这个别名来执行的命令，这样一个命令别名就创建好了。举个例子，`ls` 命令在默认情况下是不会对输出的内容进行着色的，这样就不能让用户一眼分辨出目录、文件和连接了。对此，可以创建这样一个命令别名，在输出目录内容的时候为输出内容着色：
```
alias lc='ls --color=auto'
```
其中 `lc` 是自定义的命令别名，代表 “list with color” 的意思。在创建命令别名的时候，需要先确认使用的别名是不是已经有对应的命令了，如果有的话，原本的命令就会被覆盖掉了。注意，定义命令别名的时候，`=` 两端是没有空格的。当运行 `lc` 的时候，就相当于执行了 `ls --color` 命令。
此后，执行 `lc` 列出目录内容的时候，就会输出带有着色的内容了。
你可能会发现你在执行 `ls` 的时候，本来就是输出带有着色的内容。那是因为大部分 Linux 发行版都已经将 `ls` 设定为带有着色的命令别名了。
### 可以直接使用的命令别名
实际上，执行不带任何内容的 `alias` 命令就可以看到当前已经设定的所有命令别名。对于不同的发行版，包含的命令别名不尽相同，但普遍都会有以下这些命令别名：
* `alias ls='ls --color=auto'`：这个命令别名在前面已经提到过了。`--color=auto` 参数会让 `ls` 命令在通过标准输出在终端中显示内容时进行着色，而其它情况（例如通过管道输出到文件）下则不进行着色。`--color` 这个参数还可以设置为 `always` 或`never`。
* `alias cp='cp -i'`：`-i` 参数代表“<ruby> 交互 <rt> interactive </rt></ruby>”。在使用 `cp` 命令复制文件的时候，可能会无意中覆盖现有的文件，在使用了 `-i` 参数之后，`cp` 命令会在一些关键操作前向用户发出询问。
* `alias free='free -m'`：在 `free` 命令后面加上 `-m` 参数，就可以将输出的内存信息以 MiB 这个更方面阅读和计算的单位输出，而不是默认的 Byte 单位。
你使用的发行版自带的命令别名可能多多少少和上面有些差别。但你都可以在命令前面加上 `\` 修饰符来使用命令的最基本形式（而不是别名）。例如：
```
\free
```
就是直接执行 `free`，而不是 `free -m`。还有：
```
\ls
```
执行的就是不带有`--color=auto` 参数的 `ls`。
如果想要持久地保存命令别名，可以在 `.bashrc` 文件中进行修改，而它[来源于我们的 /etc/skel 目录](/article-10370-1.html)。
### 使用命令别名纠正错误
各种发行版的设计者都会尽量设置用户可能需要用到的命令别名。但是不同的用户的习惯各不相同，一些用户可能刚从其它操作系统迁移到 Linux，而不同操作系统的基本命令又因 shell 而异。因此，对于刚从 Windows/MS-DOS 系统迁移到 Linux 系统的用户，不妨使用
```
alias dir='ls'
```
这个命令别名来列出目录内容。
类似地，
```
alias copy='cp'
alias move='mv'
```
也可以在尚未完全熟悉 Linux 的时候用得顺手。
还有一种情况，就是在经常出现输入错误的场合中做出容错，例如，对于我来说， Administration 这个单词就很难快速正确地输入，因此很多用户都会设置类似这样的别名：
```
alias sl='ls'
```
以及
```
alias gerp='echo "You did it *again*!"; grep'
```
`grep` 命令最基本的用途就是在文件中查找字符串，在熟悉这个命令之后，它一定是最常用的命令之一，因此输入错误导致不得不重输命令就很令人抓狂。
在上面 `gerp` 的例子中，包含的不只是一条命令，而是两条。第一条命令 `echo "You did it *again*!"` 输出了一条提醒用户拼写错误的消息，然后使用分号（`；`）把两条命令隔开，再往后才是 `grep` 这一条正确的命令。
在我的系统上使用 `gerp` 来搜索 `/etc/skel/.bashrc` 中包含“alias”这个单词的行，就会输出以下内容：
```
$ gerp -R alias /etc/skel/.bashrc
You did it *again*!
alias ls='ls --color=auto'
alias grep='grep --colour=auto'
alias egrep='egrep --colour=auto'
alias fgrep='fgrep --colour=auto'
alias cp="cp -i"
alias df='df -h'
alias free='free -m'
alias np='nano -w PKGBUILD'
alias more=less
shopt -s expand_aliases
```
在命令别名中以固定的顺序执行多个命令，甚至更进一步，把多个命令串连起来，让后面的命令可以使用到前面的命令的执行结果。这样的做法已经非常接近 bash 脚本了。这篇文章已经接近尾声，我们将在下一篇文章中详细介绍。
如果想要删除在终端中临时设置的别名，可以使用 `unalias` 命令。
```
unalias gerp
```
如果想要持久保存命令别名，可以将命令别名放在用户主目录的 `.bashrc` 文件中，具体的方法在[上一篇文章](/article-10374-1.html)中已经介绍过。
---
via: <https://www.linux.com/blog/learn/2018/12/aliases-diy-shell-commands>
作者：[Paul Brown](https://www.linux.com/users/bro66) 选题：[lujun9972](https://github.com/lujun9972) 译者：[HankChow](https://github.com/HankChow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
通过询问-响应身份认证提高桌面登录安全
|
Nabooengineer
|
https://fedoramagazine.org/login-challenge-response-authentication/
|
有时候，生产环境会采用通过 Yubikey 使用一次性密码（OTP）的设置，然而，在家庭或个人的系统上，你可能更喜欢询问-响应设置。一切都是本地的，这种方法不需要通过远程网络调用。
|
/data/attachment/album/201812/24/134303a0p8zidc8lar81pn.png.thumb.jpg
|
/data/attachment/album/201812/24/134303a0p8zidc8lar81pn.png
| true | false | true |
lujun9972
|
hopefully2333
|
wxy
| false |
[
"登录",
"OTP",
"Yubikey"
] |
桌面应用
|
{
"viewnum": 4811,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
有时候，生产环境会采用通过 Yubikey 使用一次性密码（OTP）的设置，然而，在家庭或个人的系统上，你可能更喜欢询问-响应设置。一切都是本地的，这种方法不需要通过远程网络调用。
| 2018-12-24T13:42:58 | 2018-12-24T13:42:58 | 10,378 |
/article-10378-1.html
|
### 介绍
今天，Fedora 提供了多种方式来提高我们账户的身份认证的安全性。当然，它有我们熟悉的用户名密码登录方式，它也同样提供了其他的身份认证选项，比如生物识别、指纹、智能卡、一次性密码，甚至是<ruby> 询问-响应 <rt> challenge-response </rt></ruby>身份认证。
每种认证方式都有明确的优缺点。这点本身就可以成为一篇相当冗长的文章的主题。Fedora 杂志之前就已经介绍过了这其中的一些选项：
* [在 Fedora 中使用 YubiKey4](https://fedoramagazine.org/using-the-yubikey4-with-fedora/)
* [Fedora 28：在 OpenSSH 中更好的支持智能卡](https://fedoramagazine.org/fedora-28-better-smart-card-support-openssh/)
在现在的 Fedora 版本中，最安全的方法之一就是离线硬件询问-响应。它也同样是最容易部署的方法之一。下面是具体方法。
### 询问-响应认证
从技术上来讲，当你输入密码的时候，你就正在响应用户名询问。离线的询问、响应包含了这些部分：首先是需要你的用户名，接下来，Fedora 会要你提供一个加密的物理硬件的令牌。令牌会把另一个其存储的加密密钥通过<ruby> 可插入式身份认证 <rt> Pluggable Authentication Module </rt></ruby>模块（PAM）框架来响应询问。最后，Fedora 才会提示你输入密码。这可以防止其他人仅仅使用了找到的硬件令牌，或是只使用了账户名密码而没有正确的加密密钥。
这意味着除了你的账户名密码之外，你必须事先在你的操作系统中注册了一个或多个加密硬件令牌。你必须保证你的物理硬件令牌能够匹配你的用户名。
一些询问-响应的方法，比如一次性密码（OTP），在硬件令牌上获取加密的代码密钥，然后将这个密钥通过网络传输到远程身份认证服务器。然后这个服务器会告诉 Fedora 的 PAM 框架，这是否是该用户的一个有效令牌。如果身份认证服务器在本地网络上，这个方法非常好。但它的缺点是如果网络连接断开或是你在没有网的远程端工作。你会被锁在系统之外，直到你能通过网络连接到身份认证服务器。
有时候，生产环境会采用通过 Yubikey 使用一次性密码（OTP）的设置，然而，在家庭或个人的系统上，你可能更喜欢询问-响应设置。一切都是本地的，这种方法不需要通过远程网络调用。下面这些过程适用于 Fedora 27、28 和 29.
### 准备
#### 硬件令牌密钥
首先，你需要一个安全的硬件令牌密钥。具体来说，这个过程需要一个 Yubikey 4、Yubikey NEO，或者是最近发布的、同样支持 FIDO2 的 Yubikey 5 系列设备。你应该购买它们中的两个，一个做备份，以避免其中一个丢失或遭到损坏。你可以在不同的工作地点使用这些密钥。较为简单的 FIDO 和 FIDO U2F 版本不适用于这个过程，但是非常适合使用 FIDO 的在线服务。
#### 备份、备份，以及备份
接下来，为你所有的重要数据制作备份，你可能想在克隆在 VM 里的 Fedora 27/28/29 里测试配置，来确保你在设置你自己的个人工作环境之前理解这个过程。
#### 升级，然后安装
现在，确定你的 Fedora 是最新的，然后通过 `dnf` 命令安装所需要的 Fedora Yubikey 包。
```
$ sudo dnf upgrade
$ sudo dnf install ykclient* ykpers* pam_yubico*
```
如果你使用的是 VM 环境，例如 Virtual Box，确保 Yubikey 设备已经插进了 USB 口，然后允许 VM 控制的 USB 访问 Yubikey。
### 配置 Yubikey
确认你的账户访问到了 USB Yubikey：
```
$ ykinfo -v
version: 3.5.0
```
如果 Yubikey 没有被检测到，会出现下面这些错误信息：
```
Yubikey core error: no yubikey present
```
接下来，通过下面这些 `ykpersonalize` 命令初始化你每个新的 Yubikey。这将设置 Yubikey 配置插槽 2 使用 HMAC-SHA1 算法（即使少于 64 个字符）进行询问响应。如果你已经为询问响应设置好了你的 Yubikey。你就不需要再次运行 `ykpersonalize` 了。
```
ykpersonalize -2 -ochal-resp -ochal-hmac -ohmac-lt64 -oserial-api-visible
```
一些用户在使用的时候将 YubiKey 留在了他们的工作站上，甚至用于对虚拟机进行询问-响应。然而，为了更好的安全性，你可能会更愿意使用手动触发 YubiKey 来响应询问。
要添加手动询问按钮触发器，请添加 `-ochal-btn-trig` 选项，这个选项可以使得 Yubikey 在请求中闪烁其 LED。等待你在 15 秒内按下硬件密钥区域上的按钮来生成响应密钥。
```
$ ykpersonalize -2 -ochal-resp -ochal-hmac -ohmac-lt64 -ochal-btn-trig -oserial-api-visible
```
为你的每个新的硬件密钥执行此操作。每个密钥执行一次。完成编程之后，使用下面的命令将 Yubikey 配置存储到 `~/.yubico`：
```
$ ykpamcfg -2 -v
debug: util.c:222 (check_firmware_version): YubiKey Firmware version: 4.3.4
Sending 63 bytes HMAC challenge to slot 2
Sending 63 bytes HMAC challenge to slot 2
Stored initial challenge and expected response in '/home/chuckfinley/.yubico/challenge-9992567'.
```
如果你要设置多个密钥用于备份，请将所有的密钥设置为相同，然后使用 `ykpamcfg` 工具存储每个密钥的询问-响应。如果你在一个已经存在的注册密钥上运行 `ykpersonalize` 命令，你就必须再次存储配置信息。
### 配置 /etc/pam.d/sudo
现在要去验证配置是否有效，**在同一个终端窗口中**，你需要设置 `sudo` 来要求使用 Yubikey 的询问-响应。将下面这几行插入到 `/etc/pam.d/sudo` 文件中。
```
auth required pam_yubico.so mode=challenge-response
```
将上面的 `auth` 行插入到文件中的 `auth include system-auth` 行的上面，然后保存并退出编辑器。在默认的 Fedora 29 设置中，`/etc/pam.d/sudo` 应该像下面这样：
```
#%PAM-1.0
auth required pam_yubico.so mode=challenge-response
auth include system-auth
account include system-auth
password include system-auth
session optional pam_keyinit.so revoke
session required pam_limits.so
session include system-auth
```
**保持这个初始的终端窗口打开**，然后打开一个新的终端窗口进行测试，在新的终端窗口中输入：
```
$ sudo echo testing
```
你应该注意到了 Yubikey 上的 LED 在闪烁。点击 Yubikey 按钮，你应该会看见一个输入 `sudo` 密码的提示。在你输入你的密码之后，你应该会在终端屏幕上看见 “testing” 的字样。
现在去测试确保失败也正常，启动另一个终端窗口，并从 USB 插口中拔掉 Yubikey。使用下面这条命令验证，在没有 Yubikey 的情况下，`sudo` 是否会不再正常工作。
```
$ sudo echo testing fail
```
你应该立刻被提示输入 `sudo` 密码，但即使你输入了正确密码，登录也应该失败。
### 设置 Gnome 桌面管理器（GDM）
一旦你的测试完成后，你就可以为图形登录添加询问-响应支持了。将你的 Yubikey 再次插入进 USB 插口中。然后将下面这几行添加到 `/etc/pam.d/gdm-password` 文件中：
```
auth required pam_yubico.so mode=challenge-response
```
打开一个终端窗口，然后运行下面这些命令。如果需要，你可以使用其他的编辑器：
```
$ sudo vi /etc/pam.d/gdm-password
```
你应该看到 Yubikey 上的 LED 在闪烁，按下 Yubikey 按钮，然后在提示符处输入密码。
修改 `/etc/pam.d/gdm-password` 文件，在已有的 `auth substack password-auth` 行上添加新的行。这个文件的顶部应该像下面这样：
```
auth [success=done ignore=ignore default=bad] pam_selinux_permit.so
auth required pam_yubico.so mode=challenge-response
auth substack password-auth
auth optional pam_gnome_keyring.so
auth include postlogin
account required pam_nologin.so
```
保存更改并退出编辑器，如果你使用的是 vi，输入键是按 `Esc` 键，然后在提示符处输入 `wq!` 来保存并退出。
### 结论
现在注销 GNOME。将 Yubikey 插入到 USB 口，在图形登录界面上点击你的用户名。Yubikey LED 会开始闪烁。触摸那个按钮，你会被提示输入你的密码。
如果你丢失了 Yubikey，除了重置密码之外，你还可以使用备份的 Yubikey。你还可以给你的账户增加额外的 Yubikey 配置。
如果有其他人获得了你的密码，他们在没有你的物理硬件 Yubikey 的情况下，仍然不能登录。恭喜！你已经显著提高了你的工作环境登录的安全性了。
---
via: <https://fedoramagazine.org/login-challenge-response-authentication/>
作者：[nabooengineer](https://fedoramagazine.org/author/nabooengineer/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[hopefully2333](https://github.com/hopefully2333) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何构建一台网络引导服务器（一）
|
Gregory Bartholomew
|
https://fedoramagazine.org/how-to-build-a-netboot-server-part-1/
|
网络引导 服务器能够被配置为基于网络去提供一个完整的操作系统，以便于客户端计算机从一个中央位置获取配置。
|
/data/attachment/album/201812/24/234952f3k3rr8zpw6873p3.jpg.thumb.jpg
|
/data/attachment/album/201812/24/234952f3k3rr8zpw6873p3.jpg
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"网络引导"
] |
技术
|
{
"viewnum": 7277,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10396,
"displayorder": 0
}
] |
网络引导 服务器能够被配置为基于网络去提供一个完整的操作系统，以便于客户端计算机从一个中央位置获取配置。
| 2018-12-24T23:49:49 | 2018-12-24T23:49:49 | 10,379 |
/article-10379-1.html
|
有些计算机网络需要在各个物理机器上维护相同的软件和配置。学校的计算机实验室就是这样的一个环境。 [网络引导](https://en.wikipedia.org/wiki/Network_booting) 服务器能够被配置为基于网络去提供一个完整的操作系统，以便于客户端计算机从一个中央位置获取配置。本教程将向你展示构建一台网络引导服务器的一种方法。
本教程的第一部分将包括创建一台网络引导服务器和镜像。第二部分将展示如何去添加 Kerberos 验证的家目录到网络引导配置中。
### 初始化配置
首先去下载 Fedora 服务器的 [netinst](https://dl.fedoraproject.org/pub/fedora/linux/releases/28/Server/x86_64/iso/) 镜像，将它刻录到一张光盘上，然后用它引导服务器来重新格式化。我们只需要一个典型的 Fedora Server 的“最小化安装”来作为我们的开端，安装完成后，我们可以使用命令行去添加我们需要的任何额外的包。
>
> 注意：本教程中我们将使用 Fedora 28。其它版本在“最小化安装”中包含的包可能略有不同。如果你使用的是不同的 Fedora 版本，如果一个预期的文件或命令不可用，你可能需要做一些调试。
>
>
>
最小化安装的 Fedora Server 运行起来之后，以 root 用户登入：
```
$ sudo -i
```
并设置主机名字：
```
$ MY_HOSTNAME=server-01.example.edu
$ hostnamectl set-hostname $MY_HOSTNAME
```
>
> 注意：Red Hat 建议静态和临时名字应都要与这个机器在 DNS 中的完全合格域名相匹配，比如 host.example.com（[了解主机名字](https://docs.fedoraproject.org/en-US/Fedora/25/html/Networking_Guide/ch-Configure_Host_Names.html#sec_Understanding_Host_Names)）。
>
>
> 注意：本指南为了方便“复制粘贴”。需要自定义的任何值都声明为一个 `MY_*` 变量，在你运行剩余命令之前，你可能需要调整它。如果你注销之后，变量的赋值将被清除。
>
>
> 注意：Fedora 28 Server 在默认情况下往往会转储大量的日志到控制台上。你可以通过运行命令：`sysctl -w kernel.printk=0` 去禁用控制台日志输出。
>
>
>
接下来，我们需要在我们的服务器上配置一个静态网络地址。运行下面的一系列命令将找到并重新配置你的默认网络连接：
```
$ MY_DNS1=192.0.2.91
$ MY_DNS2=192.0.2.92
$ MY_IP=192.0.2.158
$ MY_PREFIX=24
$ MY_GATEWAY=192.0.2.254
$ DEFAULT_DEV=$(ip route show default | awk '{print $5}')
$ DEFAULT_CON=$(nmcli d show $DEFAULT_DEV | sed -n '/^GENERAL.CONNECTION:/s!.*:\s*!! p')
$ nohup bash << END
nmcli con mod "$DEFAULT_CON" connection.id "$DEFAULT_DEV"
nmcli con mod "$DEFAULT_DEV" connection.interface-name "$DEFAULT_DEV"
nmcli con mod "$DEFAULT_DEV" ipv4.method disabled
nmcli con up "$DEFAULT_DEV"
nmcli con add con-name br0 ifname br0 type bridge
nmcli con mod br0 bridge.stp no
nmcli con mod br0 ipv4.dns $MY_DNS1,$MY_DNS2
nmcli con mod br0 ipv4.addresses $MY_IP/$MY_PREFIX
nmcli con mod br0 ipv4.gateway $MY_GATEWAY
nmcli con mod br0 ipv4.method manual
nmcli con up br0
nmcli con add con-name br0-slave0 ifname "$DEFAULT_DEV" type bridge-slave master br0
nmcli con up br0-slave0
END
```
>
> 注意：上面最后的一组命令被封装到一个 `nohup` 脚本中，因为它将临时禁用网络。这个 `nohup` 命令可以让 `nmcli` 命令运行完成，即使你的 SSH 连接断开。注意，连接恢复可能需要 10 秒左右的时间，如果你改变了服务器 IP 地址，你将需要重新启动一个新的 SSH 连接。
>
>
> 注意：上面的网络配置在默认的连接之上创建了一个 [网桥](https://en.wikipedia.org/wiki/Bridging_(networking))，这样我们在后面的测试中就可以直接运行一个虚拟机实例。如果你不想在这台服务器上去直接测试网络引导镜像，你可以跳过创建网桥的命令，并直接在你的默认网络连接上配置静态 IP 地址。
>
>
>
### 安装和配置 NFS4
从安装 nfs-utils 包开始：
```
$ dnf install -y nfs-utils
```
为发布 NFS 去创建一个顶级的 [伪文件系统](https://www.centos.org/docs/5/html/5.1/Deployment_Guide/s3-nfs-server-config-exportfs-nfsv4.html)，然后在你的网络上共享它：
```
$ MY_SUBNET=192.0.2.0
$ mkdir /export
$ echo "/export -fsid=0,ro,sec=sys,root_squash $MY_SUBNET/$MY_PREFIX" > /etc/exports
```
SELinux 会干扰网络引导服务器的运行。为它配置例外规则超出了本教程中，因此我们这里直接禁用它：
```
$ sed -i '/GRUB_CMDLINE_LINUX/s/"$/ audit=0 selinux=0"/' /etc/default/grub
$ grub2-mkconfig -o /boot/grub2/grub.cfg
$ sed -i 's/SELINUX=enforcing/SELINUX=disabled/' /etc/sysconfig/selinux
$ setenforce 0
```
>
> 注意：应该不需要编辑 grub 命令行，但我们在测试过程中发现，直接编辑 `/etc/sysconfig/selinux` 被证明重启后是无效的，因此这样做再次确保设置了 `selinux=0` 标志。
>
>
>
现在，在本地防火墙中为 NFS 服务添加一个例外规则，然后启动 NFS 服务：
```
$ firewall-cmd --add-service nfs
$ firewall-cmd --runtime-to-permanent
$ systemctl enable nfs-server.service
$ systemctl start nfs-server.service
```
### 创建网络引导镜像
现在我们的 NFS 服务器已经启动运行了，我们需要为它提供一个操作系统镜像，以便于它提供给客户端计算机。我们将从一个非常小的镜像开始，等一切顺利之后再添加。
首先，创建一个存放我们镜像的新目录：
```
$ mkdir /fc28
```
使用 `dnf` 命令在新目录下用几个基础包去构建镜像：
```
$ dnf -y --releasever=28 --installroot=/fc28 install fedora-release systemd passwd rootfiles sudo dracut dracut-network nfs-utils vim-minimal dnf
```
在上面的命令中省略了很重要的 `kernel` 包。在它们被安装完成之前，我们需要去调整一下 `initramfs` 镜像中包含的驱动程序集，`kernel` 首次安装时将自动构建这个镜像。尤其是，我们需要禁用 `hostonly` 模式，以便于 `initramfs` 镜像能够在各种硬件平台上正常工作，并且我们还需要添加对网络和 NFS 的支持：
```
$ echo 'hostonly=no' > /fc28/etc/dracut.conf.d/hostonly.conf
$ echo 'add_dracutmodules+=" network nfs "' > /fc28/etc/dracut.conf.d/netboot.conf
```
现在，安装 `kernel` 包：
```
$ dnf -y --installroot=/fc28 install kernel
```
设置一个阻止 `kernel` 包被更新的规则：
```
$ echo 'exclude=kernel-*' >> /fc28/etc/dnf/dnf.conf
```
设置 locale：
```
$ echo 'LANG="en_US.UTF-8"' > /fc28/etc/locale.conf
```
>
> 注意：如果 locale 没有正确配置，一些程序（如 GNOME Terminal）将无法正常工作。
>
>
>
设置客户端的主机名字：
```
$ MY_CLIENT_HOSTNAME=client-01.example.edu
$ echo $MY_CLIENT_HOSTNAME > /fc28/etc/hostname
```
禁用控制台日志输出：
```
$ echo 'kernel.printk = 0 4 1 7' > /fc28/etc/sysctl.d/00-printk.conf
```
定义网络引导镜像中的本地 `liveuser` 用户：
```
$ echo 'liveuser:x:1000:1000::/home/liveuser:/bin/bash' >> /fc28/etc/passwd
$ echo 'liveuser::::::::' >> /fc28/etc/shadow
$ echo 'liveuser:x:1000:' >> /fc28/etc/group
$ echo 'liveuser:!::' >> /fc28/etc/gshadow
```
允许 `liveuser` 使用 `sudo`：
```
$ echo 'liveuser ALL=(ALL) NOPASSWD: ALL' > /fc28/etc/sudoers.d/liveuser
```
启用自动创建家目录：
```
$ dnf install -y --installroot=/fc28 authselect oddjob-mkhomedir
$ echo 'dirs /home' > /fc28/etc/rwtab.d/home
$ chroot /fc28 authselect select sssd with-mkhomedir --force
$ chroot /fc28 systemctl enable oddjobd.service
```
由于多个客户端将会同时挂载我们的镜像，我们需要去配置镜像工作在只读模式中：
```
$ sed -i 's/^READONLY=no$/READONLY=yes/' /fc28/etc/sysconfig/readonly-root
```
配置日志输出到内存而不是持久存储中：
```
$ sed -i 's/^#Storage=auto$/Storage=volatile/' /fc28/etc/systemd/journald.conf
```
配置 DNS：
```
$ MY_DNS1=192.0.2.91
$ MY_DNS2=192.0.2.92
$ cat << END > /fc28/etc/resolv.conf
nameserver $MY_DNS1
nameserver $MY_DNS2
END
```
绕开编写本教程时存在的根目录只读挂载的 bug（[BZ1542567](https://bugzilla.redhat.com/show_bug.cgi?id=1542567)）：
```
$ echo 'dirs /var/lib/gssproxy' > /fc28/etc/rwtab.d/gssproxy
$ cat << END > /fc28/etc/rwtab.d/systemd
dirs /var/lib/systemd/catalog
dirs /var/lib/systemd/coredump
END
```
最后，为我们镜像创建 NFS 文件系统，并将它共享到我们的子网中：
```
$ mkdir /export/fc28
$ echo '/fc28 /export/fc28 none bind 0 0' >> /etc/fstab
$ mount /export/fc28
$ echo "/export/fc28 -ro,sec=sys,no_root_squash $MY_SUBNET/$MY_PREFIX" > /etc/exports.d/fc28.exports
$ exportfs -vr
```
### 创建引导加载器
现在，我们已经有了可以进行网络引导的操作系统，我们需要一个引导加载器去从客户端系统上启动它。在本教程中我们使用的是 [iPXE](https://ipxe.org/)。
>
> 注意：本节和接下来的节使用 QEMU 测试，也能在另外一台单独的计算机上来完成；它们并不需要在网络引导服务器上来运行。
>
>
>
安装 `git` 并使用它去下载 iPXE：
```
$ dnf install -y git
$ git clone http://git.ipxe.org/ipxe.git $HOME/ipxe
```
现在我们需要去为我们的引导加载器创建一个指定的启动脚本：
```
$ cat << 'END' > $HOME/ipxe/init.ipxe
#!ipxe
prompt --key 0x02 --timeout 2000 Press Ctrl-B for the iPXE command line... && shell ||
dhcp || exit
set prefix file:///linux
chain ${prefix}/boot.cfg || exit
END
```
启动 “file” 下载协议：
```
$ echo '#define DOWNLOAD_PROTO_FILE' > $HOME/ipxe/src/config/local/general.h
```
安装 C 编译器以及相关的工具和库：
```
$ dnf groupinstall -y "C Development Tools and Libraries"
```
构建引导加载器：
```
$ cd $HOME/ipxe/src
$ make clean
$ make bin-x86_64-efi/ipxe.efi EMBED=../init.ipxe
```
记下新编译的引导加载器的存储位置。我们将在接下来的节中用到它：
```
$ IPXE_FILE="$HOME/ipxe/src/bin-x86_64-efi/ipxe.efi"
```
### 用 QEMU 测试
这一节是可选的，但是你需要去复制下面显示在物理机器上的 [EFI 系统分区](https://en.wikipedia.org/wiki/EFI_system_partition) 的布局，在网络引导时需要去配置它们。
>
> 注意：如果你想实现一个完全的无盘系统，你也可以复制那个文件到一个 TFTP 服务器，然后从 DHCP 上指向那台服务器。
>
>
>
为了使用 QEMU 去测试我们的引导加载器，我们继续去创建一个仅包含一个 EFI 系统分区和我们的启动文件的、很小的磁盘镜像。
从创建 EFI 系统分区所需要的目录布局开始，然后把我们在前面节中创建的引导加载器复制进去：
```
$ mkdir -p $HOME/esp/efi/boot
$ mkdir $HOME/esp/linux
$ cp $IPXE_FILE $HOME/esp/efi/boot/bootx64.efi
```
下面的命令将识别我们的引导加载器镜像正在使用的内核版本，并将它保存到一个变量中，以备后续的配置命令去使用它：
```
$ DEFAULT_VER=$(ls -c /fc28/lib/modules | head -n 1)
```
定义我们的客户端计算机将使用的引导配置：
```
$ MY_DNS1=192.0.2.91
$ MY_DNS2=192.0.2.92
$ MY_NFS4=server-01.example.edu
$ cat << END > $HOME/esp/linux/boot.cfg
#!ipxe
kernel --name kernel.efi \${prefix}/vmlinuz-$DEFAULT_VER initrd=initrd.img ro ip=dhcp rd.peerdns=0 nameserver=$MY_DNS1 nameserver=$MY_DNS2 root=nfs4:$MY_NFS4:/fc28 console=tty0 console=ttyS0,115200n8 audit=0 selinux=0 quiet
initrd --name initrd.img \${prefix}/initramfs-$DEFAULT_VER.img
boot || exit
END
```
>
> 注意：上面的引导脚本展示了如何使用 iPXE 去网络引导 Linux 的最小示例。还可以做更多更复杂的配置。值得注意的是，iPXE 支持交互式引导菜单，它可以让你配置默认选项和超时时间。比如，一个更高级一点 iPXE 脚本可以默认从本地磁盘引导一个操作系统，如果在倒计时结束之前用户按下了一个键，才会去网络引导一个操作系统。
>
>
>
复制 Linux 内核并分配 initramfs 给 EFI 系统分区：
```
$ cp $(find /fc28/lib/modules -maxdepth 2 -name 'vmlinuz' | grep -m 1 $DEFAULT_VER) $HOME/esp/linux/vmlinuz-$DEFAULT_VER
$ cp $(find /fc28/boot -name 'init*' | grep -m 1 $DEFAULT_VER) $HOME/esp/linux/initramfs-$DEFAULT_VER.img
```
我们最终的目录布局应该看起来像下面的样子：
```
esp
├── efi
│ └── boot
│ └── bootx64.efi
└── linux
├── boot.cfg
├── initramfs-4.18.18-200.fc28.x86_64.img
└── vmlinuz-4.18.18-200.fc28.x86_64
```
要让 QEMU 去使用我们的 EFI 系统分区，我们需要去创建一个小的 `uefi.img` 磁盘镜像来包含它，然后将它连接到 QEMU 作为主引导驱动器。
开始安装必需的工具：
```
$ dnf install -y parted dosfstools
```
现在创建 `uefi.img` 文件，并将 `esp` 目录中的文件复制进去：
```
$ ESP_SIZE=$(du -ks $HOME/esp | cut -f 1)
$ dd if=/dev/zero of=$HOME/uefi.img count=$((${ESP_SIZE}+5000)) bs=1KiB
$ UEFI_DEV=$(losetup --show -f $HOME/uefi.img)
$ parted ${UEFI_DEV} -s mklabel gpt mkpart EFI FAT16 1MiB 100% toggle 1 boot
$ mkfs -t msdos ${UEFI_DEV}p1
$ mkdir -p $HOME/mnt
$ mount ${UEFI_DEV}p1 $HOME/mnt
$ cp -r $HOME/esp/* $HOME/mnt
$ umount $HOME/mnt
$ losetup -d ${UEFI_DEV}
```
>
> 注意：在物理计算机上，你只需要从 `esp` 目录中复制文件到计算机上已存在的 EFI 系统分区中。你不需要使用 `uefi.img` 文件去引导物理计算机。
>
>
> 注意：在一个物理计算机上，如果文件名已存在，你可以重命名 `bootx64.efi` 文件，如果你重命名了它，就需要去编辑计算机的 BIOS 设置，并添加重命令后的 efi 文件到引导列表中。
>
>
>
接下来我们需要去安装 qemu 包：
```
$ dnf install -y qemu-system-x86
```
允许 QEMU 访问我们在本教程“初始化配置”一节中创建的网桥：
```
$ echo 'allow br0' > /etc/qemu/bridge.conf
```
创建一个 `OVMF_VARS.fd` 镜像的副本去保存我们虚拟机的持久 BIOS 配置：
```
$ cp /usr/share/edk2/ovmf/OVMF_VARS.fd $HOME
```
现在，启动虚拟机：
```
$ qemu-system-x86_64 -machine accel=kvm -nographic -m 1024 -drive if=pflash,format=raw,unit=0,file=/usr/share/edk2/ovmf/OVMF_CODE.fd,readonly=on -drive if=pflash,format=raw,unit=1,file=$HOME/OVMF_VARS.fd -drive if=ide,format=raw,file=$HOME/uefi.img -net bridge,br=br0 -net nic,model=virtio
```
如果一切顺利，你将看到类似下图所示的结果：
你可以使用 `shutdown` 命令关闭虚拟机回到我们的服务器上：
```
$ sudo shutdown -h now
```
>
> 注意：如果出现了错误或虚拟机挂住了，你可能需要启动一个新的 SSH 会话去连接服务器，使用 `kill` 命令去终止 `qemu-system-x86_64` 进程。
>
>
>
### 镜像中添加包
镜像中添加包应该是一个很简单的问题，在服务器上 `chroot` 进镜像，然后运行 `dnf install <package_name>`。
在网络引导镜像中并不限制你能安装什么包。一个完整的图形化安装应该能够完美地工作。
下面是一个如何将最小化安装的网络引导镜像变成完整的图形化安装的示例：
```
$ for i in dev dev/pts dev/shm proc sys run; do mount -o bind /$i /fc28/$i; done
$ chroot /fc28 /usr/bin/bash --login
$ dnf -y groupinstall "Fedora Workstation"
$ dnf -y remove gnome-initial-setup
$ systemctl disable sshd.service
$ systemctl enable gdm.service
$ systemctl set-default graphical.target
$ sed -i 's/SELINUX=enforcing/SELINUX=disabled/' /etc/sysconfig/selinux
$ logout
$ for i in run sys proc dev/shm dev/pts dev; do umount /fc28/$i; done
```
可选地，你可能希望去启用 `liveuser` 用户的自动登录：
```
$ sed -i '/daemon/a AutomaticLoginEnable=true' /fc28/etc/gdm/custom.conf
$ sed -i '/daemon/a AutomaticLogin=liveuser' /fc28/etc/gdm/custom.conf
```
---
via: <https://fedoramagazine.org/how-to-build-a-netboot-server-part-1/>
作者：[Gregory Bartholomew](https://fedoramagazine.org/author/glb/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何使用 Fedora IoT 点亮 LED 灯
|
Alessio Ciregia
|
https://fedoramagazine.org/turnon-led-fedora-iot/
|
如果你喜欢 Fedora、容器，而且有一块树莓派，那么这三者结合操控 LED 会怎么样？本文介绍的是 Fedora IoT，将展示如何在树莓派上安装预览镜像。还将学习如何与 GPIO 交互以点亮 LED。
|
/data/attachment/album/201812/25/002456eqq5cypt46lqayhs.jpg.thumb.jpg
|
/data/attachment/album/201812/25/002456eqq5cypt46lqayhs.jpg
| true | false | true |
lujun9972
|
ScarboroughCoral
|
wxy
| false |
[
"IoT",
"LED"
] |
树莓派
|
{
"viewnum": 7340,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
如果你喜欢 Fedora、容器，而且有一块树莓派，那么这三者结合操控 LED 会怎么样？本文介绍的是 Fedora IoT，将展示如何在树莓派上安装预览镜像。还将学习如何与 GPIO 交互以点亮 LED。
| 2018-12-25T00:24:54 | 2018-12-25T00:24:54 | 10,380 |
/article-10380-1.html
|
如果你喜欢 Fedora、容器，而且有一块树莓派，那么这三者结合操控 LED 会怎么样？本文介绍的是 Fedora IoT，将展示如何在树莓派上安装预览镜像。还将学习如何与 GPIO 交互以点亮 LED。
### 什么是 Fedora IoT?
Fedora IoT 是当前 Fedora 项目的目标之一，计划成为一个完整的 Fedora 版本。Fedora IoT 将是一个在 ARM（目前仅限 aarch64）设备上（例如树莓派），以及 x86\_64 架构上运行的系统。
Fedora IoT 基于 OSTree 开发，就像 [Fedora Silverblue](https://teamsilverblue.org/) 和以往的 [Atomic Host](https://www.projectatomic.io/)。
### 下载和安装 Fedora IoT
官方 Fedora IoT 镜像将和 Fedora 29 一起发布。但是在此期间你可以下载 [基于 Fedora 28 的镜像](https://kojipkgs.fedoraproject.org/compose/iot/latest-Fedora-IoT-28/compose/IoT/) 来进行这个实验。（LCTT 译注：截止至本译文发布，[Fedora 29 已经发布了](https://fedoramagazine.org/announcing-fedora-29/)，但是 IoT 版本并未随同发布，或许会在 Fedora 30 一同发布？）
你有两种方法来安装这个系统：要么使用 `dd` 命令烧录 SD 卡，或者使用 `fedora-arm-installer` 工具。Fedora 的 Wiki 里面提供了为 IoT [设置物理设备](https://fedoraproject.org/wiki/InternetOfThings/GettingStarted#Setting_up_a_Physical_Device) 的更多信息。另外，你可能需要调整第三个分区的大小。
把 SD 卡插入到设备后，你需要创建一个用户来完成安装。这个步骤需要串行连接或一个 HDMI 显示器和键盘来与设备进行交互。
当系统安装完成后，下一步就是要设置网络连接。使用你刚才创建的用户登录系统，可以使用下列方式之一完成网络连接设置：
* 如果你需要手动配置你的网络，可能需要执行类似如下命令，需要保证设置正确的网络地址：
```
$ nmcli connection add con-name cable ipv4.addresses \
192.168.0.10/24 ipv4.gateway 192.168.0.1 \
connection.autoconnect true ipv4.dns "8.8.8.8,1.1.1.1" \
type ethernet ifname eth0 ipv4.method manual
```
* 如果你网络上运行着 DHCP 服务，可能需要类似如下命令：
```
$ nmcli con add type ethernet con-name cable ifname eth0
```
### Fedora 中的 GPIO 接口
许多关于 Linux 上 GPIO 的教程都关注传统的 GPIO sysfis 接口。这个接口已经不推荐使用了，并且上游 Linux 内核社区由于安全和其他问题的缘故打算完全删除它。
Fedora 已经不将这个传统的接口编译到内核了，因此在系统上没有 `/sys/class/gpio` 这个文件。此教程使用一个上游内核提供的一个新的字符设备 `/dev/gpiochipN` 。这是目前和 GPIO 交互的方式。
为了和这个新设备进行交互，你需要使用一个库和一系列命令行界面的工具。常用的命令行工具比如说 `echo` 和 `cat` 在此设备上无法正常工作。
你可以通过安装 libgpiod-utils 包来安装命令行界面工具。python3-libgpiod 包提供了相应的 Python 库。
### 使用 Podman 来创建一个容器
[Podman](https://github.com/containers/libpod) 是一个容器运行环境，其命令行界面类似于 Docker。Podman 的一大优势是它不会在后台运行任何守护进程。这对于资源有限的设备尤其有用。Podman 还允许您使用 systemd 单元文件启动容器化服务。此外，它还有许多其他功能。
我们使用如下两步来创建一个容器：
1. 创建包含所需包的分层镜像。
2. 使用分层镜像创建一个新容器。
首先创建一个 Dockerfile 文件，内容如下。这些内容告诉 Podman 基于可使用的最新 Fedora 镜像来构建我们的分层镜像。然后就是更新系统和安装一些软件包：
```
FROM fedora:latest
RUN dnf -y update
RUN dnf -y install libgpiod-utils python3-libgpiod
```
这样你就完成了镜像的生成前的配置工作，这个镜像基于最新的 Fedora，而且包含了和 GPIO 交互的软件包。
现在你就可以运行如下命令来构建你的基本镜像了：
```
$ sudo podman build --tag fedora:gpiobase -f ./Dockerfile
```
你已经成功创建了你的自定义镜像。这样以后你就可以不用每次都重新搭建环境了，而是基于你创建的镜像来完成工作。
### 使用 Podman 完成工作
为了确认当前的镜像是否就绪，可以运行如下命令：
```
$ sudo podman images
REPOSITORY TAG IMAGE ID CREATED SIZE
localhost/fedora gpiobase 67a2b2b93b4b 10 minutes ago 488MB
docker.io/library/fedora latest c18042d7fac6 2 days ago 300MB
```
现在，启动容器并进行一些实际的实验。容器通常是隔离的，无法访问主机系统，包括 GPIO 接口。因此需要在启动容器时将其挂载在容器内。可以使用以下命令中的 `-device` 选项来解决：
```
$ sudo podman run -it --name gpioexperiment --device=/dev/gpiochip0 localhost/fedora:gpiobase /bin/bash
```
运行之后就进入了正在运行的容器中。在继续之前，这里有一些容器命令。输入 `exit` 或者按下 `Ctrl+D` 来退出容器。
显示所有存在的容器可以运行如下命令，这包括当前没有运行的，比如你刚刚创建的那个：
```
$ sudo podman container ls -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
64e661d5d4e8 localhost/fedora:gpiobase /bin/bash 37 seconds ago Exited (0) Less than a second ago gpioexperiment
```
使用如下命令创建一个新的容器：
```
$ sudo podman run -it --name newexperiment --device=/dev/gpiochip0 localhost/fedora:gpiobase /bin/bash
```
如果想删除容器可以使用如下命令：
```
$ sudo podman rm newexperiment
```
### 点亮 LED 灯
现在可以使用已创建的容器。如果已经从容器退出，请使用以下命令再次启动它：
```
$ sudo podman start -ia gpioexperiment
```
如前所述，可以使用 Fedora 中 libgpiod-utils 包提供的命令行工具。要列出可用的 GPIO 芯片可以使用如下命令：
```
$ gpiodetect
gpiochip0 [pinctrl-bcm2835] (54 lines)
```
要获取特定芯片的连线列表，请运行：
```
$ gpioinfo gpiochip0
```
请注意，物理引脚数与前一个命令所打印的连线数之间没有相关性。重要的是 BCM 编号，如 [pinout.xyz](https://pinout.xyz/) 所示。建议不要使用没有相应 BCM 编号的连线。
现在，将 LED 连接到物理引脚 40，也就是 BCM 21。请记住：LED 的短腿（负极，称为阴极）必须连接到带有 330 欧姆电阻的树莓派的 GND 引脚， 并且长腿（阳极）到物理引脚 40。
运行以下命令点亮 LED，按下 `Ctrl + C` 关闭：
```
$ gpioset --mode=wait gpiochip0 21=1
```
要点亮一段时间，请添加 `-b`（在后台运行）和 `-s NUM`（多少秒）参数，如下所示。 例如，要点亮 LED 5 秒钟，运行如下命令：
```
$ gpioset -b -s 5 --mode=time gpiochip0 21=1
```
另一个有用的命令是 `gpioget`。 它可以获得引脚的状态（高或低），可用于检测按钮和开关。
### 总结
你也可以使用 Python 操控 LED —— [这里有一些例子](https://github.com/brgl/libgpiod/tree/master/bindings/python/examples)。 也可以在容器内使用 i2c 设备。 此外，Podman 与此 Fedora 版本并不严格相关。你可以在任何现有的 Fedora 版本上安装它，或者在 Fedora 中使用两个基于 OSTree 的新系统进行尝试：[Fedora Silverblue](https://teamsilverblue.org/) 和 [Fedora CoreOS](https://coreos.fedoraproject.org/)。
---
via: <https://fedoramagazine.org/turnon-led-fedora-iot/>
作者：[Alessio Ciregia](http://alciregi.id.fedoraproject.org/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[ScarboroughCoral](https://github.com/ScarboroughCoral) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
以 Linux 的方式庆祝圣诞节
|
Abhishek Prakash
|
https://itsfoss.com/christmas-linux-wallpaper/
|
为了延续节日氛围，我将向你展示一些非常棒的圣诞主题的 Linux 壁纸。在呈现这些壁纸之前，先来看一棵 Linux 终端下的圣诞树。
|
/data/attachment/album/201812/25/011422uz6z1iy36wy6nmcn.jpg.thumb.jpg
|
/data/attachment/album/201812/25/011422uz6z1iy36wy6nmcn.jpg
| true | false | true |
lujun9972
|
jlztan
|
wxy
| false |
[
"圣诞节"
] |
桌面应用
|
{
"viewnum": 6561,
"commentnum": 3,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "219.227.68.101",
"message": "壁纸很棒",
"username": "来自广东深圳深圳市上沙小学的 Chrome 71.0|Windows 7 用户",
"date": "2019-01-03T17:29:35"
},
{
"postip": "219.227.68.101",
"message": "壁纸很棒",
"username": "来自广东深圳深圳市上沙小学的 Chrome 71.0|Windows 7 用户",
"date": "2019-01-03T17:29:35"
},
{
"postip": "219.227.68.101",
"message": "壁纸很棒",
"username": "来自广东深圳深圳市上沙小学的 Chrome 71.0|Windows 7 用户",
"date": "2019-01-03T17:29:36"
}
] |
[] |
为了延续节日氛围，我将向你展示一些非常棒的圣诞主题的 Linux 壁纸。在呈现这些壁纸之前，先来看一棵 Linux 终端下的圣诞树。
| 2018-12-25T01:14:00 | 2018-12-25T01:14:00 | 10,381 |
/article-10381-1.html
|
当前正是假日季，很多人可能已经在庆祝圣诞节了。祝你圣诞快乐，新年快乐。
为了延续节日氛围，我将向你展示一些非常棒的圣诞主题的 [Linux 壁纸](https://itsfoss.com/beautiful-linux-wallpapers/)。在呈现这些壁纸之前，先来看一棵 Linux 终端下的圣诞树。
### 让你的桌面飘雪（针对 GNOME 用户）
如果您在 Ubuntu 18.04 或任何其他 Linux 发行版中使用 GNOME 桌面，您可以使用一个小的 [GNOME 扩展](https://itsfoss.com/gnome-shell-extensions/)并在桌面上飘雪。
您可以从软件中心或 GNOME 扩展网站获取此 gsnow 扩展。我建议您阅读一些关于[使用 GNOME 扩展](https://itsfoss.com/gnome-shell-extensions/)的内容。
安装此扩展程序后，您会在顶部面板上看到一个小雪花图标。 如果您单击一次，您会看到桌面屏幕上的小絮状物掉落。
你可以再次点击该图标来禁止雪花落下。
### 在 Linux 终端下显示圣诞树
如果你想要在终端里显示一个动画的圣诞树，你可以使用如下命令：
```
curl https://raw.githubusercontent.com/sergiolepore/ChristBASHTree/master/tree-EN.sh | bash
```
要是不想一直从互联网上获取这棵圣诞树，也可以从它的 [GitHub 仓库](https://github.com/sergiolepore/ChristBASHTree) 中获取对应的 shell 脚本，更改权限之后按照运行普通 shell 脚本的方式运行它。
### 使用 Perl 在 Linux 终端下显示圣诞树
[](https://itsfoss.com/christmas-linux-wallpaper/perl-tree/)
这个技巧最初由 [NixCraft](https://www.cyberciti.biz/open-source/command-line-hacks/linux-unix-desktop-fun-christmas-tree-for-your-terminal/) 分享，你需要为此安装 Perl 模块。
说实话，我不喜欢使用 Perl 模块，因为卸载它们真的很痛苦。所以使用这个 Perl 模块时需谨记，你必须手动移除它。
```
perl -MCPAN -e 'install Acme::POE::Tree'
```
你可以阅读 [原文](https://www.cyberciti.biz/open-source/command-line-hacks/linux-unix-desktop-fun-christmas-tree-for-your-terminal/) 来了解更多信息。
### 下载 Linux 圣诞主题壁纸
所有这些 Linux 圣诞主题壁纸都是由 Mark Riedesel 制作的，你可以在 [他的网站](http://www.klowner.com/) 上找到很多其他艺术品。
自 2002 年以来，他几乎每年都在制作这样的壁纸。可以理解的是，最早的一些壁纸不具有现代的宽高比。我把它们按时间倒序排列。
注意一个小地方，这里显示的图片都是高度压缩的，因此你要通过图片下方提供的链接进行下载。
*[下载此壁纸](http://www.klowner.com/wallery/christmas_tux_2018/download/ChristmasTux2018_4K_3840x2160.png)*
*[下载此壁纸](http://klowner.com/wallery/christmas_tux_2017/download/ChristmasTux2017_3840x2160.png)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2016_3840x2160_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2016/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2015_2560x1920_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2015/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2014_2560x1440_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2014/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2013_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2013/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2012_2560x1440_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2012/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2011_2560x1440_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2011/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2010_5120x2880_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2010/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2009_1600x1200_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2009/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2008_2560x1600_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2008/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2007_2560x1600_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2007/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2006_1024x768_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2006/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2005_1600x1200_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2005/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2004_1600x1200_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2004/)*
[](https://itsfoss.com/christmas-linux-wallpaper/christmastux2002_1600x1200_result/)
*[下载此壁纸](http://www.klowner.com/wallpaper/christmas_tux_2002/)*
### 福利：Linux 圣诞颂歌
这是给你的一份福利，给像我们一样的 Linux 爱好者的关于 Linux 的圣诞颂歌。
在 [《计算机世界》的一篇文章](http://www.computerworld.com/article/3151076/linux/merry-linux-to-you.html) 中，[Sandra Henry-Stocker](https://twitter.com/bugfarm) 分享了这些圣诞颂歌。摘录片段如下：
这一段用的 [Chestnuts Roasting on an Open Fire](https://www.youtube.com/watch?v=dhzxQCTCI3E) 的曲调：
>
> Running merrily on open source
>
>
> With users happy as can be
>
>
> We’re using Linux and getting lots done
>
>
> And happy everything is free
>
>
>
这一段用的 [The Twelve Days of Christmas](https://www.youtube.com/watch?v=oyEyMjdD2uk) 的曲调：
>
> On my first day with Linux, my admin gave to me a password and a login ID
>
>
> On my second day with Linux my admin gave to me two new commands and a password and a login ID
>
>
>
在 [这里](http://www.computerworld.com/article/3151076/linux/merry-linux-to-you.html) 阅读完整的颂歌。
Linux 快乐！
---
via: <https://itsfoss.com/christmas-linux-wallpaper/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[jlztan](https://github.com/jlztan) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
IBM 029 型打孔机
|
Two-bit History
|
https://twobithistory.org/2018/06/23/ibm-029-card-punch.html
|
我知道这很学院派，可一行超过 80 个字符的代码还是让我抓狂。我也在网上见过不少人认为即使在现代的视网膜屏幕下也应当采用行长度为 80 个字符的标准，可他们都不理解我对破坏这一标准的怒火，就算多 1 个字符也不行。
|
/data/attachment/album/201812/25/144551dtit8dpgprga5p3n.jpg.thumb.jpg
|
/data/attachment/album/201812/25/144551dtit8dpgprga5p3n.jpg
| true | false | true |
lujun9972
|
wwhio
|
wxy
| true |
[
"打孔卡"
] |
观点
|
{
"viewnum": 8739,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10482,
"displayorder": 0
}
] |
我知道这很学院派，可一行超过 80 个字符的代码还是让我抓狂。我也在网上见过不少人认为即使在现代的视网膜屏幕下也应当采用行长度为 80 个字符的标准，可他们都不理解我对破坏这一标准的怒火，就算多 1 个字符也不行。
| 2018-12-25T14:45:00 | 2018-12-25T14:45:00 | 10,382 |
/article-10382-1.html
|
我知道这很学院派，可一行超过 80 个字符的代码还是让我抓狂。我也在网上见过不少人认为即使在现代的视网膜屏幕下也应当采用行长度为 80 个字符的标准，可他们都不理解我对破坏这一标准的怒火，就算多 1 个字符也不行。
在这一标准的黄金时期，一行代码的长度几乎不会超过 80 个字符的限制。在那时，这一限制是物理的，没有第 81 列用于存放第 81 个字符。每一个试图把函数名起的又长又臭的程序员都会在短暂的愉悦后迎来更多的麻烦，而这仅仅是因为没有足够的空间放下整个函数的声明。
这一黄金时期也是<ruby> 打孔卡 <rt> punch card </rt></ruby>编程时期。在 20 世纪 60 年代，IBM 打孔卡设立了标准，这个标准就是打孔卡的宽度为 80 列。这个 80 列标准在后来的电传打字机和哑终端时期得以延续，并逐渐成为操作系统中隐藏的细节。时至今日，即使我们用上了更大、更好的屏幕，偏向于使用更长的标识符而不是类似 `iswcntrl()` 这样令人难以猜测的函数名，可当你打开新的终端模拟器窗口时，默认的宽度依然是 80 个字符。
从 Quora 上的很多问题中可以发现，很多人并不能想象如何使用打孔卡给计算机编程。我承认，在很长的一段时间里我也不能理解打孔卡编程是如何工作的，因为这让我想到就像劳工一样不停的给这些打孔卡打孔。当然，这是一个误解，程序员不需要亲自给打孔卡打孔，就像是火车调度员不用亲自扳道岔。程序员们有<ruby> 打孔机 <rt> card punch machines </rt></ruby>（也被称为<ruby> 键控打孔机 <rt> key punches </rt></ruby>），这让他们可以使用打字机式的键盘给打孔卡打孔。这样的设备在 19 世纪 90 年代时就已经不是什么新技术了。
那时，最为广泛使用的打孔机之一便是 IBM 029 型打孔机。就算在今天，它也许是最棒的打孔机。
IBM 029 型打孔机在 1964 年作为 IBM 的 System/360 大型电脑的配件发售的。System/360 是计算系统与外设所组成的一个系列，在 20 世纪 60 年代晚期，它几乎垄断了整个大型计算机市场。就像其它 System/360 外设一样，029 型打孔机也是个大块头。那时，计算机和家具的界限还很模糊，但 029 型打孔机可不是那种会占领你的整张桌子的机器。它改进自 026 型打孔机，增加了新的字符支持，如括号，总体上也更加安静。与前辈 026 型所展出 20 世纪 40 年代的圆形按钮与工业化的样貌相比，029 型的按键方正扁平、功能按键还有酷炫的蓝色高亮提示。它的另一个重要买点是它能够在<ruby> 数字区 <rt> numeric field </rt></ruby>左侧自动的填充 0 ，这证明了 JavaScript 程序员不是第一批懒得自己做<ruby> 左填充 <rt> left-padding </rt></ruby>的程序员。（LCTT 译注：这项功能需要额外的 4 张 <ruby> <a href="https://en.wikipedia.org/wiki/IBM_Standard_Modular_System"> 标准模块系统卡 </a> <rt> SMS card </rt></ruby>才能使用。例如设置数字区域长度为 6 列时，操作员只需要输入 73 ，打孔机会自动填充起始位置上的 4 个 0 ，故最终输出 000073。[更多信息](https://en.wikipedia.org/wiki/Keypunch#IBM_029_Card_Punch)）
等等！你说的是 IBM 在 1964 年发布了全新的打孔机？你知道那张在贝尔实验室拍摄的 Unix 之父正在使用电传打字机的照片吗？那是哪一年的来着？1970？打孔机不是应该在 20 世纪 60 年代中期到晚期时就过时了吗？是的，你也许会奇怪，为什么直到 1984 年，IBM 的产品目录中还会出现 029 型打孔机的身影 <sup id="fnref1"> <a href="#fn1" rel="footnote"> 1 </a></sup>。事实上，直到 20 世纪 70 年代，大多数程序员仍然在使用打孔卡编程。其实二战期间就已经有人在用电传打字机了，可那时并没能普及。客观的讲，电传打字机几乎和打孔卡一样古老。也许和你想象的恰恰相反，并不是电传打字机本身限制了它的普及，而是计算时间。人们拒绝使用电传打字机的原因是，它是可交互的，它和计算机使用<ruby> “在线”的传输方式 <rt> <q> online </q> mode of communication </rt></ruby>。在以 Unix 为代表的分时操作系统被发明前，你和电脑的交互会被任何人的使用而打断，而这一点延迟通常意味着几千美元的损失。所以程序员们普遍选择离线地使用打孔机编程，再将打孔卡放入大型计算机中，作为<ruby> 批任务 <rt> batch job </rt></ruby>执行。在那时，还没有即廉价又可靠的存储设备，可打孔卡的廉价优势已经足够让它成为那时最流行的数据存储方式了。那时的程序是书架上一摞打孔卡而不是硬盘里的一堆文件。
那么实际使用 IBM 029 型打孔机是个什么样子呢？这很难向没有实际看过打孔卡的人解释。一张打孔卡通常有 12 行 80 列。打孔卡下面是从 1 到 9 的<ruby> 数字行 <rt> digit rows </rt></ruby>，打孔卡上的每一列都有这些行所对应的数字。最上面的三行是<ruby> 空间行 <rt> <q> zone </q> rows </rt></ruby>，通常由两行空白行和一行 0 行组成。第 12 行是打孔卡最顶部的行，接下来是 11 行，随后是从数字 0 到 9 所在的行。这个有点让人感到困惑的顺序的原因是打孔卡的上边缘被称为<ruby> 12 边 <rt> 12 edge </rt></ruby>、下边缘被称为 <ruby> 9 边 <rt> 9 edge </rt></ruby>。那时，为了让打孔卡便于整理，常常会剪去打孔卡的一个角。
（LCTT 译注：可参考[EBCDIC 编码](https://zh.wikipedia.org/wiki/EBCDIC)）
在打孔卡发明之初，孔洞的形状是圆形的，但是 IBM 最终意识到如果使用窄长方形作为孔洞，一张卡就可以放下更多的列了。每一列中孔洞的不同组合就可以表达不同的字符。像 029 型这样的拥有人性化设计的打孔机除了完成本质的打孔任务外，还会在打孔卡最上方打印出每一列所对应的字符。输入是数字就在对应的数字行上打孔。输入的是字母或符号就用一个在空间列的孔和一或俩个在数字列的孔的组合表示，例如字母 A 就用一个在第 12 空间行的空和一个数字 1 所在行的孔表示。这是一种顺序编码，在第一台打孔机被发明后，也叫 Hollerith 编码。这种编码只能表示相对较小的一套字符集，小写字母就没有包含在这套字符集中。如今一些聪明的工程师可能想知道为什么打卡不干脆使用二进制编码 —— 毕竟，有 12 行，你可以编码超过 4000 个字符。 使用 Hollerith 编码是因为它确保在单个列中出现不超过三个孔。这保留了卡的结构强度。二进制编码会带来太多的孔，会因为孔洞过于密集而断裂。
打孔卡也有不同。在 20 世纪 60 年代，80 列虽然是标准，但表达的方式不一定相同。基础打孔卡是无标注的，但用于 COBOL 编程的打孔卡会把最后的 8 列保留，供标识数保存使用。这一标识数可以在打孔卡被打乱 (例如一叠打孔卡掉在地上了) 后用于自动排序。此外，第 7 列被用于表示本张打孔卡上的是否与上一张打孔卡一起构成一条语句。也就是说当你真的对 80 字符的限制感到绝望的时候，还可以用两张卡甚至更多的卡拼接成一条长语句。用于 FORTRAN 编程的打孔卡和 COBOL 打孔卡类似，但是定义的列不同。大学里使用的打孔卡通常会由其计算机中心加上水印，其它的设计则会在如 [1976 年美国独立 200 周年](http://www.jkmscott.net/data/Punched%20card%20013.jpg) 的特殊场合才会加入。
最终，这些打孔卡都要被计算机读取和计算。IBM 出售的 System/360 大型计算机的外设 IBM 2540 可以以每分钟 1000 张打孔卡的速度读取这些卡片<sup id="fnref2"> <a href="#fn2" rel="footnote"> 2 </a></sup> 。IBM 2540 使用电刷扫过每张打孔卡，电刷通过孔洞就可以接触到卡片后面的金属板完成一次读取。一旦读取完毕，System/360 大型计算机就会把每张打孔卡上的数据使用一种定长的 8 位编码保存，这种编码是<ruby> 扩增二进式十进交换码 <rt> Extended Binary Coded Decimal Interchange Code </rt></ruby>，简写为 EBCDIC 编码。它是一种二进制编码，可以追溯自早期打孔卡所使用的 BCDIDC 编码 —— 其 6 位编码使用低 4 位表示数字行，高 2 位表示空间行。程序员们在打孔卡上编写完程序后，会把卡片们交给计算机操作员，操作员们会把这些卡片放入 IBM 2540 ，再把打印结果交给程序员。那时的程序员大多都没有见过计算机长什么样。
程序员们真正能见到的是很多打孔机。029 型打孔机虽然不是计算机，但这并不意味着它不是一台复杂的机器。看看这个由<ruby> 密歇根大学 <rt> University of Michigan </rt></ruby>计算机中心在 1967 年制作的[教学视频](https://www.youtube.com/watch?v=kaQmAybWn-w)，你就能更好的理解使用一台 029 型打孔机是什么情形了。我会尽可能在这里总结这段视频，但如果你不去亲自看看的话，你会错过许多惊奇和感叹。
029 型打孔机的结构围绕着一个打孔卡穿过机器的 U 形轨道开始。使用打孔机时，右手边也就是 U 形轨道的右侧顶部是<ruby> 进卡卡槽 <rt> hopper </rt></ruby>，使用前通常在里面放入一叠未使用的打孔卡。虽然 029 型打孔机主要使用 80 列打孔卡，但在需要的情况下也可以使用更小号的打孔卡。在打孔机的使用过程中，打孔卡离开轨道右上端的进卡卡槽，顺着 U 形轨道移动并最终进入左上端的<ruby> 出卡卡槽 <rt> stacker </rt></ruby>。这一流程可以保证出卡卡槽中的打孔卡按打孔时的先后顺序排列。
029 型打孔机的开关在桌面下膝盖高度的位置。在开机后，连按两次 “<ruby> 装入 <rt> FEED </rt></ruby>” 键让机器自动将打孔卡从进卡卡槽中取出并移动到机器内。 U 形轨道的底部是打孔机的核心区域，它由三个部分组成：右侧是等待区，中间是打孔操作区，左侧是阅读区。连按两次 “装入” 键，机器就会把一张打孔卡装入打孔机的打孔操作区，另一张打孔卡进入等待区。在打孔操作区上方有一个列数指示器来显示当前打孔所在的列的位置。这时，每按下一个按键，机器就会在打孔卡对应的位置打孔并在卡片的顶部打印按键对应的字符，随后将打孔卡向左移动一列。如果一张卡片的 80 列全部被打上了数据，这张卡片会被打孔操作区自动释放并进入阅读区，同时，一张新的打孔卡会被装入打孔操作区。如果没有打完全部的 80 列，可以使用 “<ruby> 释放 <rt> REL </rt></ruby>” 键完成上面的操作。
在打孔卡上打印对应的字符这一设计让人很容易分辨出错误。但就像密歇根大学的视频中警告的那样，打孔卡上修正一个错误可不像擦掉一个打印的字符然后再写上一个新的那样容易，因为计算机只会根据卡片上的孔来读取信息。因为被打出的孔不能被<ruby> 复原 <rt> unpunched </rt></ruby>，所以并不能直接退回一列然后再打上一个新的字符。打出更多的孔也只能让这一列的组合变成一个无效字符。IBM 029 型打孔机上虽然有一个可以让打孔卡回退一列的退格按键，但这个按键被放置在机器上而非在键盘上。这样的设计也许是为了阻止这个按键的使用，因为实际上很少有用户需要这个功能。
实际上，只有废弃错误的打孔卡再在新的打孔卡上重新打孔这一种修正错误的方式。这就是阅读区的用武之处了。当你发现打孔卡上的第 68 列出错时，你需要在新的打孔卡上小心的给前 67 列重新打孔，然后给第 68 列打上正确的字母。另一种操作方式是把带有错误信息的打孔卡放在阅读区，同时在打孔操作区载入一张新的打孔卡，然后按下 “<ruby> 重复 <rt> DUP </rt></ruby>” 按键直到列数指示器显示 68 列。这时按下正确的字符来修正错误。阅读区和重复按键使得 029 型打孔机很容易复制打孔卡上的内容。当然，这一功能的使用可能有各种各样的原因，但改错是最常见的。
（LCTT 译注：有一种说法是“补丁”这个用于对已经发布的软件进行修复的术语来源于对打孔纸带或打孔卡上打错的孔贴上补丁的做法。可能对于长长的一卷打孔纸带来说，由于个别字母的错误而整个废弃成本过高，会采用“补丁”的方式；而对于这种单张式的打孔卡来说，重新打印一张正确的更为方便。）
“重复”按键允许 029 型打孔机的操作员手动调用重复的函数。但是 029 型打孔机还可以设置为自动重复。当用于记录数据而不是编程时，这项功能十分有效。举个例子，当用打孔卡来记录大学生的信息时，每张卡片上都需要输入学生的宿舍楼的名字，如果发现所输入信息的学生都在同一栋楼，就可以使用 029 型打孔机的自动重复功能来完成宿舍楼名称的填写。
像这样的自动化操作可以通过<ruby> 程序鼓 <rt> program drum </rt></ruby>编程到 029 型打孔机里面。程序鼓就安装在打孔操作区上方的 U 形轨道中间部分的右上角。通过在打孔卡上写下程序，然后把打孔卡装入程序鼓中，就完成了一次给 029 型打孔机的编程任务。用户可以通过这种方式对打孔卡的每一列都按需要定义不同的自动化操作。029 型打孔机允许指定某些列重复上一张打孔卡相同位置的字符，这就是它能更快的输入学生信息的理由。它还允许指定某些列只能输入数字或者字母，指定特定的列为空或者到某一列时就直接跳过一整张打孔卡。编程鼓使它在打孔特定列有特殊含义的固定模式卡片时很容易。密歇根大学制作的另一个[进阶教学视频](https://www.youtube.com/watch?v=SWD1PwNxpoU)包括了给 029 型打孔机编程的过程，如果你已经掌握了它的基础操作，就快去看看吧。
这会儿，无论你是否看了密歇根大学制作的视频，都会感叹打孔机的操作之简便。虽然修正错误的过程很乏味，但除此之外，操作一台打孔机并不像想象的那样复杂。我甚至可以想象打孔卡之间的无缝切换让 COBOL 和 FORTRAN 程序员忘记了他们的程序是打在不同的打孔卡上而不是写在一个连续的文本文件内。另一方面，思考一下打孔机是如何影响编程语言的发展也是很有趣的，虽然它仅仅是一台输入设备。结构化编程最终会出现并鼓励程序员把整个代码块视为一个整体，但可以想象打孔卡程序员们强调每一行的作用且难以认同结构化编程的场景。同时你能够理解他们为什么不把代码块闭合所使用的括号放在单独的一行，只是因为这样会浪费打孔卡。
现在，虽然没有人再使用打孔卡编程了，每个程序员都该试试[这个](http://www.masswerk.at/keypunch/)，哪怕一次也好。或许你因此能够更好的理解 COBOL 和 FORTRAN 的历史，或许你就能体会到为什么每个人把 80 个字符作为长度限制的标注。
喜欢吗？这里每两周都会发表一篇这样的文章。请在推特上关注我们 [@TwoBitHistory](https://twitter.com/TwoBitHistory) 或者订阅我们的 [RSS](https://twobithistory.org/feed.xml)，这样你就能在第一时间收到新文章的通知。
---
via: <https://twobithistory.org/2018/06/23/ibm-029-card-punch.html>
作者：[Two-Bit History](https://twobithistory.org) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wwhio](https://github.com/wwhio) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
---
1. “IBM 29 Card Punch,” IBM Archives, accessed June 23, 2018, <https://www-03.ibm.com/ibm/history/exhibits/vintage/vintage_4506VV4002.html>. [↩](#fnref1)
2. IBM, IBM 2540 Component Description and Operation Procedures (Rochester, MN: IBM Product Publications, 1965), September 06, 2009, accessed June 23, 2018, <http://bitsavers.informatik.uni-stuttgart.de/pdf/ibm/25xx/A21-9033-1_2540_Card_Punch_Component_Description_1965.pdf>. [↩](#fnref2)
|
7 个最佳 Linux 电子书阅读器
|
Ambarish Kumar
|
https://itsfoss.com/best-ebook-readers-linux/
|
本文中我们涉及一些 Linux 最佳电子书阅读器。这些应用提供更佳的阅读体验甚至可以管理你的电子书。
|
/data/attachment/album/201812/25/221743h534kuezeu46iq54.png.thumb.jpg
|
/data/attachment/album/201812/25/221743h534kuezeu46iq54.png
| true | false | true |
zjon
|
wxy
| false |
[
"电子书",
"Calibre"
] |
分享
|
{
"viewnum": 25783,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
本文中我们涉及一些 Linux 最佳电子书阅读器。这些应用提供更佳的阅读体验甚至可以管理你的电子书。
| 2018-12-25T22:17:00 | 2018-12-25T22:17:00 | 10,383 |
/article-10383-1.html
|
**摘要：** 本文中我们涉及一些 Linux 最佳电子书阅读器。这些应用提供更佳的阅读体验甚至可以管理你的电子书。
最近，随着人们发现在手持设备、Kindle 或者 PC 上阅读更加舒适，对电子图书的需求有所增加。至于 Linux 用户，也有各种电子书应用满足你阅读和整理电子书的需求。
在本文中，我们选出了七个最佳 Linux 电子书阅读器。这些电子书阅读器最适合 pdf、epub 和其他电子书格式。
我提供的是 Ubuntu 安装说明，因为我现在使用它。如果你使用的是[非 Ubuntu 发行版](https://itsfoss.com/non-ubuntu-beginner-linux/)，你能在你的发行版软件仓库中找到大多数这些电子书应用。
### 1. Calibre
[Calibre](https://www.calibre-ebook.com) 是 Linux 最受欢迎的电子书应用。老实说，这不仅仅是一个简单的电子书阅读器。它是一个完整的电子书解决方案。你甚至能[通过 Calibre 创建专业的电子书](https://itsfoss.com/create-ebook-calibre-linux/)。
通过强大的电子书管理和易用的界面，它提供了创建和编辑电子书的功能。Calibre 支持多种格式和与其它电子书阅读器同步。它也可以让你轻松转换一种电子书格式到另一种。
Calibre 最大的缺点是，资源消耗太多，因此作为一个独立的电子阅读器来说是一个艰难的选择。
#### 特性
* 管理电子书：Calibre 通过管理元数据来排序和分组电子书。你能从各种来源下载一本电子书的元数据或创建和编辑现有的字段。
* 支持所有主流电子书格式：Calibre 支持所有主流电子书格式并兼容多种电子阅读器。
* 文件转换：在转换时，你能通过改变电子书风格，创建内容表和调整边距的选项来转换任何一种电子书格式到另一种。你也能转换个人文档为电子书。
* 从 web 下载杂志期刊：Calibre 能从各种新闻源或者通过 RSS 订阅源传递故事。
* 分享和备份你的电子图书馆：它提供了一个选项，可以托管你电子书集合到它的服务端，从而你能与好友共享或用任何设备从任何地方访问。备份和导入/导出特性可以确保你的收藏安全和方便携带。
#### 安装
你能在主流 Linux 发行版的软件库中找到它。对于 Ubuntu，在软件中心搜索它或者使用下面的命令：
```
sudo apt-get install calibre
```
### 2. FBReader
[FBReader](https://fbreader.org) 是一个开源的轻量级多平台电子书阅读器，它支持多种格式，比如 ePub、fb2、mobi、rtf、html 等。它包括了一些可以访问的流行网络电子图书馆，那里你能免费或付费下载电子书。
#### 特性
* 支持多种文件格式和设备比如 Android、iOS、Windows、Mac 和更多。
* 同步书集、阅读位置和书签。
* 在线管理你图书馆，可以从你的 Linux 桌面添加任何书到所有设备。
* 支持 Web 浏览器访问你的书集。
* 支持将书籍存储在 Google Drive ，可以通过作者，系列或其他属性整理书籍。
#### 安装
你能从官方库或者在终端中输入以下命令安装 FBReader 电子阅读器。
```
sudo apt-get install fbreader
```
或者你能从[这里](https://fbreader.org/content/fbreader-beta-linux-desktop)抓取一个以 .deb 包，并在你的基于 Debian 发行版的系统上安装它。
### 3. Okular
[Okular](https://okular.kde.org/) 是另一个开源的基于 KDE 开发的跨平台文档查看器，它已经作为 KDE 应用发布的一部分了。
#### 特性
* Okular 支持多种文档格式像 PDF、Postscript、DjVu、CHM、XPS、ePub 和其他。
* 支持在 PDF 文档中评论、高亮和绘制不同的形状等。
* 无需修改原始 PDF 文件，分别保存上述这些更改。
* 电子书中的文本能被提取到一个文本文件，并且有个名为 Jovie 的内置文本阅读服务。
备注：查看这个应用的时候，我发现这个应用在 Ubuntu 和它的衍生系统中不支持 ePub 文件格式。其他发行版用户仍然可以发挥它全部的潜力。
#### 安装
Ubuntu 用户可以在终端中键入下面的命令来安装它：
```
sudo apt-get install okular
```
### 4. Lucidor
Lucidor 是一个易用的、支持 epub 文件格式和在 OPDS 格式中编目的电子阅读器。它也具有在本地书架里组织电子书集、从互联网搜索和下载，和将 Web 订阅和网页转换成电子书的功能。
Lucidor 是 XULRunner 应用程序，它向您展示了具有类似火狐的选项卡式布局，和存储数据和配置时的行为。它是这个列表中最简单的电子阅读器，包括诸如文本说明和滚动选项之类的配置。
你可以通过选择单词并右击“查找单词”来查找该单词在 Wiktionary.org 的定义。它也包含 web 订阅或 web 页面作为电子书的选项。
你能从[这里](http://lucidor.org/lucidor/download.php)下载和安装 deb 或者 RPM 包。
### 5. Bookworm
Bookworm 是另一个支持多种文件格式诸如 epub、pdf、mobi、cbr 和 cbz 的自由开源的电子阅读器。我写了一篇关于 Bookworm 应用程序的特性和安装的专题文章，到这里阅读：[Bookworm：一个简单而强大的 Linux 电子阅读器](https://itsfoss.com/bookworm-ebook-reader-linux/)
#### 安装
```
sudo apt-add-repository ppa:bookworm-team/bookworm
sudo apt-get update
sudo apt-get install bookworm
```
### 6. Easy Ebook Viewer
[Easy Ebook Viewer](https://github.com/michaldaniel/Ebook-Viewer) 是又一个用于读取 ePub 文件的很棒的 GTK Python 应用。具有基本章节导航、从上次阅读位置继续、从其他电子书文件格式导入、章节跳转等功能，Easy Ebook Viewer 是一个简单而简约的 ePub 阅读器.
这个应用仍然处于初始阶段，只支持 ePub 文件。
#### 安装
你可以从 [GitHub](https://github.com/michaldaniel/Ebook-Viewer.git) 下载源代码，并自己编译它及依赖项来安装 Easy Ebook Viewer。或者，以下终端命令将执行完全相同的工作。
```
sudo apt install git gir1.2-webkit-3.0 libwebkitgtk-3.0-0 gir1.2-gtk-3.0 python3-gi
git clone https://github.com/michaldaniel/Ebook-Viewer.git
cd Ebook-Viewer/
sudo make install
```
成功完成上述步骤后，你可以从 Dash 启动它。
### 7. Buka
Buka 主要是一个具有简单而清爽的用户界面的电子书管理器。它目前支持 PDF 格式，旨在帮助用户更加关注内容。拥有 PDF 阅读器的所有基本特性，Buka 允许你通过箭头键导航，具有缩放选项，并且能并排查看两页。
你可以创建单独的 PDF 文件列表并轻松地在它们之间切换。Buka 也提供了一个内置翻译工具，但是你需要有效的互联网连接来使用这个特性。
#### 安装
你能从[官方下载页面](https://github.com/oguzhaninan/Buka/releases)下载一个 AppImage。如果你不知道如何做，请阅读[如何在 Linux 下使用 AppImage](https://itsfoss.com/use-appimage-linux/)。或者，你可以通过命令行安装它：
```
sudo snap install buka
```
### 结束语
就我个人而言，我发现 Calibre 最适合我的需要。当然，Bookworm 看起来很有前途，这几天我经常使用它。不过，电子书应用的选择完全取决于你的喜好。
你使用哪个电子书应用呢？在下面的评论中让我们知道。
---
via: <https://itsfoss.com/best-ebook-readers-linux/>
作者：[Ambarish Kumar](https://itsfoss.com/author/ambarish/) 译者：[zjon](https://github.com/zjon) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
在 Linux 终端上玩俄罗斯方块
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-tetris
|
用每个人最喜欢的砖块配对游戏“俄罗斯方块”重新创造 20 世纪 80 年代的魔力。
|
/data/attachment/album/201812/25/234327icbhd4gzhq98lauc.png.thumb.jpg
|
/data/attachment/album/201812/25/234327icbhd4gzhq98lauc.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"俄罗斯方块"
] |
分享
|
{
"viewnum": 9303,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
用每个人最喜欢的砖块配对游戏“俄罗斯方块”重新创造 20 世纪 80 年代的魔力。
| 2018-12-25T23:43:00 | 2018-12-25T23:43:00 | 10,384 |
/article-10384-1.html
|
>
> 用每个人最喜欢的砖块配对游戏“俄罗斯方块”重新创造 20 世纪 80 年代的魔力。
>
>
>
感谢你来浏览我们今天的 Linux 命令行玩具日历。如果这是你第一次访问该系列，你可能会问自己，什么是命令行玩具。即使我不太确定，但一般来说，它可能是一个游戏或任何消遣，可以帮助你在终端获得乐趣。
很可能你们中的一些人之前会看到过我们日历中的各种推荐，但我们希望每个人至少遇到一件新事物。
我承诺在我开始这个系列时，我会介绍游戏，但到目前为止，我忽略了它，所以我们今天的选择就是游戏：俄罗斯方块。
俄罗斯方块和我差不多年纪，都在 1984 年夏天来到世界。不过，俄罗斯方块不是来自北卡罗来纳州的农村地区，而是来自当时苏联的莫斯科。
在风靡世界之后，俄罗斯方块被克隆过很多次。我怀疑你可以找到任何你想找的任何语言、操作系统的俄罗斯方块的克隆。说真的，去看看吧。会有一些有趣的。
我今天带来的命令行[版本](https://github.com/samtay/tetris)是[用 Haskell 编写](https://github.com/samtay/tetris)的，它是我见过的做得更好的版本之一，有屏幕预览、得分、帮助、干净的外观。
如果你愿意从不受信任的来源运行已编译的二进制文件（我不推荐它），你可以直接获取它，但有个更安全的方法，使用 [dex](https://github.com/dockerland/dex) 的容器化版本也很容易，或者使用 [stack](https://docs.haskellstack.org/en/stable/README/#how-to-install) 从源代码安装。
这个俄罗斯方块克隆版是由 Sam Tay 编写的，并且在 BSD 许可证下发布。[请看这里获取](https://github.com/samtay/tetris)！
如果你有自己喜欢的俄罗斯方块克隆版（或者你自己写的？），请告诉我们！
你有特别喜欢的命令行小玩具需要我介绍的吗？这个系列要介绍的小玩具大部分已经有了落实，但还预留了几个空位置。如果你有特别想了解的可以评论留言，我会查看的。如果还有空位置，我会考虑介绍它的。如果没有，但如果我得到了一些很好的意见，我会在最后做一些有价值的提及。
查看昨天的玩具，[在 Linux 命令行中计划你自己的假期日历](https://opensource.com/article/18/12/linux-toy-cal)，明天再回来查看！
---
via: <https://opensource.com/article/18/12/linux-toy-tetris>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 VirtualBox 上安装并使用 FreeDOS？
|
John Paul
|
https://itsfoss.com/install-freedos/
|
这份指南将带你如何一步一步在 Linux 平台下利用 VirtualBox 安装 FreeDOS。
|
/data/attachment/album/201812/26/004042kw6a924ty66thtgb.jpg.thumb.jpg
|
/data/attachment/album/201812/26/004042kw6a924ty66thtgb.jpg
| true | false | true |
lujun9972
|
WangYueScream
|
wxy
| false |
[
"VirtualBox",
"FreeDOS"
] |
技术
|
{
"viewnum": 7354,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
这份指南将带你如何一步一步在 Linux 平台下利用 VirtualBox 安装 FreeDOS。
| 2018-12-26T00:41:00 | 2018-12-26T00:41:00 | 10,385 |
/article-10385-1.html
|
>
> 这份指南将带你如何一步一步在 Linux 平台下利用 VirtualBox 安装 FreeDOS。
>
>
>
### Linux 下借助 VirtualBox 安装 FreeDOS
2017 年的 11 月份，我[采访了 Jim Hall](https://itsfoss.com/interview-freedos-jim-hall/) 关于 [FreeDOS 项目](http://www.freedos.org/) 背后的历史故事。今天，我将告诉你如何安装并使用 FreeDOS。需要注意到是：我将在 [Solus](https://solus-project.com/home/)（一种针对家庭用户的 Linux 桌面发行版）下使用 5.2.14 版本的 [VirtualBox](https://www.virtualbox.org/) 来完成这些操作。
>
> 注意：在本教程我将使用 Solus 作为主机系统因为它很容易设置。另一个你需要注意的事情是 Solus 的软件中心有两个版本的 VirtualBox：`virtualbox` 和 `virtualbox-current`。Solus 会让你选择是使用 linux-lts 内核还是 linux-current 内核。最终区别就是，`virtualbox` 适用于 linux-lts 而 `virtualbx-current` 适用于 linux-current。
>
>
>
#### 第一步 – 创建新的虚拟机
当你打开 VirtualBox，点击 “New” 按钮来新建一个虚拟机。你可以自定义这台虚拟机的名字，我将它命名为 “FreeDOS”。你也可以在标注栏内指明你正在安装的 FreeDOS 的版本。你还需要选择你将要安装的操作系统的类型和版本。选择 “Other” 下的 “DOS”。
#### 第二步 – 设置内存大小
下一个对话框会问你要给 FreeDOS 主机分配多少可用的内存空间。默认分配 32 MB。不必更改它。在 DOS 系统盛行的年代，32 MB 大小的内存对于一台搭载 FreeDOS 的机器已经很足够了。如果你有需要，你可以通过对你针对 FreeDOS 新建的虚拟机右键并选择 “Setting -> Symtem” 来增加内存。
#### 第三步 – 创建虚拟硬盘
下一步，你会被要求创建一个虚拟硬盘用来存储 FreeDOS 和它的文件。如果你还没有创建，只需要点击 “Create”。
下一个对话框会问你想用什么磁盘文件类型。默认的类型 (VirtualBox Disk Image) 效果就挺好。点击 “Next”。
下一个你遇到的问题是你想虚拟硬盘以何种方式创建。你是否希望虚拟硬盘占据的空间刚开始很小然后会随着你创建文件和安装软件逐渐增加直至达到你设置的上限？那么选择动态分配。如果你更喜欢虚拟硬盘 (VHD) 按照既定大小直接创建，选择固定大小即可。如果你不打算使用整个 VHD 或者你的硬盘空余空间不是太足够，那么动态分配是个很不错的分配方式。（需要注意的是，动态分配的虚拟硬盘占据的空间会随着你增加文件而增加，但不会因为你删除文件而变小） 我个人更喜欢动态分配，但你可以根据实际需要来选择最合适你的分配类型然后点击 “Next”。
现在，你可以选择虚拟磁盘的大小和位置。500 MB 已经很足够了。需要注意的是很多你之后用到的程序都是基于文本的，这意味着它们占据的空间非常小。在你做好这些调整后，点击 “Create”。
#### 第四步 – 关联 .iso 文件
在我们继续之前，你需要[下载](http://www.freedos.org/download/) FreeDOS 的 .iso 文件。你需要选择 CDROM 格式的 “standard” 安装程序。
当文件下载完毕后，返回到 VirtualBox。选中你的虚拟机并打开设置。你可以通过对虚拟机右键并选中 “Setting” 或者选中虚拟机并点击 “Setting” 按钮。
接下来，点击 “Storage” 选项卡。在 “Storage Devices” 下面，选中 CD 图标。(它应该会在图标旁边显示 “Empty”。) 在右边的 “Attribute” 面板，点中 CD 图标然后在对应路径选中你刚下载的 .iso 文件。
>
> 提示：通常，在你通过 VirtualBox 安装完一个操作系统后你就可以删除对应的 .iso 文件了。但这并不适合 FreeDOS 。如果你想通过 FreeDOS 的包管理器来安装应用程序，你需要这个 .iso 文件。我通常会让这个 .iso 文件连接到虚拟机以便我安装一些程序。如果你也这么做了，你必须要确认下你让 FreeDOS 虚拟机每次启动的时候是从硬盘启动因为虚拟机的默认设置是从已关联的 .iso 文件启动。如果你忘了关联 .iso 文件，也不用担心。你可以通过选择 FreeDOS 虚拟机窗口上方的 “Devices” 来关联。然后就会发现 .iso 文件列在 “Optical Drives”。
>
>
>
#### 第五步 – 安装 FreeDOS
既然我们已经完成了所有的准备工作，让我们来开始安装 FreeDOS 吧。
首先，你需要知道关于最新版本的 VirtualBox 的一个 bug。当我们创建好虚拟硬盘然后选中 “Install to harddisk” 后，如果你开启虚拟机你会发现在 FreeDOS 的欢迎界面出现过后就是不断滚动无群无尽的机器代码。我最近就遇到过这个问题而且不管是 Linux 还是 Windows 平台的 VirtualBox 都会碰到这个问题。（我知道解决办法。）
为了避开这个问题，你需要做一个简单的修改。当你看到 FreeDOS 的欢迎界面的时候，按下 Tab 键。（确认 “Install to harddrive” 已经选中。）在 “fdboot.img” 之后输入 `raw` 然后按下回车键。接下来就会启动 FreeDOS 的安装程序。
安装程序会首先处理你的虚拟磁盘的格式化。当格式化完成后，安装程序会重启。当 FreeDOS 的欢迎界面再次出现的时候，你必须重新输入 `raw` 就像你之前输入的内容那样。
要确保在安装过程中你遇到的所有问题你选的都是 “Yes”。但也要注意有一个很重要的问题：“What FreeDOS packages do you want to install?” 的答案并不是 “Yes” 或者 “No”。答案有两个选择分别是 “Base packages” 和 “Full installation”。“Base packages” 针对的是想体验类似原始的 MS-DOS 环境的人群。“Full installation” 则包括了一系列工具和实用的程序来提升 DOS。
在整个安装过程的最后，你可以选择重启或者继续停留在 DOS。选择“reboot”。
#### 第六步 – 设置网络
不同于原始的 DOS，FreeDOS 可以访问互联网。你可以安装新的软件包或者更新你已经安装的软件包。要想使用网络，你还需要在 FreeDOS 安装些应用程序。
首先，启动进入你新创建的 FreeDOS 虚拟机。在 FreeDOS 的选择界面，选中 “Boot from System harddrive”。
现在，你可以通过输入 `fdimples` 来访问 FreeDOS 的软件包管理工具。你也可以借助方向键来浏览软件包管理器，然后用空格键选择类别或者软件包。在 “Networking” 类别中，你需要选中 `fdnet`。FreeDOS project 推荐也安装 `mtcp` 和 `wget`。多次点击 Tab 键直到选中 “OK” 然后在按下回车键。安装完成后，输入 `reboot` 并按下回车键确认执行。系统重启后，引导你的系统驱动。如果网络安装成功的话，你会在终端看到一些关于你的网络信息的新消息。
注意：
有时候 VirtualBox 的默认设置并没有生效。如果遇到这种情况，先关闭你的 FreeDOS 虚拟机窗口。在 VirtualBox 主界面右键你的虚拟机并选中 “Setting”。VirtualBox 默认的网络设置是 “NAT”。将它改为 “Bridged Adapter” 后再尝试安装 FreeDOS 的软件包。现在就应该能正常运作了。
#### 第七步 – FreeDOS 的基本使用
##### 常见命令
既然你已经成功安装了 FreeDOS，让我们来看些基础命令。如果你已经在 Windows 平台使用过命令提示符，那么你会发现有很多命令都是相似的。
* `DIR`– 显示当前目录的内容
* `CD` – 改变当前所在的目录
* `COPY OLD.TXT NEW.TXT`– 复制文件
* `TYPE TEST.TXT` – 显示文件内容
* `DEL TEST.TXT` – 删除文件
* `XCOPY DIR NEWDIR` – 复制目录及目录下的所有内容
* `EDIT TEST.TXT`– 编辑一个文件
* `MKDIR NEWDIR` – 创建一个新目录
* `CLS` – 清除屏幕
你可以借助互联网或者 Jim Hall 所创建的 [方便的速查表](https://opensource.com/article/18/6/freedos-commands-cheat-sheet) 来找到更多基本的 DOS 命令。
##### 运行一个程序
在 FreeDOS 上运行程序相当简单。需要注意的是当你借助 `fdimples` 软件包管理器来安装一个应用程序的时候，要确保你指定了待安装程序的 .EXE 文件的路径。这个路径会在应用程序的详细信息中显示。要想运行程序，通常你还需要进入到程序所在文件夹并输入该程序的名字。
例如，FreeDOS 中你可以安装一个叫 `FED` 的编辑器。安装完成后，你还需要做的就是进入 `C:\FED` 这个文件夹下并输入 `FED`。
对于位于 `\bin` 这个文件夹的程序，比如 Pico。这些程序可以在任意文件夹中被调用。
对于游戏通常会有一个或者两个 .EXE 程序，你玩游戏之前不得不先运行它们。这些设置文件通常能够修复你遇到的声音，视频，或者控制问题。
如果你遇到一些本教程中没指出的问题，别忘记访问 [FreeDOS 主站](http://www.freedos.org/) 来寻求解决办法。他们有一个 wiki 和一些其他的支持选项。
你使用过 FreeDOS 吗？你还想看关于 FreeDOS 哪些方面的教程？请在下面的评论区告诉我们。
如果你觉得本篇文章很有趣，请花一分钟的时间将它分享在你的社交媒体，Hacker News 或者 [Reddit](http://reddit.com/r/linuxusersgroup)。
---
via: <https://itsfoss.com/install-freedos/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[WangYueScream](https://github.com/WangYueScream) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
所有人的 DevOps
|
Dawn Parych
|
https://opensource.com/article/18/11/how-non-engineer-got-devops
|
让一名非工程师来解释为什么你不必成为一位开发者或运维就能爱上 DevOps。
|
/data/attachment/album/201812/26/194613xvd2wvcgu2pjj9g3.png.thumb.jpg
|
/data/attachment/album/201812/26/194613xvd2wvcgu2pjj9g3.png
| true | false | true |
lujun9972
|
alim0x
|
wxy
| false |
[
"DevOps"
] |
观点
|
{
"viewnum": 3609,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
让一名非工程师来解释为什么你不必成为一位开发者或运维就能爱上 DevOps。
| 2018-12-26T19:46:00 | 2018-12-26T19:46:00 | 10,386 |
/article-10386-1.html
|
>
> 让一名非工程师来解释为什么你不必成为一位开发者或运维就能爱上 DevOps。
>
>
>
我从未做过开发或运维的工作 —— 那怎么我在写一篇关于 [DevOps](https://opensource.com/resources/devops) 的文章？我一直都对计算机和技术有兴趣。我还对社群、心理学以及帮助他人充满热情。当我第一次听到 DevOps 时，这个概念激起了我的兴趣，因为它看起来融合了很多我感兴趣的东西，即便我是不写代码的。
我的第一台电脑是 TRS-80，我喜欢在上面编写 BASIC 程序。我只上过两门我的高中开设的计算机编程课程。若干年后，我创办了一家计算机公司。我定制邮件标签和信纸，并建立了一个数据库来存储地址。
问题是我并不能从写代码中获得享受。我想要教育和帮助人们，我没法将写代码看作这样的一个机会。是的，技术可以帮助人们并改变生活，但是写代码没有点燃我的热情。我需要对我的工作感到兴奋并做我喜欢的事情。
我发现我爱 DevOps。对我而言，DevOps 指的是：
* 文化，而不是代码
* 过程，而不是结果
* 建立一个所有人可以持续提升的环境
* 沟通与合作，而不是独立工作
归根结底，DevOps 是指成为社区工作的一部分，实现共同的目标。DevOps 融合了心理学、社群、技术。DevOps 不是一个职位名称，它是一种生活和工作的哲学。
### 找到我的社群
快四年前，我在西雅图参加了我的第一个 [DevOps 日](https://www.devopsdays.org/) 会议。我感觉我找到了我的社群。我觉得受到了欢迎和接受，尽管我从事营销工作而且没有计算机科学文凭。我可以从心理学和技术中寻找乐趣。
在 DevOps 日，我学到了 [DevOps“三步工作法”](https://itrevolution.com/the-three-ways-principles-underpinning-devops/) —— 流动、反馈、持续实验和学习 —— 以及新（对我而言）的概念，如 Kaizen（改善）和 Kaikaku（改革）。随着我的学习深入，我发现我在说这样的话，“我是这样做的！我都不知道这样做还有个名字！”
[Kaizen（改善）](https://en.wikipedia.org/wiki/Kaizen)是持续改进和学习的实践。小的量变积累随着时间的推移可以引起质变。我发现它和卡罗尔·德韦克的[成长型思维](https://en.wikipedia.org/wiki/Mindset#Fixed_and_growth)的想法很相似。人们不是生来就是专家。在某方面拥有经验需要花费时间、练习，以及常常还有失败。承认增量的改善对确保我们不会放弃是很有必要的。
另一方面，[Kaikaku（改革）](https://en.wikipedia.org/wiki/Kaikaku)的概念是指，长时间的小的改变有时不能起作用，你需要做一些完全的或破坏性的改变。在没有找到下份工作前就辞职或移居新城市就足够有破坏性 —— 是的，两者我都做过。但这些彻底的改变收获巨大。如果我没有辞职并休息一段时间，我也许不会接触到 DevOps。等我决定继续工作的时候，我一直听到 DevOps，我开始研究它。这引导我参加了我的第一个 DevOps 日，从那里我开始看到我的所有热情开始聚集。从那时起，我已经参加了五次 DevOps 日活动，并且定期撰写关于 DevOps 话题的文章。
### 将三步工作法用到工作中
改变是困难的，学习新事物可以听起来很吓人。DevOps 的三步工作法提供了一个管理改变的框架。比如：信息流动是怎样的？是什么驱动着你做出改变？一旦你认为一个改变是必需的，你如何获得这个改变是否正确的反馈？你如何知道你在取得进展？反馈是必要的，并且应该包含积极和有建设性的要素。困难的地方在于保证建设性的要素不要重于积极要素。
对我而言，第三步 —— 持续实验和学习 —— 是 DevOps 最重要的部分。有一个可以自由地实验和冒险的环境，人们可以获得意想不到的结果。有时这些结果是好的，有时不是太好 —— 但这没事。创建一个可以接受失败结果的环境可以鼓励人们冒险。我们都应该力争定期的持续实验和学习。
DevOps 的三步工作法提供了一个尝试，获得反馈，以及从错误中获取经验的方法。几年前，我的儿子告诉我，“我从来就没想做到最好，因为那样我就没法从我的错误中学到东西了。”我们都会犯错，从中获得经验帮助我们成长和改善。如果我们的文化不支持尝试和学习，我们就不会愿意去犯错。
### 成为社区的一部分
我已经在技术领域工作了超过 20 年，直到我发现 DevOps 社区前，我还经常感觉自己是个外行。如果你像我一样——对技术充满热情，但不是工程和运维那方面——你仍然可以成为 DevOps 的一部分，即便你从事的是销售、营销、产品营销、技术写作、支持或其他工作。DevOps 是属于所有人的。
---
via: <https://opensource.com/article/18/11/how-non-engineer-got-devops>
作者：[Dawn Parych](https://opensource.com/users/dawnparzych) 选题：[lujun9972](https://github.com/lujun9972) 译者：[alim0x](https://github.com/alim0x) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 Linux 终端中观看火焰
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-aafire
|
何不在命令行中进行一次“烧烤”呢？
|
/data/attachment/album/201812/26/200328cl8ncxkp8w8xznn4.png.thumb.jpg
|
/data/attachment/album/201812/26/200328cl8ncxkp8w8xznn4.png
| true | false | true |
lujun9972
|
zhs852
|
wxy
| false |
[
"命令行"
] |
分享
|
{
"viewnum": 7416,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "125.78.85.211",
"message": "gvbrdfee",
"username": "来自福建泉州的 Chromium 71.0|Ubuntu 用户",
"date": "2018-12-28T13:53:53"
}
] |
[] |
何不在命令行中进行一次“烧烤”呢？
| 2018-12-26T20:03:00 | 2018-12-26T20:03:00 | 10,387 |
/article-10387-1.html
|
>
> 何不在命令行中进行一次“烧烤”呢？
>
>
>
这里是《24 天了解 Linux 命令行小玩意》。如果你未曾读过本系列的文章，可以在本文的结尾部分获取上一篇文章的链接，以了解本系列的大概内容。我们所介绍的命令行小玩意可供你消遣无聊时光。
你或许知道它们其中的一些，也可能不曾知晓它们。无论如何，我们都希望你能度过一段愉快的时光。
如果你住在北半球的非热带地区，可能冬季来临时你会被冻得满脸通红。住在这里的我，最喜欢的事情便是在火炉旁惬意地边喝茶边读书。
不幸的是，我家刚好缺个放火炉的地方。不过，多亏了今天我要介绍的 `aafire` ，我仍然可以假装我坐在火炉旁。
在我所使用的系统里， `aafire` 被打包进了 aalib 。 aalib 是一个受人喜爱的库，它可以很方便地将图像转换成 ASCII 图并输出到终端（或其它任何地方）。 aalib 将多种多样的图像带入了 Linux 终端。你可以看看本系列的其它文章，了解一下其它小程序，以便配合使用并充分利用它们。在 Fedora 中，你可以通过以下命令来安装 aalib ：
```
$ sudo dnf install aalib
```
接着，试着运行 `aafire` 命令。 `aalib` 默认会使用 GUI 模式，我们要进行一些操作来让它在终端中运行（毕竟这一系列文章都讲的是命令行）。十分幸运的是，仅需安装 [curses](https://en.wikipedia.org/wiki/Curses_(programming_library)) 就能实现我们想要的效果。请执行：
```
$ aafire -driver curses
```
如果你觉得 aalib 挺有意思，可以在 [Sourceforge](http://aa-project.sourceforge.net/aalib/) 上找到它的源码（以 LGPLv2 许可证开源）。
欢迎将你觉得有意思的命令行小程序投稿到原作者处，只需在原文下留言即可。
如果有兴趣，可以查看原作者的上一篇文章： [在命令行中步入黑客帝国](https://opensource.com/article/18/12/linux-toy-cmatrix) 。
---
via: <https://opensource.com/article/18/12/linux-toy-aafire>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[zhs852](https://github.com/zhs852) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
27 个全方位的开放式教育解决方案
|
Don Watkins
|
https://opensource.com/article/18/1/best-open-education
|
阅读这些 2017 年 Opensource.com 发布的开放如何改进教育和学习的好文章。
|
/data/attachment/album/201812/26/211736vbywyn5lbbnnn4ll.png.thumb.jpg
|
/data/attachment/album/201812/26/211736vbywyn5lbbnnn4ll.png
| true | false | true |
lixinyuxx
|
wxy
| false |
[
"教育",
"开放"
] |
分享
|
{
"viewnum": 4200,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
阅读这些 2017 年 Opensource.com 发布的开放如何改进教育和学习的好文章。
| 2018-12-26T21:17:00 | 2018-12-26T21:17:00 | 10,388 |
/article-10388-1.html
|
>
> 阅读这些 2017 年 Opensource.com 发布的开放如何改进教育和学习的好文章。
>
>
>
开放式理念 (从开源软件到开放硬件，再到开放原则) 正在改变教育的范式。因此，为了庆祝今年发生的一切，我收集了 2017 年（译注：本文原发布于 2018 年初）在 Opensource.com 上发表的 27 篇关于这个主题的最好的文章。我把它们分成明确的主题，而不是按人气来分类。而且，如果这 27 个故事不能满足你对教育方面开源信息的胃口，那就看看我们的合作文章吧 “[教育如何借助 Linux 和树莓派](https://opensource.com/article/17/12/best-opensourcecom-linux-and-raspberry-pi-education)”。
### 开放对每个人都有好处
1. [书评：《OPEN》探讨了开放性的广泛文化含义](https://opensource.com/article/17/7/book-review-open)：Scott Nesbitt 评价 David Price 的书 《OPEN》 ，该书探讨了 “开放” 不仅仅是技术转变的观点，而是 “我们未来将如何工作、生活和学习”。
2. [通过开源技能快速开始您的职业生涯](https://opensource.com/article/17/8/jump-start-your-career): VM (Vicky) Brasseur 指出了如何借助学习开源在工作群体中脱颖而出。这个建议不仅仅是针对程序员的；设计师、作家、营销人员和其他创意专业人士也对开源的成功至关重要。
3. [研究生学位可以让你跳槽到开源职位](https://opensource.com/article/17/1/grad-school-open-source-academic-lab)：引用的研究表明会 Linux 技能会带来更高的薪水， Joshua Pearce 说对开源的熟练和研究生学位是无与伦比的职业技能组合。
4. [彻底改变了宾夕法尼亚的学校文化的三种实践](https://opensource.com/article/17/7/open-school-leadership)：Charlie Reisinger 向我们展示了开放式实践是如何在宾夕法尼亚州的一个学区创造一种更具包容性、敏捷性和开放性的文化的。Charlie 说，这不仅仅是为了省钱；该区还受益于 “开放式领导原则，促进师生创新，帮助更好地吸引社区，创造一个更有活力和包容性的学习社区”。
5. [使用开源工具促使学生进步的 15 种方法](https://opensource.com/article/17/7/empower-students-open-source-tools)：我写了开源是如何让学生自由探索、补拙和学习的，不管他们是在学习基本的数字化素养，还是通过有趣的项目来扩展这些技能。
6. [开发人员有机会编写好的代码](https://opensource.com/article/17/3/interview-anh-bui-benetech-labs)：开源往往是对社会有益的项目的支柱。正如 Benetech Labs 副总裁 Ahn Bui 在这次采访中指出的那样：“建立开放数据标准是打破数据孤岛不可或缺的一步。这些开放标准将为互操作性提供基础，进而转化为更多的组织共同建设，往往更具成本效益。最终目标是以同样的成本甚至更低的成本为更多的人服务。”
### 用于再融合和再利用的开放式教育资源
1. [学术教员可以和维基百科一起教学吗？](https://opensource.com/article/17/1/Wiki-Education-Foundation)：Wiki Ed 的项目总监 LiAnna Davis 讨论<ruby> 开放式教育资源 <rt> open educational resources </rt></ruby> (OER) ，如 Wiki Ed，是如何提供高质量且经济实惠的开源学习资源作为课堂教学工具。
2. [书本内外？开放教育资源的状态](https://opensource.com/article/17/2/future-textbooks-cable-green-creative-commons)：Cable Green 是 Creative Common 开放教育主管，分享了高等教育中教育面貌是如何变化的，以及 Creative Common 正在采取哪些措施来促进教育。
3. [急需符合标准的课程的学校系统找到了希望](https://opensource.com/article/17/1/open-up-resources)：Karen Vaites 是 Open Up Resources 社区布道师和首席营销官，谈论了非营利组织努力为 K-12 学校提供开放的、标准一致的课程。
4. [夏威夷大学如何解决当今高等教育的问题](https://opensource.com/article/17/2/interview-education-billy-meinke)：夏威夷大学 Manoa 分校的教育技术专家 Billy Meinke 表示，在大学课程中过渡到 ORE 将 “使教师能够控制他们教授的内容，我们预计这将为他们节省学生的费用。”
5. [开放式课程如何削减高等教育成本](https://opensource.com/article/17/7/college-alternatives)：塞勒学院的教育总监 Devon Ritter 报告了塞勒学院是如何建立以公开许可内容为基础的大学学分课程，目的是使更多的人能够负担得起和获得高等教育。
6. [开放教育资源运动在提速](https://opensource.com/article/17/10/open-educational-resources-alexis-clifton)：Alexis Clifton 是纽约州立大学的 OER 服务的执行董事，描述了纽约 800 万美元的投资如何刺激开放教育的增长，并使大学更实惠。
7. [开放项目合作，从小学到大学教室](https://opensource.com/article/17/3/education-should-be-open-design)：来自杜克大学的 Aria F. Chernik 探索 OSPRI (开源教育学的研究与创新)， 这是杜克大学和红帽的合作，旨在建立一个 21 世纪的，开放设计的 preK-12 学习生态系统。
8. [Perma.cc 将阻止学术链接腐烂](https://opensource.com/article/17/9/stop-link-rot-permacc)：：弗吉尼亚理工大学的 Phillip Young 写的关于 Perma.cc 的文章，这种一种“链接腐烂”的解决方案，在学术论文中的超链接随着时间的推移而消失或变化的概览很高。
9. [开放教育：学生如何通过创建开放教科书来节省资金](https://opensource.com/article/17/11/creating-open-textbooks)：OER 先驱 Robin DeRosa 谈到 “引入公开许可教科书的自由，以及教育和学习应结合包容性生态系统，以增强公益的总体理念”。
### 课堂上的开源工具
1. [开源棋盘游戏如何拯救地球](https://opensource.com/article/17/7/save-planet-board-game)：Joshua Pearce 写的关于拯救地球的一个棋盘游戏，这是一款让学生在玩乐和为创客社区做出贡献的同时解决环境问题的棋盘游戏。
2. [一个教孩子们如何阅读的新 Android 应用程序](https://opensource.com/article/17/4/phoenicia-education-software)：Michael Hall 谈到了他在儿子被诊断为自闭症后为他开发的儿童识字应用 Phoenicia，以及良好编码的价值，和为什么用户测试比你想象的更重要。
3. [8 个用于教育的开源 Android 应用程序](https://opensource.com/article/17/8/8-open-source-android-apps-education)：Joshua Allen Holm 推荐了 8 个来自 F-Droid 软件库的开源应用，使我们可以将智能手机用作学习工具。
4. [MATLA B的 3 种开源替代方案](https://opensource.com/alternatives/matlab)：Jason Baker 更新了他 2016 年的开源数学计算软件调查报告，提供了 MATLAB 的替代方案，这是数学、物理科学、工程和经济学中几乎无处不在的昂贵的专用解决方案。
5. [SVG 与教孩子编码有什么关系？](https://opensource.com/article/17/5/coding-scalable-vector-graphics-make-steam)：退休工程师 Jay Nick 谈论他如何使用艺术作为一种创新的方式，向学生介绍编码。他在学校做志愿者，使用 SVG 来教授一种结合数学和艺术原理的编码方法。
6. [5 个破灭的神话：在高等教育中使用开源](https://opensource.com/article/17/5/how-linux-higher-education): 拥有德克萨斯理工大学美术博士学位的 Kyle Conway 分享他在一个由专有解决方案统治的世界中使用开源工具的经验。 Kyle 说有一种偏见，反对在计算机科学以外的学科中使用开源：“很多人认为非技术专业的学生不能使用 Linux，他们对在高级学位课程中使用 Linux 的人做出了很多假设……嗯，这是有可能的，我就是证明。”
7. [大学开源工具列表](https://opensource.com/article/17/6/open-source-tools-university-student)：Aaron Cocker 概述了他在攻读计算机科学本科学位时使用的开源工具 (包括演示、备份和编程软件)。
8. [5 个可帮助您学习优秀 KDE 应用程序](https://opensource.com/article/17/6/kde-education-software)：Zsolt Szakács 提供五个 KDE 应用程序，可以帮助任何想要学习新技能或培养现有技能的人。
### 在教室编码
1. [如何尽早让下一代编码](https://opensource.com/article/17/8/teach-kid-code-change-life)：Bryson Payne 说我们需要在高中前教孩子们学会编码: 到了九年级，80% 的女孩和 60% 的男孩已经从 STEM 职业中自选。但他建议，这不仅仅是就业和缩小 IT 技能差距的问题。“教一个年轻人编写代码可能是你能给他们的最改变生活的技能。而且这不仅仅是一个职业提升者。编码是关于解决问题，它是关于创造力，更重要的是，它是提升能力”。
2. [孩子们无法在没有计算机的情况下编码](https://opensource.com/article/17/9/floss-desktops-kids)：Patrick Masson 推出了 FLOSS 儿童桌面计划， 该计划教授服务不足学校的学生使用开源软件 (如 Linux、LibreOffice 和 GIMP) 重新利用较旧的计算机。该计划不仅为破旧或退役的硬件注入新的生命，还为学生提供了重要的技能，而且还为学生提供了可能转化为未来职业生涯的重要技能。
3. [如今 Scratch 是否能像 80 年代的 LOGO 语言一样教孩子们编码？](https://opensource.com/article/17/3/logo-scratch-teach-programming-kids)：Anderson Silva 提出使用 [Scratch](https://scratch.mit.edu/) 以激发孩子们对编程的兴趣，就像在 20 世纪 80 年代开始使用 LOGO 语言时一样。
4. [通过这个拖放框架学习Android开发](https://opensource.com/article/17/8/app-inventor-android-app-development)：Eric Eslinger 介绍了 App Inventor，这是一个编程框架，用于构建 Android 应用程序使用可视块语言（类似 Scratch 或者 [Snap](http://snap.berkeley.edu/)）。
在这一年里，我们了解到，教育领域的各个方面都有了开放的解决方案，我预计这一主题将在 2018 年及以后继续下去。在未来的一年里，你是否希望 Opensource.com 涵盖开放式的教育主题？如果是， 请在评论中分享你的想法。
---
via: <https://opensource.com/article/18/1/best-open-education>
作者：[Don Watkins](https://opensource.com/users/don-watkins) 译者：[lixinyuxx](https://github.com/lixinyuxx) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
Caffeinated 6.828：实验 5：文件系统、Spawn 和 Shell
|
Csail.mit
|
https://pdos.csail.mit.edu/6.828/2018/labs/lab5/
|
在本实验中，你将要去实现 spawn，它是一个加载和运行磁盘上可运行文件的库调用。然后，你接着要去充实你的内核和库，以使操作系统能够在控制台上运行一个 shell。而这些特性需要一个文件系统，本实验将引入一个可读/写的简单文件系统。
|
/data/attachment/album/201812/27/125429u3xhxx1urgh9zkkl.jpg.thumb.jpg
|
/data/attachment/album/201812/27/125429u3xhxx1urgh9zkkl.jpg
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"6.828"
] |
技术
|
{
"viewnum": 5283,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 2,
"likes": 0
}
|
[] |
[
{
"raid": 10351,
"displayorder": 0
},
{
"raid": 10452,
"displayorder": 0
}
] |
在本实验中，你将要去实现 spawn，它是一个加载和运行磁盘上可运行文件的库调用。然后，你接着要去充实你的内核和库，以使操作系统能够在控制台上运行一个 shell。而这些特性需要一个文件系统，本实验将引入一个可读/写的简单文件系统。
| 2018-12-27T12:54:44 | 2018-12-27T12:54:44 | 10,389 |
/article-10389-1.html
|
### 简介
在本实验中，你将要去实现 `spawn`，它是一个加载和运行磁盘上可运行文件的库调用。然后，你接着要去充实你的内核和库，以使操作系统能够在控制台上运行一个 shell。而这些特性需要一个文件系统，本实验将引入一个可读/写的简单文件系统。
#### 预备知识
使用 Git 去获取最新版的课程仓库，然后创建一个命名为 `lab5` 的本地分支，去跟踪远程的 `origin/lab5` 分支：
```
athena% cd ~/6.828/lab
athena% add git
athena% git pull
Already up-to-date.
athena% git checkout -b lab5 origin/lab5
Branch lab5 set up to track remote branch refs/remotes/origin/lab5.
Switched to a new branch "lab5"
athena% git merge lab4
Merge made by recursive.
.....
athena%
```
在实验中这一部分的主要新组件是文件系统环境，它位于新的 `fs` 目录下。通过检查这个目录中的所有文件，我们来看一下新的文件都有什么。另外，在 `user` 和 `lib` 目录下还有一些文件系统相关的源文件。
* `fs/fs.c` 维护文件系统在磁盘上结构的代码
* `fs/bc.c` 构建在我们的用户级页故障处理功能之上的一个简单的块缓存
* `fs/ide.c` 极简的基于 PIO（非中断驱动的）IDE 驱动程序代码
* `fs/serv.c` 使用文件系统 IPC 与客户端环境交互的文件系统服务器
* `lib/fd.c` 实现一个常见的类 UNIX 的文件描述符接口的代码
* `lib/file.c` 磁盘上文件类型的驱动，实现为一个文件系统 IPC 客户端
* `lib/console.c` 控制台输入/输出文件类型的驱动
* `lib/spawn.c` spawn 库调用的框架代码
你应该再次去运行 `pingpong`、`primes` 和 `forktree`，测试实验 4 完成后合并到新的实验 5 中的代码能否正确运行。你还需要在 `kern/init.c` 中注释掉 `ENV_CREATE(fs_fs)` 行，因为 `fs/fs.c` 将尝试去做一些 I/O，而 JOS 到目前为止还不具备该功能。同样，在 `lib/exit.c` 中临时注释掉对 `close_all()` 的调用；这个函数将调用你在本实验后面部分去实现的子程序，如果现在去调用，它将导致 JOS 内核崩溃。如果你的实验 4 的代码没有任何 bug，将很完美地通过这个测试。在它们都能正常工作之前是不能继续后续实验的。在你开始做练习 1 时，不要忘记去取消这些行上的注释。
如果它们不能正常工作，使用 `git diff lab4` 去重新评估所有的变更，确保你在实验 4（及以前）所写的代码在本实验中没有丢失。确保实验 4 仍然能正常工作。
#### 实验要求
和以前一样，你需要做本实验中所描述的所有常规练习和至少一个挑战问题。另外，你需要写出你在本实验中问题的详细答案，和你是如何解决挑战问题的一个简短（即：用一到两个段落）的描述。如果你实现了多个挑战问题，你只需要写出其中一个即可，当然，我们欢迎你做的越多越好。在你动手实验之前，将你的问题答案写入到你的 `lab5` 根目录下的一个名为 `answers-lab5.txt` 的文件中。
### 文件系统的雏形
你将要使用的文件系统比起大多数“真正的”文件系统（包括 xv6 UNIX 的文件系统）要简单的多，但它也是很强大的，足够去提供基本的特性：创建、读取、写入和删除组织在层次目录结构中的文件。
到目前为止，我们开发的是一个单用户操作系统，它提供足够的保护并能去捕获 bug，但它还不能在多个不可信用户之间提供保护。因此，我们的文件系统还不支持 UNIX 的所有者或权限的概念。我们的文件系统目前也不支持硬链接、时间戳、或像大多数 UNIX 文件系统实现的那些特殊的设备文件。
### 磁盘上的文件系统结构
主流的 UNIX 文件系统将可用磁盘空间分为两种主要的区域类型：节点区域和数据区域。UNIX 文件系统在文件系统中为每个文件分配一个节点；一个文件的节点保存了这个文件重要的元数据，比如它的 `stat` 属性和指向数据块的指针。数据区域被分为更大的（一般是 8 KB 或更大）数据块，它在文件系统中存储文件数据和目录元数据。目录条目包含文件名字和指向到节点的指针；如果文件系统中的多个目录条目指向到那个文件的节点上，则称该文件是硬链接的。由于我们的文件系统不支持硬链接，所以我们不需要这种间接的级别，并且因此可以更方便简化：我们的文件系统将压根就不使用节点，而是简单地将文件的（或子目录的）所有元数据保存在描述那个文件的（唯一的）目录条目中。
文件和目录逻辑上都是由一系列的数据块组成，它或许是很稀疏地分散到磁盘上，就像一个环境的虚拟地址空间上的页，能够稀疏地分散在物理内存中一样。文件系统环境隐藏了块布局的细节，只提供文件中任意偏移位置读写字节序列的接口。作为像文件创建和删除操作的一部分，文件系统环境服务程序在目录内部完成所有的修改。我们的文件系统允许用户环境去直接读取目录元数据（即：使用 `read`），这意味着用户环境自己就能够执行目录扫描操作（即：实现 `ls` 程序），而不用另外依赖对文件系统的特定调用。用这种方法做目录扫描的缺点是，（也是大多数现代 UNIX 操作系统变体摒弃它的原因）使得应用程序依赖目录元数据的格式，如果不改变或至少要重编译应用程序的前提下，去改变文件系统的内部布局将变得很困难。
#### 扇区和块
大多数磁盘都不能执行以字节为粒度的读写操作，而是以扇区为单位执行读写。在 JOS 中，每个扇区是 512 字节。文件系统实际上是以块为单位来分配和使用磁盘存储的。要注意这两个术语之间的区别：扇区大小是硬盘硬件的属性，而块大小是使用这个磁盘的操作系统上的术语。一个文件系统的块大小必须是底层磁盘的扇区大小的倍数。
UNIX xv6 文件系统使用 512 字节大小的块，与它底层磁盘的扇区大小一样。而大多数现代文件系统使用更大尺寸的块，因为现在存储空间变得很廉价了，而使用更大的粒度在存储管理上更高效。我们的文件系统将使用 4096 字节的块，以更方便地去匹配处理器上页的大小。
#### 超级块
文件系统一般在磁盘上的“易于查找”的位置（比如磁盘开始或结束的位置）保留一些磁盘块，用于保存描述整个文件系统属性的元数据，比如块大小、磁盘大小、用于查找根目录的任何元数据、文件系统最后一次挂载的时间、文件系统最后一次错误检查的时间等等。这些特定的块被称为超级块。
我们的文件系统只有一个超级块，它固定为磁盘的 1 号块。它的布局定义在 `inc/fs.h` 文件里的 `struct Super` 中。而 0 号块一般是保留的，用于去保存引导加载程序和分区表，因此文件系统一般不会去使用磁盘上比较靠前的块。许多“真实的”文件系统都维护多个超级块，并将它们复制到间隔较大的几个区域中，这样即便其中一个超级块坏了或超级块所在的那个区域产生了介质错误，其它的超级块仍然能够被找到并用于去访问文件系统。
#### 文件元数据
元数据的布局是描述在我们的文件系统中的一个文件中，这个文件就是 `inc/fs.h` 中的 `struct File`。元数据包含文件的名字、大小、类型（普通文件还是目录）、指向构成这个文件的块的指针。正如前面所提到的，我们的文件系统中并没有节点，因此元数据是保存在磁盘上的一个目录条目中，而不是像大多数“真正的”文件系统那样保存在节点中。为简单起见，我们将使用 `File` 这一个结构去表示文件元数据，因为它要同时出现在磁盘上和内存中。
在 `struct File` 中的数组 `f_direct` 包含一个保存文件的前 10 个块（`NDIRECT`）的块编号的空间，我们称之为文件的直接块。对于最大 `10*4096 = 40KB` 的小文件，这意味着这个文件的所有块的块编号将全部直接保存在结构 `File` 中，但是，对于超过 40 KB 大小的文件，我们需要一个地方去保存文件剩余的块编号。所以我们分配一个额外的磁盘块，我们称之为文件的间接块，由它去保存最多 4096/4 = 1024 个额外的块编号。因此，我们的文件系统最多允许有 1034 个块，或者说不能超过 4MB 大小。为支持大文件，“真正的”文件系统一般都支持两个或三个间接块。
#### 目录与普通文件
我们的文件系统中的结构 `File` 既能够表示一个普通文件，也能够表示一个目录；这两种“文件”类型是由 `File` 结构中的 `type` 字段来区分的。除了文件系统根本就不需要解释的、分配给普通文件的数据块的内容之外，它使用完全相同的方式来管理普通文件和目录“文件”，文件系统将目录“文件”的内容解释为包含在目录中的一系列的由 `File` 结构所描述的文件和子目录。
在我们文件系统中的超级块包含一个结构 `File`（在 `struct Super` 中的 `root` 字段中）,它用于保存文件系统的根目录的元数据。这个目录“文件”的内容是一系列的 `File` 结构所描述的、位于文件系统根目录中的文件和目录。在根目录中的任何子目录转而可以包含更多的 `File` 结构所表示的子目录，依此类推。
### 文件系统
本实验的目标并不是让你去实现完整的文件系统，你只需要去实现几个重要的组件即可。实践中，你将负责把块读入到块缓存中，并且刷新脏块到磁盘上；分配磁盘块；映射文件偏移量到磁盘块；以及实现读取、写入、和在 IPC 接口中打开。因为你并不去实现完整的文件系统，熟悉提供给你的代码和各种文件系统接口是非常重要的。
### 磁盘访问
我们的操作系统的文件系统环境需要能访问磁盘，但是我们在内核中并没有实现任何磁盘访问的功能。与传统的在内核中添加了 IDE 磁盘驱动程序、以及允许文件系统去访问它所必需的系统调用的“大一统”策略不同，我们将 IDE 磁盘驱动实现为用户级文件系统环境的一部分。我们仍然需要对内核做稍微的修改，是为了能够设置一些东西，以便于文件系统环境拥有实现磁盘访问本身所需的权限。
只要我们依赖轮询、基于 “编程的 I/O”（PIO）的磁盘访问，并且不使用磁盘中断，那么在用户空间中实现磁盘访问还是很容易的。也可以去实现由中断驱动的设备驱动程序（比如像 L3 和 L4 内核就是这么做的），但这样做的话，内核必须接收设备中断并将它派发到相应的用户模式环境上，这样实现的难度会更大。
x86 处理器在 EFLAGS 寄存器中使用 IOPL 位去确定保护模式中的代码是否允许执行特定的设备 I/O 指令，比如 `IN` 和 `OUT` 指令。由于我们需要的所有 IDE 磁盘寄存器都位于 x86 的 I/O 空间中而不是映射在内存中，所以，为了允许文件系统去访问这些寄存器，我们需要做的唯一的事情便是授予文件系统环境“I/O 权限”。实际上，在 EFLAGS 寄存器的 IOPL 位上规定，内核使用一个简单的“要么全都能访问、要么全都不能访问”的方法来控制用户模式中的代码能否访问 I/O 空间。在我们的案例中，我们希望文件系统环境能够去访问 I/O 空间，但我们又希望任何其它的环境完全不能访问 I/O 空间。
>
> **练习 1**、`i386_init` 通过将类型 `ENV_TYPE_FS` 传递给你的环境创建函数 `env_create` 来识别文件系统。修改 `env.c` 中的 `env_create` ，以便于它只授予文件系统环境 I/O 的权限，而不授予任何其它环境 I/O 的权限。
>
>
> 确保你能启动这个文件系统环境，而不会产生一般保护故障。你应该要通过在 `make grade` 中的 fs i/o 测试。
>
>
>
.
>
> **问题 1**、当你从一个环境切换到另一个环境时，你是否需要做一些操作来确保 I/O 权限设置能被保存和正确地恢复？为什么？
>
>
>
注意本实验中的 `GNUmakefile` 文件，它用于设置 QEMU 去使用文件 `obj/kern/kernel.img` 作为磁盘 0 的镜像（一般情况下表示 DOS 或 Windows 中的 “C 盘”），以及使用（新）文件 `obj/fs/fs.img` 作为磁盘 1 的镜像（”D 盘“）。在本实验中，我们的文件系统应该仅与磁盘 1 有交互；而磁盘 0 仅用于去引导内核。如果你想去恢复其中一个有某些错误的磁盘镜像，你可以通过输入如下的命令，去重置它们到最初的、”崭新的“版本：
```
$ rm obj/kern/kernel.img obj/fs/fs.img
$ make
```
或者：
```
$ make clean
$ make
```
小挑战！实现中断驱动的 IDE 磁盘访问，既可以使用也可以不使用 DMA 模式。由你来决定是否将设备驱动移植进内核中、还是与文件系统一样保留在用户空间中、甚至是将它移植到一个它自己的的单独的环境中（如果你真的想了解微内核的本质的话）。
### 块缓存
在我们的文件系统中，我们将在处理器虚拟内存系统的帮助下，实现一个简单的”缓冲区“（实际上就是一个块缓冲区）。块缓存的代码在 `fs/bc.c` 文件中。
我们的文件系统将被限制为仅能处理 3GB 或更小的磁盘。我们保留一个大的、尺寸固定为 3GB 的文件系统环境的地址空间区域，从 0x10000000（`DISKMAP`）到 0xD0000000（`DISKMAP+DISKMAX`）作为一个磁盘的”内存映射版“。比如，磁盘的 0 号块被映射到虚拟地址 0x10000000 处，磁盘的 1 号块被映射到虚拟地址 0x10001000 处，依此类推。在 `fs/bc.c` 中的 `diskaddr` 函数实现从磁盘块编号到虚拟地址的转换（以及一些完整性检查）。
由于我们的文件系统环境在系统中有独立于所有其它环境的虚拟地址空间之外的、它自己的虚拟地址空间，并且文件系统环境仅需要做的事情就是实现文件访问，以这种方式去保留大多数文件系统环境的地址空间是很明智的。如果在一台 32 位机器上的”真实的“文件系统上这么做是很不方便的，因为现在的磁盘都远大于 3 GB。而在一台有 64 位地址空间的机器上，这样的缓存管理方法仍然是明智的。
当然，将整个磁盘读入到内存中需要很长时间，因此，我们将它实现成”按需“分页的形式，那样我们只在磁盘映射区域中分配页，并且当在这个区域中产生页故障时，从磁盘读取相关的块去响应这个页故障。通过这种方式，我们能够假装将整个磁盘装进了内存中。
>
> **练习 2**、在 `fs/bc.c` 中实现 `bc_pgfault` 和 `flush_block` 函数。`bc_pgfault` 函数是一个页故障服务程序，就像你在前一个实验中编写的写时复制 fork 一样，只不过它的任务是从磁盘中加载页去响应一个页故障。在你编写它时，记住： (1) `addr` 可能并不会做边界对齐，并且 (2) 在扇区中的 `ide_read` 操作并不是以块为单位的。
>
>
> （如果需要的话）函数 `flush_block` 应该会将一个块写入到磁盘上。如果在块缓存中没有块（也就是说，页没有映射）或者它不是一个脏块，那么 `flush_block` 将什么都不做。我们将使用虚拟内存硬件去跟踪，磁盘块自最后一次从磁盘读取或写入到磁盘之后是否被修改过。查看一个块是否需要写入时，我们只需要去查看 `uvpt` 条目中的 `PTE_D` 的 ”dirty“ 位即可。（`PTE_D` 位由处理器设置，用于表示那个页被写入；具体细节可以查看 x386 参考手册的 [第 5 章](http://pdos.csail.mit.edu/6.828/2011/readings/i386/s05_02.htm) 的 5.2.4.3 节）块被写入到磁盘上之后，`flush_block` 函数将使用 `sys_page_map` 去清除 `PTE_D` 位。
>
>
> 使用 `make grade` 去测试你的代码。你的代码应该能够通过 check\_bc、check\_super、和 check\_bitmap 的测试。
>
>
>
在 `fs/fs.c` 中的函数 `fs_init` 是块缓存使用的一个很好的示例。在初始化块缓存之后，它简单地在全局变量 `super` 中保存指针到磁盘映射区。在这之后，如果块在内存中，或我们的页故障服务程序按需将它们从磁盘上读入后，我们就能够简单地从 `super` 结构中读取块了。
.
>
> **小挑战！**到现在为止，块缓存还没有清除策略。一旦某个块因为页故障被读入到缓存中之后，它将一直不会被清除，并且永远保留在内存中。给块缓存增加一个清除策略。在页表中使用 `PTE_A` 的 accessed 位来实现，任何环境访问一个页时，硬件就会设置这个位，你可以通过它来跟踪磁盘块的大致使用情况，而不需要修改访问磁盘映射区域的任何代码。使用脏块要小心。
>
>
>
### 块位图
在 `fs_init` 设置了 `bitmap` 指针之后，我们可以认为 `bitmap` 是一个装满比特位的数组，磁盘上的每个块就是数组中的其中一个比特位。比如 `block_is_free`，它只是简单地在位图中检查给定的块是否被标记为空闲。
>
> **练习 3**、使用 `free_block` 作为实现 `fs/fs.c` 中的 `alloc_block` 的一个模型，它将在位图中去查找一个空闲的磁盘块，并将它标记为已使用，然后返回块编号。当你分配一个块时，你应该立即使用 `flush_block` 将已改变的位图块刷新到磁盘上，以确保文件系统的一致性。
>
>
> 使用 `make grade` 去测试你的代码。现在，你的代码应该要通过 alloc\_block 的测试。
>
>
>
### 文件操作
在 `fs/fs.c` 中，我们提供一系列的函数去实现基本的功能，比如，你将需要去理解和管理结构 `File`、扫描和管理目录”文件“的条目、 以及从根目录开始遍历文件系统以解析一个绝对路径名。阅读 `fs/fs.c` 中的所有代码，并在你开始实验之前，确保你理解了每个函数的功能。
>
> **练习 4**、实现 `file_block_walk` 和 `file_get_block`。`file_block_walk` 从一个文件中的块偏移量映射到 `struct File` 中那个块的指针上或间接块上，它非常类似于 `pgdir_walk` 在页表上所做的事。`file_get_block` 将更进一步，将去映射一个真实的磁盘块，如果需要的话，去分配一个新的磁盘块。
>
>
> 使用 `make grade` 去测试你的代码。你的代码应该要通过 file\_open、filegetblock、以及 fileflush/filetruncated/file rewrite、和 testfile 的测试。
>
>
>
`file_block_walk` 和 `file_get_block` 是文件系统中的”劳动模范“。比如，`file_read` 和 `file_write` 或多或少都在 `file_get_block` 上做必需的登记工作，然后在分散的块和连续的缓存之间复制字节。
.
>
> **小挑战！**如果操作在中途实然被打断（比如，突然崩溃或重启），文件系统很可能会产生错误。实现软件更新或日志处理的方式让文件系统的”崩溃可靠性“更好，并且演示一下旧的文件系统可能会崩溃，而你的更新后的文件系统不会崩溃的情况。
>
>
>
### 文件系统接口
现在，我们已经有了文件系统环境自身所需的功能了，我们必须让其它希望使用文件系统的环境能够访问它。由于其它环境并不能直接调用文件系统环境中的函数，我们必须通过一个远程过程调用或 RPC、构建在 JOS 的 IPC 机制之上的抽象化来暴露对文件系统的访问。如下图所示，下图是对文件系统服务调用（比如：读取）的样子：
```
Regular env FS env
+---------------+ +---------------+
| read | | file_read |
| (lib/fd.c) | | (fs/fs.c) |
...|.......|.......|...|.......^.......|...............
| v | | | | RPC mechanism
| devfile_read | | serve_read |
| (lib/file.c) | | (fs/serv.c) |
| | | | ^ |
| v | | | |
| fsipc | | serve |
| (lib/file.c) | | (fs/serv.c) |
| | | | ^ |
| v | | | |
| ipc_send | | ipc_recv |
| | | | ^ |
+-------|-------+ +-------|-------+
| |
+-------------------+
```
圆点虚线下面的过程是一个普通的环境对文件系统环境请求进行读取的简单机制。从（我们提供的）在任何文件描述符上的 `read` 工作开始，并简单地派发到相关的设备读取函数上，在我们的案例中是 `devfile_read`（我们还有更多的设备类型，比如管道）。`devfile_read` 实现了对磁盘上文件指定的 `read`。它和 `lib/file.c` 中的其它的 `devfile_*` 函数实现了客户端侧的文件系统操作，并且所有的工作大致都是以相同的方式来完成的，把参数打包进一个请求结构中，调用 `fsipc` 去发送 IPC 请求以及解包并返回结果。`fsipc` 函数把发送请求到服务器和接收来自服务器的回复的普通细节做了简化处理。
在 `fs/serv.c` 中可以找到文件系统服务器代码。它是一个 `serve` 函数的循环，无休止地接收基于 IPC 的请求，并派发请求到相关的服务函数，并通过 IPC 来回送结果。在读取示例中，`serve` 将派发到 `serve_read` 函数上，它将去处理读取请求的 IPC 细节，比如，解包请求结构并最终调用 `file_read` 去执行实际的文件读取动作。
回顾一下 JOS 的 IPC 机制，它让一个环境发送一个单个的 32 位数字和可选的共享页。从一个客户端向服务器发送一个请求，我们为请求类型使用 32 位的数字（文件系统服务器 RPC 是有编号的，就像系统调用那样的编号），然后通过 IPC 在共享页上的一个 `union Fsipc` 中存储请求参数。在客户端侧，我们已经在 `fsipcbuf` 处共享了页；在服务端，我们在 `fsreq`（`0x0ffff000`）处映射入站请求页。
服务器也通过 IPC 来发送响应。我们为函数的返回代码使用 32 位的数字。对于大多数 RPC，这已经涵盖了它们全部的返回代码。`FSREQ_READ` 和 `FSREQ_STAT` 也返回数据，它们只是被简单地写入到客户端发送它的请求时的页上。在 IPC 的响应中并不需要去发送这个页，因为这个页是文件系统服务器和客户端从一开始就共享的页。另外，在它的响应中，`FSREQ_OPEN` 与客户端共享一个新的 “Fd page”。我们将快捷地返回到文件描述符页上。
>
> **练习 5**、实现 `fs/serv.c` 中的 `serve_read`。
>
>
> `serve_read` 的重任将由已经在 `fs/fs.c` 中实现的 `file_read` 来承担（它实际上不过是对 `file_get_block` 的一连串调用）。对于文件读取，`serve_read` 只能提供 RPC 接口。查看 `serve_set_size` 中的注释和代码，去大体上了解服务器函数的结构。
>
>
> 使用 `make grade` 去测试你的代码。你的代码通过 serveopen/filestat/file\_close 和 file\_read 的测试后，你得分应该是 70（总分为 150）。
>
>
>
.
>
> **练习 6**、实现 `fs/serv.c` 中的 `serve_write` 和 `lib/file.c` 中的 `devfile_write`。
>
>
> 使用 `make grade` 去测试你的代码。你的代码通过 file\_write、fileread after filewrite、open、和 large file 的测试后，得分应该是 90（总分为150）。
>
>
>
### 进程增殖
我们给你提供了 `spawn` 的代码（查看 `lib/spawn.c` 文件），它用于创建一个新环境、从文件系统中加载一个程序镜像并启动子环境来运行这个程序。然后这个父进程独立于子环境持续运行。`spawn` 函数的行为，在效果上类似于UNIX 中的 `fork`，然后同时紧跟着 `fork` 之后在子进程中立即启动执行一个 `exec`。
我们实现的是 `spawn`，而不是一个类 UNIX 的 `exec`，因为 `spawn` 是很容易从用户空间中、以”外内核式“ 实现的，它无需来自内核的特别帮助。为了在用户空间中实现 `exec`，想一想你应该做什么？确保你理解了它为什么很难。
>
> **练习 7**、`spawn` 依赖新的系统调用 `sys_env_set_trapframe` 去初始化新创建的环境的状态。实现 `kern/syscall.c` 中的 `sys_env_set_trapframe`。（不要忘记在 `syscall()` 中派发新系统调用）
>
>
> 运行来自 `kern/init.c` 中的 `user/spawnhello` 程序来测试你的代码`kern/init.c` ，它将尝试从文件系统中增殖 `/hello`。
>
>
> 使用 `make grade` 去测试你的代码。
>
>
>
.
>
> **小挑战！**实现 Unix 式的 `exec`。
>
>
>
.
>
> **小挑战！**实现 `mmap` 式的文件内存映射，并如果可能的话，修改 `spawn` 从 ELF 中直接映射页。
>
>
>
### 跨 fork 和 spawn 共享库状态
UNIX 文件描述符是一个通称的概念，它还包括管道、控制台 I/O 等等。在 JOS 中，每个这类设备都有一个相应的 `struct Dev`，使用指针去指向到实现读取/写入/等等的函数上。对于那个设备类型，`lib/fd.c` 在其上实现了类 UNIX 的文件描述符接口。每个 `struct Fd` 表示它的设备类型，并且大多数 `lib/fd.c` 中的函数只是简单地派发操作到 `struct Dev` 中相应函数上。
`lib/fd.c` 也在每个应用程序环境的地址空间中维护一个文件描述符表区域，开始位置在 `FDTABLE` 处。这个区域为应该程序能够一次最多打开 `MAXFD`（当前为 32）个文件描述符而保留页的地址空间值（4KB）。在任意给定的时刻，当且仅当相应的文件描述符处于使用中时，一个特定的文件描述符表才会被映射。在区域的 `FILEDATA` 处开始的位置，每个文件描述符表也有一个可选的”数据页“，如果它们被选定，相应的设备就能使用它。
我们想跨 `fork` 和 `spawn` 共享文件描述符状态，但是文件描述符状态是保存在用户空间的内存中。而现在，在 `fork` 中，内存是标记为写时复制的，因此状态将被复制而不是共享。（这意味着环境不能在它们自己无法打开的文件中去搜索，并且管道不能跨一个 `fork` 去工作）在 `spawn` 上，内存将被保留，压根不会去复制。（事实上，增殖的环境从使用一个不打开的文件描述符去开始。）
我们将要修改 `fork`，以让它知道某些被”库管理的系统“所使用的、和总是被共享的内存区域。而不是去”硬编码“一个某些区域的列表，我们将在页表条目中设置一个”这些不使用“的位（就像我们在 `fork` 中使用的 `PTE_COW` 位一样）。
我们在 `inc/lib.h` 中定义了一个新的 `PTE_SHARE` 位，在 Intel 和 AMD 的手册中，这个位是被标记为”软件可使用的“的三个 PTE 位之一。我们将创建一个约定，如果一个页表条目中这个位被设置，那么在 `fork` 和 `spawn` 中应该直接从父环境中复制 PTE 到子环境中。注意它与标记为写时复制的差别：正如在第一段中所描述的，我们希望确保能共享页更新。
>
> **练习 8**、修改 `lib/fork.c` 中的 `duppage`，以遵循最新约定。如果页表条目设置了 `PTE_SHARE` 位，仅直接复制映射。（你应该去使用 `PTE_SYSCALL`，而不是 `0xfff`，去从页表条目中掩掉有关的位。`0xfff` 仅选出可访问的位和脏位。）
>
>
> 同样的，在 `lib/spawn.c` 中实现 `copy_shared_pages`。它应该循环遍历当前进程中所有的页表条目（就像 `fork` 那样），复制任何设置了 `PTE_SHARE` 位的页映射到子进程中。
>
>
>
使用 `make run-testpteshare` 去检查你的代码行为是否正确。正确的情况下，你应该会看到像 `fork handles PTE_SHARE right` 和 ”`spawn handles PTE_SHARE right`” 这样的输出行。
使用 `make run-testfdsharing` 去检查文件描述符是否正确共享。正确的情况下，你应该会看到 `read in child succeeded` 和 “`read in parent succeeded`” 这样的输出行。
### 键盘接口
为了能让 shell 工作，我们需要一些方式去输入。QEMU 可以显示输出，我们将它的输出写入到 CGA 显示器上和串行端口上，但到目前为止，我们仅能够在内核监视器中接收输入。在 QEMU 中，我们从图形化窗口中的输入作为从键盘到 JOS 的输入，虽然键入到控制台的输入作为出现在串行端口上的字符的方式显现。在 `kern/console.c` 中已经包含了由我们自实验 1 以来的内核监视器所使用的键盘和串行端口的驱动程序，但现在你需要去把这些增加到系统中。
>
> **练习 9**、在你的 `kern/trap.c` 中，调用 `kbd_intr` 去处理捕获 `IRQ_OFFSET+IRQ_KBD` 和 `serial_intr`，用它们去处理捕获 `IRQ_OFFSET+IRQ_SERIAL`。
>
>
>
在 `lib/console.c` 中，我们为你实现了文件的控制台输入/输出。`kbd_intr` 和 `serial_intr` 将使用从最新读取到的输入来填充缓冲区，而控制台文件类型去排空缓冲区（默认情况下，控制台文件类型为 stdin/stdout，除非用户重定向它们）。
运行 `make run-testkbd` 并输入几行来测试你的代码。在你输入完成之后，系统将回显你输入的行。如果控制台和窗口都可以使用的话，尝试在它们上面都做一下测试。
### Shell
运行 `make run-icode` 或 `make run-icode-nox` 将运行你的内核并启动 `user/icode`。`icode` 又运行 `init`，它将设置控制台作为文件描述符 0 和 1（即：标准输入 stdin 和标准输出 stdout），然后增殖出环境 `sh`，就是 shell。之后你应该能够运行如下的命令了：
```
echo hello world | cat
cat lorem |cat
cat lorem |num
cat lorem |num |num |num |num |num
lsfd
```
注意用户库常规程序 `cprintf` 将直接输出到控制台，而不会使用文件描述符代码。这对调试非常有用，但是对管道连接其它程序却很不利。为将输出打印到特定的文件描述符（比如 1，它是标准输出 stdout），需要使用 `fprintf(1, "...", ...)`。`printf("...", ...)` 是将输出打印到文件描述符 1（标准输出 stdout） 的快捷方式。查看 `user/lsfd.c` 了解更多示例。
>
> **练习 10**、这个 shell 不支持 I/O 重定向。如果能够运行 `run sh <script` 就更完美了，就不用将所有的命令手动去放入一个脚本中，就像上面那样。为 `<` 在 `user/sh.c` 中添加重定向的功能。
>
>
> 通过在你的 shell 中输入 `sh <script` 来测试你实现的重定向功能。
>
>
> 运行 `make run-testshell` 去测试你的 shell。`testshell` 只是简单地给 shell ”喂“上面的命令（也可以在 `fs/testshell.sh` 中找到），然后检查它的输出是否与 `fs/testshell.key` 一样。
>
>
>
.
>
> **小挑战！**给你的 shell 添加更多的特性。最好包括以下的特性（其中一些可能会要求修改文件系统）：
>
>
> * 后台命令 (`ls &`)
> * 一行中运行多个命令 (`ls; echo hi`)
> * 命令组 (`(ls; echo hi) | cat > out`)
> * 扩展环境变量 (`echo $hello`)
> * 引号 (`echo "a | b"`)
> * 命令行历史和/或编辑功能
> * tab 命令补全
> * 为命令行查找目录、cd 和路径
> * 文件创建
> * 用快捷键 `ctl-c` 去杀死一个运行中的环境
>
>
> 可做的事情还有很多，并不仅限于以上列表。
>
>
>
到目前为止，你的代码应该要通过所有的测试。和以前一样，你可以使用 `make grade` 去评级你的提交，并且使用 `make handin` 上交你的实验。
**本实验到此结束。** 和以前一样，不要忘了运行 `make grade` 去做评级测试，并将你的练习答案和挑战问题的解决方案写下来。在动手实验之前，使用 `git status` 和 `git diff` 去检查你的变更，并不要忘记使用 `git add answers-lab5.txt` 去提交你的答案。完成之后，使用 `git commit -am 'my solutions to lab 5’` 去提交你的变更，然后使用 `make handin` 去提交你的解决方案。
---
via: <https://pdos.csail.mit.edu/6.828/2018/labs/lab5/>
作者：[csail.mit](https://pdos.csail.mit.edu) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在你的终端里探索海洋的秘密
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-asciiquarium
|
“亲爱的，当您的命令行变得更湿润的时候会更好。这多亏了 ASCII。”
|
/data/attachment/album/201812/27/192002aozxs5jrwnqwq2xj.png.thumb.jpg
|
/data/attachment/album/201812/27/192002aozxs5jrwnqwq2xj.png
| true | false | true |
lujun9972
|
amwps290
|
wxy
| false |
[
"鱼缸"
] |
分享
|
{
"viewnum": 3396,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "180.172.253.249",
"message": "蛮好玩",
"username": "来自上海的 Chrome 71.0|Mac 10.14 用户",
"date": "2018-12-28T16:39:09"
}
] |
[] |
“亲爱的，当您的命令行变得更湿润的时候会更好。这多亏了 ASCII。”
| 2018-12-27T19:19:59 | 2018-12-27T19:19:59 | 10,390 |
/article-10390-1.html
|
>
> “亲爱的，当您的命令行变得更湿润的时候会更好。这多亏了 ASCII。”
>
>
>
现在，我们即将数完长达 24 天的 Linux 命令行玩具日历。离今天只剩一周了！如果这是您第一次访问本系列文章，那么您可能会问自己什么是命令行玩具。我们一边走，一边说，但一般来说，这可能是一个游戏，或者可以帮助你在终端玩得开心的任何简单的娱乐活动。
你们其中的一些人可能已经在以前的系列文章中看到了各种各样的命令行玩具。但是，我们希望每个人都能够获得一个新玩具。
今天的玩具有一点鱼的味道。先和 `asciiquarium` 打个招呼，一个在你终端里海底冒险的玩具。我是在我的 Fedora 仓库里发现 `asciiquarium` 的，因此安装它非常容易：
```
$ sudo dnf install asciiquarium
```
如果您正在运行不同的发行版，那么它也可能已经为您打包。 只需在您的终端中运行 `asciiquarium` 即可感受到蛤蜊的快乐。 该项目也在终端之外进行了“翻译”，所有水族伙伴的屏保都是为几个非 Linux 操作系统制作的，甚至还有一个 Android 动态壁纸版本。
访问 asciiquarium [主页](https://robobunny.com/projects/asciiquarium/html/)了解更多信息或下载 Perl 源代码。 该项目是 GPL 第 2 版许可证下的开源项目。 如果你想更多地了解开源，开放数据和开放科学如何在实际的海洋中发挥作用，请花点时间去了解[海洋健康指数](https://opensource.com/article/18/12/protecting-world-oceans)。
你觉得我应该介绍一下你最喜欢的命令行玩具吗？时间不多了，但我还是想听听你的建议。请在下面的评论中告诉我，我会查阅的。让我知道你对今天的娱乐有什么看法。
一定要看看昨天的玩具，[安排一次与 Emacs 精神病医生的访问](https://opensource.com/article/18/12/linux-toy-eliza)，明天再来看另一个玩具！
---
via: <https://opensource.com/article/18/12/linux-toy-asciiquarium>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[amwps290](https://github.com/amwps290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
糖尿病患者们是怎样使用开源造出自己的医疗设备的
|
Taylor Greene
|
https://opensource.com/article/18/5/dana-lewis-women-open-source-community-award-winner-2018
|
Red Hat 的 2018 女性开源社区奖获得者 Dana Lewis 的故事。
|
/data/attachment/album/201812/27/194646n3swww32uj3r5wnm.png.thumb.jpg
|
/data/attachment/album/201812/27/194646n3swww32uj3r5wnm.png
| true | false | true |
lujun9972
|
Valoniakim
|
wxy
| false |
[
"糖尿病",
"医疗"
] |
观点
|
{
"viewnum": 3300,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "61.186.31.31",
"message": "开源的力量！",
"username": "linux [Chrome 70.0|Mac 10.14]",
"date": "2018-12-27T19:59:33"
},
{
"postip": "125.78.85.211",
"message": "关闭了很久的评论最近才开放了吗？",
"username": "来自福建泉州的 Chromium 71.0|Ubuntu 用户",
"date": "2018-12-28T13:55:56"
},
{
"postip": "36.101.25.55",
"message": "是的",
"username": "linux [Chrome 70.0|Mac 10.14]",
"date": "2018-12-28T20:35:59"
}
] |
[] |
Red Hat 的 2018 女性开源社区奖获得者 Dana Lewis 的故事。
| 2018-12-27T19:46:44 | 2018-12-27T19:46:44 | 10,391 |
/article-10391-1.html
|
>
> Red Hat 的 2018 女性开源社区奖获得者 Dana Lewis 的故事。
>
>
>
Dana Lewis 被评选为[开源社区 2018 年度最佳女性](https://www.redhat.com/en/about/women-in-open-source)！下面是开源怎样改善了她的健康的故事。
Dana 患有 I 型糖尿病，但当时市面上流通的药品和医疗设备都对她无效。她用来管理血糖的动态血糖监测（CGM）报警器的声音太小了，根本叫不醒熟睡的她，产品这样的设计无法保证她每天睡眠时间的生命安全。
“我和生产厂家见了一面商议提出意见，厂家的回复是‘我们产品的音量已经足够大了，很少有人叫不醒’，我被告知‘这不是普遍问题，我们正在改进，请期待我们的新产品。’听到这些时我真的很挫败，但我从没想象过我能做出什么改变，毕竟那是通过了 FDA 标准的医疗设备，不是我们能随意改变的。”
面临着这些阻碍，Dana 想着如果她能把自己的数据从设备里导出，就可以设置手机闹铃来叫醒自己。在 2013 年末，她看到的一条推特解决了她的疑问。那条推特的作者是一位糖尿病患儿的家长，他把动态血糖监测仪进行了逆向工程，这样就可以导出孩子的血糖数据进行远程监控了。
她意识到如果对方愿意把过程分享给她，她也可以用那些代码做一个自己的响亮的血糖监测仪了。
“我并不知道向别人要源代码是件稀松平常的事，那是我第一次接触开源。”
那个系统演化成一个响亮闹钟的代码，她也可以把代码在网页上分享给别人。和她的丈夫 Scott Leibrand 一起，她逐步向闹铃添加属性，最终形成了一个算法，这个算法不仅能监测实时血糖水平，还能主动预测未来血糖波动。
随着 Dana 与开源糖尿病患者社区的接触越来越深，她认识了 Ben West，他花了很多年才研究出与 Dana 使用的胰岛素泵沟通数据的方法，与血糖监测仪不同，胰岛素泵不是简单的报告血糖，它是个单独的设备，要按人体需要持续推注胰岛素，比血糖监测仪要复杂得多。
“老路行不通了，我们说‘哦，如果我们能用这段代码和胰岛素泵沟通，就像我们之前用算法和血糖监测仪沟通实时数据那样，我们就能获取两个设备的实时数据，创建一个闭路系统。’”
我们得到的是一个自制人工胰腺系统 (DIY APS)。
这个系统可以使用算法处理胰岛素泵和血糖监测仪的数据，来预测患者血糖水平，据此调整胰岛素的注射量，从而保持患者的血糖稳定。这个人工胰岛素系统取代了从前患者每日多次对胰岛素注射量的计算和调整，减轻了糖尿病患者的负担。
“正因为我们使用的是开源软件，在做出这个系统之后我们就把成果开源化了，这样可以造福更多的人。”开源人工胰腺系统 (OpenAPS) 由此诞生。
OpenAPS 社区已经拥有超过 600 名用户，大家都提供了各种各样的自制“闭路”系统代码。OpenAPS 贡献者们聚集到了 #WeAreNotWaiting 话题之下，以表达患者群体不该干等着医疗保健工厂制造出真正有效便捷产品的理念。
“你可以选择等待未来的商业解决方案，这无可厚非，选择等待是你的自由。等待可以是一种选择，但不能是无法改变的现状。对我来说，开源在医疗保健方面做出的这个举动让等待变成了一种选择。你可以选择不自行解决，你可以选择等待商业解决方案，但如果你不想等了，你无需再等。现在你有很多选择，开源社区的人们已经解决了很多问题。”
OpenAPS 社区由糖尿病患者、患者家属，还有想要合理利用这项技术的人们。在社区的帮助下，Dana 学会了很多种贡献开源项目的方式。她发现许多从 Facebook 或 [Gitter](https://gitter.im/) 上过来的非技术贡献者也对 OpenAPS 做出了很大贡献。
“贡献有很多方式，我们要认识到各种方式的贡献都是平等的。它们一般涉及不同的兴趣领域和技能组合，只有把这些综合起来，才能做成社区的项目。”
她亲身经历过，所以知道自己的贡献不被社区的其他成员认可是怎样难过的感受。对于人们习惯把女性的贡献打折的这一现象，她也不回避。在她的 [2014 年博客](https://diyps.org/2014/08/25/being-female-a-patient-and-co-designing-diyps-means-often-being-discounted/) 和 [反思](https://diyps.org/2018/02/01/women-in-open-source-make-a-difference/) 文章中她初次写到在入围开源年度最佳人物时所遭受到的区别待遇，这些待遇让她意识到身为女性的不同。
在她最初的博客中，她写道了自己和丈夫 Scott 同为开源社区成员，遭受到的区别待遇。他们都注意到，Dana 总是被提出一些细枝末节的要求，但 Scott 就不会。而 Scott 总被问道一些技术性问题，即使他向他们推荐 Dana，人们也更倾向于问身为男性的 Scott。大家都或多或少经历过这些行为，Dana 的博文在社区里引起了广泛的讨论。
“人们更愿意认为项目是‘Scott 发起的’而非‘Dana 和 Scott 一起发起的’。”这让我感受到千刀万剐般的痛苦和挫败，我写了博客把这个现象提到明面上，我说，‘看看这些行为，我知道你们有些是故意的，有些是无意的，但如果我们的社区想要得到多元化参与者的支持，想要发展壮大，我们就要规范自己的行为，有不妥之处也不要回避，直接摊开来交流。”值得赞扬的是，社区里的大部分成员都加入进来，认真地讨论这个问题。他们都说，‘好的，我知道有哪里需要改了，如果我再无意识这样做时提醒我一下。’这就是我们社区形成的风气。”
她还说如果没有 Scott 这位社区里活跃开发者的支持，还有社区里其他女性贡献者的鼓励，她可能就半途而废了。
“我想如果我就放弃努力了，可能开源世界里糖尿病患者们的现状会有很大不同。我知道别人不幸的遭遇，他们在开源社区中感受不到认同感和自身价值，最终离开了开源。我希望我们可以继续这种讨论，大家都能意识到如果我们不故意打击贡献者，我们可以变得更加温暖，成员们也能感受到认同感，大家的付出也能得到相应的认可。
OpenAPS 社区的交流和分享给我们提供了一个很好的例子，它说明非技术性的贡献者对于整个社区的成功都是至关重要的。Dana 在现实社会中的关系和交流经历对她为开源社区做出的宣传有着很大的贡献。她为社区在 [DIYPS 博客](https://diyps.org/) 上写了很多篇文章，她还在 [TEDx Talk](https://www.youtube.com/watch?v=kgu-AYSnyZ8) 做过一场演讲, 在 [开源大会 （OSCON）](https://www.youtube.com/watch?v=eQGWrdgu_fE) 上也演讲过很多次，诸如此类的还有很多。
“不是每个项目都像 OpenAPS 一样，对患者有那么大的影响，甚至成为患者中间的主流项目。糖尿病社区在项目的沟通中真的做了很多贡献，引来了很多糖尿病患者，也让需要帮助的人们知道了我们的存在。”
Dana 现在的目标是帮助其他疾病的患者社区创建项目。她尤其想要把社区成员们学到的工具和技术和其他的患者社区分享，特别是那些想要把项目进一步提升，进行深入研究，或者想和公司合作的社区。
“我听说很多参与项目的患者都听过这样的话，‘你应该申请个专利；你应该拿它开个公司；你应该成立个非营利组织。’但这些都是大事，它们太耗时间了，不仅占据你的工作时间，甚至强行改变你的专业领域。我这样的人并不想做那样的事，我们更倾向于把精力放在壮大其他项目上，以此帮助更多的人。”
在此之后，她开始寻找其他不那么占用时间的任务，比如给小孩们写一本书。Dana 在 2017 年进行了这项挑战，她写了本书给侄子侄女，讲解他们婶婶的糖尿病设备是怎样工作的。在她侄女问她“胳膊上的东西是什么”（那是她的血糖监测仪）时，她意识到她不知道怎么和一个小孩子解释糖尿病患者是什么，所以写了[《卡罗琳的机器人亲戚》](https://www.amazon.com/gp/product/1977641415/ref=as_li_tl?ie=UTF8&tag=diyps-20&camp=1789&creative=9325&linkCode=as2&creativeASIN=1977641415&linkId=96bb65e21b5801901586e9fabd12c860)这本书。
“我想用我侄子侄女那个年纪的语言和他们交流，毕竟不同年龄的人说话方式也不同。我当时想，‘真希望有本这方面的儿童读物，那我为什么不自己写一本呢？’”
她写了书在亚马逊上出版，因为她想把开源的价值分享给更多的人。她还开了一个名为[“自己在亚马逊上出书”](https://diyps.org/2017/11/01/makers-gonna-make-a-book-about-diabetes-devices-kids-book-written-by-danamlewis/)的博客，希望大家也可以把自己的经历写进书里出版。
像《卡罗琳的机器人亲戚》这本书还有开源社区年度最佳女性这样的奖项都说明生活中包括开源在内的不同领域中，还有很多人的工作等待着大众的认知。
“社区越多元，事情越好办。”
---
via: <https://opensource.com/article/18/5/dana-lewis-women-open-source-community-award-winner-2018>
作者：[Taylor Greene](https://opensource.com/users/tgreene) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Valoniakim](https://github.com/Valoniakim) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Linux 中安装 Rust 编程语言
|
Prakash Subramanian
|
https://www.2daygeek.com/how-to-install-rust-programming-language-in-linux/
|
Rust 通常被称为 rust-lang。Rust 是一个由 Mozilla Research 赞助的通用的、多范式、现代的、跨平台和开源系统编程语言。
|
/data/attachment/album/201812/29/112734kg41ft1f5o1ffz05.jpg.thumb.jpg
|
/data/attachment/album/201812/29/112734kg41ft1f5o1ffz05.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Rust"
] |
技术
|
{
"viewnum": 13040,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "122.96.41.215",
"message": "这头图是认真的吗……虽然Rust社区里自己也会开玩笑。",
"username": "来自江苏南京的 Chrome 71.0|Windows 10 用户",
"date": "2018-12-29T09:05:47"
},
{
"postip": "27.159.150.178",
"message": "这个配图错了啦，用了生存游戏的Logo……",
"username": "来自福建宁德的 Chrome 68.0|GNU/Linux 用户",
"date": "2018-12-29T11:18:31"
},
{
"postip": "36.101.25.55",
"message": "好吧，我换回来。",
"username": "linux [Chrome 70.0|Mac 10.14]",
"date": "2018-12-29T19:44:57"
}
] |
[] |
Rust 通常被称为 rust-lang。Rust 是一个由 Mozilla Research 赞助的通用的、多范式、现代的、跨平台和开源系统编程语言。
| 2018-12-28T23:47:00 | 2018-12-28T23:47:00 | 10,392 |
/article-10392-1.html
|
Rust 通常被称为 rust-lang。Rust 是一个由 Mozilla Research 赞助的通用的、多范式、现代的、跨平台和开源系统编程语言。
它旨在实现安全性、速度和并发性等目标。
Rust 在语法上与 C++ 相似，但它的设计者希望它在保持性能的同时提供更好的内存安全性。
Rust 目前在许多组织中使用，例如 Firefox、Chef、Dropbox、Oracle、GNOME 等。
### 如何在 Linux 中安装 Rust 语言？
我们可以通过多种方式安装 Rust，但以下是官方推荐的安装方式。
```
$ curl https://sh.rustup.rs -sSf | sh
info: downloading installer
Welcome to Rust!
This will download and install the official compiler for the Rust programming
language, and its package manager, Cargo.
It will add the cargo, rustc, rustup and other commands to Cargo's bin
directory, located at:
/home/daygeek/.cargo/bin
This path will then be added to your PATH environment variable by modifying the
profile files located at:
/home/daygeek/.profile
/home/daygeek/.bash_profile
You can uninstall at any time with rustup self uninstall and these changes will
be reverted.
Current installation options:
default host triple: x86_64-unknown-linux-gnu
default toolchain: stable
modify PATH variable: yes
1) Proceed with installation (default)
2) Customize installation
3) Cancel installation
>1
info: syncing channel updates for 'stable-x86_64-unknown-linux-gnu'
info: latest update on 2018-12-06, rust version 1.31.0 (abe02cefd 2018-12-04)
info: downloading component 'rustc'
77.7 MiB / 77.7 MiB (100 %) 1.2 MiB/s ETA: 0 s
info: downloading component 'rust-std'
54.2 MiB / 54.2 MiB (100 %) 1.2 MiB/s ETA: 0 s
info: downloading component 'cargo'
4.7 MiB / 4.7 MiB (100 %) 1.2 MiB/s ETA: 0 s
info: downloading component 'rust-docs'
8.5 MiB / 8.5 MiB (100 %) 1.2 MiB/s ETA: 0 s
info: installing component 'rustc'
info: installing component 'rust-std'
info: installing component 'cargo'
info: installing component 'rust-docs'
info: default toolchain set to 'stable'
stable installed - rustc 1.31.0 (abe02cefd 2018-12-04)
Rust is installed now. Great!
To get started you need Cargo's bin directory ($HOME/.cargo/bin) in your PATH
environment variable. Next time you log in this will be done automatically.
To configure your current shell run source $HOME/.cargo/env
```
运行以下命令配置当前 shell。
```
$ source $HOME/.cargo/env
```
运行以下命令验证已安装的 Rust 版本。
```
$ rustc --version
rustc 1.31.0 (abe02cefd 2018-12-04)
```
### 如何测试 Rust 编程语言？
安装 Rust 后，请按照以下步骤检查 Rust 语言是否正常工作。
```
$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world
```
创建一个文件并添加以下代码并保存。确保 Rust 文件始终以 .rs 扩展名结尾。
```
$ vi 2g.rs
fn main() {
println!("Hello, It's 2DayGeek.com - Best Linux Practical Blog!");
}
```
运行以下命令编译 rust 代码。
```
$ rustc 2g.rs
```
上面的命令将在同一目录中创建一个可执行的 Rust 程序。
```
$ ls -lh
total 3.9M
-rwxr-xr-x 1 daygeek daygeek 3.9M Dec 14 11:09 2g
-rw-r--r-- 1 daygeek daygeek 86 Dec 14 11:09 2g.rs
```
运行 Rust 可执行文件得到输出。
```
$ ./2g
Hello, It's 2DayGeek.com - Best Linux Practical Blog!
```
好了！正常工作了。
将 Rust 更新到最新版本。
```
$ rustup update
info: syncing channel updates for 'stable-x86_64-unknown-linux-gnu'
info: checking for self-updates
stable-x86_64-unknown-linux-gnu unchanged - rustc 1.31.0 (abe02cefd 2018-12-04)
```
运行以下命令从系统中删除 Rust 包。
```
$ rustup self uninstall
```
卸载 Rust 包后，删除 Rust 项目目录。
```
$ rm -fr ~/projects
```
---
via: <https://www.2daygeek.com/how-to-install-rust-programming-language-in-linux/>
作者：[Prakash Subramanian](https://www.2daygeek.com/author/prakash/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 Linux 终端收听广播
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-mplayer
|
MPlayer 是一个多功能的开源媒体播放器，它在 Linux 命令行中非常有用。
|
/data/attachment/album/201812/29/113239cii055al7hnsx764.png.thumb.jpg
|
/data/attachment/album/201812/29/113239cii055al7hnsx764.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"MPlayer"
] |
分享
|
{
"viewnum": 4861,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
MPlayer 是一个多功能的开源媒体播放器，它在 Linux 命令行中非常有用。
| 2018-12-29T11:32:38 | 2018-12-29T11:32:38 | 10,393 |
/article-10393-1.html
|
>
> MPlayer 是一个多功能的开源媒体播放器，它在 Linux 命令行中非常有用。
>
>
>
你已经看到我们为期 24 天的 Linux 命令行玩具日历。如果这是你第一次访问该系列，你可能会问自己什么是命令行玩具。它可能是一个游戏或任何简单的消遣，可以帮助你在终端玩得开心。
你们中的一些人之前已经看过我们日历中的各种玩具，但我们希望每个人至少见到一件新玩具。
在命令行中有很多方法可以听音乐。如果你有本地存储的媒体，`cmus` 是一个很好的选择，但还有[很多其他选择](https://opensource.com/life/16/8/3-command-line-music-players-linux)。
不过，很多时候，当我在终端的时候，我会走神并且不会注意挑选每首歌，并让其他的来做。虽然为了这个我有很多播放列表，但过了一段时间，即使过时，我也会切换到互联网电台。
今天的玩具，MPlayer，是一个多功能的多媒体播放器，几乎可以支持任何你给它的媒体格式。如果尚未安装 MPlayer，你可能会发现它已在你的发行版中打包。在 Fedora 中，我在 [RPM Fusion](https://rpmfusion.org/) 中找到了它（请注意，这不是 Fedora 的“官方”仓库，因此请谨慎操作）：
```
$ sudo dnf install mplayer
```
MPlayer 有一系列命令行选项可根据你的具体情况进行设置。我想听 Raleigh 当地的大学广播电台（[88.1 WKN](https://wknc.org/index.php)，这个很棒！），在它们的网站得到流媒体网址之后，像这样就可以让收音机运行了，不需要 GUI 或 Web 播放器：
```
$ mplayer -nocache -afm ffmpeg http://wknc.sma.ncsu.edu:8000/wknchd1.mp3
```
MPlayer 是 GPLv3 许可证下的开源软件，你可以从项目的[网站](http://www.mplayerhq.hu/)中找到更多关于项目的信息并下载源代码。
正如我在昨天的文章中提到的，我试图使用每个玩具的截图作为每篇文章的主图，但是当进入音频世界时，我不得不稍微改改。所以今天的图像是由 **libcaca** 包中的 **img2txt** 绘制的来自公共域的无线电塔图标。
你有特别喜欢的命令行小玩具需要我介绍的吗？我们的日历基本上是为这个系列剩余的玩具设置的，但我们仍然很想在新的一年里推出一些很酷的命令行玩具。评论告诉我，我会查看的。如果还有空位置，我会考虑介绍它的。并让我知道你对今天的玩具有何看法。
一定要看看昨天的玩具，[让你的 Linux 终端说出来](https://opensource.com/article/18/12/linux-toy-espeak)，明天记得回来！
---
via: <https://opensource.com/article/18/12/linux-toy-mplayer>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
UCloud 技术副总裁杨镭：技术的初心是什么？
|
Wxy
|
UCloud 技术副总裁杨镭首谈 UCloudStack、保护客户隐私、回馈开源社区背后的故事和挑战。
|
/data/attachment/album/201812/29/113701rfalnabdr5tnottx.jpeg.thumb.jpg
|
/data/attachment/album/201812/29/113701rfalnabdr5tnottx.jpeg
| true | false | false | true |
[
"UCloud"
] |
穿山甲专访
|
{
"viewnum": 10587,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10744,
"displayorder": 0
}
] |
UCloud 技术副总裁杨镭首谈 UCloudStack、保护客户隐私、回馈开源社区背后的故事和挑战。
| 2018-12-29T11:40:00 | 2018-12-29T11:40:00 | 10,394 |
/article-10394-1.html
|
>
> UCloud 技术副总裁杨镭首谈 UCloudStack、保护客户隐私、回馈开源社区背后的故事和挑战。
>
>
>
日前，Linux 中国社区的老王参加了 UCloud 用户大会，并有幸和 UCloud 技术副总裁杨镭进行了面谈。以下将我们谈话中一些内容分享给大家。
>
> *杨镭，UCloud 技术**副总裁。全面负责 UCloud 产品研发和产品运营工作，有超过十年 IT & 互联网行业从业经验，在网络领域拥有丰富的经验和深刻的理解。*
>
>
>
### 为什么专门开发了 UCloudStack？
**今天的大会上面您提出一个针对私有云的** **UCloudStack****，****是否可以给我们详细介绍一下为什么在有了生态很成熟的** **OpenStack** **的情况下****，UCloud** **还投入了巨大的资源去研发****UCloudStack****？**
杨镭：
我们在 OpenStack 上做的还比较早的，当时我们的认知就是公有云是公有云，而私有云 OpenStack 做的比较好。但实际上，通过不断的时间验证，我们发现 OpenStack 有一个比较大的问题，就是过于复杂。
回到用户对私有云需求来讲，用户实际上关注的还是能不能解决他的需求，而不是说要不要用 OpenStack。所以，我们考虑到，既然已经有了多年的云计算的开发和运维经验，如果从头开始做一个自己的私有云产品，是不是会做的更好？
我们做了 16 个月就做出来了这个产品，在完成核心产品之后，整体的代码量还是很少的。代码量是相对来讲是衡量一个项目复杂性的很好的指标。我们根据自己这么多年来的经验做下来，我们发现这个事情并没有那么的难，而且，现在这个时候，在做这个产品的时候认知就和几年前不太一样，我们会比以前想的成熟很多。我们相信做出来的东西会比 OpenStack 更轻量、更好用，这是我们做这个产品的一个主要的想法。
其实现在真正能自己独立用 OpenStack 产品的公司一般都有一个一定规模研发的团队，至少十个人。但是云计算这个市场的人才竞争还是蛮厉害的，一个公司很难有这样一群比较好的人去做这个事情，所以它的门槛会很高。如果说公司的目标只是为了有一个私有云，那么这样研发投入的必要性是打问号的。这些企业的目标和我们云服务商的目标不一样，它的云只是一个工具，不像我们的云是我们本身的一个产品。所以这时实际上企业往往会考虑说怎么能把这个私有云更好的建起来，很快、很稳定的用起来，在成本上比较合理。所以在我们的这个产品上，我们最重要的一个点确实就是在轻量上。
假如你对 OpenStack 需要做一些改动，是牵一发而动全身的，为了做某个功能可能要改造底层的东西，这个时候整个过程在研发上来讲就太“重”了，所以我们如果从零开始做，其实我们的底层就是可控的。我们在第一次推出的时候，我们总的代码量才八九万行，而 OpenStack 所有项目代码量加起来有几千万行，这之间的复杂性灵活性是完全不能比拟的，这是它的一个轻的主要原因。
另外一个，因为我们做这个产品的目的性会比做一个开源的社区项目更明确一点，比如说我们做产品的路线很不一样。当我们的核心产品完成以后，我们做的一个比较大的改变是和传统的网络打通，我们 UCloudStack 部署完了以后和传统的网络做很大的打通，这点和开源社区项目的目标不一样，它要让这个东西更加通用。这在产品的改变选择的路径差别特别大。这个时候看用户要什么，往往用户要的东西更贴近它想要的，这里面也是一个很大差异点。
今天本来想放一段视频，那段视频是当时在富士康的办公园区里面拍的，当时是下午四点钟进入机房到晚上十点种整个私有云的交付就完成了。而且当中大概有 2-3 个小时是因为机房的一些问题影响了整个的进度，如果看到那个视频就会真正感觉到它很轻，但一般而言 OpenStack 部署起来时间会更长，比如说好几天的时间，它的底层太复杂了。
我们一直认同的一点是说，开源软件比较适合做一个组件，比如说一个数据库、一个操作系统、一个很垂直的部分。但是云实际上不是一个垂直的组件，而是很多组件组成在一起的一个体系。如果你去用开源软件做组件的方式去做云，这其实不是特别的理想。
### 为什么将客户隐私保护拔高到这样的高度？
**今天上午大会上您提到一个隐私的产品，禁止一些 API 采集用户数据，来保护用户的隐私，这方面能够详细谈谈吗？**
杨镭：
这个我需要澄清一下，我们说的是禁止我们的云平台收集我们客户的信息，而不是说我们禁止了客户收集他的用户信息。因为我们是给企业提供服务的，企业本身给他的终端用户提供服务，我们控制的是我们和企业之间数据的隐私问题。比如说它的使用习惯是什么，或者它业务的模型是什么，我们在控制这个。
因为我们自己是做云服务的，我们的技术工程师在管理我们云业务的时候，实际上是有可能看到用户的数据。比如说你是一个电商公司，假设你的数据库如果没有进行加密，技术人员是可以看到这个数据的。目前来讲绝大多数的厂商，靠的还是流程和制度，靠的不是技术手段保护。什么叫技术手段，就是说我想看却看不到，因为是加密的。你只有拿到相应的解密密钥才能去看。我们说的数据保护更多的是这方面。
再比如说我们的云主机最终跑在 SSD 硬盘上，如果你去机房里把硬盘直接拔插走，而没有加密的话，一定是能读到里面的数据。从长远来看，这是不能出任何问题的，哪怕是一两次。像某互联网公司出了几次乘客的安全事件以后，事情影响就非常恶劣。回到做云服务，我们的责任一样重大。我们如果只是一家公司，也许我有的只是很特定的一些数据，但是作为做云服务的公司，我们上面的客户不是我们能决定的，要看客户自己做什么业务，所以我们上面有几十万，甚至几百万的数据，这是一个非常长远、需要很认真对待的事情。所以我们把这一点放到了一个很高的、甚至于到我们企业文化和价值观的角度。
作为一个工程师来讲，首先我们要有价值观，这是第一点，但是也要从技术上保证，所以我们未来会在这方面投入很多的技术研发工作，来实现比如说我们自己的技术工程师没有任何可能能看到我们客户数据。这里面实际上是有很多的技术工作要做的。
在我们刚刚做云的前两年，那时候如果去对数据做加密，就会严重影响到性能。这个时候你很难两者兼得，但是随着这几年的技术的演进，很多的加密算法被逐渐的优化以后，基本能做到做了加密也不怎么会影响性能。所以现在这个时代，是一个非常好的时机，是一个你应该要去做这件事的时机。
整个这个事情大概我们是这样看的。除了数据的加密，包括用户有时候会输入给我们很多数据，他在做一些操作需要提供身份信息，比如说现在网络安全法要求用户使用要做实名认证，也就是说他的身份证会上传到我们这儿，这些数据其实是一个很隐私的数据。这件信息的泄露是一次都不能发生的，所以我们如果回到最根本的来说，我们怎么样尊重我们的用户？这个事情其实比一些产品功能更重要。
我们不希望出了事故以后我们再做一些补救的工作，那时候即使你是真的去做，你的用户也已经受到了很大的伤害。
另外一个层面，我今天没有提到，因为云计算的公司，我们特别需要最顶尖的技术人才，我们这么多年来在吸引最顶尖的人才上我们逐渐意识到靠的不是钱、待遇，或者是一些职位。最优秀的顶尖技术人才，看的是你公司的理念和价值观，比如说谷歌、苹果他们有非常多的几十年的行业人才在里面，为什么？他们做的工作就是数据安全性、隐私就这方面的工作。所以我们也是在商业的进化过程中，我们发现要做一家几十年的公司，不是靠一两年的财报，而是靠这些背后的东西，这是我们很真实的一个自己成长的过程。
### 对开源社区的回馈
**我们非常关注 UCloud 在采用开源软件方面的情况，云服务商的很多基础设施都是基于开源软件的。目前UCloud在开源方面对上游社区的贡献情况怎么样？**
杨镭：
我们目前在开源方面目前做的工作还不多。但是为什么不多？不是我们不想做，而是因为我们处在一个技术竞争特别激烈的行业里面，你的产品实际上卖的都是技术。我们的技术人员这么多年来其实一直不太够用，所以我们绝大多数的精力是在做我们自己不得不做的事情，比如说今天说的网络架构的透明升级，这个事情实际上把我们的核心人员的精力全部消耗掉了。为了这些升级，我们要跟客户沟通好这个事情让客户放心我们才能做，这也是为什么我们会做 29 个月的原因，其中有 9 个月是跟客户沟通的过程中。我们的人并不是很多，我们对自己产品的要求还是蛮高的，在这两个因素影响下，我们也很难拆出精力来更多的主动回馈社区。
但是这一点上我们想法是很明确的，只要我们现在有精力就会回馈社区。比如说这次做的 25G 的网卡，这个解决了一个核心障碍，我们把这个东西交给上游，但是从整个公司来讲这块投的人员和精力还不是很多。像我们开源的命令行工具，我们和 Hashicorp 做的整合，这些我们全部开源了，但是这些还远远不够。其实开源，也是想让用户知道你的代码到底怎么写的，只是说这里面是一个精力问题，不是意愿问题。
我们在 2013 年做了一个内核模块，是可以把 SSD 盘加速 100 多倍，由于一些原因，我们的代码是针对某些特定场景的。同时在代码的规范上也做了一点牺牲，如果要开源，相当于要额外增加 30% 的工作量。但是我们现在一直在想，就像今天举的例子，把很多东西开源，尽量的变成工具化，而不是放在 UCloud 的内部一个产品，只是我们精力不太够。
**最近** **Redis、Kafka、ES 这样的软件都在许可件上改了自己原来的开源许可证，针对云服务商提出了特别的条款。比如说云服务商用 Redis给客户提供服务，但是很少对 Redis 进行社区回馈，所以云服务商需要额外采购商业许可证，您怎么看这个事情，UCloud 怎么面对这个情况？**
杨镭：
目前来看，我觉得确实云服务商对社区的回馈是偏少的，所以说我觉得 Kafka 和 Redis 在这个事情上他们是有一定的道理。但这个事情也不能单方面的看待，因为实际上云厂商在推出 Kafka、Redis、ES 产品时，其实也帮这些开源软件做了很多的推广。Redis 比较简单，Kafka 或者是 ES，其实还是一个蛮复杂的软件。云厂商将这些组件加入平台后，把最复杂的地方把简化了，用户甚至连性能维护都不用考虑，另一个维度来看相当于推广了 Kafka。我认为云厂商或者是以此谋利的厂商，他应该做足够的回馈，不管你是以钱的方式，还是以研发的方式，我觉得是应该回馈的。
---
和杨镭的沟通当中，我们还谈到了许多其他问题，这里限于篇幅就不展开叙述了。从上面的谈话当中，我们能感受到 UCloud 做为一家新兴发展起来的初创公司，无论是在技术还是企业价值观方面，逐渐形成了自己独有的优势。其实作为 UCloud 多年的老朋友，这次参加这个大会，让我意外的是，原来我对他们的了解还所知甚少；也为他们在隐私保护、技术研发等方面默默做的工作而吃惊。希望这些技术人可以秉持初心，真正做出一个好用、值得用的产品来。
>
> 
>
>
> “穿山甲专访”栏目是 Linux 中国社区推出的面向开源界、互联网技术圈的重要领军人物的系列采访，将为大家介绍中国开源领域中一些积极推动开源，谙熟开源思想的技术人，并辨析其思考、挖掘其动因，揭示其背后所发生的事情，为关注开源、有志于开源的企业和技术人标出一条路径。
>
>
> 取名为“穿山甲”寓意有二：取穿山甲挖掘、深入之意来象征技术进步和表征技术领袖的作用；穿山甲是珍稀保护动物，宣传公益。
>
>
>
|
||||
救命！我的电子邮件发不到 500 英里以外！
|
Trey Harris
|
http://web.mit.edu/jemorris/humor/500-miles
|
这是一个听起来几乎不可能的事情……我甚至有点后悔将它发到网上，因为它在一个会议上成了一则著名的酒后故事。
|
/data/attachment/album/201812/29/164052m11xmbbadbxyle4p.jpg.thumb.jpg
|
/data/attachment/album/201812/29/164052m11xmbbadbxyle4p.jpg
| true | false | true |
wxy
| true |
[
"邮件"
] |
观点
|
{
"viewnum": 39141,
"commentnum": 4,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "61.186.31.105",
"message": "光速",
"username": "来自海南海口的 Chrome Mobile iOS 71.0|iOS 12.1 用户",
"date": "2018-12-30T19:16:16"
},
{
"postip": "125.121.234.30",
"message": "还有个细节 1英里=1.6公里",
"username": "来自浙江杭州的 QQ Browser 10.3|Windows 10 用户",
"date": "2018-12-30T20:38:22"
},
{
"postip": "112.21.2.168",
"message": "哈哈哈哈哈哈哈~",
"username": "来自江苏无锡的 Firefox 65.0|Windows 10 用户",
"date": "2018-12-31T00:49:51"
},
{
"postip": "61.158.146.129",
"message": "文章的来源应该是国外吧",
"username": "来自河南开封的 Mobile Safari 12.0|iOS 12.1 用户",
"date": "2019-01-26T19:43:46"
}
] |
[] |
这是一个听起来几乎不可能的事情……我甚至有点后悔将它发到网上，因为它在一个会议上成了一则著名的酒后故事。
| 2018-12-29T16:41:00 | 2018-12-29T16:41:00 | 10,395 |
/article-10395-1.html
|
这是一个听起来几乎不可能的事情……我甚至有点后悔将它发到网上，因为它在一个会议上成了一则著名的酒后故事。这个故事略有改动，以保护故事中的人物，以及忽略了一些无关的细节使之更有趣一些。
几年前，当我接到统计系主任的电话时，我正在从事维护校园电子邮件系统的工作。
“我们从部门发送电子邮件时遇到了问题。”
“有什么问题？” 我问。
“我们不能发送超过 500 英里的邮件，”主任解释说。
“咳咳”，我被我喝的拿铁呛了一口，“您再说一遍？”
“我们不能发送距这里超过 500 英里的邮件，”他重复道。 “实际上，更远一点，是 520 英里，但不能更远了。”
“嗯......电子邮件真的不会这样，通常，”我说，试着让我的声音听起来不那么慌乱。我不能和一个系主任说话时显得慌乱，即使是一个像统计系这样的相对没钱的院系。 “是什么让你觉得你不能发送邮件超过 500 英里？”
“这不是我**认为的**，”主任有点急躁地回答道。 “我们首先注意到了这种情况是几天前。”
“你等了**几天**？” 我打断他，带点颤音说道。 “这段时间你一直你不能发送电子邮件？”
“我们可以发送电子邮件。只是不超过 ——”
“—— 500 英里，我知道，”我接过他的话，“我知道了。但为什么没有你早点打电话呢？”
“好吧，我们没有收集到足够的数据来确定发生了什么，直到现在。”没错，这是**统计**系的主任。“不管怎么说，我请了一位地理统计学家研究它 ——”
“地理统计学家……”
“—— 是的，她制作了一张地图，显示了我们发送电子邮件能够达到的半径略超过 500 英里。在那个半径范围内有零星的几个无法到达的目的地，但我们永远不能发送比这半径更远的电子邮件。”
“我明白了，”我说，把头埋在我的手中。 “这是什么时候开始的？几天前，你说过，但是那时你的系统做了什么改变？”
“嗯，服务顾问来给我们的服务器打了补丁，并重新启动了它。但我打电话给他，他说他没有碰过邮件系统。”
“好的，让我来看看，我稍后会给你回电话，”我说。我简直觉得我在做梦，这不是愚人节。我试着回想是不是有人恶作剧报复我。
我登录了他们系的服务器，并发送了一些测试邮件。在北卡罗来纳州的<ruby> 三角研究园 <rp> （ </rp> <rt> Research Triangle Park </rt> <rp> ） </rp></ruby>，我自己的帐户的测试邮件顺利投递。发往里士满、亚特兰大和华盛顿的也是如此。发往普林斯顿（400 英里）的另一个邮件也正常。
但后来我尝试向孟菲斯（600 英里）发送电子邮件，失败了。波士顿，失败了。底特律，也失败了。我拿出了我的地址簿，开始试图缩小它的范围。纽约（420 英里）成功，但普罗维登斯（580 英里）失败了。
我开始怀疑自己是不是疯了。我试过给住在北卡罗来纳州的朋友发电子邮件，但他的 ISP 在西雅图。谢天谢地，它失败了。如果问题与收件人的地理位置有关，而不是他的邮件服务器，我想我要哭了。
已经确定！虽然令人难以置信，但所报告的问题是真实的、可重复的，我看了一下 `sendmail.cf` 文件。它看起来很正常。事实上，它看起来很熟悉。
我把它与我主目录中的 `sendmail.cf` 做了个对比。它没有被改过 —— 这是我写的 `sendmail.cf`。 而且我相当确定我没有启用某种 “`FAIL_MAIL_OVER_500_MILES`” 选项。我不知所措，我 telnet 到 SMTP 端口。 服务器愉快地回复了 SunOS sendmail 的横幅消息。
等一下……一个 SunOS sendmail 的横幅消息？当时，即使 Sendmail 8 已经相当成熟，Sun 公司在其操作系统中装的仍然是 Sendmail 5。作为一名优秀的系统管理员，我已经对 Sendmail 8 进行了标准化。并且作为一名优秀的系统管理员，我编写了一个 `sendmail.cf`，它使用了 Sendmail 8 中提供的很长的、具有自我描述意义的选项和变量，而不是 Sendmail 5 中使用的那种神秘的标点符号式配置选项。
这个细节一下子又回到了起点，我再次被我现在已经冷掉了的拿铁咖啡渣呛了。 当服务顾问“对服务器打补丁”时，他显然升级了 SunOS 的版本，并且这样做**降级了** Sendmail。这次升级会将 sendmail.cf 单独留下，即使它现在是错误的版本。
事实上，Sendmail 5 —— 至少是 Sun 所带的版本，是有一些调整的 —— 它可以处理 Sendmail 8 的 `sendmail.cf`，因为大多数规则在那时保持不变。但新的长配置选项 —— 它被视为垃圾，并跳过。 并且 `sendmail` 二进制文件编译时没有针对其中大多数设置默认值，因此，在 `sendmail.cf` 文件中找不到合适的配置，它们被设置为 0。
被设置为 **0** 的配置之一是连接到远程 SMTP 服务器的超时选项。 一些实验证明，在具有典型负载的特定机器上，**0** 超时将在稍微超过 **3 毫秒**的时间内中止连接调用。
当时我们校园网络的一个奇怪的特点是它是 100％ 交换的。传出的数据包不会出现路由器延迟，直到命中 POP 服务器并到达远端的路由器。因此，连接到附近网络上的轻负载的远程主机的时间实际上主要取决于到目的地的光速的速度，而不是偶然的路由器延迟。
这让我有点晕，我在我的 shell 中输入：
```
$ units
1311 units, 63 prefixes
You have: 3 millilightseconds
You want: miles
* 558.84719
/ 0.0017893979
```
“500 英里，或者稍微多一点点。”
|
||
如何构建一台网络引导服务器（二）
|
Gregory Bartholomew
|
https://fedoramagazine.org/how-to-build-a-netboot-server-part-2/
|
我们将向你展示如何在第一部分的基础上，重新配置网络引导镜像，以便 活动目录 中的用户帐户可以进行登录，然后从一个 NFS 服务器上自动挂载他们的家目录。
|
/data/attachment/album/201812/29/224635ia5a06njzjy00zsz.jpg.thumb.jpg
|
/data/attachment/album/201812/29/224635ia5a06njzjy00zsz.jpg
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"网络引导",
"NFS"
] |
技术
|
{
"viewnum": 5042,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10379,
"displayorder": 0
},
{
"raid": 10405,
"displayorder": 0
}
] |
我们将向你展示如何在第一部分的基础上，重新配置网络引导镜像，以便 活动目录 中的用户帐户可以进行登录，然后从一个 NFS 服务器上自动挂载他们的家目录。
| 2018-12-29T22:46:32 | 2018-12-29T22:46:32 | 10,396 |
/article-10396-1.html
|
在 [如何构建一台网络引导服务器（一）](/article-10379-1.html) 的文章中，我们展示了如何创建一个网络引导镜像，在那个镜像中使用了一个名为 `liveuser` 帐户，它的家目录位于内存中，重启后家目录中的内容将全部消失。然而很多用户都希望机器重启后保存他们的文件和设置。因此，在本系列的第二部分，我们将向你展示如何在第一部分的基础上，重新配置网络引导镜像，以便 [活动目录](https://en.wikipedia.org/wiki/Active_Directory) 中的用户帐户可以进行登录，然后从一个 NFS 服务器上自动挂载他们的家目录。
本系列的第三部分，我们将向你展示网络引导客户端如何与中心化配置的 iPXE 引导菜单进行交互。
### 设置使用 KRB5 认证的 NFS4 Home 目录
按以前的文章 “[使用 Kerberos 强化共享的 NFS Home 目录安全性](https://fedoramagazine.org/secure-nfs-home-directories-kerberos)” 的指导来做这个设置。
### 删除 Liveuser 帐户
删除本系列文章第一部分中创建的 `liveuser` 帐户：
```
$ sudo -i
# sed -i '/automaticlogin/Id' /fc28/etc/gdm/custom.conf
# rm -f /fc28/etc/sudoers.d/liveuser
# for i in passwd shadow group gshadow; do sed -i '/^liveuser:/d' /fc28/etc/$i; done
```
### 配置 NTP、KRB5 和 SSSD
接下来，我们需要将 NTP、KRB5 和 SSSD 的配置文件复制进客户端使用的镜像中，以便于它们能够使用同一个帐户：
```
# MY_HOSTNAME=$(</etc/hostname)
# MY_DOMAIN=${MY_HOSTNAME#*.}
# dnf -y --installroot=/fc28 install ntp krb5-workstation sssd
# cp /etc/ntp.conf /fc28/etc
# chroot /fc28 systemctl enable ntpd.service
# cp /etc/krb5.conf.d/${MY_DOMAIN%%.*} /fc28/etc/krb5.conf.d
# cp /etc/sssd/sssd.conf /fc28/etc/sssd
```
在已配置的识别服务的基础上，重新配置 sssd 提供认证服务：
```
# sed -i '/services =/s/$/, pam/' /fc28/etc/sssd/sssd.conf
```
另外，配置成确保客户端不能更改这个帐户密码：
```
# sed -i '/id_provider/a \ \ ad_maximum_machine_account_password_age = 0' /fc28/etc/sssd/sssd.conf
```
另外，复制 nfsnobody 的定义：
```
# for i in passwd shadow group gshadow; do grep "^nfsnobody:" /etc/$i >> /fc28/etc/$i; done
```
### 加入活动目录
接下来，你将执行一个 `chroot` 将客户端镜像加入到活动目录。从删除预置在网络引导镜像中同名的计算机帐户开始：
```
# MY_USERNAME=jsmith
# MY_CLIENT_HOSTNAME=$(</fc28/etc/hostname)
# adcli delete-computer "${MY_CLIENT_HOSTNAME%%.*}" -U "$MY_USERNAME"
```
在网络引导镜像中如果有 `krb5.keytab` 文件，也删除它：
```
# rm -f /fc28/etc/krb5.keytab
```
`chroot` 到网络引导镜像中：
```
# for i in dev dev/pts dev/shm proc sys run; do mount -o bind /$i /fc28/$i; done
# chroot /fc28 /usr/bin/bash --login
```
执行一个加入操作：
```
# MY_USERNAME=jsmith
# MY_HOSTNAME=$(</etc/hostname)
# MY_DOMAIN=${MY_HOSTNAME#*.}
# MY_REALM=${MY_DOMAIN^^}
# MY_OU="cn=computers,dc=${MY_DOMAIN//./,dc=}"
# adcli join $MY_DOMAIN --login-user="$MY_USERNAME" --computer-name="${MY_HOSTNAME%%.*}" --host-fqdn="$MY_HOSTNAME" --user-principal="host/$MY_HOSTNAME@$MY_REALM" --domain-ou="$MY_OU"
```
现在登出 chroot，并清除 root 用户的命令历史：
```
# logout
# for i in run sys proc dev/shm dev/pts dev; do umount /fc28/$i; done
# > /fc28/root/.bash_history
```
### 安装和配置 PAM 挂载
我们希望客户端登入后自动挂载用户家目录。为实现这个目的，我们将要使用 `pam_mount` 模块。安装和配置 `pam_mount`：
```
# dnf install -y --installroot=/fc28 pam_mount
# cat << END > /fc28/etc/security/pam_mount.conf.xml
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE pam_mount SYSTEM "pam_mount.conf.xml.dtd">
<pam_mount>
<debug enable="0" />
<volume uid="1400000000-1499999999" fstype="nfs4" server="$MY_HOSTNAME" path="/home/%(USER)" mountpoint="/home/%(USER)" options="sec=krb5" />
<mkmountpoint enable="1" remove="0" />
<msg-authpw>Password:</msg-authpw>
</pam_mount>
END
```
重新配置 PAM 去使用 `pam_mount`：
```
# dnf install -y patch
# cp -r /fc28/usr/share/authselect/default/sssd /fc28/etc/authselect/custom
# echo 'initgroups: files' >> /fc28/etc/authselect/custom/sssd/nsswitch.conf
# patch /fc28/etc/authselect/custom/sssd/system-auth << END
@@ -12 +12,2 @@
-auth sufficient pam_sss.so forward_pass
+auth requisite pam_mount.so {include if "with-pammount"}
+auth sufficient pam_sss.so {if "with-pammount":use_first_pass|forward_pass}
@@ -35,2 +36,3 @@
session required pam_unix.so
+session optional pam_mount.so {include if "with-pammount"}
session optional pam_sss.so
END
# patch /fc28/etc/authselect/custom/sssd/password-auth << END
@@ -9 +9,2 @@
-auth sufficient pam_sss.so forward_pass
+auth requisite pam_mount.so {include if "with-pammount"}
+auth sufficient pam_sss.so {if "with-pammount":use_first_pass|forward_pass}
@@ -32,2 +33,3 @@
session required pam_unix.so
+session optional pam_mount.so {include if "with-pammount"}
session optional pam_sss.so
END
# chroot /fc28 authselect select custom/sssd with-pammount --force
```
另外，要确保从客户端上总是可解析 NFS 服务器的主机名：
```
# MY_IP=$(host -t A $MY_HOSTNAME | awk '{print $4}')
# echo "$MY_IP $MY_HOSTNAME ${MY_HOSTNAME%%.*}" >> /fc28/etc/hosts
```
可选，允许所有用户可以使用 `sudo`：
```
# echo '%users ALL=(ALL) NOPASSWD: ALL' > /fc28/etc/sudoers.d/users
```
### 转换 NFS 根目录到一个 iSCSI 后备存储器
在一个 nfsroot 连接建立之后，目前版本的 nfs-utils 可能很难为家目录建立一个从客户端到 NFS 服务器的第二个连接。当尝试去访问家目录时，客户端将被挂起。因此，为了共享网络引导镜像，我们将使用一个不同的协议（iSCSI）来规避这个问题。
首先 `chroot` 到镜像中，重新配置它的 `initramfs`，让它从一个 iSCSI 根目录中去引导：
```
# for i in dev dev/pts dev/shm proc sys run; do mount -o bind /$i /fc28/$i; done
# chroot /fc28 /usr/bin/bash --login
# dnf install -y iscsi-initiator-utils
# sed -i 's/nfs/iscsi/' /etc/dracut.conf.d/netboot.conf
# echo 'omit_drivers+=" qedi "' > /etc/dracut.conf.d/omit-qedi.conf
# echo 'blacklist qedi' > /etc/modprobe.d/blacklist-qedi.conf
# KERNEL=$(ls -c /lib/modules | head -n 1)
# INITRD=$(find /boot -name 'init*' | grep -m 1 $KERNEL)
# dracut -f $INITRD $KERNEL
# logout
# for i in run sys proc dev/shm dev/pts dev; do umount /fc28/$i; done
# > /fc28/root/.bash_history
```
在测试时，qedi 驱动会破坏 iSCSI，因此我们将它禁用。
接着，创建一个 `fc28.img` [稀疏文件](https://en.wikipedia.org/wiki/Sparse_file)。这个稀疏文件代表 iSCSI 目标的后备存储器：
```
# FC28_SIZE=$(du -ms /fc28 | cut -f 1)
# dd if=/dev/zero of=/fc28.img bs=1MiB count=0 seek=$(($FC28_SIZE*2))
```
（如果你有一个可使用的独立分区或磁盘驱动器，也可以用它，而不用再去创建这个稀疏文件了。）
接着，使用一个文件系统去格式化镜像、挂载它、然后将网络引导镜像复制进去：
```
# mkfs -t xfs -L NETROOT /fc28.img
# TEMP_MNT=$(mktemp -d)
# mount /fc28.img $TEMP_MNT
# cp -a /fc28/* $TEMP_MNT
# umount $TEMP_MNT
```
在使用 SquashFS 测试时，客户端偶尔会出现小状况。似乎是因为 SquashFS 在多处理器客户端上没法执行随机 I/O。（更多内容见 [squashfs 读取卡顿的奇怪案例](https://chrisdown.name/2018/04/17/kernel-adventures-the-curious-case-of-squashfs-stalls.html)）。如果你希望使用文件系统压缩来提升吞吐性能，[ZFS](https://en.wikipedia.org/wiki/ZFS) 或许是个很好的选择。
如果你对 iSCSI 服务器的吞吐性能要求非常高（比如，成百上千的客户端要连接它），可能需要使用带 [负载均衡](https://en.wikipedia.org/wiki/Load_balancing_(computing)) 的 [Ceph](http://docs.ceph.com/docs/mimic/rbd/iscsi-overview/) 集群了。更多相关内容，请查看 [使用 HAProxy 和 Keepalived 负载均衡的 Ceph 对象网关](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/7/html/load_balancer_administration/ceph_example)。
### 安装和配置 iSCSI
为了给我们的客户端提供网络引导镜像，安装 `scsi-target-utils` 包：
```
# dnf install -y scsi-target-utils
```
配置 iSCSI 守护程序去提供 `fc28.img` 文件：
```
# MY_REVERSE_HOSTNAME=$(echo $MY_HOSTNAME | tr '.' "\n" | tac | tr "\n" '.' | cut -b -${#MY_HOSTNAME})
# cat << END > /etc/tgt/conf.d/fc28.conf
<target iqn.$MY_REVERSE_HOSTNAME:fc28>
backing-store /fc28.img
readonly 1
</target>
END
```
开头的 `iqn.` 是 `/usr/lib/dracut/modules.d/40network/net-lib.sh` 所需要的。
添加一个防火墙例外，并启用和启动这个服务：
```
# firewall-cmd --add-service=iscsi-target
# firewall-cmd --runtime-to-permanent
# systemctl enable tgtd.service
# systemctl start tgtd.service
```
你现在应该能够使用 `tatadm` 命令看到这个镜像共享了：
```
# tgtadm --mode target --op show
```
上述命令的输出应该类似如下的内容：
```
Target 1: iqn.edu.example.server-01:fc28
System information:
Driver: iscsi
State: ready
I_T nexus information:
LUN information:
LUN: 0
Type: controller
SCSI ID: IET 00010000
SCSI SN: beaf10
Size: 0 MB, Block size: 1
Online: Yes
Removable media: No
Prevent removal: No
Readonly: No
SWP: No
Thin-provisioning: No
Backing store type: null
Backing store path: None
Backing store flags:
LUN: 1
Type: disk
SCSI ID: IET 00010001
SCSI SN: beaf11
Size: 10488 MB, Block size: 512
Online: Yes
Removable media: No
Prevent removal: No
Readonly: Yes
SWP: No
Thin-provisioning: No
Backing store type: rdwr
Backing store path: /fc28.img
Backing store flags:
Account information:
ACL information:
ALL
```
现在，我们可以去删除本系列文章的第一部分中创建的 NFS 共享了：
```
# rm -f /etc/exports.d/fc28.exports
# exportfs -rv
# umount /export/fc28
# rmdir /export/fc28
# sed -i '/^\/fc28 /d' /etc/fstab
```
你也可以删除 `/fc28` 文件系统，但为了以后进一步更新，你可能需要保留它。
### 更新 ESP 去使用 iSCSI 内核
更新 ESP 去包含启用了 iSCSI 的 `initramfs`：
```
$ rm -vf $HOME/esp/linux/*.fc28.*
$ MY_KRNL=$(ls -c /fc28/lib/modules | head -n 1)
$ cp $(find /fc28/lib/modules -maxdepth 2 -name 'vmlinuz' | grep -m 1 $MY_KRNL) $HOME/esp/linux/vmlinuz-$MY_KRNL
$ cp $(find /fc28/boot -name 'init*' | grep -m 1 $MY_KRNL) $HOME/esp/linux/initramfs-$MY_KRNL.img
```
更新 `boot.cfg` 文件去传递新的 `root` 和 `netroot` 参数：
```
$ MY_NAME=server-01.example.edu
$ MY_EMAN=$(echo $MY_NAME | tr '.' "\n" | tac | tr "\n" '.' | cut -b -${#MY_NAME})
$ MY_ADDR=$(host -t A $MY_NAME | awk '{print $4}')
$ sed -i "s! root=[^ ]*! root=/dev/disk/by-path/ip-$MY_ADDR:3260-iscsi-iqn.$MY_EMAN:fc28-lun-1 netroot=iscsi:$MY_ADDR::::iqn.$MY_EMAN:fc28!" $HOME/esp/linux/boot.cfg
```
现在，你只需要从 `$HOME/esp/linux` 目录中复制更新后的文件到所有客户端系统的 ESP 中。你应该会看到类似下面屏幕截图的结果：
### 更新镜像
首先，复制出一个当前镜像的副本：
```
# cp -a /fc28 /fc29
```
`chroot` 进入到镜像的新副本：
```
# for i in dev dev/pts dev/shm proc sys run; do mount -o bind /$i /fc29/$i; done
# chroot /fc29 /usr/bin/bash --login
```
允许更新内核：
```
# sed -i 's/^exclude=kernel-\*$/#exclude=kernel-*/' /etc/dnf/dnf.conf
```
执行升级：
```
# dnf distro-sync -y --releasever=29
```
阻止更新过的内核被再次更新：
```
# sed -i 's/^#exclude=kernel-\*$/exclude=kernel-*/' /etc/dnf/dnf.conf
```
上述命令是可选的，但是在以后，如果在镜像中添加和更新了几个包，在你的客户端之外保存有一个最新内核的副本，会在关键时刻对你非常有帮助。
清理 dnf 的包缓存：
```
# dnf clean all
```
退出 chroot 并清理 root 的命令历史：
```
# logout
# for i in run sys proc dev/shm dev/pts dev; do umount /fc29/$i; done
# > /fc29/root/.bash_history
```
创建 iSCSI 镜像：
```
# FC29_SIZE=$(du -ms /fc29 | cut -f 1)
# dd if=/dev/zero of=/fc29.img bs=1MiB count=0 seek=$(($FC29_SIZE*2))
# mkfs -t xfs -L NETROOT /fc29.img
# TEMP_MNT=$(mktemp -d)
# mount /fc29.img $TEMP_MNT
# cp -a /fc29/* $TEMP_MNT
# umount $TEMP_MNT
```
定义一个新的 iSCSI 目标，指向到新的镜像并导出它：
```
# MY_HOSTNAME=$(</etc/hostname)
# MY_REVERSE_HOSTNAME=$(echo $MY_HOSTNAME | tr '.' "\n" | tac | tr "\n" '.' | cut -b -${#MY_HOSTNAME})
# cat << END > /etc/tgt/conf.d/fc29.conf
<target iqn.$MY_REVERSE_HOSTNAME:fc29>
backing-store /fc29.img
readonly 1
</target>
END
# tgt-admin --update ALL
```
添加新内核和 `initramfs` 到 ESP：
```
$ MY_KRNL=$(ls -c /fc29/lib/modules | head -n 1)
$ cp $(find /fc29/lib/modules -maxdepth 2 -name 'vmlinuz' | grep -m 1 $MY_KRNL) $HOME/esp/linux/vmlinuz-$MY_KRNL
$ cp $(find /fc29/boot -name 'init*' | grep -m 1 $MY_KRNL) $HOME/esp/linux/initramfs-$MY_KRNL.img
```
更新 ESP 的 `boot.cfg`：
```
$ MY_DNS1=192.0.2.91
$ MY_DNS2=192.0.2.92
$ MY_NAME=server-01.example.edu
$ MY_EMAN=$(echo $MY_NAME | tr '.' "\n" | tac | tr "\n" '.' | cut -b -${#MY_NAME})
$ MY_ADDR=$(host -t A $MY_NAME | awk '{print $4}')
$ cat << END > $HOME/esp/linux/boot.cfg
#!ipxe
kernel --name kernel.efi \${prefix}/vmlinuz-$MY_KRNL initrd=initrd.img ro ip=dhcp rd.peerdns=0 nameserver=$MY_DNS1 nameserver=$MY_DNS2 root=/dev/disk/by-path/ip-$MY_ADDR:3260-iscsi-iqn.$MY_EMAN:fc29-lun-1 netroot=iscsi:$MY_ADDR::::iqn.$MY_EMAN:fc29 console=tty0 console=ttyS0,115200n8 audit=0 selinux=0 quiet
initrd --name initrd.img \${prefix}/initramfs-$MY_KRNL.img
boot || exit
END
```
最后，从我的 `$HOME/esp/linux` 目录中复制文件到所有客户端系统的 ESP 中去使用它吧！
---
via: <https://fedoramagazine.org/how-to-build-a-netboot-server-part-2/>
作者：[Gregory Bartholomew](https://fedoramagazine.org/author/glb/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linux 求职建议
|
Andrea W.codingly
|
http://reallylinux.com/docs/gettinglinuxjobs.shtml
|
通过对招聘网站数据的仔细研究，我们发现，即使是非常有经验的 Linux 程序员，也会在面试中陷入困境。
|
/data/attachment/album/201812/30/103638xo3qtjrnq8g6q3wj.jpg.thumb.jpg
|
/data/attachment/album/201812/30/103638xo3qtjrnq8g6q3wj.jpg
| true | false | true |
Ryze-Borgia
|
wxy
| false |
[
"面试",
"招聘"
] |
职业生涯
|
{
"viewnum": 4743,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
通过对招聘网站数据的仔细研究，我们发现，即使是非常有经验的 Linux 程序员，也会在面试中陷入困境。
| 2018-12-30T10:37:00 | 2018-12-30T10:37:00 | 10,397 |
/article-10397-1.html
|
通过对招聘网站数据的仔细研究，我们发现，即使是非常有经验的 Linux 程序员，也会在面试中陷入困境。
这就导致了很多优秀并且有经验的人无缘无故地找不到合适的工作，因为如今的就业市场需要我们有一些手段来提高自己的竞争力。
我有两个同事和一个表哥，他们都有 RedHat 认证，管理过比较大的服务器机房，也都收到过前雇主的认真推荐。
可是，在他们应聘的时候，所有的这些证书、本身的能力、工作经验好像都没有起到任何作用，他们所面对的招聘广告是某人从技术词汇中临时挑选的一些“技能片段”所组成的。
现如今，礼貌变得过时了，**不回应**变成了发布招聘广告的公司的新沟通方式。
这同样也意味着大多公司的招聘或者人事可能会**错过**非常优秀的应聘者。
我之所以敢说的如此肯定，是因为现在招聘广告大多数看上去都非常的滑稽。
[Reallylinux.com](http://reallylinux.com) 另一位特约撰稿人 Walter ，发表过一篇关于 [招聘广告疯掉了](http://reallylinux.com/docs/wantadsmad.shtml) 的文章。
他说的也许是对的，可是我认为 Linux 工作应聘者可以通过注意招聘广告的**三个关键点**避免落入陷阱。
**首先**，很少会有 Linux 系统管理员的招聘广告只针对 Linux 有要求。
一定要注意很少有 Linux 系统管理员的职位是实际在服务器上跑 Linux的，反而，很多在搜索 “Linux 管理员” 得到的职位实际上是指大量的 \*NX 操作系统的。
举个例子，有一则关于 **Linux 管理员** 的招聘广告：
>
> 该职位需要为建立系统集成提供支持，尤其是 BSD 应用的系统安装…
>
>
>
或者有一些其他的要求：
>
> 有 Windows 系统管理经验的。
>
>
>
最为讽刺的是，如果你在应聘面试的时候表现出专注于 Linux 的话，你可能不会被聘用。
另外，如果你直接把 Linux 写在你的特长或者专业上，他们可能都不会仔细看你的简历，因为他们根本区分不了 UNIX、BSD、Linux。
最终的结果就是，如果你太老实，只在简历上写了 Linux，你可能会被直接过掉，但是如果你把 Linux 改成 UNIX/Linux 的话，可能会走得更远。
我有两个同事最后修改了他们的简历，然后获得了更好的面试机会，虽然依旧没有被聘用，因为大多数招聘广告其实已经内定人员了，这些招聘信息被放出来仅仅是为了表现出他们有招聘的想法。
**第二点**，公司里唯一在乎系统管理员职位的只有技术主管，其他人包括人事或管理层根本不关心这个。
我记得有一次开会旁听的时候，听见一个执行副总裁把服务器管理人员说成“一毛钱一打的人”，这种想法是多么的奇怪啊。
讽刺的是，等到邮件系统出故障，电话交换机连接时不时会断开，或者核心商业文件从企业内网中消失的时候，这些总裁又是最先打电话给系统管理员的。
或许如果他们不整天在电话留言中说那么多空话，或者不往邮件里塞满妻子的照片和旅行途中的照片的话，服务器可能就不会崩溃。
请注意，招聘 Linux 运维或者服务器管理员的广告被放出来是因为公司**技术层**认为有迫切的需求。你也不需要和人事或者公司高层聊什么，搞清楚谁是招聘的技术经理然后打电话给他们。
你需要直接联系他们因为“有些技术问题”是人事回答不了的，即使你只有 60 秒的时间可以和他们交流，你也必须抓住这个机会和真正有需求并且懂技术的人沟通。
那如果人事的漂亮 MM 不让你直接联系技术怎么办呢？
开始记得问人事一些技术性问题，比如说他们的 Linux 集群是如何建立的，它们运行在独立的虚拟机上吗？这些技术性的问题会让人事变得不耐烦，最后让你有机会问出“我能不能直接联系你们团队的技术人员”。
如果对方的回答是“应该可以”或者“稍后回复你”，那么他们可能已经在两周前就已经计划好了找一个人来填补这个空缺，比如说人事部员工的未婚夫。**他们只是不希望看起来太像裙带主义，而是带有一点利己主义的不确定主义。**
所以一定要记得花点时间弄清楚到底谁是发布招聘广告的直接**技术**负责人，然后和他们聊一聊，这可能会让你少一番胡扯并且让你更有可能应聘成功。
**第三点**，现在的招聘广告很少有完全真实的内容了。
我以前见过一个招聘具有高级别专家也不会有的专门知识的初级系统管理员的广告，他们的计划是列出公司的发展计划蓝图，然后找到应聘者。
在这种情况下，你应聘 Linux 管理员职位应该提供几个关键性信息，例如工作经验和相关证书。
诀窍在于，用这些关键词尽量装点你的简历，以匹配他们的招聘信息，这样他们几乎不可能发现你缺失了哪个关键词。
这并不一定会让你成功找到一份工作，但它可以让你获得一次面试机会，这也算是一个巨大的进步。
通过理解和应用以上三点，或许可以让那些寻求 Linux 管理员工作的人能够比那些只有一线地狱机会的人领先一步。
即使这些建议不能让你马上得到面试机会，你也可以利用这些经验和意识去参加贸易展或公司主办的技术会议等活动。
我强烈建议你们也经常参加这种活动，尤其是当它们比较近的话，可以给你一个扩展人脉的机会。
请记住，如今的职业人脉已经失去了原来的意义了，现在只是可以用来获取“哪些公司实际上在招聘、哪些公司只是为了给股东带来增长的表象而在职位方面撒谎”的小道消息。
---
via: <http://reallylinux.com/docs/gettinglinuxjobs.shtml>
作者：[Andrea W.Codingly](http://reallylinux.com) 译者：[Ryze-Borgia](https://github.com/Ryze-Borgia) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
在 Linux 命令行中观看彩虹猫来稍事休息
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-nyancat
|
你甚至可以在终端里欣赏彩虹猫。
|
/data/attachment/album/201812/30/111259x9ssj5a9881a1h88.png.thumb.jpg
|
/data/attachment/album/201812/30/111259x9ssj5a9881a1h88.png
| true | false | true |
lujun9972
|
zhs852
|
wxy
| false |
[
"彩虹猫"
] |
分享
|
{
"viewnum": 6236,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "210.30.193.134",
"message": "Emacs有这个插件，终于知道是怎么回事了。原来是外国流行的梗☺",
"username": "来自210.30.193.134的 Chrome 71.0|GNU/Linux 用户",
"date": "2018-12-30T17:27:26"
}
] |
[] |
你甚至可以在终端里欣赏彩虹猫。
| 2018-12-30T11:12:00 | 2018-12-30T11:12:00 | 10,398 |
/article-10398-1.html
|
>
> 你甚至可以在终端里欣赏彩虹猫。
>
>
>
今天是《Linux 命令行小玩具介绍》的第六天。在本系列文章中，我们将会探索一些娱乐用途（甚至有时完全没用）的 Linux 命令行小玩具。所有我们介绍的小玩具都是开源的。
也许你会问，它们都很独特吗？是的。不过，它们对你是否独特，我就不知道了。但是，我们相信你应该能在这系列文章结束之前找到至少一个好玩的玩具。
从[昨天的选题](https://opensource.com/article/18/12/linux-toy-lolcat)继续：我们谈到了猫和彩虹。不过，在 Linux 命令行下有更有趣的彩虹和猫结合的程序吗？答案是肯定的。
我们不妨看看之前可以在命令行中使用彩虹猫的方式吧。意料之中，2011 年发布的 [彩虹猫](https://en.wikipedia.org/wiki/Nyan_Cat) 可以用 `nyancat` 呈现在终端中。你想念这只曾火遍网络的彩虹猫吗？看看下面这个视频记录吧，我会等你看完的。
现在，让我们在终端中重新感受这个令人惊奇的体验吧。`nyancat` 包正在很多发行版上（比如 Arch、Debian、Gentoo、Ubuntu 等等……）都有，不过我的系统（Fedora）没有，但是我们仍然可以很轻松地从源码编译它。
根据读者的一个很好的提醒，对于我来说，这应该在该系列中提及：要警惕从不受信任的来源安装应用程序，或者编译和运行你在网上找到的任何代码，就像你在这样的文章中找到这个一样。如果您不确定，请采取适当的预防措施，特别是如果您在生产机器上。
从这里克隆源代码：
```
git clone https://github.com/klange/nyancat.git
```
然后使用 `make` 编译，并用 `./nyancat` 来运行。
这直接为我带来了彩虹猫体验，甚至还有个计时器来显示我享受 “彩虹猫魔法”的时间。
你可以在 [GitHub](https://github.com/klange/nyancat) 上找到 `nyancat` 的源码，它正以 [NCSA 许可证](http://en.wikipedia.org/wiki/University_of_Illinois/NCSA_Open_Source_License) 开源。
命令行版本的彩虹猫可在[这个公共 Telnet 服务器上访问](http://nyancat.dakko.us/)（或者用另外一个猫 [netcat](http://netcat.sourceforge.net/) 也行），所以理论上来说你不必安装它。不过不幸的是，由于带宽限制，该服务器目前已经被关闭了。尽管如此，在各种老设备上连接老 Telnet 服务器上运行彩虹猫的[照片](http://nyancat.dakko.us/)还是值得一看的，说不准你还会萌生搭建一个能让大家连接的公共服务器的想法呢（如果你真的搭建了，请务必告知作者，万一他们可能会向公众分享呢？）。
你想让我介绍一下你最喜爱的命令行玩具吗？请在原文下留言，作者会考虑介绍的。
瞧瞧我们昨天介绍的小玩意：[用 lolcat 为你的 Linux 终端增添些许色彩](https://opensource.com/article/18/12/linux-toy-lolcat)。明天再来看我们的下一篇文章吧！
---
via: <https://opensource.com/article/18/12/linux-toy-nyancat>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[zhs852](https://github.com/zhs852) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用户、组及其它 Linux 特性（二）
|
Paul Brown
|
https://www.linux.com/blog/learn/intro-to-linux/2018/7/users-groups-and-other-linux-beasts-part-2
|
我们继续创建和管理用户和组的 Linux 教程之旅。
|
/data/attachment/album/201812/30/193339hj9zyiyosbnbdrjo.jpg.thumb.jpg
|
/data/attachment/album/201812/30/193339hj9zyiyosbnbdrjo.jpg
| true | false | true |
lujun9972
|
MjSeven
|
wxy
| false |
[
"用户",
"用户组"
] |
技术
|
{
"viewnum": 4465,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10370,
"displayorder": 0
}
] |
我们继续创建和管理用户和组的 Linux 教程之旅。
| 2018-12-30T19:33:35 | 2018-12-30T19:33:35 | 10,399 |
/article-10399-1.html
|
>
> 我们继续创建和管理用户和组的 Linux 教程之旅。
>
>
>
在正在进行的 Linux 之旅中，我们了解了[如何操作文件夹或目录](/article-10066-1.html)，现在我们继续讨论 权限、用户 和 组，这对于确定谁可以操作哪些文件和目录是必要的。[上次](/article-10370-1.html)，我们展示了如何创建新用户，现在我们将重新起航：
你可以使用 `groupadd` 命令创建新组，然后随意添加用户。例如，使用：
```
sudo groupadd photos
```
这将会创建 `photos` 组。
你需要在根目录下[创建一个目录](/article-10066-1.html)：
```
sudo mkdir /photos
```
如果你运行 `ls -l /`，结果中会有如下这一行：
```
drwxr-xr-x 1 root root 0 jun 26 21:14 photos
```
输出中的第一个 `root` 是所属的用户，第二个 `root` 是所属的组。
要将 `/photos` 目录的所有权转移到 `photos` 组，使用：
```
chgrp photos /photos
```
`chgrp` 命令通常采用两个参数，第一个参数是将要获得文件或目录所有权的组，第二个参数是希望交给组的文件或目录。
接着，运行 `ls -l /`，你会发现刚才那一行变了：
```
drwxr-xr-x 1 root photos 0 jun 26 21:14 photos
```
你已成功将新目录的所有权转移到了 `photos` 组。
然后，将你自己的用户和 `guest` 用户添加到 `photos` 组：
```
sudo usermod <你的用户名> -a -G photos
sudo usermod guest -a -G photos
```
你可能必须注销并重新登录才能看到更改，但是当你这样做时，运行 `groups` 会将 `photos` 显示为你所属的组之一。
关于上面提到的 `usermod` 命令，需要指明几点。第一：注意要使用 `-G` 选项而不是 `-g` 选项。`-g` 选项更改你的主要组，如果你意外地使用它，它可能会锁定你的一些东西。另一方面，`-G` 将你添加到列出的组中，并没有干扰主要组。如果要将用户添加到多个组中，在 `-G` 之后逐个列出它们，用逗号分隔，不要有空格：
```
sudo usermod <your username> -a -G photos,pizza,spaceforce
```
第二点：小心点不要忘记 `-a` 参数。`-a` 参数代表追加，将你传递给 `-G` 的组列表附加到你已经属于的组。这意味着，如果你不包含 `-a`，那么你之前所属的组列表将被覆盖，再次将你拒之门外。
这些都不是灾难性问题，但这意味着你必须手动将用户添加回你所属的所有组，这可能是个麻烦，特别是如果你失去了对 `sudo` 和 `wheel` 组的访问权限。
### 权限
在将图像复制到 `/photos` 目录之前，还要做一件事情。注意，当你执行上面的 `ls -l /` 时，该文件夹的权限将以 `drwxr-xr-x` 形式返回。
如果你阅读[我在本文开头推荐的文章](https://www.linux.com/learn/understanding-linux-file-permissions)，你将知道第一个 `d` 表示文件系统中的条目是一个目录，接着你有三组三个字符（`rwx`、`r-x`、`r-x`），它们表示目录的所属用户（`rwx`）的权限，然后是所属组（`r-x`）的权限，最后是其他用户（`r-x`）的权限。这意味着到目前为止唯一具有写权限的人，即能够在 `/photos` 目录中复制或创建文件的唯一人员是 `root` 用户。
但是[我提到的那篇文章也告诉你如何更改目录或文件的权限](https://www.linux.com/learn/understanding-linux-file-permissions)：
```
sudo chmod g+w /photos
```
运行 `ls -l /`，你会看到 `/photos` 权限变为了 `drwxrwxr-x`。这就是你希望的：组成员现在可以对目录进行写操作了。
现在你可以尝试将图像或任何其他文件复制到目录中，它应该没有问题：
```
cp image.jpg /photos
```
`guest` 用户也可以从目录中读取和写入。他们也可以读取和写入，甚至移动或删除共享目录中其他用户创建的文件。
### 总结
Linux 中的权限和特权系统已经磨练了几十年，它继承自昔日的旧 Unix 系统。就其本身而言，它工作的非常好，而且经过了深思熟虑。熟悉它对于任何 Linux 系统管理员都是必不可少的。事实上，除非你理解它，否则你根本就无法做很多事情。但是，这并不难。
下一次，我们将深入研究文件，并以一个创新的方式查看创建，操作和销毁文件的不同方法。最后一个总是很有趣。
回头见！
*通过 Linux 基金会和 edX 的免费[“Linux 简介”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)课程了解有关 Linux 的更多信息。*
---
via: <https://www.linux.com/blog/learn/intro-to-linux/2018/7/users-groups-and-other-linux-beasts-part-2>
作者：[Paul Brown](https://www.linux.com/users/bro66) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用于游戏开发的图形和音乐工具
|
Charlie Murphy
|
https://opensource.com/article/18/1/graphics-music-tools-game-dev
|
要在三天内打造一个可玩的游戏，你需要一些快速而稳定的好工具。
|
/data/attachment/album/201812/31/001708cq67g0u9kkzz7j6z.png.thumb.jpg
|
/data/attachment/album/201812/31/001708cq67g0u9kkzz7j6z.png
| true | false | true |
robsean
|
wxy
| false |
[
"游戏",
"开发"
] |
软件开发
|
{
"viewnum": 6640,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "202.189.2.194",
"message": "三天",
"username": "来自北京的 Chrome 71.0|Windows 7 用户",
"date": "2019-01-05T17:26:56"
}
] |
[
{
"raid": 10496,
"displayorder": 0
}
] |
要在三天内打造一个可玩的游戏，你需要一些快速而稳定的好工具。
| 2018-12-31T00:17:01 | 2018-12-31T00:17:01 | 10,400 |
/article-10400-1.html
|
>
> 要在三天内打造一个可玩的游戏，你需要一些快速而稳定的好工具。
>
>
>
在十月初，我们的俱乐部马歇尔大学的 [Geeks and Gadgets](http://mugeeks.org/) 参加了首次 [Open Jam](https://itch.io/jam/open-jam-1)，这是一个庆祝最佳开源工具的游戏 Jam。游戏 Jam 是一种活动，参与者以团队协作的方式来开发有趣的计算机游戏。Jam 一般都很短，仅有三天，并且非常累。Opensource.com 在八月下旬[发布了](https://opensource.com/article/17/8/open-jam-announcement) Open Jam 活动，足有 [45 支游戏](https://opensource.com/article/17/11/open-jam) 进入到了竞赛中。
我们的俱乐部希望在我们的项目中创建和使用开放源码软件，所以 Open Jam 自然是我们想要参与的 Jam 了。我们提交的游戏是一个实验性的游戏，名为 [Mark My Words](https://mugeeksalpha.itch.io/mark-omy-words)。我们使用了多种自由和开放源码 (FOSS) 工具来开发它；在这篇文章中，我们将讨论一些我们使用的工具和我们注意到可能有潜在阻碍的地方。
### 音频工具
#### MilkyTracker
[MilkyTracker](http://milkytracker.titandemo.org/) 是一个可用于编曲老式视频游戏中的音乐的软件包。它是一种<ruby> <a href="https://en.wikipedia.org/wiki/Music_tracker"> 音乐声道器 </a> <rt> music tracker </rt></ruby>，是一个强大的 MOD 和 XM 文件创建器，带有基于特征网格的模式编辑器。在我们的游戏中，我们使用它来编曲大多数的音乐片段。这个程序最好的地方是，它比我们其它的大多数工具消耗更少的硬盘空间和内存。虽然如此，MilkyTracker 仍然非常强大。
其用户界面需要一会来习惯，这里有对一些想试用 MilkyTracker 的音乐家的一些提示：
* 转到 “Config > Misc.” ，设置编辑模式的控制风格为 “MilkyTracker”，这将给你提供几乎全部现代键盘快捷方式。
* 用 `Ctrl+Z` 撤销
* 用 `Ctrl+Y` 重做
* 用空格键切换模式编辑方式
* 用退格键删除先前的音符
* 用插入键来插入一行
* 默认情况下，一个音符将持续作用，直到它在该频道上被替换。你可以明确地结束一个音符，通过使用一个反引号（`）键来插入一个 KeyOff 音符
* 在你开始谱写乐曲前，你需要创建或查找采样。我们建议在诸如 [Freesound](https://freesound.org/) 或 [ccMixter](http://ccmixter.org/view/media/home) 这样的网站上查找采用 [Creative Commons](https://creativecommons.org/) 协议的采样，
另外，把 [MilkyTracker 文档页面](http://milkytracker.titandemo.org/documentation/) 放在手边。它含有数不清的教程和手册的链接。一个好的起点是在该项目 wiki 上的 [MilkyTracker 指南](https://github.com/milkytracker/MilkyTracker/wiki/MilkyTracker-Guide)。
#### LMMS
我们的两个音乐家使用多用途的现代音乐创建工具 [LMMS](https://lmms.io/)。它带有一个绝妙的采样和效果库，以及多种多样的灵活的插件来生成独特的声音。LMMS 的学习曲线令人吃惊的低，在某种程度上是因为其好用的节拍/低音线编辑器。
我们对于想试试 LMMS 的音乐家有一个建议：使用插件。对于 [chiptune](https://en.wikipedia.org/wiki/Chiptune)式音乐，我们推荐 [sfxr](https://github.com/grimfang4/sfxr)、[BitInvader](https://lmms.io/wiki/index.php?title=BitInvader) 和 [FreeBoy](https://lmms.io/wiki/index.php?title=FreeBoy)。对于其它风格，[ZynAddSubFX](http://zynaddsubfx.sourceforge.net/) 是一个好的选择。它配备了各种合成仪器，可以根据您的需要进行更改。
### 图形工具
#### Tiled
在开放源码游戏开发中，[Tiled](http://www.mapeditor.org/) 是一个流行的贴片地图编辑器。我们使用它为来为我们在游戏场景中组合连续的、复古式的背景。
Tiled 可以导出地图为 XML、JSON 或普通的图片。它是稳定的、跨平台的。
Tiled 的功能之一允许你在地图上定义和放置随意的游戏对象，例如硬币和提升道具，但在 jam 期间我们没有使用它。你需要做的全部是以贴片集的方式加载对象的图像，然后使用“插入平铺”来放置它们。
一般来说，对于需要一个地图编辑器的项目，Tiled 是我们所推荐的软件中一个不可或缺的部分。
#### Piskel
[Piskel](https://www.piskelapp.com/) 是一个像素艺术编辑器，它的源文件代码以 [Apache 2.0 协议](https://github.com/piskelapp/piskel/blob/master/LICENSE) 发布。在这次 Jam 期间，们的大多数的图像资源都使用 Piskel 来处理，我们当然也将在未来的工程中使用它。
在这个 Jam 期间，Piskel 极大地帮助我们的两个功能是<ruby> 洋葱皮 <rt> Onion skin </rt></ruby>和<ruby> 精灵序列图 <rt> spritesheet </rt></ruby>导出。
##### 洋葱皮
洋葱皮功能将使 Piskel 以虚影显示你编辑的动画的前一帧和后一帧的，像这样:
洋葱皮是很方便的，因为它适合作为一个绘制指引和帮助你在整个动画进程中保持角色的一致形状和体积。 要启用它，只需单击屏幕右上角预览窗口下方的洋葱形图标即可。
##### 精灵序列图导出
Piskel 将动画导出为精灵序列图的能力也非常有用。精灵序列图是一个包含动画所有帧的光栅图像。例如，这是我们从 Piskel 导出的精灵序列图：
该精灵序列图包含两帧。一帧位于图像的上半部分，另一帧位于图像的下半部分。精灵序列图通过从单个文件加载整个动画，大大简化了游戏的代码。这是上面精灵序列图的动画版本：
##### Unpiskel.py
在 Jam 期间，我们很多次想批量转换 Piskel 文件到 PNG 文件。由于 Piskel 文件格式基于 JSON，我们写一个基于 GPLv3 协议的名为 [unpiskel.py](https://raw.githubusercontent.com/MUGeeksandGadgets/MarkMyWords/master/tools/unpiskel.py) 的 Python 小脚本来做转换。
它像这样被调用的：
```
python unpiskel.py input.piskel
```
这个脚本将从一个 Piskel 文件（这里是 `input.piskel`）中提取 PNG 数据帧和图层，并将它们各自存储。这些文件采用模式 `NAME_XX_YY.png` 命名，在这里 `NAME` 是 Piskel 文件的缩减名称，`XX` 是帧的编号，`YY` 是层的编号。
因为脚本可以从一个 shell 中调用，它可以用在整个文件列表中。
```
for f in *.piskel; do python unpiskel.py "$f"; done
```
### Python、Pygame 和 cx\_Freeze
#### Python 和 Pygame
我们使用 [Python](https://www.python.org/) 语言来制作我们的游戏。它是一个脚本语言，通常被用于文本处理和桌面应用程序开发。它也可以用于游戏开发，例如像 [Angry Drunken Dwarves](https://www.sacredchao.net/%7Epiman/angrydd/) 和 [Ren'Py](https://renpy.org/) 这样的项目所展示的。这两个项目都使用一个称为 [Pygame](https://www.Pygame.org/) 的 Python 库来显示图形和产生声音，所以我们也决定在 Open Jam 中使用这个库。
Pygame 被证明是既稳定又富有特色，并且它对我们创建的街机式游戏来说是很棒的。在低分辨率时，库的速度足够快的，但是在高分辨率时，它只用 CPU 的渲染开始变慢。这是因为 Pygame 不使用硬件加速渲染。然而，开发者可以充分利用 OpenGL 基础设施的优势。
如果你正在寻找一个好的 2D 游戏编程库，Pygame 是值得密切注意的一个。它的网站有 [一个好的教程](http://Pygame.org/docs/tut/PygameIntro.html) 可以作为起步。务必看看它！
#### cx\_Freeze
准备发行我们的游戏是有趣的。我们知道，Windows 用户不喜欢装一套 Python，并且要求他们来安装它可能很过分。除此之外，他们也可能必须安装 Pygame，在 Windows 上，这不是一个简单的工作。
很显然：我们必须放置我们的游戏到一个更方便的格式中。很多其他的 Open Jam 参与者使用专有的游戏引擎 Unity，它能够使他们的游戏在网页浏览器中来玩。这使得它们非常方便地来玩。便利性是一个我们的游戏中根本不存在的东西。但是，感谢生机勃勃的 Python 生态系统，我们有选择。已有的工具可以帮助 Python 程序员将他们的游戏做成 Windows 上的发布版本。我们考虑过的两个工具是 [cx\_Freeze](https://anthony-tuininga.github.io/cx_Freeze/) 和 [Pygame2exe](https://Pygame.org/wiki/Pygame2exe)（它使用 [py2exe](http://www.py2exe.org/)）。我们最终决定用 cx\_Freeze，因为它是跨平台的。
在 cx\_Freeze 中，你可以把一个单脚本游戏打包成发布版本，只要在 shell 中运行一个命令，像这样：
```
cxfreeze main.py --target-dir dist
```
`cxfreeze` 的这个调用将把你的脚本（这里是 `main.py`）和在你系统上的 Python 解释器捆绑到到 `dist` 目录。一旦完成，你需要做的是手动复制你的游戏的数据文件到 `dist` 目录。你将看到，`dist` 目录包含一个可以运行来开始你的游戏的可执行文件。
这里有使用 cx\_Freeze 的更复杂的方法，允许你自动地复制数据文件，但是我们发现简单的调用 `cxfreeze` 足够满足我们的需要。感谢这个工具，我们使我们的游戏玩起来更便利一些。
### 庆祝开源
Open Jam 是庆祝开源模式的软件开发的重要活动。这是一个分析开源工具的当前状态和我们在未来工作中需求的一个机会。对于游戏开发者探求其工具的使用极限，学习未来游戏开发所必须改进的地方，游戏 Jam 或许是最好的时机。
开源工具使人们能够在不损害自由的情况下探索自己的创造力，而无需预先投入资金。虽然我们可能不会成为专业的游戏开发者，但我们仍然能够通过我们的简短的实验性游戏 [Mark My Words](https://mugeeksalpha.itch.io/mark-omy-words) 获得一点点体验。它是一个以语言学为主题的游戏，描绘了虚构的书写系统在其历史中的演变。还有很多其他不错的作品提交给了 Open Jam，它们都值得一试。 真的，[去看看](https://itch.io/jam/open-jam-1/entries)！
在本文结束前，我们想要感谢所有的 [参加俱乐部的成员](https://github.com/MUGeeksandGadgets/MarkMyWords/blob/3e1e8aed12ebe13acccf0d87b06d4f3bd124b9db/README.md#credits)，使得这次经历真正的有价值。我们也想要感谢 [Michael Clayton](https://twitter.com/mwcz)、[Jared Sprague](https://twitter.com/caramelcode) 和 [Opensource.com](https://opensource.com/) 主办 Open Jam。简直酷毙了。
现在，我们对读者提出了一些问题。你是一个 FOSS 游戏开发者吗？你选择的工具是什么？务必在下面留下一个评论！
---
via: <https://opensource.com/article/18/1/graphics-music-tools-game-dev>
作者：[Charlie Murphy](https://opensource.com/users/rsg167) 译者：[robsean](https://github.com/robsean) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
CEO 的 Emacs 秘籍
|
Josh Stella
|
https://blog.fugue.co/2015-11-11-guide-to-emacs.html
|
一旦你了解了 Emacs，你就会意识到它其实是一台可以当发动机用的热核烤面包机……好吧，只是文本处理的所有事情。当考虑到你计算机的使用周期在很大程度上都是与文本有关时，这是一个相当大胆的声明。大胆，但却是真的。
|
/data/attachment/album/201812/31/201447ifjh5gn6idn0dvh0.jpg.thumb.jpg
|
/data/attachment/album/201812/31/201447ifjh5gn6idn0dvh0.jpg
| true | false | true |
oneforalone
|
wxy, oneforalone
| true |
[
"Emacs"
] |
技术
|
{
"viewnum": 8596,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10510,
"displayorder": 0
}
] |
一旦你了解了 Emacs，你就会意识到它其实是一台可以当发动机用的热核烤面包机……好吧，只是文本处理的所有事情。当考虑到你计算机的使用周期在很大程度上都是与文本有关时，这是一个相当大胆的声明。大胆，但却是真的。
| 2018-12-31T20:16:00 | 2018-12-31T20:16:00 | 10,401 |
/article-10401-1.html
|
几年前，不，是几十年前，我就在用 Emacs。不论是码代码、编写文档，还是管理邮件和日程，我都用这个编辑器，或者是说操作系统，而且我还乐此不疲。许多年过去了，我也转向了其他更新、更好的工具。结果，就连最基本的文件浏览，我都已经忘了在不用鼠标的情况下该怎么操作。大约三个月前，我意识到我在应用程序和计算机之间切换上耗费了大量的时间，于是我决定再次使用 Emacs。这是个很正确的决定，原因有以下几个。其中包括用 `.emacs` 和 Dropbox 来搭建一个良好的、可移植的环境的一些技巧。
对于那些还没用过 Emacs 的人来说，Emacs 会让你爱恨交加。它有点像一个房子大小的<ruby> 鲁布·戈德堡机械 <rt> Rube Goldberg machine </rt></ruby>，乍一看，它具备烤面包机的所有功能。这听起来不像是一种认可，但关键词是“乍一看”。一旦你了解了 Emacs，你就会意识到它其实是一台可以当发动机用的热核烤面包机……好吧，只是指文本处理的所有事情。当考虑到你计算机的使用周期在很大程度上都是与文本有关时，这是一个相当大胆的声明。大胆，但却是真的。
也许对我来说更重要的是，Emacs 是我曾经使用过的一个应用，并让我觉得我真正的拥有它，而不是把我塑造成一个匿名的“用户”，就好像位于 [Soma](http://www.huffingtonpost.com/zachary-ehren/soma-isnt-a-drug-san-fran_b_987841.html)（LCTT 译注：旧金山的一个街区）或雷蒙德（LCTT 译注：微软总部所在地）附近某个高档办公室的产品营销部门把钱作为明确的目标一样。现代生产力和创作应用程序（如 Pages 或 IDE）就像碳纤维赛车，它们装备得很好，也很齐全。而 Emacs 就像一盒经典的 [Campagnolo](http://www.campagnolo.com/US/en) （LCTT 译注：世界上最好的三个公路自行车套件系统品牌之一）零件和一个漂亮的自行车牵引式钢框架，但缺少曲柄臂和刹车杆，你必须在网上某个小众文化中找到它们。前者更快而且很完整，后者是无尽的快乐或烦恼的源泉，当然这取决于你自己，而且这种快乐或烦恼会伴随到你死。我就是那种在找到一堆老古董或用 `Emacs Lisp` 配置编辑器时会感到高兴的人，具体情况因人而异。
*一辆我还在骑的 1933 年产的钢制自行车。你可以看看框架管差别： <https://www.youtube.com/watch?v=khJQgRLKMU0>*
这可能给人一种 Emacs 已经过气或过时的印象。然而并不是，Emacs 是强大和永恒的，只要你耐心地去理解它的一些规则。Emacs 的规则很另类，也很奇怪，但其中的逻辑却引人注目，且魅力十足。对于我来说， Emacs 更像是未来而不是过去。就像牵引式钢框架在未来几十年里将会变得好用和舒适，而神奇的碳纤维自行车将会被扔进垃圾场，在撞击中粉碎一样，Emacs 也将会作为一种在最新的流行应用早已被遗忘的时候的好用的工具继续存在这里。
使用 Lisp 代码来构建个人工作环境，并将这个恰到好处的环境移植到任何计算机，如果这种想法打动了你，那么你将会爱上 Emacs。如果你喜欢很潮、很炫的，又不想投入太多时间和精力的情况下就能直接工作的话，那么 Emacs 可能不适合你。我已经不再写代码了（除了 Ludwig 和 Emacs Lisp），但是 Fugue 公司的很多工程师都使用 Emacs 来提高码代码的效率。我公司有 30% 的工程师用 Emacs，40% 用 IDE 和 30% 的用 vim。但这篇文章是写给 CEO 和其他<ruby> <a href="http://www.businessinsider.com/best-pointy-haired-boss-moments-from-dilbert-2013-10"> 精英 </a> <rt> Pointy-Haired Bosses </rt></ruby>（PHB<sup id="fnref1"> <a href="#fn1" rel="footnote"> 1 </a></sup> ）（以及对 Emacs 感兴趣的人）的，所以我将解释或者说辩解我为什么喜欢它以及我如何使用它。同时我也希望我能介绍清楚，从而让你有个良好的体验，而不是花上几个小时去 Google。
### 恒久优势
使用 Emacs 带来的长期优势是让生活更轻松。与最后的收获相比，最开始的付出完全值得。想想这些：
#### 简单高效
Org 模式本身就值得花时间，但如果你像我一样，你通常要处理十几份左右的文件 —— 从博客帖子到会议事务清单，再到员工评估。在现代计算世界中，这通常意味着要使用多个应用程序，所有这些程序都有不同的用户界面、保存方式、排序和搜索方式。结果就是你需要不断转换思维环境，记住各种细节。我讨厌在程序间切换，这是在强人所难，因为这是个不完整界面模型<sup id="fnref2"> <a href="#fn2" rel="footnote"> 2 </a></sup> ，并且我讨厌记住本该由计算机记住的东西。在单个环境下，Emacs 对 PHB 甚至比对于程序员更高效，因为程序员更多时候只需要专注于一个程序。转换思维环境的成本比表面上的要更高。操作系统和应用程序厂商已经构建了各种界面，以分散我们对这一现实的注意力。如果你是技术人员，通过快捷键（`M-:`）来访问功能强大的[语言解释器](http://www.webopedia.com/TERM/I/interpreter.html)会方便的多<sup id="fnref3"> <a href="#fn3" rel="footnote"> 3 </a></sup> 。
许多应用程序可以全天全屏地用于编辑文本。但Emacs 是唯一的，因为它既是编辑器也是 Emacs Lisp 解释器。从本质上来说，你工作时只要用电脑上的一两个键就能完成。如果你略懂编程的话，就会发现这代表着你可以在 Emacs 中做 任何事情。一旦你在内存中存储了这些指令，你的电脑就可以在工作时几乎实时地为你提供高效的运转。你不会想用 Emacs Lisp 来重建 Excel，因为只要用简单的一两行代码就能实现 Excel 中大多数的功能。比如说我要处理数字，我更有可能转到 scratch 缓冲区，编写一些代码，而不是打开电子表格。即便是要写一封比较大的邮件时，我通常也会先在 Emacs 中写完，然后再复制粘贴到邮件客户端中。当你可以流畅的书写时，为什么要去切换呢？你可以先从一两个简单的算术开始，随着时间的推移，你可以很容易的在 Emacs 中添加你所需要处理的计算。这在应用程序中可能是独一无二的，同时还提供了让为其他的人创造的丰富特性。还记得艾萨克·阿西莫夫书中那些神奇的终端吗？ Emacs 是我所遇到的最接近它们的东西<sup id="fnref4"> <a href="#fn4" rel="footnote"> 4 </a></sup> 。我决定不再用什么应用程序来做这个或那个。相反，我只是工作。拥有一个伟大的工具并致力于此，这才是真正的动力和效率。
#### 静中造物
拥有所发现的最好的文本编辑功能的最终结果是什么？有一群人在做各种各样有用的补充吗？发挥了 Lisp 键盘的全部威力了吗？我用 Emacs 来完成所有的创作性工作，音乐和图片除外。
我办公桌上有两个显示器。其中一块竖屏是将 Emacs 全天全屏显示，另一个显示浏览器，用来搜索和阅读，我通常也会打开一个终端。我将日历、邮件等放在 OS X 的另一个桌面上，当我使用 Emacs 时，这个桌面会隐藏起来，同时我也会关掉所有通知。这样就能让我专注于我手头上在做的事了。我发现，越是先进的 UI 应用程序，消除干扰越是不可能，因为这些应用程序致力于提供帮助和易用性。我不需要经常被提醒该如何操作，我已经做了成千上万次了，我真正需要的是一张干净整洁的白纸用来思考。也许因为年龄和自己的“恶习”，我不太喜欢处在嘈杂的环境中，但我认为这值得一试。看看在你电脑环境中有一些真正的宁静是怎样的。当然，现在很多应用程序都有隐藏界面的模式，谢天谢地，苹果和微软现在都有了真正意义上的全屏模式。但是，没有并没有应用程序可以强大到足以“处理”大多数事务。除非你整天写代码，或者像出书一样，处理很长的文档，否则你仍然会面临其他应用程序的干扰。而且，大多数现代应用程序似乎同时显得自视甚高，缺乏功能和可用性<sup id="fnref5"> <a href="#fn5" rel="footnote"> 5 </a></sup> 。比起 office 桌面版，我更讨厌它的在线版。
*我的桌面布局， Emacs 在左边*
但是沟通呢？创造和沟通之间的差别很大。当我将这两件事在不同时间段处理时，我的效率会更高。我们 Fugue 公司使用 Slack，痛并快乐着。我把 Slack 和我的日历、电子邮件放在一个即时通讯的桌面上，这样，当我正在做事时，我就能够忽略所有的聊天信息了。虽然只要一个 Slackstorm 或一封风投或董事会董事的电子邮件，就能让我立刻丢掉手头工作。但是，大多数事情通常可以等上一两个小时。
#### 普适恒久
第三个原因是，我发现 Emacs 比其它的环境更有优势的是，你可以很容易地用它来处理事务。我的意思是，你所需要的只是通过类似于 Dropbox 的网站同步一两个目录，而不是让大量的应用程序以它们自己的方式进行交互和同步。然后，你可以在任何你已经精心打造了适合你的目的的套件的环境中工作了。我在 OS X、Windows，或有时在 Linux 都是这样做的。它非常简单可靠。这种功能很有用，以至于我害怕处理 Pages、Google Docs、Office 或其他类型的文件和应用程序，这些文件和应用程序会迫使我回到文件系统或云中的某个地方去寻找。
限制在计算机上永久存储的因素是文件格式。假设人类已经解决了存储问题<sup id="fnref6"> <a href="#fn6" rel="footnote"> 6 </a></sup> ，随着时间的推移，我们面临的问题是我们能否够继续访问我们创建的信息。文本文件是保存时间最久的格式。你可以用 Emacs 轻松地打开 1970 年的文本文件。然而对于 Office 应用程序却并非如此。同时文本文件要比 Office 应用程序数据文件小得多，也要好的多。作为一个数码背包迷，作为一个在脑子里一闪而过就会做很多小笔记的人，拥有一个简单、轻便、永久、随时可用的东西对我来说很重要。
如果你准备尝试 Emacs，请继续读下去！下面的部分不是完整的教程，但是在读完后，就可以动手操作了。
### 驾驭之道 —— 专业定制
所有这些强大、精神上的平静和安宁的代价是，Emacs 有一个陡峭的学习曲线，它的一切都与你以前所习惯的不同。一开始，这会让你觉得你是在浪费时间在一个过时和奇怪的应用程序上，就好像穿越到过去。这有点像你只开过车，却要你去学骑自行车<sup id="fnref7"> <a href="#fn7" rel="footnote"> 7 </a></sup> 。
#### 类型抉择
我用的是来自 GNU 的 OS X 和 Windows 的通用版本的 Emacs。你可以在 [http://emacsformacos.com/](http://emacsformacosx.com/) 获取 OS X 版本，在 <http://www.gnu.org/software/emacs/> 获取 Windows 版本。市面上还有很多其他版本，尤其是 Mac 版本，但我发现，要做一些功能强大的东西（涉及到 Lisp 和许多模式），学习曲线要比实际操作低得多。下载，然后我们就可以开始了<sup id="fnref8"> <a href="#fn8" rel="footnote"> 8 </a></sup> ！
#### 驾驭之始
在本文中，我将使用 Emacs 的按键和组合键约定。`C` 表示 `Control` 键，`M` 表示 `meta`（通常是 `Alt` 或 `Option` 键），以及用于组合键的连字符。因此，`C-h t` 表示同时按下 `Control` 和 `h` 键，然后释放，再按下 `t`。这个组合快捷键会指向一个教程，这是你首先要做的一件事。
不要使用方向键或鼠标。它们可以工作，但是你应该给自己一周的时间来使用 Emacs 教程中的原生的导航命令。一旦你这些命令变为了肌肉记忆，你可能就会乐在其中，无论到哪里，你都会非常想念它们。这个 Emacs 教程在介绍它们方面做得很好，但是我将进行总结，所以你不需要阅读全部内容。最无聊的是，不用方向键，用 `C-b` 向前移动，用 `C-f` 向后移动，上一行用 `C-p`，下一行用 `C-n`。你可能会想：“我用方向键就很好，为什么还要这样做？” 有几个原因。首先，你不需要从主键盘区将你的手移开。第二，使用 `Alt`（或用 Emacs 的说法 `Meta`）键来向前或向后在单词间移动。显而易见这样更方便。第三，如果想重复某个命令，可以在命令前面加上一个数字。在编辑文档时，我经常使用这种方法，通过估计向后移动多少个单词或向上或向下移动多少行，然后按下 `C-9 C-p` 或 `M-5 M-b` 之类的快捷键。其它真正重要的导航命令基于开头用 `a` 和结尾用 `e`。在行中使用 `C-a|e`，在句中使用 `M-a|e`。为了让句中的命令正常工作，需要在句号后增加两个空格，这同时提供了一个有用的特性，并消除了脑中一个过时的[观点](http://www.huffingtonpost.com/2015/05/29/two-spaces-after-period-debate_n_7455660.html)。如果需要将文档导出到单个空间[发布环境](http://practicaltypography.com/one-space-between-sentences.html)，可以编写一个宏来执行此操作。
Emacs 所附带的教程很值得去看。对于真正缺乏耐心的人，我将介绍一些重要的命令，但那个教程非常有用。记住：用 `C-h t` 进入教程。
#### 驾驭之复制粘贴
你可以把 Emacs 设为 CUA 模式，这将会以熟悉的方式工作来操作复制粘贴，但是原生的 Emacs 方法更好，而且你一旦学会了它，就很容易。你可以使用 `Shift` 和导航命令来标记区域（如同选择）。所以 `C-F` 是选中光标前的一个字符，等等。亦可以用 `M-w` 来复制，用 `C-w` 剪切，然后用 `C-y` 粘贴。这些实际上叫做<ruby> 删除 <rt> killing </rt></ruby>和<ruby> 召回 <rt> yanking </rt></ruby>，但它非常类似于剪切和粘贴。在删除中还有一些小技巧，但是现在，你只需要关注剪切、复制和粘贴。如果你开始尝试了，那么 `C-x u` 是撤销。
#### 驾驭之 Ido 模式
相信我，Ido 会让文件的工作变得很简单。通常，你在 Emacs 中处理文件不需要使用一个单独的访达或文件资源管理器的窗口。相反，你可以用编辑器的命令来创建、打开和保存文件。如果没有 Ido 的话，这将有点麻烦，所以我建议你在学习其他之前安装好它。 Ido 是 Emacs 的 22 版时开始出现的，但是需要对你的 `.emacs` 文件做一些调整，来确保它一直开启着。这是个配置环境的好理由。
Emacs 中的大多数功能都表现在模式上。要安装指定的模式，需要做两件事。嗯，一开始你需要做一些额外的事情，但这些只需要做一次，然后再做这两件事。那么，这件额外的事情是你需要一个单独的位置来放置所有 Emacs Lisp 文件，并且你需要告诉 Emacs 这个位置在哪。我建议你在 Dropbox 上创建一个单独的目录，那是你 Emacs 主目录。在这里，你需要创建一个 `.emacs` 文件和 `.emacs.d` 目录。在 `.emacs.d` 目录下，创建一个 `lisp` 的目录。就像这样:
```
home
|
+.emacs
|
-.emacs.d
|
-lisp
```
你可以将 `.el` 文件，比如说模式文件，放到 `home/.emacs.d/lisp` 目录下，然后在你的 `.emacs` 文件中添加以下代码来指明该路径：
```
(add-to-list 'load-path "~/.emacs.d/lisp/")
```
Ido 模式是 Emacs 自带的，所以你不需要在你的 `lisp` 目录中放这个 `.el` 文件，但你仍然需要添加上面代码，因为下面的介绍会使用到它.
#### 驾驭之符号链接
等等，这里写的 `.emacs` 和 `.emacs.d` 都是存放在你的主目录下，但我们把它们放到了 Dropbox 的某些愚蠢的文件夹！对，这就让你的环境在任何地方都很容易使用。把所有东西都保存在 Dropbox 上，并做符号链接到 `~` 下的 `.emacs` 、`.emacs.d` 和你的主要存放文档的目录。在 OS X 上，使用 `ln -s` 命令非常简单，但在 Windows 上却很麻烦。幸运的是，Emacs 提供了一种简单的方法来替代 Windows 上的符号链接，Windows 的 `HOME` 环境变量。转到 Windows 的环境变量（Windows 10,你可以按 Windows 键然后输入 “环境变量” 来搜索，这是 Windows 10 最好的地方了)，在你的帐户下创建一个指向你在 Dropbox 中 Emacs 的文件夹的 `HOME` 环境变量。如果你想方便地浏览 Dropbox 之外的本地文件，你可能想在你的实际主目录下建立一个到 Dropbox 下 Emacs 主目录的符号链接。
至此，你已经完成了在任意机器上指向你的 Emacs 配置和文件所需的技巧。如果你买了一台新电脑，或者用别人的电脑一小时或一天，你就可以得到你的整个工作环境。第一次操作起来似乎有点难，但是一旦你知道你在做什么，就（最多）只需要 10 分钟。
但我们现在是在配置 Ido ……
按下 `C-x` `C-f` 然后输入 `~/.emacs` 和两次回车来创建 `.emacs` 文件，将下面几行添加进去:
```
;; set up ido mode
(require `ido)
(setq ido-enable-flex-matching t)
(setq ido-everywhere t)
(ido-mode 1)
```
在 `.emacs` 窗口开着的时候，执行 `M-x evaluate-buffer` 命令。如果某处弄错了的话，将得到一个错误，或者你将得到 Ido。Ido 改变了在 minibuffer 中操作文件操方式。关于这个有一篇比较好的文档，但是我也会指出一些技巧。有效地使用 `~/`；你可以在 minibuffer 的任何地方输入 `~/`，它就会跳转到主目录。这就意味着，你应该让你的大部分东西就近的放在主目录下。我用 `~/org` 目录来保存所有非代码的东西，用 `~/code` 保存代码。一旦你进入到正确的目录，通常会拥有一组具有不同扩展名的文件，特别是当你使用 Org 模式并从中发布的话。你可以输入 `.` 和想要的扩展名，无论你的在文件名的什么位置，Ido 都会将选择限制在具有该扩展名的文件中。例如，我在 Org 模式下写这篇博客，所以该文件是：
```
~/org/blog/emacs.org
```
我偶尔也会用 Org 模式发布成 HTML 格式，所以我将在同一目录下得到 `emacs.html` 文件。当我想打开该 Org 文件时，我会输入：
```
C-x C-f ~/o[RET]/bl[RET].or[RET]
```
其中 `[RET]` 是我使用 `Ido` 模式的自动补全而按下的回车键。所以，这只需要按 12 个键，如果你习惯了的话， 这将比打开访达或文件资源管理器再用鼠标点要节省 很 多时间。 Ido 模式很有用，而这只是操作 Emacs 的一种实用模式而已。下面让我们去探索一些其它对完成工作很有帮助的模式吧。
#### 驾驭之字体风格
我推荐在 Emacs 中使用漂亮的字体族。它们可以使用不同的括号、0 和其他字符进行自定义。你可以在字体文件本身中构建额外的行间距。我推荐 1.5 倍的行间距，并在代码和数据中使用不等宽字体。写作中我用 `Serif` 字体，它有一种紧凑但时髦的感觉。你可以在 <http://input.fontbureau.com/> 上找到它们，在那里你可以根据自己的喜好进行定制。你可以使用 Emacs 中的菜单手动设置字体，但这会将代码保存到你的 `.emacs` 文件中，如果你使用多个设备，你可能需要一些不同的设置。我将我的 `.emacs` 设置为根据使用的机器的名称来相应配置屏幕。代码如下：
```
;; set up fonts for different OSes. OSX toggles to full screen.
(setq myfont "InputSerif")
(cond
((string-equal system-name "Sampo.local")
(set-face-attribute 'default nil :font myfont :height 144)
(toggle-frame-fullscreen))
((string-equal system-name "Morpheus.local")
(set-face-attribute 'default nil :font myfont :height 144))
((string-equal system-name "ILMARINEN")
(set-face-attribute 'default nil :font myfont :height 106))
((string-equal system-name "UKKO")
(set-face-attribute 'default nil :font myfont :height 104)))
```
你应该将 Emacs 中的 `system-name` 的值替换成你通过 `(system-name)` 得到的值。注意，在 Sampo （我的 MacBook）上，我还将 Emacs 设置为全屏。我也想在 Windows 实现这个功能，但是 Windows 和 Emacs 好像互相嫌弃对方，当我尝试配置时，它总是不稳定。相反，我只能在启动后手动全屏。
我还建议去掉 Emacs 中的上世纪 90 年代出现的难看工具栏，当时比较流行在应用程序中使用工具栏。我还去掉了一些其它的“电镀层”，这样我就有了一个简单、高效的界面。把这些加到你的 `.emacs` 的文件中来去掉工具栏和滚动条，但要保留菜单（在 OS X 上，它将被隐藏，除非你将鼠标到屏幕顶部）：
```
(if (fboundp 'scroll-bar-mode) (scroll-bar-mode -1))
(if (fboundp 'tool-bar-mode) (tool-bar-mode -1))
(if (fboundp 'menu-bar-mode) (menu-bar-mode 1))
```
#### 驾驭之 Org 模式
我基本上是在 Org 模式下处理工作的。它是我创作文档、记笔记、列任务清单以及 90% 其他工作的首选环境。Org 模式是笔记和待办事项列表的组合工具，最初是由一个在会议中使用笔记本电脑的人构想出来的。我反对在会议中使用笔记本电脑，自己也不使用，所以我的用法与他的有些不同。对我来说，Org 模式主要是一种处理结构中内容的方式。在 Org 模式中有标题和副标题等，它们的作用就像一个大纲。Org 模式允许你展开或隐藏大纲树，还可以重新排列该树。这正合我意，并且我发现用这种方式使用它是一种乐趣。
Org 模式也有很多让生活愉快的小功能。例如，脚注处理非常好，LaTeX/PDF 输出也很好。Org 模式能够根据所有文档中的待办事项生成议程，并能很好地将它们与日期/时间联系起来。我不把它用在任何形式的外部任务上，这些任务都是在一个共享的日历上处理的，但是在创建事物和跟踪我未来需要创建的东西时，它是无价的。安装它，你只要将 `org-mode.el` 放到你的 `lisp` 目录下。如果你想要它基于文档的结构进行缩进并在打开时全部展开的话，在你的 `.emacs` 文件中添加如下代码：
```
;; set up org mode
(setq org-startup-indented t)
(setq org-startup-folded "showall")
(setq org-directory "~/org")
```
最后一行是让 Org 模式知道在哪里查找要包含在议程和其他事情中的文件。我把 Org 模式保存在我的主目录中，也就是说，像前面介绍的一样，它是 Dropbox 目录的一个符号链接。
我有一个总是在缓冲区中打开的 `stuff.org` 文件。我把它当作记事本。Org 模式使得提取待办事项和有期限的事情变得很容易。当你能够内联 Lisp 代码并在需要计算它时，它特别有用。拥有包含内容的代码非常方便。同样，你可以使用 Emacs 访问实际的计算机，这是一种解放。
##### 用 Org 模式进行发布
我关心的是文档的外观及格式。我刚开始工作时是个设计师，而且我认为信息可以，也应该表现得清晰和美丽。Org 模式对将 LaTeX 生成 PDF 支持的很好，LaTeX 虽然也有学习曲线，但是很容易处理一些简单的事务。
如果你想使用字体和样式，而不是典型的 LaTeX 字体和样式，你需要做些事。首先，你要用到 XeLaTeX，这样就可以使用普通的系统字体，而不是 LaTeX 的特殊字体。接下来，你需要将以下代码添加到 `.emacs` 中：
```
(setq org-latex-pdf-process
'("xelatex -interaction nonstopmode %f"
"xelatex -interaction nonstopmode %f"))
```
我把这个放在 `.emacs` 中 Org 模式配置部分的末尾，使文档变得更整洁。这让你在从 Org 模式发布时可以使用更多格式化选项。例如，我经常使用：
```
#+LaTeX_HEADER: \usepackage{fontspec}
#+LATEX_HEADER: \setmonofont[Scale=0.9]{Input Mono}
#+LATEX_HEADER: \setromanfont{Maison Neue}
#+LATEX_HEADER: \linespread{1.5}
#+LATEX_HEADER: \usepackage[margin=1.25in]{geometry}
#+TITLE: Document Title Here
```
这些都可以在 `.org` 文件中找到。我们的公司规定的正文字体是 `Maison Neue`，但你也可以在这写上任何适当的东西。我很是抵制 `Maison Neue`，因为这是一种糟糕的字体，任何人都不应该使用它。
这个文件是一个使用该配置输出为 PDF 的实例。这就是开箱即用的 LaTeX 一样。在我看来这还不错，但是字体很平淡，而且有点奇怪。此外，如果你使用标准格式，人们会觉得他们正在阅读的东西是、或者假装是一篇学术论文。别怪我没提醒你。
#### 驾驭之 Ace Jump 模式
这只是一个辅助模式，而不是一个主模式，但是你也需要它。其工作原理有点像之前提到的 Jef Raskin 的 Leap 功能<sup id="fnref9"> <a href="#fn9" rel="footnote"> 9 </a></sup> 。 按下 `C-c C-SPC`，然后输入要跳转到单词的第一个字母。它会高亮显示所有以该字母开头的单词，并将其替换为字母表中的字母。你只需键入所需位置的字母，光标就会跳转到该位置。我常将它作为导航键或是用来检索。将 `.el` 文件下到你的 `lisp` 目录下，并在 `.emacs` 文件添加如下代码：
```
;; set up ace-jump-mode
(add-to-list 'load-path "which-folder-ace-jump-mode-file-in/")
(require 'ace-jump-mode)
(define-key global-map (kbd "C-c C-SPC" ) 'ace-jump-mode)
```
### 待续
本文已经够详细了，你能在其中得到你所想要的。我很想知道除编程之外（或用于编程）Emacs 的使用情况，及其是否高效。在我使用 Emacs 的过程中，可能存在一些自作聪明的老板式想法，如果你能指出来，我将不胜感激。之后，我可能会写一些更新来介绍其它特性或模式。我很确定我将会向你展示如何在 Emacs 和 Ludwig 模式下使用 Fugue，因为我会将它发展成比代码高亮更有用的东西。更多想法，请在 Twitter 上 [@fugueHQ](https://twitter.com/fugueHQ) 。
### 脚注
---
1. 如果你是位精英，但从没涉及过技术方面，那么 Emacs 并不适合你。对于少数的人来说，Emacs 可能会为他们开辟一条通往计算机技术方面的道路，但这只是极少数。如果你知道怎么使用 Unix 或 Windows 的终端，或者曾编辑过 dotfile，或者说你曾写过一点代码的话，这对使用 Emacs 有很大的帮助。 [↩](#fnref1)
2. 参考链接： <http://archive.wired.com/wired/archive/2.08/tufte.html> [↩](#fnref2)
3. 我主要是在写作时使用这个模式来进行一些运算。比如说，当我在给一个新雇员写一封入职信时，我想要算这封入职信中有多少个选项。由于我在我的 `.emacs` 为 outstanding-shares 定义了一个变量，所以我只要按下 `M-:` 然后输入 `(* .001 outstanding-shares)` 就能再无需打开计算器或电子表格的情况下得到精度为 0.001 的结果。我使用了 大量 的变量来避免程序间切换。 [↩](#fnref3)
4. 缺少的部分是 web。有个名为 eww 的 Emacs 网页浏览器能够让你在 Emacs 中浏览网页。我用的就是这个，因为它既能拦截广告（LCTT 译注：实质上是无法显示，/laugh），同时也在可读性方面为 web 开发者消除了大多数差劲的选项。这个其实有点类似于 Safari 的阅读模式。不幸的是，大部分网站都有很多令人讨厌的繁琐的东西以及难以转换为文本的导航， [↩](#fnref4)
5. 易用性和易学性这两者经常容易被搞混。易学性是指学习使用工具的难易程度。而易用性是指工具高效的程度。通常来说，这是要差别的，就想鼠标和菜单栏的差别一样。菜单栏很容易学会，但是却不怎么高效，以致于早期会存在一些键盘的快捷键。除了在 GUI 方面上，Raskin 在很多方面上的观点都很正确。如今，操作系统正在将一些合适的搜索映射到键盘的快捷键上。比如说在 OS X 和 Windows 上，我默认的导航方式就是搜索。Ubuntu 的搜索做的很差劲，如同它的 GUI 一样差劲。 [↩](#fnref5)
6. 在有网的情况下，[AWS S3](https://baike.baidu.com/item/amazon%20s3/10809744?fr=aladdin) 是解决文件存储问题的有效方案。数万亿个对象存在 S3 中，但是从来没有遗失过。大部分提供云存储的服务都是在 S3 上或是模拟 S3 构建的。没人能够拥有 S3 一样的规模，所以我将重要的文件通过 Dropbox 存储在上面。 [↩](#fnref6)
7. 目前，你可能会想：“这个人和自行车有什么关系？”……我在各个层面上都喜欢自行车。自行车是迄今为止发明的最具机械效率的交通工具。自行车可以是真正美丽的事物。而且，只要注意点的话，自行车可以用一辈子。早在 2001 年，我曾向 Rivendell Bicycle Works 订购了一辆自行车，现在我每次看到那辆自行车依然很高兴，自行车和 Unix 是我接触过的最好的两个发明。对了，还有 Emacs。 [↩](#fnref7)
8. 这个网站有一个很棒的 Emacs 教程，但不是这个。当我浏览这个页面时，我确实得到了一些对获取高效的 Emacs 配置很重要的知识，但无论怎么说，这都不是个替代品。 [↩](#fnref8)
9. 20 世纪 80 年代，Jef Raskin 与 Steve Jobs 在 Macintosh 项目上闹翻后， Jef Raskin 又设计了 [Canon Cat 计算机](https://en.wikipedia.org/wiki/Canon_Cat)。这台 Cat 计算机是以文档为中心的界面（所有的计算机都应如此），并以一种全新的方式使用键盘，你现在可以用 Emacs 来模仿这种键盘。如果现在有一台现代的，功能强大的 Cat 计算机并配有一个高分辨的显示器和 Unix 系统的话，我立马会用 Mac 来换。[https://youtu.be/oTlEU\_X3c?t=19s](https://youtu.be/o_TlE_U_X3c?t=19s) [↩](#fnref9)
###
---
via: <https://blog.fugue.co/2015-11-11-guide-to-emacs.html>
作者：[Josh Stella](https://blog.fugue.co/authors/josh.html) 译者：[oneforalone](https://github.com/oneforalone) 校对：[wxy](https://github.com/wxy), [oneforalone](https://github.com/oneforalone)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
用 PGP 保护代码完整性（四）：将主密钥移到离线存储中
|
Konstantin Ryabitsev
|
https://www.linux.com/blog/learn/pgp/2018/3/protecting-code-integrity-pgp-part-4-moving-your-master-key-offline-storage
|
如果开发者的 PGP 密钥被偷了，危害非常大。了解一下如何更安全。
|
/data/attachment/album/201901/01/003541ehzdol364f315cf5.jpg.thumb.jpg
|
/data/attachment/album/201901/01/003541ehzdol364f315cf5.jpg
| true | false | true |
qhwdw
|
wxy
| false |
[
"pgp"
] |
技术
|
{
"viewnum": 6223,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "119.137.55.200",
"message": "> 因此，最好是从你的家目录中删除它<br />\r\n<br />\r\n因此，最好是从你的 home 目录中删除它",
"username": "lowkey2046 [Chrome 71.0|GNU/Linux]",
"date": "2019-01-17T16:49:15"
}
] |
[
{
"raid": 9607,
"displayorder": 0
},
{
"raid": 10415,
"displayorder": 0
}
] |
如果开发者的 PGP 密钥被偷了，危害非常大。了解一下如何更安全。
| 2019-01-01T00:35:38 | 2019-01-01T00:35:38 | 10,402 |
/article-10402-1.html
|
>
> 如果开发者的 PGP 密钥被偷了，危害非常大。了解一下如何更安全。
>
>
>
在本系列教程中，我们为使用 PGP 提供了一个实用指南。你可以从下面的链接中查看前面的文章：
* [第一部分：基本概念和工具](/article-9524-1.html)
* [第二部分：生成你的主密钥](/article-9529-1.html)
* [第三部分：生成 PGP 子密钥](/article-9607-1.html)
这是本系列教程的第四部分，我们继续本教程，我们将谈一谈如何及为什么要将主密钥从你的家目录移到离线存储中。现在开始我们的教程。
#### 清单
* 准备一个加密的可移除的存储（必要）
* 备份你的 GnuPG 目录（必要）
* 从你的家目录中删除主密钥（推荐）
* 从你的家目录中删除吊销证书（推荐）
#### 考虑事项
为什么要从你的家目录中删除你的主 [C] 密钥 ？这样做的主要原因是防止你的主密钥失窃或意外泄露。对于心怀不轨的人来说，私钥对他们具有很大的诱惑力 —— 我们知道有几个恶意软件成功地实现了扫描用户的家目录并将发现的私钥内容上传。
对于开发者来说，私钥失窃是非常危险的事情 —— 在自由软件的世界中，这无疑是身份证明失窃。从你的家目录中删除私钥将帮你防范这类事件的发生。
#### 备份你的 GnuPG 目录
**!!!绝对不要跳过这一步!!!**
备份你的 PGP 密钥将让你在需要的时候很容易地恢复它们，这很重要！（这与我们做的使用 paperkey 的灾难级备份是不一样的）。
#### 准备可移除的加密存储
我们从取得一个（最好是两个）小型的 USB “拇指“ 驱动器（可加密 U 盘）开始，我们将用它来做备份。你首先需要去加密它们：
加密密码可以使用与主密钥相同的密码。
#### 备份你的 GnuPG 目录
加密过程结束之后，重新插入 USB 驱动器并确保它能够正常挂载。你可以通过运行 `mount` 命令去找到设备挂载点的完全路径。（在 Linux 下，外置介质一般挂载在 `/media/disk` 下，Mac 一般在它的 `/Volumes` 下）
你知道了挂载点的全路径后，将你的整个 GnuPG 的目录复制进去：
```
$ cp -rp ~/.gnupg [/media/disk/name]/gnupg-backup
```
（注意：如果出现任何套接字不支持的错误，没有关系，直接忽略它们。）
现在，用如下的命令去测试一下，确保它们能够正常地工作：
```
$ gpg --homedir=[/media/disk/name]/gnupg-backup --list-key [fpr]
```
如果没有出现任何错误，说明一切正常。弹出这个 USB 驱动器并给它粘上一个明确的标签，以便于你下次需要它时能够很快找到它。接着，将它放到一个安全的 —— 但不要太远 —— 的地方，因为从现在起，你需要偶尔使用它来做一些像编辑身份信息、添加或吊销子证书、或签署其它人的密钥这样的事情。
#### 删除主密钥
我们家目录中的文件并没有像我们所想像的那样受到保护。它们可能会通过许多不同的方式被泄露或失窃：
* 通过快速复制来配置一个新工作站时的偶尔事故
* 通过系统管理员的疏忽或恶意操作
* 通过安全性欠佳的备份
* 通过桌面应用中的恶意软件（浏览器、pdf 查看器等等）
* 通过跨境胁迫
使用一个很好的密码来保护你的密钥是降低上述风险的一个很好方法，但是密码能够通过键盘记录器、背后窥视、或其它方式被发现。基于以上原因，我们建议去配置一个从你的家目录上可移除的主密钥，将它保存在一个离线存储中。
##### 删除你的主密钥
**请查看前面的节，确保你有完整的你的 GnuPG 目录的一个备份。如果你没有一个可用的备份，下面所做的操作将会使你的主密钥失效！！！**
首先，识别你的主密钥的 keygrip：
```
$ gpg --with-keygrip --list-key [fpr]
```
它的输出应该像下面这样：
```
pub rsa4096 2017-12-06 [C] [expires: 2019-12-06]
111122223333444455556666AAAABBBBCCCCDDDD
Keygrip = AAAA999988887777666655554444333322221111
uid [ultimate] Alice Engineer <alice@example.org>
uid [ultimate] Alice Engineer <allie@example.net>
sub rsa2048 2017-12-06 [E]
Keygrip = BBBB999988887777666655554444333322221111
sub rsa2048 2017-12-06 [S]
Keygrip = CCCC999988887777666655554444333322221111
```
找到 `pub` 行下方的 `Keygrip` 条目（就在主密钥指纹的下方）。它与你的家目录下 `.gnupg` 目录下的一个文件是一致的：
```
$ cd ~/.gnupg/private-keys-v1.d
$ ls
AAAA999988887777666655554444333322221111.key
BBBB999988887777666655554444333322221111.key
CCCC999988887777666655554444333322221111.key
```
现在你做的全部操作就是简单地删除与主密钥 keygrip 一致的 `.key` 文件：
```
$ cd ~/.gnupg/private-keys-v1.d
$ rm AAAA999988887777666655554444333322221111.key
```
现在，如果运行 `--list-secret-keys` 命令将出现问题，它将显示主密钥丢失（`#` 表示不可用）：
```
$ gpg --list-secret-keys
sec# rsa4096 2017-12-06 [C] [expires: 2019-12-06]
111122223333444455556666AAAABBBBCCCCDDDD
uid [ultimate] Alice Engineer <alice@example.org>
uid [ultimate] Alice Engineer <allie@example.net>
ssb rsa2048 2017-12-06 [E]
ssb rsa2048 2017-12-06 [S]
```
#### 删除吊销证书
你应该去删除的另一个文件是吊销证书（**删除之前，确保你的备份中有它**），它是使用你的主密钥自动创建的。吊销证书允许一些人去永久标记你的证书为吊销状态，这意味着它无论在任何用途中将不再被使用或信任。一般是使用它来吊销由于某些原因不再受控的一个密钥 —— 比如，你丢失了密钥密码。
与使用主密钥一样，如果一个吊销证书泄露到恶意者手中，他们能够使用它去破坏你的开发者数字身份，因此，最好是从你的家目录中删除它。
```
cd ~/.gnupg/openpgp-revocs.d
rm [fpr].rev
```
在下一篇文章中，你将学习如何保护你的子密钥。敬请期待。
从来自 Linux 基金会和 edX 的免费课程 [“Linux 入门”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux) 中学习更多 Linux 知识。
---
via: <https://www.linux.com/blog/learn/pgp/2018/3/protecting-code-integrity-pgp-part-4-moving-your-master-key-offline-storage>
作者：[Konstantin Ryabitsev](https://www.linux.com/users/mricon) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
极客漫画：呃，70 后
|
Daniel Stori
|
http://turnoff.us/geek/oh-the-70s/
|
70 后的老程序员已经对层出不穷的编程语言感到了厌烦，虽然这已经距离上一个编程语言出现已经十年了。
|
/data/attachment/album/201901/01/104029faj9q9s9t4zzsoss.png.thumb.jpg
|
/data/attachment/album/201901/01/104029faj9q9s9t4zzsoss.png.large.jpg
| false | false | true |
wxy
|
wxy
| false |
[
"编程语言"
] |
极客漫画
|
{
"viewnum": 13580,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
70 后的老程序员已经对层出不穷的编程语言感到了厌烦，虽然这已经距离上一个编程语言出现已经十年了。
| 2019-01-01T10:40:51 | 2019-01-01T10:40:51 | 10,403 |
/article-10403-1.html
|
70 后的老程序员已经对层出不穷的编程语言感到了厌烦，虽然这已经距离上一个编程语言出现已经十年了。
虽然老程序员依旧很潮——扎着马尾，穿着花裤子——但是不能掩饰其秃顶和肥胖的腰身。
IT 行业，是一个日新月异的行业，老程序员们如何跟上时代呢？十年，快吗？
---
via: <http://turnoff.us/geek/oh-the-70s/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者 & 校对：[wxy](https://github.com/wxy) 校对 & 合成：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
一个 HTTP/2 的故事
|
Louis-philippe Véronneau
|
https://veronneau.org/a-tale-of-http2.html
|
我花了大约 25 个小时来完成。坐下来穿上舒适的拖鞋，听听这个 HTTP/2 的故事！
|
/data/attachment/album/201901/01/170158dnzuuw8ids3dw8sb.jpg.thumb.jpg
|
/data/attachment/album/201901/01/170158dnzuuw8ids3dw8sb.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"HTTP/2"
] |
技术
|
{
"viewnum": 3822,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
我花了大约 25 个小时来完成。坐下来穿上舒适的拖鞋，听听这个 HTTP/2 的故事！
| 2019-01-01T16:57:00 | 2019-01-01T16:57:00 | 10,404 |
/article-10404-1.html
|
大约一个月前，有人在我所在的 IRC 频道中提到了 [HTTP/2](https://en.wikipedia.org/wiki/HTTP/2)。由于某种原因，我从未听说过它，而且新协议的一些功能（比如无需打开多个 TCP 连接就能复用请求）似乎很酷。
说实话，我刚刚重写了管理我们备份程序的 Puppet 代码，启用 HTTP/2 似乎是一种转向另一个大型项目之前有效的拖延方式。这有多难？
结果我花了大约 25 个小时来完成。坐下来穿上舒适的拖鞋，听听这个 HTTP/2 的故事！
### 被诅咒的 HTTP/1.1
当我第一次看到如何在 Apache 上启用 HTTP/2 时，这似乎是一项非常简单的任务。文档提到加载 `http2` 模块并通过如下配置文件确保新协议优先：
```
Protocols h2 h2c http/1.1
H2Push on
H2PushPriority * after
H2PushPriority text/css before
H2PushPriority image/jpeg after 32
H2PushPriority image/png after 32
H2PushPriority application/javascript interleaved
```
这当然很容易。即使 Apache 中的所有内容都已正确设置，网站仍然使用的是 HTTP/1.1。不过，显然我做得没错，因为我的网站现在发送了一个新的 HTTP 头：`Upgrade: h2, h2c`。
在浪费了大量时间调试 TLS 密钥（HTTP/2 [与 TLS 1.1 不兼容](https://http2.github.io/http2-spec/#TLSUsage)）之后，我终于发现问题是没有使用正确的 Apache 多进程处理模块。
事实证明，在使用 `mpm_prefork`（默认 MPM）时，Apache 不会使用 HTTP/2，因为 `mod_http2` 不支持它。尽管 Apache 还有两个其他的 MPM，但只有 `mpm_prefork` 支持 `mod_php`。突然之间，添加对 HTTP/2 的支持意味着我们将要把所有的 PHP 网站切换到 PHP-FPM。
### 掉进兔子洞
在很长一段时间里，一位好友一直试图让我相信 [PHP-FPM](https://wiki.apache.org/httpd/PHP-FPM) 的优点。虽然表面上看起来很好，但我从来没有真正试过。它看起来很复杂。常规的 `mod_php` 做得很好，还有其他事情需要我注意。
事实上，这次的 HTTP/2 事件是让我钻研它的一个契机。在我理解了 FPM 池的工作原理后，它实际上很容易设置。由于我不得不重写我们用于部署网站的 Puppet 配置文件，我也借此机会巩固了一堆东西。
PHP-FPM 允许你在不同的 Unix 用户下运行网站来增加隔离性。最重要的是，我决定是时候让我们服务器上的 PHP 代码以只读模式运行，并且不得不为我们的 Wordpress、Nextcloud、KanBoard 和 Drupal 实例调整一些东西来减少报错。
过了很长时间通过 Puppet 的自动任务后，我终于能够全部关闭 `mod_php` 和 `mpm_prefork` 并启用 `mpm_event` 和 `mod_http2`。PHP-FPM 和 HTTP/2 带来的速度提升不错，但更让我感到高兴的是这次磨练增强了我们的 Apache 处理 PHP 的能力。
---
via: <https://veronneau.org/a-tale-of-http2.html>
作者：[Louis-Philippe Véronneau](https://veronneau.org/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何构建一台网络引导服务器（三）
|
Gregory Bartholomew
|
https://fedoramagazine.org/how-to-build-a-netboot-server-part-3/
|
我们将向你展示如何设置一个更复杂的 iPXE 配置。它将允许终端用户以更容易的方式去选择引导哪个操作系统。它也可以配置为让系统管理员从一台中央服务器来统一管理引导菜单。
|
/data/attachment/album/201901/01/172110uwb7tt3x0gapas33.jpg.thumb.jpg
|
/data/attachment/album/201901/01/172110uwb7tt3x0gapas33.jpg
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"网络引导"
] |
技术
|
{
"viewnum": 6283,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10396,
"displayorder": 0
},
{
"raid": 10470,
"displayorder": 0
}
] |
我们将向你展示如何设置一个更复杂的 iPXE 配置。它将允许终端用户以更容易的方式去选择引导哪个操作系统。它也可以配置为让系统管理员从一台中央服务器来统一管理引导菜单。
| 2019-01-01T17:18:00 | 2019-01-01T17:18:00 | 10,405 |
/article-10405-1.html
|
在 [如何构建一台网络引导服务器（一）](/article-10379-1.html) 中，我们提供了一个极简的 [iPXE](https://ipxe.org/) 引导脚本来引导你的网络引导镜像。许多用户除了使用网络引导镜像外，可能在机器本地也有一个操作系统。但是使用常见的工作站的 BIOS 去切换引导加载器是很笨拙的。在本系列文件的第三部分，我们将向你展示如何设置一个更复杂的 iPXE 配置。它将允许终端用户以更容易的方式去选择引导哪个操作系统。它也可以配置为让系统管理员从一台中央服务器来统一管理引导菜单。
### 一个交互式 iPXE 引导菜单
下面这些命令重定义了网络引导镜像的 `boot.cfg` 来作为一个交互式的 iPXE 引导菜单，并使用了一个 5 秒倒计时的定时器：
```
$ MY_FVER=29
$ MY_KRNL=$(ls -c /fc$MY_FVER/lib/modules | head -n 1)
$ MY_DNS1=192.0.2.91
$ MY_DNS2=192.0.2.92
$ MY_NAME=server-01.example.edu
$ MY_EMAN=$(echo $MY_NAME | tr '.' "\n" | tac | tr "\n" '.' | cut -b -${#MY_NAME})
$ MY_ADDR=$(host -t A $MY_NAME | awk '{print $4}')
$ cat << END > $HOME/esp/linux/boot.cfg
#!ipxe
set timeout 5000
:menu
menu iPXE Boot Menu
item --key 1 lcl 1. Microsoft Windows 10
item --key 2 f$MY_FVER 2. RedHat Fedora $MY_FVER
choose --timeout \${timeout} --default lcl selected || goto shell
set timeout 0
goto \${selected}
:failed
echo boot failed, dropping to shell...
goto shell
:shell
echo type 'exit' to get the back to the menu
set timeout 0
shell
goto menu
:lcl
exit
:f$MY_FVER
kernel --name kernel.efi \${prefix}/vmlinuz-$MY_KRNL initrd=initrd.img ro ip=dhcp rd.peerdns=0 nameserver=$MY_DNS1 nameserver=$MY_DNS2 root=/dev/disk/by-path/ip-$MY_ADDR:3260-iscsi-iqn.$MY_EMAN:fc$MY_FVER-lun-1 netroot=iscsi:$MY_ADDR::::iqn.$MY_EMAN:fc$MY_FVER console=tty0 console=ttyS0,115200n8 audit=0 selinux=0 quiet
initrd --name initrd.img \${prefix}/initramfs-$MY_KRNL.img
boot || goto failed
END
```
上述菜单有五个节：
* `menu` 定义了显示在屏幕上的实际菜单内容。
* `failed` 提示用户发生了错误，并将用户带到 shell 以错误错误。
* `shell` 提供了交互式命令提示符。你可以在引导菜单出现时按下 `Esc` 键进入，或者是 `boot` 命令失败时也会进入到命令提示符。
* `lcl` 包含一个提供给 iPXE 退出的简单命令，以及返还控制权给 BIOS。在 iPXE 之后，无论你希望缺省引导的设备（即：工作站的本地硬件）是什么，都必须在你的工作站的 BIOS 中正确地作为下一个引导设备列出来。
* `f29` 包含前面文章提到同一个网络引导代码，但使用最终的退出代码来替换掉 `goto failed`。
从你的 `$HOME/esp/linux` 目录中复制更新后的 `boot.cfg` 到所有客户端系统的 ESP 中。如果一切顺利，你应该会看到类似下面图片的结果：
### 一个服务器托管的引导菜单
你可以添加到网络引导服务器的另一个特性是，能够从一台中央位置去管理所有客户端的引导菜单。这个特性尤其适用于批量安装（升级）一个新版本的操作系统。在你将新内核和新的 `initramfs` 复制到所有客户端的 ESP 之后，这个特性可以让你执行一种 [原子事务](https://en.wikipedia.org/wiki/Atomicity_(database_systems)) 去切换所有客户端到新操作系统。
安装 Mojolicious：
```
$ sudo -i
# dnf install -y perl-Mojolicious
```
定义 “bootmenu” 应用程序：
```
# mkdir /opt/bootmenu
# cat << END > /opt/bootmenu/bootmenu.pl
#!/usr/bin/env perl
use Mojolicious::Lite;
use Mojolicious::Plugins;
plugin 'Config';
get '/menu';
app->start;
END
# chmod 755 /opt/bootmenu/bootmenu.pl
```
为 “bootmenu” 应用程序定义配置文件：
```
# cat << END > /opt/bootmenu/bootmenu.conf
{
hypnotoad => {
listen => ['http://*:80'],
pid_file => '/run/bootmenu/bootmenu.pid',
}
}
END
```
这是一个非常简单的 Mojolicious 应用程序，它监听 80 端口，并且只回应对 `/menu` 的请求。如果你想快速了解 Mojolicious 能做什么，运行 `man Mojolicious::Guides::Growing` 去查看手册。按 `Q` 键退出手册。
将 `boot.cfg` 移到我们的网络引导应用程序中作为一个名为 `menu.html.ep` 的模板：
```
# mkdir /opt/bootmenu/templates
# mv $HOME/esp/linux/boot.cfg /opt/bootmenu/templates/menu.html.ep
```
定义一个 systemd 服务去管理引导菜单应用程序：
```
# cat << END > /etc/systemd/system/bootmenu.service
[Unit]
Description=Serves iPXE Menus over HTTP
After=network-online.target
[Service]
Type=forking
DynamicUser=true
RuntimeDirectory=bootmenu
PIDFile=/run/bootmenu/bootmenu.pid
ExecStart=/usr/bin/hypnotoad /opt/bootmenu/bootmenu.pl
ExecReload=/usr/bin/hypnotoad /opt/bootmenu/bootmenu.pl
AmbientCapabilities=CAP_NET_BIND_SERVICE
KillMode=process
[Install]
WantedBy=multi-user.target
END
```
在本地防火墙中为 HTTP 服务添加一个例外规则，并启动 bootmenu 服务：
```
# firewall-cmd --add-service http
# firewall-cmd --runtime-to-permanent
# systemctl enable bootmenu.service
# systemctl start bootmenu.service
```
用 `wget` 测试它：
```
$ sudo dnf install -y wget
$ MY_BOOTMENU_SERVER=server-01.example.edu
$ wget -q -O - http://$MY_BOOTMENU_SERVER/menu
```
以上的命令应该会输出类似下面的内容：
```
#!ipxe
set timeout 5000
:menu
menu iPXE Boot Menu
item --key 1 lcl 1. Microsoft Windows 10
item --key 2 f29 2. RedHat Fedora 29
choose --timeout ${timeout} --default lcl selected || goto shell
set timeout 0
goto ${selected}
:failed
echo boot failed, dropping to shell...
goto shell
:shell
echo type 'exit' to get the back to the menu
set timeout 0
shell
goto menu
:lcl
exit
:f29
kernel --name kernel.efi ${prefix}/vmlinuz-4.19.4-300.fc29.x86_64 initrd=initrd.img ro ip=dhcp rd.peerdns=0 nameserver=192.0.2.91 nameserver=192.0.2.92 root=/dev/disk/by-path/ip-192.0.2.158:3260-iscsi-iqn.edu.example.server-01:fc29-lun-1 netroot=iscsi:192.0.2.158::::iqn.edu.example.server-01:fc29 console=tty0 console=ttyS0,115200n8 audit=0 selinux=0 quiet
initrd --name initrd.img ${prefix}/initramfs-4.19.4-300.fc29.x86_64.img
boot || goto failed
```
现在，引导菜单服务器已经正常工作了，重新构建 `ipxe.efi` 引导加载器，使用一个初始化脚本指向它。
第一步，先更新我们在本系列文章的第一部分中创建的 `init.ipxe` 脚本：
```
$ MY_BOOTMENU_SERVER=server-01.example.edu
$ cat << END > $HOME/ipxe/init.ipxe
#!ipxe
dhcp || exit
set prefix file:///linux
chain http://$MY_BOOTMENU_SERVER/menu || exit
END
```
现在，重新构建引导加载器：
```
$ cd $HOME/ipxe/src
$ make clean
$ make bin-x86_64-efi/ipxe.efi EMBED=../init.ipxe
```
将更新后的引导加载器复制到你的 ESP 中：
```
$ cp $HOME/ipxe/src/bin-x86_64-efi/ipxe.efi $HOME/esp/efi/boot/bootx64.efi
```
将更新后的引导加载器复制到所有的客户端中之后，以后更新引导菜单只需要简单地编辑 `/opt/bootmenu/templates/menu.html.ep` 文件，然后再运行如下命令：
```
$ sudo systemctl restart bootmenu.service
```
### 做一步的改变
如果引导菜单服务器工作正常，在你的客户端系统上的 `boot.cfg` 文件将更长。
比如，重新添加 Fedora 28 镜像到引导菜单中：
```
$ sudo -i
# MY_FVER=28
# MY_KRNL=$(ls -c /fc$MY_FVER/lib/modules | head -n 1)
# MY_DNS1=192.0.2.91
# MY_DNS2=192.0.2.92
# MY_NAME=$(</etc/hostname)
# MY_EMAN=$(echo $MY_NAME | tr '.' "\n" | tac | tr "\n" '.' | cut -b -${#MY_NAME})
# MY_ADDR=$(host -t A $MY_NAME | awk '{print $4}')
# cat << END >> /opt/bootmenu/templates/menu.html.ep
:f$MY_FVER
kernel --name kernel.efi \${prefix}/vmlinuz-$MY_KRNL initrd=initrd.img ro ip=dhcp rd.peerdns=0 nameserver=$MY_DNS1 nameserver=$MY_DNS2 root=/dev/disk/by-path/ip-$MY_ADDR:3260-iscsi-iqn.$MY_EMAN:fc$MY_FVER-lun-1 netroot=iscsi:$MY_ADDR::::iqn.$MY_EMAN:fc$MY_FVER console=tty0 console=ttyS0,115200n8 audit=0 selinux=0 quiet
initrd --name initrd.img \${prefix}/initramfs-$MY_KRNL.img
boot || goto failed
END
# sed -i "/item --key 2/a item --key 3 f$MY_FVER 3. RedHat Fedora $MY_FVER" /opt/bootmenu/templates/menu.html.ep
# systemctl restart bootmenu.service
```
如果一切顺利，你的客户端下次引导时，应该看到如下图所示的结果：
---
via: <https://fedoramagazine.org/how-to-build-a-netboot-server-part-3/>
作者：[Gregory Bartholomew](https://fedoramagazine.org/author/glb/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
初级：如何在终端及图形界面中更新 Ubuntu
|
Abhishek Prakash
|
https://itsfoss.com/update-ubuntu/
|
这篇教程将向你展示如何更新服务器版本或者桌面版本的 Ubuntu。它还解释了更新和升级之间的区别以及你应该了解的有关于 Ubuntu Linux 中的更新的一些其他内容。
|
/data/attachment/album/201901/01/212906rhz7lwatjcha74a4.png.thumb.jpg
|
/data/attachment/album/201901/01/212906rhz7lwatjcha74a4.png
| true | false | true |
lujun9972
|
LazyWolfLin
|
wxy
| false |
[
"Ubuntu",
"升级",
"更新"
] |
技术
|
{
"viewnum": 9081,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "61.140.26.252",
"message": "请问图里面的字体是什么字体",
"username": "来自广东广州的 Chrome 71.0|Mac 10.14 用户",
"date": "2019-01-03T10:57:25"
}
] |
[] |
这篇教程将向你展示如何更新服务器版本或者桌面版本的 Ubuntu。它还解释了更新和升级之间的区别以及你应该了解的有关于 Ubuntu Linux 中的更新的一些其他内容。
| 2019-01-01T21:29:04 | 2019-01-01T21:29:04 | 10,406 |
/article-10406-1.html
|
>
> 这篇教程将向你展示如何更新服务器版本或者桌面版本的 Ubuntu。它还解释了更新和升级之间的区别以及你应该了解的有关于 Ubuntu Linux 中的更新的一些其他内容。
>
>
>
如果你是一个新手并已经体验 Ubuntu 数天或几周，你可能想知道如何更新你的 [Ubuntu](https://www.ubuntu.com/) 系统以获取安全补丁，错误修复和应用升级。
更新 Ubuntu 非常简单。我并不是瞎说。它简单得只要运行两个命令。让我来告诉你这两个命令的更多细节。
请注意，本教程适用于 Ubuntu 18.04、16.04 或任何其他版本。命令行方式也适用于基于 Ubuntu 的发行版如 Linux Mint、Linux Lite、elementary OS 等。
### 通过命令行更新 Ubuntu
在桌面上，打开终端。你可以在菜单里找到它或者使用 `Ctrl+Alt+T` [快捷键](https://itsfoss.com/ubuntu-shortcuts/)。如果你是登录到一台 [Ubuntu 服务器](https://www.ubuntu.com/download/server)，那你已经在访问一个终端了。
在终端里，你只需要使用以下命令：
```
sudo apt update && sudo apt upgrade -y
```
它将询问你密码，而你可以使用你的账号密码。输入时，你将不会看到任何内容在屏幕上，所以请继续输入你的密码并按回车键。
现在，我来解释下上面的命令。
事实上，这不是一条命令。它由两条命令组成。符号 `&&` 是合并两条命令的一个方法，第二条命令仅在前一条命令执行成功时执行。
当命令 `apt upgrade` 要求你在安装更新前确认时，末尾的参数 `-y` 会自动输入 `yes`。
请注意，你也可以逐条使用这两条命令：
```
sudo apt update
sudo apt upgrade
```
这将花费更长的时间，因为你必须等待第一条命令执行完成后才能输入第二条命令。
#### 说明：sudo apt update
这条命令更新了可用软件包的本地数据库。如果你没运行这条命令，本地数据库将不会被更新，而你的系统将不会知道是否有可用的新版本。
这就是为什么当你运行 `sudo apt update`，你会在输出中看到大量的 URL。这条命令会从对应的储存库（你在输出中看到的 URL）中获取软件包信息。
在命令的末尾，它告诉你有多少个软件包可以被更新。你可以使用下列命令查看这些软件包：
```
apt list --upgradable
```
**补充阅读：** 阅读这篇文章了解[命令 apt update 的输出中的 Ign、Hit 和 Get 是什么](https://itsfoss.com/apt-get-linux-guide/)。
#### 说明：sudo apt upgrade
这条命令将已安装的软件包版本与本地数据库进行匹配。它收集全部信息，然后列出所有具有更新版本的软件包。此时，它会询问您是否要升级（已安装的软件包更新到新版本）。
你可以键入 `yes`、`y` 或者只敲回车键去确认安装这些更新。
所以总的来说，`sudo apt update` 会检查可用的新版本，而 `sudo apt upgrade` 实际上会执行更新。
命令 `update` 可能会令人困惑，因为你可能期望通过命令 `apt update` 安装更新来更新系统，但这并不会发生。
### 通过 GUI 更新 Ubuntu（适用于桌面用户）
如果你使用桌面版 Ubuntu，你并不需要为了更新系统而打开终端。你可以仍可以使用命令行更新，但这只是一个选择。
在菜单里，找到 “软件更新” 并运行它。
它将检查你的系统是否有可用的更新。
如果有可用的更新，它将给你提供安装更新的选择。
现在，点击 “安装”，它可能会向你询问密码。
一旦你输入你的密码，它将开始安装更新。
在某些情况下，你可能需要重启系统才能使已安装的更新正常工作。如果需要重启系统，你将在更新结束时收到通知。
如果你不希望马上重启你的系统，可以选择稍后重启。
提示：如果“软件更新”返回一个错误，你需要在终端是使用命令 `sudo apt update`。输出的最后几行将包含真正的错误信息。你可以在因特网上搜索该错误并解决问题。
### 更新 Ubuntu 时要记住几件事
你刚学习了如何更新你的 Ubuntu 系统。如果你感兴趣，你还需要了解一些关于 Ubuntu 更新的内容。
#### 更新后清理
你的系统将会有一些更新后不再需要的软件包。你可用使用这条命令删除这些软件包并[释放空间](https://itsfoss.com/free-up-space-ubuntu-linux/)：
```
sudo apt autoremove
```
#### 在 Ubuntu Server 中内核热修复以避免重启
如果是 Linux 内核更新，你将需要在系统更新后重启。当你不希望服务器停机时，这将会是一个问题。
[热修复](https://www.ubuntu.com/livepatch)功能允许 Linux 内核在持续运行时打补丁。换句话说就是你不需要重启你的系统。
如果你在管理服务器，你可能需要[在 Ubuntu 中启用热修复](https://www.cyberciti.biz/faq/howto-live-patch-ubuntu-linux-server-kernel-without-rebooting/)。
#### 版本升级是不同的
本文讨论的更新是使你安装的 Ubuntu 保持最新。但它不包括[版本升级](https://itsfoss.com/upgrade-ubuntu-version/)（例如从 Ubuntu 16.04 升级到 18.04）。
[Ubuntu 版本](https://itsfoss.com/how-to-know-ubuntu-unity-version/) 升级完全是另一回事。它更新整个操作系统核心。你需要在这个漫长的过程开始前做好备份。
### 总结
我希望你喜欢这个关于 Ubuntu 系统更新的教程并学到一些新东西。
如果你有其他问题，请随时提出。如果你是一位经验丰富的 Linux 用户并且有些更好的技巧，请同我们分享。
---
via: <https://itsfoss.com/update-ubuntu/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[LazyWolfLin](https://github.com/LazyWolfLin) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linux 下最棒的 11 个图片查看器
|
Ankush Das
|
https://itsfoss.com/image-viewers-linux/
|
如果不是因为系统自带的图片查看器没有你想要的功能，或者你想要更棒的体验，你大概不会想切换到其它图片查看器吧。
|
/data/attachment/album/201901/02/140524oz705o0cqm57mg3l.png.thumb.jpg
|
/data/attachment/album/201901/02/140524oz705o0cqm57mg3l.png
| true | false | true |
lujun9972
|
zhs852
|
wxy
| false |
[
"图片",
"图像"
] |
分享
|
{
"viewnum": 25898,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果不是因为系统自带的图片查看器没有你想要的功能，或者你想要更棒的体验，你大概不会想切换到其它图片查看器吧。
| 2019-01-02T14:05:21 | 2019-01-02T14:05:21 | 10,407 |
/article-10407-1.html
|
如果不是因为系统自带的图片查看器没有你想要的功能，或者你想要更棒的体验，你大概不会想切换到其它图片查看器吧。
不过，如果你喜欢折腾，你可能就会想用不同的图片查看器了吧。我猜最终你会被新图片查看器的全新用户体验或特色功能所吸引的。
在本篇文章中，无论是简单的还是复杂的、无论是为 Ubuntu 准备的还是其它 Linux 发行版准备的，我们都有提到。
### Linux 下最棒的图片查看器
**注意：** 在准备安装一个图片查看器时，请前往您系统中预先安装的软件商店中查找。如果您没有任何软件商店或无法在软件商店中找到它，请手动执行我们给出的命令。
#### 1. Nomacs
**它有什么特点？**
* 轻快
* 内建图像调整工具（可以调整色彩和大小）
* 拍摄位置信息
* 元数据调节器
* 局域网同步
* 全屏模式
Nomacs 是一款自由软件。虽然没有什么出众的功能，但是它的兼容性还不错，可以支持许多常见格式。
它的界面超级简单，但是提供了简单的图片编辑功能（可以调整色彩、亮度、大小和裁剪）。除此之外，它还支持全屏模式、直方图，以及可以切换显示元数据、编辑历史等信息的许多面板。
**我该如何安装它？**
简单起见，你可以在各种软件中心中安装它。如果你想通过终端安装它，请参见它的 [GitHub 页](https://github.com/nomacs/nomacs) 。或者，在使用 APT 包管理的系统中使用如下命令安装：
```
sudo apt install nomacs
```
#### 2. Gnome 之眼
**它有什么特点？**
* 极其简单的图像查看器
* 幻灯片视图
* 为 GNOME 量身打造的图片查看器
这是一款经典的图片查看器，它在数年前作为 GNOME 项目的一部分被开发出来。不过需要注意的是，对它的维护目前已经不是很活跃了。不过它仍能在最新版 Ubuntu LTS 和部分 Linux 发行版中正常工作。
如果你需要一个简单、有幻灯片视图并可以在侧栏看到元数据的图像查看器，Gnome 之眼是最佳选择。
**我该如何安装它？**
若要在 Ubuntu 及基于 Ubuntu 的 Linux 发行版上安装它，仅需一条命令：
```
sudo apt install eog
```
如果你想在其它发行版中安装它，请参见 [该项目的 GitHub 页面](https://github.com/GNOME/eog) 。
#### 3. EOM
**它有什么特点？**
* 简洁
* 可扩展
* 为 MATE 量身打造的图片查看器
另一个基本功能齐全，支持幻灯片视图和图像旋转的查看器。
虽然它没什么特色功能，但它支持大部分的图像格式，并且还能处理大体积的图像。
**我该如何安装它？**
若要在 Ubuntu 及基于 Ubuntu 的 Linux 发行版上安装它，仅需一条命令：
```
sudo apt install eom
```
如果你想在其它发行版中安装它，请参见 [该项目的 GitHub 页面](https://github.com/mate-desktop/eom) 。
#### 4. Geeqie
**它有什么特点？**
* 可扩展的灵活的图像查看器（其它的图像查看器支持它）
* 可以显示色彩信息
Geeqie 是一个令用户印象深刻的图片管理/查看器。它支持将其它查看器作为扩展使用，不过它并不提供任何对图像操作的工具。
如果你希望获取图像的颜色信息、元数据，或是查看/管理一组图片，它将会是一个不错的选择。
**我该如何安装它？**
在终端输入：
```
sudo apt install geeqie
```
若想查看它的源代码，请前往 [它的 GitHub 主页](https://github.com/BestImageViewer/geeqie)。
#### 5. gThumb
**它有什么特点？**
* 全功能（查看、编辑和管理）
* 可清除 EXIF 信息
* 图像格式转换
* 查找重复的图像
gThumb 会让你眼前一亮，因为它有很多功能。它的查看/管理界面和编辑工具（裁剪、缩放、颜色编辑等等）将会给你留下很深的印象。
你甚至可以为图像添加评论或清除它的 EXIF 信息。它使得你可以方便地找到重复的图像或转码图像。
**我该如何安装它？**
你可以在终端中输入这条命令：
```
sudo apt install gthumb
```
输了没用？请参阅 [项目 GitHub 主页](https://github.com/GNOME/gthumb) 来获取帮助。
#### 6. Gwenview
**它有什么特点？**
* 简单，有基础图像编辑功能（旋转、调整大小）
* 可使用 KIPI 插件扩展
Gwenview 又是一个基本的图像查看器，它为 KDE 量身定做。不过这并不影响你在其它桌面环境中使用它。
如果你使用 Konqueror 浏览器，你可以将 Gwenview 作为它的内嵌图片浏览器。你也可以为图片添加评论。此外，它还支持 [KIPI](https://en.wikipedia.org/wiki/KDE_Image_Plugin_Interface) 插件。
**我该如何安装它？**
你可以在终端中输入这条命令：
```
sudo apt install gwenview
```
若想查看它的源代码，请前往 [它的 GitHub 主页](https://github.com/KDE/gwenview)。
#### 7. Mirage
**它有什么特点？**
* 可定制的基本用户界面
* 基本图像编辑工具
* 可在命令行使用
如果你想要一个可在命令行中访问、支持全屏和幻灯片视图、带有基础编辑工具以及可定制 UI 的普通查看器，Mirage 是个不二之选。
它是一个非常快速且兼容性优良的查看器。它支持包括 png、jpg、svg、xpm、gif、bmp 和 tiff 在内的多种图像格式。
**我该如何安装它？**
你需要执行：
```
sudo apt install mirage
```
访问 [该项目 GitHub 页面](https://github.com/xiongchiamiov/Mirage) 来获取更多信息。
#### 8. KPhotoAlbum
**它有什么特点？**
* 为图像添加标签
* 数据库支持
* 图片压缩
* 将图像合并到一组图像，或移除
确切地说，KPhotoAlbum 其实不仅仅是一款图像查看器，它还能为图像添加标签并管理图像。
你可以用它来压缩图片以及使用标签搜索你的图片。你还可以使用幻灯片视图来观看图片。
**我该如何安装它？**
在终端中输入：
```
sudo apt kphotoalbum
```
跟从 [官网上的指引](https://www.kphotoalbum.org/download/) 来在其它 Linux 发行版中安装它。
#### 9. Shotwell
**它有什么特点？**
* 红眼消除工具
* 将照片上传到 Facebook 或 Flickr 等社交网络中
* 支持原始格式（RAW）的图片
Shotwell 是一个多功能照片管理器。在此，你能查看或管理你的照片。虽然它没带有许多图像编辑工具，但是你还是可以裁剪和调整亮度的。
**我该如何安装它？**
在终端中执行以下命令 (Ubuntu 及其衍生版本)：
```
sudo apt install shotwell
```
若想获取更多信息，请 [前往它的 GitHub 页面](https://github.com/GNOME/shotwell)。
#### 10. Ristretto
**它有什么特点？**
* 极其简单
* 全屏模式
* 幻灯片视图
简易的图像查看器。它能查看、全屏查看、缩放查看或以幻灯片视图查看图片。
它是为 Xfce 定制的，但你仍然可以在其它任何地方安装它。
**我该如何安装它？**
即使它是为 Xfce 桌面环境构建的，你仍能在其它地方安装它。对 Ubuntu 及其衍生发行版，请执行：
```
sudo apt install ristretto
```
#### 11. digiKam
**它有什么特点？**
* 带有高级图像管理功能（查看/管理/编辑）的多合一查看器
* 可以进行批处理
* 带有 [Light Table 功能](https://docs.kde.org/trunk5/en/extragear-graphics/digikam/using-lighttable.html)
digiKam 是一个带有多种图像编辑功能的高级照片管理器。你可以使用 SQLite 或 MySQL 来配置它的数据库。
为了提升你的看图体验，你可以在预览图片时加载低画质的图片。这样一来，即使你有一大堆图片，它也丝滑般流畅。不仅如此，你还可以通过 Google、Facebook、Imgur 等来导入/导出图片。如果你希望使用一个超多功能的查看器，请务必试试这个 digiKam。
**我该如何安装它？**
执行这条命令：
```
sudo apt install digikam
```
访问 [项目 GitHub 页面](https://github.com/KDE/digikam) 来获取更多信息。
### 尾声
总的来说，无论你想要不同的用户体验、丰富的功能还是强大的管理工具，上面总有适合你的工具。
你更喜欢哪个图像查看器呢？它是系统自带的吗？
欢迎前往原文的评论区留下你的答案。
---
via: <https://itsfoss.com/image-viewers-linux/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[zhs852](https://github.com/zhs852) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 Node.js 构建交互式命令行工具
|
Hugo Dias
|
https://opensource.com/article/18/7/node-js-interactive-cli
|
使用 Node.js 构建一个根据询问创建文件的命令行工具。
|
/data/attachment/album/201901/02/232550x51um1yim1msd19m.jpg.thumb.jpg
|
/data/attachment/album/201901/02/232550x51um1yim1msd19m.jpg
| true | false | true |
lujun9972
|
bestony
|
wxy
| false |
[
"Node.js"
] |
软件开发
|
{
"viewnum": 7015,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用 Node.js 构建一个根据询问创建文件的命令行工具。
| 2019-01-02T23:25:54 | 2019-01-02T23:25:54 | 10,408 |
/article-10408-1.html
|
>
> 使用 Node.js 构建一个根据询问创建文件的命令行工具。
>
>
>
当用于构建命令行界面（CLI）时，Node.js 十分有用。在这篇文章中，我将会教你如何使用 [Node.js](https://nodejs.org/en/) 来构建一个问一些问题并基于回答创建一个文件的命令行工具。
### 开始
首先，创建一个新的 [npm](https://www.npmjs.com/) 包（NPM 是 JavaScript 包管理器）。
```
mkdir my-script
cd my-script
npm init
```
NPM 将会问一些问题。随后，我们需要安装一些包。
```
npm install --save chalk figlet inquirer shelljs
```
这是我们需要的包：
* Chalk：正确设定终端的字符样式
* Figlet：使用普通字符制作大字母的程序（LCTT 译注：使用标准字符，拼凑出图片）
* Inquirer：通用交互式命令行用户界面的集合
* ShellJS：Node.js 版本的可移植 Unix Shell 命令行工具
### 创建一个 index.js 文件
现在我们要使用下述内容创建一个 `index.js` 文件。
```
#!/usr/bin/env node
const inquirer = require("inquirer");
const chalk = require("chalk");
const figlet = require("figlet");
const shell = require("shelljs");
```
### 规划命令行工具
在我们写命令行工具所需的任何代码之前，做计划总是很棒的。这个命令行工具只做一件事：**创建一个文件**。
它将会问两个问题：文件名是什么以及文件后缀名是什么？然后创建文件，并展示一个包含了所创建文件路径的成功信息。
```
// index.js
const run = async () => {
// show script introduction
// ask questions
// create the file
// show success message
};
run();
```
第一个函数只是该脚本的介绍。让我们使用 `chalk` 和 `figlet` 来把它完成。
```
const init = () => {
console.log(
chalk.green(
figlet.textSync("Node JS CLI", {
font: "Ghost",
horizontalLayout: "default",
verticalLayout: "default"
})
)
);
}
const run = async () => {
// show script introduction
init();
// ask questions
// create the file
// show success message
};
run();
```
然后，我们来写一个函数来问问题。
```
const askQuestions = () => {
const questions = [
{
name: "FILENAME",
type: "input",
message: "What is the name of the file without extension?"
},
{
type: "list",
name: "EXTENSION",
message: "What is the file extension?",
choices: [".rb", ".js", ".php", ".css"],
filter: function(val) {
return val.split(".")[1];
}
}
];
return inquirer.prompt(questions);
};
// ...
const run = async () => {
// show script introduction
init();
// ask questions
const answers = await askQuestions();
const { FILENAME, EXTENSION } = answers;
// create the file
// show success message
};
```
注意，常量 `FILENAME` 和 `EXTENSIONS` 来自 `inquirer` 包。
下一步将会创建文件。
```
const createFile = (filename, extension) => {
const filePath = `${process.cwd()}/${filename}.${extension}`
shell.touch(filePath);
return filePath;
};
// ...
const run = async () => {
// show script introduction
init();
// ask questions
const answers = await askQuestions();
const { FILENAME, EXTENSION } = answers;
// create the file
const filePath = createFile(FILENAME, EXTENSION);
// show success message
};
```
最后，重要的是，我们将展示成功信息以及文件路径。
```
const success = (filepath) => {
console.log(
chalk.white.bgGreen.bold(`Done! File created at ${filepath}`)
);
};
// ...
const run = async () => {
// show script introduction
init();
// ask questions
const answers = await askQuestions();
const { FILENAME, EXTENSION } = answers;
// create the file
const filePath = createFile(FILENAME, EXTENSION);
// show success message
success(filePath);
};
```
来让我们通过运行 `node index.js` 来测试这个脚本，这是我们得到的：
### 完整代码
下述代码为完整代码：
```
#!/usr/bin/env node
const inquirer = require("inquirer");
const chalk = require("chalk");
const figlet = require("figlet");
const shell = require("shelljs");
const init = () => {
console.log(
chalk.green(
figlet.textSync("Node JS CLI", {
font: "Ghost",
horizontalLayout: "default",
verticalLayout: "default"
})
)
);
};
const askQuestions = () => {
const questions = [
{
name: "FILENAME",
type: "input",
message: "What is the name of the file without extension?"
},
{
type: "list",
name: "EXTENSION",
message: "What is the file extension?",
choices: [".rb", ".js", ".php", ".css"],
filter: function(val) {
return val.split(".")[1];
}
}
];
return inquirer.prompt(questions);
};
const createFile = (filename, extension) => {
const filePath = `${process.cwd()}/${filename}.${extension}`
shell.touch(filePath);
return filePath;
};
const success = filepath => {
console.log(
chalk.white.bgGreen.bold(`Done! File created at ${filepath}`)
);
};
const run = async () => {
// show script introduction
init();
// ask questions
const answers = await askQuestions();
const { FILENAME, EXTENSION } = answers;
// create the file
const filePath = createFile(FILENAME, EXTENSION);
// show success message
success(filePath);
};
run();
```
### 使用这个脚本
想要在其它地方执行这个脚本，在你的 `package.json` 文件中添加一个 `bin` 部分，并执行 `npm link`：
```
{
"name": "creator",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"start": "node index.js"
},
"author": "",
"license": "ISC",
"dependencies": {
"chalk": "^2.4.1",
"figlet": "^1.2.0",
"inquirer": "^6.0.0",
"shelljs": "^0.8.2"
},
"bin": {
"creator": "./index.js"
}
}
```
执行 `npm link` 使得这个脚本可以在任何地方调用。
这就是是当你运行这个命令时的结果。
```
/usr/bin/creator -> /usr/lib/node_modules/creator/index.js
/usr/lib/node_modules/creator -> /home/hugo/code/creator
```
这会连接 `index.js` 作为一个可执行文件。这是完全可能的，因为这个 CLI 脚本的第一行是 `#!/usr/bin/env node`。
现在我们可以通过执行如下命令来调用。
```
$ creator
```
### 总结
正如你所看到的，Node.js 使得构建一个好的命令行工具变得非常简单。如果你希望了解更多内容，查看下列包。
* [meow](https://github.com/sindresorhus/meow)：一个简单的命令行助手工具
* [yargs](https://github.com/yargs/yargs)：一个命令行参数解析工具
* [pkg](https://github.com/zeit/pkg)：将你的 Node.js 程序包装在一个可执行文件中。
在评论中留下你关于构建命令行工具的经验吧！
---
via: <https://opensource.com/article/18/7/node-js-interactive-cli>
作者：[Hugo Dias](https://opensource.com/users/hugodias) 选题：[lujun9972](https://github.com/lujun9972) 译者：[bestony](https://github.com/bestony) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Ubuntu 18.04 中启动到救援模式或紧急模式
|
Sk
|
https://www.ostechnix.com/how-to-boot-into-rescue-mode-or-emergency-mode-in-ubuntu-18-04/
|
在救援模式下，将挂载所有本地文件系统，仅启动一些重要服务。与救援模式相比，在紧急模式中不启动任何东西。
|
/data/attachment/album/201901/02/233456h882cm5rw28ynwrm.png.thumb.jpg
|
/data/attachment/album/201901/02/233456h882cm5rw28ynwrm.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"救援模式",
"紧急模式"
] |
技术
|
{
"viewnum": 25076,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
在救援模式下，将挂载所有本地文件系统，仅启动一些重要服务。与救援模式相比，在紧急模式中不启动任何东西。
| 2019-01-02T23:34:00 | 2019-01-02T23:34:00 | 10,409 |
/article-10409-1.html
|
正如你可能已经知道的那样，**运行级别** 在许多最近的 Linux 发行版（如 RHEL 7 和 Ubuntu 16.04 LTS）中被 **systemd 的目标** 替换。有关它们的更多详细信息，请参阅[这个指南](https://www.ostechnix.com/check-runlevel-linux/)。在这个简短的教程中，我们将看到如何启动**救援模式**以及**紧急模式**。本指南在 Ubuntu 18.04 LTS 中进行了测试，但是下面给出的步骤适用于大多数使用 systemd 作为默认服务管理器的 Linux 发行版。在进一步讨论之前，让我澄清什么是救援模式和紧急模式以及这两种模式的目的是什么。
### 什么是救援模式？
**救援模式**相当于使用 **SysV** 作为默认的服务管理器的 Linux 发行版中的 **单用户模式**。在救援模式下，将挂载所有本地文件系统，仅启动一些重要服务。但是，不会启动正常服务（例如网络服务）。救援模式在系统无法正常启动的情况下很有用。此外，我们可以在救援模式下执行一些重要的救援操作，例如[重置 root 密码](https://www.ostechnix.com/how-to-reset-or-recover-root-user-password-in-linux/)。
### 什么是紧急模式？
与救援模式相比，在**紧急模式**中不启动任何东西。没有服务启动、没有挂载点、没有建立套接字，什么也没有。你所拥有的只是一个**原始的 shell**。紧急模式适用于调试目的。
### 在 Ubuntu 18.04 LTS 中进入救援模式
启动你的 Ubuntu 系统。出现 Grub 菜单时，选择第一条并按下 `e` 进行编辑。
如果你没有看到 Grub 菜单，只需在 BIOS 的 logo 消失后立即按下 `ESC` 键。
找到以单词 `linux` 开头的行，并在该行的末尾添加以下内容（要到达末尾，只需按下 `CTRL+e` 或使用 `END` 键或左右箭头键）：
```
systemd.unit=rescue.target
```
添加完成后，只需按下 `CTRL+x` 或 `F10` 即可继续启动救援模式。几秒钟后，你将以 root 用户身份进入救援模式（单用户模式）。以下是 Ubuntu 18.04 LTS 服务器版中救援模式的样子：
接下来，输入以下命令将根 （`/`） 文件系统重新挂载成读/写模式。
```
mount -n -o remount,rw /
```
### 启动到紧急模式
将 Ubuntu 引导到紧急模式与上述方法相同。你只需在编辑 Grub 菜单时将 `systemd.unit=rescue.target` 替换为 `systemd.unit=emergency.target` 即可。
添加 `systemd.unit=emergency.target` 后，按下 `Ctrl+x` 或 `F10` 继续启动到紧急模式。
最后，你可以使用以下命令将根文件系统重新挂载成读/写模式：
```
mount -n -o remount,rw /
```
### 在救援模式和紧急模式之间切换
如果你处于救援模式，则不必像上面提到的那样编辑 Grub 条目。相反，只需输入以下命令即可立即切换到紧急模式：
```
systemctl emergency
```
同样，要从紧急模式切换到救援模式，请输入：
```
systemctl rescue
```
你现在知道了什么是救援模式和紧急模式以及如何在 Ubuntu 18.04 中启动这些模式。就像我已经提到的，这里提供的步骤将适用于许多使用 systemd 的 Linux 版本。
就是这些了。希望这篇文章有用。
还有更多好东西。敬请期待！
干杯！
---
via: <https://www.ostechnix.com/how-to-boot-into-rescue-mode-or-emergency-mode-in-ubuntu-18-04/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
dbxfs：在 Linux 中本地挂载 Dropbox 文件夹
|
Sk
|
https://www.ostechnix.com/dbxfs-mount-dropbox-folder-locally-as-virtual-file-system-in-linux/
|
虽然在 Linux 中很容易安装 Dropbox 客户端，但这种方法与官方方法略有不同。它是一个命令行 dropbox 客户端，且无需磁盘空间即可访问。
|
/data/attachment/album/201901/03/134500k83d0xphlm3pxd52.png.thumb.jpg
|
/data/attachment/album/201901/03/134500k83d0xphlm3pxd52.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Dropbox",
"FUSE"
] |
技术
|
{
"viewnum": 4896,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
虽然在 Linux 中很容易安装 Dropbox 客户端，但这种方法与官方方法略有不同。它是一个命令行 dropbox 客户端，且无需磁盘空间即可访问。
| 2019-01-03T13:44:55 | 2019-01-03T13:44:55 | 10,410 |
/article-10410-1.html
|
不久前，我们总结了所有 [在本地挂载 Google Drive](https://www.ostechnix.com/how-to-mount-google-drive-locally-as-virtual-file-system-in-linux/) 作为虚拟文件系统，并从 Linux 系统访问存储在 Google Drive 中的文件的方法。今天，我们将学习使用 `dbxfs` 将 Dropbox 文件夹挂载到本地文件系统中。`dbxfs` 用于在类 Unix 操作系统中本地挂载 Dropbox 文件夹作为虚拟文件系统。虽然在 Linux 中很容易[安装 Dropbox 客户端](https://www.ostechnix.com/install-dropbox-in-ubuntu-18-04-lts-desktop/)，但这种方法与官方方法略有不同。它是一个命令行 dropbox 客户端，且无需磁盘空间即可访问。`dbxfs` 是自由开源的，并且是用 Python 3.5+ 编写的。
### 安装 dbxfs
`dbxfs` 官方支持 Linux 和 Mac OS。但是，它应该适用于任何提供 **FUSE 兼容库**或能够挂载 SMB 共享的 POSIX 系统。由于它是用 Python 3.5 编写的，因此可以使用 pip3 包管理器进行安装。如果尚未安装 pip，请参阅以下指南。
* [如何使用 pip 管理 Python 包](https://www.ostechnix.com/manage-python-packages-using-pip/)
并且也要安装 FUSE 库。
在基于 Debian 的系统上，运行以下命令以安装 FUSE：
```
$ sudo apt install libfuse2
```
在 Fedora 上：
```
$ sudo dnf install fuse
```
安装完所有必需的依赖项后，运行以下命令以安装 `dbxfs`：
```
$ pip3 install dbxfs
```
### 在本地挂载 Dropbox 文件夹
创建一个挂载点以将 Dropbox 文件夹挂载到本地文件系统中。
```
$ mkdir ~/mydropbox
```
然后，使用 `dbxfs` 在本地挂载 dropbox 文件夹，如下所示：
```
$ dbxfs ~/mydropbox
```
你将被要求生成一个访问令牌：
要生成访问令牌，只需在 Web 浏览器中输入上面输出的 URL，然后单击 **允许** 以授权 Dropbox 访问。你需要登录 Dropbox 帐户才能完成授权过程。
下一个页面将生成新的授权码。复制代码并返回终端将其粘贴到 cli-dbxfs 提示符中以完成该过程。
然后，系统会要求你保存凭据以供将来访问。根据你是要保存还是拒绝，输入 `Y` 或 `N`。然后，你需要为新的访问令牌输入两次密码。
最后，输入 `Y` 接受 `/home/username/mydropbox` 作为默认挂载点。如果你要设置不同的路径，输入 `N` 并输入你选择的位置。
完成了！从现在开始，你可以看到你的 Dropbox 文件夹已挂载到本地文件系统中。
### 更改访问令牌存储路径
默认情况下，`dbxfs` 会将 Dropbox 访问令牌存储在系统密钥环或加密文件中。但是，你可能希望将其存储在 gpg 加密文件或其他地方。如果是这样，请在 [Dropbox 开发者应用控制台](https://dropbox.com/developers/apps)上创建个人应用来获取访问令牌。
创建应用后，单击下一步中的**生成**按钮。此令牌可用于通过 API 访问你的 Dropbox 帐户。不要与任何人共享你的访问令牌。
创建访问令牌后，使用任何你选择的加密工具对其进行加密，例如 [Cryptomater](https://www.ostechnix.com/cryptomator-open-source-client-side-encryption-tool-cloud/)、[Cryptkeeper](https://www.ostechnix.com/how-to-encrypt-your-personal-foldersdirectories-in-linux-mint-ubuntu-distros/)、[CryptGo](https://www.ostechnix.com/cryptogo-easy-way-encrypt-password-protect-files/)、[Cryptr](https://www.ostechnix.com/cryptr-simple-cli-utility-encrypt-decrypt-files/)、[Tomb](https://www.ostechnix.com/tomb-file-encryption-tool-protect-secret-files-linux/)、[Toplip](https://www.ostechnix.com/toplip-strong-file-encryption-decryption-cli-utility/) 和 [\*\*GnuPG](https://www.ostechnix.com/an-easy-way-to-encrypt-and-decrypt-files-from-commandline-in-linux/) 等，并在你喜欢的位置保存。
接下来编辑 dbxfs 配置文件并添加以下行：
```
"access_token_command": ["gpg", "--decrypt", "/path/to/access/token/file.gpg"]
```
你可以通过运行以下命令找到 dbxfs 配置文件：
```
$ dbxfs --print-default-config-file
```
有关更多详细信息，请参阅 dbxfs 帮助：
```
$ dbxfs -h
```
如你所见，使用 `dbxfs` 在你的文件系统中本地挂载 Dropfox 文件夹并不复杂。经过测试，`dbxfs` 如常工作。如果你有兴趣了解它是如何工作的，请尝试一下，并在下面的评论栏告诉我们你的体验。
就是这些了。希望这篇文章有用。还有更多好东西。敬请期待！
干杯!
---
via: <https://www.ostechnix.com/dbxfs-mount-dropbox-folder-locally-as-virtual-file-system-in-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
下载 Linux 游戏的最佳网站
|
Munif Tanjim
|
https://itsfoss.com/download-linux-games/
|
新接触 Linux 游戏并想知道从哪里来 下载 Linux 游戏？我们列出了最好的资源，在这里你既能 下载免费的 Linux 游戏 ，也能购买优质的 Linux 游戏。
|
/data/attachment/album/201901/03/143700nn81vt4nnvt4tx8v.jpg.thumb.jpg
|
/data/attachment/album/201901/03/143700nn81vt4nnvt4tx8v.jpg
| true | false | true |
robsean
|
wxy
| false |
[
"游戏"
] |
分享
|
{
"viewnum": 11867,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "222.90.70.234",
"message": "非DRM的意味着免费吗,也不是吧?",
"username": "来自陕西西安的 Chrome 70.0|GNU/Linux 用户",
"date": "2019-01-06T18:28:41"
}
] |
[] |
新接触 Linux 游戏并想知道从哪里来 下载 Linux 游戏？我们列出了最好的资源，在这里你既能 下载免费的 Linux 游戏 ，也能购买优质的 Linux 游戏。
| 2019-01-03T14:36:57 | 2019-01-03T14:36:57 | 10,411 |
/article-10411-1.html
|
>
> 新接触 Linux 游戏并想知道从哪里来 下载 Linux 游戏？我们列出了最好的资源，在这里你既能 下载免费的 Linux 游戏 ，也能购买优质的 Linux 游戏。
>
>
>
Linux 和游戏？从前，很难想象这两者走到一起。然而随着时间流逝，很多事情都在变化。到如今，有成千上万在 Linux 上可以玩的游戏，而大公司和独立开发者们正在开发更多的游戏。
[在 Linux 上玩游戏](/article-7316-1.html) 现在已经是现实。今天我们将去看看，你在哪里可以找到 Linux 平台游戏、搜索到你喜欢的游戏。
### 在哪里来下载 Linux 游戏？
首先，看看你的 Linux 发行版的软件中心（如果有的话）。在这里你也能找到大量的游戏。
但是，这不意味着你应该将自己的视野局限于软件中心上。让我们来为你列出一些可以下载 Linux 游戏网站。
#### 1. Steam
如果你是老练的玩家，你应该听过 Steam。如果你还不知道的话，没错，Steam 在 Linux 上也是可用的。Steam 推荐运行在 Ubuntu 上，但是它也能运行在其它主要的发行版上。如果你真的对 Steam 很狂热，这里甚至还有一个玩 Steam 游戏的专用操作系统：[SteamOS](http://store.steampowered.com/steamos/)。我们在上一年 [最佳的 Linux 游戏发行版](https://itsfoss.com/linux-gaming-distributions/) 文章中提及了它。
Steam 有最大的 Linux 游戏商店。当写这篇文章的时候，在 Linux 平台上，确切地说有 3487 款游戏，这真的是很多了。你可以从宽广的类型中寻找游戏。至于 [数字版权管理（DRM）](https://www.wikiwand.com/en/Digital_rights_management)，大多数的 Steam 游戏都有某种 DRM 。
对于使用 Steam ，要么你必须在你的 Linux 系统上安装 [Steam 客户端](http://store.steampowered.com/about/)，要么使用 SteamOS。Steam 的一个优势是，在初始化安装后，对于大多数的游戏，你不需要担心依赖关系和复杂的安装过程。 Steam 客户端将为你做这些繁重的任务。
* [Steam 商店](http://store.steampowered.com/linux)
#### 2. GOG
如果你只对免 DRM 的游戏感兴趣，GOG 收集了相当多的这种游戏。此刻，GOG 在它们的库中有 1978 种免 DRM 游戏。GOG 因它大量收集了免 DRM 游戏而闻名。
GOG 游戏官方支持 Ubuntu LTS 版本和 Linux Mint。所以，Ubuntu 和它的衍生版在安装它们时将没有问题。在其他发行版上安装它们时可能需要一些额外的工作，例如，你需要安装正确的依赖关系。
从 GOG 中下载游戏，你不需要额外的客户端。所有购买的游戏都可在你的账户区内找到。你可以使用你最爱的下载管理器直接下载它们。
* [GOG 商店](https://www.gog.com/games?system=lin_mint,lin_ubuntu)
#### 3. Humble 商店
Humble 商店是另一个你可以查找各种各样 Linux 游戏的地方。在 Humble 商店中有免 DRM 和非免 DRM 的游戏。非免 DRM 游戏通常来自 Steam。在 Humble 商店中，当前有超过 1826 款 Linux 游戏。
Humble 商店因另一个原因而著名。它们有一个被称为 [Humble 独立包](https://www.humblebundle.com/?partner=itsfoss)的活动，其中打包提供了一批游戏，带有令人不可抗拒的限时优惠。关于 Humble 的另一件事是，当你购买时，你的购买金额的 10% 将捐给慈善机构。
Humble 不需要额外的客户端来下载它们的游戏。
* [Humble 商店](https://www.humblebundle.com/store?partner=itsfoss)
#### 4. itch.io 商店
itch.io 是给独立数字创作者的一个开放市场，其致力于独立视频游戏。itch.io 有一些你能找到的最有趣、最独特的游戏。在 itch.io 的大多数游戏是免 DRM 的。
现今，itch.io 在它的商店中有 9514 款 Linux 平台的游戏。
itch.io 有它自己的 [客户端](https://itch.io/app)，可以轻松地下载、安装、更新和玩它们的游戏。
* [itch.io 商店](https://itch.io/games/platform-linux)
#### 5. LGDB
LGDB 是 <ruby> Linux 游戏数据库 <rt> Linux Game DataBase </rt></ruby>的缩写。虽然从技术上说它不是一个游戏商店，它收集有大量的 Linux 游戏，以及关于它们的各种各样的信息。每一款游戏都有你可以在哪里找到它们的链接。
如今，在该数据库中有 2046 款游戏。它们也有很长的关于 [模拟器](https://lgdb.org/emulators)、[工具](https://lgdb.org/tools) 和 [游戏引擎](https://lgdb.org/engines) 的列表。
* [LGDB](https://lgdb.org/games)
#### 6. Game Jolt 商店
Game Jolt 有一个非常可观的集合，在它的库藏中大约有 5000 个 Linux 独立游戏。
Game Jolt 有一个（预览版）[客户端](http://gamejolt.com/client)，可用于轻松地下载、安装、更新和玩游戏。
* [Game Jolt 商店](http://gamejolt.com/games/best?os=linux)
### 其他
有很多其他的销售 Linux 游戏的商店。也有很多你能找到免费游戏的地方。这是它们中的两个：
* [Bundle Stars](https://www.bundlestars.com/en/games?page=1&platforms=Linux)：当前有 814 个 Linux 游戏和 31 个游戏包。
* [GamersGate](https://www.gamersgate.com/games?state=available)：现在有 595 个 Linux 游戏。既有免 DRM 的，也有非免 DRM 的。
#### 应用商店、软件中心 & 软件库
Linux 发行版有它们自己的应用商店或软件库。尽管不是很多，但是在这里你也能找到各种各样的游戏。
今天到此为止。你知道这里有这么多 Linux 上可玩的游戏吗？你使用一些其他的网站来下载 Linux 游戏吗？与我们分享你的收藏。
---
via: <https://itsfoss.com/download-linux-games/>
作者：[Munif Tanjim](https://itsfoss.com/author/munif/) 译者：[robsean](https://github.com/robsean) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
在 Linux 终端上观看 YouTube 视频
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-youtube-dl
|
视频只能在 GUI 下看么？再想想。
|
/data/attachment/album/201901/04/094842dm9jhmg99meolcqm.png.thumb.jpg
|
/data/attachment/album/201901/04/094842dm9jhmg99meolcqm.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"终端",
"视频"
] |
分享
|
{
"viewnum": 9196,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
视频只能在 GUI 下看么？再想想。
| 2019-01-04T09:48:37 | 2019-01-04T09:48:37 | 10,412 |
/article-10412-1.html
|
>
> 视频只能在 GUI 下看么？再想想。
>
>
>
我们即将结束为期 24 天的 Linux 命令行玩具日历。希望你一直在看，如果没有，请回到[这里](https://opensource.com/article/18/12/linux-toy-boxes)开始，自己试试。你会发现 Linux 终端有很多游戏，消遣和奇怪的东西。
虽然你之前可能已经看过我们日历中的一些玩具，但我们希望对每个人至少有一个新事物。
今天我们要在昨天的玩具 [MPlayer](/article-10393-1.html) 上再加上一个 [youtube-dl](https://rg3.github.io/youtube-dl/)。
正如其名称所暗示的那样，`youtube-dl` 是一个用于下载 YouTube 视频的命令行程序，但它也可以从其他许多站点下载视频，而且它是一个有着[丰富文档](https://github.com/rg3/youtube-dl/blob/master/README.md#readme)的功能齐全的程序，从而使视频获取变得容易。注意：请勿在任何违反你所在司法辖区的版权法的情况下使用 `youtube-dl`。
`youtube-dl` 使用的是 [Unlicense](https://unlicense.org/) 这个公共领域许可，类似于 Creative Common 的 [CC0](https://creativecommons.org/share-your-work/public-domain/cc0/)。这里还有哪些公共领域贡献适用于开源领域的[法律意见](https://opensource.org/faq#public-domain)，但它通常被认为与现有的开源许可证兼容，即使是不推荐使用它的组织也是如此。
最简单地，我们将使用 `youtube-dl` 来获取视频以便在终端中播放。首先，使用适用于你发行版的方法[安装](https://github.com/rg3/youtube-dl/blob/master/README.md#installation)它。对我来说，在 Fedora 中，它被打包在我的仓库中，因此安装非常简单：
```
$ sudo dnf install youtube-dl
```
然后，获取一个视频。YouTube 允许你按照许可证进行搜索，所以今天我们将根据知识共享署名许可证查看来自 [Gemmy’s Videos](https://www.youtube.com/channel/UCwwaepmpWZVDd605MIRC20A) 中的壁炉[视频](https://www.youtube.com/watch?v=pec8P5K4s8c)。对于 YouTube 视频，你可以像这样用文件 ID 下载，我们也可以指定输出文件名。我故意选择了一个短片，因为长视频会变得很大！
```
$ youtube-dl pec8P5K4s8c -o fireplace.mp4
```
如果你昨天没有安装 [MPlayer](/article-10393-1.html)，请继续安装好，如果你之前没有安装 libcaca 则需要安装它。如果你直接用 MPlayer 在命令行中播放视频 ( `$ mplayer fireplace.webm` )，它能够播放，但是会在一个自己的窗口中，这不是我们想要的。
首先，我设置将 libcaca 强制使用 ncurses 作为显示驱动，使输出保持在我的终端：
```
$ export CACA_DRIVER=ncurses
```
然后，我放大了终端（“像素”越多越好），并使用以下命令播放文件（强制使用 libcaca 并静默 MPlayer 的文本输出）：
```
$ mplayer -really-quiet -vo caca fireplace.mp4
```
这就完成了！
你有特别喜欢的命令行小玩具需要我介绍的吗？提交今年的建议有点晚了，但我们仍然希望在新的一年里有一些很酷的命令行玩具。请在下面的评论中告诉我，我会查看的。让我知道你对今天的玩具有何看法。
一定要看看昨天的玩具，[在 Linux 终端收听广播](/article-10393-1.html)，明天还要再来！
---
via: <https://opensource.com/article/18/12/linux-toy-youtube-dl>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 Xfce Linux 桌面环境的 8 个理由
|
David Both
|
https://opensource.com/article/18/6/xfce-desktop
|
整体上很优雅的 Xfce 桌面所具备的足够轻巧和快速的特性能够让它很容易都知道如何做好一件事。
|
/data/attachment/album/201901/04/224757c2dxwzkaw2ue5jwc.png.thumb.jpg
|
/data/attachment/album/201901/04/224757c2dxwzkaw2ue5jwc.png
| true | false | true |
lujun9972
|
WangYueScream
|
wxy
| false |
[
"桌面",
"Xfce"
] |
观点
|
{
"viewnum": 23859,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "112.87.14.12",
"message": "身轻体柔性能强！尤其喜欢xfce4-terminal，不管DE怎么换终端总是她",
"username": "来自江苏淮安的 Firefox 64.0|Fedora 用户",
"date": "2019-01-06T09:57:40"
},
{
"postip": "106.42.94.75",
"message": "其实我以前一直使用xubuntu，后来换了双显示器。xubuntu不支持使用热键把应用程序窗口在显示器之间移动，必须使用鼠标拖动。就是因此放弃了Xfce。",
"username": "来自河南的 Android Browser|Android 用户",
"date": "2019-01-06T21:24:56"
},
{
"postip": "111.60.22.130",
"message": "mate-terminal第一",
"username": "来自111.60.22.130的 Firefox 108.0|GNU/Linux 用户",
"date": "2022-12-21T10:31:37"
}
] |
[] |
整体上很优雅的 Xfce 桌面所具备的足够轻巧和快速的特性能够让它很容易都知道如何做好一件事。
| 2019-01-04T22:48:00 | 2019-01-04T22:48:00 | 10,413 |
/article-10413-1.html
|
>
> 整体上很优雅的 Xfce 桌面所具备的足够轻巧和快速的特性能够让它很容易都知道如何做好一件事。
>
>
>
由于某些原因（也包括好奇），几周前我开始使用 [Xfce](https://xfce.org/) 作为我的 Linux 桌面。促使我更换 Linux 桌面环境的原因之一是桌面相关的守护进程占据了我的性能非常强大的主工作站的绝大部分 CPU 资源和 I/O 带宽。当然，有些不稳定性可能是因为我删除了提供这些守护进程的 RPM 包。然而，事实是在我删除这些 RPM 包之前，KDE 就已经很不稳定了而且还导致了一系列其他方面的性能和稳定性问题。所以我需要换一个桌面来避免这些问题。
在回顾了我为 Linux 桌面所写的一系列文章后我才意识到我忽略了 Xfce。这篇文章也是力图能够纠正弥补这个疏忽。我非常喜欢 Xfce 也很享受它所带给我超乎预期的快速、轻量的体验。
作为研究的一部分，我有尝试过在 Google 上查询 Xfce 对应什么意思。有个历史参考是它对应着 “XForms Common Environment”，但 Xfce 早已不在使用 XForms 工具。几年前，我找到另一个参考是 “Xtra fine computing environment” 而且我也很喜欢这个解释。我将会用它作为 Xfce 的全称（尽管再也找不到这个参考页面）。
### 推荐 Xfce 的 8 个理由
#### 1、轻量级架构
Xfce 相对于其他的桌面如 KDE 和 GNOME，不管是内存还是 CPU 的占用率都非常小。在我的系统中，组成 Xfce 桌面的程序仅占用了少量内存就构成一个如此强大的桌面。超低的 CPU 占用率也是 Xfce 桌面的一个特点。了解到 Xfce 内存占用特别低后，我对它的 CPU 占用率也非常低这个特性自然而言也就不感到奇怪了。
#### 2、简洁
Xfce 桌面很简单，就像绒毛整洁的动物让人一目了然、赏心悦目。基础的桌面有两个面板和一条在左边垂直的图标行。面板 0 在底部，并由一些基础的应用启动程序和能访问到系统里对应程序的图标组成。面板 1 在顶部，由一个应用程序启动器和一个能够允许用户在多个工作区之间来回切换的工作区切换器组成。面板可以通过补充项自定义修改，比如增加个新的应用启动器或者更改它们的宽高。
桌面左侧的图标对应是家目录和垃圾桶。它也可以显示其他的图标，如完整的文件系统目录树和已连接上系统的可插拔的任意 USB 存储设备。这些图标可以用来挂载和卸载设备，也可以用来打开默认的文件管理器。如果你愿意，它们都可以被隐藏，同时文件系统、垃圾箱、家目录对应的图标都可以逐个控制管理。所有的可移动设备也可以被隐藏或作为一个组显示。
#### 3、文件管理
作为 Xfce 的默认文件管理器 Thunar，它很简单，既易于使用和配置也非常容易学习。尽管它并不像其他的文件管理器比如 Konqueror 或者 Dolphin 那样效果华丽，但它很强大也很快。Thunar 并不能在一个窗口里面打开多个面板，但它提供了选项卡来支持多个目录的同时打开。Thunar 也有一个非常漂亮的侧边栏，其上同样的图标就像桌面那样能够显示完整的文件系统目录树和所有已连接的 USB 存储设备。设备能够被挂载和卸载，可移动媒介如 CD 也能够被弹出。Thunar 也可以使用类似 Ark 这种帮助软件来在你点击归档文件的时候打开它们。比如 ZIP、TAR、RPM 这种归档文件都可以被浏览也可以从中复制单个文件。
*Xfce 桌面及 Thunar 和 Xfce 下的终端模拟器。*
在我的[文件管理器系列](https://opensource.com/sitewide-search?search_api_views_fulltext=David%20Both%20File%20managers)文章中，我已经使用体验过很多不同的文件管理器软件，我不得不说 Thunar 的简单易用让你无法不喜欢上它。它可以让你通过使用侧边栏来很容易地浏览文件系统。
#### 4、稳定
Xfce 桌面非常稳定。新版本的发布周期似乎是三年，但也会根据需要发布相关更新。最新的版本是于 2015 年 2 月发布的 4.12。在使用 KDE 遇到一系列问题后，稳如磐石的 Xfce 桌面环境显得让人格外放心。在我使用 Xfce 的过程中，它从来没有崩溃过，也不会产生额外的守护进程占据过多的系统资源。这正是我想要的：它安安静静地工作，不会给你带来额外的困扰。
#### 5、优雅
Xfce 简单优雅。在我的今年秋天将面世的新书《系统管理员的 Linux 哲学》中我谈到了关于简单的一系列好处，包括简单事实上也是优雅的诸多标志之一。很明确能够确定的就是 Xfce 及相关组件程序的开发者和维护者也是极力推崇简单至上。这种简单特性很可能也是 Xfce 如此稳定的主要原因，但它也给用户带来了一个整洁的桌面外观，一个反应灵敏的操作界面，一个会让人感觉很自然也很易用的导航结构，而且 Xfce 整体上的优雅特性也会让用户的使用过程中充满愉悦感。
#### 6、终端仿真程序
Xfce4 的终端仿真程序非常强大，而且和其他很多终端仿真程序一样可以允许你使用多个选项卡来让多个终端在一个单独窗口里共存。尽管它与 Tilix、Terminator、Konsole 这种终端仿真程序比起来相对简陋，但它也能很好的完成工作。选项卡的名字可以更改，而且选项卡也可以通过拖放或者工具栏的箭头图标或者菜单栏的选项重新排列。我特别喜欢 Xfce 的终端仿真程序的一点就是不管你连接了多少主机，相对应的选项卡都会显示对应的主机名，比如，从 host1=>host2=>host3=>host4，会准确地在选项卡显示了 “host4”。但其他的终端仿真程序最多也就显示 “host2”。
至于这个终端仿真程序功能和外观的其他方面都可以根据你的需要很容易配置成你想要的。当然同 Xfce 的其他组件一样，这款终端仿真程序占用了系统资源的很少一部分。
#### 7、可配置性
Xfce 能够配置的范围极大。虽然 Xfce 桌面的可配置性比不上 KDE，但依旧远超 GNOME，而且比它更容易配置。比如，我发现设置管理器是 Xfce 配置一切的入口。虽然每个配置程序都可以单独使用，但是设置管理器把他们都放在一个窗口里以便快速访问。关于 Xfce 桌面很多重要的部分都可以通过配置来满足我的需求。
#### 8、模块化
Xfce 是由一系列单个的项目组成的整体，而且在你的 Linux 桌面发行版中也未必安装了 Xfce 的所有组件。[Xfce 项目](https://xfce.org/projects) 的主页列出了主要的项目，所以你可以根据需要安装你想安装的附加组件。比如在我的 Fedora 28 workstation 版本上我安装的 Xfce 组时就没有 [Xfce 项目](https://xfce.org/projects) 主页最下面的说明的一些程序。
这里还有个关于 Xfce 的 [文档页面](https://docs.xfce.org/) 和 一个被称为 [Xfce 超值项目](https://goodies.xfce.org/) 的 wiki 列举了其他的 Xfce 相关的项目，它们为 Xfce 的面板及 Thunar 提供了很多不错的应用程序、精美的插图、好用的插件。
### 总结
整体上很优雅的 Xfce 桌面所具备的足够轻巧和快速的特性能够让它很容易都知道如何做好一件事。它的轻量级的结构也节省了大量的 CPU 和内存资源。这也使得 Xfce 非常适合那种由于硬件有限而无法分配给桌面太多资源的旧主机。然而，Xfce 又是足够的灵活和强大的，能够满足高级用户的需要。
我知道，更换到一个新的 Linux 桌面环境需要你自己按照你想要的做些对应的自定义设置：比如面板上显示你最爱用的程序对应的启动器，设置下你最喜欢的桌面背景壁纸等一系列工作。这些年来我已经在切换到新桌面环境或更新旧桌面环境折腾很多次了。这需要时间也需要耐心。
我觉得切换 Linux 的桌面环境就像我在工作中换个办公工位或者办公室一样。别人把我的东西装箱从旧办公室搬到新办公室，然后我在我的新办公室里组装连接好我的电脑，打开箱子再把里面的东西放在合适的位置。而切换到 Xfce 桌面大概就是我做过的最简单省事容易的桌面环境更换了。
---
via: <https://opensource.com/article/18/6/xfce-desktop>
作者：[David Both](https://opensource.com/users/dboth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[WangYueScream](https://github.com/WangYueScream) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
McFly：利用神经网络为 Bash 提供历史命令搜索功能
|
Sk
|
https://www.ostechnix.com/mcfly-a-replacement-to-ctrlr-bash-history-search-feature/
|
McFly 是一个使用 Rust 编程语言写就的简洁工具，自带一个智能的搜索引擎，用来替换默认的 Ctrl+r 这个 Bash 历史命令搜索功能。 McFly 提供的命令建议都是通过一个小巧的 神经网络 来实时排序给出的。
|
/data/attachment/album/201901/04/232508t98p95pyp5ww2h9w.png.thumb.jpg
|
/data/attachment/album/201901/04/232508t98p95pyp5ww2h9w.png
| true | false | true |
lujun9972
|
FSSlc
|
wxy
| false |
[
"McFly",
"命令历史"
] |
分享
|
{
"viewnum": 4927,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
McFly 是一个使用 Rust 编程语言写就的简洁工具，自带一个智能的搜索引擎，用来替换默认的 Ctrl+r 这个 Bash 历史命令搜索功能。 McFly 提供的命令建议都是通过一个小巧的 神经网络 来实时排序给出的。
| 2019-01-04T23:25:03 | 2019-01-04T23:25:03 | 10,414 |
/article-10414-1.html
|
假如你在命令行模式下渡过了很长时间，那么你必定使用过或者听说过 BASH 的 **反向搜索** 功能，在 Bash 中执行反向搜索功能的快捷键是 `Ctrl+r`。通过使用这个特性，我们可以找到我们执行过的命令而无需再次输入它们。当然，你可以使用上下键来搜索你的 bash 命令记录，但使用 `Ctrl+r` 快捷键可以让这个搜索过程更简单快速。今天我找寻到了 Bash 历史命令搜索特性 `Ctrl+r` 的一个替代品，它就是 McFly。McFly 是一个使用 Rust 编程语言写就的简洁工具，自带一个智能的搜索引擎，用来替换默认的 `Ctrl+r` 这个 Bash 历史命令搜索功能。 McFly 提供的命令建议都是通过一个小巧的 **神经网络** 来实时排序给出的。
McFly 重新绑定了 `Ctrl+r` 快捷键，可以从你的 Bash 历史命令中找到所有最近执行过的命令。它通过追溯下面的信息来增强你的 shell 历史命令搜索特性：
* 命令结束状态
* 当你运行命令时的时间戳
* 以及你运行命令的执行目录
它将所有追溯的信息保存在一个 SQLite 数据库中。由于它追溯了命令的历史结束状态，所以你可以很轻易地忽略掉失败的命令。听起来很酷，对吧？
在给出一个命令建议时，它将考虑如下因素：
* 你在哪个目录执行的这个命令，将来你很有可能在相同的目录重复这个命令
* 在你执行这个命令之前，执行过什么命令
* 你执行这个命令有多频繁
* 你最后执行该命令的时间
* 你是否在 McFly 中选择过这个命令
* 以及这个命令的历史结束状态。因为你很有可能不会去执行失败过的命令，对吧？
McFly 维护着你的默认 Bash 历史文件，所以你可以随时停止使用它。McFly 也并不只服务于 BASH， 它也可以扩展到其他 shell 程序。
### 安装 McFly
在 Linux 中，McFly 可以使用 Linuxbrew 来安装。如若你还没有安装过 Linuxbrew，那么你可以参考下面的这个链接。（LCTT 译注：从其 [GitHub 主页](https://github.com/cantino/mcfly)了解到也可以下载其二进制来使用。）
* [Linuxbrew：一个用于 Linux 和 Mac OS X 的通用包管理](https://www.ostechnix.com/linuxbrew-common-package-manager-linux-mac-os-x/)
一旦安装好了 Linuxbrew，运行下面的命令来安装 McFly：
```
$ brew tap cantino/mcfly https://github.com/cantino/mcfly
$ brew install mcfly
```
在安装完成后，你将看到下面的输出：
```
==> Installing mcfly from cantino/mcfly
==> Downloading https://github.com/cantino/mcfly/releases/download/v0.2.5/mcfly-v0
==> Downloading from https://github-production-release-asset-2e65be.s3.amazonaws.c
######################################################################## 100.0%
==> ONE MORE STEP! Edit ~/.bashrc and add the following:
if [ -f $(brew --prefix)/opt/mcfly/mcfly.bash ]; then
. $(brew --prefix)/opt/mcfly/mcfly.bash
fi
/home/linuxbrew/.linuxbrew/Cellar/mcfly/v0.2.5: 4 files, 3.5MB, built in 33 seconds
```
正如你上面看到的那样，在使用 McFly 之前我们需要再做一些配置。
将下面几行添加到你的 `~/.bashrc` 文件中：
```
if [ -f $(brew --prefix)/opt/mcfly/mcfly.bash ]; then
. $(brew --prefix)/opt/mcfly/mcfly.bash
fi
```
最后，再运行下面的命令来让更改生效。
```
$ source ~/.bashrc
```
当你第一次执行上面的这个命令时，你的 BASH 历史将会被导入 McFly 的数据库。依据你的 bash 历史文件的大小，这个过程将花费一些时间。一旦导入完成，你讲看到下面的提示信息。
```
McFly: Importing Bash history for the first time. This may take a minute or two...done.
```
现在你就可以使用 McFly 了。
### 使用方法
要在你的命令历史中执行搜索，只需要键入 `mcfly search` 再加上命令名的一部分，最后敲击回车键即可。Mcfly 将会基于你刚才键入的搜索查询语句给出命令建议。
```
$ mcfly search <part-of-the-command>
```
例如我键入了下面的命令：
```
$ mcfly search mk
```
下面展示的是我 Ubuntu 机子上的示例输出：
如你所见，我已经使用过 `mkdir` 这个命令两次。假如你想从这些命令建议中执行其中之一，只需使用上下键来选择它，然后敲击**回车键**来执行它就可以了。假如你想编辑其中一个命令，则需要先选择它，然后敲 `TAB` 键将这个命令放置到终端中，最后在运行它之前更改它就行了。要从历史中删除已经选择的命令，按 `F2` 即可。
或者，输入下面的命令来打开历史搜索，然后输入任意一个命令或者命令的一部分来从你的历史命令中查看它提供的建议。
```
$ mcfly search
```
在你输入的同时， McFly 将会展示命令的提示。
下面是一个介绍 McFly 的简短演示视频：
你还可以使用下面的命令来查看帮助：
```
$ mcfly --help
```
### 移除 McFly
不喜欢 McFly，没问题！可以使用下面的命令来移除它：
```
$ brew uninstall mcfly
$ brew untap cantino/mcfly
```
最后，移除先前添加到 `~/.bashrc` 文件中的几行命令。
好了，这些就是所有了，更多精彩内容敬请期待，请保存关注！
干杯！
---
via: <https://www.ostechnix.com/mcfly-a-replacement-to-ctrlr-bash-history-search-feature/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[FSSlc](https://github.com/FSSlc) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用 PGP 保护代码完整性（五）：将子密钥移到一个硬件设备中
|
Konstantin Ryabitsev
|
https://www.linux.com/blog/learn/pgp/2018/3/protecting-code-integrity-pgp-part-5-moving-subkeys-hardware-device
|
在这个系列教程中，将为你提供使用 PGP 和保护你的私钥的最佳体验。
|
/data/attachment/album/201901/05/001540guuubwk558wvc8sx.jpg.thumb.jpg
|
/data/attachment/album/201901/05/001540guuubwk558wvc8sx.jpg
| true | false | true |
qhwdw
|
wxy
| false |
[
"PGP"
] |
技术
|
{
"viewnum": 8097,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10402,
"displayorder": 0
},
{
"raid": 10421,
"displayorder": 0
}
] |
在这个系列教程中，将为你提供使用 PGP 和保护你的私钥的最佳体验。
| 2019-01-05T00:15:36 | 2019-01-05T00:15:36 | 10,415 |
/article-10415-1.html
|
>
> 在这个系列教程中，将为你提供使用 PGP 和保护你的私钥的最佳体验。
>
>
>
在本系列教程中，我们将提供一个使用 PGP 的实用指南。如果你没有看过前面的文章，你可以通过下面的链接去查看。在这篇文章中，我们将继续讨论如何保护你的密钥，谈一谈将你的子密钥移到一个专门的硬件设备中的一些技巧。
* [第一部分：基本概念和工具](/article-9524-1.html)
* [第二部分：生成你的主密钥](/article-9529-1.html)
* [第三部分：生成 PGP 子密钥](/article-9607-1.html)
* [第四部分：将主密钥移到离线存储中](/article-10402-1.html)
#### 清单
* 取得一个 GnuPG 兼容的硬件设备（必要）
* 配置 GnuPG 在设备上工作（必要）
* 设置用户和管理员的 PIN（必要）
* 移动子密钥到设备中（必要）
#### 考虑事项
虽然现在主密钥已经不用担心泄露或失窃了，但子密钥仍然在你的家目录中。任何得到它的人都能够解密你的通讯或假冒你的签名（如果他们知道密钥的密码）。并且，每次执行一个 GnuPG 操作都要将密钥加载到操作系统内存中，这将使一些更高级的恶意软件有机会得到你的密钥（想想 Meltdown 和 Spectre）。
完全保护密钥的最好方式就是，将它移到一个专门的硬件设备中，这种硬件设备是一个可操作的智能卡。
##### 智能卡的好处
一个智能卡包含一个加密芯片，它能够存储私钥，并且直接在智能卡内部执行秘密操作。因为密钥内容从来没有离开过智能卡，计算机操作系统并不能检索你插入的智能卡上的私钥。这与前面用于备份目的的加密 USB 存储是不同的 —— 虽然 USB 设备也是插入并解密的，但操作系统是能够去访问私钥内容的。使用外置的加密 USB 介质并不能代替智能卡设备的功能。
智能卡的一些其它好处：
* 它们很便宜且易于获得
* 它们小巧且易于携带
* 它们可以用于多种设备上
* 它们中的很多都具有防篡改功能（取决于制造商）
#### 可用的智能卡设备
智能卡最初是嵌入到真实钱包大小的卡中，故而得名智能卡。你肯定可以买到并使用 GnuPG 功能的智能卡，并且它们是你能得到的最便宜的可用设备之一。但是，事实上智能卡有一个很重要的缺点：它们需要一个智能卡读卡器，只有极小数的笔记本电脑上有这种读卡器。
由于这个原因，制造商开始推出小型 USB 设备，它的大小和 U 盘类似，内置有微型智能卡，并且在芯片上简单地实现了智能卡协议特性。下面推荐几个这样的设备：
* [Nitrokey Start](https://shop.nitrokey.com/shop/product/nitrokey-start-6)：开源硬件和自由软件，可用于 GnuPG 的最便宜的选择之一，但是额外的安全特性很少。
* [Nitrokey Pro](https://shop.nitrokey.com/shop/product/nitrokey-pro-3)：类似于 Nitrokey Start，它提供防篡改及更多的安全特性（但没有 U2F，具体查看指南的 U2F 节）。
* [Yubikey 4](https://www.yubico.com/product/yubikey-4-series/)：专利硬件和软件，但比 Nitrokey Pro 便宜，并且可以用在最新的笔记本电脑上的 USB-C 接口；也提供像 U2F 这样的额外的安全特性。
我们推荐选一个同时具备智能卡功能和 U2F 的设备，在写这篇文章时，只能选择 Yubikey 4。
#### 配置智能卡设备
你的智能卡设备插入任何一台现代的 Linux 或 Mac 工作站上都应该能正常工作。你可以通过运行如下的命令去验证它：
```
$ gpg --card-status
```
如果你没有收到错误，有一个完整的卡列表，就表示一切正常。不幸的是，排除为什么设备不能正常工作的所有可能原因，已经超出了本指南的范围。如果你的智能卡使用 GnuPG 时有问题，请通过你的操作系统的常见支持通道寻求支持。
##### PIN 不一定是数字
注意，尽管名为 “PIN”（暗示你它必须是一个“数字”），不论是用户 PIN 还是管理员 PIN 都不必非要是数字。
当你收到一个新设备时，它可能设置有一个默认的用户和管理员 PIN，对于 Yubikey，它分别是 `123456` 和 `12345678`。如果它们的 PIN 不是默认的，请查看设备附带的说明书。
##### 快速设置
为配置你的智能卡，你需要使用 GnuPG 菜单系统，因此这里并没有更方便的命令行开关：
```
$ gpg --card-edit
[...omitted...]
gpg/card> admin
Admin commands are allowed
gpg/card> passwd
```
你应该去设置用户 PIN (1)、管理员 PIN (3)、和重置码 (4)。请确保把它们记录并保存到一个安全的地方 —— 尤其是管理员 PIN 和重置码（它允许你去擦除整个智能卡内容）。你很少使用到管理员 PIN，因此如果你不记录下来，很可能会忘掉它。
返回到智能卡主菜单，你也可以设置其它值（比如名字、性别、登入日期、等等），但是这些都不是必需的，一旦你的智能卡丢失了，将导致额外的信息泄露。
#### 将子密钥移到你的智能卡中
退出卡菜单（使用 `q` 命令）保存所有更改。接下来，我们将你的子密钥移到智能卡中。将需要用到你的 PGP 密钥的密码，在大多数的智能卡操作中都将用到管理员 PIN。记住，那个 `[fpr]` 表示你的密钥的完整的 40 个字符的指纹。
```
$ gpg --edit-key [fpr]
Secret subkeys are available.
pub rsa4096/AAAABBBBCCCCDDDD
created: 2017-12-07 expires: 2019-12-07 usage: C
trust: ultimate validity: ultimate
ssb rsa2048/1111222233334444
created: 2017-12-07 expires: never usage: E
ssb rsa2048/5555666677778888
created: 2017-12-07 expires: never usage: S
[ultimate] (1). Alice Engineer <alice@example.org>
[ultimate] (2) Alice Engineer <allie@example.net>
gpg>
```
使用 `--edit-key` 再次进入到菜单模式，你将注意到那个密钥清单有一点小差别。从现在开始，所有的命令都是在这个菜单模式下运行，它用 `gpg>` 提示符来表示。
首先，我们来选择移到智能卡中的密钥 —— 你可以通过键入 `key 1`（它表示选择清单中的第一个密钥）来实现：
```
gpg> key 1
```
这个输出会有一点细微的差别：
```
pub rsa4096/AAAABBBBCCCCDDDD
created: 2017-12-07 expires: 2019-12-07 usage: C
trust: ultimate validity: ultimate
ssb* rsa2048/1111222233334444
created: 2017-12-07 expires: never usage: E
ssb rsa2048/5555666677778888
created: 2017-12-07 expires: never usage: S
[ultimate] (1). Alice Engineer <alice@example.org>
[ultimate] (2) Alice Engineer <allie@example.net>
```
注意与密钥对应的 `ssb` 行旁边的 `*` —— 它表示这是当前选定的密钥。它是可切换的，意味着如果你再次输入 `key 1`，这个 `*` 将消失，这个密钥将不再被选中。
现在，我们来将密钥移到智能卡中：
```
gpg> keytocard
Please select where to store the key:
(2) Encryption key
Your selection? 2
```
由于它是我们的 [E] 密钥，把它移到加密区中是有很有意义的。当你提交了你的选择之后，将会被提示输入你的 PGP 密钥的保护密码，接下来输入智能卡的管理员 PIN。如果命令没有返回错误，表示你的密钥已经被移到智能卡中了。
**重要：** 现在再次输入 `key 1` 去取消选中第一个密钥，并输入 `key 2` 去选择 [S] 密钥：
```
gpg> key 1
gpg> key 2
gpg> keytocard
Please select where to store the key:
(1) Signature key
(3) Authentication key
Your selection? 1
```
你可以使用 [S] 密钥同时做签名和验证，但是我们希望确保它在签名区，因此，我们选择 (`1`)。完成后，如果你的命令没有返回错误，表示操作已成功。
最后，如果你创建了一个 [A](https://www.linux.com/users/mricon) 密钥，你也可以将它移到智能卡中，但是你需要先取消选中 `key 2`。完成后，选择 `q`：
```
gpg> q
Save changes? (y/N) y
```
保存变更将把你的子密钥移到智能卡后，把你的家目录中的相应子密钥删除（没有关系，因为我们的备份中还有，如果更换了智能卡，你需要再做一遍）。
##### 验证移动后的密钥
现在，如果你执行一个`--list-secret-keys` 操作，你将看到一个稍有不同的输出：
```
$ gpg --list-secret-keys
sec# rsa4096 2017-12-06 [C] [expires: 2019-12-06]
111122223333444455556666AAAABBBBCCCCDDDD
uid [ultimate] Alice Engineer <alice@example.org>
uid [ultimate] Alice Engineer <allie@example.net>
ssb> rsa2048 2017-12-06 [E]
ssb> rsa2048 2017-12-06 [S]
```
在 `ssb>` 的输出中的 `>` 表示子密钥仅在智能卡上有效。如果你进入到你的密钥目录中，查看目录的内容，你将会看到那个 `.key` 文件已经被存根替换：
```
$ cd ~/.gnupg/private-keys-v1.d
$ strings *.key
```
这个输出将包含一个影子私钥，它表示那个文件仅是个存根，真正的内容在智能卡中。
#### 验证智能卡的功能
验证智能卡能否如期正常运行，你可以通过创建一个签名来验证：
```
$ echo "Hello world" | gpg --clearsign > /tmp/test.asc
$ gpg --verify /tmp/test.asc
```
首次运行这个命令时将询问你智能卡的 PIN，在你运行 `gpg —verify` 之后，它将显示 “Good signature”。
祝贺你，你已经成功将窃取你的开发者数字身份变得更加困难了！
#### 其它常见 GnuPG 操作
下面是使用你的 PGP 密钥需要做的一些常见操作的快速指南。
在下面的所有命令中，`[fpr]` 表示你的密钥指纹。
##### 挂载主密钥离线存储
下面的一些操作将需要你的主密钥，因此首先需要去挂载你的主密钥离线存储，并告诉 GnuPG 去使用它。首先，找出介质挂载路径，可以通过查看 `mount` 命令的输出找到它。接着，设置你的 GnuPG 目录为你的介质上备份的目录，并告诉 GnuPG 将那个目录做为它的家目录：
```
$ export GNUPGHOME=/media/disk/name/gnupg-backup
$ gpg --list-secret-keys
```
确保你在输出中看到的是 `sec` 而不是 `sec#`（这个 `#` 表示密钥不可用，仍然使用的是惯常的那个 Home 目录）。
##### 更新你惯常使用的那个 GnuPG 工作目录
在你的离线存储上做了任何更改之后，你应该将这些更改同步应用到你惯常使用的工作目录中：
```
$ gpg --export | gpg --homedir ~/.gnupg --import
$ unset GNUPGHOME
```
##### 延长密钥过期日期
我们创建的主密钥的默认过期日期是自创建之日起两年后。这样做都是为安全考虑，这样将使淘汰密钥最终从密钥服务器上消失。
延长你的密钥过期日期，从当前日期延长一年，只需要运行如下命令：
```
$ gpg --quick-set-expire [fpr] 1y
```
如果为了好记住，你也可以使用一个特定日期（比如，你的生日、1 月 1 日、或加拿大国庆日）：
```
$ gpg --quick-set-expire [fpr] 2020-07-01
```
记得将更新后的密钥发送到密钥服务器：
```
$ gpg --send-key [fpr]
```
##### 吊销身份
如果你需要吊销一个身份（比如，你换了雇主并且旧的邮件地址不再有效了），你可以使用一行命令搞定：
```
$ gpg --quick-revoke-uid [fpr] 'Alice Engineer <aengineer@example.net>'
```
你也可以通过使用 `gpg --edit-key [fpr]` 在菜单模式下完成同样的事情。
完成后，记得将更新后的密钥发送到密钥服务器上：
```
$ gpg --send-key [fpr]
```
下一篇文章中，我们将谈谈 Git 如何支持 PGP 的多级别集成。
通过来自 Linux 基金会和 edX 的免费课程 [“Linux 入门”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)学习更多 Linux 知识。
---
via: <https://www.linux.com/blog/learn/pgp/2018/3/protecting-code-integrity-pgp-part-5-moving-subkeys-hardware-device>
作者：[KONSTANTIN RYABITSEV](https://www.linux.com/users/mricon) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
让 Linux 终端说出它的想法
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-espeak
|
eSpeak 是一个可在 Linux 命令行中使用的开源的 TTS 合成器。
|
/data/attachment/album/201901/05/154129z41mh4s61bf6q0bt.png.thumb.jpg
|
/data/attachment/album/201901/05/154129z41mh4s61bf6q0bt.png
| true | false | true |
lujun9972
|
zhs852
|
wxy
| false |
[
"TTS",
"语音"
] |
分享
|
{
"viewnum": 4481,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
eSpeak 是一个可在 Linux 命令行中使用的开源的 TTS 合成器。
| 2019-01-05T15:41:26 | 2019-01-05T15:41:26 | 10,416 |
/article-10416-1.html
|
>
> eSpeak 是一个可在 Linux 命令行中使用的开源的 TTS 合成器。
>
>
>
欢迎回到《24 天介绍 Linux 命令行小玩具》。如果这是你首次阅读本系列文章，你可能不知道什么是 Linux 命令行小玩具。无需担心，你只需要边看边体会。通常来说，它有可能是游戏或其它能让你在终端中娱乐的小程序。
或许你已经对一些玩具有了解了，不过我们相信，在本系列文章中总有那么几个你没见过的玩意。
年轻读者可能不知道，在 Alexa、Siri 或 Google Assistant 问世之前，计算机就能说话了。
我们也许永远不会忘记来自 [2001 太空漫游](https://en.wikipedia.org/wiki/2001:_A_Space_Odyssey_(film)) 中与机组人员交流的 HAL 9000。但是在 1960 年代到今天的时间里，是存在着许多能说话的计算机的。它们有些很出色，也有些不那么出色。
其中一个我最爱的是一个叫做 [eSpeak](http://espeak.sourceforge.net/) 的开源项目。它以多种形式发布，比如可以嵌入你自己项目中的库。与此同时，它也提供了可供你安装的命令行版本。在我所用的发行版中，安装十分简单，只需使用：
```
$ sudo dnf install espeak
```
你既可以与 eSpeak 交互，也可以用它来输出其它程序的信息，甚至通过简单的 `echo` 命令来使用它。[这里](http://espeak.sourceforge.net/voices.html) 有一些可供 eSpeak 使用的声音文件，你可以在无聊时切换他们。甚者你可以制作一个属于你自己的声音。
在 2015 年，一些希望继续 eSpeak 开发的开发者创建了一个名为 eSpeak NG （即 “Next Generation”，“下一代”的意思）的项目。eSpeak 目前在 GPL v3 许可证下开源，你可以在 [SourceForge](http://espeak.sourceforge.net/) 上详细了解这个项目或下载源代码。
别急，我今天还会介绍一个额外的小程序，它叫 [cava](https://github.com/karlstav/cava)。我经常希望用一张独一无二的截图作为我文章的头图，更何况今天的玩具主要是关于声音的，这就图片更少了。因此，我需要一些东西来填补这些空白。Cava 是<ruby> 基于 ALSA 的命令行音频可视化工具 <rt> console-based audio visualizer for ALSA </rt></ruby>的简写（尽管它现在支持的比 ALSA 更多），它是一个优秀的命令行音频可视化工具，并且它正以 MIT 许可证开源。下面是一个将 eSpeak 输出可视化的命令：
```
$ echo "Rudolph, the red-nosed reindeer, had a very shiny nose." | espeak
```
你想让作者介绍你喜欢的命令行玩具吗？请前往原文下留言，作者可能会考虑介绍的。同时，你也可以去原文下评论你对文章的看法。
欢迎去看看我们昨天介绍的玩具，[在 Linux 命令行中使用 nudoku 解决谜题](https://opensource.com/article/18/12/linux-toy-nudoku)。敬请期待我们明天的文章吧！
---
via: <https://opensource.com/article/18/12/linux-toy-espeak>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[zhs852](https://github.com/zhs852) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何用 Gonimo 创建一个免费的婴儿监视系统
|
Robert Klotzner
|
https://opensource.com/article/17/9/gonimo
|
当你可以用两个设备、浏览器和网络连接就能免费搭建一个婴儿监视器时，谁还会花钱去买呢？
|
/data/attachment/album/201901/05/221707g6iiwkkuduntd5ai.jpg.thumb.jpg
|
/data/attachment/album/201901/05/221707g6iiwkkuduntd5ai.jpg
| true | false | true |
lintaov587
|
wxy
| false |
[
"监视器",
"婴儿"
] |
技术
|
{
"viewnum": 4196,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
当你可以用两个设备、浏览器和网络连接就能免费搭建一个婴儿监视器时，谁还会花钱去买呢？
| 2019-01-05T20:31:00 | 2019-01-05T20:31:00 | 10,417 |
/article-10417-1.html
|
>
> 当你可以用两个设备、浏览器和网络连接就能免费搭建一个婴儿监视器时，谁还会花钱去买呢？
>
>
>
新父母和准父母很快就会知道将会有一个既长且昂贵的新生儿所需设备的清单，清单中的首位是一个婴儿监视器，借此他们可以在做其他事情时照看自己的婴儿，但这儿有一件不必消耗你的婴儿经费的设备，Gonimo 是一个可以将现有的设备转换成婴儿监控系统的自由开源解决方案，附近大型婴儿用品商店的过道中有数以千计的其他必备或时尚物品，就可以为其中某一个腾出一些婴儿的预算。
Gonimo 诞生时，它的开发者，一个有双胞胎的开源粉丝，发现现有选择存在问题：
* 现有硬件婴儿监视器价格昂贵，使用范围有限，需要您带着额外的设备。
* 虽然有移动监控应用程序，但大多数现有的 iOS / Android 婴儿监控应用程序都不可靠且不安全，不太容易找到开源产品。
* 如果您有两个小孩（例如双胞胎），您将需要两台监视器，使您的成本翻倍。
Gonimo 是作为一个解决典型的监视器的缺点的开源解决方案而创建的：
* 昂贵？不，它是免费的！
* 使用范围有限？不，它适用于互联网 / WiFi，无论您身在何处。
* 下载并安装应用程序？噢不，它适用于您现有的网络浏览器。
* 购买新设备？不用，你可以使用任何笔记本电脑、手机或平板电脑与网络浏览器和麦克风和/或相机。
（注意：遗憾的是，Apple iOS 设备尚不支持，但预计很快就会发生变化 —— 请继续阅读，了解如何帮实现这一目标。）
### 开始
将您的设备转换为婴儿监视器很容易。从您设备的浏览器（理想情况下为 Chrome），访问 [gonimo.com](https://gonimo.com/) 并单击 “Start baby monitor” 以访问该 Web 应用程序。
1、创建家庭：在首次启动的屏幕上，你会看到一只可爱的兔子在地球上奔跑。这是您创建新家庭的地方。单击 “+” 按钮并接受随机生成的姓氏或键入您自己的选择。
*从开始屏幕创建一个新家庭*
2、邀请设备：建立完家庭以后，下个屏幕将指示您邀请其他设备加入你的 Gonimo 家庭。您可以通过电子邮件直接发送一次性邀请链接，也可以将其复制并粘贴到消息中。对其他设备，只需打开该链接并接受邀请。对您要邀请的任何其他设备重复此过程。您的设备现在属于同一家庭，可以作为一个完全正常工作的婴儿监视器系统进行配合。
*邀请家庭成员*
3、启动婴儿站流：接下来，通过转到 [Gonimo 主屏](https://app.gonimo.com/)，点击带有奶嘴的按钮，并允许网络浏览器访问设备的麦克风和摄像头，选择将婴儿的音频和视频流式传输到父母的设备。调整相机以指向宝宝的床，或关闭它以节省设备电池（音频仍将流式传输）。点击“Start”。该流现在处于活动状态。
*选择婴儿站*
*按“Start”开始以流式传输视频*
4、连接到父母站流：要查看婴儿站流，请转到 Gonimo 家族中的另外的设备 —— 即父母站。点击 Gonimo 主屏幕上的 “Parent” 按钮。您将看到该系列中所有设备的列表；旁边有一个闪动的“Connect”按钮的是活跃的婴儿站。选择“Connect”，您可以通过点对点音频/视频流看到和听到您的宝宝。音量条为传输的音频流提供可视化。
*选择父母站*
*按下“Connect”开始观看婴儿流。*
5、恭喜！您已成功将设备直接通过网络浏览器转换为婴儿监视器，无需下载或安装任何应用程序！
有关重命名设备，从系列中删除设备或删除系列的详细信息和详细说明，请查看 gonimo.com 的[视频教程](https://gonimo.com/index.php#intro)。
### 家庭系统的灵活性
Gonimo 的优势之一是其基于家庭的系统，它为即使在商业 Android 或 iOS 应用中也无法提供的各种情况提供了极大的灵活性。要深入了解这些功能，我们假设您创建了一个由三个设备组成的家庭系统。
* 多婴儿：如果你想留意你在两个不同房间睡觉的两个小孩怎么办？在每个孩子的房间放一个设备，并将其设置为婴儿站。第三个设备将充当父母站，您可以在其上连接到两个流并通过分屏查看您的幼儿。您甚至可以通过向该家庭系统提供更多设备，并将其设置为婴儿站来将此用例扩展到两个以上的婴儿站。只要您的父母站连接到第一个婴儿站，请单击左上角的后退箭头返回“设备概述”屏幕。现在您可以连接到第二个（以及依次为第三个、第四个、第五个和第五个等）设备，并自动建立分屏。酷！
* 多父母：如果爸爸想在他上班的时候看孩子怎么办？只需邀请第四个设备（例如，他的办公室 PC ）到家庭并将其设置为父母站。父母双方都可以通过他们自己的设备同时检查他们的孩子，甚至可以独立地选择他们希望连接的孩子。
* 多家庭：单个设备也可以是几个家庭系统的一部分。当您的婴儿站与您一起时，如平板电脑，您经常访问亲戚或朋友时，这非常有用。为“奶奶的房子”或“约翰叔叔的房子”创建另一个家庭，其中包括您的婴儿站设备与奶奶或约翰叔叔的设备配对。您可以随时通过婴儿站设备的 Gonimo 主屏幕在这些家庭中切换婴儿站设备。
### 想要参加吗？
Gonimo 团队喜欢开源。代码来自社区，代码用于社区。Gonimo 的用户对我们非常重要，但它们只是 Gonimo 故事的一部分。幕后有创意的大脑是创造出色婴儿监视器体验的关键。
目前我们特别需要那些愿意成为 iOS 11 测试者的人的帮助，因为 Apple 在 iOS 11 中对 WebRTC 的支持意味着我们最终将能够支持 iOS 设备。如果可以，请帮助我们实现这个令人赞叹的里程碑。
如果您了解 Haskell 或想要了解它，您可以查看 [GitHub 上我们的代码](https://github.com/gonimo/gonimo)。欢迎发起拉取请求、审查代码以及提出问题。
最后，请通过向新父母和开源世界宣传 Gonimo 婴儿监视器是易于使用并且便携的。
### 关于作者
Robert Klotzner：我是双胞胎的父亲，一个程序员。当我听到普通人可以给计算机编程时，我买了一本 1200 页的关于 C++ 的书开始学习，我当时才十五岁。我坚持用 C++ 相当长的一段时间，学习了 Java 又回归到 C++，学习了 D、Python 等等，最终学习了 Haskell。我喜欢 Haskell 是因为它丰富的类型系统，这几乎可以避免我书写错误的代码。强壮的静态类型和性能让我爱上了 C++……
---
via: <https://opensource.com/article/17/9/gonimo>
作者：[Robert Klotzner](https://opensource.com/users/robert-klotzner) 译者：[lintaov587](https://github.com/lintaov587) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
在 Linux 上使用 tarball
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3328840/linux/working-with-tarballs-on-linux.html
|
Tarball 提供了一种在 Linux 系统上备份和管理一组文件的通用方法。请按照以下提示了解如何创建它们，以及从中提取和删除单个文件。
|
/data/attachment/album/201901/05/215151s2zqe3qzcd43f3ls.jpg.thumb.jpg
|
/data/attachment/album/201901/05/215151s2zqe3qzcd43f3ls.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"tar",
"归档"
] |
技术
|
{
"viewnum": 8938,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Tarball 提供了一种在 Linux 系统上备份和管理一组文件的通用方法。请按照以下提示了解如何创建它们，以及从中提取和删除单个文件。
| 2019-01-05T21:52:00 | 2019-01-05T21:52:00 | 10,418 |
/article-10418-1.html
|
>
> Tarball 提供了一种在 Linux 系统上备份和管理一组文件的通用方法。请按照以下提示了解如何创建它们，以及从中提取和删除单个文件。
>
>
>
“tarball” （LCTT 译注：国内也常称为“tar 包”）一词通常用于描述备份一组选择的文件并将它们打包在一个文件中的一种文件格式。该名称来自 .tar 文件扩展名和 `tar` 命令，它用于将文件打包到一个文件中，有时还会压缩该文件，使其在移动到其它系统时更小。
tarball 通常用于备份个人或系统文件来创建存档，特别是在进行可能需要撤消的更改之前。例如，Linux 系统管理员通常会在更改应用之前创建包含一系列配置文件的 tarball，以防必须撤消这些更改。从 tarball 中解压文件通常比在备份中搜索文件快。
### 如何在 Linux 上创建 tarball
使用如下命令，你可以在单条命令中创建 tarball 并压缩它。
```
$ tar -cvzf PDFs.tar.gz *.pdf
```
其结果是一个压缩文件（gzip 压缩的），其中包含了当前目录中的所有 PDF 文件。当然，压缩是可选的。一个稍微简单的只是将 PDF 文件打包成未压缩 tarball 的命令：
```
$ tar -cvf PDFs.tar *.pdf
```
注意，选项中的 `z` 将文件变成压缩的。 `c` 表明创建文件，`v`（详细）表示你在命令运行时需要一些反馈。如果你不想查看列出的文件，请忽略 `v`。
另一个常见的命名约定是给压缩的 tarball 命名成 .tgz 而不是双扩展名 .tar.gz，如下所示：
```
$ tar cvzf MyPDFs.tgz *.pdf
```
### 如何从 tarball 中解压文件
要从 gzip 压缩包中解压所有文件，你可以使用如下命令：
```
$ tar -xvzf file.tar.gz
```
如果使用 .tgz 命名约定，该命令将如下所示：
```
$ tar -xvzf MyPDFs.tgz
```
要从 gzip 包中解压单个文件，你可以执行几乎相同的操作，只需添加文件名：
```
$ tar -xvzf PDFs.tar.gz ShenTix.pdf
ShenTix.pdf
ls -l ShenTix.pdf
-rw-rw-r-- 1 shs shs 122057 Dec 14 14:43 ShenTix.pdf
```
如果未压缩 tarball，你甚至可以从 tarball 中删除文件。例如，如果我们想从 PDFs.tar.gz 中删除我们上面解压过的文件，我们会这样做：
```
$ gunzip PDFs.tar.gz
$ ls -l PDFs.tar
-rw-rw-r-- 1 shs shs 10700800 Dec 15 11:51 PDFs.tar
$ tar -vf PDFs.tar --delete ShenTix.pdf
$ ls -l PDFs.tar
-rw-rw-r-- 1 shs shs 10577920 Dec 15 11:45 PDFs.tar
```
请注意，我们在删除 ShenTix.pdf 后，缩小了一点 tarball 文件占用的空间。如果我们想要，我们可以再次压缩文件：
```
$ gzip -f PDFs.tar
ls -l PDFs.tar.gz
-rw-rw-r-- 1 shs shs 10134499 Dec 15 11:51 PDFs.tar.gzFlickr / James St. John
```
丰富的命令行选项使得 tarball 使用起来简单方便。
---
via: <https://www.networkworld.com/article/3328840/linux/working-with-tarballs-on-linux.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何成为一名懒惰的系统管理员
|
David Both
|
https://opensource.com/article/18/7/how-be-lazy-sysadmin
|
我们是聪明地工作，而不是刻苦工作，但仍能把工作做好。
|
/data/attachment/album/201901/06/225109ycdfdggifxcdg43w.png.thumb.jpg
|
/data/attachment/album/201901/06/225109ycdfdggifxcdg43w.png
| true | false | true |
lujun9972
|
zgj1024
|
wxy
| false |
[
"系统管理员"
] |
观点
|
{
"viewnum": 7238,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们是聪明地工作，而不是刻苦工作，但仍能把工作做好。
| 2019-01-06T22:50:00 | 2019-01-06T22:50:00 | 10,419 |
/article-10419-1.html
|
>
> 我们是聪明地工作，而不是刻苦工作，但仍能把工作做好。
>
>
>
Linux 的系统管理员的工作总是复杂的，并且总是伴随着各种陷阱和障碍。做每件事都没有足够时间，当你想完成那个半秃头老板（PHB）给的任务时，他（只会）不停在你的后面盯着，而最核心的服务器总是在最不合时宜的时间点崩溃，问题和挑战比比皆是。而我发现，成为一名<ruby> 懒惰的系统管理员 <rt> Lazy SysAdmin </rt></ruby>可以解决这一困境。
（LCTT 译注：<ruby> <a href="https://en.wikipedia.org/wiki/Pointy-haired_Boss"> 半秃头老板 </a> <rt> Pointy-Haired Boss </rt></ruby>（PHB），那是[呆伯特漫画](https://zh.wikipedia.org/wiki/%E5%91%86%E4%BC%AF%E7%89%B9)中的角色，缺乏一般知识常识及其职位所应具有的管理能力，爱说大话且富有向物理显示挑战的精神，大概长成下图这样。）
我在即将在 Apress 出版的新书 《The Linux Philosophy for SysAdmins》（LCTT 译注：暂译《系统管理员的 Linux 哲学》）中更详细地讨论如何成为一个懒惰的系统管理员，那书预计会在 9 月出版（LCTT 译注：已于 2018 年 8 月出版）。这本的部分内容摘录自该书，特别是第九章，“成为一名懒惰的系统管理员”。在我们讨论如何做到这点前，让我们简单了解一下成为一个名懒惰的系统管理员意味着什么。
### 真实生产力 vs. 虚假生产力
#### 虚假生产力
在我工作的地方，半秃头老板相信的管理风格叫“<ruby> 走动式管理 <rt> management by walking around </rt></ruby>”。通过判断某人在不在他的键盘上输入东西，或者至少要看看他们显示器上显示的东西，来判断他们的工作是否有效率。这是一个糟糕的工作场所。各部门间有道很高的行政墙，这会造就了许多的、微小的沟通壁垒，大量无用的文书工作，以及获得任何事情的许可都要等待漫长的时间。因为这样、那样的原因，不可能高效地做任何事情，如果真的是这样，那是非常低效。为了看起来很忙，我们都有自己的一套<ruby> “看起来很忙”的工具包 <rt> Look Busy Kits </rt></ruby>（LBK），可能是一些短小的、用来显示一些行为活动的 Bash 脚本，或者是 `top`、`htop`、`iotop` 之类的程序，或者是一些持续显示某些行为活动的监控工具。这种工作场所的风气让人不可能真正高效，我讨厌这种地方，也讨厌那个几乎不可能完成任何有价值的事情的事实。
这种糟糕场所对真实的系统管理员来讲是场噩梦。没有人会感到快乐。在那里花费四五个月才能完成的事，在其他地方只需的一个早晨。我们没有什么实际工作要做，却要花大量的时间干活来让自己看起来很忙。我们在默默地竞赛，看谁能创造最好的“看起来很忙”的工具包，这就是我们花费最多时间的地方了。那份工作我只做了几个月，但好像已经耗费了一生。如果你看到的这个监狱的表面，你可能会说我们是很懒，因为我们只完成了几乎为 0 的实际工作。
这是个极端的例子，它完全与我所说的“我是一个懒惰的系统管理员”的意思相反，而做一个懒惰的系统管理是件好事。
#### 真实生产力
我很幸运，曾为一些真正的管理者工作过 —— 他们明白，系统管理员的生产力并不是以每天花多少小时敲键盘来衡量。毕竟，即使一只猴子能敲击他们的键盘，但也不能说明结果的价值。
正如我书中所言：
>
> “我是一个懒惰的系统管理员，同时我也是一个高效的系统管理员。这两者看似矛盾的说法不是相互排斥的，而是会以一种非常积极的方式相辅相成……
>
>
> “系统管理员在思考的时候是最高效的 —— 思考关于如何解决现有问题和避免未来的问题；思考怎样监控 Linux 计算机，以便找到预测和预示这些未来的问题的线索；思考如何让他们的工作更有效率；思考如何自动化所有这些要执行的任务，无论是每天还是每年一次的任务。
>
>
> “系统管理员冥思苦想的那一面是不会被非系统管理员所熟知的，那些人包括很多管理着系统管理员的人，比如那个半秃头老板。系统管理员都会以不同的方式解决他们工作中苦思的部分。一些我认识的系统管理员会在沙滩、骑自行车、参加马拉松或者攀岩时找到最好的想法。另一些人会认为静坐或听音乐的时候思考得最好。还有一些会在阅读小说、学习不相关的学科、甚至在学习 Linux 系统的时候可以最佳思考。关键是我们都有不同的方式激发我们的创造力，而这些创造力的推进器中很多并不涉及键盘上的任何一个按键。我们真正的生产力对于系统管理员周围的人来说可能是完全看不见的。”
>
>
>
成为懒惰的系统管理员有一些简单的秘诀 —— 系统管理员要完成一切需要完成的事，而且更多的是，当所有人都处于恐慌的状态时要保持冷静和镇定。秘诀的一部分是高效工作，另一部分是把预防问题放在首位。
### 成为懒惰系统管理员的方法
#### 多思考
我相信关于懒惰系统管理员最重要的秘诀在于思考。正如上面的摘录所言，优秀的系统管理员会花大量的时候思考这些事情，如何更有效率地工作，在异常成为问题前如何定位，更聪明地工作，做其它事情的同时会考虑如何完成这些事情等等。
例如，除了撰写本文之外，我现在正在想一个项目，我打算在从亚马逊和本地计算机商店采购的新部件到达时才开始。我有一台不太关键的计算机上的主板坏了，最近它的崩溃更频率。但我的一台非常老的小服务器并没有出现故障，它负责处理我的电子邮件和外部网站，以及为我的网络的其余部分提供 DHCP 和 DNS 服务，但需要解决由于各种外部攻击而导致的间歇性过载。
我一开始想，我只要替换故障设备的主板及其直接部件：内存、CPU，可能还有电源。但是在考虑了一段时间之后，我决定将新部件放到服务器中，并将旧的（但仍然可用的）部件从服务器移到故障设备中。可以这样做的，只需一、两个小时就可以从服务器上移除旧部件并安装新的。然后我就可以花时间更换出故障的电脑里的部件了。太好了，所以我开始在脑海中列出要完成的任务。
然而，当我查看这个任务列表时，我意识到服务器中唯一不能替换的部件是机箱和硬盘驱动器，这两台计算机的机箱几乎完全相同。在有了这个小小的发现之后，我开始考虑用新的部件替换出了故障的计算机的部件，并将之作为我的服务器。经过一些测试之后，我只需从当前的服务器移除硬盘，并将它安装到用了新组件的机箱中，改下网络配置项，再更改 KVM 交换机端口上的主机名，并更改机箱上的主机名标签，就可以了。这将大大减少服务器停机时间，大大减少我的压力。此外，如果出现故障，我可以简单地将硬盘移回原来的服务器，直到我可以用新服务器解决问题为止。
所以，现在我在脑海中已经创建了一个完成这项工作我所需要做的任务清单。而且，我希望你能仔细观察，当我脑子里想着这一切的时候，我的手指从来没有碰过键盘。我新的心理行动计划风险很低，与我最初的计划相比，涉及的服务器停机时间要少得多。
当我在 IBM 工作的时候，我经常看到很多语言中都有写着“**思考**”的标语。思考可以节省时间和压力，是懒散的系统管理员的主要标志。
#### 做预防性维护
在 1970 年代中期，我被 IBM 聘为客户工程师，我的领地由相当多的[穿孔卡片设备](https://en.wikipedia.org/wiki/Unit_record_equipment)组成。这也就是说，它们是处理打孔卡的重型机械设备，其中一些可以追溯到 20 世纪 30 年代。因为这些机器主要是机械的，所以它们的部件经常磨损或失调。我的部分工作是在它们损坏时修复它们。我工作的主要部分，也是最重要的部分，是首先要防止它们损坏。预防性维护的目的是在磨损部件损坏之前进行更换，并对还在运行的部件进行润滑和调整，以确保它们工作正常。
正如我在《系统管理员的 Linux 哲学》中所言：
>
> “我在 IBM 的经理们明白这只是冰山一角；他们和我都知道，我的工作是让顾客满意。虽然这通常意味着修复损坏的硬件，但也意味着减少硬件损坏的次数。这对客户来说是好事，因为他们的机器在工作时工作效率更高。这对我有好处，因为我从那些快乐的客户那里接到的电话要少得多。我也睡了更多的觉，因为这样做的结果是更少的非工作时间的紧急电话。我是个懒惰的（客户工程师）。通过提前做额外的工作，从长远来看，我需要做的工作要少得多。
>
>
> “这一原则已成为系统管理员的 Linux 哲学的功能原则之一。作为系统管理员，我们的时间最好用在最大限度地减少未来工作量的任务上。”
>
>
>
在 Linux 计算机中查找要解决的问题相当于项目管理。我检查系统日志，寻找以后可能会变得非常危险的问题的迹象。如果出现了一些小问题，或者我注意到我的工作站、服务器没有做出该有的响应，或者如果日志显示了一些不寻常的东西，所有这些都可以暗示出潜在的问题，而对于用户或半秃头老板来说，这些问题并没有产生明显的症状。
我经常检查 `/var/log/` 中的文件，特别是 `messages` 和 `security` 文件。我最常见的问题之一是许多脚本小子在我的防火墙系统上尝试各种类型的攻击。而且，不，我不依赖 ISP 提供的调制解调器/路由器中的所谓的防火墙。这些日志包含了大量关于企图攻击来源的信息，非常有价值。但是要扫描不同主机上的日志并将解决方案部署到位，需要做大量的工作，所以我转向自动化。
#### 自动化
我发现我的工作有很大一部分可以通过某种形式的自动化来完成。系统管理员的 Linux 哲学的原则之一是 “自动化一切”，这包括每天扫描日志文件等枯燥乏味的任务。
像是 [Logwatch](https://www.techrepublic.com/article/how-to-install-and-use-logwatch-on-linux/) 这类的程序能够监控你的日志文件中的异常条目，并在异常条目发生时通知您。Logwatch 通常作为 cron 任务每天运行一次，并向本地主机上的 root 用户发送电子邮件。你可以从命令行运行 Logwatch，并立即在显示器上查看结果。现在我只需要每天查看 Logwatch 的电子邮件通知。
但现实是，仅仅收到通知是不够的，因为我们不能坐以待毙。有时需要立即作出反应。我喜欢的另一个程序是——它能为我做所有事（看，这就是懒惰的管理员）——它就是 [Fail2ban](https://www.fail2ban.org/wiki/index.php/Main_Page)。Fail2Ban 会扫描指定的日志文件，查找各种类型的黑客攻击和入侵尝试，如果它发现某个 IP 地址在持续做特定类型的活动，它会向防火墙添加一个条目，在指定的时间内阻止来自该 IP 地址的任何进一步的黑客尝试。默认值通常在 10 分钟左右，但我喜欢为大多数类型的攻击指定为 12 或 24 小时。每种类型的黑客攻击都是单独配置的，例如尝试通过 SSH 登录和那些 Web 服务器的攻击。
#### 写脚本
自动化是这种哲学的关键组成部分之一。一切可以自动化的东西都应该自动化的，其余的尽可能地自动化。所以，我也写了很多脚本来解决问题，也就是说我编写了脚本来完成我的大部分工作。
我的脚本帮我节省了大量时间，因为它们包含执行特定任务的命令，这大大减少了我需要输入的数量。例如，我经常重新启动我的电子邮件服务器和垃圾邮件过滤软件（当修改 SpamAssassin 的 `local.cf` 配置文件时，就需要重启）。必须按特定顺序停止并重新启动这些服务。因此，我用几个命令编写了一个简短的脚本，并将其存储在可访问的 `/usr/local/bin` 中。现在，不用键入几个命令并等待每个命令都完成，然后再键入下一个命令，更不用记住正确的命令顺序和每个命令的正确语法，我输入一个三个字符的命令，其余的留给我的脚本来完成。
#### 简化键入
另一种成为懒惰的系统管理员的方法是减少我们需要键入的数量。而且，我的打字技巧真的很糟糕（也就是说，我一点也没有，顶多是几个笨拙的手指）。导致错误的一个可能原因是我糟糕的打字技巧，所以我会尽量少打字。
绝大多数 GNU 和 Linux 核心实用程序都有非常短的名称。然而，它们都是有意义的名字。诸如用于更改目录的 `cd` 、用于列出目录内容的 `ls` 和用于磁盘转储的 `dd` 等工具都一目了然。短名字意味着更少的打字和更少的产生错误机会。我认为短的名字通常更容易记住。
当我编写 shell 脚本时，我喜欢保持名称简短而意义（至少对我来说是），比如用于 rsync 备份的 `rsbu`（LCTT 译注，Rsync Backup 的简写）。但在某些情况下，我喜欢使用更长的名称，比如 `doUpdates` 来执行系统更新。在后一种情况下，更长一点的名字让脚本的目的更明显。这可以节省时间，因为很容易记住脚本的名称。
其他减少键入的方法包括命令行别名、历史命令调回和编辑。别名只是你在 Bash shell 键入命令时才做的替换。键入 `alias` 命令会看到默认配置的别名列表。例如，当你输入命令 `ls` 时，会被条目 `alias ls='ls –color=auto'` 替成较长的命令，因此你只需键入 2 个字符而不是 14 个字符即可获得带有颜色的文件列表。还可以使用 `alias` 命令添加你自己定义的别名。
历史命令调回允许你使用键盘的向上和向下箭头键滚动浏览命令历史记录。如果需要再次使用相同的命令，只需在找到所需的命令时按回车键即可。如果在找到命令后需要更改该命令，则可以使用标准命令行编辑功能进行更改。
### 结束语
一名懒惰的系统管理员实际上也有很多的工作。但我们是聪明地工作，而不是刻苦工作。早在一堆小问题汇聚成大问题之前，我们就花时间探索我们负责的主机，并处理好所有的小问题。我们花了很多时间思考解决问题的最佳方法，我们也花了很多时间来发现新的方法，让自己更聪明地工作，成为懒惰的系统管理员。
除了这里描述的少数方法外，还有许多其他的方式可以成为懒惰的系统管理员。我相信你也有一些自己的方式；请在评论中和我们分享。
---
via: <https://opensource.com/article/18/7/how-be-lazy-sysadmin>
作者：[David Both](https://opensource.com/users/dboth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[zgj1024](https://github.com/zgj1024) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
COPR 仓库中 4 个很酷的新软件（2018.12）
|
Dominik Turecek
|
https://fedoramagazine.org/4-try-copr-december-2018/
|
COPR 是软件的个人存储库的集合，它包含那些不在标准的 Fedora 仓库中的软件。
|
/data/attachment/album/201901/06/232251f997n99953z98z8y.jpg.thumb.jpg
|
/data/attachment/album/201901/06/232251f997n99953z98z8y.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"COPR"
] |
分享
|
{
"viewnum": 5385,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
COPR 是软件的个人存储库的集合，它包含那些不在标准的 Fedora 仓库中的软件。
| 2019-01-06T23:22:47 | 2019-01-06T23:22:47 | 10,420 |
/article-10420-1.html
|
COPR 是软件的个人存储库的[集合](https://copr.fedorainfracloud.org/)，它包含那些不在标准的 Fedora 仓库中的软件。某些软件不符合允许轻松打包的标准。或者它可能不符合其他 Fedora 标准，尽管它是自由开源的。COPR 可以在标准的 Fedora 包之外提供这些项目。COPR 中的软件不受 Fedora 基础设施的支持，或者是由项目自己背书的。但是，它是尝试新的或实验性软件的一种很好的方法。
这是 COPR 中一组新的有趣项目。
### MindForger
[MindForger](https://www.mindforger.com/) 是一个 Markdown 编辑器和笔记本。除了你预期的 Markdown 编辑器的功能之外，MindForger 还允许你将单个文件拆分为多个笔记。组织笔记并在文件之间移动、搜索它们都很容易。我已经使用 MindForger 一段时间来记录学习笔记了，现在可以在 COPR 中找到它啦。
#### 安装说明
该仓库目前在 Fedora 29 和 Rawhide 中提供 MindForger。要安装 MindForger，请使用以下命令：
```
sudo dnf copr enable deadmozay/mindforger
sudo dnf install mindforger
```
### Clingo
[Clingo](https://potassco.org/clingo/) 是使用[回答集编程](https://en.wikipedia.org/wiki/Answer_set_programming)（ASP）建模语言解决逻辑问题的程序。使用 ASP，你可以将问题声明为一个逻辑程序，然后 Clingo 来解决。最后，Clingo 以逻辑模型的形式产生问题的解决方案，称为回答集。
#### 安装说明
该仓库目前为 Fedora 28 和 29 提供 Clingo。要安装 Clingo，请使用以下命令：
```
sudo dnf copr enable timn/clingo
sudo dnf install clingo
```
### SGVrecord
[SGVrecord](https://github.com/yucefsourani/sgvrecord) 是一个用于录制屏幕的简单工具。它允许你捕获整个屏幕或仅选择其中的一部分。此外，有没有声音都可以进行录制。SGVrecord 以 WebM 格式生成文件。
#### 安装说明
该仓库目前为 Fedora 28、29 和 Rawhide 提供 SGVrecord。要安装 SGVrecord，请使用以下命令：
```
sudo dnf copr enable youssefmsourani/sgvrecord
sudo dnf install sgvrecord
```
### Watchman
[Watchman](https://facebook.github.io/watchman/) 是一个对文件更改进行监视和记录的服务。你可以为指定 Watchman 监视的目录树，以及定义指定文件发生更改时触发的操作。
#### 安装说明
该仓库目前为 Fedora 29 和 Rawhide 提供 Watchman。要安装 Watchman，请使用以下命令：
```
sudo dnf copr enable eklitzke/watchman
sudo dnf install watchman
```
---
via: <https://fedoramagazine.org/4-try-copr-december-2018/>
作者：[Dominik Turecek](https://fedoramagazine.org) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用 PGP 保护代码完整性（六）：在 Git 上使用 PGP
|
Konstantin Ryabitsev
|
https://www.linux.com/blog/learn/pgp/2018/3/protecting-code-integrity-pgp-part-6-using-pgp-git
|
我们继续我们的 PGP 实践系列，来看看签名标签的标签和提交，这可以帮你确保你的仓库没有被篡改。
|
/data/attachment/album/201901/07/000946kbvjmw5aj6q38qr8.jpg.thumb.jpg
|
/data/attachment/album/201901/07/000946kbvjmw5aj6q38qr8.jpg
| true | false | true |
qhwdw
|
wxy
| false |
[
"PGP",
"git"
] |
技术
|
{
"viewnum": 7250,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 10415,
"displayorder": 0
},
{
"raid": 10432,
"displayorder": 0
}
] |
我们继续我们的 PGP 实践系列，来看看签名标签的标签和提交，这可以帮你确保你的仓库没有被篡改。
| 2019-01-07T00:09:00 | 2019-01-07T00:09:00 | 10,421 |
/article-10421-1.html
|
>
> 我们继续我们的 PGP 实践系列，来看看签名标签的标签和提交，这可以帮你确保你的仓库没有被篡改。
>
>
>
在本系列教程中，我们提供了一个使用 PGP 的实用指南，包括基本概念和工具、生成和保护你的密钥。如果你错过了前面的文章，你可以查看下面的链接。在这篇文章中，我们谈一谈在 Git 中如何集成 PGP、使用签名的标签，然后介绍签名提交，最后添加签名推送的支持。
* [第一部分：基本概念和工具](/article-9524-1.html)
* [第二部分：生成你的主密钥](/article-9529-1.html)
* [第三部分：生成 PGP 子密钥](/article-9607-1.html)
* [第四部分：将主密钥移到离线存储中](/article-10402-1.html)
* [第五部分：将子密钥移到硬件设备中](/article-10415-1.html)
Git 的核心特性之一就是它的去中心化本质 —— 一旦仓库克隆到你的本地系统，你就拥有了项目的完整历史，包括所有的标签、提交和分支。然而由于存在着成百上千的克隆仓库，如何才能验证你下载的仓库没有被恶意的第三方做过篡改？你可以从 GitHub 或一些貌似官方的位置来克隆它们，但是如果有些人故意欺骗了你怎么办？
或者在你参与的一些项目上发现了后门，而 “Author” 行显示是你干的，然而你很确定 [不是你干的](https://github.com/jayphelps/git-blame-someone-else)，会发生什么情况？
为解决上述问题，Git 添加了 PGP 集成。签名的标签通过确认它的内容与创建这个标签的开发者的工作站上的内容完全一致来证明仓库的完整性，而签名的提交几乎是不可能在不访问你的 PGP 密钥的情况下能够假冒你。
#### 清单
* 了解签名的标签、提交和推送（必要）
* 配置 git 使用你的密钥（必要）
* 学习标签如何签名和验证（必要）
* 配置 git 总是签名带注释标签（推荐）
* 学习提交如何签名和验证工作（必要）
* 配置 git 总是签名提交（推荐）
* 配置 gpg-agent 选项（必要）
#### 考虑事项
git 实现了 PGP 的多级集成，首先从签名标签开始，接着介绍签名提交，最后添加签名推送的支持。
##### 了解 Git 哈希
git 是一个复杂的东西，为了你能够更好地掌握它如何集成 PGP，你需要了解什么是”哈希“。我们将它归纳为两种类型的哈希：树哈希和提交哈希。
###### 树哈希
每次你向仓库提交一个变更，对于仓库中的每个子目录，git 都会记录它里面所有对象的校验和哈希 —— 内容（blobs）、目录（trees）、文件名和许可等等。它只对每次提交中发生变更的树和内容做此操作，这样在只变更树的一小部分时就不必去重新计算整个树的校验和。
然后再计算和存储处于顶级的树的校验和，这样如果仓库的任何一部分发生变化，校验和将不可避免地发生变化。
###### 提交哈希
一旦创建了树哈希，git 将计算提交哈希，它将包含有关仓库和变更的下列信息：
* 树哈希的校验和
* 变更前树哈希的校验和（父级）
* 有关作者的信息（名字、email、创作时间）
* 有关提交者的信息（名字、email、提交时间）
* 提交信息
###### 哈希函数
在写这篇文章时，虽然研究一种更强大的、抗碰撞的算法的工作正在进行，但 git 仍然使用的是 SHA1 哈希机制去计算校验和。注意，git 已经包含了碰撞防范程序，因此认为对 git 成功进行碰撞攻击仍然是不可行的。
#### 带注释标签和标签签名
在每个 Git 仓库中，标签允许开发者标记特定的提交。标签可以是 “轻量级的” —— 几乎只是一个特定提交上的指针，或者它们可以是 “带注释的”，它自己将成为 git 树中的项目。一个带注释标签对象包含所有下列的信息：
* 成为标签的提交的哈希的校验和
* 标签名字
* 关于打标签的人的信息（名字、email、打标签时间）
* 标签信息
一个 PGP 签名的标签是一个带有将所有这些条目封装进一个 PGP 签名的带注释标签。当开发者签名他们的 git 标签时，他们实际上是向你保证了如下的信息：
* 他们是谁（以及他们为什么应该被信任）
* 他们在签名时的仓库状态是什么样：
+ 标签包含的提交的哈希
- 提交的哈希包含了顶级树的哈希
- 顶级树哈希包含了所有文件、内容和子树的哈希
- 它也包含有关作者的所有信息
- 包含变更发生时的精确时间
当你克隆一个仓库并验证一个签名的标签时，就是向你以密码方式保证：仓库中的所有内容、包括所有它的历史，与开发者签名时在它的计算机上的仓库完全一致。
#### 签名的提交
签名的提交与签名的标签非常类似 —— PGP 签名的是提交对象的内容，而不是标签对象的内容。一个提交签名也给你提供了开发者签名时开发者树上的全部可验证信息。标签签名和提交的 PGP 签名提供了有关仓库和它的完整历史的完全一致的安全保证。
#### 签名的推送
为了完整起见，在这里包含了签名的推送这一功能，因为在你使用这个功能之前，需要在接收推送的服务器上先启用它。正如我们在上面所说过的，PGP 签名一个 git 对象就是提供了开发者的 git 树当时的可验证信息，但不提供开发者对那个树意图相关的信息。
比如，你可以在你自己复刻的 git 仓库的一个实验分支上尝试一个很酷的特性，为了评估它，你提交了你的工作，但是有人在你的代码中发现了一个恶意的 bug。由于你的提交是经过正确签名的，因此有人可能将包含有恶意 bug 的分支推入到 master 分支中，从而在生产系统中引入一个漏洞。由于提交是经过你的密钥正确签名的，所以一切看起来都是合理合法的，而当 bug 被发现时，你的声誉就会因此而受到影响。
在 `git push` 时，为了验证提交的意图而不仅仅是验证它的内容，添加了要求 PGP 推送签名的功能。
#### 配置 git 使用你的 PGP 密钥
如果在你的钥匙环上只有一个密钥，那么你就不需要再做额外的事了，因为它是你的默认密钥。
然而，如果你有多个密钥，那么你必须要告诉 git 去使用哪一个密钥。（`[fpr]` 是你的密钥的指纹）：
```
$ git config --global user.signingKey [fpr]
```
注意：如果你有一个不同的 `gpg2` 命令，那么你应该告诉 git 总是去使用它，而不是传统的版本 1 的 `gpg`：
```
$ git config --global gpg.program gpg2
```
#### 如何使用签名标签
创建一个签名的标签，只要传递一个简单地 `-s` 开关给 `tag` 命令即可：
```
$ git tag -s [tagname]
```
我们建议始终对 git 标签签名，这样让其它的开发者确信他们使用的 git 仓库没有被恶意地修改过（比如，引入后门）：
##### 如何验证签名的标签
验证一个签名的标签，只需要简单地使用 `verify-tag` 命令即可：
```
$ git verify-tag [tagname]
```
如果你要验证其他人的 git 标签，那么就需要你导入他的 PGP 公钥。请参考 “可信任的团队沟通” 一文中关于此主题的指导。
##### 在拉取时验证
如果你从项目仓库的其它复刻中拉取一个标签，git 将自动验证签名，并在合并操作时显示结果：
```
$ git pull [url] tags/sometag
```
合并信息将包含类似下面的内容：
```
Merge tag 'sometag' of [url]
[Tag message]
# gpg: Signature made [...]
# gpg: Good signature from [...]
```
#### 配置 git 始终签名带注释标签
很可能的是，你正在创建一个带注释标签，你应该去签名它。强制 git 始终签名带注释的标签，你可以设置一个全局配置选项：
```
$ git config --global tag.forceSignAnnotated true
```
或者，你始终记得每次都传递一个 `-s` 开关：
```
$ git tag -asm "Tag message" tagname
```
#### 如何使用签名的提交
创建一个签名的提交很容易，但是将它纳入到你的工作流中却很困难。许多项目使用签名的提交作为一种 “Committed-by:” 的等价行，它记录了代码来源 —— 除了跟踪项目历史外，签名很少有人去验证。在某种意义上，签名的提交用于 “篡改证据”，而不是 git 工作流的 “篡改证明”。
为创建一个签名的提交，你只需要 `git commit` 命令传递一个 `-S` 标志即可（由于它与另一个标志冲突，所以改为大写的 `-S`）：
```
$ git commit -S
```
我们建议始终使用签名提交，并要求项目所有成员都这样做，这样其它人就可以验证它们（下面就讲到如何验证）。
##### 如何去验证签名的提交
验证签名的提交需要使用 `verify-commit` 命令：
```
$ git verify-commit [hash]
```
你也可以查看仓库日志，要求所有提交签名是被验证和显示的：
```
$ git log --pretty=short --show-signature
```
##### 在 git 合并时验证提交
如果项目的所有成员都签名了他们的提交，你可以在合并时强制进行签名检查（然后使用 `-S` 标志对合并操作本身进行签名）：
```
$ git merge --verify-signatures -S merged-branch
```
注意，如果有一个提交没有签名或验证失败，将导致合并操作失败。通常情况下，技术是最容易的部分 —— 而人的因素使得项目中很难采用严格的提交验证。
##### 如果你的项目在补丁管理上采用邮件列表
如果你的项目在提交和处理补丁时使用一个邮件列表，那么一般很少使用签名提交，因为通过那种方式发送时，签名信息将会丢失。对提交进行签名仍然是非常有用的，这样其他人就能引用你托管在公开 git 树作为参考，但是上游项目接收你的补丁时，仍然不能直接使用 git 去验证它们。
尽管，你仍然可以签名包含补丁的电子邮件。
#### 配置 git 始终签名提交
你可以告诉 git 总是签名提交：
```
git config --global commit.gpgSign true
```
或者你每次都记得给 `git commit` 操作传递一个 `-S` 标志（包括 `—amend`）。
#### 配置 gpg-agent 选项
GnuPG agent 是一个守护工具，它能在你使用 gpg 命令时随时自动启动，并运行在后台来缓存私钥的密码。这种方式让你只需要解锁一次密钥就可以重复地使用它（如果你需要在一个自动脚本中签署一组 git 操作，而不想重复输入密钥，这种方式就很方便）。
为了调整缓存中的密钥过期时间，你应该知道这两个选项：
* `default-cache-ttl`（秒）：如果在 TTL 过期之前再次使用同一个密钥，这个倒计时将重置成另一个倒计时周期。缺省值是 600（10 分钟）。
* `max-cache-ttl`（秒）：自首次密钥输入以后，不论最近一次使用密钥是什么时间，只要最大值的 TTL 倒计时过期，你将被要求再次输入密码。它的缺省值是 30 分钟。
如果你认为这些缺省值过短（或过长），你可以编辑 `~/.gnupg/gpg-agent.conf` 文件去设置你自己的值：
```
# set to 30 minutes for regular ttl, and 2 hours for max ttl
default-cache-ttl 1800
max-cache-ttl 7200
```
##### 补充：与 ssh 一起使用 gpg-agent
如果你创建了一个 [A](https://www.linux.com/users/mricon)（验证）密钥，并将它移到了智能卡，你可以将它用到 ssh 上，为你的 ssh 会话添加一个双因子验证。为了与 agent 沟通你只需要告诉你的环境去使用正确的套接字文件即可。
首先，添加下列行到你的 `~/.gnupg/gpg-agent.conf` 文件中：
```
enable-ssh-support
```
接着，添加下列行到你的 `.bashrc` 文件中：
```
export SSH_AUTH_SOCK=$(gpgconf --list-dirs agent-ssh-socket)
```
为了让改变生效，你需要杀掉正在运行的 gpg-agent 进程，并重新启动一个新的登入会话：
```
$ killall gpg-agent
$ bash
$ ssh-add -L
```
最后的命令将列出代表你的 PGP Auth 密钥的 SSH（注释应该会在结束的位置显示： cardno:XXXXXXXX，表示它来自智能卡）。
为了启用 ssh 的基于密钥的登入，只需要在你要登入的远程系统上添加 `ssh-add -L` 的输出到 `~/.ssh/authorized_keys` 中。祝贺你，这将使你的 SSH 登入凭据更难以窃取。
此外，你可以从公共密钥服务器上下载其它人的基于 PGP 的 ssh 公钥，这样就可以赋予他登入 ssh 的权利：
```
$ gpg --export-ssh-key [keyid]
```
如果你有让开发人员通过 ssh 来访问 git 仓库的需要，这将让你非常方便。下一篇文章，我们将提供像保护你的密钥那样保护电子邮件帐户的小技巧。
---
via: <https://www.linux.com/blog/learn/pgp/2018/3/protecting-code-integrity-pgp-part-6-using-pgp-git>
作者：[KONSTANTIN RYABITSEV](https://www.linux.com/users/mricon) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
10 个供管理员救急的杀手级工具
|
Grant Hamono
|
https://opensource.com/article/18/7/tools-admin
|
可以让你赶快离开办公室的网络管理技巧和工具。
|
/data/attachment/album/201901/07/222713gl2xjjr2qz6rij29.png.thumb.jpg
|
/data/attachment/album/201901/07/222713gl2xjjr2qz6rij29.png
| true | false | true |
lujun9972
|
bestony
|
wxy
| false |
[
"系统管理"
] |
技术
|
{
"viewnum": 6603,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
可以让你赶快离开办公室的网络管理技巧和工具。
| 2019-01-07T22:27:01 | 2019-01-07T22:27:01 | 10,422 |
/article-10422-1.html
|
>
> 可以让你赶快离开办公室的网络管理技巧和工具。
>
>
>
当工作任务堆积成山时，管理网络和系统就变得十分有压力了。没有人能真正意识到需要花费多长时间，每个人都希望在昨天就完成他们的工作。
所以难怪我们这么多人都被致力于找出有效的方法并与大家分享的开源精神所吸引。因为，当截止日期来临，并且当天没有足够多的时间时，如果你可以找到立刻施行的免费答案，那会非常有帮助。
因此，闲话少叙，下述是我的瑞士军刀，可以保证你在晚饭前离开办公室。
### 服务器配置和脚本
让我们看一看！
* [NixCraft](https://www.cyberciti.biz/)
使用该网站的搜索功能。经过十多年的定期更新，这里遍地是黄金！有用的脚本和方便的技巧可以立刻解决你的问题。这是我一般使用 Google 后的第二个选项。
* [Webmin](http://www.webmin.com/)
它提供给你了一个很好的 Web 界面来帮助你远程编辑配置文件。它减少了在处理目录路径和 `sudo nano` 上花费的大量时间，在你处理多个客户时，非常方便。
* [Windows 下的 Linux 子系统](http://wsl-guide.org/en/latest/)
现代工作场所的现实是大多数员工都运行着 Windows，而服务器机房中不断增长的设备则运行着 Linux 。因此，有些时候你会发现尝试在 Windows 桌面上执行管理任务。
你怎么做？装一个虚拟机？如果安装目前 Windows 10 中免费提供的 Linux 子系统的兼容层，实际上要快得多，配置要少的多。
这为你提供了一个 Bash 终端窗口，你可以在这个窗口中执行本地计算机上的 Bash 脚本和 Linux 二进制文件，可以完全访问 Windows 和 Linux 文件系统，以及安装网络驱动器。它包含 Ubuntu 、OpenSUSE、SLES、Debian 和 Kali 发行版。
* [mRemoteNG](https://mremoteng.org/)
当你有 100 多个服务器需要去管理时，这会是一个出色的 SSH 和远程桌面客户端。
### 设置网络，这样你就无需再这样做了。
一个设计不周的网络是厌恶加班的管理员的死敌。
* [可拓展的 IP 寻址方案](https://blog.dxmtechsupport.com.au/ip-addressing-for-a-small-business-that-might-grow/)
IP 地址耗尽的可怕之处在于，当 IP 地址耗尽时，网络已经变的足够大，而新的寻址方案是众所周知的昂贵、令人痛苦的耗时。
没有人有时间做这件事！
到了某个时候，IPv6 终将到来，来拯救这世界。但在那之前，无论世界向我们扔了多少可穿戴设备、平板电脑、智能锁、灯、安全摄像头、VoIP 耳机和浓缩咖啡机，这些以不变应万变的 IP 寻址方案都应该让我们继续前行。
* [Linux Chmod 权限备忘录](https://isabelcastillo.com/linux-chmod-permissions-cheat-sheet)
一个简短但是有用的 Bash 命令备忘录可以帮助你通过网络设置权限。所以，客户服务部的账单落入到勒索软件骗局时，你可以只恢复他们的文件，而不是整个公司的文件。
* [VLSM 子网计算器](http://www.vlsm-calc.net/)
只需要输入你想要从地址空间中创建的网络的数量，以及每个网络所需要的主机数量，它就可以计算出所有的子网掩码应该是什么。
### 单一用途的 Linux 发行版
需要一个只做一件事的 Linux 容器？如果其他人已经在一个操作系统上搞好了一个小东西，你就可以快速安装它并马上投入使用。
下面这些每一个都使得我的工作变得轻松了许多。
* [Porteus Kiosk](http://porteus-kiosk.org/)
这个工具用来帮你把一台电脑上锁定到一个浏览器上。通过稍稍一些调整，你甚至可以把浏览器锁定在一个特定的网站上。它对于公共访问机器来说非常方便。它可以与触摸屏或键盘鼠标配合使用。
* [Parted Magic](https://partedmagic.com/)
这是一个你可以从 USB 驱动器启动的，可以用来划分磁盘驱动器、恢复数据并运行基准测试工具的操作系统。
* [IPFire](https://www.ipfire.org/)
啊哈～我还是不敢相信有人把路由器/防火墙/代理组合成为“我尿火”（LCTT 译注：IPFire 和 “I pee Fire“ 同音)。这是我在这个 Linux 发行版中第二喜欢的东西。我最喜欢的是它是一个非常可靠的软件套件，设置和配置十分容易，而且有一系列的插件可以拓展它。
那么，你呢？你发现了哪些工具、资源和备忘录可以让我们的工作日更加的轻松？我很高兴知道，请在评论中分享您的工具。
---
via: <https://opensource.com/article/18/7/tools-admin>
作者：[Grant Hamono](https://opensource.com/users/grantdxm) 选题：[lujun9972](https://github.com/lujun9972) 译者：[bestony](https://github.com/bestony) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
YAML：可能并不是那么完美
|
Martin Tournoij
|
https://arp242.net/weblog/yaml_probably_not_so_great_after_all.html
|
不要误解我的意思，并不是说 YAML 很糟糕 —— 它肯定不像使用 JSON 那么多的问题 —— 但它也不是非常好。
|
/static/image/common/nophoto.png
|
/static/image/common/nophoto.png
| true | false | true |
lujun9972
|
MjSeven
|
wxy
| false |
[
"YAML"
] |
观点
|
{
"viewnum": 8464,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
不要误解我的意思，并不是说 YAML 很糟糕 —— 它肯定不像使用 JSON 那么多的问题 —— 但它也不是非常好。
| 2019-01-07T23:51:00 | 2019-01-07T23:51:00 | 10,423 |
/article-10423-1.html
|
我之前写过[为什么将 JSON 用于人类可编辑的配置文件是一个坏主意](http://arp242.net/weblog/JSON_as_configuration_files-_please_dont.html)，今天我们将讨论 YAML 格式的一些常见问题。
### 默认情况下不安全
YAML 默认是不安全的。加载用户提供的（不可信的）YAML 字符串需要仔细考虑。
```
!!python/object/apply:os.system
args: ['ls /']
```
用 `print(yaml.load(open('a.yaml')))` 运行它，应该给你这样的东西：
```
bin etc lib lost+found opt root sbin tmp var sys
boot dev efi home lib64 mnt proc run srv usr
0
```
许多其他语言（包括 Ruby 和 PHP <sup id="fnref1"> <a href="#fn1" rel="footnote"> 1 </a></sup> ）默认情况下也不安全（LCTT 译注：这里应该说的是解析 yaml）。[在 GitHub 上搜索 yaml.load](https://github.com/search?q=yaml.load&type=Code&utf8=%E2%9C%93) 会得到惊人的 280 万个结果，而 [yaml.safe\_load](https://github.com/search?q=yaml.safe_load&type=Code&utf8=%E2%9C%93) 只能得到 26000 个结果。
提个醒，很多这样的 `yaml.load()` 都工作的很好，在配置文件中加载 `yaml.load()` 通常没问题，因为它通常（虽然并不总是！）来自“可靠源”，而且很多都来自静态的 YAML 测试文件。但是，人们还是不禁怀疑在这 280 万个结果中隐藏了多少漏洞。
这不是一个理论问题。在 2013 年，[正是由于这个问题，所有的 Ruby on Rails 应用程序都被发现易受](https://www.sitepoint.com/anatomy-of-an-exploit-an-in-depth-look-at-the-rails-yaml-vulnerability/)远程代码执行攻击。
有人可能会反驳说这不是 YAML 格式的错误，而是那些库实现错误的的问题，但似乎大多数库默认不是安全的（特别是动态语言），所以事实上这是 YAML 的一个问题。
有些人可能会反驳认为修复它就像用 `safe_load()` 替换 `load()` 一样容易，但是很多人都没有意识到这个问题，即使你知道它，它也是很容易忘记的事情之一。这是非常糟糕的 API 设计。
### 可能很难编辑，特别是对于大文件
YAML 文件可能很难编辑，随着文件变大，这个难度会快速增大。
一个很好的例子是 Ruby on Rails 的本地化翻译文件。例如：
```
en:
formtastic:
labels:
title: "Title" # Default global value
article:
body: "Article content"
post:
new:
title: "Choose a title..."
body: "Write something..."
edit:
title: "Edit title"
body: "Edit body"
```
看起来不错，对吧？但是如果这个文件有 100 行怎么办？或者 1,000 行？在文件中很难看到 “where”，因为它可能在屏幕外。你需要向上滚动，但是你需要跟踪缩进，即使遵循缩进指南也很难，特别是因为 2 个空格缩进是常态而且 [制表符缩进被禁止](http://www.yaml.org/faq.html) <sup id="fnref2"> <a href="#fn2" rel="footnote"> 2 </a></sup> 。
不小心缩进出错通常不算错误，它通常只是反序列化为你不想要的东西。这样只能祝你调试快乐！
我已经愉快地编写 Python 长达十多年，所以我已经习惯了显眼的空白，但有时候我仍在和 YAML 抗争。在 Python 中，虽然没有那种长达几页的函数，但数据或配置文件的长度没有这种自然限制，这就带来了缺点和损失了清晰度。
对于小文件，这不是问题，但它确实无法很好地扩展到较大的文件，特别是如果你以后想编辑它们的话。
### 这非常复杂
在浏览一个基本的例子时，YAML 看似“简单”和“显而易见”，但事实证明并非如此。[YAML 规范](http://yaml.org/spec/1.2/spec.pdf)有 23449 个单词，为了比较，[TOML](https://github.com/toml-lang/toml) 有 3339 个单词，[Json](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf) 有 1969 个单词，[XML](https://www.w3.org/TR/REC-xml/) 有 20603 个单词。
我们中有谁读过全部规范吗？有谁读过并理解了全部？谁阅读过，理解进而**记住**所有这些？
例如，你知道[在 YAML 中编写多行字符串有 9 种方法](http://stackoverflow.com/a/21699210/660921)吗？并且它们具有细微的不同行为。
是的 :-/
如果你看一下[那篇文章的修订历史](http://stackoverflow.com/posts/21699210/revisions)，它就会变得更加有趣，因为文章的作者发现了越来越多的方法可以实现这一点，以及更多的细微之处。
它从预览开始告诉我们 YAML 规范，它表明（强调我的）：
>
> 本节简要介绍了 YAML 的表达能力。**预计初次阅读的人不可能理解所有的例子**。相反，这些选择用作该规范其余部分的动机。
>
>
>
#### 令人惊讶的行为
以下会解析成什么（[Colm O’Connor](https://github.com/crdoconnor/strictyaml/blob/master/FAQ.rst#what-is-wrong-with-implicit-typing) 提供的例子）：
```
- Don Corleone: Do you have faith in my judgment?
- Clemenza: Yes
- Don Corleone: Do I have your loyalty?
```
结果为：
```
[
{'Don Corleone': 'Do you have faith in my judgment?'},
{'Clemenza': True},
{'Don Corleone': 'Do I have your loyalty?'}
]
```
那么这个呢：
```
python: 3.5.3
postgres: 9.3
```
`3.5.3` 被识别为字符串，但 `9.3` 被识别为数字而不是字符串：
```
{'python': '3.5.3', 'postgres': 9.3}
```
这个呢：
```
Effenaar: Eindhoven
013: Tilburg
```
`013` 是<ruby> 蒂尔堡 <rt> Tilburg </rt> <rt> </rt></ruby>的一个流行音乐场地，但 YAML 会告诉你错误答案，因为它被解析为八进制数字：
```
{11: 'Tilburg', 'Effenaar': 'Eindhoven'}
```
所有这一切，以及更多，就是为什么许多经验丰富的 YAMLer 经常会将所有字符串用引号引起来的原因，即使它不是严格要求。许多人不使用引号，而且很容易忘记，特别是如果文件的其余部分（可能由其他人编写）不使用引号。
### 它不方便
因为它太复杂了，它所声称的可移植性被夸大了。例如，考虑以下这个从 YAML 规范中获取的示例：
```
? - Detroit Tigers
- Chicago cubs
:
- 2001-07-23
? [ New York Yankees,
Atlanta Braves ]
: [ 2001-07-02, 2001-08-12,
2001-08-14 ]
```
抛开大多数读者可能甚至不知道这是在做什么之外，请尝试使用 PyYAML 在 Python 中解析它：
```
yaml.constructor.ConstructorError: while constructing a mapping
in "a.yaml", line 1, column 1
found unhashable key
in "a.yaml", line 1, column 3
```
在 Ruby 中，它可以工作：
```
{
["Detroit Tigers", "Chicago cubs"] => [
#<Date: 2001-07-23 ((2452114j,0s,0n),+0s,2299161j)>
],
["New York Yankees", "Atlanta Braves"] => [
#<Date: 2001-07-02 ((2452093j,0s,0n),+0s,2299161j)>,
#<Date: 2001-08-12 ((2452134j,0s,0n),+0s,2299161j)>,
#<Date: 2001-08-14 ((2452136j,0s,0n),+0s,2299161j)>
]
}
```
这个原因是你不能在 Python 中使用列表作为一个字典的键：
```
>>> {['a']: 'zxc'}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
```
而这种限制并不是 Python 特有的，PHP、JavaScript 和 Go 等常用语言都有此限制。
因此，在 YAML 文件中使用这种语法，你将无法在大多数语言中解析它。
这是另一个从 YAML 规范的示例部分中获取的：
```
# Ranking of 1998 home runs
---
- Mark McGwire
- Sammy Sosa
- Ken Griffey
# Team ranking
---
- Chicago Cubs
- St Louis Cardinals
```
Python 会输出：
```
yaml.composer.ComposerError: expected a single document in the stream
in "a.yaml", line 3, column 1
but found another document
in "a.yaml", line 8, column 1
```
然而 Ruby 输出：
```
["Mark McGwire", "Sammy Sosa", "Ken Griffey"]
```
原因是单个文件中有多个 YAML 文档（`---` 意味开始一个新文档）。在 Python 中，有一个 `load_all` 函数来解析所有文档，而 Ruby 的 `load()` 只是加载第一个文档，据我所知，它没有办法加载多个文档。
[在实现之间存在很多不兼容](https://github.com/cblp/yaml-sucks)。
### 目标实现了吗？
规范说明：
>
> YAML 的设计目标安装优先级降序排列如下：
>
>
> 1. YAML 很容易被人类阅读。
> 2. YAML 数据在编程语言之间是可移植的。
> 3. YAML 匹配敏捷语言的原生数据结构。
> 4. YAML 有一个一致的模型来支持通用工具。
> 5. YAML 支持一次性处理。
> 6. YAML 具有表现力和可扩展性。
> 7. YAML 易于实现和使用。
>
>
>
那么它做的如何呢？
>
> YAML 很容易被人类阅读。
>
>
>
只有坚持一小部分子集时才有效。完整的规则集很复杂 —— 远远超过 XML 或 JSON。
>
> YAML 数据在编程语言之间是可移植的。
>
>
>
事实并非如此，因为创建常见语言不支持的结构太容易了。
>
> YAML 匹配敏捷语言的原生数据结构。
>
>
>
参见上面。另外，为什么只支持敏捷（或动态）语言？其他语言呢？
>
> YAML 有一个一致的模型来支持通用工具。
>
>
>
我甚至不确定这意味着什么，我找不到任何详细说明。
>
> YAML 支持一次性处理。
>
>
>
这点我接受。
>
> YAML 具有表现力和可扩展性。
>
>
>
嗯，是的，但它太富有表现力（例如太复杂）。
>
> YAML 易于实现和使用。
>
>
>
```
$ cat `ls -1 ~/gocode/src/github.com/go-yaml/yaml/*.go | grep -v _test` | wc -l
9247
$ cat /usr/lib/python3.5/site-packages/yaml/*.py | wc -l
5713
```
### 结论
不要误解我的意思，并不是说 YAML 很糟糕 —— 它肯定不像[使用 JSON 那么多的问题](http://arp242.net/weblog/JSON_as_configuration_files-_please_dont.html) —— 但它也不是非常好。有一些一开始并不明显的缺点和惊喜，还有许多更好的替代品，如 [TOML](https://github.com/toml-lang/toml) 和其他更专业的格式。
就个人而言，当我有选择时，我不太可能再次使用它。
如果你必须使用 YAML，那么我建议你使用 [StrictYAML](https://github.com/crdoconnor/strictyaml)，它会删除一些（虽然不是全部）比较麻烦的部分。
### 反馈
你可以发送电子邮件至 [martin@arp242.net](mailto:martin@arp242.net) 或[创建 GitHub issue](https://github.com/Carpetsmoker/arp242.net/issues/new) 以获取反馈、问题等。
### 脚注
1. 在 PHP 中你需要修改一个 INI 设置来获得安全的行为，不能只是调用像 `yaml_safe()` 这样的东西。PHP 想尽办法让愚蠢的东西越发愚蠢。干得漂亮！ [↩](#fnref1)
2. 不要在这里做空格与制表符之争，如果这里可以用制表符的话，我可以（临时）增加制表符宽度来使它更易读——这是制表符的一种用途。 [↩](#fnref2)
---
via: <https://arp242.net/weblog/yaml_probably_not_so_great_after_all.html>
作者：[Martin Tournoij](https://arp242.net/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
极客漫画：当你雇佣了一个错误的架构师
|
Daniel Stori
|
http://turnoff.us/geek/wrong-architect/
|
这幅漫画讽刺了一些不懂架构的人，盲目使用复杂的、新的架构来尝试业务，建立了一堆无用的组件，但却不知道该怎么用这些组件完成需求。
|
/data/attachment/album/201901/08/104258rb8zuiu74ubghrzu.png.thumb.jpg
|
/data/attachment/album/201901/08/104258rb8zuiu74ubghrzu.png.large.jpg
| false | false | true |
bestony
|
wxy
| false |
[
"漫画"
] |
极客漫画
|
{
"viewnum": 13603,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "113.74.11.105",
"message": "太过真实",
"username": "等待时候 [Chrome 81.0|Windows 7]",
"date": "2020-05-13T14:37:30"
}
] |
[] |
这幅漫画讽刺了一些不懂架构的人，盲目使用复杂的、新的架构来尝试业务，建立了一堆无用的组件，但却不知道该怎么用这些组件完成需求。
| 2019-01-08T10:43:00 | 2019-01-08T10:43:00 | 10,424 |
/article-10424-1.html
|
这幅漫画讽刺了一些不懂架构的人，盲目使用复杂的、新的架构来尝试业务，建立了一堆无用的组件（灯/LAMP，即常见的 Linux+Apache+MySQL+PHP 网站架构），但却不知道该怎么用这些组件完成需求。
---
via: - <http://turnoff.us/geek/wrong-architect/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者&点评：[Besony](https://github.com/bestony) 校对：[wxy](https://github.com/wxy) 合成：[Bestony](https://github.com/bestony)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
怎样如软件工程师一样组织知识
|
Bruno Paz
|
https://dev.to/brpaz/how-do-i-organize-my-knowledge-as-a-software-engineer-4387
|
保存和组织所有这些信息可能是一项艰巨的任务。在这篇文章中，我将介绍一些我用来组织信息的工具。
|
/data/attachment/album/201901/08/153009n1wdrptp1i6peprq.jpg.thumb.jpg
|
/data/attachment/album/201901/08/153009n1wdrptp1i6peprq.jpg
| true | false | true |
oska874
|
wxy
|
wxy
| false |
[
"知识"
] |
分享
|
{
"viewnum": 5302,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
保存和组织所有这些信息可能是一项艰巨的任务。在这篇文章中，我将介绍一些我用来组织信息的工具。
| 2019-01-08T15:30:17 | 2019-01-08T15:30:17 | 10,425 |
/article-10425-1.html
|
总体上说，软件开发和技术是以非常快的速度发展的领域，所以持续学习是必不可少的。在互联网上花几分钟找一下，在 Twitter、媒体、RSS 订阅、Hacker News 和其它专业网站和社区等地方，就可以从文章、案例研究、教程、代码片段、新应用程序和信息中找到大量有用的信息。
保存和组织所有这些信息可能是一项艰巨的任务。在这篇文章中，我将介绍一些我用来组织信息的工具。
我认为在知识管理方面非常重要的一点就是避免锁定在特定平台。我使用的所有工具都允许以标准格式（如 Markdown 和 HTML）导出数据。
请注意，我的流程并不完美，我一直在寻找新工具和方法来优化它。每个人都不同，所以对我有用的东西可能不适合你。
### 用 NotionHQ 做知识库
对我来说，知识管理的基本部分是拥有某种个人知识库或维基。这是一个你可以以有组织的方式保存链接、书签、备注等的地方。
我使用 [NotionHQ](https://www.notion.so/) 做这件事。我使用它来记录各种主题，包括资源列表，如通过编程语言分组的优秀的库或教程，为有趣的博客文章和教程添加书签等等，不仅与软件开发有关，而且与我的个人生活有关。
我真正喜欢 NotionHQ 的是，创建新内容是如此简单。你可以使用 Markdown 编写它并将其组织为树状。
这是我的“开发”工作区的顶级页面：
[](https://res.cloudinary.com/practicaldev/image/fetch/s--uMbaRUtu--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/http://i.imgur.com/kRnuvMV.png)
NotionHQ 有一些很棒的其他功能，如集成了电子表格/数据库和任务板。
如果您想认真使用 NotionHQ，您将需要订阅付费个人计划，因为免费计划有所限制。我觉得它物有所值。NotionHQ 允许将整个工作区导出为 Markdown 文件。导出功能存在一些重要问题，例如丢失页面层次结构，希望 Notion 团队可以改进这一点。
作为一个免费的替代方案，我可能会使用 [VuePress](https://vuepress.vuejs.org/) 或 [GitBook](https://www.gitbook.com/?t=1) 来托管我自己的知识库。
### 用 Pocket 保存感兴趣的文章
[Pocket](https://getpocket.com/) 是我最喜欢的应用之一！使用 Pocket，您可以创建一个来自互联网上的文章的阅读列表。每当我看到一篇看起来很有趣的文章时，我都会使用 Chrome 扩展程序将其保存到 Pocket。稍后，我会阅读它，如果我发现它足够有用，我将使用 Pocket 的“存档”功能永久保存该文章并清理我的 Pocket 收件箱。
我尽量保持这个阅读清单足够小，并存档我已经处理过的信息。Pocket 允许您标记文章，以便以后更轻松地搜索特定主题的文章。
如果原始网站消失，您还可以在 Pocket 服务器中保存文章的副本，但是您需要 Pocket Premium 订阅计划。
Pocket 还具有“发现”功能，根据您保存的文章推荐类似的文章。这是找到可以阅读的新内容的好方法。
### 用 SnippetStore 做代码片段管理
从 GitHub 到 Stack Overflow 的答案，到博客文章，经常能找到一些你想要保存备用的好代码片段。它可能是一些不错的算法实现、一个有用的脚本或如何在某种语言中执行某种操作的示例。
我尝试了很多应用程序，从简单的 GitHub Gists 到 [Boostnote](https://boostnote.io/)，直到我发现 [SnippetStore](https://github.com/ZeroX-DG/SnippetStore)。
SnippetStore 是一个开源的代码片段管理应用。SnippetStore 与其他产品的区别在于其简单性。您可以按语言或标签整理片段，并且可以拥有多个文件片段。它不完美，但是可以用。例如，Boostnote 具有更多功能，但我更喜欢 SnippetStore 组织内容的简单方法。
对于我每天使用的缩写和片段，我更喜欢使用我的编辑器 / IDE 的代码片段功能，因为它更便于使用。我使用 SnippetStore 更像是作为编码示例的参考。
[Cacher](https://www.cacher.io/) 也是一个有趣的选择，因为它与许多编辑器进行了集成，他有一个命令行工具，并使用 GitHub Gists 作为后端，但其专业计划为 6 美元/月，我觉这有点太贵。
### 用 DevHints 管理速查表
[Devhints](https://devhints.io/) 是由 Rico Sta. Cruz 创建的一个速查表集合。它是开源的，是用 Jekyll 生成的，Jekyll 是最受欢迎的静态站点生成器之一。
这些速查表是用 Markdown 编写的，带有一些额外的格式化支持，例如支持列。
我非常喜欢其界面的外观，并且不像可以在 [Cheatography](https://cheatography.com/) 等网站上找到 PDF 或图像格式的速查表， Markdown 非常容易添加新内容并保持更新和进行版本控制。
因为它是开源，我创建了自己的分叉版本，删除了一些我不需要的速查表，并添加了更多。
我使用速查表作为如何使用某些库或编程语言或记住一些命令的参考。速查表的单个页面非常方便，例如，可以列出特定编程语言的所有基本语法。
我仍在尝试这个工具，但到目前为止它的工作很好。
### Diigo
[Diigo](https://www.diigo.com/index) 允许您注释和突出显示部分网站。我在研究新东西时使用它来注释重要信息，或者从文章、Stack Overflow 答案或来自 Twitter 的鼓舞人心的引语中保存特定段落！;）
---
就这些了。某些工具的功能方面可能存在一些重叠，但正如我在开始时所说的那样，这是一个不断演进的工作流程，因为我一直在尝试和寻找改进和提高工作效率的方法。
你呢？是如何组织你的知识的？请随时在下面发表评论。
谢谢你的阅读。
---
作者简介：Bruno Paz，Web 工程师，专精 #PHP 和 @Symfony 框架。热心于新技术。喜欢运动，@FCPorto 的粉丝！
---
via: <https://dev.to/brpaz/how-do-i-organize-my-knowledge-as-a-software-engineer-4387>
作者：[Bruno Paz](http://brunopaz.net/) 选题：[oska874](https://github.com/oska874) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 Linux 命令行中使用 nudoku 解决谜题
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-nudoku
|
数独是简单的逻辑游戏，它可以在任何地方玩，包括在 Linux 终端中。
|
/data/attachment/album/201901/08/183631eapvfqcd662vbpee.png.thumb.jpg
|
/data/attachment/album/201901/08/183631eapvfqcd662vbpee.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"数独"
] |
分享
|
{
"viewnum": 4014,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
数独是简单的逻辑游戏，它可以在任何地方玩，包括在 Linux 终端中。
| 2019-01-08T18:36:29 | 2019-01-08T18:36:29 | 10,426 |
/article-10426-1.html
|
>
> 数独是简单的逻辑游戏，它可以在任何地方玩，包括在 Linux 终端中。
>
>
>
欢迎回到我们为期 24 天的 Linux 命令行玩具日历。如果这是你第一次访问该系列，你甚至可能会问什么是命令行玩具。我们在考虑中，但一般来说，它可能是一个游戏，或任何简单的消遣，可以帮助你在终端玩得开心。
很可能你们中的一些人之前已经看过我们日历中的各种玩具，但我们希望每个人至少见到一件新事物。
每年圣诞节，我的岳母都会给我妻子一本数独日历。它接着会在我们的咖啡桌上呆上一年。每天都是一张单独的表格（星期六和星期日除外，它们合并在一页上），这样你每天都有一个新的谜题，同时还有一本能用的日历。
问题在于在实际中它是一本很好的谜题，但不是一本好的日历，因为事实证明有些日子的题目比其他日子更难，我们没有以每天一个的速度解决它们。然后，我们会在懒散的周日来解决这周堆积的谜题。
既然我在这个系列的一部分中介绍过[日历](https://opensource.com/article/18/12/linux-toy-cal)，那么在这里介绍数独也是公平的，除了我们的命令行版本是解耦的，因此将来很容易就能完成它。
我在 Fedora 的默认仓库中找到了 `nudoku`，因此安装它就像下面这样简单：
```
$ sudo dnf install nudoku
```
安装完后，只需输入 `nudoku` 即可启动它，之后的操作就很明了。如果你以前从未玩过数独，它它很容易：你只需要确保每行、每列、每个 3x3 构成的方块里都包含了 1-9 的所有数字。
你可在 [Github](https://github.com/jubalh/nudoku) 中找到 GPLv3 许可的 `nudoku` 源码
你有特别喜欢的命令行小玩具需要我介绍的吗？我们的日历基本上满了，但我们仍然希望在新的一年中展示一些很酷的命令行玩具。请在评论中留言，我会查看的。记得让我知道你对今天玩具的看法。
一定要看看昨天的玩具，[使用 Linux 终端庆祝丰年](https://opensource.com/article/18/12/linux-toy-figlet)，记得明天回来！
---
via: <https://opensource.com/article/18/12/linux-toy-nudoku>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用你的 Linux 终端庆祝新年
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-figlet
|
想让你的终端被记住么？将它打在横幅上，不要错过。
|
/data/attachment/album/201901/09/185007m01ysxbwrsg1r1ok.png.thumb.jpg
|
/data/attachment/album/201901/09/185007m01ysxbwrsg1r1ok.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"终端"
] |
分享
|
{
"viewnum": 4742,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
想让你的终端被记住么？将它打在横幅上，不要错过。
| 2019-01-09T18:50:06 | 2019-01-09T18:50:06 | 10,428 |
/article-10428-1.html
|
>
> 想让你的终端被记住么？将它打在横幅上，不要错过。
>
>
>
欢迎再次来到为期 24 天的 Linux 命令行玩具日历。如果这是你第一次访问该系列，你甚至可能会问自己什么是命令行玩具。我们也在思考，但一般来说，它可能是一个游戏，或任何简单的消遣，可以帮助你在终端玩得开心。
很可能你们中的一些人之前已经看过我们日历中的各种玩具，但我们希望每个人至少见到一件新事物。
今天的玩具是 `figlet`，一个在 Linux 终端上以横幅形式打印文本的程序。
你可能会再标准仓库中找到 `figlet`。在我的 Fedora 上，这意味着安装就像下面这样简单：
```
$ sudo dnf install figlet
```
之后，只需使用程序的名称来调用它。你可以以交互方式使用它，或者将一些文本通过管道输入，如下所示：
```
echo "Hello world" | figlet
_ _ _ _ _ _
| | | | ___| | | ___ __ _____ _ __| | __| |
| |_| |/ _ \ | |/ _ \ \ \ /\ / / _ \| '__| |/ _` |
| _ | __/ | | (_) | \ V V / (_) | | | | (_| |
|_| |_|\___|_|_|\___/ \_/\_/ \___/|_| |_|\__,_|
```
`figlet` 有许多不同的字体。要查看可用的字体，请尝试使用命令 `showfigfonts`。在我这里显示了十几个。我在下面复制了一些我的最爱。
```
block :
_| _| _|
_|_|_| _| _|_| _|_|_| _| _|
_| _| _| _| _| _| _|_|
_| _| _| _| _| _| _| _|
_|_|_| _| _|_| _|_|_| _| _|
bubble :
_ _ _ _ _ _
/ \ / \ / \ / \ / \ / \
( b | u | b | b | l | e )
\_/ \_/ \_/ \_/ \_/ \_/
lean :
_/
_/ _/_/ _/_/_/ _/_/_/
_/ _/_/_/_/ _/ _/ _/ _/
_/ _/ _/ _/ _/ _/
_/ _/_/_/ _/_/_/ _/ _/
script :
o
, __ ,_ _ _|_
/ \_/ / | | |/ \_|
\/ \___/ |_/|_/|__/ |_/
/|
\|
```
你可以在项目的[主页](http://www.figlet.org/)上找到有关 `figlet` 的更多信息。我下载的版本是以 MIT 许可开源的。
你会发现 `figlet` 不是唯一的 Linux 终端横幅打印机。另外一个你可以选择的是 [toilet](http://caca.zoy.org/wiki/toilet)，它有一套自己的 ASCII 艺术风格的打印选项。
你有特别喜欢的命令行小玩具需要我介绍的吗？我们的日历基本上满了，但我们仍然希望在新的一年中展示一些很酷的命令行玩具。请在评论中留言，我会查看的。记得让我知道你对今天玩具的看法。
一定要看看昨天的玩具，[使用 asciiquarium 在终端中游泳](https://opensource.com/article/18/12/linux-toy-asciiquarium)，记得明天回来！
---
via: <https://opensource.com/article/18/12/linux-toy-figlet>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
计算机实验室之树莓派：课程 0 简介
|
Robert Mullins
|
https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/introduction.html
|
这个课程简介不包含实践内容，但它解释了一个操作系统的基本概念、汇编代码、和其它很重要的一些基本原理。
|
/data/attachment/album/201901/09/225414hclxe1ymhcme5cmi.jpg.thumb.jpg
|
/data/attachment/album/201901/09/225414hclxe1ymhcme5cmi.jpg
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"树莓派"
] |
树莓派
|
{
"viewnum": 6191,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10458,
"displayorder": 0
}
] |
这个课程简介不包含实践内容，但它解释了一个操作系统的基本概念、汇编代码、和其它很重要的一些基本原理。
| 2019-01-09T19:37:00 | 2019-01-09T19:37:00 | 10,429 |
/article-10429-1.html
|
这个课程简介不包含实践内容，但它解释了一个操作系统的基本概念、汇编代码、和其它很重要的一些基本原理。如果你想直接进入实践环节，跳过本课程并不会有什么问题。
### 1、操作系统
操作系统就是一个非常复杂的程序。它的任务就是组织安排计算机上的其它程序，包括共享计算机的时间、内存、硬件和其它资源。你可能听说过的一些比较大的桌面操作系统家族有 GNU/Linux、Mac OS X 和 Microsoft Windows。其它的设备比如电话，也需要操作系统，它可能使用的操作系统是 Android、iOS 和 Windows Phone。 <sup id="fnref1"> <a href="#fn1" rel="footnote"> 1 </a></sup>
由于操作系统是用来与计算机系统上的硬件进行交互的，所以它必须了解系统上硬件专有的信息。为了能让操作系统适用于各种类型的计算机，发明了 **驱动程序** 的概念。驱动程序是为了能够让操作系统与特定的硬件进行交互而添加（并可删除）到操作系统上的一小部分代码。在本课程中，我们并不涉及如何创建可删除的驱动程序，而是专注于特定的一个硬件：树莓派。
操作系统有各种不同的设计方式，在本课程中，我们只触及操作系统设计的皮毛。本课程中，我们主要专注于操作系统与各种硬件的交互部分，因为这经常是比较棘手的部分，并且也是在网络上文档和帮助最少的部分。
### 2、汇编代码
>
> 处理器每秒可以执行上百万的指令，但是这些指令必须要简单。
>
>
>
本课程几乎要完全靠汇编代码来写。汇编代码非常接近计算机的底层。计算机其实是靠一个叫处理器的设备来工作的，处理器能够执行像加法这样的简单任务，还有一组叫做 RAM 的芯片，它能够用来保存数字。当计算机通电后，处理器执行程序员给定的一系列指令，这将导致内存中的数字发生变化，以及与连接的硬件进行交互。汇编代码只是将这些机器命令转换为人类可读的文本。
常规的编程就是，程序员使用编程语言，比如 C++、Java、C#、Basic 等等来写代码，然后一个叫编译器的程序将程序员写的代码转换成汇编代码，然后进一步转换为二进制代码。<sup id="fnref2"> <a href="#fn2" rel="footnote"> 2 </a></sup> 二进制代码才是计算机真正能够理解的东西，但它是人类无法读取的东西。汇编代码比二进制代码好一点，至少它的命令是人类可读的，但它仍然让人很沮丧。请记住，你用汇编代码写的每个命令都是处理器可以直接认识的，因此这些命令设计的很简单，因为物理电路必须能够处理每个命令。
和普通编程一样，也有很多不同的汇编代码编程语言，但与普通编程不一样的是，每个汇编编程语言是面对不同的处理器的，每种处理器设计为去理解不同的语言。因此，用一个针对某种机器设计的汇编语言所写的汇编代码，是不能在其它种类的机器上运行的。很多情况下，这都是一个大灾难，因此每个程序都必须在使用它的不同种类的机器上重写一遍，但对于操作系统，这不是个问题，因为在不同的硬件上它必须得重写。尽管如此，大多数操作系统都是用 C++ 或 C 来写的，这样它们就可以很容易地在不同种类的硬件上使用，只需要重写那些必须用汇编代码来实现的部分即可。
现在，你已经准备好进入第一节课了，它是 [课程 1 OK01](https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/ok01.html)。
---
1. 要查看更完整的操作系统列表，请参照：[操作系统列表 - Wikipedia](http://en.wikipedia.org/wiki/List_of_operating_systems) [↩](#fnref1)
2. 当然，我简化了普通编程的这种解释，实际上它在很大程度上取决于语言和机器。感兴趣的话，参见 [编译器 - Wikipedia](http://en.wikipedia.org/wiki/Compiler) [↩](#fnref2)
---
via: <https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/introduction.html>
作者：[Robert Mullins](http://www.cl.cam.ac.uk/%7Erdm34) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
区块链的生态系统
|
Vegard Nordahl & Meghana Rao
|
https://www.myblockchainblog.com/blog/the-blockchain-ecosystem
|
在这篇文章中，我们将讨论一个典型区块链的生态系统。这里说的生态系统，指的是不同的利益相关者及其相互之间，系统和外部世界间的相互作用。
|
/data/attachment/album/201901/10/124034f5oyfrsrgzf5ef3d.png.thumb.jpg
|
/data/attachment/album/201901/10/124034f5oyfrsrgzf5ef3d.png
| true | false | true |
jasminepeng
|
jasminepeng
|
wxy
| false |
[
"区块链"
] |
区块链
|
{
"viewnum": 6278,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "121.238.149.134",
"message": "有意思",
"username": "来自江苏苏州的 Chrome 108.0|Windows 10 用户",
"date": "2022-11-11T17:41:08"
}
] |
[] |
在这篇文章中，我们将讨论一个典型区块链的生态系统。这里说的生态系统，指的是不同的利益相关者及其相互之间，系统和外部世界间的相互作用。
| 2019-01-10T12:40:00 | 2019-01-10T12:40:00 | 10,431 |
/article-10431-1.html
|
### 介绍
在这篇文章中，我们将讨论一个典型区块链的生态系统。这里说的生态系统，指的是不同的利益相关者及其相互之间，系统和外部世界间的相互作用。我们将要探索的不同利益相关者是：
1. 用户
2. 投资者
3. 矿工
4. 开发商
了解这些利益相关者如何融入区块链生态系统，不仅可以让您更好地了解区块链的运作方式，还可以让您更好地评估其增长潜力。区块链对于上述每个利益相关者来说越有吸引力，就越有可能健康的增长。所以，不多说了，下面介绍区块链生态系统的丰富的特色。
### 用户
用户是使用区块链或加密货币实现某些目的的普通人，而不仅仅是投资者。为维护用户，加密货币必须具有一些实用程序（用于花费你的钱币）。让我们快速浏览三个最受欢迎的区块链，以了解它们当前和潜在的效用。
#### 比特币
比特币只有一个功能，即用于货物和服务的付款。在撰写本文时，全球约有 48,000 家（编者注：截止到 2018 年 9 月）商家接受比特币为商品和服务付款（[Coinbase](https://www.coinbase.com/clients?locale=en-US)）。事实上，包括 PayPal、Expedia、微软、赛百味、彭博、Reddit、戴尔、Steam、Whole Foods、Shopify 和 Webjet 在内的几个家用品牌和主要电子商务公司都将自己的名字添加到了不断增长的比特币商家名单中。未来十年，这个名单将不可避免地继续增长，并且在不远的将来的某个时候，比特币完全有可能像 Visa、AMEX 或万事达卡那样被广泛接受。这可以说意味着比特币目前比任何其他区块链更具实用性。与传统支付方式相比，比特币支付的优势在于：
* 更快的国际支付和交易
* 交易费用非常低
* 伪匿名
* 没有第三方介入
商家的额外好处包括：
* 没有 chargeback（编者注：Chargeback 是信用卡中的一个术语，意思是顾客可以声明一笔交易并非本人发起的。根据国家法律，这种情况往往商家或银行要负责对顾客的全额退款，是一种保护顾客的机制，但也给商家和银行增加了支付处理中的风险。）
* 额外的客户群
由于比特币的高效用，其生态系统的相当大部分由用户组成。从长期投资的角度来看，这非常好，因为它可以提高价格稳定性，并为投资者提供有详实的数据（用户增长，商家采用，交易数量等）以便预测其价格。
#### 以太坊
以太坊区块链与比特币区块链根本不同，因为它能够将智能合约嵌入区块链（见前一篇区块链历史介绍）。因此，以太坊为其用户提供了两种不同类型的应用：
货币应用：虽然不是以太坊的主要目标，但用户可以使用 Ether（以太币，以太坊区块链的加密货币）来支付商品和服务。一些公司（[TenX](https://www.tenx.tech/)、[Token Card](https://tokencard.io/)、[Monaco](https://mona.co/)）正在竞相通过其加密货币借记卡和 Coinify 等在线支付平台获取市场份额，为在线商家提供即插即用解决方案，以接受像以太币这样的加密货币作为支付。然而，目前，比特币仍然是加密货币的王者，以太和其他加密货币可能不得不追赶几年。
常规应用：这是指用户与基于以太坊区块链的 dApp 交互。已有数百个 dApp 允许用户以各种方式与以太坊区块链进行交互。例如，Numerai 是一种独特的对冲基金，它为世界各地的数据科学家提供加密市场数据，激励他们超越当前的交易算法并提高对冲基金的整体表现。还有一些彩票 dApp，以公平透明的方式提供彩票服务。然而，这只是一个开始。新的 dApp 每天都在发布，将来必定会有人开发出一款真正吸引公众注意力并引领下一波以太坊用户浪潮的 dApp。
可以在[此处](https://dapps.ethercasts.com/)找到以太坊区块链上所有 dApp 的列表。
#### 瑞波
市值排名第三的区块链是<ruby> 瑞波 <rt> Ripple </rt></ruby>。 瑞波与比特币和以太坊的不同之处在于它的设计考虑了一个特定的目标：为金融机构提供任何规模的安全，即时和近乎免费的全球交易。瑞波也与大多数区块链不同，因为它的目标用户是金融机构而不是私人。瑞波已经宣布与渣打银行和 UniCredit 等世界上大型金融机构建立合作伙伴关系，已经在区块链市场排行榜上获得第三名。
### 投资者
几乎所有区块链生态系统中的大多数利益相关者仍然是投资者。因此，加密货币市场仍然具有高度投机性，一天内价格波动 +/- 30％ 或更多并不罕见。区块链市场如此不稳定的部分原因是，评估加密货币或 dApp 的真正价值极其困难。该技术仍然年轻，由于实用性有限导致缺乏用户，因此很难预测在大规模采用时该技术将如何。
尽管投资区块链技术存在许多陷阱，但目前的市场条件实际上是一个有吸引力的投资机会：
* 专家、顾问和投资者几乎一致同意，区块链技术市场将在未来十年内继续快速增长（[麦肯锡](http://www.mckinsey.com/industries/high-tech/our-insights/how-blockchains-could-change-the-world)、[世界经济论坛](https://www.weforum.org/whitepapers/realizing-the-potential-of-blockchain)）
* 进入壁垒仍然很高，大多数人不愿意进入市场
* 虽然区块链在 2016 年和 2017 年都经历了令人难以置信的增长，但所有公共区块链的总市值仍然相对较小，约为 150 亿美元。为了更好地理解这一点，在撰写本文时，整个区块链行业的市值将只是世界第 50 大公司，位于荷兰的消费品公司联合利华之后。[HowMuch.net](https://howmuch.net/articles/worlds-money-in-perspective) 的这篇文章将加密货币的总市值与其他类型的资产进行了比较，并且展望了未来：
话虽如此，并非所有的区块链都是平等的……在接下来的几年里，我们无疑会看到很多初创公司倒闭或烧钱，导致投资者辛苦赚来的钱损失掉。我们将看到诈骗公司，其唯一目标是从愚蠢的投资者那里榨取资金。我们将看到来自成熟公司的激烈竞争，以开发自己的区块链应用程序。生活中没有任何东西是免费的。如果想把钱投入区块链，将不得不接受高风险。我们将有足够的时间在未来的博客文章中讨论投资策略，但现在我们将给您留下两个想法：
1. 在投资任何公司之前，请积极研究至少一周。向自己提出有关投资的一些棘手问题。如果您无法回答问题，请与社区和开发人员联系。如果他们采用某些主观信息来回答，要持怀疑态度。如果他们不能充分回答您的问题，那么不是说一定就要停止投资，但请注意它是一种风险，并在购买之前将其考虑在内。
2. 多样化。必须强调这一点。在接下来的几年里，很多公司都会陷入困境，如果你把所有的鸡蛋都放在一个篮子里，你不仅会冒失去钱的风险，还可能有失去对该行业中最终占据主导地位的公司投资机会的风险。
我认为在任何区块链生态系统中，有 4 种不同类型的投资者：
#### 新手
区块链市场的巨大增长和不断增加的宣传吸引了成千上万的新投资者。很大一部分投资者会被潜在的收益所吸引,而没有去充分了解这项技术。新手用自己的情绪做决定，而且没有比害怕这种情绪更强迫人行动的了。害怕失去钱，也害怕失去机会。因此，新手的买入价格经常过高。
同样，如果价格下跌超过其初始买入点 10-20％，由于害怕失去所有资金，新手经常会卖出。这在超级易变的区块链市场尤其危险。因此，新手经常会买高卖低卖。
[Vanguard](https://personal.vanguard.com/pdf/ISGPRINC.pdf) 的结论是：
1. 对于大多数私人非专业投资者来说，追求投机绩效常常影响回报率
2. 市场波动性越大，追逐绩效的负面影响就越大
在区块链市场上很难不扮演新手的角色。即使您有先前的投资经验，区块链市场的不确定性和极端波动性也将考验您的意志力和自制力。
#### 鲸鱼
鲸鱼是那些拥有庞大储备的大型投资者，他们可以使市场向某一个方向发展。
通常，订单约为 1-500 万美元或以上的人被视为鲸鱼。像这样的大订单足以显著影响大多数加密货币或区块链令牌。如果这种变化吸引了小玩家的注意，并对他们的钱进行相同的操作（如果价格上涨则买入，或者如果价格下降则卖出），鲸鱼可以在稍后的时间执行相反的操作以获取利润。
另一个深渊，即巨鲸。
巨鲸在这里指对冲基金和比特币投资基金，通常管理约 1 亿美元以上的投资组合。他们管理的资本过于庞大，一次下单市场常无法消化。他们通常会在一周或更长时间内将成千上万的比特币注入或流出市场，从而慢慢推动价格上涨或下跌，以满足他们自己的需求。
这些听起来可能令人难以置信，但区块链市场确实具有一些特征，使其成为具有正确手段和风险承受能力的高风险对冲基金的理想场所：
* 没有规定
* 相对较少的竞争
* 小市场给大型企业带来优势
* 大量缺乏经验的投资者
还有最后一个水下野兽，一个足以完全吞噬世界巨头并永远改变区块链市场的人。这里说的是政府投资者。政府可能有一天将加密货币作为一种多样化储备货币组合的方式，这种想法非常有趣，无疑会导致之前闻所未闻的价格水平 ([Coin Telegraph](https://cointelegraph.com/news/bitcoin-price-will-skyrocket-if-it-becomes-worlds-reserve-currency-by-2020))。
#### 套利者
套利者不断寻找并利用不同在线交易所之间的小价格差距。他们与数百家交易所相连，如果有机会，他们将在澳大利亚交易所买入低价并在瑞士交易所卖出高价。你可能认为套利者正在破坏区块链生态系统，但它们实际上发挥了一个非常特别和重要的功能。它们稳定了交易所的价格。他们就像大海的清洁工一样，总是在海底搜寻，以寻找市场上的不合理处。
#### 聪明的八爪鱼
这种投资者是你想成为的人！这种聪明的八足动物买得低，卖得很高。他们在做出决定之前进行了广泛的研究，并认识到风险和潜在的回报。这种聪明的八足动物认识到，利用加密货币的短期波动操作非常困难，要关注长期回报。他们避免情绪化决策，并通过价格波动坚持他们的投资，除非他们的投资有一些根本性的变化。这种聪明的八足动物认识到在区块链这样的新兴行业中识别赢家和输家是极其困难的。他们认识到总体行业风险，关注传统公司进入市场并密切关注他们的投资。
如果你发展出聪明的八爪鱼的特性，你将有很大机会在未来十年内为你的投资带来非常好的回报。
虽然很希望告诉你，我们属于最后一类，而且我们从未做过情绪化或恐惧驱动的决定，但事实并非如此。在这一点上，我们可能介于新手和聪明的八足动物之间。希望通过撰写此博客并继续获得区块链市场的经验，将在未来几年内把我们变成聪明的八足动物。我希望你能加入我们，成为这次旅程的积极参与者。我们可以共同学习和研究，做出更好的决策。
### 矿工
为了使区块链能够运行并保持其完整性，它需要世界各地的独立节点网络来持续维护它。在私有区块链中，中心组织拥有网络上的每个节点。而在公共区块链中，任何人都可以将其计算机设置为节点。这些计算机的所有者称为矿工。
由于区块链的完整性与网络上独立节点的数量直接相关，因此还需要一些挖矿激励。不同的区块链使用不同的采矿系统，但大多数采用以下形式：
* 激励系统：最常见的是微交易费用和块解决方案奖励的组合（比特币矿工每解决一个比特币块，获得 12.5 BTC 奖励。按照约定奖励着时间的推移逐渐减少）。
* 共识算法：所有区块链都需要一种验证广播到网络的块的方法。比特币区块链使用工作证明（PoW）。您将在下一篇文章中了解有关 PoW 如何工作的更多信息。以太坊也使用 PoW，但将更改为权益证明 (PoS）（以太坊区块链包含故意放置在代码中的 <ruby> 难度炸弹 <rt> difficulty bomb </rt></ruby>，以强制在某些时候更改为 PoS。之后将详细介绍）。
正如您将在下一篇文章中看到的那样，挖掘一个块是非常困难的，一台计算机需要多年来实现。因此，个体矿工组建了采矿行会，将他们的资源汇集在一起并分享回报。[blockchain.info](https://blockchain.info/pools?timespan=4days) 的资料显示了过去 4 天比特币区块链中每个采矿公会的相对哈希率（工作量）。
因为矿工需要保持区块链的完整性，所以他们拥有很大的权力。如果比特币社区想以这种或那种方式改变比特币协议，他们将不得不说服大多数矿工采用新代码。对现有区块链协议的更改称为分叉。潜在的分叉一直是采矿论坛上讨论的热门话题，没有中央权威就很难达成共识。
### 开发商
正如上一篇文章中所讨论的，区块链有可能变得不仅仅是加密货币。区块链世界中目前有两种类型的开发人员：
* 区块链开发人员
* dApp 开发人员
区块链开发人员构建具有不同功能级别的全新区块链。dApp 开发人员可以构建在区块链上运行的去中心化应用程序，从而为用户提供使用区块链（即实用程序）的理由。
以太坊推出的智能合约为渴望创造下一个重大事件的 dApp 开发者打开了大门。在评估区块链时，重要的是要考虑开发人员如何对其做出反应。有些问题要问自己，包括：
* 该平台允许开发人员使用哪些脚本语言？
* 社区是否有足够的活跃，能够说服开发人员花时间为该平台开发 dApp？
* 区块链中是否有一些特殊功能，当 dApp 开发人员无法在更受欢迎的区块链上创建其应用，而在这个区块链上可以？
* 区块链的可扩展性如何？如果它最终变得流行，代码是否能够处理大量的交易？
要充分利用区块链技术，您需要同时了解区块链和 dApp 开发中的最新消息。
### 结论
区块链生态系统复杂而充满活力。
了解这一点将使您能够做出更好的决策并充分利用这一新兴技术。你喜欢这篇博文吗？我们是否错过了任何利益相关者？您对不同的利益相关者及其对整个区块链生态系统的影响有何看法？你认为会看到政府在他们的储备中加入加密货币吗？
我们很乐意在下面的留言板上收到您的来信！如果您发现我们的内容有任何错误或错误，请随时通知我们，我们会及时更正。我们的下一篇文章将为您提供加密功能的概述，使区块链能够安全且伪匿名地工作。希望能在那里见到你！
---
via: <https://www.myblockchainblog.com/blog/the-blockchain-ecosystem>
作者：[Vegard Nordahl & Meghana Rao](https://www.myblockchainblog.com/blog/the-blockchain-ecosystem) 选题：[jasminepeng](https://github.com/jasminepeng) 译者：[jasminepeng](https://github.com/jasminepeng) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用 PGP 保护代码完整性（七）：保护在线帐户
|
Konstantin Ryabitsev
|
https://www.linux.com/blog/learn/pgp/2018/3/protecting-code-integrity-pgp-part-7-protecting-online-accounts
|
在这个系列的最后一篇当中，我们将为你展示如何用双因子认证保护你的在线账户。
|
/data/attachment/album/201901/10/231213u5qkg5zk39n9jcc5.jpg.thumb.jpg
|
/data/attachment/album/201901/10/231213u5qkg5zk39n9jcc5.jpg
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"PGP"
] |
技术
|
{
"viewnum": 4488,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 10421,
"displayorder": 0
}
] |
在这个系列的最后一篇当中，我们将为你展示如何用双因子认证保护你的在线账户。
| 2019-01-10T23:12:00 | 2019-01-10T23:12:00 | 10,432 |
/article-10432-1.html
|
>
> 在这个系列的最后一篇当中，我们将为你展示如何用双因子认证保护你的在线账户。
>
>
>
到目前为止，本系列教程已经提供了 PGP 的实用指南，包括基本概念和工具、生成和保护你的密钥的步骤。如果你错过了前面的文章，可以通过下面的链接查看。在本系列的最后一篇文章中，我们将为你保护在线帐户提供一个额外的指南，保护在线帐户是当今非常重要的一件事情。
* [第一部分：基本概念和工具](/article-9524-1.html)
* [第二部分：生成你的主密钥](/article-9529-1.html)
* [第三部分：生成 PGP 子密钥](/article-9607-1.html)
* [第四部分：将主密钥移到离线存储中](/article-10402-1.html)
* [第五部分：将子密钥移到硬件设备中](/article-10415-1.html)
* [第六部分：在 Git 中使用 PGP](/article-10421-1.html)
#### 清单
* 取得一个具备 U2F 功能的设备（必要）
* 为你的在线帐户启用双因子认证（必要）
+ GitHub/GitLab
+ Google
+ 社交媒体
* 使用 U2F 作为主验证机制，使用 TOTP 作为备选（必要）
#### 考虑事项
你可能注意到，很多在线开发者身份是捆绑了 email 地址的。如果有人能够访问你的邮箱，他们就能够去做一些对你会产生危害的事情，进而会损害你作为自由软件开发者的声誉。应该像保护你的 PGP 密钥那样保护你的 email 地址。
##### 使用 Fido U2F 的双因子认证
[双因子认证](https://en.wikipedia.org/wiki/Multi-factor_authentication) 是一种提升帐户安全性的机制，它除了要求用户名和密码之外，还要求一个物理令牌。它的目标是即便在有人窃取了你的密码（通过按键记录器、肩窥攻击或其它方式）的情况下，仍然能确保你的帐户安全，他们在没有得到你的一个专用的物理设备（“必备”的那个因子）的情况下，始终不能获取你的帐户。
广为人知的双因子认证机制有：
* 基于 SMS 的验证
* 借助智能手机应用程序的基于时间的一次性令牌（TOTP），比如 Google Authenticator 或类似解决方案
* 支持 Fido U2F 的硬件令牌
基于 SMS 的验证很容易配置，但是它有如下的缺点：它在没有手机信号的地方无法使用（比如，建筑物的地下室），并且如果攻击者能够阻断或转向 SMS 信息，这种方式可能就会失败，比如通过克隆你的 SIM 卡。
基于 TOTP 的多因子认证提供了比 SMS 更好的安全保护，但它也有一些重要的缺点（你要在智能手机中添加的那么多令牌中找到正确的那个）。此外，还不能避免一个事实，那就是你的密钥最终还是保存在你的智能手机中 —— 它是一个复杂的、全球连接的设备，它有可能还没有及时从制造商那儿收到安全补丁。
更重要的是，不论是使用 TOTP 还是 SMS 的方法来保护你免受诱骗攻击 —— 如果诱骗攻击者能够窃取你的帐户密码和双因子令牌，他们就可以在合法的站点上使用它们，访问你的帐户。
[Fido U2F](https://en.wikipedia.org/wiki/Universal_2nd_Factor) 是一个按标准开发的专用设备，它能够提供双因子认证机制来对付诱骗攻击。U2F 协议在 USB 令牌中保存每个站点的的唯一密钥，如果你在任何合法站点以外的地方尝试使用它，它将阻止你，以防范偶然让攻击者获得你的密码和一次性令牌。
Chrome 和 Firefox 都支持 U2F 双因子认证，希望其它浏览器也能够提供对 U2F 的支持。
#### 获得一个支持 Fido U2F 功能的令牌
支持 U2F 的硬件令牌的 [可选目标很多](http://www.dongleauth.info/dongles/)，但如果你已经订购了一个支持智能卡的物理设备，那么你最好的选择就是 Yubikey 4，它两者都支持。
#### 启用你的在线帐户的双因子认证
你要确定想启用双因子认证的在线账户，你的 email 提供商已经使用了（特别是 Google，它对 U2F 的支持非常好）。其它的站点这个功能应该是启用了：
* GitHub：当你上传你的 PGP 公钥时，你应该要想到，如果其他人能够获得访问你的帐户，他们可以用他们自己的 PGP 公钥替换掉你的 PGP 公钥。如果在 GitHub 上发布代码，你应该使用 U2F 认证来保护你的帐户安全。
* GitLab：理由同上
* Google：如果你有 google 帐户，你就惊奇地发现，许多帐户都允许以 Google 帐户来代替站点专用的认证来登入它们。
* Facebook：理由同上，许多在线站点都提供一个选择让你以 Facebook 的帐户来认证。即便你不使用 Facebook 也应该使用双因子认证来保护你的 Facebook 帐户。
* 你认为必要的其它站点。查看 [dongleauth.info](http://www.dongleauth.info/) 去找找灵感。
#### 如有可能，配置 TOTP 作为备选
许多站点都允许你配置多个双因子认证机制，推荐的设置是：
* U2F 令牌作为主认证机制
* TOTP 手机应用作为辅助认证机制
通过这种方式，即便你丢失了你的 U2F 令牌，你仍然能够重新获取对你的帐户的访问。或者，你可以注册多个 U2F 令牌（即：你可以用一个便宜的令牌仅用它做 U2F，并且将它用作备份）。
### 延伸阅读
到目前为止，你已经完成了下列的重要任务：
1. 创建你的开发者身份并使用 PGP 加密来保护它。
2. 通过将你的主密钥移到一个离线存储中并将子密钥移到一个外置硬件设备中的方式来配置你的环境，让窃取你的身份变得极为困难。
3. 配置你的 Git 环境去确保任何使用你项目的人都能够验证仓库的完整性和它的整个历史。
4. 使用双因子认证强化你的在线帐户。
在安全保护方面，你已经做的很好了，但是你还应该去阅读以下的主题：
* 如何去强化你的团队沟通。你的项目开发和治理决策的要求应该和保护提交代码那样去保护，如果不这样做，应该确保你的团队沟通是可信任的，并且所有决策的完整性是可验证的。
* 如何去强化你的工作站的安全。你的目标是尽可能减少导致项目代码被污染的危险或你的开发者身份被窃的行为。
* 如何写出安全的代码（查看相关编程语言和你项目所使用的库的各种文档）。即便引入它的提交代码上有一个 PGP 签名，糟糕的、不安全的代码仍然是糟糕的、不安全的代码！
---
via: <https://www.linux.com/blog/learn/pgp/2018/3/protecting-code-integrity-pgp-part-7-protecting-online-accounts>
作者：[Konstantin Ryabitsev](https://www.linux.com/users/mricon) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
5 款 Linux 街机游戏
|
Joshua Allen Holm
|
https://opensource.com/article/18/1/arcade-games-linux
|
本文首先介绍 Linux 开源游戏中的街机类型游戏，在之后的文章中，我将介绍桌面和卡牌游戏，解谜游戏，竞速游戏，以及策略模拟游戏。
|
/data/attachment/album/201901/11/095443vv2wgc6y3ihw43wz.jpg.thumb.jpg
|
/data/attachment/album/201901/11/095443vv2wgc6y3ihw43wz.jpg
| true | false | true |
Scoutydren
|
wxy
| false |
[
"游戏",
"街机"
] |
分享
|
{
"viewnum": 9680,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "223.104.212.204",
"message": "ubuntu 下载完了 如何运行游戏呢？？？",
"username": "来自223.104.212.204的 Microsoft Edge 18.18362|Windows 10 用户",
"date": "2020-07-10T17:58:53"
}
] |
[
{
"raid": 10492,
"displayorder": 0
}
] |
本文首先介绍 Linux 开源游戏中的街机类型游戏，在之后的文章中，我将介绍桌面和卡牌游戏，解谜游戏，竞速游戏，以及策略模拟游戏。
| 2019-01-11T09:54:40 | 2019-01-11T09:54:40 | 10,433 |
/article-10433-1.html
|
长久以来，游戏都是 Linux 的软肋。近些年，Steam、GOG 等游戏发布平台上不少商业游戏都开始支持 Linux，这对于 Linux 的游戏生态来说是件好事，但是我们能在这些平台上玩到的游戏通常是不开源的商业作品。当然，这些游戏在一个开源的操作系统上运行，但对于一个开源提倡者来说这似乎还不够纯粹。
那么，我们能找到既自由开源又能给玩家带来完整游戏体验的优质游戏吗？当然！虽然绝大多数的开源游戏很难和 3A 商业游戏大作竞争，但仍然有不少各种类型的开源游戏，不仅内容有趣而且直接可以通过几大 Linux 发行版本库中直接安装。
本文首先介绍 Linux 开源游戏中的街机类型游戏，在之后的文章中，我将介绍桌面和卡牌游戏，解谜游戏，竞速游戏，以及策略模拟游戏。
### <ruby> 太空危机 <rt> AstroMenace </rt></ruby>
[太空危机](http://www.viewizard.com/) 是一个近现代太空背景下的滚动页面射击游戏。开发初期它是一个闭源游戏，但它的代码和素材而后以开源许可证发布了。游戏玩法和大多数此类游戏大同小异，但它有质量极高的 3D 画面。飞船和武器升级可以通过击杀敌人所获得的点数购买。游戏的难度可以选择，因此适合新手以及想要追求挑战的硬核玩家。
安装太空危机，你只需要在终端下运行以下指令：
* Fedora 用户： `dnf install astromenace`
* Debian/Ubuntu 用户： `apt install astromenace`
### <ruby> 坦克战役 <rt> Battle Tanks </rt></ruby>
[坦克战役](http://btanks.sourceforge.net/blog/about-game) 是一个俯瞰式视角的快节奏坦克战斗游戏。玩家可以选择三种不同的陆地坦克，操纵其在地图上前行，收集道具并且尝试炸飞敌军。它有四种游戏模式，死亡竞赛（又称“死斗”）、团队死斗、夺旗模式和合作模式。死斗和夺旗模式下，分别有 9 张地图可供玩家选择，合作模式则有 4 张。该游戏支持分屏本地双人游戏，以及在线多人竞技。游戏节奏很快，默认一次战役仅 5 分钟，因此，坦克战役十分适合想要利用零碎时间快速来一局的玩家。
安装坦克战役，你只需要在终端下运行以下指令：
* Fedora 用户： `dnf install btanks`
* Debian/Ubuntu 用户： `apt install btanks`
### <ruby> 火星 <rt> M.A.R.S. </rt></ruby>
[火星](http://mars-game.sourceforge.net/?page_id=10) 是一个自上而下的太空射击游戏，游戏机制类似传统街机游戏 “<ruby> 爆破彗星 <rt> Asteroids </rt></ruby>”。玩家在操控一个太空船的同时向敌方射击并躲避敌军的弹幕射击。游戏有标准的死斗和团体死斗模式，除此之外也有更新鲜的比赛形式 —— 例如在一个模式下，玩家需要控制一个球使其进入敌方母星。该游戏支持本地多人游戏，但遗憾的是不支持多人联机。该游戏的开发更新似乎已经停止，所以该游戏之后增加联机模式的几率很小，但就算没有联机支持，这个游戏仍然值得一试。
安装火星，你只需要在终端下运行以下指令：
* Fedora 用户： `dnf install marsshooter`
* Debian/Ubuntu 用户： `apt install marsshooter`
### <ruby> 不存在之球 <rt> Neverball </rt></ruby>
[不存在之球](https://neverball.org/index.php) 的游戏灵感来源自世嘉的 “<ruby> 超级猴子球 <rt> Super Monkey Ball </rt></ruby>” ，玩家需要将一个球在 3D 球场上运动起来，但是玩家控制的不是球，而是球场。游戏任务是在规定的时限内，收集足够多的金币从而打开该关卡的出口并且将小球落进该洞中。游戏可以调整难度，从休闲到难以超乎想象，可以适应不同的玩家需求。该游戏支持键盘/鼠标以及控制杆操作。
安装不存在之球，你只需要在终端下运行以下指令:
* Fedora 用户：`dnf install neverball`
* Debian/Ubuntu 用户：`apt install neverball`
### <ruby> 超级 Tux <rt> SuperTux </rt></ruby>
[超级 Tux](http://supertux.org/) 是继任天堂超级马里奥后的一款 2D 的平台跳跃游戏。Linux 的吉祥物企鹅 Tux 代替了马里奥，而鸡蛋对应着马里奥系列中的蘑菇能力提升。当 Tux 获得了鸡蛋得到了能力提升，它便可以收集花朵，而花朵可以带来新的附加特殊能力。火焰花在关卡中最为常见，收集了火焰花的 Tux 可以掷出火球。除此之外，冰冻花/空气花/土地花也在游戏的程序中。收集星星的能力提升能使 Tux 暂时变得隐形，就如同马里奥系列游戏。该游戏最基础的一组关卡，冰之岛也有 30 关之多，因此游戏的内容和流程和超级马里奥系列一般长。SuperTux 还有一些附加关卡，例如三个额外奖励小岛、一个森林之岛、一个万圣节岛、一个孵化处，以及很多测试关卡。SuperTux 有一个自带的关卡编辑器，所以玩家可以创建他们的原创关卡。
安装超级 Tux，你只需要在终端下运行以下指令:
* Fedora 用户：`dnf install supertux`
* Debian/Ubuntu 用户: `apt install supertux`
如果我没有在上文中提及你最喜欢的开源街机游戏，欢迎在评论中分享。
### 有关作者
Joshua Allen Holm - 是 Opensource.com 的社区协调者之一。他的主要兴趣有数字人文、学术开放以及公开教育资源。你可以在 GitHub、GitLab、LinkedIn 和 Zotero 上找到他。可以通过 [holmja@opensource.com](mailto:holmja@opensource.com) 联系到他。
---
via: <https://opensource.com/article/18/1/arcade-games-linux>
作者：[Joshua Allen Holm](https://opensource.com/users/holmja) 译者：[Scoutydren](https://github.com/Scoutydren) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
如何使用 Ansible 管理你的工作站配置
|
Jay Lacroix
|
https://opensource.com/article/18/3/manage-workstation-ansible
|
在这个系列的第一篇中，学习一下管理笔记本电脑和台式机配置的基础内容。
|
/data/attachment/album/201901/11/224838rank1a1gj3131kma.jpg.thumb.jpg
|
/data/attachment/album/201901/11/224838rank1a1gj3131kma.jpg
| true | false | true |
wxy
|
wxy
| false |
[
"Ansible"
] |
技术
|
{
"viewnum": 4832,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "183.128.92.239",
"message": "好东西",
"username": "来自浙江杭州的 Chrome 71.0|Mac 10.14 用户",
"date": "2019-01-24T14:50:07"
}
] |
[
{
"raid": 10449,
"displayorder": 0
}
] |
在这个系列的第一篇中，学习一下管理笔记本电脑和台式机配置的基础内容。
| 2019-01-11T22:48:46 | 2019-01-11T22:48:46 | 10,434 |
/article-10434-1.html
|
>
> 在这个系列的第一篇中，学习一下管理笔记本电脑和台式机配置的基础内容。
>
>
>
配置管理是服务器管理和 DevOps 的一个非常重要的方面。“<ruby> 基础架构即代码 <rt> infrastructure as code </rt></ruby>”方法可以轻松地以各种配置部署服务器，并动态扩展组织的资源以满足用户需求。但是，对于希望自动设置自己的笔记本电脑和台式机（工作站）的个人管理员的关注较少。
在本系列中，我将向你展示如何通过 [Ansible](https://www.ansible.com/) 自动化你的工作站设置，如果你想要或需要重新安装你的机器，这可以让你轻松恢复整个配置。此外，如果你有多个工作站，则可以使用相同的方法在每个工作站上进行相同的配置。在第一篇文章中，我们将为个人或工作计算机设置基本的配置管理，并为本系列的其余部分奠定基础。到本文结束时，你将会因此得到一个可以工作的环境。本系列之后的每篇文章都会自动化更多内容并增加复杂性。
### 为什么用 Ansible？
有许多配置管理解决方案，包括 Salt Stack、Chef 和 Puppet。我更喜欢 Ansible，因为它在资源利用方面更轻量级，语法更容易阅读，并且如果正确使用它可以彻底改变你的配置管理。Ansible 的轻量级特性与这个主题特别相关，因为我们可能不希望运行一整台服务器而只是为了自动化我们的笔记本电脑和台式机的设置。一般我们总是想要快一些；我们可以使用某些东西来快速启动和运行，以在我们需要恢复的工作站或在多台机器之间同步我们的配置。我使用 Ansible 的具体方法（我将在本文中演示）非常适用于此，而不需要维护服务器。你只需下载配置并运行它。
### 我的方法
通常，Ansible 运行于中央服务器。它使用一个<ruby> 库存清单 <rt> inventory </rt></ruby>文件，该文件是一个文本文件，其中包含我们希望 Ansible 管理的所有主机及其 IP 地址或域名的列表。这对于静态环境非常有用，但对于工作站来说并不理想。原因是我们真的不知道我们的工作站在某一时刻的状态。也许我关闭了台式电脑，或者笔记本电脑可能会被挂起并放在我的包里。在任何一种情况下，Ansible 服务器都会抱怨，因为如果它们处于脱机状态，Ansible 就无法联系到我的机器。我们更需要的是按需方式，我们通过利用 `ansible-pull` 来实现这一目标。`ansible-pull` 命令是 Ansible 的一个命令，允许你从 Git 仓库下载配置并立即应用它。你不需要维护服务器或库存清单；你只需运行 `ansible-pull` 命令，给它一个 Git 仓库 URL，它将为你完成剩下的工作。
### 起步
首先，在要管理的计算机上安装 Ansible。有一个问题是许多发行版都附带了旧版本的 Ansible。根据经验，你肯定希望获得最新版本。Ansible 中经常引入新功能，如果你运行的是旧版本，则你在网上找到的示例语法可能无法正常运行，因为它使用的功能未在你安装的版本中实现。甚至发布的小版本都有很多新功能。其中一个例子是 `dconf` 模块，它是从 Ansible 2.4 开始的新功能。如果你尝试使用使用此模块的语法，除非你使用 2.4 或更新版本，否则会失败。在 Ubuntu 及其衍生产品中，我们可以使用官方个人包存档（[PPA](https://launchpad.net/ubuntu/+ppas)）轻松安装最新版本的 Ansible。以下命令可以解决这个问题：
```
sudo apt-get install software-properties-common
sudo apt-add-repository ppa:ansible/ansible
sudo apt-get update
sudo apt-get install ansible
```
如果你没有使用 Ubuntu，请参阅 [Ansible 的文档](http://docs.ansible.com/ansible/latest/intro_installation.html) 了解如何为你的平台获取它。
接下来，我们需要一个 Git 仓库来保存我们的配置。满足此要求的最简单方法是在 GitHub 上创建一个空的仓库，或者如果有的话，也可以使用自己的 Git 服务器。为了简单起见，我假设你正在使用 GitHub，因此如果你正在使用其他仓库，请相应调整命令。在 GitHub 中创建一个仓库；你最终会得到一个与此类似的仓库 URL：
```
git@github.com:<your_user_name>/ansible.git
```
将该仓库克隆到你的本地工作目录（忽略任何抱怨仓库为空的消息）：
```
git clone git@github.com:<your_user_name>/ansible.git
```
现在我们有了一个可以使用的空仓库。将你的工作目录切换到仓库（例如 `cd ./ansible`），并在你喜欢的文本编辑器中创建名为 `local.yml` 的文件。将以下配置放在该文件中：
```
- hosts: localhost
become: true
tasks:
- name: Install htop
apt: name=htop
```
你刚刚创建的文件被称为<ruby> 剧本 <rt> playbook </rt></ruby>，安装 `htop` 的指令（我任意选择的一个包作为例子）被称为<ruby> 动作 <rt> play </rt></ruby>。剧本本身是一个 YAML 格式的文件，它是一种易于阅读的标记语言。对 YAML 的完整讲述超出了本文的范围，但你无需专业理解即可熟练使用 Ansible。该配置易于阅读；只需查看此文件，你就可以轻松理解我们正在安装的 `htop` 软件包。要注意一下最后一行的 `apt` 模块，它只适用于基于 Debian 的系统。如果你使用的是 Red Hat 平台，你可以将其更改为 `yum` 而不是 `apt`，或者如果你正在使用 Fedora，则将其更改为 `dnf`。`name` 行只是提供有关我们任务的信息，并将显示在输出中。因此，你需要确保名称具有描述性，以便在需要对多个动作进行故障排除时很容易找到。
接下来，让我们将新文件提交到我们的仓库：
```
git add local.yml
git commit -m "initial commit"
git push origin master
```
现在我们的新剧本应该出现在我们的 GitHub 上的仓库中。我们可以使用以下命令应用我们创建的剧本：
```
sudo ansible-pull -U https://github.com/<your_user_name>/ansible.git
```
如果执行正确，`htop`包应该会安装在你的系统上。你可能会在开头附近看到一些警告，抱怨缺少库存清单文件。这很好，因为我们没有使用库存清单文件（我们也不需要这样做）。在输出结束时，它将概述它做的内容。如果 `htop` 安装正确，你应该在输出的最后一行看到 `changed = 1`。
它是如何工作的呢？`ansible-pull` 命令使用了 `-U` 选项，它需要一个仓库 URL。出于安全考虑，我给它提供了仓库 URL 的 https 版本，因为我不希望任何主机对仓库具有写访问权限（默认情况下 https 是只读的）。`local.yml` 是预设的剧本名称，因此我们不需要为剧本提供文件名：如果它在仓库的根目录中找到名为 `local.yml` 的剧本，它将自动运行它。接下来，我们在命令前面使用了 `sudo`，因为我们正在修改系统。
让我们继续为我们的剧本添加更多的包。我将添加两个包，使它看起来像这样：
```
- hosts: localhost
become: true
tasks:
- name: Install htop
apt: name=htop
- name: Install mc
apt: name=mc
- name: Install tmux
apt: name=tmux
```
我添加了更多的动作（任务）来安装另外两个包，`mc` 和 `tmux`。在此剧本中选择安装的哪些软件包并不重要；我只是随意挑选这些。你应该安装你希望所有的系统都具有的软件包。唯一需要注意的是，在你分发前，你必须知道那个包存在于软件仓库中。
在我们提交并应用这个更新的剧本之前，我们应该整理一下它。它可以很好地工作，但（说实话）它看起来有点混乱。让我们尝试在一个动作中安装所有三个包。用下面这个替换你的 `local.yml` 的内容：
```
- hosts: localhost
become: true
tasks:
- name: Install packages
apt: name={{item}}
with_items:
- htop
- mc
- tmux
```
现在看起来更干净、更有效率了。我们使用 `with_items` 将我们的包列表合并为一个动作。如果我们想要添加其他包，我们只需添加另一个带有连字符和包名称的行。可以把 `with_items` 看做类似于 `for` 循环。我们列出的每个包都将安装。
将我们的新更改提交回仓库：
```
git add local.yml
git commit -m "added additional packages, cleaned up formatting"
git push origin master
```
现在我们可以运行我们的剧本以接受新的新配置：
```
sudo ansible-pull -U https://github.com/<your_user_name>/ansible.git
```
不可否认，这个例子还没有做多少事情；它所做的就是安装一些软件包。你可以使用包管理器更快地安装这些包。然而，随着这个系列的继续，这些例子将变得更加复杂，我们将自动化更多的东西。最后，你创建的 Ansible 配置将自动执行越来越多的任务。例如，我自己使用的那个配置可以自动安装数百个软件包、设置cron 作业、处理桌面配置等等。
从我们迄今为止所取得的成就来看，你可能已经有了大概了解。我们所要做的就是创建一个仓库，在该仓库中放置一个剧本，然后利用 `ansible-pull` 命令拉取该仓库并将其应用到我们的机器上。我们不需要设置服务器。将来，如果我们想要更改配置，我们可以拉取该仓库、更新它，然后将其推回到我们的仓库并应用它。如果我们要设置新机器，我们只需要安装 Ansible 并应用配置。
在下一篇文章中，我们将通过 cron 和一些其他项目进一步自动化。与此同时，我已将本文的代码复制到 [我的 GitHub 仓库](https://github.com/jlacroix82/ansible_article) 中，以便你可以用你的语法对比一下我的。随着我们的进展，我会不断更新代码。
---
via: <https://opensource.com/article/18/3/manage-workstation-ansible>
作者：[Jay LaCroix](https://opensource.com/users/jlacroix) 译者：[wxy](https://github.com/) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
在 Linux 终端中玩贪吃蛇
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-snake
|
有了这个 20 世纪 70 年代的经典重制游戏，Python 将不再是你在 Linux 终端能发现的唯一的“蛇”。
|
/data/attachment/album/201901/12/104301hucp64f1cj1o47mz.png.thumb.jpg
|
/data/attachment/album/201901/12/104301hucp64f1cj1o47mz.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"贪吃蛇"
] |
分享
|
{
"viewnum": 9095,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "221.11.67.243",
"message": "安装 Emacs，M-x snake 就能在终端玩蛇了。",
"username": "来自陕西西安的 Firefox 64.0|GNU/Linux 用户",
"date": "2019-01-19T09:29:28"
}
] |
[] |
有了这个 20 世纪 70 年代的经典重制游戏，Python 将不再是你在 Linux 终端能发现的唯一的“蛇”。
| 2019-01-12T10:42:59 | 2019-01-12T10:42:59 | 10,435 |
/article-10435-1.html
|
>
> 有了这个 20 世纪 70 年代的经典重制游戏，Python 将不再是你在 Linux 终端能发现的唯一的“蛇”。
>
>
>
欢迎回到 Linux 命令行玩具日历。如果这是你第一次访问该系列，你可能会问什么是命令行玩具。这很难确切地说，但我的定义是任何可以帮助你在终端玩得开心的东西。
我们这周都在介绍游戏，这很有趣，接着让我们看下今天的游戏，贪吃蛇！
贪吃蛇是一个古老又很好的游戏，这些年一直有各种版本。我记得我第一次玩得版本是 20 世纪 90 年代与 [QBasic](https://en.wikipedia.org/wiki/QBasic) 一起打包发布的 [Nibbles](https://en.wikipedia.org/wiki/Nibbles_(video_game))，它对我理解什么是编程语言起了很重要的作用。我有游戏的源码，我可以修改并查看会发生什么，并学习到一些组成这个编程语言的有趣词汇究竟是什么意思。
今天的[贪吃蛇](https://github.com/DyegoCosta/snake-game)是用 Go 写的，它很简单并且和原版的游戏一样有趣。像大多数简单的老游戏一样，它有很多版本可供选择。这今天的贪吃蛇中，甚至还有一个经典的 [bsdgames](https://github.com/vattam/BSDGames) 形式的包，它的发行版几乎一定有它。
但我喜欢的是用 Docker 打包的贪吃蛇，因为我可以轻松地在命令行中运行，而不用担心发行版相关的问题。这个版本使用 15 个随机的食物 emoji 图案让蛇来吃。我玩得不好。不管怎样，请试一下：
```
$ docker run -ti dyego/snake-game
```
这个贪吃蛇以 MIT 许可证开源，你可在 [Github](https://github.com/DyegoCosta/snake-game) 取得源码。
你有特别喜欢的命令行小玩具需要我介绍的吗？这个系列要介绍的小玩具大部分已经有了落实，但还预留了几个空位置。请在评论区留言，我会查看的。如果还有空位置，我会考虑介绍它的。如果没有，但如果我得到了一些很好的意见，我会在最后做一些有价值的提及。
请查看昨天的玩具，[数字 2 的力量，Linux 的力量：在命令行中玩 2048](https://opensource.com/article/18/12/linux-toy-2048)，记得明天再来！
---
via: <https://opensource.com/article/18/12/linux-toy-snake>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
能从远程获得乐趣的 Linux 命令
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-remote
|
使用这些工具从远程了解天气、阅读资料等。
|
/data/attachment/album/201901/12/153112se1b7tf780eb1011.png.thumb.jpg
|
/data/attachment/album/201901/12/153112se1b7tf780eb1011.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"终端"
] |
分享
|
{
"viewnum": 5441,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
使用这些工具从远程了解天气、阅读资料等。
| 2019-01-12T15:31:07 | 2019-01-12T15:31:07 | 10,437 |
/article-10437-1.html
|
>
> 使用这些工具从远程了解天气、阅读资料等。
>
>
>
我们即将结束为期 24 天的 Linux 命令行玩具日历。希望你有一直在看，如果没有，请回到[开始](https://opensource.com/article/18/12/linux-toy-boxes)，从头看过来。你会发现 Linux 终端有很多游戏、消遣和奇怪之处。
虽然你之前可能已经看过我们日历中的一些玩具，但我们希望每个人都遇见一个新事物。
今天的玩具（实际是玩具集合）有点不同。到目前为止，我主要是想把重点放在那些独立的玩具上，并且完全可在开源许可下使用。但是我从读者那里得到了一些很好的建议，利用开源工具远程访问一些开源或者不开源的东西。今天，我将介绍其中的一些。
第一个是经典之作：使用 Telnet 观看星球大战的 ASCII 演绎版本。你的系统可能已经安装了 Telnet，因此你只需运行：
```
$ telnet towel.blinkenlights.nl
```
我第一次看到它是十年之前，因此我对于它还存在有点惊奇。如果你还没看过，请留出一点时间看一下。你不会后悔的。
接下来，Opensource.com 的撰稿人 [Manuel Dewald](https://opensource.com/users/ntlx) 提出了一种从终端获取当地天气的方法。它很简单，你只需安装 `curl`（或者，`wget`）。
```
$ curl wttr.in
```
最后，在假期中虽然你可以从[命令行 Web 浏览器](https://opensource.com/article/16/12/web-browsers-linux-command-line)浏览你喜欢的网站（包括 Opensource.com），但有一些我最喜欢的网站可以通过专用客户端更轻松地浏览。其中两个是 Reddit 和 Hacker News，有人推荐给我一些它们的客户端，你可能也想尝试，它们都使用开源许可。我尝试过 [haxor-news](https://github.com/donnemartin/haxor-news) （Hacker News） 和 [rtv](https://github.com/michael-lazar/rtv) （Reddit），它们都还不错。
你有特别喜欢的命令行小玩具需要我介绍的吗？提交今年的建议有点晚了，但我们仍然希望在新的一年里有一些很酷的命令行玩具。请在下面的评论中告诉我，我会查看的。让我知道你对今天的玩具有何看法。
一定要看看昨天的玩具，[在 Linux 终端收看 Youtube 视频](https://opensource.com/users/ntlx)，明天还要再来！
---
via: <https://opensource.com/article/18/12/linux-toy-remote>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 Linux 中移除从源代码安装的程序的一种简单的方法
|
Sk
|
https://www.ostechnix.com/an-easy-way-to-remove-programs-installed-from-source-in-linux/
|
GNU Stow 是一个符号链接归集管理器，它可以收集文件系统上不同目录中的不同软件和/或数据包，使它们看起来像是一个整体。
|
/data/attachment/album/201901/12/235455jw7erex3e3d3cdmq.jpg.thumb.jpg
|
/data/attachment/album/201901/12/235455jw7erex3e3d3cdmq.jpg
| true | false | true |
lujun9972
|
dianbanjiu
|
wxy
| false |
[
"源代码",
"安装"
] |
技术
|
{
"viewnum": 5960,
"commentnum": 0,
"favtimes": 5,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
GNU Stow 是一个符号链接归集管理器，它可以收集文件系统上不同目录中的不同软件和/或数据包，使它们看起来像是一个整体。
| 2019-01-12T23:54:00 | 2019-01-12T23:54:00 | 10,438 |
/article-10438-1.html
|
不是所有的程序都可以在官方或者第三方库中找到，因此你不能使用常规的包管理来安装它们。有时你不得不从源代码中手动构建这些程序。就如你已经知道的一样，当你从源代码中安装一个程序的时候，这个软件包所包含的文件将会复制到本地的多个位置，例如 `/usr/local/bin`、`/usr/local/etc/`。如果从源代码中安装的程序没有内置的卸载程序，当你不再需要这个程序的时候，卸载它就会很麻烦。你可能会花费双倍（甚至更多）的时间找出这些文件然后手动删除它们。我以前一直是这样做的，直到我发现了 GNU Stow。谢天谢地，Stow 有一个很棒的方法可以轻松管理从源代码安装的程序。
引用官方网站里的一段介绍，
>
> GNU Stow 是一个符号链接归集管理器，它可以收集文件系统上不同目录中的不同软件和/或数据包，使它们看起来像是一个整体。
>
>
>
简单来说，Stow 帮助你把这些程序文件以一种容易管理的方式组织在了一起。在这个方法中，文件将不会被复制到多个位置。所有的这些文件都会被保存在一个特定的文件夹中，通常是以程序名命名的，然后 Stow 会在一个合适的位置为所有的程序文件创建符号连接。比如 `/usr/local/bin` 中会包含 `/usr/local/stow/vim/bin`、`/usr/local/stow/python/bin` 中文件的符号链接。并且同样递归地用于其他的任何的子目录，例如 `.../share`、`.../man`，等等。在这篇教程中，我将会举例教你如何轻松地使用 Stow 管理从源中安装的程序。
### 安装 GNU Stow
GNU Stow 在流行 Linux 操作系统的默认库中都可用。
在 Arch Linux 及它的衍生版本中，运行下面的命令安装 Stow。
```
$ sudo pacman -S stow
```
在 Debian、Ubuntu、Linux Mint 上：
```
$ sudo apt install stow
```
在 Fedora 上：
```
$ sudo dnf install stow
```
在 RHEL/CentOS 上：
```
$ sudo yum install epel-release
$ sudo yum install stow
```
### 在 Linux 上轻松移除从源代码安装的程序
就像我之前提到的，所有包的程序文件都将被保存在位于 `/usr/local/stow/` 的一个根文件夹。在这个根文件夹或者父目录之下，每个包都将保存在对应的子目录中。例如，如果我们从源代码中安装了 Vim 编辑器，所有关联到 Vim 的程序文件和目录都将保存在 `/usr/local/stow/vim` 文件夹之下。如果你从源代码中安装了 Python，所有关联到 python 的文件都会保存在 `/usr/local/stow/python` 之下。
我现在从源代码中来安装一个叫做 hello 的程序。
首先下载 hello 程序的压缩包。
```
$ wget http://ftp.gnu.org/gnu/hello/hello-2.10.tar.gz
```
使用下面的命令解压压缩包：
```
$ tar -zxvf hello-2.10.tar.gz
```
上面的命令将会在当前工作目录下创建一个叫做 `hello-2.10` 的目录，并且提取压缩包中的所有内容到其中去。
切换到这个目录当中：
```
$ cd hello-2.10/
```
运行下面的命令，并且添加 `-prefix` 选项。
```
$ ./configure --prefix=/usr/local/stow/hello
```
上面的命令将会保存构建文件到一个指定位置，在这个例子中是 `/usr/local/stow/hello`。
最后，使用下面的命令构建并安装 hello 这个程序：
```
$ make
$ sudo make install
```
就这样。hello 这个程序就已经安装在 `/usr/local/stow/hello/` 这个位置了。你可以使用下面的 `ls` 命令确认一下。
```
$ ls /usr/local/stow/hello/
bin share
```
最后，进入 `/usr/local/stow/` 目录，运行下面的命令来生成必要的符号链接。
```
$ cd /usr/local/stow/
$ sudo stow hello
```
大功告成！
刚才那一步是将包含在 hello 这个程序中的所有文件或者目录创建了链接到 `/usr/local/` 目录中。换一种说法， `/usr/local/stow/hello/bin` 链接到 `/usr/local/share`，以及 `/usr/local/stow/hello/share/man` 链接到 `/usr/local/share`，还有 `/usr/local/stow/hello/share/man` 链接到 `/usr/local/share/man`。
你可以使用 `ls` 命令来确认一下：
```
$ ls /usr/local/bin/
hello
```
可以使用下面的命令来确认 hello 这个程序是否可以正常工作了：
```
$ hello
Hello, world!
```
很好，它已经开始工作了！！
类似地，你可以像上面描述的那样安装程序到它对应的子目录下。
下面是 Stow 根目录包含的内容：
```
$ tree /usr/local/stow/
```
看，hello 这个程序已经安装在 `/usr/local/stow/hello/` 下。同样地，所有的包都将保存在它们对应的目录之下。
下面进入主要环节，移除 hello 这个程序。首先进入 `/usr/local/stow/` 目录：
```
$ cd /usr/local/stow/
```
然后运行下面的命令：
```
$ sudo stow --delete hello
```
hello 这个程序就会被移除了。你可以使用下面的命令确认它是否真的被移除了：
```
$ hello
-bash: /usr/local/bin/hello: No such file or directory
```
看， Hello 已经被移除了！
请注意 Stow 仅仅只移除了符号链接。所有与 hello 这个程序相关的文件或者目录还保存在 `/usr/local/stow/hello` 目录下。所以你无需再次下载源文件就可以再次安装 hello 这个程序。如果你不再需要它了，直接删除这个文件夹即可。
```
$ sudo rm -fr /usr/local/stow/hello/
```
想了解更多 Stow 的细节，请参阅 man 手册。
```
$ man stow
```
Stow 可以像安装程序一样轻松地帮你移除它。如果你想知道如何高效的管理很多从源代码中安装的程序，GNU Stow 就是一个使得这个任务更加轻松的一个选择，尝试一下，你一定不会失望的。
这就是所有的内容了，希望对你有所帮助。还有更多干活即将到来，可以期待一下的！
祝近祺！
---
via: <https://www.ostechnix.com/an-easy-way-to-remove-programs-installed-from-source-in-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[dianbanjiu](https://github.com/dianbanjiu) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何使用 Beamer 创建演示文稿
|
Moshe Zadka
|
https://opensource.com/article/19/1/create-presentations-beamer
|
Beamer 将 LaTeX 强大的排版功能和生态系统带进创建幻灯片中。
|
/data/attachment/album/201901/13/113905one2p82t58vtqgtq.jpeg.thumb.jpg
|
/data/attachment/album/201901/13/113905one2p82t58vtqgtq.jpeg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Beamer",
"PPT"
] |
技术
|
{
"viewnum": 8212,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Beamer 将 LaTeX 强大的排版功能和生态系统带进创建幻灯片中。
| 2019-01-13T11:39:13 | 2019-01-13T11:39:13 | 10,439 |
/article-10439-1.html
|
>
> Beamer 将 LaTeX 强大的排版功能和生态系统带进创建幻灯片中。
>
>
>
[Beamer](https://www.overleaf.com/learn/latex/Beamer) 是用于生成幻灯片的 LaTeX 包。它最棒的功能之一是它可以利用 LaTeX 强大的排版系统和其生态系统中的所有其他软件包。例如，我经常在包含代码的 Beamer 演示文稿中使用 LaTeX 的 [listings](https://www.overleaf.com/learn/latex/Code_listing) 包。
### 创建演示文稿
要创建一个 Beamer 文档，输入：
```
\documentclass{beamer}
```
与任何其他 LaTeX 文档一样，添加你要使用的任何包。例如，要使用 `listings` 包，请输入：
```
\usepackage{listings}
```
将所有内容放在 `document` 环境中：
```
\begin{document}
```
Beamer 文档通常时是一系列的 `frame` 环境。包含代码的 `frame` 应该被标记为 `fragile`：
```
\begin{frame}[fragile]
```
使用标题开始你的 `frame`：
```
\frametitle{Function to Do Stuff}
```
### 开始演示前测试你的代码
世上最糟糕的感受之一你在演讲中说到代码时，突然发现了一个 bug —— 也许是拼错了关键词或者漏掉了括号。
解决方法之一就是测试演示的代码。在多数演示环境中，这意味着创建一个单独的文件、编写测试接着拷贝和粘贴。
然而，在 Beamer 中有一种更好的方法。想象一下，你有一个名为 `do_stuff.py` 的文件，其中包含代码。你可以在第二个文件中编写 `do_stuff.py` 代码的测试，你可以将其命名为 `test_do_stuff.py`，并且可以使用 [pytest](https://docs.pytest.org/en/latest/) 测试。但是，`do_stuff.py` 中的大多数行都缺乏教学价值，比如定义辅助函数。
要简化你受众看到的东西，你可在演示文稿中只导入你要讨论的行到 frame 中：
```
\lstinputlisting[
language=Python,
firstline=8,
lastline=15
]{do_stuff.py}
```
由于你会对这几行（从 8 到 15）进行讨论，因此幻灯片上不需要任何其他内容。结束 `frame`：
```
\end{frame}
```
在下一张幻灯片中，你想展示刚才的 `do_stuff()` 函数的用法示例：
```
\begin{frame}[fragile]
\frametitle{Calling Function to Do Stuff}
\lstinputlisting[
language=Python,
firstline=17,
lastline=19
]{do_stuff.py}
\end{frame}
```
你使用相同的文件，但这次显示调用该函数的行。最后，结束 `document`：
```
\end{document}
```
假设你在 `do_stuff.py` 中有一个合适的 Python 文件，这将生成一个含有 2 页的幻灯片。
Beamer 还支持必要的功能如渐进式演示，每次给观众展示一部分以免受到前面的打扰。在行中放入 `\pause` 会将页面分成不同的部分：
```
\begin{frame}
Remember:
\begin{itemize}
\item This will show up on the first slide. \pause
\item This will show up on the
second slide, as well as the preceding point. \pause
\item Finally, on the third slide,
all three bullets will show up.
\end{frame}
```
### 创建讲义
Beamer 中我最喜欢的功能是可以用 `\documentclass[ignorenonframetext]{beamer}` 设置忽略 `frame` 外的所有内容。当我准备演示文稿时，我离开顶部（声明文档类的位置）并自动生成它的两个版本：我的演示稿使用 Beamer 忽略任何 `frame` 之外的所有文本，另一个含有类似这样的头：
```
\documentclass{article}
\usepackage{beamerarticle}
```
这会生成一份讲义：一份含有所有 `frame` 和它们之间文字的 PDF。
当会议组织者要求我发布我的幻灯片时，我会包含原始幻灯片作为参考，但我希望人们拿到的是讲义，它包含了所有我不想在幻灯片上写的解释部分。
在创建幻灯片时，人们经常会考虑是为演讲优化讲稿还是为之后想要阅读它的人们优化。幸运的是，Beamer 提供了两全其美的办法。
---
via: <https://opensource.com/article/19/1/create-presentations-beamer>
作者：[Moshe Zadka](https://opensource.com/users/moshez) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
JSON 的兴起与崛起
|
Two-bit History
|
https://twobithistory.org/2017/09/21/the-rise-and-rise-of-json.html
|
我们不禁要问为什么 XML 的噩运来的如此之快，以至于短短十来年，“异步 JavaScript 和 XML” 这个名称就成为一个很讽刺的误称。
|
/data/attachment/album/201901/14/115006ibcnakngxqxi6lnl.png.thumb.jpg
|
/data/attachment/album/201901/14/115006ibcnakngxqxi6lnl.png
| true | false | true |
lujun9972
|
runningwater
|
wxy
| true |
[
"JavaScript",
"JSON",
"XML"
] |
观点
|
{
"viewnum": 8122,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
我们不禁要问为什么 XML 的噩运来的如此之快，以至于短短十来年，“异步 JavaScript 和 XML” 这个名称就成为一个很讽刺的误称。
| 2019-01-14T11:50:00 | 2019-01-14T11:50:00 | 10,440 |
/article-10440-1.html
|
JSON 已经占领了全世界。当今，任何两个应用程序彼此通过互联网通信时，可以打赌它们在使用 JSON。它已被所有大型企业所采用：十大最受欢迎的 web API 接口列表中（主要由 Google、Facebook 和 Twitter 提供），仅仅只有一个 API 接口是以 XML 的格式开放数据的。<sup id="fnref1"> <a href="#fn1" rel="footnote"> 1 </a></sup> 这个列表中的 Twitter API 为此做了一个鲜活的注脚：其对 XML 格式的支持到 2013 年结束，其时发布的新版本的 API 取消 XML 格式，转而仅使用 JSON。JSON 也在程序编码级别和文件存储上被广泛采用：在 Stack Overflow（LCTT 译注：一个面向程序员的问答网站）上，现在更多的是关于 JSON 的问题，而不是其他的数据交换格式。<sup id="fnref2"> <a href="#fn2" rel="footnote"> 2 </a></sup>
XML 仍然在很多地方存在。网络上它被用于 SVG 和 RSS / Atom 信息流。Android 开发者想要获得用户权限许可时，需要在其 APP 的 `manifest` 文件中声明 —— 此文件是 XML 格式的。XML 的替代品也不仅仅只有 JSON，现在有很多人在使用 YAML 或 Google 的 Protocol Buffers 等技术，但这些技术的受欢迎程度远不如 JSON。目前来看，JSON 是应用程序在网络之间通信的首选协议格式。
考虑到自 2005 年来 Web 编程世界就垂涎于 “异步 JavaScript 和 XML” 而非 “异步 JavaScript 和 JSON” 的技术潜力，你可以发现 JSON 的主导地位是如此的让人惊讶。当然了，这可能与这两种通信格式的受欢迎程度无关，而仅反映出缩写 “AJAX” 似乎比 “AJAJ” 更具吸引力。但是，即使在 2005 年有些人（实际上没有太多人）已经用 JSON 来取代 XML 了，我们不禁要问 XML 的噩运来的如此之快，以至于短短十来年，“异步 JavaScript 和 XML” 这个名称就成为一个很讽刺的误称。那这十来年发生了什么？JSON 怎么会在那么多应用程序中取代了 XML？现在被全世界工程师和系统所使用、依赖的这种数据格式是谁提出的？
### JSON 之诞生
2001 年 4 月，首个 JSON 格式的消息被发送出来。此消息是从旧金山湾区某车库的一台计算机发出的，这是计算机历史上重要的的时刻。Douglas Crockford 和 Chip Morningstar 是一家名为 State Software 的技术咨询公司的联合创始人，他们当时聚集在 Morningstar 的车库里测试某个想法，发出了此消息。
在 “AJAX” 这个术语被创造之前，Crockford 和 Morningstar 就已经在尝试构建好用的 AJAX 应用程序了，可是浏览器对其兼容性不好。他们想要在初始页面加载后就将数据传递给应用程序，但其目标要针对所有的浏览器，这就实现不了。
这在今天看来不太可信，但是要记得 2001 年的时候 Internet Explorer（IE）代表了网页浏览器的最前沿技术产品。早在 1999 年的时候，Internet Explorer 5 就支持了原始形式的 `XMLHttpRequest`，开发者可以使用名为 ActiveX 的框架来访问此对象。Crockford 和 Morningstar 能够使用此技术（在 IE 中）来获取数据，但是在 Netscape 4 中（这是他们想要支持的另一种浏览器）就无法使用这种解决方案。为此 Crockford 和 Morningstar 只得使用一套不同的系统以兼容不同的浏览器。
第一条 JSON 消息如下所示：
```
<html><head><script>
document.domain = 'fudco';
parent.session.receive(
{ to: "session", do: "test",
text: "Hello world" }
)
</script></head></html>
```
消息中只有一小部分类似于今天我们所知的 JSON，本身其实是一个包含有一些 JavaScript 的 HTML 文档。类似于 JSON 的部分只是传递给名为 `receive()` 的函数的 JavaScript 对象字面量。
Crockford 和 Morningstar 决定滥用 HTML 的帧（`<frame>`）以发送数据。他们可以让一个帧指向一个返回的上述 HTML 文档的 URL。当接收到 HTML 时，JavaScript 代码段就会运行，就可以把数据对象字面量如实地传递回应用程序。只要小心的回避浏览器保护策略（即子窗口不允许访问父窗口），这种技术就可以正常运行无误。可以看到 Crockford 和 Mornginstar 通过明确地设置文档域这种方法来达到其目的。（这种基于帧的技术，有时称为隐藏帧技术，通常在 90 年代后期，即在广泛使用 XMLHttpRequest 技术之前使用。<sup id="fnref3"> <a href="#fn3" rel="footnote"> 3 </a></sup> ）
第一个 JSON 消息的惊人之处在于，它显然不是一种新的数据格式的首次使用。它就是 JavaScript！实际上，以此方式使用 JavaScript 的想法如此简单，Crockford 自己也说过他不是第一个这样做的人。他说 Netscape 公司的某人早在 1996 年就使用 JavaScript 数组字面量来交换信息。<sup id="fnref4"> <a href="#fn4" rel="footnote"> 4 </a></sup> 因为消息就是 JavaScript，其不需要任何特殊解析工作，JavaScript 解释器就可搞定一切。
最初的 JSON 信息实际上与 JavaScript 解释器发生了冲突。JavaScript 保留了大量的关键字（ECMAScript 6 版本就有 64 个保留字），Crockford 和 Morningstar 无意中在其 JSON 中使用了一个保留字。他们使用了 `do` 作为了键名，但 `do` 是解释器中的保留字。因为 JavaScript 使用的保留字太多了，Crockford 做了决定：既然不可避免的要使用到这些保留字，那就要求所有的 JSON 键名都加上引号。被引起来的键名会被 JavaScript 解释器识别成字符串，其意味着那些保留字也可以放心安全的使用。这就为什么今天 JSON 键名都要用引号引起来的原因。
Crockford 和 Morningstar 意识到这技术可以应用于各类应用系统。想给其命名为 “JSML”，即 <ruby> JavaScript 标记语言 <rt> JavaScript Markup Language </rt></ruby>的意思，但发现这个缩写已经被一个名为 Java Speech 标记语言的东西所使用了。因此他们决定采用 “JavaScript Object Notation”，缩写为 JSON。他们开始向客户推销，但很快发现客户不愿意冒险使用缺乏官方规范的未知技术。所以 Crockford 决定写一个规范。
2002 年，Crockford 买下了 [JSON.org](http://JSON.org) 域名，放上了 JSON 语法及一个解释器的实例例子。该网站仍然在运行，现在已经包含有 2013 年正式批准的 JSON ECMA 标准的显著链接。在该网站建立后，Crockford 并没有过多的推广，但很快发现很多人都在提交各种不同编程语言的 JSON 解析器实现。JSON 的血统显然与 JavaScript 相关联，但很明显 JSON 非常适合于不同语言之间的数据交换。
### AJAX 导致的误会
2005 年，JSON 有了一次大爆发。那一年，一位名叫 Jesse James Garrett 的网页设计师和开发者在博客文章中创造了 “AJAX” 一词。他很谨慎地强调：AJAX 并不是新技术，而是 “好几种蓬勃发展的技术以某种强大的新方式汇集在一起。<sup id="fnref5"> <a href="#fn5" rel="footnote"> 5 </a></sup> ” AJAX 是 Garrett 给这种正受到青睐的 Web 应用程序的新开发方法的命名。他的博客文章接着描述了开发人员如何利用 JavaScript 和 XMLHttpRequest 构建新型应用程序，这些应用程序比传统的网页更具响应性和状态性。他还以 Gmail 和 Flickr 网站已经使用 AJAX 技术作为了例子。
当然了，“AJAX” 中的 “X” 代表 XML。但在随后的问答帖子中，Garrett 指出，JSON 可以完全替代 XML。他写道：“虽然 XML 是 AJAX 客户端进行数据输入、输出的最完善的技术，但要实现同样的效果，也可以使用像 JavaScript Object Notation（JSON）或任何类似的结构数据方法等技术。 ”<sup id="fnref6"> <a href="#fn6" rel="footnote"> 6 </a></sup>
开发者确实发现在构建 AJAX 应用程序时可以很容易的使用 JSON，许多人更喜欢它而不是 XML。具有讽刺意味的是，对 AJAX 的兴趣逐渐的导致了 JSON 的普及。大约在这个时候，JSON 引起了博客圈的注意。
2006 年，Dave Winer，一位高产的博主，他也是许多基于 XML 的技术（如 RSS 和 XML-RPC）背后的开发工程师，他抱怨到 JSON 毫无疑问的正在重新发明 XML。尽管人们认为数据交换格式之间的竞争不会导致某一技术的消亡。其写到：
>
> 毫无疑问，我可以编写一个例程来解析 JSON，但来看看他们要重新发明一个东西有多大的意义，出于某种原因 XML 本身对他们来说还不够好（我很想听听原因）。谁想干这荒谬之事？查找一棵树然后把节点串起来。可以立马试试。<sup id="fnref7"> <a href="#fn7" rel="footnote"> 7 </a></sup>
>
>
>
我很理解 Winer 的挫败感。事实上并没有太多人喜欢 XML。甚至 Winer 也说过他不喜欢 XML。<sup id="fnref8"> <a href="#fn8" rel="footnote"> 8 </a></sup> 但 XML 已被设计成一个可供任何人使用，并且可以用于几乎能想象到的所有事情。归根到底，XML 实际上是一门元语言，允许你为特定应用程序自定义该领域特定的语言。如 Web 信息流技术 RSS 和 SOAP（简单对象访问协议）就是例子。Winer 认为由于通用交换格式所带来的好处，努力达成共识非常重要。XML 的灵活性应该能满足任何人的需求，然而 JSON 格式呢，其并没有比 XML 提供更多东西，除了它抛弃了使 XML 更灵活的那些繁琐的东西。
Crockford 阅读了 Winer 的这篇文章并留下了评论。为了回应 JSON 重新发明 XML 的指责，Crockford 写到：“重造轮子的好处是可以得到一个更好的轮子。”<sup id="fnref9"> <a href="#fn9" rel="footnote"> 9 </a></sup>
### JSON 与 XML 对比
到 2014 年，JSON 已经由 ECMA 标准和 RFC 官方正式认可。它有了自己的 MIME 类型。JSON 已经进入了大联盟时代。
为什么 JSON 比 XML 更受欢迎？
在 [JSON.org](http://JSON.org) 网站上，Crockford 总结了一些 JSON 的优势。他写到，JSON 的语法极少，其结构可预测，因此 JSON 更容易被人类和机器理解。<sup id="fnref10"> <a href="#fn10" rel="footnote"> 10 </a></sup> 其他博主一直关注 XML 的冗长啰嗦及“尖括号负担”。<sup id="fnref11"> <a href="#fn11" rel="footnote"> 11 </a></sup> XML 中每个开始标记都必须与结束标记匹配，这意味着 XML 文档包含大量的冗余信息。在未压缩时，XML 文档的体积比同等信息量 JSON 文档的体积大很多，但是，更重要的，这也使 XML 文档更难以阅读。
Crockford 还声称 JSON 的另一个巨大优势是其被设计为数据交换格式。<sup id="fnref12"> <a href="#fn12" rel="footnote"> 12 </a></sup> 从一开始，它的目的就是在应用程序间传递结构化信息的。而 XML 呢，虽然也可以使用来传递数据，但其最初被设计为文档标记语言。它演变自 SGML（通用标准标记语言），而它又是从被称为 Scribe 的标记语言演变而来，其旨在发展成类似于 LaTeX 一样的文字处理系统。XML 中，一个标签可以包含有所谓的“混合内容”，即带有围绕单词、短语的内嵌标签的文本。这会让人浮现出一副用红蓝笔记录的手稿画面，这是标记语言核心思想的形象比喻。另一方面，JSON 不支持对混合内容模型的清晰构建，但这也意味着它的结构足够简单。一份文档最好的建模就是一棵树，但 JSON 抛弃了这种文档的思想，Crockford 将 JSON 抽象限制为字典和数组，这是所有程序员构建程序时都会使用的最基本的、也最熟悉的元素。
最后，我认为人们不喜欢 XML 是因为它让人困惑。它让人迷惑的地方就是有很多不同的风格。乍一看，XML 本身及其子语言（如 RSS、ATOM、SOAP 或 SVG）之间的界限并不明显。典型的 XML 文档的第一行标识了该 XML 的版本，然后该 XML 文档应该符合特定的子语言。这就有变化需要考虑了，特别是跟 JSON 做比较，JSON 是如此简单，以至于永远不需要编写新版本的 JSON 规范。XML 的设计者试图将 XML 做为唯一的数据交换格式以支配所有格式，就会掉入那个经典的程序员陷阱：过度工程化。XML 非常笼统及概念化，所以很难于简单的使用。
在 2000 年的时候，发起了一场使 HTML 符合 XML 标准的活动，发布了一份符合 XML 标准的 HTML 开发规范，这就此后很出名的 XHTML。虽然一些浏览器厂商立即开始支持这个新标准，但也很明显，大部分基于 HTML 技术的开发者不愿意改变他们的习惯。新标准要求对 XHTML 文档进行严格的验证，而不是基于 HTML 的基准。但大多的网站都是依赖于 HTML 的宽容规则的。到 2009 年的时候，试图编写第二版本的 XHTML 标准的努力已经流产，因为未来已清晰可见，HTML 将会发展为 HTML5（一种不强制要求接受 XML 规则的标准）。
如果 XHTML 的努力取得了成功，那么 XML 可能会成为其设计者所希望的通用数据格式。想象一下，一个 HTML 文档和 API 响应具有完全相同结构的世界。在这样的世界中，JSON 可能不会像现在一样普遍存在。但我把 HTML 的失败看做是 XML 阵营的一种道义上的失败。如果 XML 不是 HTML 的最佳工具，那么对于其他应用程序，也许会有更好的工具出现。在这个世界，我们的世界，很容易看到像 JSON 格式这样的足够简单、量体裁衣的才能获得更大的成功。
如果你喜欢这博文，每两周会更新一次！ 请在 Twitter 上关注 [@TwoBitHistory](https://twitter.com/TwoBitHistory) 或订阅 [RSS feed](https://twobithistory.org/feed.xml)，以确保得到更新的通知。
---
1. <http://www.cs.tufts.edu/comp/150IDS/final_papers/tstras01.1/FinalReport/FinalReport.html#software> [↩](#fnref1)
2. <https://insights.stackoverflow.com/trends?tags=json%2Cxml%2Cprotocol-buffers%2Cyaml%2Ccsv> [↩](#fnref2)
3. Zakas, Nicholas C., et al. “What Is Ajax?” Professional Ajax, 2nd ed., Wiley, 2007. [↩](#fnref3)
4. <https://youtu.be/-C-JoyNuQJs?t=32s> [↩](#fnref4)
5. <http://adaptivepath.org/ideas/ajax-new-approach-web-applications/> [↩](#fnref5)
6. 同上 [↩](#fnref6)
7. <http://scripting.com/2006/12/20.html> [↩](#fnref7)
8. <http://blogoscoped.com/archive/2009-03-05-n15.html> [↩](#fnref8)
9. <https://scripting.wordpress.com/2006/12/20/scripting-news-for-12202006/#comment-26383> [↩](#fnref9)
10. <http://www.json.org/xml.html> [↩](#fnref10)
11. <https://blog.codinghorror.com/xml-the-angle-bracket-tax> [↩](#fnref11)
12. <https://youtu.be/-C-JoyNuQJs?t=33m50sgg> [↩](#fnref12)
---
via: <https://twobithistory.org/2017/09/21/the-rise-and-rise-of-json.html>
作者：[Two-Bit History](https://twobithistory.org) 选题：[lujun9972](https://github.com/lujun9972) 译者：[runningwater](https://github.com/runningwater) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Termtosvg：将你在 Linux 终端中操作录制成 SVG 动画
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/termtosvg-record-your-terminal-sessions-as-svg-animations-in-linux/
|
Termtosvg 是一个用 Python 编写的 Unix 终端录制器，它可以将你的命令行会话保存为 SVG 动画。
|
/data/attachment/album/201901/14/121313jcoeexcx1di7i1xl.jpg.thumb.jpg
|
/data/attachment/album/201901/14/121313jcoeexcx1di7i1xl.jpg
| true | false | true |
lujun9972
|
zhs852
|
wxy
| false |
[
"SVG",
"终端",
"动画"
] |
分享
|
{
"viewnum": 6365,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Termtosvg 是一个用 Python 编写的 Unix 终端录制器，它可以将你的命令行会话保存为 SVG 动画。
| 2019-01-14T12:13:17 | 2019-01-14T12:13:17 | 10,441 |
/article-10441-1.html
|
一般人喜欢使用历史命令功能来查看/再次调用之前在终端中输入的命令。不幸的是，那样做只会显示先前输入的命令，而不是之前输出的内容。
在 Linux 中，有许多可以用来记录终端活动的实用工具。这种工具将会帮助我们记录用户在终端中的活动，并帮助我们识别输出中有用的信息。
在这之前，我们已经介绍了一些这类实用工具了。今天，让我们接着讨论这类工具。
如果你希望尝试其它一些记录你终端活动的工具，我推荐你试试 [script](https://www.2daygeek.com/script-command-record-save-your-terminal-session-activity-linux/) 命令和 [Terminalizer](https://www.2daygeek.com/terminalizer-a-tool-to-record-your-terminal-and-generate-animated-gif-images/) 工具。`script` 是在无头服务器中记录终端活动的最佳方式之一。`script` 是一个记录在终端中输入过的 Unix 命令的实用工具（在某些终端中，它会记录显示在你终端中的所有东西）。它会在当前工作目录下以文本文件方式储存所有终端输出。
不过，如果你在寻找 [GIF 录制器](https://www.2daygeek.com/category/gif-recorder/) ，你可以尝试 [Gifine](https://www.2daygeek.com/gifine-create-animated-gif-vedio-recorder-linux-mint-debian-ubuntu/)、[Kgif](https://www.2daygeek.com/kgif-create-animated-gif-file-active-window-screen-recorder-capture-arch-linux-mint-fedora-ubuntu-debian-opensuse-centos/) 和 [Peek](https://www.2daygeek.com/peek-create-animated-gif-screen-recorder-capture-arch-linux-mint-fedora-ubuntu/)。
### 什么是 Termtosvg
Termtosvg 是一个用 Python 编写的 Unix 终端录制器，它可以将你的命令行会话保存为 SVG 动画。
### Termtosvg 的特点
* 可以制作嵌入于项目主页的简洁美观的动画。
* 可以在 SVG 模板中自定义配色、终端 UI 和动画。
* 兼容 asciinema 录制格式。
* 要求 Python 版本为 3.5 或更高。
### 如何在 Linux 中安装 Termtosvg
它是用 Python 编写的，所以我推荐使用 `pip` 来安装它。
请确保你已经安装了 python-pip 包。如果你还没安装，请输入下面的命令。 对于 Debian 或 Ubuntu 用户，请使用 [apt](https://www.2daygeek.com/apt-command-examples-manage-packages-debian-ubuntu-systems/) 或 [apt-get](https://www.2daygeek.com/apt-get-apt-cache-command-examples-manage-packages-debian-ubuntu-systems/) 来安装 `pip`。
```
sudo apt install python-pip
```
对于 Archlinux 用户，请使用 [pacman](https://www.2daygeek.com/pacman-command-examples-manage-packages-arch-linux-system/) 来安装 `pip`。
```
sudo pacman -S python-pip
```
对于 Fedora 用户，请使用 [dnf](https://www.2daygeek.com/dnf-command-examples-manage-packages-fedora-system/) 来安装 `pip`。
```
sudo dnf install python-pip
```
对于 CentOS 或 RHEL 用户，请使用 [yum](https://www.2daygeek.com/yum-command-examples-manage-packages-rhel-centos-systems/) 来安装 `pip`。
```
sudo yum install python-pip
```
对于 openSUSE 用户，请使用 [zypper](https://www.2daygeek.com/zypper-command-examples-manage-packages-opensuse-system/) 来安装 `pip`。
```
sudo zypper install python-pip
```
最后，请执行 [pip](https://www.2daygeek.com/install-pip-manage-python-packages-linux/) 来安装 Termtosvg。
```
sudo pip3 install termtosvg pyte python-xlib svgwrite
```
### 如何使用 Termtosvg
成功安装 Termtosvg 后，请使用以下命令来开始录制。
```
$ termtosvg
Recording started, enter "exit" command or Control-D to end
```
如果只是想测试它是否正常工作，随意输入几行命令即可。
```
$ uname -a
Linux daygeek-Y700 4.19.8-2-MANJARO #1 SMP PREEMPT Sat Dec 8 14:45:36 UTC 2018 x86_64 GNU/Linux
$ hostname
daygeek-Y700
$ cat /etc/*-release
Manjaro Linux
DISTRIB_ID=ManjaroLinux
DISTRIB_RELEASE=18.0
DISTRIB_CODENAME=Illyria
DISTRIB_DESCRIPTION="Manjaro Linux"
Manjaro Linux
NAME="Manjaro Linux"
ID=manjaro
ID_LIKE=arch
PRETTY_NAME="Manjaro Linux"
ANSI_COLOR="1;32"
HOME_URL="https://www.manjaro.org/"
SUPPORT_URL="https://www.manjaro.org/"
BUG_REPORT_URL="https://bugs.manjaro.org/"
$ free -g
free: Multiple unit options doesn't make sense.
$ free -m
free: Multiple unit options doesn't make sense.
$ pip3 --version
pip 18.1 from /usr/lib/python3.7/site-packages/pip (python 3.7)
```
完成后，你可以按下 `CTRL+D` 或输入 `exit` 来停止录制。录制完后，输出文件会以一个独一无二的名字被保存在 `/tmp` 文件夹中。
```
$ exit
exit
Recording ended, SVG animation is /tmp/termtosvg_5waorper.svg
```
我们可以在任意浏览器中打开 SVG 文件。
```
firefox /tmp/termtosvg_5waorper.svg
```
---
via: <https://www.2daygeek.com/termtosvg-record-your-terminal-sessions-as-svg-animations-in-linux/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[zhs852](https://github.com/zhs852) 校对：[校对者ID](https://github.com/%E6%A0%A1%E5%AF%B9%E8%80%85ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
极客漫画：你准备好微服务了吗？
|
Daniel Stori
|
http://turnoff.us/geek/are-you-ready-for-microservices/
|
微服务是个好东西，就像乐高积木一样，你可以拼成各种东西，当前，前提是你足够会玩。
从早些年的 SOA 和中间件，到现在的微服务和容器，但似乎历史总是螺旋式变化的。看起来笨拙而大而无当的独石应用，其实在很多场景，要比微服务更适合。
|
/data/attachment/album/201901/14/123302dn2g2zmgzr29g9tz.png.thumb.jpg
|
/data/attachment/album/201901/14/123302dn2g2zmgzr29g9tz.png.large.jpg
| false | false | true |
wxy
|
wxy
| false |
[
"微服务",
"极客漫画"
] |
极客漫画
|
{
"viewnum": 13850,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
微服务是个好东西，就像乐高积木一样，你可以拼成各种东西，当前，前提是你足够会玩。
从早些年的 SOA 和中间件，到现在的微服务和容器，但似乎历史总是螺旋式变化的。看起来笨拙而大而无当的独石应用，其实在很多场景，要比微服务更适合。
| 2019-01-14T12:34:38 | 2019-01-14T12:34:38 | 10,442 |
/article-10442-1.html
|
微服务是个好东西，就像乐高积木一样，你可以拼成各种东西，当前，前提是你足够会玩。
从早些年的 SOA 和中间件，到现在的微服务和容器，但似乎历史总是螺旋式变化的。看起来笨拙而大而无当的独石应用，其实在很多场景，要比微服务更适合。
话说，微服务的锅该那只汤姆猫背吗？:->
---
via: <http://turnoff.us/geek/are-you-ready-for-microservices/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者&点评&校对：[wxy](https://github.com/wxy) 合成：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
Linux 上查看系统/服务器运行时间的 11 种方法
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/11-methods-to-find-check-system-server-uptime-in-linux/
|
你是否想知道自己的 Linux 系统正常运行了多长时间而没有宕机？系统是什么时候启动的？
|
/data/attachment/album/201901/15/100936fvejs5lsgwkws552.jpg.thumb.jpg
|
/data/attachment/album/201901/15/100936fvejs5lsgwkws552.jpg
| true | false | true |
lujun9972
|
LuuMing
|
wxy
| false |
[
"时间",
"启动",
"运行"
] |
技术
|
{
"viewnum": 30115,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
你是否想知道自己的 Linux 系统正常运行了多长时间而没有宕机？系统是什么时候启动的？
| 2019-01-15T10:09:00 | 2019-01-15T10:09:00 | 10,443 |
/article-10443-1.html
|
你是否想知道自己的 Linux 系统正常运行了多长时间而没有宕机？系统是什么时候启动的？
Linux 上有多个查看服务器/系统运行时间的命令，大多数用户喜欢使用标准并且很有名的 `uptime` 命令获取这些具体的信息。
服务器的运行时间对一些用户来说不那么重要，但是当服务器运行诸如在线商城<ruby> 门户 <rt> portal </rt></ruby>、网上银行门户等<ruby> 关键任务应用 <rt> mission-critical applications </rt></ruby>时，它对于<ruby> 服务器管理员 <rt> server adminstrators </rt></ruby>来说就至关重要。
它必须做到零宕机，因为一旦停机就会影响到数百万用户。
正如我所说，许多命令都可以让用户看到 Linux 服务器的运行时间。在这篇教程里我会教你如何使用下面 11 种方式来查看。
<ruby> 正常运行时间 <rt> uptime </rt></ruby>指的是服务器自从上次关闭或重启以来经过的时间。
`uptime` 命令获取 `/proc` 文件中的详细信息并输出正常运行时间，而 `/proc` 文件并不适合人直接看。
以下这些命令会输出系统运行和启动的时间。也会显示一些额外的信息。
### 方法 1：使用 uptime 命令
`uptime` 命令会告诉你系统运行了多长时间。它会用一行显示以下信息。
当前时间、系统运行时间、当前登录用户的数量、过去 1 分钟/5 分钟/15 分钟系统负载的均值。
```
# uptime
08:34:29 up 21 days, 5:46, 1 user, load average: 0.06, 0.04, 0.00
```
### 方法 2：使用 w 命令
`w` 命令为每个登录进系统的用户，每个用户当前所做的事情，所有活动的负载对计算机的影响提供了一个快速的概要。这个单一命令结合了多个 Unix 程序：`who`、`uptime`，和 `ps -a` 的结果。
```
# w
08:35:14 up 21 days, 5:47, 1 user, load average: 0.26, 0.09, 0.02
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
root pts/1 103.5.134.167 08:34 0.00s 0.01s 0.00s w
```
### 方法 3：使用 top 命令
`top` 命令是 Linux 上监视实时系统进程的基础命令之一。它显示系统信息和运行进程的信息，例如正常运行时间、平均负载、运行的任务、登录用户数量、CPU 数量 & CPU 利用率、内存 & 交换空间信息。
**推荐阅读：**[TOP 命令监视服务器性能的例子](https://www.2daygeek.com/top-command-examples-to-monitor-server-performance/)
```
# top -c
top - 08:36:01 up 21 days, 5:48, 1 user, load average: 0.12, 0.08, 0.02
Tasks: 98 total, 1 running, 97 sleeping, 0 stopped, 0 zombie
Cpu(s): 0.0%us, 0.3%sy, 0.0%ni, 99.7%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st
Mem: 1872888k total, 1454644k used, 418244k free, 175804k buffers
Swap: 2097148k total, 0k used, 2097148k free, 1098140k cached
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1 root 20 0 19340 1492 1172 S 0.0 0.1 0:01.04 /sbin/init
2 root 20 0 0 0 0 S 0.0 0.0 0:00.00 [kthreadd]
3 root RT 0 0 0 0 S 0.0 0.0 0:00.00 [migration/0]
4 root 20 0 0 0 0 S 0.0 0.0 0:34.32 [ksoftirqd/0]
5 root RT 0 0 0 0 S 0.0 0.0 0:00.00 [stopper/0]
```
### 方法 4：使用 who 命令
`who` 命令列出当前登录进计算机的用户。`who` 命令与 `w` 命令类似，但后者还包含额外的数据和统计信息。
```
# who -b
system boot 2018-04-12 02:48
```
### 方法 5：使用 last 命令
`last` 命令列出最近登录过的用户。`last` 回溯 `/var/log/wtmp` 文件并显示自从文件创建后登录进（出）的用户。
```
# last reboot -F | head -1 | awk '{print $5,$6,$7,$8,$9}'
Thu Apr 12 02:48:04 2018
```
### 方法 6：使用 /proc/uptime 文件
这个文件中包含系统上次启动后运行时间的详细信息。`/proc/uptime` 的输出相当精简。
第一个数字是系统自从启动的总秒数。第二个数字是总时间中系统空闲所花费的时间，以秒为单位。
```
# cat /proc/uptime
1835457.68 1809207.16
```
### 方法 7：使用 tuptime 命令
`tuptime` 是一个汇报系统运行时间的工具，输出历史信息并作以统计，保留重启之间的数据。和 `uptime` 命令很像，但输出更有意思一些。
```
$ tuptime
```
### 方法 8：使用 htop 命令
`htop` 是运行在 Linux 上的一个交互式进程查看器，是 Hisham 使用 ncurses 库开发的。`htop` 比起 `top` 有很多的特性和选项。
**推荐阅读：** [使用 Htop 命令监控系统资源](https://www.2daygeek.com/htop-command-examples-to-monitor-system-resources/)
```
# htop
CPU[| 0.5%] Tasks: 48, 5 thr; 1 running
Mem[||||||||||||||| 165/1828MB] Load average: 0.10 0.05 0.01
Swp[ 0/2047MB] Uptime: 21 days, 05:52:35
PID USER PRI NI VIRT RES SHR S CPU% MEM% TIME+ Command
29166 root 20 0 110M 2484 1240 R 0.0 0.1 0:00.03 htop
29580 root 20 0 11464 3500 1032 S 0.0 0.2 55:15.97 /bin/sh ./OSWatcher.sh 10 1
1 root 20 0 19340 1492 1172 S 0.0 0.1 0:01.04 /sbin/init
486 root 16 -4 10780 900 348 S 0.0 0.0 0:00.07 /sbin/udevd -d
748 root 18 -2 10780 932 360 S 0.0 0.0 0:00.00 /sbin/udevd -d
```
### 方法 9：使用 glances 命令
`glances` 是一个跨平台的基于 curses 库的监控工具，它是使用 python 编写的。可以说它非常强大，仅用一点空间就能获得很多信息。它使用 psutil 库从系统中获取信息。
`glances` 可以监控 CPU、内存、负载、进程、网络接口、磁盘 I/O、<ruby> 磁盘阵列 <rt> RAID </rt></ruby>、传感器、文件系统（与文件夹）、容器、监视器、Alert 日志、系统信息、运行时间、<ruby> 快速查看 <rt> Quicklook </rt></ruby>（CPU，内存、负载）等。
**推荐阅读：** [Glances （集大成）– Linux 上高级的实时系统运行监控工具](https://www.2daygeek.com/install-glances-advanced-real-time-linux-system-performance-monitoring-tool-on-centos-fedora-ubuntu-debian-opensuse-arch-linux/)
```
glances
ubuntu (Ubuntu 17.10 64bit / Linux 4.13.0-37-generic) - IP 192.168.1.6/24 Uptime: 21 days, 05:55:15
CPU [||||||||||||||||||||| 90.6%] CPU - 90.6% nice: 0.0% ctx_sw: 4K MEM \ 78.4% active: 942M SWAP - 5.9% LOAD 2-core
MEM [|||||||||||||||| 78.0%] user: 55.1% irq: 0.0% inter: 1797 total: 1.95G inactive: 562M total: 12.4G 1 min: 4.35
SWAP [| 5.9%] system: 32.4% iowait: 1.8% sw_int: 897 used: 1.53G buffers: 14.8M used: 749M 5 min: 4.38
idle: 7.6% steal: 0.0% free: 431M cached: 273M free: 11.7G 15 min: 3.38
NETWORK Rx/s Tx/s TASKS 211 (735 thr), 4 run, 207 slp, 0 oth sorted automatically by memory_percent, flat view
docker0 0b 232b
enp0s3 12Kb 4Kb Systemd 7 Services loaded: 197 active: 196 failed: 1
lo 616b 616b
_h478e48e 0b 232b CPU% MEM% VIRT RES PID USER NI S TIME+ R/s W/s Command
63.8 18.9 2.33G 377M 2536 daygeek 0 R 5:57.78 0 0 /usr/lib/firefox/firefox -contentproc -childID 1 -isForBrowser -intPrefs 6:50|7:-1|19:0|34:1000|42:20|43:5|44:10|51
DefaultGateway 83ms 78.5 10.9 3.46G 217M 2039 daygeek 0 S 21:07.46 0 0 /usr/bin/gnome-shell
8.5 10.1 2.32G 201M 2464 daygeek 0 S 8:45.69 0 0 /usr/lib/firefox/firefox -new-window
DISK I/O R/s W/s 1.1 8.5 2.19G 170M 2653 daygeek 0 S 2:56.29 0 0 /usr/lib/firefox/firefox -contentproc -childID 4 -isForBrowser -intPrefs 6:50|7:-1|19:0|34:1000|42:20|43:5|44:10|51
dm-0 0 0 1.7 7.2 2.15G 143M 2880 daygeek 0 S 7:10.46 0 0 /usr/lib/firefox/firefox -contentproc -childID 6 -isForBrowser -intPrefs 6:50|7:-1|19:0|34:1000|42:20|43:5|44:10|51
sda1 9.46M 12K 0.0 4.9 1.78G 97.2M 6125 daygeek 0 S 1:36.57 0 0 /usr/lib/firefox/firefox -contentproc -childID 7 -isForBrowser -intPrefs 6:50|7:-1|19:0|34:1000|42:20|43:5|44:10|51
```
### 方法 10：使用 stat 命令
`stat` 命令显示指定文件或文件系统的详细状态。
```
# stat /var/log/dmesg | grep Modify
Modify: 2018-04-12 02:48:04.027999943 -0400
```
### 方法 11：使用 procinfo 命令
`procinfo` 从 `/proc` 文件夹下收集一些系统数据并将其很好的格式化输出在标准输出设备上。
```
# procinfo | grep Bootup
Bootup: Fri Apr 20 19:40:14 2018 Load average: 0.16 0.05 0.06 1/138 16615
```
---
via: <https://www.2daygeek.com/11-methods-to-find-check-system-server-uptime-in-linux/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[LuuMing](https://github.com/LuuMing) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
将旧的 Linux 台式机变成家庭媒体中心
|
Alan Formy-duval
|
https://opensource.com/article/18/11/old-linux-desktop-new-home-media-center
|
重新利用过时的计算机来浏览互联网并在大屏电视上观看视频。
|
/data/attachment/album/201901/16/083919nakdodn7qbl78fqg.jpg.thumb.jpg
|
/data/attachment/album/201901/16/083919nakdodn7qbl78fqg.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"媒体中心"
] |
技术
|
{
"viewnum": 6781,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
重新利用过时的计算机来浏览互联网并在大屏电视上观看视频。
| 2019-01-16T08:39:25 | 2019-01-16T08:39:25 | 10,446 |
/article-10446-1.html
|
>
> 重新利用过时的计算机来浏览互联网并在大屏电视上观看视频。
>
>
>
我第一次尝试搭建一台“娱乐电脑”是在 20 世纪 90 年代后期，使用了一台带 Trident ProVidia 9685 PCI 显卡的普通旧台式电脑。我使用了所谓的“电视输出”卡，它有一个额外的输出可以连接到标准电视端子上。屏幕显示看起来不太好，而且没有音频输出。并且外观很丑：有一条 S-Video 线穿过了客厅地板连接到我的 19 英寸 Sony Trinitron CRT 电视机上。
我在 Linux 和 Windows 98 上得到了同样令人遗憾的结果。在和那些看起来不对劲的系统挣扎之后，我放弃了几年。值得庆幸的是，如今的 HDMI 拥有更好的性能和标准化的分辨率，这使得廉价的家庭媒体中心成为现实。
我的新媒体中心娱乐电脑实际上是我的旧 Ubuntu Linux 桌面，最近我用更快的电脑替换了它。这台电脑在工作中太慢，但是它的 3.4GHz 的 AMD Phenom II X4 965 处理器和 8GB 的 RAM 足以满足一般浏览和视频流的要求。
以下是我让旧系统在新角色中发挥最佳性能所采取的步骤。
### 硬件
首先，我移除了不必要的设备，包括读卡器、硬盘驱动器、DVD 驱动器和后置 USB 卡，我添加了一块 PCI-Express 无线网卡。我将 Ubuntu 安装到单个固态硬盘 （SSD） 上，这可以切实提高任何旧系统的性能。
### BIOS
在 BIOS 中，我禁用了所有未使用的设备，例如软盘和 IDE 驱动器控制器。我禁用了板载显卡，因为我安装了带 HDMI 输出的 NVidia GeForce GTX 650 PCI Express 显卡。我还禁用了板载声卡，因为 NVidia 显卡芯片组提供音频。
### 音频
Nvidia GeForce GTX 音频设备在 GNOME 控制中心的声音设置中被显示为 GK107 HDMI Audio Controller，因此单条 HDMI 线缆可同时处理音频和视频。无需将音频线连接到板载声卡的输出插孔。
*GNOME 音频设置中的 HDMI 音频控制器。*
### 键盘和鼠标
我有罗技的无线键盘和鼠标。当我安装它们时，我插入了两个外置 USB 接收器，它们可以使用，但我经常遇到信号反应问题。接着我发现其中一个被标记为联合接收器，这意味着它可以自己处理多个罗技输入设备。罗技不提供在 Linux 中配置联合接收器的软件。但幸运的是，有个开源程序 [Solaar](https://pwr.github.io/Solaar/) 能够做到。使用单个接收器解决了我的输入性能问题。
*Solaar 联合接收器界面。*
### 视频
最初很难在我的 47 英寸平板电视上阅读文字，所以我在 Universal Access 下启用了“大文字”。我下载了一些与电视 1920x1080 分辨率相匹配的壁纸，这看起来很棒！
### 最后处理
我需要在电脑的冷却需求和我对不受阻碍的娱乐的渴望之间取得平衡。由于这是一台标准的 ATX 微型塔式计算机，我确保我有足够的风扇转速，以及在 BIOS 中精心配置过的温度以减少噪音。我还把电脑放在我的娱乐控制台后面，以进一步减少风扇噪音，但同时我可以按到电源按钮。
最后得到一台简单的、没有巨大噪音的机器，而且只使用了两根线缆：交流电源线和 HDMI。它应该能够运行任何主流或专门的媒体中心 Linux 发行版。我不期望去玩高端的游戏，因为这可能需要更多的处理能力。
*Ubuntu Linux 的关于页面。*
*在大屏幕上测试 YouTube 视频。*
我还没安装像 [Kodi](https://kodi.tv/) 这样专门的媒体中心发行版。截至目前，它运行的是 Ubuntu Linux 18.04.1 LTS，而且很稳定。
这是一个有趣的挑战，可以充分利用我已经拥有的东西，而不是购买新的硬件。这只是开源软件的一个好处。最终，我可能会用一个更小，更安静的带有媒体中心的系统或其他小机顶盒替换它，但是现在，它很好地满足了我的需求。
---
via: <https://opensource.com/article/18/11/old-linux-desktop-new-home-media-center>
作者：[Alan Formy-Duval](https://opensource.com/users/alanfdoss) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
2 的威力，Linux 的威力：终端中的 2048
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-2048
|
正在寻找基于终端的游戏来打发时间么？来看看 2048-cli 吧。
|
/data/attachment/album/201901/16/085325rtbawhbxb55z1skk.png.thumb.jpg
|
/data/attachment/album/201901/16/085325rtbawhbxb55z1skk.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"2048"
] |
分享
|
{
"viewnum": 4294,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
正在寻找基于终端的游戏来打发时间么？来看看 2048-cli 吧。
| 2019-01-16T08:53:24 | 2019-01-16T08:53:24 | 10,447 |
/article-10447-1.html
|
>
> 正在寻找基于终端的游戏来打发时间么？来看看 2048-cli 吧。
>
>
>
你好，欢迎来到今天的 Linux 命令行玩具日历。每天，我们会为你的终端带来一个不同的玩具：它可能是一个游戏或任何简单的消遣，可以帮助你获得乐趣。
很可能你们中的一些人之前已经看过我们日历中的各种玩具，但我们希望每个人至少见到一件新事物。
今天的玩具是我最喜欢的休闲游戏之一 [2048](https://github.com/gabrielecirulli/2048) （它本身就是另外一个克隆品的克隆）的[命令行版本](https://github.com/tiehuis/2048-cli)。
要进行游戏，你只需将滑块向上、向下、向左、向右移动，组合成对的数字，并增加数值，直到你得到数字为 2048 的块。最吸引人的地方（以及挑战）是你不能只移动一个滑块，而是需要移动屏幕上的每一块。（LCTT 译注：不知道有没有人在我们 Linux 中国的网站上遇到过 [404](https://linux.cn/404) 页面？那就是一个 2048 游戏，经常我错误地打开一个不存在的页面时，本应该去修复这个问题，却不小心沉迷于其中……）
它简单、有趣，很容易在里面沉迷几个小时。这个 2048 的克隆 [2048-cli](https://github.com/tiehuis/2048-cli) 是 Marc Tiehuis 用 C 编写的，并在 MIT 许可下开源。你可以在 [GitHub](https://github.com/tiehuis/2048-cli) 上找到源代码，你也可在这找到适用于你的平台的安装说明。由于它已为 Fedora 打包，因此我来说，安装就像下面那样简单：
```
$ sudo dnf install 2048-cli
```
这是这样，玩得开心！
你有特别喜欢的命令行小玩具需要我介绍的吗？这个系列要介绍的小玩具大部分已经有了落实，但还预留了几个空位置。如果你有特别想了解的可以评论留言，我会查看的。如果还有空位置，我会考虑介绍它的。如果没有，但如果我得到了一些很好的意见，我会在最后做一些有价值的提及。
查看昨天的玩具，[在 Linux 终端中玩俄罗斯方块](https://opensource.com/article/18/12/linux-toy-tetris)，记得明天再来！
---
via: <https://opensource.com/article/18/12/linux-toy-2048>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
一位开源项目维护者的 5 个决心
|
Ben Cotton
|
https://opensource.com/article/18/12/resolutions-open-source-project-maintainers
|
不管怎么说，好的交流是一个活跃的开源社区的必备品。
|
/data/attachment/album/201901/16/093920o0m0zi1ki1kxukg0.png.thumb.jpg
|
/data/attachment/album/201901/16/093920o0m0zi1ki1kxukg0.png
| true | false | true |
lujun9972
|
bestony
|
wxy
| false |
[
"开源",
"贡献者"
] |
观点
|
{
"viewnum": 5304,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
不管怎么说，好的交流是一个活跃的开源社区的必备品。
| 2019-01-16T09:39:17 | 2019-01-16T09:39:17 | 10,448 |
/article-10448-1.html
|
>
> 不管怎么说，好的交流是一个活跃的开源社区的必备品。
>
>
>
我通常不会定下大的新年决心。当然，我在自我提升方面没有任何问题，这篇文章我希望锚定的是这个日历中的另外一部分。不过即使是这样，这里也有一些东西要从今年的免费日历上划掉，并将其替换为一些可以激发我的自省的新日历内容。
在 2017 年，我从不在社交媒体上分享我从未阅读过的文章。我一直保持这样的状态，我也认为它让我成为了一个更好的互联网公民。对于 2019 年，我正在考虑让我成为更好的开源软件维护者的决心。
下面是一些我在一些项目中担任维护者或共同维护者时坚持的决心：
### 1、包含行为准则
Jono Bacon 在他的文章“[7 个你可能犯的错误](https://opensource.com/article/17/8/mistakes-open-source-avoid)”中包含了一条“不强制执行行为准则”。当然，要强制执行行为准则，你首先需要有一个行为准则。我打算默认用[贡献者契约](https://www.contributor-covenant.org/)，但是你可以使用其他你喜欢的。关于这个许可协议，最好的方法是使用别人已经写好的，而不是你自己写的。但是重要的是，要找到一些能够定义你希望你的社区执行的，无论它们是什么样子。一旦这些被记录下来并强制执行，人们就能自行决定是否成为他们想象中社区的一份子。
### 2、使许可证清晰且明确
你知道什么真的很烦么？不清晰的许可证。这个软件基于 GPL 授权，如果没有进一步提供更多信息的文字，我无法知道更多信息。基于哪个版本的[GPL](https://opensource.org/licenses/gpl-license)？我可以用它吗？对于项目的非代码部分，“根据知识共享许可证（CC）授权”更糟糕。我喜欢[知识共享许可证](https://creativecommons.org/share-your-work/licensing-types-examples/)，但它有几个不同的许可证包含着不同的权利和义务。因此，我将非常清楚的说明哪个许可证的变种和版本适用于我的项目。我将会在仓库中包含许可的全文，并在其他文件中包含简明的注释。
与此相关的一类问题是使用 [OSI](https://opensource.org/) 批准的许可证。想出一个新的准确的说明了你想要表达什么的许可证是有可能的，但是如果你需要强制推行它，祝你好运。会坚持使用它么？使用您项目的人会理解么？
### 3、快速分类错误报告和问题
在技术领域, 很少有比开源维护者更贫乏的东西了。即使在小型项目中，也很难找到时间去回答每个问题并修复每个错误。但这并不意味着我不能哪怕回应一下，它没必要是多段的回复。即使只是给 GitHub 问题贴了个标签也表明了我看见它了。也许我马上就会处理它，也许一年后我会处理它。但是让社区看到它很重要，是的，这里还有人管。
### 4、如果没有伴随的文档，请不要推送新特性或错误修复
尽管多年来我的开源贡献都围绕着文档，但我的项目并没有反映出我对它的重视。我能推送的提交不多，并不不需要某种形式的文档。新的特性显然应该在他们被提交时甚至是在之前就编写文档。但即使是错误修复，也应该在发行说明中有一个条目提及。如果没有什么意外，推送提交也是很好的改善文档的机会。
### 5、放弃一个项目时，要说清楚
我很不擅长对事情说“不”，我告诉编辑我会为 [Opensource.com](http://Opensource.com) 写一到两篇文章，而现在我有了将近 60 篇文章。哎呀。但在某些时候，曾经我有兴趣的事情也会不再有兴趣。也许该项目是不必要的，因为它的功能被吸收到更大的项目中；也许只是我厌倦了它。但这对社区是不公平的（并且存在潜在的危险，正如最近的 [event-stream 恶意软件注入](https://arstechnica.com/information-technology/2018/11/hacker-backdoors-widely-used-open-source-software-to-steal-bitcoin/)所示），会让该项目陷入困境。维护者有权随时离开，但他们离开时应该说清楚。
无论你是开源维护者还是贡献者，如果你知道项目维护者应该作出的其他决心，请在评论中分享！
---
via: <https://opensource.com/article/18/12/resolutions-open-source-project-maintainers>
作者：[Ben Cotton](https://opensource.com/users/bcotton) 选题：[lujun9972](https://github.com/lujun9972) 译者：[bestony](https://github.com/bestony) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 Ansible 来管理你的工作站：配置自动化
|
Jay Lacroix
|
https://opensource.com/article/18/3/manage-your-workstation-configuration-ansible-part-2
|
学习如何使 Ansible 自动对一系列台式机和笔记本应用配置。
|
/data/attachment/album/201901/16/162446gszu3hzkrewilswr.jpg.thumb.jpg
|
/data/attachment/album/201901/16/162446gszu3hzkrewilswr.jpg
| true | false | true |
lujun9972
|
FelixYFZ
|
wxy
| false |
[
"Ansible",
"工作站"
] |
技术
|
{
"viewnum": 6024,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10434,
"displayorder": 0
},
{
"raid": 11105,
"displayorder": 0
}
] |
学习如何使 Ansible 自动对一系列台式机和笔记本应用配置。
| 2019-01-16T16:25:20 | 2019-01-16T16:25:20 | 10,449 |
/article-10449-1.html
|
>
> 学习如何使 Ansible 自动对一系列台式机和笔记本应用配置。
>
>
>
Ansible 是一个令人惊讶的自动化的配置管理工具。其主要应用在服务器和云部署上，但在工作站上的应用（无论是台式机还是笔记本）却鲜少得到关注，这就是本系列所要关注的。
在这个系列的[第一部分](/article-10434-1.html)，我向你展示了 `ansible-pull` 命令的基本用法，我们创建了一个安装了少量包的剧本。它本身是没有多大的用处的，但是为后续的自动化做了准备。
在这篇文章中，将会达成闭环，而且在最后部分，我们将会有一个针对工作站自动配置的完整的工作解决方案。现在，我们将要设置 Ansible 的配置，这样未来将要做的改变将会自动的部署应用到我们的工作站上。现阶段，假设你已经完成了[第一部分](/article-10434-1.html)的工作。如果没有的话，当你完成的时候回到本文。你应该已经有一个包含第一篇文章中代码的 GitHub 库。我们将直接在之前创建的部分之上继续。
首先，因为我们要做的不仅仅是安装包文件，所以我们要做一些重新的组织工作。现在，我们已经有一个名为 `local.yml` 并包含以下内容的剧本：
```
- hosts: localhost
become: true
tasks:
- name: Install packages
apt: name={{item}}
with_items:
- htop
- mc
- tmux
```
如果我们仅仅想实现一个任务那么上面的配置就足够了。随着向我们的配置中不断的添加内容，这个文件将会变的相当的庞大和杂乱。最好能够根据不同类型的配置将我们的<ruby> 动作 <rt> play </rt></ruby>分为独立的文件。为了达到这个要求，创建一个名为<ruby> 任务手册 <rt> taskbook </rt></ruby>的东西，它和<ruby> 剧本 <rt> playbook </rt></ruby>很像但内容更加的流线型。让我们在 Git 库中为任务手册创建一个目录。
```
mkdir tasks
```
`local.yml` 剧本中的代码可以很好地过渡为安装包文件的任务手册。让我们把这个文件移动到刚刚创建好的 `task` 目录中，并重新命名。
```
mv local.yml tasks/packages.yml
```
现在，我们编辑 `packages.yml` 文件将它进行大幅的瘦身，事实上，我们可以精简除了独立任务本身之外的所有内容。让我们把 `packages.yml` 编辑成如下的形式：
```
- name: Install packages
apt: name={{item}}
with_items:
- htop
- mc
- tmux
```
正如你所看到的，它使用同样的语法，但我们去掉了对这个任务无用没有必要的所有内容。现在我们有了一个专门安装包文件的任务手册。然而我们仍然需要一个名为 `local.yml` 的文件，因为执行 `ansible-pull` 命令时仍然会去找这个文件。所以我们将在我们库的根目录下（不是在 `task` 目录下）创建一个包含这些内容的全新文件：
```
- hosts: localhost
become: true
pre_tasks:
- name: update repositories
apt: update_cache=yes
changed_when: False
tasks:
- include: tasks/packages.yml
```
这个新的 `local.yml` 扮演的是导入我们的任务手册的索引的角色。我已经在这个文件中添加了一些你在这个系列中还没见到的内容。首先，在这个文件的开头处，我添加了 `pre_tasks`，这个任务的作用是在其他所有任务运行之前先运行某个任务。在这种情况下，我们给 Ansible 的命令是让它去更新我们的发行版的软件库的索引，下面的配置将执行这个任务要求：
```
apt: update_cache=yes
```
通常 `apt` 模块是用来安装包文件的，但我们也能够让它来更新软件库索引。这样做的目的是让我们的每个动作在 Ansible 运行的时候能够以最新的索引工作。这将确保我们在使用一个老旧的索引安装一个包的时候不会出现问题。因为 `apt` 模块仅仅在 Debian、Ubuntu 及它们的衍生发行版下工作。如果你运行的一个不同的发行版，你要使用特定于你的发行版的模块而不是 `apt`。如果你需要使用一个不同的模块请查看 Ansible 的相关文档。
下面这行也需要进一步解释：
```
changed_when: False
```
在某个任务中的这行阻止了 Ansible 去报告动作改变的结果，即使是它本身在系统中导致的一个改变。在这里，我们不会去在意库索引是否包含新的数据；它几乎总是会的，因为库总是在改变的。我们不会去在意 `apt` 库的改变，因为索引的改变是正常的过程。如果我们删除这行，我们将在过程报告的后面看到所有的变动，即使仅仅库的更新而已。最好忽略这类的改变。
接下来是常规任务的阶段，我们将创建好的任务手册导入。我们每次添加另一个任务手册的时候，要添加下面这一行：
```
tasks:
- include: tasks/packages.yml
```
如果你现在运行 `ansible-pull` 命令，它应该基本上像上一篇文章中做的一样。不同的是我们已经改进了我们的组织方式，并且能够更有效的扩展它。为了节省你到上一篇文章中去寻找，`ansible-pull` 命令的语法参考如下：
```
sudo ansible-pull -U https://github.com/<github_user>/ansible.git
```
如果你还记得话，`ansible-pull` 的命令拉取一个 Git 仓库并且应用它所包含的配置。
既然我们的基础已经搭建好，我们现在可以扩展我们的 Ansible 并且添加功能。更特别的是，我们将添加配置来自动化的部署对工作站要做的改变。为了支撑这个要求，首先我们要创建一个特殊的账户来应用我们的 Ansible 配置。这个不是必要的，我们仍然能够在我们自己的用户下运行 Ansible 配置。但是使用一个隔离的用户能够将其隔离到不需要我们参与的在后台运行的一个系统进程中，
我们可以使用常规的方式来创建这个用户，但是既然我们正在使用 Ansible，我们应该尽量避开使用手动的改变。替代的是，我们将会创建一个任务手册来处理用户创建任务。这个任务手册目前将会仅仅创建一个用户，但你可以在这个任务手册中添加额外的动作来创建更多的用户。我将这个用户命名为 `ansible`，你可以按照自己的想法来命名（如果你做了这个改变要确保更新所有出现地方）。让我们来创建一个名为 `user.yml` 的任务手册并且将以下代码写进去：
```
- name: create ansible user
user: name=ansible uid=900
```
下一步，我们需要编辑 `local.yml` 文件，将这个新的任务手册添加进去，像如下这样写：
```
- hosts: localhost
become: true
pre_tasks:
- name: update repositories
apt: update_cache=yes
changed_when: False
tasks:
- include: tasks/users.yml
- include: tasks/packages.yml
```
现在当我们运行 `ansible-pull` 命令的时候，一个名为 `ansible` 的用户将会在系统中被创建。注意我特地通过参数 `uid` 为这个用户声明了用户 ID 为 900。这个不是必须的，但建议直接创建好 UID。因为在 1000 以下的 UID 在登录界面是不会显示的，这样是很棒的，因为我们根本没有需要去使用 `ansibe` 账户来登录我们的桌面。UID 900 是随便定的；它应该是在 1000 以下没有被使用的任何一个数值。你可以使用以下命令在系统中去验证 UID 900 是否已经被使用了：
```
cat /etc/passwd |grep 900
```
不过，你使用这个 UID 应该不会遇到什么问题，因为迄今为止在我使用的任何发行版中我还没遇到过它是被默认使用的。
现在，我们已经拥有了一个名为 `ansible` 的账户，它将会在之后的自动化配置中使用。接下来，我们可以创建实际的定时作业来自动操作。我们应该将其分开放到它自己的文件中，而不是将其放置到我们刚刚创建的 `users.yml` 文件中。在任务目录中创建一个名为 `cron.yml` 的任务手册并且将以下的代码写进去：
```
- name: install cron job (ansible-pull)
cron: user="ansible" name="ansible provision" minute="*/10" job="/usr/bin/ansible-pull -o -U https://github.com/<github_user>/ansible.git > /dev/null"
```
`cron` 模块的语法几乎不需加以说明。通过这个动作，我们创建了一个通过用户 `ansible` 运行的定时作业。这个作业将每隔 10 分钟执行一次，下面是它将要执行的命令：
```
/usr/bin/ansible-pull -o -U https://github.com/<github_user>/ansible.git > /dev/null
```
同样，我们也可以添加想要我们的所有工作站部署的额外的定时作业到这个文件中。我们只需要在新的定时作业中添加额外的动作即可。然而，仅仅是添加一个定时的任务手册是不够的，我们还需要将它添加到 `local.yml` 文件中以便它能够被调用。将下面的一行添加到末尾：
```
- include: tasks/cron.yml
```
现在当 `ansible-pull` 命令执行的时候，它将会以用户 `ansible` 每隔十分钟设置一个新的定时作业。但是，每个十分钟运行一个 Ansible 作业并不是一个好的方式，因为这个将消耗很多的 CPU 资源。每隔十分钟来运行对于 Ansible 来说是毫无意义的，除非我们已经在 Git 仓库中改变一些东西。
然而，我们已经解决了这个问题。注意我在定时作业中的命令 `ansible-pill` 添加的我们之前从未用到过的参数 `-o`。这个参数告诉 Ansible 只有在从上次 `ansible-pull` 被调用以后库有了变化后才会运行。如果库没有任何变化，它将不会做任何事情。通过这个方法，你将不会无端的浪费 CPU 资源。当然在拉取存储库的时候会使用一些 CPU 资源，但不会像再一次应用整个配置的时候使用的那么多。当 `ansible-pull` 执行的时候，它将会遍历剧本和任务手册中的所有任务，但至少它不会毫无目的的运行。
尽管我们已经添加了所有必须的配置要素来自动化 `ansible-pull`，它仍然还不能正常的工作。`ansible-pull` 命令需要 `sudo` 的权限来运行，这将允许它执行系统级的命令。然而我们创建的用户 `ansible` 并没有被设置为以 `sudo` 的权限来执行命令，因此当定时作业触发的时候，执行将会失败。通常我们可以使用命令 `visudo` 来手动的去设置用户 `ansible` 去拥有这个权限。然而我们现在应该以 Ansible 的方式来操作，而且这将会是一个向你展示 `copy` 模块是如何工作的机会。`copy` 模块允许你从库复制一个文件到文件系统的任何位置。在这个案列中，我们将会复制 `sudo` 的一个配置文件到 `/etc/sudoers.d/` 以便用户 `ansible` 能够以管理员的权限执行任务。
打开 `users.yml`，将下面的的动作添加到文件末尾。
```
- name: copy sudoers_ansible
copy: src=files/sudoers_ansible dest=/etc/sudoers.d/ansible owner=root group=root mode=0440
```
正如我们看到的，`copy`模块从我们的仓库中复制一个文件到其他任何位置。在这个过程中，我们正在抓取一个名为 `sudoers_ansible`（我们将在后续创建）的文件并将它复制为 `/etc/sudoers/ansible`，并且拥有者为 `root`。
接下来，我们需要创建我们将要复制的文件。在你的仓库的根目录下，创建一个名为 `files` 的目录：
```
mkdir files
```
然后，在我们刚刚创建的 `files` 目录里，创建名为 `sudoers_ansible` 的文件，包含以下内容：
```
ansible ALL=(ALL) NOPASSWD: ALL
```
就像我们正在这样做的，在 `/etc/sudoer.d` 目录里创建一个文件允许我们为一个特殊的用户配置 `sudo` 权限。现在我们正在通过 `sudo` 允许用户 `ansible` 不需要密码提示就拥有完全控制权限。这将允许 `ansible-pull` 以后台任务的形式运行而不需要手动去运行。
现在，你可以通过再次运行 `ansible-pull` 来拉取最新的变动：
```
sudo ansible-pull -U https://github.com/<github_user>/ansible.git
```
从这里开始，`ansible-pull` 的定时作业将会在后台每隔十分钟运行一次来检查你的仓库是否有变化，如果它发现有变化，将会运行你的剧本并且应用你的任务手册。
所以现在我们有了一个完整的可工作方案。当你第一次设置一台新的笔记本或者台式机的时候，你要去手动的运行 `ansible-pull` 命令，但仅仅是在第一次的时候。从第一次之后，用户 `ansible` 将会在后台接手后续的运行任务。当你想对你的机器做变动的时候，你只需要简单的去拉取你的 Git 仓库来做变动，然后将这些变化回传到库中。接着，当定时作业下次在每台机器上运行的时候，它将会拉取变动的部分并应用它们。你现在只需要做一次变动，你的所有工作站将会跟着一起变动。这方法尽管有一点不同寻常，通常，你会有一个包含你的机器列表和不同机器所属规则的清单文件。然而，`ansible-pull` 的方法，就像在文章中描述的，是管理工作站配置的非常有效的方法。
我已经在我的 [Github 仓库](https://github.com/jlacroix82/ansible_article.git)中更新了这篇文章中的代码，所以你可以随时去浏览来对比检查你的语法。同时我将前一篇文章中的代码移到了它自己的目录中。
在[第三部分](https://opensource.com/article/18/5/manage-your-workstation-ansible-part-3)，我们将通过介绍使用 Ansible 来配置 GNOME 桌面设置来结束这个系列。我将会告诉你如何设置你的墙纸和锁屏壁纸、应用一个桌面主题以及更多的东西。
同时，到了布置一些作业的时候了，大多数人都有我们所使用的各种应用的配置文件。可能是 Bash、Vim 或者其他你使用的工具的配置文件。现在你可以尝试通过我们在使用的 Ansible 库来自动复制这些配置到你的机器中。在这篇文章中，我已将向你展示了如何去复制文件，所以去尝试以下看看你是都已经能应用这些知识。
---
via: <https://opensource.com/article/18/3/manage-your-workstation-configuration-ansible-part-2>
作者：[Jay LaCroix](https://opensource.com/users/jlacroix) 选题：[lujun9972](https://github.com/lujun9972) 译者：[FelixYFZ](https://github.com/FelixYFZ) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 Linux 中打扮你的冬季 Bash 提示符
|
Jason Baker
|
https://opensource.com/article/18/12/linux-toy-bash-prompt
|
你的 Linux 终端可能支持 Unicode，那么为何不利用它在提示符中添加季节性的图标呢？
|
/data/attachment/album/201901/16/184022d59vyvvkvqaa578v.png.thumb.jpg
|
/data/attachment/album/201901/16/184022d59vyvvkvqaa578v.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"提示符"
] |
分享
|
{
"viewnum": 4780,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
你的 Linux 终端可能支持 Unicode，那么为何不利用它在提示符中添加季节性的图标呢？
| 2019-01-16T18:40:00 | 2019-01-16T18:40:00 | 10,450 |
/article-10450-1.html
|
>
> 你的 Linux 终端可能支持 Unicode，那么为何不利用它在提示符中添加季节性的图标呢？
>
>
>
欢迎再次来到 Linux 命令行玩具日历的另一篇。如果这是你第一次访问该系列，你甚至可能会问自己什么是命令行玩具？我们对此比较随意：它会是终端上有任何有趣的消遣，对于任何节日主题相关的还有额外的加分。
也许你以前见过其中的一些，也许你没有。不管怎样，我们希望你玩得开心。
今天的玩具非常简单：它是你的 Bash 提示符。你的 Bash 提示符？是的！我们还有几个星期的假期可以盯着它看，在北半球冬天还会再多几周，所以为什么不玩玩它。
目前你的 Bash 提示符号可能是一个简单的美元符号（ `$`），或者更有可能是一个更长的东西。如果你不确定你的 Bash 提示符是什么，你可以在环境变量 `$PS1` 中找到它。要查看它，请输入：
```
echo $PS1
```
对于我而言，它返回：
```
[\u@\h \W]\$
```
`\u`、`\h` 和 `\W` 分别是用户名、主机名和工作目录的特殊字符。你还可以使用其他一些符号。为了帮助构建你的 Bash 提示符，你可以使用 [EzPrompt](http://ezprompt.net/)，这是一个 `PS1` 配置的在线生成器，它包含了许多选项，包括日期和时间、Git 状态等。
你可能还有其他变量来组成 Bash 提示符。对我来说，`$PS2` 包含了我命令提示符的结束括号。有关详细信息，请参阅 [这篇文章](https://access.redhat.com/solutions/505983)。
要更改提示符，只需在终端中设置环境变量，如下所示：
```
$ PS1='\u is cold: '
jehb is cold:
```
要永久设置它，请使用你喜欢的文本编辑器将相同的代码添加到 `/etc/bashrc` 中。
那么这些与冬季化有什么关系呢？好吧，你很有可能有现代一下的机器，你的终端支持 Unicode，所以你不仅限于标准的 ASCII 字符集。你可以使用任何符合 Unicode 规范的 emoji，包括雪花 ❄、雪人 ☃ 或一对滑雪板。你有很多冬季 emoji 可供选择。
* 圣诞树
* 外套
* 鹿手套
* 圣诞夫人
* 圣诞老人
* 围巾
* 滑雪者
* 滑雪板
* 雪花
* 雪人
* 没有雪的雪人
* 包装好的礼物
选择你最喜欢的，享受冬天的欢乐。有趣的事实：现代文件系统也支持文件名中的 Unicode 字符，这意味着技术上你可以将你下个程序命名为 `❄❄❄❄❄.py`。只是说说，不要这么做。
你有特别喜欢的命令行小玩具需要我介绍的吗？这个系列要介绍的小玩具大部分已经有了落实，但还预留了几个空位置。如果你有特别想了解的可以评论留言，我会查看的。如果还有空位置，我会考虑介绍它的。如果没有，但如果我得到了一些很好的意见，我会在最后做一些有价值的提及。
查看昨天的玩具，[在 Linux 终端玩贪吃蛇](https://opensource.com/article/18/12/linux-toy-snake)，记得明天再来！
---
via: <https://opensource.com/article/18/12/linux-toy-bash-prompt>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Caffeinated 6.828：实验 6：网络驱动程序
|
Csail.mit
|
https://pdos.csail.mit.edu/6.828/2018/labs/lab6/
|
现在你已经有了一个文件系统，一个典型的操作系统都应该有一个网络栈。在本实验中，你将继续为一个网卡去写一个驱动程序。
|
/data/attachment/album/201901/17/204350s86sch2hc3939xs3.jpeg.thumb.jpg
|
/data/attachment/album/201901/17/204350s86sch2hc3939xs3.jpeg
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"网卡",
"6.828"
] |
技术
|
{
"viewnum": 5777,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10389,
"displayorder": 0
},
{
"raid": 10461,
"displayorder": 0
}
] |
现在你已经有了一个文件系统，一个典型的操作系统都应该有一个网络栈。在本实验中，你将继续为一个网卡去写一个驱动程序。
| 2019-01-17T20:44:00 | 2019-01-17T20:44:00 | 10,452 |
/article-10452-1.html
|
### 简介
这个实验是默认你能够自己完成的最终项目。
现在你已经有了一个文件系统，一个典型的操作系统都应该有一个网络栈。在本实验中，你将继续为一个网卡去写一个驱动程序。这个网卡基于 Intel 82540EM 芯片，也就是众所周知的 E1000 芯片。
#### 预备知识
使用 Git 去提交你的实验 5 的源代码（如果还没有提交的话），获取课程仓库的最新版本，然后创建一个名为 `lab6` 的本地分支，它跟踪我们的远程分支 `origin/lab6`：
```
athena% cd ~/6.828/lab
athena% add git
athena% git commit -am 'my solution to lab5'
nothing to commit (working directory clean)
athena% git pull
Already up-to-date.
athena% git checkout -b lab6 origin/lab6
Branch lab6 set up to track remote branch refs/remotes/origin/lab6.
Switched to a new branch "lab6"
athena% git merge lab5
Merge made by recursive.
fs/fs.c | 42 +++++++++++++++++++
1 files changed, 42 insertions(+), 0 deletions(-)
athena%
```
然后，仅有网卡驱动程序并不能够让你的操作系统接入互联网。在新的实验 6 的代码中，我们为你提供了网络栈和一个网络服务器。与以前的实验一样，使用 git 去拉取这个实验的代码，合并到你自己的代码中，并去浏览新的 `net/` 目录中的内容，以及在 `kern/` 中的新文件。
除了写这个驱动程序以外，你还需要去创建一个访问你的驱动程序的系统调用。你将要去实现那些在网络服务器中缺失的代码，以便于在网络栈和你的驱动程序之间传输包。你还需要通过完成一个 web 服务器来将所有的东西连接到一起。你的新 web 服务器还需要你的文件系统来提供所需要的文件。
大部分的内核设备驱动程序代码都需要你自己去从头开始编写。本实验提供的指导比起前面的实验要少一些：没有框架文件、没有现成的系统调用接口、并且很多设计都由你自己决定。因此，我们建议你在开始任何单独练习之前，阅读全部的编写任务。许多学生都反应这个实验比前面的实验都难，因此请根据你的实际情况计划你的时间。
#### 实验要求
与以前一样，你需要做实验中全部的常规练习和至少一个挑战问题。在实验中写出你的详细答案，并将挑战问题的方案描述写入到 `answers-lab6.txt` 文件中。
### QEMU 的虚拟网络
我们将使用 QEMU 的用户模式网络栈，因为它不需要以管理员权限运行。QEMU 的文档的[这里](http://wiki.qemu.org/download/qemu-doc.html#Using-the-user-mode-network-stack)有更多关于用户网络的内容。我们更新后的 makefile 启用了 QEMU 的用户模式网络栈和虚拟的 E1000 网卡。
缺省情况下，QEMU 提供一个运行在 IP 地址 10.2.2.2 上的虚拟路由器，它给 JOS 分配的 IP 地址是 10.0.2.15。为了简单起见，我们在 `net/ns.h` 中将这些缺省值硬编码到网络服务器上。
虽然 QEMU 的虚拟网络允许 JOS 随意连接互联网，但 JOS 的 10.0.2.15 的地址并不能在 QEMU 中的虚拟网络之外使用（也就是说，QEMU 还得做一个 NAT），因此我们并不能直接连接到 JOS 上运行的服务器，即便是从运行 QEMU 的主机上连接也不行。为解决这个问题，我们配置 QEMU 在主机的某些端口上运行一个服务器，这个服务器简单地连接到 JOS 中的一些端口上，并在你的真实主机和虚拟网络之间传递数据。
你将在端口 7（echo）和端口 80（http）上运行 JOS，为避免在共享的 Athena 机器上发生冲突，makefile 将为这些端口基于你的用户 ID 来生成转发端口。你可以运行 `make which-ports` 去找出是哪个 QEMU 端口转发到你的开发主机上。为方便起见，makefile 也提供 `make nc-7` 和 `make nc-80`，它允许你在终端上直接与运行这些端口的服务器去交互。（这些目标仅能连接到一个运行中的 QEMU 实例上；你必须分别去启动它自己的 QEMU）
#### 包检查
makefile 也可以配置 QEMU 的网络栈去记录所有的入站和出站数据包，并将它保存到你的实验目录中的 `qemu.pcap` 文件中。
使用 `tcpdump` 命令去获取一个捕获的 hex/ASCII 包转储：
```
tcpdump -XXnr qemu.pcap
```
或者，你可以使用 [Wireshark](http://www.wireshark.org/) 以图形化界面去检查 pcap 文件。Wireshark 也知道如何去解码和检查成百上千的网络协议。如果你在 Athena 上，你可以使用 Wireshark 的前辈：ethereal，它运行在加锁的保密互联网协议网络中。
#### 调试 E1000
我们非常幸运能够去使用仿真硬件。由于 E1000 是在软件中运行的，仿真的 E1000 能够给我们提供一个人类可读格式的报告、它的内部状态以及它遇到的任何问题。通常情况下，对祼机上做驱动程序开发的人来说，这是非常难能可贵的。
E1000 能够产生一些调试输出，因此你可以去打开一个专门的日志通道。其中一些对你有用的通道如下：
| 标志 | 含义 |
| --- | --- |
| tx | 包发送日志 |
| txerr | 包发送错误日志 |
| rx | 到 RCTL 的日志通道 |
| rxfilter | 入站包过滤日志 |
| rxerr | 接收错误日志 |
| unknown | 未知寄存器的读写日志 |
| eeprom | 读取 EEPROM 的日志 |
| interrupt | 中断和中断寄存器变更日志 |
例如，你可以使用 `make E1000_DEBUG=tx,txerr` 去打开 “tx” 和 “txerr” 日志功能。
注意：`E1000_DEBUG` 标志仅能在打了 6.828 补丁的 QEMU 版本上工作。
你可以使用软件去仿真硬件，来做进一步的调试工作。如果你使用它时卡壳了，不明白为什么 E1000 没有如你预期那样响应你，你可以查看在 `hw/e1000.c` 中的 QEMU 的 E1000 实现。
### 网络服务器
从头开始写一个网络栈是很困难的。因此我们将使用 lwIP，它是一个开源的、轻量级 TCP/IP 协议套件，它能做包括一个网络栈在内的很多事情。你能在 [这里](http://www.sics.se/%7Eadam/lwip/) 找到很多关于 lwIP 的信息。在这个任务中，对我们而言，lwIP 就是一个实现了一个 BSD 套接字接口和拥有一个包输入端口和包输出端口的黑盒子。
一个网络服务器其实就是一个有以下四个环境的混合体：
* 核心网络服务器环境（包括套接字调用派发器和 lwIP）
* 输入环境
* 输出环境
* 定时器环境
下图展示了各个环境和它们之间的关系。下图展示了包括设备驱动的整个系统，我们将在后面详细讲到它。在本实验中，你将去实现图中绿色高亮的部分。
#### 核心网络服务器环境
核心网络服务器环境由套接字调用派发器和 lwIP 自身组成的。套接字调用派发器就像一个文件服务器一样。用户环境使用 stubs（可以在 `lib/nsipc.c` 中找到它）去发送 IPC 消息到核心网络服务器环境。如果你看了 `lib/nsipc.c`，你就会发现核心网络服务器与我们创建的文件服务器 `i386_init` 的工作方式是一样的，`i386_init` 是使用 NSTYPENS 创建的 NS 环境，因此我们检查 `envs`，去查找这个特殊的环境类型。对于每个用户环境的 IPC，网络服务器中的派发器将调用相应的、由 lwIP 提供的、代表用户的 BSD 套接字接口函数。
普通用户环境不能直接使用 `nsipc_*` 调用。而是通过在 `lib/sockets.c` 中的函数来使用它们，这些函数提供了基于文件描述符的套接字 API。以这种方式，用户环境通过文件描述符来引用套接字，就像它们引用磁盘上的文件一样。一些操作（`connect`、`accept` 等等）是特定于套接字的，但 `read`、`write` 和 `close` 是通过 `lib/fd.c` 中一般的文件描述符设备派发代码的。就像文件服务器对所有的打开的文件维护唯一的内部 ID 一样，lwIP 也为所有的打开的套接字生成唯一的 ID。不论是文件服务器还是网络服务器，我们都使用存储在 `struct Fd` 中的信息去映射每个环境的文件描述符到这些唯一的 ID 空间上。
尽管看起来文件服务器的网络服务器的 IPC 派发器行为是一样的，但它们之间还有很重要的差别。BSD 套接字调用（像 `accept` 和 `recv`）能够无限期阻塞。如果派发器让 lwIP 去执行其中一个调用阻塞，派发器也将被阻塞，并且在整个系统中，同一时间只能有一个未完成的网络调用。由于这种情况是无法接受的，所以网络服务器使用用户级线程以避免阻塞整个服务器环境。对于每个入站 IPC 消息，派发器将创建一个线程，然后在新创建的线程上来处理请求。如果线程被阻塞，那么只有那个线程被置入休眠状态，而其它线程仍然处于运行中。
除了核心网络环境外，还有三个辅助环境。核心网络服务器环境除了接收来自用户应用程序的消息之外，它的派发器也接收来自输入环境和定时器环境的消息。
#### 输出环境
在为用户环境套接字调用提供服务时，lwIP 将为网卡生成用于发送的包。lwIP 将使用 `NSREQ_OUTPUT` 去发送在 IPC 消息页参数中附加了包的 IPC 消息。输出环境负责接收这些消息，并通过你稍后创建的系统调用接口来转发这些包到设备驱动程序上。
#### 输入环境
网卡接收到的包需要传递到 lwIP 中。输入环境将每个由设备驱动程序接收到的包拉进内核空间（使用你将要实现的内核系统调用），并使用 `NSREQ_INPUT` IPC 消息将这些包发送到核心网络服务器环境。
包输入功能是独立于核心网络环境的，因为在 JOS 上同时实现接收 IPC 消息并从设备驱动程序中查询或等待包有点困难。我们在 JOS 中没有实现 `select` 系统调用，这是一个允许环境去监视多个输入源以识别准备处理哪个输入的系统调用。
如果你查看了 `net/input.c` 和 `net/output.c`，你将会看到在它们中都需要去实现那个系统调用。这主要是因为实现它要依赖你的系统调用接口。在你实现了驱动程序和系统调用接口之后，你将要为这两个辅助环境写这个代码。
#### 定时器环境
定时器环境周期性发送 `NSREQ_TIMER` 类型的消息到核心服务器，以提醒它那个定时器已过期。lwIP 使用来自线程的定时器消息来实现各种网络超时。
### Part A：初始化和发送包
你的内核还没有一个时间概念，因此我们需要去添加它。这里有一个由硬件产生的每 10 ms 一次的时钟中断。每收到一个时钟中断，我们将增加一个变量值，以表示时间已过去 10 ms。它在 `kern/time.c` 中已实现，但还没有完全集成到你的内核中。
>
> **练习 1**、为 `kern/trap.c` 中的每个时钟中断增加一个到 `time_tick` 的调用。实现 `sys_time_msec` 并增加到 `kern/syscall.c` 中的 `syscall`，以便于用户空间能够访问时间。
>
>
>
使用 `make INIT_CFLAGS=-DTEST_NO_NS run-testtime` 去测试你的代码。你应该会看到环境计数从 5 开始以 1 秒为间隔减少。`-DTEST_NO_NS` 参数禁止在网络服务器环境上启动，因为在当前它将导致 JOS 崩溃。
#### 网卡
写驱动程序要求你必须深入了解硬件和软件中的接口。本实验将给你提供一个如何使用 E1000 接口的高度概括的文档，但是你在写驱动程序时还需要大量去查询 Intel 的手册。
>
> **练习 2**、为开发 E1000 驱动，去浏览 Intel 的 [软件开发者手册](https://pdos.csail.mit.edu/6.828/2018/readings/hardware/8254x_GBe_SDM.pdf)。这个手册涵盖了几个与以太网控制器紧密相关的东西。QEMU 仿真了 82540EM。
>
>
> 现在，你应该去浏览第 2 章，以对设备获得一个整体概念。写驱动程序时，你需要熟悉第 3 到 14 章，以及 4.1（不包括 4.1 的子节）。你也应该去参考第 13 章。其它章涵盖了 E1000 的组件，你的驱动程序并不与这些组件去交互。现在你不用担心过多细节的东西；只需要了解文档的整体结构，以便于你后面需要时容易查找。
>
>
> 在阅读手册时，记住，E1000 是一个拥有很多高级特性的很复杂的设备，一个能让 E1000 工作的驱动程序仅需要它一小部分的特性和 NIC 提供的接口即可。仔细考虑一下，如何使用最简单的方式去使用网卡的接口。我们强烈推荐你在使用高级特性之前，只去写一个基本的、能够让网卡工作的驱动程序即可。
>
>
>
##### PCI 接口
E1000 是一个 PCI 设备，也就是说它是插到主板的 PCI 总线插槽上的。PCI 总线有地址、数据、和中断线，并且 PCI 总线允许 CPU 与 PCI 设备通讯，以及 PCI 设备去读取和写入内存。一个 PCI 设备在它能够被使用之前，需要先发现它并进行初始化。发现 PCI 设备是 PCI 总线查找已安装设备的过程。初始化是分配 I/O 和内存空间、以及协商设备所使用的 IRQ 线的过程。
我们在 `kern/pci.c` 中已经为你提供了使用 PCI 的代码。PCI 初始化是在引导期间执行的，PCI 代码遍历PCI 总线来查找设备。当它找到一个设备时，它读取它的供应商 ID 和设备 ID，然后使用这两个值作为关键字去搜索 `pci_attach_vendor` 数组。这个数组是由像下面这样的 `struct pci_driver` 条目组成：
```
struct pci_driver {
uint32_t key1, key2;
int (*attachfn) (struct pci_func *pcif);
};
```
如果发现的设备的供应商 ID 和设备 ID 与数组中条目匹配，那么 PCI 代码将调用那个条目的 `attachfn` 去执行设备初始化。（设备也可以按类别识别，那是通过 `kern/pci.c` 中其它的驱动程序表来实现的。）
绑定函数是传递一个 PCI 函数 去初始化。一个 PCI 卡能够发布多个函数，虽然这个 E1000 仅发布了一个。下面是在 JOS 中如何去表示一个 PCI 函数：
```
struct pci_func {
struct pci_bus *bus;
uint32_t dev;
uint32_t func;
uint32_t dev_id;
uint32_t dev_class;
uint32_t reg_base[6];
uint32_t reg_size[6];
uint8_t irq_line;
};
```
上面的结构反映了在 Intel 开发者手册里第 4.1 节的表 4-1 中找到的一些条目。`struct pci_func` 的最后三个条目我们特别感兴趣的，因为它们将记录这个设备协商的内存、I/O、以及中断资源。`reg_base` 和 `reg_size` 数组包含最多六个基址寄存器或 BAR。`reg_base` 为映射到内存中的 I/O 区域（对于 I/O 端口而言是基 I/O 端口）保存了内存的基地址，`reg_size` 包含了以字节表示的大小或来自 `reg_base` 的相关基值的 I/O 端口号，而 `irq_line` 包含了为中断分配给设备的 IRQ 线。在表 4-2 的后半部分给出了 E1000 BAR 的具体涵义。
当设备调用了绑定函数后，设备已经被发现，但没有被启用。这意味着 PCI 代码还没有确定分配给设备的资源，比如地址空间和 IRQ 线，也就是说，`struct pci_func` 结构的最后三个元素还没有被填入。绑定函数将调用 `pci_func_enable`，它将去启用设备、协商这些资源、并在结构 `struct pci_func` 中填入它。
>
> **练习 3**、实现一个绑定函数去初始化 E1000。添加一个条目到 `kern/pci.c` 中的数组 `pci_attach_vendor` 上，如果找到一个匹配的 PCI 设备就去触发你的函数（确保一定要把它放在表末尾的 `{0, 0, 0}` 条目之前）。你在 5.2 节中能找到 QEMU 仿真的 82540EM 的供应商 ID 和设备 ID。在引导期间，当 JOS 扫描 PCI 总线时，你也可以看到列出来的这些信息。
>
>
> 到目前为止，我们通过 `pci_func_enable` 启用了 E1000 设备。通过本实验我们将添加更多的初始化。
>
>
> 我们已经为你提供了 `kern/e1000.c` 和 `kern/e1000.h` 文件，这样你就不会把构建系统搞糊涂了。不过它们现在都是空的；你需要在本练习中去填充它们。你还可能在内核的其它地方包含这个 `e1000.h` 文件。
>
>
> 当你引导你的内核时，你应该会看到它输出的信息显示 E1000 的 PCI 函数已经启用。这时你的代码已经能够通过 `make grade` 的 `pci attach` 测试了。
>
>
>
##### 内存映射的 I/O
软件与 E1000 通过内存映射的 I/O（MMIO）来沟通。你在 JOS 的前面部分可能看到过 MMIO 两次：CGA 控制台和 LAPIC 都是通过写入和读取“内存”来控制和查询设备的。但这些读取和写入不是去往内存芯片的，而是直接到这些设备的。
`pci_func_enable` 为 E1000 协调一个 MMIO 区域，来存储它在 BAR 0 的基址和大小（也就是 `reg_base[0]` 和 `reg_size[0]`），这是一个分配给设备的一段物理内存地址，也就是说你可以通过虚拟地址访问它来做一些事情。由于 MMIO 区域一般分配高位物理地址（一般是 3GB 以上的位置），因此你不能使用 `KADDR` 去访问它们，因为 JOS 被限制为最大使用 256MB。因此，你可以去创建一个新的内存映射。我们将使用 `MMIOBASE`（从实验 4 开始，你的 `mmio_map_region` 区域应该确保不能被 LAPIC 使用的映射所覆盖）以上的部分。由于在 JOS 创建用户环境之前，PCI 设备就已经初始化了，因此你可以在 `kern_pgdir` 处创建映射，并且让它始终可用。
>
> **练习 4**、在你的绑定函数中，通过调用 `mmio_map_region`（它就是你在实验 4 中写的，是为了支持 LAPIC 内存映射）为 E1000 的 BAR 0 创建一个虚拟地址映射。
>
>
> 你将希望在一个变量中记录这个映射的位置，以便于后面访问你映射的寄存器。去看一下 `kern/lapic.c` 中的 `lapic` 变量，它就是一个这样的例子。如果你使用一个指针指向设备寄存器映射，一定要声明它为 `volatile`；否则，编译器将允许缓存它的值，并可以在内存中再次访问它。
>
>
> 为测试你的映射，尝试去输出设备状态寄存器（第 12.4.2 节）。这是一个在寄存器空间中以字节 8 开头的 4 字节寄存器。你应该会得到 `0x80080783`，它表示以 1000 MB/s 的速度启用一个全双工的链路，以及其它信息。
>
>
>
提示：你将需要一些常数，像寄存器位置和掩码位数。如果从开发者手册中复制这些东西很容易出错，并且导致调试过程很痛苦。我们建议你使用 QEMU 的 [e1000\_hw.h](https://pdos.csail.mit.edu/6.828/2018/labs/lab6/e1000_hw.h) 头文件做为基准。我们不建议完全照抄它，因为它定义的值远超过你所需要，并且定义的东西也不见得就是你所需要的，但它仍是一个很好的参考。
##### DMA
你可能会认为是从 E1000 的寄存器中通过写入和读取来传送和接收数据包的，其实这样做会非常慢，并且还要求 E1000 在其中去缓存数据包。相反，E1000 使用直接内存访问（DMA）从内存中直接读取和写入数据包，而且不需要 CPU 参与其中。驱动程序负责为发送和接收队列分配内存、设置 DMA 描述符、以及配置 E1000 使用的队列位置，而在这些设置完成之后的其它工作都是异步方式进行的。发送包的时候，驱动程序复制它到发送队列的下一个 DMA 描述符中，并且通知 E1000 下一个发送包已就绪；当轮到这个包发送时，E1000 将从描述符中复制出数据。同样，当 E1000 接收一个包时，它从接收队列中将它复制到下一个 DMA 描述符中，驱动程序将能在下一次读取到它。
总体来看，接收队列和发送队列非常相似。它们都是由一系列的描述符组成。虽然这些描述符的结构细节有所不同，但每个描述符都包含一些标志和包含了包数据的一个缓存的物理地址（发送到网卡的数据包，或网卡将接收到的数据包写入到由操作系统分配的缓存中）。
队列被实现为一个环形数组，意味着当网卡或驱动到达数组末端时，它将重新回到开始位置。它有一个头指针和尾指针，队列的内容就是这两个指针之间的描述符。硬件就是从头开始移动头指针去消费描述符，在这期间驱动程序不停地添加描述符到尾部，并移动尾指针到最后一个描述符上。发送队列中的描述符表示等待发送的包（因此，在平静状态下，发送队列是空的）。对于接收队列，队列中的描述符是表示网卡能够接收包的空描述符（因此，在平静状态下，接收队列是由所有的可用接收描述符组成的）。正确的更新尾指针寄存器而不让 E1000 产生混乱是很有难度的；要小心！
指向到这些数组及描述符中的包缓存地址的指针都必须是物理地址，因为硬件是直接在物理内存中且不通过 MMU 来执行 DMA 的读写操作的。
#### 发送包
E1000 中的发送和接收功能本质上是独立的，因此我们可以同时进行发送接收。我们首先去攻克简单的数据包发送，因为我们在没有先去发送一个 “I’m here!” 包之前是无法测试接收包功能的。
首先，你需要初始化网卡以准备发送，详细步骤查看 14.5 节（不必着急看子节）。发送初始化的第一步是设置发送队列。队列的详细结构在 3.4 节中，描述符的结构在 3.3.3 节中。我们先不要使用 E1000 的 TCP offload 特性，因此你只需专注于 “传统的发送描述符格式” 即可。你应该现在就去阅读这些章节，并要熟悉这些结构。
##### C 结构
你可以用 C `struct` 很方便地描述 E1000 的结构。正如你在 `struct Trapframe` 中所看到的结构那样，C `struct` 可以让你很方便地在内存中描述准确的数据布局。C 可以在字段中插入数据，但是 E1000 的结构就是这样布局的，这样就不会是个问题。如果你遇到字段对齐问题，进入 GCC 查看它的 “packed” 属性。
查看手册中表 3-8 所给出的一个传统的发送描述符，将它复制到这里作为一个示例：
```
63 48 47 40 39 32 31 24 23 16 15 0
+---------------------------------------------------------------+
| Buffer address |
+---------------|-------|-------|-------|-------|---------------+
| Special | CSS | Status| Cmd | CSO | Length |
+---------------|-------|-------|-------|-------|---------------+
```
从结构右上角第一个字节开始，我们将它转变成一个 C 结构，从上到下，从右到左读取。如果你从右往左看，你将看到所有的字段，都非常适合一个标准大小的类型：
```
struct tx_desc
{
uint64_t addr;
uint16_t length;
uint8_t cso;
uint8_t cmd;
uint8_t status;
uint8_t css;
uint16_t special;
};
```
你的驱动程序将为发送描述符数组去保留内存，并由发送描述符指向到包缓冲区。有几种方式可以做到，从动态分配页到在全局变量中简单地声明它们。无论你如何选择，记住，E1000 是直接访问物理内存的，意味着它能访问的任何缓存区在物理内存中必须是连续的。
处理包缓存也有几种方式。我们推荐从最简单的开始，那就是在驱动程序初始化期间，为每个描述符保留包缓存空间，并简单地将包数据复制进预留的缓冲区中或从其中复制出来。一个以太网包最大的尺寸是 1518 字节，这就限制了这些缓存区的大小。主流的成熟驱动程序都能够动态分配包缓存区（即：当网络使用率很低时，减少内存使用量），或甚至跳过缓存区，直接由用户空间提供（就是“零复制”技术），但我们还是从简单开始为好。
>
> **练习 5**、执行一个 14.5 节中的初始化步骤（它的子节除外）。对于寄存器的初始化过程使用 13 节作为参考，对发送描述符和发送描述符数组参考 3.3.3 节和 3.4 节。
>
>
> 要记住，在发送描述符数组中要求对齐，并且数组长度上有限制。因为 TDLEN 必须是 128 字节对齐的，而每个发送描述符是 16 字节，你的发送描述符数组必须是 8 个发送描述符的倍数。并且不能使用超过 64 个描述符，以及不能在我们的发送环形缓存测试中溢出。
>
>
> 对于 TCTL.COLD，你可以假设为全双工操作。对于 TIPG、IEEE 802.3 标准的 IPG（不要使用 14.5 节中表上的值），参考在 13.4.34 节中表 13-77 中描述的缺省值。
>
>
>
尝试运行 `make E1000_DEBUG=TXERR,TX qemu`。如果你使用的是打了 6.828 补丁的 QEMU，当你设置 TDT（发送描述符尾部）寄存器时你应该会看到一个 “e1000: tx disabled” 的信息，并且不会有更多 “e1000” 信息了。
现在，发送初始化已经完成，你可以写一些代码去发送一个数据包，并且通过一个系统调用使它可以访问用户空间。你可以将要发送的数据包添加到发送队列的尾部，也就是说复制数据包到下一个包缓冲区中，然后更新 TDT 寄存器去通知网卡在发送队列中有另外的数据包。（注意，TDT 是一个进入发送描述符数组的索引，不是一个字节偏移量；关于这一点文档中说明的不是很清楚。）
但是，发送队列只有这么大。如果网卡在发送数据包时卡住或发送队列填满时会发生什么状况？为了检测这种情况，你需要一些来自 E1000 的反馈。不幸的是，你不能只使用 TDH（发送描述符头）寄存器；文档上明确说明，从软件上读取这个寄存器是不可靠的。但是，如果你在发送描述符的命令字段中设置 RS 位，那么，当网卡去发送在那个描述符中的数据包时，网卡将设置描述符中状态字段的 DD 位，如果一个描述符中的 DD 位被设置，你就应该知道那个描述符可以安全地回收，并且可以用它去发送其它数据包。
如果用户调用你的发送系统调用，但是下一个描述符的 DD 位没有设置，表示那个发送队列已满，该怎么办？在这种情况下，你该去决定怎么办了。你可以简单地丢弃数据包。网络协议对这种情况的处理很灵活，但如果你丢弃大量的突发数据包，协议可能不会去重新获得它们。可能需要你替代网络协议告诉用户环境让它重传，就像你在 `sys_ipc_try_send` 中做的那样。在环境上回推产生的数据是有好处的。
>
> **练习 6**、写一个函数去发送一个数据包，它需要检查下一个描述符是否空闲、复制包数据到下一个描述符并更新 TDT。确保你处理的发送队列是满的。
>
>
>
现在，应该去测试你的包发送代码了。通过从内核中直接调用你的发送函数来尝试发送几个包。在测试时，你不需要去创建符合任何特定网络协议的数据包。运行 `make E1000_DEBUG=TXERR,TX qemu` 去测试你的代码。你应该看到类似下面的信息：
```
e1000: index 0: 0x271f00 : 9000002a 0
...
```
在你发送包时，每行都给出了在发送数组中的序号、那个发送的描述符的缓存地址、`cmd/CSO/length` 字段、以及 `special/CSS/status` 字段。如果 QEMU 没有从你的发送描述符中输出你预期的值，检查你的描述符中是否有合适的值和你配置的正确的 TDBAL 和 TDBAH。如果你收到的是 “e1000: TDH wraparound @0, TDT x, TDLEN y” 的信息，意味着 E1000 的发送队列持续不断地运行（如果 QEMU 不去检查它，它将是一个无限循环），这意味着你没有正确地维护 TDT。如果你收到了许多 “e1000: tx disabled” 的信息，那么意味着你没有正确设置发送控制寄存器。
一旦 QEMU 运行，你就可以运行 `tcpdump -XXnr qemu.pcap` 去查看你发送的包数据。如果从 QEMU 中看到预期的 “e1000: index” 信息，但你捕获的包是空的，再次检查你发送的描述符，是否填充了每个必需的字段和位。（E1000 或许已经遍历了你的发送描述符，但它认为不需要去发送）
>
> **练习 7**、添加一个系统调用，让你从用户空间中发送数据包。详细的接口由你来决定。但是不要忘了检查从用户空间传递给内核的所有指针。
>
>
>
#### 发送包：网络服务器
现在，你已经有一个系统调用接口可以发送包到你的设备驱动程序端了。输出辅助环境的目标是在一个循环中做下面的事情：从核心网络服务器中接收 `NSREQ_OUTPUT` IPC 消息，并使用你在上面增加的系统调用去发送伴随这些 IPC 消息的数据包。这个 `NSREQ_OUTPUT` IPC 是通过 `net/lwip/jos/jif/jif.c` 中的 `low_level_output` 函数来发送的。它集成 lwIP 栈到 JOS 的网络系统。每个 IPC 将包含一个页，这个页由一个 `union Nsipc` 和在 `struct jif_pkt pkt` 字段中的一个包组成（查看 `inc/ns.h`）。`struct jif_pkt` 看起来像下面这样：
```
struct jif_pkt {
int jp_len;
char jp_data[0];
};
```
`jp_len` 表示包的长度。在 IPC 页上的所有后续字节都是为了包内容。在结构的结尾处使用一个长度为 0 的数组来表示缓存没有一个预先确定的长度（像 `jp_data` 一样），这是一个常见的 C 技巧（也有人说这是一个令人讨厌的做法）。因为 C 并不做数组边界的检查，只要你确保结构后面有足够的未使用内存即可，你可以把 `jp_data` 作为一个任意大小的数组来使用。
当设备驱动程序的发送队列中没有足够的空间时，一定要注意在设备驱动程序、输出环境和核心网络服务器之间的交互。核心网络服务器使用 IPC 发送包到输出环境。如果输出环境在由于一个发送包的系统调用而挂起，导致驱动程序没有足够的缓存去容纳新数据包，这时核心网络服务器将阻塞以等待输出服务器去接收 IPC 调用。
>
> **练习 8**、实现 `net/output.c`。
>
>
>
你可以使用 `net/testoutput.c` 去测试你的输出代码而无需整个网络服务器参与。尝试运行 `make E1000_DEBUG=TXERR,TX run-net_testoutput`。你将看到如下的输出：
```
Transmitting packet 0
e1000: index 0: 0x271f00 : 9000009 0
Transmitting packet 1
e1000: index 1: 0x2724ee : 9000009 0
...
```
运行 `tcpdump -XXnr qemu.pcap` 将输出：
```
reading from file qemu.pcap, link-type EN10MB (Ethernet)
-5:00:00.600186 [|ether]
0x0000: 5061 636b 6574 2030 30 Packet.00
-5:00:00.610080 [|ether]
0x0000: 5061 636b 6574 2030 31 Packet.01
...
```
使用更多的数据包去测试，可以运行 `make E1000_DEBUG=TXERR,TX NET_CFLAGS=-DTESTOUTPUT_COUNT=100 run-net_testoutput`。如果它导致你的发送队列溢出，再次检查你的 DD 状态位是否正确，以及是否告诉硬件去设置 DD 状态位（使用 RS 命令位）。
你的代码应该会通过 `make grade` 的 `testoutput` 测试。
>
> **问题 1**、你是如何构造你的发送实现的？在实践中，如果发送缓存区满了，你该如何处理？
>
>
>
### Part B：接收包和 web 服务器
#### 接收包
就像你在发送包中做的那样，你将去配置 E1000 去接收数据包，并提供一个接收描述符队列和接收描述符。在 3.2 节中描述了接收包的操作，包括接收队列结构和接收描述符、以及在 14.4 节中描述的详细的初始化过程。
>
> **练习 9**、阅读 3.2 节。你可以忽略关于中断和 offload 校验和方面的内容（如果在后面你想去使用这些特性，可以再返回去阅读），你现在不需要去考虑阈值的细节和网卡内部缓存是如何工作的。
>
>
>
除了接收队列是由一系列的等待入站数据包去填充的空缓存包以外，接收队列的其它部分与发送队列非常相似。所以，当网络空闲时，发送队列是空的（因为所有的包已经被发送出去了），而接收队列是满的（全部都是空缓存包）。
当 E1000 接收一个包时，它首先与网卡的过滤器进行匹配检查（例如，去检查这个包的目标地址是否为这个 E1000 的 MAC 地址），如果这个包不匹配任何过滤器，它将忽略这个包。否则，E1000 尝试从接收队列头部去检索下一个接收描述符。如果头（RDH）追上了尾（RDT），那么说明接收队列已经没有空闲的描述符了，所以网卡将丢弃这个包。如果有空闲的接收描述符，它将复制这个包的数据到描述符指向的缓存中，设置这个描述符的 DD 和 EOP 状态位，并递增 RDH。
如果 E1000 在一个接收描述符中接收到了一个比包缓存还要大的数据包，它将按需从接收队列中检索尽可能多的描述符以保存数据包的全部内容。为表示发生了这种情况，它将在所有的这些描述符上设置 DD 状态位，但仅在这些描述符的最后一个上设置 EOP 状态位。在你的驱动程序上，你可以去处理这种情况，也可以简单地配置网卡拒绝接收这种”长包“（这种包也被称为”巨帧“），你要确保接收缓存有足够的空间尽可能地去存储最大的标准以太网数据包（1518 字节）。
>
> **练习 10**、设置接收队列并按 14.4 节中的流程去配置 E1000。你可以不用支持 ”长包“ 或多播。到目前为止，我们不用去配置网卡使用中断；如果你在后面决定去使用接收中断时可以再去改。另外，配置 E1000 去除以太网的 CRC 校验，因为我们的评级脚本要求必须去掉校验。
>
>
> 默认情况下，网卡将过滤掉所有的数据包。你必须使用网卡的 MAC 地址去配置接收地址寄存器（RAL 和 RAH）以接收发送到这个网卡的数据包。你可以简单地硬编码 QEMU 的默认 MAC 地址 52:54:00:12:34:56（我们已经在 lwIP 中硬编码了这个地址，因此这样做不会有问题）。使用字节顺序时要注意；MAC 地址是从低位字节到高位字节的方式来写的，因此 52:54:00:12 是 MAC 地址的低 32 位，而 34:56 是它的高 16 位。
>
>
> E1000 的接收缓存区大小仅支持几个指定的设置值（在 13.4.22 节中描述的 RCTL.BSIZE 值）。如果你的接收包缓存够大，并且拒绝长包，那你就不用担心跨越多个缓存区的包。另外，要记住的是，和发送一样，接收队列和包缓存必须是连接的物理内存。
>
>
> 你应该使用至少 128 个接收描述符。
>
>
>
现在，你可以做接收功能的基本测试了，甚至都无需写代码去接收包了。运行 `make E1000_DEBUG=TX,TXERR,RX,RXERR,RXFILTER run-net_testinput`。`testinput` 将发送一个 ARP（地址解析协议）通告包（使用你的包发送的系统调用），而 QEMU 将自动回复它，即便是你的驱动尚不能接收这个回复，你也应该会看到一个 “e1000: unicast match[0]: 52:54:00:12:34:56” 的消息，表示 E1000 接收到一个包，并且匹配了配置的接收过滤器。如果你看到的是一个 “e1000: unicast mismatch: 52:54:00:12:34:56” 消息，表示 E1000 过滤掉了这个包，意味着你的 RAL 和 RAH 的配置不正确。确保你按正确的顺序收到了字节，并不要忘记设置 RAH 中的 “Address Valid” 位。如果你没有收到任何 “e1000” 消息，或许是你没有正确地启用接收功能。
现在，你准备去实现接收数据包。为了接收数据包，你的驱动程序必须持续跟踪希望去保存下一下接收到的包的描述符（提示：按你的设计，这个功能或许已经在 E1000 中的一个寄存器来实现了）。与发送类似，官方文档上表示，RDH 寄存器状态并不能从软件中可靠地读取，因为确定一个包是否被发送到描述符的包缓存中，你需要去读取描述符中的 DD 状态位。如果 DD 位被设置，你就可以从那个描述符的缓存中复制出这个数据包，然后通过更新队列的尾索引 RDT 来告诉网卡那个描述符是空闲的。
如果 DD 位没有被设置，表明没有接收到包。这就与发送队列满的情况一样，这时你可以有几种做法。你可以简单地返回一个 ”重传“ 错误来要求对端重发一次。对于满的发送队列，由于那是个临时状况，这种做法还是很好的，但对于空的接收队列来说就不太合理了，因为接收队列可能会保持好长一段时间的空的状态。第二个方法是挂起调用环境，直到在接收队列中处理了这个包为止。这个策略非常类似于 `sys_ipc_recv`。就像在 IPC 的案例中，因为我们每个 CPU 仅有一个内核栈，一旦我们离开内核，栈上的状态就会被丢弃。我们需要设置一个标志去表示那个环境由于接收队列下溢被挂起并记录系统调用参数。这种方法的缺点是过于复杂：E1000 必须被指示去产生接收中断，并且驱动程序为了恢复被阻塞等待一个包的环境，必须处理这个中断。
>
> **练习 11**、写一个函数从 E1000 中接收一个包，然后通过一个系统调用将它发布到用户空间。确保你将接收队列处理成空的。
>
>
>
.
>
> 小挑战！如果发送队列是满的或接收队列是空的，环境和你的驱动程序可能会花费大量的 CPU 周期是轮询、等待一个描述符。一旦完成发送或接收描述符，E1000 能够产生一个中断，以避免轮询。修改你的驱动程序，处理发送和接收队列是以中断而不是轮询的方式进行。
>
>
> 注意，一旦确定为中断，它将一直处于中断状态，直到你的驱动程序明确处理完中断为止。在你的中断服务程序中，一旦处理完成要确保清除掉中断状态。如果你不那样做，从你的中断服务程序中返回后，CPU 将再次跳转到你的中断服务程序中。除了在 E1000 网卡上清除中断外，也需要使用 `lapic_eoi` 在 LAPIC 上清除中断。
>
>
>
#### 接收包：网络服务器
在网络服务器输入环境中，你需要去使用你的新的接收系统调用以接收数据包，并使用 `NSREQ_INPUT` IPC 消息将它传递到核心网络服务器环境。这些 IPC 输入消息应该会有一个页，这个页上绑定了一个 `union Nsipc`，它的 `struct jif_pkt pkt` 字段中有从网络上接收到的包。
>
> **练习 12**、实现 `net/input.c`。
>
>
>
使用 `make E1000_DEBUG=TX,TXERR,RX,RXERR,RXFILTER run-net_testinput` 再次运行 `testinput`，你应该会看到：
```
Sending ARP announcement...
Waiting for packets...
e1000: index 0: 0x26dea0 : 900002a 0
e1000: unicast match[0]: 52:54:00:12:34:56
input: 0000 5254 0012 3456 5255 0a00 0202 0806 0001
input: 0010 0800 0604 0002 5255 0a00 0202 0a00 0202
input: 0020 5254 0012 3456 0a00 020f 0000 0000 0000
input: 0030 0000 0000 0000 0000 0000 0000 0000 0000
```
“input:” 打头的行是一个 QEMU 的 ARP 回复的十六进制转储。
你的代码应该会通过 `make grade` 的 `testinput` 测试。注意，在没有发送至少一个包去通知 QEMU 中的 JOS 的 IP 地址上时，是没法去测试包接收的，因此在你的发送代码中的 bug 可能会导致测试失败。
为彻底地测试你的网络代码，我们提供了一个称为 `echosrv` 的守护程序，它在端口 7 上设置运行 `echo` 的服务器，它将回显通过 TCP 连接发送给它的任何内容。使用 `make E1000_DEBUG=TX,TXERR,RX,RXERR,RXFILTER run-echosrv` 在一个终端中启动 `echo` 服务器，然后在另一个终端中通过 `make nc-7` 去连接它。你输入的每一行都被这个服务器回显出来。每次在仿真的 E1000 上接收到一个包，QEMU 将在控制台上输出像下面这样的内容：
```
e1000: unicast match[0]: 52:54:00:12:34:56
e1000: index 2: 0x26ea7c : 9000036 0
e1000: index 3: 0x26f06a : 9000039 0
e1000: unicast match[0]: 52:54:00:12:34:56
```
做到这一点后，你应该也就能通过 `echosrv` 的测试了。
>
> **问题 2**、你如何构造你的接收实现？在实践中，如果接收队列是空的并且一个用户环境要求下一个入站包，你怎么办？
>
>
>
.
>
> 小挑战！在开发者手册中阅读关于 EEPROM 的内容，并写出从 EEPROM 中加载 E1000 的 MAC 地址的代码。目前，QEMU 的默认 MAC 地址是硬编码到你的接收初始化代码和 lwIP 中的。修复你的初始化代码，让它能够从 EEPROM 中读取 MAC 地址，和增加一个系统调用去传递 MAC 地址到 lwIP 中，并修改 lwIP 去从网卡上读取 MAC 地址。通过配置 QEMU 使用一个不同的 MAC 地址去测试你的变更。
>
>
>
.
>
> 小挑战！修改你的 E1000 驱动程序去使用 零复制 技术。目前，数据包是从用户空间缓存中复制到发送包缓存中，和从接收包缓存中复制回到用户空间缓存中。一个使用 ”零复制“ 技术的驱动程序可以通过直接让用户空间和 E1000 共享包缓存内存来实现。还有许多不同的方法去实现 ”零复制“，包括映射内容分配的结构到用户空间或直接传递用户提供的缓存到 E1000。不论你选择哪种方法，都要注意你如何利用缓存的问题，因为你不能在用户空间代码和 E1000 之间产生争用。
>
>
>
.
>
> 小挑战！把 “零复制” 的概念用到 lwIP 中。
>
>
> 一个典型的包是由许多头构成的。用户发送的数据被发送到 lwIP 中的一个缓存中。TCP 层要添加一个 TCP 包头，IP 层要添加一个 IP 包头，而 MAC 层有一个以太网头。甚至还有更多的部分增加到包上，这些部分要正确地连接到一起，以便于设备驱动程序能够发送最终的包。
>
>
> E1000 的发送描述符设计是非常适合收集分散在内存中的包片段的，像在 lwIP 中创建的包的帧。如果你排队多个发送描述符，但仅设置最后一个描述符的 EOP 命令位，那么 E1000 将在内部把这些描述符串成包缓存，并在它们标记完 EOP 后仅发送串起来的缓存。因此，独立的包片段不需要在内存中把它们连接到一起。
>
>
> 修改你的驱动程序，以使它能够发送由多个缓存且无需复制的片段组成的包，并且修改 lwIP 去避免它合并包片段，因为它现在能够正确处理了。
>
>
>
.
>
> 小挑战！增加你的系统调用接口，以便于它能够为多于一个的用户环境提供服务。如果有多个网络栈（和多个网络服务器）并且它们各自都有自己的 IP 地址运行在用户模式中，这将是非常有用的。接收系统调用将决定它需要哪个环境来转发每个入站的包。
>
>
> 注意，当前的接口并不知道两个包之间有何不同，并且如果多个环境去调用包接收的系统调用，各个环境将得到一个入站包的子集，而那个子集可能并不包含调用环境指定的那个包。
>
>
> 在 [这篇](http://pdos.csail.mit.edu/papers/exo:tocs.pdf) 外内核论文的 2.2 节和 3 节中对这个问题做了深度解释，并解释了在内核中（如 JOS）处理它的一个方法。用这个论文中的方法去解决这个问题，你不需要一个像论文中那么复杂的方案。
>
>
>
#### Web 服务器
一个最简单的 web 服务器类型是发送一个文件的内容到请求的客户端。我们在 `user/httpd.c` 中提供了一个非常简单的 web 服务器的框架代码。这个框架内码处理入站连接并解析请求头。
>
> **练习 13**、这个 web 服务器中缺失了发送一个文件的内容到客户端的处理代码。通过实现 `send_file` 和 `send_data` 完成这个 web 服务器。
>
>
>
在你完成了这个 web 服务器后，启动这个 web 服务器（`make run-httpd-nox`），使用你喜欢的浏览器去浏览 `http://host:port/index.html` 地址。其中 host 是运行 QEMU 的计算机的名字（如果你在 athena 上运行 QEMU，使用 `hostname.mit.edu`（其中 hostname 是在 athena 上运行 `hostname` 命令的输出，或者如果你在运行 QEMU 的机器上运行 web 浏览器的话，直接使用 `localhost`），而 port 是 web 服务器运行 `make which-ports` 命令报告的端口号。你应该会看到一个由运行在 JOS 中的 HTTP 服务器提供的一个 web 页面。
到目前为止，你的评级测试得分应该是 105 分（满分为 105）。
>
> 小挑战！在 JOS 中添加一个简单的聊天服务器，多个人可以连接到这个服务器上，并且任何用户输入的内容都被发送到其它用户。为实现它，你需要找到一个一次与多个套接字通讯的方法，并且在同一时间能够在同一个套接字上同时实现发送和接收。有多个方法可以达到这个目的。lwIP 为 `recv`（查看 `net/lwip/api/sockets.c` 中的 `lwip_recvfrom`）提供了一个 MSG\_DONTWAIT 标志，以便于你不断地轮询所有打开的套接字。注意，虽然网络服务器的 IPC 支持 `recv` 标志，但是通过普通的 `read` 函数并不能访问它们，因此你需要一个方法来传递这个标志。一个更高效的方法是为每个连接去启动一个或多个环境，并且使用 IPC 去协调它们。而且碰巧的是，对于一个套接字，在结构 Fd 中找到的 lwIP 套接字 ID 是全局的（不是每个环境私有的），因此，比如一个 `fork` 的子环境继承了它的父环境的套接字。或者，一个环境通过构建一个包含了正确套接字 ID 的 Fd 就能够发送到另一个环境的套接字上。
>
>
> **问题 3**、由 JOS 的 web 服务器提供的 web 页面显示了什么？
>
>
>
.
>
> **问题 4**、你做这个实验大约花了多长的时间？
>
>
>
**本实验到此结束了。**一如既往，不要忘了运行 `make grade` 并去写下你的答案和挑战问题的解决方案的描述。在你动手之前，使用 `git status` 和 `git diff` 去检查你的变更，并不要忘了去 `git add answers-lab6.txt`。当你完成之后，使用 `git commit -am 'my solutions to lab 6’` 去提交你的变更，然后 `make handin` 并关注它的动向。
---
via: <https://pdos.csail.mit.edu/6.828/2018/labs/lab6/>
作者：[csail.mit](https://pdos.csail.mit.edu) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Linux 中安装微软的 .NET Core SDK
|
Sk
|
https://www.ostechnix.com/how-to-install-microsoft-net-core-sdk-on-linux/
|
本分步操作指南文章解释了如何在 Linux 中安装 .NET Core SDK 以及如何使用 .NET 开发出第一个应用程序。
|
/data/attachment/album/201901/17/215837aa9devtxvnqq7nb0.png.thumb.jpg
|
/data/attachment/album/201901/17/215837aa9devtxvnqq7nb0.png
| true | false | true |
lujun9972
|
runningwater
|
wxy
| false |
[
".NET"
] |
技术
|
{
"viewnum": 11218,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
本分步操作指南文章解释了如何在 Linux 中安装 .NET Core SDK 以及如何使用 .NET 开发出第一个应用程序。
| 2019-01-17T21:58:00 | 2019-01-17T21:58:00 | 10,453 |
/article-10453-1.html
|
**.NET Core** 是微软提供的免费、跨平台和开源的开发框架，可以构建桌面应用程序、移动端应用程序、网络应用程序、物联网应用程序和游戏应用程序等。如果你是 Windows 平台下的 dotnet 开发人员的话，使用 .NET core 可以很轻松就设置好任何 Linux 和类 Unix 操作系统下的开发环境。本分步操作指南文章解释了如何在 Linux 中安装 .NET Core SDK 以及如何使用 .NET 开发出第一个应用程序。
### Linux 中安装 .NET Core SDK
.NET Core 支持 GNU/Linux、Mac OS 和 Windows 系统，可以在主流的 GNU/Linux 操作系统上安装运行，包括 Debian、Fedora、CentOS、Oracle Linux、RHEL、SUSE/openSUSE 和 Ubuntu 。在撰写这篇教程时，其最新版本为 **2.2**。
**Debian 9** 系统上安装 .NET Core SDK，请按如下步骤进行。
首先，需要注册微软的密钥，接着把 .NET 源仓库地址添加进来，运行的命令如下：
```
$ wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.asc.gpg
$ sudo mv microsoft.asc.gpg /etc/apt/trusted.gpg.d/
$ wget -q https://packages.microsoft.com/config/debian/9/prod.list
$ sudo mv prod.list /etc/apt/sources.list.d/microsoft-prod.list
$ sudo chown root:root /etc/apt/trusted.gpg.d/microsoft.asc.gpg
$ sudo chown root:root /etc/apt/sources.list.d/microsoft-prod.list
```
注册好密钥及添加完仓库源后，就可以安装 .NET SDK 了，命令如下：
```
$ sudo apt-get update
$ sudo apt-get install dotnet-sdk-2.2
```
**Debian 8 系统上安装：**
增加微软密钥，添加 .NET 仓库源：
```
$ wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.asc.gpg
$ sudo mv microsoft.asc.gpg /etc/apt/trusted.gpg.d/
$ wget -q https://packages.microsoft.com/config/debian/8/prod.list
$ sudo mv prod.list /etc/apt/sources.list.d/microsoft-prod.list
$ sudo chown root:root /etc/apt/trusted.gpg.d/microsoft.asc.gpg
$ sudo chown root:root /etc/apt/sources.list.d/microsoft-prod.list
```
安装 .NET SDK：
```
$ sudo apt-get update
$ sudo apt-get install dotnet-sdk-2.2
```
**Fedora 28 系统上安装：**
增加微软密钥，添加 .NET 仓库源：
```
$ sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc
$ wget -q https://packages.microsoft.com/config/fedora/27/prod.repo
$ sudo mv prod.repo /etc/yum.repos.d/microsoft-prod.repo
$ sudo chown root:root /etc/yum.repos.d/microsoft-prod.repo
```
现在, 可以安装 .NET SDK 了：
```
$ sudo dnf update
$ sudo dnf install dotnet-sdk-2.2
```
**Fedora 27 系统下：**
增加微软密钥，添加 .NET 仓库源，命令如下：
```
$ sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc
$ wget -q https://packages.microsoft.com/config/fedora/27/prod.repo
$ sudo mv prod.repo /etc/yum.repos.d/microsoft-prod.repo
$ sudo chown root:root /etc/yum.repos.d/microsoft-prod.repo
```
接着安装 .NET SDK ，命令如下：
```
$ sudo dnf update
$ sudo dnf install dotnet-sdk-2.2
```
**CentOS/Oracle 版本的 Linux 系统上：**
增加微软密钥，添加 .NET 仓库源，使其可用：
```
$ sudo rpm -Uvh https://packages.microsoft.com/config/rhel/7/packages-microsoft-prod.rpm
```
更新源仓库，安装 .NET SDK：
```
$ sudo yum update
$ sudo yum install dotnet-sdk-2.2
```
**openSUSE Leap 版本的系统上：**
添加密钥，使仓库源可用，安装必需的依赖包，其命令如下：
```
$ sudo zypper install libicu
$ sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc
$ wget -q https://packages.microsoft.com/config/opensuse/42.2/prod.repo
$ sudo mv prod.repo /etc/zypp/repos.d/microsoft-prod.repo
$ sudo chown root:root /etc/zypp/repos.d/microsoft-prod.repo
```
更新源仓库，安装 .NET SDK，命令如下：
```
$ sudo zypper update
$ sudo zypper install dotnet-sdk-2.2
```
**Ubuntu 18.04 LTS 版本的系统上：**
注册微软的密钥和 .NET Core 仓库源，命令如下：
```
$ wget -q https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb
$ sudo dpkg -i packages-microsoft-prod.deb
```
使 Universe 仓库可用：
```
$ sudo add-apt-repository universe
```
然后，安装 .NET Core SDK ，命令如下：
```
$ sudo apt-get install apt-transport-https
$sudo apt-get update
$ sudo apt-get install dotnet-sdk-2.2
```
**Ubuntu 16.04 LTS 版本的系统上：**
注册微软的密钥和 .NET Core 仓库源，命令如下：
```
$ wget -q https://packages.microsoft.com/config/ubuntu/16.04/packages-microsoft-prod.deb
$ sudo dpkg -i packages-microsoft-prod.deb
```
然后安装 .NET core SDK：
```
$ sudo apt-get install apt-transport-https
$ sudo apt-get update
$ sudo apt-get install dotnet-sdk-2.2
```
### 创建你的第一个应用程序
我们已经成功的在 Linux 机器中安装了 .NET Core SDK。是时候使用 dotnet 创建第一个应用程序了。
接下来的目的，我们会创建一个名为 ostechnixApp 的应用程序。为此，可以简单的运行如下命令：
```
$ dotnet new console -o ostechnixApp
```
**示例输出：**
```
Welcome to .NET Core!
---------------------
Learn more about .NET Core: https://aka.ms/dotnet-docs
Use 'dotnet --help' to see available commands or visit: https://aka.ms/dotnet-cli-docs
Telemetry
---------
The .NET Core tools collect usage data in order to help us improve your experience. The data is anonymous and doesn't include command-line arguments. The data is collected by Microsoft and shared with the community. You can opt-out of telemetry by setting the DOTNET_CLI_TELEMETRY_OPTOUT environment variable to '1' or 'true' using your favorite shell.
Read more about .NET Core CLI Tools telemetry: https://aka.ms/dotnet-cli-telemetry
ASP.NET Core
------------
Successfully installed the ASP.NET Core HTTPS Development Certificate.
To trust the certificate run 'dotnet dev-certs https --trust' (Windows and macOS only). For establishing trust on other platforms refer to the platform specific documentation.
For more information on configuring HTTPS see https://go.microsoft.com/fwlink/?linkid=848054.
Getting ready...
The template "Console Application" was created successfully.
Processing post-creation actions...
Running 'dotnet restore' on ostechnixApp/ostechnixApp.csproj...
Restoring packages for /home/sk/ostechnixApp/ostechnixApp.csproj...
Generating MSBuild file /home/sk/ostechnixApp/obj/ostechnixApp.csproj.nuget.g.props.
Generating MSBuild file /home/sk/ostechnixApp/obj/ostechnixApp.csproj.nuget.g.targets.
Restore completed in 894.27 ms for /home/sk/ostechnixApp/ostechnixApp.csproj.
Restore succeeded.
```
正如上面的输出所示的，.NET 已经为我们创建一个控制台类型的应用程序。`-o` 参数创建了一个名为 “ostechnixApp” 的目录，其包含有存储此应用程序数据所必需的文件。
让我们切换到 ostechnixApp 目录，看看里面有些什么。
```
$ cd ostechnixApp/
$ ls
obj ostechnixApp.csproj Program.cs
```
可以看到有两个名为 `ostechnixApp.csproj` 和 `Program.cs` 的文件，以及一个名为 `obj` 的目录。默认情况下, `Program.cs` 文件包含有可以在控制台中运行的 “Hello World” 程序代码。可以看看此代码：
```
$ cat Program.cs
using System;
namespace ostechnixApp
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
}
```
要运行此应用程序，可以简单的使用如下命令：
```
$ dotnet run
Hello World!
```
很简单，对吧？是的，就是如此简单。现在你可以在 `Program.cs` 这文件中写上自己的代码，然后像上面所示的执行。
或者，你可以创建一个新的目录，如例子所示的 `mycode` 目录，命令如下：
```
$ mkdir ~/.mycode
$ cd mycode/
```
然后运行如下命令，使其成为你的新开发环境目录：
```
$ dotnet new console
```
示例输出：
```
The template "Console Application" was created successfully.
Processing post-creation actions...
Running 'dotnet restore' on /home/sk/mycode/mycode.csproj...
Restoring packages for /home/sk/mycode/mycode.csproj...
Generating MSBuild file /home/sk/mycode/obj/mycode.csproj.nuget.g.props.
Generating MSBuild file /home/sk/mycode/obj/mycode.csproj.nuget.g.targets.
Restore completed in 331.87 ms for /home/sk/mycode/mycode.csproj.
Restore succeeded.
```
上的命令会创建两个名叫 `mycode.csproj` 和 `Program.cs` 的文件及一个名为 `obj` 的目录。用你喜欢的编辑器打开 `Program.cs` 文件, 删除或修改原来的 “hello world” 代码段，然后编写自己的代码。
写完代码，保存，关闭 `Program.cs` 文件，然后运行此应用程序，命令如下：
```
$ dotnet run
```
想要查看安装的 .NET core SDK 的版本的话，可以简单的运行：
```
$ dotnet --version
2.2.101
```
要获得帮助，请运行：
```
$ dotnet --help
```
### 使用微软的 Visual Studio Code 编辑器
要编写代码，你可以任选自己喜欢的编辑器。同时微软自己也有一款支持 .NET 的编辑器，其名为 “Microsoft Visual Studio Code”。它是一款开源、轻量级、功能强大的源代码编辑器。其内置了对 JavaScript、TypeScript 和 Node.js 的支持，并为其它语言（如 C++、C#、Python、PHP、Go）和运行时态（如 .NET 和 Unity）提供了丰富的扩展，已经形成一个完整的生态系统。它是一款跨平台的代码编辑器，所以在微软的 Windows 系统、GNU/Linux 系统和 Mac OS X 系统都可以使用。如果对其感兴趣，就可以使用。
想了解如何在 Linux 上安装和使用，请参阅以下指南。
[Linux 中安装 Microsoft Visual Studio Code](https://www.ostechnix.com/install-microsoft-visual-studio-code-linux/)
关于 Visual Studio Code editor 中 .NET Core 和 .NET Core SDK 工具的使用，[此网页](https://docs.microsoft.com/en-us/dotnet/core/tutorials/index)有一些基础的教程。想了解更多就去看看吧。
### Telemetry
默认情况下，.NET core SDK 会采集用户使用情况数据，此功能被称为 Telemetry。采集数据是匿名的，并根据[知识共享署名许可](https://creativecommons.org/licenses/by/4.0/)分享给其开发团队和社区。因此 .NET 团队会知道这些工具的使用状况，然后根据统计做出决策，改进产品。如果你不想分享自己的使用信息的话，可以使用顺手的 shell 工具把名为 `DOTNET_CLI_TELEMETRY_OPTOUT` 的环境变量参数设置为 `1` 或 `true`，这样就简单的关闭此功能了。
就这样。你已经知道如何在各 Linux 平台上安装 .NET Core SDK 以及知道如何创建基本的应用程序了。想了解更多 .NET 使用知识的话，请参阅此文章末尾给出的链接。
会爆出更多干货的。敬请关注！
祝贺下!
### 资源
* [.NET Core](https://dotnet.microsoft.com/)
---
via: <https://www.ostechnix.com/how-to-install-microsoft-net-core-sdk-on-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[runningwater](https://github.com/runningwater) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
开始使用 Wekan 吧，一款开源看板软件
|
Kevin Sonney
|
https://opensource.com/article/19/1/productivity-tool-wekan
|
这是开源工具类软件推荐的第二期，本文将让你在 2019 年更具生产力。来，让我们一起看看 Wekan 吧。
|
/data/attachment/album/201901/18/104136gsdtspyese2z2ktd.png.thumb.jpg
|
/data/attachment/album/201901/18/104136gsdtspyese2z2ktd.png
| true | false | true |
lujun9972
|
wwhio
|
wxy
| false |
[
"看板"
] |
分享
|
{
"viewnum": 12292,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这是开源工具类软件推荐的第二期，本文将让你在 2019 年更具生产力。来，让我们一起看看 Wekan 吧。
| 2019-01-18T10:41:31 | 2019-01-18T10:41:31 | 10,454 |
/article-10454-1.html
|
>
> 这是开源工具类软件推荐的第二期，本文将让你在 2019 年更具生产力。来，让我们一起看看 Wekan 吧。
>
>
>
每年年初，人们似乎都在想方设法地让自己更具生产力。对新年目标、期待，当然还有“新年新气象”这样的口号等等都促人上进。可大部分生产力软件的推荐都严重偏向闭源的专有软件，但事实上并不用这样。
这是我挑选的 19 款帮助你在 2019 年提升生产力的开源工具中的第 2 个。
### Wekan
[看板](https://en.wikipedia.org/wiki/Kanban)是当今敏捷开发流程中的重要组成部分。我们中的很多人使用它同时管理自己的工作和生活。有些人在用 [Trello](https://www.trello.com) 这样的 APP 来跟踪他们的项目，例如哪些事务正在处理，哪些事务已经完成。
但这些 APP 通常需要连接到一个工作账户或者商业服务中。而 [Wekan](https://wekan.github.io/) 作为一款开源看板工具，你可以让它完全在本地运行，或者使用你自己选择的服务运行它。其他的看板 APP 提供的功能在 Wekan 里几乎都有，例如创建看板、列表、泳道、卡片，在列表间拖放，给指定的用户安排任务，给卡片添加标签等等，基本上你对一款现代看板软件的功能需求它都能提供。
Wekan 的独到之处在于它的内置规则。虽然其他的看板软件支持<ruby> 邮件更新 <rt> emailing updates </rt></ruby>，但 Wekan 允许用户自行设定触发器，其触发条件可以是卡片变动、清单变动或标签变动等等。
当触发条件满足时， Wekan 可以自动执行如移动卡片、更新标签、添加清单或者发送邮件等操作。
Wekan 的本地搭建可以直接使用 snap 。如果你的桌面环境支持 [Snapcraft](https://snapcraft.io/) 构建的应用，那么只需要一条命令就能安装 Wekan ：
```
sudo snap install wekan
```
此外 Wekan 还支持 Docker 安装，这使它在大部分服务器环境和桌面环境下的搭建变得相当容易。
最后，如果你想寻找一款能自建又好用的看板软件，你已经遇上了 Wekan 。
---
via: <https://opensource.com/article/19/1/productivity-tool-wekan>
作者：[Kevin Sonney](https://opensource.com/users/ksonney "Kevin Sonney") 选题：[lujun9972](https://github.com/lujun9972) 译者：[wwhio](https://github.com/wwhio) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
设计微服务架构前应该了解的 5 项指导原则
|
Jake Lumetta
|
https://opensource.com/article/18/4/guide-design-microservices
|
顶级 CTO 基于五个简单的原则为精心设计的微服务提供建议。
|
/data/attachment/album/201901/19/002658s8xpfp7qzk1j3jwc.jpg.thumb.jpg
|
/data/attachment/album/201901/19/002658s8xpfp7qzk1j3jwc.jpg
| true | false | true |
lujun9972
|
lixinyuxx
|
wxy
| false |
[
"微服务"
] |
观点
|
{
"viewnum": 5527,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
顶级 CTO 基于五个简单的原则为精心设计的微服务提供建议。
| 2019-01-19T00:27:05 | 2019-01-19T00:27:05 | 10,455 |
/article-10455-1.html
|
>
> 顶级 CTO 基于五个简单的原则为精心设计的微服务提供建议。
>
>
>
对于从微服务开始的团队来说，最大的挑战之一就是坚持<ruby> 金发女孩原则 <rt> The Goldilocks principle </rt></ruby>（该典故来自于童话《金发姑娘和三只熊》）：不要太大，不要太小，不能太紧密耦合。之所以是挑战的部分原因是会对究竟什么是设计良好的微服务感到疑惑。
数十位 CTO 通过采访分享了他们的经验，这些对话说明了设计良好的微服务的五个特点。本文将帮助指导团队设计微服务。（有关详细信息，请查看即将出版的书籍 [Microservices for Startups](https://buttercms.com/books/microservices-for-startups/)，LCTT 译注：已可免费下载完整的电子版）。本文将简要介绍微服务的边界和主观的 “规则”，以避免在深入了解五个特征之前就开始指导您的微服务设计。
### 微服务边界
[使用微服务开发新系统的核心优势](https://buttercms.com/books/microservices-for-startups/should-you-always-start-with-a-monolith)之一是该体系结构允许开发人员独立构建和修改各个组件，但在最大限度地减少每个 API 之间的回调数量方面可能会出现问题。根据 [SparkPost](https://www.sparkpost.com/) 工程副总裁 Chris McFadden 所说，解决方案是应用适当的服务边界。
关于边界，与有时难以理解和抽象的领域驱动设计（DDD，一种微服务框架）形成鲜明对比，本文重点介绍了和我们行业的一些顶级 CTO 一同建立的明确定义的微服务边界的实用原则。
### 避免主观的 “规则”
如果您阅读了足够多的关于设计和创建微服务的建议，您一定会遇到下面的一些 “规则”。 尽管将它们用作创建微服务的指南很有吸引力，但加入这些主观规则并不是思考确定微服务的边界的原则性方式。
#### “微服务应该有 X 行代码”
让我们直说：微服务中有多少行代码没有限制。微服务不会因为您写了几行额外的代码而突然变成一个独石应用。关键是要确保服务中的代码具有很高的内聚性（稍后将对此进行更多介绍）。
#### “将每个功能转换为微服务”
如果函数基于三个输入值计算某些内容并返回结果，它是否是微服务的理想候选项？它是否应该是单独可部署应用程序？这确实取决于该函数是什么以及它是如何服务于整个系统。将每个函数转换为微服务在您的情景中可能根本没有意义。
其他主观规则包括不考虑整个情景的规则，例如团队的经验、DevOps 能力、服务正在执行的操作以及数据的可用性需求。
### 精心设计的服务的 5 个特点
如果您读过关于微服务的文章，您无疑会遇到有关设计良好的服务的建议。简单地说，高内聚和低耦合。如果您不熟悉这些概念，有[许多](https://thebojan.ninja/2015/04/08/high-cohesion-loose-coupling/)[文章](https://thebojan.ninja/2015/04/08/high-cohesion-loose-coupling/)关于这些概念的文章。虽然它们提供了合理的建议，但这些概念是相当抽象的。基于与经验丰富的 CTO 们的对话，下面是在创建设计良好的微服务时需要牢记的关键特征。
#### #1：不与其他服务共享数据库表
在 SparkPost 的早期，Chris McFadden 和他的团队必须解决每个 SaaS 业务需要面对的问题：它们需要提供基本服务，如身份验证、帐户管理和计费。
为了解决这个问题，他们创建了两个微服务：用户 API 和帐户 API。用户 API 将处理用户帐户、API 密钥和身份验证，而帐户 API 将处理所有与计费相关的逻辑。这是一个非常合乎逻辑的分离 —— 但没过多久，他们发现了一个问题。
McFadden 解释说，“我们有一个名为‘用户 API’的服务，还有一个名为‘帐户 API’的服务。问题是，他们之间实际上有几个来回的调用。因此，您会在帐户服务中执行一些操作，然后调用并终止于用户服务，反之亦然”
这两个服务的耦合太紧密了。
在设计微服务时，如果您有多个服务引用同一个表，则它是一个危险的信号，因为这可能意味着您的数据库是耦合的源头。
这确实是关于服务与数据的关系，这正是 [Swiftype SRE，Elastic](https://www.elastic.co/solutions/site-search) 的负责人 Oleksiy Kovrin 告诉我。他说，“我们在开发新服务时使用的主要基本原则之一是，它们不应跨越数据库边界。每个服务都应依赖于自己的一组底层数据存储。这使我们能够集中访问控制、审计日志记录、缓存逻辑等。”
Kovrin 接着解释说，如果数据库表的某个子集“与数据集的其余部分没有或很少连接，则这是一个强烈的信号，表明该组件可以被隔离到单独的 API 或单独的服务中”。
[Lead Honestly](https://leadhonestly.com/) 的联合创始人 Darby Frey 与此的观点相呼应：“每个服务都应该有自己的表并且永远不应该共享数据库表。”
#### #2：数据库表数量最小化
微服务的理想尺寸应该足够小，但不能太小。每个服务的数据库表的数量也是如此。
[Scaylr](https://www.scalyr.com/) 的工程主管 Steven Czerwinski 在接受采访时解释说 Scaylr 的最佳选择是“一个或两个服务的数据库表。”
SparkPost 的 Chris McFadden 表示同意：“我们有一个 suppression 微服务，它处理、跟踪数以百万计和数十亿围绕 suppression 的条目，但它们都非常专注于围绕 suppression，所以实际上只有一个或两个表。其他服务也是如此，比如 webhooks。
#### #3：考虑有状态和无状态
在设计微服务时，您需要问问自己它是否需要访问数据库，或者它是否是处理 TB 级数据 (如电子邮件或日志) 的无状态服务。
[Algolia](https://www.algolia.com/) 的 CTO Julien Lemoine 解释说：“我们通过定义服务的输入和输出来定义服务的边界。有时服务是网络 API，但它也可能是使用文件并在数据库中生成记录的进程 (这就是我们的日志处理服务)。”
事先要明确是否有状态，这将引导一个更好的服务设计。
#### #4：考虑数据可用性需求
在设计微服务时，请记住哪些服务将依赖于此新服务，以及在该数据不可用时的整个系统的影响。考虑到这一点，您可以正确地设计此服务的数据备份和恢复系统。
Steven Czerwinski 提到，在 Scaylr 由于关键客户行空间映射数据的重要性，它将以不同的方式复制和分离。
相比之下，他补充说，“每个分片信息，都在自己的小分区里。如果部分客户群体因为没有可用日志而停止服务那很糟糕，但它只影响 5% 的客户，而不是100% 的客户。”
#### #5：单一的真实来源
设计服务，使其成为系统中某些内容的唯一真实来源。
例如，当您从电子商务网站订购内容时，则会生成订单 ID，其他服务可以使用此订单 ID 来查询订单服务，以获取有关订单的完整信息。使用 [发布/订阅模式](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern)，在服务之间传递的数据应该是订单 ID ，而不是订单本身的属性信息。只有订单服务具有订单的完整信息，并且是给定订单信息的唯一真实来源。
### 大型团队的注意事项
考虑到上面列出的五个注意事项，较大的团队应了解其组织结构对微服务边界的影响。
对于较大的组织，整个团队可以专门拥有服务，在确定服务边界时，组织性就会发挥作用。还有两个需要考虑的因素：**独立的发布计划**和**不同的正常运行时间**的重要性。
[Cloud66.](https://www.cloud66.com/) 的 CEO Khash Sajadi 说：“我们所看到的微服务最成功的实现要么基于类似领域驱动设计这样的软件设计原则 (如面向服务的体系结构)，要么基于反映组织方法的设计原则。”
“所以 (对于) 支付团队” Sajadi 说，“他们有支付服务或信用卡验证服务，这就是他们向外界提供的服务。所以这不一定是关于软件的。这主要是关于为外界提供更多服务的业务单位。”
### 双披萨原理
Amazon 是一个拥有多个团队的大型组织的完美示例。正如在一篇发表于 [API Evangelist](https://apievangelist.com/2012/01/12/the-secret-to-amazons-success-internal-apis/) 的文章中所提到的，Jeff Bezos 向所有员工发布一项要求，告知他们公司内的每个团队都必须通过 API 进行沟通。任何不这样做的人都会被解雇。
这样，所有数据和功能都通过该接口公开。Bezos 还设法让每个团队解耦，定义他们的资源，并通过 API 提供。Amazon 正在从头建立一个系统。这使得公司内的每一支团队都能成为彼此的合作伙伴。
我与 [Iron.io](https://www.iron.io/) 的 CTO Travis Reeder 谈到了 Bezos 的内部倡议。
“Jeff Bezos 规定所有团队都必须构建 API 才能与其他团队进行沟通，” Reeder 说。“他也是提出‘双披萨’规则的人：一支团队不应该比两个比萨饼能养活的大。”
“我认为这里也可以适用同样的方法：无论一个小型团队是否能够开发、管理和富有成效。如果它开始变得笨重或开始变慢，它可能变得太大了。” Reeder 告诉我。
### 最后注意事项: 您的服务是否具有合适的大小和正确的定义？
在微服务系统的测试和实施阶段，有一些指标需要记住。
#### 指标 #1: 服务之间是否存在过度依赖？
如果两个服务不断地相互回调，那么这就是强烈的耦合信号，也是它们可能更好地合并为一个服务的信号。
回到 Chris McFadden 的例子， 他有两个 API 服务，帐户服务和用户服务不断地相互通信， McFadden 提出了一个合并服务的想法，并决定将其称为 “账户用户 API”。事实证明，这是一项富有成效的战略。
“我们开始做的是消除这些内部 API 之间调用的链接，” McFadden 告诉我。“这有助于简化代码。”
#### 指标 #2: 设置服务的开销是否超过了服务独立的好处？
Darby Frey 解释说，“每个应用都需要将其日志聚合到某个位置，并需要进行监视。你需要设置它的警报。你需要有标准的操作程序，和在出现问题时的操作手册。您必须管理 SSH 对它的访问。只是为了让一个应用运行起来，就有大量的基础性工作必须存在。”
### 关键要点
设计微服务往往会让人感觉更像是一门艺术，而不是一门科学。对工程师来说，这可能并不顺利。有很多一般性的建议，但有时可能有点太抽象了。让我们回顾一下在设计下一组微服务时要注意的五个具体特征：
1. 不与其他服务共享数据库表
2. 数据库表数量最小化
3. 考虑有状态和无状态
4. 考虑数据可用性需求
5. 单一的真实来源
下次设计一组微服务并确定服务边界时，回顾这些原则应该会使任务变得更容易。
---
via: <https://opensource.com/article/18/4/guide-design-microservices>
作者：[Jake Lumetta](https://opensource.com/users/jakelumetta) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lixinyuxx](https://github.com/lixinyuxx) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Ubuntu PPA 使用指南
|
Abhishek Prakash
|
https://itsfoss.com/ppa-guide/
|
一篇涵盖了在 Ubuntu 和其他 Linux 发行版中使用 PPA 的几乎所有问题的深入的文章。
|
/data/attachment/album/201901/19/110250dii8pypjzqyhz3j3.png.thumb.jpg
|
/data/attachment/album/201901/19/110250dii8pypjzqyhz3j3.png
| true | false | true |
lujun9972
|
jlztan
|
wxy
| false |
[
"PPA",
"Ubuntu"
] |
技术
|
{
"viewnum": 19163,
"commentnum": 9,
"favtimes": 2,
"sharetimes": 2,
"likes": 0
}
|
[
{
"postip": "117.89.132.164",
"message": "写的非常好，赞一个。",
"username": "来自江苏南京的 Chrome 71.0|GNU/Linux 用户",
"date": "2019-01-21T09:31:47"
},
{
"postip": "61.141.249.39",
"message": "内容全面",
"username": "来自广东深圳的 Chrome 74.0|Mac 10.13 用户",
"date": "2019-06-22T12:51:17"
},
{
"postip": "36.63.37.136",
"message": "is nice",
"username": "来自安徽合肥的 Firefox 72.0|Ubuntu 用户",
"date": "2020-03-16T19:53:40"
},
{
"postip": "116.247.114.102",
"message": "very good",
"username": "来自上海的 Firefox 75.0|Ubuntu 用户",
"date": "2020-04-23T12:15:16"
},
{
"postip": "183.11.39.172",
"message": "非常不错~！！！",
"username": "来自广东深圳的 Chrome 87.0|Windows 10 用户",
"date": "2020-12-27T14:44:22"
},
{
"postip": "183.236.19.167",
"message": "很赞的文章，爱了爱了，原来学习Linux这个网站比CSDN好用啊",
"username": "来自广东东莞的 Chrome 90.0|Windows 10 用户",
"date": "2021-05-19T17:24:52"
},
{
"postip": "112.91.68.31",
"message": "写得非常好",
"username": "来自广东惠州的 Chrome 96.0|GNU/Linux 用户",
"date": "2021-11-17T19:55:58"
},
{
"postip": "221.4.34.106",
"message": "太感谢您的讲解了",
"username": "来自广东广州的 Firefox 90.0|Android 11 用户",
"date": "2022-07-30T01:54:55"
},
{
"postip": "183.210.84.92",
"message": "如果说这篇文章翻译腔能再小一点儿，那就完美了",
"username": "来自江苏扬州的 Chrome 104.0|Windows 10 用户",
"date": "2022-08-09T13:11:39"
}
] |
[] |
一篇涵盖了在 Ubuntu 和其他 Linux 发行版中使用 PPA 的几乎所有问题的深入的文章。
| 2019-01-19T11:02:47 | 2019-01-19T11:02:47 | 10,456 |
/article-10456-1.html
|
>
> 一篇涵盖了在 Ubuntu 和其他 Linux 发行版中使用 PPA 的几乎所有问题的深入的文章。
>
>
>
如果你一直在使用 Ubuntu 或基于 Ubuntu 的其他 Linux 发行版，例如 Linux Mint、Linux Lite、Zorin OS 等，你可能会遇到以下三种神奇的命令：
```
sudo add-apt-repository ppa:dr-akulavich/lighttable
sudo apt-get update
sudo apt-get install lighttable-installer
```
许多网站推荐使用类似于以上几行的形式 [在 Ubuntu 中安装应用程序](https://itsfoss.com/remove-install-software-ubuntu/)。这就是所谓的使用 PPA 安装应用程序。
但什么是 PPA？为什么要用它？使用 PPA 安全吗？如何正确使用 PPA？如何删除 PPA？
我将在这个详细的指南中回答上述所有问题。即使你已经了解了一些关于 PPA 的事情，我相信这篇文章仍然会让你了解这方面的更多知识。
请注意我正在使用 Ubuntu 撰写本文。因此，我几乎在各个地方都使用了 Ubuntu 这个术语，但文中的说明和步骤也适用于其他基于 Debian/Ubuntu 的发行版。
### 什么是 PPA？为什么要使用 PPA？
PPA 表示<ruby> 个人软件包存档 <rt> Personal Package Archive </rt></ruby>。
这样说容易理解吗？可能不是很容易。
在了解 PPA 之前，你应该了解 Linux 中软件仓库的概念。关于软件仓库，在这里我不会详述。
#### 软件仓库和包管理的概念
软件仓库是一组文件，其中包含各种软件及其版本的信息，以及校验和等其他一些详细信息。每个版本的 Ubuntu 都有自己的四个官方软件仓库：
* Main - Canonical 支持的自由开源软件。
* Universe - 社区维护的自由开源软件。
* Restricted - 设备的专有驱动程序。
* Multiverse - 受版权或法律问题限制的软件。
你可以在 [这里](http://archive.ubuntu.com/ubuntu/dists/) 看到所有版本的 Ubuntu 的软件仓库。你可以浏览并转到各个仓库。例如，可以在 [这里](http://archive.ubuntu.com/ubuntu/dists/xenial/main/) 找到 Ubuntu 16.04 的主存储库（Main）。
所以，PPA 基本上是一个包含软件信息的网址。那你的系统又是如何知道这些仓库的位置的呢？
这些信息存储在 `/etc/apt` 目录中的 `sources.list` 文件中。如果查看此文件的内容，你就会看到里面有软件仓库的网址。`#` 开头的行将被忽略。
这样的话，当你运行 `sudo apt update` 命令时，你的系统将使用 [APT 工具](https://wiki.debian.org/Apt) 来检查软件仓库并将软件及其版本信息存储在缓存中。当你使用 `sudo apt install package_name` 命令时，它通过该信息从实际存储软件的网址获取该软件包。
如果软件仓库中没有关于某个包的信息，你将看到如下错误：
```
E: Unable to locate package
```
此时，建议阅读我的 [apt 命令使用指南](https://itsfoss.com/apt-command-guide/) 一文，这将帮你更好地理解 `apt`、`update` 等命令。
以上是关于软件仓库的内容。但什么是 PPA？PPA 和软件仓库又有什么关联呢？
#### 为什么要用 PPA？
如你所见，Ubuntu 对系统中的软件进行管理，更重要的是控制你在系统上获得哪个版本的软件。但想象一下开发人员发布了软件的新版本的情况。
Ubuntu 不会立即提供该新版本的软件。需要一个步骤来检查此新版本的软件是否与系统兼容，从而可以确保系统的稳定性。
但这也意味着它需要经过几周才能在 Ubuntu 上可用，在某些情况下，这可能需要几个月的时间。不是每个人都想等待那么长时间才能获得他们最喜欢的软件的新版本。
类似地，假设有人开发了一款软件，并希望 Ubuntu 将该软件包含在官方软件仓库中。在 Ubuntu 做出决定并将其包含在官方存软件仓库之前，还需要几个月的时间。
另一种情况是在 beta 测试阶段。即使官方软件仓库中提供了稳定版本的软件，软件开发人员也可能希望某些终端用户测试他们即将发布的版本。他们是如何使终端用户对即将发布的版本进行 beta 测试的呢？
通过 PPA！
### 如何使用 PPA？PPA 是怎样工作的？
正如我已经告诉过你的那样，[PPA](https://launchpad.net/ubuntu/+ppas) 代表<ruby> 个人软件包存档 <rt> Personal Package Archive </rt></ruby>。在这里注意 “个人” 这个词，它暗示了这是开发人员独有的东西，并没有得到分发的正式许可。
Ubuntu 提供了一个名为 Launchpad 的平台，使软件开发人员能够创建自己的软件仓库。终端用户，也就是你，可以将 PPA 仓库添加到 `sources.list` 文件中，当你更新系统时，你的系统会知道这个新软件的可用性，然后你可以使用标准的 `sudo apt install` 命令安装它。
```
sudo add-apt-repository ppa:dr-akulavich/lighttable
sudo apt-get update
sudo apt-get install lighttable-installer
```
概括一下上面三个命令：
* `sudo add-apt-repository <PPA_info>` <- 此命令将 PPA 仓库添加到列表中。
* `sudo apt-get update` <- 此命令更新可以在当前系统上安装的软件包列表。
* `sudo apt-get install <package_in_PPA>` <- 此命令安装软件包。
你会发现使用 `sudo apt update` 命令非常重要，否则你的系统将无法知道新软件包何时可用。
现在让我们更详细地看一下第一个命令。
```
sudo add-apt-repository ppa:dr-akulavich/lighttable
```
你会注意到此命令没有软件仓库的 URL。这是因为该工具被设计成将 URL 信息抽象之后再展示给你。
小小注意一下：如果你添加的是 `ppa:dr-akulavich/lighttable`，你会得到 Light Table。但是如果你添加 `ppa:dr-akulavich`，你将得到 “上层软件仓库” 中的所有仓库或软件包。它是按层级划分的。
基本上，当您使用 `add-apt-repository` 添加 PPA 时，它将执行与手动运行这些命令相同的操作：
```
deb http://ppa.launchpad.net/dr-akulavich/lighttable/ubuntu YOUR_UBUNTU_VERSION_HERE main
deb-src http://ppa.launchpad.net/dr-akulavich/lighttable/ubuntu YOUR_UBUNTU_VERSION_HERE main
```
以上两行是将任何软件仓库添加到你系统的 `sources.list` 文件的传统方法。但 PPA 会自动为你完成这些工作，无需考虑确切的软件仓库 URL 和操作系统版本。
此处不那么重要的一点是，当你使用 PPA 时，它不会更改原始的 `sources.list` 文件。相反，它在 `/etc/apt/sources.d` 目录中创建了两个文件，一个 `.list` 文件和一个带有 `.save` 后缀的备份文件。
*PPA 创建了单独的 `sources.list` 文件*
带有后缀 `.list` 的文件含有添加软件仓库的信息的命令。
*一个 PPA 的 `source.list` 文件的内容*
这是一种安全措施，可以确保添加的 PPA 不会和原始的 `sources.list` 文件弄混，它还有助于移除 PPA。
#### 为什么使用 PPA？为何不用 DEB 包
你可能会问为什么要使用 PPA，PPA 需要通过命令行使用，而不是每个人都喜欢用命令行。为什么不直接分发可以图形方式安装的 DEB 包呢？
答案在于更新的过程。如果使用 DEB 包安装软件，将无法保证在运行 `sudo apt update` 和 `sudo apt upgrade` 命令时，已安装的软件会被更新为较新的版本。
这是因为 `apt` 的升级过程依赖于 `sources.list` 文件。如果文件中没有相应的软件条目，则不会通过标准软件更新程序获得更新。
那么这是否意味着使用 DEB 安装的软件永远不会得到更新？不是的。这取决于 DEB 包的创建方式。
一些开发人员会自动在 `sources.list` 中添加一个条目，这样软件就可以像普通软件一样更新。谷歌 Chrome 浏览器就是这样一个例子。
某些软件会在运行时通知你有新版本可用。你必须下载新的 DEB 包并再次运行，来将当前软件更新为较新版本。Oracle Virtual Box 就是这样一个例子。
对于其余的 DEB 软件包，你必须手动查找更新，这很不方便，尤其是在你的软件面向 Beta 测试者时，你需要频繁的添加很多更新。这正是 PPA 要解决的问题。
#### 官方 PPA vs 非官方 PPA
你或许听过官方 PPA 或非官方 PPA 这个词，二者有什么不同呢？
开发人员为他们的软件创建的 PPA 称为官方 PPA。很明显，这是因为它来自项目开发者。
但有时，个人会创建由其他开发人员所创建的项目的 PPA。
为什么会有人这样做？ 因为许多开发人员只提供软件的源代码，而且你也知道 [在 Linux 中从源代码安装软件](/article-9172-1.html) 是一件痛苦的事情，并不是每个人都可以或者会这样做。
这就是志愿者自己从这些源代码创建 PPA 以便其他用户可以轻松安装软件的原因。毕竟，使用这 3 行命令比从源代码安装要容易得多。
#### 确保你的 Linux 发行版本可以使用 PPA
当在 Ubuntu 或任何其他基于 Debian 的发行版中使用 PPA 时，你应该记住一些事情。
并非每个 PPA 都适用于你的特定版本。你应该知道正在使用 [哪个版本的 Ubuntu](https://itsfoss.com/how-to-know-ubuntu-unity-version/)。版本的开发代号很重要，因为当你访问某个 PPA 的页面时，你可以看到该 PPA 都支持哪些版本的 Ubuntu。
对于其他基于 Ubuntu 的发行版，你可以查看 `/etc/os-release` 的内容来 [找出 Ubuntu 版本](https://itsfoss.com/how-to-know-ubuntu-unity-version/) 的信息。
*检查 PPA 是否适用于你的 Ubuntu 版本*
如何知道 PPA 的网址呢？只需在网上搜索 PPA 的名称，如 `ppa:dr-akulavich/lighttable`，第一个搜索结果来自 [Launchpad](https://launchpad.net/)，这是托管 PPA 的官方平台。你也可以转到 Launchpad 并直接在那里搜索所需的 PPA。
如果不验证是否适用当前的版本就添加 PPA，当尝试安装不适用于你的系统版本的软件时，可能会看到类似下面的错误。
```
E: Unable to locate package
```
更糟糕的是，因为它已经添加到你的 `source.list` 中，每次运行软件更新程序时，你都会看到 “[无法下载软件仓库信息](https://itsfoss.com/failed-to-download-repository-information-ubuntu-13-04/)” 的错误。
如果你在终端中运行 `sudo apt update`，错误提示将包含导致此问题的仓库的更多详细信息。你可以在 `sudo apt update` 的输出内容结尾看到类似的内容：
```
W: Failed to fetch http://ppa.launchpad.net/venerix/pkg/ubuntu/dists/raring/main/binary-i386/Packages 404 Not Found
E: Some index files failed to download. They have been ignored, or old ones used instead.
```
上面的错误提示说的很明白，是因为系统找不到当前版本对应的仓库。还记得我们之前看到的仓库结构吗？APT 将尝试在 `http://ppa.launchpad.net/<PPA_NAME>/ubuntu/dists/<Ubuntu_Version>` 中寻找软件信息。
如果特定版本的 PPA 不可用，它将永远无法打开 URL，你会看到著名的 404 错误。
#### 为什么 PPA 不适用于所有 Ubuntu 发行版？
这是因为 PPA 的作者必须编译软件并在特定版本上创建 PPA。考虑到每六个月发布一个新的 Ubuntu 版本，为每个版本的 Ubuntu 更新 PPA 是一项繁琐的任务，并非所有开发人员都有时间这样做。
#### 如果 PPA 不适用于你的系统版本，该如何安装应用程序？
尽管 PPA 不适用于你的 Ubuntu 版本，你仍然可以下载 DEB 文件并安装应用程序。
比如说，你访问 Light Table 的 PPA 页面，使用刚刚学到的有关 PPA 的知识，你会发现 PPA 不适用于你的特定 Ubuntu 版本。
你可以点击 “查看软件包详细信息”。
在这里，你可以单击软件包以显示更多详细信息，还可以在此处找到包的源代码和 DEB 文件。
我建议 [使用 Gdebi 安装这些 DEB 文件](https://itsfoss.com/gdebi-default-ubuntu-software-center/) 而不是通过软件中心，因为 Gdebi 在处理依赖项方面要好得多。
请注意，以这种方式安装的软件包可能无法获得任何将来的更新。
我认为你已经阅读了足够多的关于添加 PPA 的内容，那么如何删除 PPA 及其安装的软件呢？
### 如何删除 PPA？
我过去曾写过 [删除 PPA](https://itsfoss.com/how-to-remove-or-delete-ppas-quick-tip/) 的教程，这里写的也是同样的方法。
我建议在删除 PPA 之前删除从 PPA 安装的软件。如果只是删除 PPA，则已安装的软件仍保留在系统中，但不会获得任何更新。这不是你想要的，不是吗？
那么，问题来了，如何知道是哪个 PPA 安装了哪个应用程序？
#### 查找 PPA 安装的软件包并将其移除
Ubuntu 软件中心无法移除 PPA 安装的软件包，你必须使用具有更多高级功能的 Synaptic 包管理器。
可以从软件中心安装 Synaptic 或使用以下命令进行安装：
```
sudo apt install synaptic
```
安装后，启动 Synaptic 包管理器并选择 “Origin”。你会看到添加到系统的各种软件仓库。PPA 条目将以前缀 PPA 进行标识，单击以查看 PPA 可用的包。已安装的软件前面会有恰当的符号进行标识。
*查找通过 PPA 安装的软件包*
找到包后，你可以从 Synaptic 删除它们。此外，也始终可以选择使用命令行进行移除：
```
sudo apt remove package_name
```
删除 PPA 安装的软件包后，你可以继续从 `sources.list` 中删除PPA。
#### 以图形界面的方式删除 PPA
在设置中打开 “软件和更新”，然后点击 “其他软件” 选项卡。查找要删除的 PPA：
此处你可以进项两项操作，可以取消选择 PPA 或选择 “删除” 选项。
区别在于，当你取消选择 PPA 条目时，系统将在 `/etc/apt/sources.list.d` 中的`ppa_name.list` 文件中注释掉仓库条目；但如果选择 “删除” 选项，将会删除 `/etc/apt/sources.list.d`目录中 `ppa_name.list` 文件里的仓库条目。
在这两种情况下，文件 `ppa_name.list` 都保留在所在的目录中，即使它是空的。
### 使用 PPA 安全吗？
这是一个主观问题。纯粹主义者厌恶 PPA，因为大多数时候 PPA 来自第三方开发者。但与此同时，PPA 在 Debian/Ubuntu 世界中很受欢迎，因为它们提供了更简单的安装选项。
就安全性而言，很少见到因为使用 PPA 之后你的 Linux 系统被黑客攻击或注入恶意软件。到目前为止，我不记得发生过这样的事件。
官方 PPA 可以不加考虑的使用，使用非官方 PPA 完全是你自己的决定。
根据经验，如果程序需要 sudo 权限，则应避免通过第三方 PPA 进行安装。
### 你如何看待使用 PPA？
我知道这篇文章需要挺长时间来阅读，但我想让你更好地了解 PPA。我希望这份详细指南能够回答你关于使用 PPA 的大部分问题。
如果你对 PPA 有更多疑问，请随时在评论区提问。
如果你发现任何技术或语法错误，或者有改进的建议，请告诉我。
---
via: <https://itsfoss.com/ppa-guide/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[jlztan](https://github.com/jlztan) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Turtl：Evernote 的开源替代品
|
Scott Nesbitt
|
https://opensource.com/article/17/12/using-turtl-open-source-alternative-evernote
|
如果你正在寻找一个 Evernote 和 Google Keep 的替代品，那么 Turtl 是一个可靠的记笔记工具。
|
/data/attachment/album/201901/19/133836jlxxu3l8u8k83uul.jpg.thumb.jpg
|
/data/attachment/album/201901/19/133836jlxxu3l8u8k83uul.jpg
| true | false | true |
geekpi
|
wxy
| false |
[
"Evernote",
"笔记"
] |
分享
|
{
"viewnum": 7979,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
如果你正在寻找一个 Evernote 和 Google Keep 的替代品，那么 Turtl 是一个可靠的记笔记工具。
| 2019-01-19T13:38:50 | 2019-01-19T13:38:50 | 10,457 |
/article-10457-1.html
|
>
> 如果你正在寻找一个 Evernote 和 Google Keep 的替代品，那么 Turtl 是一个可靠的记笔记工具。
>
>
>
我认识的每个人都会记笔记，许多人使用在线笔记应用，如 Evernote、Simplenote 或 Google Keep。这些都是很好的工具，但你不得不担忧信息的安全性和隐私性 —— 特别是考虑到 [Evernote 2016 年的隐私策略变更](https://blog.evernote.com/blog/2016/12/15/evernote-revisits-privacy-policy/)。如果你想要更好地控制笔记和数据，你需要转向开源工具。
无论你离开 Evernote 的原因是什么，都有开源替代品。让我们来看看其中一个选择：Turtl。
### 入门
[Turtl](https://turtlapp.com/) 背后的开发人员希望你将其视为“具有绝对隐私的 Evernote”。说实话，我不能保证 Turtl 提供的隐私级别，但它是一个非常好的笔记工具。
要开始使用 Turtl，[下载](https://turtlapp.com/download/)适用于 Linux、Mac OS 或 Windows 的桌面客户端，或者获取它的 [Android 应用](https://turtlapp.com/download/)。安装它，然后启动客户端或应用。系统会要求你输入用户名和密码。Turtl 使用密码来生成加密密钥，根据开发人员的说法，加密密钥会在将笔记存储在设备或服务器上之前对其进行加密。
### 使用 Turtl
你可以使用 Turtl 创建以下类型的笔记：
* 密码
* 档案
* 图片
* 书签
* 文字笔记
无论你选择何种类型的笔记，你都可以在类似的窗口中创建：
*在 Turtl 中创建新笔记*
添加笔记标题、文字并（如果你正在创建文件或图像笔记）附加文件或图像等信息。然后单击“保存”。
你可以通过 [Markdown](https://en.wikipedia.org/wiki/Markdown) 为你的笔记添加格式。因为没有工具栏快捷方式，所以你需要手动添加格式。
如果你需要整理笔记，可以将它们添加到“白板”中。白板就像 Evernote 中的笔记本。要创建新的白板，请单击 “Board” 选项卡，然后单击“创建”按钮。输入白板的标题，然后单击“创建”。
*在 Turtl 中创建新的白板*
要向白板中添加笔记，请创建或编辑笔记，然后单击笔记底部的“此笔记不在任何白板”的链接。选择一个或多个白板，然后单击“完成”。
要为笔记添加标记，请单击记事本底部的“标记”图标，输入一个或多个以逗号分隔的关键字，然后单击“完成”。
### 跨设备同步你的笔记
例如，如果你在多台计算机和 Android 设备上使用 Turtl，Turtl 会在你上线时同步你的笔记。但是，我在同步时遇到了一个小问题：我手机上创建的笔记经常不会同步到我的笔记本电脑上。我尝试通过单击窗口左上角的图标手动同步，然后单击立即同步，但这并不总是有效。我发现偶尔需要单击“设置”图标，然后单击“清除本地数据”。然后我需要重新登录 Turtl，但所有数据都能正确同步了。
### 一个疑问和一些问题
当我开始使用 Turtl 时，我被一个疑问所困扰：我的笔记保存在哪里？事实证明，Turtl 背后的开发人员位于美国，这也是他们服务器的所在地。虽然 Turtl 使用的加密[非常强大](https://turtlapp.com/docs/security/encryption-specifics/)并且你的笔记在服务器上加密，但我偏执地认为你不应该在 Turtl 中保存任何敏感内容（或在任何类似的在线笔记中）。
Turtl 以平铺视图显示笔记，让人想起 Google Keep：
*Turtl 中的一系列笔记*
无法在桌面或 Android 应用上将其更改为列表视图。这对我来说不是问题，但我听说有些人因为它没有列表视图而不喜欢 Turtl。
说到 Android 应用，它并不差。但是，它没有与 Android 共享菜单集成。如果你想把在其他应用中看到或阅读的内容添加到 Turtl 笔记中，则需要手动复制并粘贴。
我已经在我的 Linux 笔记本，[运行 GalliumOS 的 Chromebook](https://opensource.com/article/17/4/linux-chromebook-gallium-os)，还有一台 Android 手机上使用 Turtl 几个月了。对所有这些设备来说这都是一种非常无缝的体验。虽然它不是我最喜欢的开源笔记工具，但 Turtl 做得非常好。试试看它，它可能是你正在寻找的简单的笔记工具。
---
via: <https://opensource.com/article/17/12/using-turtl-open-source-alternative-evernote>
作者：[Scott Nesbitt](https://opensource.com/users/scottnesbitt) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
计算机实验室之树莓派：课程 1 OK01
|
Robert Mullins
|
https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/ok01.html
|
OK01 课程讲解了树莓派如何入门，以及在树莓派上如何启用靠近 RCA 和 USB 端口的 OK 或 ACT 的 LED 指示灯。这个指示灯最初是为了指示 OK 状态的，但它在第二版的树莓派上被改名为 ACT。
|
/data/attachment/album/201901/19/163408xpyibrbyq5d4q5cf.jpg.thumb.jpg
|
/data/attachment/album/201901/19/163408xpyibrbyq5d4q5cf.jpg
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"树莓派"
] |
树莓派
|
{
"viewnum": 7341,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10429,
"displayorder": 0
},
{
"raid": 10478,
"displayorder": 1
}
] |
OK01 课程讲解了树莓派如何入门，以及在树莓派上如何启用靠近 RCA 和 USB 端口的 OK 或 ACT 的 LED 指示灯。这个指示灯最初是为了指示 OK 状态的，但它在第二版的树莓派上被改名为 ACT。
| 2019-01-19T16:36:00 | 2019-01-19T16:36:00 | 10,458 |
/article-10458-1.html
|
OK01 课程讲解了树莓派如何入门，以及在树莓派上如何启用靠近 RCA 和 USB 端口的 OK 或 ACT 的 LED 指示灯。这个指示灯最初是为了指示 OK 状态的，但它在第二版的树莓派上被改名为 ACT。
### 1、入门
我们假设你已经访问了[下载](https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/downloads.html)页面，并且已经获得了必需的 GNU 工具链。也下载了一个称为操作系统模板的文件。请下载这个文件并在一个新目录中解开它。
### 2、开始
现在，你已经展开了这个模板文件，在 `source` 目录中创建一个名为 `main.s` 的文件。这个文件包含了这个操作系统的代码。具体来看，这个文件夹的结构应该像下面这样：
```
build/
(empty)
source/
main.s
kernel.ld
LICENSE
Makefile
```
用文本编辑器打开 `main.s` 文件，这样我们就可以输入汇编代码了。树莓派使用了称为 ARMv6 的汇编代码变体，这就是我们即将要写的汇编代码类型。
>
> 扩展名为 `.s` 的文件一般是汇编代码，需要记住的是，在这里它是 ARMv6 的汇编代码。
>
>
>
首先，我们复制下面的这些命令。
```
.section .init
.globl _start
_start:
```
实际上，上面这些指令并没有在树莓派上做任何事情，它们是提供给汇编器的指令。汇编器是一个转换程序，它将我们能够理解的汇编代码转换成树莓派能够理解的机器代码。在汇编代码中，每个行都是一个新的命令。上面的第一行告诉汇编器 <sup id="fnref1"> <a href="#fn1" rel="footnote"> 1 </a></sup> 在哪里放我们的代码。我们提供的模板中将它放到一个名为 `.init` 的节中的原因是，它是输出的起始点。这很重要，因为我们希望确保我们能够控制哪个代码首先运行。如果不这样做，首先运行的代码将是按字母顺序排在前面的代码！`.section` 命令简单地告诉汇编器，哪个节中放置代码，从这个点开始，直到下一个 `.section` 或文件结束为止。
>
> 在汇编代码中，你可以跳行、在命令前或后放置空格去提升可读性。
>
>
>
接下来两行是停止一个警告消息，它们并不重要。<sup id="fnref2"> <a href="#fn2" rel="footnote"> 2 </a></sup>
### 3、第一行代码
现在，我们正式开始写代码。计算机执行汇编代码时，是简单地一行一行按顺序执行每个指令，除非明确告诉它不这样做。每个指令都是开始于一个新行。
复制下列指令。
```
ldr r0,=0x20200000
```
>
> `ldr reg,=val` 将数字 `val` 加载到名为 `reg` 的寄存器中。
>
>
>
那是我们的第一个命令。它告诉处理器将数字 `0x20200000` 保存到寄存器 `r0` 中。在这里我需要去回答两个问题，<ruby> 寄存器 <rt> register </rt></ruby>是什么？`0x20200000` 是一个什么样的数字？
寄存器在处理器中就是一个极小的内存块，它是处理器保存正在处理的数字的地方。处理器中有很多寄存器，很多都有专门的用途，我们在后面会一一接触到它们。最重要的有十三个（命名为 `r0`、`r1`、`r2`、…、`r9`、`r10`、`r11`、`r12`），它们被称为通用寄存器，你可以使用它们做任何计算。由于是写我们的第一行代码，我们在示例中使用了 `r0`，当然你可以使用它们中的任何一个。只要后面始终如一就没有问题。
>
> 树莓派上的一个单独的寄存器能够保存任何介于 `0` 到 `4,294,967,295`（含）之间的任意整数，它可能看起来像一个很大的内存，实际上它仅有 32 个二进制比特。
>
>
>
`0x20200000` 确实是一个数字。只不过它是以十六进制表示的。下面的内容详细解释了十六进制的相关信息：
>
> 延伸阅读：十六进制解释
>
>
> 十六进制是另一种表示数字的方式。你或许只知道十进制的数字表示方法，十进制共有十个数字：`0`、`1`、`2`、`3`、`4`、`5`、`6`、`7`、`8` 和 `9`。十六进制共有十六个数字：`0`、`1`、`2`、`3`、`4`、`5`、`6`、`7`、`8`、`9`、`a`、`b`、`c`、`d`、`e` 和 `f`。
>
>
> 你可能还记得十进制是如何用位制来表示的。即最右侧的数字是个位，紧接着的左边一位是十位，再接着的左边一位是百位，依此类推。也就是说，它的值是 100 × 百位的数字，再加上 10 × 十位的数字，再加上 1 × 个位的数字。
>
>
> 
>
>
> 从数学的角度来看，我们可以发现规律，最右侧的数字是 10<sup> 0</sup> = 1s，紧接着的左边一位是 10<sup> 1</sup> = 10s，再接着是 10<sup> 2</sup> = 100s，依此类推。我们设定在系统中，0 是最低位，紧接着是 1，依此类推。但如果我们使用一个不同于 10 的数字为幂底会是什么样呢？我们在系统中使用的十六进制就是这样的一个数字。
>
>
> 
>
>
> 
>
>
> 上面的数学等式表明，十进制的数字 567 等于十六进制的数字 237。通常我们需要在系统中明确它们，我们使用下标 <sub> 10</sub> 表示它是十进制数字，用下标 <sub> 16</sub> 表示它是十六进制数字。由于在汇编代码中写上下标的小数字很困难，因此我们使用 0x 来表示它是一个十六进制的数字，因此 0x237 的意思就是 237<sub> 16</sub> 。
>
>
> 那么，后面的 `a`、`b`、`c`、`d`、`e` 和 `f` 又是什么呢？好问题！在十六进制中为了能够写每个数字，我们就需要额外的东西。例如 9<sub> 16</sub> = 9×16<sup> 0</sup> = 9<sub> 10</sub> ，但是 10<sub> 16</sub> = 1×16<sup> 1</sup> + 1×16<sup> 0</sup> = 16<sub> 10</sub> 。因此，如果我们只使用 0、1、2、3、4、5、6、7、8 和 9，我们就无法写出 10<sub> 10</sub> 、11<sub> 10</sub> 、12<sub> 10</sub> 、13<sub> 10</sub> 、14<sub> 10</sub> 、15<sub> 10</sub> 。因此我们引入了 6 个新的数字，这样 a<sub> 16</sub> = 10<sub> 10</sub> 、b<sub> 16</sub> = 11<sub> 10</sub> 、c<sub> 16</sub> = 12<sub> 10</sub> 、d<sub> 16</sub> = 13<sub> 10</sub> 、e<sub> 16</sub> = 14<sub> 10</sub> 、f<sub> 16</sub> = 15<sub> 10</sub> 。
>
>
> 所以，我们就有了另一种写数字的方式。但是我们为什么要这么麻烦呢？好问题！由于计算机总是工作在二进制中，事实证明，十六进制是非常有用的，因为每个十六进制数字正好是四个二进制数字的长度。这种方法还有另外一个好处，那就是许多计算机的数字都是十六进制的整数倍，而不是十进制的整数倍。比如，我在上面的汇编代码中使用的一个数字 20200000<sub> 16</sub> 。如果我们用十进制来写，它就是一个不太好记住的数字 538968064<sub> 10</sub> 。
>
>
> 我们可以用下面的简单方法将十进制转换成十六进制：
>
>
> 
>
>
> 1. 我们以十进制数字 567 为例来说明。
> 2. 将十进制数字 567 除以 16 并计算其余数。例如 567 ÷ 16 = 35 余数为 7。
> 3. 在十六进制中余数就是答案中的最后一位数字，在我们的例子中它是 7。
> 4. 重复第 2 步和第 3 步，直到除法结果的整数部分为 0。例如 35 ÷ 16 = 2 余数为 3，因此 3 就是答案中的下一位。2 ÷ 16 = 0 余数为 2，因此 2 就是答案的接下来一位。
> 5. 一旦除法结果的整数部分为 0 就结束了。答案就是反序的余数，因此 567<sub> 10</sub> = 237<sub> 16</sub>。
>
>
> 转换十六进制数字为十进制，也很容易，将数字展开即可，因此 237<sub> 16</sub> = 2×16<sup> 2</sup> + 3×16<sup> 1</sup> +7 ×16<sup> 0</sup> = 2×256 + 3×16 + 7×1 = 512 + 48 + 7 = 567。
>
>
>
因此，我们所写的第一个汇编命令是将数字 20200000<sub> 16</sub> 加载到寄存器 `r0` 中。那个命令看起来似乎没有什么用，但事实并非如此。在计算机中，有大量的内存块和设备。为了能够访问它们，我们给每个内存块和设备指定了一个地址。就像邮政地址或网站地址一样，它用于标识我们想去访问的内存块或设备的位置。计算机中的地址就是一串数字，因此上面的数字 20200000<sub> 16</sub> 就是 GPIO 控制器的地址。这个地址是由制造商的设计所决定的，他们也可以使用其它地址（只要不与其它的冲突即可）。我之所以知道这个地址是 GPIO 控制器的地址是因为我看了它的手册，<sup id="fnref3"> <a href="#fn3" rel="footnote"> 3 </a></sup> 地址的使用没有专门的规范（除了它们都是以十六进制表示的大数以外）。
### 4、启用输出
阅读了手册可以得知，我们需要给 GPIO 控制器发送两个消息。我们必须用它的语言告诉它，如果我们这样做了，它将非常乐意实现我们的意图，去打开 OK 的 LED 指示灯。幸运的是，它是一个非常简单的芯片，为了让它能够理解我们要做什么，只需要给它设定几个数字即可。
```
mov r1,#1
lsl r1,#18
str r1,[r0,#4]
```
>
> `mov reg,#val` 将数字 `val` 放到名为 `reg` 的寄存器中。
>
>
> `lsl reg,#val` 将寄存器 `reg` 中的二进制操作数左移 `val` 位。
>
>
> `str reg,[dest,#val]` 将寄存器 `reg` 中的数字保存到地址 `dest + val` 上。
>
>
>
这些命令的作用是在 GPIO 的第 16 号插针上启用输出。首先我们在寄存器 `r1` 中获取一个必需的值，接着将这个值发送到 GPIO 控制器。因此，前两个命令是尝试取值到寄存器 `r1` 中，我们可以像前面一样使用另一个命令 `ldr` 来实现，但 `lsl` 命令对我们后面能够设置任何给定的 GPIO 针比较有用，因此从一个公式中推导出值要比直接写入来好一些。表示 OK 的 LED 灯是直接连线到 GPIO 的第 16 号针脚上的，因此我们需要发送一个命令去启用第 16 号针脚。
寄存器 `r1` 中的值是启用 LED 针所需要的。第一行命令将数字 1<sub> 10</sub> 放到 `r1` 中。在这个操作中 `mov` 命令要比 `ldr` 命令快很多，因为它不需要与内存交互，而 `ldr` 命令是将需要的值从内存中加载到寄存器中。尽管如此，`mov` 命令仅能用于加载某些值。<sup id="fnref4"> <a href="#fn4" rel="footnote"> 4 </a></sup> 在 ARM 汇编代码中，基本上每个指令都使用一个三字母代码表示。它们被称为助记词，用于表示操作的用途。`mov` 是 “move” 的简写，而 `ldr` 是 “load register” 的简写。`mov` 是将第二个参数 `#1` 移动到前面的 `r1` 寄存器中。一般情况下，`#` 肯定是表示一个数字，但我们已经看到了不符合这种情况的一个反例。
第二个指令是 `lsl`（逻辑左移）。它的意思是将第一个参数的二进制操作数向左移第二个参数所表示的位数。在这个案例中，将 1<sub> 10</sub> （即 1<sub> 2</sub> ）向左移 18 位（将它变成 1000000000000000000<sub> 2</sub>=262144<sub> 10</sub> ）。
如果你不熟悉二进制表示法，可以看下面的内容：
>
> 延伸阅读： 二进制解释
>
>
> 与十六进制一样，二进制是写数字的另一种方法。在二进制中只有两个数字，即 `0` 和 `1`。它在计算机中非常有用，因为我们可以用电路来实现它，即电流能够通过电路表示为 `1`，而电流不能通过电路表示为 `0`。这就是计算机能够完成真实工作和做数学运算的原理。尽管二进制只有两个数字，但它却能够表示任何一个数字，只是写起来有点长而已。
>
>
> 
>
>
> 这个图片展示了 567<sub> 10</sub> 的二进制表示是 1000110111<sub> 2</sub> 。我们使用下标 2 来表示这个数字是用二进制写的。
>
>
> 我们在汇编代码中大量使用二进制的其中一个巧合之处是，数字可以很容易地被 `2` 的幂（即 `1`、`2`、`4`、`8`、`16`）乘或除。通常乘法和除法都是非常难的，而在某些特殊情况下却变得非常容易，所以二进制非常重要。
>
>
> 
>
>
> 将一个二进制数字左移 `n` 位就相当于将这个数字乘以 2<sup> n</sup>。因此，如果我们想将一个数乘以 4，我们只需要将这个数字左移 2 位。如果我们想将它乘以 256，我们只需要将它左移 8 位。如果我们想将一个数乘以 12 这样的数字，我们可以有一个替代做法，就是先将这个数乘以 8，然后再将那个数乘以 4，最后将两次相乘的结果相加即可得到最终结果（N × 12 = N × (8 + 4) = N × 8 + N × 4）。
>
>
> 
>
>
> 右移一个二进制数 `n` 位就相当于这个数除以 2<sup> n</sup> 。在右移操作中，除法的余数位将被丢弃。不幸的是，如果对一个不能被 2 的幂次方除尽的二进制数字做除法是非常难的，这将在 [课程 9 Screen04](https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/screen04.html) 中讲到。
>
>
> 
>
>
> 这个图展示了二进制常用的术语。一个<ruby> 比特 <rt> bit </rt></ruby>就是一个单独的二进制位。一个“<ruby> 半字节 <rt> nibble </rt></ruby>“ 是 4 个二进制位。一个<ruby> 字节 <rt> byte </rt></ruby>是 2 个半字节，也就是 8 个比特。<ruby> 半字 <rt> half </rt></ruby>是指一个字长度的一半，这里是 2 个字节。<ruby> 字 <rt> word </rt></ruby>是指处理器上寄存器的大小，因此，树莓派的字长是 4 字节。按惯例，将一个字最高有效位标识为 31，而将最低有效位标识为 0。顶部或最高位表示最高有效位，而底部或最低位表示最低有效位。一个 kilobyte（KB）就是 1000 字节，一个 megabyte 就是 1000 KB。这样表示会导致一些困惑，到底应该是 1000 还是 1024（二进制中的整数）。鉴于这种情况，新的国际标准规定，一个 KB 等于 1000 字节，而一个 Kibibyte（KiB）是 1024 字节。一个 Kb 是 1000 比特，而一个 Kib 是 1024 比特。
>
>
> 树莓派默认采用小端法，也就是说，从你刚才写的地址上加载一个字节时，是从一个字的低位字节开始加载的。
>
>
>
再强调一次，我们只有去阅读手册才能知道我们所需要的值。手册上说，GPIO 控制器中有一个 24 字节的集合，由它来决定 GPIO 针脚的设置。第一个 4 字节与前 10 个 GPIO 针脚有关，第二个 4 字节与接下来的 10 个针脚有关，依此类推。总共有 54 个 GPIO 针脚，因此，我们需要 6 个 4 字节的一个集合，总共是 24 个字节。在每个 4 字节中，每 3 个比特与一个特定的 GPIO 针脚有关。我们想去启用的是第 16 号 GPIO 针脚，因此我们需要去设置第二组 4 字节，因为第二组的 4 字节用于处理 GPIO 针脚的第 10-19 号，而我们需要第 6 组 3 比特，它在上面的代码中的编号是 18（6×3）。
最后的 `str`（“store register”）命令去保存第一个参数中的值，将寄存器 `r1` 中的值保存到后面的表达式计算出来的地址上。这个表达式可以是一个寄存器，在上面的例子中是 `r0`，我们知道 `r0` 中保存了 GPIO 控制器的地址，而另一个值是加到它上面的，在这个例子中是 `#4`。它的意思是将 GPIO 控制器地址加上 `4` 得到一个新的地址，并将寄存器 `r1` 中的值写到那个地址上。那个地址就是我们前面提到的第二组 4 字节的位置，因此，我们发送我们的第一个消息到 GPIO 控制器上，告诉它准备启用 GPIO 第 16 号针脚的输出。
### 5、生命的信号
现在，LED 已经做好了打开准备，我们还需要实际去打开它。意味着需要给 GPIO 控制器发送一个消息去关闭 16 号针脚。是的，你没有看错，就是要发送一个关闭的消息。芯片制造商认为，在 GPIO 针脚关闭时打开 LED 更有意义。<sup id="fnref5"> <a href="#fn5" rel="footnote"> 5 </a></sup> 硬件工程师经常做这种反常理的决策，似乎是为了让操作系统开发者保持警觉。可以认为是给自己的一个警告。
```
mov r1,#1
lsl r1,#16
str r1,[r0,#40]
```
希望你能够认识上面全部的命令，先不要管它的值。第一个命令和前面一样，是将值 `1` 推入到寄存器 `r1` 中。第二个命令是将二进制的 `1` 左移 16 位。由于我们是希望关闭 GPIO 的 16 号针脚，我们需要在下一个消息中将第 16 比特设置为 1（想设置其它针脚只需要改变相应的比特位即可）。最后，我们写这个值到 GPIO 控制器地址加上 40<sub> 10</sub> 的地址上，这将使那个针脚关闭（加上 28 将打开针脚）。
### 6、永远幸福快乐
似乎我们现在就可以结束了，但不幸的是，处理器并不知道我们做了什么。事实上，处理器只要通电，它就永不停止地运转。因此，我们需要给它一个任务，让它一直运转下去，否则，树莓派将进入休眠（本示例中不会，LED 灯会一直亮着）。
```
loop$:
b loop$
```
>
> `name:` 下一行的名字。
>
>
> `b label` 下一行将去标签 `label` 处运行。
>
>
>
第一行不是一个命令，而是一个标签。它给下一行命名为 `loop$`，这意味着我们能够通过名字来指向到该行。这就称为一个标签。当代码被转换成二进制后，标签将被丢弃，但这对我们通过名字而不是数字（地址）找到行比较有用。按惯例，我们使用一个 `$` 表示这个标签只对这个代码块中的代码起作用，让其它人知道，它不对整个程序起作用。`b`（“branch”）命令将去运行指定的标签中的命令，而不是去运行它后面的下一个命令。因此，下一行将再次去运行这个 `b` 命令，这将导致永远循环下去。因此处理器将进入一个无限循环中，直到它安全关闭为止。
代码块结尾的一个空行是有意这样写的。GNU 工具链要求所有的汇编代码文件都是以空行结束的，因此，这就可以你确实是要结束了，并且文件没有被截断。如果你不这样处理，在汇编器运行时，你将收到烦人的警告。
### 7、树莓派上场
由于我们已经写完了代码，现在，我们可以将它上传到树莓派中了。在你的计算机上打开一个终端，改变当前工作目录为 `source` 文件夹的父级目录。输入 `make` 然后回车。如果报错，请参考排错章节。如果没有报错，你将生成三个文件。 `kernel.img` 是你的编译后的操作系统镜像。`kernel.list` 是你写的汇编代码的一个清单，它实际上是生成的。这在将来检查程序是否正确时非常有用。`kernel.map` 文件包含所有标签结束位置的一个映射，这对于跟踪值非常有用。
为安装你的操作系统，需要先有一个已经安装了树莓派操作系统的 SD 卡。如果你浏览 SD 卡中的文件，你应该能看到一个名为 `kernel.img` 的文件。将这个文件重命名为其它名字，比如 `kernel_linux.img`。然后，复制你编译的 `kernel.img` 文件到 SD 卡中原来的位置，这将用你的操作系统镜像文件替换现在的树莓派操作系统镜像。想切换回来时，只需要简单地删除你自己的 `kernel.img` 文件，然后将前面重命名的文件改回 `kernel.img` 即可。我发现，保留一个原始的树莓派操作系统的备份是非常有用的，万一你要用到它呢。
将这个 SD 卡插入到树莓派，并打开它的电源。这个 OK 的 LED 灯将亮起来。如果不是这样，请查看故障排除页面。如果一切如愿，恭喜你，你已经写出了你的第一个操作系统。[课程 2 OK02](https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/ok02.html) 将指导你让 LED 灯闪烁和关闭闪烁。
---
1. 是的，我说错了，它告诉的是链接器，它是另一个程序，用于将汇编器转换过的几个代码文件链接到一起。直接说是汇编器也没有大问题。 [↩](#fnref1)
2. 其实它们对你很重要。由于 GNU 工具链主要用于开发操作系统，它要求入口点必须是名为 `_start` 的地方。由于我们是开发一个操作系统，无论什么时候，它总是从 `_start` 开时的，而我们可以使用 `.section .init` 命令去设置它。因此，如果我们没有告诉它入口点在哪里，就会使工具链困惑而产生警告消息。所以，我们先定义一个名为 `_start` 的符号，它是所有人可见的（全局的），紧接着在下一行生成符号 `_start` 的地址。我们很快就讲到这个地址了。 [↩](#fnref2)
3. 本教程的设计减少了你阅读树莓派开发手册的难度，但是，如果你必须要阅读它，你可以在这里 [SoC-Peripherals.pdf](https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/downloads/SoC-Peripherals.pdf) 找到它。由于添加了混淆，手册中 GPIO 使用了不同的地址系统。我们的操作系统中的地址 0x20200000 对应到手册中是 0x7E200000。 [↩](#fnref3)
4. `mov` 能够加载的值只有前 8 位是 `1` 的二进制表示的值。换句话说就是一个 0 后面紧跟着 8 个 `1` 或 `0`。 [↩](#fnref4)
5. 一个很友好的硬件工程师是这样向我解释这个问题的： [↩](#fnref5)
原因是现在的芯片都是用一种称为 CMOS 的技术来制成的，它是互补金属氧化物半导体的简称。互补的意思是每个信号都连接到两个晶体管上，一个是使用 N 型半导体的材料制成，它用于将电压拉低，而另一个使用 P 型半导体材料制成，它用于将电压升高。在任何时刻，仅有一个半导体是打开的，否则将会短路。P 型材料的导电性能不如 N 型材料。这意味着三倍大的 P 型半导体材料才能提供与 N 型半导体材料相同的电流。这就是为什么 LED 总是通过降低为低电压来打开它，因为 N 型半导体拉低电压比 P 型半导体拉高电压的性能更强。
还有一个原因。早在上世纪七十年代，芯片完全是由 N 型材料制成的（NMOS），P 型材料部分使用了一个电阻来代替。这意味着当信号为低电压时，即便它什么事都没有做，芯片仍然在消耗能量（并发热）。你的电话装在口袋里什么事都不做，它仍然会发热并消耗你的电池电量，这不是好的设计。因此，信号设计成 “活动时低”，而不活动时为高电压，这样就不会消耗能源了。虽然我们现在已经不使用 NMOS 了，但由于 N 型材料的低电压信号比 P 型材料的高电压信号要快，所以仍然使用了这种设计。通常在一个 “活动时低” 信号名字上方会有一个条型标记，或者写作 `SIGNAL_n` 或 `/SIGNAL`。但是即便这样，仍然很让人困惑，那怕是硬件工程师，也不可避免这种困惑！
---
via: <https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/ok01.html>
作者：[Robert Mullins](http://www.cl.cam.ac.uk/%7Erdm34) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Flatpak 新手指南
|
Sk
|
https://www.ostechnix.com/flatpak-new-framework-desktop-applications-linux/
|
Flatpak 作为分发桌面应用的新框架可以让开发者完全摆脱这些负担。开发者只需构建一个 Flatpak app 就可以在多种发行版上安装使用。
|
/data/attachment/album/201901/20/113109d3443v33qv66vb4y.jpg.thumb.jpg
|
/data/attachment/album/201901/20/113109d3443v33qv66vb4y.jpg
| true | false | true |
lujun9972
|
wwhio
|
wxy
| false |
[
"Flatpak"
] |
技术
|
{
"viewnum": 13458,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Flatpak 作为分发桌面应用的新框架可以让开发者完全摆脱这些负担。开发者只需构建一个 Flatpak app 就可以在多种发行版上安装使用。
| 2019-01-20T11:31:08 | 2019-01-20T11:31:08 | 10,459 |
/article-10459-1.html
|
以前，我们介绍 Ubuntu 推出的 [Snaps](http://www.ostechnix.com/introduction-ubuntus-snap-packages/)。Snaps 是由 Canonical 公司为 Ubuntu 开发的，并随后移植到其他的 Linux 发行版，如 Arch、Gentoo、Fedora 等等。由于一个 snap 包中含有软件的二进制文件和其所需的所有依赖和库，所以可以在无视软件版本、在任意 Linux 发行版上安装软件。和 Snaps 类似，还有一个名为 Flatpak 的工具。也许你已经知道，为不同的 Linux 发行版打包并分发应用是一件多么费时又复杂的工作，因为不同的 Linux 发行版的库不同，库的版本也不同。现在，Flatpak 作为分发桌面应用的新框架可以让开发者完全摆脱这些负担。开发者只需构建一个 Flatpak app 就可以在多种发行版上安装使用。这真是又酷又棒！
用户也完全不用担心库和依赖的问题了，所有的东西都和 app 打包在了一起。更重要的是 Flatpak app 们都自带沙箱，而且与宿主操作系统的其他部分隔离。对了，Flatpak 还有一个很棒的特性，它允许用户在同一个系统中安装同一应用的多个版本，例如 VLC 播放器的 2.1 版、2.2 版、2.3 版。这使开发者测试同一个软件的多个版本变得更加方便。
在本文中，我们将指导你如何在 GNU/Linux 中安装 Flatpak。
### 安装 Flatpak
Flatpak 可以在大多数的主流 Linux 发行版上安装使用，如 Arch Linux、Debian、Fedora、Gentoo、Red Hat、Linux Mint、openSUSE、Solus、Mageia 还有 Ubuntu。
在 Arch Linux 上，使用这一条命令来安装 Flatpak：
```
$ sudo pacman -S flatpak
```
对于 Debian 用户，Flatpak 被收录进 Stretch 或之后版本的默认软件源中。要安装 Flatpak，直接执行：
```
$ sudo apt install flatpak
```
对于 Fedora 用户，Flatpak 是发行版默认安装的软件。你可以直接跳过这一步。
如果因为某种原因没有安装的话，可以执行：
```
$ sudo dnf install flatpak
```
对于 RHEL 7 用户，安装 Flatpak 的命令为：
```
$ sudo yum install flatpak
```
如果你在使用 Linux Mint 18.3，那么 Flatpat 也随系统默认安装，所以跳过这一步。
在 openSUSE Tumbleweed 中，使用 Zypper 包管理来安装 Flatpak：
```
$ sudo zypper install flatpak
```
而 Ubuntu 需要添加下面的软件源再安装 Flatpak，命令如下：
```
$ sudo add-apt-repository ppa:alexlarsson/flatpak
$ sudo apt update
$ sudo apt install flatpak
```
Gnome 提供了一个 Flatpak 插件，安装它就可以使用图形界面来安装 Flatpak app 了。插件的安装命令为：
```
$ sudo apt install gnome-software-plugin-flatpak
```
如果你是用发行版没有在上述的说明里，请你参考官方[安装指南](https://flatpak.org/setup/)。
### 开始使用 Flatpak
有不少流行应用都支持 Flatpak 安装，如 Gimp、Kdenlive、Steam、Spotify、Visual Sudio Code 等。
下面让我来一起学习 flatpak 的基本操作命令。
首先，我们需要添加远程仓库。
#### 添加软件仓库
**添加 Flathub 仓库：**
**Flathub** 是一个包含了几乎所有 flatpak 应用的仓库。运行这条命令来启用它：
```
$ sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
```
对于流行应用来说，Flathub 已经可以满足需求。如果你想试试 GNOME 应用的话，可以添加 GNOME 的仓库。
**添加 GNOME 仓库：**
GNOME 仓库包括了所有的 GNOME 核心应用，它提供了两种版本：<ruby> 稳定版 <rt> stable </rt></ruby>和<ruby> 每日构建版 <rt> nightly </rt></ruby>。
使用下面的命令来添加 GNOME 稳定版仓库：
```
$ wget https://sdk.gnome.org/keys/gnome-sdk.gpg
$ sudo flatpak remote-add --gpg-import=gnome-sdk.gpg --if-not-exists gnome-apps https://sdk.gnome.org/repo-apps/
```
需要注意的是，GNOME 稳定版仓库中的应用需要 **3.20 版本的 org.gnome.Platform 运行时环境**。
安装稳定版运行时环境，请执行：
```
$ sudo flatpak remote-add --gpg-import=gnome-sdk.gpg gnome https://sdk.gnome.org/repo/
```
如果想使用每日构建版的 GNOME 仓库，使用如下的命令：
```
$ wget https://sdk.gnome.org/nightly/keys/nightly.gpg
$ sudo flatpak remote-add --gpg-import=nightly.gpg --if-not-exists gnome-nightly-apps https://sdk.gnome.org/nightly/repo-apps/
```
同样，每日构建版的 GNOME 仓库也需要 **org.gnome.Platform 运行时环境的每日构建版本**。
执行下面的命令安装每日构建版的运行时环境：
```
$ sudo flatpak remote-add --gpg-import=nightly.gpg gnome-nightly https://sdk.gnome.org/nightly/repo/
```
#### 查看软件仓库
要查看已经添加的软件仓库，执行下面的命令：
```
$ flatpak remotes
Name Options
flathub system
gnome system
gnome-apps system
gnome-nightly system
gnome-nightly-apps system
```
如你所见，上述命令会列出你添加到系统中的软件仓库。此外，执行结果还表明了软件仓库的配置是<ruby> 用户级 <rt> per-user </rt></ruby>还是<ruby> 系统级 <rt> system-wide </rt></ruby>。
#### 删除软件仓库
要删除软件仓库，例如 flathub，用这条命令：
```
$ sudo flatpak remote-delete flathub
```
这里的 flathub 是软件仓库的名字。
#### 安装 Flatpak 应用
这一节，我们将学习如何安装 flatpak 应用。
要安装一个应用，只要一条命令就能完成：
```
$ sudo flatpak install flathub com.spotify.Client
```
所有的稳定版 GNOME 软件仓库中的应用，都使用“stable”作为版本名。
例如，想从稳定版 GNOME 软件仓库中安装稳定版 Evince，就执行：
```
$ sudo flatpak install gnome-apps org.gnome.Evince stable
```
所有的每日构建版 GNOME 仓库中的应用，都使用“master”作为版本名。
例如，要从每日构建版 GNOME 软件仓库中安装 gedit 的每次构建版本，就执行：
```
$ sudo flatpak install gnome-nightly-apps org.gnome.gedit master
```
如果不希望应用安装在<ruby> 系统级 <rt> system-wide </rt></ruby>，而只安装在<ruby> 用户级 <rt> per-user </rt></ruby>，那么你可以这样安装软件：
```
$ flatpak install --user <name-of-app>
```
所有的应用都会被存储在 `$HOME/.var/app/` 目录下.
```
$ ls $HOME/.var/app/
com.spotify.Client
```
#### 执行 Flatpak 应用
你可以直接使用<ruby> 应用启动器 <rt> application launcher </rt></ruby>来运行已安装的 Flatpak 应用。如果你想从命令行启动的话，以 Spotify 为例，执行下面的命令：
```
$ flatpak run com.spotify.Client
```
#### 列出已安装的 Flatpak 应用
要查看已安装的应用程序和运行时环境，执行：
```
$ flatpak list
```
想只查看已安装的应用，那就用这条命令：
```
$ flatpak list --app
```
如果想查询已添加的软件仓库中的可安装程序和可安装的运行时环境，使用命令：
```
$ flatpak remote-ls
```
只列出可安装的应用程序的命令是：
```
$ flatpak remote-ls --app
```
查询指定远程仓库中的所有可安装的应用程序和运行时环境，这里以 gnome-apps 为例，执行命令：
```
$ flatpak remote-ls gnome-apps
```
只列出可安装的应用程序，这里以 flathub 为例：
```
$ flatpak remote-ls flathub --app
```
#### 更新应用程序
更新所有的 Flatpak 应用程序，执行：
```
$ flatpak update
```
更新指定的 Flatpak 应用程序，执行：
```
$ flatpak update com.spotify.Client
```
#### 获取应用详情
执行下面的命令来查看已安装应用程序的详细信息：
```
$ flatpak info io.github.mmstick.FontFinder
```
输出样例：
```
Ref: app/io.github.mmstick.FontFinder/x86_64/stable
ID: io.github.mmstick.FontFinder
Arch: x86_64
Branch: stable
Origin: flathub
Date: 2018-04-11 15:10:31 +0000
Subject: Workaround appstream issues (391ef7f5)
Commit: 07164e84148c9fc8b0a2a263c8a468a5355b89061b43e32d95008fc5dc4988f4
Parent: dbff9150fce9fdfbc53d27e82965010805f16491ec7aa1aa76bf24ec1882d683
Location: /var/lib/flatpak/app/io.github.mmstick.FontFinder/x86_64/stable/07164e84148c9fc8b0a2a263c8a468a5355b89061b43e32d95008fc5dc4988f4
Installed size: 2.5 MB
Runtime: org.gnome.Platform/x86_64/3.28
```
#### 删除应用程序
要删除一个 Flatpak 应用程序，这里以 spotify 为例，执行：
```
$ sudo flatpak uninstall com.spotify.Client
```
如果你需要更多信息，可以参考 Flatpak 的帮助。
```
$ flatpak --help
```
到此，希望你对 Flatpak 有了一些基础了解。
如果你觉得这篇指南有些帮助，请在你的社交媒体上分享它来支持我们。
稍后还有更多精彩内容，敬请期待~
---
via: <https://www.ostechnix.com/flatpak-new-framework-desktop-applications-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wwhio](https://github.com/wwhio) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
理解 Linux 中的 /etc/services 文件
|
Kerneltalks
|
https://kerneltalks.com/linux/understanding-etc-services-file-in-linux/
|
这篇文章将帮助你了解 Linux 中 /etc/services 文件，包括它的内容，格式以及重要性。
|
/data/attachment/album/201901/20/121500zzzcic6ikkz4m7fc.jpg.thumb.jpg
|
/data/attachment/album/201901/20/121500zzzcic6ikkz4m7fc.jpg
| true | false | true |
lujun9972
|
MjSeven
|
wxy
| false |
[
"inetd",
"services"
] |
技术
|
{
"viewnum": 12897,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
这篇文章将帮助你了解 Linux 中 /etc/services 文件，包括它的内容，格式以及重要性。
| 2019-01-20T12:16:00 | 2019-01-20T12:16:00 | 10,460 |
/article-10460-1.html
|
这篇文章将帮助你了解 Linux 中 `/etc/services` 文件，包括它的内容，格式以及重要性。
Internet 守护程序（`ineted`）是 Linux 世界中的重要服务。它借助 `/etc/services` 文件来处理所有网络服务。在本文中，我们将向你介绍这个文件的内容，格式以及它对于 Linux 系统的意义。
`/etc/services` 文件包含网络服务和它们映射端口的列表。`inetd` 或 `xinetd` 会查看这些细节，以便在数据包到达各自的端口或服务有需求时，它会调用特定的程序。
作为普通用户，你可以查看此文件，因为文件一般都是可读的。要编辑此文件，你需要有 root 权限。
```
$ ll /etc/services
-rw-r--r--. 1 root root 670293 Jun 7 2013 /etc/services
```
### /etc/services 文件格式
```
service-name port/protocol [aliases..] [#comment]
```
最后两个字段是可选的，因此用 `[` `]` 表示。
其中：
* `service-name` 是网络服务的名称。例如 [telnet](https://kerneltalks.com/config/configure-telnet-server-linux/)、[ftp](https://kerneltalks.com/config/ftp-server-configuration-steps-rhel-6/) 等。
* `port/protocol` 是网络服务使用的端口（一个数值）和服务通信使用的协议（TCP/UDP）。
* `alias` 是服务的别名。
* `comment` 是你可以添加到服务的注释或说明。以 `#` 标记开头。
### /etc/services 文件示例
```
# 每行描述一个服务，形式如下：
#
# service-name port/protocol [aliases ...] [# comment]
tcpmux 1/tcp # TCP port service multiplexer
rje 5/tcp # Remote Job Entry
echo 7/udp
discard 9/udp sink null
```
在这里，你可以看到可选的最后两个字段的用处。`discard` 服务的别名为 `sink` 或 `null`。
---
via: <https://kerneltalks.com/linux/understanding-etc-services-file-in-linux/>
作者：[kerneltalks](https://kerneltalks.com) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Caffeinated 6.828：实验 7：最终的 JOS 项目
|
Csail.mit
|
https://pdos.csail.mit.edu/6.828/2018/labs/lab7/
|
下面是一个启迪你的想法列表。但是，你应该大胆地去实现你自己的想法。其中一些想法只是一个开端，并且本身不在实验 6 的领域内，并且其它的可能是在更大的领域中。
|
/data/attachment/album/201901/20/205649f6e69119bzw7wo7r.jpg.thumb.jpg
|
/data/attachment/album/201901/20/205649f6e69119bzw7wo7r.jpg
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"6.828"
] |
技术
|
{
"viewnum": 4869,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10452,
"displayorder": 0
}
] |
下面是一个启迪你的想法列表。但是，你应该大胆地去实现你自己的想法。其中一些想法只是一个开端，并且本身不在实验 6 的领域内，并且其它的可能是在更大的领域中。
| 2019-01-20T20:57:00 | 2019-01-20T20:57:00 | 10,461 |
/article-10461-1.html
|
### 简介
对于最后的项目，你有两个选择：
* 继续使用你自己的 JOS 内核并做 [实验 6](https://pdos.csail.mit.edu/6.828/2018/labs/lab6/index.html)，包括实验 6 中的一个挑战问题。（你可以随意地、以任何有趣的方式去扩展实验 6 或者 JOS 的任何部分，当然了，这不是课程规定的。）
* 在一个、二个或三个人组成的团队中，你选择去做一个涉及了你的 JOS 的项目。这个项目必须是涉及到与实验 6 相同或更大的领域（如果你是团队中的一员）。
目标是为了获得乐趣或探索更高级的 O/S 的话题；你不需要做最新的研究。
如果你做了你自己的项目，我们将根据你的工作量有多少、你的设计有多优雅、你的解释有多高明、以及你的解决方案多么有趣或多有创意来为你打分。我们知道时间有限，因此也不期望你能在本学期结束之前重写 Linux。要确保你的目标是合理的；合理地设定一个绝对可以实现的最小目标（即：控制你的实验 6 的规模），如果进展顺利，可以设定一个更大的目标。
如果你做了实验 6，我们将根据你是否通过了测试和挑战练习来为你打分。
### 交付期限
>
> 11 月 3 日：Piazza 讨论和 1、2、或 3 年级组选择（根据你的最终选择来定）。使用在 Piazza 上的 lab7 标记/目录。在 Piazza 上的文章评论区与其它人计论想法。使用这些文章帮你去找到有类似想法的其它学生一起组建一个小组。课程的教学人员将在 Piazza 上为你的项目想法给出反馈；如果你想得到更详细的反馈，可以与我们单独讨论。
>
>
>
.
>
> 11 月 9 日：在 [提交网站](https://6828.scripts.mit.edu/2018/handin.py/) 上提交一个提议，只需要一到两个段落就可以。提议要包括你的小组成员列表、你的计划、以及明确的设计和实现打算。（如果你做实验 6，就不用做这个了）
>
>
>
.
>
> 12 月 7 日：和你的简短报告一起提交源代码。将你的报告放在与名为 “README.pdf” 的文件相同的目录下。由于你只是这个实验任务小组中的一员，你可能需要去使用 git 在小组成员之间共享你的项目代码。因此你需要去决定哪些源代码将作为你的小组项目的共享起始点。一定要为你的最终项目去创建一个分支，并且命名为 `lab7`。（如果你做了实验 6，就按实验 6 的提交要求做即可。）
>
>
>
.
>
> 12 月 11 日这一周：简短的课堂演示。为你的 JOS 项目准备一个简短的课堂演示。为了你的项目演示，我们将提供一个投影仪。根据小组数量和每个小组选择的项目类型，我们可能会限制总的演讲数，并且有些小组可能最终没有机会上台演示。
>
>
>
.
>
> 12 月 11 日这一周：助教们验收。向助教演示你的项目，因此我们可能会提问一些问题，去了解你所做的一些细节。
>
>
>
### 项目想法
如果你不做实验 6，下面是一个启迪你的想法列表。但是，你应该大胆地去实现你自己的想法。其中一些想法只是一个开端，并且本身不在实验 6 的领域内，并且其它的可能是在更大的领域中。
* 使用 [x86 虚拟机支持](http://www.intel.com/technology/itj/2006/v10i3/1-hardware/3-software.htm) 去构建一个能够运行多个访客系统（比如，多个 JOS 实例）的虚拟机监视器。
* 使用 Intel SGX 硬件保护机制做一些有用的事情。[这是使用 Intel SGX 的最新的论文](https://www.usenix.org/system/files/conference/osdi14/osdi14-paper-baumann.pdf)。
* 让 JOS 文件系统支持写入、文件创建、为持久性使用日志、等等。或许你可以从 Linux EXT3 上找到一些启示。
* 从 [软更新](http://www.ece.cmu.edu/%7Eganger/papers/osdi94.pdf)、[WAFL](https://ng.gnunet.org/sites/default/files/10.1.1.40.3691.pdf)、ZFS、或其它较高级的文件系统上找到一些使用文件系统的想法。
* 给一个文件系统添加快照功能，以便于用户能够查看过去的多个时间点上的文件系统。为了降低空间使用量，你或许要使用一些写时复制技术。
* 使用分页去提供实时共享的内存，来构建一个 [分布式的共享内存](http://www.cdf.toronto.edu/%7Ecsc469h/fall/handouts/nitzberg91.pdf)（DSM）系统，以便于你在一个机器集群上运行多线程的共享内存的并行程序。当一个线程尝试去访问位于另外一个机器上的页时，页故障将给 DSM 系统提供一个机会，让它基于网络去从当前存储这个页的任意一台机器上获取这个页。
* 允许进程在机器之间基于网络进行迁移。你将需要做一些关于一个进程状态的多个片段方面的事情，但是由于在 JOS 中许多状态是在用户空间中，它或许从 Linux 上的进程迁移要容易一些。
* 在 JOS 中实现 [分页](http://en.wikipedia.org/wiki/Paging) 到磁盘，这样那个进程使用的内存就可以大于真实的内存。使用交换空间去扩展你的内存。
* 为 JOS 实现文件的 [mmap()](http://en.wikipedia.org/wiki/Mmap)。
* 使用 [xfi](http://static.usenix.org/event/osdi06/tech/erlingsson.html) 将一个进程的代码沙箱化。
* 支持 x86 的 [2MB 或 4MB 的页大小](http://en.wikipedia.org/wiki/Page_(computer_memory))。
* 修改 JOS 让内核支持进程内的线程。从查看 [课堂上的 uthread 任务](http://pdos.csail.mit.edu/6.828/2018/homework/xv6-uthread.html) 去开始。实现调度器触发将是实现这个项目的一种方式。
* 在 JOS 的内核中或文件系统中（实现多线程之后），使用细粒度锁或无锁并发。Linux 内核使用 [读复制更新](http://en.wikipedia.org/wiki/Read-copy-update) 去执行无需上锁的读取操作。通过在 JOS 中实现它来探索 RCU，并使用它去支持无锁读取的名称缓存。
* 实现 [外内核论文](http://pdos.csail.mit.edu/6.828/2018/readings/engler95exokernel.pdf) 中的想法。例如包过滤器。
* 使 JOS 拥有软实时行为。用它来辨识一些应用程序时非常有用。
* 使 JOS 运行在 64 位 CPU 上。这包括重设计虚拟内存让它使用 4 级页表。有关这方面的文档，请查看 [参考页](http://pdos.csail.mit.edu/6.828/2018/reference.html)。
* 移植 JOS 到一个不同的微处理器。这个 [osdev wiki](http://wiki.osdev.org/Main_Page) 或许对你有帮助。
* 为 JOS 系统增加一个“窗口”系统，包括图形驱动和鼠标。有关这方面的文档，请查看 [参考页](http://pdos.csail.mit.edu/6.828/2018/reference.html)。[sqrt(x)](http://web.mit.edu/amdragon/www/pubs/sqrtx-6.828.html) 就是一个 JOS “窗口” 系统的示例。
* 在 JOS 中实现 [dune](https://www.usenix.org/system/files/conference/osdi12/osdi12-final-117.pdf)，以提供特权硬件指令给用户空间应用程序。
* 写一个用户级调试器，添加类似跟踪的功能；硬件寄存器概要（即：Oprofile）；调用跟踪等等。
* 为（静态的）Linux 可运行程序做一个二进制仿真。
---
via: <https://pdos.csail.mit.edu/6.828/2018/labs/lab7/>
作者：[csail.mit](https://pdos.csail.mit.edu) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
4 个值得一提的 Firefox 扩展插件
|
Zsolt Szakács
|
https://opensource.com/article/18/6/firefox-open-source-extensions
|
这些扩展可以使火狐更具生产力和使用乐趣。
|
/data/attachment/album/201901/21/110914kg7g1y78b6z6sk2t.jpg.thumb.jpg
|
/data/attachment/album/201901/21/110914kg7g1y78b6z6sk2t.jpg
| true | false | true |
lujun9972
|
lixinyuxx
|
wxy
| false |
[
"Firefox",
"扩展",
"插件"
] |
分享
|
{
"viewnum": 14109,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "218.252.97.112",
"message": "使用拼音输入法过滤连接提示<br />\r\n<br />\r\n给三指加上拼音输入过滤。当 hinting 的时候，输入中文文字的拼音首键，可以过滤相应的中文连接和英文连接。<br />\r\n<br />\r\nmozbugbox/tridactyl<br />\r\nforked from tridactyl/tridactyl",
"username": "来自香港的 Firefox 68.0|GNU/Linux 用户",
"date": "2020-02-05T00:41:47"
}
] |
[] |
这些扩展可以使火狐更具生产力和使用乐趣。
| 2019-01-21T11:09:09 | 2019-01-21T11:09:09 | 10,462 |
/article-10462-1.html
|
>
> 这些扩展可以使火狐更具生产力和使用乐趣。
>
>
>
自从大约 12 年前 Firefox（火狐浏览器）v2.0 推出以来, 我一直是它的用户。它不是那时最好的网络浏览器，但是总会有一个理由让我回到它：我最喜爱的浏览器扩展插件不能工作在其它浏览器上。
如今，我喜欢现下的 Firefox，因为它快速、可定制和开源，我也很欣赏那些体现了原开发人员从未想到过的想法的扩展插件：如果你想在没有鼠标的情况下浏览网页呢？如果你不喜欢盯着晚上从显示器里发出来的强光呢？如何在 YouTube 和其他视频托管网站上使用一个更专业的播放器来获得更好的性能和更多播放控制呢？如果你需要更复杂的方法来禁用跟踪器和加快加载页面，该怎么办？
幸运的是，这些问题都有答案，我将展现给你我最喜爱的扩展 —— 所有这些都是免费软件或开源的 (即，在 [GNU GPL](https://www.gnu.org/licenses/gpl-3.0.en.html)、[MPL](https://www.mozilla.org/en-US/MPL/) 或 [Apache](https://www.apache.org/licenses/LICENSE-2.0) 许可帧下) ，它们可以使一个优秀的浏览器更优秀。
尽管术语<ruby> 加载项 <rt> add-on </rt></ruby>和<ruby> 扩展 <rt> extension </rt></ruby>的含义稍微不同，但我在本文中的使用不会区分它们。
### Tridactyl
*Tridactyl 的新选项卡页面，展示了链接的指引。*
[Tridactyl](https://addons.mozilla.org/en-US/firefox/addon/tridactyl-vim/) 使你能够在大多数浏览活动中使用键盘。它的灵感来自于现已不复存在的 [Vimperator](https://github.com/vimperator/vimperator-labs) 和 [Pentadactyl](https://addons.mozilla.org/en-US/firefox/addon/pentadactyl/)，而它们受到了 [Vim](https://www.vim.org/) 的默认键绑定的启发。由于我已经习惯了 Vim 和其他命令行应用程序，我发现了它的功能类似于使用键值 `h/j/k/l` 进行导航，用 `f/F` 可以与超链接进行交互，而且创建自定义的键绑定和命令非常方便。
Tridactyl 最近刚刚实现了一个可选的本地信使（目前，仅适用于 GNU/Linux 和 Mac OSX），提供了更酷的功能。例如，有了它，你可以隐藏 Firefox 用户界面上的一些元素（以 Vimperator 和 Pentadactyl 的方式）、在外部程序中打开链接或当前页（我经常用 [mpv](https://mpv.io/) 和 [youtube-dl](https://rg3.github.io/youtube-dl/index.html) 播放视频）、通过按 `Ctrl-I`（或者任意你选择的组合键）用你喜爱的编辑器来编辑文本框的内容。
话虽如此，但要记住，这是一个相对早期的项目，细节可能还是很粗糙。另一方面，它的开发非常活跃，当你回顾它早期的缺陷时，未尝不是一种乐趣。
### Open With
*Open With 提供的菜单。我可以用这里列出的一个外部程序打开当前页面。*
说到与外部程序的互动，有时能够用鼠标来做到这一点还是让人很高兴的。这是 [Open With](https://addons.mozilla.org/en-US/firefox/addon/open-with/) 的用武之地。
除了添加的上下文菜单（如屏幕截图所示）之外，你还可以通过单击加载项栏上的扩展图标来找到自己定义的命令。如[它在 Mozilla Add-ons 页面上](https://addons.mozilla.org/en-US/firefox/addon/open-with/) 的图标和描述所示，它主要是为了切换到其它的 web 浏览器，但我也可以轻松地将它与 mpv 和 youtube-dl 相配合。
它也提供了键盘快捷方式，但它们受到了严重限制。可以在扩展设置的下拉列表中选择的组合不超过三种。相反，Tridactyl 允许我将命令分配给几乎任何没有被 Firefox 所阻止的东西。没错，Open With 目前为鼠标而准备的。
### Stylus
*在这个屏幕截图中，我刚刚搜索并为当前正在浏览的 Stylus 的网站安装了一个黑暗主题。即使是弹出窗口也可以定制风格（称为 Deepdark Stylus）！*
[Stylus](https://addons.mozilla.org/en-US/firefox/addon/styl-us/) 是一个用户样式管理器，这意味着可以通过编写自定义 CSS 规则并将其加载到 Stylus 中来更改任何网页的外观。如果你不懂 CSS，在如 [userstyles.org](https://userstyles.org/) 这样网站上有大量的其他人制作的样式。
现在，你可能会问，“这不就是 [Stylish](https://addons.mozilla.org/en-US/firefox/addon/stylish/) 么？” 你是对的！Stylus 是基于 Stylish 的，并提供了更多的改进：它不包含任何远程记录、尊重你的隐私，所有开发都是公开的（尽管 Stylish 仍在积极开发，我一直未能找到最新版本的源代码），而且它还支持 [UserCSS](https://github.com/openstyles/stylus/wiki/Usercss)。
UserCSS 是一种有趣的格式，尤其是对于开发人员来说。我已经为不同的网站写了几种用户样式（主要是黑暗主题，和为了提高可读性的调整），虽然 Stylus 的内部编辑器很好，我还是喜欢用 Neovim 编辑代码。为了做到这样我所需要做的就是用 “.user.css” 作为本地加载文件的后缀名，在 Stylus 里启动 “Live Reload” 选项，只要我在 Neovim 中保存文件就会应用所有的更改。它也支持远程 UserCSS 文件，因此，每当我将更改推送到 GitHub 或任何基于 git 的开发平台时，它们将自动对用户可用。（我提供了指向该文件的原始版本的链接，以便他们可以轻松地访问它。）
### uMatrix
*uMatrix 的用户界面，显示当前访问过的网页的当前规则。*
Jeremy Garcia 在他发表在 Opensource.com 的[文章](https://opensource.com/article/18/5/firefox-extensions)中提到了一个优秀的拦截器 uBlock Origin。我想提请大家关注另一个由 [gorhill](https://addons.mozilla.org/en-US/firefox/user/gorhill/) 开发的扩展插件: uMatrix 。
[uMatrix](https://addons.mozilla.org/en-US/firefox/addon/umatrix) 允许你为网页上的某些请求设置拦截规则，可以通过点击该加载项的弹出窗口来切换（在上面的屏幕截图中可以看到）。这些请求的区别在于脚本的类别、脚本发起的请求、cookies、CSS 规则、图像、媒体、帧，和被 uMatrix 标记为“other” 的其它内容。例如，你可以设置全局规则，以便在默认情况下允许所有请求，并将特定的请求添加到黑名单中（更方便的方法），或在默认情况下阻止所有内容，并手动将某些请求列入白名单（更安全的方法）。如果你一直在使用 NoScript 或 RequestPolicy，你可以从它们 [导入](https://github.com/gorhill/uMatrix/wiki/FAQ) 你的白名单规则。
另外 uMatrix 支持 [hosts 文件](https://en.wikipedia.org/wiki/Hosts_(file))，可用于阻止来自某些域的请求。不要与 uBlock Origin 所使用的筛选列表混淆，它使用的语法同 Adblock Plus 一样。默认情况下，uMatrix 会通过几个 hosts 文件阻止已知的分发广告、跟踪器和恶意软件的服务器，如果需要，你可以添加更多外部数据源。
那么你将选择哪一个：uBlock Origin 或 uMatrix ？就个人而言，我在电脑上两个都用，而只在安卓手机上用 uMatrix 。[据 gorhill 所说](https://github.com/gorhill/uMatrix/issues/32#issuecomment-61372436)，两者之间存在某种重叠，但它们有不同的目标用户和目地。如果你想要的只是阻止跟踪器和广告的简单方法，uBlock Origine 是更好的选择；另一方面，如果你希望对网页在浏览器中可以执行或不能执行的操作进行精细的控制，即使需要一些时间来进行配置，并且可能会阻止某些网站如预期的工作，uMatrix 也是更好的选择。
### 结论
目前，这些是 Firefox 里我最喜欢的扩展。Tridactyl 通过依靠键盘和与外部程序交互，加快了浏览导航速度；Open With 能让我用鼠标在另外一个程序中打开页面；Stylus 是全面的用户样式管理器，对用户和开发人员都很有吸引力；uMatrix 本质上是 Firefox 的防火墙，可以用于过滤未知的请求。
尽管我基本上只是讨论了这些加载项的好处，但没有一个软件是完美的。如果你喜欢它们中的任何一个，并认为它们的某些方面可以改进，我建议你去它们的 Github 页面，并查看它们的贡献指南。通常情况下，自由开源软件的开发人员是欢迎错误报告和提交请求的。告诉你的朋友或道谢也是帮助开发者的好方法，特别是如果这些开发者是在业余时间从事他们的项目的话。
---
via: <https://opensource.com/article/18/6/firefox-open-source-extensions>
作者：[Zsolt Szakács](https://opensource.com/users/zsolt) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lixinyuxx](https://github.com/lixinyuxx) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
红宝石（Ruby）史话
|
Two-bit History
|
https://twobithistory.org/2017/11/19/the-ruby-story.html
|
尽管我很难说清楚为什么，但 Ruby 一直是我最喜爱的一门编程语言。
|
/data/attachment/album/201901/21/113443k7kzkkmmi17o9hmb.jpg.thumb.jpg
|
/data/attachment/album/201901/21/113443k7kzkkmmi17o9hmb.jpg
| true | false | true |
lujun9972
|
wwhio
|
wxy
| true |
[
"Ruby",
"Rails",
"RoR"
] |
观点
|
{
"viewnum": 5936,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
尽管我很难说清楚为什么，但 Ruby 一直是我最喜爱的一门编程语言。
| 2019-01-21T11:35:00 | 2019-01-21T11:35:00 | 10,463 |
/article-10463-1.html
|
尽管我很难说清楚为什么，但 Ruby 一直是我最喜爱的一门编程语言。如果用音乐来类比的话，Python 给我的感觉像是<ruby> 朋克摇滚 <rt> punk rock </rt></ruby>，简单、直接，但略显单调，而 Ruby 则像是爵士乐，从根本上赋予了程序员表达自我的自由，虽然这可能会让代码变复杂，编写出来的程序对其他人来说不直观。
Ruby 社区一直将<ruby> 灵活表达 <rt> freedom of expression </rt></ruby>视为其核心价值。可我不认同这对于 Ruby 的开发和普及是最重要的。创建一门编程语言也许是为了更高的性能，也许是为了在抽象上节省更多的时间，可 Ruby 就有趣在它并不关心这些，从它诞生之初，它的目标就是让程序员更快乐。
### 松本·行弘
<ruby> 松本·行弘 <rt> Yukihiro Matsumoto </rt></ruby>，亦称为 “Matz”，于 1990 年毕业于筑波大学。筑波是东京东北方向上的一个小城市，是科学研究与技术开发的中心之一。筑波大学以其 STEM 计划广为流传。松本·行弘在筑波大学的信息科学专业学习过，且专攻编程语言。他也在 Ikuo Nakata 的编程语言实验室工作过。（LCTT 译注：STEM 是<ruby> 科学 <rt> Science </rt></ruby>、<ruby> 技术 <rt> Technology </rt></ruby>、<ruby> 工程 <rt> Engineering </rt></ruby>、<ruby> 数学 <rt> Mathematics </rt></ruby>四门学科英文首字母的缩写。）
松本从 1993 年开始制作 Ruby，那时他才刚毕业几年。他制作 Ruby 的起因是觉得那时的脚本语言缺乏一些特性。他在使用 Perl 的时候觉得这门语言过于“玩具”，此外 Python 也有点弱，用他自己的话说：
>
> 我那时就知道 Python 了，但我不喜欢它，因为我认为它不是一门真正的面向对象的语言。面向对象就像是 Python 的一个附件。作为一个编程语言狂热者，我在 15 年里一直是面向对象的忠实粉丝。我真的想要一门生来就面向对象而且易用的脚本语言。我为此特地寻找过，可事实并不如愿。<sup id="fnref1"> <a href="#fn1" rel="footnote"> 1 </a></sup>
>
>
>
所以一种解释松本创造 Ruby 的动机就是他想要创造一门更好，且面向对象的 Perl。
但在其他场合，松本说他创造 Ruby 主要是为了让他自己和别人更快乐。2008 年，松本在谷歌技术讲座结束时放映了这张幻灯片：
他对听众说到，
>
> 我希望 Ruby 能帮助世界上的每一个程序员更有效率地工作，享受编程并感到快乐。这也是制作 Ruby 语言的主要意图。<sup id="fnref2"> <a href="#fn2" rel="footnote"> 2 </a></sup>
>
>
>
松本开玩笑的说他制作 Ruby 的原因很自私，因为他觉得其它的语言乏味，所以需要创造一点让自己开心的东西。
这张幻灯片展现了松本谦虚的一面。其实，松本是一位摩门教践行者，因此我很好奇他传奇般的友善有多少归功于他的宗教信仰。无论如何，他的友善在 Ruby 社区广为流传，甚至有一条称为 MINASWAN 的原则，即“<ruby> 松本人很好，我们也一样 <rt> Matz Is Nice And So We Are Nice </rt></ruby>”。我想那张幻灯片一定震惊了来自 Google 的观众。我想谷歌技术讲座上的每张幻灯片都充满着代码和运行效率的指标，来说明一个方案比另一个更快更有效，可仅仅放映崇高的目标的幻灯片却寥寥无几。
Ruby 主要受到 Perl 的影响。Perl 则是由 Larry Wall 于 20 世纪 80 年代晚期创造的语言，主要用于处理和转换基于文本的数据。Perl 因其文本处理和正则表达式而闻名于世。对于 Ruby 程序员，Perl 程序中的很多语法元素都不陌生，例如符号 `$`、符号 `@`、`elsif` 等等。虽然我觉得，这些不是 Ruby 应该具有的特征。除了这些符号外，Ruby 还借鉴了 Perl 中的正则表达式的处理和标准库。
但影响了 Ruby 的不仅仅只有 Perl 。在 Ruby 之前，松本制作过一个仅用 Emacs Lisp 编写的邮件客户端。这一经历让他对 Emacs 和 Lisp 语言运行的内部原理有了更多的认识。松本说 Ruby 底层的对象模型也受其启发。在那之上，松本添加了一个 Smalltalk 风格的信息传递系统，这一系统随后成为了 Ruby 中任何依赖 `#method_missing` 的操作的基石。松本也表示过 Ada 和 Eiffel 也影响了 Ruby 的设计。
当时间来到了给这门新语言命名的时候，松本和他的同事 Keiju Ishitsuka 挑选了很多个名字。他们希望名字能够体现新语言和 Perl、shell 脚本间的联系。在[这一段非常值得一读的即时消息记录](http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/88819)中，Ishitsuka 和 松本也许花了太多的时间来思考 <ruby> shell <rt> 贝壳 </rt></ruby>、<ruby> clam <rt> 蛤蛎 </rt></ruby>、<ruby> oyster <rt> 牡蛎 </rt></ruby>和<ruby> pearl <rt> 珍珠 </rt></ruby>之间的关系了，以至于差点把 Ruby 命名为“<ruby> Coral <rt> 珊瑚虫 </rt></ruby>”或“<ruby> Bisque <rt> 贝类浓汤 </rt></ruby>”。幸好，他们决定使用 Ruby，因为它就像 pearl 一样，是一种珍贵的宝石。此外，<ruby> Ruby <rt> 红宝石 </rt></ruby> 还是 7 月的生辰石，而 <ruby> Pearl <rt> 珍珠 </rt></ruby> 则是 6 月的生辰石，采用了类似 C++ 和 C# 的隐喻，暗示着她们是改进自前辈的编程语言。（LCTT 译注：Perl 和 Pearl 发音相同，所以也常以“珍珠”来借喻 Perl；shell 是操作系统提供的用户界面，这里指的是命令行界面；更多有关生辰石的[信息](https://zh.wikipedia.org/zh-hans/%E8%AA%95%E7%94%9F%E7%9F%B3)。）
### Ruby 西渐
Ruby 在日本的普及很快。1995 年 Ruby 刚刚发布后不久后，松本就被一家名为 Netlab 的日本软件咨询财团（全名 Network Applied Communication Laboratory）雇用，并全职为 Ruby 工作。到 2000 年时，在 Ruby 发布仅仅 5 年后，Ruby 在日本的流行度就超过了 Python。可这时的 Ruby 才刚刚进入英语国家。虽然从 Ruby 的诞生之初就存在讨论它的日语邮件列表，但是英语的邮件列表直到 1998 年才建立起来。起初，在英语的邮件列表中交流的大多是日本的 Ruby 狂热者，可随着 Ruby 在西方的逐渐普及而得以改变。
在 2000 年，Dave Thomas 出版了第一本涵盖 Ruby 的英文书籍《Programming Ruby》。因为它的封面上画着一把锄头，所以这本书也被称为锄头书。这是第一次向身处西方的程序员们介绍了 Ruby。就像在日本那样，Ruby 的普及很快，到 2002 年时，英语的 Ruby 邮件列表的通信量就超过了日语邮件列表。
时间来到了 2005 年，Ruby 更流行了，但它仍然不是主流的编程语言。然而，Ruby on Rails 的发布让一切都不一样了。Ruby on Rails 是 Ruby 的“杀手级应用”，没有别的什么项目能比它更推动 Ruby 的普及了。在 Ruby on Rails 发布后，人们对 Ruby 的兴趣爆发式的增长，看看 TIOBE 监测的语言排行：
有时人们开玩笑的说，Ruby 程序全是基于 Ruby-on-Rails 的网站。虽然这听起来就像是 Ruby on Rails 占领了整个 Ruby 社区，但在一定程度上，这是事实。因为编写 Rails 应用时使用的语言正是 Ruby。Rails 欠 Ruby 的和 Ruby 欠 Rails 的一样多。
Ruby 的设计哲学也深深地影响了 Rails 的设计与开发。Rails 之父 David Heinemeier Hansson 常常提起他第一次与 Ruby 的接触的情形，那简直就是一次传教。他说，那种经历简直太有感召力了，让他感受到要为松本的杰作（指 Ruby）“传教”的使命。<sup id="fnref3"> <a href="#fn3" rel="footnote"> 3 </a></sup> 对于 Hansson 来说，Ruby 的灵活性简直就是对 Python 或 Java 语言中自上而下的设计哲学的反抗。他很欣赏 Ruby 这门能够信任自己的语言，Ruby 赋予了他自由选择<ruby> 程序表达方式 <rt> express his programs </rt></ruby>的权力。
就像松本那样，Hansson 声称他创造 Rails 时因为对现状的不满并想让自己能更开心。他也认同让程序员更快乐高于一切的观点，所以检验 Rails 是否需要添加一项新特性的标准是“<ruby> 更灿烂的笑容标准 <rt> The Principle of The Bigger Smile </rt></ruby>”。什么功能能让 Hansson 更开心就给 Rails 添加什么。因此，Rails 中包括了很多非正统的功能，例如 “Inflector” 类和 `Time` 扩展（“Inflector”类试图将单个类的名字映射到多个数据库表的名字；`Time` 扩展允许程序员使用 `2.days.ago` 这样的表达式）。可能会有人觉得这些功能太奇怪了，但 Rails 的成功表明它的确能让很多人的生活得更快乐。
因此，虽然 Rails 的火热带动了 Ruby 的普及看起来是一个偶然，但事实上 Rails 体现了 Ruby 的很多核心准则。此外，很难看到使用其他语言开发的 Rails，正是因为 Rails 的实现依赖于 Ruby 中<ruby> 类似于宏的类方法调用 <rt> macro-like class method calls </rt></ruby>来实现模型关联这样的功能。一些人认为这么多的 Ruby 开发需要基于 Ruby on Rails 是 Ruby 生态不健康的表现，但 Ruby 和 Ruby on Rails 结合的如此紧密并不是没有道理的。
### Ruby 之未来
人们似乎对 Ruby（及 Ruby on Rails）是否正在消亡有着异常的兴趣。早在 2011 年，Stack Overflow 和 Quora 上就充斥着程序员在咨询“如果几年后不再使用 Ruby 那么现在是否有必要学它”的话题。这些担忧对 Ruby 并非没有道理，根据 TIOBE 指数和 Stack Overflow 趋势，Ruby 和 Ruby on Rails 的人气一直在萎缩，虽然它也曾是热门新事物，但在更新更热的框架面前它已经黯然失色。
一种解释这种趋势的理论是程序员们正在舍弃动态类型的语言转而选择静态类型的。TIOBE 指数的趋势中可以看出对软件质量的需求在上升，这意味着出现在运行时的异常变得难以接受。他们引用 TypeScript 来说明这一趋势，TypeScript 是 JavaScript 的全新版本，而创造它的目的正是为了保证客户端运行的代码能受益于编译所提供的安全保障。
我认为另一个更可能的原因是比起 Ruby on Rails 推出的时候，现在存在着更多有竞争力的框架。2005 年它刚刚发布的时候，还没有那么多用于创建 Web 程序的框架，其主要的替代者还是 Java。可在今天，你可以使用为 Go、Javascript 或者 Python 开发的各种优秀的框架，而这还仅仅是主流的选择。Web 的世界似乎正走向更加分布式的结构，与其使用一块代码来完成从数据库读取到页面渲染所有事务，不如将事务拆分到多个组件，其中每个组件专注于一项事务并将其做到最好。在这种趋势下，Rails 相较于那些专攻于 JavaScript 前端通信的 JSON API 就显得过于宽泛和臃肿。
总而言之，我们有理由对 Ruby 的未来持乐观态度。因为不管是 Ruby 还是 Rails 的开发都还很活跃。松本和其他的贡献者们都在努力开发 Ruby 的第三个主要版本。新的版本将比现在的版本快上 3 倍，以减轻制约着 Ruby 发展的性能问题。虽然从 2005 年起，越来越多的 Web 框架被开发出来，但这并不意味着 Ruby on Rails 就失去了其生存空间。Rails 是一个富有大量功能的成熟的工具，对于一些特定类型的应用开发一直是非常好的选择。
但就算 Ruby 和 Rails 走上了消亡的道路，Ruby 让程序员更快乐的信条一定会存活下来。Ruby 已经深远的影响了许多新的编程语言的设计，这些语言的设计中能够看到来自 Ruby 的很多理念。而其他的新生语言则试着变成 Ruby 更现代的实现，例如 Elixir 是一个强调函数式编程范例的语言，仍在开发中的 Crystal 目标是成为使用静态类型的 Ruby 。世界上许多程序员都喜欢上了 Ruby 及其语法，因此它的影响必将会在未来持续很长一段时间。
喜欢这篇文章吗？这里每两周都会发表一篇这样的文章。请在推特上关注我们 [@TwoBitHistory](https://twitter.com/TwoBitHistory) 或者订阅我们的 [RSS](https://twobithistory.org/feed.xml)，这样新文章发布的第一时间你就能得到通知。
---
1. <http://ruby-doc.org/docs/ruby-doc-bundle/FAQ/FAQ.html> [↩](#fnref1)
2. <https://www.youtube.com/watch?v=oEkJvvGEtB4?t=30m55s> [↩](#fnref2)
3. <http://rubyonrails.org/doctrine/>
---
via: <https://twobithistory.org/2017/11/19/the-ruby-story.html>
作者：[Two-Bit History](https://twobithistory.org) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wwhio](https://github.com/wwhio) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何从命令行同时移动多种文件类型
|
Sk
|
https://www.ostechnix.com/how-to-move-multiple-file-types-simultaneously-from-commandline/
|
如果你曾遇到这样的情况，我知道在类 Unix 系统中从命令行执行该操作的一个简单方法。
|
/data/attachment/album/201901/21/224428kbq6nvvn3aq5ab1a.png.thumb.jpg
|
/data/attachment/album/201901/21/224428kbq6nvvn3aq5ab1a.png
| true | false | true |
lujun9972
|
MjSeven
|
wxy
| false |
[
"文件",
"移动"
] |
技术
|
{
"viewnum": 4829,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
如果你曾遇到这样的情况，我知道在类 Unix 系统中从命令行执行该操作的一个简单方法。
| 2019-01-21T22:44:00 | 2019-01-21T22:44:00 | 10,464 |
/article-10464-1.html
|
前几天，我想知道如何将多个文件类型从一个目录移动（不复制）到另一个目录。我已经知道如何[查找并将某些类型的文件从一个目录复制到另一个目录](https://www.ostechnix.com/find-copy-certain-type-files-one-directory-another-linux/)。但是，我不知道如何同时移动多种文件类型。如果你曾遇到这样的情况，我知道在类 Unix 系统中从命令行执行该操作的一个简单方法。
### 同时移动多种文件类型
想象一下这种场景，你在名为 `dir1` 的目录中有多种类型的文件，例如 .pdf、 .doc、 .mp3、 .mp4、 .txt 等等。我们来看看 `dir1` 的内容：
```
$ ls dir1
file.txt image.jpg mydoc.doc personal.pdf song.mp3 video.mp4
```
你希望将某些文件类型（不是所有文件类型）移动到另一个位置。例如，假设你想将 .doc、 .pdf 和 .txt 文件一次性移动到名为 `dir2` 的另一个目录中。
要同时将 .doc、 .pdf 和 .txt 文件从 `dir1` 移动到 `dir2`，命令是：
```
$ mv dir1/*.{doc,pdf,txt} dir2/
```
很容易，不是吗？
现在让我们来查看一下 `dir2` 的内容：
```
$ ls dir2/
file.txt mydoc.doc personal.pdf
```
看到了吗？只有 .doc、 .pdf 和 .txt 从 `dir1` 移到了 `dir2`。
在上面的命令中，你可以在花括号内添加任意数量的文件类型，以将它们移动到不同的目录中。它在 Bash 上非常适合我。
另一种移动多种文件类型的方法是转到源目录，在我们的例子中即为 `dir1`：
```
$ cd ~/dir1
```
将你选择的文件类型移动到目的地（即 `dir2`），如下所示：
```
$ mv *.doc *.txt *.pdf /home/sk/dir2/
```
要移动具有特定扩展名的所有文件，例如 .doc，运行：
```
$ mv dir1/*.doc dir2/
```
更多细节，参考 man 页：
```
$ man mv
```
移动一些相同或不同的文件类型很容易！你可以在 GUI 模式下单击几下鼠标，或在 CLI 模式下使用一行命令来完成。但是，如果目录中有数千种不同的文件类型，并且希望一次将多种文件类型移动到不同的目录，这将是一项繁琐的任务。对我来说，上面的方法很容易完成工作！如果你知道任何其它一行命令可以一次移动多种文件类型，请在下面的评论部分与我们分享。我会核对并更新指南。
这些就是全部了，希望这很有用。更多好东西将要来了，敬请关注！
共勉！
---
via: <https://www.ostechnix.com/how-to-move-multiple-file-types-simultaneously-from-commandline/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linux 工具：点的含义
|
Paul Brown
|
https://www.linux.com/blog/learn/2019/1/linux-tools-meaning-dot
|
Paul Brown 解释了 Linux shell 命令中那个不起眼的“点”的各种意思和用法。
|
/data/attachment/album/201901/22/000250f1x67c4ec3kxicp1.jpg.thumb.jpg
|
/data/attachment/album/201901/22/000250f1x67c4ec3kxicp1.jpg
| true | false | true |
lujun9972
|
asche910
|
wxy
| false |
[
"shell",
"bash"
] |
技术
|
{
"viewnum": 10720,
"commentnum": 7,
"favtimes": 2,
"sharetimes": 2,
"likes": 0
}
|
[
{
"postip": "183.15.178.197",
"message": "touch {blahg, splurg, mmmf}_file.txt中间不能有空格<br />\r\ntouch {blahg,splurg,mmmf}_file.txt",
"username": "L-ios [Firefox 66.0|GNU/Linux]",
"date": "2019-02-15T13:48:49"
},
{
"postip": "61.186.30.81",
"message": "谢谢！",
"username": "linux [Chrome 72.0|Mac 10.14]",
"date": "2019-02-15T15:46:06"
},
{
"postip": "183.246.29.76",
"message": "我已经将网站列为广告拦截的白名单了。谢谢",
"username": "来自浙江杭州的 Chrome 72.0|Windows 7 用户",
"date": "2019-03-08T13:24:29"
},
{
"postip": "183.246.29.76",
"message": "我已经将网站列为广告拦截的白名单了。谢谢",
"username": "来自浙江杭州的 Chrome 72.0|Windows 7 用户",
"date": "2019-03-08T13:24:31"
},
{
"postip": "61.186.31.236",
"message": "感谢！",
"username": "linux [Chrome 72.0|Mac 10.14]",
"date": "2019-03-10T09:26:24"
},
{
"postip": "223.89.222.156",
"message": "写的很好，已经收藏网址",
"username": "来自河南商丘的 Chrome 87.0|Windows 10 用户",
"date": "2020-12-15T22:04:40"
},
{
"postip": "123.149.78.167",
"message": "写得非常棒！翻译得也相当好！学习了，受益了，还会学习咱们网站更多得文章！",
"username": "来自河南郑州的 Chrome 95.0|Windows 10 用户",
"date": "2021-11-16T13:55:22"
}
] |
[
{
"raid": 10761,
"displayorder": 0
}
] |
Paul Brown 解释了 Linux shell 命令中那个不起眼的“点”的各种意思和用法。
| 2019-01-22T00:02:00 | 2019-01-22T00:02:00 | 10,465 |
/article-10465-1.html
|
>
> Paul Brown 解释了 Linux shell 命令中那个不起眼的“点”的各种意思和用法。
>
>
>
在现实情况中，使用 shell 命令编写的单行命令或脚本可能会令人很困惑。你使用的很多工具的名称与它们的实际功能相差甚远（`grep`、`tee` 和 `awk`，还有吗？），而当你将两个或更多个组合起来时，所组成的 “句子” 看起来更像某种外星人的天书。
因此，上面说的这些对于你并无帮助，因为你用来编写一连串的指令所使用的符号根据你使用的场景有着不同的意义。
### 位置、位置、位置
就拿这个不起眼的点（`.`）来说吧。当它放在一个需要一个目录名称的命令的参数处时，表示“当前目录”：
```
find . -name "*.jpg"
```
意思就是“在当前目录（包括子目录）中寻找以 `.jpg` 结尾的文件”。
`ls .` 和 `cd .` 结果也如你想的那样，它们分别列举和“进入”到当前目录，虽然在这两种情况下这个点都是多余的。
而一个紧接着另一个的两个点呢，在同样的场景下（即当你的命令期望一个文件目录的时候）表示“当前目录的父目录”。如果你当前在 `/home/your_directory` 下并且运行：
```
cd ..
```
你就会进入到 `/home`。所以，你可能认为这仍然适合“点代表附近目录”的叙述，并且毫不复杂，对吧？
那下面这样会怎样呢？如果你在一个文件或目录的开头加上点，它表示这个文件或目录会被隐藏：
```
$ touch somedir/file01.txt somedir/file02.txt somedir/.secretfile.txt
$ ls -l somedir/
total 0
-rw-r--r-- 1 paul paul 0 Jan 13 19:57 file01.txt
-rw-r--r-- 1 paul paul 0 Jan 13 19:57 file02.txt
$ # 注意上面列举的文件中没有 .secretfile.txt
$ ls -la somedir/
total 8
drwxr-xr-x 2 paul paul 4096 Jan 13 19:57 .
drwx------ 48 paul paul 4096 Jan 13 19:57 ..
-rw-r--r-- 1 paul paul 0 Jan 13 19:57 file01.txt
-rw-r--r-- 1 paul paul 0 Jan 13 19:57 file02.txt
-rw-r--r-- 1 paul paul 0 Jan 13 19:57 .secretfile.txt
$ # 这个 -a 选项告诉 ls 去展示“all”文件，包括那些隐藏的
```
然后就是你可以将 `.` 当作命令。是的，你听我说：`.` 是个真真正正的命令。它是 `source` 命令的代名词，所以你可以用它在当前 shell 中执行一个文件，而不是以某种其它的方式去运行一个脚本文件（这通常指的是 Bash 会产生一个新的 shell 去运行它）
很困惑？别担心 —— 试试这个：创建一个名为 `myscript` 的脚本，内容包含下面一行：
```
myvar="Hello"
```
然后通过常规的方法执行它，也就是用 `sh myscript`（或者通过 `chmod a+x myscript` 命令让它可执行，然后运行 `./myscript`）。现在尝试并且观察 `myvar` 的内容，通过 `echo $myvar`（理所当然你什么也得不到）。那是因为，当你的脚本赋值 `"Hello"` 给 `myvar` 时，它是在一个隔离的bash shell 实例中进行的。当脚本运行结束时，这个新产生的实例会消失并且将控制权转交给原来的shell，而原来的 shell 里甚至都不存在 `myvar` 变量。
然而，如果你这样运行 `myscript`：
```
. myscript
```
`echo $myvar` 就会打印 `Hello` 到命令行上。
当你的 `.bashrc` 文件发生变化后，你经常会用到 `.`（或 `source`）命令，[就像当你要扩展 `PATH` 变量那样](https://www.linux.com/blog/learn/2018/12/bash-variables-environmental-and-otherwise)。在你的当前 shell 实例中，你可以使用 `.` 来让变化立即生效。
### 双重麻烦
就像看似无关紧要的一个点有多个含义一样，两个点也是如此。除了指向当前目录的父级之外，两个点（`..`）也用于构建序列。
尝试下这个：
```
echo {1..10}
```
它会打印出从 1 到 10 的序列。在这种场景下，`..` 表示 “从左边的值开始，计数到右边的值”。
现在试下这个：
```
echo {1..10..2}
```
你会得到 `1 3 5 7 9`。`..2` 这部分命令告诉 Bash 输出这个序列，不过不是每个相差 1，而是相差 2。换句话说，就是你会得到从 1 到 10 之间的奇数。
它反着也仍然有效：
```
echo {10..1..2}
```
你也可以用多个 0 填充你的数字。这样：
```
echo {000..121..2}
```
会这样打印出从 0 到 121 之间的偶数（填充了前置 0）：
```
000 002 004 006 ... 050 052 054 ... 116 118 120
```
不过这样的序列发生器有啥用呢？当然，假设您的新年决心之一是更加谨慎控制您的帐户花销。作为决心的一部分，您需要创建目录，以便对过去 10 年的数字发票进行分类：
```
mkdir {2009..2019}_Invoices
```
工作完成。
或者你可能有数百个带编号的文件，比如从视频剪辑中提取的帧，或许因为某种原因，你只想从第 43 帧到第 61 帧每隔三帧删除一帧：
```
rm frame_{043..61..3}
```
很可能，如果你有超过 100 个帧，它们将以填充 0 命名，如下所示：
```
frame_000 frame_001 frame_002 ...
```
那就是为什么你在命令中要用 `043`，而不是`43` 的原因。
### 花括号花招
说实话，序列的神奇之处不在于双点，而是花括号（`{}`）的巫术。看看它对于字母是如何工作的。这样做：
```
touch file_{a..z}.txt
```
它创建了从 `file_a.txt` 到 `file_z.txt` 的文件。
但是，你必须小心。使用像 `{Z..a}` 这样的序列将产生一大堆大写字母和小写字母之间的非字母、数字的字符（既不是数字或字母的字形）。其中一些字形是不可打印的或具有自己的特殊含义。使用它们来生成文件名称可能会导致一系列意外和可能令人不快的影响。
最后一件值得指出的事：包围在 `{...}` 的序列，它们也可以包含字符串列表：
```
touch {blahg,splurg,mmmf}_file.txt
```
将创建了 `blahg_file.txt`、`splurg_file.txt` 和 `mmmf_file.txt`。
当然，在别的场景中，大括号也有不同的含义（惊喜吗！）。不过那是别的文章的内容了。
### 总结
Bash 以及运行于其中的各种工具已经被寻求解决各种特定问题的系统管理员们把玩了数十年。要说这种有自己之道的系统管理员是一种特殊物种的话，那是有点轻描淡写。总而言之，与其他语言相反，Bash 的设计目标并不是为了用户友好、简单、甚至合乎逻辑。
但这并不意味着它不强大 —— 恰恰相反。Bash 的语法和 shell 工具可能不一致且很庞大，但它们也提供了一系列令人眼花缭乱的方法来完成您可能想象到的一切。就像有一个工具箱，你可以从中找到从电钻到勺子的所有东西，以及橡皮鸭、一卷胶带和一些指甲钳。
除了引人入胜之外，探明你可以直接在 shell 中达成的所有能力也很有趣，所以下次我们将深入探讨如何构建更大更好的 Bash 命令行。
在那之前，玩得开心！
---
via: <https://www.linux.com/blog/learn/2019/1/linux-tools-meaning-dot>
作者：[Paul Brown](https://www.linux.com/users/bro66) 选题：[lujun9972](https://github.com/lujun9972) 译者：[asche910](https://github.com/asche910) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.