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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
基于 FUSE 的 Bittorrent 文件系统
|
Sk
|
https://www.ostechnix.com/btfs-a-bittorrent-filesystem-based-on-fuse/
|
使用 BTFS，你可以将种子文件或磁力链接挂载为目录，然后在文件树中作为只读目录。这些文件的内容将在程序读取时按需下载。
|
/data/attachment/album/201806/08/073727d0blkrxr005qkvxc.png.thumb.jpg
|
/data/attachment/album/201806/08/073727d0blkrxr005qkvxc.png
| true | false | true |
geekpi
| false |
[
"BTFS",
"Bittorrent"
] |
分享
|
{
"viewnum": 6295,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用 BTFS，你可以将种子文件或磁力链接挂载为目录，然后在文件树中作为只读目录。这些文件的内容将在程序读取时按需下载。
| 2018-06-08T13:36:00 | 2018-06-08T13:36:00 | 9,727 |
/article-9727-1.html
|
Bittorrent 已经存在了很长时间，它可以从互联网上共享和下载数据。市场上有大量的 GUI 和 CLI 的 Bittorrent 客户端。有时，你不能坐下来等待你的下载完成。你可能想要立即观看内容。这就是 **BTFS** 这个不起眼的文件系统派上用场的地方。使用 BTFS，你可以将种子文件或磁力链接挂载为目录，然后在文件树中作为只读目录。这些文件的内容将在程序读取时按需下载。由于 BTFS 在 FUSE 之上运行，因此不需要干预 Linux 内核。
### 安装 BTFS
BTFS 存在于大多数 Linux 发行版的默认仓库中。
在 Arch Linux 及其变体上，运行以下命令来安装 BTFS。
```
$ sudo pacman -S btfs
```
在Debian、Ubuntu、Linux Mint 上：
```
$ sudo apt-get install btfs
```
在 Gentoo 上：
```
# emerge -av btfs
```
BTFS 也可以使用 [Linuxbrew](https://www.ostechnix.com/linuxbrew-common-package-manager-linux-mac-os-x/) 包管理器进行安装。
```
$ brew install btfs
```
### 用法
BTFS 的使用非常简单。你所要做的就是找到 .torrent 文件或磁力链接，并将其挂载到一个目录中。种子文件或磁力链接的内容将被挂载到你选择的目录内。当一个程序试图访问该文件进行读取时，实际的数据将按需下载。此外，像 `ls` 、`cat` 和 `cp` 这样的工具能按照预期的方式来操作种子。像 `vlc` 和 `mplayer` 这样的程序也可以不加修改地工作。玩家甚至不知道实际内容并非物理存在于本地磁盘中，而是根据需要从 peer 中收集。
创建一个目录来挂载 torrent/magnet 链接：
```
$ mkdir mnt
```
挂载 torrent/magnet 链接：
```
$ btfs video.torrent mnt
```
cd 到目录：
```
$ cd mnt
```
然后，开始观看！
```
$ vlc <path-to-video.mp4>
```
给 BTFS 一些时间来找到并获取网站 tracker。一旦加载了真实数据，BTFS 将不再需要 tracker。
要卸载 BTFS 文件系统，只需运行以下命令：
```
$ fusermount -u mnt
```
现在，挂载目录中的内容将消失。要再次访问内容，你需要按照上面的描述挂载 torrent。
BTFS 会将你的 VLC 或 Mplayer 变成爆米花时间。挂载你最喜爱的电视节目或电影的种子文件或磁力链接，然后开始观看，无需下载整个种子内容或等待下载完成。种子或磁力链接的内容将在程序访问时按需下载。
就是这些了。希望这些有用。还会有更好的东西。敬请关注！
干杯！
---
via: <https://www.ostechnix.com/btfs-a-bittorrent-filesystem-based-on-fuse/>
作者：[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/) 荣誉推出
|
||
解决构建全球社区带来的挑战
|
José Antonio Rey
|
https://opensource.com/article/17/12/working-worldwide-communities
|
全球开源社区通常面临着语音壁垒、文化差异以及其它的挑战。如何去解决它们呢？
|
/data/attachment/album/201806/08/075508z5ytolbu5h569xt5.png.thumb.jpg
|
/data/attachment/album/201806/08/075508z5ytolbu5h569xt5.png
| true | false | true |
lujun9972
| false |
[
"开源社区"
] |
观点
|
{
"viewnum": 4070,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
全球开源社区通常面临着语音壁垒、文化差异以及其它的挑战。如何去解决它们呢？
| 2018-06-08T15:54:00 | 2018-06-08T15:54:00 | 9,728 |
/article-9728-1.html
|
>
> 全球开源社区通常面临着语音壁垒、文化差异以及其它的挑战。如何去解决它们呢？
>
>
>
今天的开源组织参与人员来自于全世界。你能预见到组建在线社区可能遇到哪些困难吗？有没有什么办法能够克服这些困难呢？
为开源社区贡献力量的人共同合作推动软件的开发和发展。在过去，人们是面对面或者通过邮件和电话来交流的。今天，科技孕育出了在线交流——人们只需要进入一个聊天室或消息渠道就能一起工作了。比如，你可以早上跟摩洛哥的人一起工作，到了晚上又跟夏威夷的人一起工作。
### 全球社区的三个挑战
任何一个团队合作过的人都知道意见分歧是很难被克服的。对于在线社区来说，语言障碍、不同的时区，以及文化差异也带来了新的挑战。
#### 语言障碍
英语是开源社区中的主流语言，因此英语不好的人会很难看懂文档和修改意见。为了克服这个问题，吸引其他地区的社区成员，你需要邀请双语者参与到社区中来。问问周围的人——你会发现意想不到的精通其他语言的人。社区的双语成员可以帮助别人跨越语言障碍，并且可以通过翻译软件和文档来扩大项目的受众范围。
人们使用的编程语言也不一样。你可能喜欢用 Bash 而其他人则可能更喜欢 Python、Ruby、C 等其他语言。这意味着，人们可能由于编程语言的原因而难以为你的代码库做贡献。项目负责人为项目选择一门被软件社区广泛认可的语言至关重要。如果你选择了一门偏门的语言，则很少人能够参与其中。
#### 不同的时区
时区为开源社区带来了另一个挑战。比如，若你在芝加哥，想与一个在伦敦的成员安排一次视频会议，你需要调整 8 小时的时差。根据合作者的地理位置，你可能要在深夜或者清晨工作。
肉身转移，可以让你的团队在同一个时区工作可以帮助克服这个挑战，但这种方法只有极少数社区才能够负担的起。我们还可以定期举行虚拟会议讨论项目，建立一个固定的时间和地点以供所有人来讨论未决的事项，即将发布的版本等其他主题。
不同的时区也可以成为你的优势，因为团队成员可以全天候的工作。若你拥有一个类似 IRC 这样的实时交流平台，用户可以在任意时间都能找到人来回答问题。
#### 文化差异
文化差异是开源组织面临的最大挑战。世界各地的人都有不同的思考方式、计划以及解决问题的方法。政治环境也会影响工作环境并影响决策。
作为项目负责人，你应该努力构建一种能包容不同看法的环境。文化差异可以鼓励社区沟通。建设性的讨论总是对项目有益，因为它可以帮助社区成员从不同角度看待问题。不同意见也有助于解决问题。
要成功开源，团队必须学会拥抱差异。这不简单，但多样性最终会使社区收益。
### 加强在线沟通的其他方法
* **本地化：** 在线社区成员可能会发现位于附近的贡献者——去见个面并组织一个本地社区。只需要两个人就能组建一个社区了。可以邀请其他当地用户或雇员参与其中；他们甚至还能为以后的聚会提供场所呢。
* **组织活动：** 组织活动是构建本地社区的好方法，而且费用也不高。你可以在当地的咖啡屋或者啤酒厂聚会，庆祝最新版本的发布或者某个核心功能的实现。组织的活动越多，人们参与的热情就越高（即使只是因为单纯的好奇心）。最终，可能会找到一家公司为你提供聚会的场地，或者为你提供赞助。
* **保持联系：** 每次活动后，联系本地社区成员。收起电子邮箱地址或者其他联系方式并邀请他们参与到你的交流平台中。邀请他们为其他社区做贡献。你很可能会发现很多当地的人才，运气好的话，甚至可能发现新的核心开发人员！
* **分享经验：** 本地社区是一种非常有价值的资源，对你，对其他社区来说都是。与可能受益的人分享你的发现和经验。如果你不清楚（LCTT 译注：这里原文是说 sure，但是根据上下文，这里应该是 not sure）如何策划一场活动或会议，可以咨询其他人的意见。也许能找到一些有经验的人帮你走到正轨。
* **关注文化差异：** 记住，文化规范因地点和人而异，因此在清晨安排某项活动可能适用于一个地方的人，但是不合适另一个地方的人。当然，你可以（也应该）利用其他社区的参考资料来更好地理解这种差异性，但有时你也需要通过试错的方式来学习。不要忘了分享你所学到的东西，让别人也从中获益。
* **检查个人观点：** 避免在工作场合提出带有很强主观色彩的观点（尤其是与政治相关的观点）。这会抑制开放式的沟通和问题的解决。相反，应该专注于鼓励与团队成员展开建设性讨论。如果你发现陷入了激烈的争论中，那么后退一步，冷静一下，然后再从更加积极的角度出发重新进行讨论。讨论必须是有建设性的，从多个角度讨论问题对社区有益。永远不要把自己的主观观念放在社区的总体利益之前。
* **尝试异步沟通：** 这些天，实时通讯平台已经引起了大家的关注，但除此之外还别忘了电子邮件。如果没有在网络平台上找到人的话，可以给他们发送一封电子邮件。有可能你很快就能得到回复。考虑使用那些专注于异步沟通的平台，比如 [Twist](https://twistapp.com)，也不要忘了查看并更新论坛和维基。
* **使用不同的解决方案：** 并不存在一个单一的完美的解决方法，学习最有效的方法还是通过经验来学习。从反复试验中你可以学到很多东西。不要害怕失败；你会从失败中学到很多东西从而不停地进步。
### 社区需要营养
将社区想象成是一颗植物的幼苗。你需要每天给它浇水，提供阳光和氧气。社区也是一样：倾听贡献者的声音，记住你在与活生生的人进行互动，他们需要以合适的方式进行持续的交流。如果社区缺少了人情味，人们会停止对它的贡献。
最后，请记住，每个社区都是不同的，没有一种单一的解决方法能够适用于所有社区。坚持不断地从社区中学习并适应这个社区。
---
via: <https://opensource.com/article/17/12/working-worldwide-communities>
作者：[José Antonio Rey](https://opensource.com/users/jose) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
面向数据科学的 Anaconda Python 入门
|
Don Watkins
|
https://opensource.com/article/18/4/getting-started-anaconda-python
|
Anaconda 是一个完备的、开源的数据科学软件包，拥有超过 600 万社区用户。
|
/data/attachment/album/201806/08/221955rc3dj0j3m4bj811m.png.thumb.jpg
|
/data/attachment/album/201806/08/221955rc3dj0j3m4bj811m.png
| true | false | true |
pinewall
| false |
[
"Anaconda",
"数据科学"
] |
技术
|
{
"viewnum": 5747,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Anaconda 是一个完备的、开源的数据科学软件包，拥有超过 600 万社区用户。
| 2018-06-08T22:19:37 | 2018-06-08T22:19:37 | 9,729 |
/article-9729-1.html
|
>
> Anaconda 是一个完备的、开源的数据科学软件包，拥有超过 600 万社区用户。
>
>
>
像很多人一样，我一直努力加入到快速发展的数据科学领域。我上过 Udemy 的 [R](https://www.r-project.org/) 及 [Python](https://www.python.org/) 语言编程课，那时我分别下载并安装了应用程序。当我试图解决各种依赖关系，安装类似 [Numpy](http://www.numpy.org/) 和 [Matplotlib](https://matplotlib.org/) 这样的数据科学扩展包时，我了解了 [Anaconda Python 发行版](https://www.anaconda.com/distribution/)。
Anaconda 是一个完备的、[开源](https://docs.anaconda.com/anaconda/eula)的数据科学包，拥有超过 600 万社区用户。[下载](https://www.anaconda.com/download/#linux)和安装 Anaconda 都很容易，支持的操作系统包括 Linux, MacOS 及 Windows。
我感谢 Anaconda 降低了初学者的学习门槛。发行版自带 1000 多个数据科学包以及 [Conda](https://conda.io/) 包和虚拟环境管理器，让你无需单独学习每个库的安装方法。就像 Anaconda 官网上提到的，“Anaconda 库中的 Python 和 R 语言的 conda 包是我们在安全环境中修订并编译得到的优化二进制程序，可以在你系统上工作”。
我推荐使用 [Anaconda Navigator](https://docs.anaconda.com/anaconda/navigator/)，它是一个桌面 GUI 系统，包含了发行版自带的全部应用的链接，包括 [RStudio](https://www.rstudio.com/)、 [iPython](https://ipython.org/)、 [Jupyter Notebook](http://jupyter.org/)、 [JupyterLab](https://blog.jupyter.org/jupyterlab-is-ready-for-users-5a6f039b8906)、 [Spyder](https://spyder-ide.github.io/)、 [Glue](http://glueviz.org/) 和 [Orange](https://orange.biolab.si/)。默认环境采用 Python 3.6，但你可以轻松安装 Python 3.5、 Python 2.7 或 R。[文档](https://orange.biolab.si/)十分详尽，而且用户社区极好，可以提供额外的支持。
### 安装 Anaconda
为在我的 Linux 笔记本（I3 CPU，4GB 内存）上安装 Anaconda，我下载了 Anaconda 5.1 Linux 版安装器并运行 `md5sum` 进行文件校验：
```
$ md5sum Anaconda3-5.1.0-Linux-x86_64.sh
```
接着按照[安装文档](https://docs.anaconda.com/anaconda/install/linux)的说明，无论是否在 Bash shell 环境下，执行如下 shell 命令：
```
$ bash Anaconda3-5.1.0-Linux-x86_64.sh
```
我完全按照安装指南操作，运行这个精心编写的脚本，大约花费 5 分钟可以完成安装。安装过程中会提示：“是否希望安装器将 Anaconda 的安装路径加入到你的 `/home/<user>/.bashrc`？”我选择允许并重启了 shell，这会让 `.bashrc` 中的环境变量生效。
安装完成后，我启动了 Anaconda Navigator，具体操作是在 shell 中执行如下命令：
```
$ anaconda-navigator
```
Anaconda Navigator 每次启动时会检查是否有可更新的软件包，如果有，会提醒你进行更新。
按照提醒进行更新即可，无需使用命令行。Anaconda 初次启动会有些慢，如果涉及更新会额外花费几分钟。
当然，你也可以通过执行如下命令手动更新：
```
$ conda update anaconda-navigator
```
### 浏览和安装应用
Navigator 启动后，可以很容易地浏览 Anaconda 发行版包含的应用。按照文档所述，64 位 Python 3.6 版本的 Anaconda [支持 499 个软件包](https://docs.anaconda.com/anaconda/packages/py3.6_linux-64)。我浏览的第一个应用是 [Jupyter QtConsole](http://qtconsole.readthedocs.io/en/stable/)，这个简单易用的 GUI 支持内联数据 (inline figures) 和语法高亮。
发行版中包含 Jupyter Notebook，故无需另外安装（不像我用的其它 Python 环境那样）。
我习惯使用的 RStudio 并没有默认安装，但安装它也仅需点击一下鼠标。其它应用的启动或安装也仅需点击一下鼠标，包括 JupyterLab、 Orange、 Glue 和 Spyder 等。
Anaconda 发行版的一个强大功能是创建多套环境。假如我需要创建一套与默认 Python 3.6 不同的 Python 2.7 的环境，可以在 shell 中执行如下命令：
```
$ conda create -n py27 python=2.7 anaconda
```
Conda 负责整个安装流程，如需启动它，仅需在 shell 中执行如下命令：
```
$ anaconda-navigator
```
在 Anaconda GUI 的 “Applications on” 下拉菜单中选取 **py27** 即可。
### 更多内容
如果你想了解更多关于 Anaconda 的信息，可供参考的资源十分丰富。不妨从检索 [Anaconda 社区](https://www.anaconda.com/community/)及对应的[邮件列表](https://groups.google.com/a/continuum.io/forum/#!forum/anaconda)开始。
你是否在使用 Anaconda 发行版及 Navigator 呢？欢迎在评论中留下你的使用感想。
---
via: <https://opensource.com/article/18/4/getting-started-anaconda-python>
作者：[Don Watkins](https://opensource.com/users/don-watkins) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Arch Linux 中降级软件包
|
Sk
|
https://www.ostechnix.com/downgrade-package-arch-linux/
|
有时候，你想更新到最新的版本，但你可能会被破损的包卡住。不要惊慌！在这种情况下，你可以简单地回滚到旧的稳定包。
|
/data/attachment/album/201806/08/222736c4nnx414oxommorm.jpg.thumb.jpg
|
/data/attachment/album/201806/08/222736c4nnx414oxommorm.jpg
| true | false | true |
MjSeven
| false |
[
"Arch"
] |
技术
|
{
"viewnum": 16676,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "13.75.77.185",
"message": "这个软件找不到啊",
"username": "来自美国的 Chrome 84.0|Windows 10 用户",
"date": "2020-08-04T11:17:09"
}
] |
[] |
有时候，你想更新到最新的版本，但你可能会被破损的包卡住。不要惊慌！在这种情况下，你可以简单地回滚到旧的稳定包。
| 2018-06-08T22:27:31 | 2018-06-08T22:27:31 | 9,730 |
/article-9730-1.html
|
正如你了解的，Arch Linux 是一个滚动版本和 DIY（自己动手）发行版。因此，在经常更新时必须小心，特别是从 AUR 等第三方存储库安装或更新软件包。如果你不知道自己在做什么，那么最终很可能会破坏系统。你有责任使 Arch Linux 更加稳定。但是，我们都会犯错误，要时刻小心是很难的。有时候，你想更新到最新的版本，但你可能会被破损的包卡住。不要惊慌！在这种情况下，你可以简单地回滚到旧的稳定包。这个简短的教程描述了如何在 Arch Linux 中以及它的变体，如 Antergos，Manjaro Linux 中降级一个包，
### 在 Arch Linux 中降级一个包
在 Arch Linux 中，有一个名为 “downgrade” 的实用程序，可帮助你将安装的软件包降级为任何可用的旧版本。此实用程序将检查你的本地缓存和远程服务器（Arch Linux 仓库）以查找所需软件包的旧版本。你可以从该列表中选择任何一个旧的稳定的软件包并进行安装。
该软件包在官方仓库中不可用，你需要添加非官方的 **archlinuxfr** 仓库。
为此，请编辑 `/etc/pacman.conf` 文件：
```
$ sudo nano /etc/pacman.conf
```
添加以下行：
```
[archlinuxfr]
SigLevel = Never
Server = http://repo.archlinux.fr/$arch
```
保存并关闭文件。
使用以下命令来更新仓库：
```
$ sudo pacman -Sy
```
然后在终端中使用以下命令安装 “Downgrade” 实用程序：
```
$ sudo pacman -S downgrade
```
示例输出：
```
resolving dependencies...
looking for conflicting packages...
Packages (1) downgrade-5.2.3-1
Total Download Size: 0.01 MiB
Total Installed Size: 0.10 MiB
:: Proceed with installation? [Y/n]
```
“downgrade” 命令的典型用法是：
```
$ sudo downgrade [PACKAGE, ...] [-- [PACMAN OPTIONS]]
```
让我们假设你想要将 opera web 浏览器 降级到任何可用的旧版本。
为此，运行：
```
$ sudo downgrade opera
```
此命令将从本地缓存和远程镜像列出所有可用的 opera 包（新旧两种版本）。
示例输出：
```
Available packages:
1) opera-37.0.2178.43-1-x86_64.pkg.tar.xz (local)
2) opera-37.0.2178.43-1-x86_64.pkg.tar.xz (remote)
3) opera-37.0.2178.32-1-x86_64.pkg.tar.xz (remote)
4) opera-36.0.2130.65-2-x86_64.pkg.tar.xz (remote)
5) opera-36.0.2130.65-1-x86_64.pkg.tar.xz (remote)
6) opera-36.0.2130.46-2-x86_64.pkg.tar.xz (remote)
7) opera-36.0.2130.46-1-x86_64.pkg.tar.xz (remote)
8) opera-36.0.2130.32-2-x86_64.pkg.tar.xz (remote)
9) opera-36.0.2130.32-1-x86_64.pkg.tar.xz (remote)
10) opera-35.0.2066.92-1-x86_64.pkg.tar.xz (remote)
11) opera-35.0.2066.82-1-x86_64.pkg.tar.xz (remote)
12) opera-35.0.2066.68-1-x86_64.pkg.tar.xz (remote)
13) opera-35.0.2066.37-2-x86_64.pkg.tar.xz (remote)
14) opera-34.0.2036.50-1-x86_64.pkg.tar.xz (remote)
15) opera-34.0.2036.47-1-x86_64.pkg.tar.xz (remote)
16) opera-34.0.2036.25-1-x86_64.pkg.tar.xz (remote)
17) opera-33.0.1990.115-2-x86_64.pkg.tar.xz (remote)
18) opera-33.0.1990.115-1-x86_64.pkg.tar.xz (remote)
19) opera-33.0.1990.58-1-x86_64.pkg.tar.xz (remote)
20) opera-32.0.1948.69-1-x86_64.pkg.tar.xz (remote)
21) opera-32.0.1948.25-1-x86_64.pkg.tar.xz (remote)
22) opera-31.0.1889.174-1-x86_64.pkg.tar.xz (remote)
23) opera-31.0.1889.99-1-x86_64.pkg.tar.xz (remote)
24) opera-30.0.1835.125-1-x86_64.pkg.tar.xz (remote)
25) opera-30.0.1835.88-1-x86_64.pkg.tar.xz (remote)
26) opera-30.0.1835.59-1-x86_64.pkg.tar.xz (remote)
27) opera-30.0.1835.52-1-x86_64.pkg.tar.xz (remote)
28) opera-29.0.1795.60-1-x86_64.pkg.tar.xz (remote)
29) opera-29.0.1795.47-1-x86_64.pkg.tar.xz (remote)
30) opera-28.0.1750.51-1-x86_64.pkg.tar.xz (remote)
31) opera-28.0.1750.48-1-x86_64.pkg.tar.xz (remote)
32) opera-28.0.1750.40-1-x86_64.pkg.tar.xz (remote)
33) opera-27.0.1689.76-1-x86_64.pkg.tar.xz (remote)
34) opera-27.0.1689.69-1-x86_64.pkg.tar.xz (remote)
35) opera-27.0.1689.66-1-x86_64.pkg.tar.xz (remote)
36) opera-27.0.1689.54-2-x86_64.pkg.tar.xz (remote)
37) opera-27.0.1689.54-1-x86_64.pkg.tar.xz (remote)
38) opera-26.0.1656.60-1-x86_64.pkg.tar.xz (remote)
39) opera-26.0.1656.32-1-x86_64.pkg.tar.xz (remote)
40) opera-12.16.1860-2-x86_64.pkg.tar.xz (remote)
41) opera-12.16.1860-1-x86_64.pkg.tar.xz (remote)
select a package by number:
```
只需输入你选择的包号码，然后按回车即可安装。
就这样。当前安装的软件包将被降级为旧版本。
另外阅读：[在 Arch Linux 中如何将所有软件包降级到特定日期](https://www.ostechnix.com/downgrade-packages-specific-date-arch-linux/)
### 那么，如何避免已损坏的软件包并使 Arch Linux 更加稳定？
在更新 Arch Linux 之前查看 [Arch Linux 新闻](https://www.archlinux.org/news/)和[论坛](https://bbs.archlinux.org/)，看看是否有任何已报告的问题。过去几周我一直在使用 Arch Linux 作为我的主要操作系统，以下是我在这段时间内发现的一些简单提示，以避免在 Arch Linux 中安装不稳定的软件包。
1. 避免部分升级。这意味着永远不要运行 `pacman -Sy <软件包名称>`。此命令将在安装软件包时部分升级你的系统。相反，优先使用 `pacman -Syu` 来更新系统，然后使用 `package -S <软件包名称>` 安装软件包。
2. 避免使用 `pacman -Syu -force` 命令。`-force` 标志将忽略程序包和文件冲突，并且可能会以破损的程序包或损坏的系统结束。
3. 不要跳过依赖性检查。这意味着不要使用 `pacman -Rdd <软件包名称>`。此命令将在删除软件包时避免依赖性检查。如果你运行这个命令，另一个重要的包所需的关键依赖也可以被删除。最终，它会损坏你的 Arch Linux。
4. 定期备份重要数据和配置文件以避免数据丢失总是一个好习惯。
5. 安装第三方软件包和 AUR 等非官方软件包时要小心。不要安装那些正在经历重大发展的软件包。
有关更多详细信息，请查看 [Arch Linux 维护指南](https://wiki.archlinux.org/index.php/System_maintenance)。
我不是 Arch Linux 专家，我仍然在学习如何使它更稳定。如果你有任何技巧让 Arch Linux 保持稳定和安全，请在下面的评论部分保持稳定和安全告诉我，我将洗耳恭听。
希望这可以有帮助。目前为止这就是全部了。我很快会再次在这里与另一篇有趣的文章。在此之前，请继续关注。
干杯！
---
via: <https://www.ostechnix.com/downgrade-package-arch-linux/>
作者：[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/) 荣誉推出
|
||
探秘“栈”之旅（II）：结语、金丝雀和缓冲区溢出
|
Gustavo Duarte
|
https://manybutfinite.com/post/epilogues-canaries-buffer-overflows/
|
我们讲解了 栈是如何工作的 以及在函数的序言上栈帧是如何被构建的。今天，我们来看一下它的相反的过程，在函数结语中栈帧是如何被销毁的。
|
/data/attachment/album/201806/09/232719ca6qhnmdan1qp34s.jpg.thumb.jpg
|
/data/attachment/album/201806/09/232719ca6qhnmdan1qp34s.jpg
| true | false | true |
qhwdw
| false |
[
"序言",
"结语"
] |
技术
|
{
"viewnum": 5907,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9645,
"displayorder": 0
},
{
"raid": 9746,
"displayorder": 0
},
{
"raid": 9759,
"displayorder": 0
}
] |
我们讲解了 栈是如何工作的 以及在函数的序言上栈帧是如何被构建的。今天，我们来看一下它的相反的过程，在函数结语中栈帧是如何被销毁的。
| 2018-06-09T23:26:39 | 2018-06-09T23:26:39 | 9,731 |
/article-9731-1.html
|
上一周我们讲解了 [栈是如何工作的](/article-9645-1.html) 以及在函数的<ruby> 序言 <rt> prologue </rt></ruby>上栈帧是如何被构建的。今天，我们来看一下它的相反的过程，在函数<ruby> 结语 <rt> epilogue </rt></ruby>中栈帧是如何被销毁的。重新回到我们的 `add.c` 上：
```
int add(int a, int b)
{
int result = a + b;
return result;
}
int main(int argc)
{
int answer;
answer = add(40, 2);
}
```
*简单的一个做加法的程序 - add.c*
在运行到第 4 行时，在把 `a + b` 值赋给 `result` 后，这时发生了什么：
第一个指令是有些多余而且有点傻的，因为我们知道 `eax` 已经等于 `result` 了，但这就是关闭优化时得到的结果。`leave` 指令接着运行，这一小段做了两个任务：重置 `esp` 并将它指向到当前栈帧开始的地方，另一个是恢复在 `ebp` 中保存的值。这两个操作在逻辑上是独立的，因此，在图中将它们分开来说，但是，如果你使用一个调试器去跟踪，你就会发现它们都是自动发生的。
在 `leave` 运行后，恢复了前一个栈帧。`add` 调用唯一留下的东西就是在栈顶部的返回地址。它包含了运行完 `add` 之后在 `main` 中必须运行的指令的地址。`ret` 指令用来处理它：它弹出返回地址到 `eip` 寄存器（LCTT 译注：32 位的指令寄存器），这个寄存器指向下一个要执行的指令。现在程序将返回到 `main` ，主要部分如下：
`main` 从 `add` 中拷贝返回值到本地变量 `answer`，然后，运行它自己的<ruby> 结语 <rt> epilogue </rt></ruby>，这一点和其它的函数是一样的。在 `main` 中唯一的怪异之处是，保存在 `ebp` 中的是 `null` 值，因为它是我们的代码中的第一个栈帧。最后一步执行的是，返回到 C 运行时库（`libc`），它将退回到操作系统中。这里为需要的人提供了一个 [完整的返回顺序](https://manybutfinite.com/img/stack/returnSequence.png) 的图。
现在，你已经理解了栈是如何运作的，所以我们现在可以来看一下，一直以来最臭名昭著的黑客行为：利用缓冲区溢出。这是一个有漏洞的程序：
```
void doRead()
{
char buffer[28];
gets(buffer);
}
int main(int argc)
{
doRead();
}
```
*有漏洞的程序 - buffer.c*
上面的代码中使用了 [gets](http://linux.die.net/man/3/gets) 从标准输入中去读取内容。`gets` 持续读取直到一个新行或者文件结束。下图是读取一个字符串之后栈的示意图：
在这里存在的问题是，`gets` 并不知道缓冲区（`buffer`）大小：它毫无查觉地持续读取输入内容，并将读取的内容填入到缓冲区那边的栈，清除保存在 `ebp` 中的值、返回地址，下面的其它内容也是如此。对于利用这种行为，攻击者制作一个精密的载荷并将它“喂”给程序。在这个时候，栈应该是下图所示的样子，然后去调用 `gets`：
基本的思路是提供一个恶意的汇编代码去运行，通过覆写栈上的返回地址指向到那个代码。这有点像病毒侵入一个细胞，颠覆它，然后引入一些 RNA 去达到它的目的。
和病毒一样，挖掘者的载荷有许多特别的功能。它以几个 `nop` 指令开始，以提升成功利用的可能性。这是因为返回的地址是一个绝对的地址，需要猜测，而攻击者并不知道保存它的代码的栈的准确位置。但是，只要它们进入一个 `nop`，这个漏洞利用就成功了：处理器将运行 `nop` 指令，直到命中它希望去运行的指令。
`exec /bin/sh` 表示运行一个 shell 的原始汇编指令（假设漏洞是在一个网络程序中，因此，这个漏洞可能提供一个访问系统的 shell）。将一个命令或用户输入以原始汇编指令的方式嵌入到一个程序中的思路是很可怕的，但是，那只是让安全研究如此有趣且“脑洞大开”的一部分而已。对于防范这个怪异的 `get`，给你提供一个思路，有时候，在有漏洞的程序上，让它的输入转换为小写或者大写，将迫使攻击者写的汇编指令的完整字节不属于小写或者大写的 ascii 字母的范围内。
最后，攻击者重复猜测几次返回地址，这将再次提升他们的胜算。以 4 字节为界进行多次重复，它们就会更好地覆写栈上的原始返回地址。
幸亏，现代操作系统有了 [防止缓冲区溢出](http://paulmakowski.wordpress.com/2011/01/25/smashing-the-stack-in-2011/) 的一系列保护措施，包括不可执行的栈和<ruby> 栈内金丝雀 <rt> stack canary </rt></ruby>。这个 “<ruby> 金丝雀 <rt> canary </rt></ruby>” 名字来自 <ruby> <a href="http://en.wiktionary.org/wiki/canary_in_a_coal_mine"> 煤矿中的金丝雀 </a> <rt> canary in a coal mine </rt></ruby> 中的表述（LCTT 译注：指在过去煤矿工人下井时会带一只金丝雀，因为金丝雀对煤矿中的瓦斯气体非常敏感，如果进入煤矿后，金丝雀死亡，说明瓦斯超标，矿工会立即撤出煤矿。金丝雀做为煤矿中瓦斯预警器来使用），这是对计算机科学词汇的补充，用 Steve McConnell 的话解释如下：
>
> 计算机科学拥有比其它任何领域都丰富多彩的语言，在其它的领域中你进入一个无菌室，小心地将温度控制在 68°F，然后，能找到病毒、特洛伊木马、蠕虫、臭虫（bug）、炸弹（逻辑炸弹）、崩溃、爆发（口水战）、扭曲的变性者（双绞线转换头），以及致命错误吗？
>
>
> —— Steve McConnell 《代码大全 2》
>
>
>
不管怎么说，这里所谓的“栈金丝雀”应该看起来是这个样子的：
金丝雀是通过汇编来实现的。例如，由于 GCC 的 [栈保护器](http://gcc.gnu.org/onlinedocs/gcc-4.2.3/gcc/Optimize-Options.html) 选项的原因使金丝雀能被用于任何可能有漏洞的函数上。函数序言加载一个魔法值到金丝雀的位置，并且在函数结语时确保这个值完好无损。如果这个值发生了变化，那就表示发生了一个缓冲区溢出（或者 bug），这时，程序通过 [`__stack_chk_fail`](http://refspecs.linux-foundation.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/libc---stack-chk-fail-1.html) 被终止运行。由于金丝雀处于栈的关键位置上，它使得栈缓冲区溢出的漏洞挖掘变得非常困难。
深入栈的探秘之旅结束了。我并不想过于深入。下一周我将深入递归、尾调用以及其它相关内容。或许要用到谷歌的 V8 引擎。作为函数的序言和结语的讨论的结束，我引述了美国国家档案馆纪念雕像上的一句名言：（<ruby> 凡是过去 皆为序章 <rt> what is past is prologue </rt></ruby>）。
---
via:<https://manybutfinite.com/post/epilogues-canaries-buffer-overflows/>
作者：[Gustavo Duarte](http://duartes.org/gustavo/blog/about/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Fedora 系统上设置 zsh
|
Eduard Lucena
|
https://fedoramagazine.org/set-zsh-fedora-system/
|
对于一些人来说，终端可能会很吓人。但终端不仅仅是一个输入的黑屏。它通常运行一个 shell（外壳），如此称呼的原因是它围绕着内核。
|
/data/attachment/album/201806/09/234047chxm6e9nisfdbvvf.jpg.thumb.jpg
|
/data/attachment/album/201806/09/234047chxm6e9nisfdbvvf.jpg
| true | false | true |
geekpi
| false |
[
"zsh",
"shell"
] |
技术
|
{
"viewnum": 7490,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
对于一些人来说，终端可能会很吓人。但终端不仅仅是一个输入的黑屏。它通常运行一个 shell（外壳），如此称呼的原因是它围绕着内核。
| 2018-06-09T23:40:43 | 2018-06-09T23:40:43 | 9,732 |
/article-9732-1.html
|
对于一些人来说，终端可能会很吓人。但终端不仅仅是一个输入的黑屏。它通常运行一个 shell（外壳），如此称呼的原因是它围绕着内核。shell 是一个基于文本的界面，可让你在系统上运行命令。它有时也被称为<ruby> 命令行解释器 <rt> command line interpreter </rt></ruby>（CLI）。与大多数 Linux 发行版一样，Fedora 带有 bash 作为默认 shell。但是，它不是唯一可用的 shell，你可以安装其他的 shell。本文重点介绍 Z Shell （即 zsh）。
Bash 是对 UNIX 中提供的旧式 Bourne shell（sh）的重写（LCTT 译注：Bourne Again SHell）。zsh 视图通过更好的交互以比 bash 更友善。它的一些有用功能是：
* 可编程的命令行补全 \* 在运行的 shell 会话之间共享命令历史 \* 拼写纠正 \* 可加载模块 \* 交互式选择文件和文件夹
zsh 在 Fedora 仓库中存在。要安装，请运行以下命令：
```
$ sudo dnf install zsh
```
### 使用 zsh
要开始使用它，只需输入 `zsh`，新的 shell 在第一次运行时显示向导。该向导可帮助你配置初始功能，如历史记录行为和自动补全。或者你可以选择保持 [rc 文件](https://en.wikipedia.org/wiki/Configuration_file) 为空：
如果输入 `1`，则启动配置向导。其他选项立即启动 shell。
请注意，用户提示符是 `％` 而不是与 bash 的 `$`。这里的一个重要功能是自动补全功能，它允许你使用 `Tab` 键在文件和目录之间移动，非常类似于菜单：
另一个有趣的功能是拼写纠正，这有助于在混合大小写的情况下输入文件名：
使用 zsh 成为你的默认 shell
-------------------
zsh 提供了很多插件，如 zsh-syntax-highlighting 和著名的 “Oh my zsh”（[在此查看其页面](http://ohmyz.sh/)）。也许你希望将其设为默认 shell，以便在你在开始会话或打开终端时运行。为此，请使用 `chsh`（“更改 shell”）命令：
```
$ chsh -s $(which zsh)
```
这个命令告诉你的系统你要设置（`-s`）默认 shell 为该 shell 的正确位置（`which zsh`）。
图片来自 [Flickr](https://www.flickr.com/photos/katerha/34714051013/) 由 [Kate Ter Haar](https://www.flickr.com/photos/katerha/) 提供（CC BY-SA）。
---
via: <https://fedoramagazine.org/set-zsh-fedora-system/>
作者：[Eduard Lucena](https://fedoramagazine.org/author/x3mboy/) 选题：[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/) 荣誉推出
|
||
4 种基于 Markdown 的幻灯片生成器
|
Scott Nesbitt
|
https://opensource.com/article/18/5/markdown-slide-generators
|
这些简单的幻灯片创建工具可以无缝地使用 Markdown，可以让你的演示添加魅力。
|
/data/attachment/album/201806/09/234956jzrziipqpjci4djw.png.thumb.jpg
|
/data/attachment/album/201806/09/234956jzrziipqpjci4djw.png
| true | false | true |
pinewall
| false |
[
"markdown",
"演示",
"幻灯片"
] |
分享
|
{
"viewnum": 13981,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这些简单的幻灯片创建工具可以无缝地使用 Markdown，可以让你的演示添加魅力。
| 2018-06-09T23:49:51 | 2018-06-09T23:49:51 | 9,733 |
/article-9733-1.html
|
>
> 这些简单的幻灯片创建工具可以无缝地使用 Markdown，可以让你的演示添加魅力。
>
>
>
假设你需要做一个<ruby> 演示 <rt> presentation </rt></ruby>。在准备的过程中，你想到“我需要写几张幻灯片”。
你可能倾向于简洁的[纯文本](https://plaintextproject.online/)，认为 LibreOffice Writer 这样的软件对你要做的事情而言像是杀鸡用牛刀。或者你只是遵从你内心深处的极客意识。
将 [Markdown](https://en.wikipedia.org/wiki/Markdown) 格式的文件转换为优雅的演示幻灯片并不困难。下面介绍可以完成这项工作的四种工具。
### Landslide
在这些工具中，[Landslide](https://github.com/adamzap/landslide) 具有更高的灵活性。它是一个命令行工具，可以将 Markdown、[reStructuredText](https://en.wikipedia.org/wiki/ReStructuredText) 或 [Textile](https://en.wikipedia.org/wiki/Textile_(markup_language)) 格式的文件转换为基于 [Google HTML5 幻灯片模板](https://github.com/skaegi/html5slides)的 HTML 文件。
你要做的不过是编写 Markdown 格式的幻灯片源文件，打开一个终端窗口并运行 `landslide` 命令即可，其中命令参数为 Markdown 文件的文件名。Landslide 会生成 `presentation.html`，可以在任何 Web 浏览器中打开。简单吧？
但不要被简易的操作误导你。Landslide 提供了不少有用的特性，例如增加注记以及为幻灯片增加配置文件。为何要使用这些特性呢？按照 Landslide 开发者的说法，这样可以汇聚不同演示中的源文件目录并重用。
*在 Landslide 演示中查看演示者注记*
### Marp
[Marp](https://yhatt.github.io/marp/) 仍处于开发中，但值得期待。它是 “Markdown Presentation Writer” 的简写。Marp 是一个基于 [Electron](https://en.wikipedia.org/wiki/Electron_(software_framework)) 的工具，让你在一个简单的双栏编辑器中编写幻灯片：在左栏编写 Markdown，在右栏中预览效果。
Marp 支持 [GitHub 风格 Markdown](https://guides.github.com/features/mastering-markdown/)。如果你需要一个使用 GitHub 风格 Markdown 编写幻灯片的快速教程，可以参考 [示例项目](https://raw.githubusercontent.com/yhatt/marp/master/example.md)。GitHub 风格 Markdown 比基础 Markdown 更加灵活。
Marp 只自带两个基础主题，但你可以为幻灯片增加背景图片、调整图片大小以及增加数学表达式。不足之处，目前只支持 PDF 格式导出。老实说，我很好奇为何不一开始就提供 HTML 格式导出。
*使用 Marp 编辑简单的幻灯片*
### Pandoc
你可能已经知道 [pandoc](https://pandoc.org/) 是一种支持多种<ruby> 标记语言 <rt> markup languages </rt></ruby>相互转换的神奇工具。但你可能不知道，pandoc 可以将 Markdown 格式文件转换为 [Slidy](https://www.w3.org/Talks/Tools/Slidy2/Overview.html#(1))、[Slideous](http://goessner.net/articles/slideous/)、[DZSlides](http://paulrouget.com/dzslides/) 和 [Reveal.js](https://revealjs.com/#/) 等演示框架支持的优雅 HTML 幻灯片。如果你使用 [LaTeX](https://www.latex-project.org/)，可以使用 [Beamer 软件包](https://en.wikipedia.org/wiki/Beamer_(LaTeX))输出 PDF 格式的幻灯片。
你需要在幻灯片中[使用特定格式](https://pandoc.org/MANUAL.html#producing-slide-shows-with-pandoc)，但可以通过[变量](https://pandoc.org/MANUAL.html#variables-for-slides)控制其效果。你也可以更改幻灯片的外观与风格，增加幻灯片之间的暂停，添加演示者注记等。
当然，你需要在你的主机上安装你喜欢的演示框架，因为 Pandoc 只生成原始幻灯片文件。
*查看使用 Pandoc 和 DZSlides 创建的幻灯片*
### Hacker Slides
[Hacker Slides](https://github.com/jacksingleton/hacker-slides) 是一个 [Sandstorm](https://sandstorm.io/) 和 [Sandstorm Oasis](https://oasis.sandstorm.io/) 平台上的应用，基于 Markdown 和 [Reveal.js](https://revealjs.com/#/) 幻灯片框架。生成的幻灯片可以比较朴素，也可以很炫。
在浏览器的两栏界面中编写幻灯片，左栏输入 Markdown 文本，右栏渲染效果。当你制作完成后，可以在 Sandstorm 中演示，也可以生成分享链接让其它人演示。
你可能会说，你不使用 Sandstorm 或 Sandstorm Oasis 怎么办？不要担心，Hacker Slides 提供了可以在桌面或服务器上运行的[版本](https://github.com/msoedov/hacker-slides)。
*在 Hacker Slides 中编辑幻灯片*
### 两点特别补充
如果你使用 [Jupyter <ruby> 笔记本 <rt> Notebooks </rt></ruby>](http://jupyter.org/) （参考社区版主 Don Watkins 的[文章](/article-9664-1.html)）发布数据或指令文本，你可以使用 [Jupyter2slides](https://github.com/datitran/jupyter2slides)。该工具基于 Reveal.js，可以将笔记本转换为一系列精美的 HTML 幻灯片。
如果你倾向于托管应用，试试 [GitPitch](https://gitpitch.com/)，支持 GitHub、GitLab 和 Bitbucket。只需在将幻灯片源文件推送到支持的代码仓库中，在 GitPitch 中指向该仓库，这样你就可以在 GitPitch 网站上看到你的幻灯片了。
你有最喜欢的基于 Markdown 的幻灯片生成器吗？留下评论分享吧。
---
via: <https://opensource.com/article/18/5/markdown-slide-generators>
作者：[Scott Nesbitt](https://opensource.com/users/scottnesbitt) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
面向 Linux 和开源爱好者的书单
|
Jen Wike Huger
|
https://opensource.com/article/18/5/list-books-Linux-open-source
|
看看我们现在在读什么？
|
/data/attachment/album/201806/11/085543tn69uken8kd2kglb.jpg.thumb.jpg
|
/data/attachment/album/201806/11/085543tn69uken8kd2kglb.jpg
| true | false | true |
pinewall
| true |
[
"书籍"
] |
分享
|
{
"viewnum": 12850,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
看看我们现在在读什么？
| 2018-06-11T08:55:40 | 2018-06-11T08:55:40 | 9,734 |
/article-9734-1.html
|
>
> 看看我们现在在读什么？
>
>
>
最近我在作者社区征集分享大家正在读的书。大家生活阅历和工作岗位各不相同，共同点是每天都与 Linux 和开源打交道。
享受这份不可思议的书单吧，其中大部分是免费的，可以下载。
在书单中，你可能发现一直想读的书、完全陌生的书以及像老朋友一样的已经读过的书。
我们期待你给出对书单的看法，可以在分享在下方的评论区，也可以通过 #Linuxbooks 和 #opensourcebooks 主题词分享在 Twitter 上。
### 加入你书单的 17 本书
**文末，还附赠了一篇科幻小说作品。**
#### [*FreeDOS 的 23 年岁月*](http://www.freedos.org/ebook/)，作者 Jim Hall
从去年起，[FreeDOS](https://opensource.com/article/18/5/node/44116) 项目已经 23 岁了。虽然在 23 年中并没有什么特殊事件，但该项目决定庆祝这个里程碑，形式为分享不同人群使用 FreeDOS 或对 FreeDOS 做出贡献的故事。这本以 CC BY 协议开源的书籍收录了一系列短文，描绘了 FreeDOS 从 1994 开始的历程，以及人们现在如何使用 FreeDOS。（[Jim Hall](https://opensource.com/users/jim-hall) 推荐并评论）
#### [*JavaScript 编程精解*](https://eloquentjavascript.net/)，作者 Marijn Haverbeke
这本书基于无处不在的编程语言 [Javascript](https://opensource.com/article/18/5/node/32826)，教你编写制作精美的程序。你可以学习语言的基本知识和高级特性，学习如何编写可在浏览器或 Node.js 环境中运行的程序。本书包含 5 个有趣的项目，例如制作游戏平台，甚至编写你自己的编程语言，在这过程中你会更加深入理解真实的编程。（[Rahul Thakoor](https://opensource.com/users/rahul27) 推荐并评论）
#### [*使用开源打造未来*](https://pragprog.com/book/vbopens/forge-your-future-with-open-source)，作者 VM (Vicky) Brasseur
如果你希望在开源领域做出贡献但无从下手，这本书会教会你。内容包括如何确定要加入的项目，以及如何做出你的首次贡献。（[Ben Cotton](https://opensource.com/users/bcotton) 推荐并评论）
#### [*Git 团队协作*](http://gitforteams.com/)，作者 Emma Jane Hogbin Westby
Git 是一款版本管理系统，被个人和团队广泛使用；但其强大的功能也意味着复杂性。这本书指导你如何在团队环境中有效地使用 [Git](https://opensource.com/article/18/5/node/43741)。想了解更多信息，请参考我们的[深入点评](https://opensource.com/business/15/11/git-for-teams-review)。（[Ben Cotton](https://opensource.com/users/bcotton) 推荐并评论）
#### [*谈判力*](http://www.williamury.com/books/getting-to-yes/)，作者 Fisher, Ury 及 Patton
<ruby> 哈佛谈判项目 <rt> The Harvard Negotiation Project </rt></ruby>成立于 20 世纪七十年代，是一个经济学家、心理学家、社会学家和政治学者共同参与的学术项目，目标是建立一个让谈判各方都受益更多的谈判框架。他们的框架和技巧已经在各类场景发挥作用，其中包括 1978 年埃及与以色列之间的签订的<ruby> 戴维营协议 <rt> Camp David Accords </rt></ruby>。
<ruby> 原则式谈判 <rt> Principled Negotiation </rt></ruby> 包括理解谈判参与者的真实需求，以及基于该信息达成各方都可接受的条款。同样的技巧可以在处理人与人之间的纠纷、关于车辆与房屋的谈判以及与保险公司的商讨时发挥作用。
这与开源软件开发有什么联系呢？在某种意义上，开源领域中的一切都是谈判。提交漏洞报告就是指出某些代码工作不正常，让某些人放下手头工作并优先处理该漏洞。邮件列表中对完成某些工作的正确方式的激烈讨论或对功能请求的评论，都是一种关于项目范畴和目标的谈判，通常是在信息不充足情况下进行的。
将上述对话视为一种探索，试图理解为何其它人提出来某些需求，让其明白你为何持有另外的观点，可以让你在开源项目中显著地改善人际关系和提高工作效率。（[Dave Neary](https://opensource.com/users/dneary) 推荐并评论）
#### [*只是为了好玩：Linux 之父 Linus Torvalds 自传*](http://a.co/749s27n)，作者 Linus Torvalds 等
Linux 是一款令人惊奇的、强力的操作系统，引发了关于透明和开放的运动。驱动 Linux 的开源思潮对传统商业和资本增值模型造成冲击。在本书中，你会了解到 Linus 本人及 [Linux](https://opensource.com/article/18/5/node/19796) 操作系统的过人之处。洞悉那些改变 Linus 命运的经历，这些经历让他从一个喜欢折腾他祖父钟表的怪人，转变成编写全球主流操作系统 Linux 的大师。（[Don Watkins](https://opensource.com/users/don-watkins) 推荐并评论）
#### [*1 个月速成 Linux*](https://manning.com/ovadia)，作者 Steven Ovadia
这本书用于教会非技术领域的用户如何使用桌面版 [Linux](https://opensource.com/article/18/5/node/42626)，读者每天花费一小时即可。这本书覆盖面比较很广，包括选择桌面环境、安装软件以及如何使用 Git。阅读完这本书，你可以完全使用 Linux 替换掉其它操作系统。（[Steven Ovadia](https://opensource.com/users/stevenov) 推荐并评论）
#### [*Linux 实战*](https://www.manning.com/books/linux-in-action?a_aid=bootstrap-it&a_bid=4ca15fc9)，作者 David Clinton
这本身介绍了不少 Linux 管理工具的干货，适用于想提升技术水平的人群，包括 IT 专家、开发者、[DevOps](https://opensource.com/article/18/5/node/44696) 专家等。本书不是割裂地介绍各种技术，而是按照真实项目组织内容，例如异地备份自动化、Web 服务器安全加密以及搭建可以安全连接公司资源的 VPN 等。更多内容可以参考作者的[另一本书](https://bootstrap-it.com/index.php/books/)。（[David Clinton](https://opensource.com/users/dbclinton) 推荐并评论）
#### [*创客丛书： 为创客准备的 Linux*](https://www.makershed.com/products/make-linux-for-makers)，作者 Aaron Newcomb
对于想通过 [树莓派](https://opensource.com/article/18/5/node/35731) 创造和创新的人来说，这本书是必读的。这本书将领你入门，让你玩转你的树莓派，同时帮你理解 Raspbian Linux 操作系统（与传统 Linux ）的细微差别。书中文字巧妙又浅显，可以让任何阅读本书的创客解锁树莓派的潜力。文字简洁，编写精良，包含大量极好的阐述和实战案例。（Jason Hibbets 推荐，[Don Watkins](https://opensource.com/users/don-watkins) 评论）
#### [*人性管理：一个软件工程经理刺激诙谐的经历*](https://www.amazon.com/Managing-Humans-Humorous-Software-Engineering/dp/1484221575/ref=dp_ob_title_bk) by Michael Lopp
Michael Lopp 是热门博客 [Rands 在休息](http://randsinrepose.com/)的作者，他的笔名 Rands 更为人熟知。这本书是在博客帖子的基础上修订集结而成，内容为软件开发团队的管理。Rands 的工作哲学为“软件开发中最复杂的部分是人际交往”，这是我对于本书和博客内容最欣赏的一点。本书涵盖一系列主题，包括分析一个团队，理解每个团队成员的个性以及设计如何让每个人都各尽所能。
这些主题适用面很广，作为一个开源社区管理者，我一直和这些事情打交道。如何得知某个成员已经精疲力尽？如何组织一个好的会议？如何在项目和团队扩大时形成项目和团队文化？如何判断流程是适度的？在开发之外，这类问题一直涌现出来；Rands 的不羁、诙谐的看法让人受教的同时给人感到快乐。（[Dave Neary](https://opensource.com/users/dneary) 推荐并评论）
#### [*开源：来自开源革命的呐喊*](https://www.oreilly.com/openbook/opensources/book/index.html) (O'Reilly, 1999)
对于开源狂热者而言，这本书是必读的。Linus Torvalds、Eric S. Raymond、Richard Stallman、Michael Tiemann、 Tim O'Reilly 等开源运动中的领军人物分享他们对发展迅猛的[开源软件](https://opensource.com/article/18/5/node/42001)运动的看法。（[Jim Hall](https://opensource.com/users/jim-hall) 推荐，Jen Wike Huger 评论）
#### [*创作开源软件：如何运营一个成功的自由软件项目*](https://producingoss.com/)，作者 Karl Fogel
这本书面向人群包括，期望建立或已经正在建立开源社区，或更好的理解成功开源项目社区的开发趋势。Karl Fogel 分析研究了成功开源项目的特点，以及它们如何围绕项目发展成社区。对于如何围绕项目发展社区，这本书为社区管理者（或致力于成为社区管理者的人）提供了建设性的建议。鲜有书籍可以（像本书这样）深入观察开源社区的发展并给出大量成功点子，但你仍需要结合你的项目和社区因地制宜的行动。（[Justin Flory](https://opensource.com/users/justinflory) 推荐并评论）
#### [*机器人编程*](http://engineering.nyu.edu/gk12/amps-cbri/pdf/RobotC%20FTC%20Books/notesRobotC.pdf)，作者 Albert W. Schueller
这本书介绍乐高头脑风暴 NXT 编程的基础。并不需要读者编写复杂的程序，而是通过编程让设备可以感知并与真实世界进行交互。通过完成传感器、电机实验，以及编程制作音乐，你可以了解软硬件如何协调工作。（[Rahul Thakoor](https://opensource.com/users/rahul27) 推荐并评论）
#### [*AWK 编程语言*](https://archive.org/details/pdfy-MgN0H1joIoDVoIC7)，作者 Alfred V. Aho, Brian W. Kernighan 和 Peter J. Weinberger
这本书的作者就是 awk 语言的发明者，本书风格类似于 20 世纪 70 至 90 年代贝尔实验室 Unix 小组出版的类 Unix 工具书籍，使用简明、紧凑的文字介绍了 awk 的原理和目标。书中包含不少示例，从简单的开始，后面会结合描述详尽的问题或前沿案例，示例也变得复杂。本书刚出版时，典型的读者需求如下：处理和转换文本或数据文件，以及便捷地创建查询表、使用正则表达式、根据输入调整结构、对数值执行数学变换并便捷设置输出格式等。
上述需求依然存在，现在这本书也可以给人们提供一个回顾那个只能使用终端交互的年代的机会。在那时，通过“模块化”可以使用多个单一用途的程序编写 shell 脚本，用于管道处理数据，最终计算机给出人们预期的结果。在今天，awk 被视为运维工具，在处理配置文件和日志文件方面效果不错，这本书也介绍了一些这方面的内容。（[Jim Hall](https://opensource.com/users/jim-hall) 推荐，[Chris Hermansen](https://opensource.com/users/clhermansen) 评论）
#### [*像计算机科学家一样思考 Python*](http://greenteapress.com/thinkpython2/thinkpython2.pdf)，作者 Allen Downey
这本书是作者系列图书中的一本，介绍 Python 编程语言，系列中还有其它编程语言，包括 Java 和 [Perl](https://opensource.com/article/18/5/node/35141) 等。介绍完基础的编程语法后，本书进入主题环节，着重介绍问题解决者如何构建解决方案。本书概念层次清晰，对编程初学者是很好的入门读物；对于希望在课堂等地方提高编程技能的新手，本书也适用；本书的若干章节配有例子和习题，可供测试已学的技能。（[Steve Morris](https://opensource.com/users/smorris12) 介绍并评论）
#### [*认识开源和自由软件协议*](http://shop.oreilly.com/product/9780596005818.do) (O'Reilly, 2004)
“这本书填补了开源理念与法律基础上的真实意义之间的空白。如果你对开源和自由软件协议感兴趣，那么本书可以帮忙加深理解。如果你是一名开源/自由软件开发者，这本书显然是必须的。“（[Jim Hall](https://opensource.com/users/jim-hall) 推荐，评论来自 [Amazon](https://www.amazon.com/Understanding-Open-Source-Software-Licensing/dp/0596005814)）
#### [*Unix 文本处理*](http://www.oreilly.com/openbook/utp/)，作者 Dale Dougherty 及 Tim O'Reilly
本书写于 1987 年，用于介绍 Unix 系统及作家如何使用 Unix 工具帮助其工作。对于希望学习包括 vi 编辑器、awk、shell 脚本在内的 Unix shell 基础及 nroff/troff 排版系统的初学者而言，本书仍然是有用的资源。原版已绝版，但 O'Reilly 将本书制作为电子书，可在其网站上免费获得。（[Jim Hall](https://opensource.com/users/jim-hall) 推荐并评论）
### 福利：科幻小说
#### [*11 号太空站*](http://www.emilymandel.com/stationeleven.html)，作者 Emily St. John Mandel
故事时间设定为不远的未来，地球人口随着神秘而致命的流感爆发而锐减，故事发生在 20 年后。主人公 Kirsten Raymonde 是一名年轻女性，坚信“仅仅活着是不够的”，为此她在后世界末日时代带着一个游牧剧团在五大湖区域附近勇敢地旅行。这是个精彩的故事，很值得一读。
这本书让我震惊的是我们与技术之间实际上那么脆弱的关系。Douglas Adams 的 《Mostly Harmless》 书中有一句话很经典：“仅靠双手，他无法制造一个面包机。但他可以制作三明治，就是这样”。在 Kristin Raymonde 的世界中，每个人仅能靠自己的双手。这里没有电，因为电力网络无法运作；没有汽车，因为炼油厂无法运作。
书中有一个有趣的桥段，一个发明家使用自行车组装了一台发电机，试图启动一台笔记本电脑，尝试查看是否还存在互联网。我们看到旧世界留存的、无用的东西堆成的文明博物馆，内容包括护照、移动电话、信用卡和高跟鞋等。
世界上的全部技术都变得无用。（[Dave Neary](https://opensource.com/users/dneary) 推荐并评论）
---
via: <https://opensource.com/article/18/5/list-books-Linux-open-source>
作者：[Jen Wike Huger](https://opensource.com/users/remyd) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Ohcount：源代码行计数器和分析器
|
Sk
|
https://www.ostechnix.com/ohcount-the-source-code-line-counter-and-analyzer/
|
它不仅仅是代码行计数器，还可以在含有大量代码的目录中检测流行的开源许可证，和检测针对特定编程 API（例如 KDE 或 Win32）的代码。
|
/data/attachment/album/201806/11/113250p2y8yxxxmv1hieme.jpg.thumb.jpg
|
/data/attachment/album/201806/11/113250p2y8yxxxmv1hieme.jpg
| true | false | true |
geekpi
| false |
[
"代码"
] |
技术
|
{
"viewnum": 5341,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
它不仅仅是代码行计数器，还可以在含有大量代码的目录中检测流行的开源许可证，和检测针对特定编程 API（例如 KDE 或 Win32）的代码。
| 2018-06-11T11:33:02 | 2018-06-11T11:33:02 | 9,735 |
/article-9735-1.html
|
**Ohcount** 是一个简单的命令行工具，可用于分析源代码并打印代码的总行数。它不仅仅是代码行计数器，还可以在含有大量代码的目录中检测流行的开源许可证，例如 GPL。此外，Ohcount 还可以检测针对特定编程 API（例如 KDE 或 Win32）的代码。在编写本指南时，Ohcount 目前支持 70 多种流行的编程语言。它用 **C** 语言编写，最初由 **Ohloh** 开发，用于在 [www.openhub.net](http://www.openhub.net) 中生成报告。
在这篇简短的教程中，我们将介绍如何安装和使用 Ohcount 来分析 Debian、Ubuntu 及其变体（如 Linux Mint）中的源代码文件。
### Ohcount – 代码行计数器
#### 安装
Ohcount 存在于 Debian 和 Ubuntu 及其派生版的默认仓库中，因此你可以使用 APT 软件包管理器来安装它，如下所示。
```
$ sudo apt-get install ohcount
```
#### 用法
Ohcount 的使用非常简单。
你所要做的就是进入你想要分析代码的目录并执行程序。
举例来说，我将分析 [coursera-dl](https://www.ostechnix.com/coursera-dl-a-script-to-download-coursera-videos/) 程序的源代码。
```
$ cd coursera-dl-master/
$ ohcount
```
以下是 Coursera-dl 的行数摘要：
如你所见，Coursera-dl 的源代码总共包含 141 个文件。第一列说明源码含有的编程语言的名称。第二列显示每种编程语言的文件数量。第三列显示每种编程语言的总行数。第四行和第五行显示代码中由多少行注释及其百分比。第六列显示空行的数量。最后一列和第七列显示每种语言的全部代码行数以及 coursera-dl 的总行数。
或者，直接使用下面的完整路径。
```
$ ohcount coursera-dl-master/
```
路径可以是任何数量的单个文件或目录。目录将被递归探测。如果没有给出路径，则使用当前目录。
如果你不想每次都输入完整目录路径，只需 cd 进入它，然后使用 ohcount 来分析该目录中的代码。
要计算每个文件的代码行数，请使用 `-i` 标志。
```
$ ohcount -i
```
示例输出：
当您使用 `-a` 标志时，ohcount 还可以显示带标注的源码。
```
$ ohcount -a
```
如你所见，显示了目录中所有源代码的内容。每行都以制表符分隔的语言名称和语义分类（代码、注释或空白）为前缀。
有时候，你只是想知道源码中使用的许可证。为此，请使用 `-l` 标志。
```
$ ohcount -l
lgpl3, coursera_dl.py
gpl coursera_dl.py
```
另一个可用选项是 `-re`，用于将原始实体信息打印到屏幕（主要用于调试）。
```
$ ohcount -re
```
要递归地查找给定路径内的所有源码文件，请使用 `-d` 标志。
```
$ ohcount -d
```
上述命令将显示当前工作目录中的所有源码文件，每个文件名将以制表符分隔的语言名称为前缀。
要了解更多详细信息和支持的选项，请运行：
```
$ ohcount --help
```
对于想要分析自己或其他开发人员开发的代码，并检查代码的行数，用于编写这些代码的语言以及代码的许可证详细信息等，ohcount 非常有用。
就是这些了。希望对你有用。会有更好的东西。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/ohcount-the-source-code-line-counter-and-analyzer/>
作者：[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 中使用 Stratis 配置本地存储
|
Andy Grover
|
https://opensource.com/article/18/4/stratis-easy-use-local-storage-management-linux
|
关注于易用性，Stratis 为桌面用户提供了一套强力的高级存储功能。
|
/data/attachment/album/201806/11/115418aq0e85ss081523sn.jpg.thumb.jpg
|
/data/attachment/album/201806/11/115418aq0e85ss081523sn.jpg
| true | false | true |
pinewall
| false |
[
"Stratis",
"存储"
] |
技术
|
{
"viewnum": 6097,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9743,
"displayorder": 0
}
] |
关注于易用性，Stratis 为桌面用户提供了一套强力的高级存储功能。
| 2018-06-11T11:54:24 | 2018-06-11T11:54:24 | 9,736 |
/article-9736-1.html
|
>
> 关注于易用性，Stratis 为桌面用户提供了一套强力的高级存储功能。
>
>
>
对桌面 Linux 用户而言，极少或仅在安装系统时配置本地存储。Linux 存储技术进展比较慢，以至于 20 年前的很多存储工具仍在今天广泛使用。但从那之后，存储技术已经提升了不少，我们为何不享受新特性带来的好处呢？
本文介绍 Startis，这是一个新项目，试图让所有 Linux 用户从存储技术进步中受益，适用场景可以是仅有一块 SSD 的单台笔记本，也可以是包含上百块硬盘的存储阵列。Linux 支持新特性，但由于缺乏易于使用的解决方案，使其没有被广泛采用。Stratis 的目标就是让 Linux 的高级存储特性更加可用。
### 简单可靠地使用高级存储特性
Stratis 希望让如下三件事变得更加容易：存储初始化配置；后续变更；使用高级存储特性，包括<ruby> 快照 <rt> snapshots </rt></ruby>、<ruby> 精简配置 <rt> thin provisioning </rt></ruby>，甚至<ruby> 分层 <rt> tiering </rt></ruby>。
### Stratis：一个卷管理文件系统
Stratis 是一个<ruby> 卷管理文件系统 <rt> volume-managing filesystem </rt></ruby>（VMF），类似于 [ZFS](https://en.wikipedia.org/wiki/ZFS) 和 [Btrfs](https://en.wikipedia.org/wiki/Btrfs)。它使用了存储“池”的核心思想，该思想被各种 VMF 和 形如 [LVM](https://en.wikipedia.org/wiki/Logical_Volume_Manager_(Linux)) 的独立卷管理器采用。使用一个或多个硬盘（或分区）创建存储池，然后在存储池中创建<ruby> 卷 <rt> volume </rt></ruby>。与使用 [fdisk](https://en.wikipedia.org/wiki/Fdisk) 或 [GParted](https://gparted.org/) 执行的传统硬盘分区不同，存储池中的卷分布无需用户指定。
VMF 更进一步与文件系统层结合起来。用户无需在卷上部署选取的文件系统，因为文件系统和卷已经被合并在一起，成为一个概念上的文件树（ZFS 称之为<ruby> 数据集 <rt> dataset </rt></ruby>，Brtfs 称之为<ruby> 子卷 <rt> subvolume </rt></ruby>，Stratis 称之为文件系统），文件数据位于存储池中，但文件大小仅受存储池整体容量限制。
换一个角度来看：正如文件系统对其中单个文件的真实存储块的实际位置做了一层<ruby> 抽象 <rt> abstract </rt></ruby>，而 VMF 对存储池中单个文件系统的真实存储块的实际位置做了一层抽象。
基于存储池，我们可以启用其它有用的特性。特性中的一部分理所当然地来自典型的 VMF <ruby> 实现 <rt> implementation </rt></ruby>，例如文件系统快照，毕竟存储池中的多个文件系统可以共享<ruby> 物理数据块 <rt> physical data block </rt></ruby>；<ruby> 冗余 <rt> redundancy </rt></ruby>，分层，<ruby> 完整性 <rt> integrity </rt></ruby>等其它特性也很符合逻辑，因为存储池是操作系统中管理所有文件系统上述特性的重要场所。
上述结果表明，相比独立的卷管理器和文件系统层，VMF 的搭建和管理更简单，启用高级存储特性也更容易。
### Stratis 与 ZFS 和 Btrfs 有哪些不同？
作为新项目，Stratis 可以从已有项目中吸取经验，我们将在[第二部分](https://opensource.com/article/18/4/stratis-lessons-learned)深入介绍 Stratis 采用了 ZFS、Brtfs 和 LVM 的哪些设计。总结一下，Stratis 与其不同之处来自于对功能特性支持的观察，来自于个人使用及计算机自动化运行方式的改变，以及来自于底层硬件的改变。
首先，Stratis 强调易用性和安全性。对个人用户而言，这很重要，毕竟他们与 Stratis 交互的时间间隔可能很长。如果交互不那么友好，尤其是有丢数据的可能性，大部分人宁愿放弃使用新特性，继续使用功能比较基础的文件系统。
第二，当前 API 和 <ruby> DevOps 式 <rt> Devops-style </rt></ruby>自动化的重要性远高于早些年。Stratis 提供了支持自动化的一流 API，这样人们可以直接通过自动化工具使用 Stratis。
第三，SSD 的容量和市场份额都已经显著提升。早期的文件系统中很多代码用于优化机械介质访问速度慢的问题，但对于基于闪存的介质，这些优化变得不那么重要。即使当存储池过大而不适合使用 SSD 的情况，仍可以考虑使用 SSD 充当<ruby> 缓存层 <rt> caching tier </rt></ruby>，可以提供不错的性能提升。考虑到 SSD 的优良性能，Stratis 主要聚焦存储池设计方面的<ruby> 灵活性 <rt> flexibility </rt></ruby>和<ruby> 可靠性 <rt> reliability </rt></ruby>。
最后，与 ZFS 和 Btrfs 相比，Stratis 具有明显不一样的<ruby> 实现模型 <rt> implementation model </rt></ruby>（我会在[第二部分](https://opensource.com/article/18/4/stratis-lessons-learned)进一步分析）。这意味着对 Stratis 而言，虽然一些功能较难实现，但一些功能较容易实现。这也加快了 Stratis 的开发进度。
### 了解更多
如果希望更多了解 Stratis，可以查看本系列的[第二部分](https://opensource.com/article/18/4/stratis-lessons-learned)。你还可以在 [Stratis 官网](https://stratis-storage.github.io/) 找到详细的[设计文档](https://stratis-storage.github.io/StratisSoftwareDesign.pdf)。
### 如何参与
如果希望参与开发、测试 Stratis 或给出反馈，请订阅我们的[邮件列表](https://lists.fedoraproject.org/admin/lists/stratis-devel.lists.fedorahosted.org/)。
[GitHub](https://github.com/stratis-storage/) 上的开发项目包括 [守护进程](https://github.com/stratis-storage/stratisd) （使用 [Rust](https://www.rust-lang.org/) 开发）和 [命令行工具](https://github.com/stratis-storage/stratis-cli) （使用 [Python](https://www.python.org/) 开发）两部分。
可以在 [Freenode](https://freenode.net/) IRC 网络的 #stratis-storage 频道加入我们。
Andy Grover 将在今年的 LinuxFest Northwest 会议上演讲。查看[会议安排](https://www.linuxfestnorthwest.org/conferences/lfnw18) 或 [注册参会](https://www.linuxfestnorthwest.org/conferences/lfnw18/register/new)。
---
via: <https://opensource.com/article/18/4/stratis-easy-use-local-storage-management-linux>
作者：[Andy Grover](https://opensource.com/users/agrover) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 RHEL 中使用订阅管理器启用软件仓库
|
Kerneltalks
|
https://kerneltalks.com/howto/how-to-enable-repository-using-subscription-manager-in-rhel/
|
了解如何在 RHEL 中使用订阅管理器来启用软件仓库。 这篇文章还包括了将系统注册到 Red Hat 的步骤、添加订阅和发生错误时的解决方案。
|
/data/attachment/album/201806/12/102117vbr929yzx2m8hmpf.png.thumb.jpg
|
/data/attachment/album/201806/12/102117vbr929yzx2m8hmpf.png
| true | false | true |
S9mtAt
| false |
[
"RedHat",
"RHEL",
"订阅"
] |
技术
|
{
"viewnum": 7994,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
了解如何在 RHEL 中使用订阅管理器来启用软件仓库。 这篇文章还包括了将系统注册到 Red Hat 的步骤、添加订阅和发生错误时的解决方案。
| 2018-06-12T10:21:12 | 2018-06-12T10:21:12 | 9,737 |
/article-9737-1.html
|
>
> 了解如何在 RHEL 中使用订阅管理器来启用软件仓库。 这篇文章还包括了将系统注册到 Red Hat 的步骤、添加订阅和发生错误时的解决方案。
>
>
>
在本文中，我们将逐步介绍如何在刚安装的 RHEL 服务器中启用 Red Hat 软件仓库。
可以利用 `subscription-manager` 命令启用软件仓库，如下所示：
```
root@kerneltalks # subscription-manager repos --enable rhel-6-server-rhv-4-agent-beta-debug-rpms
Error: 'rhel-6-server-rhv-4-agent-beta-debug-rpms' does not match a valid repository ID. Use "subscription-manager repos --list" to see valid repositories.
```
当您的订阅没有配置好时，您会看到上述错误。让我们一步一步地通过 `subscription-manager` 来启用软件仓库。
### 步骤 1：使用 Red Hat 注册您的系统
这里假设您已经安装了新系统并且尚未在 Red Hat 上注册。如果您已经注册了该系统，那么您可以忽略此步骤。
您可以使用下面的命令来检查您的系统是否已在 Red Hat 注册了该订阅：
```
# subscription-manager version
server type: This system is currently not registered.
subscription management server: Unknown
subscription management rules: Unknown
subscription-manager: 1.18.10-1.el6
python-rhsm: 1.18.6-1.el6
```
在这里输出的第一行中，您可以看到该系统未注册。那么，让我们开始注册系统。您需要在 `subscription-manager` 命令中使用 `register` 选项。在这一步需要使用您的 Red Hat 帐户凭证。
```
root@kerneltalks # subscription-manager register
Registering to: subscription.rhsm.redhat.com:443/subscription
Username: admin@kerneltalks.com
Password:
Network error, unable to connect to server. Please see /var/log/rhsm/rhsm.log for more information.
```
如果您遇到上述错误，那么表明您的服务器无法连接到 RedHat。检查您的网络连接，或者您能[解决网站名称解析的问题](https://kerneltalks.com/howto/how-to-configure-nameserver-in-linux/)。有时候，即使你能够 ping 通订阅服务器，你也会看到这个错误。这可能是因为您的环境中有代理服务器。在这种情况下，您需要将其详细信息添加到文件 `/etc/rhsm/rhsm.conf` 中。以下详细的代理信息应根据你的环境填充：
```
# an http proxy server to use
proxy_hostname =
# port for http proxy server
proxy_port =
# user name for authenticating to an http proxy, if needed
proxy_user =
# password for basic http proxy auth, if needed
proxy_password =
```
一旦你完成了这些，通过使用下面的命令重新检查 `subscription-manager` 是否获得了新的代理信息：
```
root@kerneltalks # subscription-manager config
[server]
hostname = [subscription.rhsm.redhat.com]
insecure = [0]
port = [443]
prefix = [/subscription]
proxy_hostname = [kerneltalksproxy.abc.com]
proxy_password = [asdf]
proxy_port = [3456]
proxy_user = [user2]
server_timeout = [180]
ssl_verify_depth = [3]
[rhsm]
baseurl = [https://cdn.redhat.com]
ca_cert_dir = [/etc/rhsm/ca/]
consumercertdir = [/etc/pki/consumer]
entitlementcertdir = [/etc/pki/entitlement]
full_refresh_on_yum = [0]
manage_repos = [1]
pluginconfdir = [/etc/rhsm/pluginconf.d]
plugindir = [/usr/share/rhsm-plugins]
productcertdir = [/etc/pki/product]
repo_ca_cert = /etc/rhsm/ca/redhat-uep.pem
report_package_profile = [1]
[rhsmcertd]
autoattachinterval = [1440]
certcheckinterval = [240]
[logging]
default_log_level = [INFO]
[] - Default value in use
```
现在，请尝试重新注册您的系统。
```
root@kerneltalks # subscription-manager register
Registering to: subscription.rhsm.redhat.com:443/subscription
Username: admin@kerneltalks.com
Password:
You must first accept Red Hat's Terms and conditions. Please visit https://www.redhat.com/wapps/tnc/termsack?event[]=signIn . You may have to log out of and back into the Customer Portal in order to see the terms.
```
如果您是第一次将服务器添加到 Red Hat 帐户，您将看到上述错误。转到该 [URL](https://www.redhat.com/wapps/tnc/termsack?event%5B%5D=signIn)并接受条款。回到终端，然后再试一次。
```
oot@kerneltalks # subscription-manager register
Registering to: subscription.rhsm.redhat.com:443/subscription
Username: admin@kerneltalks.com
Password:
The system has been registered with ID: xxxxb2-xxxx-xxxx-xxxx-xx8e199xxx
```
Bingo！系统现在已在 Red Hat 上注册。你可以再次用 `version` 选项来验证它。
```
#subscription-managerversionservertype:RedHatSubscriptionManagementsubscriptionmanagementserver:2.0.43-1subscriptionmanagementrules:5.26subscription-manager:1.18.10-1.el6python-rhsm:1.18.6-1.el6" decode="true" ]root@kerneltalks # subscription-manager version
server type: Red Hat Subscription Management
subscription management server: 2.0.43-1
subscription management rules: 5.26
subscription-manager: 1.18.10-1.el6
python-rhsm: 1.18.6-1.el6
```
### 步骤 2：将订阅添加到您的服务器
首先尝试列出软件仓库。您将无法列出任何内容，因为我们尚未在我们的服务器中添加任何订阅。
```
root@kerneltalks # subscription-manager repos --list
This system has no repositories available through subscriptions.
```
正如您所看到 `subscription-manager` 找不到任何软件仓库，您需要将订阅添加到您的服务器上。一旦订阅被添加，`subscription-manager` 将能够列出下列的软件仓库。
要添加订阅，请先使用以下命令检查服务器的所有可用订阅：
```
root@kerneltalks # subscription-manager list --available
+-------------------------------------------+
Available Subscriptions
+-------------------------------------------+
Subscription Name: Red Hat Enterprise Linux for Virtual Datacenters, Standard
Provides: Red Hat Beta
Red Hat Software Collections (for RHEL Server)
Red Hat Enterprise Linux Atomic Host Beta
Oracle Java (for RHEL Server)
Red Hat Enterprise Linux Server
dotNET on RHEL (for RHEL Server)
Red Hat Enterprise Linux Atomic Host
Red Hat Software Collections Beta (for RHEL Server)
Red Hat Developer Tools Beta (for RHEL Server)
Red Hat Developer Toolset (for RHEL Server)
Red Hat Developer Tools (for RHEL Server)
SKU: RH00050
Contract: xxxxxxxx
Pool ID: 8a85f98c6011059f0160110a2ae6000f
Provides Management: Yes
Available: Unlimited
Suggested: 0
Service Level: Standard
Service Type: L1-L3
Subscription Type: Stackable (Temporary)
Ends: 12/01/2018
System Type: Virtual
```
您将获得可用于您的服务器的此类订阅的软件仓库列表。您需要阅读它提供的内容并记下对您有用或需要的订阅的 `Pool ID`。
现在，使用 pool ID 将订阅添加到您的服务器。
```
# subscription-manager attach --pool=8a85f98c6011059f0160110a2ae6000f
Successfully attached a subscription for: Red Hat Enterprise Linux for Virtual Datacenters, Standard
```
如果您不确定选择哪一个，则可以使用下面的命令自动地添加最适合您的服务器的订阅：
```
root@kerneltalks # subscription-manager attach --auto
Installed Product Current Status:
Product Name: Red Hat Enterprise Linux Server
Status: Subscribed
```
接下来是最后一步启用软件仓库。
### 步骤 3：启用软件仓库
现在您将能够启用软件仓库，该软件仓库在您的附加订阅下可用。
```
root@kerneltalks # subscription-manager repos --enable rhel-6-server-rhv-4-agent-beta-debug-rpms
Repository 'rhel-6-server-rhv-4-agent-beta-debug-rpms' is enabled for this system.
```
到这里，您已经完成了。您可以[用 yum 命令列出软件仓库](https://kerneltalks.com/howto/how-to-list-yum-repositories-in-rhel-centos/)并确认。
---
via: <https://kerneltalks.com/howto/how-to-enable-repository-using-subscription-manager-in-rhel/>
作者：[kerneltalks](https://kerneltalks.com) 译者：[S9mtAt](https://github.com/S9mtAt) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
PacVim：一个学习 vim 命令的命令行游戏
|
Sk
|
https://www.ostechnix.com/pacvim-a-cli-game-to-learn-vim-commands/
|
PacVim 的灵感来源于经典游戏 PacMan，它以一种好玩有趣的方式为你提供了大量的 Vim 命令练习。
|
/data/attachment/album/201806/12/104232uv9l5vv9969vs9jv.png.thumb.jpg
|
/data/attachment/album/201806/12/104232uv9l5vv9969vs9jv.png
| true | false | true |
geekpi
| false |
[
"PacVim",
"Vim"
] |
技术
|
{
"viewnum": 13470,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
PacVim 的灵感来源于经典游戏 PacMan，它以一种好玩有趣的方式为你提供了大量的 Vim 命令练习。
| 2018-06-12T10:42:00 | 2018-06-12T10:42:00 | 9,738 |
/article-9738-1.html
|
你好，Vim用户！今天，我偶然发现了一个很酷的程序来提高 Vim 的使用技巧。Vim 是编写和编辑代码的绝佳编辑器。然而，你们中的一些人（包括我）仍在陡峭的学习曲线中挣扎。再也不用了！来看看 **PacVim**，一款可帮助你学习 Vim 命令的命令行游戏。PacVim 的灵感来源于经典游戏 [PacMan](https://en.wikipedia.org/wiki/Pac-Man)，它以一种好玩有趣的方式为你提供了大量的 Vim 命令练习。简而言之，PacVim 是一种深入了解 vim 命令的有趣而自由的方式。请不要将 PacMan 与 [pacman](https://www.ostechnix.com/getting-started-pacman/) （arch Linux 包管理器）混淆。 PacMan 是 20 世纪 80 年代发布的经典流行街机游戏。
在本简要指南中，我们将看到如何在 Linux 中安装和使用 PacVim。
### 安装 PacVim
首先按如下链接安装 **Ncurses** 库和**开发工具**。
* [如何在 Linux 中安装 Ncurses 库](https://www.ostechnix.com/how-to-install-ncurses-library-in-linux/)
* [如何在 Linux 中安装开发工具](https://www.ostechnix.com/install-development-tools-linux/)
请注意，如果没有 gcc 4.8.X 或更高版本，这款游戏可能无法正确编译和安装。我在 Ubuntu 18.04 LTS 上测试了 PacVim，并且完美运行。
安装 Ncurses 和 gcc 后，运行以下命令来安装 PacVim。
```
$ git clone https://github.com/jmoon018/PacVim.git
$ cd PacVim
$ sudo make install
```
### 使用 PacVim 学习 Vim 命令
#### 启动 PacVim 游戏
要玩这个游戏，只需运行：
```
$ pacvim [LEVEL_NUMER] [MODE]
```
例如，以下命令以普通模式启动游戏第 5 关。
```
$ pacvim 5 n
```
这里，`5` 表示等级，`n`表示模式。有两种模式：
* `n` – 普通模式。
* `h` – 困难模式。
默认模式是 `h`，这很难：
要从头开始（`0` 级），请运行：
```
$ pacvim
```
以下是我 Ubuntu 18.04 LTS 的示例输出。
要开始游戏，只需按下回车。
现在开始游戏。阅读下一节了解如何玩。
要退出，请按下 `ESC` 或 `q`。
以下命令以困难模式启动游戏第 `5` 关。
```
$ pacvim 5 h
```
或者，
```
$ pacvim 5
```
#### 如何玩 PacVim？
PacVim 的使用与 PacMan 非常相似。
你必须跑过屏幕上所有的字符，同时避免鬼魂（红色字符）。
PacVim有两个特殊的障碍：
1. 你不能移动到墙壁中（黄色）。你必须使用 vim 动作来跳过它们。
2. 如果你踩到波浪字符（青色的 `~`），你就输了！
你有三条生命。每次打赢 0、3、6、9 关时你都会获得新生命。总共有 10 关，从 0 到 9，打赢第 9 关后，游戏重置为第 0 关，但是鬼魂速度变快。
**获胜条件**
使用 vim 命令将光标移动到字母上并高亮显示它们。所有字母都高亮显示后，你就会获胜并进入下一关。
**失败条件**
如果你碰到鬼魂（用**红色 G** 表示）或者**波浪字符**，你就会失去一条命。如果命小于 0 条，你将会输掉整个游戏。
这是实现的命令列表：
| 键 | 作用 |
| --- | --- |
| q | 退出游戏 |
| h | 向左移动 |
| j | 向下移动 |
| k | 向上移动 |
| l | 向右移动 |
| w | 向前移动到下一个 word 开始 |
| W | 向前移动到下一个 WORD 开始 |
| e | 向前移动到下一个 word 结束 |
| E | 向前移动到下一个 WORD 结束 |
| b | 向后移动到下一个 word 开始 |
| B | 向后移动到下一个 WORD 开始 |
| $ | 移动到行的末尾 |
| 0 | 移动到行的开始 |
| gg/1G | 移动到第一行的开始 |
| 数字加 G | 移动到由数字给出的行的开始 |
| G | 移到最后一行的开头 |
| ^ | 移到当前行的第一个 word |
| ＆ | 1337 cheatz（打赢当前关） |
玩过几关之后，你可能会注意到 vim 的使用有改善。一段时间后继续玩这个游戏，直到你掌握 Vim 的使用。
**建议阅读：**
今天就是这些。希望这篇文章有用。PacVim 好玩又有趣并且让你有事做。同时，你应该能够彻底学习足够的 Vim 命令。试试看，你不会感到失望。
还有更多的好东西。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/pacvim-a-cli-game-to-learn-vim-commands/>
作者：[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/) 荣誉推出
|
||
使用 ARA 分析 Ansible 运行
|
Ajinkya Bapat
|
https://opensource.com/article/18/5/analyzing-ansible-runs-using-ara
|
Ansible 运行分析工具（ARA）与 Ansible 无缝集成，可以简单便捷的找到你所需数据的方法。
|
/data/attachment/album/201806/12/110004oyw5z6m5ocro5ni5.png.thumb.jpg
|
/data/attachment/album/201806/12/110004oyw5z6m5ocro5ni5.png
| true | false | true |
geekpi
| false |
[
"Ansible"
] |
系统运维
|
{
"viewnum": 5821,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Ansible 运行分析工具（ARA）与 Ansible 无缝集成，可以简单便捷的找到你所需数据的方法。
| 2018-06-12T11:00:00 | 2018-06-12T11:00:00 | 9,739 |
/article-9739-1.html
|
>
> Ansible 运行分析工具（ARA）与 Ansible 无缝集成，可以简单便捷的找到你所需数据的方法。
>
>
>
[Ansible](https://www.ansible.com/) 是一个多功能平台，它已经成为管理服务器和服务器配置的流行平台。如今，Ansible 大量用于通过持续集成 （CI） 进行部署和测试。
在自动化持续集成的世界中，每天都有数百个甚至数千个作业运行测试、构建、编译、部署等等，这并不罕见。
### Ansible 运行分析 （ARA） 工具
Ansible 运行生成大量控制台数据，在 CI 的环境下跟上大量的 Ansible 输出是具有挑战性的。Ansible Run Analysis（ARA） 工具使此详细输出可读并且使作业状态和调试信息更有代表性。ARA 组织了记录的<ruby> 剧本 <rt> playbook </rt></ruby>数据，以便你尽可能快速和容易地搜索并找到你感兴趣的内容。
请注意，ARA 不会运行你的<ruby> 剧本 <rt> playbook </rt></ruby>。相反，无论在哪它都它作为回调插件与 Ansible 集成。回调插件可以在响应事件时向 Ansible 添加新行为。它可以根据 Ansible 事件执行自定义操作，例如在主机开始执行或任务完成时执行。
与 [AWX](https://www.ansible.com/products/awx-project) 和 [Tower](https://www.ansible.com/products/tower) 相比，它们是控制整个工作流程的工具，具有仓库管理、<ruby> 剧本 <rt> playbook </rt></ruby>执行、编辑功能等功能，ARA 的范围相对较窄：记录数据并提供直观的界面。这是一个相对简单的程序，易于安装和配置。
#### 安装
在系统上安装 ARA 有两种方法：
* 使用托管在 [GitHub 帐户](https://github.com/AjinkyaBapat/Ansible-Run-Analyser) 上的 Ansible 角色。克隆仓库并：
```
ansible-playbook Playbook.yml
```
如果剧本执行成功，你将看到：
```
TASK [ara : Display ara UI URL] ************************
ok: [localhost] => {}
"msg": "Access playbook records at http://YOUR_IP:9191"
```
注意：它从 Ansible 收集的 `ansible_default_ipv4` fact 中选择 IP 地址。如果没有收集这些 fact，请用 `roles/ara/tasks/` 文件夹中 `main.yml` 文件中的 IP 替换它。
* ARA 是一个在 [GitHub](https://github.com/dmsimard/ara) 上以 Apache v2 许可证授权的开源项目。安装说明在快速入门章节。[文档](http://ara.readthedocs.io/en/latest/)和 [FAQ](http://ara.readthedocs.io/en/latest/faq.html) 可在 [readthedocs.io](http://ara.readthedocs.io/en/latest/) 上找到。
#### ARA 能做些什么？
下图显示了从浏览器启动 ARA 登录页面：
*ARA 登录页面*
它提供了每个主机或每个 playbook 的任务结果摘要：
*ARA 显示任务摘要*
它允许你通过剧本，play，主机、任务或状态来过滤任务结果：
*通过主机过滤剧本运行*
借助 ARA，你可以在摘要视图中轻松查看你感兴趣的结果，无论是特定的主机还是特定的任务：
*每项任务的详细摘要*
ARA 支持在同一数据库中记录和查看多个运行。
*显示收集的 fact*
#### 总结
ARA 是一个已经帮助我从 Ansible 运行日志和输出中了解更多的有用资源。我强烈推荐给所有的 Ansible 使用者。
请随意分享，并请在评论中告诉我你使用 ARA 的经历。
[参见我们的相关文章，[成功使用 Ansible 的秘诀](/article/18/2/tips-success-when-getting-started-ansible)]。
---
via: <https://opensource.com/article/18/5/analyzing-ansible-runs-using-ara>
作者：[Ajinkya Bapat](https://opensource.com/users/iamajinkya) 选题：[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：实验 1：PC 的引导过程
|
Mit
|
https://sipb.mit.edu/iap/6.828/lab/lab1/
|
第一部分主要是为了熟悉使用 x86 汇编语言、QEMU x86 仿真器、以及 PC 的加电引导过程。第二部分查看我们的 6.828 内核的引导加载器，它位于 lab 树的 boot 目录中。第三部分深入到我们的名为 JOS 的 6.828 内核模型内部，它在 kernel 目录中。
|
/data/attachment/album/201806/12/180844cgvvx3gjo5vn5gvg.jpg.thumb.jpg
|
/data/attachment/album/201806/12/180844cgvvx3gjo5vn5gvg.jpg
| true | false | true |
qhwdw
| false |
[
"内核",
"引导"
] |
技术
|
{
"viewnum": 9053,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9608,
"displayorder": 0
},
{
"raid": 10201,
"displayorder": 0
},
{
"raid": 10273,
"displayorder": 0
}
] |
第一部分主要是为了熟悉使用 x86 汇编语言、QEMU x86 仿真器、以及 PC 的加电引导过程。第二部分查看我们的 6.828 内核的引导加载器，它位于 lab 树的 boot 目录中。第三部分深入到我们的名为 JOS 的 6.828 内核模型内部，它在 kernel 目录中。
| 2018-06-12T18:08:00 | 2018-06-12T18:08:00 | 9,740 |
/article-9740-1.html
|
### 简介
这个实验分为三个部分。第一部分主要是为了熟悉使用 x86 汇编语言、QEMU x86 仿真器、以及 PC 的加电引导过程。第二部分查看我们的 6.828 内核的引导加载器，它位于 `lab` 树的 `boot` 目录中。第三部分深入到我们的名为 JOS 的 6.828 内核模型内部，它在 `kernel` 目录中。
#### 软件安装
本课程中你需要的文件和接下来的实验任务所需要的文件都是通过使用 [Git](http://www.git-scm.com/) 版本控制系统来分发的。学习更多关于 Git 的知识，请查看 [Git 用户手册](http://www.kernel.org/pub/software/scm/git/docs/user-manual.html)，或者，如果你熟悉其它的版本控制系统，这个 [面向 CS 的 Git 概述](http://eagain.net/articles/git-for-computer-scientists/) 可能对你有帮助。
本课程在 Git 仓库中的地址是 <https://exokernel.scripts.mit.edu/joslab.git> 。在你的 Athena 帐户中安装文件，你需要运行如下的命令去克隆课程仓库。你也可以使用 `ssh -X athena.dialup.mit.edu` 去登入到一个公共的 Athena 主机。
```
athena% mkdir ~/6.828
athena% cd ~/6.828
athena% add git
athena% git clone https://exokernel.scripts.mit.edu/joslab.git lab
Cloning into lab...
athena% cd lab
athena%
```
Git 可以帮你跟踪代码中的变化。比如，如果你完成了一个练习，想在你的进度中打一个检查点，你可以运行如下的命令去提交你的变更：
```
athena% git commit -am 'my solution for lab1 exercise 9'
Created commit 60d2135: my solution for lab1 exercise 9
1 files changed, 1 insertions(+), 0 deletions(-)
athena%
```
你可以使用 `git diff` 命令跟踪你的变更。运行 `git diff` 将显示你的代码自最后一次提交之后的变更，而 `git diff origin/lab1` 将显示这个实验相对于初始代码的变更。在这里，`origin/lab1` 是为了完成这个作业，从我们的服务器上下载的初始代码在 Git 分支上的名字。
在 Athena 上，我们为你配置了合适的编译器和模拟器。如果你要去使用它们，请运行 `add exokernel` 命令。 每次登入 Athena 主机你都必须要运行这个命令（或者你可以将它添加到你的 `~/.environment` 文件中）。如果你在编译或者运行 `qemu` 时出现晦涩难懂的错误，可以双击 "check" 将它添加到你的课程收藏夹中。
如果你使用的是非 Athena 机器，你需要安装 `qemu` 和 `gcc`，它们在 [工具页面](https://sipb.mit.edu/iap/6.828/tools) 目录中。为了以后的实验需要，我们做了一些 `qemu` 调试方面的变更和补丁，因此，你必须构建你自己的工具。如果你的机器使用原生的 ELF 工具链（比如，Linux 和大多数 BSD，但不包括 OS X），你可以简单地从你的包管理器中安装 `gcc`。除此之外，都应该按工具页面的指导去做。
#### 动手过程
我们为了你便于做实验，为你使用了不同的 Git 仓库。做实验用的仓库位于一个 SSH 服务器后面。你可以拥有你自己的实验仓库，其他的任何同学都不可访问你的这个仓库。为了通过 SSH 服务器的认证，你必须有一对 RSA 密钥，并让服务器知道你的公钥。
实验代码同时还带有一个脚本，它可以帮你设置如何访问你的实验仓库。在运行这个脚本之前，你必须在我们的 [submission web 界面](https://exokernel.scripts.mit.edu/submit/) 上有一个帐户。在登陆页面上，输入你的 Athena 用户名，然后点击 “Mail me my password”。在你的邮箱中将马上接收到一封包含有你的 `6.828` 课程密码的邮件。注意，每次你点击这个按钮的时候，系统将随机给你分配一个新密码。
现在，你已经有了你的 `6.828` 密码，在 `lab` 目录下，运行如下的命令去配置实践仓库：
```
athena% make handin-prep
Using public key from ~/.ssh/id_rsa:
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD0lnnkoHSi4JDFA ...
Continue? [Y/n] Y
Login to 6.828 submission website.
If you do not have an account yet, sign up at https://exokernel.scripts.mit.edu/submit/
before continuing.
Username: <your Athena username>
Password: <your 6.828 password>
Your public key has been successfully updated.
Setting up hand-in Git repository...
Adding remote repository ssh://josgit@exokernel.mit.edu/joslab.git as 'handin'.
Done! Use 'make handin' to submit your lab code.
athena%
```
如果你没有 RSA 密钥对，这个脚本可能会询问你是否生成一个新的密钥对：
```
athena% make handin-prep
SSH key file ~/.ssh/id_rsa does not exists, generate one? [Y/n] Y
Generating public/private rsa key pair.
Your identification has been saved in ~/.ssh/id_rsa.
Your public key has been saved in ~/.ssh/id_rsa.pub.
The key fingerprint is:
xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx
The keyʼs randomart image is:
+--[ RSA 2048]----+
| ........ |
| ........ |
+-----------------+
Using public key from ~/.ssh/id_rsa:
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD0lnnkoHSi4JDFA ...
Continue? [Y/n] Y
.....
athena%
```
当你开始动手做实验时，在 `lab` 目录下，输入 `make handin` 去使用 git 做第一次提交。后面将运行 `git push handin HEAD`，它将推送当前分支到远程 `handin` 仓库的同名分支上。
```
athena% git commit -am "ready to submit my lab"
[lab1 c2e3c8b] ready to submit my lab
2 files changed, 18 insertions(+), 2 deletions(-)
athena% make handin
Handin to remote repository using 'git push handin HEAD' ...
Counting objects: 59, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (55/55), done.
Writing objects: 100% (59/59), 49.75 KiB, done.
Total 59 (delta 3), reused 0 (delta 0)
To ssh://josgit@am.csail.mit.edu/joslab.git
* [new branch] HEAD -> lab1
athena%
```
如果在你的实验仓库上产生变化，你将收到一封电子邮件，让你去确认这个提交。以后，你可能会多次去运行 `run make handin`（或者 `git push handin`）。对于一个指定实验的最后提交时间是由相应分支的最新推送（最后一个推送）的时间决定的。
在这个案例中，`make handin` 运行可能并不正确，你可以使用 Git 命令去尝试修复这个问题。或者，你可以去运行 `make tarball`。它将为你生成一个 tar 文件，这个文件可以通过我们的 [web 界面](https://exokernel.scripts.mit.edu/submit/) 来上传。`make handin` 提供了很多特殊说明。
对于实验 1，你不需要去回答下列的任何一个问题。（尽管你不用自己回答，但是它们对下面的实验有帮助）
我们将使用一个评级程序来分级你的解决方案。你可以使用这个评级程序去测试你的解决方案的分级情况。
### 第一部分：PC 引导
第一个练习的目的是向你介绍 x86 汇编语言和 PC 引导过程，你可以使用 QEMU 和 QEMU/GDB 调试开始你的练习。这部分的实验你不需要写任何代码，但是，通过这个实验，你将对 PC 引导过程有了你自己的理解，并且为回答后面的问题做好准备。
#### 从使用 x86 汇编语言开始
如果你对 x86 汇编语言的使用还不熟悉，通过这个课程，你将很快熟悉它！如果你想学习它，[PC 汇编语言](https://sipb.mit.edu/iap/6.828/readings/pcasm-book.pdf) 这本书是一个很好的开端。希望这本书中有你所需要的一切内容。
警告：很不幸，这本书中的示例是为 NASM 汇编语言写的，而我们使用的是 GNU 汇编语言。NASM 使用所谓的 Intel 语法，而 GNU 使用 AT&T 语法。虽然在语义上是等价的，但是根据你使用的语法不同，至少从表面上看，汇编文件的差别还是挺大的。幸运的是，这两种语法的转换很简单，在 [Brennan's Guide to Inline Assembly](http://www.delorie.com/djgpp/doc/brennan/brennan_att_inline_djgpp.html) 有详细的介绍。
>
> **练习 1**
>
>
> 熟悉在 [6.828 参考页面](https://sipb.mit.edu/iap/6.828/reference) 上列出的你想去使用的可用汇编语言。你不需要现在就去阅读它们，但是在你阅读和写 x86 汇编程序的时候，你可以去参考相关的内容。
>
>
>
我并不推荐你阅读 [Brennan's Guide to Inline Assembly](http://www.delorie.com/djgpp/doc/brennan/brennan_att_inline_djgpp.html) 上的 “语法” 章节。虽然它对 AT&T 汇编语法描述的很好（并且非常详细），而且我们在 JOS 中使用的 GNU 汇编就是它。
对于 x86 汇编语言程序最终还是需要参考 Intel 的指令集架构，你可以在 [6.828 参考页面](https://sipb.mit.edu/iap/6.828/reference) 上找到它，它有两个版本：一个是 HTML 版的，是老的 [80386 程序员参考手册](https://sipb.mit.edu/iap/6.828/readings/i386/toc.htm)，它比起最新的手册更简短，更易于查找，但是，它包含了我们的 6.828 上所使用的 x86 处理器的所有特性；而更全面的、更新的、更好的是，来自 Intel 的 [IA-32 Intel 架构软件开发者手册](http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html)，它涵盖了我们在课程中所需要的、（并且可能有些是你不感兴趣的）大多数处理器的全部特性。另一个差不多的（并且经常是很友好的）一套手册是 [来自 AMD](http://developer.amd.com/documentation/guides/Pages/default.aspx#manuals) 的。当你为了一个特定的处理器特性或者指令，去查找最终的解释时，保存的最新的 Intel/AMD 架构手册或者它们的参考就很有用了。
#### 仿真 x86
与在一台真实的、物理的、个人电脑上引导一个操作系统不同，我们使用程序去如实地仿真一台完整的 PC：你在仿真器中写的代码，也能够引导一台真实的 PC。使用仿真器可以简化调试工作；比如，你可以在仿真器中设置断点，而这在真实的机器中是做不到的。
在 6.828 中，我们将使用 [QEMU 仿真器](http://www.qemu.org/)，它是一个现代化的并且速度非常快的仿真器。虽然 QEMU 内置的监视功能提供了有限的调试支持，但是，QEMU 也可以做为 [GNU 调试器](http://www.gnu.org/software/gdb/) (GDB) 的远程调试目标，我们在这个实验中将使用它来一步一步完成引导过程。
在开始之前，按照前面 “软件安装“ 中在 Athena 主机上描述的步骤，提取实验 1 的文件到你自己的目录中，然后，在 `lab` 目录中输入 `make`（如果是 BSD 的系统，是输入 `gmake` ）来构建最小的 6.828 引导加载器和用于启动的内核。（把在这里我们运行的这些代码称为 ”内核“ 有点夸大，但是，通过这个学期的课程，我们将把这些代码充实起来，成为真正的 ”内核“）
```
athena% cd lab
athena% make
+ as kern/entry.S
+ cc kern/init.c
+ cc kern/console.c
+ cc kern/monitor.c
+ cc kern/printf.c
+ cc lib/printfmt.c
+ cc lib/readline.c
+ cc lib/string.c
+ ld obj/kern/kernel
+ as boot/boot.S
+ cc -Os boot/main.c
+ ld boot/boot
boot block is 414 bytes (max 510)
+ mk obj/kern/kernel.img
```
（如果你看到有类似 ”undefined reference to `\_\_udivdi3'” 这样的错误，可能是因为你的电脑上没有 32 位的 “gcc multilib”。如果你运行在 Debian 或者 Ubuntu，你可以尝试去安装 “gcc-multilib” 包。）
现在，你可以去运行 QEMU 了，并将上面创建的 `obj/kern/kernel.img` 文件提供给它，以作为仿真 PC 的 “虚拟硬盘”，这个虚拟硬盘中包含了我们的引导加载器（`obj/boot/boot`) 和我们的内核（`obj/kernel`）。
```
athena% make qemu
```
运行 QEMU 时需要使用选项去设置硬盘，以及指示串行端口输出到终端。在 QEMU 窗口中将出现一些文本内容：
```
Booting from Hard Disk...
6828 decimal is XXX octal!
entering test_backtrace 5
entering test_backtrace 4
entering test_backtrace 3
entering test_backtrace 2
entering test_backtrace 1
entering test_backtrace 0
leaving test_backtrace 0
leaving test_backtrace 1
leaving test_backtrace 2
leaving test_backtrace 3
leaving test_backtrace 4
leaving test_backtrace 5
Welcome to the JOS kernel monitor!
Type 'help' for a list of commands.
K>
```
在 `Booting from Hard Disk...` 之后的内容，就是由我们的基本 JOS 内核输出的：`K>` 是包含在我们的内核中的小型监听器或者交互式控制程序的提示符。内核输出的这些行也会出现在你运行 QEMU 的普通 shell 窗口中。这是因为测试和实验分级的原因，我们配置了 JOS 的内核，使它将控制台输出不仅写入到虚拟的 VGA 显示器（就是 QEMU 窗口），也写入到仿真 PC 的虚拟串口上，QEMU 会将虚拟串口上的信息转发到它的标准输出上。同样，JOS 内核也将接收来自键盘和串口的输入，因此，你既可以从 VGA 显示窗口中输入命令，也可以从运行 QEMU 的终端窗口中输入命令。或者，你可以通过运行 `make qemu-nox` 来取消虚拟 VGA 的输出，只使用串行控制台来输出。如果你是通过 SSH 拨号连接到 Athena 主机，这样可能更方便。
在这里有两个可以用来监视内核的命令，它们是 `help` 和 `kerninfo`。
```
K> help
help - display this list of commands
kerninfo - display information about the kernel
K> kerninfo
Special kernel symbols:
entry f010000c (virt) 0010000c (phys)
etext f0101a75 (virt) 00101a75 (phys)
edata f0112300 (virt) 00112300 (phys)
end f0112960 (virt) 00112960 (phys)
Kernel executable memory footprint: 75KB
K>
```
`help` 命令的用途很明确，我们将简短地讨论一下 `kerninfo` 命令输出的内容。虽然它很简单，但是，需要重点注意的是，这个内核监视器是 “直接” 运行在仿真 PC 的 “原始（虚拟）硬件” 上的。这意味着你可以去拷贝 `obj/kern/kernel.img` 的内容到一个真实硬盘的前几个扇区，然后将那个硬盘插入到一个真实的 PC 中，打开这个 PC 的电源，你将在一台真实的 PC 屏幕上看到和上面在 QEMU 窗口完全一样的内容。（我们并不推荐你在一台真实机器上这样做，因为拷贝 `kernel.img` 到硬盘的前几个扇区将覆盖掉那个硬盘上原来的主引导记录，这将导致这个硬盘上以前的内容丢失！）
#### PC 的物理地址空间
我们现在将更深入去了解 “关于 PC 是如何启动” 的更多细节。一台 PC 的物理地址空间是硬编码为如下的布局：
```
+------------------+ <- 0xFFFFFFFF (4GB)
| 32-bit |
| memory mapped |
| devices |
| |
/\/\/\/\/\/\/\/\/\/\
/\/\/\/\/\/\/\/\/\/\
| |
| Unused |
| |
+------------------+ <- depends on amount of RAM
| |
| |
| Extended Memory |
| |
| |
+------------------+ <- 0x00100000 (1MB)
| BIOS ROM |
+------------------+ <- 0x000F0000 (960KB)
| 16-bit devices, |
| expansion ROMs |
+------------------+ <- 0x000C0000 (768KB)
| VGA Display |
+------------------+ <- 0x000A0000 (640KB)
| |
| Low Memory |
| |
+------------------+ <- 0x00000000
```
首先，这台 PC 是基于 16 位的 Intel 8088 处理器，它仅能处理 1 MB 的物理地址。所以，早期 PC 的物理地址空间开始于 `0x00000000`，结束于 `0x000FFFFF` 而不是 `0xFFFFFFFF`。被标记为 “低位内存” 的区域是早期 PC 唯一可以使用的随机访问内存（RAM）；事实上，更早期的 PC 仅可以配置 16KB、32KB、或者 64KB 的内存！
从 `0x000A0000` 到 `0x000FFFFF` 的 384 KB 的区域是为特定硬件保留的区域，比如，视频显示缓冲和保存在非易失存储中的固件。这个保留区域中最重要的部分是基本输入/输出系统（BIOS），它位于从 `0x000F0000` 到 `0x000FFFFF` 之间的 64KB 大小的区域。在早期的 PC 中，BIOS 在真正的只读存储（ROM）中，但是，现在的 PC 的 BIOS 都保存在可更新的 FLASH 存储中。BIOS 负责执行基本系统初始化工作，比如，激活视频卡和检查已安装的内存数量。这个初始化工作完成之后，BIOS 从相关位置加载操作系统，比如从软盘、硬盘、CD-ROM、或者网络，然后将机器的控制权传递给操作系统。
当 Intel 最终在 80286 和 80386 处理器上 “打破了 1MB 限制” 之后，这两个处理器各自支持 16MB 和 4GB 物理地址空间，尽管如此，为了确保向下兼容现存软件，PC 架构还是保留着 1 MB 以内物理地址空间的原始布局。因此，现代 PC 的物理内存，在 `0x000A0000` 和 `0x00100000` 之间有一个 “黑洞区域”，将内存分割为 “低位” 或者 “传统内存” 区域（前 640 KB）和 “扩展内存”（其它的部分）。除此之外，在 PC 的 32 位物理地址空间顶部之上的一些空间，在全部的物理内存上面，现在一般都由 BIOS 保留给 32 位的 PCI 设备使用。
最新的 x86 处理器可以支持超过 4GB 的物理地址空间，因此，RAM 可以进一步扩展到 `0xFFFFFFFF` 之上。在这种情况下，BIOS 必须在 32 位可寻址空间顶部之上的系统 RAM 上，设置第二个 “黑洞区域”，以便于为这些 32 位的设备映射留下空间。因为 JOS 设计的限制，它仅可以使用 PC 物理内存的前 256 MB，因此，我们将假设所有的 PC “仅仅” 拥有 32 位物理地址空间。但是处理复杂的物理地址空间和其它部分的硬件系统，将涉及到许多年前操作系统开发所遇到的实际挑战之一。
#### ROM BIOS
在实验的这一部分中，你将使用 QEMU 的调试功能去研究 IA-32 相关的计算机是如何引导的。
打开两个终端窗口，在其中一个中，输入 `make qemu-gdb`（或者 `make qemu-nox-gdb`），这将启动 QEMU，但是处理器在运行第一个指令之前将停止 QEMU，以等待来自 GDB 的调试连接。在第二个终端窗口中，从相同的目录中运行 `make`，以及运行 `make gdb`。你将看到如下的输出。
```
athena% make gdb
GNU gdb (GDB) 6.8-debian
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "i486-linux-gnu".
+ target remote localhost:1234
The target architecture is assumed to be i8086
[f000:fff0] 0xffff0: ljmp $0xf000,$0xe05b
0x0000fff0 in ?? ()
+ symbol-file obj/kern/kernel
(gdb)
```
`make gdb` 的运行目标是一个称为 `.gdbrc` 的脚本，它设置了 GDB 在早期引导期间调试所用到的 16 位代码，并且将它指向到正在监听的 QEMU 上。
下列行：
```
[f000:fff0] 0xffff0: ljmp $0xf000,$0xe05b
```
是 GDB 运行的第一个指令的反汇编。这个输出包含如下的信息：
* IBM PC 从物理地址 `0x000ffff0` 开始运行，这个地址位于为 ROM BIOS 保留的 64 KB 区域的顶部。
* PC 使用 `CS = 0xf000` 和 `IP = 0xfff0` 开始运行。
* 运行的第一个指令是一个 `jmp` 指令，它跳转段地址 `CS = 0xf000` 和 `IP = 0xe05b`。
为什么 QEMU 是这样开始的呢？这是因为 Intel 设计的 8088 处理器是这样做的，这个处理器是 IBM 最早用在他们的 PC 上的处理器。因为在一台 PC 中，BIOS 是硬编码在物理地址范围 `0x000f0000-0x000fffff` 中的，这样的设计确保了在机器接通电源或者任何系统重启之后，BIOS 总是能够首先控制机器 —— 这是至关重要的，因为机器接通电源之后，在机器的内存中没有处理器可以运行的任何软件。QEMU 仿真器有它自己的 BIOS，它的位置在处理器的模拟地址空间中。在处理器复位之后，（模拟的）处理器进入了实模式，然后设置 `CS` 为 `0xf000` 、`IP` 为 `0xfff0`，所以，运行开始于那个（`CS:IP`）段地址。那么，段地址 `0xf000:fff0` 是如何转到物理地址的呢？
在回答这个问题之前，我们需要了解有关实模式地址的知识。在实模式（PC 启动之后就处于实模式）中，物理地址是根据这个公式去转换的：物理地址 = 16 \* 段地址 + 偏移。因此，当 PC 设置 `CS` 为 `0xf000` 、`IP` 为 `0xfff0` 之后，物理地址指向到：
```
16 * 0xf000 + 0xfff0 # in hex multiplication by 16 is
= 0xf0000 + 0xfff0 # easy--just append a 0.
= 0xffff0
```
`0xffff0` 是 BIOS (`0x100000`) 结束之前的 16 字节。因此，BIOS 所做的第一件事情是向后 `jmp` 到 BIOS 中的早期位置就一点也不奇怪了；毕竟只有 16 字节，还能指望它做些什么呢？
>
> **练习 2**
>
>
> 使用 GDB 的 `si`（步进指令）指令去跟踪进入到 ROM BIOS 的更多指令，然后尝试猜测它可能会做什么。你可能需要去查看 [Phil Storrs I/O 端口描述](http://web.archive.org/web/20040404164813/members.iweb.net.au/%7Epstorr/pcbook/book2/book2.htm)，以及在 [6.828 参考资料页面](https://sipb.mit.edu/iap/6.828/reference) 上的其它资料。不需要了解所有的细节 —— 只要搞明白 BIOS 首先要做什么就可以了。
>
>
>
当 BIOS 运行后，它将设置一个中断描述符表和初始化各种设备，比如， VGA 显示。在这时，你在 QEMU 窗口中将出现 `Starting SeaBIOS` 的信息。
在初始化 PCI 产品线和 BIOS 知道的所有重要设备之后，它将搜索可引导设备，比如，一个软盘、硬盘、或者 CD-ROM。最后，当它找到可引导磁盘之后，BIOS 从可引导硬盘上读取引导加载器，然后将控制权交给它。
### 第二部分：引导加载器
在 PC 的软盘和硬盘中，将它们分割成 512 字节大小的区域，每个区域称为一个扇区。一个扇区就是磁盘的最小转存单元：每个读或写操作都必须是一个或多个扇区大小，并且按扇区边界进行对齐。如果磁盘是可引导盘，第一个扇区则为引导扇区，因为，第一个扇区中驻留有引导加载器的代码。当 BIOS 找到一个可引导软盘或者硬盘时，它将 512 字节的引导扇区加载进物理地址为 `0x7c00` 到 `0x7dff` 的内存中，然后使用一个 `jmp` 指令设置 `CS:IP` 为 `0000:7c00`，并传递控制权到引导加载器。与 BIOS 加载地址一样，这些地址是任意的 —— 但是它们对于 PC 来说是固定的，并且是标准化的。
后来，随着 PC 的技术进步，它们可以从 CD-ROM 中引导，因此，PC 架构师趁机对引导过程进行轻微的调整。最后的结果使现代的 BIOS 从 CD-ROM 中引导的过程更复杂（并且功能更强大）。CD-ROM 使用 2048 字节大小的扇区，而不是 512 字节的扇区，并且，BIOS 在传递控制权之前，可以从磁盘上加载更大的（不止是一个扇区）引导镜像到内存中。更多内容，请查看 [“El Torito” 可引导 CD-ROM 格式规范](https://sipb.mit.edu/iap/6.828/readings/boot-cdrom.pdf)。
不过对于 6.828，我们将使用传统的硬盘引导机制，意味着我们的引导加载器必须小于 512 字节。引导加载器是由一个汇编源文件 `boot/boot.S` 和一个 C 源文件 `boot/main.c` 构成，仔细研究这些源文件可以让你彻底理解引导加载器都做了些什么。引导加载器必须要做两件主要的事情：
1. 第一、引导加载器将处理器从实模式切换到 32 位保护模式，因为只有在 32 位保护模式中，软件才能够访问处理器中 1 MB 以上的物理地址空间。关于保护模式将在 [PC 汇编语言](https://sipb.mit.edu/iap/6.828/readings/pcasm-book.pdf) 的 1.2.7 和 1.2.8 节中详细描述，更详细的内容请参阅 Intel 架构手册。在这里，你只要理解在保护模式中段地址（段基地址：偏移量）与物理地址转换的差别就可以了，并且转换后的偏移是 32 位而不是 16 位。
2. 第二、引导加载器通过 x86 的专用 I/O 指令直接访问 IDE 磁盘设备寄存器，从硬盘中读取内核。如果你想去更好地了解在这里说的专用 I/O 指令，请查看 [6.828 参考页面](https://sipb.mit.edu/iap/6.828/reference) 上的 “IDE 硬盘控制器” 章节。你不用学习太多的专用设备编程方面的内容：在实践中，写设备驱动程序是操作系统开发中的非常重要的部分，但是，从概念或者架构的角度看，它也是最让人乏味的部分。
理解了引导加载器源代码之后，我们来看一下 `obj/boot/boot.asm` 文件。这个文件是在引导加载器编译过程中，由我们的 GNUmakefile 创建的引导加载器的反汇编文件。这个反汇编文件让我们可以更容易地看到引导加载器代码所处的物理内存位置，并且也可以更容易地跟踪在 GDB 中步进的引导加载器发生了什么事情。同样的，`obj/kern/kernel.asm` 文件中包含了 JOS 内核的一个反汇编，它也经常被用于内核调试。
你可以使用 `b` 命令在 GDB 中设置中断点地址。比如，`b *0x7c00` 命令在地址 `0x7C00` 处设置了一个断点。当处于一个断点中时，你可以使用 `c` 和 `si` 命令去继续运行：`c` 命令让 QEMU 继续运行，直到下一个断点为止（或者是你在 GDB 中按下了 Ctrl - C），而 `si N` 命令是每次步进 `N` 个指令。
要检查内存中的指令（除了要立即运行的下一个指令之外，因为它是由 GDB 自动输出的），你可以使用 `x/i` 命令。这个命令的语法是 `x/Ni ADDR`，其中 `N` 是连接的指令个数，`ADDR` 是开始反汇编的内存地址。
>
> **练习 3**
>
>
> 查看 [实验工具指南](https://sipb.mit.edu/iap/6.828/labguide)，特别是 GDB 命令的相关章节。即便你熟悉使用 GDB 也要好好看一看，GDB 的一些命令比较难理解，但是它对操作系统的工作很有帮助。
>
>
>
在地址 0x7c00 处设置断点，它是加载后的引导扇区的位置。继续运行，直到那个断点。在 `boot/boot.S` 中跟踪代码，使用源代码和反汇编文件 `obj/boot/boot.asm` 去保持跟踪。你也可以使用 GDB 中的 `x/i` 命令去反汇编引导加载器接下来的指令，比较引导加载器源代码与在 `obj/boot/boot.asm` 和 GDB 中的反汇编文件。
在 `boot/main.c` 文件中跟踪进入 `bootmain()` ，然后进入 `readsect()`。识别 `readsect()` 中相关的每一个语句的准确汇编指令。跟踪 `readsect()` 中剩余的指令，然后返回到 `bootmain()` 中，识别 `for` 循环的开始和结束位置，这个循环从磁盘上读取内核的剩余扇区。找出循环结束后运行了什么代码，在这里设置一个断点，然后继续。接下来再走完引导加载器的剩余工作。
完成之后，就能够回答下列的问题了：
* 处理器开始运行 32 代码时指向到什么地方？从 16 位模式切换到 32 位模式的真实原因是什么？
* 引导加载器执行的最后一个指令是什么，内核加载之后的第一个指令是什么？
* 内核的第一个指令在哪里？
* 为从硬盘上获取完整的内核，引导加载器如何决定有多少扇区必须被读入？在哪里能找到这些信息？
#### 加载内核
我们现在来进一步查看引导加载器在 `boot/main.c` 中的 C 语言部分的详细细节。在继续之前，我们先停下来回顾一下 C 语言编程的基础知识。
>
> **练习 4**
>
>
> 下载 [pointers.c](https://sipb.mit.edu/iap/6.828/files/pointers.c) 的源代码，运行它，然后确保你理解了输出值的来源的所有内容。尤其是，确保你理解了第 1 行和第 6 行的指针地址的来源、第 2 行到第 4 行的值是如何得到的、以及为什么第 5 行指向的值表面上看像是错误的。
>
>
> 如果你对指针的使用不熟悉，Brian Kernighan 和 Dennis Ritchie（就是大家知道的 “K&R”）写的《C Programming Language》是一个非常好的参考书。同学们可以去买这本书（这里是 [Amazon 购买链接](http://www.amazon.com/C-Programming-Language-2nd/dp/0131103628/sr=8-1/qid=1157812738/ref=pd_bbs_1/104-1502762-1803102?ie=UTF8&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;s=books)），或者在 [MIT 的图书馆的 7 个副本](http://library.mit.edu/F/AI9Y4SJ2L5ELEE2TAQUAAR44XV5RTTQHE47P9MKP5GQDLR9A8X-10422?func=item-global&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;doc_library=MIT01&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;doc_number=000355242&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;year=&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;volume=&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;sub_library=) 中找到其中一个。在 [SIPB Office](http://sipb.mit.edu/) 也有三个副本可以细读。
>
>
> 在课程阅读中，[Ted Jensen 写的教程](https://sipb.mit.edu/iap/6.828/readings/pointers.pdf) 可以使用，它大量引用了 K&R 的内容。
>
>
> 警告：除非你特别精通 C 语言，否则不要跳过这个阅读练习。如果你没有真正理解了 C 语言中的指针，在接下来的实验中你将非常痛苦，最终你将很难理解它们。相信我们；你将不会遇到什么是 ”最困难的方式“。
>
>
>
要了解 `boot/main.c`，你需要了解一个 ELF 二进制格式的内容。当你编译和链接一个 C 程序时，比如，JOS 内核，编译器将每个 C 源文件（'`.c`'）转换为一个包含预期硬件平台的汇编指令编码的二进制格式的对象文件（'`.o`'），然后链接器将所有编译过的对象文件组合成一个单个的二进制镜像，比如，`obj/kern/kernel`，在本案例中，它就是 ELF 格式的二进制文件，它表示是一个 ”可运行和可链接格式“。
关于这个格式的全部信息可以在 [我们的参考页面](https://sipb.mit.edu/iap/6.828/reference) 上的 [ELF 规范](https://sipb.mit.edu/iap/6.828/readings/elf.pdf) 中找到，但是，你并不需要深入地研究这个格式 的细节。虽然完整的格式是非常强大和复杂的，但是，大多数复杂的部分是为了支持共享库的动态加载，在我们的课程中，并不需要做这些。
鉴于 6.828 的目的，你可以认为一个 ELF 可运行文件是一个用于加载信息的头文件，接下来的几个程序节，根据加载到内存中的特定地址的不同，每个都是连续的代码块或数据块。引导加载器并不修改代码或者数据；它加载它们到内存，然后开始运行它。
一个 ELF 二进制文件使用一个固定长度的 ELF 头开始，紧接着是一个可变长度的程序头，列出了每个加载的程序节。C 语言在 `inc/elf.h` 中定义了这些 ELF 头。在程序节中我们感兴趣的部分有：
* `.text`：程序的可运行指令。
* `.rodata`：只读数据，比如，由 C 编译器生成的 ASCII 字符串常量。（然而我们并不需要操心设置硬件去禁止写入它）
* `.data`：保持在程序的初始化数据中的数据节，比如，初始化声明所需要的全局变量，比如，像 `int x = 5;`。
当链接器计算程序的内存布局的时候，它为未初始化的全局变量保留一些空间，比如，`int x;`，在内存中的被称为 `.bss` 的节后面会马上跟着一个 `.data`。C 规定 "未初始化的" 全局变量以一个 0 值开始。因此，在 ELF 二进制中 `.bss` 中并不存储内容；而是，链接器只记录地址和`.bss` 节的大小。加载器或者程序自身必须在 `.bss` 节中写入 0。
通过输入如下的命令来检查在内核中可运行的所有节的名字、大小、以及链接地址的列表：
```
athena% i386-jos-elf-objdump -h obj/kern/kernel
```
如果在你的计算机上默认使用的是一个 ELF 工具链，比如像大多数现代的 Linux 和 BSD，你可以使用 `objdump` 来代替 `i386-jos-elf-objdump`。
你将看到更多的节，而不仅是上面列出的那几个，但是，其它的那些节对于我们的实验目标来说并不重要。其它的那些节中大多数都是为了保留调试信息，它们一般包含在程序的可执行文件中，但是，这些节并不会被程序加载器加载到内存中。
我们需要特别注意 `.text` 节中的 VMA（或者链接地址）和 LMA（或者加载地址）。一个节的加载地址是那个节加载到内存中的地址。在 ELF 对象中，它保存在 `ph->p_pa` 域（在本案例中，它实际上是物理地址，不过 ELF 规范在这个域的意义方面规定的很模糊）。
一个节的链接地址是这个节打算在内存中运行时的地址。链接器在二进制代码中以变量的方式去编码这个链接地址，比如，当代码需要全局变量的地址时，如果二进制代码从一个未链接的地址去运行，结果将是无法运行。（它一般是去生成一个不包含任何一个绝对地址的、与位置无关的代码。现在的共享库大量使用的就是这种方法，但这是以性能和复杂性为代价的，所以，我们在 6.828 中不使用这种方法。）
一般情况下，链接和加载地址是一样的。比如，通过如下的命令去查看引导加载器的 `.text` 节：
```
athena% i386-jos-elf-objdump -h obj/boot/boot.out
```
BIOS 加载引导扇区到内存中的 0x7c00 地址，因此，这就是引导扇区的加载地址。这也是引导扇区的运行地址，因此，它也是链接地址。我们在`boot/Makefrag` 中通过传递 `-Ttext 0x7C00` 给链接器来设置链接地址，因此，链接器将在生成的代码中产生正确的内存地址。
>
> **练习 5**
>
>
> 如果你得到一个错误的引导加载器链接地址，通过再次跟踪引导加载器的前几个指令，你将会发现第一个指令会 “中断” 或者出错。然后在 `boot/Makefrag` 修改链接地址来修复错误，运行 `make clean`，使用 `make` 重新编译，然后再次跟踪引导加载器去查看会发生什么事情。不要忘了改回正确的链接地址，然后再次 `make clean`！
>
>
>
我们继续来看内核的加载和链接地址。与引导加载器不同，这里有两个不同的地址：内核告诉引导加载器加载它到内存的低位地址（小于 1 MB 的地址），但是它期望在一个高位地址来运行。我们将在下一节中深入研究它是如何实现的。
除了节的信息之外，在 ELF 头中还有一个对我们很重要的域，它叫做 `e_entry`。这个域保留着程序入口的链接地址：程序的 `.text` 节中的内存地址就是将要被执行的程序的地址。你可以用如下的命令来查看程序入口链接地址：
```
athena% i386-jos-elf-objdump -f obj/kern/kernel
```
你现在应该能够理解在 `boot/main.c` 中的最小的 ELF 加载器了。它从硬盘中读取内核的每个节，并将它们节的加载地址读入到内存中，然后跳转到内核的入口点。
>
> **练习 6**
>
>
> 我们可以使用 GDB 的 `x` 命令去检查内存。[GDB 手册](http://sourceware.org/gdb/current/onlinedocs/gdb_9.html#SEC63) 上讲的非常详细，但是现在，我们知道命令 `x/Nx ADDR` 是输出地址 `ADDR` 上 `N` 个<ruby> 词 <rt> word </rt></ruby>就够了。（注意在命令中所有的 `x` 都是小写。）警告：<ruby> 词 <rt> word </rt></ruby>的多少并没有一个普遍的标准。在 GNU 汇编中，一个<ruby> 词 <rt> word </rt></ruby>是两个字节（在 xorw 中的 'w'，它在这个词中就是 2 个字节）。
>
>
>
重置机器（退出 QEMU/GDB 然后再次启动它们）。检查内存中在 `0x00100000` 地址上的 8 个词，输出 BIOS 上的引导加载器入口，然后再次找出引导载器上的内核的入口。为什么它们不一样？在第二个断点上有什么内容？（你并不用真的在 QEMU 上去回答这个问题，只需要思考就可以。）
### 第三部分：内核
我们现在开始去更详细地研究最小的 JOS 内核。（最后你还将写一些代码！）就像引导加载器一样，内核也是从一些汇编语言代码设置一些东西开始的，以便于 C 语言代码可以正确运行。
#### 使用虚拟内存去解决位置依赖问题
前面在你检查引导加载器的链接和加载地址时，它们是完全一样的，但是内核的链接地址（可以通过 `objdump` 来输出）和它的加载地址之间差别很大。可以回到前面去看一下，以确保你明白我们所讨论的内容。（链接内核比引导加载器更复杂，因此，链接和加载地址都在 `kern/kernel.ld` 的顶部。）
操作系统内核经常链接和运行在高位的虚拟地址，比如，`0xf0100000`，为的是给让用户程序去使用处理器的虚拟地址空间的低位部分。至于为什么要这么安排，在下一个实验中我们将会知道。
许多机器在 `0xf0100000` 处并没有物理地址，因此，我们不能指望在那个位置可以存储内核。相反，我们使用处理器的内存管理硬件去映射虚拟地址 `0xf0100000`（内核代码打算运行的链接地址）到物理地址 `0x00100000`（引导加载器将内核加载到内存的物理地址的位置）。通过这种方法，虽然内核的虚拟地址是高位的，离用户程序的地址空间足够远，它将被加载到 PC 的物理内存的 1MB 的位置，只处于 BIOS ROM 之上。这种方法要求 PC 至少要多于 1 MB 的物理内存（以便于物理地址 `0x00100000` 可以工作），这在上世纪九十年代以后生产的PC 上应该是没有问题的。
实际上，在下一个实验中，我们将映射整个 256 MB 的 PC 的物理地址空间，从物理地址 `0x00000000` 到 `0x0fffffff`，映射到虚拟地址 `0xf0000000` 到 `0xffffffff`。你现在就应该明白了为什么 JOS 只能使用物理内存的前 256 MB 的原因了。
现在，我们只映射前 4 MB 的物理内存，它足够我们的内核启动并运行。我们通过在 `kern/entrypgdir.c` 中手工写入静态初始化的页面目录和页面表就可以实现。现在，你不需要理解它们是如何工作的详细细节，只需要达到目的就行了。将上面的 `kern/entry.S` 文件中设置 `CR0_PG` 标志，内存引用就被视为物理地址（严格来说，它们是线性地址，但是，在 `boot/boot.S` 中设置了一个从线性地址到物理地址的映射标识，我们绝对不能改变它）。一旦 `CR0_PG` 被设置，内存引用的就是虚拟地址，这个虚拟地址是通过虚拟地址硬件将物理地址转换得到的。`entry_pgdir` 将把从 `0x00000000` 到 `0x00400000` 的物理地址范围转换在 `0xf0000000` 到 `0xf0400000` 的范围内的虚拟地址。任何不在这两个范围之一中的地址都将导致硬件异常，因为，我们还没有设置中断去处理这种情况，这种异常将导致 QEMU 去转储机器状态然后退出。（或者如果你没有在 QEMU 中应用 6.828 专用补丁，将导致 QEMU 无限重启。)
>
> **练习 7**
>
>
> 使用 QEMU 和 GDB 去跟踪进入到 JOS 内核，然后停止在 `movl %eax, %cr0` 指令处。检查 `0x00100000` 和 `0xf0100000` 处的内存。现在使用GDB 的 `stepi` 命令去单步执行那个指令。再次检查 `0x00100000` 和 `0xf0100000` 处的内存。确保你能理解这时发生的事情。
>
>
>
新映射建立之后的第一个指令是什么？如果没有映射到位，它将不能正常工作。在 `kern/entry.S` 中注释掉 `movl %eax, %cr0`。然后跟踪它，看看你的猜测是否正确。
#### 格式化控制台的输出
大多数人认为像 `printf()` 这样的函数是天生就有的，有时甚至认为这是 C 语言的 “原语”。但是在操作系统的内核中，我们需要自己去实现所有的 I/O。
通过阅读 `kern/printf.c`、`lib/printfmt.c`、以及 `kern/console.c`，确保你理解了它们之间的关系。在后面的实验中，你将会明白为什么 `printfmt.c` 是位于单独的 `lib` 目录中。
>
> **练习 8**
>
>
> 我们将省略掉一小部分代码片断 —— 这部分代码片断是使用 ”%o" 模式输出八进制数字所需要的。找到它并填充到这个代码片断中。
>
>
> 然后你就能够回答下列的问题：
>
>
> 1. 解释 `printf.c` 和 `console.c` 之间的接口。尤其是，`console.c` 出口的函数是什么？这个函数是如何被 `printf.c` 使用的？
> 2. 在 `console.c` 中解释下列的代码：
>
>
>
> ```
> if (crt_pos >= CRT_SIZE) {
> int i;
> memcpy(crt_buf, crt_buf + CRT_COLS, (CRT_SIZE - CRT_COLS) * sizeof(uint16_t));
> for (i = CRT_SIZE - CRT_COLS; i < CRT_SIZE; i++)
> crt_buf[i] = 0x0700 | ' ';
> crt_pos -= CRT_COLS;
> }
>
> ```
> 3. 下列的问题你可能需要参考第一节课中的笔记。这些笔记涵盖了 GCC 在 x86 上的调用规则。
>
>
> 一步一步跟踪下列代码的运行：
>
>
>
> ```
> int x = 1, y = 3, z = 4;
> cprintf("x %d, y %x, z %d\n", x, y, z);
>
> ```
>
> 1. 在调用 `cprintf()` 时，`fmt` 做了些什么？`ap` 做了些什么？
> 2. （按运行顺序）列出 `cons_putc`、`va_arg`、以及 `vcprintf` 的调用列表。对于 `cons_putc`，同时列出它的参数。对于`va_arg`，列出调用之前和之后的 `ap` 内容？对于 `vcprintf`，列出它的两个参数值。
> 4. 运行下列代码：
>
>
>
> ```
> unsigned int i = 0x00646c72;
> cprintf("H%x Wo%s", 57616, &i);
>
> ```
>
> 输出是什么？解释如何在前面的练习中一步一步实现这个输出。这是一个 [ASCII 表](http://web.cs.mun.ca/%7Emichael/c/ascii-table.html)，它是一个字节到字符串的映射表。
>
>
> 这个输出取决于 x86 是小端法这一事实。如果这个 x86 采用大端法格式，你怎么去设置 `i`，以产生相同的输出？你需要将 `57616` 改变为一个不同值吗？
>
>
> [这是小端法和大端法的描述](http://www.webopedia.com/TERM/b/big_endian.html) 和 [一个更古怪的描述](http://www.networksorcery.com/enp/ien/ien137.txt)。
> 5. 在下列代码中，`y=` 会输出什么？（注意：这个问题没有确切值）为什么会发生这种情况？ `cprintf("x=%d y=%d", 3);`
> 6. 假设修改了 GCC 的调用规则，以便于按声明的次序在栈上推送参数，这样最后的参数就是最后一个推送进去的。那你如何去改变 `cprintf` 或者它的接口，以便它仍然可以传递数量可变的参数？
>
>
>
#### 栈
在本实验的最后一个练习中，我们将理详细地解释在 x86 中 C 语言是如何使用栈的，以及在这个过程中，我们将写一个新的内核监视函数，这个函数将输出栈的回溯信息：一个保存了指令指针（IP）值的列表，这个列表中有嵌套的 `call` 指令运行在当前运行点的指针值。
>
> **练习 9**
>
>
> 搞清楚内核在什么地方初始化栈，以及栈在内存中的准确位置。内核如何为栈保留空间？以及这个保留区域的 “结束” 位置是指向初始化结束后的指针吗？
>
>
>
x86 栈指针（`esp` 寄存器）指向当前使用的栈的最低位置。在这个区域中那个位置以下的所有部分都是空闲的。给一个栈推送一个值涉及下移栈指针和栈指针指向的位置中写入值。从栈中弹出一个值涉及到从栈指针指向的位置读取值和上移栈指针。在 32 位模式中，栈中仅能保存 32 位值，并且 `esp` 通常分为四部分。各种 x86 指令，比如，`call`，是 “硬编码” 去使用栈指针寄存器的。
相比之下，`ebp`（基指针）寄存器，按软件惯例主要是由栈关联的。在进入一个 C 函数时，函数的前序代码在函数运行期间，通常会通过推送它到栈中来保存前一个函数的基指针，然后拷贝当前的 `esp` 值到 `ebp` 中。如果一个程序中的所有函数都遵守这个规则，那么，在程序运行过程中的任何一个给定时间点，通过在 `ebp` 中保存的指针链和精确确定的函数嵌套调用顺序是如何到达程序中的这个特定的点，就可以通过栈来跟踪回溯。这种跟踪回溯的函数在实践中非常有用，比如，由于给某个函数传递了一个错误的参数，导致一个 `assert` 失败或者 `panic`，但是，你并不能确定是谁传递了错误的参数。栈的回溯跟踪可以让你找到这个惹麻烦的函数。
>
> **练习 10**
>
>
> 要熟悉 x86 上的 C 调用规则，可以在 `obj/kern/kernel.asm` 文件中找到函数 `test_backtrace` 的地址，设置一个断点，然后检查在内核启动后，每次调用它时发生了什么。每个递归嵌套的 `test_backtrace` 函数在栈上推送了多少个词（word），这些词（word）是什么？
>
>
>
上面的练习可以给你提供关于实现栈跟踪回溯函数的一些信息，为实现这个函数，你应该去调用 `mon_backtrace()`。在 `kern/monitor.c` 中已经给你提供了这个函数的一个原型。你完全可以在 C 中去使用它，但是，你可能需要在 `inc/x86.h` 中使用到 `read_ebp()` 函数。你应该在这个新函数中实现一个到内核监视命令的钩子，以便于用户可以与它交互。
这个跟踪回溯函数将以下面的格式显示一个函数调用列表：
```
Stack backtrace:
ebp f0109e58 eip f0100a62 args 00000001 f0109e80 f0109e98 f0100ed2 00000031
ebp f0109ed8 eip f01000d6 args 00000000 00000000 f0100058 f0109f28 00000061
...
```
输出的第一行列出了当前运行的函数，名字为 `mon_backtrace`，就是它自己，第二行列出了被 `mon_backtrace` 调用的函数，第三行列出了另一个被调用的函数，依次类推。你可以输出所有未完成的栈帧。通过研究 `kern/entry.S`，你可以发现，有一个很容易的方法告诉你何时停止。
在每一行中，`ebp` 表示了那个函数进入栈的基指针：即，栈指针的位置，它就是函数进入之后，函数的前序代码设置的基指针。`eip` 值列出的是函数的返回指令指针：当函数返回时，指令地址将控制返回。返回指令指针一般指向 `call` 指令之后的指令（想一想为什么？）。在 `args` 之后列出的五个十六进制值是在问题中传递给函数的前五个参数。当然，如果函数调用时传递的参数少于五个，那么，在这里就不会列出全部五个值了。（为什么跟踪回溯代码不能检测到调用时实际上传递了多少个参数？如何去修复这个 “缺陷”？）
下面是在阅读 K&R 的书中的第 5 章中的一些关键点，为了接下来的练习和将来的实验，你应该记住它们。
* 如果 `int *p = (int*)100`，那么 `(int)p + 1` 和 `(int)(p + 1)` 是不同的数字：前一个是 `101`，但是第二个是 `104`。当在一个指针上加一个整数时，就像第二种情况，这个整数将隐式地与指针所指向的对象相乘。
* `p[i]` 的定义与 `*(p+i)` 定义是相同的，都反映了在内存中由 `p` 指向的第 `i` 个对象。当对象大于一个字节时，上面的加法规则可以使这个定义正常工作。
* `&p[i]` 与 `(p+i)` 是相同的，获取在内存中由 p 指向的第 `i` 个对象的地址。
虽然大多数 C 程序不需要在指针和整数之间转换，但是操作系统经常做这种转换。不论何时，当你看到一个涉及内存地址的加法时，你要问你自己，你到底是要做一个整数加法还是一个指针加法，以确保做完加法后的值是正确的，而不是相乘后的结果。
>
> **练 11**
>
>
> 实现一个像上面详细描述的那样的跟踪回溯函数。一定使用与示例中相同的输出格式，否则，将会引发评级脚本的识别混乱。在你认为你做的很好的时候，运行 `make grade` 这个评级脚本去查看它的输出是否是我们的脚本所期望的结果，如果不是去修改它。你提交了你的实验 1 代码后，我们非常欢迎你将你的跟踪回溯函数的输出格式修改成任何一种你喜欢的格式。
>
>
>
在这时，你的跟踪回溯函数将能够给你提供导致 `mon_backtrace()` 被运行的，在栈上调用它的函数的地址。但是，在实践中，你经常希望能够知道这个地址相关的函数名字。比如，你可能希望知道是哪个有 Bug 的函数导致了你的内核崩溃。
为帮助你实现这个功能，我们提供了 `debuginfo_eip()` 函数，它在符号表中查找 `eip`，然后返回那个地址的调试信息。这个函数定义在 `kern/kdebug.c` 文件中。
>
> **练习 12**
>
>
> 修改你的栈跟踪回溯函数，对于每个 `eip`，显示相关的函数名字、源文件名、以及那个 `eip` 的行号。
>
>
>
在 `debuginfo_eip` 中，`__STAB_*` 来自哪里？这个问题的答案很长；为帮助你找到答案，下面是你需要做的一些事情：
* 在 `kern/kernel.ld` 文件中查找 `__STAB_*`
* 运行 `i386-jos-elf-objdump -h obj/kern/kernel`
* 运行 `i386-jos-elf-objdump -G obj/kern/kernel`
* 运行 `i386-jos-elf-gcc -pipe -nostdinc -O2 -fno-builtin -I. -MD -Wall -Wno-format -DJOS_KERNEL -gstabs -c -S kern/init.c, and look at init.s`。
* 如果引导加载器在加载二进制内核时，将符号表作为内核的一部分加载进内存中，那么，去查看它。
通过在 `stab_binsearch` 中插入调用，可以完成在 `debuginfo_eip` 中通过地址找到行号的功能。
在内核监视中添加一个 `backtrace` 命令，扩展你实现的 `mon_backtrace` 的功能，通过调用 `debuginfo_eip`，然后以下面的格式来输出每个栈帧行：
```
K> backtrace
Stack backtrace:
ebp f010ff78 eip f01008ae args 00000001 f010ff8c 00000000 f0110580 00000000
kern/monitor.c:143: monitor+106
ebp f010ffd8 eip f0100193 args 00000000 00001aac 00000660 00000000 00000000
kern/init.c:49: i386_init+59
ebp f010fff8 eip f010003d args 00000000 00000000 0000ffff 10cf9a00 0000ffff
kern/entry.S:70: <unknown>+0
K>
```
每行都给出了文件名和在那个文件中栈帧的 `eip` 所在的行，紧接着是函数的名字和那个函数的第一个指令到 `eip` 的偏移量（比如，`monitor+106` 意味着返回 `eip` 是从 `monitor` 开始之后的 106 个字节）。
为防止评级脚本引起混乱，应该将文件和函数名输出在单独的行上。
提示：`printf` 格式的字符串提供一个易用（尽管有些难理解）的方式去输出<ruby> 非空终止 <rt> non-null-terminated </rt></ruby>字符串，就像在 STABS 表中的这些一样。`printf("%.*s", length, string)` 输出 `string` 中的最多 `length` 个字符。查阅 `printf` 的 man 页面去搞清楚为什么这样工作。
你可以从 `backtrace` 中找到那些没有的功能。比如，你或者可能看到一个到 `monitor()` 的调用，但是没有到 `runcmd()` 中。这是因为编译器的行内（in-lines）函数调用。其它的优化可能导致你看到一些意外的行号。如果你从 `GNUMakefile` 删除 `-O2` 参数，`backtraces` 可能会更有意义（但是你的内核将运行的更慢）。
**到此为止， 在 `lab` 目录中的实验全部完成**，使用 `git commit` 提交你的改变，然后输入 `make handin` 去提交你的代码。
---
via: <https://sipb.mit.edu/iap/6.828/lab/lab1/>
作者：[mit](https://sipb.mit.edu) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
完全指南：在容器中运行 Jenkins 构建
|
Balazs Szeti
|
https://opensource.com/article/18/4/running-jenkins-builds-containers
|
容器应用程序平台能够动态地启动具有资源限制的独立容器，从而改变了运行 CI/CD 任务的方式。
|
/data/attachment/album/201806/13/111450vsyhlo44rtszsp57.jpg.thumb.jpg
|
/data/attachment/album/201806/13/111450vsyhlo44rtszsp57.jpg
| true | false | true |
pinewall
| false |
[
"Jenkins",
"Maven",
"CI",
"CD"
] |
技术
|
{
"viewnum": 7845,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11546,
"displayorder": 0
}
] |
容器应用程序平台能够动态地启动具有资源限制的独立容器，从而改变了运行 CI/CD 任务的方式。
| 2018-06-13T11:15:05 | 2018-06-13T11:15:05 | 9,741 |
/article-9741-1.html
|
>
> 容器应用程序平台能够动态地启动具有资源限制的独立容器，从而改变了运行 CI/CD 任务的方式。
>
>
>
现今，由于 [Docker](https://opensource.com/resources/what-docker) 和 [Kubernetes](https://opensource.com/resources/what-is-kubernetes)（K8S）提供了可扩展、可管理的应用平台，将应用运行在容器中的实践已经被企业广泛接受。近些年势头很猛的[微服务架构](https://martinfowler.com/articles/microservices.html)也很适合用容器实现。
容器应用平台可以动态启动指定资源配额、互相隔离的容器，这是其最主要的优势之一。让我们看看这会对我们运行<ruby> 持续集成/持续部署 <rt> continuous integration/continuous development </rt></ruby>（CI/CD）任务的方式产生怎样的改变。
构建并打包应用需要一定的环境，要求能够下载源代码、使用相关依赖及已经安装构建工具。作为构建的一部分，运行单元及组件测试可能会用到本地端口或需要运行第三方应用（如数据库及消息中间件等）。另外，我们一般定制化多台构建服务器，每台执行一种指定类型的构建任务。为方便测试，我们维护一些实例专门用于运行第三方应用（或者试图在构建服务器上启动这些第三方应用），避免并行运行构建任务导致结果互相干扰。为 CI/CD 环境定制化构建服务器是一项繁琐的工作，而且随着开发团队使用的开发平台或其版本变更，会需要大量的构建服务器用于不同的任务。
一旦我们有了容器管理平台（自建或在云端），将资源密集型的 CI/CD 任务在动态生成的容器中执行是比较合理的。在这种方案中，每个构建任务运行在独立启动并配置的构建环境中。构建过程中，构建任务的测试环节可以任意使用隔离环境中的可用资源；此外，我们也可以在辅助容器中启动一个第三方应用，只在构建任务生命周期中为测试提供服务。
听上去不错，让我们在现实环境中实践一下。
注：本文基于现实中已有的解决方案，即一个在 [Red Hat OpenShift](https://www.openshift.com/) v3.7 集群上运行的项目。OpenShift 是企业级的 Kubernetes 版本，故这些实践也适用于 K8S 集群。如果愿意尝试，可以下载 [Red Hat CDK](https://developers.redhat.com/products/cdk/overview/)，运行 `jenkins-ephemeral` 或 `jenkins-persistent` [模板](https://github.com/openshift/origin/tree/master/examples/jenkins)在 OpenShift 上创建定制化好的 Jenkins 管理节点。
### 解决方案概述
在 OpenShift 容器中执行 CI/CD 任务（构建和测试等） 的方案基于[分布式 Jenkins 构建](https://wiki.jenkins.io/display/JENKINS/Distributed+builds)，具体如下：
* 我们需要一个 Jenkins 主节点；可以运行在集群中，也可以是外部提供
* 支持 Jenkins 特性和插件，以便已有项目仍可使用
* 可以用 Jenkins GUI 配置、运行任务或查看任务输出
* 如果你愿意编码，也可以使用 [Jenkins Pipeline](https://jenkins.io/doc/book/pipeline/)
从技术角度来看，运行任务的动态容器是 Jenkins 代理节点。当构建启动时，首先是一个新节点启动，通过 Jenkins 主节点的 JNLP（5000 端口） 告知就绪状态。在代理节点启动并提取构建任务之前，构建任务处于排队状态。就像通常 Jenkins 代理服务器那样，构建输出会送达主节点；不同的是，构建完成后代理节点容器会自动关闭。
不同类型的构建任务（例如 Java、 NodeJS、 Python等）对应不同的代理节点。这并不新奇，之前也是使用标签来限制哪些代理节点可以运行指定的构建任务。启动用于构建任务的 Jenkins 代理节点容器需要配置参数，具体如下：
* 用于启动容器的 Docker 镜像
* 资源限制
* 环境变量
* 挂载的卷
这里用到的关键组件是 [Jenkins Kubernetes 插件](https://github.com/jenkinsci/kubernetes-plugin)。该插件（通过使用一个服务账号） 与 K8S 集群交互，可以启动和关闭代理节点。在插件的配置管理中，多种代理节点类型表现为多种 Kubernetes pod 模板，它们通过项目标签对应。
这些[代理节点镜像](https://access.redhat.com/containers/#/search/jenkins%2520slave)以开箱即用的方式提供（也有 [CentOS7](https://hub.docker.com/search/?isAutomated=0&isOfficial=0&page=1&pullCount=0&q=openshift+jenkins+slave+&starCount=0) 系统的版本）：
* [jenkins-slave-base-rhel7](https://github.com/openshift/jenkins/tree/master/slave-base)：基础镜像，启动与 Jenkins 主节点连接的代理节点；其中 Java 堆大小根据容器内容设置
* [jenkins-slave-maven-rhel7](https://github.com/openshift/jenkins/tree/master/slave-maven)：用于 Maven 和 Gradle 构建的镜像（从基础镜像扩展）
* [jenkins-slave-nodejs-rhel7](https://github.com/openshift/jenkins/tree/master/slave-nodejs)：包含 NodeJS4 工具的镜像（从基础镜像扩展）
注意：本解决方案与 OpenShift 中的 [Source-to-Image（S2I）](https://docs.openshift.com/container-platform/3.7/architecture/core_concepts/builds_and_image_streams.html#source-build) 构建无关，虽然后者也可以用于某些特定的 CI/CD 任务。
### 入门学习资料
有很多不错的博客和文档介绍了如何在 OpenShift 上执行 Jenkins 构建。不妨从下面这些开始：
* [OpenShift Jenkins](https://docs.openshift.com/container-platform/3.7/using_images/other_images/jenkins.html) 镜像文档及 [源代码](https://github.com/openshift/jenkins)
* 网络播客：[基于 OpenShift 的 CI/CD](https://blog.openshift.com/cicd-with-openshift/)
* [外部 Jenkins 集成](http://v1.uncontained.io/playbooks/continuous_delivery/external-jenkins-integration.html) 剧本
阅读这些博客和文档有助于完整的理解本解决方案。在本文中，我们主要关注具体实践中遇到的各类问题。
### 构建我的应用
作为[示例项目](https://github.com/bszeti/camel-springboot/tree/master/camel-rest-complex)，我们选取了包含如下构建步骤的 Java 项目：
* **代码源：** 从一个 Git 代码库中获取项目代码
* **使用 Maven 编译：** 依赖可从内部仓库获取，(不妨使用 Apache Nexus） 镜像自外部 Maven 仓库
* **发布成品：** 将编译好的 JAR 上传至内部仓库
在 CI/CD 过程中，我们需要与 Git 和 Nexus 交互，故 Jenkins 任务需要能够访问这些系统。这要求参数配置和已存储凭证可以在下列位置进行管理：
* **在 Jenkins 中：** 我们可以在 Jenkins 中添加凭证，通过 Git 插件能够对项目添加和使用文件（使用容器不会改变操作）
* **在 OpenShift 中：** 使用 ConfigMap 和 Secret 对象，以文件或环境变量的形式附加到 Jenkins 代理容器中
* **在高度定制化的 Docker 容器中：** 镜像是定制化的，已包含完成特定类型构建的全部特性；从一个代理镜像进行扩展即可得到。
你可以按自己的喜好选择一种实现方式，甚至你最终可能混用多种实现方式。下面我们采用第二种实现方式，即首选在 OpenShift 中管理参数配置。使用 Kubernetes 插件配置来定制化 Maven 代理容器，包括设置环境变量和映射文件等。
注意：对于 Kubernetes 插件 v1.0 版，由于 [bug](https://issues.jenkins-ci.org/browse/JENKINS-47112)，在 UI 界面增加环境变量并不生效。可以升级插件，或（作为变通方案） 直接修改 `config.xml` 文件并重启 Jenkins。
### 从 Git 获取源代码
从公共 Git 仓库获取源代码很容易。但对于私有 Git 仓库，不仅需要认证操作，客户端还需要信任服务器以便建立安全连接。一般而言，通过两种协议获取源代码：
* HTTPS：验证通过用户名/密码完成。Git 服务器的 SSL 证书必须被代理节点信任，这仅在证书被自建 CA 签名时才需要特别注意。
```
git clone https://git.mycompany.com:443/myapplication.git
```
* SSH：验证通过私钥完成。如果服务器的公钥指纹出现在 `known_hosts` 文件中，那么该服务器是被信任的。
```
git clone ssh://git@git.mycompany.com:22/myapplication.git
```
对于手动操作，使用用户名/密码通过 HTTP 方式下载源代码是可行的；但对于自动构建而言，SSH 是更佳的选择。
#### 通过 SSH 方式使用 Git
要通过 SSH 方式下载源代码，我们需要保证代理容器与 Git 的 SSH 端口之间可以建立 SSH 连接。首先，我们需要创建一个私钥-公钥对。使用如下命令生成：
```
ssh keygen -t rsa -b 2048 -f my-git-ssh -N ''
```
命令生成的私钥位于 `my-git-ssh` 文件中（口令为空），对应的公钥位于 `my-git-ssh.pub` 文件中。将公钥添加至 Git 服务器的对应用户下（推荐使用“服务账号”）；网页界面一般支持公钥上传。为建立 SSH 连接，我们还需要在代理容器上配置两个文件：
* 私钥文件位于 `~/.ssh/id_rsa`
* 服务器的公钥位于 `~/.ssh/known_hosts`。要实现这一点，运行 `ssh git.mycompany.com` 并接受服务器指纹，系统会在 `~/.ssh/known_hosts` 文件中增加一行。这样需求得到了满足。
将 `id_rsa` 对应的私钥和 `known_hosts` 对应的公钥保存到一个 OpenShift 的 secret（或 ConfigMap） 对象中。
```
apiVersion: v1
kind: Secret
metadata:
name: mygit-ssh
stringData:
id_rsa: |-
-----BEGIN RSA PRIVATE KEY-----
...
-----END RSA PRIVATE KEY-----
known_hosts: |-
git.mycompany.com ecdsa-sha2-nistp256 AAA...
```
在 Kubernetes 插件中将 secret 对象配置为卷，挂载到 `/home/jenkins/.ssh/`，供 Maven pod 使用。secret 中的每个对象对应挂载目录的一个文件，文件名与 key 名称相符。我们可以使用 UI（管理 Jenkins / 配置 / 云 / Kubernetes），也可以直接编辑 Jenkins 配置文件 `/var/lib/jenkins/config.xml`：
```
<org.csanchez.jenkins.plugins.kubernetes.PodTemplate>
<name>maven</name>
...
<volumes>
<org.csanchez.jenkins.plugins.kubernetes.volumes.SecretVolume>
<mountPath>/home/jenkins/.ssh</mountPath>
<secretName>mygit-ssh</secretName>
</org.csanchez.jenkins.plugins.kubernetes.volumes.SecretVolume>
</volumes>
```
此时，在代理节点上运行的任务应该可以通过 SSH 方式从 Git 代码库获取源代码。
注：我们也可以在 `~/.ssh/config` 文件中自定义 SSH 连接。例如，如果你不想处理 `known_hosts` 或私钥位于其它挂载目录中：
```
Host git.mycompany.com
StrictHostKeyChecking no
IdentityFile /home/jenkins/.config/git-secret/ssh-privatekey
```
#### 通过 HTTP 方式使用 Git
如果你选择使用 HTTP 方式下载，在指定的 [Git-credential-store](https://git-scm.com/docs/git-credential-store/1.8.2) 文件中添加用户名/密码：
* 例如，在一个 OpenShift secret 对象中增加 `/home/jenkins/.config/git-secret/credentials` 文件对应，其中每个站点对应文件中的一行:
```
https://username:password@git.mycompany.com
https://user:pass@github.com
```
* 在 [git-config](https://git-scm.com/docs/git-config/1.8.2) 配置中启用该文件，其中配置文件默认路径为 `/home/jenkins/.config/git/config`：
```
[credential]
helper = store --file=/home/jenkins/.config/git-secret/credentials
```
如果 Git 服务使用了自有 CA 签名的证书，为代理容器设置环境变量 `GIT_SSL_NO_VERIFY=true` 是最便捷的方式。更恰当的解决方案包括如下两步：
* 利用 ConfigMap 将自有 CA 的公钥映射到一个路径下的文件中，例如 `/usr/ca/myTrustedCA.pem`）。
* 通过环境变量 `GIT_SSL_CAINFO=/usr/ca/myTrustedCA.pem` 或上面提到的 `git-config` 文件的方式，将证书路径告知 Git。
```
[http "https://git.mycompany.com"]
sslCAInfo = /usr/ca/myTrustedCA.pem
```
注：在 OpenShift v3.7 及早期版本中，ConfigMap 及 secret 的挂载点之间[不能相互覆盖](https://bugzilla.redhat.com/show_bug.cgi?id=1430322)，故我们不能同时映射 `/home/jenkins` 和 `/home/jenkins/dir`。因此，上面的代码中并没有使用常见的文件路径。预计 OpenShift v3.9 版本会修复这个问题。
### Maven
要完成 Maven 构建，一般需要完成如下两步：
* 建立一个社区 Maven 库（例如 Apache Nexus），充当外部库的代理。将其当作镜像使用。
* 这个内部库可能提供 HTTPS 服务，其中使用自建 CA 签名的证书。
对于容器中运行构建的实践而言，使用内部 Maven 库是非常关键的，因为容器启动后并没有本地库或缓存，这导致每次构建时 Maven 都下载全部的 Jar 文件。在本地网络使用内部代理库下载明显快于从因特网下载。
[Maven Jenkins 代理](https://github.com/openshift/jenkins/tree/master/slave-maven)镜像允许配置环境变量，指定代理的 URL。在 Kubernetes 插件的容器模板中设置如下：
```
MAVEN_MIRROR_URL=https://nexus.mycompany.com/repository/maven-public
```
构建好的成品（JAR） 也应该保存到库中，可以是上面提到的用于提供依赖的镜像库，也可以是其它库。Maven 完成 `deploy` 操作需要在 `pom.xml` 的[分发管理](https://maven.apache.org/pom.html#Distribution_Management) 下配置库 URL，这与代理镜像无关。
```
<project ...>
<distributionManagement>
<snapshotRepository>
<id>mynexus</id>
<url>https://nexus.mycompany.com/repository/maven-snapshots/</url>
</snapshotRepository>
<repository>
<id>mynexus</id>
<url>https://nexus.mycompany.com/repository/maven-releases/</url>
</repository>
</distributionManagement>
```
上传成品可能涉及认证。在这种情况下，在 `settings.xml` 中配置的用户名/密码要与 `pom.xml` 文件中的对应的服务器 `id` 下的设置匹配。我们可以使用 OpenShift secret 将包含 URL、用户名和密码的完整 `settings.xml` 映射到 Maven Jenkins 代理容器中。另外，也可以使用环境变量。具体如下：
* 利用 secret 为容器添加环境变量：
```
MAVEN_SERVER_USERNAME=admin
MAVEN_SERVER_PASSWORD=admin123
```
* 利用 config map 将 `settings.xml` 挂载至 `/home/jenkins/.m2/settings.xml`：
```
<settings ...>
<mirrors>
<mirror>
<mirrorOf>external:*</mirrorOf>
<url>${env.MAVEN_MIRROR_URL}</url>
<id>mirror</id>
</mirror>
</mirrors>
<servers>
<server>
<id>mynexus</id>
<username>${env.MAVEN_SERVER_USERNAME}</username>
<password>${env.MAVEN_SERVER_PASSWORD}</password>
</server>
</servers>
</settings>
```
禁用交互模式（即，使用批处理模式） 可以忽略下载日志，一种方式是在 Maven 命令中增加 `-B` 参数，另一种方式是在 `settings.xml` 配置文件中增加 `<interactiveMode>false</interactiveMode>` 配置。
如果 Maven 库的 HTTPS 服务使用自建 CA 签名的证书，我们需要使用 [keytool](https://docs.oracle.com/javase/8/docs/technotes/tools/unix/keytool.html) 工具创建一个将 CA 公钥添加至信任列表的 Java KeyStore。在 OpenShift 中使用 ConfigMap 将这个 Keystore 上传。使用 `oc` 命令基于文件创建一个 ConfigMap：
```
oc create configmap maven-settings --from-file=settings.xml=settings.xml --from-
file=myTruststore.jks=myTruststore.jks
```
将这个 ConfigMap 挂载至 Jenkins 代理容器。在本例中我们使用 `/home/jenkins/.m2` 目录，但这仅仅是因为配置文件 `settings.xml` 也对应这个 ConfigMap。KeyStore 可以放置在任意路径下。
接着在容器环境变量 `MAVEN_OPTS` 中设置 Java 参数，以便让 Maven 对应的 Java 进程使用该文件：
```
MAVEN_OPTS=
-Djavax.net.ssl.trustStore=/home/jenkins/.m2/myTruststore.jks
-Djavax.net.ssl.trustStorePassword=changeit
```
### 内存使用量
这可能是最重要的一部分设置，如果没有正确的设置最大内存，我们会遇到间歇性构建失败，虽然每个组件都似乎工作正常。
如果没有在 Java 命令行中设置堆大小，在容器中运行 Java 可能导致高内存使用量的报错。JVM [可以利用全部的宿主机内存](https://developers.redhat.com/blog/2017/03/14/java-inside-docker/)，而不是使用容器内存现在并相应设置[默认的堆大小](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/parallel.html#default_heap_size)。这通常会超过容器的内存资源总额，故当 Java 进程为堆分配过多内存时，OpenShift 会直接杀掉容器。
虽然 `jenkins-slave-base` 镜像包含一个内建[脚本设置堆最大为](https://github.com/openshift/jenkins/blob/master/slave-base/contrib/bin/run-jnlp-client)容器内存的一半（可以通过环境变量 `CONTAINER_HEAP_PERCENT=0.50` 修改），但这只适用于 Jenkins 代理节点中的 Java 进程。在 Maven 构建中，还有其它重要的 Java 进程运行：
* `mvn` 命令本身就是一个 Java 工具。
* [Maven Surefire 插件](http://maven.apache.org/surefire/maven-surefire-plugin/examples/fork-options-and-parallel-execution.html) 默认派生一个 JVM 用于运行单元测试。
总结一下，容器中同时运行着三个重要的 Java 进程，预估内存使用量以避免 pod 被误杀是很重要的。每个进程都有不同的方式设置 JVM 参数：
* 我们在上面提到了 Jenkins 代理容器堆最大值的计算方法，但我们显然不应该让代理容器使用如此大的堆，毕竟还有两个 JVM 需要使用内存。对于 Jenkins 代理容器，可以设置 `JAVA_OPTS`。
* `mvn` 工具被 Jenkins 任务调用。设置 `MAVEN_OPTS` 可以用于自定义这类 Java 进程。
* Maven `surefire` 插件滋生的用于单元测试的 JVM 可以通过 Maven [argLine](http://maven.apache.org/surefire/maven-surefire-plugin/test-mojo.html#argLine) 属性自定义。可以在 `pom.xml` 或 `settings.xml` 的某个配置文件中设置，也可以直接在 `maven` 命令参数 `MAVEN_OPS` 中增加 `-DargLine=…`。
下面例子给出 Maven 代理容器环境变量设置方法：
```
JAVA_OPTS=-Xms64m -Xmx64m
MAVEN_OPTS=-Xms128m -Xmx128m -DargLine=${env.SUREFIRE_OPTS}
SUREFIRE_OPTS=-Xms256m -Xmx256m
```
我们的测试环境是具有 1024Mi 内存限额的代理容器，使用上述参数可以正常构建一个 SpringBoot 应用并进行单元测试。测试环境使用的资源相对较小，对于复杂的 Maven 项目和对应的单元测试，我们需要更大的堆大小及更大的容器内存限额。
注：Java8 进程的实际内存使用量包括“堆大小 + 元数据 + 堆外内存”，因此内存使用量会明显高于设置的最大堆大小。在我们上面的测试环境中，三个 Java 进程使用了超过 900Mi 的内存。可以在容器内查看进程的 RSS 内存使用情况，命令如下：`ps -e -o pid,user,rss,comm,args`。
Jenkins 代理镜像同时安装了 JDK 64 位和 32 位版本。对于 `mvn` 和 `surefire`，默认使用 64 位版本 JVM。为减低内存使用量，只要 `-Xmx` 不超过 1.5 GB，强制使用 32 位 JVM 都是有意义的。
```
JAVA_HOME=/usr/lib/jvm/Java-1.8.0-openjdk-1.8.0.161–0.b14.el7_4.i386
```
注意到我们可以在 `JAVA_TOOL_OPTIONS` 环境变量中设置 Java 参数，每个 JVM 启动时都会读取该参数。`JAVA_OPTS` 和 `MAVEN_OPTS` 中的参数会覆盖 `JAVA_TOOL_OPTIONS` 中的对应值，故我们可以不使用 `argLine`，实现对 Java 进程同样的堆配置：
```
JAVA_OPTS=-Xms64m -Xmx64m
MAVEN_OPTS=-Xms128m -Xmx128m
JAVA_TOOL_OPTIONS=-Xms256m -Xmx256m
```
但缺点是每个 JVM 的日志中都会显示 `Picked up JAVA_TOOL_OPTIONS:`，这可能让人感到迷惑。
### Jenkins 流水线
完成上述配置，我们应该已经可以完成一次成功的构建。我们可以获取源代码，下载依赖，运行单元测试并将成品上传到我们的库中。我们可以通过创建一个 Jenkins 流水线项目来完成上述操作。
```
pipeline {
/* Which container to bring up for the build. Pick one of the templates configured in Kubernetes plugin. */
agent {
label 'maven'
}
stages {
stage('Pull Source') {
steps {
git url: 'ssh://git@git.mycompany.com:22/myapplication.git', branch: 'master'
}
}
stage('Unit Tests') {
steps {
sh 'mvn test'
}
}
stage('Deploy to Nexus') {
steps {
sh 'mvn deploy -DskipTests'
}
}
}
}
```
当然，对应真实项目，CI/CD 流水线不仅仅完成 Maven 构建，还可以部署到开发环境，运行集成测试，提升至更接近于生产的环境等。上面给出的学习资料中有执行这些操作的案例。
### 多容器
一个 pod 可以运行多个容器，每个容器有单独的资源限制。这些容器共享网络接口，故我们可以从 `localhost` 访问已启动的服务，但我们需要考虑端口冲突的问题。在一个 Kubernetes pod 模板中，每个容器的环境变量是单独设置的，但挂载的卷是统一的。
当一个外部服务需要单元测试且嵌入式方案无法工作（例如，数据库、消息中间件等） 时，可以启动多个容器。在这种情况下，第二个容器会随着 Jenkins 代理容器启停。
查看 Jenkins `config.xml` 片段，其中我们启动了一个辅助的 `httpbin` 服务用于 Maven 构建：
```
<org.csanchez.jenkins.plugins.kubernetes.PodTemplate>
<name>maven</name>
<volumes>
...
</volumes>
<containers>
<org.csanchez.jenkins.plugins.kubernetes.ContainerTemplate>
<name>jnlp</name>
<image>registry.access.redhat.com/openshift3/jenkins-slave-maven-rhel7:v3.7</image>
<resourceLimitCpu>500m</resourceLimitCpu>
<resourceLimitMemory>1024Mi</resourceLimitMemory>
<envVars>
...
</envVars>
...
</org.csanchez.jenkins.plugins.kubernetes.ContainerTemplate>
<org.csanchez.jenkins.plugins.kubernetes.ContainerTemplate>
<name>httpbin</name>
<image>citizenstig/httpbin</image>
<resourceLimitCpu></resourceLimitCpu>
<resourceLimitMemory>256Mi</resourceLimitMemory>
<envVars/>
...
</org.csanchez.jenkins.plugins.kubernetes.ContainerTemplate>
</containers>
<envVars/>
</org.csanchez.jenkins.plugins.kubernetes.PodTemplate>
```
### 总结
作为总结，我们查看上面已描述配置的 Jenkins `config.xml` 对应创建的 OpenShift 资源以及 Kubernetes 插件的配置。
```
apiVersion: v1
kind: List
metadata: {}
items:
- apiVersion: v1
kind: ConfigMap
metadata:
name: git-config
data:
config: |
[credential]
helper = store --file=/home/jenkins/.config/git-secret/credentials
[http "http://git.mycompany.com"]
sslCAInfo = /home/jenkins/.config/git/myTrustedCA.pem
myTrustedCA.pem: |-
-----BEGIN CERTIFICATE-----
MIIDVzCCAj+gAwIBAgIJAN0sC...
-----END CERTIFICATE-----
- apiVersion: v1
kind: Secret
metadata:
name: git-secret
stringData:
ssh-privatekey: |-
-----BEGIN RSA PRIVATE KEY-----
...
-----END RSA PRIVATE KEY-----
credentials: |-
https://username:password@git.mycompany.com
https://user:pass@github.com
- apiVersion: v1
kind: ConfigMap
metadata:
name: git-ssh
data:
config: |-
Host git.mycompany.com
StrictHostKeyChecking yes
IdentityFile /home/jenkins/.config/git-secret/ssh-privatekey
known_hosts: '[git.mycompany.com]:22 ecdsa-sha2-nistp256 AAAdn7...'
- apiVersion: v1
kind: Secret
metadata:
name: maven-secret
stringData:
username: admin
password: admin123
```
基于文件创建另一个 ConfigMap：
```
oc create configmap maven-settings --from-file=settings.xml=settings.xml
--from-file=myTruststore.jks=myTruststore.jks
```
Kubernetes 插件配置如下：
```
<?xml version='1.0' encoding='UTF-8'?>
<hudson>
...
<clouds>
<org.csanchez.jenkins.plugins.kubernetes.KubernetesCloud plugin="kubernetes@1.0">
<name>openshift</name>
<defaultsProviderTemplate></defaultsProviderTemplate>
<templates>
<org.csanchez.jenkins.plugins.kubernetes.PodTemplate>
<inheritFrom></inheritFrom>
<name>maven</name>
<namespace></namespace>
<privileged>false</privileged>
<alwaysPullImage>false</alwaysPullImage>
<instanceCap>2147483647</instanceCap>
<slaveConnectTimeout>100</slaveConnectTimeout>
<idleMinutes>0</idleMinutes>
<label>maven</label>
<serviceAccount>jenkins37</serviceAccount>
<nodeSelector></nodeSelector>
<nodeUsageMode>NORMAL</nodeUsageMode>
<customWorkspaceVolumeEnabled>false</customWorkspaceVolumeEnabled>
<workspaceVolume class="org.csanchez.jenkins.plugins.kubernetes.volumes.workspace.EmptyDirWorkspaceVolume">
<memory>false</memory>
</workspaceVolume>
<volumes>
<org.csanchez.jenkins.plugins.kubernetes.volumes.SecretVolume>
<mountPath>/home/jenkins/.config/git-secret</mountPath>
<secretName>git-secret</secretName>
</org.csanchez.jenkins.plugins.kubernetes.volumes.SecretVolume>
<org.csanchez.jenkins.plugins.kubernetes.volumes.ConfigMapVolume>
<mountPath>/home/jenkins/.ssh</mountPath>
<configMapName>git-ssh</configMapName>
</org.csanchez.jenkins.plugins.kubernetes.volumes.ConfigMapVolume>
<org.csanchez.jenkins.plugins.kubernetes.volumes.ConfigMapVolume>
<mountPath>/home/jenkins/.config/git</mountPath>
<configMapName>git-config</configMapName>
</org.csanchez.jenkins.plugins.kubernetes.volumes.ConfigMapVolume>
<org.csanchez.jenkins.plugins.kubernetes.volumes.ConfigMapVolume>
<mountPath>/home/jenkins/.m2</mountPath>
<configMapName>maven-settings</configMapName>
</org.csanchez.jenkins.plugins.kubernetes.volumes.ConfigMapVolume>
</volumes>
<containers>
<org.csanchez.jenkins.plugins.kubernetes.ContainerTemplate>
<name>jnlp</name>
<image>registry.access.redhat.com/openshift3/jenkins-slave-maven-rhel7:v3.7</image>
<privileged>false</privileged>
<alwaysPullImage>false</alwaysPullImage>
<workingDir>/tmp</workingDir>
<command></command>
<args>${computer.jnlpmac} ${computer.name}</args>
<ttyEnabled>false</ttyEnabled>
<resourceRequestCpu>500m</resourceRequestCpu>
<resourceRequestMemory>1024Mi</resourceRequestMemory>
<resourceLimitCpu>500m</resourceLimitCpu>
<resourceLimitMemory>1024Mi</resourceLimitMemory>
<envVars>
<org.csanchez.jenkins.plugins.kubernetes.ContainerEnvVar>
<key>JAVA_HOME</key>
<value>/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.161-0.b14.el7_4.i386</value>
</org.csanchez.jenkins.plugins.kubernetes.ContainerEnvVar>
<org.csanchez.jenkins.plugins.kubernetes.ContainerEnvVar>
<key>JAVA_OPTS</key>
<value>-Xms64m -Xmx64m</value>
</org.csanchez.jenkins.plugins.kubernetes.ContainerEnvVar>
<org.csanchez.jenkins.plugins.kubernetes.ContainerEnvVar>
<key>MAVEN_OPTS</key>
<value>-Xms128m -Xmx128m -DargLine=${env.SUREFIRE_OPTS} -Djavax.net.ssl.trustStore=/home/jenkins/.m2/myTruststore.jks -Djavax.net.ssl.trustStorePassword=changeit</value>
</org.csanchez.jenkins.plugins.kubernetes.ContainerEnvVar>
<org.csanchez.jenkins.plugins.kubernetes.ContainerEnvVar>
<key>SUREFIRE_OPTS</key>
<value>-Xms256m -Xmx256m</value>
</org.csanchez.jenkins.plugins.kubernetes.ContainerEnvVar>
<org.csanchez.jenkins.plugins.kubernetes.ContainerEnvVar>
<key>MAVEN_MIRROR_URL</key>
<value>https://nexus.mycompany.com/repository/maven-public</value>
</org.csanchez.jenkins.plugins.kubernetes.ContainerEnvVar>
<org.csanchez.jenkins.plugins.kubernetes.model.SecretEnvVar>
<key>MAVEN_SERVER_USERNAME</key>
<secretName>maven-secret</secretName>
<secretKey>username</secretKey>
</org.csanchez.jenkins.plugins.kubernetes.model.SecretEnvVar>
<org.csanchez.jenkins.plugins.kubernetes.model.SecretEnvVar>
<key>MAVEN_SERVER_PASSWORD</key>
<secretName>maven-secret</secretName>
<secretKey>password</secretKey>
</org.csanchez.jenkins.plugins.kubernetes.model.SecretEnvVar>
</envVars>
<ports/>
<livenessProbe>
<execArgs></execArgs>
<timeoutSeconds>0</timeoutSeconds>
<initialDelaySeconds>0</initialDelaySeconds>
<failureThreshold>0</failureThreshold>
<periodSeconds>0</periodSeconds>
<successThreshold>0</successThreshold>
</livenessProbe>
</org.csanchez.jenkins.plugins.kubernetes.ContainerTemplate>
<org.csanchez.jenkins.plugins.kubernetes.ContainerTemplate>
<name>httpbin</name>
<image>citizenstig/httpbin</image>
<privileged>false</privileged>
<alwaysPullImage>false</alwaysPullImage>
<workingDir></workingDir>
<command>/run.sh</command>
<args></args>
<ttyEnabled>false</ttyEnabled>
<resourceRequestCpu></resourceRequestCpu>
<resourceRequestMemory>256Mi</resourceRequestMemory>
<resourceLimitCpu></resourceLimitCpu>
<resourceLimitMemory>256Mi</resourceLimitMemory>
<envVars/>
<ports/>
<livenessProbe>
<execArgs></execArgs>
<timeoutSeconds>0</timeoutSeconds>
<initialDelaySeconds>0</initialDelaySeconds>
<failureThreshold>0</failureThreshold>
<periodSeconds>0</periodSeconds>
<successThreshold>0</successThreshold>
</livenessProbe>
</org.csanchez.jenkins.plugins.kubernetes.ContainerTemplate>
</containers>
<envVars/>
<annotations/>
<imagePullSecrets/>
</org.csanchez.jenkins.plugins.kubernetes.PodTemplate>
</templates>
<serverUrl>https://172.30.0.1:443</serverUrl>
<serverCertificate>-----BEGIN CERTIFICATE-----
MIIC6jCC...
-----END CERTIFICATE-----</serverCertificate>
<skipTlsVerify>false</skipTlsVerify>
<namespace>first</namespace>
<jenkinsUrl>http://jenkins.cicd.svc:80</jenkinsUrl>
<jenkinsTunnel>jenkins-jnlp.cicd.svc:50000</jenkinsTunnel>
<credentialsId>1a12dfa4-7fc5-47a7-aa17-cc56572a41c7</credentialsId>
<containerCap>10</containerCap>
<retentionTimeout>5</retentionTimeout>
<connectTimeout>0</connectTimeout>
<readTimeout>0</readTimeout>
<maxRequestsPerHost>32</maxRequestsPerHost>
</org.csanchez.jenkins.plugins.kubernetes.KubernetesCloud>
</clouds>
</hudson>
```
尝试愉快的构建吧！
原文发表于 [ITNext](https://itnext.io/running-jenkins-builds-in-containers-458e90ff2a7b)，已获得翻版授权。
---
via: <https://opensource.com/article/18/4/running-jenkins-builds-containers>
作者：[Balazs Szeti](https://opensource.com/users/bszeti) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
程序员最佳网站
|
Rishabh Kandari
|
http://www.theitstuff.com/best-websites-programmers
|
作为程序员，你经常会发现自己是某些网站的永久访问者。它们可以是教程、参考或论坛。因此，在这篇文章中，让我们看看给程序员的最佳网站。
|
/data/attachment/album/201806/13/113419ebo0mutowobu6ouv.jpg.thumb.jpg
|
/data/attachment/album/201806/13/113419ebo0mutowobu6ouv.jpg
| true | false | true |
geekpi
| false |
[
"网站"
] |
分享
|
{
"viewnum": 14906,
"commentnum": 3,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "39.88.193.186",
"message": "不错不错！",
"username": "绿色圣光 [Firefox 58.0|GNU/Linux]",
"date": "2018-06-14T10:55:22"
},
{
"postip": "123.139.165.25",
"message": "W3Schools 打不开",
"username": "我才是飞天 [Chrome 67.0|Windows 7]",
"date": "2018-06-18T15:25:50"
},
{
"postip": "61.186.24.198",
"message": "可以的： https://www.w3schools.com/",
"username": "linux [Chrome 67.0|Mac 10.13]",
"date": "2018-06-19T09:15:59"
}
] |
[] |
作为程序员，你经常会发现自己是某些网站的永久访问者。它们可以是教程、参考或论坛。因此，在这篇文章中，让我们看看给程序员的最佳网站。
| 2018-06-13T11:34:00 | 2018-06-13T11:34:00 | 9,742 |
/article-9742-1.html
|
作为程序员，你经常会发现自己是某些网站的永久访问者。它们可以是教程、参考或论坛。因此，在这篇文章中，让我们看看给程序员的最佳网站。
### W3Schools
[W3Schools](https://www.w3schools.com/) 是为初学者和有经验的 Web 开发人员学习各种编程语言的最佳网站之一。你可以学习 HTML5、CSS3、PHP、 JavaScript、ASP 等。
更重要的是，该网站为网页开发人员提供了大量资源和参考资料。
[](http://www.theitstuff.com/wp-content/uploads/2017/12/w3schools-logo.png)
你可以快速浏览各种关键字及其功能。该网站非常具有互动性，它允许你在网站本身的嵌入式编辑器中尝试和练习代码。该网站是你作为网页开发人员少数需要经常访问的网站之一。
（LCTT 译注：有一个国内网站 [www.w3school.com.cn](http://www.w3school.com.cn) 提供类似的中文内容，但二者似无关系。）
### GeeksforGeeks
[GeeksforGeeks](http://www.geeksforgeeks.org/) 是一个主要专注于计算机科学的网站。它有大量的算法，解决方案和编程问题。
[](http://www.theitstuff.com/wp-content/uploads/2017/12/geeksforgeeks-programming-support.png)
该网站也有很多面试中经常问到的问题。由于该网站更多地涉及计算机科学，因此你可以找到很多编程问题在大多数著名语言下的解决方案。
### TutorialsPoint
一个学习任何东西的地方。[TutorialsPoint](https://www.tutorialspoint.com/) 有一些又好又简单的教程，它可以教你任何编程语言。我真的很喜欢这个网站，它不仅限于通用编程语言。
你可以在这里上找到几乎所有语言框架的教程。
### StackOverflow
你可能已经知道 [StackOverflow](https://stackoverflow.com/) 是遇到程序员的地方。你在代码中遇到问题，只要在 StackOverflow 问一个问题，来自互联网的程序员将会在那里帮助你。
[](http://www.theitstuff.com/wp-content/uploads/2017/12/stackoverflow-linux-programming-website.png)
关于 StackOverflow 最好的是几乎所有的问题都得到了答案。你可能会从其他程序员的几个不同观点获得答案。
### HackerRank
[HackerRank](https://www.hackerrank.com/) 是一个你可以参与各种编码竞赛并检测你的竞争能力的网站。
[](http://www.theitstuff.com/wp-content/uploads/2017/12/hackerrank-programming-forums.png)
这里有以各种编程语言举办的各种比赛，赢得比赛将增加你的分数。这个分数可以让你处于最高级别，并增加你获得一些软件公司注意的机会。
### Codebeautify
由于我们是程序员，所以美不是我们所关心的。很多时候，我们的代码很难被其他人阅读。[Codebeautify](https://codebeautify.org/) 可以使你的代码易于阅读。
该网站有大多数可以美化的语言。另外，如果你想让你的代码不能被某人读取，你也可以这样做。
这些是我选择的一些最好的程序员网站。如果你有经常访问的我没有提及的网站，请在下面的评论区让我知道。
---
via: <http://www.theitstuff.com/best-websites-programmers>
作者：[Rishabh Kandari](http://www.theitstuff.com/author/reevkandari) 选题：[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/) 荣誉推出
|
||
Stratis 从 ZFS、Btrfs 和 LVM 学到哪些
|
Andy Grover
|
https://opensource.com/article/18/4/stratis-lessons-learned
|
深入了解这个强大而不繁琐的 Linux 存储管理系统。
|
/data/attachment/album/201806/13/225943j7iuzp9rstlyt79f.jpg.thumb.jpg
|
/data/attachment/album/201806/13/225943j7iuzp9rstlyt79f.jpg
| true | false | true |
pinewall
| false |
[
"存储",
"Stratis"
] |
技术
|
{
"viewnum": 7666,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9736,
"displayorder": 0
},
{
"raid": 9755,
"displayorder": 0
}
] |
深入了解这个强大而不繁琐的 Linux 存储管理系统。
| 2018-06-13T22:59:00 | 2018-06-13T22:59:00 | 9,743 |
/article-9743-1.html
|
>
> 深入了解这个强大而不繁琐的 Linux 存储管理系统。
>
>
>
在本系列[第一部分](/article-9736-1.html)中提到，Stratis 是一个<ruby> 卷管理文件系统 <rt> volume-managing filesystem </rt></ruby>（VMF），功能特性类似于 [ZFS](https://en.wikipedia.org/wiki/ZFS) 和 [Btrfs](https://en.wikipedia.org/wiki/Btrfs)。在设计 Stratis 过程中，我们研究了已有解决方案开发者做出的取舍。
### 为何不使用已有解决方案
理由千差万别。先说说 [ZFS](https://en.wikipedia.org/wiki/ZFS)，它最初由 Sun Microsystems 为 Solaris （目前为 Oracle 所有）开发，后移植到 Linux。但 [CDDL](https://en.wikipedia.org/wiki/Common_Development_and_Distribution_License) 协议授权的代码无法合并到 [GPL](https://en.wikipedia.org/wiki/GNU_General_Public_License) 协议授权的 Linux 源码树中。CDDL 与 GPLv2 是否真的不兼容有待讨论，但这种不确定性足以打消企业级 Linux 供应商采用并支持 ZFS 的积极性。
[Btrfs](https://en.wikipedia.org/wiki/Btrfs) 发展也很好，没有授权问题。它已经多年被很多用户列为“最佳文件系统”，但在稳定性和功能特性方面仍有待提高。
我们希望打破现状，解决已有方案的种种问题，这种渴望促成了 Stratis。
### Stratis 如何与众不同
ZFS 和 Btrfs 让我们知道一件事情，即编写一个内核支持的 VMF 文件系统需要花费极大的时间和精力，才能消除漏洞、增强稳定性。涉及核心数据时，提供正确性保证是必要的。如果 Stratis 也采用这种方案并从零开始的话，开发工作也需要十数年，这是无法接受的。
相反地，Stratis 采用 Linux 内核的其它一些已有特性：[device mapper](https://en.wikipedia.org/wiki/Device_mapper) 子系统以及久经考验的高性能文件系统 [XFS](https://en.wikipedia.org/wiki/XFS)，其中前者被 LVM 用于提供 RAID、精简配置和其它块设备特性而广为人知。Stratis 将已有技术作为（技术架构中的）层来创建存储池，目标是通过集成为用户提供一个看似无缝的整体。
### Stratis 从 ZFS 学到哪些
对很多用户而言，ZFS 影响了他们对下一代文件系统的预期。通过查看人们在互联网上关于 ZFS 的讨论，我们设定了 Stratis 的最初开发目标。ZFS 的设计思路也潜在地为我们指明应该避免哪些东西。例如，当挂载一个在其它主机上创建的存储池时，ZFS 需要一个“<ruby> 导入 <rt> import </rt></ruby>”步骤。这样做出于某些原因，但每一种原因都似乎是 Stratis 需要解决的问题，无论是否采用同样的实现方式。
对于增加新硬盘或将已有硬盘替换为更大容量的硬盘，ZFS 有一些限制，尤其是存储池做了冗余配置的时候，这一点让我们不太满意。当然，这么设计也是有其原因的，但我们更愿意将其视为可以改进的空间。
最后，一旦掌握了 ZFS 的命令行工具，用户体验很好。我们希望让 Stratis 的命令行工具能够保持这种体验；同时，我们也很喜欢 ZFS 命令行工具的发展趋势，包括使用<ruby> 位置参数 <rt> positional parameters </rt></ruby>和控制每个命令需要的键盘输入量。
（LCTT 译注：位置参数来自脚本，$n 代表第 n 个参数）
### Stratis 从 Btrfs 学到哪些
Btrfs 让我们满意的一点是，有单一的包含位置子命令的命令行工具。Btrfs 也将冗余（选择对应的 Btrfs profiles）视为存储池的特性之一。而且和 ZFS 相比实现方式更好理解，也允许增加甚至移除硬盘。
（LCTT 译注：Btrfs profiles 包括 single/DUP 和 各种 RAID 等类型）
最后，通过了解 ZFS 和 Btrfs 共有的特性，例如快照的实现、对发送/接收的支持，让我们更好的抉择 Stratis 应该包括的特性。
### Stratis 从 LVM 学到哪些
在 Stratis 设计阶段早期，我们仔细研究了 LVM。LVM 目前是 Linux device mapper (DM) 最主要的使用者；事实上，DM 就是由 LVM 的核心开发团队维护的。我们研究了将 LVM 真的作为 Stratis 其中一层的可能性，也使用 DM 做了实验，其中 Stratis 可以作为<ruby> 对等角色 <rt> peer </rt></ruby>直接与 LVM 打交道。我们参考了 LVM 的<ruby> 磁盘元数据格式 <rt> on-disk metadata format </rt></ruby>（也结合 ZFS 和 XFS 的相应格式），获取灵感并定义了 Stratis 的磁盘元数据格式。
在提到的项目中，LVM 与 Stratis 内在地有最多的共性，毕竟它们都使用 DM。不过从使用的角度来看，LVM 内在工作更加透明，为专业用户提供相当多的控制和选项，使其可以精确配置<ruby> 卷组 <rt> volume group </rt></ruby>（存储池）的<ruby> 布局 <rt> layout </rt></ruby>；但 Stratis 不采用这种方式。
### 多种多样的解决方案
基于自由和开源软件工作的明显好处在于，没有什么组件是不可替代的。包括内核在内的每个组成部分都是开源的，可以查看修改源代码，如果当前的软件不能满足用户需求可以用其它软件替换。新项目产生不一定意味着旧项目的终结，只要都有足够的（社区）支持，两者可以并行存在。
对于寻找一个不存在争议、简单易用、强大的本地存储管理解决方案的人而言，Stratis 是更好满足其需求的一种尝试。这意味着一种设计思路所做的抉择不一定对所有用户适用。考虑到用户的其它需求，另一种设计思路可能需要艰难的做出抉择。所有用户可以选择最适合其的工作的工具并从这种自由选择中受益。
---
via: <https://opensource.com/article/18/4/stratis-lessons-learned>
作者：[Andy Grover](https://opensource.com/users/agrover) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用机器学习来进行卡通上色
|
K. Gretchen Greene
|
https://opensource.com/article/18/4/dragonpaint-bootstrapping
|
我们可以自动应用简单的配色方案，而无需手绘几百个训练数据示例吗？
|
/data/attachment/album/201806/14/111733cp2j1px17w2mz27x.png.thumb.jpg
|
/data/attachment/album/201806/14/111733cp2j1px17w2mz27x.png
| true | false | true |
hopefully2333
| false |
[
"机器学习"
] |
软件开发
|
{
"viewnum": 4176,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们可以自动应用简单的配色方案，而无需手绘几百个训练数据示例吗？
| 2018-06-14T11:17:29 | 2018-06-14T11:17:29 | 9,744 |
/article-9744-1.html
|
>
> 我们可以自动应用简单的配色方案，而无需手绘几百个训练数据示例吗？
>
>
>
监督式机器学习的一个大问题是需要大量的归类数据，特别是如果你没有这些数据时——即使这是一个充斥着大数据的世界，我们大多数人依然没有大数据——这就真的是一个大问题了。
尽管少数公司可以访问某些类型的大量归类数据，但对于大多数的组织和应用来说，创造足够的正确类型的归类数据，花费还是太高了，以至于近乎不可能。在某些时候，这个领域还是一个没有太多数据的领域（比如说，当我们诊断一种稀有的疾病，或者判断一个数据是否匹配我们已知的那一点点样本时）。其他时候，通过 Amazon Turkers 或者暑假工这些人工方式来给我们需要的数据做分类，这样做的花费太高了。对于一部电影长度的视频，因为要对每一帧做分类，所以成本上涨得很快，即使是一帧一美分。
### 大数据需求的一个大问题
我们团队目前打算解决一个问题是：我们能不能在没有手绘的数百或者数千训练数据的情况下，训练出一个模型，来自动化地为黑白像素图片提供简单的配色方案。
在这个实验中（我们称这个实验为龙画），面对深度学习庞大的对分类数据的需求，我们使用以下这种方法：
* 对小数据集的快速增长使用基于规则的的策略。
* 借用 tensorflow 图像转换的模型，Pix2Pix 框架，从而在训练数据非常有限的情况下实现自动化卡通渲染。
我曾见过 Pix2Pix 框架，在一篇论文（由 Isola 等人撰写的“Image-to-Image Translation with Conditional Adversarial Networks”）中描述的机器学习图像转换模型，假设 A 是风景图 B 的灰度版，在对 AB 对进行训练后，再给风景图片进行上色。我的问题和这是类似的，唯一的问题就是训练数据。
我需要的训练数据非常有限，因为我不想为了训练这个模型，一辈子画画和上色来为它提供彩色图片，深度学习模型需要成千上万（或者成百上千）的训练数据。
基于 Pix2Pix 的案例，我们需要至少 400 到 1000 个黑白、彩色成对的数据。你问我愿意画多少？可能就只有 30 个。我画了一小部分卡通花和卡通龙，然后去确认我是否可以把他们放进数据集中。
### 80% 的解决方案：按组件上色
*按组件规则对黑白像素进行上色*
当面对训练数据的短缺时，要问的第一个问题就是，是否有一个好的非机器学习的方法来解决我们的问题，如果没有一个完整的解决方案，那是否有一个部分的解决方案，这个部分解决方案对我们是否有好处？我们真的需要机器学习的方法来为花和龙上色吗？或者我们能为上色指定几何规则吗？
*如何按组件进行上色*
现在有一种非机器学习的方法来解决我的问题。我可以告诉一个孩子，我想怎么给我的画上色：把花的中心画成橙色，把花瓣画成黄色，把龙的身体画成橙色，把龙的尖刺画成黄色。
开始的时候，这似乎没有什么帮助，因为我们的电脑不知道什么是中心，什么是花瓣，什么是身体，什么是尖刺。但事实证明，我们可以依据连接组件来定义花和龙的部分，然后得到一个几何解决方案为我们 80% 的画来上色，虽然 80% 还不够，我们可以使用战略性违规转换、参数和机器学习来引导基于部分规则的解决方案达到 100%。
连接的组件使用的是 Windows 画图（或者类似的应用）上的色，例如，当我们对一个二进制黑白图像上色时，如果你单击一个白色像素，这个白色像素会在不穿过黑色的情况下变成一种新的颜色。在一个规则相同的卡通龙或者花的素描中，最大的白色组件就是背景，下一个最大的组件就是身体（加上手臂和腿）或者花的中心，其余的部分就是尖刺和花瓣，除了龙眼睛，它可以通过和背景的距离来做区分。
### 使用战略规则和 Pix2Pix 来达到 100%
我的一部分素描不符合规则，一条粗心画下的线可能会留下一个缺口，一条后肢可能会上成尖刺的颜色，一个小的，居中的雏菊会交换花瓣和中心的上色规则。
对于那 20% 我们不能用几何规则进行上色的部分，我们需要其他的方法来对它进行处理，我们转向 Pix2Pix 模型，它至少需要 400 到 1000 个素描/彩色对作为数据集（在 Pix2Pix 论文里的最小的数据集），里面包括违反规则的例子。
所以，对于每个违反规则的例子，我们最后都会通过手工的方式进行上色（比如后肢）或者选取一些符合规则的素描 / 彩色对来打破规则。我们在 A 中删除一些线，或者我们多转换一些，居中的花朵 A 和 B 使用相同的函数 (f) 来创造新的一对，f(A) 和 f(B)，一个小而居中的花朵，这可以加入到数据集。
### 使用高斯滤波器和同胚增大到最大
在计算机视觉中使用几何转换增强数据集是很常见的做法。例如循环，平移，和缩放。
但是如果我们需要把向日葵转换为雏菊或者把龙的鼻子变成球型和尖刺型呢？
或者如果说我们只需要大量增加数据量而不管过拟合？那我们需要比我们一开始使用的数据集大 10 到 30 倍的数据集。
*向日葵通过 r -> r 立方体方式变成一个雏菊*
*高斯滤波器增强*
单位盘的某些同胚可以形成很好的雏菊（比如 r -> r 立方体，高斯滤波器可以改变龙的鼻子。这两者对于数据集的快速增长是非常有用的，并且产生的大量数据都是我们需要的。但是他们也会开始用一种不能仿射转换的方式来改变画的风格。
之前我们考虑的是如何自动化地设计一个简单的上色方案，上述内容激发了一个在这之外的问题：什么东西定义了艺术家的风格，不管是外部的观察者还是艺术家自己？他们什么时候确定了自己的的绘画风格呢？他们不可能没有自己画画的算法？工具、助手和合作者之间的区别是什么？
### 我们可以走多远？
我们画画的投入可以有多低？保持在一个主题之内并且风格可以辨认出为某个艺术家的作品，在这个范围内我们可以创造出多少的变化和复杂性？我们需要做什么才能完成一个有无限的长颈鹿、龙、花的游行画卷？如果我们有了这样一幅，我们可以用它来做什么？
这些都是我们会继续在后面的工作中进行探索的问题。
但是现在，规则、增强和 Pix2Pix 模型起作用了。我们可以很好地为花上色了，给龙上色也不错。
*结果：通过花这方面的模型训练来给花上色。*
*结果：龙的模型训练的训练结果。*
想了解更多，参与 Gretchen Greene's talk, DragonPaint – bootstrapping small data to color cartoons, 在 PyCon Cleveland 2018.
---
via: <https://opensource.com/article/18/4/dragonpaint-bootstrapping>
作者：[K. Gretchen Greene](https://opensource.com/users/kggreene) 选题：[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/) 荣誉推出
|
||
大学生对开源的反思
|
Christine Hwang
|
https://opensource.com/article/18/3/college-getting-started
|
开源工具的威力和开源运动的重要性。
|
/data/attachment/album/201806/14/120239rp39dcp933o9qlfl.png.thumb.jpg
|
/data/attachment/album/201806/14/120239rp39dcp933o9qlfl.png
| true | false | true |
geekpi
| false |
[
"开源"
] |
观点
|
{
"viewnum": 4205,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
开源工具的威力和开源运动的重要性。
| 2018-06-14T12:02:36 | 2018-06-14T12:02:36 | 9,745 |
/article-9745-1.html
|
>
> 开源工具的威力和开源运动的重要性。
>
>
>
我刚刚完成大学二年级的第一学期，我正在思考我在课堂上学到的东西。有一节课特别引起了我的注意：“[开源世界的基础](https://ssri.duke.edu/news/new-course-explores-open-source-principles)”，它由杜克大学的 Bryan Behrenshausen 博士讲授。我在最后一刻参加了课程，因为它看起来很有趣，诚实地来说，因为它符合我的日程安排。
第一天，Behrenshausen 博士问我们学生是否知道或使用过任何开源程序。直到那一天，我几乎没有听过[术语“开源”](https://opensource.com/node/42001)，当然也不知道任何属于该类别的产品。然而，随着学期的继续，对我而言，如果没有开源，我对事业抱负的激情就不会存在。
### Audacity 和 GIMP
我对技术的兴趣始于 12 岁。我负责为我的舞蹈团队裁剪音乐，我在网上搜索了几个小时，直到找到开源音频编辑器 Audacity。Audacity 为我敞开了大门。我不再局限于重复的 8 音节。我开始接受其他想要独特演绎他们最喜爱歌曲的人的请求。
几周后，我偶然在互联网上看到了一只有着 Pop-Tart 躯干并且后面拖着彩虹在太空飞行的猫。我搜索了“如何制作动态图像”，并发现了一个开源的图形编辑器 [GIMP](https://www.gimp.org/)，并用它为我兄弟做了一张“辛普森一家”的 GIF 作为生日礼物。
我萌芽的兴趣成长为完全的痴迷：在我笨重的、落后的笔记本上制作艺术品。由于我没有很好的炭笔，油彩或水彩，所以我用[图形设计](https://opensource.com/node/30251)作为创意的表达。我花了几个小时在计算机实验室上 [W3Schools](https://www.w3schools.com/) 学习 HTML 和 CSS 的基础知识，以便我可以用我幼稚的 GIF 填充在线作品集。几个月后，我在 [WordPress](https://opensource.com/node/31441) 发布了我的第一个网站。
### 为什么开源
开源让我们不仅可以实现我们的目标，还可以发现驱动这些目标的兴趣。
快进近十年。虽然有些仍然保持一致，但许多事情已经发生了变化：我仍然在制作图形（主要是传单），为舞蹈团编辑音乐，以及设计网站（我希望更时尚、更有效）。我使用的产品经历了无数版本升级。但最戏剧性的变化是我对开源资源的态度。
考虑到开源产品在我的生活中的意义，使我珍视开放运动和它的使命。开源项目提醒我，科技领域有些倡议可以促进社会的良好和自我学习，而不会被那些具有社会经济优势的人排斥。我中学时的自己，像无数其他人一样，无法购买 Adobe Creative Suite、GarageBand 或 Squarespace。开源平台使我们不仅能够实现我们的目标，而且还能通过扩大我们接触来发现推动这些目标的兴趣。
我的建议？一时心血来潮报名上课。它可能会改变你对世界的看法。
---
via: <https://opensource.com/article/18/3/college-getting-started>
作者：[Christine Hwang](https://opensource.com/users/christinehwang) 选题：[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/) 荣誉推出
|
||
尾调用、优化和 ES6
|
Gustavo Duarte
|
https://manybutfinite.com/post/tail-calls-optimization-es6/
|
当一个函数 F 调用另一个函数作为它的结束动作时，就发生了一个尾调用。
|
/data/attachment/album/201806/14/125010urao2rzn7ccn7om0.jpg.thumb.jpg
|
/data/attachment/album/201806/14/125010urao2rzn7ccn7om0.jpg
| true | false | true |
qhwdw
| false |
[
"尾调用",
"堆栈"
] |
软件开发
|
{
"viewnum": 4235,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9609,
"displayorder": 0
},
{
"raid": 9759,
"displayorder": 0
},
{
"raid": 9731,
"displayorder": 1
}
] |
当一个函数 F 调用另一个函数作为它的结束动作时，就发生了一个尾调用。
| 2018-06-14T12:50:16 | 2018-06-14T12:50:16 | 9,746 |
/article-9746-1.html
|
在探秘“栈”的倒数第二篇文章中，我们提到了<ruby> 尾调用 <rt> tail call </rt></ruby>、编译优化、以及新发布的 JavaScript 上<ruby> 合理尾调用 <rt> proper tail call </rt></ruby>。
当一个函数 F 调用另一个函数作为它的结束动作时，就发生了一个**尾调用**。在那个时间点，函数 F 绝对不会有多余的工作：函数 F 将“球”传给被它调用的任意函数之后，它自己就“消失”了。这就是关键点，因为它打开了尾调用优化的“可能之门”：我们可以简单地重用函数 F 的栈帧，而不是为函数调用 [创建一个新的栈帧](https://manybutfinite.com/post/journey-to-the-stack)，因此节省了栈空间并且避免了新建一个栈帧所需要的工作量。下面是一个用 C 写的简单示例，然后使用 [mild 优化](https://github.com/gduarte/blog/blob/master/code/x86-stack/asm-tco.sh) 来编译它的结果：
```
int add5(int a)
{
return a + 5;
}
int add10(int a)
{
int b = add5(a); // not tail
return add5(b); // tail
}
int add5AndTriple(int a){
int b = add5(a); // not tail
return 3 * add5(a); // not tail, doing work after the call
}
int finicky(int a){
if (a > 10){
return add5AndTriple(a); // tail
}
if (a > 5){
int b = add5(a); // not tail
return finicky(b); // tail
}
return add10(a); // tail
}
```
*简单的尾调用 [下载](https://manybutfinite.com/code/x86-stack/tail.c)*
在编译器的输出中，在预期会有一个 [调用](https://github.com/gduarte/blog/blob/master/code/x86-stack/tail.s#L37-L39) 的地方，你可以看到一个 [跳转](https://github.com/gduarte/blog/blob/master/code/x86-stack/tail-tco.s#L27) 指令，一般情况下你可以发现尾调用优化（以下简称 TCO）。在运行时中，TCO 将会引起调用栈的减少。
一个通常认为的错误观念是，尾调用必须要 [递归](https://manybutfinite.com/post/recursion/)。实际上并不是这样的：一个尾调用可以被递归，比如在上面的 `finicky()` 中，但是，并不是必须要使用递归的。在调用点只要函数 F 完成它的调用，我们将得到一个单独的尾调用。是否能够进行优化这是一个另外的问题，它取决于你的编程环境。
“是的，它总是可以！”，这是我们所希望的最佳答案，它是著名的 Scheme 中的方式，就像是在 [SICP](https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-11.html)上所讨论的那样（顺便说一声，如果你的程序不像“一个魔法师使用你的咒语召唤你的电脑精灵”那般有效，建议你读一下这本书）。它也是 [Lua](http://www.lua.org/pil/6.3.html) 的方式。而更重要的是，它是下一个版本的 JavaScript —— ES6 的方式，这个规范清晰地定义了[尾的位置](https://people.mozilla.org/%7Ejorendorff/es6-draft.html#sec-tail-position-calls)，并且明确了优化所需要的几个条件，比如，[严格模式](https://people.mozilla.org/%7Ejorendorff/es6-draft.html#sec-strict-mode-code)。当一个编程语言保证可用 TCO 时，它将支持<ruby> 合理尾调用 <rt> proper tail call </rt></ruby>。
现在，我们中的一些人不能抛开那些 C 的习惯，心脏出血，等等，而答案是一个更复杂的“有时候”，它将我们带进了编译优化的领域。我们看一下上面的那个 [简单示例](https://github.com/gduarte/blog/blob/master/code/x86-stack/tail.c)；把我们 [上篇文章](/article-9609-1.html) 的阶乘程序重新拿出来：
```
#include <stdio.h>
int factorial(int n)
{
int previous = 0xdeadbeef;
if (n == 0 || n == 1) {
return 1;
}
previous = factorial(n-1);
return n * previous;
}
int main(int argc)
{
int answer = factorial(5);
printf("%d\n", answer);
}
```
*递归阶乘 [下载](https://manybutfinite.com/code/x86-stack/factorial.c)*
像第 11 行那样的，是尾调用吗？答案是：“不是”，因为它被后面的 `n` 相乘了。但是，如果你不去优化它，GCC 使用 [O2 优化](https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html) 的 [结果](https://github.com/gduarte/blog/blob/master/code/x86-stack/factorial-o2.s) 会让你震惊：它不仅将阶乘转换为一个 [无递归循环](https://github.com/gduarte/blog/blob/master/code/x86-stack/factorial-o2.s#L16-L19)，而且 `factorial(5)` 调用被整个消除了，而以一个 120 (`5! == 120`) 的 [编译时常数](https://github.com/gduarte/blog/blob/master/code/x86-stack/factorial-o2.s#L38)来替换。这就是调试优化代码有时会很难的原因。好的方面是，如果你调用这个函数，它将使用一个单个的栈帧，而不会去考虑 n 的初始值。编译算法是非常有趣的，如果你对它感兴趣，我建议你去阅读 [构建一个优化编译器](http://www.amazon.com/Building-Optimizing-Compiler-Bob-Morgan-ebook/dp/B008COCE9G/) 和 [ACDI](http://www.amazon.com/Advanced-Compiler-Design-Implementation-Muchnick-ebook/dp/B003VM7GGK/)。
但是，这里**没有**做尾调用优化时到底发生了什么？通过分析函数的功能和无需优化的递归发现，GCC 比我们更聪明，因为一开始就没有使用尾调用。由于过于简单以及很确定的操作，这个任务变得很简单。我们给它增加一些可以引起混乱的东西（比如，`getpid()`），我们给 GCC 增加难度：
```
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int pidFactorial(int n)
{
if (1 == n) {
return getpid(); // tail
}
return n * pidFactorial(n-1) * getpid(); // not tail
}
int main(int argc)
{
int answer = pidFactorial(5);
printf("%d\n", answer);
}
```
*递归 PID 阶乘 [下载](https://manybutfinite.com/code/x86-stack/pidFactorial.c)*
优化它，unix 精灵！现在，我们有了一个常规的 [递归调用](https://github.com/gduarte/blog/blob/master/code/x86-stack/pidFactorial-o2.s#L20) 并且这个函数分配 O(n) 栈帧来完成工作。GCC 在递归的基础上仍然 [为 getpid 使用了 TCO](https://github.com/gduarte/blog/blob/master/code/x86-stack/pidFactorial-o2.s#L43)。如果我们现在希望让这个函数尾调用递归，我需要稍微变一下：
```
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int tailPidFactorial(int n, int acc)
{
if (1 == n) {
return acc * getpid(); // not tail
}
acc = (acc * getpid() * n);
return tailPidFactorial(n-1, acc); // tail
}
int main(int argc)
{
int answer = tailPidFactorial(5, 1);
printf("%d\n", answer);
}
```
*tailPidFactorial.c [下载](https://manybutfinite.com/code/x86-stack/tailPidFactorial.c)*
现在，结果的累加是 [一个循环](https://github.com/gduarte/blog/blob/master/code/x86-stack/tailPidFactorial-o2.s#L22-L27)，并且我们获得了真实的 TCO。但是，在你庆祝之前，我们能说一下关于在 C 中的一般情形吗？不幸的是，虽然优秀的 C 编译器在大多数情况下都可以实现 TCO，但是，在一些情况下它们仍然做不到。例如，正如我们在 [函数序言](https://manybutfinite.com/post/epilogues-canaries-buffer-overflows/) 中所看到的那样，函数调用者在使用一个标准的 C 调用规则调用一个函数之后，它要负责去清理栈。因此，如果函数 F 带了两个参数，它只能使 TCO 调用的函数使用两个或者更少的参数。这是 TCO 的众多限制之一。Mark Probst 写了一篇非常好的论文，他们讨论了 [在 C 中的合理尾递归](http://www.complang.tuwien.ac.at/schani/diplarb.ps)，在这篇论文中他们讨论了这些属于 C 栈行为的问题。他也演示一些 [疯狂的、很酷的欺骗方法](http://www.complang.tuwien.ac.at/schani/jugglevids/index.html)。
“有时候” 对于任何一种关系来说都是不坚定的，因此，在 C 中你不能依赖 TCO。它是一个在某些地方可以或者某些地方不可以的离散型优化，而不是像合理尾调用一样的编程语言的特性，虽然在实践中可以使用编译器来优化绝大部分的情形。但是，如果你想必须要实现 TCO，比如将 Scheme <ruby> 转译 <rt> transpilation </rt></ruby>成 C，你将会 [很痛苦](http://en.wikipedia.org/wiki/Tail_call#Through_trampolining)。
因为 JavaScript 现在是非常流行的转译对象，合理尾调用比以往更重要。因此，对 ES6 及其提供的许多其它的重大改进的赞誉并不为过。它就像 JS 程序员的圣诞节一样。
这就是尾调用和编译优化的简短结论。感谢你的阅读，下次再见！
---
via:<https://manybutfinite.com/post/tail-calls-optimization-es6/>
作者：[Gustavo Duarte](http://duartes.org/gustavo/blog/about/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
底层 Linux 容器运行时之发展史
|
Daniel Walsh
|
https://opensource.com/article/18/1/history-low-level-container-runtimes
|
“容器运行时”是一个被过度使用的名词。
|
/data/attachment/album/201806/14/225149obv5opg7svvcbpcp.jpg.thumb.jpg
|
/data/attachment/album/201806/14/225149obv5opg7svvcbpcp.jpg
| true | false | true |
pinewall
| false |
[
"容器",
"Docker"
] |
容器与云
|
{
"viewnum": 6714,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
“容器运行时”是一个被过度使用的名词。
| 2018-06-14T22:51:00 | 2018-06-14T22:51:00 | 9,747 |
/article-9747-1.html
|
>
> “容器运行时”是一个被过度使用的名词。
>
>
>
在 Red Hat，我们乐意这么说，“容器即 Linux，Linux 即容器”。下面解释一下这种说法。传统的容器是操作系统中的进程，通常具有如下 3 个特性：
1. 资源限制
当你在系统中运行多个容器时，你肯定不希望某个容器独占系统资源，所以我们需要使用资源约束来控制 CPU、内存和网络带宽等资源。Linux 内核提供了 cgroup 特性，可以通过配置控制容器进程的资源使用。
2. 安全性配置
一般而言，你不希望你的容器可以攻击其它容器或甚至攻击宿主机系统。我们使用了 Linux 内核的若干特性建立安全隔离，相关特性包括 SELinux、seccomp 和 capabilities。
（LCTT 译注：从 2.2 版本内核开始，Linux 将特权从超级用户中分离，产生了一系列可以单独启用或关闭的 capabilities）
3. 虚拟隔离
容器外的任何进程对于容器而言都应该不可见。容器应该使用独立的网络。不同的容器对应的进程应该都可以绑定 80 端口。每个容器的<ruby> 内核映像 <rt> image </rt></ruby>、<ruby> 根文件系统 <rt> rootfs </rt></ruby>（rootfs）都应该相互独立。在 Linux 中，我们使用内核的<ruby> 名字空间 <rt> namespace </rt></ruby>特性提供<ruby> 虚拟隔离 <rt> virtual separation </rt></ruby>。
那么，具有安全性配置并且在 cgroup 和名字空间下运行的进程都可以称为容器。查看一下 Red Hat Enterprise Linux 7 操作系统中的 PID 1 的进程 systemd，你会发现 systemd 运行在一个 cgroup 下。
```
# tail -1 /proc/1/cgroup
1:name=systemd:/
```
`ps` 命令让我们看到 systemd 进程具有 SELinux 标签：
```
# ps -eZ | grep systemd
system_u:system_r:init_t:s0 1 ? 00:00:48 systemd
```
以及 capabilities：
```
# grep Cap /proc/1/status
...
CapEff: 0000001fffffffff
CapBnd: 0000001fffffffff
CapBnd: 0000003fffffffff
```
最后，查看 `/proc/1/ns` 子目录，你会发现 systemd 运行所在的名字空间。
```
ls -l /proc/1/ns
lrwxrwxrwx. 1 root root 0 Jan 11 11:46 mnt -> mnt:[4026531840]
lrwxrwxrwx. 1 root root 0 Jan 11 11:46 net -> net:[4026532009]
lrwxrwxrwx. 1 root root 0 Jan 11 11:46 pid -> pid:[4026531836]
...
```
如果 PID 1 进程（实际上每个系统进程）具有资源约束、安全性配置和名字空间，那么我可以说系统上的每一个进程都运行在容器中。
容器运行时工具也不过是修改了资源约束、安全性配置和名字空间，然后 Linux 内核运行起进程。容器启动后，容器运行时可以在容器内监控 PID 1 进程，也可以监控容器的标准输入/输出，从而进行容器进程的生命周期管理。
### 容器运行时
你可能自言自语道，“哦，systemd 看起来很像一个容器运行时”。经过若干次关于“为何容器运行时不使用 `systemd-nspawn` 工具来启动容器”的邮件讨论后，我认为值得讨论一下容器运行时及其发展史。
[Docker](https://github.com/docker) 通常被称为容器运行时，但“<ruby> 容器运行时 <rt> container runtime </rt></ruby>”是一个被过度使用的词语。当用户提到“容器运行时”，他们其实提到的是为开发人员提供便利的<ruby> 上层 <rt> high-level </rt></ruby>工具，包括 Docker，[CRI-O](https://github.com/kubernetes-incubator/cri-o) 和 [RKT](https://github.com/rkt/rkt)。这些工具都是基于 API 的，涉及操作包括从容器仓库拉取容器镜像、配置存储和启动容器等。启动容器通常涉及一个特殊工具，用于配置内核如何运行容器，这类工具也被称为“容器运行时”，下文中我将称其为“底层容器运行时”以作区分。像 Docker、CRI-O 这样的守护进程及形如 [Podman](https://github.com/projectatomic/libpod/tree/master/cmd/podman)、[Buildah](https://github.com/projectatomic/buildah) 的命令行工具，似乎更应该被称为“容器管理器”。
早期版本的 Docker 使用 `lxc` 工具集启动容器，该工具出现在 `systemd-nspawn` 之前。Red Hat 最初试图将 [libvirt](https://libvirt.org/) （`libvirt-lxc`）集成到 Docker 中替代 `lxc` 工具，因为 RHEL 并不支持 `lxc`。`libvirt-lxc` 也没有使用 `systemd-nspawn`，在那时 systemd 团队仅将 `systemd-nspawn` 视为测试工具，不适用于生产环境。
与此同时，包括我的 Red Hat 团队部分成员在内的<ruby> 上游 <rt> upstream </rt></ruby> Docker 开发者，认为应该采用 golang 原生的方式启动容器，而不是调用外部应用。他们的工作促成了 libcontainer 这个 golang 原生库，用于启动容器。Red Hat 工程师更看好该库的发展前景，放弃了 `libvirt-lxc`。
后来成立 <ruby> <a href="https://www.opencontainers.org/"> 开放容器组织 </a> <rt> Open Container Initiative </rt></ruby>（OCI）的部分原因就是人们希望用其它方式启动容器。传统的基于名字空间隔离的容器已经家喻户晓，但人们也有<ruby> 虚拟机级别隔离 <rt> virtual machine-level isolation </rt></ruby>的需求。Intel 和 [Hyper.sh](https://www.hyper.sh/) 正致力于开发基于 KVM 隔离的容器，Microsoft 致力于开发基于 Windows 的容器。OCI 希望有一份定义容器的标准规范，因而产生了 [OCI <ruby> 运行时规范 <rt> Runtime Specification </rt></ruby>](https://github.com/opencontainers/runtime-spec)。
OCI 运行时规范定义了一个 JSON 文件格式，用于描述要运行的二进制，如何容器化以及容器根文件系统的位置。一些工具用于生成符合标准规范的 JSON 文件，另外的工具用于解析 JSON 文件并在该根文件系统（rootfs）上运行容器。Docker 的部分代码被抽取出来构成了 libcontainer 项目，该项目被贡献给 OCI。上游 Docker 工程师及我们自己的工程师创建了一个新的前端工具，用于解析符合 OCI 运行时规范的 JSON 文件，然后与 libcontainer 交互以便启动容器。这个前端工具就是 [runc](https://github.com/opencontainers/runc)，也被贡献给 OCI。虽然 `runc` 可以解析 OCI JSON 文件，但用户需要自行生成这些文件。此后，`runc` 也成为了最流行的底层容器运行时，基本所有的容器管理工具都支持 `runc`，包括 CRI-O、Docker、Buildah、Podman 和 [Cloud Foundry Garden](https://github.com/cloudfoundry/garden) 等。此后，其它工具的实现也参照 OCI 运行时规范，以便可以运行 OCI 兼容的容器。
[Clear Containers](https://clearlinux.org/containers) 和 Hyper.sh 的 `runV` 工具都是参照 OCI 运行时规范运行基于 KVM 的容器，二者将其各自工作合并到一个名为 [Kata](https://clearlinux.org/containers) 的新项目中。在去年，Oracle 创建了一个示例版本的 OCI 运行时工具，名为 [RailCar](https://github.com/oracle/railcar)，使用 Rust 语言编写。但该 GitHub 项目已经两个月没有更新了，故无法判断是否仍在开发。几年前，Vincent Batts 试图创建一个名为 [nspawn-oci](https://github.com/vbatts/nspawn-oci) 的工具，用于解析 OCI 运行时规范文件并启动 `systemd-nspawn`；但似乎没有引起大家的注意，而且也不是原生的实现。
如果有开发者希望实现一个原生的 `systemd-nspawn --oci OCI-SPEC.json` 并让 systemd 团队认可和提供支持，那么CRI-O、Docker 和 Podman 等容器管理工具将可以像使用 `runc` 和 Clear Container/runV （[Kata](https://github.com/kata-containers)） 那样使用这个新的底层运行时。（目前我的团队没有人参与这方面的工作。）
总结如下，在 3-4 年前，上游开发者打算编写一个底层的 golang 工具用于启动容器，最终这个工具就是 `runc`。那时开发者有一个使用 C 编写的 `lxc` 工具，在 `runc` 开发后，他们很快转向 `runc`。我很确信，当决定构建 libcontainer 时，他们对 `systemd-nspawn` 或其它非原生（即不使用 golang）的运行 namespaces 隔离的容器的方式都不感兴趣。
---
via: <https://opensource.com/article/18/1/history-low-level-container-runtimes>
作者：[Daniel Walsh](https://opensource.com/users/rhatdan) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
无密码验证：服务器
|
Nicolás Parada
|
https://nicolasparada.netlify.com/posts/passwordless-auth-server/
|
无密码验证可以让你只输入一个 email 而无需输入密码即可登入系统。这是一种比传统的电子邮件/密码验证方式登入更安全的方法。
|
/data/attachment/album/201806/15/000057ms1oszswwhooiiis.jpg.thumb.jpg
|
/data/attachment/album/201806/15/000057ms1oszswwhooiiis.jpg
| true | false | true |
qhwdw
| false |
[
"密码",
"登录"
] |
软件开发
|
{
"viewnum": 11750,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9830,
"displayorder": 0
}
] |
无密码验证可以让你只输入一个 email 而无需输入密码即可登入系统。这是一种比传统的电子邮件/密码验证方式登入更安全的方法。
| 2018-06-15T00:01:00 | 2018-06-15T00:01:00 | 9,748 |
/article-9748-1.html
|
无密码验证可以让你只输入一个 email 而无需输入密码即可登入系统。这是一种比传统的电子邮件/密码验证方式登入更安全的方法。
下面我将为你展示，如何在 [Go](https://golang.org/) 中实现一个 HTTP API 去提供这种服务。
### 流程
* 用户输入他的电子邮件地址。
* 服务器创建一个临时的一次性使用的代码（就像一个临时密码一样）关联到用户，然后给用户邮箱中发送一个“魔法链接”。
* 用户点击魔法链接。
* 服务器提取魔法链接中的代码，获取关联的用户，并且使用一个新的 JWT 重定向到客户端。
* 在每次有新请求时，客户端使用 JWT 去验证用户。
### 必需条件
* 数据库：我们为这个服务使用了一个叫 [CockroachDB](https://www.cockroachlabs.com/) 的 SQL 数据库。它非常像 postgres，但它是用 Go 写的。
* SMTP 服务器：我们将使用一个第三方的邮件服务器去发送邮件。开发的时我们使用 [mailtrap](https://mailtrap.io/)。Mailtrap 发送所有的邮件到它的收件箱，因此，你在测试时不需要创建多个假邮件帐户。
从 [Go 的主页](https://golang.org/dl/) 上安装它，然后使用 `go version`（1.10.1 atm）命令去检查它能否正常工作。
从 [CockroachDB 的主页](https://www.cockroachlabs.com/docs/stable/install-cockroachdb.html) 上下载它，展开它并添加到你的 `PATH` 变量中。使用 `cockroach version`（2.0 atm）命令检查它能否正常工作。
### 数据库模式
现在，我们在 `GOPATH` 目录下为这个项目创建一个目录，然后使用 `cockroach start` 启动一个新的 CockroachDB 节点：
```
cockroach start --insecure --host 127.0.0.1
```
它会输出一些内容，找到 SQL 地址行，它将显示像 `postgresql://root@127.0.0.1:26257?sslmode=disable` 这样的内容。稍后我们将使用它去连接到数据库。
使用如下的内容去创建一个 `schema.sql` 文件。
```
DROP DATABASE IF EXISTS passwordless_demo CASCADE;
CREATE DATABASE IF NOT EXISTS passwordless_demo;
SET DATABASE = passwordless_demo;
CREATE TABLE IF NOT EXISTS users (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
email STRING UNIQUE,
username STRING UNIQUE
);
CREATE TABLE IF NOT EXISTS verification_codes (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID NOT NULL REFERENCES users ON DELETE CASCADE,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
INSERT INTO users (email, username) VALUES
('john@passwordless.local', 'john_doe');
```
这个脚本创建了一个名为 `passwordless_demo` 的数据库、两个名为 `users` 和 `verification_codes` 的表，以及为了稍后测试而插入的一些假用户。每个验证代码都与用户关联并保存创建时间，以用于去检查验证代码是否过期。
在另外的终端中使用 `cockroach sql` 命令去运行这个脚本：
```
cat schema.sql | cockroach sql --insecure
```
### 环境配置
需要配置两个环境变量：`SMTP_USERNAME` 和 `SMTP_PASSWORD`，你可以从你的 mailtrap 帐户中获得它们。将在我们的程序中用到它们。
### Go 依赖
我们需要下列的 Go 包：
* [github.com/lib/pq](https://github.com/lib/pq)：它是 CockroachDB 使用的 postgres 驱动
* [github.com/matryer/way](https://github.com/matryer/way): 路由器
* [github.com/dgrijalva/jwt-go](https://github.com/dgrijalva/jwt-go): JWT 实现
```
go get -u github.com/lib/pq
go get -u github.com/matryer/way
go get -u github.com/dgrijalva/jwt-go
```
### 代码
#### 初始化函数
创建 `main.go` 并且通过 `init` 函数里的环境变量中取得一些配置来启动。
```
var config struct {
port int
appURL *url.URL
databaseURL string
jwtKey []byte
smtpAddr string
smtpAuth smtp.Auth
}
func init() {
config.port, _ = strconv.Atoi(env("PORT", "80"))
config.appURL, _ = url.Parse(env("APP_URL", "http://localhost:"+strconv.Itoa(config.port)+"/"))
config.databaseURL = env("DATABASE_URL", "postgresql://root@127.0.0.1:26257/passwordless_demo?sslmode=disable")
config.jwtKey = []byte(env("JWT_KEY", "super-duper-secret-key"))
smtpHost := env("SMTP_HOST", "smtp.mailtrap.io")
config.smtpAddr = net.JoinHostPort(smtpHost, env("SMTP_PORT", "25"))
smtpUsername, ok := os.LookupEnv("SMTP_USERNAME")
if !ok {
log.Fatalln("could not find SMTP_USERNAME on environment variables")
}
smtpPassword, ok := os.LookupEnv("SMTP_PASSWORD")
if !ok {
log.Fatalln("could not find SMTP_PASSWORD on environment variables")
}
config.smtpAuth = smtp.PlainAuth("", smtpUsername, smtpPassword, smtpHost)
}
func env(key, fallbackValue string) string {
v, ok := os.LookupEnv(key)
if !ok {
return fallbackValue
}
return v
}
```
* `appURL` 将去构建我们的 “魔法链接”。
* `port` 将要启动的 HTTP 服务器。
* `databaseURL` 是 CockroachDB 地址，我添加 `/passwordless_demo` 前面的数据库地址去表示数据库名字。
* `jwtKey` 用于签名 JWT。
* `smtpAddr` 是 `SMTP_HOST` + `SMTP_PORT` 的联合；我们将使用它去发送邮件。
* `smtpUsername` 和 `smtpPassword` 是两个必需的变量。
* `smtpAuth` 也是用于发送邮件。
`env` 函数允许我们去获得环境变量，不存在时返回一个回退值。
#### 主函数
```
var db *sql.DB
func main() {
var err error
if db, err = sql.Open("postgres", config.databaseURL); err != nil {
log.Fatalf("could not open database connection: %v\n", err)
}
defer db.Close()
if err = db.Ping(); err != nil {
log.Fatalf("could not ping to database: %v\n", err)
}
router := way.NewRouter()
router.HandleFunc("POST", "/api/users", jsonRequired(createUser))
router.HandleFunc("POST", "/api/passwordless/start", jsonRequired(passwordlessStart))
router.HandleFunc("GET", "/api/passwordless/verify_redirect", passwordlessVerifyRedirect)
router.Handle("GET", "/api/auth_user", authRequired(getAuthUser))
addr := fmt.Sprintf(":%d", config.port)
log.Printf("starting server at %s \n", config.appURL)
log.Fatalf("could not start server: %v\n", http.ListenAndServe(addr, router))
}
```
首先，打开数据库连接。记得要加载驱动。
```
import (
_ "github.com/lib/pq"
)
```
然后，我们创建路由器并定义一些端点。对于无密码流程来说，我们使用两个端点：`/api/passwordless/start` 发送魔法链接，和 `/api/passwordless/verify_redirect` 用 JWT 响应。
最后，我们启动服务器。
你可以创建空处理程序和中间件去测试服务器启动。
```
func createUser(w http.ResponseWriter, r *http.Request) {
http.Error(w, http.StatusText(http.StatusNotImplemented), http.StatusNotImplemented)
}
func passwordlessStart(w http.ResponseWriter, r *http.Request) {
http.Error(w, http.StatusText(http.StatusNotImplemented), http.StatusNotImplemented)
}
func passwordlessVerifyRedirect(w http.ResponseWriter, r *http.Request) {
http.Error(w, http.StatusText(http.StatusNotImplemented), http.StatusNotImplemented)
}
func getAuthUser(w http.ResponseWriter, r *http.Request) {
http.Error(w, http.StatusText(http.StatusNotImplemented), http.StatusNotImplemented)
}
func jsonRequired(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
next(w, r)
}
}
func authRequired(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
next(w, r)
}
}
```
接下来：
```
go build
./passwordless-demo
```
我们在目录中有了一个 “passwordless-demo”，但是你的目录中可能与示例不一样，`go build` 将创建一个同名的可执行文件。如果你没有关闭前面的 cockroach 节点，并且你正确配置了 `SMTP_USERNAME` 和 `SMTP_PASSWORD` 变量，你将看到命令 `starting server at http://localhost/` 没有错误输出。
#### 请求 JSON 的中间件
端点需要从请求体中解码 JSON，因此要确保请求是 `application/json` 类型。因为它是一个通用的东西，我将它解耦到中间件。
```
func jsonRequired(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
ct := r.Header.Get("Content-Type")
isJSON := strings.HasPrefix(ct, "application/json")
if !isJSON {
respondJSON(w, "JSON body required", http.StatusUnsupportedMediaType)
return
}
next(w, r)
}
}
```
实现很容易。首先它从请求头中获得内容的类型，然后检查它是否是以 “application/json” 开始，如果不是则以 `415 Unsupported Media Type` 提前返回。
#### 响应 JSON 的函数
以 JSON 响应是非常通用的做法，因此我把它提取到函数中。
```
func respondJSON(w http.ResponseWriter, payload interface{}, code int) {
switch value := payload.(type) {
case string:
payload = map[string]string{"message": value}
case int:
payload = map[string]int{"value": value}
case bool:
payload = map[string]bool{"result": value}
}
b, err := json.Marshal(payload)
if err != nil {
respondInternalError(w, fmt.Errorf("could not marshal response payload: %v", err))
return
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(code)
w.Write(b)
}
```
首先，对原始类型做一个类型判断，并将它们封装到一个 `map`。然后将它们编组到 JSON，设置响应内容类型和状态码，并写 JSON。如果 JSON 编组失败，则响应一个内部错误。
#### 响应内部错误的函数
`respondInternalError` 是一个响应 `500 Internal Server Error` 的函数，但是也同时将错误输出到控制台。
```
func respondInternalError(w http.ResponseWriter, err error) {
log.Println(err)
respondJSON(w,
http.StatusText(http.StatusInternalServerError),
http.StatusInternalServerError)
}
```
#### 创建用户的处理程序
下面开始编写 `createUser` 处理程序，因为它非常容易并且是 REST 式的。
```
type User struct {
ID string `json:"id"`
Email string `json:"email"`
Username string `json:"username"`
}
```
`User` 类型和 `users` 表相似。
```
var (
rxEmail = regexp.MustCompile("^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$")
rxUsername = regexp.MustCompile("^[a-zA-Z][\\w|-]{1,17}$")
)
```
这些正则表达式是分别用于去验证电子邮件和用户名的。这些都很简单，可以根据你的需要随意去适配。
现在，在 `createUser` 函数内部，我们将开始解码请求体。
```
var user User
if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
respondJSON(w, err.Error(), http.StatusBadRequest)
return
}
defer r.Body.Close()
```
我们将使用请求体去创建一个 JSON 解码器来解码出一个用户指针。如果发生错误则返回一个 `400 Bad Request`。不要忘记关闭请求体读取器。
```
errs := make(map[string]string)
if user.Email == "" {
errs["email"] = "Email required"
} else if !rxEmail.MatchString(user.Email) {
errs["email"] = "Invalid email"
}
if user.Username == "" {
errs["username"] = "Username required"
} else if !rxUsername.MatchString(user.Username) {
errs["username"] = "Invalid username"
}
if len(errs) != 0 {
respondJSON(w, errs, http.StatusUnprocessableEntity)
return
}
```
这是我如何做验证；一个简单的 `map` 并检查如果 `len(errs) != 0`，则使用 `422 Unprocessable Entity` 去返回。
```
err := db.QueryRowContext(r.Context(), `
INSERT INTO users (email, username) VALUES ($1, $2)
RETURNING id
`, user.Email, user.Username).Scan(&user.ID)
if errPq, ok := err.(*pq.Error); ok && errPq.Code.Name() == "unique_violation" {
if strings.Contains(errPq.Error(), "email") {
errs["email"] = "Email taken"
} else {
errs["username"] = "Username taken"
}
respondJSON(w, errs, http.StatusForbidden)
return
} else if err != nil {
respondInternalError(w, fmt.Errorf("could not insert user: %v", err))
return
}
```
这个 SQL 查询使用一个给定的 email 和用户名去插入一个新用户，并返回自动生成的 id，每个 `$` 将被接下来传递给 `QueryRowContext` 的参数替换掉。
因为 `users` 表在 `email` 和 `username` 字段上有唯一性约束，因此我将检查 “unique\_violation” 错误并返回 `403 Forbidden` 或者返回一个内部错误。
```
respondJSON(w, user, http.StatusCreated)
```
最后使用创建的用户去响应。
#### 无密码验证开始部分的处理程序
```
type PasswordlessStartRequest struct {
Email string `json:"email"`
RedirectURI string `json:"redirectUri"`
}
```
这个结构体含有 `passwordlessStart` 的请求体：希望去登入的用户 email、来自客户端的重定向 URI（这个应用中将使用我们的 API）如：`https://frontend.app/callback`。
```
var magicLinkTmpl = template.Must(template.ParseFiles("templates/magic-link.html"))
```
我们将使用 golang 模板引擎去构建邮件，因此需要你在 `templates` 目录中，用如下的内容创建一个 `magic-link.html` 文件：
```
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Magic Link</title>
</head>
<body>
Click <a href="{{ .MagicLink }}" target="_blank">here</a> to login.
<br>
<em>This link expires in 15 minutes and can only be used once.</em>
</body>
</html>
```
这个模板是给用户发送魔法链接邮件用的。你可以根据你的需要去随意调整它。
现在， 进入 `passwordlessStart` 函数内部：
```
var input PasswordlessStartRequest
if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
respondJSON(w, err.Error(), http.StatusBadRequest)
return
}
defer r.Body.Close()
```
首先，我们像前面一样解码请求体。
```
errs := make(map[string]string)
if input.Email == "" {
errs["email"] = "Email required"
} else if !rxEmail.MatchString(input.Email) {
errs["email"] = "Invalid email"
}
if input.RedirectURI == "" {
errs["redirectUri"] = "Redirect URI required"
} else if u, err := url.Parse(input.RedirectURI); err != nil || !u.IsAbs() {
errs["redirectUri"] = "Invalid redirect URI"
}
if len(errs) != 0 {
respondJSON(w, errs, http.StatusUnprocessableEntity)
return
}
```
我们使用 golang 的 URL 解析器去验证重定向 URI，检查那个 URI 是否为绝对地址。
```
var verificationCode string
err := db.QueryRowContext(r.Context(), `
INSERT INTO verification_codes (user_id) VALUES
((SELECT id FROM users WHERE email = $1))
RETURNING id
`, input.Email).Scan(&verificationCode)
if errPq, ok := err.(*pq.Error); ok && errPq.Code.Name() == "not_null_violation" {
respondJSON(w, "No user found with that email", http.StatusNotFound)
return
} else if err != nil {
respondInternalError(w, fmt.Errorf("could not insert verification code: %v", err))
return
}
```
这个 SQL 查询将插入一个验证代码，这个代码通过给定的 email 关联到用户，并且返回一个自动生成的 id。因为有可能会出现用户不存在的情况，那样的话子查询可能解析为 `NULL`，这将导致在 `user_id` 字段上因违反 `NOT NULL` 约束而导致失败，因此需要对这种情况进行检查，如果用户不存在，则返回 `404 Not Found` 或者一个内部错误。
```
q := make(url.Values)
q.Set("verification_code", verificationCode)
q.Set("redirect_uri", input.RedirectURI)
magicLink := *config.appURL
magicLink.Path = "/api/passwordless/verify_redirect"
magicLink.RawQuery = q.Encode()
```
现在，构建魔法链接并设置查询字符串中的 `verification_code` 和 `redirect_uri` 的值。如：`http://localhost/api/passwordless/verify_redirect?verification_code=some_code&redirect_uri=https://frontend.app/callback`。
```
var body bytes.Buffer
data := map[string]string{"MagicLink": magicLink.String()}
if err := magicLinkTmpl.Execute(&body, data); err != nil {
respondInternalError(w, fmt.Errorf("could not execute magic link template: %v", err))
return
}
```
我们将得到的魔法链接模板的内容保存到缓冲区中。如果发生错误则返回一个内部错误。
```
to := mail.Address{Address: input.Email}
if err := sendMail(to, "Magic Link", body.String()); err != nil {
respondInternalError(w, fmt.Errorf("could not mail magic link: %v", err))
return
}
```
现在来写给用户发邮件的 `sendMail` 函数。如果发生错误则返回一个内部错误。
```
w.WriteHeader(http.StatusNoContent)
```
最后，设置响应状态码为 `204 No Content`。对于成功的状态码，客户端不需要很多数据。
#### 发送邮件函数
```
func sendMail(to mail.Address, subject, body string) error {
from := mail.Address{
Name: "Passwordless Demo",
Address: "noreply@" + config.appURL.Host,
}
headers := map[string]string{
"From": from.String(),
"To": to.String(),
"Subject": subject,
"Content-Type": `text/html; charset="utf-8"`,
}
msg := ""
for k, v := range headers {
msg += fmt.Sprintf("%s: %s\r\n", k, v)
}
msg += "\r\n"
msg += body
return smtp.SendMail(
config.smtpAddr,
config.smtpAuth,
from.Address,
[]string{to.Address},
[]byte(msg))
}
```
这个函数创建一个基本的 HTML 邮件结构体并使用 SMTP 服务器去发送它。邮件的内容你可以随意定制，我喜欢使用比较简单的内容。
#### 无密码验证重定向的处理程序
```
var rxUUID = regexp.MustCompile("^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$")
```
首先，这个正则表达式去验证一个 UUID（即验证代码）。
现在进入 `passwordlessVerifyRedirect` 函数内部：
```
q := r.URL.Query()
verificationCode := q.Get("verification_code")
redirectURI := q.Get("redirect_uri")
```
`/api/passwordless/verify_redirect` 是一个 `GET` 端点，以便于我们从查询字符串中读取数据。
```
errs := make(map[string]string)
if verificationCode == "" {
errs["verification_code"] = "Verification code required"
} else if !rxUUID.MatchString(verificationCode) {
errs["verification_code"] = "Invalid verification code"
}
var callback *url.URL
var err error
if redirectURI == "" {
errs["redirect_uri"] = "Redirect URI required"
} else if callback, err = url.Parse(redirectURI); err != nil || !callback.IsAbs() {
errs["redirect_uri"] = "Invalid redirect URI"
}
if len(errs) != 0 {
respondJSON(w, errs, http.StatusUnprocessableEntity)
return
}
```
类似的验证，我们保存解析后的重定向 URI 到一个 `callback` 变量中。
```
var userID string
if err := db.QueryRowContext(r.Context(), `
DELETE FROM verification_codes
WHERE id = $1
AND created_at >= now() - INTERVAL '15m'
RETURNING user_id
`, verificationCode).Scan(&userID); err == sql.ErrNoRows {
respondJSON(w, "Link expired or already used", http.StatusBadRequest)
return
} else if err != nil {
respondInternalError(w, fmt.Errorf("could not delete verification code: %v", err))
return
}
```
这个 SQL 查询通过给定的 id 去删除相应的验证代码，并且确保它创建之后时间不超过 15 分钟，它也返回关联的 `user_id`。如果没有检索到内容，意味着代码不存在或者已过期，我们返回一个响应信息，否则就返回一个内部错误。
```
expiresAt := time.Now().Add(time.Hour * 24 * 60)
tokenString, err := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.StandardClaims{
Subject: userID,
ExpiresAt: expiresAt.Unix(),
}).SignedString(config.jwtKey)
if err != nil {
respondInternalError(w, fmt.Errorf("could not create JWT: %v", err))
return
}
```
这些是如何去创建 JWT。我们为 JWT 设置一个 60 天的过期值，你也可以设置更短的时间（大约 2 周），并添加一个新端点去刷新令牌，但是不要搞的过于复杂。
```
expiresAtB, err := expiresAt.MarshalText()
if err != nil {
respondInternalError(w, fmt.Errorf("could not marshal expiration date: %v", err))
return
}
f := make(url.Values)
f.Set("jwt", tokenString)
f.Set("expires_at", string(expiresAtB))
callback.Fragment = f.Encode()
```
我们去规划重定向；你可使用查询字符串去添加 JWT，但是更常见的是使用一个哈希片段。如：`https://frontend.app/callback#jwt=token_here&expires_at=some_date`.
过期日期可以从 JWT 中提取出来，但是这样做的话，就需要在客户端上实现一个 JWT 库来解码它，因此为了简化，我将它加到这里。
```
http.Redirect(w, r, callback.String(), http.StatusFound)
```
最后我们使用一个 `302 Found` 重定向。
---
无密码的流程已经完成。现在需要去写 `getAuthUser` 端点的代码了，它用于获取当前验证用户的信息。你应该还记得，这个端点使用了 `guard` 中间件。
#### 使用 Auth 中间件
在编写 `guard` 中间件之前，我将编写一个不需要验证的分支。目的是，如果没有传递 JWT，它将不去验证用户。
```
type ContextKey struct {
Name string
}
var keyAuthUserID = ContextKey{"auth_user_id"}
func withAuth(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
a := r.Header.Get("Authorization")
hasToken := strings.HasPrefix(a, "Bearer ")
if !hasToken {
next(w, r)
return
}
tokenString := a[7:]
p := jwt.Parser{ValidMethods: []string{jwt.SigningMethodHS256.Name}}
token, err := p.ParseWithClaims(
tokenString,
&jwt.StandardClaims{},
func (*jwt.Token) (interface{}, error) { return config.jwtKey, nil },
)
if err != nil {
respondJSON(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
return
}
claims, ok := token.Claims.(*jwt.StandardClaims)
if !ok || !token.Valid {
respondJSON(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
return
}
ctx := r.Context()
ctx = context.WithValue(ctx, keyAuthUserID, claims.Subject)
next(w, r.WithContext(ctx))
}
}
```
JWT 将在每次请求时以 `Bearer <token_here>` 格式包含在 `Authorization` 头中。因此，如果没有提供令牌，我们将直接通过，进入接下来的中间件。
我们创建一个解析器来解析令牌。如果解析失败则返回 `401 Unauthorized`。
然后我们从 JWT 中提取出要求的内容，并添加 `Subject`（就是用户 ID）到需要的地方。
#### Guard 中间件
```
func guard(next http.HandlerFunc) http.HandlerFunc {
return withAuth(func(w http.ResponseWriter, r *http.Request) {
_, ok := r.Context().Value(keyAuthUserID).(string)
if !ok {
respondJSON(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
return
}
next(w, r)
})
}
```
现在，`guard` 将使用 `withAuth` 并从请求内容中提取出验证用户的 ID。如果提取失败，它将返回 `401 Unauthorized`，提取成功则继续下一步。
#### 获取 Auth 用户
在 `getAuthUser` 处理程序内部：
```
ctx := r.Context()
authUserID := ctx.Value(keyAuthUserID).(string)
user, err := fetchUser(ctx, authUserID)
if err == sql.ErrNoRows {
respondJSON(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
return
} else if err != nil {
respondInternalError(w, fmt.Errorf("could not query auth user: %v", err))
return
}
respondJSON(w, user, http.StatusOK)
```
首先，我们从请求内容中提取验证用户的 ID，我们使用这个 ID 去获取用户。如果没有获取到内容，则发送一个 `418 I'm a teapot`，或者一个内部错误。最后，我们将用这个用户去响应。
#### 获取 User 函数
下面你看到的是 `fetchUser` 函数。
```
func fetchUser(ctx context.Context, id string) (User, error) {
user := User{ID: id}
err := db.QueryRowContext(ctx, `
SELECT email, username FROM users WHERE id = $1
`, id).Scan(&user.Email, &user.Username)
return user, err
}
```
我将它解耦是因为通过 ID 来获取用户是个常做的事。
---
以上就是全部的代码。你可以自己去构建它和测试它。[这里](https://go-passwordless-demo.herokuapp.com/) 还有一个 demo 你可以试用一下。
如果你在 mailtrap 上点击之后出现有关 `脚本运行被拦截，因为文档的框架是沙箱化的，并且没有设置 'allow-scripts' 权限` 的问题，你可以尝试右键点击 “在新标签中打开链接“。这样做是安全的，因为邮件内容是 [沙箱化的](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-sandbox)。我在 `localhost` 上有时也会出现这个问题，但是我认为你一旦以 `https://` 方式部署到服务器上应该不会出现这个问题了。
如果有任何问题，请在我的 [GitHub repo](https://github.com/nicolasparada/go-passwordless-demo) 留言或者提交 PRs
以后，我为这个 API 写了一个客户端作为这篇文章的[第二部分](https://nicolasparada.netlify.com/posts/passwordless-auth-client/)。
---
via: <https://nicolasparada.netlify.com/posts/passwordless-auth-server/>
作者：[Nicolás Parada](https://nicolasparada.netlify.com/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何装载/卸载 Linux 内核模块
|
David Clinton
|
https://opensource.com/article/18/5/how-load-or-unload-linux-kernel-module
|
找到并装载内核模块以解决外设问题。
|
/data/attachment/album/201806/16/112027iau92bydbyxuf7mn.png.thumb.jpg
|
/data/attachment/album/201806/16/112027iau92bydbyxuf7mn.png
| true | false | true |
amwps290
| false |
[
"模块",
"内核"
] |
技术
|
{
"viewnum": 13864,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
找到并装载内核模块以解决外设问题。
| 2018-06-16T11:20:38 | 2018-06-16T11:20:38 | 9,750 |
/article-9750-1.html
|
>
> 找到并装载内核模块以解决外设问题。
>
>
>
本文来自 Manning 出版的 [Linux in Action](https://www.manning.com/books/linux-in-action?a_aid=bootstrap-it&a_bid=4ca15fc9&chan=opensource) 的第 15 章。
Linux 使用内核模块管理硬件外设。 我们来看看它是如何工作的。
运行中的 Linux 内核是您不希望被破坏的东西之一。毕竟，内核是驱动计算机所做的一切工作的软件。考虑到在一个运行的系统上必须同时管理诸多细节，最好能让内核尽可能的减少分心，专心的完成它的工作。但是，如果对计算环境进行任何微小的更改都需要重启整个系统，那么插入一个新的网络摄像头或打印机就可能会严重影响您的工作流程。每次添加设备时都必须重新启动，以使系统识别它，这效率很低。
为了在稳定性和可用性之间达成有效的平衡，Linux 将内核隔离，但是允许您通过可加载内核模块 (LKM) 实时添加特定的功能。如下图所示，您可以将模块视为软件的一部分，它告诉内核在哪里找到一个设备以及如何使用它。反过来，内核使设备对用户和进程可用，并监视其操作。
*内核模块充当设备和 Linux 内核之间的转换器。*
虽然你可以自己编写模块来完全按照你喜欢的方式来支持一个设备，但是为什么要这样做呢？Linux 模块库已经非常强大，通常不需要自己去实现一个模块。 而绝大多数时候，Linux 会自动加载新设备的模块，而您甚至不知道它。
不过，有时候，出于某种原因，它本身并不会自动进行。（你肯定不想让那个招聘经理不耐烦地一直等待你的笑脸加入视频面试。）为了帮助你解决问题，你需要更多地了解内核模块，特别是，如何找到运行你的外设的实际模块，然后如何手动激活它。
### 查找内核模块
按照公认的约定，内核模块是位于 `/lib/modules/` 目录下的具有 .ko（内核对象）扩展名的文件。 然而，在你找到这些文件之前，你还需要选择一下。因为在引导时你需要从版本列表中选择其一加载，所以支持您选择的特定软件（包括内核模块）必须存在某处。 那么，`/lib/modules/` 就是其中之一。 你会发现目录里充满了每个可用的 Linux 内核版本的模块; 例如：
```
$ ls /lib/modules
4.4.0-101-generic
4.4.0-103-generic
4.4.0-104-generic
```
在我的电脑上，运行的内核是版本号最高的版本（4.4.0-104-generic），但不能保证这对你来说是一样的（内核经常更新）。 如果您将要在一个运行的系统上使用模块完成一些工作的话，你需要确保您找到正确的目录树。
好消息：有一个可靠的窍门。相对于通过名称来识别目录，并希望能够找到正确的目录，你可以使用始终指向使用的内核名称的系统变量。 您可以使用 `uname -r`（ `-r` 从系统信息中指定通常显示的内核版本号）来调用该变量：
```
$ uname -r
4.4.0-104-generic
```
通过这些信息，您可以使用称为命令替换的过程将 `uname` 并入您的文件系统引用中。 例如，要导航到正确的目录，您需要将其添加到 `/lib/modules` 。 要告诉 Linux “uname” 不是一个文件系统中的位置，请将 `uname` 部分用反引号括起来，如下所示：
```
$ ls /lib/modules/`uname -r`
build modules.alias modules.dep modules.softdep
initrd modules.alias.bin modules.dep.bin modules.symbols
kernel modules.builtin modules.devname modules.symbols.bin
misc modules.builtin.bin modules.order vdso
```
你可以在 `kernel/` 目录下的子目录中找到大部分模块。 花几分钟时间浏览这些目录，了解事物的排列方式和可用内容。 这些文件名通常会让你知道它们是什么。
```
$ ls /lib/modules/`uname -r`/kernel
arch crypto drivers fs kernel lib mm
net sound ubuntu virt zfs
```
这是查找内核模块的一种方法；实际上，这是一种快速的方式。 但这不是唯一的方法。 如果你想获得完整的集合，你可以使用 `lsmod` 列出所有当前加载的模块以及一些基本信息。 这个截断输出的第一列（在这里列出的太多了）是模块名称，后面是文件大小和数量，然后是每个模块的名称：
```
$ lsmod
[...]
vboxdrv 454656 3 vboxnetadp,vboxnetflt,vboxpci
rt2x00usb 24576 1 rt2800usb
rt2800lib 94208 1 rt2800usb
[...]
```
到底有多少？好吧，我们再运行一次 `lsmod` ，但是这一次将输出管道输送到 `wc -l` 看一下一共多少行:
```
$ lsmod | wc -l
113
```
这是已加载的模块。 总共有多少个？ 运行 `modprobe -c` 并计算这些行将给我们这个数字：
```
$ modprobe -c | wc -l
33350
```
有 33,350 个可用模块！？ 看起来好像有人多年来一直在努力为我们提供软件来驱动我们的物理设备。
注意：在某些系统中，您可能会遇到自定义的模块，这些模块要么在 `/etc/modules` 文件中使用独特的条目进行引用，要么在 `/etc/modules-load.d/` 下的配置文件中。这些模块很可能是本地开发项目的产物，可能涉及前沿实验。不管怎样，知道你看到的是什么总是好的。
这就是如何找到模块的方法。 如果出于某种原因，它不会自行加载，您的下一个工作就是弄清楚如何手动加载未激活的模块。
### 手动加载内核模块
在加载内核模块之前，逻辑上您必须确认它存在。在这之前，你需要知道它叫什么。要做到这一点，有时需要兼有魔法和运气以及在线文档作者的辛勤工作的帮助。
我将通过描述一段时间前遇到的问题来说明这个过程。在一个晴朗的日子里，出于某种原因，笔记本电脑上的 WiFi 接口停止工作了。就这样。也许是软件升级把它搞砸了。谁知道呢？我运行了 `lshw -c network` ，得到了这个非常奇怪的信息:
```
network UNCLAIMED
AR9485 Wireless Network Adapter
```
Linux 识别到了接口（Atheros AR9485），但将其列为未声明。 那么，正如他们所说的那样，“当情况变得严峻时，就会在互联网上进行艰难的搜索。” 我搜索了一下 atheros ar9 linux 模块，在浏览了一页又一页五年前甚至是十年前的页面后，它们建议我自己写个模块或者放弃吧，然后我终于发现（最起码 Ubuntu 16.04）有一个可以工作的模块。 它的名字是 ath9k 。
是的! 这场战斗胜券在握！向内核添加模块比听起来容易得多。 要仔细检查它是否可用，可以针对模块的目录树运行 `find`，指定 `-type f` 来告诉 Linux 您正在查找文件，然后将字符串 `ath9k` 和星号一起添加以包含所有以你的字符串打头的文件：
```
$ find /lib/modules/$(uname -r) -type f -name ath9k*
/lib/modules/4.4.0-97-generic/kernel/drivers/net/wireless/ath/ath9k/ath9k_common.ko
/lib/modules/4.4.0-97-generic/kernel/drivers/net/wireless/ath/ath9k/ath9k.ko
/lib/modules/4.4.0-97-generic/kernel/drivers/net/wireless/ath/ath9k/ath9k_htc.ko
/lib/modules/4.4.0-97-generic/kernel/drivers/net/wireless/ath/ath9k/ath9k_hw.ko
```
再一步，加载模块：
```
# modprobe ath9k
```
就是这样。无启动，没烦恼。
这里还有一个示例，向您展示如何使用已经崩溃的运行模块。曾经有一段时间，我使用罗技网络摄像头和一个特定的软件会使摄像头在下次系统启动前无法被任何其他程序访问。有时我需要在不同的应用程序中打开相机，但没有时间关机重新启动。（我运行了很多应用程序，在引导之后将它们全部准备好需要一些时间。）
由于这个模块可能是运行的，所以使用 `lsmod` 来搜索 video 这个词应该给我一个关于相关模块名称的提示。 实际上，它比提示更好：用 video 这个词描述的唯一模块是 uvcvideo（如下所示）：
```
$ lsmod | grep video
uvcvideo 90112 0
videobuf2_vmalloc 16384 1 uvcvideo
videobuf2_v4l2 28672 1 uvcvideo
videobuf2_core 36864 2 uvcvideo,videobuf2_v4l2
videodev 176128 4 uvcvideo,v4l2_common,videobuf2_core,videobuf2_v4l2
media 24576 2 uvcvideo,videodev
```
有可能是我自己的操作导致了崩溃，我想我可以挖掘更深一点，看看我能否以正确的方式解决问题。但结果你知道的；有时你不关心理论，只想让设备工作。 所以我用 `rmmod` 杀死了 `uvcvideo` 模块，然后用 `modprobe` 重新启动它，一切都好：
```
# rmmod uvcvideo
# modprobe uvcvideo
```
再一次：不重新启动。没有其他的后续影响。
---
via: <https://opensource.com/article/18/5/how-load-or-unload-linux-kernel-module>
作者：[David Clinton](https://opensource.com/users/dbclinton) 选题：[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/) 荣誉推出
|
||
Vim-plug：极简 Vim 插件管理器
|
Sk
|
https://www.ostechnix.com/vim-plug-a-minimalist-vim-plugin-manager/
|
Vim 插件管理器就可以派上用场。插件管理器将安装插件的文件保存在单独的目录中，因此管理所有插件变得非常容易。
|
/data/attachment/album/201806/16/114435wd3f3jgwjeewfdxs.png.thumb.jpg
|
/data/attachment/album/201806/16/114435wd3f3jgwjeewfdxs.png
| true | false | true |
geekpi
| false |
[
"Vim",
"插件"
] |
技术
|
{
"viewnum": 50149,
"commentnum": 3,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "120.244.214.22",
"message": "没法用，你用过么，瞎翻译",
"username": "来自120.244.214.22的 Internet Explorer 11.0|Windows 10 用户",
"date": "2021-06-17T02:19:49"
},
{
"postip": "211.93.124.193",
"message": "挺好用的，说实话",
"username": "来自211.93.124.193的 Firefox 91.0|Ubuntu 用户",
"date": "2021-08-26T17:22:30"
},
{
"postip": "119.123.132.200",
"message": ":PlugXXX应该是:PluginXXX，少了`in`",
"username": "来自广东深圳的 Chrome 103.0|Mac 10.15 用户",
"date": "2022-07-23T23:19:46"
}
] |
[] |
Vim 插件管理器就可以派上用场。插件管理器将安装插件的文件保存在单独的目录中，因此管理所有插件变得非常容易。
| 2018-06-16T11:44:32 | 2018-06-16T11:44:32 | 9,751 |
/article-9751-1.html
|
当没有插件管理器时，Vim 用户必须手动下载 tarball 包形式的插件，并将它们解压到 `~/.vim` 目录中。在少量插件的时候可以。但当他们安装更多的插件时，就会变得一团糟。所有插件文件分散在单个目录中，用户无法找到哪个文件属于哪个插件。此外，他们无法找到他们应该删除哪个文件来卸载插件。这时 Vim 插件管理器就可以派上用场。插件管理器将安装插件的文件保存在单独的目录中，因此管理所有插件变得非常容易。我们几个月前已经写了关于 [Vundle](/article-9416-1.html) 的文章。今天，我们将看到又一个名为 “Vim-plug” 的 Vim 插件管理器。
Vim-plug 是一个自由、开源、速度非常快的、极简的 vim 插件管理器。它可以并行地安装或更新插件。你还可以回滚更新。它创建<ruby> 浅层克隆 <rt> shallow clone </rt></ruby>最小化磁盘空间使用和下载时间。它支持按需加载插件以加快启动时间。其他值得注意的特性是支持分支/标签/提交、post-update 钩子、支持外部管理的插件等。
### 安装
安装和使用起来非常容易。你只需打开终端并运行以下命令：
```
$ curl -fLo ~/.vim/autoload/plug.vim --create-dirs https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
```
Neovim 用户可以使用以下命令安装 Vim-plug：
```
$ curl -fLo ~/.config/nvim/autoload/plug.vim --create-dirs https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
```
### 用法
#### 安装插件
要安装插件，你必须如下所示首先在 Vim 配置文件中声明它们。一般 Vim 的配置文件是 `~/.vimrc`，Neovim 的配置文件是 `~/.config/nvim/init.vim`。请记住，当你在配置文件中声明插件时，列表应该以 `call plug#begin(PLUGIN_DIRECTORY)` 开始，并以 `plug#end()` 结束。
例如，我们安装 “lightline.vim” 插件。为此，请在 `~/.vimrc` 的顶部添加以下行。
```
call plug#begin('~/.vim/plugged')
Plug 'itchyny/lightline.vim'
call plug#end()
```
在 vim 配置文件中添加上面的行后，通过输入以下命令重新加载：
```
:source ~/.vimrc
```
或者，只需重新加载 Vim 编辑器。
现在，打开 vim 编辑器：
```
$ vim
```
使用以下命令检查状态：
```
:PlugStatus
```
然后输入下面的命令，然后按回车键安装之前在配置文件中声明的插件。
```
:PlugInstall
```
#### 更新插件
要更新插件，请运行：
```
:PlugUpdate
```
更新插件后，按下 `d` 查看更改。或者，你可以之后输入 `:PlugDiff`。
#### 审查插件
有时，更新的插件可能有新的 bug 或无法正常工作。要解决这个问题，你可以简单地回滚有问题的插件。输入 `:PlugDiff` 命令，然后按回车键查看上次 `:PlugUpdate`的更改，并在每个段落上按 `X` 将每个插件回滚到更新前的前一个状态。
#### 删除插件
删除一个插件删除或注释掉你以前在你的 vim 配置文件中添加的 `plug` 命令。然后，运行 `:source ~/.vimrc` 或重启 Vim 编辑器。最后，运行以下命令卸载插件：
```
:PlugClean
```
该命令将删除 vim 配置文件中所有未声明的插件。
#### 升级 Vim-plug
要升级vim-plug本身，请输入：
```
:PlugUpgrade
```
如你所见，使用 Vim-plug 管理插件并不难。它简化了插件管理。现在去找出你最喜欢的插件并使用 Vim-plug 来安装它们。
就是这些了。我将很快在这里发布另一个有趣的话题。在此之前，请继续关注我们。
干杯!
---
via: <https://www.ostechnix.com/vim-plug-a-minimalist-vim-plugin-manager/>
作者：[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/) 荣誉推出
|
||
机器人学影响 CIO 角色的 3 种方式
|
Dennis Walsh
|
https://enterprisersproject.com/article/2017/11/3-ways-robotics-affects-cio-role
|
机器人流程自动化如何影响 CIO ？考虑这些可能。
|
/data/attachment/album/201806/16/120845tip64et67xp4qpqt.png.thumb.jpg
|
/data/attachment/album/201806/16/120845tip64et67xp4qpqt.png
| true | false | true |
qhwdw
| false |
[
"CIO"
] |
观点
|
{
"viewnum": 3140,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
机器人流程自动化如何影响 CIO ？考虑这些可能。
| 2018-06-16T12:08:41 | 2018-06-16T12:08:41 | 9,752 |
/article-9752-1.html
|
>
> 机器人流程自动化如何影响 CIO ？考虑这些可能。
>
>
>
随着 2017 的结束，许多 CIO 们的 2018 年目标也将确定。或许你们将参与到机器人流程自动化（RPA）中。多年以来，RPA 对许多公司来说只是一个可望不可及的概念。但是随着组织被迫变得越来越敏捷高效，RPA 所具有的潜在优势开始受到重视。
根据 Redwood Sofeware 和 Sapio Research 的最新 [研究报告](https://www.redwood.com/press-releases/it-decision-makers-speak-59-of-business-processes-could-be-automated-by-2022/)，IT 决策者们相信，未来 5 年有 59% 的业务可以被自动化处理，从而产生新的速度和效率，并且消减相应的重复性的人工工作量的岗位。但是，目前在相应岗位上没有实施 RPA 的公司中，有 20% 的公司员工超过 1000 人。
对于 CIO 们来说，RPA 会潜在影响你在业务中的角色和你的团队。随着 RPA 的地位在 2018 年中越来越重要，CIO 们和其它 IT 决策者的角色也能会受到如下三种方式的改变：
### 成为战略性变革代理人的机会增加
随着压力的增长，用最少的时间做更多的事，内部流程越来越重要。在每个企业中，员工们每天做着既重要又枯燥的一些任务。这些任务可能是枯燥且重复性的任务，但是要求他们必须快速完成且不能出错。
**[有关你的自动化策略的 ROI 建议，查看我们相关的文章，[如何在自动化方面提升 ROI：4 个小提示](https://enterprisersproject.com/article/2017/11/how-improve-roi-automation-4-tips?sc_cid=70160000000h0aXAAQ)。]**
在财务中从后台的一些操作到采购、供应链、账务、客户服务、以及人力资源，在一个组织中几乎所有的岗位都有一些枯燥的任务。这就为 CIO 们提供了一个机会，将 IT 与业务联合起来，成为使用 RPA 进行战略变革的先锋。
除了过去的屏幕抓取技术，机器人现在已经实现可定制化，即插即用的解决方案可以根据企业的需要进行设计。使用这种以流程为中心的方法，企业不仅可以将以前由人来完成的任务进行自动化，也可以将应用程序和系统特定任务自动化，比如 ERP 和企业其它应用程序。
为端到端的流程实施更高级别的自动化将是 CIO 们的价值所在。CIO 们将会站在这种机遇的最前沿。
### 重新关注人和培训
技术的变动将让员工更加恐慌，尤其是当这些自动化的变动涉及到他们每日职责的相当大的部分。CIO 们应该清楚地告诉他们，RPA 将如何让他们的角色和责任变得更好，以及用数据说明的、最终将影响到他们底线的战略决策。
当实施 RPA 时，清晰明确地表达出“人对组织的成功来说是很重要的”信息是很关键的，并且，这种成功需要使技术和人的技能实现适当的平衡。
CIO 们也应该分析工作流并实施更好的流程，这种流程能够超越以前由终端用户完成的特定任务。通过端到端的流程自动化，CIO 们可以让员工表现更加出色。
因为在整个自动化的过程中，提升和培训员工技术是很重要的，CIO 们必须与企业高管们一起去决定，帮助员工自信地应对变化的培训项目。
### 需要长远的规划
为确保机器人流程自动化的成功，甲方必须有一个长期的方法。这将要求一个弹性的解决方案，它将对整个业务模型有好处，包括消费者。比如，当年亚马逊为他的 Prime 消费者推广快速投递服务时，他们不仅在他们的仓库中重新调整了订单交付流程，他们也自动化了他们的在线客户体验，让它们变得更简化、更快速，并且让消费者比以前更容易下订单。
在即将到来的一年里，CIO 们可以用同样的方法来应用技术，构建整体的解决方案来改变组织的动作方式。裁员只会让最终效益产生很大影响，但是流程自动化将使 CIO 们能够通过优化和授权来考虑更大的问题。这种方法让 CIO 们去为他们自己和 RPA 构建长期的信誉。这反过来将强化 CIO 们作为探路者的角色，并为整个组织的成功作出贡献。
对于 CIO 们来说，采用一个长期的、策略性的方法让 RPA 成功，需要时间和艰苦的努力。尽管如此，那些致力于创建一种人力和技术平衡战略的 CIO 们，将会在现在和将来实现更大的价值。
---
via: <https://enterprisersproject.com/article/2017/11/3-ways-robotics-affects-cio-role>
作者：[Dennis Walsh](https://enterprisersproject.com/user/dennis-walsh) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 中不安装软件测试一个软件包
|
Sk
|
https://www.ostechnix.com/how-to-test-a-package-without-installing-it-in-linux/
|
Nix 包管理器的一个显著特性是它允许用户测试软件包而无需先安装它们。当你想要临时使用特定的程序时，这会很有帮助。
|
/data/attachment/album/201806/16/225749u8hbmbr1r88nhm1k.png.thumb.jpg
|
/data/attachment/album/201806/16/225749u8hbmbr1r88nhm1k.png
| true | false | true |
geekpi
| false |
[
"安装",
"软件包"
] |
技术
|
{
"viewnum": 5035,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Nix 包管理器的一个显著特性是它允许用户测试软件包而无需先安装它们。当你想要临时使用特定的程序时，这会很有帮助。
| 2018-06-16T22:57:00 | 2018-06-16T22:57:00 | 9,753 |
/article-9753-1.html
|
出于某种原因，你可能需要在将软件包安装到你的 Linux 系统之前对其进行测试。如果是这样，你很幸运！今天，我将向你展示如何在 Linux 中使用 **Nix** 包管理器来实现。Nix 包管理器的一个显著特性是它允许用户测试软件包而无需先安装它们。当你想要临时使用特定的程序时，这会很有帮助。
### 测试一个软件包而不在 Linux 中安装它
确保你先安装了 Nix 包管理器。如果尚未安装，请参阅以下指南。
例如，假设你想测试你的 C++ 代码。你不必安装 GCC。只需运行以下命令：
```
$ nix-shell -p gcc
```
该命令会构建或下载 gcc 软件包及其依赖项，然后将其放入一个存在 `gcc` 命令的 Bash shell 中，所有这些都不会影响正常环境。
```
LANGUAGE = (unset),
LC_ALL = (unset),
LANG = "en_US.UTF-8"
are supported and installed on your system.
perl: warning: Falling back to the standard locale ("C").
download-using-manifests.pl: perl: warning: Setting locale failed.
download-using-manifests.pl: perl: warning: Please check that your locale settings:
download-using-manifests.pl: LANGUAGE = (unset),
download-using-manifests.pl: LC_ALL = (unset),
download-using-manifests.pl: LANG = "en_US.UTF-8"
download-using-manifests.pl: are supported and installed on your system.
download-using-manifests.pl: perl: warning: Falling back to the standard locale ("C").
download-from-binary-cache.pl: perl: warning: Setting locale failed.
download-from-binary-cache.pl: perl: warning: Please check that your locale settings:
download-from-binary-cache.pl: LANGUAGE = (unset),
download-from-binary-cache.pl: LC_ALL = (unset),
download-from-binary-cache.pl: LANG = "en_US.UTF-8"
[...]
fetching path ‘/nix/store/6mk1s81va81dl4jfbhww86cwkl4gyf4j-stdenv’...
perl: warning: Setting locale failed.
perl: warning: Please check that your locale settings:
LANGUAGE = (unset),
LC_ALL = (unset),
LANG = "en_US.UTF-8"
are supported and installed on your system.
perl: warning: Falling back to the standard locale ("C").
*** Downloading ‘https://cache.nixos.org/nar/0aznfg1g17a8jdzvnp3pqszs9rq2wiwf2rcgczyg5b3k6d0iricl.nar.xz’ to ‘/nix/store/6mk1s81va81dl4jfbhww86cwkl4gyf4j-stdenv’...
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 8324 100 8324 0 0 6353 0 0:00:01 0:00:01 --:--:-- 6373
[nix-shell:~]$
```
检查GCC版本：
```
[nix-shell:~]$ gcc -v
Using built-in specs.
COLLECT_GCC=/nix/store/dyj2k6ch35r1ips4vr97md2i0yvl4r5c-gcc-5.4.0/bin/gcc
COLLECT_LTO_WRAPPER=/nix/store/dyj2k6ch35r1ips4vr97md2i0yvl4r5c-gcc-5.4.0/libexec/gcc/x86_64-unknown-linux-gnu/5.4.0/lto-wrapper
Target: x86_64-unknown-linux-gnu
Configured with:
Thread model: posix
gcc version 5.4.0 (GCC)
```
现在，继续并测试代码。完成后，输入 `exit` 返回到控制台。
```
[nix-shell:~]$ exit
exit
```
一旦你从 nix-shell 中退出，你就不能使用 GCC。
这是另一个例子。
```
$ nix-shell -p hello
```
这会构建或下载 GNU Hello 和它的依赖关系，然后将其放入 `hello` 命令所在的 Bash shell 中，所有这些都不会影响你的正常环境：
```
[nix-shell:~]$ hello
Hello, world!
```
输入 `exit` 返回到控制台。
```
[nix-shell:~]$ exit
```
现在测试你的 `hello` 程序是否可用。
```
$ hello
hello: command not found
```
有关 Nix 包管理器的更多详细信息，请参阅以下指南。
希望本篇对你有帮助！还会有更好的东西。敬请关注！！
干杯!
---
via: <https://www.ostechnix.com/how-to-test-a-package-without-installing-it-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/) 荣誉推出
|
||
使用 OpenCV 进行高动态范围（HDR）成像
|
Satya Mallick
|
http://www.learnopencv.com/high-dynamic-range-hdr-imaging-using-opencv-cpp-python/
|
将在不同曝光设置下获取的相同场景的不同图像组合的过程称为高动态范围（HDR）成像。
|
/data/attachment/album/201806/16/235137u634bg9q363lfhwx.jpg.thumb.jpg
|
/data/attachment/album/201806/16/235137u634bg9q363lfhwx.jpg
| true | false | true |
Flowsnow
| false |
[
"图像",
"OpenCV",
"HDR"
] |
软件开发
|
{
"viewnum": 10594,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
将在不同曝光设置下获取的相同场景的不同图像组合的过程称为高动态范围（HDR）成像。
| 2018-06-16T23:52:00 | 2018-06-16T23:52:00 | 9,754 |
/article-9754-1.html
|
在本教程中，我们将学习如何使用由不同曝光设置拍摄的多张图像创建<ruby> 高动态范围 <rt> High Dynamic Range </rt></ruby>（HDR）图像。 我们将以 C++ 和 Python 两种形式分享代码。
### 什么是高动态范围成像？
大多数数码相机和显示器都是按照 24 位矩阵捕获或者显示彩色图像。 每个颜色通道有 8 位，因此每个通道的像素值在 0-255 范围内。 换句话说，普通的相机或者显示器的动态范围是有限的。
但是，我们周围世界动态范围极大。 在车库内关灯就会变黑，直接看着太阳就会变得非常亮。 即使不考虑这些极端，在日常情况下，8 位的通道勉强可以捕捉到现场场景。 因此，相机会尝试去评估光照并且自动设置曝光，这样图像的最关注区域就会有良好的动态范围，并且太暗和太亮的部分会被相应截取为 0 和 255。
在下图中，左侧的图像是正常曝光的图像。 请注意，由于相机决定使用拍摄主体（我的儿子）的设置，所以背景中的天空已经完全流失了，但是明亮的天空也因此被刷掉了。 右侧的图像是由 iPhone 生成的HDR图像。
[](http://www.learnopencv.com/wp-content/uploads/2017/09/high-dynamic-range-hdr.jpg)
iPhone 是如何拍摄 HDR 图像的呢？ 它实际上采用三种不同的曝光度拍摄了 3 张图像，3 张图像拍摄非常迅速，在 3 张图像之间几乎没有产生位移。然后组合三幅图像来产生 HDR 图像。 我们将在下一节看到一些细节。
>
> 将在不同曝光设置下获取的相同场景的不同图像组合的过程称为高动态范围（HDR）成像。
>
>
>
### 高动态范围（HDR）成像是如何工作的？
在本节中，我们来看下使用 OpenCV 创建 HDR 图像的步骤。
>
> 要想轻松学习本教程，请点击[此处](http://www.learnopencv.com/wp-content/uploads/2017/10/hdr.zip)[下载](http://www.learnopencv.com/wp-content/uploads/2017/10/hdr.zip) C++ 和 Python 代码还有图像。 如果您有兴趣了解更多关于人工智能，计算机视觉和机器学习的信息，请[订阅](https://bigvisionllc.leadpages.net/leadbox/143948b73f72a2%3A173c9390c346dc/5649050225344512/)我们的电子杂志。
>
>
>
### 第 1 步：捕获不同曝光度的多张图像
当我们使用相机拍照时，每个通道只有 8 位来表示场景的动态范围（亮度范围）。 但是，通过改变快门速度，我们可以在不同的曝光条件下拍摄多个场景图像。 大多数单反相机（SLR）有一个功能称为<ruby> 自动包围式曝光 <rt> Auto Exposure Bracketing </rt></ruby>（AEB），只需按一下按钮，我们就可以在不同的曝光下拍摄多张照片。 如果你正在使用 iPhone，你可以使用这个[自动包围式 HDR 应用程序](https://itunes.apple.com/us/app/autobracket-hdr/id923626339?mt=8&amp;ign-mpt=uo%3D8)，如果你是一个 Android 用户，你可以尝试一个[更好的相机应用程序](https://play.google.com/store/apps/details?id=com.almalence.opencam&amp;hl=en)。
场景没有变化时，在相机上使用自动包围式曝光或在手机上使用自动包围式应用程序，我们可以一张接一张地快速拍摄多张照片。 当我们在 iPhone 中使用 HDR 模式时，会拍摄三张照片。
1. 曝光不足的图像：该图像比正确曝光的图像更暗。 目标是捕捉非常明亮的图像部分。
2. 正确曝光的图像：这是相机将根据其估计的照明拍摄的常规图像。
3. 曝光过度的图像：该图像比正确曝光的图像更亮。 目标是拍摄非常黑暗的图像部分。
但是，如果场景的动态范围很大，我们可以拍摄三张以上的图片来合成 HDR 图像。 在本教程中，我们将使用曝光时间为1/30 秒，0.25 秒，2.5 秒和 15 秒的 4 张图像。 缩略图如下所示。
[](http://www.learnopencv.com/wp-content/uploads/2017/10/hdr-image-sequence.jpg)
单反相机或手机的曝光时间和其他设置的信息通常存储在 JPEG 文件的 EXIF 元数据中。 查看此[链接](https://www.howtogeek.com/289712/how-to-see-an-images-exif-data-in-windows-and-macos)可在 Windows 和 Mac 中查看存储在 JPEG 文件中的 EXIF 元数据。 或者，您可以使用我最喜欢的名为 [EXIFTOOL](https://www.sno.phy.queensu.ca/%7Ephil/exiftool) 的查看 EXIF 的命令行工具。
我们先从读取分配到不同曝光时间的图像开始。
**C++**
```
void readImagesAndTimes(vector<Mat> &images, vector<float> ×)
{
int numImages = 4;
// 曝光时间列表
static const float timesArray[] = {1/30.0f,0.25,2.5,15.0};
times.assign(timesArray, timesArray + numImages);
// 图像文件名称列表
static const char* filenames[] = {"img_0.033.jpg", "img_0.25.jpg", "img_2.5.jpg", "img_15.jpg"};
for(int i=0; i < numImages; i++)
{
Mat im = imread(filenames[i]);
images.push_back(im);
}
}
```
**Python**
```
def readImagesAndTimes():
# 曝光时间列表
times = np.array([ 1/30.0, 0.25, 2.5, 15.0 ], dtype=np.float32)
# 图像文件名称列表
filenames = ["img_0.033.jpg", "img_0.25.jpg", "img_2.5.jpg", "img_15.jpg"]
images = []
for filename in filenames:
im = cv2.imread(filename)
images.append(im)
return images, times
```
### 第 2 步：对齐图像
合成 HDR 图像时使用的图像如果未对齐可能会导致严重的伪影。 在下图中，左侧的图像是使用未对齐的图像组成的 HDR 图像，右侧的图像是使用对齐的图像的图像。 通过放大图像的一部分（使用红色圆圈显示的）我们会在左侧图像中看到严重的鬼影。
[](http://www.learnopencv.com/wp-content/uploads/2017/10/aligned-unaligned-hdr-comparison.jpg)
在拍摄照片制作 HDR 图像时，专业摄影师自然是将相机安装在三脚架上。 他们还使用称为[镜像锁定](https://www.slrlounge.com/workshop/using-mirror-up-mode-mirror-lockup)功能来减少额外的振动。 即使如此，图像可能仍然没有完美对齐，因为没有办法保证无振动的环境。 使用手持相机或手机拍摄图像时，对齐问题会变得更糟。
幸运的是，OpenCV 提供了一种简单的方法，使用 `AlignMTB` 对齐这些图像。 该算法将所有图像转换为<ruby> 中值阈值位图 <rt> median threshold bitmaps </rt></ruby>（MTB）。 图像的 MTB 生成方式为将比中值亮度的更亮的分配为 1，其余为 0。 MTB 不随曝光时间的改变而改变。 因此不需要我们指定曝光时间就可以对齐 MTB。
基于 MTB 的对齐方式的代码如下。
**C++**
```
// 对齐输入图像
Ptr<AlignMTB> alignMTB = createAlignMTB();
alignMTB->process(images, images);
```
**Python**
```
# 对齐输入图像
alignMTB = cv2.createAlignMTB()
alignMTB.process(images, images)
```
### 第 3 步：提取相机响应函数
典型相机的响应与场景亮度不成线性关系。 那是什么意思呢？ 假设有两个物体由同一个相机拍摄，在现实世界中其中一个物体是另一个物体亮度的两倍。 当您测量照片中两个物体的像素亮度时，较亮物体的像素值将不会是较暗物体的两倍。 在不估计<ruby> 相机响应函数 <rt> Camera Response Function </rt></ruby>（CRF）的情况下，我们将无法将图像合并到一个HDR图像中。
将多个曝光图像合并为 HDR 图像意味着什么？
只考虑图像的某个位置 `(x,y)` 一个像素。 如果 CRF 是线性的，则像素值将直接与曝光时间成比例，除非像素在特定图像中太暗（即接近 0）或太亮（即接近 255）。 我们可以过滤出这些不好的像素（太暗或太亮），并且将像素值除以曝光时间来估计像素的亮度，然后在像素不差的（太暗或太亮）所有图像上对亮度值取平均。我们可以对所有像素进行这样的处理，并通过对“好”像素进行平均来获得所有像素的单张图像。
但是 CRF 不是线性的， 我们需要评估 CRF 把图像强度变成线性，然后才能合并或者平均它们。
好消息是，如果我们知道每个图像的曝光时间，则可以从图像估计 CRF。 与计算机视觉中的许多问题一样，找到 CRF 的问题本质是一个最优解问题，其目标是使由数据项和平滑项组成的目标函数最小化。 这些问题通常会降维到线性最小二乘问题，这些问题可以使用<ruby> 奇异值分解 <rt> Singular Value Decomposition </rt></ruby>（SVD）来解决，奇异值分解是所有线性代数包的一部分。 CRF 提取算法的细节在[从照片提取高动态范围辐射图](http://www.pauldebevec.com/Research/HDR/debevec-siggraph97.pdf)这篇论文中可以找到。
使用 OpenCV 的 `CalibrateDebevec` 或者 `CalibrateRobertson` 就可以用 2 行代码找到 CRF。本篇教程中我们使用 `CalibrateDebevec`
**C++**
```
// 获取图像响应函数 (CRF)
Mat responseDebevec;
Ptr<CalibrateDebevec> calibrateDebevec = createCalibrateDebevec();
calibrateDebevec->process(images, responseDebevec, times);
```
**Python**
```
# 获取图像响应函数 (CRF)
calibrateDebevec = cv2.createCalibrateDebevec()
responseDebevec = calibrateDebevec.process(images, times)
```
下图显示了使用红绿蓝通道的图像提取的 CRF。
[](http://www.learnopencv.com/wp-content/uploads/2017/10/camera-response-function.jpg)
### 第 4 步：合并图像
一旦 CRF 评估结束，我们可以使用 `MergeDebevec` 将曝光图像合并成一个HDR图像。 C++ 和 Python 代码如下所示。
**C++**
```
// 将图像合并为HDR线性图像
Mat hdrDebevec;
Ptr<MergeDebevec> mergeDebevec = createMergeDebevec();
mergeDebevec->process(images, hdrDebevec, times, responseDebevec);
// 保存图像
imwrite("hdrDebevec.hdr", hdrDebevec);
```
**Python**
```
# 将图像合并为HDR线性图像
mergeDebevec = cv2.createMergeDebevec()
hdrDebevec = mergeDebevec.process(images, times, responseDebevec)
# 保存图像
cv2.imwrite("hdrDebevec.hdr", hdrDebevec)
```
上面保存的 HDR 图像可以在 Photoshop 中加载并进行色调映射。示例图像如下所示。
[](http://www.learnopencv.com/wp-content/uploads/2017/10/hdr-Photoshop-Tonemapping.jpg)
*HDR Photoshop 色调映射*
### 第 5 步：色调映射
现在我们已经将我们的曝光图像合并到一个 HDR 图像中。 你能猜出这个图像的最小和最大像素值吗？ 对于黑色条件，最小值显然为 0。 理论最大值是什么？ 无限大！ 在实践中，不同情况下的最大值是不同的。 如果场景包含非常明亮的光源，那么最大值就会非常大。
尽管我们已经使用多个图像恢复了相对亮度信息，但是我们现在又面临了新的挑战：将这些信息保存为 24 位图像用于显示。
>
> 将高动态范围（HDR）图像转换为 8 位单通道图像的过程称为色调映射。这个过程的同时还需要保留尽可能多的细节。
>
>
>
有几种色调映射算法。 OpenCV 实现了其中的四个。 要记住的是没有一个绝对正确的方法来做色调映射。 通常，我们希望在色调映射图像中看到比任何一个曝光图像更多的细节。 有时色调映射的目标是产生逼真的图像，而且往往是产生超现实图像的目标。 在 OpenCV 中实现的算法倾向于产生现实的并不那么生动的结果。
我们来看看各种选项。 以下列出了不同色调映射算法的一些常见参数。
1. <ruby> 伽马 <rt> gamma </rt></ruby>：该参数通过应用伽马校正来压缩动态范围。 当伽马等于 1 时，不应用修正。 小于 1 的伽玛会使图像变暗，而大于 1 的伽马会使图像变亮。
2. <ruby> 饱和度 <rt> saturation </rt></ruby>：该参数用于增加或减少饱和度。 饱和度高时，色彩更丰富，更浓。 饱和度值接近零，使颜色逐渐消失为灰度。
3. <ruby> 对比度 <rt> contrast </rt></ruby>：控制输出图像的对比度（即 `log(maxPixelValue/minPixelValue)`）。
让我们来探索 OpenCV 中可用的四种色调映射算法。
#### Drago 色调映射
Drago 色调映射的参数如下所示：
```
createTonemapDrago
(
float gamma = 1.0f,
float saturation = 1.0f,
float bias = 0.85f
)
```
这里，`bias` 是 `[0, 1]` 范围内偏差函数的值。 从 0.7 到 0.9 的值通常效果较好。 默认值是 0.85。 有关更多技术细节，请参阅这篇[论文](http://resources.mpi-inf.mpg.de/tmo/logmap/logmap.pdf)。
C++ 和 Python 代码如下所示。 参数是通过反复试验获得的。 最后的结果乘以 3 只是因为它给出了最令人满意的结果。
**C++**
```
// 使用Drago色调映射算法获得24位彩色图像
Mat ldrDrago;
Ptr<TonemapDrago> tonemapDrago = createTonemapDrago(1.0, 0.7);
tonemapDrago->process(hdrDebevec, ldrDrago);
ldrDrago = 3 * ldrDrago;
imwrite("ldr-Drago.jpg", ldrDrago * 255);
```
**Python**
```
# 使用Drago色调映射算法获得24位彩色图像
tonemapDrago = cv2.createTonemapDrago(1.0, 0.7)
ldrDrago = tonemapDrago.process(hdrDebevec)
ldrDrago = 3 * ldrDrago
cv2.imwrite("ldr-Drago.jpg", ldrDrago * 255)
```
结果如下：
[](http://www.learnopencv.com/wp-content/uploads/2017/10/hdr-Drago.jpg)
*使用Drago算法的HDR色调映射*
#### Durand 色调映射
Durand 色调映射的参数如下所示：
```
createTonemapDurand
(
float gamma = 1.0f,
float contrast = 4.0f,
float saturation = 1.0f,
float sigma_space = 2.0f,
float sigma_color = 2.0f
);
```
该算法基于将图像分解为基础层和细节层。 使用称为双边滤波器的边缘保留滤波器来获得基本层。 `sigma_space` 和`sigma_color` 是双边滤波器的参数，分别控制空间域和彩色域中的平滑量。
有关更多详细信息，请查看这篇[论文](https://people.csail.mit.edu/fredo/PUBLI/Siggraph2002/DurandBilateral.pdf)。
**C++**
```
// 使用Durand色调映射算法获得24位彩色图像
Mat ldrDurand;
Ptr<TonemapDurand> tonemapDurand = createTonemapDurand(1.5,4,1.0,1,1);
tonemapDurand->process(hdrDebevec, ldrDurand);
ldrDurand = 3 * ldrDurand;
imwrite("ldr-Durand.jpg", ldrDurand * 255);
```
**Python**
```
# 使用Durand色调映射算法获得24位彩色图像
tonemapDurand = cv2.createTonemapDurand(1.5,4,1.0,1,1)
ldrDurand = tonemapDurand.process(hdrDebevec)
ldrDurand = 3 * ldrDurand
cv2.imwrite("ldr-Durand.jpg", ldrDurand * 255)
```
结果如下：
[](http://www.learnopencv.com/wp-content/uploads/2017/10/hdr-Durand.jpg)
*使用Durand算法的HDR色调映射*
#### Reinhard 色调映射
```
createTonemapReinhard
(
float gamma = 1.0f,
float intensity = 0.0f,
float light_adapt = 1.0f,
float color_adapt = 0.0f
)
```
`intensity` 参数应在 `[-8, 8]` 范围内。 更高的亮度值会产生更明亮的结果。 `light_adapt` 控制灯光，范围为 `[0, 1]`。 值 1 表示仅基于像素值的自适应，而值 0 表示全局自适应。 中间值可以用于两者的加权组合。 参数 `color_adapt` 控制色彩，范围为 `[0, 1]`。 如果值被设置为 1，则通道被独立处理，如果该值被设置为 0，则每个通道的适应级别相同。中间值可以用于两者的加权组合。
有关更多详细信息，请查看这篇[论文](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.106.8100&amp;rep=rep1&amp;type=pdf)。
**C++**
```
// 使用Reinhard色调映射算法获得24位彩色图像
Mat ldrReinhard;
Ptr<TonemapReinhard> tonemapReinhard = createTonemapReinhard(1.5, 0,0,0);
tonemapReinhard->process(hdrDebevec, ldrReinhard);
imwrite("ldr-Reinhard.jpg", ldrReinhard * 255);
```
**Python**
```
# 使用Reinhard色调映射算法获得24位彩色图像
tonemapReinhard = cv2.createTonemapReinhard(1.5, 0,0,0)
ldrReinhard = tonemapReinhard.process(hdrDebevec)
cv2.imwrite("ldr-Reinhard.jpg", ldrReinhard * 255)
```
结果如下：
[](http://www.learnopencv.com/wp-content/uploads/2017/10/hdr-Reinhard.jpg)
*使用Reinhard算法的HDR色调映射*
#### Mantiuk 色调映射
```
createTonemapMantiuk
(
float gamma = 1.0f,
float scale = 0.7f,
float saturation = 1.0f
)
```
参数 `scale` 是对比度比例因子。 从 0.7 到 0.9 的值通常效果较好
有关更多详细信息，请查看这篇[论文](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.60.4077&amp;rep=rep1&amp;type=pdf)。
**C++**
```
// 使用Mantiuk色调映射算法获得24位彩色图像
Mat ldrMantiuk;
Ptr<TonemapMantiuk> tonemapMantiuk = createTonemapMantiuk(2.2,0.85, 1.2);
tonemapMantiuk->process(hdrDebevec, ldrMantiuk);
ldrMantiuk = 3 * ldrMantiuk;
imwrite("ldr-Mantiuk.jpg", ldrMantiuk * 255);
```
**Python**
```
# 使用Mantiuk色调映射算法获得24位彩色图像
tonemapMantiuk = cv2.createTonemapMantiuk(2.2,0.85, 1.2)
ldrMantiuk = tonemapMantiuk.process(hdrDebevec)
ldrMantiuk = 3 * ldrMantiuk
cv2.imwrite("ldr-Mantiuk.jpg", ldrMantiuk * 255)
```
结果如下：
[](http://www.learnopencv.com/wp-content/uploads/2017/10/hdr-Mantiuk.jpg)
*使用Mantiuk算法的HDR色调映射*
### 订阅然后下载代码
如果你喜欢这篇文章，并希望下载本文中使用的代码（C++ 和 Python）和示例图片，请[订阅](https://bigvisionllc.leadpages.net/leadbox/143948b73f72a2%3A173c9390c346dc/5649050225344512/)我们的电子杂志。 您还将获得免费的[计算机视觉资源](https://bigvisionllc.leadpages.net/leadbox/143948b73f72a2%3A173c9390c346dc/5649050225344512/)指南。 在我们的电子杂志中，我们分享了用 C++ 还有 Python 编写的 OpenCV 教程和例子，以及计算机视觉和机器学习的算法和新闻。
[点此订阅](https://bigvisionllc.leadpages.net/leadbox/143948b73f72a2%3A173c9390c346dc/5649050225344512/)
图片致谢
本文中使用的四个曝光图像获得 [CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/) 许可，并从[维基百科的 HDR 页面](https://en.wikipedia.org/wiki/High-dynamic-range_imaging)下载。 图像由 Kevin McCoy拍摄。
---
作者简介：
我是一位热爱计算机视觉和机器学习的企业家，拥有十多年的实践经验（还有博士学位）。
2007 年，在完成博士学位之后，我和我的顾问 David Kriegman 博士还有 Kevin Barnes 共同创办了 TAAZ 公司。 我们的计算机视觉和机器学习算法的可扩展性和鲁棒性已经经过了试用了我们产品的超过 1 亿的用户的严格测试。
---
via: <http://www.learnopencv.com/high-dynamic-range-hdr-imaging-using-opencv-cpp-python/>
作者：[SATYA MALLICK](http://www.learnopencv.com/about/) 译者：[Flowsnow](https://github.com/Flowsnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Stratis 从命令行管理 Linux 存储
|
Andy Grover
|
https://opensource.com/article/18/5/stratis-storage-linux-command-line
|
通过从命令行运行它，得到这个易于使用的 Linux 存储工具的主要用途。
|
/data/attachment/album/201806/17/000945iop8quph8z11f1a8.jpg.thumb.jpg
|
/data/attachment/album/201806/17/000945iop8quph8z11f1a8.jpg
| true | false | true |
geekpi
| false |
[
"存储",
"Stratis"
] |
技术
|
{
"viewnum": 6302,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "183.197.57.53",
"message": "为什么2G的硬盘挂载后df显示1TB空间，写满2G文件后还可以继续写入，重启后无法挂载分区，使用VMware虚拟机",
"username": "来自河北唐山的 Microsoft Edge 18.18362|Windows 10 用户",
"date": "2020-01-29T18:16:27"
}
] |
[
{
"raid": 9743,
"displayorder": 0
}
] |
通过从命令行运行它，得到这个易于使用的 Linux 存储工具的主要用途。
| 2018-06-17T00:09:00 | 2018-06-17T00:09:00 | 9,755 |
/article-9755-1.html
|
>
> 通过从命令行运行它，得到这个易于使用的 Linux 存储工具的主要用途。
>
>
>
正如本系列的[第一部分](/article-9736-1.html)和[第二部分](/article-9743-1.html)中所讨论的，Stratis 是一个具有与 [ZFS](https://en.wikipedia.org/wiki/ZFS) 和 [Btrfs](https://en.wikipedia.org/wiki/Btrfs) 相似功能的卷管理文件系统。在本文中，我们将介绍如何在命令行上使用 Stratis。
### 安装 Stratis
对于非开发人员，现在尝试 Stratis 最简单的方法是在 [Fedora 28](https://fedoraproject.org/wiki/Releases/28/Schedule) 中。
你可以用以下命令安装 Stratis 守护进程和 Stratis 命令行工具：
```
# dnf install stratis-cli stratisd
```
### 创建一个池
Stratis 有三个概念：blockdevs、池和文件系统。 Blockdevs 是组成池的块设备，例如磁盘或磁盘分区。一旦创建池，就可以从中创建文件系统。
假设你的系统上有一个名为 `vdg` 的块设备，它目前没有被使用或挂载，你可以在它上面创建一个 Stratis 池：
```
# stratis pool create mypool /dev/vdg
```
这假设 `vdg` 是完全清零并且是空的。如果它没有被使用，但有旧数据，则可能需要使用 `pool create` 的 `-force` 选项。如果正在使用，请勿将它用于 Stratis。
如果你想从多个块设备创建一个池，只需在 `pool create` 命令行中列出它们。你也可以稍后使用 `blockdev add-data` 命令添加更多的 blockdevs。请注意，Stratis 要求 blockdevs 的大小至少为 1 GiB。
### 创建文件系统
在你创建了一个名为 `mypool` 的池后，你可以从它创建文件系统：
```
# stratis fs create mypool myfs1
```
从 `mypool` 池创建一个名为 `myfs1` 的文件系统后，可以使用 Stratis 在 `/dev/stratis` 中创建的条目来挂载并使用它：
```
# mkdir myfs1
# mount /dev/stratis/mypool/myfs1 myfs1
```
文件系统现在已被挂载在 `myfs1` 上并准备可以使用。
### 快照
除了创建空文件系统之外，你还可以创建一个文件系统作为现有文件系统的快照：
```
# stratis fs snapshot mypool myfs1 myfs1-experiment
```
这样做后，你可以挂载新的 `myfs1-experiment`，它将初始包含与 `myfs1` 相同的文件内容，但它可能随着文件系统的修改而改变。无论你对 `myfs1-experiment` 所做的任何更改都不会反映到 `myfs1` 中，除非你卸载了 `myfs1` 并将其销毁：
```
# umount myfs1
# stratis fs destroy mypool myfs1
```
然后进行快照以重新创建并重新挂载它：
```
# stratis fs snapshot mypool myfs1-experiment myfs1
# mount /dev/stratis/mypool/myfs1 myfs1
```
### 获取信息
Stratis 可以列出系统中的池：
```
# stratis pool list
```
随着文件系统写入更多数据，你将看到 “Total Physical Used” 值的增加。当这个值接近 “Total Physical Size” 时要小心。我们仍在努力处理这个问题。
列出池中的文件系统：
```
# stratis fs list mypool
```
列出组成池的 blockdevs：
```
# stratis blockdev list mypool
```
目前只提供这些最少的信息，但它们将在未来提供更多信息。
### 摧毁池
当你了解了 Stratis 可以做什么后，要摧毁池，首先确保从它创建的所有文件系统都被卸载并销毁，然后使用 `pool destroy` 命令：
```
# umount myfs1
# umount myfs1-experiment (if you created it)
# stratis fs destroy mypool myfs1
# stratis fs destroy mypool myfs1-experiment
# stratis pool destroy mypool
```
`stratis pool list` 现在应该显示没有池。
就是这些！有关更多信息，请参阅手册页：“man stratis”。
---
via: <https://opensource.com/article/18/5/stratis-storage-linux-command-line>
作者：[Andy Grover](https://opensource.com/users/agrover) 选题：[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 服务器，你的业务为什么需要它？
|
Daniel Oh
|
https://opensource.com/article/18/5/what-linux-server
|
想寻找一个稳定、安全的基础来为您的企业应用程序提供未来的动力？Linux 服务器可能是答案。
|
/data/attachment/album/201806/17/185713qwqp6s7wwd7d7lel.png.thumb.jpg
|
/data/attachment/album/201806/17/185713qwqp6s7wwd7d7lel.png
| true | false | true |
MjSeven
| false |
[
"服务器"
] |
观点
|
{
"viewnum": 6645,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
想寻找一个稳定、安全的基础来为您的企业应用程序提供未来的动力？Linux 服务器可能是答案。
| 2018-06-17T18:57:11 | 2018-06-17T18:57:11 | 9,756 |
/article-9756-1.html
|
>
> 想寻找一个稳定、安全的基础来为您的企业应用程序的未来提供动力？Linux 服务器可能是答案。
>
>
>
IT 组织力求通过提高生产力和提供更快速的服务来提供商业价值，同时保持足够的灵活性，将云、容器和配置自动化等创新融入其中。现代的工作任务，无论是裸机、虚拟机、容器，还是私有云或公共云，都需要是可移植且可扩展的。支持所有的这些需要一个现代且安全的平台。
通往创新最直接的途径并不总是一条直线。随着私有云和公共云、多种体系架构和虚拟化的日益普及，当今的数据中心就像一个球一样，基础设施的选择各不相同，从而带来了维度和深度。就像飞行员依赖空中交通管制员提供持续更新一样，数字化转型之旅应该由像 Linux 这样可信赖的操作系统来指引，以提供持续更新的技术，以及对云、容器和配置自动化等创新的最有效和安全的访问。
Linux 是一个家族，它围绕 Linux 内核构建的自由、开源软件操作系统。最初开发的是基于 Intel x86 架构的个人电脑，此后比起任何其他操作系统，Linux 被移植到更多的平台上。得益于基于 Linux 内核的 Android 操作系统在智能手机上的主导地位，Linux 拥有所有通用操作系统中最大的安装基数。Linux 也是服务器和大型计算机等“大型机”系统的主要操作系统，也是 [TOP500](https://en.wikipedia.org/wiki/TOP500) 超级计算机上唯一使用的操作系统。
为了利用这一功能，许多企业公司已经采用具有高性能的 Linux 开源操作系统的服务器。这些旨在处理最苛刻的业务应用程序要求，如网络和系统管理、数据库管理和 Web 服务。出于其稳定性、安全性和灵活性，通常选择 Linux 服务器而不是其他服务器操作系统。位居前列的 Linux 服务器操作系统包括 [Debian](https://www.debian.org/)、 [Ubuntu Server](https://www.ubuntu.com/download/server)、 [CentOS](https://www.centos.org/)、[Slackware](http://www.slackware.com/) 和 [Gentoo](https://www.gentoo.org/)。
在企业级工作任务中，你应该考虑企业级 Linux 服务器上的哪些功能和优势？首先，通过对 Linux 和 Windows 管理员都熟悉的界面，内置的安全控制和可管理的扩展使你可以专注于业务增长，而不是对安全漏洞和昂贵的管理配置错误担心。你选择的 Linux 服务器应提供安全技术和认证，并保持增强以抵御入侵，保护你的数据，而且满足一个开放源代码项目或特定系统供应商的合规性。它应该：
* 使用集中式身份管理和[安全增强型 Linux](https://en.wikipedia.org/wiki/Security-Enhanced_Linux)（SELinux）、强制访问控制（MAC）等集成控制功能来**安全地交付资源**，这是[通用标准认证](https://en.wikipedia.org/wiki/Common_Criteria) 和 [FIPS 140-2 认证](https://en.wikipedia.org/wiki/FIPS_140-2)，并且第一个 Linux 容器框架支持也是通用标准认证。
* **自动执行法规遵从和安全配置修复** 应贯穿于你的系统和容器。通过像 OpenSCAP 的映像扫描，它应该可以检查、补救漏洞和配置安全基准，包括针对 [PCI-DSS](https://www.pcisecuritystandards.org/pci_security/)、 [DISA STIG](https://iase.disa.mil/stigs/Pages/index.aspx) 等的[国家清单程序](https://www.nist.gov/programs-projects/national-checklist-program)内容。另外，它应该在整个混合环境中集中和扩展配置修复。
* **持续接收漏洞安全更新**，从上游社区或特定的系统供应商，如有可能，可在下一工作日补救并提供所有关键问题，以最大限度地降低业务影响。
作为混合数据中心的基础，Linux 服务器应提供平台可管理性和与传统管理和自动化基础设施的灵活集成。与非付费的 Linux 基础设施相比，这将节省 IT 员工的时间并减少意外停机的情况。它应该：
* 通过内置功能 **加速整个数据中心的映像构建、部署和补丁管理**，并丰富系统生命周期管理，配置和增强的修补等等。
* 通过一个 **简单易用的 web 界面管理单个系统**，包括存储、网络、容器、服务等等。
* 通过使用 [Ansible](https://www.ansible.com/)、 [Chef](https://www.chef.io/chef/)、 [Salt](https://saltstack.com/salt-open-source/)、 [Puppet](https://puppet.com/) 等原生配置管理工具，可以跨多个异构环境实现 **自动化一致性和合规性**，并通过系统角色减少脚本返工。
* 通过就地升级 **简化平台更新**，消除机器迁移和应用程序重建的麻烦。
* 通过使用预测分析工具自动识别和修复异常情况及其根本原因，在技术问题影响业务运营之前 **解决技术问题**。
Linux 服务器正在在全球范围内推动创新。作为一个企业工作任务的平台，Linux 服务器应该为运行当下和未来业务的应用程序提供稳定，安全和性能驱动的基础。
---
via: <https://opensource.com/article/18/5/what-linux-server>
作者：[Daniel Oh](https://opensource.com/users/daniel-oh) 选题：[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/) 荣誉推出
|
||
闭包、对象，以及堆“族”
|
Gustavo Duarte
|
https://manybutfinite.com/post/closures-objects-heap/
|
它就好像是 makeGreeter 的词法作用域在那个时刻被关闭了，一旦需要时被具体化到一个堆对象（在这个案例中，是指返回的函数的生命周期）。因此叫做闭包。
|
/data/attachment/album/201806/18/110440nuqxqqq88r61qr8t.jpg.thumb.jpg
|
/data/attachment/album/201806/18/110440nuqxqqq88r61qr8t.jpg
| true | false | true |
qhwdw
| false |
[
"闭包"
] |
软件开发
|
{
"viewnum": 3837,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9731,
"displayorder": 0
},
{
"raid": 9746,
"displayorder": 1
}
] |
它就好像是 makeGreeter 的词法作用域在那个时刻被关闭了，一旦需要时被具体化到一个堆对象（在这个案例中，是指返回的函数的生命周期）。因此叫做闭包。
| 2018-06-18T11:05:00 | 2018-06-18T11:05:00 | 9,759 |
/article-9759-1.html
|
在上篇文章中我们提到了闭包、对象、以及栈外的其它东西。我们学习的大部分内容都是与特定编程语言无关的元素，但是，我主要还是专注于 JavaScript，以及一些 C。让我们以一个简单的 C 程序开始，它的功能是读取一首歌曲和乐队名字，然后将它们输出给用户：
```
#include <stdio.h>
#include <string.h>
char *read()
{
char data[64];
fgets(data, 64, stdin);
return data;
}
int main(int argc, char *argv[])
{
char *song, *band;
puts("Enter song, then band:");
song = read();
band = read();
printf("\n%sby %s", song, band);
return 0;
}
```
*stackFolly.c [下载](https://manybutfinite.com/code/x86-stack/stackFolly.c)*
如果你运行这个程序，你会得到什么？（=> 表示程序输出）：
```
./stackFolly
=> Enter song, then band:
The Past is a Grotesque Animal
of Montreal
=> ?ǿontreal
=> by ?ǿontreal
```
（曾经的 C 新手说）发生了错误？
事实证明，函数的栈变量的内容仅在栈帧活动期间才是可用的，也就是说，仅在函数返回之前。在上面的返回中，被栈帧使用过的内存 [被认为是可用的](https://manybutfinite.com/post/epilogues-canaries-buffer-overflows/)，并且在下一个函数调用中可以被覆写。
下面的图展示了这种情况下究竟发生了什么。这个图现在有一个图片映射（LCTT 译注：译文中无法包含此映射，上下两个矩形区域分别链接至输出的 [#47](https://github.com/gduarte/blog/blob/master/code/x86-stack/stackFolly-gdb-output.txt#L47) 行和 [#70](https://github.com/gduarte/blog/blob/master/code/x86-stack/stackFolly-gdb-output.txt#L70) 行），因此，你可以点击一个数据片断去看一下相关的 GDB 输出（GDB 命令在 [这里](https://github.com/gduarte/blog/blob/master/code/x86-stack/stackFolly-gdb-commands.txt)）。只要 `read()` 读取了歌曲的名字，栈将是这个样子：
在这个时候，这个 `song` 变量立即指向到歌曲的名字。不幸的是，存储字符串的内存位置准备被下次调用的任意函数的栈帧重用。在这种情况下，`read()` 再次被调用，而且使用的是同一个位置的栈帧，因此，结果变成下图的样子（LCTT 译注：上下两个矩形映射分别链接至 [#76](https://github.com/gduarte/blog/blob/master/code/x86-stack/stackFolly-gdb-output.txt#L76) 行和 [#79](https://github.com/gduarte/blog/blob/master/code/x86-stack/stackFolly-gdb-output.txt#L79) 行）：
乐队名字被读入到相同的内存位置，并且覆盖了前面存储的歌曲名字。`band` 和 `song` 最终都准确指向到相同点。最后，我们甚至都不能得到 “of Montreal”（LCTT 译注：一个欧美乐队的名字） 的正确输出。你能猜到是为什么吗？
因此，即使栈很有用，但也有很重要的限制。它不能被一个函数用于去存储比该函数的运行周期还要长的数据。你必须将它交给 [堆](https://github.com/gduarte/blog/blob/master/code/x86-stack/readIntoHeap.c)，然后与热点缓存、明确的瞬时操作、以及频繁计算的偏移等内容道别。有利的一面是，它是[工作](https://github.com/gduarte/blog/blob/master/code/x86-stack/readIntoHeap-gdb-output.txt#L47) 的：
这个代价是你必须记得去 `free()` 内存，或者由一个垃圾回收机制花费一些性能来随机回收，垃圾回收将去找到未使用的堆对象，然后去回收它们。那就是栈和堆之间在本质上的权衡：性能 vs. 灵活性。
大多数编程语言的虚拟机都有一个中间层用来做一个 C 程序员该做的一些事情。栈被用于**值类型**，比如，整数、浮点数、以及布尔型。这些都按特定值（像上面的 `argc` ）的字节顺序被直接保存在本地变量和对象字段中。相比之下，堆被用于**引用类型**，比如，字符串和 [对象](https://code.google.com/p/v8/source/browse/trunk/src/objects.h#37)。 变量和字段包含一个引用到这个对象的内存地址，像上面的 `song` 和 `band`。
参考这个 JavaScript 函数：
```
function fn()
{
var a = 10;
var b = { name: 'foo', n: 10 };
}
```
它可能的结果如下（LCTT 译注：图片内“object”、“string”和“a”的映射分别链接至 [#1671](https://code.google.com/p/v8/source/browse/trunk/src/objects.h#1671) 行、 [#8656](https://code.google.com/p/v8/source/browse/trunk/src/objects.h#8656) 行和 [#1264](https://code.google.com/p/v8/source/browse/trunk/src/objects.h#1264) 行）：
我之所以说“可能”的原因是，特定的行为高度依赖于实现。这篇文章使用的许多流程图形是以一个 V8 为中心的方法，这些图形都链接到相关的源代码。在 V8 中，仅 [小整数](https://code.google.com/p/v8/source/browse/trunk/src/objects.h#1264) 是 [以值的方式保存](https://code.google.com/p/v8/source/browse/trunk/src/objects.h#148)。因此，从现在开始，我将在对象中直接以字符串去展示，以避免引起混乱，但是，请记住，正如上图所示的那样，它们在堆中是分开保存的。
现在，我们来看一下闭包，它其实很简单，但是由于我们将它宣传的过于夸张，以致于有点神化了。先看一个简单的 JS 函数：
```
function add(a, b)
{
var c = a + b;
return c;
}
```
这个函数定义了一个<ruby> 词法域 <rt> lexical scope </rt></ruby>，它是一个快乐的小王国，在这里它的名字 `a`、`b`、`c` 是有明确意义的。它有两个参数和由函数声明的一个本地变量。程序也可以在别的地方使用相同的名字，但是在 `add` 内部它们所引用的内容是明确的。尽管词法域是一个很好的术语，它符合我们直观上的理解：毕竟，我们从字面意义上看，我们可以像词法分析器一样，把它看作在源代码中的一个文本块。
在看到栈帧的操作之后，很容易想像出这个名称的具体实现。在 `add` 内部，这些名字引用到函数的每个运行实例中私有的栈的位置。这种情况在一个虚拟机中经常发生。
现在，我们来嵌套两个词法域：
```
function makeGreeter()
{
return function hi(name){
console.log('hi, ' + name);
}
}
var hi = makeGreeter();
hi('dear reader'); // prints "hi, dear reader"
```
那样更有趣。函数 `hi` 在函数 `makeGreeter` 运行的时候被构建在它内部。它有它自己的词法域，`name` 在这个地方是一个栈上的参数，但是，它似乎也可以访问父级的词法域，它可以那样做。我们来看一下那样做的好处：
```
function makeGreeter(greeting)
{
return function greet(name){
console.log(greeting + ', ' + name);
}
}
var heya = makeGreeter('HEYA');
heya('dear reader'); // prints "HEYA, dear reader"
```
虽然有点不习惯，但是很酷。即便这样违背了我们的直觉：`greeting` 确实看起来像一个栈变量，这种类型应该在 `makeGreeter()` 返回后消失。可是因为 `greet()` 一直保持工作，出现了一些奇怪的事情。进入闭包（LCTT 译注：“Context” 和 “JSFunction” 映射分别链接至 [#188](https://code.google.com/p/v8/source/browse/trunk/src/contexts.h#188) 行和 [#7245](https://code.google.com/p/v8/source/browse/trunk/src/objects.h#7245) 行）：
虚拟机分配一个对象去保存被里面的 `greet()` 使用的父级变量。它就好像是 `makeGreeter` 的词法作用域在那个时刻被<ruby> 关闭 <rt> closed over </rt></ruby>了，一旦需要时被具体化到一个堆对象（在这个案例中，是指返回的函数的生命周期）。因此叫做<ruby> 闭包 <rt> closure </rt></ruby>，当你这样去想它的时候，它的名字就有意义了。如果使用（或者捕获）了更多的父级变量，对象内容将有更多的属性，每个捕获的变量有一个。当然，发送到 `greet()` 的代码知道从对象内容中去读取问候语，而不是从栈上。
这是完整的示例：
```
function makeGreeter(greetings)
{
var count = 0;
var greeter = {};
for (var i = 0; i < greetings.length; i++) {
var greeting = greetings[i];
greeter[greeting] = function(name){
count++;
console.log(greeting + ', ' + name);
}
}
greeter.count = function(){return count;}
return greeter;
}
var greeter = makeGreeter(["hi", "hello","howdy"])
greeter.hi('poppet');//prints "howdy, poppet"
greeter.hello('darling');// prints "howdy, darling"
greeter.count(); // returns 2
```
是的，`count()` 在工作，但是我们的 `greeter` 是在 `howdy` 中的栈上。你能告诉我为什么吗？我们使用 `count` 是一条线索：尽管词法域进入一个堆对象中被关闭，但是变量（或者对象属性）带的值仍然可能被改变。下图是我们拥有的内容（LCTT 译注：映射从左到右“Object”、“JSFunction”和“Context”分别链接至 [#1671](https://code.google.com/p/v8/source/browse/trunk/src/objects.h#1671) 行、[#7245](https://code.google.com/p/v8/source/browse/trunk/src/objects.h#7245) 行和 [#188](https://code.google.com/p/v8/source/browse/trunk/src/contexts.h#188) 行）：
这是一个被所有函数共享的公共内容。那就是为什么 `count` 工作的原因。但是，`greeting` 也是被共享的，并且它被设置为迭代结束后的最后一个值，在这个案例中是 “howdy”。这是一个很常见的一般错误，避免它的简单方法是，引用一个函数调用，以闭包变量作为一个参数。在 CoffeeScript 中， [do](http://coffeescript.org/#loops) 命令提供了一个实现这种目的的简单方式。下面是对我们的 `greeter` 的一个简单的解决方案：
```
function makeGreeter(greetings)
{
var count = 0;
var greeter = {};
greetings.forEach(function(greeting){
greeter[greeting] = function(name){
count++;
console.log(greeting + ', ' + name);
}
});
greeter.count = function(){return count;}
return greeter;
}
var greeter = makeGreeter(["hi", "hello", "howdy"])
greeter.hi('poppet'); // prints "hi, poppet"
greeter.hello('darling'); // prints "hello, darling"
greeter.count(); // returns 2
```
它现在是工作的，并且结果将变成下图所示（LCTT 译注：映射从左到右“Object”、“JSFunction”和“Context”分别链接至 [#1671](https://code.google.com/p/v8/source/browse/trunk/src/objects.h#1671) 行、[#7245](https://code.google.com/p/v8/source/browse/trunk/src/objects.h#7245) 行和 [#188](https://code.google.com/p/v8/source/browse/trunk/src/contexts.h#188) 行）：
这里有许多箭头！在这里我们感兴趣的特性是：在我们的代码中，我们闭包了两个嵌套的词法内容，并且完全可以确保我们得到了两个链接到堆上的对象内容。你可以嵌套并且闭包任何词法内容，像“俄罗斯套娃”似的，并且最终从本质上说你使用的是所有那些 Context 对象的一个链表。
当然，就像受信鸽携带信息启发实现了 TCP 一样，去实现这些编程语言的特性也有很多种方法。例如，ES6 规范定义了 [词法环境](http://people.mozilla.org/%7Ejorendorff/es6-draft.html#sec-lexical-environments) 作为 [环境记录](http://people.mozilla.org/%7Ejorendorff/es6-draft.html#sec-environment-records)( 大致相当于在一个块内的本地标识）的组成部分，加上一个链接到外部环境的记录，这样就允许我们看到的嵌套。逻辑规则是由规范（一个希望）所确定的，但是其实现取决于将它们变成比特和字节的转换。
你也可以检查具体案例中由 V8 产生的汇编代码。[Vyacheslav Egorov](http://mrale.ph) 有一篇很好的文章，它使用 V8 的 [闭包内部构件](http://mrale.ph/blog/2012/09/23/grokking-v8-closures-for-fun.html) 详细解释了这一过程。我刚开始学习 V8，因此，欢迎指教。如果你熟悉 C#，检查闭包产生的中间代码将会很受启发 —— 你将看到显式定义的 V8 内容和实例化的模拟。
闭包是个强大的“家伙”。它在被一组函数共享期间，提供了一个简单的方式去隐藏来自调用者的信息。我喜欢它们真正地隐藏你的数据：不像对象字段，调用者并不能访问或者甚至是看到闭包变量。保持接口清晰而安全。
但是，它们并不是“银弹”（LCTT 译注：意指极为有效的解决方案，或者寄予厚望的新技术）。有时候一个对象的拥护者和一个闭包的狂热者会无休止地争论它们的优点。就像大多数的技术讨论一样，他们通常更关注的是自尊而不是真正的权衡。不管怎样，Anton van Straaten 的这篇 [史诗级的公案](http://people.csail.mit.edu/gregs/ll1-discuss-archive-html/msg03277.html) 解决了这个问题：
>
> 德高望重的老师 Qc Na 和它的学生 Anton 一起散步。Anton 希望将老师引入到一个讨论中，Anton 说：“老师，我听说对象是一个非常好的东西，是这样的吗？Qc Na 同情地看了一眼，责备它的学生说：“可怜的孩子 —— 对象不过是穷人的闭包而已。” Anton 待它的老师走了之后，回到他的房间，专心学习闭包。他认真地阅读了完整的 “Lambda：The Ultimate…" 系列文章和它的相关资料，并使用一个基于闭包的对象系统实现了一个小的架构解释器。他学到了很多的东西，并期待告诉老师他的进步。在又一次和 Qc Na 散步时，Anton 尝试给老师留下一个好的印象，说“老师，我仔细研究了这个问题，并且，现在理解了对象真的是穷人的闭包。”Qc Na 用它的手杖打了一下 Anton 说：“你什么时候才能明白？闭包是穷人的对象。”在那个时候，Anton 顿悟了。Anton van Straaten 说：“原来架构这么酷啊？”
>
>
>
探秘“栈”系列文章到此结束了。后面我将计划去写一些其它的编程语言实现的主题，像对象绑定和虚表。但是，内核调用是很强大的，因此，明天将发布一篇操作系统的文章。我邀请你 [订阅](https://manybutfinite.com/feed.xml) 并 [关注我](http://twitter.com/manybutfinite)。
---
via:<https://manybutfinite.com/post/closures-objects-heap/>
作者：[Gustavo Duarte](http://duartes.org/gustavo/blog/about/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
我正在运行的 Linux 是什么版本？
|
Joshua Allen Holm
|
https://opensource.com/article/18/6/linux-version
|
掌握这些快捷命令以找出你正在运行的 Linux 系统的内核版本和发行版。
|
/data/attachment/album/201806/18/223459z28f88yxxgbxcwtx.png.thumb.jpg
|
/data/attachment/album/201806/18/223459z28f88yxxgbxcwtx.png
| true | false | true |
MjSeven
| false |
[
"Linux",
"版本",
"发行版"
] |
技术
|
{
"viewnum": 10561,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
掌握这些快捷命令以找出你正在运行的 Linux 系统的内核版本和发行版。
| 2018-06-18T22:35:18 | 2018-06-18T22:35:18 | 9,760 |
/article-9760-1.html
|
>
> 掌握这些快捷命令以找出你正在运行的 Linux 系统的内核版本和发行版。
>
>
>
“什么版本的 Linux ？”这个问题可能意味着两个不同的东西。严格地说，Linux 是内核，所以问题可以特指内核的版本号，或者 “Linux” 可以更通俗地用来指整个发行版，就像在 Fedora Linux 或 Ubuntu Linux 中一样。
两者都很重要，你可能需要知道其中一个或全部答案来修复系统中的问题。例如，了解已安装的内核版本可能有助于诊断带有专有驱动程序的问题，并且确定正在运行的发行版将帮助你快速确定是否应该使用 `apt`、 `dnf`、 `yum` 或其他命令来安装软件包。
以下内容将帮助你了解 Linux 内核的版本和/或系统上正在运行的 Linux 发行版是什么。
### 如何找到 Linux 内核版本
要找出哪个 Linux 内核版本正在运行，运行以下命令：
```
uname -srm
```
或者，可以使用更长，更具描述性的各种标志的版本来运行该命令：
```
uname --kernel-name --kernel-release --machine
```
无论哪种方式，输出都应该类似于以下内容：
```
Linux 4.16.10-300.fc28.x86_64 x86_64
```
这为你提供了（按顺序）：内核名称、内核版本以及运行内核的硬件类型。在上面的情况下，内核是 Linux ，版本 4.16.10-300.fc28.x86*64 ，运行于 x86*64 系统。
有关 `uname` 命令的更多信息可以通过运行 `man uname` 找到。
### 如何找出 Linux 发行版
有几种方法可以确定系统上运行的是哪个发行版，但最快的方法是检查 `/etc/os-release` 文件的内容。此文件提供有关发行版的信息，包括但不限于发行版名称及其版本号。某些发行版的 `os-release` 文件包含比其他发行版更多的细节，但任何包含 `os-release` 文件的发行版都应该提供发行版的名称和版本。
要查看 `os-release` 文件的内容，运行以下命令：
```
cat /etc/os-release
```
在 Fedora 28 中，输出如下所示：
```
NAME=Fedora
VERSION="28 (Workstation Edition)"
ID=fedora
VERSION_ID=28
PLATFORM_ID="platform:f28"
PRETTY_NAME="Fedora 28 (Workstation Edition)"
ANSI_COLOR="0;34"
CPE_NAME="cpe:/o:fedoraproject:fedora:28"
HOME_URL="https://fedoraproject.org/"
SUPPORT_URL="https://fedoraproject.org/wiki/Communicating_and_getting_help"
BUG_REPORT_URL="https://bugzilla.redhat.com/"
REDHAT_BUGZILLA_PRODUCT="Fedora"
REDHAT_BUGZILLA_PRODUCT_VERSION=28
REDHAT_SUPPORT_PRODUCT="Fedora"
REDHAT_SUPPORT_PRODUCT_VERSION=28
PRIVACY_POLICY_URL="https://fedoraproject.org/wiki/Legal:PrivacyPolicy"
VARIANT="Workstation Edition"
VARIANT_ID=workstation
```
如上面那个例子展示的那样，Fedora 的 `os-release` 文件提供了发行版的名称和版本，但它也标识这个安装的变体（“Workstation Edition”）。如果我们在 Fedora 28 服务器版本上运行相同的命令，`os-release` 文件的内容会反映在 `VARIANT` 和 `VARIANT_ID` 行中。
有时候知道一个发行版是否与另一个发行版相似非常有用，因此 `os-release` 文件可以包含一个 `ID_LIKE` 行，用于标识正在运行的是基于什么的发行版或类似的发行版。例如，Red Hat Linux 企业版的 `os-release` 文件包含 `ID_LIKE` 行，声明 RHEL 与 Fedora 类似；CentOS 的 `os-release` 文件声明 CentOS 与 RHEL 和 Fedora 类似。如果你正在使用基于另一个发行版的发行版并需要查找解决问题的说明，那么 `ID_LIKE` 行非常有用。
CentOS 的 `os-release` 文件清楚地表明它就像 RHEL 一样，所以在各种论坛中关于 RHEL 的文档，问题和答案应该（大多数情况下）适用于 CentOS。CentOS 被设计成一个 RHEL 近亲，因此在某些字段它更兼容其 `ID_LIKE` 系统的字段。如果你找不到正在运行的发行版的信息，检查有关 “类似” 发行版的答案总是一个好主意。
有关 `os-release` 文件的更多信息可以通过运行 `man os-release` 命令来查找。
---
via: <https://opensource.com/article/18/6/linux-version>
作者：[Joshua Allen Holm](https://opensource.com/users/holmja) 选题：[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/) 荣誉推出
|
||
Oracle Linux 系统如何去注册使用坚不可摧 Linux 网络（ULN）
|
Vinoth Kumar
|
https://www.2daygeek.com/how-to-register-the-oracle-linux-system-with-the-unbreakable-linux-network-uln/
|
ULN 为 Oracle Linux 和 Oracle VM 提供软件补丁、更新、以及修复，这些信息同时提供在 yum、Ksplice、并提供支持策略。你也可以通过它来下载原始发行版中没有包含的有用的安装包。
|
/data/attachment/album/201806/18/230317ts9jixj6dfn382fl.jpg.thumb.jpg
|
/data/attachment/album/201806/18/230317ts9jixj6dfn382fl.jpg
| true | false | true |
qhwdw
| false |
[
"Oracle",
"ULN"
] |
技术
|
{
"viewnum": 7417,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
ULN 为 Oracle Linux 和 Oracle VM 提供软件补丁、更新、以及修复，这些信息同时提供在 yum、Ksplice、并提供支持策略。你也可以通过它来下载原始发行版中没有包含的有用的安装包。
| 2018-06-18T23:03:00 | 2018-06-18T23:03:00 | 9,761 |
/article-9761-1.html
|
大多数人都知道 RHEL 的订阅 ，但是知道 Oracle 订阅及细节的人却很少。
甚至我也不知道关于它的信息，我是最近才了解了有关它的信息，想将这些内容共享给其他人。因此写了这篇文章，它将指导你去注册 Oracle Linux 系统去使用坚不可摧 Linux 网络（ULN） 。
这将允许你去注册系统以尽快获得软件更新和其它的补丁。
### 什么是坚不可摧 Linux 网络
ULN 代表<ruby> 坚不可摧 Linux 网络 <rt> Unbreakable Linux Network </rt></ruby>，它是由 Oracle 所拥有的。如果你去 Oracle OS 支持中去激活这个订阅，你就可以注册你的系统去使用坚不可摧 Linux 网络（ULN）。
ULN 为 Oracle Linux 和 Oracle VM 提供软件补丁、更新、以及修复，这些信息同时提供在 yum、Ksplice、并提供支持策略。你也可以通过它来下载原始发行版中没有包含的有用的安装包。
ULN 的告警提示工具会周期性地使用 ULN 进行检查，当有更新的时候它给你发送警报信息。
如果你想在 yum 上使用 ULN 仓库去管理你的系统，需要确保你的系统已经注册到 ULN 上，并且订阅了一个或多个 ULN 频道。当你注册一个系统使用 ULN，它将基于你的系统架构和操作系统去自动选择频道中最新的版本。
### 如何注册为一个 ULN 用户
要注册为一个 ULN 用户，需要你有一个 Oracle Linux 支持或者 Oracle VM 支持的有效客户支持代码（CSI）。
请按以下步骤去注册为一个 ULN 用户。
请访问 [linux.oracle.com](https://linux.oracle.com/register)：
如果你已经有一个 SSO 帐户，请点击 “Sign On”。
如果你没有帐户，点击 “Create New Single Signon Account” 然后按屏幕上的要求去创建一个帐户。
验证你的电子邮件地址以完成帐户设置。
使用你的 SSO 帐户的用户名和密码去登入。在 “Create New ULN User” 页面上，输入你的 CSI 然后点击 “Create New User”。
**注意：**
* 如果当前没有分配管理员去管理 CSI，将会提示你去点击确认让你成为 CSI 管理员。
* 如果你的用户名已经在系统上存在，你将被提示通过点击坚不可摧 Linux 网络的链接去操作 ULN。
### 如何注册 Oracle Linux 6/7 系统使用 ULN
只需要运行下列的命令，并按随后的指令提示去注册系统。
```
# uln_register
```
确保你的系统有一个激活的因特网连接。同时准备好你的 Oracle 单点登录帐户（SSO）的用户名和密码，然后点击 `Next`。
```
Copyright ▪© 2006--2010 Red Hat, Inc. All rights reserved.
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪¤ Setting up software updates ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
▪ This assistant will guide you through connecting your system to Unbreakable Linux Network (ULN) to receive software updates, ▪
▪ including security updates, to keep your system supported and compliant. You will need the following at this time: ▪
▪ ▪
▪ * A network connection ▪
▪ * Your Oracle Single Sign-On Login & password ▪
▪ ▪
▪ ▪
▪ ▪
▪ ▪
▪ ▪
▪ ▪
▪ ▪
▪ ▪
▪ ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪ Why Should I Connect to ULN? ... ▪ ▪ Next ▪ ▪ Cancel ▪ ▪
▪ ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
```
输入你的 ULN 登录信息，然后点击 `Next`。
```
Copyright ▪© 2006--2010 Red Hat, Inc. All rights reserved.
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪¤ Setting up software updates ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
▪ ▪
▪ Please enter your login information for Unbreakable Linux Network (http://linux.oracle.com/): ▪
▪ ▪
▪ ▪
▪ Oracle Single Sign-On Login: thamuthu@gmail.com_ ▪
▪ Password: **********__________ ▪
▪ CSI: 12345678____________ ▪
▪ Tip: Forgot your login or password? Visit: http://www.oracle.com/corporate/contact/getaccthelp.html ▪
▪ ▪
▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪ Next ▪ ▪ Back ▪ ▪ Cancel ▪ ▪
▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪
▪ ▪
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
```
注册一个系统概要 – 硬件信息，然后点击 `Next`。
```
Copyright ▪© 2006--2010 Red Hat, Inc. All rights reserved.
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪¤ Register a System Profile - Hardware ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
▪ ▪
▪ A Profile Name is a descriptive name that you choose to identify this ▪
▪ System Profile on the Unbreakable Linux Network web pages. Optionally, ▪
▪ include a computer serial or identification number. ▪
▪ Profile name: 2g-oracle-sys___________________________ ▪
▪ ▪
▪ [*] Include the following information about hardware and network: ▪
▪ Press to deselect the option. ▪
▪ ▪
▪ Version: 6 CPU model: Intel(R) Xeon(R) CPU E5-5650 0 @ 2.00GHz ▪
▪ Hostname: 2g-oracle-sys ▪
▪ CPU speed: 1199 MHz IP Address: 192.168.1.101 Memory: ▪
▪ ▪
▪ Additional hardware information including PCI devices, disk sizes and mount points will be included in the profile. ▪
▪ ▪
▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪ Next ▪ ▪ Back ▪ ▪ Cancel ▪ ▪
▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪
▪ ▪
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
```
注册一个系统概要 – 包配置，然后点击 `Next`。
```
Copyright ▪© 2006--2010 Red Hat, Inc. All rights reserved.
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪¤ Register a System Profile - Packages ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
▪ ▪
▪ RPM information is important to determine what updated software packages are relevant to this system. ▪
▪ ▪
▪ [*] Include RPM packages installed on this system in my System Profile ▪
▪ ▪
▪ You may deselect individual packages by unchecking them below. ▪
▪ [*] ConsoleKit-0.4.1-6.el6 ▪ ▪
▪ [*] ConsoleKit-libs-0.4.1-6.el6 ▪ ▪
▪ [*] ConsoleKit-x11-0.4.1-6.el6 ▪ ▪
▪ [*] DeviceKit-power-014-3.el6 ▪ ▪
▪ [*] GConf2-2.28.0-7.el6 ▪ ▪
▪ [*] GConf2-2.28.0-7.el6 ▪ ▪
▪ [*] GConf2-devel-2.28.0-7.el6 ▪ ▪
▪ [*] GConf2-gtk-2.28.0-7.el6 ▪ ▪
▪ [*] MAKEDEV-3.24-6.el6 ▪ ▪
▪ [*] MySQL-python-1.2.3-0.3.c1.1.el6 ▪ ▪
▪ [*] NessusAgent-7.0.3-es6 ▪ ▪
▪ [*] ORBit2-2.14.17-6.el6_8 ▪ ▪
▪ [*] ORBit2-2.14.17-6.el6_8 ▪ ▪
▪ [*] ORBit2-devel-2.14.17-6.el6_8 ▪ ▪
▪ [*] PackageKit-0.5.8-26.0.1.el6 ▪ ▪
▪ [*] PackageKit-device-rebind-0.5.8-26.0.1.el6 ▪ ▪
▪ [*] PackageKit-glib-0.5.8-26.0.1.el6 ▪ ▪
▪ ▪
▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪ Next ▪ ▪ Back ▪ ▪ Cancel ▪ ▪
▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪
▪ ▪
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
```
按下 “Next” 去发送系统概要到 ULN。
```
Copyright ▪© 2006--2010 Red Hat, Inc. All rights reserved.
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪¤ Send Profile Information to Unbreakable Linux Network ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
▪ ▪
▪ We are finished collecting information for the System Profile. ▪
▪ ▪
▪ Press "Next" to send this System Profile to Unbreakable Linux Network. Click "Cancel" and no information will be sent. You ▪
▪ can run the registration program later by typing `uln_register` at the command line. ▪
▪ ▪
▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪ Next ▪ ▪ Back ▪ ▪ Cancel ▪ ▪
▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪ ▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪
▪ ▪
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
```
发送概要到 ULN 是如下的一个过程。
```
Copyright ▪© 2006--2010 Red Hat, Inc. All rights reserved.
▪▪¤ Sending Profile to Unbreakable Linux Network ▪
▪ ▪
▪ 75% ▪
▪ ▪
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
```
ULN 注册做完后，重新回顾系统订阅的详细情况。如果一切正确，然后点击 `ok`。
```
Copyright ▪© 2006--2010 Red Hat, Inc. All rights reserved.
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪¤ Review system subscription details ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
▪ ▪
▪ ▪
▪ Note: yum-rhn-plugin has been enabled. ▪
▪ ▪
▪ Please review the subscription details below: ▪
▪ ▪
▪ Software channel subscriptions: ▪
▪ This system will receive updates from the following Unbreakable Linux Network software channels: ▪
▪ Oracle Linux 6 Latest (x86_64) ▪
▪ Unbreakable Enterprise Kernel Release 4 for Oracle Linux 6 (x86_64) ▪
▪ ▪
▪ Warning: If an installed product on this system is not listed above, you will not receive updates or support for that product. If ▪
▪ you would like to receive updates for that product, please visit http://linux.oracle.com/ and subscribe this system to the ▪
▪ appropriate software channels to get updates for that product. ▪
▪ ▪
▪ ▪
▪ ▪
▪ ▪
▪ ▪
▪ ▪
▪ ▪
▪ ▪▪▪▪▪▪ ▪
▪ ▪ OK ▪ ▪
▪ ▪▪▪▪▪▪ ▪
▪ ▪
▪ ▪
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
```
最后点击 `Finish` 完成注册。
```
Copyright ▪© 2006--2010 Red Hat, Inc. All rights reserved.
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪¤ Finish setting up software updates ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
▪ ▪
▪ You may now run 'yum update' from this system's command line to get the latest software updates from Unbreakable Linux Network. ▪
▪ You will need to run this periodically to get the latest updates. ▪
▪ ▪
▪ ▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪ Finish ▪ ▪
▪ ▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪
▪ ▪
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
```
ULN 注册已经成功，为了从 ULN 中得到仓库，运行如下的命令。
```
# yum repolist
Loaded plugins: aliases, changelog, presto, refresh-packagekit, rhnplugin, security, tmprepo, ulninfo, verify, versionlock
This system is receiving updates from ULN.
ol6_x86_64_UEKR3_latest | 1.2 kB 00:00
ol6_x86_64_UEKR3_latest/primary | 35 MB 00:14
ol6_x86_64_UEKR3_latest 874/874
repo id repo name status
ol6_x86_64_UEKR3_latest Unbreakable Enterprise Kernel Release 3 for Oracle Linux 6 (x86_64) - Latest 874
ol6_x86_64_latest Oracle Linux 6 Latest (x86_64) 40,092
repolist: 40,966
```
另外，你也可以在 ULN 网站上查看到相同的信息。转到 `System` 标签页去查看已注册的系统列表。
去查看已经启用的仓库列表。转到 `System` 标签页，然后点击相应的系统。另外，你也能够看到系统勘误及可用更新。
去管理订阅的频道。转到 `System` 标签页，然后点击有关的 `system name`，最后点击 `Manage Subscriptions`。
---
via: <https://www.2daygeek.com/how-to-register-the-oracle-linux-system-with-the-unbreakable-linux-network-uln/>
作者：[Vinoth Kumar](https://www.2daygeek.com/author/vinoth/) 选题：[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 工具
|
Adam Worth
|
https://opensource.com/article/18/3/top-Linux-tools-for-writers
|
这些易用的开源应用可以帮助你打磨你的写作技巧、使研究更高效、更具有条理。
|
/data/attachment/album/201806/20/110135nkivw9v7rac9kr9f.jpg.thumb.jpg
|
/data/attachment/album/201806/20/110135nkivw9v7rac9kr9f.jpg
| true | false | true |
MjSeven
| false |
[
"写作"
] |
分享
|
{
"viewnum": 8815,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这些易用的开源应用可以帮助你打磨你的写作技巧、使研究更高效、更具有条理。
| 2018-06-20T11:01:43 | 2018-06-20T11:01:43 | 9,763 |
/article-9763-1.html
|
>
> 这些易用的开源应用可以帮助你打磨你的写作技巧、使研究更高效、更具有条理。
>
>
>
如果你已经阅读过[我关于如何切换到 Linux 的文章](https://opensource.com/article/18/2/my-linux-story-Antergos)，那么你就知道我是一个超级用户。另外，我不是任何方面的“专家”，目前仍然如此。但是在过去几年里我学到了很多有用的东西，我想将这些技巧传给其他新的 Linux 用户。
今天，我将讨论我写作时使用的工具，基于三个标准来选择：
1. 当我提交作品或文章时，我的主要写作工具必须与任何发布者兼容。
2. 该软件使用起来必须简单快捷。
3. 免费（自由）是很棒的。
有一些很棒的一体化免费解决方案，比如：
1. [bibisco](http://www.bibisco.com/)
2. [Manuskript](http://www.theologeek.ch/manuskript/)
3. [oStorybook](http://ostorybook.tuxfamily.org/index.php?lng=en)
但是，当我试图寻找信息时，我往往会迷失方向并失去思路，所以我选择了适合我需求的多个应用程序。另外，我不想依赖互联网，以免服务下线。我把这些程序放在显示器桌面上，以便我一下全看到它们。
请考虑以下工具建议 ： 每个人的工作方式都不相同，并且你可能会发现一些更适合你工作方式的其他应用程序。以下这些工具是目前的写作工具：
### 文字处理器
[LibreOffice 6.0.1](https://www.libreoffice.org/)。直到最近，我使用了 [WPS](http://wps-community.org/)，但由于字体渲染问题（Times New Roman 总是以粗体显示）而否定了它。LibreOffice 的最新版本非常适应 Microsoft Office，而且事实上它是开源的，这对我来说很重要。
### 词库
[Artha](https://sourceforge.net/projects/artha/) 可以给出同义词、反义词、派生词等等。它外观整洁、速度快。例如，输入 “fast” 这个词，你会得到字典定义以及上面列出的其他选项。Artha 是送给开源社区的一个巨大的礼物，人们应该试试它，因为它似乎是一个冷僻的小程序。如果你使用 Linux，请立即安装此应用程序，你不会后悔的。
### 记笔记
[Zim](http://zim-wiki.org/) 标榜自己是一个桌面维基，但它也是你所能找到的最简单的多层级笔记应用程序。还有其它更漂亮的笔记程序，但 Zim 正是那种我需要管理角色、地点、情节和次要情节的程序。
### 投稿跟踪
我曾经使用过一款名为 [FileMaker Pro](http://www.filemaker.com/) 的专有软件，它惯坏了我。有很多数据库应用程序，但在我看来，最容易使用的某过于 [Glom](https://www.glom.org/) 了。它以图形方式满足我的需求，让我以表单形式输入信息而不是表格。在 Glom 中，你可以创建你需要的表单，这样你就可以立即看到相关信息（对于我来说，通过电子表格来查找信息就像将我的眼球拖到玻璃碎片上）。尽管 Glom 不再处于开发阶段，但它仍然是很棒的。
### 搜索
我已经开始使用 [StartPage.com](https://www.startpage.com/) 作为我的默认搜索引擎。当然，当你写作时，[Google](https://www.google.com/) 可以成为你最好的朋友之一。但我不喜欢每次我想了解特定人物、地点或事物时，Google 都会跟踪我。所以我使用 StartPage.com 来代替。它速度很快，并且不会跟踪你的搜索。我也使用 [DuckDuckGo.com](https://duckduckgo.com/) 作为 Google 的替代品。
### 其他的工具
[Chromium 浏览器](https://www.chromium.org/) 是 [Google Chrome](https://www.google.com/chrome/) 的开源版本，带有隐私插件。
尽管来自 [Mozilla](https://www.mozilla.org/en-US/) 的 [Thunderbird](https://www.mozilla.org/en-US/thunderbird/) 是一个很棒的程序，但我发现 [Geary](https://wiki.gnome.org/Apps/Geary) 是一个更快更轻的电子邮件应用程序。有关开源电子邮件应用程序的更多信息，请阅读 [Jason Baker](https://opensource.com/users/jason-baker) 的优秀文章：[6 个开源的桌面电子邮件客户端](https://opensource.com/business/18/1/desktop-email-clients)。
正如你可能已经注意到，我对应用程序的喜爱趋向于将最好的 Windows、MacOS 都能运行，以及此处提到的开源 Linux 替代品融合在一起。我希望这些建议能帮助你发现有用的新方法来撰写并跟踪你的写作（谢谢你，Artha！）。
写作愉快！
---
via: <https://opensource.com/article/18/3/top-Linux-tools-for-writers>
作者：[Adam Worth](https://opensource.com/users/adamworth) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 中禁用内置摄像头
|
Sk
|
https://www.ostechnix.com/how-to-disable-built-in-webcam-in-ubuntu/
|
在不使用时用胶带覆盖它或者拔掉相机或者在 BIOS 中禁用它是一个不错的主意。
|
/data/attachment/album/201806/20/110711r1ltfvf81ulq9fud.jpg.thumb.jpg
|
/data/attachment/album/201806/20/110711r1ltfvf81ulq9fud.jpg
| true | false | true |
geekpi
| false |
[
"摄像头"
] |
桌面应用
|
{
"viewnum": 7223,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在不使用时用胶带覆盖它或者拔掉相机或者在 BIOS 中禁用它是一个不错的主意。
| 2018-06-20T11:07:00 | 2018-06-20T11:07:00 | 9,764 |
/article-9764-1.html
|
今天，我们将看到如何禁用未使用的内置网络摄像头或外置摄像头，以及如何在 Linux 中需要时启用它。禁用网络摄像头可以在很多方面为你提供帮助。你可以防止恶意软件控制你的集成摄像头，并监视你和你的家庭。我们已经阅读过无数的故事，一些黑客可以在你不知情的情况下使用你的摄像头监视你。通过黑客攻击你的网络摄像头，用户可以在线共享你的私人照片和视频。可能有很多原因。如果你想知道如何禁用笔记本电脑或台式机中的网络摄像头，那么你很幸运。这个简短的教程将告诉你如何做。请继续阅读。
我在 Arch Linux 和 Ubuntu 上测试了这个指南。它的工作原理如下所述。我希望这也可以用在其他 Linux 发行版上。
### 在 Linux 中禁用内置摄像头
首先，使用如下命令找到网络摄像头驱动：
```
$ sudo lsmod | grep uvcvideo
```
示例输出：
```
uvcvideo 114688 1
videobuf2_vmalloc 16384 1 uvcvideo
videobuf2_v4l2 28672 1 uvcvideo
videobuf2_common 53248 2 uvcvideo,videobuf2_v4l2
videodev 208896 4 uvcvideo,videobuf2_common,videobuf2_v4l2
media 45056 2 uvcvideo,videodev
usbcore 286720 9 uvcvideo,usbhid,usb_storage,ehci_hcd,ath3k,btusb,uas,ums_realtek,ehci_pci
```
这里，**uvcvideo** 是我的网络摄像头驱动。
现在，让我们禁用网络摄像头。
为此，请编辑以下文件（如果文件不存在，只需创建它）：
```
$ sudo nano /etc/modprobe.d/blacklist.conf
```
添加以下行：
```
##Disable webcam.
blacklist uvcvideo
```
`##Disable webcam` 这行不是必需的。为了便于理解，我添加了它。
保存并退出文件。重启系统以使更改生效。
要验证网络摄像头是否真的被禁用，请打开任何即时通讯程序或网络摄像头软件，如 Cheese 或 Guvcview。你会看到如下的空白屏幕。
Cheese 输出：
Guvcview 输出：
看见了么？网络摄像头被禁用而无法使用。
要启用它，请编辑：
```
$ sudo nano /etc/modprobe.d/blacklist.conf
```
注释掉你之前添加的行。
```
##Disable webcam.
#blacklist uvcvideo
```
保存并关闭文件。然后，重启计算机以启用网络摄像头。
这样够了吗？不。为什么？如果有人可以远程访问你的系统，他们可以轻松启用网络摄像头。所以，在不使用时用胶带覆盖它或者拔掉相机或者在 BIOS 中禁用它是一个不错的主意。此方法不仅用于禁用内置摄像头，还用于外部网络摄像头。
就是这些了。希望对你有用。还有更好的东西。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/how-to-disable-built-in-webcam-in-ubuntu/>
作者：[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 比 Windows 和 macOS 更安全？
|
Dave Taylor
|
https://www.computerworld.com/article/3252823/linux/why-linux-is-better-than-windows-or-macos-for-security.html
|
多年前做出的操作系统选型终将影响到如今的企业安全。在三大主流操作系统当中，有一个能被称作最安全的。
|
/data/attachment/album/201806/21/010400o08mzi8hfspuwo0i.jpg.thumb.jpg
|
/data/attachment/album/201806/21/010400o08mzi8hfspuwo0i.jpg
| true | false | true |
fuzheng1998
| true |
[
"操作系统",
"安全"
] |
观点
|
{
"viewnum": 27545,
"commentnum": 4,
"favtimes": 2,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "202.98.86.164",
"message": "首先linux没有windows好用！<br />\r\nlinux安全？无非是用的人都是比较懂行的安全意识比较高，linux注度不如windows，攻击的人没有windows的多。windows小白多安全意识差不关端口不设密码乱下软件导致出现大量漏洞和病毒。",
"username": "来自云南昆明的 Firefox 65.0|Windows 10 用户",
"date": "2019-03-01T16:01:51"
},
{
"postip": "182.47.118.22",
"message": "我觉得还有一个原因，linux用在服务端，运维部署好就不用管了保持环境运行几年十几年，windows作为个人电脑，用户今天装这个，明天玩那个，系统环境瞬息万变，这种比较本身就不靠谱，相反我觉的windows 还是挺好的，因为他在平衡安全易用和灵活。如果让一个普通用户用linux不用病毒，他自己就能把系统整崩溃了。",
"username": "来自山东济南的 Chrome 74.0|Windows 10 用户",
"date": "2019-06-11T14:36:02"
},
{
"postip": "182.47.118.22",
"message": "我觉得还有一个原因，linux用在服务端，运维部署好就不用管了保持环境运行几年十几年，windows作为个人电脑，用户今天装这个，明天玩那个，系统环境瞬息万变，这种比较本身就不靠谱，相反我觉的windows 还是挺好的，因为他在平衡安全易用和灵活。如果让一个普通用户用linux不用病毒，他自己就能把系统整崩溃了。",
"username": "来自山东济南的 Chrome 74.0|Windows 10 用户",
"date": "2019-06-11T14:36:06"
},
{
"postip": "182.47.118.22",
"message": "我觉得还有一个原因，linux用在服务端，运维部署好就不用管了保持环境运行几年十几年，windows作为个人电脑，用户今天装这个，明天玩那个，系统环境瞬息万变，这种比较本身就不靠谱，相反我觉的windows 还是挺好的，因为他在平衡安全易用和灵活。如果让一个普通用户用linux不用病毒，他自己就能把系统整崩溃了。",
"username": "来自山东济南的 Chrome 74.0|Windows 10 用户",
"date": "2019-06-11T14:36:07"
}
] |
[] |
多年前做出的操作系统选型终将影响到如今的企业安全。在三大主流操作系统当中，有一个能被称作最安全的。
| 2018-06-21T01:03:00 | 2018-06-21T01:03:00 | 9,765 |
/article-9765-1.html
|
>
> 多年前做出的操作系统选型终将影响到如今的企业安全。在三大主流操作系统当中，有一个能被称作最安全的。
>
>
>
企业投入了大量时间、精力和金钱来保障系统的安全性。最强的安全意识可能就是有一个安全运行中心（SOC），肯定用上了防火墙以及反病毒软件，或许还花费了大量时间去监控他们的网络，以寻找可能表明违规的异常信号，用那些 IDS、SIEM 和 NGFW 之类的东西，他们部署了一个名副其实的防御阵列。
然而又有多少人想过数字化操作的基础之一——部署在员工的个人电脑上的操作系统呢？当选择桌面操作系统时，安全性是一个考虑的因素吗？
这就产生了一个 IT 人士都应该能回答的问题：一般部署哪种操作系统最安全呢？
我们问了一些专家他们对于以下三种选择的看法：Windows，最复杂的平台也是最受欢迎的桌面操作系统；macOS X，基于 FreeBSD 的 Unix 操作系统，驱动着苹果的 Macintosh 系统运行；还有 Linux，这里我们指的是所有的 Linux 发行版以及与基于 Unix 的操作系统相关的系统。
### 怎么会这样
企业可能没有评估他们部署给工作人员的操作系统的安全性的一个原因是，他们多年前就已经做出了选择。退一步讲，所有操作系统都还算安全，因为侵入它们、窃取数据或安装恶意软件的牟利方式还处于起步阶段。而且一旦选择了操作系统，就很难再改变。很少有 IT 组织想要面对将全球分散的员工队伍转移到全新的操作系统上的痛苦。唉，他们已经受够了把用户搬到一个现有的操作系统的新版本时的负面反响。
还有，重新考虑操作系统是高明的吗？这三款领先的桌面操作系统在安全方面的差异是否足以值得我们去做出改变呢？
当然商业系统面临的威胁近几年已经改变了。攻击变得成熟多了。曾经支配了公众想象力的单枪匹马的青少年黑客已经被组织良好的犯罪分子网络以及具有庞大计算资源的政府资助组织的网络所取代。
像你们许多人一样，我有过很多那时的亲身经历：我曾经在许多 Windows 电脑上被恶意软件和病毒感染，我甚至被宏病毒感染了 Mac 上的文件。最近，一个广泛传播的自动黑客攻击绕开了网站的保护程序并用恶意软件感染了它。这种恶意软件的影响一开始是隐形的，甚至有些东西你没注意，直到恶意软件最终深深地植入系统以至于它的性能开始变差。一件有关病毒蔓延的震惊之事是不法之徒从来没有特定针对过我；当今世界，用僵尸网络攻击 100,000 台电脑容易得就像一次攻击几台电脑一样。
### 操作系统真的很重要吗?
给你的用户部署的哪个操作系统确实对你的安全态势产生了影响，但那并不是一个可靠的安全措施。首先，现在的攻击很可能会发生，因为攻击者探测的是你的用户，而不是你的系统。一项对参加了 DEFCON 会议的黑客的[调查](https://www.esecurityplanet.com/hackers/fully-84-percent-of-hackers-leverage-social-engineering-in-attacks.html)表明，“84％ 的人使用社交工程作为攻击策略的一部分。”部署安全的操作系统只是一个重要的起点，但如果没有用户培训、强大的防火墙和持续的警惕性，即使是最安全的网络也会受到入侵。当然，用户下载的软件、扩展程序、实用程序、插件和其他看起来还好的软件总是有风险的，成为了恶意软件出现在系统上的一种途径。
无论你选择哪种平台，保持你系统安全最好的方法之一就是确保立即应用了软件更新。一旦补丁正式发布，黑客就可以对其进行反向工程并找到一种新的漏洞，以便在下一波攻击中使用。
而且别忘了最基本的操作。别用 root 权限，别授权访客连接到网络中的老服务器上。教您的用户如何挑选一个真正的好密码并且使用例如 [1Password](http://www.1password.com) 这样的工具，以便在每个他们使用的帐户和网站上拥有不同的密码
因为底线是您对系统做出的每一个决定都会影响您的安全性，即使您的用户工作使用的操作系统也是如此。
### Windows，流行之选
若你是一个安全管理人员，很可能文章中提出的问题就会变成这样：是否我们远离微软的 Windows 会更安全呢？说 Windows 主导企业市场都是低估事实了。[NetMarketShare](https://www.netmarketshare.com/operating-system-market-share.aspx?options=%7B%22filter%22%3A%7B%22%24and%22%3A%5B%7B%22deviceType%22%3A%7B%22%24in%22%3A%5B%22Desktop%2Flaptop%22%5D%7D%7D%5D%7D%2C%22dateLabel%22%3A%22Trend%22%2C%22attributes%22%3A%22share%22%2C%22group%22%3A%22platform%22%2C%22sort%22%3A%7B%22share%22%3A-1%7D%2C%22id%22%3A%22platformsDesktop%22%2C%22dateInterval%22%3A%22Monthly%22%2C%22dateStart%22%3A%222017-02%22%2C%22dateEnd%22%3A%222018-01%22%2C%22segments%22%3A%22-1000%22%7D) 估计互联网上 88% 的电脑令人震惊地运行着 Windows 的某个版本。
如果你的系统在这 88％ 之中，你可能知道微软会继续加强 Windows 系统的安全性。这些改进被不断重写，或者重新改写了其代码库，增加了它的反病毒软件系统，改进了防火墙以及实现了沙箱架构，这样在沙箱里的程序就不能访问系统的内存空间或者其他应用程序。
但可能 Windows 的流行本身就是个问题，操作系统的安全性可能很大程度上依赖于装机用户量的规模。对于恶意软件作者来说，Windows 提供了大的施展平台。专注其中可以让他们的努力发挥最大作用。
就像 Troy Wilkinson，Axiom Cyber Solutions 的 CEO 解释的那样，“Windows 总是因为很多原因而导致安全性保障来的最晚，主要是因为消费者的采用率。由于市场上大量基于 Windows 的个人电脑，黑客历来最有针对性地将这些系统作为目标。”
可以肯定地说，从梅丽莎病毒到 WannaCry 或者更强的，许多世界上已知的恶意软件早已对准了 Windows 系统.
### macOS X 以及通过隐匿实现的安全
如果最流行的操作系统总是成为大目标，那么用一个不流行的操作系统能确保安全吗？这个主意是老法新用——而且是完全不可信的概念——“通过隐匿实现的安全”，这秉承了“让软件内部运作保持专有，从而不为人知是抵御攻击的最好方法”的理念。
Wilkinson 坦言，macOS X “比 Windows 更安全”，但他马上补充说，“macOS 曾被认为是一个安全漏洞很小的完全安全的操作系统，但近年来，我们看到黑客制造了攻击苹果系统的额外漏洞。”
换句话说，攻击者会扩大活动范围而不会无视 Mac 领域。
Comparitech 的安全研究员 Lee Muson 说，在选择更安全的操作系统时，“macOS 很可能是被选中的目标”，但他提醒说，这一想法并不令人费解。它的优势在于“它仍然受益于通过隐匿实现的安全感和微软提供的操作系统是个更大的攻击目标。”
Wolf Solutions 公司的 Joe Moore 给予了苹果更多的信任，称“现成的 macOS X 在安全方面有着良好的记录，部分原因是它不像 Windows 那么广泛，而且部分原因是苹果公司在安全问题上干的不错。”
### 最终胜者是 ……
你可能一开始就知道它：专家们的明确共识是 Linux 是最安全的操作系统。然而，尽管它是服务器的首选操作系统，而将其部署在桌面上的企业很少。
如果你确定 Linux 是要选择的系统，你仍然需要决定选择哪种 Linux 系统，并且事情会变得更加复杂。 用户需要一个看起来很熟悉的用户界面，而你需要最安全的操作系统。
像 Moore 解释的那样，“Linux 有可能是最安全的，但要求用户是资深用户。”所以，它不是针对所有人的。
将安全性作为主要功能的 Linux 发行版包括 [Parrot Linux](https://www.parrotsec.org/)，这是一个基于 Debian 的发行版，Moore 说，它提供了许多与安全相关开箱即用的工具。
当然，一个重要的区别是 Linux 是开源的。Simplex Solutions 的 CISO Igor Bidenko 说，编码人员可以阅读和审查彼此工作的现实看起来像是一场安全噩梦，但这确实是让 Linux 如此安全的重要原因。 “Linux 是最安全的操作系统，因为它的源代码是开放的。任何人都可以查看它，并确保没有错误或后门。”
Wilkinson 阐述说：“Linux 和基于 Unix 的操作系统具有较少的在信息安全领域已知的、可利用的安全缺陷。技术社区对 Linux 代码进行了审查，该代码有助于提高安全性：通过进行这么多的监督，易受攻击之处、漏洞和威胁就会减少。”
这是一个微妙而违反直觉的解释，但是通过让数十人（有时甚至数百人）通读操作系统中的每一行代码，代码实际上更加健壮，并且发布漏洞错误的机会减少了。这与 《PC World》 为何出来说 Linux 更安全有很大关系。正如 Katherine Noyes [解释](https://www.pcworld.com/article/202452/why_linux_is_more_secure_than_windows.html)的那样，“微软可能吹捧它的大型的付费开发者团队，但团队不太可能与基于全球的 Linux 用户开发者进行比较。 安全只能通过所有额外的关注获益。”
另一个被 《PC World》举例的原因是 Linux 更好的用户特权模式：Noye 的文章讲到，Windows 用户“一般被默认授予管理员权限，那意味着他们几乎可以访问系统中的一切”。Linux，反而很好地限制了“root”权限。
Noyes 还指出，Linux 环境下的多样性可能比典型的 Windows 单一文化更好地对抗攻击：Linux 有很多不同的发行版。其中一些以其特别的安全关注点而差异化。Comparitech 的安全研究员 Lee Muson 为 Linux 发行版提供了这样的建议：“[Qubes OS](https://www.qubes-os.org/) 对于 Linux 来说是一个很好的出发点，现在你可以发现，[爱德华·斯诺登的认可](https://twitter.com/snowden/status/781493632293605376?lang=en)极大地超过了其谦逊的宣传。”其他安全性专家指出了专门的安全 Linux 发行版，如 [Tails Linux](https://tails.boum.org/about/index.en.html)，它旨在直接从 USB 闪存驱动器或类似的外部设备安全地匿名运行。
### 构建安全趋势
惯性是一股强大的力量。虽然人们有明确的共识，认为 Linux 是桌面系统的最安全选择，但并没有出现对 Windows 和 Mac 机器压倒性的倾向。尽管如此，Linux 采用率的小幅增长却可能会产生对所有人都更加安全的计算，因为市场份额的丧失是确定能获得微软和苹果公司关注的一个方式。换句话说，如果有足够的用户在桌面上切换到 Linux，Windows 和 Mac PC 很可能成为更安全的平台。
---
via: <https://www.computerworld.com/article/3252823/linux/why-linux-is-better-than-windows-or-macos-for-security.html>
作者：[Dave Taylor](https://www.computerworld.com/author/Dave-Taylor/) 译者：[fuzheng1998](https://github.com/fuzheng1998) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用树莓派制作一个数字针孔摄像头
|
Daniel Berrange
|
https://opensource.com/article/18/3/how-build-digital-pinhole-camera-raspberry-pi
|
学习如何使用一个树莓派 Zero、高清网络摄像头和一个空的粉盒来搭建一个简单的相机。
|
/data/attachment/album/201806/21/094812a1ahq6ha69q6v36v.jpg.thumb.jpg
|
/data/attachment/album/201806/21/094812a1ahq6ha69q6v36v.jpg
| true | false | true |
qhwdw
| false |
[
"树莓派",
"相机"
] |
树莓派
|
{
"viewnum": 10431,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
学习如何使用一个树莓派 Zero、高清网络摄像头和一个空的粉盒来搭建一个简单的相机。
| 2018-06-21T09:50:09 | 2018-06-21T09:50:09 | 9,766 |
/article-9766-1.html
|
>
> 学习如何使用一个树莓派 Zero、高清网络摄像头和一个空的粉盒来搭建一个简单的相机。
>
>
>
在 2015 年底的时候，树莓派基金会发布了一个让大家很惊艳的非常小的 [树莓派 Zero](https://www.raspberrypi.org/products/raspberry-pi-zero/)。更夸张的是，他们随 MagPi 杂志一起 [免费赠送](https://opensource.com/users/node/24776)。我看到这个消息后立即冲出去到处找报刊亭，直到我在这一地区的某处找到最后两份。实际上我还没有想好如何去使用它们，但是我知道，因为它们非常小，所以，它们可以做很多全尺寸树莓派没法做的一些项目。
*从 MagPi 杂志上获得的树莓派 Zero。CC BY-SA.4.0。*
因为我对天文摄影非常感兴趣，我以前还改造过一台微软出的 LifeCam Cinema 高清网络摄像头，拆掉了它的外壳、镜头、以及红外滤镜，露出了它的 [CCD 芯片](https://en.wikipedia.org/wiki/Charge-coupled_device)。我把它定制为我的 Celestron 天文望远镜的目镜。用它我捕获到了令人难以置信的木星照片、月球上的陨石坑、以及太阳黑子的特写镜头（使用了适当的 Baader 安全保护膜）。
在那之前，我甚至还在我的使用胶片的 SLR 摄像机上，通过在镜头盖（这个盖子就是在摄像机上没有安装镜头时，用来保护摄像机的内部元件的那个盖子）上钻一个小孔来变成一个 [针孔摄像机](https://en.wikipedia.org/wiki/Pinhole_camera)，将这个钻了小孔的盖子，盖到一个汽水罐上切下来的小圆盘上，以提供一个针孔。碰巧有一天，这个放在我的桌子上的针孔镜头盖被改成了用于天文摄像的网络摄像头。我很好奇这个网络摄像头是否有从针孔盖子后面捕获低照度图像的能力。我花了一些时间使用 [GNOME Cheese](https://help.gnome.org/users/cheese/stable/) 应用程序，去验证这个针孔摄像头确实是个可行的创意。
自从有了这个想法，我就有了树莓派 Zero 的一个用法！针孔摄像机一般都非常小，除了曝光时间和胶片的 ISO 速率外，一般都不提供其它的控制选项。数字摄像机就不一样了，它至少有 20 多个按钮和成百上千的设置菜单。我的数字针孔摄像头的目标是真实反映天文摄像的传统风格，设计一个没有控制选项的极简设备，甚至连曝光时间控制也没有。
用树莓派 Zero、高清网络镜头和空的粉盒设计的数字针孔摄像头，是我设计的 [一系列](https://pinholemiscellany.berrange.com/) 针孔摄像头的 [第一个项目](https://pinholemiscellany.berrange.com/motivation/m-arcturus/)。现在，我们开始来制作它。
### 硬件
因为我手头已经有了一个树莓派 Zero，为完成这个项目我还需要一个网络摄像头。这个树莓派 Zero 在英国的零售价是 4 英磅，这个项目其它部件的价格，我希望也差不多是这样的价格水平。花费 30 英磅买来的摄像头安装在一个 4 英磅的计算机主板上，让我感觉有些不平衡。显而易见的答案是前往一个知名的拍卖网站上，去找到一些二手的网络摄像头。不久之后，我仅花费了 1 英磅再加一些运费，获得了一个普通的高清摄像头。之后，在 Fedora 上做了一些测试操作，以确保它是可用正常使用的，我拆掉了它的外壳，以检查它的电子元件的大小是否适合我的项目。
*Hercules DualPix 高清网络摄像头，它将被解剖以提取它的电路板和 CCD 图像传感器。CC BY-SA 4.0.*
接下来，我需要一个安放摄像头的外壳。树莓派 Zero 电路板大小仅仅为 65mm x 30mm x 5mm。虽然网络摄像头的 CCD 芯片周围有一个用来安装镜头的塑料支架，但是，实际上它的电路板尺寸更小。我在家里找了一圈，希望能够找到一个适合盛放这两个极小的电路板的容器。最后，我发现我妻子的粉盒足够去安放树莓派的电路板。稍微做一些小调整，似乎也可以将网络摄像头的电路板放进去。
*变成我的针孔摄像头外壳的粉盒。CC BY-SA 4.0.*
我拆掉了网络摄像头外壳上的一些螺丝，取出了它的内部元件。网络摄像头外壳的大小反映了它的电路板的大小或 CCD 的位置。我很幸运，这个网络摄像头很小而且它的电路板的布局也很方便。因为我要做一个针孔摄像头，我需要取掉镜头，露出 CCD 芯片。
它的塑料外壳大约有 1 厘米高，它太高了没有办法放进粉盒里。我拆掉了电路板后面的螺丝，将它完全拆开，我认为将它放在盒子里有助于阻挡从缝隙中来的光线，因此，我用一把工艺刀将它修改成 4 毫米高，然后将它重新安装。我折弯了 LED 的支脚以降低它的高度。最后，我切掉了安装麦克风的塑料管，因为我不想采集声音。
*取下镜头以后，就可以看到裸露的 CCD 芯片了。圆柱形的塑料柱将镜头固定在合适的位置上，并阻挡 LED 光进入镜头破坏图像。CC BY-SA 4.0*
网络摄像头有一个很长的带全尺寸插头的 USB 线缆，而树莓派 Zero 使用的是一个 Micro-USB 插座，因此，我需要一个 USB 转 Micro-USB 的适配器。但是，使用适配器插入，这个树莓派将放不进这个粉盒中，更不用说还有将近一米长的 USB 线缆。因此，我用刀将 Micro-USB 适配器削开，切掉了它的 USB 插座并去掉这些塑料，露出连接到 Micro-USB 插头上的金属材料。同时也把网络摄像头的 USB 电缆切到大约 6 厘米长，并剥掉裹在它外面的锡纸，露出它的四根电线。我把它们直接焊接到 Micro-USB 插头上。现在网络摄像头可以插入到树莓派 Zero 上了，并且电线也可以放到粉盒中了。
*网络摄像头使用的 Micro-USB 插头已经剥掉了线，并直接焊接到触点上。这个插头现在插入到树莓派 Zero 后大约仅高出树莓派 1 厘米。CC BY-SA 4.0*
最初，我认为到此为止，已经全部完成了电子设计部分，但是在测试之后，我意识到，如果摄像头没有捕获图像或者甚至没有加电我都不知道。我决定使用树莓派的 GPIO 针脚去驱动 LED 指示灯。一个黄色的 LED 表示网络摄像头控制软件已经运行，而一个绿色的 LED 表示网络摄像头正在捕获图像。我在 BCM 的 17 号和 18 号针脚上各自串接一个 300 欧姆的电阻，并将它们各自连接到 LED 的正极上，然后将 LED 的负极连接到一起并接入到公共地针脚上。
*LED 使用一个 300 欧姆的电阻连接到 GPIO 的 BCM 17 号和 BCM 18 号针脚上，负极连接到公共地针脚。CC BY-SA 4.0.*
接下来，该去修改粉盒了。首先，我去掉了卡在粉盒上的托盘以腾出更多的空间，并且用刀将连接处切开。我打算在一个便携式充电宝上运行树莓派 Zero，充电宝肯定是放不到这个盒子里面，因此，我挖了一个孔，这样就可以引出 USB 连接头。LED 的光需要能够从盒子外面看得见，因此，我在盖子上钻了两个 3 毫米的小孔。
然后，我使用一个 6 毫米的钻头在盖子的底部中间处钻了一个孔，并找了一个薄片盖在它上面，然后用针在它的中央扎了一个小孔。一定要确保针尖很细，因为如果插入整个针会使孔太大。我使用干/湿砂纸去打磨这个针孔，以让它更光滑，然后从另一面再次打孔，再强调一次仅使用针尖。使用针孔摄像头的目的是为了得到一个规则的、没有畸形或凸起的圆孔，并且勉强让光通过。孔越小，图像越锐利。
*带针孔的盒子底部。CC BY-SA 4.0*
剩下的工作就是将这些已经改造完成的设备封装起来。首先我使用蓝色腻子将摄像头的电路板固定在盒子中合适的位置，这样针孔就直接处于 CCD 之上了。使用蓝色腻子的好处是，如果我需要清理污渍（或者如果放错了位置）时，就可以很容易地重新安装 CCD 了。将树莓派 Zero 直接放在摄像头电路板上面。为防止这两个电路板之间可能出现的短路情况，我在树莓派的背面贴了几层防静电胶带。
[树莓派 Zero](https://opensource.com/users/node/34916) 非常适合放到这个粉盒中，并且不需要任何固定，而从小孔中穿出去连接充电宝的 USB 电缆需要将它粘住固定。最后，我将 LED 塞进了前面在盒子上钻的孔中，并用胶水将它们固定住。我在 LED 的针脚之中放了一些防静电胶带，以防止盒子盖上时，它与树莓派电路板接触而发生短路。
*树莓派 Zero 塞入到这个盒子中后，周围的空隙不到 1mm。从盒子中引出的连接到网络摄像头上的 Micro-USB 插头，接下来需要将它连接到充电宝上。CC BY-SA 4.0*
### 软件
当然，计算机硬件离开控制它的软件是不能使用的。树莓派 Zero 同样可以运行全尺寸树莓派能够运行的软件，但是，因为树莓派 Zero 的 CPU 速度比较慢，让它去引导传统的 [Raspbian OS](https://www.raspberrypi.org/downloads/raspbian/) 镜像非常耗时。打开摄像头都要花费差不多一分钟的时间，这样的速度在现实中是没有什么用处的。而且，一个完整的树莓派操作系统对我的这个摄像头项目来说也没有必要。甚至是，我禁用了引导时启动的所有可禁用的服务，启动仍然需要很长的时间。因此，我决定仅使用需要的软件，我将用一个 [U-Boot](https://www.denx.de/wiki/U-Boot) 引导加载器和 Linux 内核。自定义 `init` 二进制文件从 microSD 卡上加载 root 文件系统、读入驱动网络摄像头所需要的内核模块，并将它放在 `/dev` 目录下，然后运行二进制的应用程序。
这个二进制的应用程序是另一个定制的 C 程序，它做的核心工作就是管理摄像头。首先，它等待内核驱动程序去初始化网络摄像头、打开它、以及通过低级的 `v4l ioctl` 调用去初始化它。GPIO 针配置用来通过 `/dev/mem` 寄存器去驱动 LED。
初始化完成之后，摄像头进入一个循环。每个图像捕获循环是摄像头使用缺省配置，以 JPEG 格式捕获一个单一的图像帧、保存这个图像帧到 SD 卡、然后休眠三秒。这个循环持续运行直到断电为止。这已经很完美地实现了我的最初目标，那就是用一个传统的模拟的针孔摄像头设计一个简单的数字摄像头。
定制的用户空间 [代码](https://gitlab.com/berrange/pinholemiscellany/) 在遵守 [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html) 或者更新版许可下自由使用。树莓派 Zero 需要 ARMv6 的二进制文件，因此，我使用了 [QEMU ARM](https://wiki.qemu.org/Documentation/Platforms/ARM) 模拟器在一台 x86\_64 主机上进行编译，它使用了 [Pignus](https://pignus.computer/) 发行版（一个针对 ARMv6 移植/重构建的 Fedora 23 版本）下的工具链，在 `chroot` 环境下进行编译。所有的二进制文件都静态链接了 [glibc](https://www.gnu.org/software/libc/)，因此，它们都是自包含的。我构建了一个定制的 RAMDisk 去包含这些二进制文件和所需的内核模块，并将它拷贝到 SD 卡，这样引导加载器就可以找到它们了。
*最终完成的摄像机完全隐藏在这个粉盒中了。唯一露在外面的东西就是 USB 电缆。CC BY-SA 4.0*
### 照像
软件和硬件已经完成了，是该去验证一下它能做什么了。每个人都熟悉用现代的数字摄像头拍摄的高质量图像，不论它是用专业的 DSLRs 还是移动电话拍的。但是，这个高清的 1280x1024 分辨率的网络摄像头（差不多是一百万像素），在这里可能会让你失望。这个 CCD 从一个光通量极小的针孔中努力捕获图像。网络摄像头自动提升增益和曝光时间来进行补偿，最后的结果是一幅噪点很高的图像。图像的动态范围也非常窄，从一个非常拥挤的柱状图就可以看出来，这可以通过后期处理来拉长它，以得到更真实的亮部和暗部。
在户外阳光充足时捕获的图像达到了最佳效果，因此在室内获得的图像大多数都是不可用的图像。它的 CCD 直径仅有大约 1cm，并且是从一个几毫米的针孔中来捕获图像的，它的视界相当窄。比如，在自拍时，手臂拿着相机尽可能伸长，所获得的图像也就是充满整个画面的人头。最后，图像都是失焦的，所有的针孔摄像机都是这样的。
*在伦敦，大街上的屋顶。CC BY-SA 4.0*
*范堡罗机场的老航站楼。CC BY-SA 4.0*
最初，我只是想使用摄像头去捕获一些静态图像。后面，我降低了循环的延迟时间，从三秒改为一秒，然后用它捕获一段时间内的一系列图像。我使用 [GStreamer](https://gstreamer.freedesktop.org/modules/gst-ffmpeg.html) 将这些图像做成了延时视频。
以下是我创建视频的过程：
*视频是我在某天下班之后，从银行沿着泰晤式河到滑铁卢的画面。以每分钟 40 帧捕获的 1200 帧图像被我制作成了每秒 20 帧的动画。*
---
via: <https://opensource.com/article/18/3/how-build-digital-pinhole-camera-raspberry-pi>
作者：[Daniel Berrange](https://opensource.com/users/berrange) 选题：[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 中一种友好的 find 替代工具
|
Patrick H. Mullins
|
https://opensource.com/article/18/6/friendly-alternative-find
|
fd 命令提供了一种简单直白的搜索 Linux 文件系统的方式。
|
/data/attachment/album/201806/21/100623ti556k1bjomgkc64.jpg.thumb.jpg
|
/data/attachment/album/201806/21/100623ti556k1bjomgkc64.jpg
| true | false | true |
geekpi
| false |
[
"fd",
"find",
"查找"
] |
分享
|
{
"viewnum": 10430,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
fd 命令提供了一种简单直白的搜索 Linux 文件系统的方式。
| 2018-06-21T10:06:29 | 2018-06-21T10:06:29 | 9,767 |
/article-9767-1.html
|
>
> fd 命令提供了一种简单直白的搜索 Linux 文件系统的方式。
>
>
>
[fd](https://github.com/sharkdp/fd) 是一个超快的，基于 [Rust](https://www.rust-lang.org/en-US/) 的 Unix/Linux `find` 命令的替代品。它不提供所有 `find` 的强大功能。但是，它确实提供了足够的功能来覆盖你可能遇到的 80％ 的情况。诸如良好的规划和方便的语法、彩色输出、智能大小写、正则表达式以及并行命令执行等特性使 `fd` 成为一个非常有能力的后继者。
### 安装
进入 [fd](https://github.com/sharkdp/fd) GitHub 页面，查看安装部分。它涵盖了如何在[macOS](https://en.wikipedia.org/wiki/MacOS)、 [Debian/Ubuntu](https://www.ubuntu.com/community/debian) [Red Hat](https://www.redhat.com/en) 和 [Arch Linux](https://www.archlinux.org/) 上安装程序。安装完成后，你可以通过运行帮助来获得所有可用命令行选项的完整概述，通过 `fd -h` 获取简明帮助，或者通过 `fd --help` 获取更详细的帮助。
### 简单搜索
`fd` 旨在帮助你轻松找到文件系统中的文件和文件夹。你可以用 `fd` 带上一个参数执行最简单的搜索，该参数就是你要搜索的任何东西。例如，假设你想要找一个 Markdown 文档，其中包含单词 `services` 作为文件名的一部分：
```
$ fd services
downloads/services.md
```
如果仅带一个参数调用，那么 `fd` 递归地搜索当前目录以查找与莫的参数匹配的任何文件和/或目录。使用内置的 `find` 命令的等效搜索如下所示：
```
$ find . -name 'services'
downloads/services.md
```
如你所见，`fd` 要简单得多，并需要更少的输入。在我心中用更少的输入做更多的事情总是对的。
### 文件和文件夹
您可以使用 `-t` 参数将搜索范围限制为文件或目录，后面跟着代表你要搜索的内容的字母。例如，要查找当前目录中文件名中包含 `services` 的所有文件，可以使用：
```
$ fd -tf services
downloads/services.md
```
以及，找到当前目录中文件名中包含 `services` 的所有目录：
```
$ fd -td services
applications/services
library/services
```
如何在当前文件夹中列出所有带 `.md` 扩展名的文档？
```
$ fd .md
administration/administration.md
development/elixir/elixir_install.md
readme.md
sidebar.md
linux.md
```
从输出中可以看到，`fd` 不仅可以找到并列出当前文件夹中的文件，还可以在子文件夹中找到文件。很简单。
你甚至可以使用 `-H` 参数来搜索隐藏文件：
```
fd -H sessions .
.bash_sessions
```
### 指定目录
如果你想搜索一个特定的目录，这个目录的名字可以作为第二个参数传给 `fd`：
```
$ fd passwd /etc
/etc/default/passwd
/etc/pam.d/passwd
/etc/passwd
```
在这个例子中，我们告诉 `fd` 我们要在 `etc` 目录中搜索 `passwd` 这个单词的所有实例。
### 全局搜索
如果你知道文件名的一部分，但不知道文件夹怎么办？假设你下载了一本关于 Linux 网络管理的书，但你不知道它的保存位置。没有问题：
```
fd Administration /
/Users/pmullins/Documents/Books/Linux/Mastering Linux Network Administration.epub
```
### 总结
`fd` 是 `find` 命令的极好的替代品，我相信你会和我一样发现它很有用。要了解该命令的更多信息，只需浏览手册页。
---
via: <https://opensource.com/article/18/6/friendly-alternative-find>
作者：[Patrick H. Mullins](https://opensource.com/users/pmullins) 选题：[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/) 荣誉推出
|
||
8 个基本的 Docker 容器管理命令
|
Shrikant Lavhate
|
https://kerneltalks.com/virtualization/8-basic-docker-container-management-commands/
|
利用这 8 个命令可以学习 Docker 容器的基本管理方式。这是一个为 Docker 初学者准备的，带有示范命令输出的指南。
|
/data/attachment/album/201806/21/185359izqkkd1d1lc1c1ys.png.thumb.jpg
|
/data/attachment/album/201806/21/185359izqkkd1d1lc1c1ys.png
| true | false | true |
lonaparte
| false |
[
"容器",
"Docker"
] |
容器与云
|
{
"viewnum": 10435,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
利用这 8 个命令可以学习 Docker 容器的基本管理方式。这是一个为 Docker 初学者准备的，带有示范命令输出的指南。
| 2018-06-21T18:53:54 | 2018-06-21T18:53:54 | 9,768 |
/article-9768-1.html
|
>
> 利用这 8 个命令可以学习 Docker 容器的基本管理方式。这是一个为 Docker 初学者准备的，带有示范命令输出的指南。
>
>
>
在这篇文章中，我们将带你学习 8 个基本的 Docker 容器命令，它们操控着 Docker 容器的基本活动，例如 <ruby> 运行 <rt> run </rt></ruby>、 <ruby> 列举 <rt> list </rt></ruby>、 <ruby> 停止 <rt> stop </rt></ruby>、 查看<ruby> 历史纪录 <rt> logs </rt></ruby>、 <ruby> 删除 <rt> delete </rt></ruby> 等等。如果你对 Docker 的概念很陌生，推荐你看看我们的 [介绍指南](https://kerneltalks.com/virtualization/what-is-docker-introduction-guide-to-docker/)，来了解 Docker 的基本内容以及 [如何](https://kerneltalks.com/virtualization/how-to-install-docker-in-linux/) 在 Linux 上安装 Docker。 现在让我们赶快进入要了解的命令：
### 如何运行 Docker 容器？
众所周知，Docker 容器只是一个运行于<ruby> 宿主操作系统 <rt> host OS </rt></ruby>上的应用进程，所以你需要一个镜像来运行它。Docker 镜像以进程的方式运行时就叫做 Docker 容器。你可以加载本地 Docker 镜像，也可以从 Docker Hub 上下载。Docker Hub 是一个提供公有和私有镜像来进行<ruby> 拉取 <rt> pull </rt></ruby>操作的集中仓库。官方的 Docker Hub 位于 [hub.docker.com](https://hub.docker.com/)。 当你指示 Docker 引擎运行容器时，它会首先搜索本地镜像，如果没有找到，它会从 Docker Hub 上拉取相应的镜像。
让我们运行一个 Apache web 服务器的 Docker 镜像，比如 httpd 进程。你需要运行 `docker container run` 命令。旧的命令为 `docker run`， 但后来 Docker 添加了子命令部分，所以新版本支持下列命令：
```
root@kerneltalks # docker container run -d -p 80:80 httpd
Unable to find image 'httpd:latest' locally
latest: Pulling from library/httpd
3d77ce4481b1: Pull complete
73674f4d9403: Pull complete
d266646f40bd: Pull complete
ce7b0dda0c9f: Pull complete
01729050d692: Pull complete
014246127c67: Pull complete
7cd2e04cf570: Pull complete
Digest: sha256:f4610c3a1a7da35072870625733fd0384515f7e912c6223d4a48c6eb749a8617
Status: Downloaded newer image for httpd:latest
c46f2e9e4690f5c28ee7ad508559ceee0160ac3e2b1688a61561ce9f7d99d682
```
Docker 的 `run` 命令将镜像名作为强制参数，另外还有很多可选参数。常用的参数有：
* `-d`：从当前 shell 脱离容器
* `-p X:Y`：绑定容器的端口 Y 到宿主机的端口 X
* `--name`：命名你的容器。如果未指定，它将被赋予随机生成的名字
* `-e`：当启动容器时传递环境编辑及其值
通过以上输出你可以看到，我们将 `httpd` 作为镜像名来运行容器。接着，本地镜像没有找到，Docker 引擎从 Docker Hub 拉取了它。注意，它下载了镜像 `httpd:latest`， 其中 `:` 后面跟着版本号。如果你需要运行特定版本的容器，你可以在镜像名后面注明版本名。如果不提供版本名，Docker 引擎会自动拉取最新的版本。
输出的最后一行显示了你新运行的 httpd 容器的唯一 ID。
### 如何列出所有运行中的 Docker 容器？
现在，你的容器已经运行起来了，你可能想要确认这一点，或者你想要列出你的机器上运行的所有容器。你可以使用 `docker container ls` 命令。在旧的 Docker 版本中，对应的命令为 `docker ps`。
```
root@kerneltalks # docker container ls
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
c46f2e9e4690 httpd "httpd-foreground" 11 minutes ago Up 11 minutes 0.0.0.0:80->80/tcp cranky_cori
```
列出的结果是按列显示的。每一列的值分别为：
1. Container ID ：一开始的几个字符对应你的容器的唯一 ID
2. Image ：你运行容器的镜像名
3. Command ：容器启动后运行的命令
4. Created ：创建时间
5. Status ：容器当前状态
6. Ports ：与宿主端口相连接的端口信息
7. Names ：容器名（如果你没有命名你的容器，那么会随机创建）
### 如何查看 Docker 容器的历史纪录？
在第一步我们使用了 `-d` 参数来将容器，在它一开始运行的时候，就从当前的 shell 中脱离出来。在这种情况下，我们不知道容器里面发生了什么。所以为了查看容器的历史纪录，Docker 提供了 `logs` 命令。它采用容器名称或 ID 作为参数。
```
root@kerneltalks # docker container logs cranky_cori
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 172.17.0.2. Set the 'ServerName' directive globally to suppress this message
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 172.17.0.2. Set the 'ServerName' directive globally to suppress this message
[Thu May 31 18:35:07.301158 2018] [mpm_event:notice] [pid 1:tid 139734285989760] AH00489: Apache/2.4.33 (Unix) configured -- resuming normal operations
[Thu May 31 18:35:07.305153 2018] [core:notice] [pid 1:tid 139734285989760] AH00094: Command line: 'httpd -D FOREGROUND'
```
这里我使用了容器名称作为参数。你可以看到在我们的 httpd 容器中与 Apache 相关的历史纪录。
### 如何确定 Docker 容器的进程？
容器是一个使用宿主资源来运行的进程。这样，你可以在宿主系统的进程表中定位容器的进程。让我们在宿主系统上确定容器进程。
Docker 使用著名的 `top` 命令作为子命令的名称，来查看容器产生的进程。它采用容器的名称或 ID 作为参数。在旧版本的 Docker 中，只可运行 `docker top` 命令。在新版本中，`docker top` 和 `docker container top` 命令都可以生效。
```
root@kerneltalks # docker container top cranky_cori
UID PID PPID C STIME TTY TIME CMD
root 15702 15690 0 18:35 ? 00:00:00 httpd -DFOREGROUND
bin 15729 15702 0 18:35 ? 00:00:00 httpd -DFOREGROUND
bin 15730 15702 0 18:35 ? 00:00:00 httpd -DFOREGROUND
bin 15731 15702 0 18:35 ? 00:00:00 httpd -DFOREGROUND
root@kerneltalks # ps -ef |grep -i 15702
root 15702 15690 0 18:35 ? 00:00:00 httpd -DFOREGROUND
bin 15729 15702 0 18:35 ? 00:00:00 httpd -DFOREGROUND
bin 15730 15702 0 18:35 ? 00:00:00 httpd -DFOREGROUND
bin 15731 15702 0 18:35 ? 00:00:00 httpd -DFOREGROUND
root 15993 15957 0 18:59 pts/0 00:00:00 grep --color=auto -i 15702
```
在第一个输出中，列出了容器产生的进程的列表。它包含了所有细节，包括<ruby> 用户号 <rt> uid </rt></ruby>、<ruby> 进程号 <rt> pid </rt></ruby>，<ruby> 父进程号 <rt> ppid </rt></ruby>、开始时间、命令，等等。这里所有的进程号你都可以在宿主的进程表里搜索到。这就是我们在第二个命令里做得。这证明了容器确实是宿主系统中的进程。
### 如何停止 Docker 容器？
只需要 `stop` 命令！同样，它采用容器名称或 ID 作为参数。
```
root@kerneltalks # docker container stop cranky_cori
cranky_cori
```
### 如何列出停止的或不活动的 Docker 容器？
现在我们停止了我们的容器，这时如果我们使用 `ls` 命令，它将不会出现在列表中。
```
root@kerneltalks # docker container ls
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
```
所以，在这种情况下，如果想要查看停止的或不活动的容器，你需要在 `ls` 命令里同时使用 `-a` 参数。
```
root@kerneltalks # docker container ls -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
c46f2e9e4690 httpd "httpd-foreground" 33 minutes ago Exited (0) 2 minutes ago cranky_cori
```
有了 `-a` 参数，现在我们可以查看已停止的容器。注意这些容器的状态被标注为 <ruby> 已退出 <rt> exited </rt></ruby>。既然容器只是一个进程，那么用“退出”比“停止”更合适！
### 如何（重新）启动 Docker 容器？
现在，我们来启动这个已停止的容器。这和运行一个容器有所区别。当你运行一个容器时，你将启动一个全新的容器。当你启动一个容器时，你将开始一个已经停止并保存了当时运行状态的容器。它将以停止时的状态重新开始运行。
```
root@kerneltalks # docker container start c46f2e9e4690
c46f2e9e4690
root@kerneltalks # docker container ls -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
c46f2e9e4690 httpd "httpd-foreground" 35 minutes ago Up 8 seconds 0.0.0.0:80->80/tcp cranky_cori
```
### 如何移除 Docker 容器？
我们使用 `rm` 命令来移除容器。你不可以移除运行中的容器。移除之前需要先停止容器。你可以使用 `-f` 参数搭配 `rm` 命令来强制移除容器，但并不推荐这么做。
```
root@kerneltalks # docker container rm cranky_cori
cranky_cori
root@kerneltalks # docker container ls -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
```
你看，一旦移除了容器，即使再使用 `ls -a` 命令也查看不到容器了。
---
via: <https://kerneltalks.com/virtualization/8-basic-docker-container-management-commands/>
作者：[Shrikant Lavhate](https://kerneltalks.com) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lonaparte](https://github.com/lonaparte) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
将 DEB 软件包转换成 Arch Linux 软件包
|
Sk
|
https://www.ostechnix.com/convert-deb-packages-arch-linux-packages/
|
AUR 是这个星球上的大型软件存储库，几乎所有的软件都可以在其中使用。 为什么我需要将 DEB 软件包转换为 Arch Linux 软件包？
|
/data/attachment/album/201806/21/190307beac7rzimrane54r.png.thumb.jpg
|
/data/attachment/album/201806/21/190307beac7rzimrane54r.png
| true | false | true |
amwps290
| false |
[
"AUR",
"Arch"
] |
技术
|
{
"viewnum": 19832,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "113.109.111.9",
"message": "debtap 支持打 zstd 包吗",
"username": "来自广东广州的 Chrome 81.0|Windows 10 用户",
"date": "2020-05-08T19:30:10"
}
] |
[] |
AUR 是这个星球上的大型软件存储库，几乎所有的软件都可以在其中使用。 为什么我需要将 DEB 软件包转换为 Arch Linux 软件包？
| 2018-06-21T19:03:05 | 2018-06-21T19:03:05 | 9,769 |
/article-9769-1.html
|
我们已经学会了如何[为多个平台构建包](https://www.ostechnix.com/build-linux-packages-multiple-platforms-easily/)，以及如何从[源代码构建包](https://www.ostechnix.com/build-packages-source-using-checkinstall/)。 今天，我们将学习如何将 DEB 包转换为 Arch Linux 包。 您可能会问，AUR 是这个星球上的大型软件存储库，几乎所有的软件都可以在其中使用。 为什么我需要将 DEB 软件包转换为 Arch Linux 软件包？ 这的确没错！ 但是，由于某些软件包无法编译（封闭源代码软件包），或者由于各种原因（如编译时出错或文件不可用）而无法从 AUR 生成。 或者，开发人员懒得在 AUR 中构建一个包，或者他/她不想创建 AUR 包。 在这种情况下，我们可以使用这种快速但有点粗糙的方法将 DEB 包转换成 Arch Linux 包。
### Debtap - 将 DEB 包转换成 Arch Linux 包
为此，我们将使用名为 “Debtap” 的实用程序。 它代表了 **DEB** **T** o **A** rch （Linux） **P** ackage。 Debtap 在 AUR 中可以使用，因此您可以使用 AUR 辅助工具（如 [Pacaur](https://www.ostechnix.com/install-pacaur-arch-linux/)、[Packer](https://www.ostechnix.com/install-packer-arch-linux-2/) 或 [Yaourt](https://www.ostechnix.com/install-yaourt-arch-linux/) ）来安装它。
使用 pacaur 安装 debtap 运行：
```
pacaur -S debtap
```
使用 Packer 安装：
```
packer -S debtap
```
使用 Yaourt 安装：
```
yaourt -S debtap
```
同时，你的 Arch 系统也应该已经安装好了 `bash`， `binutils` ，`pkgfile` 和 `fakeroot` 包。
在安装 Debtap 和所有上述依赖关系之后，运行以下命令来创建/更新 pkgfile 和 debtap 数据库。
```
sudo debtap -u
```
示例输出是：
```
==> Synchronizing pkgfile database...
:: Updating 6 repos...
download complete: archlinuxfr [ 151.7 KiB 67.5K/s 5 remaining]
download complete: multilib [ 319.5 KiB 36.2K/s 4 remaining]
download complete: core [ 707.7 KiB 49.5K/s 3 remaining]
download complete: testing [ 1716.3 KiB 58.2K/s 2 remaining]
download complete: extra [ 7.4 MiB 109K/s 1 remaining]
download complete: community [ 16.9 MiB 131K/s 0 remaining]
:: download complete in 131.47s < 27.1 MiB 211K/s 6 files >
:: waiting for 1 process to finish repacking repos...
==> Synchronizing debtap database...
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 34.1M 100 34.1M 0 0 206k 0 0:02:49 0:02:49 --:--:-- 180k
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 814k 100 814k 0 0 101k 0 0:00:08 0:00:08 --:--:-- 113k
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 120k 100 120k 0 0 61575 0 0:00:02 0:00:02 --:--:-- 52381
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 35.4M 100 35.4M 0 0 175k 0 0:03:27 0:03:27 --:--:-- 257k
==> Downloading latest virtual packages list...
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 149 0 149 0 0 49 0 --:--:-- 0:00:03 --:--:-- 44
100 11890 0 11890 0 0 2378 0 --:--:-- 0:00:05 --:--:-- 8456
==> Downloading latest AUR packages list...
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 264k 0 264k 0 0 30128 0 --:--:-- 0:00:09 --:--:-- 74410
==> Generating base group packages list...
==> All steps successfully completed!
```
你至少需要运行上述命令一次。
现在是时候开始转换包了。
比如说要使用 debtap 转换包 Quadrapassel，你可以这样做：
```
debtap quadrapassel_3.22.0-1.1_arm64.deb
```
上述的命令会将 DEB 包文件转换为 Arch Linux 包。你需要输入包的维护者和许可证，输入他们，然后按下回车键就可以开始转换了。
包转换的过程可能依赖于你的 CPU 的速度从几秒到几分钟不等。喝一杯咖啡等一等。
示例输出：
```
==> Extracting package data...
==> Fixing possible directories structure differencies...
==> Generating .PKGINFO file...
:: Enter Packager name:
quadrapassel
:: Enter package license (you can enter multiple licenses comma separated):
GPL
*** Creation of .PKGINFO file in progress. It may take a few minutes, please wait...
Warning: These dependencies (depend = fields) could not be translated into Arch Linux packages names:
gsettings-backend
==> Checking and generating .INSTALL file (if necessary)...
:: If you want to edit .PKGINFO and .INSTALL files (in this order), press (1) For vi (2) For nano (3) For default editor (4) For a custom editor or any other key to continue:
==> Generating .MTREE file...
==> Creating final package...
==> Package successfully created!
==> Removing leftover files...
```
**注**：Quadrapassel 在 Arch Linux 官方的软件库中早已可用，我只是用它来说明一下。
如果在包转化的过程中，你不想回答任何问题，使用 `-q` 略过除了编辑元数据之外的所有问题。
```
debtap -q quadrapassel_3.22.0-1.1_arm64.deb
```
为了略过所有的问题（不推荐），使用 `-Q`。
```
debtap -Q quadrapassel_3.22.0-1.1_arm64.deb
```
转换完成后，您可以使用 `pacman` 在 Arch 系统中安装新转换的软件包，如下所示。
```
sudo pacman -U <package-name>
```
显示帮助文档，使用 `-h`：
```
$ debtap -h
Syntax: debtap [options] package_filename
Options:
-h --h -help --help Prints this help message
-u --u -update --update Update debtap database
-q --q -quiet --quiet Bypass all questions, except for editing metadata file(s)
-Q --Q -Quiet --Quiet Bypass all questions (not recommended)
-s --s -pseudo --pseudo Create a pseudo-64-bit package from a 32-bit .deb package
-w --w -wipeout --wipeout Wipeout versions from all dependencies, conflicts etc.
-p --p -pkgbuild --pkgbuild Additionally generate a PKGBUILD file
-P --P -Pkgbuild --Pkgbuild Generate a PKGBUILD file only
```
这就是现在要讲的。希望这个工具有所帮助。如果你发现我们的指南有用，请花一点时间在你的社交、专业网络分享并支持我们!
更多的好东西来了。请继续关注!
干杯!
---
via: <https://www.ostechnix.com/convert-deb-packages-arch-linux-packages/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[amwps290](https://github.com/amwps290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
怎么去转换任何系统调用为一个事件：对 eBPF 内核探针的介绍
|
Jean-tiare Le Bigot
|
https://blog.yadutaf.fr/2016/03/30/turn-any-syscall-into-event-introducing-ebpf-kernel-probes/
|
在最新的 Linux 内核（>=4.4）中使用 eBPF，你可以将任何内核函数调用转换为一个带有任意数据的用户空间事件。这通过 bcc 来做很容易。这个探针是用 C 语言写的，而数据是由 Python 来处理的。
|
/data/attachment/album/201806/22/144303vbnrgmmynvhcwczl.jpg.thumb.jpg
|
/data/attachment/album/201806/22/144303vbnrgmmynvhcwczl.jpg
| true | false | true |
qhwdw
| false |
[
"eBPF",
"内核"
] |
技术
|
{
"viewnum": 6110,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在最新的 Linux 内核（>=4.4）中使用 eBPF，你可以将任何内核函数调用转换为一个带有任意数据的用户空间事件。这通过 bcc 来做很容易。这个探针是用 C 语言写的，而数据是由 Python 来处理的。
| 2018-06-22T14:43:21 | 2018-06-22T14:43:21 | 9,770 |
/article-9770-1.html
|
长文预警：在最新的 Linux 内核（>=4.4）中使用 eBPF，你可以将任何内核函数调用转换为一个带有任意数据的用户空间事件。这通过 bcc 来做很容易。这个探针是用 C 语言写的，而数据是由 Python 来处理的。
如果你对 eBPF 或者 Linux 跟踪不熟悉，那你应该好好阅读一下整篇文章。本文尝试逐步去解决我在使用 bcc/eBPF 时遇到的困难，以为您节省我在搜索和挖掘上花费的时间。
### 在 Linux 的世界中关于推送与轮询的一个看法
当我开始在容器上工作的时候，我想知道我们怎么基于一个真实的系统状态去动态更新一个负载均衡器的配置。一个通用的策略是这样做的，无论什么时候只要一个容器启动，容器编排器触发一个负载均衡配置更新动作，负载均衡器去轮询每个容器，直到它的健康状态检查结束。它也许只是简单进行 “SYN” 测试。
虽然这种配置方式可以有效工作，但是它的缺点是你的负载均衡器为了让一些系统变得可用需要等待，而不是 … 让负载去均衡。
可以做的更好吗？
当你希望在一个系统中让一个程序对一些变化做出反应，这里有两种可能的策略。程序可以去 *轮询* 系统去检测变化，或者，如果系统支持，系统可以 *推送* 事件并且让程序对它作出反应。你希望去使用推送还是轮询取决于上下文环境。一个好的经验法则是，基于处理时间的考虑，如果事件发生的频率较低时使用推送，而当事件发生的较快或者让系统变得不可用时切换为轮询。例如，一般情况下，网络驱动程序将等待来自网卡的事件，但是，像 dpdk 这样的框架对事件将主动轮询网卡，以达到高吞吐低延迟的目的。
理想状态下，我们将有一些内核接口告诉我们：
>
> * “容器管理器，你好，我刚才为容器 *servestaticfiles* 的 Nginx-ware 创建了一个套接字，或许你应该去更新你的状态？
> * “好的，操作系统，感谢你告诉我这个事件”
>
>
>
虽然 Linux 有大量的接口去处理事件，对于文件事件高达 3 个，但是没有专门的接口去得到套接字事件提示。你可以得到路由表事件、邻接表事件、连接跟踪事件、接口变化事件。唯独没有套接字事件。或者，也许它深深地隐藏在一个 Netlink 接口中。
理想情况下，我们需要一个做这件事的通用方法，怎么办呢？
### 内核跟踪和 eBPF，一些它们的历史
直到最近，内核跟踪的唯一方式是对内核上打补丁或者借助于 SystemTap。[SytemTap](https://en.wikipedia.org/wiki/SystemTap) 是一个 Linux 系统跟踪器。简单地说，它提供了一个 DSL，编译进内核模块，然后被内核加载运行。除了一些因安全原因禁用动态模块加载的生产系统之外，包括在那个时候我开发的那一个。另外的方式是为内核打一个补丁程序以触发一些事件，可能是基于 netlink。但是这很不方便。深入内核所带来的缺点包括 “有趣的” 新 “特性” ，并增加了维护负担。
从 Linux 3.15 开始给我们带来了希望，它支持将任何可跟踪内核函数可安全转换为用户空间事件。在一般的计算机科学中，“安全” 是指 “某些虚拟机”。在此也不例外。自从 Linux 2.1.75 在 1997 年正式发行以来，Linux 已经有这个多好年了。但是，它被称为伯克利包过滤器，或简称 BPF。正如它的名字所表达的那样，它最初是为 BSD 防火墙开发的。它仅有两个寄存器，并且它仅允许向前跳转，这意味着你不能使用它写一个循环（好吧，如果你知道最大迭代次数并且去手工实现它，你也可以实现循环）。这一点保证了程序总会终止，而不会使系统处于挂起的状态。还不知道它有什么用？你用过 iptables 的话，其作用就是 [CloudFlare 的 DDos 防护的基础](https://blog.cloudflare.com/bpf-the-forgotten-bytecode/)。
好的，因此，随着 Linux 3.15，[BPF 被扩展](https://blog.yadutaf.fr/2016/03/30/turn-any-syscall-into-event-introducing-ebpf-kernel-probes/TODO) 成为了 eBPF。对于 “扩展的” BPF。它从两个 32 位寄存器升级到 10 个 64 位寄存器，并且增加了它们之间向后跳转的特性。然后它 [在 Linux 3.18 中被进一步扩展](https://lwn.net/Articles/604043/)，并将被移出网络子系统中，并且增加了像映射（map）这样的工具。为保证安全，它 [引进了一个检查器](http://lxr.free-electrons.com/source/kernel/bpf/verifier.c#L21)，它验证所有的内存访问和可能的代码路径。如果检查器不能保证代码会终止在固定的边界内，它一开始就要拒绝程序的插入。
关于它的更多历史，可以看 [Oracle 的关于 eBPF 的一个很棒的演讲](http://events.linuxfoundation.org/sites/events/files/slides/tracing-linux-ezannoni-linuxcon-ja-2015_0.pdf)。
让我们开始吧！
### 来自 inet\_listen 的问候
因为写一个汇编程序并不是件十分容易的任务，甚至对于很优秀的我们来说，我将使用 [bcc](https://github.com/iovisor/bcc)。bcc 是一个基于 LLVM 的工具集，并且用 Python 抽象了底层机制。探针是用 C 写的，并且返回的结果可以被 Python 利用，可以很容易地写一些不算简单的应用程序。
首先安装 bcc。对于一些示例，你可能会需要使用一个最新的内核版本（>= 4.4）。如果你想亲自去尝试一下这些示例，我强烈推荐你安装一台虚拟机， *而不是* 一个 Docker 容器。你不能在一个容器中改变内核。作为一个非常新的很活跃的项目，其安装教程高度依赖于平台/版本。你可以在 <https://github.com/iovisor/bcc/blob/master/INSTALL.md> 上找到最新的教程。
现在，我希望不管在什么时候，只要有任何程序开始监听 TCP 套接字，我将得到一个事件。当我在一个 `AF_INET` + `SOCK_STREAM` 套接字上调用一个 `listen()` 系统调用时，其底层的内核函数是 [`inet_listen`](http://lxr.free-electrons.com/source/net/ipv4/af_inet.c#L194)。我将从钩在一个“Hello World” `kprobe` 的入口上开始。
```
from bcc import BPF
# Hello BPF Program
bpf_text = """
#include <net/inet_sock.h>
#include <bcc/proto.h>
// 1. Attach kprobe to "inet_listen"
int kprobe__inet_listen(struct pt_regs *ctx, struct socket *sock, int backlog)
{
bpf_trace_printk("Hello World!\\n");
return 0;
};
"""
# 2. Build and Inject program
b = BPF(text=bpf_text)
# 3. Print debug output
while True:
print b.trace_readline()
```
这个程序做了三件事件：
1. 它通过命名惯例来附加到一个内核探针上。如果函数被调用，比如说 `my_probe` 函数，它会使用 `b.attach_kprobe("inet_listen", "my_probe")` 显式附加。
2. 它使用 LLVM 新的 BPF 后端来构建程序。使用（新的） `bpf()` 系统调用去注入结果字节码，并且按匹配的命名惯例自动附加探针。
3. 从内核管道读取原生输出。
注意：eBPF 的后端 LLVM 还很新。如果你认为你遇到了一个 bug，你也许应该去升级。
注意到 `bpf_trace_printk` 调用了吗？这是一个内核的 `printk()` 精简版的调试函数。使用时，它产生跟踪信息到一个专门的内核管道 `/sys/kernel/debug/tracing/trace_pipe` 。就像名字所暗示的那样，这是一个管道。如果多个读取者在读取它，仅有一个将得到一个给定的行。对生产系统来说，这样是不合适的。
幸运的是，Linux 3.19 引入了对消息传递的映射，以及 Linux 4.4 带来了对任意 perf 事件的支持。在这篇文章的后面部分，我将演示基于 perf 事件的方式。
```
# From a first console
ubuntu@bcc:~/dev/listen-evts$ sudo /python tcv4listen.py
nc-4940 [000] d... 22666.991714: : Hello World!
# From a second console
ubuntu@bcc:~$ nc -l 0 4242
^C
```
搞定！
### 抓取 backlog
现在，让我们输出一些很容易访问到的数据，比如说 “backlog”。backlog 是正在建立 TCP 连接的、即将被 `accept()` 的连接的数量。
只要稍微调整一下 `bpf_trace_printk`：
```
bpf_trace_printk("Listening with with up to %d pending connections!\\n", backlog);
```
如果你用这个 “革命性” 的改善重新运行这个示例，你将看到如下的内容：
```
(bcc)ubuntu@bcc:~/dev/listen-evts$ sudo python tcv4listen.py
nc-5020 [000] d... 25497.154070: : Listening with with up to 1 pending connections!
```
`nc` 是个单连接程序，因此，其 backlog 是 1。而 Nginx 或者 Redis 上的 backlog 将在这里输出 128 。但是，那是另外一件事。
简单吧？现在让我们获取它的端口。
### 抓取端口和 IP
正在研究的 `inet_listen` 来源于内核，我们知道它需要从 `socket` 对象中取得 `inet_sock`。只需要从源头拷贝，然后插入到跟踪器的开始处：
```
// cast types. Intermediate cast not needed, kept for readability
struct sock *sk = sock->sk;
struct inet_sock *inet = inet_sk(sk);
```
端口现在可以按网络字节顺序（就是“从小到大、大端”的顺序）从 `inet->inet_sport` 访问到。很容易吧！因此，我们只需要把 `bpf_trace_printk` 替换为：
```
bpf_trace_printk("Listening on port %d!\\n", inet->inet_sport);
```
然后运行：
```
ubuntu@bcc:~/dev/listen-evts$ sudo /python tcv4listen.py
...
R1 invalid mem access 'inv'
...
Exception: Failed to load BPF program kprobe__inet_listen
```
抛出的异常并没有那么简单，Bcc 现在提升了 *许多*。直到写这篇文章的时候，有几个问题已经被处理了，但是并没有全部处理完。这个错误意味着内核检查器可以证实程序中的内存访问是正确的。看这个显式的类型转换。我们需要一点帮助，以使访问更加明确。我们将使用 `bpf_probe_read` 可信任的函数去读取一个任意内存位置，同时确保所有必要的检查都是用类似这样方法完成的：
```
// Explicit initialization. The "=0" part is needed to "give life" to the variable on the stack
u16 lport = 0;
// Explicit arbitrary memory access. Read it:
// Read into 'lport', 'sizeof(lport)' bytes from 'inet->inet_sport' memory location
bpf_probe_read(&lport, sizeof(lport), &(inet->inet_sport));
```
读取 IPv4 边界地址和它基本上是相同的，使用 `inet->inet_rcv_saddr` 。如果我把这些一起放上去，我们将得到 backlog、端口和边界 IP：
```
from bcc import BPF
# BPF Program
bpf_text = """
#include <net/sock.h>
#include <net/inet_sock.h>
#include <bcc/proto.h>
// Send an event for each IPv4 listen with PID, bound address and port
int kprobe__inet_listen(struct pt_regs *ctx, struct socket *sock, int backlog)
{
// Cast types. Intermediate cast not needed, kept for readability
struct sock *sk = sock->sk;
struct inet_sock *inet = inet_sk(sk);
// Working values. You *need* to initialize them to give them "life" on the stack and use them afterward
u32 laddr = 0;
u16 lport = 0;
// Pull in details. As 'inet_sk' is internally a type cast, we need to use 'bpf_probe_read'
// read: load into 'laddr' 'sizeof(laddr)' bytes from address 'inet->inet_rcv_saddr'
bpf_probe_read(&laddr, sizeof(laddr), &(inet->inet_rcv_saddr));
bpf_probe_read(&lport, sizeof(lport), &(inet->inet_sport));
// Push event
bpf_trace_printk("Listening on %x %d with %d pending connections\\n", ntohl(laddr), ntohs(lport), backlog);
return 0;
};
"""
# Build and Inject BPF
b = BPF(text=bpf_text)
# Print debug output
while True:
print b.trace_readline()
```
测试运行输出的内容像下面这样:
```
(bcc)ubuntu@bcc:~/dev/listen-evts$ sudo python tcv4listen.py
nc-5024 [000] d... 25821.166286: : Listening on 7f000001 4242 with 1 pending connections
```
这证明你的监听是在本地主机上的。因为没有处理为友好的输出，这里的地址以 16 进制的方式显示，但是这是没错的，并且它很酷。
注意：你可能想知道为什么 `ntohs` 和 `ntohl` 可以从 BPF 中被调用，即便它们并不可信。这是因为它们是宏，并且是从 “.h” 文件中来的内联函数，并且，在写这篇文章的时候一个小的 bug 已经 [修复了](https://github.com/iovisor/bcc/pull/453)。
全部达成了，还剩下一些：我们希望获取相关的容器。在一个网络环境中，那意味着我们希望取得网络的命名空间。网络命名空间是一个容器的构建块，它允许它们拥有独立的网络。
### 抓取网络命名空间：被迫引入的 perf 事件
在用户空间中，网络命名空间可以通过检查 `/proc/PID/ns/net` 的目标来确定，它将看起来像 `net:[4026531957]` 这样。方括号中的数字是网络空间的 inode 编号。这就是说，我们可以通过 `/proc` 来取得，但是这并不是好的方式，我们或许可以临时处理时用一下。我们可以从内核中直接抓取 inode 编号。幸运的是，那样做很容易：
```
// Create an populate the variable
u32 netns = 0;
// Read the netns inode number, like /proc does
netns = sk->__sk_common.skc_net.net->ns.inum;
```
很容易！而且它做到了。
但是，如果你看到这里，你可能猜到那里有一些错误。它在：
```
bpf_trace_printk("Listening on %x %d with %d pending connections in container %d\\n", ntohl(laddr), ntohs(lport), backlog, netns);
```
如果你尝试去运行它，你将看到一些令人难解的错误信息：
```
(bcc)ubuntu@bcc:~/dev/listen-evts$ sudo python tcv4listen.py
error: in function kprobe__inet_listen i32 (%struct.pt_regs*, %struct.socket*, i32)
too many args to 0x1ba9108: i64 = Constant<6>
```
clang 想尝试去告诉你的是 “嗨，哥们，`bpf_trace_printk` 只能带四个参数，你刚才给它传递了 5 个”。在这里我不打算继续追究细节了，但是，那是 BPF 的一个限制。如果你想继续去深入研究，[这里是一个很好的起点](http://lxr.free-electrons.com/source/kernel/trace/bpf_trace.c#L86)。
去修复它的唯一方式是 … 停止调试并且准备投入使用。因此，让我们开始吧（确保运行在内核版本为 4.4 的 Linux 系统上）。我将使用 perf 事件，它支持传递任意大小的结构体到用户空间。另外，只有我们的读者可以获得它，因此，多个没有关系的 eBPF 程序可以并发产生数据而不会出现问题。
去使用它吧，我们需要：
1. 定义一个结构体
2. 声明事件
3. 推送事件
4. 在 Python 端重新声明事件（这一步以后将不再需要）
5. 处理和格式化事件
这看起来似乎很多，其它并不多，看下面示例：
```
// At the begining of the C program, declare our event
struct listen_evt_t {
u64 laddr;
u64 lport;
u64 netns;
u64 backlog;
};
BPF_PERF_OUTPUT(listen_evt);
// In kprobe__inet_listen, replace the printk with
struct listen_evt_t evt = {
.laddr = ntohl(laddr),
.lport = ntohs(lport),
.netns = netns,
.backlog = backlog,
};
listen_evt.perf_submit(ctx, &evt, sizeof(evt));
```
Python 端将需要一点更多的工作：
```
# We need ctypes to parse the event structure
import ctypes
# Declare data format
class ListenEvt(ctypes.Structure):
_fields_ = [
("laddr", ctypes.c_ulonglong),
("lport", ctypes.c_ulonglong),
("netns", ctypes.c_ulonglong),
("backlog", ctypes.c_ulonglong),
]
# Declare event printer
def print_event(cpu, data, size):
event = ctypes.cast(data, ctypes.POINTER(ListenEvt)).contents
print("Listening on %x %d with %d pending connections in container %d" % (
event.laddr,
event.lport,
event.backlog,
event.netns,
))
# Replace the event loop
b["listen_evt"].open_perf_buffer(print_event)
while True:
b.kprobe_poll()
```
来试一下吧。在这个示例中，我有一个 redis 运行在一个 Docker 容器中，并且 `nc` 运行在主机上：
```
(bcc)ubuntu@bcc:~/dev/listen-evts$ sudo python tcv4listen.py
Listening on 0 6379 with 128 pending connections in container 4026532165
Listening on 0 6379 with 128 pending connections in container 4026532165
Listening on 7f000001 6588 with 1 pending connections in container 4026531957
```
### 结束语
现在，所有事情都可以在内核中使用 eBPF 将任何函数的调用设置为触发事件，并且你看到了我在学习 eBPF 时所遇到的大多数的问题。如果你希望去看这个工具的完整版本，像 IPv6 支持这样的一些技巧，看一看 <https://github.com/iovisor/bcc/blob/master/tools/solisten.py>。它现在是一个官方的工具，感谢 bcc 团队的支持。
更进一步地去学习，你可能需要去关注 Brendan Gregg 的博客，尤其是 [关于 eBPF 映射和统计的文章](http://www.brendangregg.com/blog/2015-05-15/ebpf-one-small-step.html)。他是这个项目的主要贡献人之一。
---
via: <https://blog.yadutaf.fr/2016/03/30/turn-any-syscall-into-event-introducing-ebpf-kernel-probes/>
作者：[Jean-Tiare Le Bigot](https://blog.yadutaf.fr/about) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 中使用 parted 对磁盘分区
|
Daniel Oh
|
https://opensource.com/article/18/6/how-partition-disk-linux
|
学习如何在 Linux 中使用 parted 命令来对存储设备分区。
|
/data/attachment/album/201806/22/233843lzn6br133ebn1oww.jpg.thumb.jpg
|
/data/attachment/album/201806/22/233843lzn6br133ebn1oww.jpg
| true | false | true |
amwps290
| false |
[
"分区",
"parted"
] |
技术
|
{
"viewnum": 20065,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
学习如何在 Linux 中使用 parted 命令来对存储设备分区。
| 2018-06-22T23:38:51 | 2018-06-22T23:38:51 | 9,771 |
/article-9771-1.html
|
>
> 学习如何在 Linux 中使用 parted 命令来对存储设备分区。
>
>
>
在 Linux 中创建和删除分区是一种常见的操作，因为存储设备（如硬盘驱动器和 USB 驱动器）在使用之前必须以某种方式进行结构化。在大多数情况下，大型存储设备被分为称为<ruby> 分区 <rt> partition </rt></ruby>的独立部分。分区操作允许您将硬盘分割成独立的部分，每个部分都像是一个硬盘驱动器一样。如果您运行多个操作系统，那么分区是非常有用的。
在 Linux 中有许多强大的工具可以创建、删除和操作磁盘分区。在本文中，我将解释如何使用 `parted` 命令，这对于大型磁盘设备和许多磁盘分区尤其有用。`parted` 与更常见的 `fdisk` 和 `cfdisk` 命令之间的区别包括:
* **GPT 格式：**`parted` 命令可以创建全局惟一的标识符分区表 [GPT](https://en.wikipedia.org/wiki/GUID_Partition_Table)，而 `fdisk` 和 `cfdisk` 则仅限于 DOS 分区表。
* **更大的磁盘：** DOS 分区表可以格式化最多 2TB 的磁盘空间，尽管在某些情况下最多可以达到 16TB。然而，一个 GPT 分区表可以处理最多 8ZiB 的空间。
* **更多的分区：** 使用主分区和扩展分区，DOS 分区表只允许 16 个分区。在 GPT 中，默认情况下您可以得到 128 个分区，并且可以选择更多的分区。
* **可靠性：** 在 DOS 分区表中，只保存了一份分区表备份，在 GPT 中保留了两份分区表的备份（在磁盘的起始和结束部分），同时 GPT 还使用了 [CRC](https://en.wikipedia.org/wiki/Cyclic_redundancy_check) 校验和来检查分区表的完整性，在 DOS 分区中并没有实现。
由于现在的磁盘更大，需要更灵活地使用它们，建议使用 `parted` 来处理磁盘分区。大多数时候，磁盘分区表是作为操作系统安装过程的一部分创建的。在向现有系统添加存储设备时，直接使用 `parted` 命令非常有用。
### 尝试一下 parted
下面解释了使用 `parted` 命令对存储设备进行分区的过程。为了尝试这些步骤，我强烈建议使用一块全新的存储设备或一种您不介意将其内容删除的设备。
#### 1、列出分区
使用 `parted -l` 来标识你要进行分区的设备。一般来说，第一个硬盘 （`/dev/sda` 或 `/dev/vda` ）保存着操作系统， 因此要寻找另一个磁盘，以找到你想要分区的磁盘 (例如，`/dev/sdb`、`/dev/sdc`、 `/dev/vdb`、`/dev/vdc` 等)。
```
$ sudo parted -l
[sudo] password for daniel:
Model: ATA RevuAhn_850X1TU5 (scsi)
Disk /dev/vdc: 512GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 1049kB 525MB 524MB primary ext4 boot
2 525MB 512GB 512GB primary lvm
```
#### 2、打开存储设备
使用 `parted` 选中您要分区的设备。在这里例子中，是虚拟系统上的第三个磁盘（`/dev/vdc`）。指明你要使用哪一个设备非常重要。 如果你仅仅输入了 `parted` 命令而没有指定设备名字， 它会**随机**选择一个设备进行操作。
```
$ sudo parted /dev/vdc
GNU Parted 3.2
Using /dev/vdc
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted)
```
#### 3、 设定分区表
设置分区表为 GPT ，然后输入 `Yes` 开始执行。
```
(parted) mklabel gpt
Warning: the existing disk label on /dev/vdc will be destroyed
and all data on this disk will be lost. Do you want to continue?
Yes/No? Yes
```
`mklabel` 和 `mktable` 命令用于相同的目的（在存储设备上创建分区表）。支持的分区表有：aix、amiga、bsd、dvh、gpt、mac、ms-dos、pc98、sun 和 loop。记住 `mklabel` 不会创建一个分区，而是创建一个分区表。
#### 4、 检查分区表
查看存储设备信息:
```
(parted) print
Model: Virtio Block Device (virtblk)
Disk /dev/vdc: 1396MB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:
Number Start End Size File system Name Flags
```
#### 5、 获取帮助
为了知道如何去创建一个新分区，输入： `(parted) help mkpart` 。
```
(parted) help mkpart
mkpart PART-TYPE [FS-TYPE] START END make a partition
PART-TYPE is one of: primary, logical, extended
FS-TYPE is one of: btrfs, nilfs2, ext4, ext3, ext2, fat32, fat16, hfsx, hfs+, hfs, jfs, swsusp,
linux-swap(v1), linux-swap(v0), ntfs, reiserfs, hp-ufs, sun-ufs, xfs, apfs2, apfs1, asfs, amufs5,
amufs4, amufs3, amufs2, amufs1, amufs0, amufs, affs7, affs6, affs5, affs4, affs3, affs2, affs1,
affs0, linux-swap, linux-swap(new), linux-swap(old)
START and END are disk locations, such as 4GB or 10%. Negative values count from the end of the
disk. For example, -1s specifies exactly the last sector.
'mkpart' makes a partition without creating a new file system on the partition. FS-TYPE may be
specified to set an appropriate partition ID.
```
#### 6、 创建分区
为了创建一个新分区（在这个例子中，分区 0 有 1396MB），输入下面的命令：
```
(parted) mkpart primary 0 1396MB
Warning: The resulting partition is not properly aligned for best performance
Ignore/Cancel? I
(parted) print
Model: Virtio Block Device (virtblk)
Disk /dev/vdc: 1396MB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags:
Number Start End Size File system Name Flags
1 17.4kB 1396MB 1396MB primary
```
文件系统类型（`fstype`）并不是在 `/dev/vdc1`上创建 ext4 文件系统。 DOS 分区表的分区类型是<ruby> 主分区 <rt> primary </rt></ruby>、<ruby> 逻辑分区 <rt> logical </rt></ruby>和<ruby> 扩展分区 <rt> extended </rt></ruby>。 在 GPT 分区表中，分区类型用作分区名称。 在 GPT 下必须提供分区名称；在上例中，`primary` 是分区名称，而不是分区类型。
#### 7、 保存退出
当你退出 `parted` 时，修改会自动保存。退出请输入如下命令：
```
(parted) quit
Information: You may need to update /etc/fstab.
$
```
### 谨记
当您添加新的存储设备时，请确保在开始更改其分区表之前确定正确的磁盘。如果您错误地更改了包含计算机操作系统的磁盘分区，会使您的系统无法启动。
---
via: <https://opensource.com/article/18/6/how-partition-disk-linux>
作者：[Daniel Oh](https://opensource.com/users/daniel-oh) 选题：[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/) 荣誉推出
|
||
在 Linux 上复制和重命名文件
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3276349/linux/copying-and-renaming-files-on-linux.html
|
cp 和 mv 之外，在 Linux 上有更多的复制和重命名文件的命令。试试这些命令或许会惊艳到你，并能节省一些时间。
|
/data/attachment/album/201806/23/000659kxm3mrtm92x419rt.jpg.thumb.jpg
|
/data/attachment/album/201806/23/000659kxm3mrtm92x419rt.jpg
| true | false | true |
geekpi
| false |
[
"cp",
"mv"
] |
技术
|
{
"viewnum": 35134,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
cp 和 mv 之外，在 Linux 上有更多的复制和重命名文件的命令。试试这些命令或许会惊艳到你，并能节省一些时间。
| 2018-06-23T00:06:57 | 2018-06-23T00:06:57 | 9,772 |
/article-9772-1.html
|
>
> cp 和 mv 之外，在 Linux 上有更多的复制和重命名文件的命令。试试这些命令或许会惊艳到你，并能节省一些时间。
>
>
>
Linux 用户数十年来一直在使用简单的 `cp` 和 `mv` 命令来复制和重命名文件。这些命令是我们大多数人首先学到的，每天可能有数百万人在使用它们。但是还有其他技术、方便的方法和另外的命令，这些提供了一些独特的选项。
首先，我们来思考为什么你想要复制一个文件。你可能需要在另一个位置使用同一个文件，或者因为你要编辑该文件而需要一个副本，并且希望确保备有便利的备份以防万一需要恢复原始文件。这样做的显而易见的方式是使用像 `cp myfile myfile-orig` 这样的命令。
但是，如果你想复制大量的文件，那么这个策略可能就会变得很老。更好的选择是：
* 在开始编辑之前，使用 `tar` 创建所有要备份的文件的存档。
* 使用 `for` 循环来使备份副本更容易。
使用 `tar` 的方式很简单。对于当前目录中的所有文件，你可以使用如下命令：
```
$ tar cf myfiles.tar *
```
对于一组可以用模式标识的文件，可以使用如下命令：
```
$ tar cf myfiles.tar *.txt
```
在每种情况下，最终都会生成一个 `myfiles.tar` 文件，其中包含目录中的所有文件或扩展名为 .txt 的所有文件。
一个简单的循环将允许你使用修改后的名称来制作备份副本：
```
$ for file in *
> do
> cp $file $file-orig
> done
```
当你备份单个文件并且该文件恰好有一个长名称时，可以依靠使用 `tab` 来补全文件名（在输入足够的字母以便唯一标识该文件后点击 `Tab` 键）并使用像这样的语法将 `-orig` 附加到副本的名字后。
```
$ cp file-with-a-very-long-name{,-orig}
```
然后你有一个 `file-with-a-very-long-name` 和一个 `file-with-a-very-long-name-orig`。
### 在 Linux 上重命名文件
重命名文件的传统方法是使用 `mv` 命令。该命令将文件移动到不同的目录，或原地更改其名称，或者同时执行这两个操作。
```
$ mv myfile /tmp
$ mv myfile notmyfile
$ mv myfile /tmp/notmyfile
```
但我们也有 `rename` 命令来做重命名。使用 `rename` 命令的窍门是习惯它的语法，但是如果你了解一些 Perl，你可能发现它并不棘手。
有个非常有用的例子。假设你想重新命名一个目录中的文件，将所有的大写字母替换为小写字母。一般来说，你在 Unix 或 Linux 系统上找不到大量大写字母的文件，但你可以有。这里有一个简单的方法来重命名它们，而不必为它们中的每一个使用 `mv` 命令。 `/A-Z/a-z/` 告诉 `rename` 命令将范围 `A-Z` 中的任何字母更改为 `a-z` 中的相应字母。
```
$ ls
Agenda Group.JPG MyFile
$ rename 'y/A-Z/a-z/' *
$ ls
agenda group.jpg myfile
```
你也可以使用 `rename` 来删除文件扩展名。也许你厌倦了看到带有 .txt 扩展名的文本文件。简单删除这些扩展名 —— 用一个命令。
```
$ ls
agenda.txt notes.txt weekly.txt
$ rename 's/.txt//' *
$ ls
agenda notes weekly
```
现在让我们想象一下，你改变了心意，并希望把这些扩展名改回来。没问题。只需修改命令。窍门是理解第一个斜杠前的 `s` 意味着“替代”。前两个斜线之间的内容是我们想要改变的东西，第二个斜线和第三个斜线之间是改变后的东西。所以，`$` 表示文件名的结尾，我们将它改为 `.txt`。
```
$ ls
agenda notes weekly
$ rename 's/$/.txt/' *
$ ls
agenda.txt notes.txt weekly.txt
```
你也可以更改文件名的其他部分。牢记 `s/旧内容/新内容/` 规则。
```
$ ls
draft-minutes-2018-03 draft-minutes-2018-04 draft-minutes-2018-05
$ rename 's/draft/approved/' *minutes*
$ ls
approved-minutes-2018-03 approved-minutes-2018-04 approved-minutes-2018-05
```
在上面的例子中注意到，当我们在 `s/old/new/` 中使用 `s` 时，我们用另一个名称替换名称的一部分。当我们使用 `y` 时，我们就是直译（将字符从一个范围替换为另一个范围）。
### 总结
现在有很多复制和重命名文件的方法。我希望其中的一些会让你在使用命令行时更愉快。
---
via: <https://www.networkworld.com/article/3276349/linux/copying-and-renaming-files-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/) 荣誉推出
|
||
怎样在桌面上安装 Docker CE？
|
Swapnil Bhartiya
|
https://www.linux.com/blog/learn/intro-to-linux/how-install-docker-ce-your-desktop
|
按照这些简单的步骤在你的 Linux、Mac 或 Windows 桌面上安装 Docker CE。
|
/data/attachment/album/201806/23/215043fkkyhpwe9wy59elw.jpg.thumb.jpg
|
/data/attachment/album/201806/23/215043fkkyhpwe9wy59elw.jpg
| true | false | true |
MjSeven
| false |
[
"Docker"
] |
容器与云
|
{
"viewnum": 8161,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "125.70.14.147",
"message": "以上，docker在windows中就是一个坑。",
"username": "来自四川成都的 Chrome 68.0|Windows 8.1 用户",
"date": "2019-03-22T10:44:47"
}
] |
[
{
"raid": 9541,
"displayorder": 0
},
{
"raid": 9799,
"displayorder": 1
}
] |
按照这些简单的步骤在你的 Linux、Mac 或 Windows 桌面上安装 Docker CE。
| 2018-06-23T21:50:00 | 2018-06-23T21:50:00 | 9,773 |
/article-9773-1.html
|
>
> 按照这些简单的步骤在你的 Linux、Mac 或 Windows 桌面上安装 Docker CE。
>
>
>
[在上一篇文章中](/article-9799-1.html)，我们学习了容器世界的一些基本术语。当我们运行命令并在后续文章中使用其中一些术语时，这些背景信息将会派上用场，包括这篇文章。本文将介绍在桌面 Linux、 macOS 和 Windows 上安装 Docker，它适用于想要开始使用 Docker 容器的初学者。唯一的先决条件是你对命令行界面满意。
### 为什么我在本地机器上需要 Docker CE？
作为一个新用户，你很可能想知道为什么你在本地系统上需要容器。难道它们不是作为微服务在云和服务器中运行吗？尽管容器长期以来一直是 Linux 世界的一部分，但 Docker 才真正使容器的工具和技术步入使用。
Docker 容器最大的优点是可以使用本地机器进行开发和测试。你在本地系统上创建的容器映像可以在“任何位置”运行。开发人员和操作人员之间不再会为应用程序在开发系统上运行良好但生产环境中出现问题而产生纷争。
而这个关键是，要创建容器化的应用程序，你必须能够在本地系统上运行和创建容器。
你可以使用以下三个平台中的任何一个 —— 桌面 Linux、 Windows 或 macOS 作为容器的开发平台。一旦 Docker 在这些系统上成功运行，你将可以在不同的平台上使用相同的命令。因此，接下来你运行的操作系统无关紧要。
这就是 Docker 之美。
### 让我们开始吧
现在有两个版本的 Docker：Docker 企业版（EE）和 Docker 社区版（CE）。我们将使用 Docker 社区版，这是一个免费的 Docker 版本，面向想要开始使用 Docker 的开发人员和爱好者。
Docker CE 有两个版本：stable 和 edge。顾名思义，stable（稳定）版本会为你提供经过充分测试的季度更新，而 edge 版本每个月都会提供新的更新。经过进一步的测试之后，这些边缘特征将被添加到稳定版本中。我建议新用户使用 stable 版本。
Docker CE 支持 macOS、 Windows 10、 Ubuntu 14.04/16.04/17.04/17.10、 Debian 7.7/8/9/10、 Fedora 25/26/27 和 CentOS。虽然你可以下载 Docker CE 二进制文件并安装到桌面 Linux 上，但我建议添加仓库源以便继续获得修补程序和更新。
### 在桌面 Linux 上安装 Docker CE
你不需要一个完整的桌面 Linux 来运行 Docker，你也可以将它安装在最小的 Linux 服务器上，即你可以在一个虚拟机中运行。在本教程中，我将在我的主系统的 Fedora 27 和 Ubuntu 17.04 上运行它。
### 在 Ubuntu 上安装
首先，运行系统更新，以便你的 Ubuntu 软件包完全更新：
```
$ sudo apt-get update
```
现在运行系统升级：
```
$ sudo apt-get dist-upgrade
```
然后安装 Docker PGP 密钥：
```
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
```
```
Update the repository info again:
$ sudo apt-get update
```
现在安装 Docker CE：
```
$ sudo apt-get install docker-ce
```
一旦安装完成，Docker CE 就会在基于 Ubuntu 的系统上自动运行，让我们来检查它是否在运行：
```
$ sudo systemctl status docker
```
你应该得到以下输出：
```
docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running) since Thu 2017-12-28 15:06:35 EST; 19min ago
Docs: https://docs.docker.com
Main PID: 30539 (dockerd)
```
由于 Docker 安装在你的系统上，你现在可以使用 Docker CLI（命令行界面）运行 Docker 命令。像往常一样，我们运行 ‘Hello World’ 命令：
```
$ sudo docker run hello-world
```
恭喜！在你的 Ubuntu 系统上正在运行着 Docker。
### 在 Fedora 上安装 Docker CE
Fedora 27 上的情况有些不同。在 Fedora 上，你首先需要安装 `def-plugins-core` 包，这将允许你从 CLI 管理你的 DNF 包。
```
$ sudo dnf -y install dnf-plugins-core
```
现在在你的系统上安装 Docker 仓库：
```
$ sudo dnf config-manager \
--add-repo \
https://download.docker.com/linux/fedora/docker-ce.repo
It’s time to install Docker CE:
```
```
$ sudo dnf install docker-ce
```
与 Ubuntu 不同，Docker 不会在 Fedora 上自动启动。那么让我们启动它：
```
$ sudo systemctl start docker
```
你必须在每次重新启动后手动启动 Docker，因此让我们将其配置为在重新启动后自动启动。`$ systemctl enable docker` 就行。现在该运行 Hello World 命令了：
```
$ sudo docker run hello-world
```
恭喜，在你的 Fedora 27 系统上正在运行着 Docker。
### 解除 root
你可能已经注意到你必须使用 `sudo` 来运行 `docker` 命令。这是因为 Docker 守护进程与 UNIX 套接字绑定，而不是 TCP 端口，套接字由 root 用户拥有。所以，你需要 `sudo` 权限才能运行 `docker` 命令。你可以将系统用户添加到 docker 组，这样它就不需要 `sudo` 了：
```
$ sudo groupadd docker
```
在大多数情况下，在安装 Docker CE 时会自动创建 Docker 用户组，因此你只需将用户添加到该组中即可：
```
$ sudo usermod -aG docker $USER
```
为了测试该组是否已经成功添加，根据用户名运行 `groups` 命令：
```
$ groups swapnil
```
（这里，`swapnil` 是用户名。）
这是在我系统上的输出：
```
swapnil : swapnil adm cdrom sudo dip plugdev lpadmin sambashare docker
```
你可以看到该用户也属于 docker 组。注销系统，这样组就会生效。一旦你再次登录，在不使用 `sudo` 的情况下试试 Hello World 命令：
```
$ docker run hello-world
```
你可以通过运行以下命令来查看关于 Docker 的安装版本以及更多系统信息：
```
$ docker info
```
### 在 macOS 和 Windows 上安装 Docker CE
你可以在 macOS 和 Windows 上很轻松地安装 Docker CE（和 EE）。下载官方为 macOS 提供的 Docker 安装包，在 macOS 上安装应用程序的方式是只需将它们拖到 Applications 目录即可。一旦文件被复制，从 spotlight（LCTT 译注：mac 下的搜索功能）下打开 Docker 开始安装。一旦安装，Docker 将自动启动，你可以在 macOS 的顶部看到它。
macOS 是类 UNIX 系统，所以你可以简单地打开终端应用程序，并开始使用 Docker 命令。测试 hello world 应用：
```
$ docker run hello-world
```
恭喜，你已经在你的 macOS 上运行了 Docker。
### 在 Windows 10 上安装 Docker
你需要最新版本的 Windows 10 Pro 或 Server 才能在它上面安装或运行 Docker。如果你没有完全更新，Windows 将不会安装 Docker。我在 Windows 10 系统上遇到了错误，必须运行系统更新。我的版本还很落后，我出现了[这个][14] bug。所以，如果你无法在 Windows 上安装 Docker，只要知道并不是只有你一个。仔细检查该 bug 以找到解决方案。
一旦你在 Windows 上安装 Docker 后，你可以通过 WSL 使用 bash shell，或者使用 PowerShell 来运行 Docker 命令。让我们在 PowerShell 中测试 “Hello World” 命令：
```
PS C:\Users\swapnil> docker run hello-world
```
恭喜，你已经在 Windows 上运行了 Docker。
在下一篇文章中，我们将讨论如何从 DockerHub 中拉取镜像并在我们的系统上运行容器。我们还会讨论推送我们自己的容器到 Docker Hub。
---
via: <https://www.linux.com/blog/learn/intro-to-linux/how-install-docker-ce-your-desktop>
作者：[SWAPNIL BHARTIYA](https://www.linux.com/users/arnieswap) 选题：[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/) 荣誉推出
|
||
DevOps 如何帮助你将很酷的应用交付给用户
|
Stanislav Ivaschenko
|
https://opensource.com/article/18/2/devops-delivers-cool-apps-users
|
想要在今天的快节奏的商业环境中获得成功？要么选择 DevOps，要么死亡。
|
/data/attachment/album/201806/23/224338sggn3mfg1verej39.png.thumb.jpg
|
/data/attachment/album/201806/23/224338sggn3mfg1verej39.png
| true | false | true |
FelixYFZ
| false |
[
"DevOps"
] |
观点
|
{
"viewnum": 3878,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
想要在今天的快节奏的商业环境中获得成功？要么选择 DevOps，要么死亡。
| 2018-06-23T22:43:00 | 2018-06-23T22:43:00 | 9,774 |
/article-9774-1.html
|
>
> 想要在今天的快节奏的商业环境中获得成功？要么选择 DevOps，要么死亡。
>
>
>
在很久之前，遥远的银河系中，在 DevOps 成为主流实践之前，软件开发的过程是极其缓慢、单调和按部就班的。当一个应用准备要部署的时候，就已经为下一个主要版本迭代积累了一长串的变更和修复。每次为新版本迭代所花费的准备时间都需要花费数个月的时间去回顾和贯穿整个开发周期。请记住这个过程将会在交付更新给用户的过程中不断的 重复。
今天一切都是瞬间和实时完成的，这个概念似乎很原始。这场移动革命已经极大的改变了我们和软件之间的交互。那些早期采用 DevOps 的公司已经彻底改变了对软件开发和部署的期望。
让我们看看 Facebook：这个移动应用每两周更新和刷新一次，像钟表一样。这就是新的标准，因为现在的用户期望软件持续的被修复和更新。任何一家要花费一个月或者更多的时间来部署新的功能或者修复 bug 的公司将会逐渐走向没落。如果你不能交付用户所期待的，他们将会去寻找那些能够满足他们需求的。
Facebook，以及一些工业巨头如亚马逊、Netfix、谷歌以及其他公司，都已经强制要求企业变得更快速、更有效的来满足今天的顾客们的需求。
### 为什么是 DevOps?
敏捷和 DevOps 对于移动应用开发领域是相当重要的，因为开发周期正变得如闪电般的快。现在是一个密集、快节奏的环境，公司必须加紧步伐赶超，思考的更深入，运用策略来去完成，从而生存下去。在应用商店中，排名前十的应用平均能够保持的时间只有一个月左右。
为了说明老式的瀑布方法，回想一下你第一次学习驾驶。起先，你专注于每个独立的层面，使用一套方法论的过程：你上车；系上安全带；调整座椅、镜子，控制方向盘；发动汽车，将你的手放在 10 点和 2 点钟的方向，等等。完成一个换车道一样简单的任务需要付出艰苦的努力，以一个特定的顺序执行多个步骤。
DevOps，正好相反，是在你有了几年的经验之后如何去驾驶的。一切都是靠直觉同时发生的，你可以不用过多的思考就很平滑的从 A 点移动到 B 点。
移动 app 的世界对越老式的 app 开发环境来说太快节奏了。DevOps 被设计用来快速交付有效、稳定的 app，而不需要增加资源。然而你不能像购买一件普通的商品或者服务一样去购买 DevOps。DevOps 是用来指导改变团队如何一起工作的文化和活动的。
不是只有像亚马逊和 Facebook 这样的大公司才拥抱 DevOps 文化；小的移动应用公司也在很好的使用。“缩短迭代周期，同时保持生产事故处于一个较低水平，以及满足顾客追求的整体故障成本。”来自移动产品代理 [Reinvently](https://reinvently.com/)的工程部的负责人，Oleg Reshetnyak 说道。
### DevOps: 不是如果，而是什么时候
在今天的快节奏的商业环境中，选在了 DevOps 就像是选择了呼吸：要么去[做要么就死亡](https://squadex.com/insights/devops-or-die/)。
根据[美国小企业管理局](https://www.sba.gov/)的报道，现在只有 16% 的公司能够持续一代人的时间。不采用 DevOps 的移动应用公司将冒着逐渐走向灭绝的风险。而且，同样的研究表明采用 DevOps 的公司组织可能能够获得两倍的盈利能力、生产目标以及市场份额。
更快速、更安全的革新需要做到三点：云、自动化和 DevOps。根据你对 DevOps 的定义的不同，这三个要点之间的界限是不清晰的。然而，有一点是确定的：DevOps 围绕着更快、更少风险地交付高质量的软件的共同目标将组织内的每个人都统一起来。
---
via: <https://opensource.com/article/18/2/devops-delivers-cool-apps-users>
作者：[Stanislav Ivaschenko](https://opensource.com/users/ilyadudkin) 译者：[FelixYFZ](https://github.com/FelixYFZ) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
不像 MySQL 的 MySQL：MySQL 文档存储介绍
|
Dave Stokes
|
https://opensource.com/article/18/6/mysql-document-store
|
MySQL 文档存储 可以跳过底层数据结构创建、数据规范化和其它使用传统数据库时需要做的工作，直接存储数据。
|
/data/attachment/album/201806/24/091941py6eywfye6fyeeex.jpg.thumb.jpg
|
/data/attachment/album/201806/24/091941py6eywfye6fyeeex.jpg
| true | false | true |
pinewall
| false |
[
"MySQL",
"JSON"
] |
技术
|
{
"viewnum": 7778,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
MySQL 文档存储 可以跳过底层数据结构创建、数据规范化和其它使用传统数据库时需要做的工作，直接存储数据。
| 2018-06-24T09:19:00 | 2018-06-24T09:19:00 | 9,775 |
/article-9775-1.html
|
>
> MySQL 文档存储 可以跳过底层数据结构创建、数据规范化和其它使用传统数据库时需要做的工作，直接存储数据。
>
>
>
MySQL 可以提供 NoSQL JSON <ruby> 文档存储 <rt> Document Store </rt></ruby>了，这样开发者保存数据前无需<ruby> 规范化 <rt> normalize </rt></ruby>数据、创建数据库，也无需在开发之前就制定好数据样式。从 MySQL 5.7 版本和 MySQL 8.0 版本开始，开发者可以在表的一列中存储 JSON 文档。由于引入 X DevAPI，你可以从你的代码中移除令人不爽的结构化查询字符串，改为使用支持现代编程设计的 API 调用。
系统学习过结构化查询语言（SQL）、<ruby> 关系理论 <rt> relational theory </rt></ruby>、<ruby> 集合 <rt> set </rt></ruby>和其它关系数据库底层理论的开发者并不多，但他们需要一个安全可靠的数据存储。如果数据库管理人员不足，事情很快就会变得一团糟，
[MySQL 文档存储](https://www.mysql.com/products/enterprise/document_store.html) 允许开发者跳过底层数据结构创建、数据规范化和其它使用传统数据库时需要做的工作，直接存储数据。只需创建一个 JSON <ruby> 文档集合 <rt> document collection </rt></ruby>，接着就可以使用了。
### JSON 数据类型
所有这一切都基于多年前 MySQL 5.7 引入的 JSON 数据类型。它允许在表的一行中提供大约 1GB 大小的列。数据必须是有效的 JSON，否则服务器会报错；但开发者可以自由使用这些空间。
### X DevAPI
旧的 MySQL 协议已经历经差不多四分之一个世纪，已经显现出疲态，因此新的协议被开发出来，协议名为 [X DevAPI](https://dev.mysql.com/doc/x-devapi-userguide/en/)。协议引入高级会话概念，允许代码从单台服务器扩展到多台，使用符合<ruby> 通用主机编程语言样式 <rt> common host-language programming patterns </rt></ruby>的非阻塞异步 I/O。需要关注的是如何遵循现代实践和编码风格，同时使用 CRUD （Create、 Read、 Update、 Delete）样式。换句话说，你不再需要在你精美、纯洁的代码中嵌入丑陋的 SQL 语句字符串。
一个新的 shell 支持这种新协议，即所谓的 [MySQL Shell](https://dev.mysql.com/downloads/shell/)。该 shell 可用于设置<ruby> 高可用集群 <rt> high-availability cluster </rt></ruby>、检查服务器<ruby> 升级就绪状态 <rt> upgrade readiness </rt></ruby>以及与 MySQL 服务器交互。支持的交互方式有以下三种：JavaScript，Python 和 SQL。
### 代码示例
下面的代码示例基于 JavaScript 方式使用 MySQL Shell，可以从 `JS>` 提示符看出。
下面，我们将使用用户 `dstokes` 、密码 `password` 登录本地系统上的 `demo` 库。`db` 是一个指针，指向 `demo` 库。
```
$ mysqlsh dstokes:password@localhost/demo
JS> db.createCollection("example")
JS> db.example.add(
{
Name: "Dave",
State: "Texas",
foo : "bar"
}
)
JS>
```
在上面的示例中，我们登录服务器，连接到 `demo` 库，创建了一个名为 `example` 的集合，最后插入一条记录；整个过程无需创建表，也无需使用 SQL。只要你能想象的到，你可以使用甚至滥用这些数据。这不是一种代码对象与关系语句之间的映射器，因为并没有将代码映射为 SQL；新协议直接与服务器层打交道。
### Node.js 支持
新 shell 看起来挺不错，你可以用其完成很多工作；但你可能更希望使用你选用的编程语言。下面的例子使用 `world_x` 示例数据库，搜索 `_id` 字段匹配 `CAN.` 的记录。我们指定数据库中的特定集合，使用特定参数调用 `find` 命令。同样地，操作也不涉及 SQL。
```
var mysqlx = require('@mysql/xdevapi');
mysqlx.getSession({ //Auth to server
host: 'localhost',
port: '33060',
dbUser: 'root',
dbPassword: 'password'
}).then(function (session) { // use world_x.country.info
var schema = session.getSchema('world_x');
var collection = schema.getCollection('countryinfo');
collection // Get row for 'CAN'
.find("$._id == 'CAN'")
.limit(1)
.execute(doc => console.log(doc))
.then(() => console.log("\n\nAll done"));
session.close();
})
```
下面例子使用 PHP，搜索 `_id` 字段匹配 `USA` 的记录：
```
<?PHP
// Connection parameters
$user = 'root';
$passwd = 'S3cret#';
$host = 'localhost';
$port = '33060';
$connection_uri = 'mysqlx://'.$user.':'.$passwd.'@'.$host.':'.$port;
echo $connection_uri . "\n";
// Connect as a Node Session
$nodeSession = mysql_xdevapi\getNodeSession($connection_uri);
// "USE world_x" schema
$schema = $nodeSession->getSchema("world_x");
// Specify collection to use
$collection = $schema->getCollection("countryinfo");
// SELECT * FROM world_x WHERE _id = "USA"
$result = $collection->find('_id = "USA"')->execute();
// Fetch/Display data
$data = $result->fetchAll();
var_dump($data);
?>
```
可以看出，在上面两个使用不同编程语言的例子中，`find` 操作符的用法基本一致。这种一致性对跨语言编程的开发者有很大帮助，对试图降低新语言学习成本的开发者也不无裨益。
支持的语言还包括 C、Java、Python 和 JavaScript 等，未来还会有更多支持的语言。
### 从两种方式受益
我会告诉你使用 NoSQL 方式录入的数据也可以用 SQL 方式使用？换句话说，我会告诉你新引入的 NoSQL 方式可以访问旧式关系型表中的数据？现在使用 MySQL 服务器有多种方式，作为 SQL 服务器，作为 NoSQL 服务器或者同时作为两者。
---
via: <https://opensource.com/article/18/6/mysql-document-store>
作者：[Dave Stokes](https://opensource.com/users/davidmstokes) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在命令行中整理数据
|
Bob Mesibov
|
https://opensource.com/article/18/5/command-line-data-auditing
|
命令行审计不会影响数据库，因为它使用从数据库中释放的数据。
|
/data/attachment/album/201806/24/213451olqt644bmk3ket3l.png.thumb.jpg
|
/data/attachment/album/201806/24/213451olqt644bmk3ket3l.png
| true | false | true |
amwps290
| false |
[
"命令行",
"审计",
"数据库"
] |
技术
|
{
"viewnum": 6276,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
命令行审计不会影响数据库，因为它使用从数据库中释放的数据。
| 2018-06-24T21:34:47 | 2018-06-24T21:34:47 | 9,776 |
/article-9776-1.html
|
>
> 命令行审计不会影响数据库，因为它使用从数据库中释放的数据。
>
>
>
我兼职做数据审计。把我想象成一个校对者，校对的是数据表格而不是一页一页的文章。这些表是从关系数据库导出的，并且规模相当小：100,000 到 1,000,000条记录，50 到 200 个字段。
我从来没有见过没有错误的数据表。如你所能想到的，这种混乱并不局限于重复记录、拼写和格式错误以及放置在错误字段中的数据项。我还发现:
* 损坏的记录分布在几行上，因为数据项具有内嵌的换行符
* 在同一记录中一个字段中的数据项与另一个字段中的数据项不一致
* 使用截断数据项的记录，通常是因为非常长的字符串被硬塞到具有 50 或 100 字符限制的字段中
* 字符编码失败产生称为[乱码](https://en.wikipedia.org/wiki/Mojibake)的垃圾
* 不可见的[控制字符](https://en.wikipedia.org/wiki/Control_character)，其中一些会导致数据处理错误
* 由上一个程序插入的[替换字符](https://en.wikipedia.org/wiki/Specials_(Unicode_block)#Replacement_character)和神秘的问号，这是由于不知道数据的编码是什么
解决这些问题并不困难，但找到它们存在非技术障碍。首先，每个人都不愿处理数据错误。在我看到表格之前，数据所有者或管理人员可能已经经历了<ruby> 数据悲伤 <rt> Data Grief </rt></ruby>的所有五个阶段：
1. 我们的数据没有错误。
2. 好吧，也许有一些错误，但它们并不重要。
3. 好的，有很多错误；我们会让我们的内部人员处理它们。
4. 我们已经开始修复一些错误，但这很耗时间；我们将在迁移到新的数据库软件时执行此操作。
5. 移至新数据库时，我们没有时间整理数据； 我们需要一些帮助。
第二个阻碍进展的是相信数据整理需要专用的应用程序——要么是昂贵的专有程序，要么是优秀的开源程序 [OpenRefine](http://openrefine.org/) 。为了解决专用应用程序无法解决的问题，数据管理人员可能会向程序员寻求帮助，比如擅长 [Python](https://www.python.org/) 或 [R](https://www.r-project.org/about.html) 的人。
但是数据审计和整理通常不需要专用的应用程序。纯文本数据表已经存在了几十年，文本处理工具也是如此。打开 Bash shell，您将拥有一个工具箱，其中装载了强大的文本处理器，如 `grep`、`cut`、`paste`、`sort`、`uniq`、`tr` 和 `awk`。它们快速、可靠、易于使用。
我在命令行上执行所有的数据审计工作，并且在 “[cookbook](https://www.polydesmida.info/cookbook/index.html)” 网站上发布了许多数据审计技巧。我经常将操作存储为函数和 shell 脚本（参见下面的示例）。
是的，命令行方法要求将要审计的数据从数据库中导出。而且，审计结果需要稍后在数据库中进行编辑，或者（数据库允许）将整理的数据项导入其中，以替换杂乱的数据项。
但其优势是显著的。awk 将在普通的台式机或笔记本电脑上以几秒钟的时间处理数百万条记录。不复杂的正则表达式将找到您可以想象的所有数据错误。所有这些都将安全地发生在数据库结构之外：命令行审计不会影响数据库，因为它使用从数据库中释放的数据。
受过 Unix 培训的读者此时会沾沾自喜。他们还记得许多年前用这些方法操纵命令行上的数据。从那时起，计算机的处理能力和 RAM 得到了显著提高，标准命令行工具的效率大大提高。数据审计从来没有这么快、这么容易过。现在微软的 Windows 10 可以运行 Bash 和 GNU/Linux 程序了，Windows 用户也可以用 Unix 和 Linux 的座右铭来处理混乱的数据：保持冷静，打开一个终端。
### 例子
假设我想在一个大的表中的特定字段中找到最长的数据项。 这不是一个真正的数据审计任务，但它会显示 shell 工具的工作方式。 为了演示目的，我将使用制表符分隔的表 `full0` ，它有 1,122,023 条记录（加上一个标题行）和 49 个字段，我会查看 36 号字段。（我得到字段编号的函数在我的[网站](https://www.polydesmida.info/cookbook/functions.html#fields)上有解释）
首先，使用 `tail` 命令从表 `full0` 移除标题行，结果管道至 `cut` 命令，截取第 36 个字段，接下来，管道至 `awk` ，这里有一个初始化为 0 的变量 `big` ，然后 `awk` 开始检测第一行数据项的长度，如果长度大于 0 ，`awk` 将会设置 `big` 变量为新的长度，同时存储行数到变量 `line` 中。整个数据项存储在变量 `text` 中。然后 `awk` 开始轮流处理剩余的 1,122,022 记录项。同时，如果发现更长的数据项时，更新 3 个变量。最后，它打印出行号、数据项的长度，以及最长数据项的内容。（在下面的代码中，为了清晰起见，将代码分为几行）
```
tail -n +2 full0 \
> | cut -f36 \
> | awk 'BEGIN {big=0} length($0)>big \
> {big=length($0);line=NR;text=$0} \
> END {print "\nline: "line"\nlength: "big"\ntext: "text}'
```
大约花了多长时间？我的电脑大约用了 4 秒钟（core i5，8GB RAM）；
现在我可以将这个长长的命令封装成一个 shell 函数，`longest`，它把第一个参数认为是文件名，第二个参数认为是字段号：
现在，我可以以函数的方式重新运行这个命令，在另一个文件中的另一个字段中找最长的数据项，而不需要去记忆这个命令是如何写的：
最后调整一下，我还可以输出我要查询字段的名称，我只需要使用 `head` 命令抽取表格第一行的标题行，然后将结果管道至 `tr` 命令，将制表位转换为换行，然后将结果管道至 `tail` 和 `head` 命令，打印出第二个参数在列表中名称，第二个参数就是字段号。字段的名字就存储到变量 `field` 中，然后将它传向 `awk` ，通过变量 `fld` 打印出来。（LCTT 译注：按照下面的代码，编号的方式应该是从右向左）
```
longest() { field=$(head -n 1 "$1" | tr '\t' '\n' | tail -n +"$2" | head -n 1); \
tail -n +2 "$1" \
| cut -f"$2" | \
awk -v fld="$field" 'BEGIN {big=0} length($0)>big \
{big=length($0);line=NR;text=$0}
END {print "\nfield: "fld"\nline: "line"\nlength: "big"\ntext: "text}'; }
```
注意，如果我在多个不同的字段中查找最长的数据项，我所要做的就是按向上箭头来获得最后一个最长的命令，然后删除字段号并输入一个新的。
---
via: <https://opensource.com/article/18/5/command-line-data-auditing>
作者：[Bob Mesibov](https://opensource.com/users/bobmesibov) 选题：[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/) 荣誉推出
|
||
在 Linux 上用 DNS 实现简单的负载均衡
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2018/3/simple-load-balancing-dns-linux
|
DNS 轮询将多个服务器映射到同一个主机名，并没有为这里展示的魔法做更多的工作。
|
/data/attachment/album/201806/24/230631yhide2jzb2tt2yzh.jpg.thumb.jpg
|
/data/attachment/album/201806/24/230631yhide2jzb2tt2yzh.jpg
| true | false | true |
qhwdw
| false |
[
"DNS",
"负载均衡",
"轮询"
] |
系统运维
|
{
"viewnum": 10790,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
DNS 轮询将多个服务器映射到同一个主机名，并没有为这里展示的魔法做更多的工作。
| 2018-06-24T23:06:28 | 2018-06-24T23:06:28 | 9,777 |
/article-9777-1.html
|
>
> DNS 轮询将多个服务器映射到同一个主机名，并没有为这里展示的魔法做更多的工作。
>
>
>
如果你的后端服务器是由多台服务器构成的，比如集群化或者镜像的 Web 或者文件服务器，通过负载均衡器提供了单一的入口点。业务繁忙的大型电商在高端负载均衡器上花费了大量的资金，用它来执行各种各样的任务：代理、缓存、状况检查、SSL 处理、可配置的优先级、流量整形等很多任务。
但是你并不需要做那么多工作的负载均衡器。你需要的是一个跨服务器分发负载的简单方法，它能够提供故障切换，并且不太在意它是否高效和完美。DNS 轮询和使用轮询的子域委派是实现这个目标的两种简单方法。
DNS 轮询是将多台服务器映射到同一个主机名上，当用户访问 `foo.example.com` 时多台服务器都可用于处理它们的请求，使用的就是这种方式。
当你有多个子域或者你的服务器在地理上比较分散时，使用轮询的子域委派就比较有用。你有一个主域名服务器，而子域有它们自己的域名服务器。你的主域名服务器将所有的到子域的请求指向到它们自己的域名服务器上。这将提升响应时间，因为 DNS 协议会自动查找最快的链路。
### DNS 轮询
轮询和<ruby> 旅鸫鸟 <rt> robins </rt></ruby>没有任何关系，据我相熟的图书管理员说，它最初是一个法语短语，*ruban rond*、或者 *round ribbon*。很久以前，法国政府官员以不分级的圆形、波浪线、或者直线形状来在请愿书上签字，以盖住原来的发起人。
DNS 轮询也是不分级的，简单配置一个服务器列表，然后将请求转到每个服务器上。它并不做真正的负载均衡，因为它根本就不测量负载，也没有状况检查，因此如果一个服务器宕机，请求仍然会发送到那个宕机的服务器上。它的优点就是简单。如果你有一个小的文件或者 Web 服务器集群，想通过一个简单的方法在它们之间分散负载，那么 DNS 轮询很适合你。
你所做的全部配置就是创建多条 A 或者 AAAA 记录，映射多台服务器到单个的主机名。这个 BIND 示例同时使用了 IPv4 和 IPv6 私有地址类：
```
fileserv.example.com. IN A 172.16.10.10
fileserv.example.com. IN A 172.16.10.11
fileserv.example.com. IN A 172.16.10.12
fileserv.example.com. IN AAAA fd02:faea:f561:8fa0:1::10
fileserv.example.com. IN AAAA fd02:faea:f561:8fa0:1::11
fileserv.example.com. IN AAAA fd02:faea:f561:8fa0:1::12
```
Dnsmasq 在 `/etc/hosts` 文件中保存 A 和 AAAA 记录：
```
172.16.1.10 fileserv fileserv.example.com
172.16.1.11 fileserv fileserv.example.com
172.16.1.12 fileserv fileserv.example.com
fd02:faea:f561:8fa0:1::10 fileserv fileserv.example.com
fd02:faea:f561:8fa0:1::11 fileserv fileserv.example.com
fd02:faea:f561:8fa0:1::12 fileserv fileserv.example.com
```
请注意这些示例都是很简化的，解析完全合格域名有多种方法，因此，关于如何配置 DNS 请自行学习。
使用 `dig` 命令去检查你的配置能否按预期工作。将 `ns.example.com` 替换为你的域名服务器：
```
$ dig @ns.example.com fileserv A fileserv AAA
```
它将同时显示出 IPv4 和 IPv6 的轮询记录。
### 子域委派和轮询
子域委派结合轮询要做的配置会更多，但是这样有一些好处。当你有多个子域或者地理位置比较分散的服务器时，就应该去使用它。它的响应时间更快，并且宕机的服务器不会去响应，因此客户端不会因为等待回复而被挂住。一个短的 TTL，比如 60 秒，就能帮你做到。
这种方法需要多台域名服务器。在最简化的场景中，你需要一台主域名服务器和两个子域，每个子域都有它们自己的域名服务器。在子域服务器上配置你的轮询记录，然后在你的主域名服务器上配置委派。
在主域名服务器上的 BIND 中，你至少需要两个额外的配置，一个区声明以及在区数据文件中的 A/AAAA 记录。主域名服务器中的委派应该像如下的内容：
```
ns1.sub.example.com. IN A 172.16.1.20
ns1.sub.example.com. IN AAAA fd02:faea:f561:8fa0:1::20
ns2.sub.example.com. IN A 172.16.1.21
ns2.sub.example.com. IN AAA fd02:faea:f561:8fa0:1::21
sub.example.com. IN NS ns1.sub.example.com.
sub.example.com. IN NS ns2.sub.example.com.
```
接下来的每台子域服务器上有它们自己的区文件。在这里它的关键点是每个服务器去返回它**自己的** IP 地址。在 `named.conf` 中的区声明，所有的服务上都是一样的：
```
zone "sub.example.com" {
type master;
file "db.sub.example.com";
};
```
然后数据文件也是相同的，除了那个 A/AAAA 记录使用的是各个服务器自己的 IP 地址。SOA 记录都指向到主域名服务器：
```
; first subdomain name server
$ORIGIN sub.example.com.
$TTL 60
sub.example.com IN SOA ns1.example.com. admin.example.com. (
2018123456 ; serial
3H ; refresh
15 ; retry
3600000 ; expire
)
sub.example.com. IN NS ns1.sub.example.com.
sub.example.com. IN A 172.16.1.20
ns1.sub.example.com. IN AAAA fd02:faea:f561:8fa0:1::20
; second subdomain name server
$ORIGIN sub.example.com.
$TTL 60
sub.example.com IN SOA ns1.example.com. admin.example.com. (
2018234567 ; serial
3H ; refresh
15 ; retry
3600000 ; expire
)
sub.example.com. IN NS ns1.sub.example.com.
sub.example.com. IN A 172.16.1.21
ns2.sub.example.com. IN AAAA fd02:faea:f561:8fa0:1::21
```
接下来生成子域服务器上的轮询记录，方法和前面一样。现在你已经有了多个域名服务器来处理到你的子域的请求。再说一次，BIND 是很复杂的，做同一件事情它有多种方法，因此，给你留的家庭作业是找出适合你使用的最佳配置方法。
在 Dnsmasq 中做子域委派很容易。在你的主域名服务器上的 `dnsmasq.conf` 文件中添加如下的行，去指向到子域的域名服务器：
```
server=/sub.example.com/172.16.1.20
server=/sub.example.com/172.16.1.21
server=/sub.example.com/fd02:faea:f561:8fa0:1::20
server=/sub.example.com/fd02:faea:f561:8fa0:1::21
```
然后在子域的域名服务器上的 `/etc/hosts` 中配置轮询。
获取配置方法的详细内容和帮助，请参考这些资源：
* [Dnsmasq](http://www.thekelleys.org.uk/dnsmasq/doc.html)
* [DNS and BIND, 5th Edition](http://shop.oreilly.com/product/9780596100575.do)
通过来自 Linux 基金会和 edX 的免费课程 ["Linux 入门"](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux) 学习更多 Linux 的知识。
---
via: <https://www.linux.com/learn/intro-to-linux/2018/3/simple-load-balancing-dns-linux>
作者：[CARLA SCHRODER](https://www.linux.com/users/cschroder) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
范凡：终于我见到了三次元的 Torvalds
|
Fine Fan
|
本文是 Linux 中国特约记者范凡在参加了 2018 LC3 首日会议和 Linus 媒体见面会后的花絮。
|
/data/attachment/album/201806/25/235620c9xdy5om39ajawx3.jpg.thumb.jpg
|
/data/attachment/album/201806/25/235620c9xdy5om39ajawx3.jpg
| true | false | false | true |
[
"LC3"
] |
新闻
|
{
"viewnum": 10118,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本文是 Linux 中国特约记者范凡在参加了 2018 LC3 首日会议和 Linus 媒体见面会后的花絮。
| 2018-06-25T23:58:00 | 2018-06-25T23:58:00 | 9,779 |
/article-9779-1.html
|
>
> 编者按：本文是 Linux 中国特约记者范凡在参加了 2018 LC3 首日会议和 Linus 媒体见面会后的花絮。
>
>
>
大家好，我是范凡，2018 年度的 LC3 再次在北京的国家会议中心召开，这次，我蒙 Linux 中国的老大指派，来 LC3 大会上去“巡风”一番，而且我还有个重大责任，就是和 Linus Torvalds 先生来个亲密接触。然而，想到就要见到传说中的我们的开源领袖，我竟然……太过激动，夜不成寐，直到凌晨 3 点才昏昏睡去——还好我的闹钟很尽责，在 6 点钟时将我叫了起来。
睡了不到 3 个小时，又赶上周一早高峰，两个多小时的车程，你知道的，当我到达现场的时候已经临近开场时间，整个人都是木木的。
签到之后领到了今年的 T 恤，不像去年，今年是蓝色的啦。 而为了参加这次大会，我还专门制作了咱们 Linux 中国自己的 T 恤。
进入主会场，大会很快就开始了，惯例还是由 Linux 基金会董事 Jim 做开场演讲。演讲中 Jim 还谈到了微软收购 GitHub 的事件，Jim 说微软是一个很强的软件公司，而 GitHub 能够提供更多的优秀的开发者，这两个强强结合肯定能为世界带来更多的好的改变。
之后，经过了几个演讲之后，大会主持人用一个笑话引入了众所期盼的 Linus Torvalds 演讲环节。
Jim 说 Linus Torvalds 很喜欢黑色和白色的动物，在他来到中国看过我们黑白相间的大熊猫之后，Linus 说我们要不要把 Linux 的吉祥物从那支黑白相间的企鹅，换称中国的大熊猫？！
*图片中的大熊猫看起来很开心，但是似乎是因为那根胡萝卜，而不是因为它旁边是 Linus*
之后便是和 Linus 的一个问答式的对话。之所以采用这种方式是因为 Linus 真的不喜欢公开演讲，所以这种方式会让他感觉稍微好一些。
具体的问答内容我基本忘干净了，主要内容还是和内核维护相关，内核维护的相关人员主要分为两类，一类是开发人员，另外一类是维护人员。Linus 对他们在整个内核维护过程中的职责和相关工作方法发表了一些个人的看法。
简单来说既是要求内核开发人员的代码要求有很好的<ruby> 品味 <rp> （ </rp> <rt> taste </rt> <rp> ） </rp></ruby>。然后就是大家需要通力合作才能够将整个项目良好维持下去。
然后趁着中间休息的机会和 Linux 中国的小伙伴们会了面，分了下我们定制的衣服，大家穿起来，一起开心的深蹲合了个影。
*中国合伙人式深蹲合影。（谁说前面该放四个盆的，你出来，我不打死你！）*
---
下面是重头戏！
下午，会有媒体参加的新闻发布会，Linus Torvalds 会亲自参加。Linux 中国作为邀约媒体，有幸参加，而我，则是那个幸运儿，可以近距离接触脱袜子先生啦（不枉我朝思暮想而夜不成寐）。
新闻发布会是 13:30 开始，根据老王的经验，一定要提前入场。于是乎我 12:32 就来到了会议的地点。
厚着脸皮坐到了第一排，会前准备期间，就看到了三位大佬在讨论事宜。
趁着讨论的空隙，再一次厚着脸皮拿到了下面的合影。
*非常的和蔼，没有任何脾气。标准的 Linus 式微笑……至于美颜效果我表示不知道怎么关*
之后各路大佬们就这样坐在台前一一回答台下记者们的问题。
在示意可以提问后，我顾盼了一下，大家还有点腼腆，于是赶快率先举手提了第一个问题：
>
> Linus 将来会不会写一本书来告诉大家他心目中的有品位的代码是什么样子的？
>
>
>
Linus 的的回答说了一大堆，简单来说就是，他不会再去写书了。他的更多的经历会放在内核项目的管理上，因为这样才更有意义。
在提问期间，Linus 有说到英语的话题，说现在在场的其实大部分都不是社区的开发者。他也知道，中国的社区开发者在很多时候都会因为英文的问题导致工作上会有相关的障碍，尽管 Linux 基金会现在也在做汉化的工作（[linuxfoundation.cn](http://linuxfoundation.cn)），但是还是希望大家能够通过自己的努力解决自身英文的问题。他拿自己举例子，说你们现在可能也听不出来我的母语其实不是英语，他在成长过程中其实是说的另外两种语言，（他也是后天才学习的英语）也希望中国的开发者也能够像他一样通过自己的努力解决自身的英文问题，这样在今后的开发过程中会轻松很多。（我的理解是：学英语是多么重要呀~开源的大火车就要开了，你居然<ruby> 没有买到票 <rp> （ </rp> <rt> 不会英语 </rt> <rp> ） </rp></ruby>，<ruby> 扒在车厢外面 <rp> （ </rp> <rt> 靠别人的翻译 </rt> <rp> ） </rp></ruby>一定不轻松呀~）
然后我还依稀记得，他有说到关于开源组织的一个理念。开源组织是一帮人在做一个事情遇到问题的时候他们想出了一套方法来解决对应的问题，然后将实现的代码共享出来给大家，如果大家在用的时候遇到了新的问题，Linus 更多的期望是，大家拿着这套代码继续去深入开发，解决相关领域的更多的新的问题，而不是去等待最初的团队来再次的付出人力完善他们的代码。
中间还有很多问答，现在完全不记得了。（抱歉各位~我录了音 但是音质实在太渣了，我保证下回弄一个专业的设备去录音。）
在最后的合影时候，我利用这最后的机会疯狂的将各位大佬当成背景自拍，这一个举动被站在 Linus 旁边的 Jim 看到了，他走过来拿着我的手机说，“天哪，我看你一直在自拍，自拍了不下十次，我知道你一定想和Linus合个影对吧？”于是乎我得到了下面这张由 Jim 亲手拍摄的：
感激坏了，难怪人家说 Jim 是最 nice 的人了，从此对 Jim 比心心，然后我又和他来了一张。
当时脑袋全都是木的。应该说 You and me……结果说成了 Me and you……，Jim 也只自己疑惑的重复了一下，然后完全不在乎这些细节。他们人都好 Nice。
然后在接下来的各种疯狂要签名的环节里面，我弄到了如下两个~（恩是的。我吃这么胖就是为了让自己脸皮厚一点。）
尽管由于前一天晚上太过激动，只睡了大概 2 个多小时就前往会场，导致整个人都是木的。
但是一天下来，还是被震撼了还几次，收获不少。能够从 IT 界大佬们的口中感受到我们的世界正在发生着不断地变化，不管是国内的还是国外的（其实抛开政治我们是一体的），这种变化的支撑需要优秀的贡献者，我们作为工作在一线的工程师们（是的，今天我是以媒体身份混进去的。）还是要不断的学习，提高自己的各方面能力，才能够赶上时代的步伐，去见证这一奇迹时代的到来。
最后容我用我的朋友圈嘚瑟一句。我们可以从“在每天上下班路上利用我们的智能手机鲸吞蚕食地看完一本书” 开始，踏上这一美妙的征程。
*有关本次大会更多信息，请移步[这里](https://www.lfasiallc.com/events/lc3-2018/)。*
|
||||
如何在 Linux 中使用 history 命令
|
Steve Morris
|
https://opensource.com/article/18/6/history-command
|
用强大的 history 命令使你的命令行提示符更有效率。
|
/data/attachment/album/201806/26/082437dzz94xnhe95huhxh.jpg.thumb.jpg
|
/data/attachment/album/201806/26/082437dzz94xnhe95huhxh.jpg
| true | false | true |
geekpi
| false |
[
"历史",
"history"
] |
技术
|
{
"viewnum": 10629,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用强大的 history 命令使你的命令行提示符更有效率。
| 2018-06-26T08:24:46 | 2018-06-26T08:24:46 | 9,780 |
/article-9780-1.html
|
>
> 用强大的 history 命令使你的命令行提示符更有效率。
>
>
>
随着我在终端中花费越来越多的时间，我感觉就像在不断地寻找新的命令，以使我的日常任务更加高效。GNU 的 `history` 命令是一个真正改变我日常工作的命令。
GNU `history` 命令保存了从该终端会话运行的所有其他命令的列表，然后允许你重放或者重用这些命令，而不用重新输入它们。如果你是一个老玩家，你知道 `history` 的力量，但对于我们这些半吊子或新手系统管理员来说， `history` 是一个立竿见影的生产力增益。
### 历史 101
要查看命令历史，请在 Linux 中打开终端程序，然后输入：
```
$ history
```
这是我得到的响应：
```
1 clear
2 ls -al
3 sudo dnf update -y
4 history
```
`history` 命令显示自开始会话后输入的命令列表。 `history` 有趣的地方是你可以使用以下命令重放任意一个命令：
```
$ !3
```
提示符中的 `!3` 告诉 shell 重新运行历史列表中第 3 个命令。我还可以输入以下命令来使用：
```
linuser@my_linux_box: !sudo dnf
```
`history` 将搜索与你提供的模式相匹配的最后一个命令，并运行它。
### 搜索历史
你还可以输入 `!!` 重新运行命令历史中的最后一条命令。而且，通过与`grep` 配对，你可以搜索与文本模式相匹配的命令，或者通过与 `tail` 一起使用，你可以找到你最后几条执行的命令。例如：
```
$ history | grep dnf
3 sudo dnf update -y
5 history | grep dnf
$ history | tail -n 3
4 history
5 history | grep dnf
6 history | tail -n 3
```
另一种实现这个功能的方法是输入 `Ctrl-R` 来调用你的命令历史记录的递归搜索。输入后，提示变为：
```
(reverse-i-search)`':
```
现在你可以开始输入一个命令，并且会显示匹配的命令，按回车键执行。
### 更改已执行的命令
`history` 还允许你使用不同的语法重新运行命令。例如，如果我想改变我以前的命令 `history | grep dnf` 成 `history | grep ssh`，我可以在提示符下执行以下命令：
```
$ ^dnf^ssh^
```
`history` 将重新运行该命令，但用 `ssh` 替换 `dnf`，并执行它。
### 删除历史
有时你想要删除一些或全部的历史记录。如果要删除特定命令，请输入 `history -d <行号>`。要清空历史记录，请执行 `history -c`。
历史文件存储在一个你可以修改的文件中。bash shell 用户可以在他们的家目录下找到 `.bash_history`。
### 下一步
你可以使用 `history` 做许多其他事情：
* 将历史缓冲区设置为一定数量
* 记录历史中每行的日期和时间
* 防止某些命令被记录在历史记录中
有关 `history` 命令的更多信息和其他有趣的事情，请参考 [GNU Bash 手册](https://www.gnu.org/software/bash/manual/)。
---
via: <https://opensource.com/article/18/6/history-command>
作者：[Steve Morris](https://opensource.com/users/smorris12) 选题：[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 和 Windows 之间共享文件？
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3269189/linux/sharing-files-between-linux-and-windows.html
|
用一些来自 Linux 社区的工具，在 Linux 和 Windows 之间共享文件是超容易的。让我们看看可以做这件事的两种不同方法。
|
/data/attachment/album/201806/26/083845fck3q05qlpbdk4pk.jpg.thumb.jpg
|
/data/attachment/album/201806/26/083845fck3q05qlpbdk4pk.jpg
| true | false | true |
MjSeven
| false |
[
"Windows",
"共享"
] |
技术
|
{
"viewnum": 30020,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用一些来自 Linux 社区的工具，在 Linux 和 Windows 之间共享文件是超容易的。让我们看看可以做这件事的两种不同方法。
| 2018-06-26T08:38:42 | 2018-06-26T08:38:42 | 9,781 |
/article-9781-1.html
|
>
> 用一些来自 Linux 社区的工具，在 Linux 和 Windows 之间共享文件是超容易的。让我们看看可以做这件事的两种不同方法。
>
>
>
现代很多人都在混合网络上工作，Linux 和 Windows 系统都扮演着重要的结束。在两者之间共享文件有时是非常关键的，并且使用正确的工具非常容易。只需很少的功夫，你就可以将文件从 Windows 复制到 Linux 或从 Linux 到 Windows。在这篇文章中，我们将讨论配置 Linux 和 Windows 系统所需的东西，以允许你轻松地将文件从一个操作系统转移到另一个。
### 在 Linux 和 Windows 之间复制文件
在 Windows 和 Linux 之间移动文件的第一步是下载并安装诸如 PuTTY 的 `pscp` 之类的工具。你可以从 [putty.org](https://www.putty.org) 获得它（LCTT 译注：切记从官方网站下载，并最好对比其 md5/sha1 指纹），并轻松将其设置在 Windows 系统上。PuTTY 带有一个终端仿真器（`putty`）以及像 `pscp` 这样的工具，用于在 Linux 和 Windows 系统之间安全地复制文件。当你进入 PuTTY 站点时，你可以选择安装所有工具，或选择安装你想要的工具，也可以选择单个 .exe 文件。
你还需要在你的 Linux 系统上设置并运行 ssh 服务器。这允许它支持客户端（Windows 端）连接请求。如果你还没有安装 ssh 服务器，那么以下步骤可以在 Debian 系统上运行（包括 Ubuntu 等）：
```
sudo apt update
sudo apt install ssh-server
sudo service ssh start
```
对于 Red Hat 及其相关的 Linux 系统，使用类似的命令：
```
sudo yum install openssh-server
sudo systemctl start sshd
```
注意，如果你正在运行防火墙（例如 ufw），则可能需要打开 22 端口以允许连接。
使用 `pscp` 命令，你可以将文件从 Windows 移到 Linux，反之亦然。它的 “copy from to” 命令的语法非常简单。
#### 从 Windows 到 Linux
在下面显示的命令中，我们将 Windows 系统上用户账户中的文件复制到 Linux 系统下的 /tmp 目录。
```
C:\Program Files\PuTTY>pscp \Users\shs\copy_me.txt shs@192.168.0.18:/tmp
shs@192.168.0.18's password:
copy_me.txt | 0 kB | 0.1 kB/s | ETA: 00:00:00 | 100%
```
#### 从 Linux 到 Windows
将文件从 Linux 转移到 Windows 也同样简单。只要颠倒参数即可。
```
C:\Program Files\PuTTY>pscp shs@192.168.0.18:/tmp/copy_me.txt \Users\shs
shs@192.168.0.18's password:
copy_me.txt | 0 kB | 0.1 kB/s | ETA: 00:00:00 | 100%
```
如果 1) `pscp` 位于 Windows 搜索路径中，并且 2) 你的 Linux 系统在 Windows 的 hosts 文件中，则该过程可以变得更加顺畅和轻松。
#### Windows 搜索路径
如果你使用 PuTTY 安装程序安装 PuTTY 工具，你可能会发现 `C:\Program files\PuTTY` 位于 Windows 搜索路径中。你可以通过在 Windows 命令提示符下键入 `echo %path%` 来检查是否属于这种情况（在搜索栏中键入 `cmd` 来打开命令提示符）。如果是这样，你不需要关心文件系统中相对于 `pscp` 可执行文件的位置。进入到包含你想要移动文件的文件夹可能会更容易。
```
C:\Users\shs>pscp copy_me.txt shs@192.168.0.18:/tmp
shs@192.168.0.18's password:
copy_me.txt | 0 kB | 0.1 kB/s | ETA: 00:00:00 | 100%
```
#### 更新你的 Windows 的 hosts 文件
这是另一个小修补。使用管理员权限，你可以将 Linux 系统添加到 Windows 的 hosts 文件中（`C:\Windows\System32\drivers\etc\hosts`），然后使用其主机名代替其 IP 地址。请记住，如果你的 Linux 系统的 IP 地址是动态分配的，那么它不会一直发挥作用。
```
C:\Users\shs>pscp copy_me.txt shs@stinkbug:/tmp
shs@192.168.0.18's password:
hosts | 0 kB | 0.8 kB/s | ETA: 00:00:00 | 100%
```
请注意，Windows 的 hosts 文件与 Linux 系统上的 `/etc/hosts` 文件格式相同 -- IP 地址、空格、主机名。注释以 `#` 符号来表示的。
```
# Linux systems
192.168.0.18 stinkbug
```
#### 讨厌的行结尾符
请记住，Windows 上文本文件中的行以回车符和换行符结束。`pscp` 工具不会删除回车符，以使文件看起来像 Linux 文本文件。相反，它只是完整地复制文件。你可以考虑安装 `tofrodos` 包，这使你能够在 Linux 系统上使用 `fromdos` 和 `todos` 命令来调整在平台之间移动的文件。
### 在 Windows 和 Linux 之间共享文件夹
共享文件夹是完全不同的操作。你最终将 Windows 文件夹挂载到你的 Linux 系统或将 Linux 文件夹挂载到 Windows 文件夹中，以便两个系统可以使用同一组文件，而不是将文件从一个系统复制到另一个系统。最好的工具之一就是 Samba，它模拟 Windows 协议并在 Linux 系统上运行。
一旦安装了 Samba，你将能够将 Linux 文件夹挂载到 Windows 上或将 Windows 文件夹挂载到 Linux 上。当然，这与本文前面描述的复制文件有很大的不同。相反，这两个系统中的每一个都可以同时访问相同的文件。
关于选择在 Linux 和 Windows 系统之间共享文件的正确工具的更多提示可以在[这里](https://www.infoworld.com/article/2617683/linux/linux-moving-files-between-unix-and-windows-systems.html)找到。
---
via: <https://www.networkworld.com/article/3269189/linux/sharing-files-between-linux-and-windows.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[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/) 荣誉推出
|
||
如何在 Ubuntu Linux 上挂载和使用 exFAT 驱动器
|
Abhishek Prakash
|
https://itsfoss.com/mount-exfat/
|
本教程将向你展示如何在 Ubuntu 和其他基于 Ubuntu 的 Linux 发行版上启用 exFAT 文件系统支持。用此种方法在系统上挂载 exFAT 驱动器时，你将不会看到错误消息。
|
/data/attachment/album/201806/26/172324ng09il0bnpljgvip.jpg.thumb.jpg
|
/data/attachment/album/201806/26/172324ng09il0bnpljgvip.jpg
| true | false | true |
geekpi
| false |
[
"exFAT"
] |
桌面应用
|
{
"viewnum": 7801,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本教程将向你展示如何在 Ubuntu 和其他基于 Ubuntu 的 Linux 发行版上启用 exFAT 文件系统支持。用此种方法在系统上挂载 exFAT 驱动器时，你将不会看到错误消息。
| 2018-06-26T17:23:20 | 2018-06-26T17:23:20 | 9,782 |
/article-9782-1.html
|
>
> 简介：本教程将向你展示如何在 Ubuntu 和其他基于 Ubuntu 的 Linux 发行版上启用 exFAT 文件系统支持。用此种方法在系统上挂载 exFAT 驱动器时，你将不会看到错误消息。
>
>
>
### 在 Ubuntu 上挂载 exFAT 磁盘时出现问题
有一天，我试图使用以 exFAT 格式化 的 U 盘，其中包含约为 10GB 大小的文件。只要我插入 U 盘，我的 Ubuntu 16.04 就会抛出一个错误说**无法挂载未知的文件系统类型 ‘exfat’**。
确切的错误信息是这样的：
```
Error mounting /dev/sdb1 at /media/abhishek/SHADI DATA: Command-line `mount -t "exfat" -o "uhelper=udisks2,nodev,nosuid,uid=1001,gid=1001,iocharset=utf8,namecase=0,errors=remount-ro,umask=0077" "/dev/sdb1" "/media/abhishek/SHADI DATA"` exited with non-zero exit status 32: mount: unknown filesystem type 'exfat'
```
### exFAT 挂载错误的原因
微软最喜欢的 [FAT 文件系统](http://www.ntfs.com/fat-systems.htm)仅限于最大 4GB 的文件。你不能将大于 4GB 的文件传输到 FAT 驱动器。为了克服 FAT 文件系统的限制，微软在 2006 年推出了 [exFAT](https://en.wikipedia.org/wiki/ExFAT) 文件系统。
由于大多数微软相关的东西都是专有的，exFAT 文件格式也不例外。Ubuntu 和许多其他 Linux 发行版默认不提供专有的 exFAT 文件支持。这就是你看到 exFAT 文件出现挂载错误的原因。
### 如何在 Ubuntu Linux 上挂载 exFAT 驱动器
解决这个问题很简单。你只需启用 exFAT 支持即可。
我将展示在 Ubuntu 中的命令，但这应该适用于其他基于 Ubuntu 的发行版，例如 [Linux Mint](https://linuxmint.com/)、elementary OS 等。
打开终端（Ubuntu 中 `Ctrl+Alt+T` 快捷键）并使用以下命令：
```
sudo apt install exfat-fuse exfat-utils
```
安装完这些软件包后，进入文件管理器并再次点击 U 盘来挂载它。无需重新插入 USB。它应该能直接挂载。
#### 这对你有帮助么
我希望这个提示可以帮助你修复 Linux 发行版的 exFAT 的挂载错误。如果你有任何其他问题、建议或感谢，请在评论中留言。
---
via: <https://itsfoss.com/mount-exfat/>
作者：[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/) 荣誉推出
|
||
Primas 与「Linux 中国」开源社区达成战略合作，带动开源社区升级
|
Wxy
|
此次合作的达成与「Linux 中国」近期正在积极推进的开源生态区块链化的进程相结合，为「Linux 中国」及中国广大的开源社区团体们开拓了一个新的开源发展模式，必将有力地推进中国的开源文化和技术生态的发展。
|
/data/attachment/album/201806/26/214437f1xqav6jyl9ydya6.jpg.thumb.jpg
|
/data/attachment/album/201806/26/214437f1xqav6jyl9ydya6.jpg
| true | false | false | false |
[
"Linux中国",
"Primas"
] |
新闻
|
{
"viewnum": 8539,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
此次合作的达成与「Linux 中国」近期正在积极推进的开源生态区块链化的进程相结合，为「Linux 中国」及中国广大的开源社区团体们开拓了一个新的开源发展模式，必将有力地推进中国的开源文化和技术生态的发展。
| 2018-06-26T21:45:19 | 2018-06-26T21:45:19 | 9,783 |
/article-9783-1.html
|
2018 年 6 月 24 日，由 Primas 基金会主办的“盖世来临——DTCP 协议发布暨 DApp 发布会”在上海盛大举行，「Linux 中国」联合创始人王兴宇出席了此次发布会。此前，Primas 与「Linux 中国」签订了战略合作伙伴协议，通过 Primas 提供的整套区块链技术服务：DTCP（分布式可信内容协议）、经济激励机制和去中心化爬虫在内的技术支持为「Linux 中国」创建开源社区新玩法，实现 Primas 与「Linux 中国」的互相赋能和生态链接。
「Linux中国」立志成为华文区一流的 Linux 与开源的交流社区，推动 Linux 和开源在中国的发展，促进 Linux 及开源技术在中国的普及，构建开源社区环境。「Linux 中国」开源社区主要涉及 Linux 及开源文化的传播和讨论、开源技术的研究和普及。其所传播的内容主要来自开源贡献者的写作、翻译和按内容协议的转载。
通过此次战略合作，Primas 将利用 DTCP 和相应的激励机制，带动开源社区的升级，创建社区新生态，确保社区内容的可信性，拉动更多开源爱好者参与社区建设和作出贡献，同时，使对 Linux 与开源感兴趣的开源爱好者能以更低的成本获得更优质的内容。
DTCP 是 Primas 团队开发的基于区块链技术的互联网底层协议，是对 WWW 协议的升级，旨在构建一个开放、互通、可信的高质量互联网。DTCP 定义了一整套内容元数据标准，包括作者、发布时间、信用等级、引用信息等多方位的 metadata，通过区块链技术，为元数据生成不可篡改、不会丢失的全网唯一数字身份，确保了发布内容的可信和可追溯。DTCP 为「Linux 中国」开源社区建造了信用生态环境，确保每一位社区建设者的每一次智力耕耘均有可追溯性，劳动成果不被窃取及篡改，且通过建设者之间的链接，为 Linux 技术及开源赋能，使其拥有更多延展性，成为真正意义上的 Linux 和开源生态社区。
同时，Primas 独创的经济激励机制和去中心化爬虫技术，可以为「Linux 中国」的社区建设者获得更多智力收入，吸引更多的建设者参与其中，使其价值变现，切身体验付出既得回报的满足感。去中心化爬虫技术使社区所有建设者可以将某一位建设者的相关信息记录上链，帮助单个建设者建立自己的社区“家园”，形成社区去中心化，每个建设者即是中心的形态，实现社区自治。
此次合作的达成与「Linux 中国」近期正在积极推进的开源生态区块链化的进程相结合，为「Linux 中国」及中国广大的开源社区团体们开拓了一个新的开源发展模式，必将有力地推进中国的开源文化和技术生态的发展。
通过此次战略合作，Primas 将区块链技术实际应用落地与「Linux 中国」携手创建社区新生态，从技术层面带动开源社区突破升级，开启区块链的颠覆时代。
|
||||
学习用 Thonny 写代码： 一个面向初学者的Python IDE
|
Aivar Annamaa
|
https://fedoramagazine.org/learn-code-thonny-python-ide-beginners/
|
Thonny 是一个适合初学者的 Python IDE，由爱沙尼亚的 Tartu 大学 开发，它采用了不同的方法，因为它的调试器是专为学习和教学编程而设计的。
|
/data/attachment/album/201806/27/093343c6gzva2ha9mg2ocd.jpg.thumb.jpg
|
/data/attachment/album/201806/27/093343c6gzva2ha9mg2ocd.jpg
| true | false | true |
Auk7F7
| false |
[
"Thonny",
"Python"
] |
分享
|
{
"viewnum": 29720,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Thonny 是一个适合初学者的 Python IDE，由爱沙尼亚的 Tartu 大学 开发，它采用了不同的方法，因为它的调试器是专为学习和教学编程而设计的。
| 2018-06-27T09:33:37 | 2018-06-27T09:33:37 | 9,784 |
/article-9784-1.html
|
学习编程很难。即使当你最终怎么正确使用你的冒号和括号，但仍然有很大的可能你的程序不会如果所想的工作。 通常，这意味着你忽略了某些东西或者误解了语言结构，你需要在代码中找到你的期望与现实存在分歧的地方。
程序员通常使用被叫做<ruby> 调试器 <rt> debugger </rt></ruby>的工具来处理这种情况，它允许一步一步地运行他们的程序。不幸的是，大多数调试器都针对专业用途进行了优化，并假设用户已经很好地了解了语言结构的语义（例如：函数调用）。
Thonny 是一个适合初学者的 Python IDE，由爱沙尼亚的 [Tartu 大学](https://www.ut.ee/en) 开发，它采用了不同的方法，因为它的调试器是专为学习和教学编程而设计的。
虽然 Thonny 适用于像小白一样的初学者，但这篇文章面向那些至少具有 Python 或其他命令式语言经验的读者。
### 开始
从第 Fedora 27 开始，Thonny 就被包含在 Fedora 软件库中。 使用 `sudo dnf install thonny` 或者你选择的图形工具（比如“<ruby> 软件 <rt> Software </rt></ruby>”）安装它。
当第一次启动 Thonny 时，它会做一些准备工作，然后呈现一个空白的编辑器和 Python shell 。将下列程序文本复制到编辑器中，并将其保存到文件中（`Ctrl+S`）。
```
n = 1
while n < 5:
print(n * "*")
n = n + 1
```
我们首先运行该程序。 为此请按键盘上的 `F5` 键。 你应该看到一个由星号组成的三角形出现在 shell 窗格中。
Python 分析了你的代码并理解了你想打印一个三角形了吗？让我们看看！
首先从“<ruby> 查看 <rt> View </rt></ruby>”菜单中选择“<ruby> 变量 <rt> Variables </rt></ruby>”。这将打开一张表格，向我们展示 Python 是如何管理程序的变量的。现在通过按 `Ctrl + F5`（在 XFCE 中是 `Ctrl + Shift + F5`）以调试模式运行程序。在这种模式下，Thonny 使 Python 在每一步所需的步骤之前暂停。你应该看到程序的第一行被一个框包围。我们将这称为焦点，它表明 Python 将接下来要执行的部分代码。
你在焦点框中看到的一段代码段被称为赋值语句。 对于这种声明，Python 应该计算右边的表达式，并将值存储在左边显示的名称下。按 `F7` 进行下一步。你将看到 Python 将重点放在语句的正确部分。在这个例子中，表达式实际上很简单，但是为了通用性，Thonny 提供了表达式计算框，它允许将表达式转换为值。再次按 `F7` 将文字 `1` 转换为值 `1`。现在 Python 已经准备好执行实际的赋值—再次按 `F7`，你应该会看到变量 `n` 的值为 `1` 的变量出现在变量表中。
继续按 `F7` 并观察 Python 如何以非常小的步骤前进。它看起来像是理解你的代码的目的或者更像是一个愚蠢的遵循简单规则的机器？
### 函数调用
<ruby> 函数调用 <rt> Function Call </rt></ruby>是一种编程概念，它常常给初学者带来很大的困惑。从表面上看，没有什么复杂的事情——给代码命名，然后在代码中的其他地方引用它（调用它）。传统的调试器告诉我们，当你进入调用时，焦点跳转到函数定义中（然后稍后神奇地返回到原来的位置）。这是整件事吗？这需要我们关心吗？
结果证明，“跳转模型” 只对最简单的函数是足够的。理解参数传递、局部变量、返回和递归都得理解堆栈框架的概念。幸运的是，Thonny 可以直观地解释这个概念，而无需在厚厚的掩盖下搜索重要的细节。
将以下递归程序复制到 Thonny 并以调试模式（`Ctrl+F5` 或 `Ctrl+Shift+F5`）运行。
```
def factorial(n):
if n == 0:
return 1
else:
return factorial(n-1) * n
print(factorial(4))
```
重复按 `F7`，直到你在对话框中看到表达式 `factorial(4)`。 当你进行下一步时，你会看到 Thonny 打开一个包含了函数代码、另一个变量表和另一个焦点框的新窗口（移动窗口以查看旧的焦点框仍然存在）。
此窗口表示堆栈帧，即用于解析函数调用的工作区。几个放在彼此顶部的这样的窗口称为<ruby> 调用堆栈 <rt> call stack </rt></ruby>。注意调用位置的参数 `4` 与 “局部变量” 表中的输入 `n` 之间的关系。继续按 `F7` 步进, 观察在每次调用时如何创建新窗口并在函数代码完成时被销毁，以及如何用返回值替换了调用位置。
### 值与参考
现在，让我们在 Python shell 中进行一个实验。首先输入下面屏幕截图中显示的语句：
正如你所看到的, 我们追加到列表 `b`, 但列表 `a` 也得到了更新。你可能知道为什么会发生这种情况, 但是对初学者来说，什么才是最好的解释呢？
当教我的学生列表时，我告诉他们我一直欺骗了他们关于 Python 内存模型。实际上，它并不像变量表所显示的那样简单。我告诉他们重新启动解释器（工具栏上的红色按钮），从“<ruby> 查看 <rt> View </rt></ruby>”菜单中选择“<ruby> 堆 <rt> Heap </rt></ruby>”，然后再次进行相同的实验。如果这样做，你就会发现变量表不再包含值——它们实际上位于另一个名为“<ruby> 堆 <rt> Heap </rt></ruby>”的表中。变量表的作用实际上是将变量名映射到地址（或称 ID），地址又指向了<ruby> 堆 <rt> Heap </rt></ruby>表中的行。由于赋值仅更改变量表，因此语句 `b = a` 只复制对列表的引用，而不是列表本身。这解释了为什么我们通过这两个变量看到了变化。
（为什么我要在教列表的主题之前推迟说出内存模型的事实？Python 存储的列表是否有所不同？请继续使用 Thonny 的堆模式来找出结果！在评论中告诉我你认为怎么样！）
如果要更深入地了解参考系统, 请将以下程序通过打开堆表复制到 Thonny 并进行小步调试（`F7`） 中。
```
def do_something(lst, x):
lst.append(x)
a = [1,2,3]
n = 4
do_something(a, n)
print(a)
```
即使“堆模式”向我们显示真实的图片，但它使用起来也相当不方便。 因此，我建议你现在切换回普通模式（取消选择“<ruby> 查看 <rt> View </rt></ruby>”菜单中的“<ruby> 堆 <rt> Heap </rt></ruby>”），但请记住，真实模型包含变量、参考和值。
### 结语
我在这篇文章中提及到的特性是创建 Thonny 的主要原因。很容易对函数调用和引用形成错误的理解，但传统的调试器并不能真正帮助减少混淆。
除了这些显著的特性，Thonny 还提供了其他几个初学者友好的工具。 请查看 [Thonny的主页](http://thonny.org) 以了解更多信息！
---
via: <https://fedoramagazine.org/learn-code-thonny-python-ide-beginners/>
作者：[Aivar Annamaa](https://fedoramagazine.org/) 译者：[Auk7F7](https://github.com/Auk7F7) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
值得考虑的 9 个开源 ERP 系统
|
Opensource.com
|
https://opensource.com/tools/enterprise-resource-planning
|
有一些使用灵活、功能丰富而物有所值的开源 ERP 系统，这里有 9 个值得你看看。
|
/data/attachment/album/201806/27/161345xfoqzrf8dqd2d2dq.jpg.thumb.jpg
|
/data/attachment/album/201806/27/161345xfoqzrf8dqd2d2dq.jpg
| true | false | true |
qhwdw
| false |
[
"ERP"
] |
分享
|
{
"viewnum": 33733,
"commentnum": 1,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "124.133.93.132",
"message": "大家都使用的哪个呢",
"username": "FrankHe [Chrome 69.0|Mac 10.13]",
"date": "2018-09-20T10:12:10"
}
] |
[
{
"raid": 9844,
"displayorder": 0
}
] |
有一些使用灵活、功能丰富而物有所值的开源 ERP 系统，这里有 9 个值得你看看。
| 2018-06-27T16:13:49 | 2018-06-27T16:13:49 | 9,785 |
/article-9785-1.html
|
>
> 有一些使用灵活、功能丰富而物有所值的开源 ERP 系统，这里有 9 个值得你看看。
>
>
>
拥有一定数量员工的企业就需要大量的协调工作，包括制定价格、计划生产、会计和财务、管理支出、管理存货等等。把一套截然不同的工具拼接到一起去处理这些工作，是一种粗制滥造和无价值的做法。
那种方法没有任何弹性。并且那样在各种各样的自组织系统之间高效移动数据是非常困难的。同样，它也很难维护。
因此，大多数成长型企业都转而使用一个 [企业资源计划](http://en.wikipedia.org/wiki/Enterprise_resource_planning) （ERP）系统。
在这个行业中的大咖有 Oracle、SAP、以及 Microsoft Dynamics。它们都提供了一个综合的系统，但同时也很昂贵。如果你的企业支付不起如此昂贵的大系统，或者你仅需要一个简单的系统，怎么办呢？你可以使用开源的产品来作为替代。
### 一个 ERP 系统中有什么东西
显然，你希望有一个满足你需要的系统。基于那些需要，更多的功能并不意味着就更好。但是，你的需要会根据你的业务的增长而变化的，因此，你希望能够找到一个 ERP 系统，它能够根据你新的需要而扩展它。那就意味着系统有额外的模块或者支持插件和附加功能。
大多数的开源 ERP 系统都是 web 应用程序。你可以下载并将它们安装到你的服务器上。但是，如果你不希望（或者没有相应技能或者人员）自己去维护系统，那么应该确保它们的应用程序提供托管版本。
最后，你还应该确保应用程序有良好的文档和支持 —— 要么是付费支持或者有一个活跃的用户社区。
有很多弹性很好的、功能丰富的、很划算的开源 ERP 系统。如果你正打算购买这样的系统，这里有我们挑选出来的 9 个。
### ADempiere
像大多数其它开源 ERP 解决方案，[ADempiere](http://www.adempiere.net/welcome) 的目标客户是中小企业。它已经存在一段时间了 — 这个项目出现于 2006，它是 Compiere ERP 软件的一个分支。
它的意大利语名字的意思是“实现”或者“满足”，它“涉及多个方面”的 ERP 特性，旨在帮企业去满足各种需求。它在 ERP 中增加了供应链管理（SCM）和客户关系管理（CRM）功能，能够让该 ERP 套件在一个软件中去管理销售、采购、库存以及帐务处理。它的最新版本是 v.3.9.0，更新了用户界面、POS、人力资源、工资以及其它的特性。
因为是一个跨平台的、基于 Java 的云解决方案，ADempiere 可以运行在Linux、Unix、Windows、MacOS、智能手机、平板电脑上。它使用 [GPLv2](http://wiki.adempiere.net/License) 授权。如果你想了解更多信息，这里有一个用于测试的 [demo](http://www.adempiere.net/web/guest/demo)，或者也可以在 GitHub 上查看它的 [源代码](https://github.com/adempiere/adempiere)。
### Apache OFBiz
[Apache OFBiz](http://ofbiz.apache.org/) 的业务相关的套件是构建在通用的架构上的，它允许企业根据自己的需要去定制 ERP。因此，它是有内部开发资源的大中型企业的最佳套件，可以去修改和集成它到它们现有的 IT 和业务流程。
OFBiz 是一个成熟的开源 ERP 系统；它的网站上说它是一个有十年历史的顶级 Apache 项目。可用的 [模块](https://ofbiz.apache.org/business-users.html#UsrModules) 有会计、生产制造、人力资源、存货管理、目录管理、客户关系管理，以及电子商务。你可以在它的 [demo 页面](http://ofbiz.apache.org/ofbiz-demos.html) 上试用电子商务的网上商店以及后端的 ERP 应用程序。
Apache OFBiz 的源代码能够在它的 [项目仓库](http://ofbiz.apache.org/source-repositories.html) 中找到。它是用 Java 写的，它在 [Apache 2.0 license](http://www.apache.org/licenses/LICENSE-2.0) 下可用。
### Dolibarr
[Dolibarr](http://www.dolibarr.org/) 提供了中小型企业端到端的业务管理，从发票跟踪、合同、存货、订单，以及支付，到文档管理和电子化 POS 系统支持。它的全部功能封装在一个清晰的界面中。
如果你担心不会使用 Dolibarr，[这里有一些关于它的文档](http://wiki.dolibarr.org/index.php/What_Dolibarr_can%27t_do)。
另外，还有一个 [在线演示](http://www.dolibarr.org/onlinedemo)，Dolibarr 也有一个 [插件商店](http://www.dolistore.com/)，你可以在那是购买一些软件来扩展它的功能。你可以在 GitHub 上查看它的 [源代码](https://github.com/Dolibarr/dolibarr)；它在 [GPLv3](https://github.com/Dolibarr/dolibarr/blob/develop/COPYING) 或者任何它的最新版本许可下面使用。
### ERPNext
[ERPNext](https://erpnext.com/) 是这类开源项目中的其中一个；实际上它最初在 2014 年就被 [Opensource.com 推荐了](https://opensource.com/business/14/11/building-open-source-erp)。它被设计用于打破一个陈旧而昂贵的专用 ERP 系统的垄断局面。
ERPNext 适合于中小型企业。它包含的模块有会计、存货管理、销售、采购、以及项目管理。ERPNext 是表单驱动的应用程序 — 你可以在一组字段中填入信息，然后让应用程序去完成剩余部分。整个套件非常易用。
如果你感兴趣，在你考虑参与之前，你可以请求获取一个 [demo](https://frappe.erpnext.com/request-a-demo)，去 [下载它](https://erpnext.com/download) 或者在托管服务上 [购买一个订阅](https://erpnext.com/pricing)。
### Metasfresh
[Metasfresh](http://metasfresh.com/en/) 的名字表示它承诺软件的代码始终保持“新鲜”。它自 2015 年以来每周发行一个更新版本，那时，它的代码是由创始人从 ADempiere 项目中分叉的。与 ADempiere 一样，它是一个基于 Java 的开源 ERP，目标客户是中小型企业。
虽然，相比在这里介绍的其它软件来说，它是一个很 “年青的” 项目，但是它早早就引起了一起人的注意，获得很多积极的评价，比如，被提名为“最佳开源”的 IT 创新奖入围者。
Metasfresh 在自托管系统上或者在云上单用户使用时是免费的，或者可以按月交纳订阅费用。它的 [源代码](https://github.com/metasfresh/metasfresh) 在 GitHub 上，可以在遵守 [GPLv2](https://github.com/metasfresh/metasfresh/blob/master/LICENSE.md) 许可的情况下使用，它的云版本是以 GPLv3 方式授权使用。
### Odoo
[Odoo](https://www.odoo.com/) 是一个应用程序集成解决方案，它包含的模块有项目管理、帐单、存货管理、生产制造、以及采购。这些模块之间可以相互通讯，实现高效平滑地信息交换。
虽然 ERP 可能很复杂，但是，Odoo 通过简单的，甚至是简洁的界面使它变得很友好。这个界面让人联想到谷歌云盘，它只让你需要的功能可见。在你决定签定采购合同之前，你可以 [得到一个 Odoo 去试用](https://www.odoo.com/page/start)。
Odoo 是基于 web 的工具。按单个模块来订阅的话，每个模块每月需要支付 20 美元。你也可以 [下载它](https://www.odoo.com/page/download)，或者可以从 GitHub 上获得 [源代码](https://github.com/odoo)，它以 [LGPLv3](https://github.com/odoo/odoo/blob/11.0/LICENSE) 方式授权。
### Opentaps
[Opentaps](http://www.opentaps.org/) 是专为大型业务设计的几个开源 ERP 解决方案之一，它的功能强大而灵活。这并不奇怪，因为它是在 Apache OFBiz 基础之上构建的。
你可以得到你所希望的模块组合，来帮你管理存货、生产制造、财务，以及采购。它也有分析功能，帮你去分析业务的各个方面。你可以借助这些信息让未来的计划做的更好。Opentaps 也包含一个强大的报表功能。
在它的基础之上，你还可以 [购买一些插件和附加模块](http://shop.opentaps.org/) 去增强 Opentaps 的功能。包括与 Amazon Marketplace Services 和 FedEx 的集成等。在你 [下载 Opentaps](http://www.opentaps.org/products/download) 之前，你可以到 [在线 demo](http://www.opentaps.org/products/online-demo) 上试用一下。它遵守 [GPLv3](https://www.gnu.org/licenses/agpl-3.0.html) 许可。
### WebERP
[WebERP](http://www.weberp.org/) 是一个如它的名字所表示的那样：一个通过 Web 浏览器来使用的 ERP 系统。另外还需要的其它软件只有一个，那就是查看报告所使用的 PDF 阅读器。
具体来说，它是一个面向批发、分销、生产制造业务的账务和业务管理解决方案。它也可以与 [第三方的业务软件](http://www.weberp.org/Links.html) 集成，包括多地点零售管理的销售点系统、电子商务模块、以及构建业务知识库的 wiki 软件。它是用 PHP 写的，并且它致力于成为低资源占用、高效、快速、以及平台无关的、普通商业用户易于使用的 ERP 系统。
WebERP 正在积极地进行开发，并且它有一个活跃的 [论坛](http://www.weberp.org/forum/)，在那里你可以咨询问题或者学习关于如何使用这个应用程序的相关知识。你也可以试用一个 [demo](http://www.weberp.org/weberp/)，或者在 GitHub 上下载它的 [源代码](https://github.com/webERP-team/webERP)（遵守 [GPLv2](https://github.com/webERP-team/webERP#legal) 许可）
### xTuple PostBooks
如果你的生产制造、分销、电子商务业务已经从小规模业务成长起来了，并且正在寻找一个适合你的成长型企业的 ERP 系统，那么，你可以去了解一下 [xTuple PostBooks](https://xtuple.com/)。它是围绕核心 ERP 功能、帐务、以及可以添加存货、分销、采购、以及供应商报告等 CRM 功能构建的全面解决方案的系统。
xTuple 在通用公共属性许可证（[CPAL](https://xtuple.com/products/license-options#cpal)）下使用，并且这个项目欢迎开发者去分叉它，然后为基于存货的生产制造型企业开发其它的业务软件。它的基于 web 的核心是用 JavaScript 写的，它的 [源代码](http://xtuple.github.io/) 可以在 GitHub 上找到。你可以去在 xTuple 的网站上注册一个免费的 [demo](https://xtuple.com/free-demo) 去了解它。
还有许多其它的开源 ERP 可供你选择 — 另外你可以去了解的还有 [Tryton](http://www.tryton.org/)，它是用 Python 写的，并且使用的是 PostgreSQL 数据库引擎，或者基于 Java 的 [Axelor](https://www.axelor.com/)，它的好处是用户可以使用拖放界面来创建或者修改业务应用。如果还有在这里没有列出的你喜欢的开源 ERP 解决方案，请在下面的评论区共享出来。你也可以去查看我们的 [供应链管理工具](https://opensource.com/tools/supply-chain-management) 榜单。
这篇文章是 [以前版本](https://opensource.com/article/16/3/top-4-open-source-erp-systems) 的一个更新版，它是由 Opensource.com 的主席 [Scott Nesbitt](https://opensource.com/users/scottnesbitt) 所写。
---
via: <https://opensource.com/tools/enterprise-resource-planning>
作者：[Opensource.com](https://opensource.com) 选题：[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/) 荣誉推出
|
||
对可互换通证（ERC-20 系列）的通证 ERC 的比较
|
Alexander Culum
|
http://blockchainers.org/index.php/2018/02/08/token-erc-comparison-for-fungible-tokens/
|
目前为止，如果你想遵循 “行业标准”，你只能选择 ERC-20。它获得了最广泛的理解与支持。但是，它还是有缺陷的
|
/data/attachment/album/201806/28/103303kriej2twmwwip8wp.jpg.thumb.jpg
|
/data/attachment/album/201806/28/103303kriej2twmwwip8wp.jpg
| true | false | true |
qhwdw
| false |
[
"ERC-20",
"以太坊"
] |
技术
|
{
"viewnum": 5040,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
目前为止，如果你想遵循 “行业标准”，你只能选择 ERC-20。它获得了最广泛的理解与支持。但是，它还是有缺陷的
| 2018-06-28T10:33:39 | 2018-06-28T10:33:39 | 9,786 |
/article-9786-1.html
|
>
> “对于标准来说，最好的事情莫过于大量的人都去选择使用它。“
>
>
> —— [*Andrew S. Tanenbaum*](https://www.goodreads.com/quotes/589703-the-good-thing-about-standards-is-that-there-are-so)
>
>
>
### 通证标准的现状
在以太坊平台上，通证标准的现状出奇的简单：ERC-20 <ruby> 通证 <rt> token </rt></ruby>标准是通证接口中唯一被采用（ [EIP-20](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md)）和接受的通证标准。
它在 2015 年被提出，最终接受是在 2017 年末。
在此期间，提出了许多解决 ERC-20 缺点的<ruby> 以太坊意见征集 <rt> Ethereum Requests for Comments </rt></ruby>（ERC），其中的一部分是因为以太坊平台自身变更所导致的，比如，由 [EIP-150](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-150.md) 修复的<ruby> 重入 <rt> re-entrancy </rt></ruby> bug。其它 ERC 提出的对 ERC-20 通证模型的强化。这些强化是通过收集大量的以太坊区块链和 ERC-20 通证标准的使用经验所确定的。ERC-20 通证接口的实际应用产生了新的要求和需要，比如像权限和操作方面的非功能性需求。
这篇文章将浅显但完整地对以太坊平台上提出的所有通证（类）的标准进行简单概述。我将尽可能客观地去做比较，但不可避免地仍有一些不客观的地方。
### 通证标准之母：ERC-20
有成打的 [非常好的](https://medium.com/@jgm.orinoco/understanding-erc-20-token-contracts-a809a7310aa5) 关于 ERC-20 的详细描述，在这里就不一一列出了。只对在文章中提到的相关核心概念做个比较。
#### 提取模式
用户不太好理解 ERC-20 接口，尤其是从一个<ruby> 外部所有者帐户 <rt> externally owned account </rt></ruby>（EOA）*转账* 通证的模式，即一个终端用户（“Alice”）到一个智能合约的转账，很难正确理解 `approve`/`transferFrom` 模式。
从软件工程师的角度看，这个提取模式非常类似于 <ruby> <a href="http://matthewtmead.com/blog/hollywood-principle-dont-call-us-well-call-you-4/"> 好莱坞原则 </a> <rt> Hollywood Principle </rt></ruby> （“不要给我们打电话，我们会给你打电话的！”）。那个调用链的想法正好相反：在 ERC-20 通证转账中，通证不能调用合约，但是合约可以调用通证上的 `transferFrom`。
虽然好莱坞原则经常用于去实现<ruby> 关注点分离 <rt> Separation-of-Concerns </rt></ruby>（SoC），但在以太坊中它是一个安全模式，目的是为了防止通证合约去调用外部合约上的未知的函数。这种行为是非常有必要的，因为会出现 <ruby> <a href="https://consensys.github.io/smart-contract-best-practices/known_attacks/"> 调用深度攻击 </a> <rt> Call Depth Attack </rt></ruby>，直到 [EIP-150](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-150.md) 被启用才解决。在这个硬分叉之后，这个重入 bug 将不再可能出现了，并且提取模式也不能提供任何比直接通证调用更好的安全性。
但是，为什么现在它成了一个问题呢？可能是由于某些原因，它的用法设计有些欠佳，但是我们可以通过前端的 DApp 来修复这个问题，对吗？
因此，我们来看一看，如果一个用户使用 `transfer` 去发送一些通证到智能合约会发生什么事情。Alice 对通证合约的合约地址进行转账，
**….啊啊啊，它不见了！**
是的，通证没有了。很有可能，没有任何人再能拿回通证了。但是像 Alice 的这种做法并不鲜见，正如 ERC-223 的发明者 Dexaran 所发现的，大约有 $400.000 的通证（由于 ETH 波动很大，我们只能说很多）是由于用户意外发送到智能合约中，并因此而丢失。
即便合约开发者是一个非常友好和无私的用户，他也不能创建一个合约以便将它收到的通证返还给你。因为合约并不会提示这类转账，并且事件仅在通证合约上发出。
从软件工程师的角度来看，那就是 ERC-20 的重大缺点。如果发生一个事件（为简单起见，我们现在假设以太坊交易是真实事件），对参与的当事人应该有一个提示。但是，这个事件是在通证的智能合约中触发的，合约接收方是无法知道它的。
目前，还不能做到防止用户向智能合约发送通证，并且在 ERC-20 通证合约上使用这种不直观的转账将导致这些发送的通证永远丢失。
### 帝国反击战：ERC-223
第一个尝试去修复 ERC-20 的问题的提案是 [Dexaran](https://github.com/Dexaran) 提出来的。这个提议通过将 EOA 和智能合约账户做不同的处理的方式来解决这个问题。
强制的策略是去反转调用链（并且使用 [EIP-150](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-150.md) 解决它现在能做到了），并且在正在接收的智能合约上使用一个预定义的回调（`tokenFallback`）。如果回调没有实现，转账将失败（将消耗掉发送方的燃料，这是 ERC-223 最常被批评的一个地方）。
**好处：**
* 创建一个新接口，有意使用这个废弃的函数来不遵守 ERC-20
* 允许合约开发者去处理收到的通证（即：接受/拒绝）并因此遵守事件模式
* 用一个交易来代替两个交易（`transfer` vs. `approve`/`transferFrom`）并且节省了燃料和区域链的存储空间
**坏处：**
* 如果 `tokenFallback` 不存在，那么合约的 `fallback` 功能将运行，这可能会产生意料之外的副作用
* 假如合约使用通证转账功能的话，比如，发送通证到一个特定的像多签名钱包一样的账户，这将使 ERC-223 通证失败，它将不能转移（即它们会丢失）。
### 程序员修练之道：ERC-677
[ERC-667：transferAndCall 通证标准](https://github.com/ethereum/EIPs/issues/677) 尝试将 ERC-20 和 ERC-223 结合起来。这个创意是在 ERC-20 中引入一个 `transferAndCall` 函数，并保持标准不变。ERC-223 有意不完全向后兼容，由于不再需要 `approve`/`allowance` 模式，并因此将它删除。
ERC-667 的主要目标是向后兼容，为新合约向外部合约转账提供一个安全的方法。
**好处：**
* 容易适用新的通证
* 兼容 ERC-20
* 为 ERC-20 设计的适配器用于安全使用 ERC-20
**坏处：**
* 不是真正的新方法。只是一个 ERC-20 和 ERC-223 的折衷
* 目前实现 [尚未完成](https://github.com/ethereum/EIPs/issues/677#issuecomment-353871138)
### 重逢：ERC-777
[ERC-777：一个先进的新通证标准](https://github.com/ethereum/EIPs/issues/777)，引入它是为了建立一个演进的通证标准，它是吸取了像带值的 `approve()` 以及上面提到的将通证发送到合约这样的错误观念的教训之后得来的演进后标准。
另外，ERC-777 使用了新标准 [ERC-820：使用一个注册合约的伪内省](https://github.com/ethereum/EIPs/issues/820)，它允许为合约注册元数据以提供一个简单的内省类型。并考虑到了向后兼容和其它的功能扩展，这些取决于由一个 EIP-820 查找到的地址返回的 `ITokenRecipient`，和由目标合约实现的函数。
ERC-777 增加了许多使用 ERC-20 通证的经验，比如，白名单操作者、提供带 `send(…)` 的以太兼容的接口，为了向后兼容而使用 ERC-820 去覆盖和调整功能。
**好处：**
* 从 ERC-20 的使用经验上得来的、经过深思熟虑的、进化的通证接口
* 为内省要求 ERC-820 使用新标准，接受了增加的功能
* 白名单操作者非常有用，而且比 `approve`/`allowance` 更有必要，它经常是无限的
**坏处：**
* 刚刚才开始，复杂的依赖合约调用的结构
* 依赖导致出现安全问题的可能性增加：第一个安全问题并不是在 ERC-777 中 [确认（并解决的）](https://github.com/ethereum/EIPs/issues/820#issuecomment-362049573)，而是在最新的 ERC-820 中
### （纯主观的）结论（轻喷）
目前为止，如果你想遵循 “行业标准”，你只能选择 ERC-20。它获得了最广泛的理解与支持。但是，它还是有缺陷的，最大的一个缺陷是因为非专业用户设计和规范问题导致的用户真实地损失金钱的问题。ERC-223 是非常好的，并且在理论上找到了 ERC-20 中这个问题的答案了，它应该被考虑为 ERC-20 的一个很好的替代标准。在一个新通证中实现这两个接口并不复杂，并且可以降低燃料的使用。
ERC-677 是事件和金钱丢失问题的一个务实的解决方案，但是它并没能提供足够多的新方法，以促使它成为一个标准。但是它可能是 ERC-20 2.0 的一个很好的候选者。
ERC-777 是一个更先进的通证标准，它应该成为 ERC-20 的合法继任者，它提供了以太坊平台所需要的非常好的成熟概念，像白名单操作者，并允许以优雅的方式进行扩展。由于它的复杂性和对其它新标准的依赖，在主链上出现第一个 ERC-777 标准的通证还需要些时日。
### 链接
1. 在 ERC-20 中使用 approve/transferFrom 模式的安全问题： <https://drive.google.com/file/d/0ByMtMw2hul0EN3NCaVFHSFdxRzA/view>
2. ERC-20 中的无事件操作：<https://docs.google.com/document/d/1Feh5sP6oQL1-1NHi-X1dbgT3ch2WdhbXRevDN681Jv4>
3. ERC-20 的故障及历史：<https://github.com/ethereum/EIPs/issues/223#issuecomment-317979258>
4. ERC-20/223 的不同之处：<https://ethereum.stackexchange.com/questions/17054/erc20-vs-erc223-list-of-differences>
---
via: <http://blockchainers.org/index.php/2018/02/08/token-erc-comparison-for-fungible-tokens/>
作者：[Alexander Culum](http://blockchainers.org/index.php/author/alex/) 选题：[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/) 荣誉推出
|
||
让孩子爱上计算机和编程的 15 本书
|
Jen Wike Huger
|
https://opensource.com/article/18/5/books-kids-linux-open-source
|
在工作之余，我听说不少技术专家透露出让他们自己的孩子学习更多关于 Linux 和 开源知识的意愿
|
/data/attachment/album/201806/28/111532ce0bs1e11qe2e9sr.jpg.thumb.jpg
|
/data/attachment/album/201806/28/111532ce0bs1e11qe2e9sr.jpg
| true | false | true |
pinewall
| false |
[
"孩子",
"书籍"
] |
分享
|
{
"viewnum": 10578,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在工作之余，我听说不少技术专家透露出让他们自己的孩子学习更多关于 Linux 和 开源知识的意愿
| 2018-06-28T11:15:45 | 2018-06-28T11:15:45 | 9,787 |
/article-9787-1.html
|
>
> 以及，还有三本是给宝宝的。
>
>
>
在工作之余，我听说不少技术专家透露出让他们自己的孩子学习更多关于 [Linux](https://opensource.com/resources/linux) 和 [开源](https://opensource.com/article/18/3/what-open-source-programming)知识的意愿，他们中有的来自高管层，有的来自普通岗位。其中一些似乎时间比较充裕，伴随其孩子一步一步成长。另一些人可能没有充足的时间让他们的孩子看到为何 Linux 和 开源如此之酷。也许他们能抽出时间，但这不一定。在这个大世界中，有太多有趣、有价值的事物。
不论是哪种方式，如果你的或你认识的孩子愿意学习使用编程和硬件，实现游戏或机器人之类东西，那么这份书单很适合你。
### 面向儿童 Linux 和 开源爱好者的 15 本书
**《[零基础学 Raspberry Pi](https://www.amazon.com/Adventures-Raspberry-Carrie-Anne-Philbin/dp/1119046025)》，作者 Carrie Anne Philbin**
在对编程感兴趣的儿童和成人中，体积小小的、仅信用卡一般大的树莓派引起了强烈的反响。你台式机能做的事情它都能做，具备一定的基础编程技能后，你可以让它做更多的事情。本书操作简明、项目风趣、技能扎实，是一本儿童可用的终极编程指南。（[Joshua Allen Holm](https://opensource.com/users/holmja) 推荐，评论节选于本书的内容提要）
**《[Python 编程快速上手：让繁琐工作自动化](https://automatetheboringstuff.com/)》，作者 Al Sweigart**
这是一本经典的编程入门书，行文足够清晰，11 岁及以上的编程爱好者都可以读懂本书并从中受益。读者很快就会投入到真实且实用的任务中，在此过程中顺便掌握了优秀的编程实践。最好的一点是，如果你愿意，你可以在互联网上阅读本书。（[DB Clinton](https://opensource.com/users/dbclinton) 推荐并评论）
**《[Scratch 游戏编程](https://www.goodreads.com/book/show/25733628-coding-games-in-scratch)》，作者 Jon Woodcock**
本书适用于 8-12 岁没有或仅有有限编程经验的儿童。作为一本直观的可视化入门书，它使用有趣的图形和易于理解的操作，教导年轻的读者如何使用 Scratch 这款流行的自由编程语言构建他们自己的编程项目。（[Joshua Allen Holm](https://opensource.com/users/holmja) 推荐，评论节选于本书的内容提要）
**《[用 Python 巧学数学](https://nostarch.com/doingmathwithpython)》，作者 Amit Saha**
无论你是一名学生还是教师，只要你对使用 Python 学习数学感兴趣，不妨读读本书。在逻辑上，本书带领读者一步一步地从基础到更为复杂的操作，从最开始简单的 Python shell 数字运算，到使用类似 matplotlib 这样的 Python 库实现数据可视化，读者可以很容易跟上作者的思路。本书充分调动你的好奇心，感叹 Python 与 数学结合的威力。（[Don Watkins](https://opensource.com/users/don-watkins) 推荐并评论）
**《[编程女生：学习编程，改变世界](https://www.amazon.com/Girls-Who-Code-Learn-Change/dp/042528753X)》，作者 Reshma Saujani**
作者是 Girls Who Code 运动的发起人，该运动得到 Sheryl Sandberg、 Malala Yousafzai 和 John Legend 支持。本书一部分是编程介绍，一部分女生赋能，这两部分都写得很有趣。本书包括动态艺术作品、零基础的编程原理讲解以及在 Pixar 和 NASA 等公司工作的女生的真实故事。这本书形象生动，向读者展示了计算机科学在我们生活中发挥的巨大作用以及其中的趣味。（[Joshua Allen Holm](https://opensource.com/users/holmja) 推荐，评论节选于本书的内容提要）
**《[Python 游戏编程快速上手](http://inventwithpython.com/invent4thed/)》，作者 Al Sweigart**
本书将让你学会如何使用流行的 Python 编程语言编写计算机游戏，不要求具有编程经验！入门阶段编写<ruby> 刽子手 <rt> Hangman </rt></ruby>，猜数字，<ruby> 井字游戏 <rt> Tic-Tac-Toe </rt></ruby>这样的经典游戏，后续更进一步编写高级一些的游戏，例如文字版寻宝游戏，以及带音效和动画的<ruby> 碰撞与闪避 <rt> collision-dodgoing </rt></ruby>游戏。（[Joshua Allen Holm](https://opensource.com/users/holmja) 推荐，评论节选于本书的内容提要）
**《[Lauren Ipsum：关于计算机科学和一些不可思议事物的故事](https://www.amazon.com/gp/product/1593275749/ref=as_li_tl?ie=UTF8&tag=projemun-20&camp=1789&creative=9325&linkCode=as2&creativeASIN=1593275749&linkId=e05e1f12176c4959cc1aa1a050908c4a)》，作者 Carlos Bueno**
本书采用爱丽丝梦游仙境的风格，女主角 Lauren Ipsum 来到一个稍微具有魔幻色彩的世界。世界的自然法则是逻辑学和计算机科学，世界谜题只能通过学习计算机编程原理并编写代码完成。书中没有提及计算机，但其作为世界的核心存在。（[DB Clinton](https://opensource.com/users/dbclinton) 推荐并评论）
**《[Java 轻松学](https://nostarch.com/learnjava)》，作者 Bryson Payne**
Java 是全世界最流行的编程语言，但众所周知上手比较难。本书让 Java 学习不再困难，通过若干实操项目，让你马上学会构建真实可运行的应用。（[Joshua Allen Holm](https://opensource.com/users/holmja) 推荐，评论节选于本书的内容提要）
**《[终身幼儿园](http://lifelongkindergarten.net/)》，作者 Mitchell Resnick**
幼儿园正变得越来越像学校。在本书中，学习专家 Mitchel Resnick 提出相反的看法：学校（甚至人的一生）应该更像幼儿园。要适应当今快速变化的世界，各个年龄段的人们都必须学会开创性思维和行动；想要达到这个目标，最好的方式就是更加专注于想象、创造、玩耍、分享和反馈，就像孩子在传统幼儿园中那样。基于在 MIT <ruby> 媒体实验室 <rt> Media Lab </rt></ruby> 30 多年的经历， Resnick 讨论了新的技术和策略，可以让年轻人拥有开创性的学习体验。（[Don Watkins](https://opensource.com/users/don-watkins) 推荐，评论来自 Amazon 书评）
**《[趣学 Python：教孩子学编程](https://nostarch.com/pythonforkids)》，作者 Jason Briggs**
在本书中，Jason Briggs 将 Python 编程教学艺术提升到新的高度。我们可以很容易地将本书用作入门书，适用群体可以是教师/学生，也可以是父母/儿童。通过一步步引导的方式介绍复杂概念，让编程新手也可以成功完成，进一步激发学习欲望。本书是一本极为易读、寓教于乐但又强大的 Python 编程入门书。读者将学习基础数据结构，包括<ruby> 元组 <rt> turple </rt></ruby>、<ruby> 列表 <rt> list </rt></ruby>和<ruby> 映射 <rt> map </rt></ruby>等，学习如何创建函数、重用代码或者使用包括循环和条件语句在内的控制结构。孩子们还将学习如何创建游戏和动画，体验 Tkinter 的强大并创建高级图形。（[Don Watkins](https://opensource.com/users/don-watkins) 推荐并评论）
**《[Scratch 编程园地](https://nostarch.com/scratchplayground)》，作者 Al Sweigart**
Scratch 编程一般被视为一种寓教于乐的教年轻人编程的方式。在本书中，Al Sweigart 告诉我们 Scratch 是一种超出绝大多数人想象的强大编程语言。独特的风格，大师级的编写和呈现。Al 让孩子通过创造复杂图形和动画，短时间内认识到 Scratch 的强大之处。（[Don Watkins](https://opensource.com/users/don-watkins) 推荐并评论）
**《[秘密编程者](http://www.secret-coders.com/)》，作者 Gene Luen Yang，插图作者 Mike Holmes**
Gene Luen Yang 是漫画小说超级巨星，也是一所高中的计算机编程教师。他推出了一个非常有趣的系列作品，将逻辑谜题、基础编程指令与引入入胜的解谜情节结合起来。故事发生在 Stately Academy 这所学校，其中充满有待解开的谜团。（[Joshua Allen Holm](https://opensource.com/users/holmja) 推荐，评论节选于本书的内容提要）
**《[想成为编程者吗？编程、视频游戏制作、机器人等职业终极指南！](https://www.amazon.com/So-You-Want-Coder-Programming/dp/1582705798?tag=ad-backfill-amzn-no-or-one-good-20)》，作者 Jane Bedell**
酷爱编程？这本书易于理解，描绘了以编程为生的完整图景，激发你的热情，磨练你的专业技能。（[Joshua Allen Holm](https://opensource.com/users/holmja) 推荐，评论节选于本书的内容提要）
**《[教孩子编程](https://opensource.com/education/15/9/review-bryson-payne-teach-your-kids-code)》，作者 Bryson Payne**
你是否在寻找一种寓教于乐的方式教你的孩子 Python 编程呢？Bryson Payne 已经写了这本大师级的书。本书通过乌龟图形打比方，引导你编写一些简单程序，为高级 Python 编程打下基础。如果你打算教年轻人编程，这本书不容错过。（[Don Watkins](https://opensource.com/users/don-watkins) 推荐并评论）
**《[图解 Kubernetes（儿童版）](https://deis.com/blog/2016/kubernetes-illustrated-guide/)》，作者 Matt Butcher, 插画作者 Bailey Beougher**
介绍了 Phippy 这个勇敢的 PHP 小应用及其 Kubernetes 之旅。（[Chris Short](https://opensource.com/users/chrisshort) 推荐，评论来自 [Matt Butcher 的博客](https://deis.com/blog/2016/kubernetes-illustrated-guide/)）
### 给宝宝的福利书
**《[宝宝的 CSS](https://www.amazon.com/CSS-Babies-Code-Sterling-Childrens/dp/1454921560/)》、《[宝宝的 Javascript](https://www.amazon.com/Javascript-Babies-Code-Sterling-Childrens/dp/1454921579/)》、《[宝宝的 HTML](https://www.amazon.com/HTML-Babies-Code-Sterling-Childrens/dp/1454921552)》，作者 Sterling Children's**
这本概念书让宝宝熟悉图形和颜色的种类，这些是互联网编程语言的基石。这本漂亮的书用富有色彩的方式介绍了编程和互联网，对于技术人士的家庭而言，本书是一份绝佳的礼物。（[Chris Short](https://opensource.com/users/chrisshort) 推荐，评论来自 Amazon 书评）
你是否有想要分享的适合宝宝或儿童的书呢？请在评论区留言告诉我们。
---
via: <https://opensource.com/article/18/5/books-kids-linux-open-source>
作者：[Jen Wike Huger](https://opensource.com/users/remyd) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 GitHub 上对编程语言与软件质量的一个大规模研究
|
Acm
|
https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007
|
在这项研究中，我们从 GitHub 上收集了大量的数据（728 个项目，6300 万行源代码，29000 位作者，150 万个提交，17 种编程语言），尝试在这个问题上提供一些实证。
|
/data/attachment/album/201806/28/180042t9ilo3tizks3qtpp.jpg.thumb.jpg
|
/data/attachment/album/201806/28/180042t9ilo3tizks3qtpp.jpg
| true | false | true |
qhwdw
| false |
[
"编程语言",
"GitHub",
"软件质量"
] |
技术
|
{
"viewnum": 7436,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这项研究中，我们从 GitHub 上收集了大量的数据（728 个项目，6300 万行源代码，29000 位作者，150 万个提交，17 种编程语言），尝试在这个问题上提供一些实证。
| 2018-06-28T18:01:00 | 2018-06-28T18:01:00 | 9,788 |
/article-9788-1.html
|
编程语言对软件质量的影响是什么？这个问题在很长一段时间内成为一个引起了大量辩论的主题。在这项研究中，我们从 GitHub 上收集了大量的数据（728 个项目，6300 万行源代码，29000 位作者，150 万个提交，17 种编程语言），尝试在这个问题上提供一些实证。这个还算比较大的样本数量允许我们去使用一个混合的方法，结合多种可视化的回归模型和文本分析，去研究语言特性的影响，比如，在软件质量上，静态与动态类型和允许混淆与不允许混淆的类型。通过从不同的方法作三角测量研究（LCTT 译注：一种测量研究的方法），并且去控制引起混淆的因素，比如，团队大小、项目大小和项目历史，我们的报告显示，语言设计确实（对很多方面）有很大的影响，但是，在软件质量方面，语言的影响是非常有限的。最明显的似乎是，不允许混淆的类型比允许混淆的类型要稍微好一些，并且，在函数式语言中，静态类型也比动态类型好一些。值得注意的是，这些由语言设计所引起的轻微影响，绝大多数是由过程因素所主导的，比如，项目大小、团队大小和提交数量。但是，我们需要提示读者，即便是这些不起眼的轻微影响，也是由其它的无形的过程因素所造成的，例如，对某些函数类型、以及不允许类型混淆的静态语言的偏爱。
### 1 序言
在给定的编程语言是否是“适合这个工作的正确工具”的讨论期间，紧接着又发生了多种辩论。虽然一些辩论出现了带有宗教般狂热的色彩，但是大部分人都一致认为，编程语言的选择能够对编码过程和由此生成的结果都有影响。
主张强静态类型的人，倾向于认为静态方法能够在早期捕获到缺陷；他们认为，一点点的预防胜过大量的矫正。动态类型拥护者主张，保守的静态类型检查无论怎样都是非常浪费开发者资源的，并且，最好是依赖强动态类型检查来捕获错误类型。然而，这些辩论，大多数都是“纸上谈兵”，只靠“传说中”的证据去支持。
这些“传说”也许并不是没有道理的；考虑到影响软件工程结果的大量其它因素，获取这种经验性的证据支持是一项极具挑战性的任务，比如，代码质量、语言特征，以及应用领域。比如软件质量，考虑到它有大量的众所周知的影响因素，比如，代码数量， <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R6"> 6 </a></sup> 团队大小， <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R2"> 2 </a></sup> 和年龄/熟练程度。 <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R9"> 9 </a></sup>
受控实验是检验语言选择在面对如此令人气馁的混淆影响时的一种方法，然而，由于成本的原因，这种研究通常会引入一种它们自己的混淆，也就是说，限制了范围。在这种研究中，完整的任务是必须要受限制的，并且不能去模拟 *真实的世界* 中的开发。这里有几个最近的这种大学本科生使用的研究，或者，通过一个实验因素去比较静态或动态类型的语言。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R7"> 7 </a> ， <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R12"> 12 </a> ， <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R15"> 15 </a></sup>
幸运的是，现在我们可以基于大量的真实世界中的软件项目去研究这些问题。GitHub 包含了多种语言的大量的项目，并且在大小、年龄、和开发者数量上有很大的差别。每个项目的仓库都提供一个详细的记录，包含贡献历史、项目大小、作者身份以及缺陷修复。然后，我们使用多种工具去研究语言特性对缺陷发生的影响。对我们的研究方法的最佳描述应该是“混合方法”，或者是三角测量法； <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R5"> 5 </a></sup> 我们使用文本分析、聚簇和可视化去证实和支持量化回归研究的结果。这个以经验为根据的方法，帮助我们去了解编程语言对软件质量的具体影响，因为，他们是被开发者非正式使用的。
### 2 方法
我们的方法是软件工程中典型的大范围观察研究法。我们首先大量的使用自动化方法，从几种数据源采集数据。然后使用预构建的统计分析模型对数据进行过滤和清洗。过滤器的选择是由一系列的因素共同驱动的，这些因素包括我们研究的问题的本质、数据质量和认为最适合这项统计分析研究的数据。尤其是，GitHub 包含了由大量的编程语言所写的非常多的项目。对于这项研究，我们花费大量的精力专注于收集那些用大多数的主流编程语言写的流行项目的数据。我们选择合适的方法来评估计数数据上的影响因素。
#### 2.1 数据收集
我们选择了 GitHub 上的排名前 19 的编程语言。剔除了 CSS、Shell 脚本、和 Vim 脚本，因为它们不是通用的编程语言。我们包含了 Typescript，它是 JavaScript 的超集。然后，对每个被研究的编程语言，我们检索出以它为主要编程语言的前 50 个项目。我们总共分析了 17 种不同的语言，共计 850 个项目。
我们的编程语言和项目的数据是从 *GitHub Archive* 中提取的，这是一个记录所有活跃的公共 GitHub 项目的数据库。它记录了 18 种不同的 GitHub 事件，包括新提交、fork 事件、PR（拉取请求）、开发者信息和以每小时为基础的所有开源 GitHub 项目的问题跟踪。打包后的数据上传到 Google BigQuery 提供的交互式数据分析接口上。
**识别编程语言排名榜单**
我们基于它们的主要编程语言分类合计项目。然后，我们选择大多数的项目进行进一步分析，如 [表 1](http://deliveryimages.acm.org/10.1145/3130000/3126905/t1.jpg) 所示。一个项目可能使用多种编程语言；将它确定成单一的编程语言是很困难的。Github Archive 保存的信息是从 GitHub Linguist 上采集的，它使用项目仓库中源文件的扩展名来确定项目的发布语言是什么。源文件中使用数量最多的编程语言被确定为这个项目的 *主要编程语言*。
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/t1.jpg)
*表 1 每个编程语言排名前三的项目*
**检索流行的项目**
对于每个选定的编程语言，我们先根据项目所使用的主要编程语言来选出项目，然后根据每个项目的相关 *星* 的数量排出项目的流行度。 *星* 的数量表示了有多少人主动表达对这个项目感兴趣，并且它是流行度的一个合适的代表指标。因此，在 C 语言中排名前三的项目是 linux、git、php-src；而对于 C++，它们则是 node-webkit、phantomjs、mongo ；对于 Java，它们则是 storm、elasticsearch、ActionBarSherlock 。每个编程语言，我们各选了 50 个项目。
为确保每个项目有足够长的开发历史，我们剔除了少于 28 个提交的项目（28 是候选项目的第一个四分位值数）。这样我们还剩下 728 个项目。[表 1](http://deliveryimages.acm.org/10.1145/3130000/3126905/t1.jpg) 展示了每个编程语言的前三个项目。
**检索项目演进历史**
对于 728 个项目中的每一个项目，我们下载了它们的非合并提交、提交记录、作者数据、作者使用 *git* 的名字。我们从每个文件的添加和删除的行数中计算代码改动和每个提交的修改文件数量。我们以每个提交中修改的文件的扩展名所代表的编程语言，来检索出所使用的编程语言（一个提交可能有多个编程语言标签）。对于每个提交，我们通过它的提交日期减去这个项目的第一个提交的日期，来计算它的 *提交年龄* 。我们也计算其它的项目相关的统计数据，包括项目的最大提交年龄和开发者总数，用于我们的回归分析模型的控制变量，它在第三节中会讨论到。我们通过在提交记录中搜索与错误相关的关键字，比如，`error`、`bug`、`fix`、`issue`、`mistake`、`incorrect`、`fault`、`defect`、`flaw`，来识别 bug 修复提交。这一点与以前的研究类似。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R18"> 18 </a></sup>
[表 2](http://deliveryimages.acm.org/10.1145/3130000/3126905/t2.jpg) 汇总了我们的数据集。因为一个项目可能使用多个编程语言，表的第二列展示了使用某种编程语言的项目的总数量。我们进一步排除了项目中该编程语言少于 20 个提交的那些编程语言。因为 20 是每个编程语言的每个项目的提交总数的第一个四分位值。例如，我们在 C 语言中共找到 220 项目的提交数量多于 20 个。这确保了每个“编程语言 – 项目”对有足够的活跃度。
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/t2.jpg)
*表 2 研究主题*
总而言之，我们研究了最近 18 年以来，用了 17 种编程语言开发的，总共 728 个项目。总共包括了 29,000 个不同的开发者，157 万个提交，和 564,625 个 bug 修复提交。
#### 2.2 语言分类
我们基于影响语言质量的几种编程语言特性定义了语言类别，<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R7"> 7 </a> ， <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R8"> 8 </a> ， <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R12"> 12 </a></sup> ，如 [表 3](http://deliveryimages.acm.org/10.1145/3130000/3126905/t3.jpg) 所示。
<ruby> 编程范式 <rt> Programming Paradigm </rt></ruby> 表示项目是以命令方式、脚本方式、还是函数语言所写的。在本文的下面部分，我们分别使用 <ruby> 命令 <rt> procedural </rt></ruby> 和 <ruby> 脚本 <rt> scripting </rt></ruby> 这两个术语去代表命令方式和脚本方式。
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/t3.jpg)
*表 3. 语言分类的不同类型*
<ruby> 类型检查 <rt> Type Checking </rt></ruby> 代表静态或者动态类型。在静态类型语言中，在编译时进行类型检查，并且变量名是绑定到一个值和一个类型的。另外，（包含变量的）表达式是根据运行时，它们可能产生的值所符合的类型来分类的。在动态类型语言中，类型检查发生在运行时。因此，在动态类型语言中，它可能出现在同一个程序中，一个变量名可能会绑定到不同类型的对象上的情形。
<ruby> 隐式类型转换 <rt> Implicit Type Conversion </rt></ruby> 允许一个类型为 T1 的操作数，作为另一个不同的类型 T2 来访问，而无需进行显式的类型转换。这样的隐式类型转换在一些情况下可能会带来类型混淆，尤其是当它表示一个明确的 T1 类型的操作数时，把它再作为另一个不同的 T2 类型的情况下。因为，并不是所有的隐式类型转换都会立即出现问题，通过我们识别出的允许进行隐式类型转换的所有编程语言中，可能发生隐式类型转换混淆的例子来展示我们的定义。例如，在像 Perl、 JavaScript、CoffeeScript 这样的编程语言中，一个字符和一个数字相加是允许的（比如，`"5" + 2` 结果是 `"52"`）。但是在 Php 中，相同的操作，结果是 `7`。像这种操作在一些编程语言中是不允许的，比如 Java 和 Python，因为，它们不允许隐式转换。在强数据类型的 C 和 C++ 中，这种操作的结果是不可预料的，例如，`int x; float y; y=3.5; x=y`；是合法的 C 代码，并且对于 `x` 和 `y` 其结果是不同的值，具体是哪一个值，取决于含义，这可能在后面会产生问题。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#FNA"> a </a></sup> 在 `Objective-C` 中，数据类型 *id* 是一个通用对象指针，它可以被用于任何数据类型的对象，而不管分类是什么。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#FNB"> b </a> 像这种通用数据类型提供了很好的灵活性，它可能导致隐式的类型转换，并且也会出现不可预料的结果。 <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#FNC"> c </a> </sup></sup> 因此，我们根据它的编译器是否 *允许* 或者 *不允许* 如上所述的隐式类型转换，对编程语言进行分类；而不允许隐式类型转换的编程语言，会显式检测类型混淆，并报告类型不匹配的错误。
不允许隐式类型转换的编程语言，使用一个类型判断算法，比如，Hindley <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R10"> 10 </a></sup> 和 Milner，<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R17"> 17 </a></sup> 或者，在运行时上使用一个动态类型检查器，可以在一个编译器（比如，使用 Java）中判断静态类型的结果。相比之下，一个类型混淆可能会悄无声息地发生，因为，它可能因为没有检测到，也可能是没有报告出来。无论是哪种方式，允许隐式类型转换在提供了灵活性的同时，最终也可能会出现很难确定原因的错误。为了简单起见，我们将用 <ruby> 隐含 <rt> implicit </rt></ruby> 代表允许隐式类型转换的编程语言，而不允许隐式类型转换的语言，我们用 <ruby> 明确 <rt> explicit </rt></ruby> 代表。
<ruby> 内存分类 <rt> Memory Class </rt></ruby> 表示是否要求开发者去管理内存。尽管 Objective-C 遵循了一个混合模式，我们仍将它放在非管理的分类中来对待，因为，我们在它的代码库中观察到很多的内存错误，在第 3 节的 RQ4 中会讨论到。
请注意，我们之所以使用这种方式对编程语言来分类和研究，是因为，这种方式在一个“真实的世界”中被大量的开发人员非正式使用。例如，TypeScript 被有意地分到静态编程语言的分类中，它不允许隐式类型转换。然而，在实践中，我们注意到，开发者经常（有 50% 的变量，并且跨 TypeScript —— 在我们的数据集中使用的项目）使用 `any` 类型，这是一个笼统的联合类型，并且，因此在实践中，TypeScript 允许动态地、隐式类型转换。为减少混淆，我们从我们的编程语言分类和相关的模型中排除了 TypeScript（查看 [表 3](http://deliveryimages.acm.org/10.1145/3130000/3126905/t3.jpg) 和 [7](http://deliveryimages.acm.org/10.1145/3130000/3126905/t7.jpg)）。
#### 2.3 识别项目领域
我们基于编程语言的特性和功能，使用一个自动加手动的混合技术，将研究的项目分类到不同的领域。在 GitHub 上，项目使用 `project descriptions` 和 `README` 文件来描述它们的特性。我们使用一种文档主题生成模型（Latent Dirichlet Allocation，缩写为：LDA） <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R3"> 3 </a></sup> 去分析这些文本。提供一组文档给它，LDA 将生成不同的关键字，然后来识别可能的主题。对于每个文档，LDA 也估算每个主题分配的文档的概率。
我们检测到 30 个不同的领域（换句话说，就是主题），并且评估了每个项目从属于每个领域的概率。因为，这些自动检测的领域包含了几个具体项目的关键字，例如，facebook，很难去界定它的底层的常用功能。为了给每个领域分配一个有意义的名字，我们手动检查了 30 个与项目名字无关的用于识别领域的领域识别关键字。我们手动重命名了所有的 30 个自动检测的领域，并且找出了以下六个领域的大多数的项目：应用程序、数据库、代码分析、中间件、库，和框架。我们也找出了不符合以上任何一个领域的一些项目，因此，我们把这个领域笼统地标记为 *其它* 。随后，我们研究组的另一名成员检查和确认了这种项目领域分类的方式。[表 4](http://deliveryimages.acm.org/10.1145/3130000/3126905/t4.jpg) 汇总了这个过程识别到的领域结果。
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/t4.jpg)
*表 4 领域特征*
#### 2.4 bug 分类
尽管修复软件 bug 时，开发者经常会在提交日志中留下关于这个 bug 的原始的重要信息；例如，为什么会产生 bug，以及怎么去修复 bug。我们利用很多信息去分类 bug，与 Tan 的 *et al* 类似。 <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R13"> 13 </a> ， <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R24"> 24 </a></sup>
首先，我们基于 bug 的 <ruby> 原因 <rt> Cause </rt></ruby> 和 <ruby> 影响 <rt> Impact </rt></ruby> 进行分类。\_ 原因 \_ 进一步分解为不相关的错误子类：算法方面的、并发方面的、内存方面的、普通编程错误，和未知的。bug 的 *影响* 也分成四个不相关的子类：安全、性能、失败、和其它的未知类。因此，每个 bug 修复提交也包含原因和影响的类型。[表 5](http://deliveryimages.acm.org/10.1145/3130000/3126905/t5.jpg) 展示了描述的每个 bug 分类。这个类别分别在两个阶段中被执行：
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/t5.jpg)
*表 5 bug 分类和在整个数据集中的描述*
**(1) 关键字搜索** 我们随机选择了 10% 的 bug 修复信息，并且使用一个基于关键字的搜索技术去对它们进行自动化分类，作为可能的 bug 类型。我们对这两种类型（原因和影响）分别使用这个注释。我们选择了一个限定的关键字和习惯用语集，如 [表 5](http://deliveryimages.acm.org/10.1145/3130000/3126905/t5.jpg) 所展示的。像这种限定的关键字和习惯用语集可以帮我们降低误报。
**(2) 监督分类** 我们使用前面步骤中的有注释的 bug 修复日志作为训练数据，为监督学习分类技术，通过测试数据来矫正，去对剩余的 bug 修复信息进行分类。我们首先转换每个 bug 修复信息为一个词袋（LCTT 译注：bag-of-words，一种信息检索模型）。然后，删除在所有的 bug 修复信息中仅出现过一次的词。这样减少了具体项目的关键字。我们也使用标准的自然语言处理技术来解决这个问题。最终，我们使用支持向量机（LCTT 译注：Support Vector Machine，缩写为 SVM，在机器学习领域中，一种有监督的学习算法）去对测试数据进行分类。
为精确评估 bug 分类器，我们手动注释了 180 个随机选择的 bug 修复，平均分布在所有的分类中。然后，我们比较手动注释的数据集在自动分类器中的结果。最终处理后的，表现出的精确度是可接受的，性能方面的精确度最低，是 70%，并发错误方面的精确度最高，是 100%，平均是 84%。再次运行，精确度从低到高是 69% 到 91%，平均精确度还是 84%。
我们的 bug 分类的结果展示在 [表 5](http://deliveryimages.acm.org/10.1145/3130000/3126905/t5.jpg) 中。大多数缺陷的原因都与普通编程错误相关。这个结果并不意外，因为，在这个分类中涉及了大量的编程错误，比如，类型错误、输入错误、编写错误、等等。我们的技术并不能将在任何（原因或影响）分类中占比为 1.4% 的 bug 修复信息再次进行分类；我们将它归类为未知。
#### 2.5 统计方法
我们使用回归模型对软件项目相关的其它因素中的有缺陷的提交数量进行了建模。所有的模型使用<ruby> 负二项回归 <rt> negative binomial regression </rt></ruby>（缩写为 NBR）（LCTT 译注：一种回归分析模型） 去对项目属性计数进行建模，比如，提交数量。NBR 是一个广义的线性模型，用于对非负整数进行响应建模。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R4"> 4 </a></sup>
在我们的模型中，我们对每个项目的编程语言，控制几个可能影响最终结果的因素。因此，在我们的回归分析中，每个（语言/项目）对是一个行，并且可以视为来自流行的开源项目中的样本。我们依据变量计数进行对象转换，以使变量保持稳定，并且提升了模型的适用度。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R4"> 4 </a></sup> 我们通过使用 AIC 和 Vuong 对非嵌套模型的测试比较来验证它们。
去检查那些过度的多重共线性（LCTT 译注：多重共线性是指，在线性回归模型中解释变量之间由于存在精确相关关系或高度相关关系而使模型估计失真或难以估计准确。）并不是一个问题，我们在所有的模型中使用一个保守的最大值 5，去计算每个依赖的变量的膨胀因子的方差。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R4"> 4 </a></sup> 我们通过对每个模型的残差和杠杆图进行视觉检查来移除高杠杆点，找出库克距离（LCTT 译注：一个统计学术语，用于诊断回归分析中是否存在异常数据）的分离值和最大值。
我们利用 *效果* ，或者 *差异* ，编码到我们的研究中，以提高编程语言回归系数的表现。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R4"> 4 </a></sup> 加权的效果代码允许我们将每种编程语言与所有编程语言的效果进行比较，同时弥补了跨项目使用编程语言的不均匀性。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R23"> 23 </a></sup> 去测试两种变量因素之间的联系，我们使用一个独立的卡方检验（LCTT 译注：Chi-square，一种统计学上的假设检验方法）测试。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R14"> 14 </a></sup> 在证实一个依赖之后，我们使用 Cramer 的 V，它是与一个 `r × c` 等价的正常数据的 `phi(φ)` 系数，去建立一个效果数据。
### 3 结果
我们从简单明了的问题开始，它非常直接地解决了人们坚信的一些核心问题，即：
#### 问题 1：一些编程语言相比其它语言来说更易于出现缺陷吗？
我们使用了回归分析模型，去比较每个编程语言对所有编程语言缺陷数量平均值的影响，以及对缺陷修复提交的影响（查看 [表 6](http://deliveryimages.acm.org/10.1145/3130000/3126905/t6.jpg)）。
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/t6.jpg)
*表 6. 一些语言的缺陷要少于其它语言*
我们包括了一些变量，作为对明确影响反应的控制因子。项目<ruby> 年龄 <rt> age </rt></ruby>也包括在内，因为，越老的项目生成的缺陷修复数量越大。<ruby> 提交 <rt> commits </rt></ruby>数量也会对项目反应有轻微的影响。另外，从事该项目的<ruby> 开发人员 <rt> dev </rt></ruby>的数量和项目的原始<ruby> 大小 <rt> size </rt></ruby>，都会随着项目的活跃而增长。
上述模型中估算系数的大小和符号（LCTT 译注：指 “+”或者“-”）与结果的预测因子有关。初始的四种变量是控制变量，并且，我们对这些变量对最终结果的影响不感兴趣，只是说它们都是积极的和有意义的。语言变量是指示变量，是每个项目的变化因子，该因子将每种编程语言与所有项目的编程语言的加权平均值进行比较。编程语言系数可以大体上分为三类。第一类是，那些在统计学上无关紧要的系数，并且在建模过程中这些系数不能从 0 中区分出来。这些编程语言的表现与平均值相似，或者它们也可能有更大的方差。剩余的系数是非常明显的，要么是正的，要么是负的。对于那些正的系数，我们猜测可能与这个编程语言有大量的缺陷修复相关。这些语言包括 C、C++、Objective-C、Php，以及 Python。所有的有一个负的系数的编程语言，比如 Clojure、Haskell、Ruby，和 Scala，暗示这些语言的缺陷修复提交可能小于平均值。
应该注意的是，虽然，从统计学的角度观察到编程语言与缺陷之间有明显的联系，但是，大家不要过高估计编程语言对于缺陷的影响，因为，这种影响效应是非常小的。异常分析的结果显示，这种影响小于总异常的 1%。
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/ut1.jpg)
我们可以这样去理解模型的系数，它代表一个预测因子在所有其它预测因子保持不变的情况下，这个预测因子一个<ruby> 单位 <rt> unit </rt></ruby>的变化，所反应出的预期的响应的对数变化；换句话说，对于一个系数 β<sub> i</sub> ，在 β<sub> i</sub> 中一个单位的变化，产生一个预期的 e<sup> β <sub> i </sub></sup> 响应的变化。对于可变因子，这个预期的变化是与所有编程语言的平均值进行比较。因此，如果对于一定数量的提交，用一个处于平均值的编程语言开发的特定项目有四个缺陷提交，那么，如果选择使用 C++ 来开发，意味着我们预计应该有一个额外的（LCTT 译注：相对于平均值 4，多 1 个）缺陷提交，因为 e<sup> 0.18</sup> × 4 = 4.79。对于相同的项目，如果选择使用 Haskell 来开发，意味着我们预计应该少一个（LCTT 译注：同上，相对于平均值 4）缺陷提交。因为， e<sup> −0.26</sup> × 4 = 3.08。预测的精确度取决于剩余的其它因子都保持不变，除了那些微不足道的项目之外，所有的这些都是一个极具挑战性的命题。所有观察性研究都面临类似的局限性；我们将在第 5 节中详细解决这些事情。
**结论 1：一些编程语言相比其它编程语言有更高的缺陷相关度，不过，影响非常小。**
在这篇文章的剩余部分，我们会在基本结论的基础上详细阐述，通过考虑不同种类的应用程序、缺陷、和编程语言，可以进一步深入了解编程语言和缺陷倾向之间的关系。
软件 bug 通常落进两种宽泛的分类中：
1. *特定领域的 bug* ：特定于项目功能，并且不依赖于底层编程语言。
2. *普通 bug* ：大多数的普通 bug 是天生的，并且与项目功能无关，比如，输入错误，并发错误、等等。
因此，在一个项目中，应用程序领域和编程语言相互作用可能会影响缺陷的数量，这一结论被认为是合理的。因为一些编程语言被认为在一些任务上相比其它语言表现更突出，例如，C 对于低级别的（底层）工作，或者，Java 对于用户应用程序，对于编程语言的一个不合适的选择，可能会带来更多的缺陷。为研究这种情况，我们将理想化地忽略领域特定的 bug，因为，普通 bug 更依赖于编程语言的特性。但是，因为一个领域特定的 bug 也可能出现在一个普通的编程错误中，这两者是很难区分的。一个可能的变通办法是在控制领域的同时去研究编程语言。从统计的角度来看，虽然，使用 17 种编程语言跨 7 个领域，在给定的样本数量中，理解大量的术语将是一个极大的挑战。
鉴于这种情况，我们首先考虑在一个项目中测试领域和编程语言使用之间的依赖关系，独立使用一个<ruby> 卡方检验 <rt> Chi-square </rt></ruby>测试。在 119 个单元中，是 46 个，也就是说是 39%，它在我们设定的保守值 5 以上，它太高了。这个数字不能超过 20%，应该低于 5。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R14"> 14 </a></sup> 我们在这里包含了完整有值； <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#FND"> d </a></sup> 但是，通过 Cramer 的 V 测试的值是 0.191，是低相关度的，表明任何编程语言和领域之间的相关度是非常小的，并且，在回归模型中包含领域并不会产生有意义的结果。
去解决这种情况的一个选择是，去移除编程语言，或者混合领域，但是，我们现有的数据没有进行完全挑选。或者，我们混合编程语言；这个选择导致一个相关但略有不同的问题。
#### 问题 2： 哪些编程语言特性与缺陷相关？
我们按编程语言类别聚合它们，而不是考虑单独的编程语言，正如在第 2.2 节所描述的那样，然后去分析与缺陷的关系。总体上说，这些属性中的每一个都将编程语言按照在上下文中经常讨论的错误、用户辩论驱动、或者按以前工作主题来划分的。因此，单独的属性是高度相关的，我们创建了六个模型因子，将所有的单独因子综合到我们的研究中。然后，我们对六个不同的因子对缺陷数量的影响进行建模，同时控制我们在 *问题 1* 节中使用的模型中的相同的基本协变量（LCTT 译注：协变量是指在实验中不能被人为操纵的独立变量）。
关于使用的编程语言（在前面的 [表 6](http://deliveryimages.acm.org/10.1145/3130000/3126905/t6.jpg)中），我们使用跨所有语言类的平均反应来比较编程语言 *类* 。这个模型在 [表 7](http://deliveryimages.acm.org/10.1145/3130000/3126905/t7.jpg) 中表达了出来。很明显，`Script-Dynamic-Explicit-Managed` 类有最小的量级系数。这个系数是微不足道的，换句话说，对这个系数的 <ruby> Z 校验 <rt> z-test </rt></ruby>（LCTT 译注：统计学上的一种平均值差异校验的方法） 并不能把它从 0 中区分出来。鉴于标准错误的量级，我们可以假设，在这个类别中的编程语言的行为是非常接近于所有编程语言行为的平均值。我们可以通过使用 `Proc-Static-Implicit-Unmanaged` 作为基本级并用于处理，或者使用基本级来虚假编码比较每个语言类，来证明这一点。在这种情况下，`Script-Dynamic-Explicit-Managed` 是明显不同于 *p* = 0.00044 的。注意，虽然我们在这是选择了不同的编码方法，影响了系数和 Z 值，这个方法和所有其它的方面都是一样的。当我们改变了编码，我们调整系数去反应我们希望生成的对比。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R4"> 4 </a></sup> 将其它类的编程语言与总体平均数进行比较，`Proc-Static-Implicit-Unmanaged` 类编程语言更容易引起缺陷。这意味着与其它过程类编程语言相比，隐式类型转换或者管理内存会导致更多的缺陷倾向。
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/t7.jpg)
*表 7. 函数式语言与缺陷的关联度和其它类语言相比要低，而过程类语言则大于或接近于平均值。*
在脚本类编程语言中，我们观察到类似于允许与不允许隐式类型转换的编程语言之间的关系，它们提供的一些证据表明，隐式类型转换（与显式类型转换相比）才是导致这种差异的原因，而不是内存管理。鉴于各种因素之间的相关性，我们并不能得出这个结论。但是，当它们与平均值进行比较时，作为一个组，那些不允许隐式类型转换的编程语言出现错误的倾向更低一些，而那些出现错误倾向更高的编程语言，出现错误的机率则相对更高。在函数式编程语言中静态和动态类型之间的差异也很明显。
函数式语言作为一个组展示了与平均值的很明显的差异。静态类型语言的系数要小很多，但是函数式语言类都有同样的标准错误。函数式静态编程语言出现错误的倾向要小于函数式动态编程语言，这是一个强有力的证据，尽管如此，Z 校验仅仅是检验系数是否能从 0 中区分出来。为了强化这个推论，我们使用处理编码，重新编码了上面的模型，并且观察到，`Functional-Static-Explicit-Managed` 编程语言类的错误倾向是明显小于 `Functional-Dynamic-Explicit-Managed` 编程语言类的 *p* = 0.034。
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/ut2.jpg)
与编程语言和缺陷一样，编程语言类与缺陷之间关系的影响是非常小的。解释类编程语言的这种差异也是相似的，虽然很小，解释类编程语言的这种差异小于 1%。
我们现在重新回到应用领域这个问题。应用领域是否与语言类相互影响？怎么选择？例如，一个函数化编程语言，对特定的领域有一定的优势？与上面一样，对于这些因素和项目领域之间的关系做一个卡方检验，它的值是 99.05， *df* = 30， *p* = 2.622e–09，我们拒绝无意义假设，Cramer 的 V 产生的值是 0.133，表示一个弱关联。因此，虽然领域和编程语言之间有一些关联，但在这里应用领域和编程语言类之间仅仅是一个非常弱的关联。
**结论 2：在编程语言类与缺陷之间有一个很小但是很明显的关系。函数式语言与过程式或者脚本式语言相比，缺陷要少。**
这个结论有些不太令人满意的地方，因为，我们并没有一个强有力的证据去证明，在一个项目中编程语言或者语言类和应用领域之间的关联性。一个替代方法是，基于全部的编程语言和应用领域，忽略项目和缺陷总数，而去查看相同的数据。因为，这样不再产生不相关的样本，我们没有从统计学的角度去尝试分析它，而是使用一个描述式的、基于可视化的方法。
我们定义了 <ruby> 缺陷倾向 <rt> Defect Proneness </rt></ruby> 作为 bug 修复提交与每语言每领域总提交的比率。[图 1](http://deliveryimages.acm.org/10.1145/3130000/3126905/f1.jpg) 使用了一个热力图展示了应用领域与编程语言之间的相互作用，从亮到暗表示缺陷倾向在增加。我们研究了哪些编程语言因素影响了跨多种语言写的项目的缺陷修复提交。它引出了下面的研究问题：
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/f1.jpg)
*图 1. 编程语言的缺陷倾向与应用领域之间的相互作用。对于一个给定的领域（列底部），热力图中的每个格子表示了一个编程语言的缺陷倾向（行头部）。“整体”列表示一个编程语言基于所有领域的缺陷倾向。用白色十字线标记的格子代表一个 null 值，换句话说，就是在那个格子里没有符合的提交。*
#### 问题 3： 编程语言的错误倾向是否取决于应用领域？
为了回答这个问题，我们首先在我们的回归模型中，以高杠杆点过滤掉认为是异常的项目，这种方法在这里是必要的，尽管这是一个非统计学的方法，一些关系可能影响可视化。例如，我们找到一个简单的项目，Google 的 v8，一个 JavaScript 项目，负责中间件中的所有错误。这对我们来说是一个惊喜，因为 JavaScript 通常不用于中间件。这个模式一直在其它应用领域中不停地重复着，因此，我们过滤出的项目的缺陷度都低于 10% 和高于 90%。这个结果在 [图 1](http://deliveryimages.acm.org/10.1145/3130000/3126905/f1.jpg) 中。
我们看到在这个热力图中仅有一个很小的差异，正如在问题 1 节中看到的那样，这个结果仅表示编程语言固有的错误倾向。为验证这个推论，我们测量了编程语言对每个应用领域和对全部应用领域的缺陷倾向。对于除了数据库以外的全部领域，关联性都是正向的，并且 p 值是有意义的（<0.01）。因此，关于缺陷倾向，在每个领域的语言排序与全部领域的语言排序是基本相同的。
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/ut3.jpg)
**结论 3： 应用领域和编程语言缺陷倾向之间总体上没有联系。**
我们证明了不同的语言产生了大量的缺陷，并且，这个关系不仅与特定的语言相关，也适用于一般的语言类；然而，我们发现，项目类型并不能在一定程度上协调这种关系。现在，我们转变我们的注意力到反应分类上，我想去了解，编程语言与特定种类的缺陷之间有什么联系，以及这种关系怎么与我们观察到的更普通的关系去比较。我们将缺陷分为不同的类别，如 [表 5](http://deliveryimages.acm.org/10.1145/3130000/3126905/t5.jpg) 所描述的那样，然后提出以下的问题：
#### 问题 4：编程语言与 bug 分类之间有什么关系？
我们使用了一个类似于问题 3 中所用的方法，去了解编程语言与 bug 分类之间的关系。首先，我们研究了 bug 分类和编程语言类之间的关系。一个热力图（[图 2](http://deliveryimages.acm.org/10.1145/3130000/3126905/f2.jpg)）展示了在编程语言类和 bug 类型之上的总缺陷数。去理解 bug 分类和语言之间的相互作用，我们对每个类别使用一个 NBR 回归模型。对于每个模型，我们使用了与问题 1 中相同的控制因素，以及使用加权效应编码后的语言，去预测缺陷修复提交。
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/f2.jpg)
*图 2. bug 类别与编程语言类之间的关系。每个格子表示每语言类（行头部）每 bug 类别（列底部）的 bug 修复提交占全部 bug 修复提交的百分比。这个值是按列规范化的。*
结果和编程语言的方差分析值展示在 [表 8](http://deliveryimages.acm.org/10.1145/3130000/3126905/t8.jpg) 中。每个模型的整体异常是非常小的，并且对于特定的缺陷类型，通过语言所展示的比例在大多数类别中的量级是类似的。我们解释这种关系为，编程语言对于特定的 bug 类别的影响要大于总体的影响。尽管我们结论概括了全部的类别，但是，在接下来的一节中，我们对 [表 5](http://deliveryimages.acm.org/10.1145/3130000/3126905/t5.jpg) 中反应出来的 bug 数较多的 bug 类别做进一步研究。
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/t8.jpg)
*表 8. 虽然编程语言对缺陷的影响因缺陷类别而不同，但是，编程语言对特定的类别的影响要大于一般的类别。*
**编程错误** 普通的编程错误占所有 bug 修复提交的 88.53% 左右，并且在所有的编程语言类中都有。因此，回归分析给出了一个与问题 1 中类似的结论（查看 [表 6](http://deliveryimages.acm.org/10.1145/3130000/3126905/t6.jpg)）。所有的编程语言都会导致这种编程错误，比如，处理错误、定义错误、输入错误、等等。
**内存错误** 内存错误占所有 bug 修复提交的 5.44%。热力图 [图 2](http://deliveryimages.acm.org/10.1145/3130000/3126905/f2.jpg) 证明了在 `Proc-Static-Implicit-Unmanaged` 类和内存错误之间存在着非常紧密的联系。非管理内存的编程语言出现内存 bug，这是预料之中的。[表 8](http://deliveryimages.acm.org/10.1145/3130000/3126905/t8.jpg) 也证明了这一点，例如，C、C++、和 Objective-C 引发了很多的内存错误。在管理内存的语言中 Java 引发了更多的内存错误，尽管它少于非管理内存的编程语言。虽然 Java 自己做内存回收，但是，它出现内存泄露一点也不奇怪，因为对象引用经常阻止内存回收。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R11"> 11 </a></sup> 在我们的数据中，Java 的所有内存错误中，28.89% 是内存泄漏造成的。就数量而言，编程语言中内存缺陷相比其它类别的 *原因* 造成的影响要大很多。
**并发错误** 在总的 bug 修复提交中，并发错误相关的修复提交占 1.99%。热力图显示，`Proc-Static-Implicit-Unmanaged` 是主要的错误类型。在这种错误中，C 和 C++ 分别占 19.15% 和 7.89%，并且它们分布在各个项目中。
[](http://deliveryimages.acm.org/10.1145/3130000/3126905/ut4.jpg)
属于 `Static-Strong-Managed` 语言类的编程语言都被证实处于热力图中的暗区中，普通的静态语言相比其它语言产生更多的并发错误。在动态语言中，仅仅有 Erlang 有更多的并发错误倾向，或许与使用这种语言开发的并发应用程序非常多有关系。同样地，在 [表 8](http://deliveryimages.acm.org/10.1145/3130000/3126905/t8.jpg) 中的负的系数表明，用诸如 Ruby 和 `Php 这样的动态编程语言写的项目，并发错误要少一些。请注意，某些语言，如 JavaScript、CoffeeScript 和 TypeScript 是不支持并发的，在传统的惯例中，虽然 Php 具有有限的并发支持（取决于它的实现）。这些语言在我们的数据中引入了虚假的 0，因此，在 [表 8](http://deliveryimages.acm.org/10.1145/3130000/3126905/t8.jpg) 中这些语言的并发模型的系数，不能像其它的语言那样去解释。因为存在这些虚假的 0，所以在这个模型中所有语言的平均数非常小，它可能影响系数的大小，因此，她们给 w.r.t. 一个平均数，但是，这并不影响他们之间的相对关系，因为我们只关注它们的相对关系。
基于 bug 修复消息中高频词的文本分析表明，大多数的并发错误发生在一个条件争用、死锁、或者不正确的同步上，正如上面表中所示。遍历所有语言，条件争用是并发错误出现最多的原因，例如，在 Go 中占 92%。在 Go 中条件争用错误的改进，或许是因为使用了一个争用检测工具帮助开发者去定位争用。同步错误主要与消息传递接口（MPI）或者共享内存操作（SHM）相关。Erlang 和 Go 对线程间通讯使用 MPI <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#FNE"> e </a></sup> ，这就是为什么这两种语言没有发生任何 SHM 相关的错误的原因，比如共享锁、互斥锁等等。相比之下，为线程间通讯使用早期的 SHM 技术的语言写的项目，就可能存在锁相关的错误。
**安全和其它冲突错误** 在所有的 bug 修复提交中，与<ruby> 冲突 <rt> Impact </rt></ruby>错误相关的提交占了 7.33% 左右。其中，Erlang、C++、Python 与安全相关的错误要高于平均值（[表 8](http://deliveryimages.acm.org/10.1145/3130000/3126905/t8.jpg)）。Clojure 项目相关的安全错误较少（[图 2](http://deliveryimages.acm.org/10.1145/3130000/3126905/f2.jpg)）。从热力图上我们也可以看出来，静态语言一般更易于发生失败和性能错误，紧随其后的是 `Functional-Dynamic-Explicit-Managed` 语言，比如 Erlang。对异常结果的分析表明，编程语言与冲突失败密切相关。虽然安全错误在这个类别中是弱相关的，与残差相比，解释类语言的差异仍然比较大。
**结论 4： 缺陷类型与编程语言强相关；一些缺陷类型比如内存错误和并发错误也取决于早期的语言（所使用的技术）。对于特定类别，编程语言所引起的错误比整体更多。**
### 4. 相关工作
在编程语言比较之前做的工作分为以下三类：
#### (1) 受控实验
对于一个给定的任务，开发者使用不同的语言进行编程时受到监视。研究然后比较结果，比如，开发成果和代码质量。Hanenberg <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R7"> 7 </a></sup> 通过开发一个解析程序，对 48 位程序员监视了 27 小时，去比较了静态与动态类型。他发现这两者在代码质量方面没有显著的差异，但是，基于动态类型的语言花费了更短的开发时间。他们的研究是在一个实验室中，使用本科学生，设置了定制的语言和 IDE 来进行的。我们的研究正好相反，是一个实际的流行软件应用的研究。虽然我们只能够通过使用回归模型间接（和 *事后* ）控制混杂因素，我们的优势是样本数量大，并且更真实、使用更广泛的软件。我们发现在相同的条件下，静态化类型的语言比动态化类型的语言更少出现错误倾向，并且不允许隐式类型转换的语言要好于允许隐式类型转换的语言，其对结果的影响是非常小的。这是合理的，因为样本量非常大，所以这种非常小的影响在这个研究中可以看得到。
Harrison et al. <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R8"> 8 </a></sup> 比较了 C++ 与 SML，一个是过程化编程语言，一个是函数化编程语言，在总的错误数量上没有找到显著的差异，不过 SML 相比 C++ 有更高的缺陷密集度。SML 在我们的数据中并没有体现出来，不过，认为函数式编程语言相比过程化编程语言更少出现缺陷。另一个重点工作是比较跨不同语言的开发工作。<sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R12"> 12 </a> ， <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R20"> 20 </a></sup> 不过，他们并不分析编程语言的缺陷倾向。
#### (2) 调查
Meyerovich 和 Rabkin <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R16"> 16 </a></sup> 调查了开发者对编程语言的观点，去研究为什么一些编程语言比其它的语言更流行。他们的报告指出，非编程语言的因素影响非常大：先前的编程语言技能、可用的开源工具、以及现有的老式系统。我们的研究也证明，可利用的外部工具也影响软件质量；例如，在 Go 中的并发 bug（请查看问题 4 节内容）。
#### (3) 对软件仓库的挖掘
Bhattacharya 和 Neamtiu <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R1"> 1 </a></sup> 研究了用 C 和 C++ 开发的四个项目，并且发现在 C++ 中开发的组件一般比在 C 中开发的组件更可靠。我们发现 C 和 C++ 的错误倾向要高于全部编程语言的平均值。但是，对于某些 bug 类型，像并发错误，C 的缺陷倾向要高于 C++（请查看第 3 节中的问题 4）。
### 5. 有效的风险
我们认为，我们的报告的结论几乎没有风险。首先，在识别 bug 修复提交方面，我们依赖的关键字是开发者经常用于表示 bug 修复的关键字。我们的选择是经过认真考虑的。在一个持续的开发过程中，我们去捕获那些开发者一直面对的问题，而不是他们报告的 bug。不过，这种选择存在过高估计的风险。我们对领域分类是为了去解释缺陷的倾向，而且，我们研究组中另外的成员验证过分类。此外，我们花费精力去对 bug 修复提交进行分类，也可能有被最初选择的关键字所污染的风险。每个项目在提交日志的描述上也不相同。为了缓解这些风险，我们像 2.4 节中描述的那样，利用手工注释评估了我们的类别。
我们判断文件所属的编程语言是基于文件的扩展名。如果使用不同的编程语言写的文件使用了我们研究的通用的编程语言文件的扩展名，这种情况下也容易出现错误倾向。为减少这种错误，我们使用一个随机样本文件集手工验证了我们的语言分类。
根据我们的数据集所显示的情形，2.2 节中的解释类编程语言，我们依据编程语言属性的主要用途作了一些假设。例如，我们将 Objective-C 分到非管理内存类型中，而不是混合类型。同样，我们将 Scala 注释为函数式编程语言，将 C# 作为过程化的编程语言，虽然，它们在设计的选择上两者都支持。 <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R19"> 19 </a> ， <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R21"> 21 </a></sup> 在这项研究工作中，我们没有从过程化编程语言中分离出面向对象的编程语言（OOP），因为，它们没有清晰的区别，主要差异在于编程类型。我们将 C++ 分到允许隐式类型转换的类别中是因为，某些类型的内存区域可以通过使用指针操作被进行不同的处理， <sup> <a href="https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007#R22"> 22 </a></sup> 并且我们注意到大多数 C++ 编译器可以在编译时检测类型错误。
最后，我们将缺陷修复提交关联到编程语言属性上，它们可以反应出报告的风格或者其它开发者的属性。可用的外部工具或者<ruby> 库 <rt> library </rt></ruby>也可以影响一个相关的编程语言的 bug 数量。
### 6. 总结
我们对编程语言和使用进行了大规模的研究，因为它涉及到软件质量。我们使用的 Github 上的数据，具有很高的复杂性和多个维度上的差异的特性。我们的样本数量允许我们对编程语言效果以及在控制一些混杂因素的情况下，对编程语言、应用领域和缺陷类型之间的相互作用，进行一个混合方法的研究。研究数据显示，函数式语言是好于过程化语言的；不允许隐式类型转换的语言是好于允许隐式类型转换的语言的；静态类型的语言是好于动态类型的语言的；管理内存的语言是好于非管理的语言的。进一步讲，编程语言的缺陷倾向与软件应用领域并没有关联。另外，每个编程语言更多是与特定的 bug 类别有关联，而不是与全部 bug。
另一方面，即便是很大规模的数据集，它们被多种方法同时进行分割后，也变得很小且不全面。因此，随着依赖的变量越来越多，很难去回答某个变量所产生的影响有多大这种问题，尤其是在变量之间相互作用的情况下。因此，我们无法去量化编程语言在使用中的特定的效果。其它的方法，比如调查，可能对此有帮助。我们将在以后的工作中来解决这些挑战。
### 致谢
这个材料是在美国国家科学基金会（NSF）以及美国空军科学研究办公室（AFOSR）的授权和支持下完成的。授权号 1445079, 1247280, 1414172，1446683，FA955-11-1-0246。
### 参考资料
1. Bhattacharya, P., Neamtiu, I. Assessing programming language impact on development and maintenance: A study on C and C++. In *Proceedings of the 33rd International Conference on Software Engineering, ICSE'11* (New York, NY USA, 2011). ACM, 171–180.
2. Bird, C., Nagappan, N., Murphy, B., Gall, H., Devanbu, P. Don't touch my code! Examining the effects of ownership on software quality. In *Proceedings of the 19th ACM SIGSOFT Symposium and the 13th European Conference on Foundations of Software Engineering* (2011). ACM, 4–14.
3. Blei, D.M. Probabilistic topic models. *Commun. ACM 55* , 4 (2012), 77–84.
4. Cohen, J. *Applied Multiple Regression/Correlation Analysis for the Behavioral Sciences.* Lawrence Erlbaum, 2003.
5. Easterbrook, S., Singer, J., Storey, M.-A., Damian, D. Selecting empirical methods for software engineering research. In *Guide to Advanced Empirical Software Engineering* (2008). Springer, 285–311.
6. El Emam, K., Benlarbi, S., Goel, N., Rai, S.N. The confounding effect of class size on the validity of object-oriented metrics. *IEEE Trans. Softw. Eng. 27* , 7 (2001), 630–650.
7. Hanenberg, S. An experiment about static and dynamic type systems: Doubts about the positive impact of static type systems on development time. In *Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications, OOPSLA'10* (New York, NY, USA, 2010). ACM, 22–35.
8. Harrison, R., Smaraweera, L., Dobie, M., Lewis, P. Comparing programming paradigms: An evaluation of functional and object-oriented programs. *Softw. Eng. J. 11* , 4 (1996), 247–254.
9. Harter, D.E., Krishnan, M.S., Slaughter, S.A. Effects of process maturity on quality, cycle time, and effort in software product development. *Manage. Sci. 46* 4 (2000), 451–466.
10. Hindley, R. The principal type-scheme of an object in combinatory logic. *Trans. Am. Math. Soc.* (1969), 29–60.
11. Jump, M., McKinley, K.S. Cork: Dynamic memory leak detection for garbage-collected languages. In *ACM SIGPLAN Notices* , Volume 42 (2007). ACM, 31–38.
12. Kleinschmager, S., Hanenberg, S., Robbes, R., Tanter, É., Stefik, A. Do static type systems improve the maintainability of software systems? An empirical study. In *2012 IEEE 20th International Conference on Program Comprehension (ICPC)* (2012). IEEE, 153–162.
13. Li, Z., Tan, L., Wang, X., Lu, S., Zhou, Y., Zhai, C. Have things changed now? An empirical study of bug characteristics in modern open source software. In *ASID'06: Proceedings of the 1st Workshop on Architectural and System Support for Improving Software Dependability* (October 2006).
14. Marques De Sá, J.P. *Applied Statistics Using SPSS, Statistica and Matlab* , 2003.
15. Mayer, C., Hanenberg, S., Robbes, R., Tanter, É., Stefik, A. An empirical study of the influence of static type systems on the usability of undocumented software. In *ACM SIGPLAN Notices* , Volume 47 (2012). ACM, 683–702.
16. Meyerovich, L.A., Rabkin, A.S. Empirical analysis of programming language adoption. In *Proceedings of the 2013 ACM SIGPLAN International Conference on Object Oriented Programming Systems Languages & Applications* (2013). ACM, 1–18.
17. Milner, R. A theory of type polymorphism in programming. *J. Comput. Syst. Sci. 17* , 3 (1978), 348–375.
18. Mockus, A., Votta, L.G. Identifying reasons for software changes using historic databases. In *ICSM'00. Proceedings of the International Conference on Software Maintenance* (2000). IEEE Computer Society, 120.
19. Odersky, M., Spoon, L., Venners, B. *Programming in Scala.* Artima Inc, 2008.
20. Pankratius, V., Schmidt, F., Garretón, G. Combining functional and imperative programming for multicore software: An empirical study evaluating scala and java. In *Proceedings of the 2012 International Conference on Software Engineering* (2012). IEEE Press, 123–133.
21. Petricek, T., Skeet, J. *Real World Functional Programming: With Examples in F# and C#.* Manning Publications Co., 2009.
22. Pierce, B.C. *Types and Programming Languages.* MIT Press, 2002.
23. Posnett, D., Bird, C., Dévanbu, P. An empirical study on the influence of pattern roles on change-proneness. *Emp. Softw. Eng. 16* , 3 (2011), 396–423.
24. Tan, L., Liu, C., Li, Z., Wang, X., Zhou, Y., Zhai, C. Bug characteristics in open source software. *Emp. Softw. Eng.* (2013).
### 作者
**Baishakhi Ray** ([rayb@virginia.edu](mailto:rayb@virginia.edu)), Department of Computer Science, University of Virginia, Charlottesville, VA.
**Daryl Posnett** ([dpposnett@ucdavis.edu](mailto:dpposnett@ucdavis.edu)), Department of Computer Science, University of California, Davis, CA.
**Premkumar Devanbu** ([devanbu@cs.ucdavis.edu](mailto:devanbu@cs.ucdavis.edu)), Department of Computer Science, University of California, Davis, CA.
**Vladimir Filkov** ([filkov@cs.ucdavis.edu](mailto:filkov@cs.ucdavis.edu)), Department of Computer Science, University of California, Davis, CA.
### 脚注
* a. Wikipedia's article on type conversion, <https://en.wikipedia.org/wiki/Type_conversion>, has more examples of unintended behavior in C.
* b. This Apple developer article describes the usage of "id" <http://tinyurl.com/jkl7cby>.
* c. Some examples can be found here <http://dobegin.com/objc-id-type/> and here <http://tinyurl.com/hxv8kvg>.
* d. Chi-squared value of 243.6 with 96 df. and p = 8.394e–15
* e. MPI does not require locking of shared resources.
---
via: <https://cacm.acm.org/magazines/2017/10/221326-a-large-scale-study-of-programming-languages-and-code-quality-in-github/fulltext?imm_mid=0f7103&cmp=em-prog-na-na-newsltr_20171007>
作者：[Baishakhi Ray](http://delivery.acm.org/10.1145/3130000/3126905/mailto:rayb@virginia.edu), [Daryl Posnett](http://delivery.acm.org/10.1145/3130000/3126905/mailto:dpposnett@ucdavis.edu), [Premkumar Devanbu](http://delivery.acm.org/10.1145/3130000/3126905/mailto:devanbu@cs.ucdavis.edu), [Vladimir Filkov](http://delivery.acm.org/10.1145/3130000/3126905/mailto:filkov@cs.ucdavis.edu) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
10 条加速 Ubuntu Linux 的杀手级技巧
|
Abhishek Prakash
|
https://itsfoss.com/speed-up-ubuntu-1310/
|
一些实用的加速 Ubuntu Linux 的技巧。 这里的技巧对于大多数版本的 Ubuntu 是有效的，也可以应用于 Linux Mint 以及其他的基于 Ubuntu 的发行版。
|
/data/attachment/album/201806/29/084505zm0hjcwjlkpa0w8m.jpg.thumb.jpg
|
/data/attachment/album/201806/29/084505zm0hjcwjlkpa0w8m.jpg
| true | false | true |
darsh8
| false |
[
"Ubuntu",
"优化"
] |
桌面应用
|
{
"viewnum": 12535,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
一些实用的加速 Ubuntu Linux 的技巧。 这里的技巧对于大多数版本的 Ubuntu 是有效的，也可以应用于 Linux Mint 以及其他的基于 Ubuntu 的发行版。
| 2018-06-29T08:45:00 | 2018-06-29T08:45:00 | 9,789 |
/article-9789-1.html
|
>
> 一些实际的**加速 Ubuntu Linux 的技巧**。 这里的技巧对于大多数版本的 Ubuntu 是有效的，也可以应用于 Linux Mint 以及其他的基于 Ubuntu 的发行版。
>
>
>
也许你经历过使用 Ubuntu 一段时间后系统开始运行缓慢的情况。 在这篇文章里，我们将看到几项调整以及**使 Ubuntu 运行更快的窍门**。
在我们了解如何提升 Ubuntu 的总体系统表现之前，首先让我们思考为什么系统逐渐变慢。这个问题可能有很多原因。也许你有一台只有基础配置的简陋的电脑；也许你安装了一些在启动时即耗尽资源的应用。事实上原因无穷无尽。
这里我列出一些能够帮助你稍微加速 Ubuntu 的小调整。也有一些你能够采用以获取一个更流畅、有所提升的系统表现的经验。你可以选择遵循全部或部分的建议。将各项调整一点一点的结合就能给你一个更流畅、更迅捷快速的 Ubuntu。
### 使 Ubuntu 更快的技巧
我在一个较老版本的 Ubuntu 上使用了这些调整，但是我相信其他的 Ubuntu 版本以及其他的例如 Linux Mint、 Elementary OS Luna 等基 Ubuntu 的 Linux 版本也是同样适用的。
#### 1、 减少默认的 grub 载入时间
Grub 给你 10 秒的时间以让你在多系统启动项或恢复模式之间改变。对我而言，它是多余的。它也意味着你将不得不坐在电脑旁，敲下回车键以尽可能快的启动进入 Ubuntu。这花了一点时间，不是吗？ 第一个技巧便是改变这个启动时间。如果你使用图形工具更舒适，阅读这篇文章来[使用 Grub 定制器改变 grub 时间以及启动顺序](https://itsfoss.com/windows-default-os-dual-boot-ubuntu-1304-easy/ "Make Windows Default OS In Dual Boot With Ubuntu 13.04: The Easy Way")。
如果更倾向于命令行，你可以简单地使用以下的命令来打开 grub 配置：
```
sudo gedit /etc/default/grub &
```
并且将 `GRUB_TIMEOUT=10` 改为 `GRUB_TIMEOUT=2`。这将改变启动时间为 2 秒。最好不要将这里改为 0，因为这样你将会失去在操作系统及恢复选项之间切换的机会。一旦你更改了 grub 配置，使用以下命令来使更改生效：
```
sudo update-grub
```
#### 2、 管理开机启动的应用
渐渐地你开始安装各种应用。 如果你是我们的老读者, 你也许从 [App of the week](https://itsfoss.com/tag/app-of-the-week/) 系列安装了许多应用。
这些应用中的一些在每次开机时都会启动，当然资源运行这些应用也会陷入繁忙。结果：一台电脑因为每次启动时的持续时间而变得缓慢。进入 Unity Dash 寻找 “Startup Applications”：
在这里，看看哪些应用在开机时被载入。现在考虑在你每次启动 Ubuntu 时是否有不需要启动的应用。尽管移除它们：
但是要是你不想从启动里移除它们怎么办？举个例子，如果你安装了 [Ubuntu 最好的指示器程序](https://itsfoss.com/best-indicator-applets-ubuntu/ "7 Best Indicator Applets For Ubuntu 13.10")之一， 你将想要它们在每次开机时自动地启动。
这里你所能做的就是延迟一些程序的启动时间。这样你将能够释放开机启动时的资源，并且一段时间后你的应用将被自动启动。在上一张图片里点击 Edit 并使用 sleep 选项来更改运行命令。
例如，如果你想要延迟 Dropbox 指示器的运行，我们指定时间 20 秒，你只需要在已有的命令里像这样**加入一个命令**：
```
sleep 20;
```
所以，命令 `dropbox start -i` 变为 `sleep 20; drobox start -i` 。这意味着现在 Dropbox 将延迟 20 秒启动。你可以通过相似的方法来改变另一个开机启动应用的启动时间。
#### 3、 安装 preload 来加速应用载入时间：
Preload 是一个后台运行的守护进程，它分析用户行为和频繁运行的应用。打开终端，使用如下的命令来安装 preload：
```
sudo apt-get install preload
```
安装后，重启你的电脑就不用管它了。它将在后台工作。[阅读更多关于preload](https://itsfoss.com/improve-application-startup-speed-with-preload-in-ubuntu/ "Improve Application Startup Speed With Preload in Ubuntu")
#### 4、 选择最好的软件更新镜像
验证你更新软件是否正在使用最好的镜像是很好的做法。Ubuntu 的软件仓库镜像跨过全球，使用离你最近的一个是相当明智的。随着从服务器获取包的时间减少，这将形成更快的系统更新。
在 “Software & Updates->Ubuntu Software tab->Download From” 里选择 “Other” 紧接着点击 “Select Best Server”：
它将运行测试来告知你那个是最好的镜像。正常地，最好的镜像已经被设置，但是我说过，验证它没什么坏处。并且，如果仓库缓存的最近的镜像没有频繁更新的话，这将引起获取更新时的一些延迟。这对于网速相对慢的人们是有用的。你可以使用这些技巧来[加速 Ubuntu 的 wifi](https://itsfoss.com/speed-up-slow-wifi-connection-ubuntu/ "Speed Up Slow WiFi Connection In Ubuntu 13.04")。
#### 5、 为了更快的更新，使用 apt-fast 而不是 apt-get
`apt-fast` 是 `apt-get` 的一个 shell 脚本包装器，通过从多连接同时下载包来提升更新及包下载速度。 如果你经常使用终端以及 `apt-get` 来安装和更新包，你也许会想要试一试 `apt-fast`。使用下面的命令来通过官方 PPA 安装 `apt-fast`：
```
sudo add-apt-repository ppa:apt-fast/stable
sudo apt-get update
sudo apt-get install apt-fast
```
#### 6、 从 apt-get 更新移除语言相关的 ign
你曾经注意过 `sudo apt-get` 更新的输出吗？其中有三种行，`hit`、`ign` 和 `get`。 你可以在[这里](http://ubuntuforums.org/showthread.php?t=231300)阅读它们的意义。如果你看到 IGN 行，你会发现它们中的大多数都与语言翻译有关。如果你使用所有的英文应用及包，你将完全不需要英文向英文的包数据库的翻译。
如果你从 `apt-get` 制止语言相关的更新，它将略微地增加 `apt-get` 的更新速度。为了那样，打开如下的文件：
```
sudo gedit /etc/apt/apt.conf.d/00aptitude
```
然后在文件末尾添加如下行：
```
Acquire::Languages "none";
```
[](https://itsfoss.com/wp-content/uploads/2014/01/ign_language-apt_get_update.jpeg)
#### 7、 减少过热
现在过热是电脑普遍的问题。一台过热的电脑运行相当缓慢。当你的 CPU 风扇转得像 [尤塞恩·博尔特](http://en.wikipedia.org/wiki/Usain_Bolt) 一样快，打开一个程序将花费很长的时间。有两个工具你可以用来减少过热，使 Ubuntu 获得更好的系统表现，即 TLP 和 CPUFREQ。
在终端里使用以下命令来安装 TLP：
```
sudo add-apt-repository ppa:linrunner/tlp
sudo apt-get update
sudo apt-get install tlp tlp-rdw
sudo tlp start
```
安装完 TLP 后你不需要做任何事。它在后台工作。
使用如下命令来安装 CPUFREQ 指示器：
```
sudo apt-get install indicator-cpufreq
```
重启你的电脑并使用 Powersave 模式：
#### 8、 调整 LibreOffice 来使它更快
如果你是频繁使用 office 产品的用户，那么你会想要稍微调整默认的 LibreOffice 使它更快。这里你将调整内存选项。打开 Open LibreOffice，进入 “Tools->Options”。在那里，从左边的侧栏选择“Memory”并启用 “Systray Quickstarter” 以及增加内存分配。
你可以阅读更多关于[如何提速 LibreOffice](https://itsfoss.com/speed-libre-office-simple-trick/ "Speed Up LibreOffice With This Simple Trick") 的细节。
#### 9、 使用轻量级的桌面环境 (如果你可以)
如果你选择安装默认的 Unity of GNOME 桌面环境, 你也许会选择一个轻量级的桌面环境像 [Xfce](https://xfce.org/) 或 [LXDE](https://lxde.org/)。
这些桌面环境使用更少的内存，消耗更少的 CPU。它们也自带轻量应用集来更深入地帮助更快地使用 Ubuntu。你可以参考这篇详细指南来学习[如何在 Ubuntu 上安装 Xfce](https://itsfoss.com/install-xfce-desktop-xubuntu/)。
当然，桌面也许没有 Unity 或 GNOME 看起来现代化。那是你必须做出的妥协。
#### 10、 使用不同应用的更轻量可选
这不仅仅是建议和喜好。一些默认的或者流行的应用是耗资源的且可能不适合低端的电脑。你能做的就是使用这些应用的一些替代品。例如，使用 [AppGrid](https://itsfoss.com/app-grid-lighter-alternative-ubuntu-software-center/ "App Grid: Lighter Alternative Of Ubuntu Software Center") 而不是 Ubuntu 软件中心。使用 [Gdebi](https://itsfoss.com/install-deb-files-easily-and-quickly-in-ubuntu-12-10-quick-tip/ "Install .deb Files Easily And Quickly In Ubuntu 12.10 [Quick Tip]") 来安装包。使用 AbiWord 而不是 LibreOffice Writer 等。
可以断定这些技巧的汇总使 Ubuntu 14.04，16.04 以及其他版本更快。我确定这些技巧会提供一个总体上更好的系统表现。
对于加速 Ubuntu 你也有妙计吗？这些技巧也帮到你了吗？分享你的观点。 问题，建议总是受欢迎的。请在评论区里提出来。
---
via: <https://itsfoss.com/speed-up-ubuntu-1310/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[darsh8](https://github.com/darsh8) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何暂时禁用 iptables 防火墙
|
Kerneltalks
|
https://kerneltalks.com/howto/how-to-disable-iptables-firewall-temporarily/
|
了解如何在 Linux 中暂时禁用 iptables 防火墙来进行故障排除。还要学习如何保存策略以及如何在启用防火墙时恢复它们。
|
/data/attachment/album/201806/30/090750t2j8purzppwjj5bq.png.thumb.jpg
|
/data/attachment/album/201806/30/090750t2j8purzppwjj5bq.png
| true | false | true |
geekpi
| false |
[
"iptables"
] |
技术
|
{
"viewnum": 10961,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "113.74.11.36",
"message": "这个操作的话、禁用就是把iptables规则全部清空吗？<br />\r\n<br />\r\niptables的服务不是还在吗、如果我新安装一个软件需要用到防火墙、岂不是这个软件会自动添加iptables规则?<br />\r\n<br />\r\n<br />\r\niptables和firewall能共存吗？ 我看测试优先权还是iptables生效<br />\r\n<br />\r\n<br />\r\n有没有办法能够完全让firewall替换iptables呢？<br />\r\n<br />\r\n<br />\r\n谢谢",
"username": "等待时候 [Chrome 80.0|Windows 7]",
"date": "2020-04-01T09:17:52"
}
] |
[] |
了解如何在 Linux 中暂时禁用 iptables 防火墙来进行故障排除。还要学习如何保存策略以及如何在启用防火墙时恢复它们。
| 2018-06-30T09:07:45 | 2018-06-30T09:07:45 | 9,791 |
/article-9791-1.html
|
>
> 了解如何在 Linux 中暂时禁用 iptables 防火墙来进行故障排除。还要学习如何保存策略以及如何在启用防火墙时恢复它们。
>
>
>
有时你需要关闭 iptables 防火墙来做一些连接故障排除，然后你需要重新打开它。在执行此操作时，你还需要保存所有[防火墙策略](https://kerneltalks.com/networking/configuration-of-iptables-policies/)。在本文中，我们将引导你了解如何保存防火墙策略以及如何禁用/启用 iptables 防火墙。有关 iptables 防火墙和策略的更多详细信息[请阅读我们的文章](https://kerneltalks.com/networking/basics-of-iptables-linux-firewall/)。
### 保存 iptables 策略
临时禁用 iptables 防火墙的第一步是保存现有的防火墙规则/策略。`iptables-save` 命令列出你可以保存到服务器中的所有现有策略。
```
root@kerneltalks # # iptables-save
# Generated by iptables-save v1.4.21 on Tue Jun 19 09:54:36 2018
*nat
:PREROUTING ACCEPT [1:52]
:INPUT ACCEPT [1:52]
:OUTPUT ACCEPT [15:1140]
:POSTROUTING ACCEPT [15:1140]
:DOCKER - [0:0]
---- output trucated----
root@kerneltalks # iptables-save > /root/firewall_rules.backup
```
因此，iptables-save 是可以用来备份 iptables 策略的命令。
### 停止/禁用 iptables 防火墙
对于较老的 Linux 内核，你可以选择使用 `service iptables stop` 停止 iptables 服务，但是如果你在用新内核，则只需清除所有策略并允许所有流量通过防火墙。这和你停止防火墙效果一样。
使用下面的命令列表来做到这一点。
```
root@kerneltalks # iptables -F
root@kerneltalks # iptables -X
root@kerneltalks # iptables -P INPUT ACCEPT
root@kerneltalks # iptables -P OUTPUT ACCEPT
root@kerneltalks # iptables -P FORWARD ACCEPT
```
这里 –
* `-F`：删除所有策略链
* `-X`：删除用户定义的链
* `-P INPUT/OUTPUT/FORWARD` ：接受指定的流量
完成后，检查当前的防火墙策略。它应该看起来像下面这样接受所有流量（和禁用/停止防火墙一样）
```
# iptables -L
Chain INPUT (policy ACCEPT)
target prot opt source destination
Chain FORWARD (policy ACCEPT)
target prot opt source destination
Chain OUTPUT (policy ACCEPT)
target prot opt source destination
```
### 恢复防火墙策略
故障排除后，你想要重新打开 iptables 的所有配置。你需要先从我们在第一步中执行的备份中恢复策略。
```
root@kerneltalks # iptables-restore </root/firewall_rules.backup
```
### 启动 iptables 防火墙
然后启动 iptables 服务，以防止你在上一步中使用 `service iptables start` 停止了它。如果你已经停止服务，那么只有恢复策略才能有用。检查所有策略是否恢复到 iptables 配置中：
```
# iptables -L
Chain INPUT (policy ACCEPT)
target prot opt source destination
Chain FORWARD (policy DROP)
target prot opt source destination
DOCKER-USER all -- anywhere anywhere
DOCKER-ISOLATION-STAGE-1 all -- anywhere anywhere
-----output truncated-----
```
就是这些了！你已成功禁用并启用了防火墙，而不会丢失你的策略规则。
---
via: <https://kerneltalks.com/howto/how-to-disable-iptables-firewall-temporarily/>
作者：[kerneltalks](https://kerneltalks.com) 选题：[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/) 荣誉推出
|
||
密码学及公钥基础设施入门
|
Alex Wood
|
https://opensource.com/article/18/5/cryptography-pki
|
学习密码学背后的基本概念，主要是保密性、完整性和身份认证。
|
/data/attachment/album/201806/30/093605tjvejilcrs5qlc40.jpg.thumb.jpg
|
/data/attachment/album/201806/30/093605tjvejilcrs5qlc40.jpg
| true | false | true |
pinewall
| true |
[
"加密",
"私钥",
"公钥"
] |
技术
|
{
"viewnum": 9154,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 10049,
"displayorder": 0
}
] |
学习密码学背后的基本概念，主要是保密性、完整性和身份认证。
| 2018-06-30T09:32:00 | 2018-06-30T09:32:00 | 9,792 |
/article-9792-1.html
|
>
> 学习密码学背后的基本概念，主要是保密性、完整性和身份认证。
>
>
>
安全通信正快速成为当今互联网的规范。从 2018 年 7 月起，Google Chrome 将对**全部**使用 HTTP 传输（而不是 HTTPS 传输）的站点[开始显示“不安全”警告](https://security.googleblog.com/2018/02/a-secure-web-is-here-to-stay.html)。虽然密码学已经逐渐变广为人知，但其本身并没有变得更容易理解。[Let's Encrypt](https://letsencrypt.org/) 设计并实现了一套令人惊叹的解决方案，可以提供免费安全证书和周期性续签；但如果不了解底层概念和缺陷，你也不过是加入了类似“[<ruby> 货物崇拜 <rt> cargo cult </rt></ruby>](https://en.wikipedia.org/wiki/Cargo_cult_programming)”的技术崇拜的程序员大军。
### 安全通信的特性
密码学最直观明显的目标是<ruby> 保密性 <rt> confidentiality </rt></ruby>：<ruby> 消息 <rt> message </rt></ruby>传输过程中不会被窥探内容。为了保密性，我们对消息进行加密：对于给定消息，我们结合一个<ruby> 密钥 <rt> key </rt></ruby>生成一个无意义的乱码，只有通过相同的密钥逆转加密过程（即解密过程）才能将其转换为可读的消息。假设我们有两个朋友 [Alice 和 Bob](https://en.wikipedia.org/wiki/Alice_and_Bob)，以及他们的<ruby> 八卦 <rt> nosy </rt></ruby>邻居 Eve。Alice 加密类似 "Eve 很讨厌" 的消息，将其发送给 Bob，期间不用担心 Eve 会窥探到这条消息的内容。
对于真正的安全通信，保密性是不够的。假如 Eve 收集了足够多 Alice 和 Bob 之间的消息，发现单词 “Eve” 被加密为 "Xyzzy"。除此之外，Eve 还知道 Alice 和 Bob 正在准备一个派对，Alice 会将访客名单发送给 Bob。如果 Eve 拦截了消息并将 “Xyzzy” 加到访客列表的末尾，那么她已经成功的破坏了这个派对。因此，Alice 和 Bob 需要他们之间的通信可以提供<ruby> 完整性 <rt> integrity </rt></ruby>：消息应该不会被篡改。
而且我们还有一个问题有待解决。假如 Eve 观察到 Bob 打开了标记为“来自 Alice”的信封，信封中包含一条来自 Alice 的消息“再买一加仑冰淇淋”。Eve 看到 Bob 外出，回家时带着冰淇淋，这样虽然 Eve 并不知道消息的完整内容，但她对消息有了大致的了解。Bob 将上述消息丢弃，但 Eve 找出了它并在下一周中的每一天都向 Bob 的邮箱中投递一封标记为“来自 Alice”的信封，内容拷贝自之前 Bob 丢弃的那封信。这样到了派对的时候，冰淇淋严重超量；派对当晚结束后，Bob 分发剩余的冰淇淋，Eve 带着免费的冰淇淋回到家。消息是加密的，完整性也没问题，但 Bob 被误导了，没有认出发信人的真实身份。<ruby> 身份认证 <rt> Authentication </rt></ruby>这个特性用于保证你正在通信的人的确是其声称的那样。
信息安全还有[其它特性](https://en.wikipedia.org/wiki/Information_security#Availability)，但保密性、完整性和身份验证是你必须了解的三大特性。
### 加密和加密算法
加密都包含哪些部分呢？首先，需要一条消息，我们称之为<ruby> 明文 <rt> plaintext </rt></ruby>。接着，需要对明文做一些格式上的初始化，以便用于后续的加密过程（例如，假如我们使用<ruby> 分组加密算法 <rt> block cipher </rt></ruby>，需要在明文尾部填充使其达到特定长度）。下一步，需要一个保密的比特序列，我们称之为<ruby> 密钥 <rt> key </rt></ruby>。然后，基于私钥，使用一种加密算法将明文转换为<ruby> 密文 <rt> ciphertext </rt></ruby>。密文看上去像是随机噪声，只有通过相同的加密算法和相同的密钥（在后面提到的非对称加密算法情况下，是另一个数学上相关的密钥）才能恢复为明文。
（LCTT 译注：cipher 一般被翻译为密码，但其具体表达的意思是加密算法，这里采用加密算法的翻译）
加密算法使用密钥加密明文。考虑到希望能够解密密文，我们用到的加密算法也必须是<ruby> 可逆的 <rt> reversible </rt></ruby>。作为简单示例，我们可以使用 [XOR](https://en.wikipedia.org/wiki/XOR_cipher)。该算子可逆，而且逆算子就是本身（`P ^ K = C; C ^ K = P`），故可同时用于加密和解密。该算子的平凡应用可以是<ruby> 一次性密码本 <rt> one-time pad </rt></ruby>，不过一般而言并不[可行](https://en.wikipedia.org/wiki/One-time_pad#Problems)。但可以将 XOR 与一个基于单个密钥生成<ruby> 任意随机数据流 <rt> arbitrary stream of random data </rt></ruby>的函数结合起来。现代加密算法 AES 和 Chacha20 就是这么设计的。
我们把加密和解密使用同一个密钥的加密算法称为<ruby> 对称加密算法 <rt> symmetric cipher </rt></ruby>。对称加密算法分为<ruby> 流加密算法 <rt> stream ciphers </rt></ruby>和分组加密算法两类。流加密算法依次对明文中的每个比特或字节进行加密。例如，我们上面提到的 XOR 加密算法就是一个流加密算法。流加密算法适用于明文长度未知的情形，例如数据从管道或 socket 传入。[RC4](https://en.wikipedia.org/wiki/RC4) 是最为人知的流加密算法，但在多种不同的攻击面前比较脆弱，以至于最新版本 （1.3）的 TLS （“HTTPS” 中的 “S”）已经不再支持该加密算法。[Efforts](https://en.wikipedia.org/wiki/ESTREAM) 正着手创建新的加密算法，候选算法 [ChaCha20](https://en.wikipedia.org/wiki/Salsa20) 已经被 TLS 支持。
分组加密算法对固定长度的分组，使用固定长度的密钥加密。在分组加密算法领域，排行第一的是 [<ruby> 先进加密标准 <rt> Advanced Encryption Standard </rt></ruby>](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)（AES），使用的分组长度为 128 比特。分组包含的数据并不多，因而分组加密算法包含一个[工作模式](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation)，用于描述如何对任意长度的明文执行分组加密。最简单的工作模式是 [<ruby> 电子密码本 <rt> Electronic Code Book </rt></ruby>](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#/media/File:ECB_encryption.svg)（ECB），将明文按分组大小划分成多个分组（在必要情况下，填充最后一个分组），使用密钥独立的加密各个分组。
这里我们留意到一个问题：如果相同的分组在明文中出现多次（例如互联网流量中的 `GET / HTTP/1.1` 词组），由于我们使用相同的密钥加密分组，我们会得到相同的加密结果。我们的安全通信中会出现一种<ruby> 模式规律 <rt> pattern </rt></ruby>，容易受到攻击。
因此还有很多高级的工作模式，例如 [<ruby> 密码分组链接 <rt> Cipher Block Chaining </rt></ruby>](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#/media/File:CBC_encryption.svg)（CBC），其中每个分组的明文在加密前会与前一个分组的密文进行 XOR 操作，而第一个分组的明文与一个随机数构成的初始化向量进行 XOR 操作。还有其它一些工作模式，在安全性和执行速度方面各有优缺点。甚至还有 Counter (CTR) 这种工作模式，可以将分组加密算法转换为流加密算法。
除了对称加密算法，还有<ruby> 非对称加密算法 <rt> asymmetric ciphers </rt></ruby>，也被称为<ruby> 公钥密码学 <rt> public-key cryptography </rt></ruby>。这类加密算法使用两个密钥：一个<ruby> 公钥 <rt> public key </rt></ruby>，一个<ruby> 私钥 <rt> private key </rt></ruby>。公钥和私钥在数学上有一定关联，但可以区分二者。经过公钥加密的密文只能通过私钥解密，经过私钥加密的密文可以通过公钥解密。公钥可以大范围分发出去，但私钥必须对外不可见。如果你希望和一个给定的人通信，你可以使用对方的公钥加密消息，这样只有他们的私钥可以解密出消息。在非对称加密算法领域，目前 [RSA](https://en.wikipedia.org/wiki/RSA_(cryptosystem)) 最具有影响力。
非对称加密算法最主要的缺陷是，它们是<ruby> 计算密集型 <rt> computationally expensive </rt></ruby>的。那么使用对称加密算法可以让身份验证更快吗？如果你只与一个人共享密钥，答案是肯定的。但这种方式很快就会失效。假如一群人希望使用对称加密算法进行两两通信，如果对每对成员通信都采用单独的密钥，一个 20 人的群体将有 190 对成员通信，即每个成员要维护 19 个密钥并确认其安全性。如果使用非对称加密算法，每个成员仅需确保自己的私钥安全并维护一个公钥列表即可。
非对称加密算法也有加密[数据长度](https://security.stackexchange.com/questions/33434/rsa-maximum-bytes-to-encrypt-comparison-to-aes-in-terms-of-security)限制。类似于分组加密算法，你需要将长消息进行划分。但实际应用中，非对称加密算法通常用于建立<ruby> 机密 <rt> confidential </rt></ruby>、<ruby> 已认证 <rt> authenticated </rt></ruby>的<ruby> 通道 <rt> channel </rt></ruby>，利用该通道交换对称加密算法的共享密钥。考虑到速度优势，对称加密算法用于后续的通信。TLS 就是严格按照这种方式运行的。
### 基础
安全通信的核心在于随机数。随机数用于生成密钥并为<ruby> 确定性过程 <rt> deterministic processes </rt></ruby>提供不可预测性。如果我们使用的密钥是可预测的，那我们从一开始就可能受到攻击。计算机被设计成按固定规则操作，因此生成随机数是比较困难的。计算机可以收集鼠标移动或<ruby> 键盘计时 <rt> keyboard timings </rt></ruby>这类随机数据。但收集随机性（也叫<ruby> 信息熵 <rt> entropy </rt></ruby>）需要花费不少时间，而且涉及额外处理以确保<ruby> 均匀分布 <rt> uniform distribution </rt></ruby>。甚至可以使用专用硬件，例如[<ruby> 熔岩灯 <rt> lava lamps </rt></ruby>墙](https://www.youtube.com/watch?v=1cUUfMeOijg)等。一般而言，一旦有了一个真正的随机数值，我们可以将其用作<ruby> 种子 <rt> seed </rt></ruby>，使用<ruby> 密码安全的伪随机数生成器 <rt> cryptographically secure pseudorandom number generator </rt></ruby>生成随机数。使用相同的种子，同一个随机数生成器生成的随机数序列保持不变，但重要的是随机数序列是无规律的。在 Linux 内核中，[/dev/random 和 /dev/urandom](https://www.2uo.de/myths-about-urandom/) 工作方式如下：从多个来源收集信息熵，进行<ruby> 无偏处理 <rt> remove biases </rt></ruby>，生成种子，然后生成随机数，该随机数可用于 RSA 密钥生成等。
### 其它密码学组件
我们已经实现了保密性，但还没有考虑完整性和身份验证。对于后两者，我们需要使用一些额外的技术。
首先是<ruby> 密码散列函数 <rt> crytographic hash function </rt></ruby>，该函数接受任意长度的输入并给出固定长度的输出（一般称为<ruby> 摘要 <rt> digest </rt></ruby>）。如果我们找到两条消息，其摘要相同，我们称之为<ruby> 碰撞 <rt> collision </rt></ruby>，对应的散列函数就不适合用于密码学。这里需要强调一下“找到”：考虑到消息的条数是无限的而摘要的长度是固定的，那么总是会存在碰撞；但如果无需海量的计算资源，我们总是能找到发生碰撞的消息对，那就令人比较担心了。更严重的情况是，对于每一个给定的消息，都能找到与之碰撞的另一条消息。
另外，哈希函数必须是<ruby> 单向的 <rt> one-way </rt></ruby>：给定一个摘要，反向计算对应的消息在计算上不可行。相应的，这类[条件](https://crypto.stackexchange.com/a/1174)被称为<ruby> 碰撞阻力 <rt> collision resistance </rt></ruby>、<ruby> 第二原象抗性 <rt> second preimage resistance </rt></ruby>和<ruby> 原象抗性 <rt> preimage resistance </rt></ruby>。如果满足这些条件，摘要可以用作消息的指纹。[理论上](https://www.telegraph.co.uk/science/2016/03/14/why-your-fingerprints-may-not-be-unique/)不存在具有相同指纹的两个人，而且你无法使用指纹反向找到其对应的人。
如果我们同时发送消息及其摘要，接收者可以使用相同的哈希函数独立计算摘要。如果两个摘要相同，可以认为消息没有被篡改。考虑到 [SHA-1](https://en.wikipedia.org/wiki/SHA-1) 已经变得[有些过时](https://security.googleblog.com/2017/02/announcing-first-sha1-collision.html)，目前最流行的密码散列函数是 [SHA-256](https://en.wikipedia.org/wiki/SHA-2)。
散列函数看起来不错，但如果有人可以同时篡改消息及其摘要，那么消息发送仍然是不安全的。我们需要将哈希与加密算法结合起来。在对称加密算法领域，我们有<ruby> 消息认证码 <rt> message authentication codes </rt></ruby>（MAC）技术。MAC 有多种形式，但<ruby> 哈希消息认证码 <rt> hash message authentication codes </rt></ruby>（HMAC） 这类是基于哈希的。[HMAC](https://en.wikipedia.org/wiki/HMAC) 使用哈希函数 H 处理密钥 K、消息 M，公式为 `H(K + H(K + M))`，其中 `+` 代表<ruby> 连接 <rt> concatenation </rt></ruby>。公式的独特之处并不在本文讨论范围内，大致来说与保护 HMAC 自身的完整性有关。发送加密消息的同时也发送 MAC。Eve 可以任意篡改消息，但一旦 Bob 独立计算 MAC 并与接收到的 MAC 做比较，就会发现消息已经被篡改。
在非对称加密算法领域，我们有<ruby> 数字签名 <rt> digital signatures </rt></ruby>技术。如果使用 RSA，使用公钥加密的内容只能通过私钥解密，反过来也是如此；这种机制可用于创建一种签名。如果只有我持有私钥并用其加密文档，那么只有我的公钥可以用于解密，那么大家潜在的承认文档是我写的：这是一种身份验证。事实上，我们无需加密整个文档。如果生成文档的摘要，只要对这个指纹加密即可。对摘要签名比对整个文档签名要快得多，而且可以解决非对称加密存在的消息长度限制问题。接收者解密出摘要信息，独立计算消息的摘要并进行比对，可以确保消息的完整性。对于不同的非对称加密算法，数字签名的方法也各不相同；但核心都是使用公钥来检验已有签名。
### 汇总
现在，我们已经有了全部的主体组件，可以用其实现一个我们期待的、具有全部三个特性的[<ruby> 体系 <rt> system </rt></ruby>](https://en.wikipedia.org/wiki/Hybrid_cryptosystem)。Alice 选取一个保密的对称加密密钥并使用 Bob 的公钥进行加密。接着，她对得到的密文进行哈希并使用其私钥对摘要进行签名。Bob 接收到密文和签名，一方面独立计算密文的摘要，另一方面使用 Alice 的公钥解密签名中的摘要；如果两个摘要相同，他可以确信对称加密密钥没有被篡改且通过了身份验证。Bob 使用私钥解密密文得到对称加密密钥，接着使用该密钥及 HMAC 与 Alice 进行保密通信，这样每一条消息的完整性都得到保障。但该体系没有办法抵御消息重放攻击（我们在 Eve 造成的冰淇淋灾难中见过这种攻击）。要解决重放攻击，我们需要使用某种类型的“<ruby> 握手 <rt> handshake </rt></ruby>”建立随机、短期的<ruby> 会话标识符 <rt> session identifier </rt></ruby>。
密码学的世界博大精深，我希望这篇文章能让你对密码学的核心目标及其组件有一个大致的了解。这些概念为你打下坚实的基础，让你可以继续深入学习。
感谢 Hubert Kario、Florian Weimer 和 Mike Bursell 在本文写作过程中提供的帮助。
---
via: <https://opensource.com/article/18/5/cryptography-pki>
作者：[Alex Wood](https://opensource.com/users/awood) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用这样的 Vi 配置来保存和组织你的笔记
|
Manuel Dewald
|
https://opensource.com/article/18/6/vimwiki-gitlab-notes
|
Vimwiki 和 GitLab 是记录笔记的强大组合。
|
/data/attachment/album/201806/30/103554uu5o5uue9zchu394.png.thumb.jpg
|
/data/attachment/album/201806/30/103554uu5o5uue9zchu394.png
| true | false | true |
singledo
| false |
[
"笔记"
] |
桌面应用
|
{
"viewnum": 7360,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Vimwiki 和 GitLab 是记录笔记的强大组合。
| 2018-06-30T10:37:03 | 2018-06-30T10:37:03 | 9,793 |
/article-9793-1.html
|
>
> Vimwiki 和 GitLab 是记录笔记的强大组合。
>
>
>
用 vi 来管理 wiki 来记录你的笔记，这听起来不像是一个符合常规的主意，但当你的日常工作都会用到 vi , 那它是有意义的。
作为一个软件开发人员，使用同编码一样的工具来写笔记会更加简单。我想将我的笔记变成一种编辑器命令，无论我在哪里，都能够用管理我代码的方法来管理我的笔记。这便是我创建一个基于 vi 的环境来搭建我自己的知识库的原因。简单概括起来，我在笔记本电脑上用 vi 插件 [Viwiki](https://vimwiki.github.io/) 来本地管理我的 wiki。用 Git 来进行版本控制（以保留一个中心化的更新版本），并用 GitLab 来进行在线修改（例如在我的手机上）。
### 为什么用 wiki 来进行笔记保存是有意义
我尝试过许多不同的工具来持续的记录我的笔记，笔记里保存着我的灵感以及需要记住的任务安排。这包括线下的笔记本 （没错，纸质的）、特殊的记录笔记的软件，以及思维导图软件。
但每种方案都有不好一面，没有一个能够满足我所有的需求。例如[思维导图](https://opensource.com/article/17/8/mind-maps-creative-dashboard)，能够很好的形象化你的想法（因而得名），但是这种工具的搜索功能很差（和纸质笔记本一样）。此外，当一段时间过去，思维导图会变得很难阅读，所以思维导图不适合长时间保存的笔记。
我为一个合作项目配置了 [DokuWiki](https://vimwiki.github.io/)，我发现这个 wiki 模型符合了我大多数的需求。在 wiki 上，你能够创建一个笔记（和你在文本编辑器中所作的一样），并在笔记间创建链接。如果一个链接指向一个不存在的页面（你想让本页面添加一条还没有创建的信息）， wiki 会为你建立这个页面。这个特性使得 wiki 很好的适应了那些需要快速写下心中所想的人的需求，而仍将你的笔记保持在能够容易浏览和搜索关键字的页面结构中。
这看起来很有希望，并且配置 DokuWiki 也很容易，但我发现只是为了记个笔记而配置整个 wiki 需要花费太多工作。在一番搜索后，我发现了 Vimwiki，这是一个我想要的 vi 插件。因为我每天使用 vi，记录笔记就行编辑代码一样。甚至在 vimwiki 创建一个页面比 Dokuwiki 更简单。你只需要对光标下的单词按下回车键就行。如果没有文件是这个名字，vimwiki 会为你创建一个。
为了更一步的实现用每天都会使用的工具来做笔记的计划，我不仅用这个我最爱的 IDE 来写笔记，而且用 Git 和 GitLab —— 我最爱的代码管理工具 —— 在我的各个机器间分发我的笔记，以便我可以在线访问它们。我也是在 Gitlab 的在线 markdown 工具上用 markdown 语法来写的这篇文章。
### 配置 vimwiki
用你已有的插件管理工具来安装 vimwiki 很简单，只需要添加 vimwiki/vimwiki 到你的插件。对于我的喜爱的插件管理器 Vundle 来说，你只需要在 `/.vimrc` 中添加 `plugin vimwiki/vimwiki` 这一行，然后执行 `:source ~/.vimrc | PluginInstall` 就行。
下面是我的文件 `.vimrc` 的一部分，展示了一些 vimwiki 配置。你能在 [vimwiki](https://vimwiki.github.io/) 页面学到更多的配置和使用的的信息。
```
let wiki_1 = {}
let wiki_1.path = '~/vimwiki_work_md/'
let wiki_1.syntax = 'markdown'
let wiki_1.ext = '.md'
let wiki_2 = {}
let wiki_2.path = '~/vimwiki_personal_md/'
let wiki_2.syntax = 'markdown'
let wiki_2.ext = '.md'
let g:vimwiki_list = [wiki_1, wiki_2]
let g:vimwiki_ext2syntax = {'.md': 'markdown', '.markdown': 'markdown', '.mdown': 'markdown'}
```
如你在上述配置中所见，我的配置还有一个优点。你能简单的区分个人和工作相关的笔记，而不用切换笔记软件。我想让我的个人笔记可以随时随地访问，而不想我的工作笔记同步到我私人的 GitLab 和计算机中。在 vimwiki 这样配置要比我试过的其他软件都要简单。
这个配置告诉 vimwiki 有两个不同 Wiki，都使用 markdown 语法（再一次，因为我的日常工作中天天都在用 markdown 语法）。我也告诉 Vimwiki 在哪个文件夹存储 wiki 页面。
如果你进入存储 wiki 页面的文件夹，你会找到你的 wiki 的普通的 markdown 页面文件，而没有其他特殊的 Vimwiki 相关内容，这使得很容易的初始化 Git 仓库和同步你的 wiki 到中心仓库。
### 同步你的 wiki 到 GitLab
这一步检出一个 GitLab 项目到本地的 VimWiki 文件夹，这步操作和你操作任何 GitHub 的仓库相同，只不过因为我更喜欢保存我的笔记到我的私人 GitLab 仓库，所以我运行了一个 GitLab 实例用于我个人的项目。
GitLab 的 wiki 功能可以用来为你的项目创建 wiki 页面。这些 wiki 就是 Git 仓库本身。它们使用 markdown 语法，你懂得。
只需要初始化你需要的 wiki ，让它与你为笔记而创建的项目的 wiki 同步即可。
```
cd ~/vimwiki_personal_md/
git init
git remote add origin git@your.gitlab.com:your_user/vimwiki_personal_md.wiki
git add .
git commit -m "Initial commit"
git push -u origin master
```
在 GitLab 创建一个新的项目后，你就可以从页面上复制这些步骤的代码。唯一的改变是仓库地址结尾是 .wiki（而不是 .git）。 这会告诉 Git 克隆 wiki 仓库而不是项目本身。
就是这样！现在你能够通过 Git 来管理你的笔记，通过 GitLab wiki 用户界面来修改笔记。
你可能（像我一样）不想手动的为每个添加到笔记本的笔记创建一个提交。为了解决这个问题，我使用了 Vim 插件 [chazy/dirsetting](https://github.com/chazy/dirsettings)。我添加一个 `.vimaddr` 文件，已经下面的内容：
```
:cd %:p:h
silent! !git pull > /dev/null
:e!
autocmd! BufWritePost * silent! !git add .;git commit -m "vim autocommit" > /dev/null; git push > /dev/null&
```
每当我打开 Wiki 文件按下 `:w` 发布我的修改时，它就会更新到最新的版本。这样做会使你的本地文件与中心仓库保持同步。如果你有合并冲突，通常你需要解决它们。
目前，这就是以我的知识来互动的方法，我很喜欢这方法；请告诉我你对于这个方法的想法，可以在评论区分享你如何追踪笔记的方法。
---
via: <https://opensource.com/article/18/6/vimwiki-gitlab-notes>
作者：[Manuel Dewald](https://opensource.com/users/ntlx) 选题：[lujun9972](https://github.com/lujun9972) 译者：[octopus](https://github.com/singledo) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 中的特定时间运行命令
|
Sk
|
https://www.ostechnix.com/run-command-specific-time-linux/
|
我只是想知道在类 Unix 操作系统中是否有简单的方法可以在特定的时间运行一个命令，并且一旦超时就自动杀死它
|
/data/attachment/album/201806/30/215416vzcnu0r888rr0hra.png.thumb.jpg
|
/data/attachment/album/201806/30/215416vzcnu0r888rr0hra.png
| true | false | true |
geekpi
| false |
[
"定时",
"超时"
] |
技术
|
{
"viewnum": 7207,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我只是想知道在类 Unix 操作系统中是否有简单的方法可以在特定的时间运行一个命令，并且一旦超时就自动杀死它
| 2018-06-30T21:54:12 | 2018-06-30T21:54:12 | 9,794 |
/article-9794-1.html
|
有一天，我使用 `rsync` 将大文件传输到局域网上的另一个系统。由于它是非常大的文件，大约需要 20 分钟才能完成。我不想再等了，我也不想按 `CTRL+C` 来终止这个过程。我只是想知道在类 Unix 操作系统中是否有简单的方法可以在特定的时间运行一个命令，并且一旦超时就自动杀死它 —— 因此有了这篇文章。请继续阅读。
### 在 Linux 中在特定时间运行命令
我们可以用两种方法做到这一点。
#### 方法 1 - 使用 timeout 命令
最常用的方法是使用 `timeout` 命令。对于那些不知道的人来说，`timeout` 命令会有效地限制一个进程的绝对执行时间。`timeout` 命令是 GNU coreutils 包的一部分，因此它预装在所有 GNU/Linux 系统中。
假设你只想运行一个命令 5 秒钟，然后杀死它。为此，我们使用：
```
$ timeout <time-limit-interval> <command>
```
例如，以下命令将在 10 秒后终止。
```
$ timeout 10s tail -f /var/log/pacman.log
```
你也可以不用在秒数后加后缀 `s`。以下命令与上面的相同。
```
$ timeout 10 tail -f /var/log/pacman.log
```
其他可用的后缀有：
* `m` 代表分钟。
* `h` 代表小时。
* `d` 代表天。
如果你运行这个 `tail -f /var/log/pacman.log` 命令，它将继续运行，直到你按 `CTRL+C` 手动结束它。但是，如果你使用 `timeout` 命令运行它，它将在给定的时间间隔后自动终止。如果该命令在超时后仍在运行，则可以发送 `kill` 信号，如下所示。
```
$ timeout -k 20 10 tail -f /var/log/pacman.log
```
在这种情况下，如果 `tail` 命令在 10 秒后仍然运行，`timeout` 命令将在 20 秒后发送一个 kill 信号并结束。
有关更多详细信息，请查看手册页。
```
$ man timeout
```
有时，某个特定程序可能需要很长时间才能完成并最终冻结你的系统。在这种情况下，你可以使用此技巧在特定时间后自动结束该进程。
另外，可以考虑使用 `cpulimit`，一个简单的限制进程的 CPU 使用率的程序。有关更多详细信息，请查看下面的链接。
* [如何在 Linux 中限制一个进程的使用的 CPU](https://www.ostechnix.com/how-to-limit-cpu-usage-of-a-process-in-linux/)
#### 方法 2 - 使用 timelimit 程序
`timelimit` 使用提供的参数执行给定的命令，并在给定的时间后使用给定的信号终止进程。首先，它会发送警告信号，然后在超时后发送 kill 信号。
与 `timeout` 不同，`timelimit` 有更多选项。你可以传递参数数量，如 `killsig`、`warnsig`、`killtime`、`warntime` 等。它存在于基于 Debian 的系统的默认仓库中。所以，你可以使用命令来安装它：
```
$ sudo apt-get install timelimit
```
对于基于 Arch 的系统，它在 AUR 中存在。因此，你可以使用任何 AUR 助手进行安装，例如 [Pacaur](https://www.ostechnix.com/install-pacaur-arch-linux/)、[Packer](https://www.ostechnix.com/install-packer-arch-linux-2/)、[Yay](https://www.ostechnix.com/yay-found-yet-another-reliable-aur-helper/)、[Yaourt](https://www.ostechnix.com/install-yaourt-arch-linux/) 等。
对于其他发行版，请[在这里](http://devel.ringlet.net/sysutils/timelimit/#download)下载源码并手动安装。安装 `timelimit` 后，运行下面的命令执行一段特定的时间，例如 10 秒钟：
```
$ timelimit -t10 tail -f /var/log/pacman.log
```
如果不带任何参数运行 `timelimit`，它将使用默认值：`warntime=3600` 秒、`warnsig=15` 秒、`killtime=120` 秒、`killsig=9`。有关更多详细信息，请参阅本指南最后给出的手册页和项目网站。
```
$ man timelimit
```
今天就是这些。我希望对你有用。还有更好的东西。敬请关注！
干杯！
### 资源
* [timelimit 网站](http://devel.ringlet.net/sysutils/timelimit/)
---
via: <https://www.ostechnix.com/run-command-specific-time-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
让我们从 GitHub 中迁移出来
|
Louis-philippe Véronneau
|
https://veronneau.org/lets-migrate-away-from-github.html
|
有些人可能认为微软的收购没有问题，但对我来说，这是压垮骆驼的最后一根稻草。
|
/data/attachment/album/201806/30/222202ocm5ue55pm29u3g4.jpg.thumb.jpg
|
/data/attachment/album/201806/30/222202ocm5ue55pm29u3g4.jpg
| true | false | true |
geekpi
| false |
[
"微软",
"GitHub"
] |
观点
|
{
"viewnum": 8497,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
有些人可能认为微软的收购没有问题，但对我来说，这是压垮骆驼的最后一根稻草。
| 2018-06-30T22:22:00 | 2018-06-30T22:22:00 | 9,795 |
/article-9795-1.html
|
>
> 编者按：本文不代表本站观点，而且微软收购 GitHub 的后果目前尚未显现出来，本文只是提供了一个选择。
>
>
>
正如你们之前听到的那样，[微软收购了 GitHub](https://www.bloomberg.com/news/articles/2018-06-03/microsoft-is-said-to-have-agreed-to-acquire-coding-site-github)。这对 GitHub 的未来意味着什么尚不清楚，但 [Gitlab 的人](https://about.gitlab.com/2018/06/03/microsoft-acquires-github/)认为微软的最终目标是将 GitHub 整合到他们的 Azure 帝国。对我来说，这很有道理。
尽管我仍然不情愿地将 GitHub 用于某些项目，但我前一段时间将所有个人仓库迁移到了 Gitlab 中。现在是时候让你做同样的事情，并抛弃 GitHub。
有些人可能认为微软的收购没有问题，但对我来说，这是压垮骆驼的最后一根稻草。几年来，微软一直在开展一场关于他们如何热爱 Linux 的大型营销活动，并突然决定用它所有的形式拥抱自由软件。更像 MS BS 给我的。
让我们花点时间提醒自己：
* Windows 仍然是一个巨大的专有怪物，数十亿人每天都在丧失他们的隐私和权利。
* 微软公司（曾经）以传播自由软件的“危害”闻名，以防止政府和学校放弃 Windows，转而支持 FOSS。
* 为了确保他们的垄断地位，微软通过向全世界的小学颁发“免费”许可证来吸引孩子使用 Windows。毒品经销商使用相同的策略并提供免费样品来获取新客户。
* 微软的 Azure 平台 - 即使它可以运行 Linux 虚拟机 - 它仍然是一个巨大的专有管理程序。
我知道移动 git 仓库看起来像是一件痛苦的事情，但是 Gitlab 的员工正在趁着人们离开 GitHub 的浪潮，通过[提供 GitHub 导入器](https://docs.gitlab.com/ee/user/project/import/github.html)使迁移变得容易。
如果你不想使用 Gitlab 的主实例（[gitlab.org](https://gitlab.org)），下面是另外两个你可以用于自由软件项目的备选实例：
* [Debian Gitlab 实例](https://salsa.debian.org)适用于每个 FOSS 项目，它不仅适用于与 Debian 相关的项目。只要项目符合 [Debian 自由软件指南](https://en.wikipedia.org/wiki/Debian_Free_Software_Guidelines)，你就可以使用该实例及其 CI。
* Riseup 为名为 [0xacab](https://0xacab.org) 的激进项目维护了一个 Gitlab 实例。如果你的[理念与 Riseup 的一致](https://riseup.net/en/about-us/politics)，他们很乐意在那里托管你的项目。
朋友不要再让人使用 Github 了。
---
via: <https://veronneau.org/lets-migrate-away-from-github.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/) 荣誉推出
|
||
你的路由器有多不安全？
|
Mike Bursell
|
https://opensource.com/article/18/5/how-insecure-your-router
|
你的路由器是你与互联网之间的第一个联系点。它给你带来了多少风险？
|
/data/attachment/album/201806/30/224955u4nthdcim0dk8nmc.jpg.thumb.jpg
|
/data/attachment/album/201806/30/224955u4nthdcim0dk8nmc.jpg
| true | false | true |
qhwdw
| false |
[
"安全",
"路由器"
] |
观点
|
{
"viewnum": 8393,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
你的路由器是你与互联网之间的第一个联系点。它给你带来了多少风险？
| 2018-06-30T22:48:00 | 2018-06-30T22:48:00 | 9,796 |
/article-9796-1.html
|
>
> 你的路由器是你与互联网之间的第一个联系点。它给你带来了多少风险？
>
>
>
我一直对写在 T 恤上的“127.0.0.1 是独一无二的地方” 这句话持有异议。我知道你可能会认为应该将它看作是“家”，但是对于我来说，我认为应该是“本地主机是独一无二的地方”，就像世界上没有完全相同的二个戒指一样。在本文中，我想去讨论一些宽泛的问题：家庭网络的入口，对大多数人来说它是线缆或宽带路由器。<sup> 1</sup> 英国和美国政府刚公布了“俄罗斯” <sup> 2</sup> 攻击路由器的通告。我估计这次的攻击主要针对的是机构，而不是家庭，（看我以前的文章 “[国家行为者是什么，我们应该注意些什么？](https://aliceevebob.com/2018/03/13/whats-a-state-actor-and-should-i-care/)”），但这对我们所有人都是一个警示。
### 路由器有什么用？
路由器很重要。它用于将一个网络（在本文中，是我们的家庭网络）与另外一个网络（在本文中，是指互联网，通过我们的互联网服务提供商的网络）连接。事实上，对于大多数人来说，我们所谓的“路由器” <sup> 3</sup> 这个小盒子能够做的事情远比我们想到的要多。“路由” 一个比特就就如其听起来的意思一样：它让网络中的计算机能够找到一条向外部网络中计算机发送数据的路径 —— 当你接收数据时，反之。
在路由器的其它功能中，大多数时候也作为一台调制解调器来使用。我们中的大部分人 <sup> 4</sup> 到互联网的连接是通过电话线来实现的 —— 无论是电缆还是标准电话线 —— 尽管现在的最新趋势是通过移动互联网连接到家庭中。当你通过电话线连接时，我们所使用的互联网信号必须转换成其它的一些东西，（从另一端来的）返回信号也是如此。对于那些还记得过去的“拨号上网”时代的人来说，它就是你的电脑边上那个用于上网的发出刺耳声音的小盒子。
但是路由器能做的事情很多，有时候很多的事情，包括流量记录、作为一个无线接入点、提供 VPN 功能以便于从外部访问你的内网、儿童上网控制、防火墙等等。
现在的家用路由器越来越复杂；虽然国家行为者也行不会想着攻破它，但是其它人也许会。
你会问，这很重要吗？如果其它人可以进入你的系统，他们可以很容易地攻击你的笔记本电脑、电话、网络设备等等。他们可以访问和删除未被保护的个人数据。他们可以假装是你。他们使用你的网络去寄存非法数据或者用于攻击其它人。基本上所有的坏事都可以做。
幸运的是，现在的路由器趋向于由互联网提供商来做设置，言外之意是你可以忘了它的存在，他们将保证它是运行良好和安全的。
### 因此，我们是安全的吗？
不幸的是，事实并非如此。
第一个问题是，互联网提供商是在有限的预算范围内做这些事情，而使用便宜的设备来做这些事可以让他们的利益最大化。互联网提供商的路由器质量越来越差。它是恶意攻击者的首选目标：如果他们知道特定型号的路由器被安装在几百万个家庭使用，那么很容易找到攻击的动机，因为攻击那个型号的路由器对他们来说是非常有价值的。
产生的其它问题还包括：
* 修复 bug 或者漏洞的过程很缓慢。升级固件可能会让互联网提供商产生较高的成本，因此，修复过程可能非常缓慢（如果他们打算修复的话）。
* 非常容易获得或者默认的管理员密码，这意味着攻击者甚至都不需要去找到真实的漏洞 —— 他们就可以登入到路由器中。
### 对策
对于进入互联网第一跳的路由器，如何才能提升它的安全性，这里给你提供一个快速应对的清单。我是按从简单到复杂的顺序来列出它们的。在你对路由器做任何改变之前，需要先保存配置数据，以便于你需要的时候回滚它们。
1. **密码：** 一定，一定，一定要改变你的路由器的管理员密码。你可能很少会用到它，所以你一定要把密码记录在某个地方。它用的次数很少，你可以考虑将密码粘贴到路由器上，因为路由器一般都放置在仅供授权的人（你和你的家人 <sup> 5</sup> ）才可以接触到的地方。
2. **仅允许管理员从内部进行访问：** 除非你有足够好的理由和你知道如何去做，否则不要允许任何机器从外部的互联网上管理你的路由器。在你的路由器上有一个这样的设置。
3. **WiFi 密码：** 一旦你做到了第 2 点，也要确保在你的网络上的那个 WiFi 密码 —— 无论是设置为你的路由器管理密码还是别的 —— 一定要是强密码。为了简单，为连接你的网络的访客设置一个“友好的”简单密码，但是，如果附近一个恶意的人猜到了密码，他做的第一件事情就是查找网络中的路由器。由于他在内部网络，他是可以访问路由器的（因此，第 1 点很重要）。
4. **仅打开你知道的并且是你需要的功能：** 正如我在上面所提到的，现代的路由器有各种很酷的选项。不要使用它们。除非你真的需要它们，并且你真正理解了它们是做什么的，以及打开它们后有什么危险。否则，将增加你的路由器被攻击的风险。
5. **购买你自己的路由器：** 用一个更好的路由器替换掉互联网提供商给你的路由器。去到你本地的电脑商店，让他们给你一些建议。你可能会花很多钱，但是也可能会遇到一些非常便宜的设备，而且比你现在拥有的更好、性能更强、更安全。你也可以只买一个调制解调器。一般设置调制解调器和路由器都很简单，并且，你可以从你的互联网提供商给你的设备中复制配置，它一般就能“正常工作”。
6. **更新固件：** 我喜欢使用最新的功能，但是通常这并不容易。有时，你的路由器上会出现固件更新的提示。大多数的路由器会自动检查并且提示你在下次登入的时候去更新它。问题是如果更新失败则会产生灾难性后果 <sup> 6</sup> 或者丢失配置数据，那就需要你重新输入。但是你真的需要考虑去持续关注修复安全问题的固件更新，并更新它们。
7. **转向开源：** 有一些非常好的开源路由器项目，可以让你用在现有的路由器上，用开源的软件去替换它的固件/软件。你可以在 [Wikipedia](https://en.wikipedia.org/wiki/List_of_router_firmware_projects) 上找到许多这样的项目，以及在 [Opensource.com 上搜索 “router”](https://opensource.com/sitewide-search?search_api_views_fulltext=router)，你将看到很多非常好的东西。对于谨慎的人来说要小心，这将会让你的路由器失去保修，但是如果你想真正控制你的路由器，开源永远是最好的选择。
### 其它问题
一旦你提升了你的路由器的安全性，你的家庭网络将变的很好——这是假像，事实并不是如此。你家里的物联网设备（Alexa、Nest、门铃、智能灯泡、等等）安全性如何？连接到其它网络的 VPN 安全性如何？通过 WiFi 的恶意主机、你的孩子手机上的恶意应用程序 …？
不，你永远不会有绝对的安全。但是正如我们前面讨论的，虽然没有绝对的“安全”这种事情，但是并不意味着我们不需要去提升安全标准，以让坏人干坏事更困难。
### 脚注
1. 我写的很简单 — 但请继续读下去，我们将达到目的。
2. “俄罗斯政府赞助的信息技术国家行为者”
3. 或者，以我父母的例子来说，我猜叫做 “互联网盒子”。
4. 这里还有一种这样的情况，我不希望在评论区告诉我，你是直接以 1TB/s 的带宽连接到本地骨干网络的。非常感谢！
5. 或许并没有包含整个家庭。
6. 你的路由器现在是一块“砖”，并且你不能访问互联网了。
这篇文章最初发表在 [Alice, Eve, 和 Bob – 安全博客](https://aliceevebob.com/2018/04/17/defending-our-homes/) 并授权重发布。
---
via: <https://opensource.com/article/18/5/how-insecure-your-router>
作者：[Mike Bursell](https://opensource.com/users/mikecamel) 选题：[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/) 荣誉推出
|
||
Python 调试技巧
|
Pythondebugging.com
|
https://pythondebugging.com/articles/python-debugging-tips
|
这里有一些我最喜欢的 Python 调试技巧。
|
/data/attachment/album/201807/02/085733el0oe0s9adjsdz2j.jpg.thumb.jpg
|
/data/attachment/album/201807/02/085733el0oe0s9adjsdz2j.jpg
| true | false | true |
geekpi
| false |
[
"Python",
"调试"
] |
软件开发
|
{
"viewnum": 4560,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这里有一些我最喜欢的 Python 调试技巧。
| 2018-07-02T08:57:40 | 2018-07-02T08:57:40 | 9,797 |
/article-9797-1.html
|
当进行调试时，你有很多选择，但是很难给出一直有效的通用建议（除了“你试过关闭再打开么？”以外）。
这里有一些我最喜欢的 Python 调试技巧。
### 建立一个分支
请相信我。即使你从来没有打算将修改提交回上游，你也会很乐意将你的实验被包含在它们自己的分支中。
不说别的，它会使清理更容易！
### 安装 pdb++
认真地说，如果你使用命令行，它会让你的生活更轻松。
pdb++ 所做的一切就是用更好的模块替换标准的 pdb 模块。以下是你在 `pip install pdbpp` 会看到的：
* 彩色提示！
* 制表符补全！（非常适合探索！）
* 支持切分！
好的，也许最后一个是有点多余……但是非常认真地说，安装 pdb++ 非常值得。
### 探索
有时候最好的办法就是胡乱试试，然后看看会发生什么。在“明显”的位置放置一个断点并确保它被命中。在代码中加入 `print()` 和/或 `logging.debug()` 语句，并查看代码执行的位置。
检查传递给你的函数的参数，检查库的版本（如果你已经非常绝望了）。
### 一次只能改变一件事
在你在探索了一下后，你将会对你可以做的事情有所了解。但在你开始摆弄代码之前，先退一步，考虑一下你可以改变什么，然后只改变一件事。
做出改变后，然后测试一下，看看你是否接近解决问题。如果没有，请将它改回来，然后尝试其他方法。
只更改一件事就可以让你知道什可以工作，哪些不工作。另外，一旦可以工作后，你的新提交将会小得多（因为将有更少的变化）。
这几乎是<ruby> 科学过程 <rt> Scientific Process </rt></ruby>中所做的事情：一次只更改一个变量。通过让自己看到并衡量一次更改的结果，你可以节省你的理智，并更快地找到解决方案。
### 不要假设，提出问题
偶尔一个开发人员（当然不是你咯！）会匆忙提交一些有问题的代码。当你去调试这段代码时，你需要停下来，并确保你明白它想要完成什么。
不要做任何假设。仅仅因为代码在 `model.py` 文件中并不意味着它不会尝试渲染一些 HTML。
同样，在做任何破坏性的事情之前，仔细检查你的所有外部关联。要删除一些配置数据？**请确保你没有连接到你的生产系统。**
### 聪明，但不要聪明过头
有时候我们编写的代码神奇般地奏效，不知道它是如何做的。
当我们发布代码时，我们可能会觉得自己很聪明，但当代码崩溃时，我们往往会感到愚蠢，我们必须记住它是如何工作的，以便弄清楚它为什么不起作用。
留意任何看起来过于复杂、冗长或极短的代码段。这些可能是隐藏复杂并导致错误的地方。
---
via: <https://pythondebugging.com/articles/python-debugging-tips>
作者：[PythonDebugging.com](https://pythondebugging.com) 选题：[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 文件系统详解
|
Paul Brown
|
https://www.linux.com/blog/learn/intro-to-linux/2018/4/linux-filesystem-explained
|
这篇教程将帮你快速了解 Linux 文件系统。
|
/static/image/common/nophoto.png
|
/static/image/common/nophoto.png
| true | false | true |
amwps290
| false |
[
"文件系统"
] |
技术
|
{
"viewnum": 46708,
"commentnum": 3,
"favtimes": 7,
"sharetimes": 13,
"likes": 0
}
|
[
{
"postip": "120.230.126.87",
"message": "超级棒的文章，已看完+收藏！！",
"username": "来自120.230.126.87的 Chrome 86.0|Windows 10 用户",
"date": "2022-06-06T15:41:00"
},
{
"postip": "117.159.17.235",
"message": "漏了一个`",
"username": "来自河南焦作的 Chrome 105.0|Windows 10 用户",
"date": "2022-09-18T16:58:28"
},
{
"postip": "116.236.160.230",
"message": "/dev 目录的条目中漏了一个 ’",
"username": "来自上海的 Chrome 104.0|Windows 7 用户",
"date": "2022-11-15T10:31:37"
}
] |
[
{
"raid": 10066,
"displayorder": 0
}
] |
这篇教程将帮你快速了解 Linux 文件系统。
| 2018-07-02T09:44:00 | 2018-07-02T09:44:00 | 9,798 |
/article-9798-1.html
|
>
> 这篇教程将帮你快速了解 Linux 文件系统。
>
>
>
早在 1996 年，在真正理解文件系统的结构之前，我就学会了如何在我崭新的 Linux 上安装软件。这是一个问题，但对程序来说不是大问题，因为即使我不知道实际的可执行文件在哪里，它们也会神奇地工作。问题在于文档。
你知道，那时候，Linux 不是像今天这样直观、用户友好的系统。你必须读很多东西。你必须知道你的 CRT 显示器的扫描频率以及拨号调制解调器的噪音来龙去脉，以及其他数以百计的事情。 我很快就意识到我需要花一些时间来掌握目录的组织方式以及 `/etc`（不是用于“其它”文件），`/usr`（不是用于“用户”文件）和 `/bin` （不是“垃圾桶”）的意思。
本教程将帮助你比我当时更快地了解这些。
### 结构
从终端窗口探索 Linux 文件系统是有道理的，这并不是因为作者是一个脾气暴躁的老人，并且对新孩子和他们漂亮的图形工具不以为然（尽管某些事实如此），而是因为终端，尽管只是文本界面，才是更好地显示 Linux 目录树结构的工具。
事实上，帮助你了解这一切的、应该首先安装的第一个工具的名为：`tree`。如果你正在使用 Ubuntu 或 Debian ，你可以：
```
sudo apt install tree
```
在 Red Hat 或 Fedora :
```
sudo dnf install tree
```
对于 SUSE/openSUSE 可以使用 `zypper`：
```
sudo zypper install tree
```
对于使用 Arch （Manjaro，Antergos，等等）使用：
```
sudo pacman -S tree
```
……等等。
一旦安装好，在终端窗口运行 `tree` 命令：
```
tree /
```
上述指令中的 `/` 指的是根目录。系统中的其他目录都是从根目录分支而出，当你运行 `tree` 命令，并且告诉它从根目录开始，那么你就可以看到整个目录树，系统中的所有目录及其子目录，还有它们的文件。
如果你已经使用你的系统有一段时间了，这可能需要一段时间，因为即使你自己还没有生成很多文件，Linux 系统及其应用程序总是在记录、缓存和存储各种临时文件。文件系统中的条目数量会快速增长。
不过，不要感到不知所措。 相反，试试这个：
```
tree -L 1 /
```
你应该看到如图 1 所示。
*tree*
上面的指令可以翻译为“只显示以 `/`（根目录） 开头的目录树的第一级”。 `-L` 选项告诉树你想看到多少层目录。
大多数 Linux 发行版都会向你显示与你在上图中看到的相同或非常类似的结构。 这意味着，即使你现在感到困惑，掌握这一点，你将掌握大部分（如果不是全部的话）全世界的 Linux 文件系统。
为了让你开始走上掌控之路，让我们看看每个目录的用途。 当我们查看每一个目录的时候，你可以使用 `ls` 来查看他们的内容。
### 目录
从上到下，你所看到的目录如下
#### /bin
`/bin` 目录是包含一些二进制文件的目录，即可以运行的一些应用程序。 你会在这个目录中找到上面提到的 `ls` 程序，以及用于新建和删除文件和目录、移动它们基本工具。还有其它一些程序，等等。文件系统树的其他部分有更多的 *bin* 目录，但我们将在一会儿讨论这些目录。
#### /boot
`/boot` 目录包含启动系统所需的文件。我必须要说吗？ 好吧，我会说：**不要动它**！ 如果你在这里弄乱了其中一个文件，你可能无法运行你的 Linux，修复被破坏的系统是非常痛苦的一件事。 另一方面，不要太担心无意中破坏系统：你必须拥有超级用户权限才能执行此操作。
#### /dev
`/dev` 目录包含设备文件。 其中许多是在启动时或甚至在运行时生成的。 例如，如果你将新的网络摄像头或 USB 随身碟连接到你的机器中，则会自动弹出一个新的设备条目。
#### /etc
`/etc` 的目录名称会让人变得非常的困惑。`/etc` 得名于最早的 Unix 系统们，它的字面意思是 “etcetera”（诸如此类） ，因为它是系统文件管理员不确定在哪里放置的文件的垃圾场。
现在，说 `/etc` 是“<ruby> 要配置的所有内容 <rt> Everything To Configure </rt></ruby>”更为恰当，因为它包含大部分（如果不是全部的话）的系统配置文件。 例如，包含系统名称、用户及其密码、网络上计算机名称以及硬盘上分区的安装位置和时间的文件都在这里。 再说一遍，如果你是 Linux 的新手，最好是不要在这里接触太多，直到你对系统的工作有更好的理解。
#### /home
`/home` 是你可以找到用户个人目录的地方。在我的情况下，`/home` 下有两个目录：`/home/paul`，其中包含我所有的东西；另外一个目录是 `/home/guest` 目录，以防有客人需要使用我的电脑。
#### /lib
`/lib` 是库文件所在的地方。库是包含应用程序可以使用的代码文件。它们包含应用程序用于在桌面上绘制窗口、控制外围设备或将文件发送到硬盘的代码片段。
在文件系统周围散布着更多的 `lib` 目录，但是这个直接挂载在 `/` 的 `/lib` 目录是特殊的，除此之外，它包含了所有重要的内核模块。 内核模块是使你的显卡、声卡、WiFi、打印机等工作的驱动程序。
#### /media
在 `/media` 目录中，当你插入外部存储器试图访问它时，将自动挂载它。与此列表中的大多数其他项目不同，`/media` 并不追溯到 1970 年代，主要是因为当计算机正在运行而动态地插入和检测存储（U 盘、USB 硬盘、SD 卡、外部 SSD 等)，这是近些年才发生的事。
#### /mnt
然而，`/mnt` 目录是一些过去的残余。这是你手动挂载存储设备或分区的地方。现在不常用了。
#### /opt
`/opt` 目录通常是你编译软件（即，你从源代码构建，并不是从你的系统的软件库中安装软件）的地方。应用程序最终会出现在 `/opt/bin` 目录，库会在 `/opt/lib` 目录中出现。
稍微的题外话：应用程序和库的另一个地方是 `/usr/local`，在这里安装软件时，也会有 `/usr/local/bin` 和 `/usr/local/lib` 目录。开发人员如何配置文件来控制编译和安装过程，这就决定了软件安装到哪个地方。
#### /proc
`/proc`，就像 `/dev` 是一个虚拟目录。它包含有关你的计算机的信息，例如关于你的 CPU 和你的 Linux 系统正在运行的内核的信息。与 `/dev` 一样，文件和目录是在计算机启动或运行时生成的，因为你的系统正在运行且会发生变化。
#### /root
`/root` 是系统的超级用户（也称为“管理员”）的主目录。 它与其他用户的主目录是分开的，**因为你不应该动它**。 所以把自己的东西放在你自己的目录中，伙计们。
#### /run
`/run` 是另一个新出现的目录。系统进程出于自己不可告人的原因使用它来存储临时数据。这是另一个**不要动它**的文件夹。
#### /sbin
`/sbin` 与 `/bin` 类似，但它包含的应用程序只有超级用户（即首字母的 `s` ）才需要。你可以使用 `sudo` 命令使用这些应用程序，该命令暂时允许你在许多 Linux 发行版上拥有超级用户权限。`/sbin` 目录通常包含可以安装、删除和格式化各种东西的工具。你可以想象，如果你使用不当，这些指令中有一些是致命的，所以要小心处理。
#### /usr
`/usr` 目录是在 UNIX 早期用户的主目录所处的地方。然而，正如我们上面看到的，现在 `/home` 是用户保存他们的东西的地方。如今，`/usr` 包含了大量目录，而这些目录又包含了应用程序、库、文档、壁纸、图标和许多其他需要应用程序和服务共享的内容。
你还可以在 `/usr` 目录下找到 `bin`，`sbin`，`lib` 目录，它们与挂载到根目录下的那些有什么区别呢？现在的区别不是很大。在早期，`/bin` 目录（挂载在根目录下的）只会包含一些基本的命令，例如 `ls`、`mv` 和 `rm` ；这是一些在安装系统的时候就会预装的一些命令，用于维护系统的一个基本的命令。 而 `/usr/bin` 目录则包含了用户自己安装和用于工作的软件，例如文字处理器，浏览器和一些其他的软件。
但是许多现代的 Linux 发行版只是把所有的东西都放到 `/usr/bin` 中，并让 `/bin` 指向 `/usr/bin`，以防彻底删除它会破坏某些东西。因此，Debian、Ubuntu 和 Mint 仍然保持 `/bin` 和 `/usr/bin` （和 `/sbin` 和 `/usr/sbin` ）分离；其他的，比如 Arch 和它衍生版，只是有一个“真实”存储二进制程序的目录，`/usr/bin`，其余的任何 `bin` 目录是指向 `/usr/`bin` 的“假”目录。
#### /srv
`/srv` 目录包含服务器的数据。如果你正在 Linux 机器上运行 Web 服务器，你网站的 HTML文件将放到 `/srv/http`（或 `/srv/www`）。 如果你正在运行 FTP 服务器，则你的文件将放到 `/srv/ftp`。
#### /sys
`/sys` 是另一个类似 `/proc` 和 `/dev` 的虚拟目录，它还包含连接到计算机的设备的信息。
在某些情况下，你还可以操纵这些设备。 例如，我可以通过修改存储在 `/sys/devices/pci0000:00/0000:00:02.0/drm/card1/card1-eDP-1/intel_backlight/brightness` 中的值来更改笔记本电脑屏幕的亮度（在你的机器上你可能会有不同的文件）。但要做到这一点，你必须成为超级用户。原因是，与许多其它虚拟目录一样，在 `/sys` 中打乱内容和文件可能是危险的，你可能会破坏系统。直到你确信你知道你在做什么。否则不要动它。
#### /tmp
`/tmp` 包含临时文件，通常由正在运行的应用程序放置。文件和目录通常（并非总是）包含应用程序现在不需要但以后可能需要的数据。
你还可以使用 `/tmp` 来存储你自己的临时文件 —— `/tmp` 是少数挂载到根目录下而你可以在不成为超级用户的情况下与它进行实际交互的目录之一。
#### /var
`/var` 最初被如此命名是因为它的内容被认为是<ruby> 可变的 <rt> variable </rt></ruby>，因为它经常变化。今天，它有点用词不当，因为还有许多其他目录也包含频繁更改的数据，特别是我们上面看到的虚拟目录。
不管怎样，`/var` 目录包含了放在 `/var/log` 子目录的日志文件之类。日志是记录系统中发生的事件的文件。如果内核中出现了什么问题，它将被记录到 `/var/log` 下的文件中；如果有人试图从外部侵入你的计算机，你的防火墙也将记录尝试。它还包含用于任务的假脱机程序。这些“任务”可以是你发送给共享打印机必须等待执行的任务，因为另一个用户正在打印一个长文档，或者是等待递交给系统上的用户的邮件。
你的系统可能还有一些我们上面没有提到的目录。例如，在屏幕截图中，有一个 `/snap` 目录。这是因为这张截图是在 Ubuntu 系统上截取的。Ubuntu 最近将 [snap](https://www.ubuntu.com/desktop/snappy) 包作为一种分发软件的方式。`/snap` 目录包含所有文件和从 snaps 安装的软件。
### 更深入的研究
这里仅仅谈了根目录，但是许多子目录都指向它们自己的一组文件和子目录。图 2 给出了基本文件系统的总体概念（图片是在 Paul Gardner 的 CC BY-SA 许可下提供的），[Wikipedia 对每个目录的用途进行了总结](https://en.wikipedia.org/wiki/Unix_filesystem#Conventional_directory_layout)。
*图 2：标准 Unix 文件系统*
要自行探索文件系统，请使用 `cd` 命令：`cd`将带你到你所选择的目录（ `cd` 代表更改目录）。
如果你不知道你在哪儿，`pwd`会告诉你，你到底在哪里，（ `pwd` 代表打印工作目录 ），同时 `cd`命令在没有任何选项或者参数的时候，将会直接带你到你自己的主目录，这是一个安全舒适的地方。
最后，`cd ..`将会带你到上一层目录，会使你更加接近根目录，如果你在 `/usr/share/wallpapers` 目录，然后你执行 `cd ..` 命令，你将会跳转到 `/usr/share` 目录
要查看目录里有什么内容，使用 `ls` 或这简单的使用 `l` 列出你所在目录的内容。
当然，你总是可以使用 `tree` 来获得目录中内容的概述。在 `/usr/share` 上试试——里面有很多有趣的东西。
### 总结
尽管 Linux 发行版之间存在细微差别，但它们的文件系统的布局非常相似。 你可以这么说：一旦你了解一个，你就会都了解了。 了解文件系统的最好方法就是探索它。 因此，伴随 `tree` ，`ls` 和 `cd` 进入未知的领域吧。
你不会只是因为查看文件系统就破坏了文件系统，因此请从一个目录移动到另一个目录并进行浏览。 很快你就会发现 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/4/linux-filesystem-explained>
作者：[PAUL BROWN](https://www.linux.com/users/bro66) 选题：[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/) 荣誉推出
|
||
容器基础知识：你需要知道的术语
|
Swapnil Bhartiya
|
https://www.linux.com/blog/intro-to-linux/2017/12/container-basics-terms-you-need-know
|
让我们来探讨 Docker 容器世界中使用的一些基本术语吧。
|
/data/attachment/album/201807/02/100402fcve3ll4fvzo9aev.jpg.thumb.jpg
|
/data/attachment/album/201807/02/100402fcve3ll4fvzo9aev.jpg
| true | false | true |
jessie-pang
| false |
[
"docker",
"容器"
] |
容器与云
|
{
"viewnum": 7486,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9468,
"displayorder": 0
},
{
"raid": 9773,
"displayorder": 0
}
] |
让我们来探讨 Docker 容器世界中使用的一些基本术语吧。
| 2018-07-02T10:03:59 | 2018-07-02T10:03:59 | 9,799 |
/article-9799-1.html
|
[在前一篇文章中](/article-9468-1.html)，我们谈到了<ruby> 容器 <rt> container </rt></ruby>是什么以及它是如何培育创新并助力企业快速发展的。在以后的文章中，我们将讨论如何使用容器。然而，在深入探讨这个话题之前，我们需要了解关于容器的一些术语和命令。掌握了这些术语，才不至于产生混淆。
让我们来探讨 [Docker](https://www.docker.com/) 容器世界中使用的一些基本术语吧。
<ruby> 容器 <rt> Container </rt></ruby>：到底什么是容器呢？它是一个 Docker <ruby> 镜像 <rt> image </rt></ruby>的运行实例。它包含一个 Docker 镜像、执行环境和说明。它与系统完全隔离，所以可以在系统上运行多个容器，并且完全无视对方的存在。你可以从同一镜像中复制出多个容器，并在需求较高时扩展服务，在需求低时对这些容器进行缩减。
Docker <ruby> 镜像 <rt> Image </rt></ruby>：这与你下载的 Linux 发行版的镜像别无二致。它是一个安装包，包含了用于创建、部署和执行容器的一系列依赖关系和信息。你可以在几秒钟内创建任意数量的完全相同的容器。镜像是分层叠加的。一旦镜像被创建出来，是不能更改的。如果你想对容器进行更改，则只需创建一个新的镜像并从该镜像部署新的容器即可。
<ruby> 仓库 <rt> Repository </rt></ruby>（repo）：Linux 的用户对于仓库这个术语一定不陌生吧。它是一个软件库，存储了可下载并安装在系统中的软件包。在 Docker 容器中，唯一的区别是它管理的是通过标签分类的 Docker 镜像。你可以找到同一个应用程序的不同版本或不同变体，他们都有适当的标记。
<ruby> 镜像管理服务 <rt> Registry </rt></ruby>：可以将其想象成 GitHub。这是一个在线服务，管理并提供了对 Docker 镜像仓库的访问，例如默认的公共镜像仓库——DockerHub。供应商可以将他们的镜像库上传到 DockerHub 上，以便他们的客户下载和使用官方镜像。一些公司为他们的镜像提供自己的服务。镜像管理服务不必由第三方机构来运行和管理。组织机构可以使用预置的服务来管理内部范围的镜像库访问。
<ruby> 标签 <rt> Tag </rt></ruby>：当你创建 Docker 镜像时，可以给它添加一个合适的标签，以便轻松识别不同的变体或版本。这与你在任何软件包中看到的并无区别。Docker 镜像在添加到镜像仓库时被标记。
现在你已经掌握了基本知识，下一个阶段是理解实际使用 Docker 容器时用到的术语。
**Dockerfile** ：这是一个文本文件，包含为了为构建 Docker 镜像需手动执行的命令。Docker 使用这些指令自动构建镜像。
<ruby> 构建 <rt> Build </rt></ruby>：这是从 Dockerfile 创建成镜像的过程。
<ruby> 推送 <rt> Push </rt></ruby>：一旦镜像创建完成，“push” 是将镜像发布到仓库的过程。该术语也是我们下一篇文章要学习的命令之一。
<ruby> 拉取 <rt> Pull </rt></ruby>：用户可以通过 “pull” 过程从仓库检索该镜像。
<ruby> 编组 <rt> Compose </rt></ruby>：复杂的应用程序会包含多个容器。docker-compose 是一个用于运行多容器应用程序的命令行工具。它允许你用单条命令运行一个多容器的应用程序，简化了多容器带来的问题。
### 总结
容器术语的范围很广泛，这里是经常遇到的一些基本术语。下一次当你看到这些术语时，你会确切地知道它们的含义。在下一篇文章中，我们将开始使用 Docker 容器。
---
via: <https://www.linux.com/blog/intro-to-linux/2017/12/container-basics-terms-you-need-know>
作者：[Swapnil Bhartiya](https://www.linux.com/users/arnieswap) 译者：[jessie-pang](https://github.com/jessie-pang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
协同编辑器的历史性清单
|
Anacr
|
https://anarc.at/blog/2018-06-26-collaborative-editors-history/
|
按时间顺序快速列出主要协同编辑器的演变。
|
/data/attachment/album/201807/03/104256fa6lfmmmexxmmxl9.jpg.thumb.jpg
|
/data/attachment/album/201807/03/104256fa6lfmmmexxmmxl9.jpg
| true | false | true |
ZenMoore
| false |
[
"编辑器",
"协同"
] |
分享
|
{
"viewnum": 5114,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
按时间顺序快速列出主要协同编辑器的演变。
| 2018-07-03T10:43:00 | 2018-07-03T10:43:00 | 9,800 |
/article-9800-1.html
|
按时间顺序快速列出主要协同编辑器的演变。
正如任何这样的清单一样，它必定会在一开始便提到被誉为“<ruby> <a href="https://en.wikipedia.org/wiki/The_Mother_of_All_Demos"> 所有演示之母 </a> <rt> the mother of all demos </rt></ruby>”，在这个演示里<ruby> <a href="https://en.wikipedia.org/wiki/Douglas_Engelbart"> 道格·恩格尔巴特 </a> <rt> Doug Engelbart </rt></ruby>早在 1968 年就描述了几乎所有软件的详尽清单。这不仅包括协同编辑器，还包括图形、编程和数学编辑器。
一切都始于那个演示，只不过软件的实现跟不上硬件的发展罢了。
>
> 软件发展的速度比硬件提升的速度慢。——沃斯定律
>
>
>
闲话少说，这里是我找到的可圈可点的协同编辑器的清单。我说“可圈可点”的意思是它们具有可圈可点的特征或实现细节。
| 项目 | 日期 | 平台 | 说明 |
| --- | --- | --- | --- |
| [SubEthaEdit](https://www.codingmonkeys.de/subethaedit/) | 2003-2015？ | 仅 Mac | 我能找到的首个协同的、实时的、多光标的编辑器， [有个在 Emacs 上的逆向工程的尝试](https://www.emacswiki.org/emacs/SubEthaEmacs)却没有什么结果。 |
| [DocSynch](http://docsynch.sourceforge.net/) | 2004-2007 | ？ | 建立于 IRC 之上！ |
| [Gobby](https://gobby.github.io/) | 2005 至今 | C，多平台 | 首个开源、稳固可靠的实现。 仍然存在！众所周知 [libinfinoted](http://infinote.0x539.de/libinfinity/API/libinfinity/) 协议很难移植到其他编辑器中（例如： [Rudel](https://www.emacswiki.org/emacs/Rudel) 不能在 Emacs 上实现此协议）。 2017 年 1 月发行的 0.7 版本添加了也许可以改善这种状况的 Python 绑定。 值得注意的插件: 自动保存到磁盘。 |
| [Ethercalc](https://ethercalc.net/) | 2005 至今 | Web，JavaScript | 首个电子表格，随同 [Google Docs](https://en.wikipedia.org/wiki/Google_docs)。 |
| [moonedit](https://web.archive.org/web/20060423192346/http://www.moonedit.com:80/) | 2005-2008？ | ？ | 原网站已关闭。其他用户的光标可见并且会模仿击键的声音。 包括一个计算器和音乐定序器。 |
| [synchroedit](http://www.synchroedit.com/) | 2006-2007 | ？ | 首个 Web 应用。 |
| [Inkscape](http://wiki.inkscape.org/wiki/index.php/WhiteBoard) | 2007-2011 | C++ | 首个具备协同功能的图形编辑器，其背后的“whiteboard” 插件构建于 Jabber 之上，现已停摆。 |
| [Abiword](https://en.wikipedia.org/wiki/AbiWord) | 2008 至今 | C++ | 首个文字处理器。 |
| [Etherpad](http://etherpad.org/) | 2008 至今 | Web | 首款稳定的 Web 应用。 最初在 2008 年被开发时是一款大型 Java 应用，在 2009 年被谷歌收购并开源，然后在 2011 年被用 Node.JS 重写。使用广泛。 |
| [Wave](https://en.wikipedia.org/wiki/Apache_Wave) | 2009-2010 | Web， Java | 在大一统协议的尝试上失败。 |
| [CRDT](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type) | 2011 | 特定平台 | 在不同电脑间可靠地复制一个文件的数据结构的标准。 |
| [Operational transform](http://operational-transformation.github.io/) | 2013 | 特定平台 | 与 CRDT 类似，然而确切地说，两者是不同的。 |
| [Floobits](https://floobits.com/) | 2013 至今 | ？ | 商业软件，但有对各种编辑器的开源插件。 |
| [LibreOffice Online](https://wiki.documentfoundation.org/Development/LibreOffice_Online) | 2015至今 | Web | 免费的 Google docs 替代品，现已集成到 [Nextcloud](https://nextcloud.com/collaboraonline/) |
| [HackMD](https://hackmd.io/) | 2015 至今 | ？ | 商业软件，[开源](https://github.com/hackmdio/hackmd)。灵感来自于（已被 Dropbox 收购的) hackpad。 |
| [Cryptpad](https://cryptpad.fr/) | 2016 至今 | Web ? | Xwiki 的副产品。服务器端的加密的、“零知识” 产品。 |
| [Prosemirror](https://prosemirror.net/) | 2016 至今 | Web， Node.JS | “试图架起消除 Markdown 文本编辑和传统的所见即所得编辑器之间隔阂的桥梁。”不是完全意义上的编辑器，而是一种可以用来构建编辑器的工具。 |
| [Qill](https://quilljs.com/) | 2013 至今 | Web， Node.JS | 富文本编辑器，同时也是 JavaScript 编辑器。不确定是否是协同式的。 |
| [Teletype](https://teletype.atom.io/) | 2017 至今 | WebRTC， Node.JS | 为 GitHub 的 [Atom 编辑器](https://atom.io) 引入了“门户”的思路 ，使得访客可以夸多个文档跟踪主人的操作。访问介绍服务器后使用实时通讯的点对点技术（P2P），基于 CRDT。 |
| [Tandem](http://typeintandem.com/) | 2018 至今 | Node.JS？ | Atom、 Vim、Neovim、 Sublime 等的插件。 使用中继来设置基于 CRDT 的 P2P 连接。多亏 Debian 开发者的参与，[可疑证书问题](https://github.com/typeintandem/tandem/issues/131)已被解决，这使它成为很有希望在未来被遵循的标准。 |
### 其他清单
* [Emacs 维基](https://www.emacswiki.org/emacs/CollaborativeEditing)
* [维基百科](https://en.wikipedia.org/wiki/Collaborative_real-time_editor)
---
via: <https://anarc.at/blog/2018-06-26-collaborative-editors-history/>
作者：[Anacr](https://anarc.at) 选题：[lujun9972](https://github.com/lujun9972) 译者：[ZenMoore](https://github.com/ZenMoore) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在开源项目中做出你的第一个贡献
|
Palash Nigam
|
https://opensource.com/article/18/4/get-started-open-source-project
|
这是许多事情的第一步
|
/data/attachment/album/201807/03/110953dg5cui5c31a3uisg.png.thumb.jpg
|
/data/attachment/album/201807/03/110953dg5cui5c31a3uisg.png
| true | false | true |
lonaparte
| false |
[
"贡献",
"开源项目"
] |
观点
|
{
"viewnum": 5038,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 2,
"likes": 0
}
|
[] |
[] |
这是许多事情的第一步
| 2018-07-03T11:09:48 | 2018-07-03T11:09:48 | 9,801 |
/article-9801-1.html
|
>
> 这是许多事情的第一步
>
>
>
有一个普遍的误解，那就是对开源做出贡献是一件很难的事。你可能会想，“有时我甚至不能理解我自己的代码；那我怎么可能理解别人的？”
放轻松。直到去年，我都以为是这样。阅读和理解他人的代码，然后在他们的基础上写上你自己的代码，这是一件令人气馁的任务；但如果有合适的资源，这不像你想象的那么糟。
第一步要做的是选择一个项目。这个决定是可能是一个菜鸟转变成一个老练的开源贡献者的关键一步。
许多对开源感兴趣的业余程序员都被建议从 [Git](https://git-scm.com/) 入手，但这并不是最好的开始方式。Git 是由许多有着多年软件开发经验的超级极客维护的。它是寻找可以做贡献的开源项目的好地方，但对新手并不友好。大多数对 Git 做出贡献的开发者都有足够的经验，他们不需要参考各类资源或文档。在这篇文章里，我将提供一个对新手友好的特性的列表，并且给出一些建议，希望可以使你更轻松地对开源做出贡献。
### 理解产品
在开始贡献之前，你需要理解项目是怎么工作的。为了理解这一点，你需要自己来尝试。如果你发现这个产品很有趣并且有用，它就值得你来做贡献。
初学者常常选择参与贡献那些他们没有使用过的软件。他们会失望，并且最终放弃贡献。如果你没有用过这个软件，你不会理解它是怎么工作的。如果你不理解它是怎么工作的，你怎么能解决 bug 或添加新特性呢？
要记住：尝试它，才能改变它。
### 确认产品的状况
这个项目有多活跃？
如果你向一个暂停维护的项目提交一个<ruby> 拉取请求 <rt> pull request </rt></ruby>，你的请求可能永远不会被讨论或合并。找找那些活跃的项目，这样你的代码可以得到即时的反馈，你的贡献也就不会被浪费。
这里介绍了怎么确认一个项目是否还是活跃的：
* **贡献者数量：** 一个增加的贡献者数量表明开发者社区乐于接受新的贡献者。
* **<ruby> 提交 <rt> commit </rt></ruby>频率：** 查看最近的提交时间。如果是一周之内，甚至是一两个月内，这个项目应该是定期维护的。
* **维护者数量：** 维护者的数量越多，你越可能得到指导。
* **聊天室或 IRC 活跃度：** 一个繁忙的聊天室意味着你的问题可以更快得到回复。
### 新手资源
Coala 是一个开源项目的例子。它有自己的教程和文档，让你可以使用它（每一个类和方法）的 API。这个网站还设计了一个有吸引力的界面，让你有阅读的兴趣。
**文档：** 不管哪种水平的开发者都需要可靠的、被很好地维护的文档，来理解项目的细节。找找在 [GitHub](https://github.com/)（或者放在其它位置）或者类似于 [Read the Docs](https://readthedocs.org/) 之类的独立站点上提供了完善文档的项目，这样可以帮助你深入了解代码。
**教程：** 教程会给新手解释如何在项目里添加特性 （然而，你不是在每个项目中都能找到它）。例如，Coala 提供了 [小熊编写指南](http://api.coala.io/en/latest/Developers/Writing_Linter_Bears.html) （进行代码分析的<ruby> 代码格式化 <rt> linting </rt></ruby>工具的 Python 包装器）。
**分类的<ruby> 讨论点 <rt> issue </rt></ruby>：** 对刚刚想明白如何选择第一个项目的初学者来说，选择一个讨论点是一个更加困难的任务。标签被设为“难度/低”、“难度/新手”、“利于初学者”，以及“<ruby> 触手可及 <rt> low-hanging fruit </rt></ruby>”都表明是对新手友好的。
### 其他因素
* **维护者对新的贡献者的态度：** 从我的经验来看，大部分开源贡献者都很乐于帮助他们项目里的新手。然而，当你问问题时，你也有可能遇到一些不太友好的人（甚至可能有点粗鲁）。不要因为这些人失去信心。他们只是因为在比他们经验更丰富的人那儿得不到发泄的机会而已。还有很多其他人愿意提供帮助。
* **审阅过程/机制：** 你的拉取请求将经历几遍你的同伴和有经验的开发者的查看和更改——这就是你学习软件开发最主要的方式。一个具有严格审阅过程的项目使您在编写生产级代码的过程中成长。
* **一个稳健的<ruby> 持续集成 <rt> continuous integration </rt></ruby>管道：** 开源项目会向新手们介绍持续集成和部署服务。一个稳健的 CI 管道将帮助你学习阅读和理解 CI 日志。它也将带给你处理失败的测试用例和代码覆盖率问题的经验。
* **参加编程项目（例如 [Google Summer Of Code](https://en.wikipedia.org/wiki/Google_Summer_of_Code)）：** 参加组织证明了你乐于对一个项目的长期发展做贡献。他们也会给新手提供一个机会来获得现实世界中的开发经验，从而获得报酬。大多数参加这些项目的组织都欢迎新人加入。
### 7 对新手友好的组织
* [coala (Python)](https://github.com/coala/coala)
* [oppia (Python, Django)](https://github.com/oppia/oppia)
* [DuckDuckGo (Perl, JavaScript)](https://github.com/duckduckgo/)
* [OpenGenus (JavaScript)](https://github.com/OpenGenus/)
* [Kinto (Python, JavaScript)](https://github.com/kinto)
* [FOSSASIA (Python, JavaScript)](https://github.com/fossasia/)
* [Kubernetes (Go)](https://github.com/kubernetes)
### 关于作者
Palash Nigam - 我是一个印度计算机科学专业本科生，十分乐于参与开源软件的开发，我在 GitHub 上花费了大部分的时间。我现在的兴趣包括 web 后端开发，区块链，和 All things python。
---
via: <https://opensource.com/article/18/4/get-started-open-source-project>
作者：[Palash Nigam](https://opensource.com/users/palash25) 译者：[lonaparte](https://github.com/lonaparte) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何记录你在终端中执行的所有操作
|
Sk
|
https://www.ostechnix.com/record-everything-terminal/
|
无论你是安装程序，创建目录/文件还是删除文件夹，一切都会被记录下来，包括命令和相应的输出。这个命令对那些想要一份交互式会话拷贝作为作业证明的人有用。无论是学生还是导师，你都可以将所有在终端中执行的操作和所有输出复制一份。
|
/data/attachment/album/201807/03/111838fnoqyctynxwzxdx4.jpg.thumb.jpg
|
/data/attachment/album/201807/03/111838fnoqyctynxwzxdx4.jpg
| true | false | true |
geekpi
| false |
[
"日志",
"script",
"记录"
] |
技术
|
{
"viewnum": 7043,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
无论你是安装程序，创建目录/文件还是删除文件夹，一切都会被记录下来，包括命令和相应的输出。这个命令对那些想要一份交互式会话拷贝作为作业证明的人有用。无论是学生还是导师，你都可以将所有在终端中执行的操作和所有输出复制一份。
| 2018-07-03T11:19:00 | 2018-07-03T11:19:00 | 9,802 |
/article-9802-1.html
|
几天前，我们发布了一个解释如何[保存终端中的命令并按需使用](https://www.ostechnix.com/save-commands-terminal-use-demand/)的指南。对于那些不想记忆冗长的 Linux 命令的人来说，这非常有用。今天，在本指南中，我们将看到如何使用 `script` 命令记录你在终端中执行的所有操作。你可能已经在终端中运行了一个命令，或创建了一个目录，或者安装了一个程序。`script` 命令会保存你在终端中执行的任何操作。如果你想知道你几小时或几天前做了什么，那么你可以查看它们。我知道我知道，我们可以使用上/下箭头或 `history` 命令查看以前运行的命令。但是，你无法查看这些命令的输出。而 `script` 命令记录并显示完整的终端会话活动。
`script` 命令会在终端中创建你所做的所有事件的记录。无论你是安装程序，创建目录/文件还是删除文件夹，一切都会被记录下来，包括命令和相应的输出。这个命令对那些想要一份交互式会话拷贝作为作业证明的人有用。无论是学生还是导师，你都可以将所有在终端中执行的操作和所有输出复制一份。
### 在 Linux 中使用 script 命令记录终端中的所有内容
`script` 命令预先安装在大多数现代 Linux 操作系统上。所以，我们不用担心安装。
让我们继续看看如何实时使用它。
运行以下命令启动终端会话记录。
```
$ script -a my_terminal_activities
```
其中，`-a` 标志用于将输出追加到文件（记录）中，并保留以前的内容。上述命令会记录你在终端中执行的所有操作，并将输出追加到名为 `my_terminal_activities` 的文件中，并将其保存在当前工作目录中。
示例输出：
```
Script started, file is my_terminal_activities
```
现在，在终端中运行一些随机的 Linux 命令。
```
$ mkdir ostechnix
$ cd ostechnix/
$ touch hello_world.txt
$ cd ..
$ uname -r
```
运行所有命令后，使用以下命令结束 `script` 命令的会话：
```
$ exit
```
示例输出：
```
exit
Script done, file is my_terminal_activities
```
如你所见，终端活动已存储在名为 `my_terminal_activities` 的文件中，并将其保存在当前工作目录中。
要查看你的终端活动，只需在任何编辑器中打开此文件，或者使用 `cat` 命令直接显示它。
```
$ cat my_terminal_activities
```
示例输出：
```
Script started on Thu 09 Mar 2017 03:33:44 PM IST
[sk@sk]: ~>$ mkdir ostechnix
[sk@sk]: ~>$ cd ostechnix/
[sk@sk]: ~/ostechnix>$ touch hello_world.txt
[sk@sk]: ~/ostechnix>$ cd ..
[sk@sk]: ~>$ uname -r
4.9.11-1-ARCH
[sk@sk]: ~>$ exit
exit
Script done on Thu 09 Mar 2017 03:37:49 PM IST
```
正如你在上面的输出中看到的，`script` 命令记录了我所有的终端活动，包括 `script` 命令的开始和结束时间。真棒，不是吗？使用 `script` 命令的原因不仅仅是记录命令，还有命令的输出。简单地说，脚本命令将记录你在终端上执行的所有操作。
### 结论
就像我说的那样，脚本命令对于想要保留其终端活动记录的学生，教师和 Linux 用户非常有用。尽管有很多 CLI 和 GUI 可用来执行此操作，但 `script` 命令是记录终端会话活动的最简单快捷的方式。
就是这些。希望这有帮助。如果你发现本指南有用，请在你的社交，专业网络上分享，并支持我们。
干杯!
---
via: <https://www.ostechnix.com/record-everything-terminal/>
作者：[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/) 荣誉推出
|
||
不要再手动合并你的拉取请求（PR）
|
Julien Danjou
|
https://julien.danjou.info/stop-merging-your-pull-request-manually/
|
如果有什么我讨厌的东西，那就是当我知道我可以自动化它们时，但我手动进行了操作。只有我有这种情况么？我觉得不是。
|
/data/attachment/album/201807/03/215624d3a6b26agw2wj6nj.png.thumb.jpg
|
/data/attachment/album/201807/03/215624d3a6b26agw2wj6nj.png
| true | false | true |
geekpi
| false |
[
"拉取请求",
"GitHub"
] |
软件开发
|
{
"viewnum": 5589,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果有什么我讨厌的东西，那就是当我知道我可以自动化它们时，但我手动进行了操作。只有我有这种情况么？我觉得不是。
| 2018-07-03T21:56:22 | 2018-07-03T21:56:22 | 9,803 |
/article-9803-1.html
|
如果有什么我讨厌的东西，那就是当我知道我可以自动化它们时，但我手动进行了操作。只有我有这种情况么？我觉得不是。
尽管如此，他们每天都有数千名使用 [GitHub](https://github.com) 的开发人员一遍又一遍地做同样的事情：他们点击这个按钮：
这没有任何意义。
不要误解我的意思。合并拉取请求是有意义的。只是每次点击这个该死的按钮是没有意义的。
这样做没有意义因为世界上的每个开发团队在合并拉取请求之前都有一个已知的先决条件列表。这些要求几乎总是相同的，而且这些要求也是如此：
* 是否通过测试？
* 文档是否更新了？
* 这是否遵循我们的代码风格指南？
* 是否有若干位开发人员对此进行审查？
随着此列表变长，合并过程变得更容易出错。 “糟糕，在没有足够的开发人员审查补丁时 John 就点了合并按钮。” 要发出警报么？
在我的团队中，我们就像外面的每一支队伍。我们知道我们将一些代码合并到我们仓库的标准是什么。这就是为什么我们建立一个持续集成系统，每次有人创建一个拉取请求时运行我们的测试。我们还要求代码在获得批准之前由团队的 2 名成员进行审查。
当这些条件全部设定好时，我希望代码被合并。
而不用点击一个按钮。
这正是启动 [Mergify](https://mergify.io) 的原因。
[Mergify](https://mergify.io) 是一个为你按下合并按钮的服务。你可以在仓库的 `.mergify.yml` 中定义规则，当规则满足时，Mergify 将合并该请求。
无需按任何按钮。
随机抽取一个请求，就像这样：
这来自一个小型项目，没有很多持续集成服务，只有 Travis。在这个拉取请求中，一切都是绿色的：其中一个所有者审查了代码，并且测试通过。因此，该代码应该被合并：但是它还在那里挂起这，等待某人有一天按下合并按钮。
使用 [Mergify](https://mergify.io) 后，你只需将 `.mergify.yml` 放在仓库的根目录即可：
```
rules:
default:
protection:
required_status_checks:
contexts:
- continuous-integration/travis-ci
required_pull_request_reviews:
required_approving_review_count: 1
```
通过这样的配置，[Mergify](https://mergify.io) 可以实现所需的限制，即 Travis 通过，并且至少有一个项目成员审阅了代码。只要这些条件是肯定的，拉取请求就会自动合并。
我们将 [Mergify](https://mergify.io) 构建为 **一个对开源项目免费的服务**。[提供服务的引擎](https://github.com/mergifyio/mergify-engine)也是开源的。
现在去[尝试它](https://mergify.io)，不要让这些拉取请求再挂起哪怕一秒钟。合并它们！
如果你有任何问题，请随时在下面向我们提问或写下评论！并且敬请期待 - 因为 Mergify 还提供了其他一些我迫不及待想要介绍的功能！
---
via: <https://julien.danjou.info/stop-merging-your-pull-request-manually/>
作者：[Julien Danjou](https://julien.danjou.info/author/jd/) 选题：[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/) 荣誉推出
|
||
Intel 和 AMD 透露新的处理器设计
|
Eric Brown
|
https://www.linux.com/blog/2018/6/intel-amd-and-arm-reveal-new-processor-designs
|
Whiskey Lake U 系列和 Amber Lake Y 系列的酷睿芯片将会在今年秋季开始出现在超过 70 款笔记本以及 2 合 1 机型中。
|
/data/attachment/album/201807/04/094930tdxid7b0jpejb8j8.jpg.thumb.jpg
|
/data/attachment/album/201807/04/094930tdxid7b0jpejb8j8.jpg
| true | false | true |
softpaopao
| false |
[
"CPU"
] |
新闻
|
{
"viewnum": 7055,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Whiskey Lake U 系列和 Amber Lake Y 系列的酷睿芯片将会在今年秋季开始出现在超过 70 款笔记本以及 2 合 1 机型中。
| 2018-07-04T09:49:26 | 2018-07-04T09:49:26 | 9,804 |
/article-9804-1.html
|
>
> Whiskey Lake U 系列和 Amber Lake Y 系列的酷睿芯片将会在今年秋季开始出现在超过 70 款笔记本以及 2 合 1 机型中。
>
>
>
根据最近的台北国际电脑展 (Computex 2018) 以及最近其它的消息，处理器成为科技新闻圈中最前沿的话题。Intel 发布了一些公告涉及从新的酷睿处理器到延长电池续航的尖端技术。与此同时，AMD 亮相了第二代 32 核心的高端游戏处理器线程撕裂者（Threadripper）以及一些适合嵌入式的新型号锐龙 Ryzen 处理器。
以上是对 Intel 和 AMD 主要公布产品的快速浏览，针对那些对嵌入式 Linux 开发者最感兴趣的处理器。
### Intel 最新的第八代 CPU 家族
在四月份，Intel 已经宣布量产 10nm 制程的 Cannon Lake 系列酷睿处理器将会延期到 2019 年，这件事引起了人们对摩尔定律最终走上正轨的议论。然而，在 Intel 的 [Computex 展区](https://newsroom.intel.com/editorials/pc-personal-contribution-platform-pushing-boundaries-modern-computers-computex/) 中有着众多让人欣慰的消息。Intel 展示了两款节能的第八代 14nm 酷睿家族产品，同时也是 Intel 首款 5GHz 的设计。
Whiskey Lake U 系列和 Amber Lake Y 系列的酷睿芯片将会在今年秋季开始出现在超过 70 款笔记本以及 2 合 1 机型中。Intel 表示，这些芯片相较于第七代的 Kaby Lake 酷睿系列处理器会带来两倍的性能提升。新的产品家族将会相比于目前出现的搭载 [Coffee Lake](https://www.linux.com/news/elc-openiot/2018/3/hot-chips-face-mwc-and-embedded-world) 芯片的产品更加节能 。
Whiskey Lake 和 Amber Lake 两者将会配备 Intel 高性能千兆 WiFi (Intel 9560 AC)，该网卡同样出现在 [Gemini Lake](http://linuxgizmos.com/intel-launches-gemini-lake-socs-with-gigabit-wifi/) 架构的奔腾银牌和赛扬处理器，随之出现在 Apollo Lake 一代。千兆 WiFi 本质上就是 Intel 将 2×2 MU-MIMO 和 160MHz 信道技术与 802.11ac 结合。
Intel 的 Whiskey Lake 将作为第七代和第八代 Skylake U 系列处理器的继任者，它们现在已经流行于嵌入式设备。Intel 透漏了少量细节，但是 Whiskey Lake 想必将会提供同样的，相对较低的 15W TDP。这与 [Coffee Lake U 系列芯片](http://linuxgizmos.com/intel-coffee-lake-h-series-debuts-in-congatec-and-seco-modules) 也很像，它将会被用于四核以及 Kaby Lake 和 Skylake U 系列的双核芯片。
[PC World](https://www.pcworld.com/article/3278091/components-processors/intel-computex-news-a-28-core-chip-a-5ghz-8086-two-new-architectures-and-more.html) 报导称，Amber Lake Y 系列芯片主要目标定位是 2 合 1 机型。就像双核的 [Kaby Lake Y 系列](http://linuxgizmos.com/more-kaby-lake-chips-arrive-plus-four-nuc-mini-pcs/) 芯片，Amber Lake 将会支持 4.5W TDP。
为了庆祝 Intel 即将到来的 50 周年庆典， 同样也是作为世界上第一款 8086 处理器的 40 周年庆典，Intel 将启动一个限量版，带有一个时钟频率 4GHz 的第八代 [酷睿 i7-8086K](https://newsroom.intel.com/wp-content/uploads/sites/11/2018/06/intel-i7-8086k-launch-fact-sheet.pdf) CPU。 这款 64 位限量版产品将会是第一块拥有 5GHz, 单核睿频加速，并且是首款带有集成显卡的 6 核，12 线程处理器。Intel 将会于 6 月 7 日开始 [赠送](https://game.intel.com/8086sweepstakes/) 8086 块超频酷睿 i7-8086K 芯片。
Intel 也展示了计划于今年年底启动新的高端 Core X 系列拥有高核心和线程数。[AnandTech 预测](https://www.anandtech.com/show/12878/intel-discuss-whiskey-lake-amber-lake-and-cascade-lake) 可能会使用类似于 Xeon 的 Cascade Lake 架构。今年晚些时候，Intel 将会公布新的酷睿 S系列型号，AnandTech 预测它可能会是八核心的 Coffee Lake 芯片。
Intel 也表示第一款疾速傲腾 SSD —— 一个 M.2 接口产品被称作 [905P](https://www.intel.com/content/www/us/en/products/memory-storage/solid-state-drives/gaming-enthusiast-ssds/optane-905p-series.htm) —— 终于可用了。今年来迟的是 Intel XMM 800 系列调制解调器，它支持 Sprint 的 5G 蜂窝技术。Intel 表示 可用于 PC 的 5G 将会在 2019 年出现。
### Intel 承诺笔记本全天候的电池寿命
另一则消息，Intel 表示将会尽快启动一项 Intel 低功耗显示技术，它将会为笔记本设备提供一整天的电池续航。合作开发伙伴 Sharp 和 Innolux 正在使用这项技术在 2018 年晚期开始生产 1W 显示面板，这能节省 LCD 一半的电量消耗。
### AMD 继续翻身
在展会中，AMD 亮相了第二代拥有 32 核 64 线程的线程撕裂者（Threadripper） CPU。为了走在 Intel 尚未命名的 28 核怪兽之前，这款高端游戏处理器将会在第三季度推出。根据 [Engadget](https://www.engadget.com/2018/06/05/amd-threadripper-32-cores/) 的消息，新的线程撕裂者同样采用了被用在锐龙 Ryzen 芯片的 12nm Zen+ 架构。
[WCCFTech](https://wccftech.com/amd-demos-worlds-first-7nm-gpu/) 报导，AMD 也表示它选自 7nm Vega Instinct GPU（为拥有 32GB 昂贵的 HBM2 显存而不是 GDDR5X 或 GDDR6 的显卡而设计）。这款 Vega Instinct 将提供相比现今 14nm Vega GPU 高出 35% 的性能和两倍的功效效率。新的渲染能力将会帮助它同 Nvidia 启用 CUDA 技术的 GPU 在光线追踪中竞争。
一些新的 Ryzen 2000 系列处理器近期出现在一个 ASRock CPU 聊天室，它将拥有比主流的 Ryzen 芯片更低的功耗。[AnandTech](https://www.anandtech.com/show/12841/amd-preps-new-ryzen-2000series-cpus-45w-ryzen-7-2700e-ryzen-5-2600e) 详细介绍了，2.8GHz，8 核心，16 线程的 Ryzen 7 2700E 和 3.4GHz/3.9GHz，六核，12 线程 Ryzen 5 2600E 都将拥有 45W TDP。这比 12-54W TDP 的 [Ryzen Embedded V1000](https://www.linux.com/news/elc-openiot/2018/3/hot-chips-face-mwc-and-embedded-world) 处理器更高，但低于 65W 甚至更高的主流 Ryzen 芯片。新的 Ryzen-E 型号是针对 SFF (外形小巧，small form factor) 和无风扇系统。
在 [开源峰会 + 欧洲嵌入式 Linux 会议](https://events.linuxfoundation.org/events/elc-openiot-europe-2018/) 加入我们，关于 Linux，云，容器，AI，社区等 100 多场会议，爱丁堡，英国，2018 年 10 月 22-24 日。
---
via: <https://www.linux.com/blog/2018/6/intel-amd-and-arm-reveal-new-processor-designs>
作者：[Eric Brown](https://www.linux.com/users/ericstephenbrown) 选题：[lujun9972](https://github.com/lujun9972) 译者：[softpaopao](https://github.com/softpaopao) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
云计算的成本
|
Elliot Forbes
|
https://read.acloud.guru/the-true-cost-of-cloud-a-comparison-of-two-development-teams-edc77d3dc6dc
|
两个开发团队的一天
|
/data/attachment/album/201807/04/114335fta5toze5dxqztpq.png.thumb.jpg
|
/data/attachment/album/201807/04/114335fta5toze5dxqztpq.png
| true | false | true |
qhwdw
| true |
[
"云计算"
] |
观点
|
{
"viewnum": 7740,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
两个开发团队的一天
| 2018-07-04T11:43:00 | 2018-07-04T11:43:00 | 9,805 |
/article-9805-1.html
|
>
> 两个开发团队的一天
>
>
>
几个月以前，我与一些人讨论过关于公共云服务成本与传统专用基础设施价格比较的话题。为给你提供一些见解，我们来跟踪一下一个企业中的两个开发团队 — 并比较他们构建类似服务的方式。
第一个团队将使用传统的专用基础设施来部署他们的应用，而第二个团队将使用 AWS 提供的公共云服务。
这两个团队被要求为一家全球化企业开发一个新的服务，该企业目前为全球数百万消费者提供服务。要开发的这项新服务需要满足以下基本需求：
1. 能够随时**扩展**以满足弹性需求
2. 具备应对数据中心故障的**弹性**
3. 确保数据**安全**以及数据受到保护
4. 为排错提供深入的**调试**功能
5. 项目必须能**迅速分发**
6. 服务构建和维护的**性价比**要高
就新服务来说，这看起来是非常标准的需求 — 从本质上看传统专用基础设备上没有什么东西可以超越公共云了。
#### 1 — 扩展以满足客户需求
当说到可扩展性时，这个新服务需要去满足客户变化无常的需求。我们构建的服务不可以拒绝任何请求，以防让公司遭受损失或者声誉受到影响。
**传统团队**
使用的是专用基础设施，架构体系的计算能力需要与峰值数据需求相匹配。对于负载变化无常的服务来说，大量昂贵的计算能力在低利用率时被浪费掉。
这是一种很浪费的方法 — 并且大量的资本支出会侵蚀掉你的利润。另外，这些未充分利用的庞大的服务器资源的维护也是一项很大的运营成本。这是一项你无法忽略的成本 — 我不得不再强调一下，为支持一个单一服务去维护一机柜的服务器是多么的浪费时间和金钱。
**云团队**
使用的是基于云的自动伸缩解决方案，应用会按需要进行自动扩展和收缩。也就是说你只需要支付你所消费的计算资源的费用。
一个架构良好的基于云的应用可以实现无缝地伸缩 — 并且还是自动进行的。开发团队只需要定义好自动伸缩的资源组即可，即当你的应用 CPU 利用率达到某个高位、或者每秒有多大请求数时启动多少实例，并且你可以根据你的意愿去定制这些规则。
#### 2 — 应对故障的弹性
当说到弹性时，将托管服务的基础设施放在同一个房间里并不是一个好的选择。如果你的应用托管在一个单一的数据中心 — （不是如果）发生某些失败时（LCTT 译注：指坍塌、地震、洪灾等），你的所有的东西都被埋了。
**传统团队**
满足这种基本需求的标准解决方案是，为实现局部弹性建立至少两个服务器 — 在地理上冗余的数据中心之间实施秒级复制。
开发团队需要一个负载均衡解决方案，以便于在发生饱和或者故障等事件时将流量转向到另一个节点 — 并且还要确保镜像节点之间，整个栈是持续完全同步的。
**云团队**
在 AWS 全球 50 个地区中，他们都提供多个*可用区*。每个区域由多个容错数据中心组成 — 通过自动故障切换功能，AWS 可以将服务无缝地转移到该地区的其它区中。
在一个 `CloudFormation` 模板中定义你的*基础设施即代码*，确保你的基础设施在自动伸缩事件中跨区保持一致 — 而对于流量的流向管理，AWS 负载均衡服务仅需要做很少的配置即可。
#### 3 — 安全和数据保护
安全是一个组织中任何一个系统的基本要求。我想你肯定不想成为那些不幸遭遇安全问题的公司之一的。
**传统团队**
为保证运行他们服务的基础服务器安全，他们不得不持续投入成本。这意味着将需要投资一个团队，以监视和识别安全威胁，并用来自不同数据源的跨多个供应商解决方案打上补丁。
**云团队**
使用公共云并不能免除来自安全方面的责任。云团队仍然需要提高警惕，但是并不需要去担心为底层基础设施打补丁的问题。AWS 将积极地对付各种零日漏洞 — 最近的一次是 Spectre 和 Meltdown。
利用来自 AWS 的身份管理和加密安全服务，可以让云团队专注于他们的应用 — 而不是无差别的安全管理。使用 CloudTrail 对 API 到 AWS 服务的调用做全面审计，可以实现透明地监视。
#### 4 — 监视和日志
任何基础设施和部署为服务的应用都需要严密监视实时数据。团队应该有一个可以访问的仪表板，当超过指标阈值时仪表板会显示警报，并能够在排错时提供与事件相关的日志。
**传统团队**
对于传统基础设施，将不得不在跨不同供应商和“雪花状”的解决方案上配置监视和报告解决方案。配置这些“见鬼的”解决方案将花费你大量的时间和精力 — 并且能够正确地实现你的目的是相当困难的。
对于大多数部署在专用基础设施上的应用来说，为了搞清楚你的应用为什么崩溃，你可以通过搜索保存在你的服务器文件系统上的日志文件来找到答案。为此你的团队需要通过 SSH 进入服务器，导航到日志文件所在的目录，然后浪费大量的时间，通过 `grep` 在成百上千的日志文件中寻找。如果你在一个横跨 60 台服务器上部署的应用中这么做 — 我能负责任地告诉你，这是一个极差的解决方案。
**云团队**
利用原生的 AWS 服务，如 CloudWatch 和 CloudTrail，来做云应用程序的监视是非常容易。不需要很多的配置，开发团队就可以监视部署的服务上的各种指标 — 问题的排除过程也不再是个恶梦了。
对于传统的基础设施，团队需要构建自己的解决方案，配置他们的 REST API 或者服务去推送日志到一个聚合器。而得到这个“开箱即用”的解决方案将对生产力有极大的提升。
#### 5 — 加速开发进程
现在的商业环境中，快速上市的能力越来越重要。由于实施的延误所失去的机会成本，可能成为影响最终利润的一个主要因素。
**传统团队**
对于大多数组织，他们需要在新项目所需要的硬件采购、配置和部署上花费很长的时间 — 并且由于预测能力差，提前获得的额外的性能将造成大量的浪费。
而且还有可能的是，传统的开发团队在无数的“筒仓”中穿梭以及在移交创建的服务上花费数月的时间。项目的每一步都会在数据库、系统、安全、以及网络管理方面需要一个独立工作。
**云团队**
而云团队开发新特性时，拥有大量的随时可投入生产系统的服务套件供你使用。这是开发者的天堂。每个 AWS 服务一般都有非常好的文档并且可以通过你选择的语言以编程的方式去访问。
使用新的云架构，例如无服务器，开发团队可以在最小化冲突的前提下构建和部署一个可扩展的解决方案。比如，只需要几天时间就可以建立一个 [Imgur 的无服务器克隆](https://read.acloud.guru/building-an-imgur-clone-part-2-image-rekognition-and-a-dynamodb-backend-abc9af300123)，它具有图像识别的特性，内置一个产品级的监视/日志解决方案，并且它的弹性极好。
*如何建立一个 Imgur 的无服务器克隆*
如果必须要我亲自去设计弹性和可伸缩性，我可以向你保证，我会陷在这个项目的开发里 — 而且最终的产品将远不如目前的这个好。
从我实践的情况来看，使用无服务器架构的交付时间远小于在大多数公司中提供硬件所花费的时间。我只是简单地将一系列 AWS 服务与 Lambda 功能 — 以及 ta-da 耦合到一起而已！我只专注于开发解决方案，而无差别的可伸缩性和弹性是由 AWS 为我处理的。
#### 关于云计算成本的结论
就弹性而言，云计算团队的按需扩展是当之无愧的赢家 — 因为他们仅为需要的计算能力埋单。而不需要为维护和底层的物理基础设施打补丁付出相应的资源。
云计算也为开发团队提供一个可使用多个可用区的弹性架构、为每个服务构建的安全特性、持续的日志和监视工具、随用随付的服务、以及低成本的加速分发实践。
大多数情况下，云计算的成本要远低于为你的应用运行所需要的购买、支持、维护和设计的按需基础架构的成本 — 并且云计算的麻烦事更少。
通过利用云计算，我们可以更少的先期投入而使业务快速开展。整体而言，当你开发和部署业务服务时，云计算的经济性可以让你的工作更赞。
也有一些云计算比传统基础设施更昂贵的例子，一些情况是在周末忘记关闭运行的一些极其昂贵的测试机器。
[Dropbox 在决定推出自己的基础设施并减少对 AWS 服务的依赖之后，在两年的时间内节省近 7500 万美元的费用，Dropbox…——www.geekwire.com](https://www.geekwire.com/2018/dropbox-saved-almost-75-million-two-years-building-tech-infrastructure/)
即便如此，这样的案例仍然是非常少见的。更不用说当初 Dropbox 也是从 AWS 上开始它的业务的 — 并且当它的业务达到一个临界点时，才决定离开这个平台。即便到现在，他们也已经进入到云计算的领域了，并且还在 AWS 和 GCP 上保留了 40% 的基础设施。
将云服务与基于单一“成本”指标（LCTT 译注：此处的“成本”仅指物理基础设施的购置成本）的传统基础设施比较的想法是极其幼稚的 — 公然无视云为开发团队和你的业务带来的一些主要的优势。
在极少数的情况下，云服务比传统基础设施产生更多的绝对成本 — 但它在开发团队的生产力、速度和创新方面仍然贡献着更好的价值。
*客户才不在乎你的数据中心呢*
*我非常乐意倾听你在云中开发的真实成本相关的经验和反馈！请在下面的评论区、Twitter [@Elliot\_F](https://twitter.com/Elliot_F) 上、或者直接在 [LinkedIn](https://www.linkedin.com/in/elliotforbes/) 上联系我。*
---
via: <https://read.acloud.guru/the-true-cost-of-cloud-a-comparison-of-two-development-teams-edc77d3dc6dc>
作者：[Elliot Forbes](https://read.acloud.guru/@elliot_f?source=post_header_lockup) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
命令行中的世界杯
|
Luke Baker
|
https://www.linuxlinks.com/football-cli-world-cup-football-on-the-command-line/
|
如果你很喜欢命令行，那么有更好的方法用一个小型命令行程序追踪最新的世界杯比分和排名。
|
/data/attachment/album/201807/04/214729riril1v7egmtxklg.jpg.thumb.jpg
|
/data/attachment/album/201807/04/214729riril1v7egmtxklg.jpg
| true | false | true |
ZenMoore
| false |
[
"足球",
"比赛"
] |
分享
|
{
"viewnum": 3858,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你很喜欢命令行，那么有更好的方法用一个小型命令行程序追踪最新的世界杯比分和排名。
| 2018-07-04T21:47:25 | 2018-07-04T21:47:25 | 9,806 |
/article-9806-1.html
|
足球始终在我们身边。即使我们国家的队伍已经出局（LCTT 译注：显然这不是指我们国家，因为我们根本没有入局……），我还是想知道球赛比分。目前， 国际足联世界杯是世界上最大的足球锦标赛，2018 届是由俄罗斯主办的。每届世界杯都有一些足球强国未能取得参赛资格（LCTT 译注：我要吐槽么？）。意大利和荷兰就无缘本次世界杯。但是即使在未参加比赛的国家，追踪关注最新比分也成为了一种仪式。我希望能及时了解这个世界级的重大赛事最新比分的变化，而不用去搜索不同的网站。
如果你很喜欢命令行，那么有更好的方法用一个小型命令行程序追踪最新的世界杯比分和排名。让我们看一看最热门的可用的球赛趋势分析程序之一，它叫作 football-cli。
football-cli 不是一个开创性的应用程序。这几年，有许多命令行工具可以让你了解到最新的球赛比分和赛事排名。例如，我是 soccer-cli （Python 写的）和 App-football （Perl 写的）的重度用户。但我总是在寻找新的趋势分析应用，而 football-cli 在某些方面脱颖而出。
football-cli 是 JavaScript 开发的，由 Manraj Singh 编写，它是开源的软件。基于 MIT 许可证发布，用 npm（JavaScript 包管理器）安装十分简单。那么，让我们直接行动吧！
该应用程序提供了命令以获取过去及现在的赛事得分、查看联赛和球队之前和将要进行的赛事。它也会显示某一特定联赛的排名。有一条指令可以列出程序所支持的不同赛事。我们不妨从最后一个条指令开始。
在 shell 提示符下：
```
luke@ganges:~$ football lists
```
世界杯被列在最下方，我错过了昨天的比赛，所以为了了解比分，我在 shell 提示下输入：
```
luke@ganges:~$ football scores
```
现在，我想看看目前的世界杯小组排名。很简单：
```
luke@ganges:~$ football standings -l WC
```
下面是输出的一个片段：
你们当中眼尖的可能会注意到这里有一个错误。比如比利时看上去领先于 G 组，但这是不正确的，比利时和英格兰（截稿前）在得分上打平。在这种情况下，纪律好的队伍排名更高。英格兰收到两张黄牌，而比利时收到三张，因此，英格兰应当名列榜首。
假设我想知道利物浦 90 天前英超联赛的结果，那么:
```
luke@ganges:~$ football fixtures -l PL -d 90 -t "Liverpool"
```
我发现这个程序非常方便。它用一种清晰、整洁而有吸引力的方式显示分数和排名。当欧洲联赛再次开始时，它就更有用了。（事实上 2018-19 冠军联赛已经在进行中）！
这几个示例让大家对 football-cli 的实用性有了更深的体会。想要了解更多，请转至开发者的 [GitHub 页面](https://github.com/ManrajGrover/football-cli)。足球 ＋ 命令行 ＝ football-cli。
如同许多类似的工具一样，该软件从 football-data.org 获取相关数据。这项服务以机器可读的方式为所有欧洲主要联赛提供数据，包括比赛、球队、球员、结果等等。所有这些信息都是以 JOSN 形式通过一个易于使用的 RESTful API 提供的。
---
via: <https://www.linuxlinks.com/football-cli-world-cup-football-on-the-command-line/>
作者：[Luke Baker](https://www.linuxlinks.com/author/luke-baker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[ZenMoore](https://github.com/ZenMoore) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
3 个 Python 命令行工具
|
Jeff Triplett, Lacey Williams Hensche
|
https://opensource.com/article/18/5/3-python-command-line-tools
|
用 Click、Docopt 和 Fire 库写你自己的命令行应用。
|
/data/attachment/album/201807/04/221255bso5csppf0437x8r.jpg.thumb.jpg
|
/data/attachment/album/201807/04/221255bso5csppf0437x8r.jpg
| true | false | true |
hoppipolla-
| false |
[
"Python",
"命令行"
] |
技术
|
{
"viewnum": 9863,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用 Click、Docopt 和 Fire 库写你自己的命令行应用。
| 2018-07-04T22:13:05 | 2018-07-04T22:13:05 | 9,807 |
/article-9807-1.html
|
>
> 用 Click、Docopt 和 Fire 库写你自己的命令行应用。
>
>
>
有时对于某项工作来说一个命令行工具就足以胜任。命令行工具是一种从你的 shell 或者终端之类的地方交互或运行的程序。[Git](https://git-scm.com/) 和 [Curl](https://curl.haxx.se/) 就是两个你也许已经很熟悉的命令行工具。
当你有一小段代码需要在一行中执行多次或者经常性地被执行，命令行工具就会很有用。Django 开发者执行 `./manage.py runserver` 命令来启动他们的网络服务器；Docker 开发者执行 `docker-compose up` 来启动他们的容器。你想要写一个命令行工具的原因可能和你一开始想写代码的原因有很大不同。
对于这个月的 Python 专栏，我们有 3 个库想介绍给希望为自己编写命令行工具的 Python 使用者。
### Click
[Click](http://click.pocoo.org/5/) 是我们最爱的用来开发命令行工具的 Python 包。其：
* 有一个富含例子的出色文档
* 包含说明如何将命令行工具打包成一个更加易于执行的 Python 应用程序
* 自动生成实用的帮助文本
* 使你能够叠加使用可选和必要参数，甚至是 [多个命令](http://click.pocoo.org/5/commands/)
* 有一个 Django 版本（ [`django-click`](https://github.com/GaretJax/django-click) ）用来编写管理命令
Click 使用 `@click.command()` 去声明一个函数作为命令，同时可以指定必要和可选参数。
```
# hello.py
import click
@click.command()
@click.option('--name', default='', help='Your name')
def say_hello(name):
click.echo("Hello {}!".format(name))
if __name__ == '__main__':
say_hello()
```
`@click.option()` 修饰器声明了一个 [可选参数](http://click.pocoo.org/5/options/) ，而 `@click.argument()` 修饰器声明了一个 [必要参数](http://click.pocoo.org/5/arguments/)。你可以通过叠加修饰器来组合可选和必要参数。`echo()` 方法将结果打印到控制台。
```
$ python hello.py --name='Lacey'
Hello Lacey!
```
### Docopt
[Docopt](http://docopt.org/) 是一个命令行工具的解析器，类似于命令行工具的 Markdown。如果你喜欢流畅地编写应用文档，在本文推荐的库中 Docopt 有着最好的格式化帮助文本。它不是我们最爱的命令行工具开发包的原因是它的文档犹如把人扔进深渊，使你开始使用时会有一些小困难。然而，它仍是一个轻量级的、广受欢迎的库，特别是当一个漂亮的说明文档对你来说很重要的时候。
Docopt 对于如何格式化文章开头的 docstring 是很特别的。在工具名称后面的 docsring 中，顶部元素必须是 `Usage:` 并且需要列出你希望命令被调用的方式（比如：自身调用，使用参数等等）。`Usage:` 需要包含 `help` 和 `version` 参数。
docstring 中的第二个元素是 `Options:`，对于在 `Usages:` 中提及的可选项和参数，它应当提供更多的信息。你的 docstring 的内容变成了你帮助文本的内容。
```
"""HELLO CLI
Usage:
hello.py
hello.py <name>
hello.py -h|--help
hello.py -v|--version
Options:
<name> Optional name argument.
-h --help Show this screen.
-v --version Show version.
"""
from docopt import docopt
def say_hello(name):
return("Hello {}!".format(name))
if __name__ == '__main__':
arguments = docopt(__doc__, version='DEMO 1.0')
if arguments['<name>']:
print(say_hello(arguments['<name>']))
else:
print(arguments)
```
在最基本的层面，Docopt 被设计用来返回你的参数键值对。如果我不指定上述的 `name` 调用上面的命令，我会得到一个字典的返回值：
```
$ python hello.py
{'--help': False,
'--version': False,
'<name>': None}
```
这里可看到我没有输入 `help` 和 `version` 标记并且 `name` 参数是 `None`。
但是如果我带着一个 `name` 参数调用，`say_hello` 函数就会执行了。
```
$ python hello.py Jeff
Hello Jeff!
```
Docopt 允许同时指定必要和可选参数，且各自有着不同的语法约定。必要参数需要在 `ALLCAPS` 和 `<carets>` 中展示，而可选参数需要单双横杠显示，就像 `--like`。更多内容可以阅读 Docopt 有关 [patterns](https://github.com/docopt/docopt#usage-pattern-format) 的文档。
### Fire
[Fire](https://github.com/google/python-fire) 是谷歌的一个命令行工具开发库。尤其令人喜欢的是当你的命令需要更多复杂参数或者处理 Python 对象时，它会聪明地尝试解析你的参数类型。
Fire 的 [文档](https://github.com/google/python-fire/blob/master/docs/guide.md) 包括了海量的样例，但是我希望这些文档能被更好地组织。Fire 能够处理 [同一个文件中的多条命令](https://github.com/google/python-fire/blob/master/docs/guide.md#exposing-multiple-commands)、使用 [对象](https://github.com/google/python-fire/blob/master/docs/guide.md#version-3-firefireobject) 的方法作为命令和 [分组](https://github.com/google/python-fire/blob/master/docs/guide.md#grouping-commands) 命令。
它的弱点在于输出到控制台的文档。命令行中的 docstring 不会出现在帮助文本中，并且帮助文本也不一定标识出参数。
```
import fire
def say_hello(name=''):
return 'Hello {}!'.format(name)
if __name__ == '__main__':
fire.Fire()
```
参数是必要还是可选取决于你是否在函数或者方法定义中为其指定了一个默认值。要调用命令，你必须指定文件名和函数名，比较类似 Click 的语法：
```
$ python hello.py say_hello Rikki
Hello Rikki!
```
你还可以像标记一样传参，比如 `--name=Rikki`。
### 额外赠送：打包！
Click 包含了使用 `setuptools` [打包](http://click.pocoo.org/5/setuptools/) 命令行工具的使用说明（强烈推荐按照说明操作）。
要打包我们第一个例子中的命令行工具，将以下内容加到你的 `setup.py` 文件里：
```
from setuptools import setup
setup(
name='hello',
version='0.1',
py_modules=['hello'],
install_requires=[
'Click',
],
entry_points='''
[console_scripts]
hello=hello:say_hello
''',
)
```
任何你看见 `hello` 的地方，使用你自己的模块名称替换掉，但是要记得忽略 `.py` 后缀名。将 `say_hello` 替换成你的函数名称。
然后，执行 `pip install --editable` 来使你的命令在命令行中可用。
现在你可以调用你的命令，就像这样：
```
$ hello --name='Jeff'
Hello Jeff!
```
通过打包你的命令，你可以省掉在控制台键入 `python hello.py --name='Jeff'` 这种额外的步骤以减少键盘敲击。这些指令也很可能可在我们提到的其他库中使用。
---
via: <https://opensource.com/article/18/5/3-python-command-line-tools>
作者：[Jeff Triplett](https://opensource.com/users/laceynwilliams)，[Lacey Williams Hensche](https://opensource.com/users/laceynwilliams) 选题：[lujun9972](https://github.com/lujun9972) 译者：[hoppipolla-](https://github.com/hoppipolla-) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
红帽 6.28 媒体开放日手记
|
Finefan
|
在一个炎热的下午我代表 Linux 中国开源社区参加了 6 月 28 日的红帽媒体开放日。
|
/data/attachment/album/201807/04/222314c85ha0gwd04l5znd.jpg.thumb.jpg
|
/data/attachment/album/201807/04/222314c85ha0gwd04l5znd.jpg
| true | false | false | false |
[
"开源",
"红帽"
] |
观点
|
{
"viewnum": 4340,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
在一个炎热的下午我代表 Linux 中国开源社区参加了 6 月 28 日的红帽媒体开放日。
| 2018-07-04T22:41:00 | 2018-07-04T22:41:00 | 9,808 |
/article-9808-1.html
|
在一个炎热的下午我代表 Linux 中国开源社区参加了 6 月 28 日的红帽媒体开放日。以下内容摘录自该活动，有删节。
本次参加红帽开放日的主要官方人员如题图，从左到右分别是：
* Fedora 社区工程师 Adam Samalik
* 红帽资深高级云技术官 Thomas Cameron
* ManageIQ 社区负责人 Carol Chen
* 社区活动经理 Jennifer Madriaga
* Fedora 社区负责人 Brian Exelbierd
* CoreOS 及 Prometheus 社区软件工程师 Max Leonard Inden
以下是问题摘录：
### 问题 1
记者：我想问各位社区成员一个问题，大家本身是社区的负责人或者工程师，同时又有红帽的背景，你们怎么把技术能量转换成价值贡献给社区，又怎么将社区开源的服务能力转化给红帽？
Thomas Cameron：这个问题非常好，其实对我们来说这并不是两边。我们想的首先是这个技术先提供给社区，然后社区进一步的开发完善，最后成为供企业可以使用的技术或者软件，开源是红帽的 DNA，对我们来说最重要的一件事是使这些软件取得成功，因此在我们的工作是就某个软件进行研究，或者推动在某个软件上增加什么新的功能的时候，或者要求红帽提供更多的资源。我们想的目的都是一样的，就是先把技术放进社区，然后在这个基础上进一步的开发创新，最终拿出来供企业使用。
### 问题 2
记者：比较一下十年前的开源社区跟今天的开源社区的用户差别，十年前的开源社区是极客在参与这个项目，现在再去社区里看一下，有一些用户级的，他可能遇到使用上的麻烦，可能到社区找一些答案，我们这个产品可能在场景应用当中遇到一些特殊的问题和麻烦，这个时候能不能向这些应用者，向被迫进入社区的人介绍一下咱们的沟通机制和反馈机制是怎么样的？另外一个我看到咱们这个众筹项目正在进行中，不同的项目的沟通机制是什么样的，能不能给用户一个介绍？
Brian Exelbierd：这个问题，涉及到沟通的机制，对任何一个项目来说沟通发生在多个不同的层次上，以 Fedora 社区为例，我们的这些核心贡献者、开发建造软件并且把它们提供出来的开发者，他们在 IRC 里进行沟通交流，但是大量的用户沟通的地点在自己感兴趣的场景或者内容不同发生在不同的地点，有些特别专注于游戏或者某个特定场景，他们都有论坛和交流地点，我们也会提醒我们的人要去不同的地点才能了解到更多用户的反馈意见。
下个问题也是令人兴奋的问题，因为 Fedora 的发布会涉及到很多不同的技术，从最开始社区发展起来的时候，我们就在不同的技术小组间建立了很强的反馈和交流机制，我们在进行测试的时候也会对所有的要素进行测试，比如我们会和 CentOS、OpenCI 这样的项目进行联系看看在哪些点上可以实现很好的集成，在哪些点上可能存在问题，这也是不同项目组之间进行沟通的方式。
Max Leonard Inden：我也想补充一个观点，我们每个项目的沟通方式都是不一样的，但是各个项目之间仍然存在着非常密切的沟通，而且我们大家的态度是一样的：所有的沟通都是受欢迎的，没有人会因为在不合适的地点问了问题而受到责难，我们会欢迎你充分的参与进来，提出问题，这是非常重要的一点。
红帽技术人员：再补充一点，关于您提到的现在的普通用户参与社区比十年前多多了，今天的科技更复杂，解决方案也更复杂，我们上游社区的项目同样更复杂，用户也在试图参与进来，第二，对于开发者而言，他使用的最主要的沟通方式是代码和编码，因为代码是他们的共同语言，虽然有人发布了代码，那么就有人从代码的角度看一看应该怎么对他检查，漏洞怎么进行修改，所以代码对于全世界的开发者来说都是同样的语言。
### 问题 3
记者：红帽愿意帮助我们设立站点下载 ISO 和文件么？当我在用一个红帽的帐户登录网站的时候，我去下载镜像，点按纽会发现有一个衔接，由于我们国家到美国的网速非常慢，整个镜像下载不下来，我们的工作没法进展，我们的解决方案是租一个美国的 VPS，从 VPS 再下载到本地还是会超时，第二个解决方案是再租一个香港 VPS，把这个从美国的拉到香港 VPS，再从香港拉到本地这个时候发现中间这一块又特别慢，想知道红帽有没有相对的解决方案？
Thomas Cameron：我非常理解您的这种沮丧的情绪，而且我们也感觉这样非常麻烦。但是特别坦率的说，这个问题的解决方案涉及到方方面面，它同时是法律问题，监管问题，涉及到条约等各种各样的问题，而我们在座的人没有一个人适合回答这样的问题，因为我们不是相关问题的专家，但是鉴于您有红帽的帐户，我建议您联系一个帐户经理，他会想办法帮您找解决方案，因为我们不想使您得到非常坏的体验，也不想麻烦您建立多个 VPS 的去解决，但是这个问题的最终解决还是需要律师法律团队和网络的工程团队，我们没办法回答，谢谢。
### 问题 4
记者：在 Fedora 社区有不同的区域划分，相互之间的差异化红帽是怎么解决的，在中国的本地化进程是怎样落地的，人员参与和贡献分别是多少？
Brian Exelbierd：我非得站起来回答您的第二个问题不可，因为要给您看一下我穿的体恤，这个体恤是 Fedora 本地化的主题，这是我们第 26 次发布 Fedora 版本的时候做的，主要目的是为了感谢全世界各地为 Fedora 本地化做出贡献的人们，因为确实有很多人都参与进来了，里面有一个泡泡写的是汉语。
我现在回答您问题的第一部分，您讲的非常对，我们 Fedora 是分区域的这个主要是有两个原因，首先是过去为了行政管理的便利做出的安排，因为这样分成不同的区域之后就可以更为容易的，相当于在本地做决定，而且资金的流动也更便利一些，随着全球化的发展，这个重要性降低了。还有第二个原因，您刚才提到差异化，差异性是无处不在的，我们希望在对话的时候，彼此的对话能在一个更适合的地方发生，因而在不同的国家和社区进行对话时所产生的决议有效，毕竟不同区域在文化上是有敏感性的。
回答您的第二个问题，您问到中国有多少贡献者，和他们在在这个社区中多活跃，对这样的问题，我们的回答永远是不够多，因为我们希望任何地方的贡献者都能够更多一些，希望他们更活跃的参与社区的活动。在中国我们也面临这样的挑战，因为中国的这些软件工程师或者相关可能的爱好者，他们本身的工作时间是非常长的，会加很长的班，通勤时间也非常长。这样他们就没有太多的精力投入开源社区的活动，此外中国社会不太重视让学生参与开源活动，大部分学生更专注于把考分弄的更高一点。我们在中国一直希望寻找对开源感兴趣的人，鼓励他们参与进来。不管你面临什么样的用户和场景，我们希望都是有人能够和你进行交流提供帮助的，所以我们非常鼓励大家的参与。
再补充一点，我们的开源社区是非常具有全球性的社区，因此绝不会在中国天然的有哪些情况就使得中国人为社区做贡献特别难，不会有这些情况，比如我本人经常在晚上九点和社区的成员进行交流，因为这个对大部分社区成员来说是最合适的时间。对不少中国人来讲，中国的时区和美国时区差异特别大，但是这一点不会阻止开源社区的交流。
### 问题 5
记者：我想问一个跟开源和闭源有关的问题，从软件开发的角度来讲，开源比闭源好，因为闭源一年更新的速度比较慢，而开源的广泛性和活跃性远远大于闭源，但是从商业角度来讲，开源还是不太成功的，以红帽为例，现在红帽每年的营收跟微软和闭源的软件厂商来讲远远不在一个级别上，从商业的角度讲，开源不那么成熟，作为开源社区的大拿来讲，吸引你们进入开源的热情是你们对技术的偏好，还是你们坚信开源技术未来在商业上有很大的潜质，什么支撑你们在开源领域里努力？
Thomas Cameron：在商业上我们已经比那些闭源的软件厂商要成功了。如果仔细的看一下红帽的财报跟他每年的增长，我们每年平均增长都在 20% 以上，所以从增速的角度来看，我们比所有的闭源软件开发公司做的都要好，所以从商业模式上已经证明了开源可以做的很好。关于为什么我个人会在开源中，这个回答非常简单，因为在这个世界上没有任何其他一个我所知道的行业能够让一个国家、或者一个村子里的人看到代码，并且利用手上的电脑开展相关的工作，没有任何一个其他的行业像开源社区一样把自己知道的一切都告诉别人，而在这个过程中我还拿到一份薪酬，当然我不能代表别人说话，我自己而言我觉得我是全世界最幸运的人，一方面我能够每天都在玩这些最酷的技术，同时还把我所知道的一切告诉任何感兴趣想学习的人，在这个过程中还能拿到工资。
给大家看一下大臂上的刺青，我觉得几乎没有那个闭源公司的员工会把自己公司的logo刻到自己的身上，但是我这样做了。大概五年前，闭源和开源软件公司之间的冲突还是非常显著的，但是今天我们可以看到所有的闭源软件公司都在采用开源的方法，他们也在发布大量的开源的代码，也就是说他们都看到了开源的模式，协作，为他人提供服务，以及做一切人人们生活变的更好的事情，这个模式是被大家认可的，这个时代是非常不可思议的，著名厂商包括IBM，微软，甲骨文等等，他们都在做开源的事情。
Jennifer Madriaga：我也补充一下，强调一下我们开源的核心是协作，在开源的社区里面，你会发现很多竞争对手同时也是合作的伙伴，我们和 IBM 是很好的伙伴，和微软是很好的伙伴，是 AWS、谷歌都是非常好的伙伴。重要的是没有他们的参与，没有我们的参与，这个行业就不可能取得这么大的成功。我经常到各个社区去，在这个过程中会和其他的组织进行交流，其中不少会被媒体描述为我们的竞争对手。我们也不仅仅和这些公司打交道，我们还和很多大学，非盈利机构进行沟通，这个社区是多样的，而且有大量的互动。开源社区伟大的一点是他特别促进创新，有这样的一个机构，CERN，欧洲原子能组织，他们的每一个软件都是开源的，他们在用 CoreOS、Fedora、Ceph 等，还有 NASA，也使用了大量的开源软件，其实他们是最早发明了 OpenStack，之后在社区得以进一步开发。行业的未来是开源，很多公司为什么用开源，因为他们知道只有用了开源才能保持自己的敏捷性，而且他们也知道自己是没有办法预测未来的，但是如果他们不与时俱进，那么这个公司可能将来就死路一条。
Adam Samalik：假如你是一个喜欢编代码的人，或者公司让程序员编写代码，如果你在社区里发布过你的代码，并且让其他人为这个代码做出贡献，你立刻会意识到开源的重要性或者价值。拿 Kubernetes 举个例子，它最早是谷歌拿出来的，一开始非常简单，但是大家都看到它的前景，现在有好多公司在为 Kubernetes 做出贡献，Kubernetes 本身也变的更为庞大，而且是非常棒的，但是在开源社区会发生这些事情，你把代码拿出来不是损失了自己的代码，有更多人会对你帮助，会有更多的贡献。
Carol Chen：谈到关系，在去年我们与阿里巴巴建立了伙伴关系，我希望并且认为肯定有更多的中国本地的伙伴关系发展起来。其实看一看 LC3 大会就知道了，有那么多大大小小的本地公司他们都在做开源，而且非常愿意分享自己用开源的经验，所以我想在这方面我们可以真实的看到这个趋势。关于个人的动机，我非常喜欢技术，我喜欢和别人分享东西，我也喜欢给别人参与这些非常酷的项目的机会，我也希望生活能够过的好，而参与开源给了我这一切。
某男：我补充一句关于创新和开源的关系，我们的 CEO 发布了一本新书《开放式创新》，现在我们看到在当今世界上人们面临的问题越来越复杂，对于这些复杂的问题一个公司单独没有办法解决，我们需要很多公司很多人合作，所以开源的平台会是非常重要的，这么多人和企业都可以一起寻找解决方案，所以开源在将来肯定会非常重要的推动创新。
Brian Exelbierd：我要讲的故事跟他们都不一样，我不知道一开始加入开源社区的动机是不是像我的同事那么纯净。 我就记得当时在大学里的朋友来找我，他当时拿着最初的 Linux 的某个版本，我们当时用软盘的复制工具复制了 64 个软盘，当时是希望能用这个东西让我非常糟糕的电脑转的更快一点。
当时我这个同学就说，欧洲有这么一个人在干这个事情，你知道我们都是美国人，住在美国也不太关心，不知道他在欧洲哪儿，但是现在我住在欧洲，知道那些地方在哪儿。当时有一个特别自私的想法，就是想让我的电脑快一点，我也做出了我的第一个贡献，因为我想让这个程序运行得有点差别，想改一下。所以最初这个动机帮助我逐步进入开源社区，当时我还是一个大学生，所以写的代码不太好，当时有代码的审阅人员，他们会看代码给你各种建议帮助你改进，这样逐步的参与动机，自私程度降低了，而更多的希望我能够也做出点贡献，也给其他人提供一些帮助。我们最早的时候有 GRP 系统，厂商根本不问我们用的怎么样，但是在开源社区情况完全不一样，我们跟企业用户沟通，他们会直接说出这个软件存在什么问题，并且他会告诉你我们应该怎么改进。
Max Leonard Inden：我为什么我参加了开源社区，我的同事们讲的非常好，从我的角度来讲是开源让我能够到这儿，让我在大会上发言，并且公开谈论我自己感兴趣的东西，而且能听别人谈。
---
听了大家的提问和回答，本人有如下感受：
* 开源在中国需要更多的非程序员的贡献者，来在艺术、营销、文档三个方面做出更多的贡献。
* 文化始终是大于代码的（Culture is bigger than code）。
* 开源本身是跨越了国界、地域、文化，让我们把资源更高效的利用起来让人们的生活更美好（OpenSource making people's life better）。
|
||||
lua 中神奇的表（table）
|
Lujun9972
|
https://github.com/lujun9972/lujun9972.github.com/blob/source/%E7%BC%96%E7%A8%8B%E4%B9%8B%E6%97%85/lua%E4%B8%AD%E7%A5%9E%E5%A5%87%E7%9A%84table.org
|
最近在尝试配置 awesome WM，因此粗略地学习了一下 lua 。 在学习过程中，我完全被 table 在 lua 中的应用所镇住了。
|
/data/attachment/album/201807/05/155958zjef7jp7jpdafy6m.jpg.thumb.jpg
|
/data/attachment/album/201807/05/155958zjef7jp7jpdafy6m.jpg
| true | false | false | false |
[
"lua"
] |
软件开发
|
{
"viewnum": 11345,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
最近在尝试配置 awesome WM，因此粗略地学习了一下 lua 。 在学习过程中，我完全被 table 在 lua 中的应用所镇住了。
| 2018-07-05T16:00:59 | 2018-07-05T16:00:59 | 9,810 |
/article-9810-1.html
|
最近在尝试配置 awesome WM，因此粗略地学习了一下 lua 。 在学习过程中，我完全被<ruby> 表 <rp> （ </rp> <rt> 表 </rt> <rp> ） </rp></ruby>在 lua 中的应用所镇住了。
表在 lua 中真的是无处不在：首先，它可以作为字典和数组来用；此外，它还可以被用于设置闭包环境、模块；甚至可以用来模拟对象和类。
### 字典
表最基础的作用就是当成字典来用。 它的键可以是除了 `nil` 之外的任何类型的值。
```
t={}
t[{}] = "table" -- key 可以是表
t[1] = "int" -- key 可以是整数
t[1.1] = "double" -- key 可以是小数
t[function () end] = "function" -- key 可以是函数
t[true] = "Boolean" -- key 可以是布尔值
t["abc"] = "String" -- key 可以是字符串
t[io.stdout] = "userdata" -- key 可以是userdata
t[coroutine.create(function () end)] = "Thread" -- key可以是thread
```
当把表当成字典来用时，可以使用 `pairs` 函数来进行遍历。
```
for k,v in pairs(t) do
print(k,"->",v)
end
```
运行结果为：
```
1 -> int
1.1 -> double
thread: 0x220bb08 -> Thread
table: 0x220b670 -> table
abc -> String
file (0x7f34a81ef5c0) -> userdata
function: 0x220b340 -> function
true -> Boolean
```
从结果中你还可以发现，使用 `pairs` 进行遍历时的顺序是随机的，事实上相同的语句执行多次得到的结果是不一样的。
表 中的键最常见的两种类型就是整数型和字符串类型。 当键为字符串时，表 可以当成结构体来用。同时形如 `t["field"]` 这种形式的写法可以简写成 `t.field` 这种形式。
### 数组
当键为整数时，表 就可以当成数组来用。而且这个数组是一个 **索引从 1 开始** 、没有固定长度、可以根据需要自动增长的数组。
```
a = {}
for i=0,5 do -- 注意，这里故意写成了i从0开始
a[i] = 0
end
```
当将表当成数组来用时，可以通过长度操作符 `#` 来获取数组的长度：
```
print(#a)
```
结果为：
```
5
```
你会发现， lua 认为数组 `a` 中只有 5 个元素，到底是哪 5 个元素呢？我们可以使用使用 `ipairs` 对数组进行遍历：
```
for i,v in ipairs(a) do
print(i,v)
end
```
结果为：
```
1 0
2 0
3 0
4 0
5 0
```
从结果中你会发现 `a` 的 0 号索引并不认为是数组中的一个元素，从而也验证了 lua 中的数组是从 **1 开始索引的**。
另外，将表当成数组来用时，一定要注意索引不连贯的情况，这种情况下 `#` 计算长度时会变得很诡异。
```
a = {}
for i=1,5 do
a[i] = 0
end
a[8] = 0 -- 虽然索引不连贯，但长度是以最大索引为准
print(#a)
a[100] = 0 -- 索引不连贯，而且长度不再以最大索引为准了
print(#a)
```
结果为：
```
8
8
```
而使用 `ipairs` 对数组进行遍历时，只会从 1 遍历到索引中断处。
```
for i,v in ipairs(a) do
print(i,v)
end
```
结果为：
```
1 0
2 0
3 0
4 0
5 0
```
### 环境（命名空间）
lua 将所有的全局变量/局部变量保存在一个常规表中，这个表一般被称为全局或者某个函数（闭包）的环境。
为了方便，lua 在创建最初的全局环境时，使用全局变量 `_G` 来引用这个全局环境。因此，在未手工设置环境的情况下，可以使用 `-G[varname]` 来存取全局变量的值。
```
for k,v in pairs(_G) do
print(k,"->",v)
end
```
```
rawequal -> function: 0x41c2a0
require -> function: 0x1ea4e70
_VERSION -> Lua 5.3
debug -> table: 0x1ea8ad0
string -> table: 0x1ea74b0
xpcall -> function: 0x41c720
select -> function: 0x41bea0
package -> table: 0x1ea4820
assert -> function: 0x41cc50
pcall -> function: 0x41cd10
next -> function: 0x41c450
tostring -> function: 0x41be70
_G -> table: 0x1ea2b80
coroutine -> table: 0x1ea4ee0
unpack -> function: 0x424fa0
loadstring -> function: 0x41ca00
setmetatable -> function: 0x41c7e0
rawlen -> function: 0x41c250
bit32 -> table: 0x1ea8fc0
utf8 -> table: 0x1ea8650
math -> table: 0x1ea7770
collectgarbage -> function: 0x41c650
rawset -> function: 0x41c1b0
os -> table: 0x1ea6840
pairs -> function: 0x41c950
arg -> table: 0x1ea9450
table -> table: 0x1ea5130
tonumber -> function: 0x41bf40
io -> table: 0x1ea5430
loadfile -> function: 0x41cb10
error -> function: 0x41c5c0
load -> function: 0x41ca00
print -> function: 0x41c2e0
dofile -> function: 0x41cbd0
rawget -> function: 0x41c200
type -> function: 0x41be10
getmetatable -> function: 0x41cb80
module -> function: 0x1ea4e00
ipairs -> function: 0x41c970
```
从 lua 5.2 开始，可以通过修改 `_ENV` 这个值（**lua 5.1 中的 `setfenv` 从 5.2 开始被废除**）来设置某个函数的环境，从而让这个函数中的执行语句在一个新的环境中查找全局变量的值。
```
a=1 -- 全局变量中a=1
local env={a=10,print=_G.print} -- 新环境中a=10,并且确保能访问到全局的print函数
function f1()
local _ENV=env
print("in f1:a=",a)
a=a*10 -- 修改的是新环境中的a值
end
f1()
print("globally:a=",a)
print("env.a=",env.a)
```
```
in f1:a= 10
globally:a= 1
env.a= 100
```
另外，新创建的闭包都继承了创建它的函数的环境。
### 模块
lua 中的模块也是通过返回一个表来供模块使用者来使用的。 这个表中包含的是模块中所导出的所有东西，包括函数和常量。
定义模块的一般模板为：
```
module(模块名, package.seeall)
```
其中 `module(模块名)` 的作用类似于：
```
local modname = 模块名
local M = {} -- M即为存放模块所有函数及常数的table
_G[modname] = M
package.loaded[modname] = M
setmetatable(M,{__index=_G}) -- package.seeall可以使全局环境_G对当前环境可见
local _ENV = M -- 设置当前的运行环境为 M，这样后续所有代码都不需要限定模块名了，所定义的所有函数自动变成M的成员
<函数定义以及常量定义>
return M -- module函数会帮你返回module table，而无需手工返回
```
### 对象
lua 中之所以可以把表当成对象来用是因为：
1. 函数在 lua 中是一类值，你可以直接存取表中的函数值。 这使得一个表既可以有自己的状态，也可以有自己的行为：
```
Account = {balance = 0}
function Account.withdraw(v)
Account.balance = Account.balance - v
end
```
2. lua 支持闭包，这个特性可以用来模拟对象的私有成员变量：
```
function new_account(b)
local balance = b
return {withdraw = function (v) balance = balance -v end,
get_balance = function () return balance end
}
end
a1 = new_account(1000)
a1.withdraw(10)
print(a1.get_balance())
```
```
990
```
不过，上面第一种定义对象的方法有一个缺陷，那就是方法与 `Account` 这个名称绑定死了。 也就是说，这个对象的名称必须为 `Accout` 否则就会出错。
```
a = Account
Account = nil
a.withdraw(10) -- 会报错，因为Accout.balance不再存在
```
为了解决这个问题，我们可以给 `withdraw` 方法多一个参数用于指向对象本身。
```
Account = {balance=100}
function Account.withdraw(self,v)
self.balance = self.balance - v
end
a = Account
Account = nil
a.withdraw(a,10) -- 没问题，这个时候 self 指向的是a，因此会去寻找 a.balance
print(a.balance)
```
```
90
```
不过由于第一个参数 `self` 几乎总是指向调用方法的对象本身，因此 lua 提供了一种语法糖形式 `object:method(...)` 用于隐藏 `self` 参数的定义及传递。这里冒号的作用有两个，其在定义函数时往函数中地一个参数的位置添加一个额外的隐藏参数 `sef`, 而在调用时传递一个额外的隐藏参数 `self` 到地一个参数位置。 即 `function object:method(v) end` 等价于 `function object.method(self,v) end`, `object:method(v)` 等价于 `object.method(object,v)`。
### 类
当涉及到类和继承时，就要用到元表和元方法了。事实上，对于 lua 来说，对象和类并不存在一个严格的划分。
当一个对象被另一个表的 `__index` 元方法所引用时，表就能引用该对象中所定义的方法，因此也就可以理解为对象变成了表的类。
类定义的一般模板为:
```
function 类名:new(o)
o = o or {}
setmetatable(o,{__index = self})
return o
end
```
或者：
```
function 类名:new(o)
o = o or {}
setmetatable(o,self)
self.__index = self
return o
end
```
相比之下，第二种写法可以多省略一个表。
另外有一点我觉得有必要说明的就是 lua 中的元方法是在元表中定义的，而不是对象本身定义的，这一点跟其他面向对象的语言比较不同。
|
|||
4 种用于构建嵌入式 Linux 系统的工具
|
Drew Moseley
|
https://opensource.com/article/18/6/embedded-linux-build-tools
|
了解 Yocto、Buildroot、 OpenWRT，和改造过的桌面发行版以确定哪种方式最适合你的项目。
|
/data/attachment/album/201807/06/095532wzz9flhboh6anfcw.jpg.thumb.jpg
|
/data/attachment/album/201807/06/095532wzz9flhboh6anfcw.jpg
| true | false | true |
LHRChina
| false |
[
"嵌入式"
] |
树莓派
|
{
"viewnum": 11775,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
了解 Yocto、Buildroot、 OpenWRT，和改造过的桌面发行版以确定哪种方式最适合你的项目。
| 2018-07-06T09:55:00 | 2018-07-06T09:55:00 | 9,811 |
/article-9811-1.html
|
>
> 了解 Yocto、Buildroot、 OpenWRT，和改造过的桌面发行版以确定哪种方式最适合你的项目。
>
>
>
Linux 被部署到比 Linus Torvalds 在他的宿舍里开发时所预期的更广泛的设备。令人震惊的支持了各种芯片，使得Linux 可以应用于大大小小的设备上：从 [IBM 的巨型机](https://en.wikipedia.org/wiki/Linux_on_z_Systems)到不如其连接的端口大的[微型设备](http://www.picotux.com/)，以及各种大小的设备。它被用于大型企业数据中心、互联网基础设施设备和个人的开发系统。它还为消费类电子产品、移动电话和许多物联网设备提供了动力。
在为桌面和企业级设备构建 Linux 软件时，开发者通常在他们的构建机器上使用桌面发行版，如 [Ubuntu](https://www.ubuntu.com/) 以便尽可能与被部署的机器相似。如 [VirtualBox](https://www.virtualbox.org/) 和 [Docker](https://www.docker.com/) 这样的工具使得开发、测试和生产环境更好的保持了一致。
### 什么是嵌入式系统？
维基百科将[嵌入式系统](https://en.wikipedia.org/wiki/Embedded_system)定义为：“在更大的机械或电气系统中具有专用功能的计算机系统，往往伴随着实时计算限制。”
我觉得可以很简单地说，嵌入式系统是大多数人不认为是计算机的计算机。它的主要作用是作为某种设备，而不被视为通用计算平台。
嵌入式系统编程的开发环境通常与测试和生产环境大不相同。它们可能会使用不同的芯片架构、软件堆栈甚至操作系统。开发工作流程对于嵌入式开发人员与桌面和 Web 开发人员来说是非常不同的。通常，其构建后的输出将包含目标设备的整个软件映像，包括内核、设备驱动程序、库和应用程序软件（有时也包括引导加载程序）。
在本文中，我将对构建嵌入式 Linux 系统的四种常用方式进行纵览。我将介绍一下每种产品的工作原理，并提供足够的信息来帮助读者确定使用哪种工具进行设计。我不会教你如何使用它们中的任何一个；一旦缩小了选择范围，就有大量深入的在线学习资源。没有任何选择适用于所有情况，我希望提供足够的细节来指导您的决定。
### Yocto
[Yocto](https://yoctoproject.org/) 项目 [定义](https://www.yoctoproject.org/about/)为“一个开源协作项目，提供模板、工具和方法，帮助您为嵌入式产品创建定制的基于 Linux 的系统，而不管硬件架构如何。”它是用于创建定制的 Linux 运行时映像的配方、配置值和依赖关系的集合，可根据您的特定需求进行定制。
完全公开：我在嵌入式 Linux 中的大部分工作都集中在 Yocto 项目上，而且我对这个系统的认识和偏见可能很明显。
Yocto 使用 [Openembedded](https://www.openembedded.org/) 作为其构建系统。从技术上讲，这两个是独立的项目；然而，在实践中，用户不需要了解区别，项目名称经常可以互换使用。
Yocto 项目的输出大致由三部分组成：
* **目标运行时二进制文件：**这些包括引导加载程序、内核、内核模块、根文件系统映像。以及将 Linux 部署到目标平台所需的任何其他辅助文件。
* **包流：**这是可以安装在目标上的软件包集合。您可以根据需要选择软件包格式（例如，deb、rpm、ipk）。其中一些可能预先安装在目标运行时二进制文件中，但可以构建用于安装到已部署系统的软件包。
* **目标 SDK：**这些是安装在目标平台上的软件的库和头文件的集合。应用程序开发人员在构建代码时使用它们，以确保它们与适当的库链接
#### 优点
Yocto 项目在行业中得到广泛应用，并得到许多有影响力的公司的支持。此外，它还拥有一个庞大且充满活力的开发人员[社区](https://www.yoctoproject.org/community/)和[生态系统](https://www.yoctoproject.org/ecosystem/participants/)。开源爱好者和企业赞助商的结合的方式有助于推动 Yocto 项目。
获得 Yocto 的支持有很多选择。如果您想自己动手，有书籍和其他培训材料。如果您想获得专业知识，有许多有 Yocto 经验的工程师。而且许多商业组织可以为您的设计提供基于 Yocto 的 Turnkey 产品或基于服务的实施和定制。
Yocto 项目很容易通过 [层](https://layers.openembedded.org/layerindex/branch/master/layers/) 进行扩展，层可以独立发布以添加额外的功能，或针对项目发布时尚不可用的平台，或用于保存系统特有定制功能。层可以添加到你的配置中，以添加未特别包含在市面上版本中的独特功能；例如，“[meta-browser](https://layers.openembedded.org/layerindex/branch/master/layer/meta-browser/)” 层包含 Web 浏览器的清单，可以轻松为您的系统进行构建。因为它们是独立维护的，所以层可以按不同的时间发布（根据层的开发速度），而不是跟着标准的 Yocto 版本发布。
Yocto 可以说是本文讨论的任何方式中最广泛的设备支持。由于许多半导体和电路板制造商的支持，Yocto 很可能能够支持您选择的任何目标平台。主版本 Yocto [分支](https://yoctoproject.org/downloads)仅支持少数几块主板（以便达成合理的测试和发布周期），但是，标准工作模式是使用外部主板支持层。
最后，Yocto 非常灵活和可定制。您的特定应用程序的自定义可以存储在一个层进行封装和隔离，通常将要素层特有的自定义项存储为层本身的一部分，这可以将相同的设置同时应用于多个系统配置。Yocto 还提供了一个定义良好的层优先和覆盖功能。这使您可以定义层应用和搜索元数据的顺序。它还使您可以覆盖具有更高优先级的层的设置；例如，现有清单的许多自定义功能都将保留。
#### 缺点
Yocto 项目最大的缺点是学习曲线陡峭。学习该系统并真正理解系统需要花费大量的时间和精力。 根据您的需求，这可能对您的应用程序不重要的技术和能力投入太大。 在这种情况下，与一家商业供应商合作可能是一个不错的选择。
Yocto 项目的开发时间和资源相当高。 需要构建的包（包括工具链，内核和所有目标运行时组件）的数量相当不少。 Yocto 开发人员的开发工作站往往是大型系统。 不建议使用小型笔记本电脑。 这可以通过使用许多提供商提供的基于云的构建服务器来缓解。 另外，Yocto 有一个内置的缓存机制，当它确定用于构建特定包的参数没有改变时，它允许它重新使用先前构建的组件。
#### 建议
为您的下一个嵌入式 Linux 设计使用 Yocto 项目是一个强有力的选择。 在这里介绍的选项中，无论您的目标用例如何，它都是最广泛适用的。 广泛的行业支持，积极的社区和广泛的平台支持使其成为必须设计师的不错选择。
### Buildroot
[Buildroot](https://buildroot.org/) 项目定义为“通过交叉编译生成嵌入式 Linux 系统的简单、高效且易于使用的工具。”它与 Yocto 项目具有许多相同的目标，但它注重简单性和简约性。一般来说，Buildroot 会禁用所有软件包的所有可选编译时设置（有一些值得注意的例外），从而生成尽可能小的系统。系统设计人员需要启用适用于给定设备的设置。
Buildroot 从源代码构建所有组件，但不支持按目标包管理。因此，它有时称为固件生成器，因为镜像在构建时大部分是固定的。应用程序可以更新目标文件系统，但是没有机制将新软件包安装到正在运行的系统中。
Buildroot 输出主要由三部分组成：
* 将 Linux 部署到目标平台所需的根文件系统映像和任何其他辅助文件
* 适用于目标硬件的内核，引导加载程序和内核模块
* 用于构建所有目标二进制文件的工具链。
#### 优点
Buildroot 对简单性的关注意味着，一般来说，它比 Yocto 更容易学习。核心构建系统用 Make 编写，并且足够短以便开发人员了解整个系统，同时可扩展到足以满足嵌入式 Linux 开发人员的需求。 Buildroot 核心通常只处理常见用例，但它可以通过脚本进行扩展。
Buildroot 系统使用普通的 Makefile 和 Kconfig 语言来进行配置。 Kconfig 由 Linux 内核社区开发，广泛用于开源项目，使得许多开发人员都熟悉它。
由于禁用所有可选的构建时设置的设计目标，Buildroot 通常会使用开箱即用的配置生成尽可能最小的镜像。一般来说，构建时间和构建主机资源的规模将比 Yocto 项目的规模更小。
#### 缺点
关注简单性和最小化启用的构建方式意味着您可能需要执行大量的自定义来为应用程序配置 Buildroot 构建。此外，所有配置选项都存储在单个文件中，这意味着如果您有多个硬件平台，则需要为每个平台进行每个定制更改。
对系统配置文件的任何更改都需要全部重新构建所有软件包。与 Yocto 相比，这个问题通过最小的镜像大小和构建时间得到了一定的解决，但在你调整配置时可能会导致构建时间过长。
中间软件包状态缓存默认情况下未启用，并且不像 Yocto 实施那么彻底。这意味着，虽然第一次构建可能比等效的 Yocto 构建短，但后续构建可能需要重建许多组件。
#### 建议
对于大多数应用程序，使用 Buildroot 进行下一个嵌入式 Linux 设计是一个不错的选择。如果您的设计需要多种硬件类型或其他差异，但由于同步多个配置的复杂性，您可能需要重新考虑，但对于由单一设置组成的系统，Buildroot 可能适合您。
### OpenWRT/LEDE
[OpenWRT](https://openwrt.org/) 项目开始为消费类路由器开发定制固件。您当地零售商提供的许多低成本路由器都可以运行 Linux 系统，但可能无法开箱即用。这些路由器的制造商可能无法提供频繁的更新来解决新的威胁，即使他们这样做，安装更新镜像的机制也很困难且容易出错。 OpenWRT 项目为许多已被其制造商放弃的设备生成更新的固件镜像，让这些设备焕发新生。
OpenWRT 项目的主要交付物是可用于大量商业设备的二进制镜像。它有网络可访问的软件包存储库，允许设备最终用户将新软件添加到他们的系统中。 OpenWRT 构建系统是一个通用构建系统，它允许开发人员创建自定义版本以满足他们自己的需求并添加新软件包，但其主要重点是目标二进制文件。
#### 优点
如果您正在为商业设备寻找替代固件，则 OpenWRT 应位于您的选项列表中。它的维护良好，可以保护您免受制造商固件无法解决的问题。您也可以添加额外的功能，使您的设备更有用。
如果您的嵌入式设计专注于网络，则 OpenWRT 是一个不错的选择。网络应用程序是 OpenWRT 的主要用例，您可能会发现许多可用的软件包。
#### 缺点
OpenWRT 对您的设计限制很多（与 Yocto 和 Buildroot 相比）。如果这些决定不符合您的设计目标，则可能需要进行大量的修改。
在部署的设备中允许基于软件包的更新是很难管理的。按照其定义，这会导致与您的 QA 团队测试的软件负载不同。此外，很难保证大多数软件包管理器的原子安装，以及错误的电源循环可能会使您的设备处于不可预知的状态。
#### 建议
OpenWRT 是爱好者项目或商用硬件再利用的不错选择。它也是网络应用程序的不错选择。如果您需要从默认设置进行大量定制，您可能更喜欢 Buildroot 或 Yocto。
### 桌面发行版
设计嵌入式 Linux 系统的一种常见方法是从桌面发行版开始，例如 [Debian](https://www.debian.org/) 或 [Red Hat](https://www.redhat.com/)，并删除不需要的组件，直到安装的镜像符合目标设备的占用空间。这是 [Raspberry Pi](https://www.raspberrypi.org/) 平台流行的 [Raspbian](https://www.raspbian.org/)发行版的方法。
#### 优点
这种方法的主要优点是熟悉。通常，嵌入式 Linux 开发人员也是桌面 Linux 用户，并且精通他们的选择发行版。在目标上使用类似的环境可能会让开发人员更快地入门。根据所选的分布，可以使用 apt 和 yum 等标准封装工具安装许多其他工具。
可以将显示器和键盘连接到目标设备，并直接在那里进行所有的开发。对于不熟悉嵌入式空间的开发人员来说，这可能是一个更为熟悉的环境，无需配置和使用棘手的跨开发平台设置。
大多数桌面发行版可用的软件包数量通常大于前面讨论的嵌入式特定的构建器可用软件包数量。由于较大的用户群和更广泛的用例，您可能能够找到您的应用程序所需的所有运行时包，这些包已经构建并可供使用。
#### 缺点
将目标平台作为您的主要开发环境可能会很慢。运行编译器工具是一项资源密集型操作，根据您构建的代码的多少，这可能会严重妨碍您的性能。
除了一些例外情况，桌面发行版的设计并不适合低资源系统，并且可能难以充分裁剪目标映像。同样，桌面环境中的预设工作流程对于大多数嵌入式设计来说都不理想。以这种方式获得可再现的环境很困难。手动添加和删除软件包很容易出错。这可以使用特定于发行版的工具进行脚本化，例如基于 Debian 系统的 [debootstrap](https://wiki.debian.org/Debootstrap)。为了进一步提高[可再现性](https://wiki.debian.org/Debootstrap)，您可以使用配置管理工具，如 [CFEngine](https://cfengine.com/)（我的雇主 [Mender.io](http://Mender.io) 完整披露了 这一工具）。但是，您仍然受发行版提供商的支配，他们将更新软件包以满足他们的需求，而不是您的需求。
#### 建议
对于您打算推向市场的产品，请谨慎使用此方法。这对于爱好者应用程序来说是一个很好的模型；但是，对于需要支持的产品，这种方法很可能会遇到麻烦。虽然您可能能够获得更快的起步，但从长远来看，您可能会花费您的时间和精力。
### 其他考虑
这个讨论集中在构建系统的功能上，但通常有非功能性需求可能会影响您的决定。如果您已经选择了片上系统（SoC）或电路板，则您的选择很可能由供应商决定。如果您的供应商为特定系统提供板级支持包（BSP），使用它通常会节省相当多的时间，但请研究 BSP 的质量以避免在开发周期后期发生问题。
如果您的预算允许，您可能需要考虑为目标操作系统使用商业供应商。有些公司会为这里讨论的许多选项提供经过验证和支持的配置，除非您拥有嵌入式 Linux 构建系统方面的专业知识，否则这是一个不错的选择，可以让您专注于核心能力。
作为替代，您可以考虑为您的开发人员进行商业培训。这可能比商业操作系统供应商便宜，并且可以让你更加自给自足。这是快速找到您选择的构建系统基础知识的学习曲线。
最后，您可能已经有一些开发人员拥有一个或多个系统的经验。如果你的工程师有倾向性，当你做出决定时，肯定值得考虑。
### 总结
构建嵌入式 Linux 系统有多种选择，每种都有优点和缺点。将这部分设计放在优先位置至关重要，因为在以后的过程中切换系统的成本非常高。除了这些选择之外，还有新的系统在开发中。希望这次讨论能够为评估新的系统（以及这里提到的系统）提供一些背景，并帮助您为下一个项目做出坚实的决定。
---
via: <https://opensource.com/article/18/6/embedded-linux-build-tools>
作者：[Drew Moseley](https://opensource.com/users/drewmoseley) 选题：[lujun9972](https://github.com/lujun9972) 译者：[LHRChina](https://github.com/LHRChina) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 上的五个开源益智游戏
|
Joshua Allen Holm
|
https://opensource.com/article/18/6/puzzle-games-linux
|
用这些有趣好玩的游戏来测试你的战略能力。
|
/data/attachment/album/201807/06/101051t97eexcgecvju9z7.jpg.thumb.jpg
|
/data/attachment/album/201807/06/101051t97eexcgecvju9z7.jpg
| true | false | true |
ZenMoore
| false |
[
"游戏"
] |
分享
|
{
"viewnum": 7401,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用这些有趣好玩的游戏来测试你的战略能力。
| 2018-07-06T10:10:48 | 2018-07-06T10:10:48 | 9,812 |
/article-9812-1.html
|
>
> 用这些有趣好玩的游戏来测试你的战略能力。
>
>
>
游戏一直是 Linux 的弱点之一。由于 Steam、GOG 和其他将商业游戏引入多种操作系统的努力，这种情况近年来有所改变，但这些游戏通常不是开源的。当然，这些游戏可以在开源操作系统上玩，但对于纯粹开源主义者来说还不够好。
那么，一个只使用开源软件的人，能否找到那些经过足够打磨的游戏，在不损害其开源理念的前提下，提供一种可靠的游戏体验呢？当然可以。虽然开源游戏历来不太可能与一些借由大量预算开发的 AAA 商业游戏相匹敌，但在多种类型的开源游戏中，有很多都很有趣，可以从大多数主要 Linux 发行版的仓库中安装。即使某个特定的游戏没有被打包成特定的发行版本，通常也很容易从项目的网站上下载该游戏以便安装和游戏。
这篇文章着眼于益智游戏。我已经写过[街机风格游戏](https://opensource.com/article/18/1/arcade-games-linux)和[棋牌游戏](https://opensource.com/article/18/3/card-board-games-linux)。 在之后的文章中，我计划涉足赛车，角色扮演、战略和模拟经营游戏。
### Atomix
[Atomix](https://wiki.gnome.org/action/raw/Apps/Atomix) 是 1990 年在 Amiga、Commodore 64、MS-DOS 和其他平台发布的 [Atomix](https://en.wikipedia.org/w/index.php?title=Atomix_(video_game)) 益智游戏的开源克隆。Atomix 的目标是通过连接原子来构建原子分子。单个原子可以向上、向下、向左或向右移动，并一直朝这个方向移动，直到原子撞上一个障碍物——水平墙或另一个原子。这意味着需要进行规划，以确定在水平上构建分子的位置，以及移动单个部件的顺序。第一关是一个简单的水分子，它由两个氢原子和一个氧原子组成，但后来的关卡是更复杂的分子。
要安装 Atomix，请运行以下命令:
* 在 Fedora： `dnf install atomix`
* 在 Debian/Ubuntu： `apt install atomix`
### Fish Fillets - Next Generation
[Fish Fillets - Next Generation](http://fillets.sourceforge.net/index.php) 是游戏 Fish fillet 的 Linux 移植版本，它于 1998 年在 Windows 发布，源代码在 2004 年以 GPL 许可证发布。游戏中，两条鱼试图将物体移出道路来通过不同的关卡。这两条鱼有不同的属性，所以玩家需要为每个任务挑选合适的鱼。较大的鱼可以移动较重的物体，但它更大，这意味着它不适合较小的空隙。较小的鱼可以适应那些较小的间隙，但它不能移动较重的物体。如果一个物体从上面掉下来，两条鱼都会被压死，所以玩家在移动棋子时要小心。
要安装 Fish fillet——Next Generation，请运行以下命令:
* 在 Fedora：`dnf install fillets-ng`
* 在 Debian/Ubuntu： `apt install fillets-ng`
### Frozen Bubble
[Frozen Bubble](http://www.frozen-bubble.org/home/) 是一款街机风格的益智游戏，从屏幕底部向屏幕顶部的一堆泡泡射击。如果三个相同颜色的气泡连接在一起，它们就会被从屏幕上移除。任何连接在被移除的气泡下面但没有连接其他任何东西的气泡也会被移除。在拼图模式下，关卡的设计是固定的，玩家只需要在泡泡掉到屏幕底部的线以下前将泡泡从游戏区域中移除。该游戏街机模式和多人模式遵循相同的基本规则，但也有不同，这增加了多样性。Frozen Bubble 是一个标志性的开源游戏，所以如果你以前没有玩过它，玩玩看。
要安装 Frozen Bubble，请运行以下命令：
* 在 Fedora： `dnf install frozen-bubble`
* 在 Debian/Ubuntu： `apt install frozen-bubble`
### Hex-a-hop
[Hex-a-hop](http://hexahop.sourceforge.net/index.html) 是一款基于六角形瓦片的益智游戏，玩家需要将所有的绿色瓦片从水平面上移除。瓦片通过移动被移除。由于瓦片在移动后会消失，所以有必要规划出穿过水平面的最佳路径，以便在不被卡住的情况下移除所有的瓦片。但是，如果玩家使用的是次优路径，会有撤销功能。之后的关卡增加了额外的复杂性，包括需要跨越多次的瓦片和使玩家跳过一定数量的六角弹跳瓦片。
要安装 Hex-a-hop，请运行以下命令：
* 在 Fedora： `dnf install hex-a-hop`
* 在 Debian/Ubuntu： `apt install hex-a-hop`
### Pingus
[Pingus](https://pingus.seul.org/index.html) 是 [Lemmings](http://en.wikipedia.org/wiki/Lemmings) 的开源克隆。这不是一个精确的克隆，但游戏非常相似。小动物（Lemmings 里是旅鼠，Pingus 里是企鹅）通过关卡入口进入关卡，开始沿着直线行走。玩家需要使用特殊技能使小动物能够到达关卡的出口而不会被困住或者掉下悬崖。这些技能包括挖掘或建桥。如果有足够数量的小动物进入出口，这个关卡将成功完成，玩家可以进入下一个关卡。Pingus 为标准的 Lemmings 添加了一些额外的特性，包括一个世界地图和一些在原版游戏中没有的技能，但经典 Lemmings 游戏的粉丝们在这个开源版本中仍会感到自在。
要安装 Pingus，请运行以下命令：
* 在 Fedora： `dnf install pingus`
* 在 Debian/Ubuntu： `apt install pingus`
我漏掉你最喜欢的开源益智游戏了吗? 请在下面的评论中分享。
---
via: <https://opensource.com/article/18/6/puzzle-games-linux>
作者：[Joshua Allen Holm](https://opensource.com/users/holmja) 选题：[lujun9972](https://github.com/lujun9972) 译者：[ZenMoore](https://github.com/ZenMoore) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 LSWC 在 Linux 中自动更改壁纸
|
Aquil Roshan
|
https://itsfoss.com/little-simple-wallpaper-changer/
|
这是一个小脚本，可以在 Linux 桌面上定期自动更改壁纸。
|
/data/attachment/album/201807/07/140202q045bz1cqug47t4z.jpg.thumb.jpg
|
/data/attachment/album/201807/07/140202q045bz1cqug47t4z.jpg
| true | false | true |
geekpi
| false |
[
"墙纸"
] |
分享
|
{
"viewnum": 5054,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这是一个小脚本，可以在 Linux 桌面上定期自动更改壁纸。
| 2018-07-07T14:01:56 | 2018-07-07T14:01:56 | 9,813 |
/article-9813-1.html
|
>
> 简介：这是一个小脚本，可以在 Linux 桌面上定期自动更改壁纸。
>
>
>
顾名思义，LittleSimpleWallpaperChanger （LSWC）是一个小脚本，可以定期地随机更改壁纸。
我知道在“外观”或“更改桌面背景”设置中有一个随机壁纸选项。但那是随机更改预置的壁纸而不是你添加的壁纸。
因此，在本文中，我们将看到如何使用 LittleSimpleWallpaperChanger 设置包含照片的随机桌面壁纸。
### Little Simple Wallpaper Changer (LSWC)
[LittleSimpleWallpaperChanger](https://github.com/LittleSimpleWallpaperChanger/lswc) （LSWC） 是一个非常轻量级的脚本，它在后台运行，从用户指定的文件夹中更改壁纸。壁纸以 1 至 5 分钟的随机间隔变化。该软件设置起来相当简单，设置完后，用户就可以不用再操心了。
#### 安装 LSWC
[点此链接下载 LSWC](https://github.com/LittleSimpleWallpaperChanger/lswc/raw/master/Lswc.zip)。压缩文件的大小约为 15KB。
* 进入下载位置。
* 右键单击下载的 .zip 文件，然后选择“在此处解压”。
* 打开解压后的文件夹，右键单击并选择“在终端中打开”。
* 在终端中复制粘贴命令 `bash ./README_and_install.sh` 并按回车键。
* 然后会弹出一个对话框，要求你选择包含壁纸的文件夹。单击它，然后选择你存放壁纸的文件夹。
* 就是这样。然后重启计算机。
#### 使用 LSWC
安装时，LSWC 会要求你选择包含壁纸的文件夹。因此，我建议你在安装 LSWC 之前创建一个文件夹并将你想要的壁纸全部移动到那。或者你可以使用图片文件夹中的“壁纸”文件夹。**所有壁纸都必须是 .jpg 格式。**
你可以添加更多壁纸或从所选文件夹中删除当前壁纸。要更改壁纸文件夹位置，你可以从以下文件中编辑壁纸的位置。
```
.config/lswc/homepath.conf
```
#### 删除 LSWC
打开终端并运行以下命令以停止 LSWC：
```
pkill lswc
```
在文件管理器中打开家目录，然后按 `Ctrl+H` 显示隐藏文件，接着删除以下文件：
* `.local` 中的 `scripts` 文件夹
* `.config` 中的 `lswc` 文件夹
* `.config/autostart` 中的 `lswc.desktop` 文件
这就完成了。创建自己的桌面背景幻灯片。LSWC 非常轻巧，易于使用。安装它然后忘记它。
LSWC 功能不是很丰富，但这是有意的。它做了它打算做的事情，那就是更换壁纸。如果你想要一个自动下载壁纸的工具试试 [WallpaperDownloader](https://itsfoss.com/wallpaperdownloader-linux/)。
请在下面的评论栏分享你对这个漂亮的小软件的想法。别忘了分享这篇文章。干杯。
---
via: <https://itsfoss.com/little-simple-wallpaper-changer/>
作者：[Aquil Roshan](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/) 荣誉推出
|
||
为什么 Python 开发人员应该使用 Pipenv
|
Lacey Williams Henschel, Jeff Triplett
|
https://opensource.com/article/18/2/why-python-devs-should-use-pipenv
|
只用了一年， Pipenv 就变成了管理软件包依赖关系的 Python 官方推荐资源。
|
/data/attachment/album/201807/07/142824cermze96p8tzaznb.jpg.thumb.jpg
|
/data/attachment/album/201807/07/142824cermze96p8tzaznb.jpg
| true | false | true |
MjSeven
| false |
[
"Python",
"包依赖"
] |
软件开发
|
{
"viewnum": 6840,
"commentnum": 1,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "103.90.189.34",
"message": "看官网也没看明白这玩意. <br />\r\n两个问题<br />\r\n1. Pipfile 和 Pipfile.lock 里面的 pip 源地址, pipenv install 的时候怎么才能让他自己替换成阿里的, 官网的 --pypi-mirror 还有 url 选项都不好使啊<br />\r\n2. 想弄一个一模一样的环境, 迁移的时候, 具体什么步骤, 两个文件移哪个, 实验了好多遍, 不得其法呀<br />\r\n<br />\r\n恰巧最近在用, 有大神知道的么??",
"username": "若我若鱼 [Chrome 71.0|Mac 10.14]",
"date": "2018-12-10T18:30:07"
}
] |
[] |
只用了一年， Pipenv 就变成了管理软件包依赖关系的 Python 官方推荐资源。
| 2018-07-07T14:28:28 | 2018-07-07T14:28:28 | 9,814 |
/article-9814-1.html
|
>
> 只用了一年， Pipenv 就变成了管理软件包依赖关系的 Python 官方推荐资源。
>
>
>
Pipenv 是由 Kenneth Reitz 在一年多前创建的“面向开发者而生的 Python 开发工作流”，它已经成为管理软件包依赖关系的 [Python 官方推荐资源](https://packaging.python.org/tutorials/managing-dependencies/#managing-dependencies)。但是对于它解决了什么问题，以及它如何比使用 `pip` 和 `requirements.txt` 文件的标准工作流更有用处，这两点仍然存在困惑。在本月的 Python 专栏中，我们将填补这些空白。
### Python 包安装简史
为了理解 Pipenv 所解决的问题，看一看 Python 包管理如何发展十分有用的。
让我们回到第一个 Python 版本，这时我们有了 Python，但是没有干净的方法来安装软件包。
然后有了 [Easy Install](http://peak.telecommunity.com/DevCenter/EasyInstall)，这是一个可以相对容易地安装其他 Python 包的软件包，但它也带来了一个问题：卸载不需要的包并不容易。
[pip](https://packaging.python.org/tutorials/installing-packages/#use-pip-for-installing) 登场，绝大多数 Python 用户都熟悉它。`pip` 可以让我们安装和卸载包。我们可以指定版本，运行 `pip freeze > requirements.txt` 来输出一个已安装包列表到一个文本文件，还可以用相同的文本文件配合 `pip install -r requirements.txt` 来安装一个应用程序需要的所有包。
但是 `pip` 并没有包含将软件包彼此隔离的方法。我们可能会开发使用相同库的不同版本的应用程序，因此我们需要一种方法来实现这一点。随之而来的是[虚拟环境](https://packaging.python.org/tutorials/installing-packages/#creating-virtual-environments)，它使我们能够为我们开发的每个应用程序创建一个小型的、隔离的环境。我们已经看到了许多管理虚拟环境的工具：[virtualenv](https://virtualenv.pypa.io/en/stable/)、 [venv](https://docs.python.org/3/library/venv.html)、 [virtualenvwrapper](https://virtualenvwrapper.readthedocs.io/en/latest/)、 [pyenv](https://github.com/pyenv/pyenv)、 [pyenv-virtualenv](https://github.com/pyenv/pyenv-virtualenv)、 [pyenv-virtualenvwrapper](https://github.com/pyenv/pyenv-virtualenvwrapper) 等等。它们都可以很好地使用 `pip` 和 `requirements.txt` 文件。
### 新方法：Pipenv
Pipenv 旨在解决几个问题：
首先，需要 `pip` 库来安装包，外加一个用于创建虚拟环境的库，以及用于管理虚拟环境的库，再有与这些库相关的所有命令。这些都需要管理。Pipenv 附带包管理和虚拟环境支持，因此你可以使用一个工具来安装、卸载、跟踪和记录依赖性，并创建、使用和组织你的虚拟环境。当你使用它启动一个项目时，如果你还没有使用虚拟环境的话，Pipenv 将自动为该项目创建一个虚拟环境。
Pipenv 通过放弃 `requirements.txt` 规范转而将其移动到一个名为 [Pipfile](https://github.com/pypa/pipfile) 的新文档中来完成这种依赖管理。当你使用 Pipenv 安装一个库时，项目的 `Pipfile` 会自动更新安装细节，包括版本信息，还有可能的 Git 仓库位置、文件路径和其他信息。
其次，Pipenv 希望能更容易地管理复杂的相互依赖关系。你的应用程序可能依赖于某个特定版本的库，而那个库可能依赖于另一个特定版本的库，这些依赖关系如海龟般堆叠起来。当你的应用程序使用的两个库有冲突的依赖关系时，你的情况会变得很艰难。Pipenv 希望通过在一个名为 `Pipfile.lock` 的文件中跟踪应用程序相互依赖关系树来减轻这种痛苦。`Pipfile.lock` 还会验证生产中是否使用了正确版本的依赖关系。
另外，当多个开发人员在开发一个项目时，Pipenv 很方便。通过 `pip` 工作流，凯西可能会安装一个库，并花两天时间使用该库实现一个新功能。当凯西提交更改时，他可能会忘记运行 `pip freeze` 来更新 `requirements.txt` 文件。第二天，杰米拉取凯西的改变，测试就突然失败了。这样会花费好一会儿才能意识到问题是在 `requirements.txt` 文件中缺少相关库，而杰米尚未在虚拟环境中安装这些文件。
因为 Pipenv 会在安装时自动记录依赖性，如果杰米和凯西使用了 Pipenv，`Pipfile` 会自动更新并包含在凯西的提交中。这样杰米和凯西就可以节省时间并更快地运送他们的产品。
最后，将 Pipenv 推荐给在你项目上工作的其他人，因为它使用标准化的方式来安装项目依赖项和开发和测试的需求。使用 `pip` 工作流和 `requirements.txt` 文件意味着你可能只有一个 `requirements.txt` 文件，或针对不同环境的多个 `requirements.txt` 文件。例如，你的同事可能不清楚他们是否应该在他们的笔记本电脑上运行项目时是运行 `dev.txt` 还是 `local.txt`。当两个相似的 `requirements.txt` 文件彼此不同步时它也会造成混淆：`local.txt` 是否过时了，还是真的应该与 `dev.txt` 不同？多个 `requirements.txt` 文件需要更多的上下文和文档，以使其他人能够按照预期正确安装依赖关系。这个工作流程有可能会混淆同时并增加你的维护负担。
使用 Pipenv，它会生成 `Pipfile`，通过为你管理对不同环境的依赖关系，可以避免这些问题。该命令将安装主项目依赖项：
```
pipenv install
```
添加 `--dev` 标志将安装开发/测试的 `requirements.txt`：
```
pipenv install --dev
```
使用 Pipenv 还有其他好处：它具有更好的安全特性，以易于理解的格式绘制你的依赖关系，无缝处理 `.env` 文件，并且可以在一个文件中自动处理开发与生产环境的不同依赖关系。你可以在[文档](https://docs.pipenv.org/)中阅读更多内容。
### 使用 Pipenv
使用 Pipenv 的基础知识在官方 Python 包管理教程[管理应用程序依赖关系](https://packaging.python.org/tutorials/managing-dependencies/)部分中详细介绍。要安装 Pipenv，使用 `pip`：
```
pip install pipenv
```
要安装在项目中使用的包，请更改为项目的目录。然后安装一个包（我们将使用 Django 作为例子），运行：
```
pipenv install django
```
你会看到一些输出，表明 Pipenv 正在为你的项目创建一个 `Pipfile`。
如果你还没有使用虚拟环境，你还会看到 Pipenv 的一些输出，说明它正在为你创建一个虚拟环境。
然后，你将看到你在安装包时常看到的输出。
为了生成 `Pipfile.lock` 文件，运行：
```
pipenv lock
```
你也可以使用 Pipenv 运行 Python 脚本。运行名为 `hello.py` 的上层 Python 脚本：
```
pipenv run python hello.py
```
你将在控制台中看到预期结果。
启动一个 shell，运行：
```
pipenv shell
```
如果你想将当前使用 `requirements.txt` 文件的项目转换为使用 Pipenv，请安装 Pipenv 并运行：
```
pipenv install requirements.txt
```
这将创建一个 Pipfile 并安装指定的 `requirements.txt`。考虑一下升级你的项目！
### 了解更多
查看 Pipenv 文档，特别是 [Pipenv 的基本用法](https://docs.pipenv.org/basics/)，以帮助你进一步学习。Pipenv 的创建者 Kenneth Reitz 为 Pipenv 在最近的 PyTennessee 发表了一篇演讲：“[Python 依赖管理的未来](https://www.pytennessee.org/schedule/presentation/158/)”。这次演讲没有被记录下来，但他的[幻灯片](https://speakerdeck.com/kennethreitz/the-future-of-python-dependency-management)有助于理解 Pipenv 所做的以及解决的问题。
---
via: <https://opensource.com/article/18/2/why-python-devs-should-use-pipenv>
作者：[Lacey Williams Henschel](https://opensource.com/users/laceynwilliams), [Jeff Triplett](https://opensource.com/users/jefftriplett) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
JavaScript 路由器
|
Nicolás Parada
|
https://nicolasparada.netlify.com/posts/js-router/
|
构建单页面应用（SPA）有许多的框架/库，但是我希望它们能少一些。我有一个解决方案，我想共享给大家。
|
/data/attachment/album/201807/07/144603n00b0ma2bmlmnx0l.jpg.thumb.jpg
|
/data/attachment/album/201807/07/144603n00b0ma2bmlmnx0l.jpg
| true | false | true |
qhwdw
| false |
[
"SPA"
] |
软件开发
|
{
"viewnum": 5412,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9830,
"displayorder": 0
}
] |
构建单页面应用（SPA）有许多的框架/库，但是我希望它们能少一些。我有一个解决方案，我想共享给大家。
| 2018-07-07T14:46:17 | 2018-07-07T14:46:17 | 9,815 |
/article-9815-1.html
|
构建单页面应用（SPA）有许多的框架/库，但是我希望它们能少一些。我有一个解决方案，我想共享给大家。
```
class Router {
constructor() {
this.routes = []
}
handle(pattern, handler) {
this.routes.push({ pattern, handler })
}
exec(pathname) {
for (const route of this.routes) {
if (typeof route.pattern === 'string') {
if (route.pattern === pathname) {
return route.handler()
}
} else if (route.pattern instanceof RegExp) {
const result = pathname.match(route.pattern)
if (result !== null) {
const params = result.slice(1).map(decodeURIComponent)
return route.handler(...params)
}
}
}
}
}
const router = new Router()
router.handle('/', homePage)
router.handle(/^\/users\/([^\/]+)$/, userPage)
router.handle(/^\//, notFoundPage)
function homePage() {
return 'home page'
}
function userPage(username) {
return `${username}'s page`
}
function notFoundPage() {
return 'not found page'
}
console.log(router.exec('/')) // home page
console.log(router.exec('/users/john')) // john's page
console.log(router.exec('/foo')) // not found page
```
使用它你可以为一个 URL 模式添加处理程序。这个模式可能是一个简单的字符串或一个正则表达式。使用一个字符串将精确匹配它，但是如果使用一个正则表达式将允许你做一些更复杂的事情，比如，从用户页面上看到的 URL 中获取其中的一部分，或者匹配任何没有找到页面的 URL。
我将详细解释这个 `exec` 方法 … 正如我前面说的，URL 模式既有可能是一个字符串，也有可能是一个正则表达式，因此，我首先来检查它是否是一个字符串。如果模式与给定的路径名相同，它返回运行处理程序。如果是一个正则表达式，我们与给定的路径名进行匹配。如果匹配成功，它将获取的参数传递给处理程序，并返回运行这个处理程序。
### 工作示例
那个例子正好记录到了控制台。我们尝试将它整合到一个页面，看看它是什么样的。
```
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Router Demo</title>
<link rel="shortcut icon" href="data:,">
<script src="/main.js" type="module"></script>
</head>
<body>
<header>
<a href="/">Home</a>
<a href="/users/john_doe">Profile</a>
</header>
<main></main>
</body>
</html>
```
这是 `index.html`。对于单页面应用程序来说，你必须在服务器侧做一个特别的工作，因为所有未知的路径都将返回这个 `index.html`。在开发时，我们使用了一个 npm 工具调用了 [serve](https://npm.im/serve)。这个工具去提供静态内容。使用标志 `-s`/`--single`，你可以提供单页面应用程序。
使用 [Node.js](https://nodejs.org/) 和安装的 npm（它与 Node 一起安装），运行：
```
npm i -g serve
serve -s
```
那个 HTML 文件将脚本 `main.js` 加载为一个模块。在我们渲染的相关页面中，它有一个简单的 `<header>` 和一个 `<main>` 元素。
在 `main.js` 文件中：
```
const main = document.querySelector('main')
const result = router.exec(location.pathname)
main.innerHTML = result
```
我们调用传递了当前路径名为参数的 `router.exec()`，然后将 `result` 设置为 `main` 元素的 HTML。
如果你访问 `localhost` 并运行它，你将看到它能够正常工作，但不是预期中的来自一个单页面应用程序。当你点击链接时，单页面应用程序将不会被刷新。
我们将在每个点击的链接的锚点上附加事件监听器，防止出现缺省行为，并做出正确的渲染。因为一个单页面应用程序是一个动态的东西，你预期要创建的锚点链接是动态的，因此要添加事件监听器，我使用的是一个叫 [事件委托](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Building_blocks/Events#Event_delegation) 的方法。
我给整个文档附加一个点击事件监听器，然后去检查在锚点上（或内部）是否有点击事件。
在 `Router` 类中，我有一个注册回调的方法，在我们每次点击一个链接或者一个 `popstate` 事件发生时，这个方法将被运行。每次你使用浏览器的返回或者前进按钮时，`popstate` 事件将被发送。
为了方便其见，我们给回调传递与 `router.exec(location.pathname)` 相同的参数。
```
class Router {
// ...
install(callback) {
const execCallback = () => {
callback(this.exec(location.pathname))
}
document.addEventListener('click', ev => {
if (ev.defaultPrevented
|| ev.button !== 0
|| ev.ctrlKey
|| ev.shiftKey
|| ev.altKey
|| ev.metaKey) {
return
}
const a = ev.target.closest('a')
if (a === null
|| (a.target !== '' && a.target !== '_self')
|| a.hostname !== location.hostname) {
return
}
ev.preventDefault()
if (a.href !== location.href) {
history.pushState(history.state, document.title, a.href)
execCallback()
}
})
addEventListener('popstate', execCallback)
execCallback()
}
}
```
对于链接的点击事件，除调用了回调之外，我们还使用 `history.pushState()` 去更新 URL。
我们将前面的 `main` 元素中的渲染移动到 `install` 回调中。
```
router.install(result => {
main.innerHTML = result
})
```
#### DOM
你传递给路由器的这些处理程序并不需要返回一个字符串。如果你需要更多的东西，你可以返回实际的 DOM。如：
```
const homeTmpl = document.createElement('template')
homeTmpl.innerHTML = `
<div class="container">
<h1>Home Page</h1>
</div>
`
function homePage() {
const page = homeTmpl.content.cloneNode(true)
// You can do `page.querySelector()` here...
return page
}
```
现在，在 `install` 回调中，你可以去检查 `result` 是一个 `string` 还是一个 `Node`。
```
router.install(result => {
if (typeof result === 'string') {
main.innerHTML = result
} else if (result instanceof Node) {
main.innerHTML = ''
main.appendChild(result)
}
})
```
这些就是基本的功能。我希望将它共享出来，因为我将在下篇文章中使用到这个路由器。
我已经以一个 [npm 包](https://www.npmjs.com/package/@nicolasparada/router) 的形式将它发布了。
---
via: <https://nicolasparada.netlify.com/posts/js-router/>
作者：[Nicolás Parada](https://nicolasparada.netlify.com/) 选题：[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/) 荣誉推出
|
||
Python 字节码介绍
|
James Bennett
|
https://opensource.com/article/18/4/introduction-python-bytecode
|
了解 Python 字节码是什么，Python 如何使用它来执行你的代码，以及知道它是如何帮到你的。
|
/data/attachment/album/201807/08/072357fqngnbmjjqqbkkvk.jpg.thumb.jpg
|
/data/attachment/album/201807/08/072357fqngnbmjjqqbkkvk.jpg
| true | false | true |
qhwdw
| false |
[
"Python",
"字节码"
] |
软件开发
|
{
"viewnum": 6343,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
了解 Python 字节码是什么，Python 如何使用它来执行你的代码，以及知道它是如何帮到你的。
| 2018-07-08T07:24:00 | 2018-07-08T07:24:00 | 9,816 |
/article-9816-1.html
|
>
> 了解 Python 字节码是什么，Python 如何使用它来执行你的代码，以及知道它是如何帮到你的。
>
>
>
如果你曾经编写过 Python，或者只是使用过 Python，你或许经常会看到 Python 源代码文件——它们的名字以 `.py` 结尾。你可能还看到过其它类型的文件，比如以 `.pyc` 结尾的文件，或许你可能听说过它们就是 Python 的 “<ruby> 字节码 <rt> bytecode </rt></ruby>” 文件。（在 Python 3 上这些可能不容易看到 —— 因为它们与你的 `.py` 文件不在同一个目录下，它们在一个叫 `__pycache__` 的子目录中）或者你也听说过，这是节省时间的一种方法，它可以避免每次运行 Python 时去重新解析源代码。
但是，除了 “噢，原来这就是 Python 字节码” 之外，你还知道这些文件能做什么吗？以及 Python 是如何使用它们的？
如果你不知道，那你走运了！今天我将带你了解 Python 的字节码是什么，Python 如何使用它去运行你的代码，以及知道它是如何帮助你的。
### Python 如何工作
Python 经常被介绍为它是一个解释型语言 —— 其中一个原因是在程序运行时，你的源代码被转换成 CPU 的原生指令 —— 但这样的看法只是部分正确。Python 与大多数解释型语言一样，确实是将源代码编译为一组虚拟机指令，并且 Python 解释器是针对相应的虚拟机实现的。这种中间格式被称为 “字节码”。
因此，这些 `.pyc` 文件是 Python 悄悄留下的，是为了让它们运行的 “更快”，或者是针对你的源代码的 “优化” 版本；它们是你的程序在 Python 虚拟机上运行的字节码指令。
我们来看一个示例。这里是用 Python 写的经典程序 “Hello, World!”：
```
def hello()
print("Hello, World!")
```
下面是转换后的字节码（转换为人类可读的格式）：
```
2 0 LOAD_GLOBAL 0 (print)
2 LOAD_CONST 1 ('Hello, World!')
4 CALL_FUNCTION 1
```
如果你输入那个 `hello()` 函数，然后使用 [CPython](https://github.com/python/cpython) 解释器去运行它，那么上述列出的内容就是 Python 所运行的。它看起来可能有点奇怪，因此，我们来深入了解一下它都做了些什么。
### Python 虚拟机内幕
CPython 使用一个基于栈的虚拟机。也就是说，它完全面向栈数据结构的（你可以 “推入” 一个东西到栈 “顶”，或者，从栈 “顶” 上 “弹出” 一个东西来）。
CPython 使用三种类型的栈：
1. <ruby> 调用栈 <rt> call stack </rt></ruby>。这是运行 Python 程序的主要结构。它为每个当前活动的函数调用使用了一个东西 —— “<ruby> 帧 <rt> frame </rt></ruby>”，栈底是程序的入口点。每个函数调用推送一个新的帧到调用栈，每当函数调用返回后，这个帧被销毁。
2. 在每个帧中，有一个<ruby> 计算栈 <rt> evaluation stack </rt></ruby> （也称为<ruby> 数据栈 <rt> data stack </rt></ruby>）。这个栈就是 Python 函数运行的地方，运行的 Python 代码大多数是由推入到这个栈中的东西组成的，操作它们，然后在返回后销毁它们。
3. 在每个帧中，还有一个<ruby> 块栈 <rt> block stack </rt></ruby>。它被 Python 用于去跟踪某些类型的控制结构：循环、`try` / `except` 块、以及 `with` 块，全部推入到块栈中，当你退出这些控制结构时，块栈被销毁。这将帮助 Python 了解任意给定时刻哪个块是活动的，比如，一个 `continue` 或者 `break` 语句可能影响正确的块。
大多数 Python 字节码指令操作的是当前调用栈帧的计算栈，虽然，还有一些指令可以做其它的事情（比如跳转到指定指令，或者操作块栈）。
为了更好地理解，假设我们有一些调用函数的代码，比如这个：`my_function(my_variable, 2)`。Python 将转换为一系列字节码指令：
1. 一个 `LOAD_NAME` 指令去查找函数对象 `my_function`，然后将它推入到计算栈的顶部
2. 另一个 `LOAD_NAME` 指令去查找变量 `my_variable`，然后将它推入到计算栈的顶部
3. 一个 `LOAD_CONST` 指令去推入一个实整数值 `2` 到计算栈的顶部
4. 一个 `CALL_FUNCTION` 指令
这个 `CALL_FUNCTION` 指令将有 2 个参数，它表示那个 Python 需要从栈顶弹出两个位置参数；然后函数将在它上面进行调用，并且它也同时被弹出（对于函数涉及的关键字参数，它使用另一个不同的指令 —— `CALL_FUNCTION_KW`，但使用的操作原则类似，以及第三个指令 —— `CALL_FUNCTION_EX`，它适用于函数调用涉及到参数使用 `*` 或 `**` 操作符的情况）。一旦 Python 拥有了这些之后，它将在调用栈上分配一个新帧，填充到函数调用的本地变量上，然后，运行那个帧内的 `my_function` 字节码。运行完成后，这个帧将被调用栈销毁，而在最初的帧内，`my_function` 的返回值将被推入到计算栈的顶部。
### 访问和理解 Python 字节码
如果你想玩转字节码，那么，Python 标准库中的 `dis` 模块将对你有非常大的帮助；`dis` 模块为 Python 字节码提供了一个 “反汇编”，它可以让你更容易地得到一个人类可读的版本，以及查找各种字节码指令。[`dis` 模块的文档](https://docs.python.org/3/library/dis.html) 可以让你遍历它的内容，并且提供一个字节码指令能够做什么和有什么样的参数的完整清单。
例如，获取上面的 `hello()` 函数的列表，可以在一个 Python 解析器中输入如下内容，然后运行它：
```
import dis
dis.dis(hello)
```
函数 `dis.dis()` 将反汇编一个函数、方法、类、模块、编译过的 Python 代码对象、或者字符串包含的源代码，以及显示出一个人类可读的版本。`dis` 模块中另一个方便的功能是 `distb()`。你可以给它传递一个 Python 追溯对象，或者在发生预期外情况时调用它，然后它将在发生预期外情况时反汇编调用栈上最顶端的函数，并显示它的字节码，以及插入一个指向到引发意外情况的指令的指针。
它也可以用于查看 Python 为每个函数构建的编译后的代码对象，因为运行一个函数将会用到这些代码对象的属性。这里有一个查看 `hello()` 函数的示例：
```
>>> hello.__code__
<code object hello at 0x104e46930, file "<stdin>", line 1>
>>> hello.__code__.co_consts
(None, 'Hello, World!')
>>> hello.__code__.co_varnames
()
>>> hello.__code__.co_names
('print',)
```
代码对象在函数中可以以属性 `__code__` 来访问，并且携带了一些重要的属性：
* `co_consts` 是存在于函数体内的任意实数的元组
* `co_varnames` 是函数体内使用的包含任意本地变量名字的元组
* `co_names` 是在函数体内引用的任意非本地名字的元组
许多字节码指令 —— 尤其是那些推入到栈中的加载值，或者在变量和属性中的存储值 —— 在这些元组中的索引作为它们参数。
因此，现在我们能够理解 `hello()` 函数中所列出的字节码：
1. `LOAD_GLOBAL 0`：告诉 Python 通过 `co_names` （它是 `print` 函数）的索引 0 上的名字去查找它指向的全局对象，然后将它推入到计算栈
2. `LOAD_CONST 1`：带入 `co_consts` 在索引 1 上的字面值，并将它推入（索引 0 上的字面值是 `None`，它表示在 `co_consts` 中，因为 Python 函数调用有一个隐式的返回值 `None`，如果没有显式的返回表达式，就返回这个隐式的值 ）。
3. `CALL_FUNCTION 1`：告诉 Python 去调用一个函数；它需要从栈中弹出一个位置参数，然后，新的栈顶将被函数调用。
“原始的” 字节码 —— 是非人类可读格式的字节 —— 也可以在代码对象上作为 `co_code` 属性可用。如果你有兴趣尝试手工反汇编一个函数时，你可以从它们的十进制字节值中，使用列出 `dis.opname` 的方式去查看字节码指令的名字。
### 字节码的用处
现在，你已经了解的足够多了，你可能会想 “OK，我认为它很酷，但是知道这些有什么实际价值呢？”由于对它很好奇，我们去了解它，但是除了好奇之外，Python 字节码在几个方面还是非常有用的。
首先，理解 Python 的运行模型可以帮你更好地理解你的代码。人们都开玩笑说，C 是一种 “可移植汇编器”，你可以很好地猜测出一段 C 代码转换成什么样的机器指令。理解 Python 字节码之后，你在使用 Python 时也具备同样的能力 —— 如果你能预料到你的 Python 源代码将被转换成什么样的字节码，那么你可以知道如何更好地写和优化 Python 源代码。
第二，理解字节码可以帮你更好地回答有关 Python 的问题。比如，我经常看到一些 Python 新手困惑为什么某些结构比其它结构运行的更快（比如，为什么 `{}` 比 `dict()` 快）。知道如何去访问和阅读 Python 字节码将让你很容易回答这样的问题（尝试对比一下： `dis.dis("{}")` 与 `dis.dis("dict()")` 就会明白）。
最后，理解字节码和 Python 如何运行它，为 Python 程序员不经常使用的一种特定的编程方式提供了有用的视角：面向栈的编程。如果你以前从来没有使用过像 FORTH 或 Fator 这样的面向栈的编程语言，它们可能有些古老，但是，如果你不熟悉这种方法，学习有关 Python 字节码的知识，以及理解面向栈的编程模型是如何工作的，将有助你开拓你的编程视野。
### 延伸阅读
如果你想进一步了解有关 Python 字节码、Python 虚拟机、以及它们是如何工作的更多知识，我推荐如下的这些资源：
* [Python 虚拟机内幕](https://leanpub.com/insidethepythonvirtualmachine)，它是 Obi Ike-Nwosu 写的一本免费在线电子书，它深入 Python 解析器，解释了 Python 如何工作的细节。
* [一个用 Python 编写的 Python 解析器](http://www.aosabook.org/en/500L/a-python-interpreter-written-in-python.html)，它是由 Allison Kaptur 写的一个教程，它是用 Python 构建的 Python 字节码解析器，并且它实现了运行 Python 字节码的全部构件。
* 最后，CPython 解析器是一个开源软件，你可以在 [GitHub](https://github.com/python/cpython) 上阅读它。它在文件 `Python/ceval.c` 中实现了字节码解析器。[这是 Python 3.6.4 发行版中那个文件的链接](https://github.com/python/cpython/blob/d48ecebad5ac78a1783e09b0d32c211d9754edf4/Python/ceval.c)；字节码指令是由第 1266 行开始的 `switch` 语句来处理的。
学习更多内容，参与到 James Bennett 的演讲，[有关字节的知识：理解 Python 字节码](https://us.pycon.org/2018/schedule/presentation/127/)，将在 [PyCon Cleveland 2018](https://us.pycon.org/2018/) 召开。
---
via: <https://opensource.com/article/18/4/introduction-python-bytecode>
作者：[James Bennett](https://opensource.com/users/ubernostrum) 选题：[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/) 荣誉推出
|
||
Sosreport：收集系统日志和诊断信息的工具
|
Sk
|
https://www.ostechnix.com/sosreport-a-tool-to-collect-system-logs-and-diagnostic-information/
|
它是一个从类 Unix 操作系统中收集系统配置详细信息和诊断信息的工具。
|
/data/attachment/album/201807/08/093729btevwc3iyv23euvc.png.thumb.jpg
|
/data/attachment/album/201807/08/093729btevwc3iyv23euvc.png
| true | false | true |
geekpi
| false |
[
"Sosreport"
] |
分享
|
{
"viewnum": 11501,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
它是一个从类 Unix 操作系统中收集系统配置详细信息和诊断信息的工具。
| 2018-07-08T09:37:25 | 2018-07-08T09:37:25 | 9,817 |
/article-9817-1.html
|
如果你是 RHEL 管理员，你可能肯定听说过 **Sosreport** ：一个可扩展、可移植的支持数据收集工具。它是一个从类 Unix 操作系统中收集系统配置详细信息和诊断信息的工具。当用户提出支持服务单时，他/她必须运行此工具并将由 Sosreport 工具生成的结果报告发送给 Red Hat 支持人员。然后，执行人员将根据报告进行初步分析，并尝试找出系统中的问题。不仅在 RHEL 系统上，你可以在任何类 Unix 操作系统上使用它来收集系统日志和其他调试信息。
### 安装 Sosreport
Sosreport 在 Red Hat 官方系统仓库中，因此你可以使用 Yum 或 DNF 包管理器安装它，如下所示。
```
$ sudo yum install sos
```
要么，
```
$ sudo dnf install sos
```
在 Debian、Ubuntu 和 Linux Mint 上运行：
```
$ sudo apt install sosreport
```
### 用法
安装后，运行以下命令以收集系统配置详细信息和其他诊断信息。
```
$ sudo sosreport
```
系统将要求你输入系统的一些详细信息，例如系统名称、案例 ID 等。相应地输入详细信息，然后按回车键生成报告。如果你不想更改任何内容并使用默认值，只需按回车键即可。
我的 CentOS 7 服务器的示例输出：
```
sosreport (version 3.5)
This command will collect diagnostic and configuration information from
this CentOS Linux system and installed applications.
An archive containing the collected information will be generated in
/var/tmp/sos.DiJXi7 and may be provided to a CentOS support
representative.
Any information provided to CentOS will be treated in accordance with
the published support policies at:
https://wiki.centos.org/
The generated archive may contain data considered sensitive and its
content should be reviewed by the originating organization before being
passed to any third party.
No changes will be made to system configuration.
Press ENTER to continue, or CTRL-C to quit.
Please enter your first initial and last name [server.ostechnix.local]:
Please enter the case id that you are generating this report for []:
Setting up archive ...
Setting up plugins ...
Running plugins. Please wait ...
Running 73/73: yum...
Creating compressed archive...
Your sosreport has been generated and saved in:
/var/tmp/sosreport-server.ostechnix.local-20180628171844.tar.xz
The checksum is: 8f08f99a1702184ec13a497eff5ce334
Please send this file to your support representative.
```
如果你不希望系统提示你输入此类详细信息，请如下使用批处理模式。
```
$ sudo sosreport --batch
```
正如你在上面的输出中所看到的，生成了一个归档报告并保存在 `/var/tmp/sos.DiJXi7` 中。在 RHEL 6/CentOS 6 中，报告将在 `/tmp` 中生成。你现在可以将此报告发送给你的支持人员，以便他可以进行初步分析并找出问题所在。
你可能会担心或想知道报告中的内容。如果是这样，你可以通过运行以下命令来查看它：
```
$ sudo tar -tf /var/tmp/sosreport-server.ostechnix.local-20180628171844.tar.xz
```
要么，
```
$ sudo vim /var/tmp/sosreport-server.ostechnix.local-20180628171844.tar.xz
```
请注意，上述命令不会解压存档，而只显示存档中的文件和文件夹列表。如果要查看存档中文件的实际内容，请首先使用以下命令解压存档：
```
$ sudo tar -xf /var/tmp/sosreport-server.ostechnix.local-20180628171844.tar.xz
```
存档的所有内容都将解压当前工作目录中 `ssosreport-server.ostechnix.local-20180628171844/` 目录中。进入目录并使用 `cat` 命令或任何其他文本浏览器查看文件内容：
```
$ cd sosreport-server.ostechnix.local-20180628171844/
$ cat uptime
17:19:02 up 1:03, 2 users, load average: 0.50, 0.17, 0.10
```
有关 Sosreport 的更多详细信息，请参阅手册页。
```
$ man sosreport
```
就是这些了。希望这些有用。还有更多好东西。敬请关注！
干杯！
---
via: <https://www.ostechnix.com/sosreport-a-tool-to-collect-system-logs-and-diagnostic-information/>
作者：[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/) 荣誉推出
|
||
将你的树莓派打造成一个 Tor 中继节点
|
Konstantin Ryabitsev
|
https://www.linux.com/blog/intro-to-linux/2018/6/turn-your-raspberry-pi-tor-relay-node
|
在此教程中学习如何将你的旧树莓派打造成一个完美的 Tor 中继节点。
|
/data/attachment/album/201807/08/095040irm37me7umm7721c.jpg.thumb.jpg
|
/data/attachment/album/201807/08/095040irm37me7umm7721c.jpg
| true | false | true |
qhwdw
| false |
[
"Tor",
"树莓派"
] |
树莓派
|
{
"viewnum": 13563,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在此教程中学习如何将你的旧树莓派打造成一个完美的 Tor 中继节点。
| 2018-07-08T09:50:37 | 2018-07-08T09:50:37 | 9,818 |
/article-9818-1.html
|
>
> 在此教程中学习如何将你的旧树莓派打造成一个完美的 Tor 中继节点。
>
>
>
你是否和我一样，在第一代或者第二代树莓派发布时买了一个，玩了一段时间就把它搁置“吃灰”了。毕竟，除非你是机器人爱好者，否则一般不太可能去长时间使用一个处理器很慢的、并且内存只有 256 MB 的计算机。这并不是说你不能用它去做一件很酷的东西，但是在工作和其它任务之间，我还没有看到用一些旧的物件发挥新作用的机会。
然而，如果你想去好好利用它并且不想花费你太多的时间和资源的话，可以将你的旧树莓派打造成一个完美的 Tor 中继节点。
### Tor 中继节点是什么
在此之前你或许听说过 [Tor 项目](https://www.torproject.org/)，如果恰好你没有听说过，我简单给你介绍一下，“Tor” 是 “The Onion Router（洋葱路由器）” 的缩写，它是用来对付在线追踪和其它违反隐私行为的技术。
不论你在互联网上做什么事情，都会在你的 IP 包通过的设备上留下一些数字“脚印”：所有的交换机、路由器、负载均衡，以及目标网络记录的来自你的原始会话的 IP 地址，以及你访问的互联网资源（通常是它的主机名，[即使是在使用 HTTPS 时](https://en.wikipedia.org/wiki/Server_Name_Indication#Security_implications)）的 IP 地址。如过你是在家中上互联网，那么你的 IP 地址可以直接映射到你的家庭所在地。如果你使用了 VPN 服务（[你应该使用](https://www.linux.com/blog/2017/10/tips-secure-your-network-wake-krack)），那么你的 IP 地址映射到你的 VPN 提供商那里，而 VPN 提供商是可以映射到你的家庭所在地的。无论如何，有可能在某个地方的某个人正在根据你访问的网络和在网站上呆了多长时间来为你建立一个个人的在线资料。然后将这个资料进行出售，并与从其它服务上收集的资料进行聚合，然后利用广告网络进行赚钱。至少，这是乐观主义者对如何利用这些数据的一些看法 —— 我相信你还可以找到更多的更恶意地使用这些数据的例子。
Tor 项目尝试去提供一个解决这种问题的方案，使它们不可能（或者至少是更加困难）追踪到你的终端 IP 地址。Tor 是通过让你的连接在一个由匿名的入口节点、中继节点和出口节点组成的匿名中继链上反复跳转的方式来实现防止追踪的目的：
1. **入口节点** 只知道你的 IP 地址和中继节点的 IP 地址，但是不知道你最终要访问的目标 IP 地址
2. **中继节点** 只知道入口节点和出口节点的 IP 地址，以及既不是源也不是最终目标的 IP 地址
3. **出口节点** 仅知道中继节点和最终目标地址，它是在到达最终目标地址之前解密流量的节点
中继节点在这个交换过程中扮演一个关键的角色，因为它在源请求和目标地址之间创建了一个加密的障碍。甚至在意图偷窥你数据的对手控制了出口节点的情况下，在他们没有完全控制整个 Tor 中继链的情况下仍然无法知道请求源在哪里。
只要存在大量的中继节点，你的隐私被会得到保护 —— 这就是我为什么真诚地建议你，如果你的家庭宽带有空闲的时候去配置和运行一个中继节点。
#### 考虑去做 Tor 中继时要记住的一些事情
一个 Tor 中继节点仅发送和接收加密流量 —— 它从不访问任何其它站点或者在线资源，因此你不用担心有人会利用你的家庭 IP 地址去直接浏览一些令人担心的站点。话虽如此，但是如果你居住在一个提供<ruby> 匿名增强服务 <rt> anonymity-enhancing services </rt></ruby>是违法行为的司法管辖区的话，那么你还是不要运营你的 Tor 中继节点了。你还需要去查看你的互联网服务提供商的服务条款是否允许你去运营一个 Tor 中继。
### 需要哪些东西
* 一个带完整外围附件的树莓派（任何型号/代次都行）
* 一张有 [Raspbian Stretch Lite](https://www.raspberrypi.org/downloads/raspbian/) 的 SD 卡
* 一根以太网线缆
* 一根用于供电的 micro-USB 线缆
* 一个键盘和带 HDMI 接口的显示器（在配置期间使用）
本指南假设你已经配置好了你的家庭网络连接的线缆或者 ADSL 路由器，它用于运行 NAT 转换（它几乎是必需的）。大多数型号的树莓派都有一个可用于为树莓派供电的 USB 端口，如果你只是使用路由器的 WiFi 功能，那么路由器应该有空闲的以太网口。但是在我们将树莓派设置为一个“配置完不管”的 Tor 中继之前，我们还需要一个键盘和显示器。
### 引导脚本
我改编了一个很流行的 Tor 中继节点引导脚本以适配树莓派上使用 —— 你可以在我的 GitHub 仓库 <https://github.com/mricon/tor-relay-bootstrap-rpi> 上找到它。你用它引导树莓派并使用缺省的用户 `pi` 登入之后，做如下的工作：
```
sudo apt-get install -y git
git clone https://github.com/mricon/tor-relay-bootstrap-rpi
cd tor-relay-bootstrap-rpi
sudo ./bootstrap.sh
```
这个脚本将做如下的工作：
1. 安装最新版本的操作系统更新以确保树莓派打了所有的补丁
2. 将系统配置为无人值守自动更新，以确保有可用更新时会自动接收并安装
3. 安装 Tor 软件
4. 告诉你的 NAT 路由器去转发所需要的端口（端口一般是 443 和 8080，因为这两个端口最不可能被互联网提供商过滤掉）上的数据包到你的中继节点
脚本运行完成后，你需要去配置 `torrc` 文件 —— 但是首先，你需要决定打算贡献给 Tor 流量多大带宽。首先，在 Google 中输入 “[Speed Test](https://www.google.com/search?q=speed+test)”，然后点击 “Run Speed Test” 按钮。你可以不用管 “Download speed” 的结果，因为你的 Tor 中继能处理的速度不会超过最大的上行带宽。
所以，将 “Mbps upload” 的数字除以 8，然后再乘以 1024，结果就是每秒多少 KB 的宽带速度。比如，如果你得到的上行带宽是 21.5 Mbps，那么这个数字应该是：
```
21.5 Mbps / 8 * 1024 = 2752 KBytes per second
```
你可以限制你的中继带宽为那个数字的一半，并允许突发带宽为那个数字的四分之三。确定好之后，使用喜欢的文本编辑器打开 `/etc/tor/torrc` 文件，调整好带宽设置。
```
RelayBandwidthRate 1300 KBytes
RelayBandwidthBurst 2400 KBytes
```
当然，如果你想更慷慨，你可以将那几个设置的数字调的更大，但是尽量不要设置为最大的出口带宽 —— 如果设置的太高，它会影响你的日常使用。
你打开那个文件之后，你应该去设置更多的东西。首先是昵称 —— 只是为了你自己保存记录，第二个是联系信息，只需要一个电子邮件地址。由于你的中继是运行在无人值守模式下的，你应该使用一个定期检查的电子邮件地址 —— 如果你的中继节点离线超过 48 个小时，你将收到 “Tor Weather” 服务的告警信息。
```
Nickname myrpirelay
ContactInfo you@example.com
```
保存文件并重引导系统去启动 Tor 中继。
### 测试它确认有 Tor 流量通过
如果你想去确认中继节点的功能，你可以运行 `arm` 工具：
```
sudo -u debian-tor arm
```
它需要一点时间才显示，尤其是在老板子上。它通常会给你显示一个表示入站和出站流量（或者是错误信息，它将有助于你去排错）的柱状图。
一旦你确信它运行正常，就可以将键盘和显示器拔掉了，然后将树莓派放到地下室，它就可以在那里悄悄地呆着并到处转发加密的比特了。恭喜你，你已经帮助去改善隐私和防范在线的恶意跟踪了！
通过来自 Linux 基金会和 edX 的免费课程 ["Linux 入门"](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux) 来学习更多的 Linux 知识。
---
via: <https://www.linux.com/blog/intro-to-linux/2018/6/turn-your-raspberry-pi-tor-relay-node>
作者：[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/) 荣誉推出
|
||
迁移到 Linux：使用 sudo
|
John Bonesio
|
https://www.linux.com/blog/learn/2018/3/migrating-linux-using-sudo
|
sudo 机制可以让你轻松以普通用户偶尔执行管理任务。让我们来学习一下。
|
/data/attachment/album/201807/09/180426anjij9nn8tjni7w7.jpg.thumb.jpg
|
/data/attachment/album/201807/09/180426anjij9nn8tjni7w7.jpg
| true | false | false | false |
[
"迁移",
"sudo"
] |
技术
|
{
"viewnum": 4518,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9565,
"displayorder": 0
},
{
"raid": 9823,
"displayorder": 0
}
] |
sudo 机制可以让你轻松以普通用户偶尔执行管理任务。让我们来学习一下。
| 2018-07-09T18:04:00 | 2018-07-09T18:04:00 | 9,819 |
/article-9819-1.html
|
>
> sudo 机制可以让你轻松以普通用户偶尔执行管理任务。让我们来学习一下。
>
>
>
本文是我们关于迁移到 Linux 的系列文章的第五篇。如果你错过了之前的那些，你可以在这里赶上：
* [第1部分 - 入门介绍](/article-9212-1.html)
* [第2部分 - 磁盘、文件和文件系统](/article-9213-1.html)
* [第3部分 - 图形操作环境](/article-9293-1.html)
* [第4部分 - 命令行](/article-9565-1.html)
你可能一直想了解 Linux。也许它在你的工作场所使用，如果你每天使用它，你的工作效率会更高。或者，也许你想在家里的某些计算机上安装 Linux。无论是什么原因，这一系列文章都是为了让过渡更容易。
与许多其他操作系统一样，Linux 支持多用户。它甚至支持多个用户同时登录。
用户帐户通常会被分配一个可以存储文件的家目录。通常这个家目录位于：
```
/home/<login name>
```
这样，每个用户都有存储自己的文档和其他文件的独立位置。
### 管理任务
在传统的 Linux 安装中，常规用户帐户无权在系统上执行管理任务。典型的安装 Linux 的系统会要求用户以管理员身份登录以执行某些任务，而不是为每个用户分配权限以执行各种任务。
Linux 上的管理员帐户称为 root。
### Sudo 解释
从历史上看，要执行管理任务，必须以 root 身份登录，执行任务，然后登出。这个过程有点乏味，所以很多人以 root 登录并且整天都以管理员身份工作。这种做法可能会导致灾难性的后果，例如，意外删除系统中的所有文件。当然，root 用户可以做任何事情，因此没有任何保护措施可以防止有人意外地执行影响很大的操作。
创建 `sudo` 工具是为了使你更容易以常规用户帐户登录，偶尔以 root 身份执行管理任务，而无需登录、执行任务然后登出。具体来说，`sudo` 允许你以不同的用户身份运行命令。如果你未指定特定用户，则假定你指的是 root 用户。
`sudo` 可以有复杂的设置，允许用户有权限使用 `sudo` 运行某些命令，而其他的不行。通常，安装的桌面系统会使创建的第一个帐户在 `sudo` 中有完全的权限，因此你作为主要用户可以完全管理 Linux 安装。
### 使用 Sudo
某些安装 Linux 的系统设置了 `sudo`，因此你仍需要知道 root 帐户的密码才能执行管理任务。其他人，设置 `sudo` 输入自己的密码。这里有不同的哲学。
当你尝试在图形环境中执行管理任务时，通常会打开一个要求输入密码的对话框。输入你自己的密码（例如，在 Ubuntu 上）或 root 帐户的密码（例如，Red Hat）。
当你尝试在命令行中执行管理任务时，它通常只会给你一个 “permission denied” 错误。然后你在前面用 `sudo` 重新运行命令。例如：
```
systemctl start vsftpd
Failed to start vsftpd.service: Access denied
sudo systemctl start vsftpd
[sudo] password for user1:
```
### 何时使用 Sudo
以 root 身份运行命令（在 `sudo` 或其他情况下）并不总是解决权限错误的最佳解决方案。虽然将以 root 身份运行会消除 “permission denied” 错误，但有时最好寻找根本原因而不是仅仅解决症状。有时文件拥有错误的所有者和权限。
当你在尝试一个需要 root 权限来执行操作的任务或者程序时使用 `sudo`。如果文件恰好由另一个用户（包括 root 用户）拥有，请不要使用 `sudo`。在第二种情况下，最好正确设置文件的权限。
通过 Linux 基金会和 edX 的免费[“Linux 介绍”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)课程了解有关 Linux 的更多信息。
---
via: <https://www.linux.com/blog/learn/2018/3/migrating-linux-using-sudo>
作者：[John Bonesio](https://www.linux.com/users/johnbonesio) 选题：[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/) 荣誉推出
|
|||
五个最热门的开源机器学习 JavaScript 框架
|
Dr.michael J.garbade
|
https://opensource.com/article/18/5/machine-learning-javascript-frameworks
|
如果你是一位想要深入机器学习的 JavaScript 程序员或想成为一位使用 JavaScript 的机器学习专家，那么这些开源框架也许会吸引你。
|
/data/attachment/album/201807/09/182213tquw1qihuyf5cnwq.jpg.thumb.jpg
|
/data/attachment/album/201807/09/182213tquw1qihuyf5cnwq.jpg
| true | false | true |
hopefully2333
| false |
[
"机器学习",
"JavaScript"
] |
软件开发
|
{
"viewnum": 5351,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你是一位想要深入机器学习的 JavaScript 程序员或想成为一位使用 JavaScript 的机器学习专家，那么这些开源框架也许会吸引你。
| 2018-07-09T18:22:24 | 2018-07-09T18:22:24 | 9,820 |
/article-9820-1.html
|
>
> 如果你是一位想要深入机器学习的 JavaScript 程序员或想成为一位使用 JavaScript 的机器学习专家，那么这些开源框架也许会吸引你。
>
>
>
开源工具的涌现使得开发者能够更加轻松地开发应用，这一点使机器学习领域本身获得了极大增长。（例如，AndreyBu，他来自德国，在机器学习领域拥有五年以上的经验，他一直在使用各种各样的开源框架来创造富有魅力的机器学习项目。）
虽然 Python 是绝大多数的机器学习框架所采用的语言，但是 JavaScript 也并没有被抛下。JavaScript 开发者可以在浏览器中使用各种框架来训练和部署机器学习模型。
下面是 JavaScript 中最热门五个机器学习框架
### 1、 TensorFlow.js
[TensorFlow.js](https://js.tensorflow.org/) 是一个开源库，它使你能在浏览器中完整地运行机器学习程序，它是 Deeplearn.js 的继承者，Deeplearn.js 不再更新了。TensorFlow.js 在 Deeplearn.js 功能的基础上进行了改善，使你能够充分利用浏览器，得到更加深入的机器学习经验。
通过这个开源库，你可以在浏览器中使用有各种功能的、直观的 API 来定义、训练和部署模型。除此之外，它自动提供 WebGL 和 Node.js 的支持。
如果您有了一个已经训练过的模型，你想要导入到浏览器中。TensorFlow.js 可以让你做到这一点，你也可以在不离开浏览器的情况下重新训练已有的模型。
### 2、 机器学习工具库
现在有很多在浏览器中提供广泛的机器学习功能的资源型开源工具，这个[机器学习工具库](https://github.com/mljs/ml)就是这些开源工具的集合。这个工具库为好几种机器学习算法提供支持，包括非监督式学习、监督式学习、数据处理、人工神经网络（ANN）、数学和回归。
如果你以前使用 Python，现在想找类似于 Scikit-learn 的，能在浏览器中使用 JavaScript 进行机器学习的工具，这套工具会满足你的要求。
### 3、 Keras.js
[Keras.js](https://transcranial.github.io/keras-js/#/) 是另外一个热门的开源框架，它使你能够在浏览器中运行机器学习模型，它使用 WebGL 来提供 GPU 模式的支持。如果你有使用 Node.js 的模型，你就只能在 GPU 模式下运行它。Keras.js 还为使用任意后端框架的模型训练提供支持，例如 Microsoft Cognitive Toolkit (CNTK) 。
一些 Keras 模型可以部署在客户端浏览器上，包括 Inception v3 (训练在 ImageNet 上)，50 层冗余网络(训练在 ImageNet 上)，和卷积变化自动编码器(训练在 MNIST 上)。
### 4、 Brain.js
机器学习里的概念非常重要，它可能会使刚开始进入这个领域的人们气馁，这个领域里的学术用语和专业词汇可能会使初学者感到崩溃，而解决以上问题的能力就是 [Brain.js](https://github.com/BrainJS/brain.js) 的优势所在。它是开源的，基于 JavaScript 的框架，简化了定义、训练和运行神经网络的流程。
如果你是一个 JavaScript 开发者，并且在机器学习领域是完全的新手，Brain.js 能减低你学习的难度曲线。它可以和 Node.js 一起使用，或者运行在客户端浏览器里来训练机器学习模型。Brain.js 支持部分类型的神经网络，包括前馈式网络、Ellman 网络，和门循环单元网络。
### 5、 STDLib
[STDLib](https://stdlib.io/) 是一个基于 JavaScript 和 Node.js 应用的开源库，如果您正在寻找一种在浏览器中运行，支持科学和数字化的基于 web 的机器学习应用，STDLib 能满足你的需要。
这个库能提供全面而先进的数学和统计学上的功能，来帮助你构建高性能的机器学习模型。你同样也可以使用它丰富的功能来构建应用程序和其他的库。除此之外，如果你想要一个数据可视化和探索性数据分析的框架 —— STDLib，你，值得拥有。
### 总结
如果你是一个 JavaScript 开发者，并且打算深入研究令人兴奋的机器学习世界，或者说，你是一个机器学习方面的专家，打算开始尝试使用 JavaScript ，那么上述的开源框架会激起您的兴趣。
你有知道其他的，提供在浏览器里运行机器学习功能的开源库吗？请在下面的评论区里告诉我们。
---
via: <https://opensource.com/article/18/5/machine-learning-javascript-frameworks>
作者：[Dr.Michael J.Garbade](https://opensource.com/users/drmjg) 选题：[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/) 荣誉推出
|
||
3 款 Linux 桌面的日记程序
|
Scott Nesbitt
|
https://opensource.com/article/18/6/linux-journaling-applications
|
用轻量、灵活的数字日记工具来记录你的活动。
|
/data/attachment/album/201807/09/183600deix08fxlsm8xmpi.jpeg.thumb.jpg
|
/data/attachment/album/201807/09/183600deix08fxlsm8xmpi.jpeg
| true | false | true |
geekpi
| false |
[
"日记"
] |
分享
|
{
"viewnum": 8225,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用轻量、灵活的数字日记工具来记录你的活动。
| 2018-07-09T18:36:08 | 2018-07-09T18:36:08 | 9,821 |
/article-9821-1.html
|
>
> 用轻量、灵活的数字日记工具来记录你的活动。
>
>
>
保持记日记的习惯，即使是不定期地记，也可以带来很多好处。这不仅是治疗和宣泄，而且还可以很好地记录你所在的位置以及你去过的地方。它可以帮助你展示你在生活中的进步，并提醒你自己做对了什么，做错了什么。
无论你记日记的原因是什么，都有多种方法可以做到这一点。你可以使用传统的笔和纸，也可以使用基于 Web 的程序，或者你可以使用[简单的文本文件](https://plaintextproject.online/2017/07/19/journal.html)。
另一种选择是使用专门的日记程序。Linux 桌面有几种非常灵活且非常有用的日记工具。我们来看看其中的三个。
### RedNotebook
在这里描述的三个日记程序中，[RedNotebook](http://rednotebook.sourceforge.net) 是最灵活的。大部分灵活性来自其模板。这些模板可让你记录个人想法或会议记录、计划旅程或记录电话。你还可以编辑现有模板或创建自己的模板。
你可以使用与 Markdown 非常相似的标记语言来记录日记。你还可以在日记中添加标签，以便于查找。只需在程序的左窗格中单击或输入标记，右窗格中将显示相应日记的列表。
最重要的是，你可以将全部、部分或仅一个日记导出为纯文本、HTML、LaTeX 或 PDF。在执行此操作之前，你可以通过单击工具栏上的“预览”按钮了解日志在 PDF 或 HTML 中的显示情况。
总的来说，RedNotebook 是一款易于使用且灵活的程序。它需要习惯，但一旦你这样做，它是一个有用的工具。
### Lifeograph
[Lifeograph](http://lifeograph.sourceforge.net/wiki/Main_Page) 与 RedNotebook 有相似的外观和感觉。它没有那么多功能，但 Lifeograph 也够了。
该程序通过保持简单和整洁性来简化记日记这件事。你有一个很大的区域可以记录，你可以为日记添加一些基本格式。这包括通常的粗体和斜体，以及箭头和高亮显示。你可以在日记中添加标签，以便更好地组织和查找它们。
Lifeograph 有一个我觉得特别有用的功能。首先，你可以创建多个日记 - 例如，工作日记和个人日记。其次是密码保护你的日记的能力。虽然该网站声称 Lifeograph 使用“真正的加密”，但没有关于它的详细信息。尽管如此，设置密码仍然会阻止大多数窥探者。
### Almanah Diary
[Almanah Diary](https://wiki.gnome.org/Apps/Almanah_Diary) 是另一种非常简单的日记工具。但不要因为它缺乏功能就丢掉它。虽简单，但足够。
有多简单？它差不多只是一个包含了日记输入和日历的区域而已。你可以做更多的事情 —— 比如添加一些基本格式（粗体、斜体和下划线）并将文本转换为超链接。Almanah 还允许你加密日记。
虽然有一个可以将纯文本文件导入该程序的功能，但我无法使其正常工作。尽管如此，如果你喜欢一个简单，能够快速记日记的软件，那么 Almanah 日记值得一看。
### 命令行怎么样？
如果你不想用 GUI 则可以不必用。命令行是保存日记的绝佳选择。
我尝试过并且喜欢的是 [jrnl](http://maebert.github.com/jrnl/)。或者你可以使用[此方案](http://tamilinux.wordpress.com/2007/07/27/writing-short-notes-and-diaries-from-the-cli/)，它使用命令行别名格式化并将日记保存到文本文件中。
你有喜欢的日记程序吗？请留下评论，随意分享。
---
via: <https://opensource.com/article/18/6/linux-journaling-applications>
作者：[Scott Nesbitt](https://opensource.com/users/scottnesbitt) 选题：[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/3/migrating-linux-installing-software
|
所有的 Linux 打包系统和工具都会让人迷惑，但是这篇面向初学者的教程可以帮助你搞明白。
|
/data/attachment/album/201807/10/074348az6w8n990m0r9vfv.jpg.thumb.jpg
|
/data/attachment/album/201807/10/074348az6w8n990m0r9vfv.jpg
| true | false | true |
MjSeven
| false |
[
"安装",
"迁移"
] |
技术
|
{
"viewnum": 7016,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9819,
"displayorder": 0
},
{
"raid": 10363,
"displayorder": 0
}
] |
所有的 Linux 打包系统和工具都会让人迷惑，但是这篇面向初学者的教程可以帮助你搞明白。
| 2018-07-10T07:43:00 | 2018-07-10T07:43:00 | 9,823 |
/article-9823-1.html
|
>
> 所有的 Linux 打包系统和工具都会让人迷惑，但是这篇面向初学者的教程可以帮助你搞明白。
>
>
>
如你所见，众所瞩目的 Linux 已经用在互联网，以及 Arduino、Beagle 和树莓派主板等设备上，或许你正在考虑是时候尝试一下 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)
### 安装软件
要在你的计算机上获得新软件，通常的方法是从供应商处获得软件产品，然后运行一个安装程序。过去，软件产品会出现在像 CD-ROM 或 DVD 一样的物理媒介上，而现在我们经常从互联网上下载软件产品。
使用 Linux，安装软件就像在你的智能手机上安装一样。如同你的手机应用商店一样，在 Linux 上有个提供开源软件工具和程序的<ruby> 中央仓库 <rt> central repository </rt></ruby>，几乎任何你想要的程序都会出现在可用软件包列表中以供你安装。
每个程序并不需要运行单独的安装程序，而是你可以使用 Linux 发行版附带的软件包管理工具。（这里说的 Linux 发行版就是你安装的 Linux，例如 Ubuntu、Fedora、Debian 等）每个发行版在互联网上都有它自己的集中存储库（称为仓库），它们存储了数千个预先构建好的应用程序。
你可能会注意到，在 Linux 上安装软件有几种例外情况。有时候，你仍然需要去供应商那里获取他们的软件，因为该程序不存在于你的发行版的中央仓库中。当软件不是开源和/或自由软件的时候，通常就是这种情况。
另外请记住，如果你想要安装一个不在发行版仓库中的程序时，事情就不是那么简单了，即使你正在安装自由及开源程序。这篇文章没有涉及到这些更复杂的情况，请遵循在线的指引。
有了所有的 Linux 包管理系统和工具，接下来干什么可能仍然令人困惑。本文应该有助于澄清一些事情。
### 包管理
目前在 Linux 发行版中有几个相互竞争的用于管理、安装和删除软件的包管理系统。每个发行版都选择使用了一个<ruby> 包管理工具 <rt> package management tools </rt> <rt> </rt></ruby>。Red Hat、Fedora、CentOS、Scientific Linux、SUSE 等使用 Red Hat 包管理（RPM）。Debian、Ubuntu、Linux Mint 等等都使用 Debian 包管理系统，简称 DPKG。还有一些其它包管理系统，但 RPM 和 DPKG 是最常见的。
*图 1: Package installers*
无论你使用的软件包管理是什么，它们通常都是一组构建于另外一种工具之上的工具（图 1）。最底层是一个命令行工具，它可以让你做任何与安装软件相关的一切工作。你可以列出已安装的程序、删除程序、安装软件包文件等等。
这个底层工具并不总是最方便使用的，所以通常会有一个命令行工具，它可以使用单个命令在发行版的中央仓库中找到软件包，并下载和安装它以及任何依赖项。最后，通常会有一个<ruby> 图形应用程序 <rt> graphical application </rt> <rt> </rt></ruby>，可以让你使用鼠标选择任何想要的内容，然后单击 “install” 按钮即可。
*图 2: PackageKit*
对于基于 Red Hat 的发行版，包括 Fedora、CentOS、Scientific Linux 等，它们的底层工具是 rpm，高级工具叫做 dnf（在旧系统上是 yum）。图形安装程序称为 PackageKit（图 2），它可能在系统管理菜单下显示名字为 “Add/Remove Software（添加/删除软件）”。
*图 3: Ubuntu Software*
对于基于 Debian 的发行版，包括 Debian、Ubuntu、Linux Mint、Elementary OS 等，它们的底层命令行工具是 dpkg，高级工具称为 apt。在 Ubuntu 上管理已安装软件的图形工具是 Ubuntu Software（图 3）。对于 Debian 和 Linux Mint，图形工具称为<ruby> 新立得 <rt> Synaptic </rt></ruby>，它也可以安装在 Ubuntu 上。
你也可以在 Debian 相关发行版上安装一个基于文本的图形化工具 aptitude。它比 <ruby> 新立得 <rt> synaptic </rt></ruby>更强大，并且即使你只能访问命令行也能工作。如果你想通过各种选项进行各种“骚”操作，你可以试试这个，但它使用起来比新立得更复杂。其它发行版也可能有自己独特的工具。
### 命令行工具
在 Linux 上安装软件的在线说明通常描述了在命令行中键入的命令。这些说明通常更容易理解，并且将命令复制粘贴到命令行窗口中，可以在不出错的情况下一步步进行。这与下面的说明相反：“打开这个菜单，选择这个程序，输入这个搜索模式，点击这个标签，选择这个程序，然后点击这个按钮”，这经常让你在各种操作中迷失。
有时你正在使用的 Linux 没有图形环境，因此熟悉从命令行安装软件包是件好事。表 1 和表 2 列出了基于 RPM 和 DPKG 系统的一下常见操作及其相关命令。
请注意 SUSE，它像 RedHat 和 Fedora 一样使用 RPM，却没有 dnf 或 yum。相反，它使用一个名为 zypper 的程序作为高级命令行工具。其他发行版也可能有不同的工具，例如 Arch Linux 上的 pacman 或 Gentoo 上的 emerge。有很多包管理工具，所以你可能需要查找哪个适用于你的发行版。
这些技巧应该能让你更好地了解如何在新的 Linux 中安装程序，以及更好地了解 Linux 中各种软件包管理方式如何相互关联。
通过 Linux 基金会和 edX 的免费 [“Linux 入门”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)课程了解有关 Linux 的更多信息。
---
via: <https://www.linux.com/blog/learn/2018/3/migrating-linux-installing-software>
作者：[JOHN BONESIO](https://www.linux.com/users/johnbonesio) 译者：[MjSeven](https://github.com/MjSeven) 校对：[pityonline](https://github.com/pityonline), [wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Arch Linux 中查找已安装的专有软件包？
|
Sk
|
https://www.ostechnix.com/find-installed-proprietary-packages-arch-linux/
|
它将基于 Arch 系统中的所有安装包与 Parabola 的软件包 blacklist 和 aur-blacklist 进行比较，然后显示出你的斯托曼自由指数（“自由/总计”比分）。
|
/data/attachment/album/201807/10/080816o0dnrwvfrfdsdvxv.jpg.thumb.jpg
|
/data/attachment/album/201807/10/080816o0dnrwvfrfdsdvxv.jpg
| true | false | true |
MjSeven
| false |
[
"专有软件"
] |
技术
|
{
"viewnum": 5819,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
它将基于 Arch 系统中的所有安装包与 Parabola 的软件包 blacklist 和 aur-blacklist 进行比较，然后显示出你的斯托曼自由指数（“自由/总计”比分）。
| 2018-07-10T08:08:13 | 2018-07-10T08:08:13 | 9,824 |
/article-9824-1.html
|
你是狂热的自由软件支持者吗？你目前在使用任何基于 Arch 的 Linux 发行版吗？我有一个小小的提示送给你！现在，你可以轻松地在 Arch Linux 及其变体（如 Antergos、Manjaro Linux 等）中找到已安装的专有软件包。你无需在已安装软件包的网站中参考其许可细节，也无需使用任何其它外部工具来查明软件包是自由的还是专有的。（LCTT 译注：其实下面还是借助了一个外部程序）
### 在 Arch Linux 中查找已安装的专有软件包
一位开发人员开发了一个名为 “[Absolutely Proprietary](https://github.com/vmavromatis/absolutely-proprietary)” 的实用程序，它是一种用于基于 Arch 发行版的专有软件包检测器。它将基于 Arch 系统中的所有安装包与 Parabola 的软件包 [blacklist](https://git.parabola.nu/blacklist.git/plain/blacklist.txt) 和 [aur-blacklist](https://git.parabola.nu/blacklist.git/plain/aur-blacklist.txt) 进行比较，然后显示出你的<ruby> 斯托曼自由指数 <rt> Stallman Freedom Index </rt></ruby>（“自由/总计”比分）。此外，你可以将该列表保存到文件中，并与其他系统/用户共享或比较。
在安装之前，确保你安装了 Python 和 Git。
然后，`git clone` 仓库：
```
git clone https://github.com/vmavromatis/absolutely-proprietary.git
```
这条命令将会下载所有内容到你当前工作目录中的 `absolutely-proprietary` 目录。
进入此目录：
```
cd absolutely-proprietary
```
接着，使用以下命令查找已安装的专有软件：
```
python main.py
```
这条命令将会下载 `blacklist.txt`、`aur-blacklist.txt`，并将本地已安装的软件包与远程软件包进行比较并显示其指数。
以下是在我的 Arch Linux 桌面的示例输出：
```
Retrieving local packages (including AUR)...
Downloading https://git.parabola.nu/blacklist.git/plain/blacklist.txt
Downloading https://git.parabola.nu/blacklist.git/plain/aur-blacklist.txt
Comparing local packages to remote...
=============================================
47 ABSOLUTELY PROPRIETARY PACKAGES INSTALLED
=============================================
Your GNU/Linux is infected with 47 proprietary packages out of 1370 total installed.
Your Stallman Freedom Index is 96.57
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
| Name | Status | Libre Alternatives | Description |
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
| chromium-pepper-flash | nonfree | | proprietary Google Chrome EULA, missing sources |
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
| faac | nonfree | | [FIXME:description] is a GPL'ed package, but has non free code that can't be distributed und|
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
| libunrar | nonfree | | part of nonfree unrar, Issue442 |
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
| opera | nonfree | | nonfree, nondistributable, built from binary installers, etc |
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
| shutter | nonfree | | need registered user to download (and access website) the source code and depends perl-net-d|
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
| ttf-ms-fonts | nonfree | | |
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
| ttf-ubuntu-font-family | nonfree | | Ubuntu font license considered non-free by DFSG and Fedora |
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
| unace | nonfree | | license forbids making competing ACE archivers from unace |
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
| unrar | nonfree | unar | |
| | | fsf | |
| | | unrar | |
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
| virtualbox | nonfree | | contains BIOS which needs a nonfree compiler to build from source (OpenWatcom compiler), doe|
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
| wordnet | nonfree | | |
+------------------------|---------|--------------------|---------------------------------------------------------------------------------------------+
Save list to file? (Y/n)
```
如你所见，我的系统中有 47 个专有软件包。就像我说的那样，我们可以将它保存到文件中稍后查看。为此，当提示你将列表保存在文件时，请按 `y`。然后按 `y` 接受默认值，或按 `n` 以你喜欢的格式和位置来保存它。
```
Save list to file? (Y/n) y
Save as markdown table? (Y/n) y
Save it to (/tmp/tmpkuky_082.md): y
The list is saved at /home/sk/absolutely-proprietary/y.md
You can review it from the command line
using the "less -S /home/sk/absolutely-proprietary/y.md"
or, if installed, the "most /home/sk/absolutely-proprietary/y.md" commands
```
你可能已经注意到，我只有 **nonfree** 包。它还会显示另外两种类型的软件包，例如 semifree、 uses-nonfree。
* **nonfree**：这个软件包是公然的非自由软件。
* **semifree**：这个软件包大部分是自由的，但包含一些非自由软件。
* **uses-nonfree**：这个软件包依赖、推荐或不恰当地与其他自由软件或服务集成。
该使用程序的另一个显著特点是它不仅显示了专有软件包，而且还显示这些包的替代品。
希望这有些帮助。我很快就会在这里提供另一份有用的指南。敬请关注！
干杯!
资源：
* [Absolutely Proprietary](https://github.com/vmavromatis/absolutely-proprietary)
---
via: <https://www.ostechnix.com/find-installed-proprietary-packages-arch-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 20 分钟内发布一个正式的 ERC20 通证
|
Mason
|
http://www.masonforest.com/blockchain/ethereum/2017/11/13/how-to-deploy-an-erc20-token-in-20-minutes.html
|
在这篇教程中，我准备指导你部署你自己的 ERC20 通证到实际的以太坊网络上去。
|
/data/attachment/album/201807/10/222045hwhg7mp7w766v7dz.jpg.thumb.jpg
|
/data/attachment/album/201807/10/222045hwhg7mp7w766v7dz.jpg
| true | false | true |
wxy
| false |
[
"以太坊",
"ERC20"
] |
技术
|
{
"viewnum": 5856,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇教程中，我准备指导你部署你自己的 ERC20 通证到实际的以太坊网络上去。
| 2018-07-10T22:21:00 | 2018-07-10T22:21:00 | 9,825 |
/article-9825-1.html
|
这段时间以来，以太坊通证很流行。这些通证可以用来代表现实世界的各种价值单位：[黄金](https://digix.global/)、 [谎言](https://www.cnbc.com/2017/08/28/burger-king-russia-cryptocurrency-whoppercoin.html)、 [猫咪](https://www.cryptokitties.co/) 甚至是类似 [公司股票](https://www.investopedia.com/terms/i/initial-coin-offering-ico.asp) 一样的东西。迄今为止，人们已经募集了 [20 亿美元的通证](https://www.forbes.com/sites/chancebarnett/2017/09/23/inside-the-meteoric-rise-of-icos/#57ac46d95670)。那些通证是以 [ERC20](https://theethereum.wiki/w/index.php/ERC20_Token_Standard) 为标准的，人们可以轻松地在钱包之间进行交易。在这篇教程中，我准备指导你部署你自己的 ERC20 通证到真实的以太坊网络上去。
事先准备：
* 一个文本编辑器（[Atom](https://atom.io/) 不错，不过我喜欢 [Vim](http://www.vim.org/)）
* 对命令行和终端（模拟器）有起码的了解。Mac 内置的应用“终端”就很好，不过我喜欢 [iTerm2](https://www.iterm2.com/)
* Chrome 浏览器
* [Node.js 8](https://nodejs.org/)（或更高版本）
* 你的通证的名字。我的准备叫做 HamburgerCoin（汉堡币）
你需要做的第一件事是安装 [MetaMask](https://metamask.io/)。访问 [Metamask 网站](https://metamask.io/) 并点击“Get Chrome Extention”。
Metamask 可以让你通过 Chrome 在以太坊上进行交易。它依靠运行着公开以太坊节点的 [Infura](https://infura.io/) ，所以你不用自己运行以太坊全节点。如果你颇具探索精神，你也可以下载和安装 [Mist](https://github.com/ethereum/mist/releases) 以替代它。运行 Mist 就可以让你运行你自己的以太坊节点。运行自己的节点你就需要将你的计算机与该网络进行同步，这需要不短的时间。从技术上讲这更安全，因为这样你不必信任 Infura 来处理你的交易。Infura 可以忽略你的交易而干预你，但是它并不能偷走你的钱。因为安装 Metamask 比 Mist 更快也更简单，所以我假设你在下面的教程中使用 Metamask。
接着你需要安装 [truffle](http://truffleframework.com/)：
```
$ npm install -g truffle
```
现在为你自己的新通证创建一个新目录，cd 到其中并初始化你的 truffle 项目。
```
$ mkdir hamburger-coin
$ cd hamburger-coin
$ truffle init
```
很好，你的 truffle 项目已经设置好了！
现在来创建我们的通证。首先我们需要安装 [OpenZepplin](https://github.com/OpenZeppelin) 框架。OpenZepplin 框架包括了大量预先构建好的合约，包括我们要部署的 ERC20 通证合约。
（只需要按下回车接受默认值即可）
```
$ npm init
package name: (hamburger-coin)
version: (1.0.0)
description:
entry point: (truffle.js)
test command:
git repository:
keywords:
author:
license: (ISC)
About to write to /Users/masonf/src/hamburger-coin/package.json:
{
"name": "hamburger-coin",
"version": "1.0.0",
"description": "",
"main": "truffle.js",
"directories": {
"test": "test"
},
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC"
}
Is this ok? (yes) yes
$ npm install zeppelin-solidity
```
现在我们可以创建我们的通证合约了。创建一个 `contracts/HamburgerCoin.sol` 文件并加入如下内容：
```
pragma solidity ^0.4.18;
import "zeppelin-solidity/contracts/token/StandardToken.sol";
contract HamburgerCoin is StandardToken {
string public name = "HamburgerCoin";
string public symbol = "HBC";
uint public decimals = 2;
uint public INITIAL_SUPPLY = 10000 * (10 ** decimals);
function HamburgerCoin() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
}
```
（LCTT 译注：上述合约内容中指定了合约的名称、符号和供应量。在 ERC20 当中，通证的供应量其实是整数，上述合约中通证的实际供应量是 10000 \* 100 个，出于显示 2 位小数的需求，你在合约浏览器、钱包软件中看到和操作的 1 个通证，实际上在交易中是以 100 个进行的。）
OpenZepplin 的 `StandardToken` 是一个标准的 ERC20 通证。如果你感兴趣，你可以看看它的 [源代码](https://github.com/OpenZeppelin/zeppelin-solidity/tree/master/contracts/token) 以了解是如何工作的。
实际上并不太复杂。该合约有一个 [地址到余额](https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/BasicToken.sol#L15) 的映射（LCTT 译注：你可以理解为哈希、关联数组），它也有一个 [允许转账](https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/StandardToken.sol#L17) 的列表。你可以看做是支票。你可以写张支票，但是直到它被兑付前，钱并不会被转账。
如果有人要转走一些资金，你可以在合约上调用 [approve](https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/StandardToken.sol#L48) 方法，设置你要发送的通证数量。这就像是写支票一样。
然后调用 [transferFrom](https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/StandardToken.sol#L26) 会实际进行转账。
我们可以从头写这些合约，但是最好采用经过完备的社区测试的合约。从头写一个 ERC20 通证那就是另外一篇文章了。
试着运行 `compile` 来编译我们的合约：
```
$ truffle compile
Compiling ./contracts/HamburgerCoin.sol...
Compiling zeppelin-solidity/contracts/math/SafeMath.sol...
Compiling zeppelin-solidity/contracts/ownership/Ownable.sol...
Compiling zeppelin-solidity/contracts/token/BasicToken.sol...
Compiling zeppelin-solidity/contracts/token/ERC20.sol...
Compiling zeppelin-solidity/contracts/token/ERC20Basic.sol...
Compiling zeppelin-solidity/contracts/token/MintableToken.sol...
Compiling zeppelin-solidity/contracts/token/StandardToken.sol...
Writing artifacts to ./build/contracts Next you'll need to add a migration file which will tell truffle how to deploy your contract.
```
接下来我们需要增加一个 truffle [迁移](http://truffleframework.com/docs/getting_started/migrations)。
创建 `migrations/2_deploy_hamburgercoin.js` 文件并添加如下内容：
```
var HamburgerCoin = artifacts.require("./HamburgerCoin.sol");
module.exports = function(deployer) {
deployer.deploy(HamburgerCoin);
};
```
现在让我们配置 truffle 以能够使用 Infura 公共节点。如果我们要部署到公共节点，那就需要钱包的私钥。我们可以将该私钥包含在我们的源代码当中，但是如果任何人可以访问你的源代码（和版本库），他就能够偷走我们所有的汉堡币！要避免这种情况，我们会使用 [dotenv](https://github.com/motdotla/dotenv) node.js 模块。（LCTT 译注：dotenv 用于存储机密信息的文件 .env 是以 “.” 开头的，默认不会进入版本库，当然，如果有人能查看你全部的项目文件，你的私钥还是会被泄露。）
让我们安装部署到 Infura 所需的所有模块。
```
npm install --save-dev dotenv truffle-wallet-provider ethereumjs-wallet
```
（LCTT 译注：可能安装过程中会有很多警告，大多应该是属于定义了未使用的变量和方法的编译警告，可以忽略。）
现在编辑 `truffle.js` 并（原样）加入如下内容：
```
require('dotenv').config();
const Web3 = require("web3");
const web3 = new Web3();
const WalletProvider = require("truffle-wallet-provider");
const Wallet = require('ethereumjs-wallet');
var mainNetPrivateKey = Buffer.from(process.env["MAINNET_PRIVATE_KEY"], "hex")
var mainNetWallet = Wallet.fromPrivateKey(mainNetPrivateKey);
var mainNetProvider = new WalletProvider(mainNetWallet, "https://mainnet.infura.io/");
var ropstenPrivateKey = Buffer.from(process.env["ROPSTEN_PRIVATE_KEY"], "hex")
var ropstenWallet = Wallet.fromPrivateKey(ropstenPrivateKey);
var ropstenProvider = new WalletProvider(ropstenWallet, "https://ropsten.infura.io/");
module.exports = {
networks: {
development: {
host: "localhost",
port: 8545,
network_id: "*" // Match any network id
},
ropsten: {
provider: ropstenProvider,
// You can get the current gasLimit by running
// truffle deploy --network rinkeby
// truffle(rinkeby)> web3.eth.getBlock("pending", (error, result) =>
// console.log(result.gasLimit))
gas: 4600000,
gasPrice: web3.toWei("20", "gwei"),
network_id: "3",
},
mainnet: {
provider: mainNetProvider,
gas: 4600000,
gasPrice: web3.toWei("20", "gwei"),
network_id: "1",
}
}
};
```
（LCTT 译注：原文采用 `new Buffer` 来获取私钥设置，但 node.js 升级后，废弃了 `new Buffer` 这种用法，运行时会发出警告，所以上面我修改为使用 `Buffer.from` 。）
接下来我们从 Metamask 中得到我们的私钥：
1. 点击你的 Chrome 窗口右上角的狐狸图标。
2. 点击 “Account 1” 右侧的省略号。
3. 点击 “Export Private Key”。
4. 输入你的密码。
5. 点击该文字以复制私钥到剪贴板。
然后打开 `.env`文件，并像下面这样贴入你的私钥（对于 Ropsten 测试网和 Mainnet 主网，你的私钥是一样的）：
```
ROPSTEN_PRIVATE_KEY="123YourPrivateKeyHere"
MAINNET_PRIVATE_KEY="123YourPrivateKeyHere"
```
接下来，让我们部署到 Ropsten 以太坊测试网。
以太坊测试网是一个你可以测试合约的地方。此外还有 [Kovan](https://kovan-testnet.github.io/website/) 和 [Rinkeby](https://www.rinkeby.io/) 测试网。我在这个教程中选择 Ropsten 是因为现在很容易得到 Ropsten 的测试 ETH。这些测试网都类似，你可以使用任何一个你喜欢的，但是在此教程当中我假设你在使用 Ropsten。访问 <https://faucet.metamask.io/> 以得到一些测试 ETH。从 faucet 得到一些 ETH 后，你就可以部署了。
```
$ truffle deploy --network ropsten
Compiling ./contracts/HamburgerCoin.sol...
Compiling ./contracts/Migrations.sol...
Compiling zeppelin-solidity/contracts/math/SafeMath.sol...
Compiling zeppelin-solidity/contracts/token/BasicToken.sol...
Compiling zeppelin-solidity/contracts/token/ERC20.sol...
Compiling zeppelin-solidity/contracts/token/ERC20Basic.sol...
Compiling zeppelin-solidity/contracts/token/StandardToken.sol...
Writing artifacts to ./build/contracts
Using network 'ropsten'.
Running migration: 1_initial_migration.js
Deploying Migrations...
... 0xc2bbe6bf5a7c7c7312c43d65de4c18c51c4d620d5bf51481ea530411dcebc499
Migrations: 0xd827b6f93fcb50631edc4cf8e293159f0c056538
Saving successful migration to network...
... 0xe6f92402e6ca0b1d615a310751568219f66b9d78b80a37c6d92ca59af26cf475
Saving artifacts...
Running migration: 2_deploy_contracts.js
Deploying HamburgerCoin...
... 0x02c4d47526772dc524851fc2180b338a6b037500ab298fa2f405f01abdee21c4
HamburgerCoin: 0x973b1a5c753a2d5d3924dfb66028b975e7ccca51
Saving artifacts...
```
在 “Saving aritfacts” 上面的这行即是你的合约的新地址。
复制并黏贴该地址到 [Ropsten Etherscan 搜索框](https://ropsten.etherscan.io/)，你就能看到你新部署的合约。
现在你可以在任何 ERC20 兼容的钱包，如 [Mist](https://github.com/ethereum/mist) 、[MyEtherWallet](https://www.myetherwallet.com/)（LCTT 译注：或 ImToken 这样的手机应用）里面使用你的通证了。
为了这篇教程，我构建了一个名为 [Etherface](http://etherface.io/) 的钱包来做演示。
首先你需要添加你的通证到 Etherface：
1. 访问 <http://etherface.io/> 。
2. 确认你在 Metamask 中选择了 “Ropsten” 网络。
3. 点击 “Tokens”。
4. 点击右上角的加号按钮。
5. 输入上面的合约地址。
如果你有朋友想要一些汉堡币，你现在就可以发送给他们了。如果没有，你也可以在你的两个账号间测试转账：
1. 在 Metamask 中点击 “切换账号”按钮（在右上角），并改变你的账号为 “Account 2”。
2. 点击 “Account 2” 右边的省略号，然后选择 “Copy Address to clipboard”。
3. 切换回 “Account 1”，这很重要！否则交易会失败。
4. 在 Etherface 中你的余额下点击 “Send”。
5. 黏贴 “Account 2” 的地址。
6. 输入你要发送的数量。
7. Metamask 会弹出确认窗口，点击 “Submit”。
8. 等大约 15-30 秒。
9. 你的 “Account 1” 的余额应该会减少，“Account 2” 现在会有了一些汉堡币！
最后，让我们来部署到主网（LCTT 译注：这会花费你真实的 ETH，你可以通过查看前面部署到 Ropsten 的合约信息中了解花费了多少 gas，以相应估计实际要花费多少 ETH）：
```
$ truffle deploy --network mainnet
```
你可以如前面一样加你的通证到 Etherface ，并发送你新打造的通证给你的朋友们了！
|
||
GNU GPL 许可证常见问题解答（六）
|
Fsf
|
https://www.gnu.org/licenses/gpl-faq.html
|
这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
|
/data/attachment/album/201807/10/230420x3sqqwzvvswiss4w.png.thumb.jpg
|
/data/attachment/album/201807/10/230420x3sqqwzvvswiss4w.png
| true | false | true |
薛亮
| false |
[
"GPL"
] |
开源智慧
|
{
"viewnum": 12560,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9448,
"displayorder": 0
},
{
"raid": 10040,
"displayorder": 0
}
] |
这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
| 2018-07-10T23:53:59 | 2018-07-10T23:53:59 | 9,826 |
/article-9826-1.html
|
本文由高级咨询师薛亮据自由软件基金会（FSF）的[英文原文](https://www.gnu.org/licenses/gpl-faq.html)翻译而成，这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
1. [关于 GNU 项目、自由软件基金会（FSF）及其许可证的基本问题](/article-9062-1.html)
2. [对于 GNU 许可证的一般了解](/article-8834-1.html)
3. [在您的程序中使用 GNU 许可证](/article-8761-1.html)
4. [依据GNU许可证分发程序](/article-9222-1.html)
5. [在编写其他程序时采用依据 GNU 许可证发布的程序](/article-9448-1.html)
6. 将作品与依据 GNU 许可证发布的代码相结合
7. 关于违反 GNU 许可证的问题
### 6 将作品与依据 GNU 许可证发布的代码相结合
#### 6.1 GPL v3 是否与 GPL v2 兼容？
不兼容。许多要求已经从 GPL v2 变为 GPL v3，这意味 GPL v2 中的精确要求并不体现在 GPL v3 中，反之亦然。例如，GPL v3 的终止条件比 GPL v2 的终止条件更为宽泛，因此与 GPL v2 的终止条件不同。
由于这些差异，两个许可证不兼容：如果您试图将依据 GPL v2 发布的代码与依据 GPL v3 发布的代码组合，则将违反 GPL v2 的第 6 部分。
但是，如果代码依据 GPL “v2 或更高版本”发布，则与 GPL v3 兼容，因为 GPL v3 是其允许的选项之一。
#### 6.2 GPL v2 是否有提供安装信息的要求？
GPL v3 明确要求再分发中包含完整的必要的“安装信息”。GPL v2 不使用该术语，但它需要再分发中包含用于控制可编译和安装可执行文件的脚本以及完整和相应的源代码。这涵盖了 GPL v3 中称为“安装信息”的部分内容，但不包括所有内容。因此，GPL v3 对安装信息的要求较强。
#### 6.3 各种 GNU 许可证之间如何相互兼容？
各种 GNU 许可证彼此之间具有广泛的兼容性。下面是唯一的一种您不能将遵循两种 GNU 许可证的代码结合起来的情况：将遵循旧版本许可证的代码与遵循该许可证新版本的代码进行结合。
以下是 GNU 许可证的各种结合的详细兼容性矩阵，以便为特定情况提供易于使用的参考。它假设有人依据其中一个许可证编写了一些软件，而您希望以某种方式将该软件的代码结合到您要发布的项目（您自己的原始作品或其他人的软件的修改版本）中。在表顶部的列中找到项目的许可证，并在左侧的一行中找到其他代码的许可证。它们交叉的单元格会告诉您这种结合是否被允许。
当我们说“复制代码”时，我们的意思就是：您正在从一个源代码中获取一段代码（无论是否修改），并将其插入到自己的程序中，从而基于第一部分代码形成一个作品。当您编译或运行代码时，“使用库”意味着您不直接复制任何源代码，而是通过链接、导入或其他典型机制将源代码绑定在一起。
矩阵中每个标明 GPL v3 的地方，其关于兼容性的声明也同样适用于 AGPL v3。
**兼容性矩阵**
| | |
| --- | --- |
| | 我希望依据以下许可证许可我的代码 |
| 仅 GPL v2 | GPL v2 或更高版本 | GPL v3 或更高版本 | 仅 LGPL v2.1 | LGPL v2.1 或更高版本 | LGPL v3 或更高版本 |
| 我希望复制遵循右侧许可证的代码： | 仅 GPL v2 | 可以 | 可以<sup> 【2】</sup> | 不可以 | 可以，结合作品只能遵循GPL v2<sup> 【7】</sup> | 可以，结合作品只能遵循GPL v2<sup> 【7】【2】</sup> | 不可以 |
| GPL v2 或更高版本 | 可以<sup> 【1】</sup> | 可以 | 可以 | 可以，结合作品需遵循GPL v2或更高版本<sup> 【7】</sup> | 可以，结合作品需遵循GPL v2或更高版本<sup> 【7】</sup> | 可以，结合作品需遵循GPL v3<sup> 【8】</sup> |
| GPL v3 | 不可以 | 可以，结合作品需遵循GPL v3<sup> 【3】</sup> | 可以 | 可以，结合作品需遵循GPL v3<sup> 【7】</sup> | 可以，结合作品需遵循GPL v3<sup> 【7】</sup> | 可以，结合作品需遵循GPL v3<sup> 【8】</sup> |
| 仅 LGPL v2.1 | 可以，需依据GPL v2传递复制后代码<sup> 【7】</sup> | 可以，需依据GPL v2或更高版本传递复制后代码<sup> 【7】</sup> | 可以，需依据GPL v3传递复制后代码<sup> 【7】</sup> | 可以 | 可以<sup> 【6】</sup> | 可以，需依据GPL v3传递复制后代码<sup> 【7】【8】</sup> |
| LGPL v2.1 或更高版本 | 可以，需依据GPL v2传递复制后代码<sup> 【7】【1】</sup> | 可以，需依据GPL v2或更高版本传递复制后代码<sup> 【7】</sup> | 可以，需依据GPL v3传递复制后代码<sup> 【7】</sup> | 可以<sup> 【5】</sup> | 可以 | 可以 |
| LGPL v3 | 不可以 | 可以，结合作品需遵循GPL v3<sup> 【8】【3】</sup> | 可以，结合作品需遵循GPL v3<sup> 【8】</sup> | 可以，结合作品需遵循GPL v3<sup> 【7】【8】</sup> | 可以，结合作品需遵循LGPL v3<sup> 【4】</sup> | 可以 |
| 我希望使用遵循右侧许可证的库： | 仅 GPL v2 | 可以 | 可以<sup> 【2】</sup> | 不可以 | 可以，结合作品只能遵循GPL v2<sup> 【7】</sup> | 可以，结合作品只能遵循GPL v2<sup> 【7】【2】</sup> | 不可以 |
| GPL v2 或更高版本 | 可以<sup> 【1】</sup> | 可以 | 可以 | 可以，结合作品需遵循GPL v2或更高版本<sup> 【7】</sup> | 可以，结合作品需遵循GPL v2或更高版本<sup> 【7】</sup> | 可以，结合作品需遵循GPL v3<sup> 【8】</sup> |
| GPL v3 | 不可以 | 可以，结合作品需遵循GPL v3<sup> 【3】</sup> | 可以 | 可以，结合作品需遵循GPL v3<sup> 【7】</sup> | 可以，结合作品需遵循GPL v3<sup> 【7】</sup> | 可以，结合作品需遵循GPL v3<sup> 【8】</sup> |
| 仅LGPL v2.1 | 可以 | 可以 | 可以 | 可以 | 可以 | 可以 |
| LGPL v2.1 或更高版本 | 可以 | 可以 | 可以 | 可以 | 可以 | 可以 |
| LGPL v3 | 不可以 | 可以，结合作品需遵循GPL v3<sup> 【9】</sup> | 可以 | 可以 | 可以 | 可以 |
**角注：**
1. 在这种情况下，当结合代码时，您必须遵守 GPL v2 的条款。您不能适用更高版本的条款。
2. 在这种情况下，您可以依据 GPL v2 或更高版本发布您的项目（您的原始作品和/或您收到并修改的作品），请注意，您使用的其他代码仍然只能遵循 GPL v2。只要您的项目依赖于该代码，您将无法将项目的许可证升级到 GPL v3 或更高版本，整个作品（您的项目和其他代码的任意结合）只能依据 GPL v2 的条款传递。
3. 如果您有能力依据 GPL v2 或任何更高版本发布项目，您可以选择依据 GPL v3 或更高版本发布该项目，一旦您执行此操作，您就可以结合依据 GPL v3 发布的代码。
4. 如果您有能力依据 LGPL v2.1 或任何更高版本发布项目，您可以选择依据 LGPL v3 或更高版本发布该项目，一旦您这样做，您就可以结合依据 LGPL v3 发布的代码。
5. 在这种情况下结合代码时，您必须遵守 LGPL v2.1 的条款。您不能适用更高版本 LGPL 中的条款。
6. 如果这样做，只要项目包含仅依据 LGPL v2.1 发布的代码，您将无法将项目的许可证升级到 LGPL v3 或更高版本。
7. LGPL v2.1 允许您将遵循自 GPL v2 之后任何版本 GPL 的代码进行重新许可。如果在这种情况下可以将遵循 LGPL 的代码切换为使用适当版本的 GPL（如表所示），则可以进行此种结合。
8. LGPL v3 是 GPL v3 加上在这种情况下可以忽略的额外权限。
9. 由于 GPL v2 不允许与 LGPL v3 结合，因此在这种情况下，您必须依据 GPL v3 的条款传递项目，因为它允许此种结合。
#### 6.4 <ruby> “聚合” <rp> （ </rp> <rt> aggregate </rt> <rp> ） </rp></ruby>与其他类型的“修改版本”有什么区别？（同 2.25）
“聚合”由多个单独的程序组成，分布在同一个 CD-ROM 或其他媒介中。GPL 允许您创建和分发聚合，即使其他软件的许可证不是自由许可证或与 GPL 不兼容。唯一的条件是，发布“聚合”所使用的许可证不能禁止用户去行使“聚合”中每个程序对应的许可证所赋予用户的权利。
两个单独的程序还是一个程序有两个部分，区分的界限在哪里？这是一个法律问题，最终由法官决定。我们认为，适当的判断标准取决于通信机制（exec、管道、rpc、共享地址空间内的函数调用等）和通信的语义（哪些信息被互换）。
如果模块们被包含在相同的可执行文件中，则它们肯定是被组合在一个程序中。如果模块们被设计为在共享地址空间中链接在一起运行，那么几乎肯定意味着它们组合成为一个程序。
相比之下，管道、套接字和命令行参数是通常在两个独立程序之间使用的通信机制。所以当它们用于通信时，模块们通常是单独的程序。但是，如果通信的语义足够亲密，交换复杂的内部数据结构，那么也可以视为这两个部分合并成了一个更大的程序。
#### 6.5 我在使用 GPL 程序的源代码时是否具有<ruby> “合理使用” <rp> （ </rp> <rt> fair use </rt> <rp> ） </rp></ruby>权限？（同 4.17）
是的，您有。“合理使用”是在没有任何特别许可的情况下允许的使用。由于您不需要开发人员的许可来进行这种使用，无论开发人员在许可证或其他地方对此怎么说，您都可以执行此操作，无论该许可证是 GNU GPL 还是其他自由软件许可证。
但是，请注意，没有全世界范围普适的合理使用原则；什么样的用途被认为“合理”因国而异。
#### 6.6 美国政府可否对遵循 GPL 的程序进行改进并发布？（同 3.14）
可以。如果这些改进是由美国政府雇员在雇佣期间编写的，那么这些改进属于公有领域。不过，GNU GPL 仍然涵盖了整体的改进版本。在这种情况下没有问题。
如果美国政府使用承包商来完成这项工作，那么改进本身可以被 GPL 覆盖。
#### 6.7 GPL 对于与其所覆盖的作品进行静态或动态链接的模块有不同的要求吗？
没有。将 GPL 覆盖的作品静态或动态地链接到其他模块是基于 GPL 覆盖的作品构建结合作品。因此，GNU GPL 的条款和条件将覆盖整个结合作品。另请参阅：6.24 如果我在 GPL 软件中使用了与 GPL 不兼容的库，会出现什么法律问题？
#### 6.8 LGPL 对于与其所覆盖的作品进行静态或动态链接的模块有不同的要求吗？
为了遵守 LGPL（任何现有版本：v2、v2.1 或 v3）：
（1）如果您静态链接到 LGPL 库，您还必须以对象（不一定是源代码）格式提供应用程序，以便用户有机会修改库并重新链接应用程序。
（2）如果您动态链接*已经存在于用户计算机上*的 LGPL 库，则不需要传递库的源代码。另一方面，如果您自己将可执行的 LGPL 库与您的应用程序一起传递，无论是静态还是动态链接，还必须以 LGPL 所提供的方式之一来传递库的源代码。
#### 6.9 如果库依据 GPL（而不是 LGPL）发布，这是否意味着使用它的任何软件必须遵循 GPL 或与 GPL 兼容的许可证？
是的，因为程序实际上与库进行了链接。因此，GPL 的条款适用于整个结合作品。与库链接的软件模块可能遵循与GPL兼容的不同许可证，但整体作品必须遵循 GPL。另见：“2.23 许可证与 GPL 兼容是什么意思？”
#### 6.10 您有一个遵循 GPL 的程序，我想将它与我的代码进行链接，来构建一个专有程序。那么事实上，我链接到您的程序意味着我必须让我的程序遵循 GPL 许可证？
不完全是。这意味着您必须依据与 GPL 兼容的许可证（更准确地说，与您链接的结合作品中所有其他代码所适用的一个或多个 GPL 版本相兼容）发布您的程序。然后，结合作品本身就可以遵循这些 GPL 版本。
#### 6.11 如果是这样的话，有没有机会依据 LGPL 获得您的程序许可？
您可以这么要求，但绝大多数的作者都会坚定不移地说不。GPL 的想法是，如果要将我们的代码包含在程序中，您的程序也必须是自由软件。GPL 的意图是给您施加压力，让您以能够使其成为我们社区一部分的方式来发布您的程序。
您始终拥有不使用我们代码的合法选择。
#### 6.12 我们构建专有软件的项目不能使用遵循 GPL 的某个 GNU 程序。您会为我们提供例外吗？ 这将意味着该程序拥有更多用户。
对不起，我们没有这样的例外。这样做是不对的。
最大化用户数量不是我们的目标。相反，我们正在努力为尽可能多的用户提供至关重要的自由。一般来说，专有软件项目是阻碍而不是实现软件自由的原因。
我们偶尔提供许可证例外来协助一个依据 GPL 以外的许可证生产自由软件的项目。不过，我们必须看到一个很好的理由，即这个项目为什么会推动自由软件的发展。
我们有时也会改变软件包的分发条款，这显然是为自由软件事业服务的正确方法；但是我们对此非常谨慎，所以您必须向我们展示非常有说服力的理由。
#### 6.13 如果一个编程语言解释器是依据 GPL 发布的，这是否意味着由它解释的程序必须遵循与 GPL 兼容的许可证？
当解释器只是解释一种语言时，答案是否定的。被解释程序对于解释器来说只是数据；根据版权法，像GPL这样的自由软件许可证不能限制您使用解释器的数据。您可以使用任何数据（被解释程序），以任何您喜欢的方式运行它，并且没有任何要求规定您必须将数据授权给任何人。
然而，当解释器被扩展以向<ruby> 其他程序 <rp> （ </rp> <rt> facilities </rt> <rp> ） </rp></ruby>（通常但不一定是库）提供<ruby> “绑定” <rp> （ </rp> <rt> bindings </rt> <rp> ） </rp></ruby>时，被解释程序通过这些绑定有效地与其使用的程序相关联。因此，如果这些程序是依据 GPL 发布的，则使用它们的被解释程序必须以与 GPL 兼容的方式发布。JNI（Java Native Interface）是这种绑定机制的一个例子；以这种方式访问的库与调用它们的 Java 程序动态链接。这些库也与解释器联系在一起。如果解释器与这些库静态链接，或者如果它被设计为[与这些特定库动态链接](https://www.gnu.org/licenses/gpl-faq.html#GPLPluginsInNF)，那么也需要以与 GPL 兼容的方式发布。
另一个类似且非常常见的情况是为库提供解释器，它们能够自我解释。例如，Perl 带有许多 Perl 模块，Java 实现带有许多 Java 类。这些库和调用它们的程序总是动态链接在一起。
结果是，如果您选择在程序中使用遵循 GPL 的 Perl 模块或 Java 类，则必须以与 GPL 兼容的方式发布该程序，无论结合后的 Perl 或 Java 程序所依之运行的 Perl 或 Java 解释器中使用什么样的许可证。
#### 6.14 如果编程语言解释器遵循与 GPL 不兼容的许可证，我可以在其上运行遵循 GPL 的程序吗？
当解释器解释一种语言时，答案是肯定的。被解释程序对于解释器来说只是数据；GPL 不会限制您处理程序时所使用的工具。
然而，当解释器被扩展以向<ruby> 其他程序 <rp> （ </rp> <rt> facilities </rt> <rp> ） </rp></ruby>（通常但不一定是库）提供“绑定”时，被解释程序通过这些绑定有效地与其使用的程序相关联。JNI（Java Native Interface）是此种程序的一个例子；以这种方式访问的库与调用它们的 Java 程序动态链接。
因此，如果这些程序是依据与 GPL 不兼容的许可证发布的，则情况就像以任何其他方式跟与 GPL 不兼容的库链接。这意味着：
1. 如果您正在编写代码并将其依据 GPL 发布，您可以声明一个<ruby> 明确例外 <rp> （ </rp> <rt> explicit exception </rt> <rp> ） </rp></ruby>，允许将其链接到与 GPL 不兼容的程序。
2. 如果您依据 GPL 编写并发布程序，并且专门设计了与这些程序配合使用的功能，人们可以将其作为<ruby> 隐性例外 <rp> （ </rp> <rt> implicit exception </rt> <rp> ） </rp></ruby>，允许它们与这些程序进行链接。但是，如果这只是你的打算的话，最好明确地这么说。
您不能把别人遵循 GPL 的代码用于这种方式，或者添加这样的例外。只有该代码的版权所有者才能添加例外。
#### 6.15 如果我将一个模块添加到遵循 GPL 的程序中，我必须使用 GPL 作为我的模块的许可证吗？
GPL 规定，整个结合后的程序必须依据 GPL 发布。所以你的模块必须可以依据 GPL 进行使用。
但是，您可以提供使用您代码的额外授权。如果您愿意，您可以依据比 GPL 更为宽松但与 GPL 兼容的许可证发布模块。许可证列表页面提供了与 [GPL 兼容许可证](https://www.gnu.org/licenses/license-list.html)的部分列表。
#### 6.16 什么时候程序和插件会被认为是单一的结合程序？
这取决于主程序如何调用其插件。如果主程序使用 `fork` 和 `exec` 来调用插件，并通过共享复杂的数据结构或来回传送复杂的数据结构来建立<ruby> 密切通信 <rp> （ </rp> <rt> intimate communication </rt> <rp> ） </rp></ruby>，可以使它们成为一个单一的结合程序。如果主程序使用简单的 `fork` 和 `exec` 来调用插件并且不建立它们之间的密切通信，插件被认为是一个单独的程序。
如果主程序动态地链接插件，并且它们彼此进行函数调用并共享数据结构，我们相信它们形成了一个单一的结合程序，它必须被视为主程序和插件的扩展。如果主程序动态地链接插件，但是它们之间的通信仅限于使用某些选项调用插件的“main”功能，并等待它返回，这是一种<ruby> 临界案例 <rp> （ </rp> <rt> borderline case </rt> <rp> ） </rp></ruby>。
使用共享内存与复杂数据结构进行通信几乎等同于动态链接。
#### 6.17 如果我写了一个用于遵循 GPL 程序的插件，那么对可用于分发我的插件的许可证有什么要求？
请参阅 “6.16 什么时候程序和插件会被认为是单一的结合程序 ？”以确定插件和主程序是否被视为单个结合程序，以及何时将其视为单独的作品。
如果主程序和插件是单个结合程序，则这意味着您必须依据 GPL 或与 GPL 兼容的自由软件许可证授权插件，并以符合 GPL 的方式将源代码进行分发。与其插件分开的主程序对插件没有要求。
#### 6.18 在为非自由程序编写插件时，可以应用 GPL 许可证吗？
请参阅 “6.16 什么时候程序和插件会被认为是单一的结合程序？”以确定插件和主程序是否被视为单个结合程序，以及何时被视为单独的程序。
如果它们组成单一的结合程序，这意味着遵循 GPL 的插件与非自由主程序的结合将违反 GPL。但是，您可以通过向插件的许可证添加例外声明来解决该法律问题，并允许将其与非自由主程序链接。
另请参阅正在编写的[使用非自由库的自由软件的问题](https://www.gnu.org/licenses/gpl-faq.html#FSWithNFLibs)。
#### 6.19 我可以发布一个旨在加载遵循 GPL 的插件的非自由程序吗？
请参阅 “6.16 什么时候程序和插件会被认为是单一的结合程序？”以确定插件和主程序是否被视为单个结合程序，以及何时被视为单独的程序。
如果它们组成单一的结合程序，则主程序必须依据 GPL 或与 GPL 兼容的自由软件许可证发布，并且当主程序为了与这些插件一起使用而被分发时，必须遵循 GPL 的条款。
然而，如果它们是单独的作品，则插件的许可证对主程序没有要求。
另请参阅正在编写的[使用非自由库的自由软件的问题](https://www.gnu.org/licenses/gpl-faq.html#FSWithNFLibs)。
#### 6.20 我想将遵循 GPL 的软件纳入我的专有系统。我只依据 GPL 给予我的权限来使用该软件。我可以这样做吗？（同 5.6）
您不能将遵循 GPL 的软件纳入专有系统。GPL 的目标是授予每个人复制、再分发、理解和修改程序的自由。如果您可以将遵循 GPL 的软件整合到非自由系统中，则可能会使遵循 GPL 的软件不再是自由软件。
包含遵循 GPL 程序的系统是该 GPL 程序的扩展版本。GPL 规定，如果它最终发布的话，任何扩展版本的程序必须依据 GPL 发布。这有两个原因：确保获得软件的用户获得自己应该拥有的自由，并鼓励人们回馈他们所做的改进。
但是，在许多情况下，您可以将遵循 GPL 的软件与专有系统一起分发。要有效地做到这一点，您必须确保自由和非自由程序之间的通信<ruby> 保持一定距离 <rp> （ </rp> <rt> arms length </rt> <rp> ） </rp></ruby>，而不是将它们有效地结合成一个程序。
这种情况与“纳入”遵循 GPL 的软件之间的区别，是一部分实质和一部分形式的问题。实质上是这样的：如果两个程序结合起来，使它们成为一个程序的两个部分，那么您不能将它们视为两个单独的程序。所以整个作品必须遵循 GPL。
如果这两个程序保持良好的分离，就像编译器和内核，或者像编辑器和shell一样，那么您可以将它们视为两个单独的程序，但是您必须恰当执行。这个问题只是一个形式问题：您如何描述您在做什么。为什么我们关心这个？因为我们想确保用户清楚地了解软件集合中遵循 GPL 的软件的自由状态。
如果人们分发遵循 GPL 的软件，将其称为系统（用户已知其中一部分为专有软件）的“一部分”，用户可能不确定其对遵循GPL的软件所拥有的权利。但是如果他们知道他们收到的是一个自由程序加上另外一个程序，那么他们的权利就会很清楚。
#### 6.21 我想将遵循 GPL 的软件纳入我的专有系统。我是否可以通过在 GPL 覆盖的部分和专有部分之间，放置一个遵循与 GPL 兼容的宽松许可证（如 X11 许可证）的<ruby> “封装” <rp> （ </rp> <rt> wrapper </rt> <rp> ） </rp></ruby>模块来实现？
不可以，X11 许可证与 GPL 兼容，因此您可以向遵循 GPL 的程序添加一个模块，并让其遵循 X11 许可证。但是，如果要将它们整合到一个更大的程序中，那么这个整体将包含 GPL 覆盖的部分，所以它必须在 GNU GPL 下作为一个整体获得许可。
专有模块 A 仅通过遵循 X11 许可证的模块 B 与遵循 GPL 的模块 C 通信，该事实在法律上是无关紧要的；重要的是模块 C 包含在整体作品中。
#### 6.22 我可以编写使用非自由库的自由软件吗？
如果您这样做，您的程序将无法在一个自由的环境中完全使用。如果您的程序依赖于一个非自由库来做某件工作，那么在自由软件世界里就不能做这个工作。如果这依赖于一个非自由库来运行，它不能是自由操作系统（例如 GNU）的一部分；这完全成为了自由软件世界里的禁区。
所以请考虑：你可以找到一种方法来完成这项工作，而不使用这个库吗？你可以为该库编写一个自由软件替代选择吗？
如果程序已经使用非自由库编写，那么改变决定也许已经太晚了。您也可以按照目前状态来发布程序，而不是不发布。但是请在 README 文件中提到，对非自由库的需求是一个缺点，并建议更改程序以便在没有非自由库的情况下执行相同的工作。请建议任何想要在程序上进行大量进一步工作的人首先将其从依赖非自由库中解脱出来。
请注意，将某些非自由库与遵循 GPL 的自由软件相结合也可能存在法律问题。有关更多信息，请参阅有关 [GPL 软件与和其不兼容库的问题](https://www.gnu.org/licenses/gpl-faq.html#GPLIncompatibleLibs)。
#### 6.23 我可以将遵循 GPL 的程序与专有系统库链接吗？
每个版本的 GPL 相对于其<ruby> 左版 <rp> （ </rp> <rt> copyleft </rt> <rp> ） </rp></ruby>都有一个例外，通常称为系统库例外。如果您要使用的与 GPL 不兼容的库符合系统库的标准，则使用它们不需要做特别的工作；分发整个程序的源代码的要求不包括那些库，即使您分发包含它们的链接可执行文件。
作为<ruby> “系统库” <rp> （ </rp> <rt> system library </rt> <rp> ） </rp></ruby>的标准在不同版本的 GPL 之间有所不同。GPL v3 在第 1 节中明确定义“系统库”，将其从<ruby> “相应源代码” <rp> （ </rp> <rt> Corresponding Source </rt> <rp> ） </rp></ruby>的定义中排除。GPL v2 在第 3 部分的末尾进行，处理这个问题略有不同。
#### 6.24 如果我在遵循 GPL 的软件中使用了与 GPL 不兼容的库，会出现什么法律问题？
如果您希望程序与未被系统库例外所涵盖的库链接，则需要提供许可来执行此操作。以下是您可以使用的两个许可证通知示例；一个用于 GPL v3，另一个用于 GPL v2。在这两种情况下，您应该将此文本放在您授予此权限的每个文件中。
只有该程序的版权持有人才能合法地按照这些条款发布其软件。如果您自己编写了整个程序，假设您的雇主或学校没有声明版权，您就是版权所有者，因此您可以授权该例外。但是，如果您想在代码中使用其他作者的其他遵循GPL的程序的一部分，那么您无法将例外授权给他们。您必须获得这些程序的版权所有者的批准。
当其他人修改程序时，他们不需要为他们的代码设置同样的例外——是否这样做是他们自己的选择。
如果您打算链接的库不是自由软件，请参阅[使用非自由库编写自由软件部分](https://www.gnu.org/licenses/gpl-faq.html#FSWithNFLibs)。
如果您使用 GPL v3，您可以通过在第 7 节下授予额外权限来实现此目标。以下许可证通知将会执行此操作。您必须使用适合您程序的文本替换括号中的所有文本。如果不是每个人都可以为您打算链接的库分发源代码，则应该删除大括号中的文本；否则，只需删除大括号。
>
> Copyright (C) [年份] [著作权人名称]
>
>
> 本程序为自由软件；您可以根据自由软件基金会发布的 GNU GPL 许可证的条款再分发和/或修改它；无论是依据本许可证的版本3，或（根据您的选择）任何更高版本。
>
>
> 本程序基于希望其有用的目标而分发，但**不提供任何担保**；甚至也**没有适销性或适用于特定用途的默示担保**。有关详细信息，请参阅 GNU GPL 许可证。
>
>
> 您应该已经收到本程序以及 GNU GPL 许可证的副本；如果没有，请参阅 <http://www.gnu.org/licenses>。
>
>
> 依据 GNU GPL v3 第7节的额外许可
>
>
> 如果您通过将[与库的名称]（或库的修改版本）链接或结合来修改本程序，或任何被覆盖的作品，其中包含被[库许可证的名称]的条款所覆盖的部分，则该程序的许可人授予您额外许可来传递所产出的作品。{这种结合的非源代码形式的相应源代码应包括所使用的[库名称]部分的源代码以及被覆盖的作品的源代码。}
>
>
>
如果您使用 GPL v2，您可以为许可证条款提供自己的例外。以下许可证通知将这样做。同样，您必须使用适合您程序的文本替换括号中的所有文本。如果不是每个人都可以为您打算链接的库分发源代码，则应该删除大括号中的文本；否则，只需删除大括号。
>
> Copyright (C) [年份] [著作权人名称]
>
>
> 本程序为自由软件；您可以根据自由软件基金会发布的 GNU GPL 许可证的条款再分发和/或修改它；无论是依据许可证的 v2，或（根据您的选择）任何更高版本。
>
>
> 本程序基于希望其有用的目标而分发，但**不提供任何担保**；甚至也**没有适销性或适用于特定用途的默示担保**。有关详细信息，请参阅 GNU GPL 许可证。
>
>
> 您应该已经收到本程序以及 GNU GPL 许可证的副本；如果没有，请参阅 <http://www.gnu.org/licenses>。
>
>
> 将[您的程序名称]与其他模块静态或动态链接是以[您的程序名称]为基础构建结合作品。因此，GNU GPL 许可证的条款和条件将覆盖整个结合作品。
>
>
> 另外，作为一个特殊例外，[您的程序名称]的版权持有人可以让您将[您的程序名称]与依据 GNU LGPL 发布的自由程序或库以及依据[库的许可证名称]标准发布的[库名称]中包含的代码相结合（或具有相同许可证的此类代码的修改版本）。您可以按照[您的程序名称]所依据的 GNU GPL 的条款和其他有关代码的许可证复制和分发此系统{前提是当 GNU GPL 要求分发源代码时将其他代码的源代码包含在内}。
>
>
> 注意，对[您的程序名称]做出修改版本的人没有义务为其修改版本授予此特殊例外；是否这样做是他们自己的选择。GNU GPL 许可证允许发布一个没有此例外的修改版本；该例外也使得发布一个带有该例外的修改版本成为可能。
>
>
>
#### 6.25 我正在使用 Microsoft Visual C ++（或 Visual Basic）编写 Windows 应用程序，我将依据 GPL 发布它。依据GPL，是否允许将我的程序与 Visual C ++（或 Visual Basic）运行时库动态链接？
您可以将您的程序链接到这些库，并将编译后的程序分发给其他程序。执行此操作时，运行时库是 GPL v3 所定义的“系统库”。这意味着您不需要担心将库的源代码包含在程序的相应源代码中。GPL v2 在第 3 节中提供了类似的例外。
您可能不会随同您的程序以编译后的 DLL 形式分发这些库。为了防止不道德的分发者试图将系统库例外作为漏洞进行利用，GPL 表示，只有库不与程序本身一起分发，库才能被认定为系统库。如果您随同您的程序分发 DLL，则它们将不再符合此例外的资格；那么遵守 GPL 的唯一方法就是提供它们的源代码，而您无法做到。
可以编写只在 Windows 上运行的自由程序，但这不是一个好主意。这些程序将被 Windows <ruby> <a href="https://www.gnu.org/philosophy/java-trap.html"> “围困” </a> <rp> （ </rp> <rt> trapped </rt> <rp> ） </rp></ruby>，因此对自由软件世界的贡献为零。
#### 6.26 我想修改遵循 GPL 的程序，并将它们与 Money Guzzler Inc. 的可移植性库链接。我无法分发这些库的源代码，因此，任何想要更改这些版本的用户都必须单独获取这些库。为什么 GPL 不允许这样做？
有两个原因。第一、一般性的原因。如果我们允许 A 公司制作一个专有文件，B 公司分发与该文件相关的遵循 GPL 的软件，其效果等同于将 GPL 撕开一个大洞。对于保持 GPL 软件各种修改和扩展的源代码来说，这如同一张署名空白纸。
让所有用户能够访问源代码是我们的主要目标之一，所以这个结果绝对是我们想要避免的。
更具体地说，根据我们对条款的理解，与 Money Guzzler 库链接的程序版本不会是真正的自由软件——它们不会附带完整的让用户能够更改和重新编译程序的源代码。
#### 6.27 如果模块 Q 的许可证具有与 GPL 不兼容的要求，但是只有当 Q 自身分发时，而不是在较大程序中包含 Q 时，该要求才适用，是否可以使得该许可证与 GPL 兼容？可以将 Q 与遵循 GPL 的程序结合使用吗？
如果程序 P 依据 GPL 被发布，这意味着“任何和所有部分”都可以依据 GPL 进行使用。如果您集成了模块 Q，并依据 GPL 发布结合程序 P + Q，则表示可以依据 GPL 使用 P + Q 的任何部分。P + Q 的一部分是 Q，所以依据 GPL 发布 P + Q 意味着，Q 的任何部分可以依据 GPL 进行使用。换句话说，依据 GPL 获得 P + Q 的用户可以删除 P，所以 Q 仍然遵循 GPL。
如果模块 Q 的许可证允许您授予该许可，则其与 GPL 兼容。否则，它不与 GPL 兼容。
如果 Q 的许可证在不明确的条件下表示，您必须在自己再分发 Q 时做某些事情（与 GPL 不兼容），那么不允许您依据 GPL 分发Q。因此，您也不能依据 GPL 发布 P + Q。所以您不能将 P 与 Q 进行链接或结合。
#### 6.28 在面向对象的语言（如 Java）中，如果我在不修改的情况下使用遵循 GPL 的类，并对其进行子类化，GPL 会以什么方式影响较大的程序？
子类化将会创建衍生作品。因此，当您创建遵循 GPL 的类的子类时，GPL 的条款会影响整个程序。
#### 6.29 分发一个意图链接到 Linux 内核的非自由驱动程序会违反 GPL 吗？
Linux（GNU / Linux 操作系统中的内核）依据 GNU GPL v2 进行分发。分发一个意图链接 Linux 的非自由驱动程序违反 GPL 吗？
是的，这是一种违规行为，因为这样做形成了更大的结合作品。用户期望把这些片段放在一起的事实并不会改变任何事情。
在代码实体部分拥有版权的 Linux 的每个贡献者都可以执行 GPL，我们鼓励他们对那些分发非自由 Linux 驱动程序的人采取行动。
#### 6.30 如何允许在受控接口下将专有模块与我的 GPL 库链接起来？
在声明该文件依据 GNU GPL 进行分发的文本末尾，将以下文本添加到软件包中每个文件的许可证通知中：
>
> 将 ABC 与其他模块静态或动态链接是基于 ABC 创建结合作品。因此，GNU GPL 许可证的条款和条件将覆盖整个结合作品。
>
>
> 作为一个特殊的例外，ABC 的版权所有者可以将 ABC 程序与自由软件程序或依据 GNU LGPL 发布的库以及通过 ABCDEF 界面与 ABC 通信的独立模块相结合。您可以根据 ABC 的 GNU GPL 条款和其他代码的许可证复制和分发此系统，前提是您在 GNU GPL 需要分发源代码时提供该代码的源代码，并且您没有修改 ABCDEF 界面。
>
>
> 请注意，制作 ABC 修改版本的人没有义务为其修改版本授予此特殊例外；是否这样做是他们自己的选择。GNU GPL 许可证允许发布不含此例外的修改版本；此例外也使得发布一个带有该例外的修改版本成为可能。如果您修改了 ABCDEF 界面，此例外不适用于您修改的 ABC 版本，并且您必须在分发修改后的版本时删除此例外。
>
>
> 此例外是依据 GNU GPL 许可证第3版（“GPL v3”）第7节的额外权限。
>
>
>
此例外允许通过指定接口（“ABCDEF”）与遵循不同许可证的模块进行链接，同时确保用户仍然会按照 GPL 通常的方式接收源代码。
只有该程序的版权持有者才能合法授权此例外。如果您自己编写了整个程序，假设您的雇主或学校没有声明版权，您就是版权所有者，因此您可以授权该例外。但是，如果您想在代码中使用其他作者的其他遵循 GPL 程序的一部分，那么您无法对他们的例外进行授权。您必须获得这些程序的版权所有者的批准。
#### 6.31 考虑这种情况：1）X 发布遵循 GPL 的项目的 V1 版本。2）基于对 V1 的修改和新代码开发，Y 对 V2 的改进做出贡献。3）X 想将 V2 转换为非 GPL 许可证。X 需要 Y 的许可吗？
需要。Y 需要依据 GNU GPL 发布其版本，因为它基于 X 的版本 V1。没有任何要求规定 Y 为其代码适用任何其他许可。因此，X 必须获得 Y 的许可才能依据另一个许可证发布该代码。
#### 6.32 我已经编写了一个与许多不同组件链接的应用程序，它们具有不同的许可证。我对我的程序有什么许可要求感到很困惑。您能告诉我可以使用哪些许可证吗？
为了回答这个问题，我们需要看一下你的程序使用的每个组件的列表，该组件的许可证和一个简短的（几句话应该足够）说明你的库如何使用该组件的描述。两个例子是：
* 为了让我的软件工作，它必须链接到遵循 LGPL 的 FOO 库。
* 我的软件进行系统调用（使用我建立的命令行）来运行 BAR 程序，该程序遵循 GPL，“具有允许与 QUUX 链接的特殊例外”。
#### 6.33 可以在依据与 GPL 不兼容的许可证进行许可的文档中使用遵循 GPL 的源代码片段吗？
如果片段足够小，依据“合理使用”或类似的法律，您可以将它们纳入其中，那么可以。否则，不可以。
---
译者介绍：薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO 分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
如何在 Fedora 上安装 Pipenv
|
Michal Cyprian
|
https://fedoramagazine.org/install-pipenv-fedora/
|
Pipenv 的目标是将打包界（bundler、composer、npm、cargo、yarn 等）最好的东西带到 Python 世界来。它试图解决一些问题，并简化整个管理过程。
|
/data/attachment/album/201807/11/150156gtptutmuktkpo85p.jpg.thumb.jpg
|
/data/attachment/album/201807/11/150156gtptutmuktkpo85p.jpg
| true | false | true |
geekpi
| false |
[
"Pipenv",
"Python"
] |
技术
|
{
"viewnum": 4682,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Pipenv 的目标是将打包界（bundler、composer、npm、cargo、yarn 等）最好的东西带到 Python 世界来。它试图解决一些问题，并简化整个管理过程。
| 2018-07-11T15:01:52 | 2018-07-11T15:01:52 | 9,827 |
/article-9827-1.html
|
Pipenv 的目标是将打包界（bundler、composer、npm、cargo、yarn 等）最好的东西带到 Python 世界来。它试图解决一些问题，并简化整个管理过程。
目前，Python 程序依赖项的管理有时似乎是一个挑战。开发人员通常为每个新项目创建一个[虚拟环境](https://packaging.python.org/tutorials/installing-packages/#creating-virtual-environments)，并使用 [pip](https://developer.fedoraproject.org/tech/languages/python/pypi-installation.html) 将依赖项安装到其中。此外，他们必须将已安装的软件包的集合保存到 `requirements.txt` 文件中。我们看到过许多旨在自动化此工作流程的工具和包装程序。但是，仍然需要结合多个程序，并且 `requirements.txt` 格式本身并不适用于更复杂的场景。
### 一个统治它们的工具
Pipenv 可以正确地管理复杂的相互依赖关系，它还提供已安装包的手动记录。例如，开发、测试和生产环境通常需要一组不同的包。过去，每个项目需要维护多个 `requirements.txt`。Pipenv 使用 [TOML](https://github.com/toml-lang/toml) 语法引入了新的 [Pipfile](https://github.com/pypa/pipfile) 格式。多亏这种格式，你终于可以在单个文件中维护不同环境的多组需求。
在将第一行代码提交到项目中仅一年后，Pipenv 已成为管理 Python 程序依赖关系的官方推荐工具。现在它终于在 Fedora 仓库中提供。
### 在 Fedora 上安装 Pipenv
在全新安装 Fedora 28 及更高版本后，你只需在终端上运行此命令即可安装 Pipenv：
```
$ sudo dnf install pipenv
```
现在，你的系统已准备好在 Pipenv 的帮助下开始使用新的 Python 3 程序。
重要的是，虽然这个工具为程序提供了很好的解决方案，但它并不是为处理库需求而设计的。编写 Python 库时，不需要固定依赖项。你应该在 `setup.py` 文件中指定 `install_requires`。
### 基本依赖管理
首先为项目创建一个目录：
```
$ mkdir new-project && cd new-project
```
接下来是为此项目创建虚拟环境：
```
$ pipenv --three
```
这里的 `-three` 选项将虚拟环境的 Python 版本设置为 Python 3。
安装依赖项：
```
$ pipenv install requests
Installing requests…
Adding requests to Pipfile's [packages]…
Pipfile.lock not found, creating…
Locking [dev-packages] dependencies…
Locking [packages] dependencies…
```
最后生成 lockfile：
```
$ pipenv lock
Locking [dev-packages] dependencies…
Locking [packages] dependencies…
Updated Pipfile.lock (b14837)
```
你还可以检查依赖关系图：
```
$ pipenv graph
- certifi [required: >=2017.4.17, installed: 2018.4.16]
- chardet [required: <3.1.0,>=3.0.2, installed: 3.0.4]
- idna [required: <2.8,>=2.5, installed: 2.7]
- urllib3 [required: >=1.21.1,<1.24, installed: 1.23]
```
有关 Pipenv 及其命令的更多详细信息，请参见[文档](https://docs.pipenv.org/)。
---
via: <https://fedoramagazine.org/install-pipenv-fedora/>
作者：[Michal Cyprian](https://fedoramagazine.org/author/mcyprian/) 选题：[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/) 荣誉推出
|
||
你应该了解的 6 个开源 AI 工具
|
Sam Dean
|
https://www.linux.com/blog/2018/6/6-open-source-ai-tools-know
|
让我们来看看几个任何人都能用的自由开源的 AI 工具。
|
/data/attachment/album/201807/12/102642bb79nfs178o7dd1m.jpg.thumb.jpg
|
/data/attachment/album/201807/12/102642bb79nfs178o7dd1m.jpg
| true | false | true |
qhwdw
| false |
[
"AI"
] |
技术
|
{
"viewnum": 7127,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
让我们来看看几个任何人都能用的自由开源的 AI 工具。
| 2018-07-12T10:00:00 | 2018-07-12T10:00:00 | 9,828 |
/article-9828-1.html
|
>
> 让我们来看看几个任何人都能用的自由开源的 AI 工具。
>
>
>
在开源领域，不管你的想法是多少的新颖独到，先去看一下别人是否已经做成了这个概念，总是一个很明智的做法。对于有兴趣借助不断成长的<ruby> 人工智能 <rt> Artificial Intelligence </rt></ruby>（AI）的力量的组织和个人来说，许多优秀的工具不仅是自由开源的，而且在很多的情况下，它们都已经过测试和久经考验的。
在领先的公司和非盈利组织中，AI 的优先级都非常高，并且这些公司和组织都开源了很有价值的工具。下面的举例是任何人都可以使用的自由开源的 AI 工具。
### Acumos
[Acumos AI](https://www.acumos.org/) 是一个平台和开源框架，使用它可以很容易地去构建、共享和分发 AI 应用。它规范了运行一个“开箱即用的”通用 AI 环境所需要的<ruby> 基础设施栈 <rt> infrastructure stack </rt></ruby>和组件。这使得数据科学家和模型训练者可以专注于它们的核心竞争力，而不用在无止境的定制、建模，以及训练一个 AI 实现上浪费时间。
Acumos 是 [LF 深度学习基金会](https://www.linuxfoundation.org/projects/deep-learning/) 的一部分，它是 Linux 基金会中的一个组织，它支持在人工智能、<ruby> 机器学习 <rt> machine learning </rt></ruby>、以及<ruby> 深度学习 <rt> deep learning </rt></ruby>方面的开源创新。它的目标是让这些重大的新技术可用于开发者和数据科学家，包括那些在深度学习和 AI 上经验有限的人。LF 深度学习基金会 [最近批准了一个项目生命周期和贡献流程](https://www.linuxfoundation.org/blog/lf-deep-learning-foundation-announces-project-contribution-process/)，并且它现在正接受项目贡献的建议。
### Facebook 的框架
Facebook [开源了](https://code.facebook.com/posts/1687861518126048/facebook-to-open-source-ai-hardware-design/) 其中心机器学习系统，它设计用于做一些大规模的人工智能任务，以及一系列其它的 AI 技术。这个工具是经过他们公司验证使用的平台的一部分。Facebook 也开源了一个叫 [Caffe2](https://venturebeat.com/2017/04/18/facebook-open-sources-caffe2-a-new-deep-learning-framework/) 的深度学习和人工智能的框架。
### CaffeOnSpark
**说到 Caffe**。 Yahoo 也在开源许可证下发布了它自己的关键的 AI 软件。[CaffeOnSpark 工具](http://yahoohadoop.tumblr.com/post/139916563586/caffeonspark-open-sourced-for-distributed-deep) 是基于深度学习的，它是人工智能的一个分支，在帮助机器识别人类语言，或者照片、视频的内容方面非常有用。同样地，IBM 的机器学习程序 [SystemML](https://systemml.apache.org/) 可以通过 Apache 软件基金会自由地共享和修改。
### Google 的工具
Google 花费了几年的时间开发了它自己的 [TensorFlow](https://www.tensorflow.org/) 软件框架，用于去支持它的 AI 软件和其它预测和分析程序。TensorFlow 是你可能都已经在使用的一些 Google 工具背后的引擎，包括 Google Photos 和在 Google app 中使用的语言识别。
Google 开源了两个 [AIY 套件](https://www.techradar.com/news/google-assistant-sweetens-raspberry-pi-with-ai-voice-control)，它可以让个人很容易地使用人工智能，它们专注于计算机视觉和语音助理。这两个套件将用到的所有组件封装到一个盒子中。该套件目前在美国的 Target 中有售，并且它是基于开源的树莓派平台的 —— 有越来越多的证据表明，在开源和 AI 交集中将发生非常多的事情。
### H2O.ai
我 [以前介绍过](https://www.linux.com/news/sparkling-water-bridging-open-source-machine-learning-and-apache-spark) H2O.ai，它在机器学习和人工智能领域中占有一席之地，因为它的主要工具是自由开源的。你可以获取主要的 H2O 平台和 Sparkling Water，它与 Apache Spark 一起工作，只需要去 [下载](http://www.h2o.ai/download) 它们即可。这些工具遵循 Apache 2.0 许可证，它是一个非常灵活的开源许可证，你甚至可以在 Amazon Web 服务（AWS）和其它的集群上运行它们，而这仅需要几百美元而已。
### Microsoft 入局
“我们的目标是让 AI 大众化，让每个人和组织获得更大的成就，“ Microsoft CEO 萨提亚·纳德拉 [说](https://blogs.msdn.microsoft.com/uk_faculty_connection/2017/02/10/microsoft-cognitive-toolkit-cntk/)。因此，微软持续迭代它的 [Microsoft Cognitive Toolkit](https://www.microsoft.com/en-us/cognitive-toolkit/)（CNTK）。它是一个能够与 TensorFlow 和 Caffe 去竞争的一个开源软件框架。Cognitive Toolkit 可以工作在 64 位的 Windows 和 Linux 平台上。
Cognitive Toolkit 团队的报告称，“Cognitive Toolkit 通过允许用户去创建、训练，以及评估他们自己的神经网络，以使企业级的、生产系统级的 AI 成为可能，这些神经网络可能跨多个 GPU 以及多个机器在大量的数据集中高效伸缩。”
---
从来自 Linux 基金会的新电子书中学习更多的有关 AI 知识。Ibrahim Haddad 的 [开源 AI：项目、洞察和趋势](https://www.linuxfoundation.org/publications/open-source-ai-projects-insights-and-trends/) 调查了 16 个流行的开源 AI 项目—— 深入研究了他们的历史、代码库、以及 GitHub 的贡献。 [现在可以免费下载这个电子书](https://www.linuxfoundation.org/publications/open-source-ai-projects-insights-and-trends/)。
---
via: <https://www.linux.com/blog/2018/6/6-open-source-ai-tools-know>
作者：[Sam Dean](https://www.linux.com/users/sam-dean) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[pityonline](https://github.com/pityonline), [wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 命令行中自定义文本颜色
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3269587/linux/customizing-your-text-colors-on-the-linux-command-line.html
|
在 Linux 命令行当中使用不同颜色以期提供一种根据文件类型来识别文件的简单方式。你可以修改这些颜色，但是在做之前应该对你做的事情有充分的理由。
|
/data/attachment/album/201807/12/105947xztc1kpcvv8o9izn.jpg.thumb.jpg
|
/data/attachment/album/201807/12/105947xztc1kpcvv8o9izn.jpg
| true | false | true |
MjSeven
| false |
[
"终端",
"颜色"
] |
技术
|
{
"viewnum": 9955,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在 Linux 命令行当中使用不同颜色以期提供一种根据文件类型来识别文件的简单方式。你可以修改这些颜色，但是在做之前应该对你做的事情有充分的理由。
| 2018-07-12T10:59:00 | 2018-07-12T10:59:00 | 9,829 |
/article-9829-1.html
|
>
> 在 Linux 命令行当中使用不同颜色以期提供一种根据文件类型来识别文件的简单方式。你可以修改这些颜色，但是在做之前应该对你做的事情有充分的理由。
>
>
>
如果你在 Linux 命令行上花费了大量的时间（如果没有，那么你可能不会读这篇文章），你无疑注意到了 `ls` 以多种不同的颜色显示文件。你可能也注意到了一些区别 —— 目录是一种颜色，可执行文件是另一种颜色等等。
这一切是如何发生的呢？以及，你可以选择哪些选项来改变颜色分配可能就不是很多人都知道的。
一种方法是运行 `dircolors` 命令得到一大堆展示了如何指定这些颜色的数据。它会显示以下这些东西：
```
$ dircolors
LS_COLORS='rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do
=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=00:su=37;41:sg
=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01
;31:*.tgz=01;31:*.arc=01;31:*.arj=01;31:*.taz=01;31:*.lha=01
;31:*.lz4=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=0
1;31:*.tzo=01;31:*.t7z=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31
:*.dz=01;31:*.gz=01;31:*.lrz=01;31:*.lz=01;31:*.lzo=01;31:*.
xz=01;31:*.zst=01;31:*.tzst=01;31:*.bz2=01;31:*.bz=01;31:*.t
bz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.j
ar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.a
lz=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.r
z=01;31:*.cab=01;31:*.jpg=01;35:*.jpeg=01;35:*.mjpg=01;35:*.
mjpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:
*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:
*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;3
5:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;
35:*.mkv=01;35:*.webm=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01
;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01
;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01
;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;3
5:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.ogv=01;3
5:*.ogx=01;35:*.aac=00;36:*.au=00;36:*.flac=00;36:*.m4a=00;3
6:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;
36:*.ogg=00;36:*.ra=00;36:*.wav=00;36:*.oga=00;36:*.opus=00;
36:*.spx=00;36:*.xspf=00;36:';
export LS_COLORS
```
如果你擅长解析文件，那么你可能会注意到这个列表有一种<ruby> 模式 <rt> patten </rt></ruby>。用冒号分隔开，你会看到这样的东西：
```
$ dircolors | tr ":" "\n" | head -10
LS_COLORS='rs=0
di=01;34
ln=01;36
mh=00
pi=40;33
so=01;35
do=01;35
bd=40;33;01
cd=40;33;01
or=40;31;01
```
OK，这里有一个模式 —— 一系列定义，有一到三个数字组件。我们来看看其中的一个定义。
```
pi=40;33
```
有些人可能会问的第一个问题是“pi 是什么？”在这里，我们研究的是颜色和文件类型，所以这显然不是以 3.14 开头的那个有趣的数字。当然不是，这个 “pi” 代表 “pipe（管道）” —— Linux 系统上的一种特殊类型的文件，它可以将数据从一个程序传递给另一个程序。所以，让我们建立一个管道。
```
$ mknod /tmp/mypipe p
$ ls -l /tmp/mypipe
prw-rw-r-- 1 shs shs 0 May 1 14:00 /tmp/mypipe
```
当我们在终端窗口中查看我们的管道和其他几个文件时，颜色差异非常明显。
在 `pi` 的定义中（如上所示），“40” 使文件在终端（或 PuTTY）窗口中使用黑色背景显示，31 使字体颜色变红。管道是特殊的文件，这种特殊的处理使它们在目录列表中突出显示。
`bd` 和 `cd` 定义是相同的 —— `40;33;01`，它有一个额外的设置。这个设置会导致 <ruby> 块设备 <rt> block device </rt></ruby>（bd）和 <ruby> 字符设备 <rt> character device </rt></ruby>（cd）以黑色背景，橙色字体和另一种效果显示 —— 字符将以粗体显示。
以下列表显示由<ruby> 文件类型 <rt> file type </rt></ruby>所指定的颜色和字体分配：
```
setting file type
======= =========
rs=0 reset to no color
di=01;34 directory
ln=01;36 link
mh=00 multi-hard link
pi=40;33 pipe
so=01;35 socket
do=01;35 door
bd=40;33;01 block device
cd=40;33;01 character device
or=40;31;01 orphan
mi=00 missing?
su=37;41 setuid
sg=30;43 setgid
ca=30;41 file with capability
tw=30;42 directory with sticky bit and world writable
ow=34;42 directory that is world writable
st=37;44 directory with sticky bit
ex=01;93 executable
```
你可能已经注意到，在 `dircolors` 命令输出中，我们的大多数定义都以星号开头（例如，`*.wav=00;36`）。这些按<ruby> 文件扩展名 <rt> file extension </rt></ruby>而不是文件类型定义显示属性。这有一个示例：
```
$ dircolors | tr ":" "\n" | tail -10
*.mpc=00;36
*.ogg=00;36
*.ra=00;36
*.wav=00;36
*.oga=00;36
*.opus=00;36
*.spx=00;36
*.xspf=00;36
';
export LS_COLORS
```
这些设置（上面列表中所有的 `00;36`）将使这些文件名以青色显示。可用的颜色如下所示。
### 如何改变设置
你要使用 `ls` 的别名来打开颜色显示功能。这通常是 Linux 系统上的默认设置，看起来是这样的：
```
alias ls='ls --color=auto'
```
如果要关闭字体颜色，可以运行 `unalias ls` 命令，然后文件列表将仅以默认字体颜色显示。
你可以通过修改 `$LS_COLORS` 设置和导出修改后的设置来更改文本颜色。
```
$ export LS_COLORS='rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;...
```
注意：上面的命令由于太长被截断了。
如果希望文本颜色的修改是永久性的，则需要将修改后的 `$LS_COLORS` 定义添加到一个启动文件中，例如 `.bashrc`。
### 更多关于命令行文本
你可以在 NetworkWorld 的 [2016 年 11 月](https://www.networkworld.com/article/3138909/linux/coloring-your-world-with-ls-colors.html)的帖子中找到有关文本颜色的其他信息。
---
via: <https://www.networkworld.com/article/3269587/linux/customizing-your-text-colors-on-the-linux-command-line.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[pityonline](https://github.com/pityonline)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
无密码验证：客户端
|
Nicolás Parada
|
https://nicolasparada.netlify.com/posts/passwordless-auth-client/
|
上一篇文章中，我们用 Go 写了一个 HTTP 服务，用这个服务来做无密码验证 API。今天，我们为它再写一个 JavaScript 客户端。
|
/data/attachment/album/201807/12/114131efzt9yrb5ggd93yr.jpg.thumb.jpg
|
/data/attachment/album/201807/12/114131efzt9yrb5ggd93yr.jpg
| true | false | true |
qhwdw
| false |
[
"无密码",
"验证"
] |
软件开发
|
{
"viewnum": 4517,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9748,
"displayorder": 0
},
{
"raid": 9815,
"displayorder": 1
}
] |
上一篇文章中，我们用 Go 写了一个 HTTP 服务，用这个服务来做无密码验证 API。今天，我们为它再写一个 JavaScript 客户端。
| 2018-07-12T11:41:37 | 2018-07-12T11:41:37 | 9,830 |
/article-9830-1.html
|
我们继续 [无密码验证](/article-9748-1.html) 的文章。上一篇文章中，我们用 Go 写了一个 HTTP 服务，用这个服务来做无密码验证 API。今天，我们为它再写一个 JavaScript 客户端。
我们将使用 [这里的](/article-9815-1.html) 这个单页面应用程序（SPA）来展示使用的技术。如果你还没有读过它，请先读它。
记住流程：
* 用户输入其 email。
* 用户收到一个带有魔法链接的邮件。
* 用户点击该链接、
* 用户验证成功。
对于根 URL（`/`），我们将根据验证的状态分别使用两个不同的页面：一个是带有访问表单的页面，或者是已验证通过的用户的欢迎页面。另一个页面是验证回调的重定向页面。
### 伺服
我们将使用相同的 Go 服务器来为客户端提供服务，因此，在我们前面的 `main.go` 中添加一些路由：
```
router.Handle("GET", "/...", http.FileServer(SPAFileSystem{http.Dir("static")}))
```
```
type SPAFileSystem struct {
fs http.FileSystem
}
func (spa SPAFileSystem) Open(name string) (http.File, error) {
f, err := spa.fs.Open(name)
if err != nil {
return spa.fs.Open("index.html")
}
return f, nil
}
```
这个伺服文件放在 `static` 下，配合 `static/index.html` 作为回调。
你可以使用你自己的服务器，但是你得在服务器上启用 [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS)。
### HTML
我们来看一下那个 `static/index.html` 文件。
```
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Passwordless Demo</title>
<link rel="shortcut icon" href="data:,">
<script src="/js/main.js" type="module"></script>
</head>
<body></body>
</html>
```
单页面应用程序的所有渲染由 JavaScript 来完成，因此，我们使用了一个空的 body 部分和一个 `main.js` 文件。
我们将使用 [上篇文章](/article-9815-1.html) 中的 Router。
### 渲染
现在，我们使用下面的内容来创建一个 `static/js/main.js` 文件：
```
import Router from 'https://unpkg.com/@nicolasparada/router'
import { isAuthenticated } from './auth.js'
const router = new Router()
router.handle('/', guard(view('home')))
router.handle('/callback', view('callback'))
router.handle(/^\//, view('not-found'))
router.install(async resultPromise => {
document.body.innerHTML = ''
document.body.appendChild(await resultPromise)
})
function view(name) {
return (...args) => import(`/js/pages/${name}-page.js`)
.then(m => m.default(...args))
}
function guard(fn1, fn2 = view('welcome')) {
return (...args) => isAuthenticated()
? fn1(...args)
: fn2(...args)
}
```
与上篇文章不同的是，我们实现了一个 `isAuthenticated()` 函数和一个 `guard()` 函数，使用它去渲染两种验证状态的页面。因此，当用户访问 `/` 时，它将根据用户是否通过了验证来展示主页或者是欢迎页面。
### 验证
现在，我们来编写 `isAuthenticated()` 函数。使用下面的内容来创建一个 `static/js/auth.js` 文件：
```
export function getAuthUser() {
const authUserItem = localStorage.getItem('auth_user')
const expiresAtItem = localStorage.getItem('expires_at')
if (authUserItem !== null && expiresAtItem !== null) {
const expiresAt = new Date(expiresAtItem)
if (!isNaN(expiresAt.valueOf()) && expiresAt > new Date()) {
try {
return JSON.parse(authUserItem)
} catch (_) { }
}
}
return null
}
export function isAuthenticated() {
return localStorage.getItem('jwt') !== null && getAuthUser() !== null
}
```
当有人登入时，我们将保存 JSON 格式的 web 令牌、它的过期日期，以及在 `localStorage` 上的当前已验证用户。这个模块就是这个用处。
* `getAuthUser()` 用于从 `localStorage` 获取已认证的用户，以确认 JSON 格式的 Web 令牌没有过期。
* `isAuthenticated()` 在前面的函数中用于去检查它是否没有返回 `null`。
### 获取
在继续这个页面之前，我将写一些与服务器 API 一起使用的 HTTP 工具。
我们使用以下的内容去创建一个 `static/js/http.js` 文件：
```
import { isAuthenticated } from './auth.js'
function get(url, headers) {
return fetch(url, {
headers: Object.assign(getAuthHeader(), headers),
}).then(handleResponse)
}
function post(url, body, headers) {
return fetch(url, {
method: 'POST',
headers: Object.assign(getAuthHeader(), { 'content-type': 'application/json' }, headers),
body: JSON.stringify(body),
}).then(handleResponse)
}
function getAuthHeader() {
return isAuthenticated()
? { authorization: `Bearer ${localStorage.getItem('jwt')}` }
: {}
}
export async function handleResponse(res) {
const body = await res.clone().json().catch(() => res.text())
const response = {
statusCode: res.status,
statusText: res.statusText,
headers: res.headers,
body,
}
if (!res.ok) {
const message = typeof body === 'object' && body !== null && 'message' in body
? body.message
: typeof body === 'string' && body !== ''
? body
: res.statusText
const err = new Error(message)
throw Object.assign(err, response)
}
return response
}
export default {
get,
post,
}
```
这个模块导出了 `get()` 和 `post()` 函数。它们是 `fetch` API 的封装。当用户是已验证的，这二个函数注入一个 `Authorization: Bearer <token_here>` 头到请求中；这样服务器就能对我们进行身份验证。
### 欢迎页
我们现在来到欢迎页面。用如下的内容创建一个 `static/js/pages/welcome-page.js` 文件：
```
const template = document.createElement('template')
template.innerHTML = `
<h1>Passwordless Demo</h1>
<h2>Access</h2>
<form id="access-form">
<input type="email" placeholder="Email" autofocus required>
<button type="submit">Send Magic Link</button>
</form>
`
export default function welcomePage() {
const page = template.content.cloneNode(true)
page.getElementById('access-form')
.addEventListener('submit', onAccessFormSubmit)
return page
}
```
这个页面使用一个 `HTMLTemplateElement` 作为视图。这只是一个输入用户 email 的简单表单。
为了避免干扰，我将跳过错误处理部分，只是将它们输出到控制台上。
现在，我们来写 `onAccessFormSubmit()` 函数。
```
import http from '../http.js'
function onAccessFormSubmit(ev) {
ev.preventDefault()
const form = ev.currentTarget
const input = form.querySelector('input')
const email = input.value
sendMagicLink(email).catch(err => {
console.error(err)
if (err.statusCode === 404 && wantToCreateAccount()) {
runCreateUserProgram(email)
}
})
}
function sendMagicLink(email) {
return http.post('/api/passwordless/start', {
email,
redirectUri: location.origin + '/callback',
}).then(() => {
alert('Magic link sent. Go check your email inbox.')
})
}
function wantToCreateAccount() {
return prompt('No user found. Do you want to create an account?')
}
```
它对 `/api/passwordless/start` 发起了 POST 请求，请求体中包含 `email` 和 `redirectUri`。在本例中它返回 `404 Not Found` 状态码时，我们将创建一个用户。
```
function runCreateUserProgram(email) {
const username = prompt("Enter username")
if (username === null) return
http.post('/api/users', { email, username })
.then(res => res.body)
.then(user => sendMagicLink(user.email))
.catch(console.error)
}
```
这个用户创建程序，首先询问用户名，然后使用 email 和用户名做一个 `POST` 请求到 `/api/users`。成功之后，给创建的用户发送一个魔法链接。
### 回调页
这是访问表单的全部功能，现在我们来做回调页面。使用如下的内容来创建一个 `static/js/pages/callback-page.js` 文件：
```
import http from '../http.js'
const template = document.createElement('template')
template.innerHTML = `
<h1>Authenticating you</h1>
`
export default function callbackPage() {
const page = template.content.cloneNode(true)
const hash = location.hash.substr(1)
const fragment = new URLSearchParams(hash)
for (const [k, v] of fragment.entries()) {
fragment.set(decodeURIComponent(k), decodeURIComponent(v))
}
const jwt = fragment.get('jwt')
const expiresAt = fragment.get('expires_at')
http.get('/api/auth_user', { authorization: `Bearer ${jwt}` })
.then(res => res.body)
.then(authUser => {
localStorage.setItem('jwt', jwt)
localStorage.setItem('auth_user', JSON.stringify(authUser))
localStorage.setItem('expires_at', expiresAt)
location.replace('/')
})
.catch(console.error)
return page
}
```
请记住……当点击魔法链接时，我们会来到 `/api/passwordless/verify_redirect`，它将把我们重定向到重定向 URI，我们将放在哈希中的 JWT 和过期日期传递给 `/callback`。
回调页面解码 URL 中的哈希，提取这些参数去做一个 `GET` 请求到 `/api/auth_user`，用 JWT 保存所有数据到 `localStorage` 中。最后，重定向到主页面。
### 主页
创建如下内容的 `static/pages/home-page.js` 文件：
```
import { getAuthUser } from '../auth.js'
export default function homePage() {
const authUser = getAuthUser()
const template = document.createElement('template')
template.innerHTML = `
<h1>Passwordless Demo</h1>
<p>Welcome back, ${authUser.username}
```
|
||
Mesos 和 Kubernetes：不是竞争者
|
Swapnil Bhartiya
|
https://www.linux.com/blog/2018/6/mesos-and-kubernetes-its-not-competition
|
人们经常用 x 相对于 y 这样的术语来考虑问题，但是它并不是一个技术对另一个技术的问题。Ben Hindman 在这里解释了 Mesos 是如何对另外一种技术进行补充的。
|
/data/attachment/album/201807/13/121145qs151ol13s2f4os8.jpg.thumb.jpg
|
/data/attachment/album/201807/13/121145qs151ol13s2f4os8.jpg
| true | false | true |
qhwdw
| false |
[
"Mesos",
"Kubernetes",
"容器"
] |
观点
|
{
"viewnum": 5421,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
人们经常用 x 相对于 y 这样的术语来考虑问题，但是它并不是一个技术对另一个技术的问题。Ben Hindman 在这里解释了 Mesos 是如何对另外一种技术进行补充的。
| 2018-07-13T12:11:40 | 2018-07-13T12:11:40 | 9,831 |
/article-9831-1.html
|
>
> 人们经常用 x 相对于 y 这样的术语来考虑问题，但是它并不是一个技术对另一个技术的问题。Ben Hindman 在这里解释了 Mesos 是如何对另外一种技术进行补充的。
>
>
>
Mesos 的起源可以追溯到 2009 年，当时，Ben Hindman 还是加州大学伯克利分校研究并行编程的博士生。他们在 128 核的芯片上做大规模的并行计算，以尝试去解决多个问题，比如怎么让软件和库在这些芯片上运行更高效。他与同学们讨论能否借鉴并行处理和多线程的思想，并将它们应用到集群管理上。
Hindman 说 “最初，我们专注于大数据” 。那时，大数据非常热门，而 Hadoop 就是其中的一个热门技术。“我们发现，人们在集群上运行像 Hadoop 这样的程序与运行多线程应用及并行应用很相似。”Hindman 说。
但是，它们的效率并不高，因此，他们开始去思考，如何通过集群管理和资源管理让它们运行的更好。“我们查看了那个时期很多的各种技术” Hindman 回忆道。
然后，Hindman 和他的同事们决定去采用一种全新的方法。“我们决定对资源管理创建一个低级的抽象，然后在此之上运行调度服务和做其它的事情。” Hindman 说，“基本上，这就是 Mesos 的本质 —— 将资源管理部分从调度部分中分离出来。”
他成功了，并且 Mesos 从那时开始强大了起来。
### 将项目呈献给 Apache
这个项目发起于 2009 年。在 2010 年时，团队决定将这个项目捐献给 Apache 软件基金会（ASF）。它在 Apache 孵化，并于 2013 年成为顶级项目（TLP）。
为什么 Mesos 社区选择 Apache 软件基金会有很多的原因，比如，Apache 许可证，以及基金会已经拥有了一个充满活力的其它此类项目的社区。
与影响力也有关系。许多在 Mesos 上工作的人也参与了 Apache，并且许多人也致力于像 Hadoop 这样的项目。同时，来自 Mesos 社区的许多人也致力于其它大数据项目，比如 Spark。这种交叉工作使得这三个项目 —— Hadoop、Mesos，以及 Spark —— 成为 ASF 的项目。
与商业也有关系。许多公司对 Mesos 很感兴趣，并且开发者希望它能由一个中立的机构来维护它，而不是让它成为一个私有项目。
### 谁在用 Mesos？
更好的问题应该是，谁不在用 Mesos？从 Apple 到 Netflix 每个都在用 Mesos。但是，Mesos 也面临任何技术在早期所面对的挑战。“最初，我要说服人们，这是一个很有趣的新技术。它叫做‘容器’，因为它不需要使用虚拟机” Hindman 说。
从那以后，这个行业发生了许多变化，现在，只要与别人聊到基础设施，必然是从”容器“开始的 —— 感谢 Docker 所做出的工作。今天再也不需要做说服工作了，而在 Mesos 出现的早期，前面提到的像 Apple、Netflix，以及 PayPal 这样的公司。他们已经知道了容器替代虚拟机给他们带来的技术优势。“这些公司在容器成为一种现象之前，已经明白了容器的价值所在”， Hindman 说。
可以在这些公司中看到，他们有大量的容器而不是虚拟机。他们所做的全部工作只是去管理和运行这些容器，并且他们欣然接受了 Mesos。在 Mesos 早期就使用它的公司有 Apple、Netflix、PayPal、Yelp、OpenTable 和 Groupon。
“大多数组织使用 Mesos 来运行各种服务” Hindman 说，“但也有些公司用它做一些非常有趣的事情，比如，数据处理、数据流、分析任务和应用程序。“
这些公司采用 Mesos 的其中一个原因是，资源管理层之间有一个明晰的界线。当公司运营容器的时候，Mesos 为他们提供了很好的灵活性。
“我们尝试使用 Mesos 去做的一件事情是去创建一个层，以让使用者享受到我们的层带来的好处，当然也可以在它之上创建任何他们想要的东西，” Hindman 说。 “我认为这对一些像 Netflix 和 Apple 这样的大公司非常有用。”
但是，并不是每个公司都是技术型的公司；不是每个公司都有或者应该有这种专长。为帮助这样的组织，Hindman 联合创建了 Mesosphere 去围绕 Mesos 提供服务和解决方案。“我们最终决定，为这样的组织去构建 DC/OS，它不需要技术专长或者不想把时间花费在像构建这样的事情上。”
### Mesos vs. Kubernetes?
人们经常用 x 相对于 y 这样的术语来考虑问题，但是它并不是一个技术对另一个技术的问题。大多数的技术在一些领域总是重叠的，并且它们可以是互补的。“我不喜欢将所有的这些东西都看做是竞争者。我认为它们中的一些与另一个在工作中是互补的，” Hindman 说。
“事实上，名字 Mesos 表示它处于 ‘中间’；它是一种中间的操作系统”， Hindman 说，“我们有一个容器调度器的概念，它能够运行在像 Mesos 这样的东西之上。当 Kubernetes 刚出现的时候，我们实际上在 Mesos 的生态系统中接受了它，并将它看做是在 Mesos 上的 DC/OS 中运行容器的另一种方式。”
Mesos 也复活了一个名为 [Marathon](https://mesosphere.github.io/marathon/)（一个用于 Mesos 和 DC/OS 的容器编排器）的项目，它成为了 Mesos 生态系统中最重要的成员。但是，Marathon 确实无法与 Kubernetes 相比较。“Kubernetes 比 Marathon 做的更多，因此，你不能将它们简单地相互交换，” Hindman 说，“与此同时，我们在 Mesos 中做了许多 Kubernetes 中没有的东西。因此，这些技术之间是互补的。”
不要将这些技术视为相互之间是敌对的关系，它们应该被看做是对行业有益的技术。它们不是技术上的重复；它们是多样化的。据 Hindman 说，“对于开源领域的终端用户来说，这可能会让他们很困惑，因为他们很难去知道哪个技术适用于哪种任务，但这是这个被称之为开源的本质所在。“
这只是意味着有更多的选择，并且每个都是赢家。
---
via: <https://www.linux.com/blog/2018/6/mesos-and-kubernetes-its-not-competition>
作者：[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/) 荣誉推出
|
||
使用 Ledger 记录（财务）情况
|
Sacha Chua
|
http://sachachua.com/blog/2014/11/keeping-financial-score-ledger/
|
自 2005 年搬到加拿大以来，我使用 Ledger CLI 来跟踪我的财务状况。
|
/data/attachment/album/201807/13/124053qclqspp9ps2tp3q4.jpg.thumb.jpg
|
/data/attachment/album/201807/13/124053qclqspp9ps2tp3q4.jpg
| true | false | true |
geekpi
| false |
[
"Ledger",
"财务"
] |
分享
|
{
"viewnum": 5200,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
自 2005 年搬到加拿大以来，我使用 Ledger CLI 来跟踪我的财务状况。
| 2018-07-13T12:40:58 | 2018-07-13T12:40:58 | 9,832 |
/article-9832-1.html
|
自 2005 年搬到加拿大以来，我使用 [Ledger CLI](http://www.ledger-cli.org/) 来跟踪我的财务状况。我喜欢纯文本的方式，它支持虚拟信封意味着我可以同时将我的银行帐户余额和我的虚拟分配到不同的目录下。以下是我们如何使用这些虚拟信封分别管理我们的财务状况。
每个月，我都有一个条目将我生活开支分配到不同的目录中，包括家庭开支的分配。W- 不要求太多， 所以我要谨慎地处理这两者之间的差别和我自己的生活费用。我们处理它的方式是我支付固定金额，这是贷记我支付的杂货。由于我们的杂货总额通常低于我预算的家庭开支，因此任何差异都会留在标签上。我过去常常给他写支票，但最近我只是支付偶尔额外的大笔费用。
这是个示例信封分配：
```
2014.10.01 * Budget
[Envelopes:Living]
[Envelopes:Household] $500
;; More lines go here
```
这是设置的信封规则之一。它鼓励我正确地分类支出。所有支出都从我的 “Play” 信封中取出。
```
= /^Expenses/
(Envelopes:Play) -1.0
```
这个为家庭支出报销 “Play” 信封，将金额从 “Household” 信封转移到 “Play” 信封。
```
= /^Expenses:House$/
(Envelopes:Play) 1.0
(Envelopes:Household) -1.0
```
我有一套定期的支出来模拟我的预算中的家庭开支。例如，这是 10 月份的。
```
2014.10.1 * House
Expenses:House
Assets:Household $-500
```
这是杂货交易的形式：
```
2014.09.28 * No Frills
Assets:Household:Groceries $70.45
Liabilities:MBNA:September $-70.45
```
接着 `ledger bal Assets:Household` 就会告诉我是否欠他钱（负余额）。如果我支付大笔费用（例如：机票、通管道），那么正常家庭开支预算会逐渐减少余额。
我从 W- 那找到了一个为我的信用卡交易添加一个月标签的技巧，他还使用 Ledger 跟踪他的交易。它允许我再次检查条目的余额，看看前一个条目是否已被正确清除。
这个资产分类使用有点奇怪，但它在精神上对我有用。
使用 Ledger 以这种方式跟踪它可以让我跟踪我们的杂货费用以及我实际支付费用和我预算费用之间的差额。如果我最终支出超出预期，我可以从更多可自由支配的信封中移动虚拟货币，因此我的预算始终保持平衡。
Ledger 是一个强大的工具。相当极客，但也许更多的工作流描述可能会帮助那些正在搞清楚它的人！
---
via: <http://sachachua.com/blog/2014/11/keeping-financial-score-ledger/>
作者：[Sacha Chua](http://sachachua.com) 选题：[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/) 荣誉推出
|
||
使用 Open edX 托管课程
|
Lawrence Mc Daniel
|
https://opensource.com/article/18/6/getting-started-open-edx
|
Open edX 为各种规模和类型的组织提供了一个强大而多功能的开源课程管理的解决方案。要不要了解一下。
|
/data/attachment/album/201807/13/130427e5auhxz8iwiw7a5a.png.thumb.jpg
|
/data/attachment/album/201807/13/130427e5auhxz8iwiw7a5a.png
| true | false | true |
qhwdw
| false |
[
"课程",
"培训"
] |
分享
|
{
"viewnum": 9503,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Open edX 为各种规模和类型的组织提供了一个强大而多功能的开源课程管理的解决方案。要不要了解一下。
| 2018-07-13T13:03:58 | 2018-07-13T13:03:58 | 9,833 |
/article-9833-1.html
|
>
> Open edX 为各种规模和类型的组织提供了一个强大而多功能的开源课程管理的解决方案。要不要了解一下。
>
>
>
[Open edX 平台](https://open.edx.org/about-open-edx) 是一个自由开源的课程管理系统，它是 [全世界](https://www.edx.org/schools-partners) 都在使用的大规模网络公开课（MOOC）以及小型课程和培训模块的托管平台。在 Open edX 的 [第七个主要发行版](https://openedx.atlassian.net/wiki/spaces/DOC/pages/11108700/Open+edX+Releases) 中，到现在为止，它已经提供了超过 8,000 个原创课程和 5000 万个课程注册数。你可以使用你自己的本地设备或者任何行业领先的云基础设施服务提供商来安装这个平台，而且，随着项目的[服务提供商](https://openedx.atlassian.net/wiki/spaces/COMM/pages/65667081/Open+edX+Service+Providers)名单越来越长，来自它们中的软件即服务（SaaS）的可用模型也越来越多了。
Open edX 平台被来自世界各地的顶尖教育机构、私人公司、公共机构、非政府组织、非营利机构，以及教育技术初创企业广泛地使用，并且该项目的服务提供商全球社区不断地让甚至更小的组织也可以访问这个平台。如果你打算向广大的读者设计和提供教育内容，你应该考虑去使用 Open edX 平台。
### 安装
安装这个软件有多种方式，这可能有点让你难以选择，至少刚开始是这样。但是不管你是以何种方式 [安装 Open edX](https://openedx.atlassian.net/wiki/spaces/OpenOPS/pages/60227779/Open+edX+Installation+Options)，最终你都得到的是有相同功能的应用程序。默认安装包含一个为在线学习者提供的、全功能的学习管理系统（LMS），和一个全功能的课程管理工作室（CMS），CMS 可以让你的讲师团队用它来编写原创课程内容。你可以把 CMS 当做是课程内容设计和管理的 “[Wordpress](https://wordpress.com/)”，把 LMS 当做是课程销售、分发、和消费的 “[Magento](https://magento.com/)”。
Open edX 是设备无关的、完全响应式的应用软件，并且不用花费很多的努力就可发布一个原生的 iOS 和 Android 应用，它可以无缝地集成到你的实例后端。Open edX 平台的代码库、原生移动应用、以及安装脚本都发布在 [GitHub](https://github.com/edx) 上。
#### 有何期望
Open edX 平台的 [GitHub 仓库](https://github.com/edx/edx-platform) 包含适用于各种类型的组织的、性能很好的、产品级的代码。来自数百个机构的数千名程序员经常为 edX 仓库做贡献，并且这个平台是一个名副其实的、研究如何去构建和管理一个复杂的企业级应用的好案例。因此，尽管你可能会遇到大量的类似“如何将平台迁移到生产环境中”的问题，但是你无需对 Open edX 平台代码库本身的质量和健状性担忧。
通过少量的培训，你的讲师就可以去设计不错的在线课程。但是请记住，Open edX 是通过它的 [XBlock](https://open.edx.org/xblocks) 组件架构进行扩展的，因此，通过他们和你的努力，你的讲师将有可能将不错的课程变成精品课程。
这个平台在单服务器环境下也运行的很好，并且它是高度模块化的，几乎可以进行无限地水平扩展。它也是主题化的和本地化的，平台的功能和外观可以根据你的需要进行几乎无限制地调整。平台在你的设备上可以按需安装并可靠地运行。
#### 需要一些封装
请记住，有大量的 edX 软件模块是不包含在默认安装中的，并且这些模块提供的经常都是各种组织所需要的功能。比如，分析模块、电商模块，以及课程的通知/公告模块都是不包含在默认安装中的，并且这些单独的模块都是值得安装的。另外，在数据备份/恢复和系统管理方面要完全依赖你自己去处理。幸运的是，有关这方面的内容，社区有越来越多的文档和如何去做的文章。你可以通过 Google 和 Bing 去搜索，以帮助你在生产环境中安装它们。
虽然有很多文档良好的程序，但是根据你的技能水平，配置 [oAuth](https://oauth.net/) 和 [SSL/TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security)，以及使用平台的 [REST API](https://en.wikipedia.org/wiki/Representational_state_transfer) 可能对你是一个挑战。另外，一些组织要求将 MySQL 和/或 MongoDB 数据库在中心化环境中管理，如果你正好是这种情况，你还需要将这些服务从默认平台安装中分离出来。edX 设计团队已经尽可能地为你做了简化，但是由于它是一个非常重大的更改，因此可能需要一些时间去实现。
如果你面临资源和/或技术上的困难 —— 不要气馁，Open edX 社区 SaaS 提供商，像 [appsembler](https://www.appsembler.com/) 和 [eduNEXT](https://www.edunext.co/)，提供了引人入胜的替代方案去进行 DIY 安装，尤其是如果你只想简单购买就行。
### 技术栈
在 Open edX 平台的安装上探索是件令人兴奋的事情，从架构的角度来说，这个项目是一个典范。应用程序模块是 [Django](https://www.djangoproject.com/) 应用，它利用了大量的开源社区的顶尖项目，包括 [Ubuntu](https://www.ubuntu.com/)、[MySQL](https://www.mysql.com/)、[MongoDB](https://www.mongodb.com/)、[RabbitMQ](https://www.rabbitmq.com/)、[Elasticsearch](https://www.elastic.co/)、[Hadoop](http://hadoop.apache.org/)、等等。
*Open edX 技术栈（CC BY，来自 edX）*
将这些组件安装并配置好本身就是一件非常不容易的事情，但是以这样的一种方式将所有的组件去打包，并适合于任意规模和复杂性的组织，并且能够按他们的需要进行任意调整搭配而无需在代码上做重大改动，看起来似乎是不可能的事情 —— 它就是这种情况，直到你看到主要的平台配置参数安排和命名是多少的巧妙和直观。请注意，平台的组织结构有一个学习曲线，但是，你所学习的一切都是值的去学习的，不仅是对这个项目，对一般意义上的大型 IT 项目都是如此。
提醒一点：这个平台的 UI 是在不断变动的，最终的目标是在 [React](%E2%80%9Chttps://reactjs.org/%E2%80%9C) 和 [Bootstrap](%E2%80%9Chttps://getbootstrap.com/%E2%80%9C) 上实现标准化。与此同时，你将会发现基本主题有多个实现的样式，这可能会让你感到困惑。
### 采用
edX 项目能够迅速得到世界范围内的采纳，很大程度上取决于该软件的运行情况。这一点也不奇怪，这个项目成功地吸引了大量才华卓越的人参与其中，他们作为程序员、项目顾问、翻译者、技术作者、以及博客作者参与了项目的贡献。一年一次的 [Open edX 会议](https://con.openedx.org/)、[官方的 edX Google Group](https://groups.google.com/forum/#!forum/openedx-ops)、以及 [Open edX 服务提供商名单](https://openedx.atlassian.net/wiki/spaces/COMM/pages/65667081/Open+edX+Service+Providers) 是了解这个多样化的、不断成长的生态系统的非常好的起点。我作为相对而言的新人，我发现参与和直接从事这个项目的各个方面是非常容易的。
祝你学习之旅一切顺利，并且当你构思你的项目时，你可以随时联系我。
---
via: <https://opensource.com/article/18/6/getting-started-open-edx>
作者：[Lawrence Mc Daniel](https://opensource.com/users/mcdaniel0073) 选题：[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 上如何得到一个段错误的核心转储
|
Julia Evans
|
https://jvns.ca/blog/2018/04/28/debugging-a-segfault-on-linux/
|
在看完这篇博客后，你应该知道如何从“哦，我的程序出现段错误，但我不知道正在发生什么”到“我知道它出现段错误时的堆栈、行号了！ ”。
|
/data/attachment/album/201807/13/221835y0g3m1gmbj7zg781.jpg.thumb.jpg
|
/data/attachment/album/201807/13/221835y0g3m1gmbj7zg781.jpg
| true | false | true |
stephenxs
| false |
[
"核心转储",
"调试",
"段错误"
] |
软件开发
|
{
"viewnum": 6766,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在看完这篇博客后，你应该知道如何从“哦，我的程序出现段错误，但我不知道正在发生什么”到“我知道它出现段错误时的堆栈、行号了！ ”。
| 2018-07-13T22:19:22 | 2018-07-13T22:19:22 | 9,834 |
/article-9834-1.html
|
本周工作中，我花了整整一周的时间来尝试调试一个段错误。我以前从来没有这样做过，我花了很长时间才弄清楚其中涉及的一些基本事情（获得核心转储、找到导致段错误的行号）。于是便有了这篇博客来解释如何做那些事情！
在看完这篇博客后，你应该知道如何从“哦，我的程序出现段错误，但我不知道正在发生什么”到“我知道它出现段错误时的堆栈、行号了！ ”。
### 什么是段错误？
“<ruby> 段错误 <rt> segmentation fault </rt></ruby>”是指你的程序尝试访问不允许访问的内存地址的情况。这可能是由于：
* 试图解引用空指针（你不被允许访问内存地址 `0`）；
* 试图解引用其他一些不在你内存（LCTT 译注：指不在合法的内存地址区间内）中的指针；
* 一个已被破坏并且指向错误的地方的 <ruby> C++ 虚表指针 <rt> C++ vtable pointer </rt></ruby>，这导致程序尝试执行没有执行权限的内存中的指令；
* 其他一些我不明白的事情，比如我认为访问未对齐的内存地址也可能会导致段错误（LCTT 译注：在要求自然边界对齐的体系结构，如 MIPS、ARM 中更容易因非对齐访问产生段错误）。
这个“C++ 虚表指针”是我的程序发生段错误的情况。我可能会在未来的博客中解释这个，因为我最初并不知道任何关于 C++ 的知识，并且这种虚表查找导致程序段错误的情况也是我所不了解的。
但是！这篇博客后不是关于 C++ 问题的。让我们谈论的基本的东西，比如，我们如何得到一个核心转储？
### 步骤1：运行 valgrind
我发现找出为什么我的程序出现段错误的最简单的方式是使用 `valgrind`：我运行
```
valgrind -v your-program
```
这给了我一个故障时的堆栈调用序列。 简洁！
但我想也希望做一个更深入调查，并找出些 `valgrind` 没告诉我的信息！ 所以我想获得一个核心转储并探索它。
### 如何获得一个核心转储
<ruby> 核心转储 <rt> core dump </rt></ruby>是您的程序内存的一个副本，并且当您试图调试您的有问题的程序哪里出错的时候它非常有用。
当您的程序出现段错误，Linux 的内核有时会把一个核心转储写到磁盘。 当我最初试图获得一个核心转储时，我很长一段时间非常沮丧，因为 - Linux 没有生成核心转储！我的核心转储在哪里？
这就是我最终做的事情：
1. 在启动我的程序之前运行 `ulimit -c unlimited`
2. 运行 `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t`
### ulimit：设置核心转储的最大尺寸
`ulimit -c` 设置核心转储的最大尺寸。 它往往设置为 0，这意味着内核根本不会写核心转储。 它以千字节为单位。 `ulimit` 是按每个进程分别设置的 —— 你可以通过运行 `cat /proc/PID/limit` 看到一个进程的各种资源限制。
例如这些是我的系统上一个随便一个 Firefox 进程的资源限制：
```
$ cat /proc/6309/limits
Limit Soft Limit Hard Limit Units
Max cpu time unlimited unlimited seconds
Max file size unlimited unlimited bytes
Max data size unlimited unlimited bytes
Max stack size 8388608 unlimited bytes
Max core file size 0 unlimited bytes
Max resident set unlimited unlimited bytes
Max processes 30571 30571 processes
Max open files 1024 1048576 files
Max locked memory 65536 65536 bytes
Max address space unlimited unlimited bytes
Max file locks unlimited unlimited locks
Max pending signals 30571 30571 signals
Max msgqueue size 819200 819200 bytes
Max nice priority 0 0
Max realtime priority 0 0
Max realtime timeout unlimited unlimited us
```
内核在决定写入多大的核心转储文件时使用<ruby> 软限制 <rt> soft limit </rt></ruby>（在这种情况下，`max core file size = 0`）。 您可以使用 shell 内置命令 `ulimit`（`ulimit -c unlimited`） 将软限制增加到<ruby> 硬限制 <rt> hard limit </rt></ruby>。
### kernel.core\_pattern：核心转储保存在哪里
`kernel.core_pattern` 是一个内核参数，或者叫 “sysctl 设置”，它控制 Linux 内核将核心转储文件写到磁盘的哪里。
内核参数是一种设定您的系统全局设置的方法。您可以通过运行 `sysctl -a` 得到一个包含每个内核参数的列表，或使用 `sysctl kernel.core_pattern` 来专门查看 `kernel.core_pattern` 设置。
所以 `sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t` 将核心转储保存到目录 `/tmp` 下，并以 `core` 加上一系列能够标识（出故障的）进程的参数构成的后缀为文件名。
如果你想知道这些形如 `%e`、`%p` 的参数都表示什么，请参考 [man core](http://man7.org/linux/man-pages/man5/core.5.html)。
有一点很重要，`kernel.core_pattern` 是一个全局设置 —— 修改它的时候最好小心一点，因为有可能其它系统功能依赖于把它被设置为一个特定的方式（才能正常工作）。
### kernel.core\_pattern 和 Ubuntu
默认情况下在 ubuntu 系统中，`kernel.core_pattern` 被设置为下面的值：
```
$ sysctl kernel.core_pattern
kernel.core_pattern = |/usr/share/apport/apport %p %s %c %d %P
```
这引起了我的迷惑（这 apport 是干什么的，它对我的核心转储做了什么？）。以下关于这个我了解到的：
* Ubuntu 使用一种叫做 apport 的系统来报告 apt 包有关的崩溃信息。
* 设定 `kernel.core_pattern=|/usr/share/apport/apport %p %s %c %d %P` 意味着核心转储将被通过管道送给 `apport` 程序。
* apport 的日志保存在文件 `/var/log/apport.log` 中。
* apport 默认会忽略来自不属于 Ubuntu 软件包一部分的二进制文件的崩溃信息
我最终只是跳过了 apport，并把 `kernel.core_pattern` 重新设置为 `sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t`，因为我在一台开发机上，我不在乎 apport 是否工作，我也不想尝试让 apport 把我的核心转储留在磁盘上。
### 现在你有了核心转储，接下来干什么？
好的，现在我们了解了 `ulimit` 和 `kernel.core_pattern` ，并且实际上在磁盘的 `/tmp` 目录中有了一个核心转储文件。太好了！接下来干什么？我们仍然不知道该程序为什么会出现段错误！
下一步将使用 `gdb` 打开核心转储文件并获取堆栈调用序列。
### 从 gdb 中得到堆栈调用序列
你可以像这样用 `gdb` 打开一个核心转储文件：
```
$ gdb -c my_core_file
```
接下来，我们想知道程序崩溃时的堆栈是什么样的。在 `gdb` 提示符下运行 `bt` 会给你一个<ruby> 调用序列 <rt> backtrace </rt></ruby>。在我的例子里，`gdb` 没有为二进制文件加载符号信息，所以这些函数名就像 “??????”。幸运的是，（我们通过）加载符号修复了它。
下面是如何加载调试符号。
```
symbol-file /path/to/my/binary
sharedlibrary
```
这从二进制文件及其引用的任何共享库中加载符号。一旦我这样做了，当我执行 `bt` 时，gdb 给了我一个带有行号的漂亮的堆栈跟踪！
如果你想它能工作，二进制文件应该以带有调试符号信息的方式被编译。在试图找出程序崩溃的原因时，堆栈跟踪中的行号非常有帮助。:)
### 查看每个线程的堆栈
通过以下方式在 `gdb` 中获取每个线程的调用栈！
```
thread apply all bt full
```
### gdb + 核心转储 = 惊喜
如果你有一个带调试符号的核心转储以及 `gdb`，那太棒了！您可以上下查看调用堆栈（LCTT 译注：指跳进调用序列不同的函数中以便于查看局部变量），打印变量，并查看内存来得知发生了什么。这是最好的。
如果您仍然正在基于 gdb 向导来工作上，只打印出栈跟踪与bt也可以。 :)
### ASAN
另一种搞清楚您的段错误的方法是使用 AddressSanitizer 选项编译程序（“ASAN”，即 `$CC -fsanitize=address`）然后运行它。 本文中我不准备讨论那个，因为本文已经相当长了，并且在我的例子中打开 ASAN 后段错误消失了，可能是因为 ASAN 使用了一个不同的内存分配器（系统内存分配器，而不是 tcmalloc）。
在未来如果我能让 ASAN 工作，我可能会多写点有关它的东西。（LCTT 译注：这里指使用 ASAN 也能复现段错误）
### 从一个核心转储得到一个堆栈跟踪真的很亲切！
这个博客听起来很多，当我做这些的时候很困惑，但说真的，从一个段错误的程序中获得一个堆栈调用序列不需要那么多步骤：
1. 试试用 `valgrind`
如果那没用，或者你想要拿到一个核心转储来调查：
1. 确保二进制文件编译时带有调试符号信息；
2. 正确的设置 `ulimit` 和 `kernel.core_pattern`；
3. 运行程序；
4. 一旦你用 `gdb` 调试核心转储了，加载符号并运行 `bt`；
5. 尝试找出发生了什么！
我可以使用 `gdb` 弄清楚有个 C++ 的虚表条目指向一些被破坏的内存，这有点帮助，并且使我感觉好像更懂了 C++ 一点。也许有一天我们会更多地讨论如何使用 `gdb` 来查找问题！
---
via: <https://jvns.ca/blog/2018/04/28/debugging-a-segfault-on-linux/>
作者：[Julia Evans](https://jvns.ca/about/) 译者：[stephenxs](https://github.com/stephenxs) 校对：[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.