新闻速读 > 你以后从爸妈那继承的可能是游戏装备

Summary: 更多：OpenBSD 在新的微软 Surface Go 2 找到了宾至如归的感觉；Mozilla Firefox 84 将彻底删除 Flash

放新闻不就行了，后面硬核老王说点废话真影响阅读体验

嗯，有点短

老王，点评。非常好。我喜欢。

# 新闻速读 > 你以后从爸妈那继承的可能是游戏装备

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

#### 你以后从爸妈那继承的可能是游戏装备

此次民法典草案继承编对继承遗产的范围做了改变，“遗产是自然人死亡时遗留的个人合法财产”，将《继承法》中遗产范围，采取了概括的方式，只要是自然人合法取得的财产，都属于遗产，可以被继承，最大限度地保障私有财产继承的需要。网络财产、虚拟货币等都概括其中。

来源：[央视财经](https://www.cnbeta.com/articles/tech/980165.htm)

>
> 硬核老王点评：数字遗产可能是更重要的资产了，你的 QQ /微信和游戏账号会留给孩子吗？
>
>
>

#### OpenBSD 在新的微软 Surface Go 2 找到了宾至如归的感觉

开发人员解释说，几乎所有东西都能正常工作。虽然微软的 Surface Go 开箱即送的是 Windows 10，但有些人宁愿把操作系统换成自己觉得更有用的东西，不一定要成为他们的日常座驾，也是为了尝试一下。比如说开发者 Joshua Stein，他在之前在原来的型号上安装了 OpenBSD 操作系统后，又在 Surface Go 2 上进行了尝试。

来源：[softpedia](https://news.softpedia.com/news/openbsd-feels-almost-like-home-on-the-new-microsoft-surface-go-2-530011.shtml)

>
> 硬核老王点评：我觉得微软可以推出预装 OpenBSD 或 Linux 发行版的 Surface 平板了。
>
>
>

#### Mozilla Firefox 84 将彻底删除 Flash

Adobe 预计将在今年晚些时候彻底放弃对 Flash 的支持，而浏览器制造商们已经为这一历史性的时刻准备了好几年了。近日，Mozilla 宣布了最后一步预计将于何时进行，将在 2020 年 12 月推出的 Firefox 84 浏览器中完全放弃 Flash。这个版本的浏览器将无法再运行 Flash 内容。目前，Mozilla Firefox 自带的 Flash 支持默认是禁用的，但用户可以在必要时手动启用该插件。

来源：[softpedia](https://news.softpedia.com/news/mozilla-firefox-84-to-remove-flash-once-and-for-all-530010.shtml)

>
> 硬核老王点评：似乎终于要等到了这一天，臭名昭著的 Flash 的时代看来要过去了，但是那些依旧残留着 Flash 支持的网站怎么办呢？
>
>
>

#### 马斯克称数字货币更可靠，但只是说说而已

近日，《哈利·波特》作者 JK·罗琳在社交网络上表示，自己不相信比特币。马斯克表示了认同，但称相比之下，美国中央银行发行大量货币使得比特币这种网络货币看起来更稳定、可靠。马斯克还透露，自己仍然只持有 0.25 个比特币。两年多以前，马斯克曾自曝，自己持有 0.25 个比特币，还是一个朋友很多年前送给他的。不过，马斯克表示，他不知道把比特币放哪里了。

来源：[TechWeb](https://www.cnbeta.com/articles/tech/980399.htm)

>
> 硬核老王点评：说明马斯克根本不认可数字货币，你怎么看数字货币呢。
>
>
>

#### Linux 平板 PineTab 即将开启预订，承诺可运行多数 Linux 发行版

在经历多次延期之后，Pine64 今天正式宣布将会在本月晚些时候开启 PineTab Linux 平板电脑的预订工作。PineTab 是一款廉价的 Linux 平板电脑，搭载 UBports 的 Ubuntu Touch 系统，并且承诺在未来能够运行大多数 GNU/Linux 发行版。零售价格为 99.99 美元，此外磁性背光键盘零售价格为 19.99 美元。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/980285.htm)

>
> 硬核老王点评：结合前一条，或许在微软 Surface 平板上运行更好？不过这个 Linux 平板比较便宜。
>
>
>

#### 华为 Mate30 的美国零部件使用率降至 1%

对华为旗舰手机 Mate30 5G 的拆解分析显示，在受到美国制裁之后，华为手机的中国产零部件的使用率按金额计算已经从 25％ 左右大幅上升到 41.8％，而美国产零部件则从 11％ 左右降到了约 1.5％，主要是玻璃壳。

来源：[solidot](https://www.solidot.org/story?sid=64392)

>
> 硬核老王点评：如果只剩下玻璃壳，我觉得这个目标还是能完成的。
>
>
>


COPR 仓库中 4 个很酷的新项目（2020.05）

Summary: 本文介绍了 COPR 中一些有趣的新项目。

本文介绍了 COPR 中一些有趣的新项目。

# COPR 仓库中 4 个很酷的新项目（2020.05）

COPR 是个人软件仓库[集合](https://copr.fedorainfracloud.org/)，它不在 Fedora 中。这是因为某些软件不符合轻松打包的标准；或者它可能不符合其他 Fedora 标准，尽管它是自由而开源的。COPR 可以在 Fedora 套件之外提供这些项目。COPR 中的软件不受 Fedora 基础设施的支持，或者是由项目自己背书的。但是，这是一种尝试新的或实验性的软件的一种巧妙的方式。

本文介绍了 COPR 中一些有趣的新项目。如果你第一次使用 COPR，请参阅 [COPR 用户文档](https://docs.pagure.org/copr.copr/user_documentation.html#)。

### Ytop

[ytop](https://github.com/cjbassi/ytop) 是类似于 `htop` 的命令行系统监视器。它们之间的主要区别是，`ytop` 在显示进程及其 CPU 和内存使用率的顶部显示了系统的 CPU、内存和网络使用率随时间变化的图表。此外，`ytop` 还显示磁盘使用情况和计算机温度。最后，`ytop` 支持多种配色方案以及创建新配色的选项。

#### 安装说明

[该仓库](https://copr.fedorainfracloud.org/coprs/atim/ytop/)当前为 Fedora 30、31、32 和 Rawhide 以及 EPEL 7 提供了 `ytop`。要安装 `ytop`，请[带上 sudo](https://fedoramagazine.org/howto-use-sudo/) 使用以下命令：

```
sudo dnf copr enable atim/ytop
sudo dnf install ytop
```

### Ctop

[ctop](https://github.com/bcicen/ctop) 是另一个命令行系统监视器。但是，与 `htop` 和 `ytop` 不同，`ctop` 专注于显示容器的资源使用情况。`ctop` 同时显示计算机上运行的所有容器的 CPU、内存、网络和磁盘使用情况的概要，以及单个容器的更全面的信息，包括一段时间内资源使用情况的图表。当前，`ctop` 支持 Docker 和 runc 容器。

#### 安装说明

[该仓库](https://copr.fedorainfracloud.org/coprs/fuhrmann/ctop/)当前为 Fedora 31、32 和 Rawhide 以及 EPEL 7 还有其他发行版提供了安装包。要安装 `ctop`，请使用以下命令：

```
sudo dnf copr enable fuhrmann/ctop
sudo dnf install ctop
```

### Shortwave

[shortwave](https://github.com/ranfdev/shortwave) 是用于收听广播电台的程序。`shortwave` 使用广播电台的社区数据库 [www.radio-browser.info](http://www.radio-browser.info/gui/#!/)。在此数据库中，你可以发现或搜索广播电台，将它们添加到库中，然后收听。此外，`shortwave` 还提供有关当前播放歌曲的信息，并且还可以记录这些歌曲。

#### 安装说明

[该仓库](https://copr.fedorainfracloud.org/coprs/atim/shortwave/) 当前为 Fedora 31、32 和 Rawhide 提供了 shortwave。要安装 `shortwave`，请使用以下命令：

```
sudo dnf copr enable atim/shortwave
sudo dnf install shortwave
```

### Setzer

[setzer](https://www.cvfosammmm.org/setzer/) 是 LaTeX 编辑器，它可以构建 pdf 文档并查看它们。它提供了各种类型文档（例如文章或幻灯片）的模板。此外，`setzer` 还有许多特殊符号、数学符号和希腊字母的按钮。

#### 安装说明

[该仓库](https://copr.fedorainfracloud.org/coprs/lyessaadi/setzer/) 当前为 Fedora 30、31、32 和 Rawhide 提供了 `setzer`。要安装 `setzer`，请使用以下命令：

```
sudo dnf copr enable lyessaadi/setzer
sudo dnf install setzer
```

---

via: <https://fedoramagazine.org/4-cool-new-projects-to-try-in-copr-for-april-2020/>

作者：[Dominik Turecek](https://fedoramagazine.org/author/dturecek/) 选题：[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/) 荣誉推出


完美生活：git rebase -i

Summary: 让大家觉得你一次就能写出完美的代码，并让你的补丁更容易审核和合并。

让大家觉得你一次就能写出完美的代码，并让你的补丁更容易审核和合并。

# 完美生活：git rebase -i

>
> 让大家觉得你一次就能写出完美的代码，并让你的补丁更容易审核和合并。
>
>
>

软件开发是混乱的。有很多错误的转折、有需要修复的错别字、有需要修正的错误、有需要稍后纠正的临时和粗陋的代码，还有在以后的开发过程中发现一次又一次的问题。有了版本控制，在创建“完美”的最终产品（即准备提交给上游的补丁）的过程中，你会有一个记录着每一个错误转折和修正的原始记录。就像电影中的花絮一样，它们会让人有点尴尬，有时也会让人觉得好笑。

如果你使用版本控制来定期保存你的工作线索，然后当你准备提交审核的东西时，又可以隐藏所有这些私人草稿工作，并只提交一份单一的、完美的补丁，那不是很好吗？`git rebase -i`，是重写历史记录的完美方法，可以让大家觉得你一次就写出了完美的代码！

### git rebase 的作用是什么？

如果你不熟悉 Git 的复杂性，这里简单介绍一下。在幕后，Git 将项目的不同版本与唯一标识符关联起来，这个标识符由父节点的唯一标识符的哈希以及新版本与其父节点的差异组成。这样就形成了一棵修订树，每个签出项目的人都会得到自己的副本。不同的人可以把项目往不同的方向发展，每个方向都可能从不同的分支点开始。

*左边是 origin 版本库中的主分支，右边是你个人副本中的私有分支。*

有两种方法可以将你的工作与原始版本库中的主分支整合起来：一种是使用合并：`git merge`，另一种是使用变基：`git rebase`。它们的工作方式非常不同。

当你使用 `git merge` 时，会在主分支（`master`）上创建一个新的提交，其中包括所有来自原始位置（`origin`）的修改和所有本地的修改。如果有任何冲突（例如，如果别人修改了你也在修改的文件），则将这些冲突标记出来，并且你有机会在将这个“合并提交”提交到本地版本库之前解决这些冲突。当你将更改推送回父版本库时，所有的本地工作都会以分支的形式出现在 Git 版本库的其他用户面前。

但是 `git rebase` 的工作方式不同。它会回滚你的提交，并从主分支（`master`）的顶端再次重放这些提交。这导致了两个主要的变化。首先，由于你的提交现在从一个不同的父节点分支出来，它们的哈希值会被重新计算，并且任何克隆了你的版本库的人都可能得到该版本库的一个残破副本。第二，你没有“合并提交”，所以在将更改重放到主分支上时会识别出任何合并冲突，因此，你需要在进行<ruby> 变基 <rt>  rebase </rt></ruby>之前先修复它们。现在，当你现在推送你的修改时，你的工作不会出现在分支上，并且看起来像是你是在主分支的最新的提交上写入了所有的修改。

*合并提交（左）保留了历史，而变基（右）重写历史。*

然而，这两种方式都有一个缺点：在你准备好分享代码之前，每个人都可以看到你在本地处理问题时的所有涂鸦和编辑。这就是 `git rebase` 的 `--interactive`（或简写 `-i`）标志发挥作用的地方。

### git rebase -i 登场

`git rebase` 的最大优点是它可以重写历史。但是，为什么仅止于假装你从后面的点分支出来呢？有一种更进一步方法可以重写你是如何准备就绪这些代码的：`git rebase -i`，即交互式的 `git rebase`。

这个功能就是 Git 中的 “魔术时光机” 功能。这个标志允许你在做变基时对修订历史记录进行复杂的修改。你可以隐藏你的错误! 将许多小的修改合并到一个崭新的功能补丁中! 重新排列修改历史记录中的显示顺序！

当你运行 `git rebase -i` 时，你会进入一个编辑器会话，其中列出了所有正在被变基的提交，以及可以对其执行的操作的多个选项。默认的选择是选择（`Pick`）。

* `Pick`：会在你的历史记录中保留该提交。
* `Reword`：允许你修改提交信息，可能是修复一个错别字或添加其它注释。
* `Edit`：允许你在重放分支的过程中对提交进行修改。
* `Squash`：可以将多个提交合并为一个。
* 你可以通过在文件中移动来重新排序提交。

当你完成后，只需保存最终结果，变基操作就会执行。在你选择修改提交的每个阶段（无论是用 `reword`、`edit`、`squash` 还是发生冲突时），变基都会停止，并允许你在继续提交之前进行适当的修改。

上面这个例子的结果是 “One-liner bug fix” 和 “Integate new header everywhere” 被合并到一个提交中，而 “New header for docs website” 和 “D'oh - typo. Fixed” 合并到另一个提交中。就像变魔术一样，其他提交的工作还在你的分支中，但相关的提交已经从你的历史记录中消失了！

这使得使用 `git send-email` 或者用你新整理好的补丁集在父版本库中创建一个拉取请求，然后来提交一个干净的补丁给上游项目变得很容易。这有很多好处，包括让你的代码更容易审核，更容易接受，也更容易合并。

---

via: <https://opensource.com/article/20/4/git-rebase-i>

作者：[Dave Neary](https://opensource.com/users/dneary) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)

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


对构建系统进行容器化的指南

Summary: 搭建一个通过容器分发应用的可复用系统可能很复杂，但这儿有个好方法。

搭建一个通过容器分发应用的可复用系统可能很复杂，但这儿有个好方法。

# 对构建系统进行容器化的指南

>
> 搭建一个通过容器分发应用的可复用系统可能很复杂，但这儿有个好方法。
>
>
>

一个用于将源代码转换成可运行的应用的构建系统是由工具和流程共同组成。在转换过程中还涉及到代码的受众从软件开发者转变为最终用户，无论最终用户是运维的同事还是部署的同事。

在使用容器搭建了一些构建系统后，我觉得有一个不错的可复用的方法值得分享。虽然这些构建系统被用于编译机器学习算法和为嵌入式硬件生成可加载的软件镜像，但这个方法足够抽象，可用于任何基于容器的构建系统。

这个方法是以一种易于使用和维护的方式搭建或组织构建系统，但并不涉及处理特定编译器或工具容器化的技巧。它适用于软件开发人员构建软件，并将可维护镜像交给其他技术人员（无论是系统管理员、运维工程师或者其他一些头衔）的常见情况。该构建系统被从终端用户中抽象出来，这样他们就可以专注于软件。

### 为什么要容器化构建系统？

搭建基于容器的可复用构建系统可以为软件团队带来诸多好处：

* **专注**：我希望专注于应用的开发。当我调用一个工具进行“构建”时，我希望这个工具集能生成一个随时可用的二进制文件。我不想浪费时间在构建系统的查错上。实际上，我宁愿不了解，或者说不关心构建系统。
* **一致的构建行为**：无论在哪种使用情况下，我都想确保整个团队使用相同版本的工具集并在构建时得到相同的结果。否则，我就得不断地处理“我这咋就是好的”的麻烦。在团队项目中，使用相同版本的工具集并对给定的输入源文件集产生一致的输出是非常重要。
* **易于部署和升级**：即使向每个人都提供一套详细说明来安装一个项目的工具集，也可能会有人翻车。问题也可能是由于每个人对自己的 Linux 环境的个性化修改导致的。在团队中使用不同的 Linux 发行版（或者其他操作系统），情况可能还会变得更复杂。当需要将工具集升级到下一版本时，问题很快就会变得更糟糕。使用容器和本指南将使得新版本升级非常简单。

对我在项目中使用的构建系统进行容器化的这些经验显然很有价值，因为它可以缓解上述问题。我倾向于使用 Docker 作为容器工具，虽然在相对特殊的环境中安装和网络配置仍可能出现问题，尤其是当你在一个使用复杂代理的企业环境中工作时。但至少现在我需要解决的构建系统问题已经很少了。

### 漫步容器化的构建系统

我创建了一个[教程存储库](https://github.com/ravi-chandran/dockerize-tutorial)，随后你可以克隆并检查它，或者按照本文内容进行操作。我将逐个介绍存储库中的文件。这个构建系统非常简单（它运行 `gcc`），从而可以让你专注于这个构建系统结构上。

### 构建系统需求

我认为构建系统中有两个关键点：

* **标准化构建调用**：我希望能够指定一些形如 `/path/to/workdir` 的工作目录来构建代码。我希望以如下形式调用构建：

```
./build.sh /path/to/workdir
```

为了使得示例的结构足够简单（以便说明），我将假定输出也在 `/path/to/workdir` 路径下的某处生成。（否则，将增加容器中显示的卷的数量，虽然这并不困难，但解释起来比较麻烦。）
* **通过 shell 自定义构建调用**：有时，工具集会以出乎意料的方式被调用。除了标准的工具集调用 `build.sh` 之外，如果需要还可以为 `build.sh` 添加一些选项。但我一直希望能够有一个可以直接调用工具集命令的 shell。在这个简单的示例中，有时我想尝试不同的 `gcc` 优化选项并查看效果。为此，我希望调用：

```
./shell.sh /path/to/workdir
```

这将让我得到一个容器内部的 Bash shell，并且可以调用工具集和访问我的工作目录（`workdir`），从而我可以根据需要尝试使用这个工具集。

### 构建系统的架构

为了满足上述基本需求，这是我的构架系统架构：

在底部的 `workdir` 代表软件开发者用于构建的任意软件源码。通常，这个 `workdir` 是一个源代码的存储库。在构建之前，最终用户可以通过任何方式来操纵这个存储库。例如，如果他们使用 `git` 作为版本控制工具的话，可以使用 `git checkout` 切换到他们正在工作的功能分支上并添加或修改文件。这样可以使得构建系统独立于 `workdir` 之外。

顶部的三个模块共同代表了容器化的构建系统。最左边的黄色模块代表最终用户与构建系统交互的脚本（`build.sh` 和 `shell.sh`）。

在中间的红色模块是 Dockerfile 和相关的脚本 `build_docker_image.sh`。开发运营者（在这个例子中指我）通常将执行这个脚本并生成容器镜像（事实上我多次执行它直到一切正常为止，但这是另一回事）。然后我将镜像分发给最终用户，例如通过<ruby> 容器信任注册库 <rt>  container trusted registry </rt></ruby>进行分发。最终用户将需要这个镜像。另外，他们将克隆构建系统的存储库（即一个与[教程存储库](https://github.com/ravi-chandran/dockerize-tutorial)等效的存储库）。

当最终用户调用 `build.sh` 或者 `shell.sh` 时，容器内将执行右边的 `run_build.sh` 脚本。接下来我将详细解释这些脚本。这里的关键是最终用户不需要为了使用而去了解任何关于红色或者蓝色模块或者容器工作原理的知识。

### 构建系统细节

把教程存储库的文件结构映射到这个系统结构上。我曾将这个原型结构用于相对复杂构建系统，因此它的简单并不会造成任何限制。下面我列出存储库中相关文件的树结构。文件夹 `dockerize-tutorial` 能用构建系统的其他任何名称代替。在这个文件夹下，我用 `workdir` 的路径作参数调用 `build.sh` 或 `shell.sh`。

```
dockerize-tutorial/
├── build.sh
├── shell.sh
└── swbuilder
    ├── build_docker_image.sh
    ├── install_swbuilder.dockerfile
    └── scripts
        └── run_build.sh
```

请注意，我上面特意没列出 `example_workdir`，但你能在教程存储库中找到它。实际的源码通常存放在单独的存储库中，而不是构建工具库中的一部分；本教程为了不必处理两个存储库，所以我将它包含在这个存储库中。

如果你只对概念感兴趣，本教程并非必须的，因为我将解释所有文件。但是如果你继续本教程（并且已经安装 Docker），首先使用以下命令来构建容器镜像 `swbuilder:v1`：

```
cd dockerize-tutorial/swbuilder/
./build_docker_image.sh
docker image ls  # resulting image will be swbuilder:v1
```

然后调用 `build.sh`：

```
cd dockerize-tutorial
./build.sh ~/repos/dockerize-tutorial/example_workdir
```

下面是 [build.sh](https://github.com/ravi-chandran/dockerize-tutorial/blob/master/build.sh) 的代码。这个脚本从容器镜像 `swbuilder:v1` 实例化一个容器。而这个容器实例映射了两个卷：一个将文件夹 `example_workdir` 挂载到容器内部路径 `/workdir` 上，第二个则将容器外的文件夹 `dockerize-tutorial/swbuilder/scripts` 挂载到容器内部路径 `/scripts` 上。

```
docker container run                              \
    --volume $(pwd)/swbuilder/scripts:/scripts    \
    --volume $1:/workdir                          \
    --user $(id -u ${USER}):$(id -g ${USER})      \
    --rm -it --name build_swbuilder swbuilder:v1  \
    build
```

另外，`build.sh` 还会用你的用户名（以及组，本教程假设两者一致）去运行容器，以便在访问构建输出时不出现文件权限问题。

请注意，[shell.sh](https://github.com/ravi-chandran/dockerize-tutorial/blob/master/shell.sh) 和 `build.sh` 大体上是一致的，除了两点不同：`build.sh` 会创建一个名为 `build_swbuilder` 的容器，而 `shell.sh` 则会创建一个名为 `shell_swbuilder` 的容器。这样一来，当其中一个脚本运行时另一个脚本被调用也不会产生冲突。

两个脚本之间的另一处关键不同则在于最后一个参数：`build.sh` 传入参数 `build` 而 `shell.sh` 则传入 `shell`。如果你看了用于构建容器镜像的 [Dockerfile](https://github.com/ravi-chandran/dockerize-tutorial/blob/master/swbuilder/install_swbuilder.dockerfile)，就会发现最后一行包含了下面的 `ENTRYPOINT` 语句。这意味着上面的 `docker container run` 调用将使用 `build` 或 `shell` 作为唯一的输入参数来执行 `run_build.sh` 脚本。

```
# run bash script and process the input command
ENTRYPOINT [ "/bin/bash", "/scripts/run_build.sh"]
```

[run\_build.sh](https://github.com/ravi-chandran/dockerize-tutorial/blob/master/swbuilder/scripts/run_build.sh) 使用这个输入参数来选择启动 Bash shell 还是调用 `gcc` 来构建 `helloworld.c` 项目。一个真正的构建系统通常会使用 Makefile 而非直接运行 `gcc`。

```
cd /workdir

if [ $1 = "shell" ]; then
    echo "Starting Bash Shell"
    /bin/bash
elif [ $1 = "build" ]; then
    echo "Performing SW Build"
    gcc helloworld.c -o helloworld -Wall
fi
```

在使用时，如果你需要传入多个参数，当然也是可以的。我处理过的构建系统，构建通常是对给定的项目调用 `make`。如果一个构建系统有非常复杂的构建调用，则你可以让 `run_build.sh` 调用 `workdir` 下最终用户编写的特定脚本。

### 关于 scripts 文件夹的说明

你可能想知道为什么 `scripts` 文件夹位于目录树深处而不是位于存储库的顶层。两种方法都是可行的，但我不想鼓励最终用户到处乱翻并修改里面的脚本。将它放到更深的地方是一个让他们更难乱翻的方法。另外，我也可以添加一个 `.dockerignore` 文件去忽略 `scripts` 文件夹，因为它不是容器必需的部分。但因为它很小，所以我没有这样做。

### 简单而灵活

尽管这一方法很简单，但我在几个相当不同的构建系统中使用过，发现它相当灵活。相对稳定的部分（例如，一年仅修改数次的给定工具集）被固定在容器镜像内。较为灵活的部分则以脚本的形式放在镜像外。这使我能够通过修改脚本并将更改推送到构建系统存储库中，轻松修改调用工具集的方式。用户所需要做的是将更改拉到本地的构建系统存储库中，这通常是非常快的（与更新 Docker 镜像不同）。这种结构使其能够拥有尽可能多的卷和脚本，同时使最终用户摆脱复杂性。

---

via: <https://opensource.com/article/20/4/how-containerize-build-system>

作者：[Ravi Chandran](https://opensource.com/users/ravichandran) 选题：[lujun9972](https://github.com/lujun9972) 译者：[LazyWolfLin](https://github.com/LazyWolfLin) 校对：[wxy](https://github.com/wxy)

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


Summary: 更多：梅赛德斯奔驰 OLU 源代码在网上曝光；Rust 发布 5 周年

hhh，rust啥都好，就是学不会

来自111.18.70.88的 Firefox 77.0|Windows 10 用户

更多：梅赛德斯奔驰 OLU 源代码在网上曝光；Rust 发布 5 周年

# 新闻速读 > MIT “AI 种菜”项目失败，还因环保问题被罚 25125 美元

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

#### MIT “AI 种菜”项目失败，还因环保问题被罚 25125 美元

4 月 30 日消息，麻省理工 MIT 永久关停由原麻省理工媒体实验室首席研究科学家 Caleb Harper 牵头的“开放农业计划（OpenAg）”项目。同一天，Caleb Harper 从 MIT 正式离职。OpenAg 项目始于2015年，其核心产品形态类似迷你培育室，是一个四方的便携密闭箱，被称作个人食品计算机（PFC）。PFC 的硬件和软件全部开源，以便更多人做室内农业试验。这个“开源食物计算机”PFC 一大的技术特色，就是利用深度学习来种菜。项目会搜集来自世界各地的食物计算机数据，然后利用机器学习算法，给植物生长提供更适合其习性的环境“食谱”。Harper 还给这个产品规划了一个充满人情味的发展路线：从帮助叙利亚难民种菜开始，逐步延伸到对未来农业发展的探索，最后建造一个全球化的数字农场，让人们都能自由种植自己喜欢的植物。但 IEEE Spectrum 的一份调查结果显示，2017 至 2019 年期间，Harper 关于 PFC 在难民营的部署的言论被证明是在说谎。PFC 的产品功能也没得到实现。

来源：[开源中国](https://www.oschina.net/news/115772/mit-openag-project-failed)

>
> 硬核老王点评：理想是好的，现实是残酷的。
>
>
>

#### 梅赛德斯奔驰 OLU 源代码在网上曝光

瑞士软件工程师 Till Kottmann 发现了一个属于戴姆勒公司的 Git 门户网站。Kottmann 在戴姆勒的代码托管门户上注册一个帐户然后下载 580 多个 Git 存储库，其中包含了戴姆勒的梅赛德斯奔驰货车上安装的车载逻辑单元（OLU）的源代码。OLU 是介于汽车硬件和软件之间的一个组件，它负责将车辆连接到云端。戴姆勒未能实施账户确认流程，而这使其能使用一个不存在的戴姆勒公司电子邮件在公司的官方 GitLab 服务器上注册一个账户。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/980757.htm)

>
> 硬核老王点评：GitLab 是好用，但是无防护的实例可能造成的信息泄漏可能更危险。
>
>
>

#### Rust 发布 5 周年

Rust 核心团队发布博客庆祝发行五周年，并反思了自 2015 年以来该语言经历的所有重大变化。自 2015 年发布 1.0 版以来，Rust 曾在 Stack Overflow 开发者调查中连续四年被评为“最受欢迎的”编程语言。微软也在 2019 年 7 月讨论了对 Rust 的探索，希望将其作为 C、C++ 和其他语言的替代方案，以此来改善应用程序的安全状况。

来源：[开源中国](https://www.oschina.net/news/115771/five-years-of-rust)

>
> 硬核老王点评：Rust 就是太难学了。
>
>
>


新闻速读 > 微软在其云服务上打造全新超算

Summary: 更多：WSL 2 计划支持 Linux GUI 应用，可和 Windows 应用同时使用；Windows 10 终于也迎来了一款软件包管理器

# 新闻速读 > 微软在其云服务上打造全新超算

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

#### 微软在其云服务上打造全新超算

微软与 OpenA 合作，专门为 OpenAI 在 Azure 上构建了一台新的超级计算机，拥有超过 28.5 万个 CPU 核心和 1 万个 GPU。按照世界超级计算机 TOP500 的排名，微软打造的这款新型超级计算机位列前五名。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/981083.htm)

>
> 硬核老王点评：不知道国内的云服务商会不会也打造一个基于云服务器的超算？
>
>
>

#### WSL 2 计划支持 Linux GUI 应用，可和 Windows 应用同时使用

微软计划在本月底在 WSL 2 中为 Windows 10 系统添加完整的 Linux 内核，而现在又有新计划将支持 Linux 的 GUI 应用，使其能够和常规 Windows 应用一起运行。目前可以使用第三方 X 显示服务器在 Windows 中运行 Linux GUI 应用程序，不过存在性能表现不佳的情况。一旦该功能上线，这就意味着 Windows 用户不需要使用 X11 转发的情况下就能启用 Linux GUI 应用程序，和 Windows 应用一同运行。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/981187.htm)

>
> 硬核老王点评：所以以后在 Windows 上会有越来越多的 Linux 应用出现，无论是命令行的还是图形界面的，或许有一天连内核都换成 Linux 内核，而用户或许会感觉不到变化。嗯，欢迎 Windows “主题”上线。
>
>
>

#### Windows 10 终于也迎来了一款软件包管理器

微软终于在今日宣布了一项新功能 —— 为 Windows 10 带来了一款内置的软件包管理器。简而言之，其使得用户无需在窗口中频繁点击，即可轻松完成桌面程序的安装工作。Windows 软件包管理器已支持如下命令：`install`：安装应用程序；`show`：显示有关应用程序的信息；`source`：管理应用程序的可用来源；`search`：查找应用程序的基本信息。感兴趣的朋友可加入 Windows Insider 测试项目，并通过 Microsoft Store 获取 Windows 软件包管理器。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/981255.htm)

>
> 硬核老王点评：在 Linux 等系统中司空见惯的包管理器终于在 Windows 中出现了，这应该算是微软拥抱开源和 Linux，甚至内嵌了 WSL 的系统而带给 Windows 产品线的影响了。
>
>
>

#### 华为 HMS 全球注册开发者达 140 万，接入应用数量超 6 万

目前，全球 170 多个国家和地区的用户已经能够使用华为应用市场、华为浏览器、华为云空间、华为智慧助手·今天等。

来源：[网易科技](https://tech.163.com/20/0519/16/FD0JPFOI00097U7S.html)

>
> 硬核老王点评：加油！
>
>
>


自定义用于 Web 开发的开源 PHP 框架 Codeigniter

# 自定义用于 Web 开发的开源 PHP 框架 Codeigniter

>
> Codeigniter 是一个 PHP 框架，可以使公司进行开发具有灵活性和便捷性的高性能网站。
>
>
>

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

PHP Codeigniter 是一个开源框架，为商业应用提供易于使用的 PHP 编程语言和强大的编码工具。它还提供商务智能、服务器监视、开发和应用集成功能。这是一个相对冷清的项目，你很少听到它，但它功能强大，许多刚接触的开发人员都对此感到惊讶和耳目一新。

我在新加坡的一家在线学习服务提供商处使用 [Codeigniter](https://codeigniter.com/)。我们提供的服务并不算常见，没有可以作为模板的默认功能集或现有后台管理系统，所以我需要一个能提供良好的、可靠的、可以建立在此基础上的原始材料。最初，我考虑用其他平台（如 Wordpress）用于我们的网站。但是，我决定使用 Codeigniter，因为它的灵活性，以及集成了在我们的补课匹配过程中需要的功能。

以下是打动我使用 Codeigniter 的原因：

* 与 MySQL 数据库的集成 —— 主要功能是允许客户端浏览导师的数据库并添加导师，例如类似于电子商务平台的“购物车”。
* 客户端界面系统 —— 用户可以登录来管理偏好并编辑详细信息，修改所教的科目、旅游的地区、手机号码、地址等。
* 定制的管理员面板 —— 管理员可以使用定制的管理面板访问客户提交的资料，它与客户服务功能集成在一起，因此管理员可以单独跟进。
* 付款系统 —— 管理面板带有与 Paypal 集成的发票和付款网关。
* CMS 编辑器界面 —— 管理员能够编辑博客和文章中的文本和图像，以及添加新页面。

该项目花费了大约六个月的时间来完成，另外花了两个月的调试时间。如果我需要从头开始构建所有，或者尝试重新设计现有的框架以满足我们的需求，那将花费更长的时间，而且可能最终无法满足客户需求。

### 功能和优点

PHP Codeigniter还有很多吸引开发者的功能，包括错误处理和代码格式化，这些功能在各种编码情景下都非常有用。它支持模板，可用于向现有网站添加功能或生成新网站。有许多基于 web 系统商业需要的功能，包括使用自定义标签。即使没有编程经验的普通开发人员也可以使用大多数工具。

Codeigniter 的主要功能是：

* XML 核心服务，
* HTTP/FTP 核心服务
* AppData 和 PHP 沙箱功能
* XSLT 和 HTML 模板
* 加密的信息传输
* PCM Codeigniter 服务器监控
* 应用集成
* 文件传输协议（FTP）
* 服务台支持
* Apache POI（用于托管网站的内容管理基础架构）

#### 兼容性

Codeigniter 与许多领先的软件程序兼容，例如 PHP、MySQL、[MariaDB](http://mariadb.org/)、[phpMyAdmin](https://www.phpmyadmin.net/)、[Apache](http://apache.org/)、OpenBSD、XSLT、[SQLite](http://sqlite.org/) 等。许多公司更喜欢使用 Codeigniter 产品来满足网站要求，因为它们易于使用和集成。如果你不想创建自己的网站，你可以找到许多提供自定义 Web 开发服务的开发人员和设计机构。

#### 安全

Codeigniter 还通过 SSL 加密提供数据安全性。加密可以保护数据免受入侵者和防火墙外部威胁的侵害。数据存储功能还允许对公司网站进行安全审核。

#### 其它功能

一家优秀的 PHP Web 开发公司会使用几种高级技术和第三方技术，例如 XML 和 PHP。它为企业提供了一个完整的平台，可以开发出具有看起来专业的、好用的商业网站。Codeigniter 使得第三方技术的使用变得容易，并可以与常见的 Web 开发软件一起使用。这使得 Web 公司可以轻松地使用所选模块创建网站。大多数 PHP 开发者也为个人提供支持和培训服务。

### 使用 PHP 框架 Codeigniter

Codeigniter 给企业提供了完整的 PHP 开发包，它将提供强大的功能、灵活性和性能完美结合在一起。到目前为止，我很满意我们的网站，并不断地升级和添加新的功能。并不断升级和增加新的功能。我期待着发现我们的网站还能用 Codeigniter 做些什么。你也是这样么？

---

via: <https://opensource.com/article/20/5/codeigniter>

作者：[Wee Ben Sen](https://opensource.com/users/bswee14) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)

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


5 种拆分 Linux 终端的方法

tmux +1

Guake Terminal 用户路过

# 5 种拆分 Linux 终端的方法

>
> 本文介绍了 Linux 提供的拆分终端的方法，它能够帮助你完成多任务工作。那么，你最喜欢哪一款终端复用工具呢？
>
>
>

没有什么问题是不能用一个 Linux 终端解决的，如果不行，那就用两个。

很早以前，[终端其实是一个物理设备](https://www.redhat.com/sysadmin/terminals-shells-consoles)，而现在的终端实际上是在计算机上被模拟出来的一个应用程序。当你使用终端和计算机进行交互的时候，就会发现，只打开一个终端是不够用的。在进行编译、数据处理等长时间任务的时候，你不得不打开一个新终端或新<ruby> 选项卡 <rt>  tab </rt></ruby>来同时进行其它工作。

如果你是系统管理员，你就需要更多的终端窗口，以便连接到多个不同的主机上并行工作了。

在 Linux 系统中，终端应用程序在很久之前就已经开始带有选项卡功能了。而现在的终端应用程序里，选项卡已经是标配功能了，这是非常流行的趋势。尽管如此，工作的时候在多个选项卡之间来回切换，或多或少也会分散我们的注意力，甚至带来不便。

而最好的解决方案就是将整个屏幕划分为多个部分，这样多个终端就可以在同一个终端应用程序窗口中同时存在。Linux 发行版中也有很多相关的工具可以实现这一功能。

### Shell、终端和控制台

在此之前，我们首先要明确 Shell、<ruby> 终端 <rt>  terminal </rt></ruby>、<ruby> 控制台 <rt>  console </rt></ruby>这三个概念。想要详细了解的话，请参阅 [Enable Sysadmin](https://www.redhat.com/sysadmin/terminals-shells-consoles) 博客上的相关文章。

简而言之：

* **Shell** 是带有<ruby> 命令提示符 <rt>  prompt </rt></ruby>的用于输入、输出的界面。准确地说，[POSIX](https://opensource.com/article/19/7/what-posix-richard-stallman-explains) 桌面底层也运行着一个 Shell，即使这个 Shell 对用户不可见，因为用户会话就是由这个 Shell 启动的。
* **终端**是在图形界面服务器（例如 X11 或 Wayland）中运行的应用程序，其中加载了一个 Shell。只有在终端窗口启动之后，才算是运行了一个终端。终端可以认为是操作 Shell 的一个入口。
* **控制台**（或称“虚拟控制台”）通常表示在桌面环境以外使用的 Shell，你可以通过 `Alt+Ctrl+F2` 进入控制台，通常情况下从 `F3` 到 `F7` 都是不同的控制台，其中桌面环境有可能是 `F1` 或者 `F7`，这在不同的发行版中可能会有所不同。

因此，有些应用程序提供的功能是拆分 Shell 或者控制台，有些应用程序的功能则是拆分终端。

### tmux

[tmux](https://github.com/tmux/tmux) 可以说是最灵活、最强大的屏幕拆分工具了，它通过键盘控制对多个终端的复用，因此你可以将一个控制台叠放在另一个控制台上面，并在两个控制台之间切换。你还可以将整个屏幕等分为多个控制台，以便同时观察不同控制台上的状况。

`tmux` 的所有操作都是通过键盘完成的，这就意味着你的手不需要离开键盘去寻找鼠标。为此，你需要记住一些按键组合。

如果你只用 `tmux` 来做屏幕拆分，那你只需要记住一下这些命令：

* `Ctrl-B %` 竖直拆分屏幕（两个 Shell 分别位于左右）
* `Ctrl-B "` 水平拆分屏幕（两个 Shell 分别位于上下）
* `Ctrl-B O` 切换到另一个 Shell
* `Ctrl-B ?` 查看帮助
* `Ctrl-B d` 断开 `tmux` 并让其在后台运行（可以使用 `tmux attach` 重新进入）

`tmux` 的一大好处是，在一台计算机上启动 `tmux` 会话之后，也可以从另一台计算机上进入到这个会话，由此可以看出，`tmux` 对 Shell 进行了<ruby> 守护进程化 <rt>  daemonize </rt></ruby>。

例如，当我在树莓派上运行 `tmux`，我就可以从计算机上连接到树莓派并登录 IRC，当我断开连接时，树莓派上的 `tmux` 会继续运行，并等待我的下一次连接，在此期间 IRC 是处于持续登录状态的。

### GNU Screen

[GNU Screen](https://www.gnu.org/software/screen/) 也是一个 Shell 复用工具，类似于 `tmux`，你可以在断开一个活动会话后重连到其中，它也支持竖直或水平拆分屏幕。

`screen` 的灵活性比 `tmux` 要弱一些。它默认的绑定按键组合是 `Ctrl-A`，和 Bash 中光标移动到行首的快捷键是一样的。因此，当你正在运行 `screen` 的时候，如果想要将光标移动到行首，就需要多按一次 `Ctrl-A`。而我自己的做法是，在 `$HOME/.screenrc` 文件中将绑定按键组合重新设置为 `Ctrl-J`。

```
escape ^jJ
```

尽管 `screen` 在屏幕拆分功能上做得很好，但 `tmux` 上的一些缺点在 Screen 上也同样存在。例如在拆分 Shell 时，在一个新的面板中不会启动新的 Shell ，而是需要使用 `Ctrl-A Tab` 导航到另一个面板（如果你按照我的方式重新设置了按键组合，需要对应地把 `Ctrl-A` 改为 `Ctrl-J`），然后通过 `Ctrl-A C` 手动创建一个新的 Shell。

和 `tmux` 不同的是，`screen` 在退出一个 Shell 的时候，屏幕拆分状态不会改变，这样的设计在某些情况下是比较适合的，但麻烦之处在于需要手动管理屏幕拆分状态。

尽管如此，`screen` 还是一个相当可靠灵活的应用程序，在无法使用 `tmux` 的时候，你可以选择 `screen` 作为备选方案。

在默认按键方案下，`screen` 常用的基本命令包括：

* `Ctrl-A |` 竖直拆分屏幕（两个 Shell 分别位于左右）
* `Ctrl-A S` 水平拆分屏幕（两个 Shell 分别位于上下）
* `Ctrl-A Tab` 切换到另一个 Shell
* `Ctrl-A ?` 查看帮助
* `Ctrl-A d` 断开 `screen` 并让其在后台运行（可以使用 `screen -r` 重新进入）

### Konsole

[Konsole](https://konsole.kde.org) 是 KDE Plasma 桌面使用的终端应用程序。和 KDE 一样，Konsole 也以高度可定制、功能强大的特点而著称。

和 `tmux`、GNU Screen 类似，Konsole 也具有拆分屏幕的功能。由于 Konsole 是图形界面的终端，因此还可以用鼠标来控制它的屏幕拆分。

Konsole 的屏幕拆分功能在“<ruby> 查看 <rt>  View </rt></ruby>”菜单中。它也支持竖直和水平方向的拆分，只要点击鼠标就可以切换到另一个面板上。每个面板都是一个独立的终端，因此都可以拥有独立的主题和标签页。

Konsole 和 `tmux`、GNU Screen 最大的不同之处在于不能断开和重新连接 Konsole。除非使用远程桌面软件，否则只能在打开 Konsole 时使用，这一点和大多数图形界面应用程序是一样的。

### Emacs

严格来说，Emacs 并不算是一个终端复用工具，但它的使用界面支持拆分和调整大小，同时还带有一个内建的终端。

如果 Emacs 是你日常使用的文本编辑器，你就可以在不关闭编辑器的情况下，在不同的应用程序之间轻松互相切换。由于 Emacs eshell 模块是通过 eLISP 实现的，因此你可以在 Emacs 中使用相同的命令进行交互，让一些繁琐的操作变得更为简单。

如果你是在图形界面中使用 Emacs，还可以使用鼠标进行操作。例如通过点击切换面板、用鼠标调整拆分屏幕的的大小等等。尽管如此，键盘的操作速度还是更快，因此记住一些键盘快捷键还是很有必要的。

Emacs 的一些重要快捷键包括：

* `Ctrl-X 3` 竖直拆分屏幕（两个 Shell 分别位于左右）
* `Ctrl-X 2` 水平拆分屏幕（两个 Shell 分别位于上下）
* `Ctrl-X O` （大写字母 `O`）切换到另一个 Shell（你也可以使用鼠标操作）
* `Ctrl-X 0` （数字 `0`）关闭当前面板

如果你运行了 emacs-client 的话，就可以像 tmux 和 GNU Screen 一样断开和重新连接到 Emacs 了。

### 窗口管理器

除了文本编辑器之外，一些 Linux 桌面也同样具有拆分屏幕、加载终端这样的功能。例如 [Ratpoison](https://opensource.com/article/19/12/ratpoison-linux-desktop)、[Herbsluftwm](https://opensource.com/article/19/12/herbstluftwm-linux-desktop)、i3、Awesome，甚至是启用了特定设置的 KDE Plasma 桌面，都可以将多个应用程序在桌面上分块显示。

这些桌面可以让各个应用程序占据屏幕的固定位置，而不是浮在你的桌面“之上”，因此你可以在多个应用程序窗口之间轻松切换。你还可以打开多个终端，排布成网格，就像终端复用工具一样。更进一步，你还可以在你的桌面复用工具中加载一个终端复用工具。

而且，没有什么可以阻止你在里面载入 Emacs 并分割缓冲区。没有人知道，如果你把它更进一步，会发生什么，大多数 Linux 用户不会外传这种秘密。

和 `tmux`、GNU Screen 不同，你在断开与桌面的连接后无法重新连接到同一个桌面会话，除非你使用了远程桌面软件进行连接。

### 更多选择

除了上面介绍到的工具以外，还有诸如 [Tilix](https://gnunn1.github.io/tilix-web/)、Terminator 这样的终端模拟器，它们同样可以实现屏幕拆分、嵌入终端组件等功能。欢迎在评论区分享你喜欢的终端拆分工具。

---

via: <https://opensource.com/article/20/5/split-terminal>

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

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


新闻速读 > 百度输入法 Linux 版本发布

Summary: • Chrome 83 稳定版发布 • EA 将在 GPL 下公开《红警》和《泰伯利亚黎明》的源代码 • OpenBSD 6.7 发布 • DirectX 将进入 WSL 2

# 新闻速读 > 百度输入法 Linux 版本发布

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

#### 百度输入法 Linux 版本发布

百度发布了其输入法的 Linux 版本，官方称支持 Ubuntu 18.04 - 19.10、Deepin 1510、1511，应该也可以支持更多 Linux 发行版版本，如 Ubuntu 20.04 LTS 和优麒麟。官网：<http://srf.baidu.com/site/guanwang_linux/> 。安装说明称，“本输入法输入面板程序与其他输入法如搜狗输入法、讯飞输入法冲突，可能会受其他输入法影响而无法正常启动，若已安装其他输入法并导致百度输入法输入面板无法正常启动，应关闭其他输入法相关进程并重启百度输入法输入面板程序”。

来源：[百度](http://srf.baidu.com/site/guanwang_linux/)

>
> 硬核老王点评：不知道会有多少 Linux 用户会信任和使用百度的软件。顺便说一句，这个“guanwang”的 URL 地址真不愧是拼音输入法的网址。
>
>
>

#### Chrome 83 稳定版发布

谷歌跳过了 Chrome 82，直接向最终用户推送了 Chrome 83。主要更新内容：有助于防止跨站点脚本漏洞的可信类型；新的表单元素外观；新的跨域政策；支持条形码检测 API，提供了检测和解码条形码的功能；Preferreds-Color-Scheme 媒体查询使作者能够选择自己的深色主题。

来源：[开源中国](https://www.oschina.net/news/115834/chrome-83-released?tdsourcetag=s_pctim_aiomsg)

>
> 硬核老王点评：直接跳过了一个大版本，带来的变化非常多。
>
>
>

#### EA 将在 GPL 下公开《红警》和《泰伯利亚黎明》的源代码

EA 游戏制作人 Jim Vessella 在 Reddit 上宣布，将在 GPLv3 许可证下公开泰伯利亚黎明和红警的源代码。Vessella 称《命令与征服》应该是第一个在 GPL 下公开源代码的大型即时战略游戏。采用 GPL 是为了确保它与开源项目如 CnCNet 和 Open RA 相互兼容。

来源：[solidot](https://www.solidot.org/story?sid=64425)

>
> 硬核老王点评：作为当年的顶级游戏，能够开源还是非常赞的，希望开源社区可以在此基础上发展出更多的衍生品。
>
>
>

#### OpenBSD 6.7 发布

主要更新内容：改进 FFS2 文件系统并成为默认文件系统，包括在新安装时默认使用 64 位时间戳和区块号；为 ARM64 设备提供对树莓派 4 的支持，同时改进对树莓派 3 的支持。对于 OpenBSD ARMv7，还改进了对树莓派 2/3 的支持；针对 SMP 的多项改进，包括更好的 AMD SMT/Core/Package 检测；引入 FIDO 驱动，支持 FIDO/U2F 安全密钥；PowerPC OpenBSD 构建切换到 Clang 作为其默认代码编译器。

来源：[开源中国](https://www.oschina.net/news/115823/openbsd-6-7-released)

>
> 硬核老王点评：OpenBSD 是 BSD 家族的重要成员，在广大的 BSD 爱好者眼中，BSD 才是最好的发行版。
>
>
>

#### DirectX 将进入 WSL 2

在 //build 2020 上，微软宣布 GPU 硬件加速将加入到 WSL 2 中。WSL 是一个允许用户在 Windows PC 上运行 Linux 应用的环境。现在，这些 Linux 应用和工具将能使用 GPU 加速。微软称，对 GPU 的访问，Linux 环境中的应用将和 Windows 原生应用一样，它不会对 Linux 应用进行限制，将根据需要对 GPU 提供动态的分享。微软表示它将完整的 D3D12 API 带到了 Linux。除了 D3D12 和 DxCore 外，它还将其机器学习 API DirectML 移植到了 Linux。

来源：[solidot](https://www.solidot.org/story?sid=64415)

>
> 硬核老王点评：自打微软将开源当成了新欢，现在微软开个开发者大会，都满满是值得大书一笔的开源新动向。DirectX 进入 WSL ，想必可以为 Linux 下的 GPU 应用提供很好的支持。
>
>
>

#### Signal 不再将电话号码作为用户的唯一 ID

主打安全的即时通信应用 Signal，本周推出了一项名叫“Signal PINs”的新功能。该公司称，此举有助于用户在设备间迁移账户数据。此外从长远来看，新功能也算是向着摆脱使用电话号码作为用户 ID 的目标迈出了重要一步。启用之后，用户将被要求创建一个与之账户相关联的 PIN 码，且可使用 4 位数及以上的字符串。当用户不慎遗失了设备、或想将资料转移到新手机时，Signal PIN 便允许其轻松实现数据迁移。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/981607.htm)

#### 广告商因疫情放弃百度

与搜索和视频相比，信息流广告是“短期而言广告商的首选渠道，而这正是百度未能吸引广告商的地方”。广告商们纷纷放弃这家中国搜索巨头，转而使用更灵活的竞争对手的应用。百度表示，第一季度营收同比下降 7%，至 225 亿元人民币，原因是旅游、汽车和医疗行业广告客户在公共卫生危机期间削减支出。其核心的搜索和新闻推送业务的营收下滑速度更快，同比下降 13%。净利润较上一季度暴跌 99%，至 4100 万元人民币。

来源：[solidot](https://www.solidot.org/story?sid=64419)

>
> 硬核老王点评：没什么好说的。
>
>
>


通过禁止比较让 Go 二进制文件变小

Summary: 本文中我会深入讲解在 Go 程序的上下文中“相等”的意义，以及为什么像这样的修改会对 Go 程序的大小有重大的影响。

# 通过禁止比较让 Go 二进制文件变小

大家常规的认知是，Go 程序中声明的类型越多，生成的二进制文件就越大。这个符合直觉，毕竟如果你写的代码不去操作定义的类型，那么定义一堆类型就没有意义了。然而，链接器的部分工作就是检测没有被程序引用的函数（比如说它们是一个库的一部分，其中只有一个子集的功能被使用），然后把它们从最后的编译产出中删除。常言道，“类型越多，二进制文件越大”，对于多数 Go 程序还是正确的。

本文中我会深入讲解在 Go 程序的上下文中“相等”的意义，以及为什么[像这样](https://github.com/golang/net/commit/e0ff5e5a1de5b859e2d48a2830d7933b3ab5b75f)的修改会对 Go 程序的大小有重大的影响。

### 定义两个值相等

Go 的语法定义了“赋值”和“相等”的概念。赋值是把一个值赋给一个标识符的行为。并不是所有声明的标识符都可以被赋值，如常量和函数就不可以。相等是通过检查标识符的内容是否相等来比较两个标识符的行为。

作为强类型语言，“相同”的概念从根源上被植入标识符的类型中。两个标识符只有是相同类型的前提下，才有可能相同。除此之外，值的类型定义了如何比较该类型的两个值。

例如，整型是用算数方法进行比较的。对于指针类型，是否相等是指它们指向的地址是否相同。映射和通道等引用类型，跟指针类似，如果它们指向相同的地址，那么就认为它们是相同的。

上面都是按位比较相等的例子，即值占用的内存的位模式是相同的，那么这些值就相等。这就是所谓的 memcmp，即内存比较，相等是通过比较两个内存区域的内容来定义的。

记住这个思路，我过会儿再来谈。

### 结构体相等

除了整型、浮点型和指针等标量类型，还有复合类型：结构体。所有的结构体以程序中的顺序被排列在内存中。因此下面这个声明：

```
type S struct {
    a, b, c, d int64
}
```

会占用 32 字节的内存空间；`a` 占用 8 个字节，`b` 占用 8 个字节，以此类推。Go 的规则说如果结构体所有的字段都是可以比较的，那么结构体的值就是可以比较的。因此如果两个结构体所有的字段都相等，那么它们就相等。

```
a := S{1, 2, 3, 4}
b := S{1, 2, 3, 4}
fmt.Println(a == b) // 输出 true
```

编译器在底层使用 memcmp 来比较 `a` 的 32 个字节和 `b` 的 32 个字节。

### 填充和对齐

然而，在下面的场景下过分简单化的按位比较的策略会返回错误的结果：

```
type S struct {
    a byte
    b uint64
    c int16
    d uint32
}

func main()
    a := S{1, 2, 3, 4}
    b := S{1, 2, 3, 4}
    fmt.Println(a == b) // 输出 true
}
```

编译代码后，这个比较表达式的结果还是 `true`，但是编译器在底层并不能仅依赖比较 `a` 和 `b` 的位模式，因为结构体有*填充*。

Go 要求结构体的所有字段都对齐。2 字节的值必须从偶数地址开始，4 字节的值必须从 4 的倍数地址开始，以此类推    1 。编译器根据字段的类型和底层平台加入了填充来确保字段都*对齐*。在填充之后，编译器实际上看到的是    2 ：

```
type S struct {
    a byte
    _ [7]byte // 填充
    b uint64
    c int16
    _ [2]int16 // 填充
    d uint32
}
```

填充的存在保证了字段正确对齐，而填充确实占用了内存空间，但是填充字节的内容是未知的。你可能会认为在 Go 中 填充字节都是 0，但实际上并不是 — 填充字节的内容是未定义的。由于它们并不是被定义为某个确定的值，因此按位比较会因为分布在 `s` 的 24 字节中的 9 个填充字节不一样而返回错误结果。

Go 通过生成所谓的相等函数来解决这个问题。在这个例子中，`s` 的相等函数只比较函数中的字段略过填充部分，这样就能正确比较类型 `s` 的两个值。

### 类型算法

呵，这是个很大的设置，说明了为什么，对于 Go 程序中定义的每种类型，编译器都会生成几个支持函数，编译器内部把它们称作类型的算法。如果类型是一个映射的键，那么除相等函数外，编译器还会生成一个哈希函数。为了维持稳定，哈希函数在计算结果时也会像相等函数一样考虑诸如填充等因素。

凭直觉判断编译器什么时候生成这些函数实际上很难，有时并不明显，（因为）这超出了你的预期，而且链接器也很难消除没有被使用的函数，因为反射往往导致链接器在裁剪类型时变得更保守。

### 通过禁止比较来减小二进制文件的大小

现在，我们来解释一下 Brad 的修改。向类型添加一个不可比较的字段    3 ，结构体也随之变成不可比较的，从而强制编译器不再生成相等函数和哈希函数，规避了链接器对那些类型的消除，在实际应用中减小了生成的二进制文件的大小。作为这项技术的一个例子，下面的程序：

```
package main

import "fmt"

func main() {
    type t struct {
        // _ [0][]byte // 取消注释以阻止比较
        a byte
        b uint16
        c int32
        d uint64
    }
    var a t
    fmt.Println(a)
}
```

用 Go 1.14.2（darwin/amd64）编译，大小从 2174088 降到了 2174056，节省了 32 字节。单独看节省的这 32 字节似乎微不足道，但是考虑到你的程序中每个类型及其传递闭包都会生成相等和哈希函数，还有它们的依赖，这些函数的大小随类型大小和复杂度的不同而不同，禁止它们会大大减小最终的二进制文件的大小，效果比之前使用 `-ldflags="-s -w"` 还要好。

最后总结一下，如果你不想把类型定义为可比较的，可以在源码层级强制实现像这样的奇技淫巧，会使生成的二进制文件变小。

---

附录：在 Brad 的推动下，[Cherry Zhang](https://go-review.googlesource.com/c/go/+/231397) 和 [Keith Randall](https://go-review.googlesource.com/c/go/+/191198) 已经在 Go 1.15 做了大量的改进，修复了最严重的故障，消除了无用的相等和哈希函数（虽然我猜想这也是为了避免这类 CL 的扩散）。

#### 相关文章：

1. [Go 运行时如何高效地实现映射（不使用泛型）](https://dave.cheney.net/2018/05/29/how-the-go-runtime-implements-maps-efficiently-without-generics "How the Go runtime implements maps efficiently (without generics)")
2. [空结构体](https://dave.cheney.net/2014/03/25/the-empty-struct "The empty struct")
3. [填充很难](https://dave.cheney.net/2015/10/09/padding-is-hard "Padding is hard")
4. [Go 中有类型的 nil（2）](https://dave.cheney.net/2017/08/09/typed-nils-in-go-2 "Typed nils in Go 2")

---

1. 在 32 位平台上 `int64` 和 `unit64` 的值可能不是按 8 字节对齐的，因为平台原生的是以 4 字节对齐的。查看 [议题 599](https://github.com/golang/go/issues/599) 了解内部详细信息。 [↩](#fnref1)
2. 32 位平台会在 `a` 和 `b` 的声明中填充 `_ [3]byte`。参见前一条。 [↩](#fnref2)
3. Brad 使用的是`[0]func()`，但是所有能限制和禁止比较的类型都可以。添加了一个有 0 个元素的数组的声明后，结构体的大小和对齐不会受影响。 [↩](#fnref3)

---

via: <https://dave.cheney.net/2020/05/09/ensmallening-go-binaries-by-prohibiting-comparisons>

作者：[Dave Cheney](https://dave.cheney.net/author/davecheney) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lxbwolf](https://github.com/lxbwolf) 校对：[wxy](https://github.com/wxy)

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


在 Linux 文件系统中导航的技巧

# 在 Linux 文件系统中导航的技巧

>
> cd 命令可能是任何 Linux 用户学习的前 10 个命令之一，但这并不是在 Linux 文件系统中导航的唯一方法，这里还有其他一些方法。
>
>
>

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

无论你是在文件系统中四处查看、寻找文件还是尝试进入重要目录，Linux 都可以提供很多帮助。在本文中，我们将介绍一些技巧，使你可以在文件系统中移动，查找和使用所需的命令也更加轻松。

### 添加到 $PATH

确保你不必花费大量时间在 Linux 系统上查找命令的最简单、最有用的方法之一就是在 `$PATH` 变量中添加适当的目录。但是，添加到 `$PATH` 变量中的目录顺序非常重要。它们确定系统在目录中查找要运行命令的目录顺序–在找到第一个匹配项时停止。

例如，你可能希望将家目录放在第一个，这样，如果你创建的脚本与其他可执行文件有相同的名称，那么只要输入该脚本的名称，它便会运行。

要将家目录添加到 `$PATH` 变量中，可以执行以下操作：

```
$ export PATH=~:$PATH
```

`~` 字符代表家目录。

如果将脚本保存在 `bin` 目录中，下面的会有效：

```
$ export PATH=~/bin:$PATH
```

然后，你可以运行位于家目录中的脚本，如下所示：

```
$ myscript
Good morning, you just ran /home/myacct/bin/myscript
```

**重要提示：**上面显示的命令会添加到你的搜索路径中，因为 `$PATH`（当前路径）被包含在内。它们不会覆盖它。你的搜索路径应该在你的 `.bashrc` 文件中配置，任何你打算永久化的更改也应该添加到那里。

### 使用符号链接

符号链接提供了一种简单而明显的方式来记录可能经常需要使用的目录的位置。例如，如果你管理网站的内容，那么可能需要通过创建如下链接来使你的帐户“记住”网页文件的位置：

```
ln -s /var/www/html www
```

参数的顺序很重要。第一个（`/var/www/html`）是目标，第二个是你创建的链接的名称。如果你当前不在家目录中，那么以下命令将执行相同的操作：

```
ln -s /var/www/html ~/www
```

设置好之后，你可以使用 `cd www` 进入 `/var/www/html`。

### 使用 shopt

`shopt` 命令还提供了一种让移动到其他目录更加容易的方法。当你使用 `shopt` 的 `autocd` 选项时，只需输入名称即可转到目录。例如：

```
$ shopt -s autocd
$ www
cd -- www
/home/myacct/www
$ pwd -P
/var/www/html

$ ~/bin
cd -- /home/myacct/bin
$ pwd
/home/myacct/bin
```

在上面的第一组命令中，启用了 `shopt` 命令的 `autocd` 选项。输入 `www`，就会调用 `cd www` 命令。由于此符号链接是在上面的 `ln` 命令示例之一中创建的，因此将我们移至 `/var/www/html`。 `pwd -P` 命令显示实际位置。

在第二组中，键入 `~/bin` 会调用 `cd` 进入在用户家目录的 `bin` 目录。

请注意，当你输入的是命令时，`autocd` 行为将*不会*生效，即使它也是目录的名称。

`shopt` 是 bash 内置命令，它有很多选项。这只是意味着你不必在要进入每个目录的名称之前输入 `cd`。

要查看 `shopt` 的其他选项，只需输入 `shopt`。

### 使用 $CDPATH

可能进入特定目录的最有用技巧之一，就是将你希望能够轻松进入的路径添加到 `$CDPATH` 中。这将创建一个目录列表，只需输入完整路径名的一部分即可进入。

一方面，这可能有点棘手。你的 `$CDPATH` 需要包含要移动到的目录的父目录，而不是目录本身。

例如，假设你希望仅通过输入 `cd html` 就可以移至 `/var/www/html` 目录，并仅使用 `cd` 和简单目录名即可移至 `/var/log` 中的子目录。在这种情况下，此 `$CDPATH` 就可以起作用：

```
$ CDPATH=.:/var/log:/var/www
```

你将看到：

```
$ cd journal
/var/log/journal
$ cd html
/var/www/html
```

当你输入的不是完整路径时，`$CDPATH` 就会生效。它向下查看其目录列表，以查看指定的目录是否存在于其中一个目录中。找到匹配项后，它将带你到那里。

在 `$CDPATH` 开头保持 `.` 意味着你可以进入本地目录，而不必在 `$CDPATH` 中定义它们。

```
$ export CDPATH=".:$CDPATH"
$ Videos
cd -- Videos
/home/myacct/Videos
```

在 Linux 文件系统键切换并不难，但是如果你使用一些方便的技巧轻松地到达各个位置，那你可以节省一些大脑细胞。

---

via: <https://www.networkworld.com/article/3533421/tricks-for-getting-around-your-linux-file-system.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/) 荣誉推出


Summary: • 性能提升 10 倍，蚂蚁金服的 OceanBase 二次 TPC-C 测试结果公布

# 新闻速读 > 初代 Xbox 主机操作系统和 Windows NT 3.5 源码泄露

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

#### 初代 Xbox 主机操作系统和 Windows NT 3.5 源码泄露

据外媒 The Verge 的报道，微软初代 Xbox 游戏主机操作系统和 Windows NT 3.5 的源码已被泄露，在本月早些时候被泄露的代码已出现在互联网上。前者被泄露的代码包括初代 Xbox 主机操作系统的部分内容——操作系统内核（Windows 2000 的定制版本）。此外，Windows NT 3.5 接近最终版本的源码也出现在了互联网上。源代码包括了所有必要的构建工具，由于对 Windows NT 3.5 的支持已在 2001 年 12 月结束，而且该内核只在全球范围内的少数系统中使用，相信不会造成严重的安全问题。

来源：[开源中国](https://www.oschina.net/news/115858/xbox-source-code-leak-original-console-windows-3-5)

>
> 硬核老王点评：即便以现在的眼光，当年的 Windows NT 3.5 依然很棒。
>
>
>

#### 性能提升 10 倍，蚂蚁金服的 OceanBase 二次 TPC-C 测试结果公布

时隔半年，蚂蚁金服的自研数据库 OceanBase 又去做了 TPC-C 测试。TPC 去年 10 月 2 日和今年 5 月 20 日公布的测试结果显示，OceanBase 都是榜单第一。性能方面，去年 OceanBase 的测试结果是 6088万 tpmC，今年则是 7.07亿 tpmC；TPC-C benchmark 价格也从 ￥6.25/tpmC 降低到 ￥3.98/tpmC。不过，一些数据库公司，如 Oracle 并未参与这两次测试。之所以在短时间内做两次测试，是因为 OceanBase 团队认为首次测试尚未充分发挥 OceanBase 分布式架构的真正实力。

来源：[开源中国](https://www.oschina.net/news/115846/oceanbase-second-tpcc-news)

>
> 硬核老王点评：之前有人质疑 OceanBase 取得高评分是由于硬件的进步，所以这次重新参加测试应该是来证明其本身软件的提升。
>
>
>


如何在 Mac 上使用 pyenv 运行多个版本的 Python

# 如何在 Mac 上使用 pyenv 运行多个版本的 Python

>
> 如果你在 macOS 上运行的项目需要没有安装的 Python 版本，请试试 pyenv。
>
>
>

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

即使对于有经验的开发人员，管理本地 Python 开发环境仍然是一个挑战。尽管有详细的[软件包管理策略](https://opensource.com/article/19/4/managing-python-packages)，但仍需要采取另外的步骤来确保你在需要时运行所需的 Python 版本。

### 为什么 Python 版本重要？

起初这是一个奇怪的概念，但是编程语言会像其他任何软件一样发生变化。它们有错误、修复和更新，就像你喜欢的 [API](https://opensource.com/article/19/5/api-evolution-right-way) 和任何其他软件一样。同样，不同的发行版由称为[语义化版本](https://semver.org/)的三位数标识。

>
> ??? [pic.twitter.com/yt1Z2439W8](https://t.co/yt1Z2439W8)
>
>
> — Denny Perez (@dennyperez18) [May 28, 2019](https://twitter.com/dennyperez18/status/1133505310516232203?ref_src=twsrc%5Etfw)
>
>
>

多年来，Python 2 是该语言的常用主要版本。在 2020 年 1 月，Python 2 [到达最后寿命](https://opensource.com/article/19/11/end-of-life-python-2)，此后，Python 的核心维护者将仅支持 Python 3。Python 3 稳步发展，并定期发布新更新。对我来说定期获取这些更新很重要。

最近，我试图在 macOS 上运行一个依赖于 Python 3.5.9 的项目，而我的系统上并没有安装这个版本。我认为 Python 包管理器 `pip` 可以安装它，但事实并非如此：

```
$ pip install python3.5.9
Collecting python3.5.9
  ERROR: Could not find a version that satisfies the requirement python3.5.9 (from versions: none)
ERROR: No matching distribution found for python3.5.9
```

或者，我也可以从官方 Python 网站下载该版本，但我如何在我的 Mac 上与现有的 Python 版本一起运行？每次运行时指定 Python 解释器版本（例如 python3.7 或 python3.5）似乎很容易出错。一定会有更好的方法。

（说明：我知道这对经验丰富的 Python 开发人员没有意义，但对当时的我来说是有意义的。我很乐意谈一谈为什么我仍然认为它应该这样做。）

### 安装和设置 pyenv

值得庆幸的是，`pyenv` 可以绕开这一系列复杂的问题。首先，我需要安装 `pyenv`。我可以[从源码](https://github.com/pyenv/pyenv)克隆并编译它，但是我更喜欢通过 Homebrew 包管理器来管理软件包：

```
$ brew install pyenv
```

为了通过 `pyenv` 使用 Python 版本，必须了解 shell 的 `PATH` 变量。`PATH` 决定了 shell 通过命令的名称来搜索文件的位置。你必须确保 shell 程序能够找到通过 `pyenv` 运行的 Python 版本，而不是默认安装的版本（通常称为*系统版本*）。如果不更改路径，那么结果如下：

```
$ which python
/usr/bin/python
```

这是 Python 的系统版本。

要正确设置 `pyenv`，可以在 Bash 或 zsh 中运行以下命令：

```
$ PATH=$(pyenv root)/shims:$PATH
```

现在，如果你检查 Python 的版本，你会看到它是 `pyenv` 管理的版本：

```
$ which python
/Users/my_username/.pyenv/shims/python
```

该导出语句（`PATH=`）仅会对该 shell 实例进行更改，为了使更改永久生效，你需要将它添加到点文件当中。由于 zsh 是 macOS 的默认 shell，因此我将重点介绍它。将相同的语法添加到 `~/.zshrc` 文件中：

```
$ echo 'PATH=$(pyenv root)/shims:$PATH' >> ~/.zshrc
```

现在，每次我们在 zsh 中运行命令时，它将使用 `pyenv` 版本的 Python。请注意，我在 `echo` 中使用了单引号，因此它不会评估和扩展命令。

`.zshrc` 文件仅管理 zsh 实例，因此请确保检查你的 shell 程序并编辑关联的点文件。如果需要再次检查默认 shell 程序，可以运行 `echo $SHELL`。如果是 zsh，请使用上面的命令。如果你使用 Bash，请将 `~/.zshrc` 更改为 `~/.bashrc`。如果你想了解更多信息，可以在 `pyenv` 的 `README` 中深入研究[路径设置](https://github.com/pyenv/pyenv#understanding-path)。

### 使用 pyenv 管理 Python 版本

现在 `pyenv` 已经可用，我们可以看到它只有系统 Python 可用：

```
$ pyenv versions
system
```

如上所述，你绝对不想使用此版本（[阅读更多有关信息](https://opensource.com/article/19/5/python-3-default-mac)）。现在 `pyenv` 已正确设置，我希望它能有我经常使用的几个不同版本的 Python。

有一种方法可以通过运行 `pyenv install --list` 来查看 pyenv 可以访问的所有仓库中的所有 Python 版本。这是一个很长的列表，将来回顾的时候可能会有所帮助。目前，我决定在 [Python 下载页面](https://www.python.org/downloads/)找到的每个最新的“点版本”（3.5.x 或 3.6.x，其中 x 是最新的）。因此，我将安装 3.5.9 和 3.8.0：

```
$ pyenv install 3.5.9
$ pyenv install 3.8.0
```

这将需要一段时间，因此休息一会（或阅读上面的链接之一）。有趣的是，输出中显示了该版本的 Python 的下载和构建。例如，输出显示文件直接来自 [Python.org](http://python.org)。

安装完成后，你可以设置默认值。我喜欢最新的，因此将全局默认 Python 版本设置为最新版本：

```
$ pyenv global 3.8.0
```

该版本立即在我的 shell 中设置完成。确认一下：

```
$ python -V
Python 3.8.0
```

我要运行的项目仅适于 Python 3.5，因此我将在本地设置该版本并确认：

```
$ pyenv local 3.5.9
$ python -V
Python 3.5.9
```

因为我在 `pyenv` 中使用了 `local` 选项，所以它向当前目录添加了一个文件来跟踪该信息。

```
$ cat .python-version
3.5.9
```

现在，我终于可以为想要的项目设置虚拟环境，并确保运行正确版本的 Python。

```
$ python -m venv venv
$ source ./venv/bin/activate
(venv) $ which python
/Users/mbbroberg/Develop/my_project/venv/bin/python
```

要了解更多信息，请查看有关[在 Mac 上管理虚拟环境](/article-11086-1.html)的教程。

### 总结

默认情况下，运行多个 Python 版本可能是一个挑战。我发现 `pyenv` 可以确保在我需要时可以有我需要的 Python 版本。

你还有其他初学者或中级 Python 问题吗？ 请发表评论，我们将在以后的文章中考虑介绍它们。

---

via: <https://opensource.com/article/20/4/pyenv>

作者：[Matthew Broberg](https://opensource.com/users/mbbroberg) 选题：[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/) 荣誉推出


Lubuntu 20.04 点评：轻量、简约、文雅

# Lubuntu 20.04 点评：轻量、简约、文雅

>
> Lubuntu 20.04 LTS 与之前的 LTS 版本有很大的不同。它旨在给你一个更完善的体验，而不仅仅是关注旧电脑。请阅读更多关于 Lubuntu 20.04 的内容。
>
>
>

### Lubuntu 20.04 点评：第一个基于 LXQt 的长期支持版

我在 Lubuntu 20.04 发行前几天就已经开始使用它了。我通常使用 Arch 阵营中 Manjaro 和 Cinnamon 桌面，所以使用 Lubuntu 对我来说是一个愉快的改变。

以下是我在使用 Lubuntu 20.04.时的一些感受和注记。

#### 再见 LXDE，你好 LXQt！

长期以来，[Lubuntu](https://lubuntu.me/) 都依靠 [LXDE](https://github.com/lxde) 来提供轻量级的 Linux 体验。但现在，它使用的是 LXQt 桌面环境。

[LXDE](https://lxde.org/) 是基于 GTK（GNOME 所使用的库），更具体地说是基于 2020 年的 GTK+ 2。由于对 GTK+ 3 不满意，LXDE 开发人员 Hong Jen Yee 决定将整个桌面移植到 Qt（KDE 所使用的库）。LXDE 的 Qt 移植版本和 [Razor-qt](https://web.archive.org/web/20160220061334/http://razor-qt.org/) 项目合并形成 [LXQt](https://lxqt.org/)。所以现在，LXDE 和 LXQt 作为单独的项目而共存。

既然 LXDE 开发者本身专注于 LXQt，那么 Lubuntu 坚持使用三年多前上一次稳定发布版的桌面环境 LXDE 是没有意义的。

因此，Lubuntu 18.04 是使用 [LXDE](https://lxde.org/) 的最后一个版本。幸运的是，这是一个长期支持版本。Lubuntu 团队将提供支持直到 2021 年。

#### 不仅适于老机器

随着在 2020 年“老机器”的定义发生了变化，Lubuntu 18.04 成为了最后一个 32 位版本。现在，即使是一台 10 年前的老机器也至少有 2G 的内存和一个双核 64 位处理器。

因此，Lubuntu 团队将不再设置最低的系统需求，也不再主要关注旧硬件。尽管 LXQt 仍然是一个轻量级的、经典而不失精致的、功能丰富的桌面环境。

在 Lubuntu 20.04 LTS 发布之前，Lubuntu 的第一个 LXQt 发行版是 18.10，开发人员经历了三个标准发行版来完善 LXQt 桌面，这是一个很好的开发策略。

#### 不用常规的 Ubiquity，Lubuntu 20.04 使用的是 Calamares 安装程序

在新版本中使用了全新的 [Calamares](https://calamares.io/) 安装程序，取代了其它 [Ubuntu 官方版本](https://itsfoss.com/which-ubuntu-install/)使用的 Ubiquity 安装程序。

整个安装过程在大约能在 10 分钟内完成，比之前 Lubuntu 的版本稍微快一些。

由于镜像文件附带了预先安装的基本应用程序，所以你可以很快就可以完成系统的完全配置。

#### 不要直接从 Lubuntu 18.04 升级到 Lubuntu 20.04

通常，你可以[将 Ubuntu 从一个 LTS 版本升级到另一个 LTS 版本](https://itsfoss.com/upgrade-ubuntu-version/)。但是 Lubuntu 团队建议不要从 Lubuntu 18.04 升级到 20.04。他们建议重新安装，这才是正确的。

Lubuntu 18.04 使用 LXDE 桌面，20.04 使用 LXQt。由于桌面环境的巨大变化，从 18.04 升级到 20.04 将导致系统崩溃。

#### 更多的 KDE 和 Qt 应用程序

下面是在这个新版本中默认提供的一些应用程序，正如我们所看到的，并非所有应用程序都是轻量级的，而且大多数应用程序都是基于 Qt 的。

甚至使用的软件中心也是 KDE 的 Discover，而不是 Ubuntu 的 GNOME 软件中心。

* Ark – 归档文件管理器
* Bluedevil – 蓝牙连接管理
* Discover 软件中心 – 包管理系统
* FeatherPad – 文本编辑器
* FireFox – 浏览器
* K3b – CD/DVD 刻录器
* Kcalc – 计算器
* KDE 分区管理器 – 分区管理工具
* LibreOffice – 办公套件（Qt 界面版本）
* LXimage-Qt – 图片查看器及截图制作
* Muon – 包管理器
* Noblenote – 笔记工具
* PCManFM-Qt – 文件管理器
* Qlipper – 剪贴板管理工具
* qPDFview – PDF 阅读器
* PulseAudio – 音频控制器
* Qtransmission – BT 下载工具（Qt 界面版本）
* Quassel – IRC 客户端
* ScreenGrab – 截屏制作工具
* Skanlite – 扫描工具
* 启动盘创建工具 – USB 启动盘制作工具
* Trojita – 邮件客户端
* VLC – 媒体播放器
* [MPV 视频播放器](https://itsfoss.com/mpv-video-player/)

#### 测试 Lubuntu 20.04 LTS

LXQt 版 Lubuntu 的启动时间不到一分钟，虽然是从 SSD 启动的。

LXQt 目前需要的内存比基于 Gtk+ 2 的 LXDE 稍微多一点，但是另一种 Gtk+ 3 工具包也需要更多的内存。

在重新启动之后，系统以非常低的内存占用情况运行，大约只有 340 MB（按照现代标准），比 LXDE 多 100 MB。

LXQt 不仅适用于硬件较旧的用户，也适用于那些希望在新机器上获得简约经典体验的用户。

桌面布局看起来类似于 KDE 的 Plasma 桌面，你觉得呢?

在左下角有一个应用程序菜单，一个用于显示固定和活动的应用程序的任务栏，右下角有一个系统托盘。

Lubuntu 的 LXQt 版本可以很容易的定制，所有的东西都在菜单的首选项下，大部分的关键项目都在 LXQt “设置”中。

值得一提的是，LXQt 在默认情况下使用流行的 [Openbox 窗口管理器](https://en.wikipedia.org/wiki/Openbox)。

与前三个发行版一样，20.04 LTS 附带了一个默认的黑暗主题 Lubuntu Arc，但是如果不适合你的口味，可以快速更换，也很方便。

就日常使用而言，事实证明，Lubuntu 20.04 向我证明，其实每一个 Ubuntu 的分支版本都完全没有问题。

#### 结论

Lubuntu 团队已经成功地过渡到一个现代的、依然轻量级的、极简的桌面环境。LXDE 看起来被遗弃了，迁移到一个活跃的项目也是一件好事。

我希望 Lubuntu 20.04 能够让你和我一样热爱，如果是这样，请在下面的评论中告诉我。请继续关注!

---

via: <https://itsfoss.com/lubuntu-20-04-review/>

作者：[Dimitrios Savvopoulos](https://itsfoss.com/author/dimitrios/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qfzy1233](https://github.com/qfzy1233) 校对：[wxy](https://github.com/wxy)

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


新闻速读 > Twitter CEO：自动化会甚至会对编程工作构成威胁

Summary: • 多个 DNS 解析程序漏洞允许攻击者发动拒绝服务攻击 • GNOME 基金会和 RPI 的专利诉讼案达成和解 • 安全研究人员分析过去几年发生的开源软件供应链攻击 • 微软开源 1983 年的 GW-BASIC

# 新闻速读 > Twitter CEO：自动化会甚至会对编程工作构成威胁

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

#### Twitter CEO：自动化会甚至会对编程工作构成威胁

Twitter CEO Jack Dorsey 表示，“机器学习和深度学习的许多目标是随着时间的发展编写软件本身，因此许多初级级编程工作将不再那么重要了，”

来源：[新浪科技](https://www.cnbeta.com/articles/tech/982339.htm)

>
> 硬核老王点评：毕竟“初级”编程工作也是要被取代的初级工种之一。
>
>
>

#### 多个 DNS 解析程序漏洞允许攻击者发动拒绝服务攻击

该漏洞被称为 NXNSAttack。DNS 解析程序不能向“名字”发送域名查询，因此解析器首先需要获得权威 DNS 服务器的 IPv4 或 IPv6 地址，之后才能继续查询域名。NXNSAttack 就是基于这一原理，攻击者发送的委托包含了假的权威服务器名字，指向受害者的 DNS 服务器，迫使解析程序对受害者的 DNS 服务器生成查询。一次查询会被放大数十次乃至数百次，对受害者服务器发动了拒绝服务攻击。众多 DNS 软件都受到影响，其中包括 BIND、 Unbound、PowerDNS、Cloudflare、Google、Amazon、Microsoft、Oracle（DYN）、Verisign、IBM Quad9 和 ICANN。

来源：[solidot](https://www.solidot.org/story?sid=64443)

>
> 硬核老王点评：互联网建设和设计之初，并没有考虑到这么复杂的安全隐患，或者说考虑到了在当时也只能暂时忽视。随着互联网的发展，这种早期的协议上的漏洞会逐一被发现、修补和迭代。
>
>
>

#### GNOME 基金会和 RPI 的专利诉讼案达成和解

去年 9 月，Rothschild Patent Imaging LLC（RPI）的公司对 GNOME 基金会提起了专利侵权诉讼，指控 GNOME 桌面环境项目中的一个组件 Shotwell 照片管理器侵犯了它于 2008 年申请的专利，该专利描述了无线连接图像捕捉设备和接收设备的系统和方法。现在，GNOME 与 RPI 达成和解，RPI 并承诺不再对 GNOME 提起任何专利诉讼。此外，RPI 和 Leigh Rothschild 的专利免除和承诺覆盖了在 OSI 批准的所有开源许可证下发布的软件。

来源：[solidot](https://www.solidot.org/story?sid=64439)

>
> 硬核老王点评：妄想从开源社区/开源组织身上咬下一块肉，先要看看是否能承受社会压力。
>
>
>

#### 安全研究人员分析过去几年发生的开源软件供应链攻击

软件供应链攻击有两类：其一是在软件产品中植入恶意代码去感染终端用户，此类攻击的一个例子是 CCleaner 的恶意版本通过官网传播给终端用户，它在长达一个多月时间里被下载了 230 万次。另一类软件供应链攻击是向软件产品的依赖包植入恶意代码。随着开源软件开发模式的流行，此类的攻击日益常见。研究人员分析了 npm、PyPI 和 RubyGems 软件包管理系统发现的 174 个恶意依赖包，他们发现 56% 的软件包在安装时触发恶意行为，41% 使用额外的条件去判断是否运行。61% 的恶意软件包利用了名字相似性向开源生态系统植入恶意包。攻击者的主要目的是析取数据。

来源：[solidot](https://www.solidot.org/story?sid=64445)

>
> 硬核老王点评：开源软件本身这个模式并不能决定是否安全，只是给用户一个安全的可能性。所以，在享受开源软件的福利时，其带来的可能的隐患也需要重视，并可能付出不菲的成本和代价。
>
>
>

#### 微软开源 1983 年的 GW-BASIC

微软在历史参考和教育目的的名义下开源了 1983 年的 GW-BASIC，源代码托管在 GitHub 上，采用 MIT 许可证。微软表示他们不接受修改任何代码的 PR 请求。GW-BASIC 是源自 IBM Advanced BASIC/BASICA 的 BASIC 解释器。微软不同的 BASIC 实现都可以上溯到比尔盖茨和保罗艾伦完成的微软首个产品：Altair 8800 BASIC 解释器。和 70/80 年代的众多软件一样，GW-BASIC 的源代码是百分之百的汇编语言。

来源：[solidot](https://www.solidot.org/story?sid=64444)

>
> 硬核老王点评：反正放家里也是烂着，就当成古董给大家把玩吧。
>
>
>


使用子模块和子树来管理 Git 项目

Summary: 使用子模块和子树来帮助你管理多个存储库中共有的子项目。

使用子模块和子树来帮助你管理多个存储库中共有的子项目。

# 使用子模块和子树来管理 Git 项目

>
> 使用子模块和子树来帮助你管理多个存储库中共有的子项目。
>
>
>

如果你参与了开源项目的开发，那么你很可能已经用了 Git 来管理你的源码。你可能遇到过有很多依赖和/或子项目的项目。你是如何管理它们的？

对于一个开源组织，要实现社区**和**产品的单一来源文档和依赖管理比较棘手。文档和项目往往会碎片化和变得冗余，这致使它们很难维护。

### 必要性

假设你想把单个项目作为一个存储库内的子项目，传统的方法是把该项目复制到父存储库中，但是，如果你想要在多个父项目中使用同一个子项目呢？如果把子项目复制到所有父项目中，当有更新时，你都要在每个父项目中做修改，这是不太可行的。这会导致父项目中的冗余和数据不一致，使更新和维护子项目变得很困难。

### Git 子模块和子树

如果你可以用一条命令把一个项目放进另一个项目中，会怎样呢？如果你随时可以把一个项目作为子项目添加到任意数目的项目中，并可以同步更新修改呢？Git 提供了这类问题的解决方案：Git <ruby> 子模块 <rt>  submodule </rt></ruby>和 Git <ruby> 子树 <rt>  subtree </rt></ruby>。创建这些工具的目的是以更加模块化的水平来支持共用代码的开发工作流，旨在 Git 存储库<ruby> 源码管理 <rt>  source-code management </rt></ruby>（SCM）与它下面的子树之间架起一座桥梁。

*生长在桑树上的樱桃树*

下面是本文要详细介绍的概念的一个真实应用场景。如果你已经很熟悉树形结构，这个模型看起来是下面这样：

### Git 子模块是什么？

Git 在它默认的包中提供了子模块，子模块可以把 Git 存储库嵌入到其他存储库中。确切地说，Git 子模块指向子树中的某次提交。下面是我 [Docs-test](https://github.com/manaswinidas/Docs-test/) GitHub 存储库中的 Git 子模块的样子：

[文件夹@提交 Id](mailto:folder@commitId) 格式表明这个存储库是一个子模块，你可以直接点击文件夹进入该子树。名为 `.gitmodules` 的配置文件包含所有子模块存储库的详细信息。我的存储库的 `.gitmodules` 文件如下：

你可以用下面的命令在你的存储库中使用 Git 子模块：

#### 克隆一个存储库并加载子模块

克隆一个含有子模块的存储库：

```
$ git clone --recursive <URL to Git repo>
```

如果你之前已经克隆了存储库，现在想加载它的子模块：

```
$ git submodule update --init
```

如果有嵌套的子模块：

```
$ git submodule update --init --recursive
```

#### 下载子模块

串行地连续下载多个子模块是很枯燥的工作，所以 `clone` 和 `submodule update` 会支持 `--jobs` （或 `-j`）参数：

例如，想一次下载 8 个子模块，使用：

```
$ git submodule update --init --recursive -j 8
$ git clone --recursive --jobs 8 <URL to Git repo>
```

#### 拉取子模块

在运行或构建父项目之前，你需要确保依赖的子项目都是最新的。

拉取子模块的所有修改：

```
$ git submodule update --remote
```

#### 使用子模块创建存储库：

向一个父存储库添加子树：

```
$ git submodule add <URL to Git repo>
```

初始化一个已存在的 Git 子模块：

```
$ git submodule init
```

你也可以通过为 `submodule update` 命令添加 `--update` 参数在子模块中创建分支和追踪提交：

```
$ git submodule update --remote
```

#### 更新子模块的提交

上面提到过，一个子模块就是一个指向子树中某次提交的链接。如果你想更新子模块的提交，不要担心。你不需要显式地指定最新的提交。你只需要使用通用的 `submodule update` 命令：

```
$ git submodule update
```

就像你平时创建父存储库和把父存储库推送到 GitHub 那样添加和提交就可以了。

#### 从一个父存储库中删除一个子模块

仅仅手动删除一个子项目文件夹不会从父项目中移除这个子项目。想要删除名为 `childmodule` 的子模块，使用：

```
$ git rm -f childmodule
```

虽然 Git 子模块看起来很容易上手，但是对于初学者来说，有一定的使用门槛。

### Git 子树是什么？

Git <ruby> 子树 <rt>  subtree </rt></ruby>，是在 Git 1.7.11 引入的，让你可以把任何存储库的副本作为子目录嵌入另一个存储库中。它是 Git 项目可以注入和管理项目依赖的几种方法之一。它在常规的提交中保存了外部依赖信息。Git 子树提供了整洁的集成点，因此很容易复原它们。

如果你参考 [GitHub 提供的子树教程](https://help.github.com/en/github/using-git/about-git-subtree-merges)来使用子树，那么无论你什么时候添加子树，在本地都不会看到 `.gittrees` 配置文件。这让我们很难分辨哪个是子树，因为它们看起来很像普通的文件夹，但是它们却是子树的副本。默认的 Git 包中不提供带 `.gittrees` 配置文件的 Git 子树版本，因此如果你想要带 `.gittrees` 配置文件的 git-subtree 命令，必须从 Git 源码存储库的 [/contrib/subtree 文件夹](https://github.com/git/git/tree/master/contrib/subtree) 下载 git-subtree。

你可以像克隆其他常规的存储库那样克隆任何含有子树的存储库，但由于在父存储库中有整个子树的副本，因此克隆过程可能会持续很长时间。

你可以用下面的命令在你的存储库中使用 Git 子树。

#### 向父存储库中添加一个子树

想要向父存储库中添加一个子树，首先你需要执行 `remote add`，之后执行 `subtree add` 命令：

```
$ git remote add remote-name <URL to Git repo>
$ git subtree add --prefix=folder/ remote-name <URL to Git repo> subtree-branchname
```

上面的命令会把整个子项目的提交历史合并到父存储库。

#### 向子树推送修改以及从子树拉取修改

```
$ git subtree push-all
```

或者

```
$ git subtree pull-all
```

### 你应该使用哪个？

任何工具都有优缺点。下面是一些可能会帮助你决定哪种最适合你的特性：

* Git 子模块的存储库占用空间更小，因为它们只是指向子项目的某次提交的链接，而 Git 子树保存了整个子项目及其提交历史。
* Git 子模块需要在服务器中可访问，但子树是去中心化的。
* Git 子模块大量用于基于组件的开发，而 Git 子树多用于基于系统的开发。

Git 子树并不是 Git 子模块的直接可替代项。有明确的说明来指导我们该使用哪种。如果有一个归属于你的外部存储库，使用场景是向它回推代码，那么就使用 Git 子模块，因为推送代码更容易。如果你有第三方代码，且不会向它推送代码，那么使用 Git 子树，因为拉取代码更容易。

自己尝试使用 Git 子树和子模块，然后在评论中留下你的使用感想。

---

via: <https://opensource.com/article/20/5/git-submodules-subtrees>

作者：[Manaswini Das](https://opensource.com/users/manaswinidas) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lxbwolf](https://github.com/lxbwolf) 校对：[wxy](https://github.com/wxy)

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


Git/GitHub 中文术语表

Summary: 我们根据 GitHub 等文档，收集整理了部分常用的 Git 和 GitHub 中的术语的中文定名及其解释。

ID=身份或标识<br />
...

clean也可译作“清理”

哈希是普通话版的音译，意译还有另外一个词“散列码”

tag没提到，可以考虑译为“（打）标记”，与label区别开

watch可译为“关注”

# Git/GitHub 中文术语表

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

Git 和 GitHub 已经成为了开发者的基础工具，尤其是参与开源软件开发时经常会使用它们。但是在 Git 和 GitHub 使用过程中遇到的很多术语并没有标准的或约定俗成的中文译名，因此，我们根据 [GitHub](https://help.github.com/cn/github/getting-started-with-github/github-glossary) 、[Git](https://mirrors.edge.kernel.org/pub/software/scm/git/docs/gitglossary.html) 等文档，并结合我们的翻译惯例，收集整理了 Git 和 GitHub 中常用术语的中文译名及其解释。

这里值得注意是术语有复刻、挂钩、议题、星标、变基、仓库等，这些术语之前要么经常中英文混杂使用，要么中文译法不确定，我们根据多年的翻译和开发经验，在 GitHub 译法的基础上进行斟酌，整理了如下的术语表供大家使用参考。此外，“复刻”这个翻译应该是我们 [LCTT 首倡](/article-7877-1.html)的；而“议题”这个对 issue 的译法也比之前的一些其它译法更为精准；“仓库”一词还有存储库、版本库等译法，但是仓库一词似乎更加合适。

##### <ruby> 受让人 <rp>  （ </rp> <rt>  assignee </rt> <rp>  ） </rp></ruby>

分配到某个议题的用户。

##### <ruby> 追溯 <rp>  （ </rp> <rt>  blame </rt> <rp>  ） </rp></ruby>

Git 中的“追溯”功能描述对文件每行的最新修改，一般会显示修订、作者和时间。这很有用，例如，可以跟踪何时添加了功能，或者哪个提交导致了特定漏洞。

##### <ruby> 分支 <rp>  （ </rp> <rt>  branch </rt> <rp>  ） </rp></ruby>

分支是仓库的平行版本。它包含在仓库中，但不影响主要或 master 分支，可让你自由工作而不中断“即时”版本。在执行所需的更改后，可以将分支合并回 master 分支以发布更改。

##### <ruby> 检出 <rp>  （ </rp> <rt>  checkout </rt> <rp>  ） </rp></ruby>

你可以在命令行上使用 `git checkout` 创建新分支，将当前的工作分支更改为不同的分支，甚至使用 `git checkout [branchname] [path to file]`从不同的分支切换到不同版本的文件。“检出”操作会使用对象数据库中的树对象或 blob 更新工作树的全部或部分，以及更新索引和 HEAD（如果整个工作树指向新分支）。

##### <ruby> 优选 <rp>  （ </rp> <rt>  cherry-picking </rt> <rp>  ） </rp></ruby>

从一系列更改（通常是提交）中选择一部分更改，并在不同的代码库上将它们记录为新的更改系列。在 Git 中，这通过 `git cherry-pick` 命令来执行，在另一个分支上解压缩现有提交引入的更改，并根据当前分支的提示将其记录为新提交。

##### <ruby> 清洁 <rp>  （ </rp> <rt>  clean </rt> <rp>  ） </rp></ruby>

工作树在对应当前头部引用的版本时是清洁的。另请参阅“脏”。

##### <ruby> 克隆 <rp>  （ </rp> <rt>  clone </rt> <rp>  ） </rp></ruby>

克隆是指存在于计算机上而非网站服务器其他位置的仓库副本，或者是复制的操作。在克隆时，可在首选编辑器中编辑文件，使用 Git 跟踪更改而无需保持在线。你克隆的仓库仍与远程版本连接，以便当你在线时将本地更改推送到远程，以保持同步。

##### <ruby> 行为准则 <rp>  （ </rp> <rt>  code of conduct </rt> <rp>  ） </rp></ruby>

为如何参与社区制定标准的文档。

##### <ruby> 代码所有者 <rp>  （ </rp> <rt>  code owner </rt> <rp>  ） </rp></ruby>

被指定为部分仓库代码所有者的个人。当有人打开对代码所有者拥有的代码进行更改的拉取请求（非草稿模式）时，会自动申请代码所有者审查。

##### <ruby> 协作者 <rp>  （ </rp> <rt>  collaborator </rt> <rp>  ） </rp></ruby>

协作者是受仓库所有者邀请参与，对仓库拥有读取和写入权限的人。

##### <ruby> 提交 <rp>  （ </rp> <rt>  commit </rt> <rp>  ） </rp></ruby>

提交或“修订”是对一个文件（或一组文件）的个别更改。在进行提交以保存工作时，Git 会创建唯一的 ID（也称为 "SHA" 或“哈希”），用于记录提交的特定更改以及提交者和提交时间。提交通常包含一条提交消息，其中简要说明所做的更改。

##### <ruby> 提交作者 <rp>  （ </rp> <rt>  commit author </rt> <rp>  ） </rp></ruby>

进行提交的用户。

##### <ruby> 提交 ID <rp>  （ </rp> <rt>  commit ID </rt> <rp>  ） </rp></ruby>

也称为 SHA。用于识别提交的 40 字符校验和的哈希。

##### <ruby> 提交消息 <rp>  （ </rp> <rt>  commit message </rt> <rp>  ） </rp></ruby>

随附于提交的简短描述性文字，用于沟通提交引入的更改。

##### <ruby> 持续集成 <rp>  （ </rp> <rt>  continuous integration </rt> <rp>  ） </rp></ruby>

也称为 CI。在个人对 GitHub 上配置的仓库提交更改后运行自动化构建和测试的过程。CI 是软件开发中一种帮助检测错误的常用最佳实践。

##### <ruby> 贡献指南 <rp>  （ </rp> <rt>  contribution guidelines </rt> <rp>  ） </rp></ruby>

说明人们应如何参与项目的文档。

##### <ruby> 贡献 <rp>  （ </rp> <rt>  contributions </rt> <rp>  ） </rp></ruby>

GitHub 上的特定活动。

##### <ruby> 贡献者 <rp>  （ </rp> <rt>  contributor </rt> <rp>  ） </rp></ruby>

贡献者是指对仓库没有协作者权限但参与过项目，并且他们打开的拉取请求已合并到仓库的人员。

##### <ruby> 默认分支 <rp>  （ </rp> <rt>  default branch </rt> <rp>  ） </rp></ruby>

仓库中的基本分支，除非你指定不同的分支，否则会自动对它完成所有拉取请求和代码提交。此分支通常称为 `master`。

##### <ruby> 游离的 HEAD <rp>  （ </rp> <rt>  detached HEAD </rt> <rp>  ） </rp></ruby>

如果你操作的是游离的 HEAD，Git 将会警告你，这意味着 Git 不指向某个分支，并且你的任何提交都不会出现在提交历史记录中。例如，在检出并非任何特定分支最新提交的任意提交时，你操作的是“游离的 HEAD”。

##### <ruby> 差异 <rp>  （ </rp> <rt>  diff </rt> <rp>  ） </rp></ruby>

差异是指两个提交之间的更改或保存的更改之间的区别，它将从视觉上描述文件自上次提交后添加或删除的内容。

##### <ruby> 脏 <rp>  （ </rp> <rt>  dirty </rt> <rp>  ） </rp></ruby>

工作树如果包含尚未提交到当前分支的更改，将被视为“脏”。

##### <ruby> 快进 <rp>  （ </rp> <rt>  fast-forward </rt> <rp>  ） </rp></ruby>

快进是一种特殊类型的合并，在其中你有修订以及“合并”另一个分支的更改作为现有分支的子系。在这种情况下，你无法进行新的合并提交，而只是更新此修订。这在远程仓库的远程跟踪分支中经常发生。

##### <ruby> 功能分支 <rp>  （ </rp> <rt>  feature branch </rt> <rp>  ） </rp></ruby>

用于试验新功能或修复未正式使用的议题的分支。也称为主题分支。

##### <ruby> 围栏代码块 <rp>  （ </rp> <rt>  fenced code block </rt> <rp>  ） </rp></ruby>

你可以在代码块前后使用三个反引号 `````，通过 GitHub Flavored Markdown 创建缩进代码块。

##### <ruby> 获取 <rp>  （ </rp> <rt>  fetch </rt> <rp>  ） </rp></ruby>

在使用 `git fetch` 时，你将从远程仓库添加更改到本地工作分支，而不提交它们。与 `git pull` 不同，提取可让你在更改提交到本地分支之前先进行审查。

##### <ruby> 跟进（用户） <rp>  （ </rp> <rt>  following (users) </rt> <rp>  ） </rp></ruby>

获取关于另一个用户的贡献和活动的通知。

##### <ruby> 强制推送 <rp>  （ </rp> <rt>  force push </rt> <rp>  ） </rp></ruby>

一种使用本地更改覆盖远程仓库的 Git 推送，不管是否冲突。

##### <ruby> 复刻 <rp>  （ </rp> <rt>  fork </rt> <rp>  ） </rp></ruby>

复刻是其他用户仓库在你的帐户上的个人副本。复刻允许你自由更改项目而不影响原始上游仓库。你也可以在上游仓库中打开拉取请求，并使复刻同步最新的更改，因为两个仓库仍然互相连接。

##### gitfile

一种普通的 `.git` 文件，始终位于工作树的根部，指向 Git 目录，包含整个 Git 仓库及其元数据。你可以在命令行上使用 `git rev-parse --git-dir` 查看仓库（实际仓库）的此文件。

##### HEAD

当前分支。

##### <ruby> 挂钩 <rp>  （ </rp> <rt>  hook </rt> <rp>  ） </rp></ruby>

在多个 Git 命令正常执行时，对可选脚本进行标注以允许开发者添加功能或检查。通常，挂钩允许预先验证和潜在中止命令，并且允许在操作完成后再发事后通知。

##### <ruby> 实例 <rp>  （ </rp> <rt>  instance </rt> <rp>  ） </rp></ruby>

组织包含在其配置和控制的虚拟机中的 GitHub 私有副本。

##### <ruby> 议题 <rp>  （ </rp> <rt>  issue </rt> <rp>  ） </rp></ruby>

议题是提议的与仓库相关的改进、任务或问题。（对于公共仓库）任何人都可创建议题，然后由仓库协作者调解。每个议题都包含自己的讨论线程。你也可以使用标签将议题归类并分配到某人。

##### <ruby> 密钥指纹 <rp>  （ </rp> <rt>  key fingerprint </rt> <rp>  ） </rp></ruby>

用于识别较长公钥的简短字节系列。

##### <ruby> 关键词 <rp>  （ </rp> <rt>  keyword </rt> <rp>  ） </rp></ruby>

用在拉取请求中时关闭议题的特定文字。

##### <ruby> 标签 <rp>  （ </rp> <rt>  label </rt> <rp>  ） </rp></ruby>

议题或拉取请求的标记。仓库随附一系列默认标签，但用户也可创建自定义标签。

##### LFS

Git Large File Storage。一种开源 Git 扩展，用于对大文件进行版本控制。

##### <ruby> 许可证 <rp>  （ </rp> <rt>  license </rt> <rp>  ） </rp></ruby>

一种可随附于项目的文档，告知们能够对你的源代码执行哪些操作，不能执行哪些操作。

##### <ruby> 行注释 <rp>  （ </rp> <rt>  line comment </rt> <rp>  ） </rp></ruby>

拉取请求内特定代码行上的评论。

##### <ruby> 主干 <rp>  （ </rp> <rt>  master </rt> <rp>  ） </rp></ruby>

默认开发分支。只要创建 Git 仓库，就会创建一个名为 `master` 的分支，并且它会变为活动的分支。大多数情况下，这包含本地开发，但纯属惯例，而非必需。

##### <ruby> 提及 <rp>  （ </rp> <rt>  mention </rt> <rp>  ） </rp></ruby>

一种通过在用户名前加上 @ 符号来发送给用户的通知。GitHub 上组织中的用户也可成为可提及的团队一部分。

##### <ruby> 合并 <rp>  （ </rp> <rt>  merge </rt> <rp>  ） </rp></ruby>

合并是从一个分支（在相同的仓库中或来自一个分叉）提取更改，然后将其应用到另一个分支。这通常是作为“拉取请求”（可视为请求合并）或通过命令行完成。如果没有冲突的更改，可通过 GitHub.com web 界面使用拉取请求完成合并，或始终通过命令行完成。

##### <ruby> 合并冲突 <rp>  （ </rp> <rt>  merge conflict </rt> <rp>  ） </rp></ruby>

合并的分支之间发生的差异。当人们对同一文件的同一行进行不同的更改时，或者一个人编辑某文件而另一个人删除该文件时，就会发生合并冲突。必须解决合并冲突后才可合并分支。

##### <ruby> 合并请求 <rp>  （ </rp> <rt>  merge request </rt> <rp>  ） </rp></ruby>

合并请求（MR）是 GitLab 上类似于 GitHub 上的拉取请求的概念。

##### <ruby> 里程碑 <rp>  （ </rp> <rt>  milestone </rt> <rp>  ） </rp></ruby>

一种跟踪仓库中议题或拉取请求组进度的方式。

##### <ruby> 镜像 <rp>  （ </rp> <rt>  mirror </rt> <rp>  ） </rp></ruby>

仓库的新副本。

##### <ruby> 非快进 <rp>  （ </rp> <rt>  non-fast-forward </rt> <rp>  ） </rp></ruby>

当仓库的本地副本未与上游仓库同步时，你在推送本地更改之前需要提取上游更改。

##### <ruby> 通知 <rp>  （ </rp> <rt>  notification </rt> <rp>  ） </rp></ruby>

web 或电子邮件（根据你的设置）传送的更新，提供你感兴趣的活动的相关信息。

##### <ruby> 外部协作者 <rp>  （ </rp> <rt>  outside collaborator </rt> <rp>  ） </rp></ruby>

已被授予访问一个或多个组织的仓库但对组织没有其他访问权限的用户，且不属于组织的成员。

##### <ruby> 开源 <rp>  （ </rp> <rt>  open source </rt> <rp>  ） </rp></ruby>

开源软件是可供任何人自由使用、修改和共享（以修改和未修改的形式）的软件。今天，“开源”的概念通常扩展到软件以外，代表一种协作原则，其中工作材料在线供任何人分叉、修改、讨论和参与。

##### <ruby> 源 <rp>  （ </rp> <rt>  origin </rt> <rp>  ） </rp></ruby>

默认上游仓库。大多数项目至少有一个它们跟踪的上游项目。默认情况下，源用于该目的。

##### <ruby> 所有者 <rp>  （ </rp> <rt>  owner </rt> <rp>  ） </rp></ruby>

对组织有完全管理权限的组织成员。

##### <ruby> 私有贡献 <rp>  （ </rp> <rt>  private contributions </rt> <rp>  ） </rp></ruby>

对私有（与公共相对）仓库的贡献。

##### <ruby> 私有仓库 <rp>  （ </rp> <rt>  private repository </rt> <rp>  ） </rp></ruby>

私有仓库仅对仓库所有者和所有者指定的协作者可见。

##### <ruby> 生产分支 <rp>  （ </rp> <rt>  production branch </rt> <rp>  ） </rp></ruby>

包含可使用或部署到应用程序或站点的最终更改的分支。

##### <ruby> 个人资料 <rp>  （ </rp> <rt>  profile </rt> <rp>  ） </rp></ruby>

显示 GitHub 上用户活动相关信息的页面。

##### <ruby> 受保护分支 <rp>  （ </rp> <rt>  protected branch </rt> <rp>  ） </rp></ruby>

受保护分支在仓库管理员选择保护的分支上禁止多项 Git 功能。必要检查未通过或必需审查未批准，不能对它们执行强制推送、删除和更改合并，或者不能从 GitHub web 界面上传文件到其中。受保护分支通常是默认分支。

##### <ruby> 公共贡献 <rp>  （ </rp> <rt>  public contributions </rt> <rp>  ） </rp></ruby>

对公共（与私有相对）仓库的贡献。

##### <ruby> 公共仓库 <rp>  （ </rp> <rt>  public repository </rt> <rp>  ） </rp></ruby>

公共仓库可供任何人查看，包括不是 GitHub 用户的人员。

##### <ruby> 拉取 <rp>  （ </rp> <rt>  pull </rt> <rp>  ） </rp></ruby>

拉取是指提取与合并更改。例如，如果有人编辑了你操作的远程文件，你要将这些更改拉取到本地副本，以使其保持最新。另请参阅“提取”。

##### <ruby> 拉取权限 <rp>  （ </rp> <rt>  pull access </rt> <rp>  ） </rp></ruby>

读取权限的同义词。

##### <ruby> 拉取请求 <rp>  （ </rp> <rt>  pull request </rt> <rp>  ） </rp></ruby>

拉取请求（PR）是提议更改用户提交的仓库，然后被仓库协作者接受或拒绝。像议题一样，每个拉取请求都有自己的论坛。

##### <ruby> 拉取请求审查 <rp>  （ </rp> <rt>  pull request review </rt> <rp>  ） </rp></ruby>

拉取请求中协作者批准更改或在拉取请求合并之前申请进一步更改的评论。

##### <ruby> 推送 <rp>  （ </rp> <rt>  push </rt> <rp>  ） </rp></ruby>

推送是指将提交的更改发送到 GitHub.com 上的远程仓库。例如，如果你在本地更改内容，便可推送这些更改，让其他人访问。

##### <ruby> 推送分支 <rp>  （ </rp> <rt>  push a branch </rt> <rp>  ） </rp></ruby>

成功将分支推送到远程仓库后，使用本地分支中的更改来更新远程分支。在你“推送分支”时，Git 将会到远程仓库中搜索分支的头部引用，并验证它是分支本地头部引用的直系原型。在验证后，Git 将拉取所有对象（从本地头部引用可获取，而远程仓库中缺失）到远程对象数据库，然后更新远程头部引用。如果远程头部不是本地头部的原型，推送将会失败。

##### <ruby> 推送权限 <rp>  （ </rp> <rt>  push access </rt> <rp>  ） </rp></ruby>

写入权限的同义词。

##### <ruby> 读取权限 <rp>  （ </rp> <rt>  read access </rt> <rp>  ） </rp></ruby>

对仓库的权限级别，允许用户拉取或者读取仓库中的信息。所有公共仓库向所有 GitHub 用户授予读取权限。拉取权限的同义词。

##### <ruby> 自述文件 <rp>  （ </rp> <rt>  README </rt> <rp>  ） </rp></ruby>

包含仓库中文件相关信息的文本文件，通常是仓库访问者看到的第一个文件。自述文件连同仓库许可证、参与指南以及行为准则，帮助你交流要求和管理项目的参与。

##### <ruby> 变基 <rp>  （ </rp> <rt>  rebase </rt> <rp>  ） </rp></ruby>

将一系列更改从一个分支重新应用到不同的基本分支，并将该分支的头部重置为结果。

##### <ruby> 发布 <rp>  （ </rp> <rt>  release </rt> <rp>  ） </rp></ruby>

GitHub 封装软件并向用户提供软件的方式。

##### <ruby> 远程 <rp>  （ </rp> <rt>  remote </rt> <rp>  ） </rp></ruby>

这是托管于服务器（很可能是 GitHub.com）上的仓库或分支版本。远程版本可以连接到本地克隆，以使更改保持同步。

##### <ruby> 远程仓库 <rp>  （ </rp> <rt>  remote repository </rt> <rp>  ） </rp></ruby>

用于跟踪同一个项目但储存在其他位置的仓库。

##### <ruby> 远程 URL <rp>  （ </rp> <rt>  remote URL </rt> <rp>  ） </rp></ruby>

存储代码的位置：GitHub、其他用户分支甚至不同服务器 上的仓库。

##### <ruby> 副本 <rp>  （ </rp> <rt>  replica </rt> <rp>  ） </rp></ruby>

为主要 GitHub Enterprise 实例提供冗余的 GitHub Enterprise 实例。

##### <ruby> 仓库 <rp>  （ </rp> <rt>  repository </rt> <rp>  ） </rp></ruby>

仓库是 GitHub 最基本的元素，最容易被想象成项目的文件夹。一个仓库包含所有项目文件（包括文档），并且存储每个文件的修订历史记录。仓库可有多个协作者，也可以是公共仓库或私有仓库。

##### <ruby> 仓库维护员 <rp>  （ </rp> <rt>  repository maintainer </rt> <rp>  ） </rp></ruby>

管理仓库的人员。此人可帮助对议题分类，以及使用标签和其他功能管理仓库的工作，也可负责更新自述文件和参与文件。

##### <ruby> 解决 <rp>  （ </rp> <rt>  resolve </rt> <rp>  ） </rp></ruby>

手动修复自动合并失败的操作。

##### <ruby> 还原 <rp>  （ </rp> <rt>  revert </rt> <rp>  ） </rp></ruby>

恢复 GitHub 上的拉取请求时，新拉取请求会自动打开，其中有一个提交用于从原始合并的拉取请求恢复合并提交。在 Git 中，你可以使用 `git revert` 恢复提交。

##### <ruby> 审查 <rp>  （ </rp> <rt>  review </rt> <rp>  ） </rp></ruby>

审查允许对仓库具有访问权限的其他人评论拉取请求中提议的更改、审批更改或在拉取请求合并之前请求进一步更改。

##### <ruby> 服务挂钩 <rp>  （ </rp> <rt>  service hook </rt> <rp>  ） </rp></ruby>

也称为“Web 挂钩”。Web 挂钩是一种通知方式，只要仓库或组织上发生特定操作，就会发送通知到外部 web 服务器。

##### <ruby> 压扁 <rp>  （ </rp> <rt>  squash </rt> <rp>  ） </rp></ruby>

将多个提交合并为一个。也是 Git 命令。

##### <ruby> 暂存实例 <rp>  （ </rp> <rt>  staging instance </rt> <rp>  ） </rp></ruby>

在修改应用到实际 GitHub Enterprise 实例之前测试修改的一种方式。

##### <ruby> 状态 <rp>  （ </rp> <rt>  status </rt> <rp>  ） </rp></ruby>

拉取请求中的可视表现形式，表示你的提交符合你参与的仓库所设定的条件。

##### <ruby> 星标 <rp>  （ </rp> <rt>  star </rt> <rp>  ） </rp></ruby>

仓库的书签或赞赏表示。星标是项目受欢迎程度排名的手动方式。

##### <ruby> 主题分支 <rp>  （ </rp> <rt>  topic branch </rt> <rp>  ） </rp></ruby>

开发者用来识别开发概念行的常规 Git 分支。由于分支很容易并且便宜，因此往往适合拥有多个小分支，每个小分支包含定义明确的概念，或者渐进但相关的更改。也可称为“特征分支”。

##### <ruby> 上游 <rp>  （ </rp> <rt>  upstream </rt> <rp>  ） </rp></ruby>

在谈论分支或分叉时，原始仓库的主要分支通常被称为“上游”，因为它是其他更改的主要来源。你操作的分支/分叉则称为“下游”。也称为“源”。

##### <ruby> 上游分支 <rp>  （ </rp> <rt>  upstream branch </rt> <rp>  ） </rp></ruby>

合并到所述分支的默认分支（或所述分支变基到的分支）。它通过 `branch.<name>.remote` 和 `branch.<name>.merge` 配置。如果 A 的上游分支是源/B，有时我们会说“A 在跟踪源/B”。

##### <ruby> 查看 <rp>  （ </rp> <rt>  watch </rt> <rp>  ） </rp></ruby>

你可以关注仓库或议题，以便在议题或拉取请求有更新时接收通知。

##### <ruby> web 挂钩 <rp>  （ </rp> <rt>  webhooks </rt> <rp>  ） </rp></ruby>

Web 挂钩可让你构建或设置订阅 GitHub.com 上特定事件的 GitHub 应用程序。Web 挂钩提供一种通知方式，只要仓库或组织中发生特定操作，就会发送通知到外部 web 服务器。也称为“服务挂钩”。

##### <ruby> 写入权限 <rp>  （ </rp> <rt>  write access </rt> <rp>  ） </rp></ruby>

对仓库的权限级别，可让用户推送或写入更改到仓库。


新闻速读 > 谷歌工程师：七成 Chrome 安全漏洞是内存安全问题

Summary: • 勒索事件追踪：4200 万美金成交！ 黑客声称特朗普“脏衣服”被买走 • 开源图形编辑器 Krita 首个测试版登陆 Play 商城

# 新闻速读 > 谷歌工程师：七成 Chrome 安全漏洞是内存安全问题

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

#### 谷歌工程师：七成 Chrome 安全漏洞是内存安全问题

近日，有谷歌工程师分析了自 2015 年以来在 Chrome 稳定版分支中修复的 912 个安全错误。并发现，在这些被标记为“高”或“严重”等级的所有安全漏洞中，大约 70％ 是内存管理和安全问题。 这一数据恰巧与微软此前的研究结果相同：微软安全响应中心（MSRC）对自 2004 年以来所有报告过的微软安全漏洞进行了分类，所有微软年度补丁中约有 70% 是针对内存安全漏洞的修复程序。

来源：[开源中国](https://www.oschina.net/news/115898/chrome-70-of-all-security-bugs-are-memory-safety-issues)

>
> 硬核老王点评：内存问题是永恒的安全问题，所以， C/C++ 这种自我管理内存的编程语言，已经越来越面临更大的挑战，因此，Rust 得到青睐也是可以预期的。
>
>
>

#### 勒索事件追踪：4200 万美金成交！ 黑客声称特朗普“脏衣服”被买走

据外媒报道，此前，黑客以 2100 万美金勒索纽约 Grubman Shire Meiselas＆Sacks 事务所无果后，声称有特朗普的黑历史，并以 4200 万美金发起新一轮的勒索。近日，该黑客组织声称已经将美国总统特朗普的“黑历史”卖给了一位神秘买家。

来源：[E安全](https://mp.weixin.qq.com/s/Ge3bbLWo5El0LNO66un2vQ)

#### 开源图形编辑器 Krita 首个测试版登陆 Play 商城

该测试版基于 Krita 4.2.9 桌面版，具备和桌面版相同的完整功能。不过值得注意的是，此版软件兼容 Android 平板和 Chromebook 设备，暂不支持Android手机。此外，它并未对平板设备进行触控优化，因此还需要等待后续版本的改进。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/982659.htm)

>
> 硬核老王点评：桌面版要移植到手机上，需要做很多的工作，但是自从平板设备和触控操作尚属可行。
>
>
>


k9s：你没看错，这是一个加速 k8s 集群管理的工具

Summary: 看看这个很酷的 Kubernetes 管理的终端 UI。

看看这个很酷的 Kubernetes 管理的终端 UI。

# k9s：你没看错，这是一个加速 k8s 集群管理的工具

>
> 看看这个很酷的 Kubernetes 管理的终端 UI。
>
>
>

通常情况下，我写的关于 Kubernetes 管理的文章中用的都是做集群管理的 `kubectl` 命令。然而最近，有人给我介绍了 [k9s](https://github.com/derailed/k9s) 项目，可以让我快速查看并解决 Kubernetes 中的日常问题。这极大地改善了我的工作流程，我会在这篇教程中告诉你如何上手它。

它可以安装在 Mac、Windows 和 Linux 中，每种操作系统的说明可以在[这里](https://github.com/derailed/k9s)找到。请先完成安装，以便能够跟上本教程。

我会使用 Linux 和 Minikube，这是一种在个人电脑上运行 Kubernetes 的轻量级方式。按照[此教程](https://opensource.com/article/18/10/getting-started-minikube)或使用[该文档](https://kubernetes.io/docs/tasks/tools/install-minikube/)来安装它。

### 设置 k9s 配置文件

安装好 `k9s` 应用后，从帮助命令开始总是很好的起点。

```
$ k9s help
```

正如你在帮助信息所看到的，我们可以用 `k9s` 来配置很多功能。我们唯一需要进行的步骤就是编写配置文件。而 `info` 命令会告诉我们该应用程序要在哪里找它的配置文件。

```
$ k9s info
 ____  __.________
|    |/ _/   __   \______
|      < \____    /  ___/
|    |  \   /    /\___ \
|____|__ \ /____//____  >
        \/            \/

Configuration:   /Users/jess/.k9s/config.yml
Logs:            /var/folders/5l/c1y1gcw97szdywgf9rk1100m0000gn/T/k9s-jess.log
Screen Dumps:    /var/folders/5l/c1y1gcw97szdywgf9rk1100m0000gn/T/k9s-screens-jess
```

如果要添加配置文件，该配置目录不存在的话就创建它，然后添加一个配置文件。

```
$ mkdir -p ~/.k9s/
$ touch ~/.k9s/config.yml
```

在这篇介绍中，我们将使用 `k9s` 版本库中推荐的默认 `config.yml`。维护者请注意，这种格式可能会有变化，可以[在这里查看](https://github.com/derailed/k9s#k9s-configuration)最新版本。

```
k9s:
  refreshRate: 2
  headless: false
  readOnly: false
  noIcons: false
  logger:
    tail: 200
    buffer: 500
    sinceSeconds: 300
    fullScreenLogs: false
    textWrap: false
    showTime: false
  currentContext: minikube
  currentCluster: minikube
  clusters:
    minikube:
      namespace:
        active: ""
        favorites:
        - all
        - kube-system
        - default
      view:
        active: dp
  thresholds:
    cpu:
      critical: 90
      warn: 70
    memory:
      critical: 90
      warn: 70
```

我们设置了 `k9s` 寻找本地的 minikube 配置，所以我要确认 minikube 已经上线可以使用了。

```
$ minikube status
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured
```

### 运行 k9s 来探索一个 Kubernetes 集群

有了配置文件，并指向我们的本地集群，我们现在可以运行 `k9s` 命令了。

```
$ k9s
```

启动后，会弹出 `k9s` 的基于文本的用户界面。在没有指定命名空间标志的情况下，它会向你显示默认命名空间中的 Pod。

如果你运行在一个有很多 Pod 的环境中，默认视图可能会让人不知所措。或者，我们可以将注意力集中在给定的命名空间上。退出该应用程序，运行 `k9s -n <namespace>`，其中 `<namespace>` 是已存在的命名空间。在下图中，我运行了 `k9s -n minecraft`，它显示了我损坏的 Pod：

所以，一旦你有了 `k9s` 后，有很多事情你可以更快地完成。

通过快捷键来导航 `k9s`，我们可以随时使用方向键和回车键来选择列出的项目。还有不少其他的通用快捷键可以导航到不同的视图。

* `0`：显示在所有命名空间中的所有 Pod
* `d`：描述所选的 Pod
* `l`：显示所选的 Pod 的日志

你可能会注意到 `k9s` 设置为使用 [Vim 命令键](https://opensource.com/article/19/3/getting-started-vim)，包括使用 `J` 和 `K` 键上下移动等。Emacs 用户们，败退吧 :)

### 快速查看不同的 Kubernetes 资源

需要去找一个不在 Pod 里的东西吗？是的，我也需要。当我们输入冒号（`:`）键时，可以使用很多快捷方式。从那里，你可以使用下面的命令来导航。

* `:svc`：跳转到服务视图
* `:deploy`：跳转到部署视图
* `:rb`：跳转到角色绑定视图，用于 [基于角色的访问控制（RBAC）](https://kubernetes.io/docs/reference/access-authn-authz/rbac/)管理
* `:namespace`：跳转到命名空间视图
* `:cj`：跳转到 cronjob 视图，查看集群中计划了哪些作业。

这个应用最常用的工具是键盘；要在任何页面往上或下翻页，请使用方向键。如果你需要退出，记得使用 Vim 绑定键，键入 `:q`，然后按回车键离开。

### 用 k9s 排除 Kubernetes 的故障示例

当出现故障的时候，`k9s` 怎么帮忙？举个例子，我让几个 Pod 由于配置错误而死亡。下面你可以看到我那个可怜的 “hello” 部署死了。当我们将其高亮显示出来，可以按 `d` 运行 `describe` 命令，看看是什么原因导致了故障。

草草掠过那些事件并不能告诉我们故障原因。接下来，我按了 `esc` 键，然后通过高亮显示 Pod 并输入`shift-l` 来检查日志。

不幸的是，日志也没有提供任何有用的信息（可能是因为部署从未正确配置过），而且 Pod 也没有出现。

然后我使用 `esc` 退了出来，我看看删除 Pod 是否能解决这个问题。要做到这一点，我高亮显示该 Pod，然后使用 `ctrl-d`。幸好 `k9s` 在删除前会提示用户。

虽然我确实删除了这个 Pod，但部署资源仍然存在，所以新的 Pod 会重新出现。无论什么原因（我们还不知道），它还会继续重启并死掉。

在这里，我会重复查看日志，描述资源，甚至使用 `e` 快捷方式来编辑运行中的 Pod 以排除故障行为。在这个特殊情况下，失败的 Pod 是因为没有配置在这个环境下运行。因此，让我们删除部署来停止崩溃接着重启的循环。

我们可以通过键入 `:deploy` 并点击回车进入部署。从那里我们高亮显示并按 `ctrl-d` 来删除。

这个有问题的部署被干掉了! 只用了几个按键就把这个失败的部署给清理掉了。

### k9s 是极其可定制的

这个应用有很多自定义选项、乃至于 UI 的配色方案。这里有几个可编辑的选项，你可能会感兴趣。

* 调整你放置 `config.yml` 文件的位置（这样你就可以把它存储在[版本控制](https://opensource.com/article/19/3/move-your-dotfiles-version-control)中）。
* 在 `alias.yml` 文件中添加[自定义别名](https://k9scli.io/topics/aliases/)。
* 在 `hotkey.yml` 文件中创建[自定义热键](https://k9scli.io/topics/hotkeys/)。
* 探索现有的[插件](https://github.com/derailed/k9s/tree/master/plugins)或编写自己的插件。

整个应用是在 YAML 文件中配置的，所以定制化对于任何 Kubernetes 管理员来说都会觉得很熟悉。

### 用 k9s 简化你的生活

我倾向于以一种非常手动的方式来管理我团队的系统，更多的是为了锻炼脑力，而不是别的。当我第一次听说 `k9s` 的时候，我想，“这只是懒惰的 Kubernetes 而已。”于是我否定了它，然后回到了到处进行人工干预的状态。实际上，当我在处理积压工作时就开始每天使用它，而让我震惊的是它比单独使用 `kubectl` 快得多。现在，我已经皈依了。

了解你的工具并掌握做事情的“硬道理”很重要。还有一点很重要的是要记住，就管理而言，重要的是要更聪明地工作，而不是更努力。使用 `k9s`，就是我践行这个目标的方法。我想，我们可以把它叫做懒惰的 Kubernetes 管理，也没关系。

---

via: <https://opensource.com/article/20/5/kubernetes-administration>

作者：[Jessica Cherry](https://opensource.com/users/cherrybomb) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)

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


Summary: • 世界上使用量最大的数据库引擎 SQLite 3.32.0 发布 • 民间高手魔改卡西欧计算器遭版权组织警告 • OpenCV 开源许可协议拟从 BSD 变更为 Apache 2

# 新闻速读 > Linus Torvalds 升级主力电脑，15 年来首次不用英特尔处理器

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

#### Linus Torvalds 升级主力电脑，15 年来首次不用英特尔处理器

在近日发布的 Linux Kernel 5.7 rc7 帖子中，托瓦兹表示主力电脑将不再使用英特尔的 CPU 了：“事实上本周对于我来说最大的兴奋点就是我升级了主力电脑，而且这是我 15 年来首次更换到非英特尔平台。我目前还没有切换到 ARM，不过我现在使用的是 AMD 的 Threadripper 3970x。我的 allmodconfig 测试版速度要比此前快了 3 倍。在这段平静期还无法突显出来，不过相信在下个窗口合并期将会有明显的升级。”

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/982945.htm)

>
> 硬核老王点评：Linus 作为最大的开源领袖之一，其一举一动都极引人瞩目。Linus 换了新电脑，是不是会加速 Linux 内核的开发工作呢？毕竟大神可能会花费更少的时间来等待内核编译完成~
>
>
>

#### 世界上使用量最大的数据库引擎 SQLite 3.32.0 发布

SQLite 是一个 C 实现的 SQL 数据库引擎，它的特点是小型、快速、自包含、高可靠性和功能齐全。SQLite 嵌入在所有手机和大多数计算机中，也捆绑在为数众多的其它应用中，是世界上使用量最大的数据库引擎。

来源：[开源中国](http://www.oschina.net/)

>
> 硬核老王点评：这个不起眼的小型数据库，因其体型小而得到广泛使用，就像 MINIX 是世界上使用最多的操作系统一样，让很多人吃惊。
>
>
>

#### 民间高手魔改卡西欧计算器遭版权组织警告

来自印度的 Neutrino 动手将一台卡西欧计算器（fx-ms991）的太阳能充电面板改造为显示屏，借助 esp 元件、Firebase 编程开发，可以通过这块屏幕连接互联网并收发即时消息。随后，改写代码等也被放上了 GitHub，供在家无聊但有兴趣的朋友效仿借鉴。然而，版权保护组织 REACT 本周出面，声称 Neutrino 托管的代码中并非全部是开源项目，有些是卡西欧专有的私产，不允许公开使用，虽然 Neutrino 坚称自己完全是从零写的程序。

来源：[快科技](https://www.cnbeta.com/articles/tech/982723.htm)

>
> 硬核老王点评：应该鼓励这种黑客精神，建议卡西欧和 REACT 对这种情况高抬贵手。
>
>
>

#### OpenCV 开源许可协议拟从 BSD 变更为 Apache 2

OpenCV 开发团队目前正在讨论变更开源许可协议的详细问题，预计在 6 月 29 日进行第一次评估。BSD 许可协议比较宽松，对于采用 BSD 的开源项目，开发者使可以自由使用、修改源码，也可以将修改后的代码作为开源或者专有软件再发布，不过需要保留当前许可内容。然而 BSD 许可协议在某些情况下（例如涉及到专利）却无法保护用户。

来源：[开源中国](https://www.oschina.net/news/115902/opencv-license-apache2-changing)

>
> 硬核老王点评：宽松自由的 BSD 许可证，是不是对开源最有利，这个要全面来看待。
>
>
>


如何安装使用 Qt 5 的音频播放器 Audacious 4.0

Summary: Audacious 是一个开源音频播放器，可用于包括 Linux 在内的多个平台。继上次发布主版本将近 2 年后，Audacious 4.0 带来了一些重大变化。

# 如何安装使用 Qt 5 的音频播放器 Audacious 4.0

[Audacious](https://audacious-media-player.org) 是一个开源音频播放器，可用于包括 Linux 在内的多个平台。继上次发布主版本将近 2 年后，Audacious 4.0 带来了一些重大变化。

最新版本的 Audacious 4.0 默认带 [Qt 5](https://doc.qt.io/qt-5/qt5-intro.html) 用户界面。你仍然可以和以前一样使用旧的 GTK2 UI，但是，新功能仅会添加到 Qt UI 中。

让我们看下发生了什么变化，以及如何在 Linux 系统上安装最新的 Audacious。

### Audacious 4.0 关键变化和功能

当然，主要的变化是默认使用 Qt 5 UI。除此之外，他们的[官方公告](https://audacious-media-player.org/news/45-audacious-4-0-released)中提到了许多改进和功能补充，它们是：

* 单击播放列表列头可对播放列表进行排序
* 拖动播放列表列头会更改列顺序
* 应用中的音量和时间步长设置
* 隐藏播放列表标签的新选项
* 按路径对播放列表排序，现在将文件夹排序在文件后面
* 实现了额外的 MPRIS 调用，以与 KDE 5.16+ 兼容
* 新的基于 OpenMPT 的跟踪器模块插件
* 新的 VU Meter 可视化插件
* 添加了使用 SOCKS 网络代理的选项
* 换歌插件现在可在 Windows 上使用
* 新的“下一张专辑”和“上一张专辑”命令
* Qt UI 中的标签编辑器现在可以一次编辑多个文件
* 为 Qt UI 实现均衡器预设窗口
* 歌词插件获得了在本地保存和加载歌词的能力
* 模糊范围和频谱分析器可视化已移植到 Qt
* MIDI 插件 “SoundFont 选择”已移植到 Qt
* JACK 输出插件获得了一些新选项
* 添加了无限循环 PSF 文件的选项

如果你以前不了解它，你可以轻松安装它，并使用均衡器和 [LADSP](https://www.ladspa.org/) 效果器来调整音乐体验。

### 如何在 Ubuntu 上安装 Audacious 4.0

值得注意的是，[非官方 PPA](https://itsfoss.com/ppa-guide/) 是由 [UbuntuHandbook](http://ubuntuhandbook.org/index.php/2020/03/audacious-4-0-released-qt5-ui/) 提供的。你可以按照以下说明在 Ubuntu 16.04、18.04、19.10 和 20.04 上进行安装。

1、首先，你必须在终端中输入以下命令将 PPA 添加到系统中：

```
sudo add-apt-repository ppa:ubuntuhandbook1/apps
```

2、接下来，你需要从仓库中更新（刷新）软件包信息，然后继续安装该应用。方法如下：

```
sudo apt update
sudo apt install audacious audacious-plugins
```

就是这样。你无需执行其他任何操作。无论什么情况，如果你想[删除 PPA 和软件](https://itsfoss.com/how-to-remove-or-delete-ppas-quick-tip/)，只需按顺序输入以下命令：

```
sudo add-apt-repository --remove ppa:ubuntuhandbook1/apps
sudo apt remove --autoremove audacious audacious-plugins
```

你也可以在它的 GitHub 页面上查看有关源码的更多信息，并根据需要在其他 Linux 发行版上进行安装。

* [Audacious 源代码](https://github.com/audacious-media-player/audacious)

### 总结

新功能和 Qt 5 UI 开关对于改善用户体验和音频播放器的功能应该是一件好事。如果你是经典 Winamp 界面的粉丝，它也可以正常工作。但缺少其公告中提到的一些功能。

你可以尝试一下，并在下面的评论中让我知道你的想法！

---

via: <https://itsfoss.com/audacious-4-release/>

作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[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/) 荣誉推出


为什么 strace 在 Docker 中不起作用？

Summary: 在编辑“容器如何工作”爱好者杂志的能力页面时，我想试着解释一下为什么 strace 在 Docker 容器中无法工作。

赞，学到了

# 为什么 strace 在 Docker 中不起作用？

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

在编辑“容器如何工作”爱好者杂志的能力页面时，我想试着解释一下为什么 `strace` 在 Docker 容器中无法工作。

这里的问题是 —— 如果我在笔记本上的 Docker 容器中运行 `strace`，就会出现这种情况：

```
$ docker run  -it ubuntu:18.04 /bin/bash
$ # ... install strace ...
[email protected]:/# strace ls
strace: ptrace(PTRACE_TRACEME, ...): Operation not permitted
```

`strace` 通过 `ptrace` 系统调用起作用，所以如果不允许使用 `ptrace`，它肯定是不能工作的! 这个问题很容易解决 —— 在我的机器上，是这样解决的：

```
docker run --cap-add=SYS_PTRACE  -it ubuntu:18.04 /bin/bash
```

但我对如何修复它不感兴趣，我想知道为什么会出现这种情况。为什么 `strace` 不能工作，为什么`--cap-add=SYS_PTRACE` 可以解决这个问题？

### 假设 1：容器进程缺少 `CAP_SYS_PTRACE` 能力。

我一直以为原因是 Docker 容器进程默认不具备 `CAP_SYS_PTRACE` 能力。这和它可以被 `--cap-add=SYS_PTRACE` 修复是一回事，是吧？

但这实际上是不合理的，原因有两个。

原因 1：在实验中，作为一个普通用户，我可以对我的用户运行的任何进程进行 `strace`。但如果我检查我的当前进程是否有 `CAP_SYS_PTRACE` 能力，则没有：

```
$ getpcaps $$
Capabilities for `11589': =
```

原因 2：`capabilities` 的手册页对 `CAP_SYS_PTRACE` 的介绍是：

```
CAP_SYS_PTRACE
       * Trace arbitrary processes using ptrace(2);
```

所以，`CAP_SYS_PTRACE` 的作用是让你像 root 一样，可以对任何用户拥有的**任意**进程进行 `ptrace`。你不需要用它来对一个只是由你的用户拥有的普通进程进行 `ptrace` 。

我用第三种方法测试了一下（LCTT 译注：此处可能原文有误） —— 我用 `docker run --cap-add=SYS_PTRACE -it ubuntu:18.04 /bin/bash` 运行了一个 Docker 容器，去掉了 `CAP_SYS_PTRACE` 能力，但我仍然可以跟踪进程，虽然我已经没有这个能力了。什么？为什么？！

### 假设 2：关于用户命名空间的事情？

我的下一个（没有那么充分的依据的）假设是“嗯，也许这个过程是在不同的用户命名空间里，而 `strace` 不能工作，因为某种原因而行不通？”这个问题其实并不相关，但这是我观察时想到的。

容器进程是否在不同的用户命名空间中？嗯，在容器中：

```
root@e27f594da870:/# ls /proc/$$/ns/user -l
... /proc/1/ns/user -> 'user:[4026531837]'
```

在宿主机：

```
bork@kiwi:~$ ls /proc/$$/ns/user -l
... /proc/12177/ns/user -> 'user:[4026531837]'
```

因为用户命名空间 ID（`4026531837`）是相同的，所以容器中的 root 用户和主机上的 root 用户是完全相同的用户。所以，绝对没有理由不能够对它创建的进程进行 `strace`!

这个假设并没有什么意义，但我（之前）没有意识到 Docker 容器中的 root 用户和主机上的 root 用户同一个，所以我觉得这很有意思。

### 假设 3：ptrace 系统的调用被 seccomp-bpf 规则阻止了

我也知道 Docker 使用 seccomp-bpf 来阻止容器进程运行许多系统调用。而 `ptrace` 在[被 Docker 默认的 seccomp 配置文件阻止的系统调用列表](https://docs.docker.com/engine/security/seccomp/)中!（实际上，允许的系统调用列表是一个白名单，所以只是`ptrace` 不在默认的白名单中。但得出的结果是一样的。）

这很容易解释为什么 `strace` 在 Docker 容器中不能工作 —— 如果 `ptrace` 系统调用完全被屏蔽了，那么你当然不能调用它，`strace` 就会失败。

让我们来验证一下这个假设 —— 如果我们禁用了所有的 seccomp 规则，`strace` 能在 Docker 容器中工作吗？

```
$ docker run --security-opt seccomp=unconfined -it ubuntu:18.04  /bin/bash
$ strace ls
execve("/bin/ls", ["ls"], 0x7ffc69a65580 /* 8 vars */) = 0
... it works fine ...
```

是的，很好用！很好。谜底解开了，除了…..

### 为什么 `--cap-add=SYS_PTRACE` 能解决问题？

我们还没有解释的是：为什么 `--cap-add=SYS_PTRACE` 可以解决这个问题？

`docker run` 的手册页是这样解释 `--cap-add` 参数的。

```
--cap-add=[]
   Add Linux capabilities
```

这跟 seccomp 规则没有任何关系! 怎么回事？

### 我们来看看 Docker 源码

当文档没有帮助的时候，唯一要做的就是去看源码。

Go 语言的好处是，因为依赖关系通常是在一个 Go 仓库里，你可以通过 `grep` 来找出做某件事的代码在哪里。所以我克隆了 `github.com/moby/moby`，然后对一些东西进行 `grep`，比如 `rg CAP_SYS_PTRACE`。

我认为是这样的。在 `containerd` 的 seccomp 实现中，在 [contrib/seccomp/seccomp/seccomp\_default.go](https://github.com/containerd/containerd/blob/4be98fa28b62e8a012491d655a4d6818ef87b080/contrib/seccomp/seccomp_default.go#L527-L537) 中，有一堆代码来确保如果一个进程有一个能力，那么它也会（通过 seccomp 规则）获得访问权限，以使用与该能力相关的系统调用。

```
case "CAP_SYS_PTRACE":
       s.Syscalls = append(s.Syscalls, specs.LinuxSyscall{
           Names: []string{
               "kcmp",
               "process_vm_readv",
               "process_vm_writev",
               "ptrace",
           },
           Action: specs.ActAllow,
           Args:   []specs.LinuxSeccompArg{},
       })
```

在 moby 中的 [profile/seccomp/seccomp.go](https://github.com/moby/moby/blob/cc0dfb6e7b22ad120c60a9ce770ea15415767cf9/profiles/seccomp/seccomp.go#L126-L132) 和 [默认的 seccomp 配置文件](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json#L723-L739)中，也有一些其他的代码似乎做了一些非常类似的事情，所以有可能就是这个代码在做这个事情。

所以我想我们有答案了!

### Docker 中的 `--cap-add` 做的事情比它说的要多

结果似乎是，`--cap-add` 并不像手册页里说的那样，它更像是 `--cap-add-and-also-whiteelist-some-extra-system-calls-if-required`。这很有意义! 如果你具有一个像 `--CAP_SYS_PTRACE` 这样的能力，可以让你使用 `process_vm_readv` 系统调用，但是该系统调用被 seccomp 配置文件阻止了，那对你没有什么帮助！

所以当你给容器 `CAP_SYS_PTRACE` 能力时，允许使用 `process_vm_readv` 和 `ptrace` 系统调用似乎是一个合理的选择。

### 就这样！

这是个有趣的小事情，我认为这是一个很好的例子，说明了容器是由许多移动的部件组成的，它们以不完全显而易见的方式一起工作。

---

via: <https://jvns.ca/blog/2020/04/29/why-strace-doesnt-work-in-docker/>

作者：[Julia Evans](https://jvns.ca/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)

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


你应该（或许）没使用过的 3 种 Python 模板语言

Summary: 包括这 3 个模板语言在内，Python 积累了许多模板语言。

包括这 3 个模板语言在内，Python 积累了许多模板语言。

# 你应该（或许）没使用过的 3 种 Python 模板语言

>
> 包括这 3 个模板语言在内，Python 积累了许多模板语言。
>
>
>

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

当需要使用模板语言来编写 [Python](https://opensource.com/resources/python) Web 应用时，有很多健壮的解决方案。

有 [Jinja2](https://opensource.com/article/20/2/jinja2-cheat-sheet)、[Genshi 和 Mako](https://opensource.com/resources/python/template-libraries)。甚至还有 [Chameleon](https://chameleon.readthedocs.io/en/latest/) 之类的解决方案，虽然有些陈旧，但仍被 [Pyramid](https://opensource.com/article/18/5/pyramid-framework) 框架推荐。

Python 已经存在了很长时间。此时，在系统的深处，它积累了一些几乎被遗忘的模板语言，它们都是值得一试的。

这些语言就像桉树上可爱的考拉一样，在自己的生态圈里快乐地生活着，有时也会有危险的工作，这些都是很少有人听说过的模板语言，使用过的应该更少。

### 3、string.Template

你是否曾经想过：“如何获得一种没有任何特性的模板语言，而且同时也不需要 `pip install` 安装任何东西？” Python 标准库已经为你提供了答案。虽然没有循环和条件，但 `string.Template` 类是一种最小的模板语言。

使用它很简单。

```
>>> import string
>>> greeting = string.Template("Hello, $name, good $time!")
>>> greeting.substitute(name="OpenSource.com", time="afternoon")
'Hello, OpenSource.com, good afternoon!'
```

### 2、twisted.web.template

你会给一个包罗万象的库送什么礼物？

当然，不是模板语言，因为它已经有了。twisted.web.template 中嵌套了两种模板语言。一种是基于 XML 的，并有一个[很棒的文档](https://twistedmatrix.com/documents/13.1.0/web/howto/twisted-templates.html)。

但是它还有另一种，一种基于使用 Python 作为领域特定语言（DSL）来生成 HTML 文档。

它基于两个原语：包含标签对象的 `twisted.web.template.tags` 和渲染它们的 `twisted.web.template.flattenString`。由于它是 Twisted 的一部分，因此它内置支持高效异步渲染。

此例将渲染一个小页面：

```
async def render(reactor):
    my_title = "A Fun page"
    things = ["one", "two", "red", "blue"]
    template = tags.html(
            tags.head(
                tags.title(my_title),
            ),
            tags.body(
                tags.h1(my_title),
                tags.ul(
                    [tags.li(thing) for thing in things],
                ),
                tags.p(
                    task.deferLater(reactor, 3, lambda: "Hello "),
                    task.deferLater(reactor, 3, lambda: "world!"),
                )
            )
    )
    res = await flattenString(None, template)
    res = res.decode('utf-8')
    with open("hello.html", 'w') as fpout:
        fpout.write(res)
```

该模板是使用 `tags.<TAGNAME>` 来指示层次结构的常规 Python 代码。原生支持渲染字符串，因此任何字符串都正常。

要渲染它，你需要做的是添加调用：

```
from twisted.internet import task, defer
from twisted.web.template import tags, flattenString

def main(reactor):
    return defer.ensureDeferred(render(reactor))
```

最后写上：

```
task.react(main)
```

只需 3 秒（而不是 6 秒），它将渲染一个不错的 HTML 页面。在实际中，这些 `deferLater` 可以是对 HTTP API 的调用：它们将并行发送和处理，而无需付出任何努力。我建议你阅读关于[更好地使用 Twisted](https://opensource.com/article/20/3/treq-python)。不过，这已经可以工作了。

### 1、Quixote

你会说：“但是 Python 并不是针对 HTML 领域而优化的领域特定语言。” 如果有一种语言可以[转化](https://en.wikipedia.org/wiki/Source-to-source_compiler)到 Python，但是更适合定义模板，而不是像 Python 那样按原样解决呢？如果可以的话，请使用“Python 模板语言”（PTL）。

编写自己的语言，有时被说成是一个攻击假想敌人的唐吉坷德项目。当 Quixote（可在 [PyPI](https://pypi.org/project/Quixote/) 中找到）的创造者决定这样做时，并没有受此影响。

以下将渲染与上面 Twisted 相同的模板。*警告：以下不是有效的 Python 代码*：

```
import time

def render [html] ():
    my_title = "A Fun page"
    things = ["one", "two", "red", "blue"]
    "<html><head><title>"
    my_title
    "</head></title><body><h1>"
    my_title
    "</h1>"
    "<ul>"
    for thing in things:
        "<li>"
        thing
        "</li>"
    "<p>"
    time.sleep(3)
    (lambda: "Hello ")()
    time.sleep(3)
    (lambda: "world!")()
    "</p>"
    "</body></html>"

def write():
    result = render()
    with open("hello.html", 'w') as fpout:
        fpout.write(str(result))
```

但是，如果将它放到 `template.ptl` 文件中，那么可以将其导入到 Quixote 中，并写出可以渲染模板的版本：

```
>>> from quixote import enable_ptl
>>> enable_ptl()
>>> import template
>>> template.write()
```

Quixote 安装了一个导入钩子，它会将 PTL 文件转换为 Python。请注意，此渲染需要 6 秒，而不是 3 秒。你不再获得自由的异步性。

### Python 中的模板太多

Python 库的历史悠久且曲折，其中一些库可以或多或少都能达到类似结果（例如，Python [包管理](https://opensource.com/article/19/4/managing-python-packages)）。

我希望你喜欢探索这三种*可以*用 Python 创建模板的方式。另外，我建议从[这三个库之一](https://opensource.com/resources/python/template-libraries)开始了解。

你是否有另一种深奥的模板方法？请在下面的评论中分享！

---

via: <https://opensource.com/article/20/4/python-templating-languages>

作者：[Moshe Zadka](https://opensource.com/users/moshez) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)

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


新闻速读 > 80％ 的 Oracle JDK 用户正在考虑其他支持选项

Summary: • 开发者将 GCC 的 JIT 库移植到 Windows

# 新闻速读 > 80％ 的 Oracle JDK 用户正在考虑其他支持选项

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

#### 80％ 的 Oracle JDK 用户正在考虑其他支持选项

在 2019 年，Oracle 决定更改许可模式，从提供免费的 Java 更新转变为要求付费订阅。据 Azul Systems 的一项新调查显示，目前有 80％ 的 Oracle JDK 用户正在考虑其他选择。Azul Systems 透露，对 Oracle JDK 的首选使用率已从 70％ 下降至 34％，大部分现有用户都选择了免费或受支持的基于 OpenJDK 的部署。不过在目前愿意支付支持费用的企业中，Oracle 仍然是赢家，占有 55 ％的市场份额。红帽（17％）、IBM（16％）和 Azul（12％）则紧随 Oracle 之后。

来源：[开源中国](https://www.oschina.net/news/115942/oracle-jdk-users-considering-alternative-support-options)

>
> 硬核老王点评：习惯了免费的开源软件，对于收费，很多企业和人还没做好准备；而另外一方面，很多免费的 JDK 看起来也完全能取代 Oracle JDK 的作用。
>
>
>

#### 开发者将 GCC 的 JIT 库移植到 Windows

libgccjit 是一个实现 GCC JIT 编译的嵌入式库，它可以动态链接到字节码解释器和其它程序中，在运行时生成本机代码。目前 GCC 开发者实验性地将 libgccjit 移植到了 Windows，并提交了补丁。GCC 代码库使用的是具有“传染性”的 GPLv3 许可，因此就算 libgccjit 移植到 Windows，那预估也不会有多少基于 Windows 的程序使用，因为有必须将新程序也开源的要求。

来源：[开源中国](https://www.oschina.net/news/115943/port-gcc-jit-libgccjit-to-windows)

>
> 硬核老王点评：GPL 的传染性在捍卫了自由的同时，也让很多软件望而生畏。另一方面，随着计算机技术的变化和互联网的发展，许可证也需要与时俱进。
>
>
>


现在你可以在 Windows 中运行 Linux 应用了

共赢的事情。Windows 推广了 Linux，越来越多的人开始接触Linux。同时也方便了Linux开发者，更多Linux开发者开始使用Windows做开发。最终，WSL成为开发主流，而服务端基本上会使用纯Linux系统，也不用担心Linux会彻底成为Windows下的桌面程序。

# 现在你可以在 Windows 中运行 Linux 应用了

微软最近的 “[Build 2020](https://news.microsoft.com/build2020/)” 开发者大会公布了一些有趣的公告。我不确定这该令人兴奋还是该令人怀疑 —— 但是微软，你现在比以往任何时候都受到我们的关注。

同时，在所有的这些公告中，能够在 WSL（Windows Subsystem for Linux）上运行 GUI 应用程序的功能备受关注。

更不要忘了 [Xamrin.Forms 更名为 MAUI 的尴尬结局](https://itsfoss.com/microsoft-maui-kde-row/)，它与 [Nitrux Linux](https://itsfoss.com/nitrux-linux/) 的 Uri Herrera 的现有开源项目（[Maui Project](https://mauikit.org/)）名字冲突。

以防你不清楚，WSL 是一种环境，可让你在 Windows 10 中获得 Linux 控制台的体验。它也是在 [Windows 中运行 Linux 命令的最佳方法](https://itsfoss.com/run-linux-commands-in-windows/)之一。

正如 [Liam Dawe](https://www.gamingonlinux.com/2020/05/microsoft-build-directx-and-linux-plus-more) 认为的那样，通过博客文章（[DirectX ❤ Linux](https://devblogs.microsoft.com/directx/directx-heart-linux/)）发布的公告可能是只是个公关诱饵。但是，仍然值得一提。

### WSL 上对 Linux GUI 应用程序的支持

最近，Microsoft 在在线开发者大会上宣布了 WSL（即 WSL 2）的一系列新功能。

[Windows 包管理器](https://devblogs.microsoft.com/commandline/windows-package-manager-preview/)、[Windows 终端 1.0](https://devblogs.microsoft.com/commandline/windows-terminal-1-0/)，以及其他一些功能的引入是其亮点。

但是， WSL 2 对 GPU 硬件加速的支持非常重要。

那么，是否意味着你可以使用 WSL 在 Windows 上运行 Linux 应用程序呢？看起来像是。

微软计划通过使用全新的 Linux 内核驱动程序 `dxgkrnl` 来实现它。为了给你一个技术性的简报, 我在这里引用他们的公告中的描述：

>
> dxgkrnl 是一个全新的 Linux 内核驱动程序，它将 `/dev/dxg` 设备提供给用户模式的 Linux。 `/dev/dxg` 提供了一组 IOCTL，它们与 Winodws 上的原生 WDDM D3DKMT 内核服务层非常相似。Linux 内核中的 dxgkrnl 通过 VM 总线连接到 Windows 主机上，并使用此 VM 总线连接与物理 GPU 进行通讯。
>
>
>

我不是这方面的专家，但这意味着 WSL 上的 Linux 应用程序将与原生的 Windows 应用程序一样可以访问 GPU。

针对 GUI 应用程序的支持将在今年秋季的晚些时候提供（而不是 2020 年 5 月的更新） —— 所以我们要看看什么时候提供。

微软专门针对的是那些希望在 Windows 上轻松使用 Linux IDE 的开发人员。谷歌也在瞄准同样的用户群，[将 GUI Linux 应用程序引入到 Chromebook](https://itsfoss.com/linux-apps-chromebook/)。

那么，对于那些坚持使用 Windows 的用户来说，这是个好消息。但是，这是真的吗？

### 微软爱上了 Linux —— 真的吗？

他们在 Windows 上整合 Linux 环境来拥抱 Linux 及其优势的努力，绝对是一件好事。

但是，它真的能给**桌面 Linux 用户**带来什么好处呢？到目前为止，我还没有看到任何实际的好处。

在这里，你可以有不同的看法。但是，我认为 WSL 的开发对于 Linux 桌面用户来说没有真正的价值。至少，到目前为止没有。

有趣的是，[Linux Unplugged podcast](https://linuxunplugged.com/354) 上有人强调了微软的举动，认为这与他们的 EEE（<ruby> 拥抱、延伸和扑灭 <rt>  Embrace, extend, and extinguish </rt></ruby>）的思路是一致的。

可能吧，谁知道呢？当然，他们为实现这一目标而付出的努力值得赞赏 —— 同时又令人感到兴奋和神秘。

### 这是否意味着 Windows 用户将不必再转到 Linux?

微软之所以在其平台上集成 Linux，是因为他们知道 Liunx 的能力，也知道开发人员（或用户）喜欢使用它的原因。

但是，随着 WSL 2 的更新，如果这种情况持续下去，我倾向于同意 Abhishek 的看法：

>
> 最终，桌面 Linux 将被限制在 Windows 下，成为桌面应用程序……
>
>
>

好吧，当然，原生的体验暂时还是比较好的。而且，很难看到现有的 Linux 桌面用户会使用 Windows 来将其替代。但是，这仍然值得担心。

你如何看待这一切？我不认为 WSL 对于被迫使用 Windows 的用户有什么好处 —— 但是，从长远来看，你认为微软在 WSL 方面的进展本质上是敌意还是对 Linux 有帮助？

在评论中让我知道你的想法！

---

via: <https://itsfoss.com/run-linux-apps-windows-wsl/>

作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lnrCoder](https://github.com/lnrCoder) 校对：[wxy](https://github.com/wxy)

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


怎样在 Linux 下用 SSH 搭建个人文件服务器

Summary: 通过 SSH 连接远程 Linux 系统很简单。下面是教程。

用到是能用了，就是空间小了点。

通过 SSH 连接远程 Linux 系统很简单。下面是教程。

# 怎样在 Linux 下用 SSH 搭建个人文件服务器

>
> 通过 SSH 连接远程 Linux 系统很简单。下面是教程。
>
>
>

树莓派是一个有用且价格低廉的家庭服务器，可用于很多事情。我的树莓派最常用来做[打印服务器](https://opensource.com/article/18/3/print-server-raspberry-pi)，可以在我的家庭网络中共享激光打印机，或作为个人文件服务器保存项目副本和其他数据。

我的文件服务器有很多用途。假设说我现在有一个项目，比如一本新书，我想把我的工作和所有相关的文件都复制一份快照。这种场景下，我只需要把 `BookProject` 文件夹复制到文件服务器的 `BookBackup` 文件夹。

或者我现在正在清理我的本地文件时，发现一些我不需要的文件，但是我不确定是否要删除，我会把它们复制到文件服务器的 `KeepForLater` 文件夹。这是我日常 Linux 系统中清除杂乱的文件，并将不常用的文件卸载到个人文件服务器上的方便方法。

用树莓派或其他 Linux 系统搭建个人文件服务器不需要配置 NFS（<ruby> 网络文件系统 <rt>  Network File System </rt></ruby>>）或 CIFS（<ruby> 通用互联网文件系统 <rt>  Common Internet File System </rt></ruby>）或改造其他的文件共享系统如 WebDAV。你可以很轻松的使用 SSH 来搭建远程文件服务器。下面是教程。

### 在远程服务器上配置 SSHD

你的 Linux 系统可能已经安装了 SSH 守护进程（`sshd`），甚至它已经默认运行了。如果没有，你可以使用你 Linux 发行版本上的任何控制面板来轻松配置 SSH。我在树莓派上运行了 [Fedora ARM](https://arm.fedoraproject.org/)，通过 Web 浏览器访问树莓派的 9090 端口，我可以远程访问控制面板。（在我的家庭网络中，树莓派的 IP 地址是 `10.0.0.11`，因此我连接的是 `10.0.0.11:9090`。）如果 SSH 守护进程没有默认运行，你可以在控制面板的“服务”里把它设置为开机启动。

你可以在系统服务列表里找到 `sshd`。

如果 `sshd` 没有开启，点击切换按钮打开它。

### 你有账号吗？

你需要有个远程系统的账号。它可以与你本地系统的账号相同，也可以不同。

在流行的 Raspbian 发行版本上，默认的账号名是 `pi`。但是其他的 Linux 发行版本可能需要你在安装系统时就设置一个唯一的新用户。如果你不知道你的用户名，你可以用系统的控制面板创建一个。在我的树莓派上，我创建了一个 `jhall` 账号，与我日常用的 Linux 桌面机器的用户名相同。

如果你用的是 Fedora 服务器，你可以点击“创建新账号”按钮。

不要忘记设置密码或添加公钥。

### 可选：添加公钥

如果你把公钥添加到远程 Linux 系统上，你就可以不使用密码登录。这一步是可选的；如果你愿意，你仍可以用密码登录。

你可以在下面的文章中学到更多关于 SSH 密钥的信息：

* [SSH 密钥管理工具](/article-11947-1.html)
* [用 Seahorse 对 SSH 密钥进行图形化管理](/article-9451-1.html)
* [如何管理多个 SSH 密钥](https://opensource.com/article/19/4/gpg-subkeys-ssh-manage)
* [使用 GPG 密钥作为鉴权依据开启 SSH 访问](https://opensource.com/article/19/4/gpg-subkeys-ssh)

### 创建文件管理器的快捷方式

现在你已经在远程系统上启动 SSH 守护进程了，也设置了用户名和密码，最后一步就是在你本地的文件管理器中创建一个快捷方式，地址映射到远程 Linux 系统。我的桌面是 GNOME，但是在其他的 Linux 桌面上的基本操作步骤都是一样的。

#### 建立初始连接

在 GNOME 的文件管理器中，在左边导航栏找到 “+其它位置” 按钮。点击它会出现一个 “连接到服务器” 提示框。在框中输入远程 Linux 服务器的地址，地址以 SSH 连接协议开头。

GNOME 文件管理器支持多种连接协议。要通过 SSH 进行连接，服务器地址请以 `sftp://` 或 `ssh://` 开头。

如果你远程 Linux 系统的用户名与本地的相同，那么你只需要输入服务器的地址和文件夹路径就可以了。比如要连接到我的树莓派的 `/home/jhall` 目录，我输入：

```
sftp://10.0.0.11/home/jhall
```

如果你远程 Linux 系统的用户名与本地的不同，你可以在远程系统地址前加 `@` 符号来指定远程系统的用户名。要连接到远程的 Raspbian 系统，你可能要输入：

```
sftp://pi@10.0.0.11/home/pi
```

如果你没有把公钥添加到远程服务器，那么你需要输入密码。如果你已经添加，GNOME 文件管理器应该会自动打开远程系统上的文件夹来让你跳转到不同的目录。

#### 创建一个快捷方式，之后就可以轻松连接服务器

在 GNOME 文件管理器中，这很简单。右击导航栏中远程系统的名字，选择“添加书签”。这一步操作就创建了连接到远程路径的快捷方式。

如果你想把标签中的快捷方式改成一个更容易记的名字，你可以右击快捷方式选择“重命名”。

### 总结

通过 SSH 连接到远程 Linux 系统是很简单的事。你可以用相同的方式连接到家庭文件服务器以外的其他系统。我还创建了一个能让我立即访问我的提供商 Web 服务器上的文件的快捷方式，和另一个能迅速打开我的项目服务器的文件夹的快捷方式。SSH 使它成为一个安全的连接；所有的传输都是加密的。当我通过 SSH 打开远程的文件时，我可以像在本地操作一样使用 GNOME 文件管理器轻松打开远程文件。

---

via: <https://opensource.com/article/20/3/personal-file-server-ssh>

作者：[Jim Hall](https://opensource.com/users/jim-hall) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lxbwolf](https://github.com/lxbwolf) 校对：[wxy](https://github.com/wxy)

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


Summary: • Microsoft Edge 浏览器迎来“上网冲浪”游戏 • 报告显示僵尸网络会利用 BAT 等常用服务进行管理 • Mozilla、Reddit 和 Twitter 等呼吁立法保护互联网浏览隐私

# 新闻速读 > Windows 纸牌已经 30 岁了，每月仍然有 3500 万玩家

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

#### Windows 纸牌已经 30 岁了，每月仍然有 3500 万玩家

纸牌游戏是随 1990 年发布的 Windows 3.0 提供给用户的，最初是设计教用户如何使用鼠标，操作鼠标抓住虚拟纸牌拖放到一个地方，教用户基本的拖曳操作。它是史上最常用的 Windows 程序之一，被预装到数以亿计的设备上。它的开发者 Wes Cherry 是微软的实习生，他没有从游戏上获得任何版税。Cherry 最初还给游戏加入了老板模式，伪装成电子表格去愚弄老板和同事，但在正式发布前被要求移除了。如果不移除的话，也许能拯救某些因上班玩纸牌被解雇的员工。

来源：[solidot](https://www.solidot.org/story?sid=64464)

>
> 硬核老王点评：有没有人第一个玩的电脑游戏就是纸牌（或扫雷）？有谁没玩过 Windows 纸牌吗？谁现在还在玩？
>
>
>

#### Microsoft Edge 浏览器迎来“上网冲浪”游戏

谷歌很早就为自家 Chrome 浏览器引入了可离线玩耍的横版跳跃“霸王龙”（T-Rex）游戏，Mozilla Firefox 和 Microsoft Edge 却迟迟没有跟进。不过最新消息是，微软今日宣布向所有用户开放了 Microsoft Edge 集成的“上网冲浪”游戏，感兴趣的朋友可在地址栏输入 edge://surf 来跳转体验。据悉，该游戏已在 Edge Canary、Dev、以及 Beta 通道上线，体验前请先将 Edge 浏览器的版本升到 83.0.478.37 及以上。

来源：[cnBeta.COM](https://hot.cnbeta.com/articles/game/983737.htm)

>
> 硬核老王点评：来，大家一起断网玩游戏！
>
>
>

#### 报告显示僵尸网络会利用 BAT 等常用服务进行管理

奇虎安全研究人员报告，双枪恶意程序的僵尸网络利用国内的常用服务进行管理。该僵尸网络的数量超过了 10 万。研究人员观察到双枪恶意程序使用百度贴吧图片来分发配置文件和恶意软件，使用了阿里云存储来托管配置文件，利用百度统计管理感染主机的活跃情况，恶意程序样本中还多次发现了腾讯微云的 URL 地址。

来源：[solidot](https://www.solidot.org/story?sid=64477)

>
> 硬核老王点评：真是防不胜防，将指令和配置放在这些常用服务中是为了避免追踪。
>
>
>

#### Mozilla、Reddit 和 Twitter 等呼吁立法保护互联网浏览隐私

ZDNet 有消息称，Mozilla、Reddit、Twitter 和 Patreon 以及包括 Reform Government Surveillance、Engine 和 i2Coalition 在内的组织则在近日签署了一封联名信， 要求美国立法者明确禁止无故收集互联网搜索和浏览历史记录的行为。Mozilla 在博客中表示：“我们希望立法者修改该法案，以限制政府对没有证据的互联网浏览和搜索历史的访问。”

来源：[开源中国](https://www.oschina.net/news/115967/mozilla-reddit-twitter-protect-browser-history-privacy)


如何在 Ubuntu 中处理自动的无人值守升级

# 如何在 Ubuntu 中处理自动的无人值守升级

>
> 本教程教你如何处理无人值守的升级，即 Ubuntu Linux 的自动系统更新。
>
>
>

有时，当你尝试[关闭 Ubuntu 系统](https://itsfoss.com/schedule-shutdown-ubuntu/)时，可能看到这个阻止你关闭的页面：

>
> 关机过程中正在进行无人值守升级，请不要关闭计算机。
>
>
>

你可能会问这个“无人值守升级”是什么，怎么会在你不知情的情况下运行呢？

原因是 [Ubuntu](https://ubuntu.com/) 非常重视系统的安全性。默认情况下，它会每天自动检查系统更新，如果发现安全更新，它会下载这些更新并自行安装。对于正常的系统和应用更新，它会通过软件更新程序通知你。

由于所有这些都是在后台发生的，所以在你尝试关闭系统或尝试自行安装应用程序之前，你甚至不会意识到这一点。

在这些无人值守的升级过程中，尝试安装新软件，会导致著名的[无法获得锁定的错误](https://itsfoss.com/could-not-get-lock-error/)。

如你所见，自动更新带来了一些小麻烦。你可以选择禁用自动更新，但这意味着你必须一直手动检查并[更新你的 Ubuntu 系统](https://itsfoss.com/update-ubuntu/)。

>
> **你真的需要禁用自动更新吗？**
>
>
> 请注意，这是一项安全功能。Linux 实际上允许你禁用系统中的所有功能，甚至禁用这些安全功能。
>
>
> 但是我认为，作为普通用户，**你不应该禁用自动更新**。毕竟，它可以确保你的系统安全。
>
>
> 为了确保系统的安全性，你可以忍受自动更新所带来的小麻烦。
>
>
>

现在，你已经收到警告，还是觉得承担手动更新系统的额外任务更好，那么让我们看看如何处理自动更新。

与往常一样，有两种方法可以做到：GUI 和命令行。 我将向你展示两种方法。

我在这里使用 Ubuntu 20.04，但是这些步骤对 Ubuntu 18.04 和任何其他 Ubuntu 版本均有效。

### 方法 1：以图形方式禁用 Ubuntu 中的自动更新

进入菜单并查找“软件和更新”工具。

在此处，进入“更新”选项卡。查找“自动检查更新”。默认情况下，它设置为“每日”。

你可以将其更改为“从不”，你的系统将永远不会检查更新。如果不检查更新，它就不会找到要安装的新的更新。

如果这样做，那么必须不时手动更新系统。但是，这是额外的工作，你可能不会一直记得。

#### 在 Ubuntu 中处理自动更新的更好方法

就个人而言，我建议让它自己检查更新。如果你不希望它自动安装更新，那么可以更改该行为，以通知有关安全更新的可用性。

保持“自动检查更新”为“每日”，然后将“有安全更新时”选项更改为“立即显示”，而不是“自动下载并安装”。

这样，它会检查是否有更新，而不是在后台自动安装更新，软件更新程序会通知你有可用于系统的更新。而你的系统已经完成正常的系统和软件更新。

使用此设置，关闭系统时将不会看到“正在进行的无人值守升级”。但是，由于两个不同的进程无法同时使用 apt 包管理器，因此你仍然可能会遇到“无法锁定”错误。

我相信这是一个更好的解决方案，你不认为是么？

如我承诺的同时有 GUI 和命令行方法一样，让我向你展示如何在终端中禁用无人值守的升级。

### 如何在 Ubuntu 中使用命令行禁用自动更新

你可以在 `/etc/apt/apt.conf.d/20auto-upgrades` 中找到自动升级设置。Ubuntu 终端中的默认文本编辑器是 Nano，因此你可以使用以下命令来编辑此文件：

```
sudo nano /etc/apt/apt.conf.d/20auto-upgrades
```

现在，如果你不希望系统自动检查更新，那么可以将 `APT::Periodic::Update-Package-Lists` 的值更改为 `"0"`。

```
APT::Periodic::Update-Package-Lists "0";
APT::Periodic::Unattended-Upgrade "0";
```

如果你希望它检查更新但不自动安装无人值守的升级，那么可以选择将其设置为：

```
APT::Periodic::Update-Package-Lists "1";
APT::Periodic::Unattended-Upgrade "0";
```

### 最后

由于某种原因，启用了自动安全更新，建议你保持这种状态。这个小烦恼实际上并不值得冒险损害系统安全性。你怎么看？

---

via: <https://itsfoss.com/auto-updates-ubuntu/>

作者：[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/) 荣誉推出


如何在 Arch Linux 上正确安装和设置 KDE Plasma？

Summary: 但现在，不是每个人都是 GNOME 的粉丝，有几个读者要求我们向他们展示如何在 Arch Linux 上配置 KDE 桌面。

kde plasma性能比gnome3好了不知道多少

# 如何在 Arch Linux 上正确安装和设置 KDE Plasma？

我相信你是按照[这份很棒的指南安装来 Arch Linux](/article-9170-1.html) 的，这篇指南最后提到了 [GNOME 桌面](https://www.gnome.org/)的安装步骤。

但现在，不是每个人都是 GNOME 的粉丝，有几个读者要求我们向他们展示如何在 [Arch Linux](https://www.archlinux.org/) 上配置 [KDE 桌面](https://kde.org/plasma-desktop)。

因此，我创建了这个指南来演示如何在 Arch Linux 上正确安装和配置 KDE 桌面（也被称为 KDE Plasma桌面）的步骤。

### 如何在 Arch Linux 上安装和设置 KDE 桌面环境？

请记住，KDE 不允许直接以 root 身份登录。如果你已经安装了 Arch Linux 并以 root 身份使用，你应该创建一个新的用户，并给它以 root 身份运行命令的 sudo 权限。

如果你只是最小化安装了 Arch Linux，那么你可能是以 TTY 终端方式登录的。如果你使用的是其他桌面环境，步骤也是一样的。

让我们开始吧!

#### 步骤 1：创建一个 sudo 用户（如果你只有 root 用户）

你可以使用 [useradd 命令](https://linuxhandbook.com/useradd-command/)来创建一个新用户。我创建的用户名为 `dimitrios`（这是我的名字）。你可以使用与你的名字匹配的东西。

选项 `-m` 为新创建的用户创建一个主目录。

```
useradd -m dimitrios
```

你还应该为这个用户设置一个密码。使用此命令：

```
passwd dimitrios
```

现在你已经创建了用户，给它 sudo 权限。首先，安装 sudo 和一个像 [nano](https://www.nano-editor.org/) 这样的[命令行文本编辑器](https://itsfoss.com/command-line-text-editors-linux/)。

```
pacman -S sudo nano
```

sudo 的配置文件是 `/etc/sudoers`。该文件应该使用 `visudo` 来编辑，它会锁定 `sudoers` 文件，将编辑的内容保存到一个临时文件中，并在复制到 `/etc/sudoers` 之前检查该文件的语法。

要使用 `nano` 作为 `visudo` 编辑器，请这样设置:

```
EDITOR=nano visudo
```

像我的示例那样添加下面这一行，然后保存并退出。

```
dimitrios ALL=(ALL) ALL
```

保存你的更改，然后退出编辑器。你现在在 Arch Linux 上有了一个 sudo 用户。

#### 步骤 2 ：安装 KDE Plasma 桌面

要运行 KDE 桌面，你需要以下软件包。

* [Xorg](https://wiki.archlinux.org/index.php/Xorg) 组
* [KDE Plasma](https://kde.org/plasma-desktop) 桌面环境
* [Wayland](https://wiki.archlinux.org/index.php/Wayland) KDE Plasma 的会话
* [KDE 应用程序](https://www.archlinux.org/groups/x86_64/kde-applications/)组（包括 KDE 特有的应用程序：Dolphin 管理器和其他有用的应用程序）。

你可以用下面的命令安装上述部分。

```
pacman -S xorg plasma plasma-wayland-session kde-applications
```

安装后，启用显示管理器和网络管理器服务。

```
systemctl enable sddm.service
systemctl enable NetworkManager.service
```

快完成了。关闭你的系统。

```
shutdown now
```

重新打开系统电源，你应该会看到 KDE 的登录界面。你还记得为你的 sudo 用户设置的密码吗？用它来登录。

#### 接下来？

你可能会想探索一下[基本的 pacman 命令](https://itsfoss.com/pacman-command/)，了解一下 [Arch 用户资源库](/article-12107-1.html)，了解一下 [AUR 助手](/article-12019-1.html)。

希望这篇教程对你在 Arch Linux 上安装 KDE 桌面有所帮助。如果你在安装过程中遇到任何障碍或困难，请在下面的评论中告诉我们。

你最喜欢的桌面环境或窗口管理器是什么？请告诉我们，别忘了在我们的社交媒体上订阅。

---

via: <https://itsfoss.com/install-kde-arch-linux/>

作者：[Dimitrios Savvopoulos](https://itsfoss.com/author/dimitrios/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)

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


新闻速读 > 百度在 GitHub 上发布量子机器学习工具包

Summary: • 为了阻止学生们规避计算器的考试模式限制，德州仪器取消了对计算器编程的部分支持 • 谷歌 TAG 报告中重点提到了印度的“黑客雇佣”公司 • Qt 5.15 LTS 发布

# 新闻速读 > 百度在 GitHub 上发布量子机器学习工具包

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

#### 百度在 GitHub 上发布量子机器学习工具包

百度日前发布了其量子机器学习平台 Paddle Quantum 的工具包，称该工具包将使开发者能够构建和训练量子神经网络模型。该工具包基于它的深度学习平台 PaddlePaddle 构建，它包括量子化学库和优化工具，以及三个量子应用：量子机器学习、量子化学模拟和量子组合优化。此外，百度还为 PaddlePaddle 推出了 7 个新工具，提供了 27 项增强功能。其中包括 Paddle.js，这是一个深度学习的 JapaScript 库，它将使开发者能够在浏览器内使用 AI 或微信等应用中的智能小程序。

来源：[zdnet](https://www.zdnet.com/article/baidu-releases-quantum-machine-learning-toolkit-on-github/)

>
> 硬核老王点评：这一点，厉害了。好好的做点有用的事情多好。
>
>
>

#### 为了阻止学生们规避计算器的考试模式限制，德州仪器取消了对计算器编程的部分支持

德州仪器公司已经取消了一些最受欢迎的计算器运行汇编或 C 语言编写的程序的能力。除了作为教育工具，德州仪器的计算器也是相对简单、便宜的可编程设备。受影响的计算器包括流行的 TI-84 Plus CE、TI-83 Plus CE-T 和 TI-83 Premium CE。可编程功能在设备的最新固件更新中消失，升级后目前还没有办法回滚。这一改变是为了阻止学生们规避计算器的考试模式限制。尽管计算器仍然支持其他编程语言，如 TI-BASIC 和 Python，但据说这些语言的程序运行效率要低得多。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/984039.htm)

>
> 硬核老王点评：对这些计算器的编程和研究，是一种值得鼓励的古典黑客精神，虽然不应该用在考试作弊上。另外就是，现在去买一台这些可编程计算器还来得及吗？:D
>
>
>

#### 谷歌 TAG 报告中重点提到了印度的“黑客雇佣”公司

谷歌威胁分析小组（TAG）是谷歌安全部门内部跟踪国家和高端网络犯罪团伙的部门，今天发布了其首份 TAG 季度报告。“我们看到了来自‘黑客雇佣’公司的新活动，这些公司很多总部设在印度，他们一直在创建 Gmail 账户，欺骗世卫组织，”谷歌 TAG 负责人 Shane Huntley 说，“这些账户主要针对众多国家内的金融服务、咨询和医疗卫生企业的商业领袖。”

来源：[zdnet](https://www.zdnet.com/article/google-highlights-indian-hack-for-hire-companies-in-new-tag-report/)

>
> 硬核老王点评：利用人类的共同灾难而做这些非法活动，可见其无下限。要警惕印度的国家黑客和黑客产业。顺便提一句，此处所说的黑客和和上面提及的古典黑客精神不是一回事。
>
>
>

#### Qt 5.15 LTS 发布

Qt 项目释出了 Qt 5 系列的最后一个功能版本 5.15，未来它的重心将转向下一个大版本 Qt 6，Qt 6 预计将在年底发布。Qt 5.15 是一个长期支持版本，为商业授权用户提供 3 年的支持，完全兼容 Qt 5 系列之前发布的版本，其主要工作是 bug 修正，它被认为是 Qt 5 系列最稳定的版本。Qt 5.15 的一个主要变化是为 Qt 6 打下基础。

来源：[solidot](https://www.solidot.org/story?sid=64481)


出于安全原因，OpenSSH 决定弃用 SHA-1 验证算法

# 出于安全原因，OpenSSH 决定弃用 SHA-1 验证算法

>
> 破坏一个 SHA-1 生成的 SSH 验证密钥，现在的成本大约为 5 万美元，使得重要的远程服务器面临着被攻击的风险。
>
>
>

<img src="content_image/album_202005_28_175710huryrfkqfzfbufrk.png" alt="OpenSSH SSH" title="OpenSSH SSH">

最受欢迎的连接和管理远程服务器的实用工具 OpenSSH 今天宣布，计划放弃对其 SHA-1 验证方案的支持。在这个宣布当中，OpenSSH 团队列举了 SHA-1 散列算法的安全问题，该算法目前被认为是不安全的。

SHA-1 算法在 2017 年 2 月的一次实际的、真实世界的攻击中被破解，当时谷歌密码学家披露的 [SHAttered](https://shattered.it/) 技术可以使两个不同的文件拥有相同的 SHA-1 文件签名（这称之为“碰撞”）。

在当时，创建一个 SHA-1 碰撞被认为需要非常昂贵的计算成本，谷歌的专家认为 SHA-1 在实际应用中至少还能用上五年，直到成本下降。

然而，随后在 2019 年 5 月和 2020 年 1 月发布的研究报告中，详细介绍了一种更新的方法，将 SHA-1 选择-前缀碰撞攻击chosen-prefix collision attack的成本分别降低到 [11 万美元](https://www.zdnet.com/article/sha-1-collision-attacks-are-now-actually-practical-and-a-looming-danger/)和 [5 万美元](https://eprint.iacr.org/2020/014.pdf)以下。

对于高级威胁攻击者，例如国家黑客和高端网络犯罪集团，如果他们能够生成一个 SSH 认证密钥，使他们能够远程不被发现地访问关键服务器，那么 5 万美元是一个很小的代价。

### OpenSSH 关闭 ssh-rsa 模式

“由于这个原因，我们将在不久的未来版本中默认禁用 ssh-rsa 公钥签名算法。”OpenSSH 开发者今天表示。

OpenSSH 应用程序使用 ssh-rsa 模式来[生成 SSH 验证密钥](https://www.ssh.com/ssh/public-key-authentication)。这些密钥中的一个存储在用户要登录的服务器上，另一个存储在用户的本地 OpenSSH 客户端中，这样用户就可以在每次登录时不需要输入密码就可以访问服务器，而是以本地认证密钥来代替。

在默认情况下，OpenSSH ssh-rsa 模式通过使用 SHA-1 哈希函数生成这些密钥，这意味着这些密钥容易受到 SHAterred 攻击，使攻击者能够生成重复的密钥。

“遗憾的是，尽管有更好的替代方案存在，但这种算法仍然被广泛使用，它是原始的 SSH RFC 规定的唯一剩下的公钥签名算法”，OpenSSH 的开发人员今天表示。

OpenSSH 团队现在要求服务器所有者检查他们的密钥是否已经使用默认的 ssh-rsa 模式生成，并使用不同的模式生成新的密钥。

OpenSSH 团队表示，推荐的模式是 rsa-sha2-256/512（从 OpenSSH 7.2 开始支持）、ssh-ed25519（从 OpenSSH 6.5 开始支持）或 ecdsa-sha2-nistp256/384/521（从 OpenSSH 5.7 开始支持）。

>
> 这里是最近公告中的最好的消息。让我们为所有的嵌入式系统和设备永远不会看到 OpenSSH 中废弃的 ssh-rsa SHA-1 密钥的升级而默哀一分钟。
>
>
> - Julio (@juliocesarfort) 2020 年 5 月 27 日
>
>
>

OpenSSH 项目将在未来（目前还未确定）的版本中默认禁用 ssh-rsa 模式，但是在此之前，他们还计划默认启用 UpdateHostKeys 功能，让服务器所有者可以轻松自动地从旧的 ssh-rsa 模式迁移到更好的验证算法。

依赖 OpenSSH 管理远程系统的服务器管理员可以在 [OpenSSH 8.3 的变更日志](http://www.openssh.com/txt/release-8.3)中找到更多关于如何测试他们的服务器是否有基于弱 SHA-1 的密钥的详细信息。

在之前的一个版本中，在 8.2 版本中，OpenSSH 团队还增加了对[基于 FIDO/U2F 的硬件安全密钥的支持](https://www.zdnet.com/article/openssh-adds-support-for-fidou2f-security-keys/)，这也可以用来更安全地登录远程服务器。

---

via: <https://www.zdnet.com/article/openssh-to-deprecate-sha-1-logins-due-to-security-risk/>

作者：[Catalin Cimpanu](https://www.zdnet.com/meet-the-team/us/catalin.cimpanu/) 选题：[wxy](https://github.com/wxy) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)

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