title
stringlengths 5
75
| author
stringlengths 0
48
| fromurl
stringlengths 0
185
| summary
stringlengths 4
460
| pic
stringlengths 32
70
| largepic
stringlengths 0
69
| titlepic
bool 2
classes | thumb
bool 2
classes | islctt
bool 2
classes | selector
stringclasses 14
values | translator
stringlengths 0
45
| reviewer
stringclasses 27
values | editorchoice
bool 2
classes | tags
sequence | category
stringclasses 20
values | count
dict | comments_data
list | related
list | excerpt
stringlengths 4
460
| date
timestamp[s] | updated
timestamp[s] | id
int64 1
16.6k
| permalink
stringlengths 17
21
| content
stringlengths 116
82.2k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
体验 Xedit 文本编辑器的实用功能 | Seth Kenlon | https://opensource.com/article/20/12/xedit | Xedit 是 X11 图形服务器的一部分，它不算好看，但却有足够的隐藏功能，使它成为一个严肃的文本编辑器。 | /data/attachment/album/202012/18/075942uzhgjgxfxve7p2ot.jpg.thumb.jpg | /data/attachment/album/202012/18/075942uzhgjgxfxve7p2ot.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Xedit"
] | 分享 | {
"viewnum": 3690,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12928,
"displayorder": 0
},
{
"raid": 12933,
"displayorder": 0
}
] | Xedit 是 X11 图形服务器的一部分，它不算好看，但却有足够的隐藏功能，使它成为一个严肃的文本编辑器。 | 2020-12-18T07:59:52 | 2020-12-18T07:59:52 | 12,930 | /article-12930-1.html |
>
> Xedit 是 X11 图形服务器的一部分，它不算好看，但却有足够的隐藏功能，使它成为一个严肃的文本编辑器。
>
>
>
X11 图形服务器由 [X.org](https://www.x.org/wiki/) 发布，它有一些象征性的应用来展示如何使用它提供的工具进行编程。这些应用包括从 [TWM](https://opensource.com/article/19/12/twm-linux-desktop) 桌面到愚蠢但催眠的 Xeyes。它还包括一个名为 Xedit 的文本编辑器，它是一个看似简单的应用，却有足够的隐藏功能，使其成为一个严肃的编辑器。
### 安装 Xedit
如果你使用的是 Linux 或 BSD，你可以从你的发行版软件仓库或 ports 树中安装 Xedit。它有时会出现在一个名为 X11-apps 的软件包中，与其他 X11 应用捆绑在一起。
在 macOS 上，你可以安装 [XQuartz](http://xquartz.org)，它提供了 Xedit、Xeyes 和其他一些小程序（以及一个 X11 图形服务器）。
### 启动 Xedit
如果它被列在你的应用菜单的话，你可以从中启动 Xedit。尽管它绝对是一个 GUI 应用，但有些发行版将它视为命令而不是 GUI 应用，所以它可能不会被列在应用菜单中。这时，你可以从终端启动 Xedit。如果你输入 `xedit &` 来启动应用，它就会启动一个空的 Xedit 编辑器，可以随时输入。如果你在输入启动命令的同时输入一个现有的文件名，Xedit 启动时会将文件加载到缓冲区。
```
$ xedit example.txt &
```
### 加载文件
在打开的 Xedit 实例中，你可以在顶部文本输入框中输入文件的路径来加载文件。点击 **Load** 按钮（在文本输入框的左边），将文件读入 Xedit 窗口。
你可以同时打开多个文件。当一个文件被加载时，它将获取焦点并出现在你的主 Xedit 缓冲区（主窗口中的大文本输入框），并将任何现有的文件切换到一个隐藏的缓冲区。
你可以使用组合键在缓冲区之间切换，这对 Emacs 用户而言很熟悉，但对其他用户会感到困惑。首先，按下 `Ctrl+X`。放开然后按 `Ctrl+B`。
### 组合键
一开始执行需要连续*两*个键盘快捷键的操作感觉很奇怪，但过了一段时间，你就会习惯。事实上，作为一个经常使用 Emacs 的用户，我发现复合键组合很有节奏感。我很惊讶也很高兴地发现，我最喜欢的一些快捷键在 Xedit 中也有效。
原来，Xedit 从几个灵感来源借用了键盘快捷键。如果你是 Emacs 用户，你会发现最常见的组合在 Xedit 中有效。例如，`C-x C-f` （即 `Ctrl+X` 后是 `Ctrl+F`）可以回到顶部的文本输入框来加载文件，而 `C-x C-s`（`Ctrl+X` 后是 `Ctrl+S`）可以保存文件。令人惊讶的是，`C-x 3` 甚至可以垂直分割窗口，而 `C-x 2` 则可以水平分割，`C-x 0` 或 `C-x 1` 则可以移除分割。
Emacs 或 Bash 用户熟悉的编辑命令也适用：
* `Ctrl+A` 移动到行首。
* `Ctrl+E` 移至行尾。
* `Alt+B` 向后移动一个单词。
* `Ctrl+B` 向后移动一个字符。
* `Ctrl+F` 向前移动一个字符。
* `Alt+F` 向前移动一个单词。
* `Ctrl+D 删除下一个字符。
还有更多，它们都在 Xedit 手册页面上列出。
### 使用行编辑模式
Xedit 还含有一个类似 `ex` 的行编辑器，这对 [Vi](https://opensource.com/article/20/12/vi-text-editor) 和 `ed` 甚至 `sed` 用户应该很熟悉。要进入行编辑模式，按下 `Esc` 键。这将使你处于顶部的文本输入框，但处于命令模式。编辑命令使用的语法是：*行号*后面跟着一个*命令*和*参数*。
比如说你有这个文本文件：
```
ed is the standard Unix text editor.
This is line number two.
```
你决定将第 1 行的 `ed` 改为 `Xedit`。在 Xedit 中，移动到第 1 行，按下 `Esc`，然后输入 `.,s/ed/Xedit/`。
```
Xedit is the standard Unix text editor.
This is line number two.
```
不用将光标移到下一行，你可以将 `two` 改为 `the second`。按下 `Esc`，然后输入 `2,s/two/the second/`。
各种命令和有效的参数在 Xedit 的手册页中列出。
### 简单但稳定
Xedit 并不算好看，它很简单，没有菜单可言，但它借鉴了一些最好的 Unix 编辑器的流行的便利性。下次你在寻找新的编辑器时，不妨试试 Xedit。
---
via: <https://opensource.com/article/20/12/xedit>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
用 PyTorch 实现基于字符的循环神经网络 | Julia Evans | https://jvns.ca/blog/2020/11/30/implement-char-rnn-in-pytorch/ | 在过去的几周里，我花了很多时间用 PyTorch 实现了一个 char-rnn 的版本。我以前从未训练过神经网络，所以这可能是一个有趣的开始。 | /data/attachment/album/202012/19/102319oe36em6d63bolg0i.jpg.thumb.jpg | /data/attachment/album/202012/19/102319oe36em6d63bolg0i.jpg | true | false | true | lujun9972 | zxp93 | wxy | false | [
"神经网络",
"RNN"
] | 软件开发 | {
"viewnum": 2828,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 在过去的几周里，我花了很多时间用 PyTorch 实现了一个 char-rnn 的版本。我以前从未训练过神经网络，所以这可能是一个有趣的开始。 | 2020-12-19T10:24:00 | 2020-12-19T10:24:00 | 12,932 | /article-12932-1.html | 
在过去的几周里，我花了很多时间用 PyTorch 实现了一个 [char-rnn](https://karpathy.github.io/2015/05/21/rnn-effectiveness/) 的版本。我以前从未训练过神经网络，所以这可能是一个有趣的开始。
这个想法（来自 [循环神经网络的不合理效应](https://karpathy.github.io/2015/05/21/rnn-effectiveness/)）可以让你在文本上训练一个基于字符的<ruby> 循环神经网络 <rt> recurrent neural network </rt></ruby>（RNN），并得到一些出乎意料好的结果。
不过，虽然没有得到我想要的结果，但是我还是想分享一些示例代码和结果，希望对其他开始尝试使用 PyTorch 和 RNN 的人有帮助。
这是 Jupyter 笔记本格式的代码：[char-rnn in PyTorch.ipynb](https://gist.github.com/jvns/b6dda36b2fdcc02b833ed5b0c7a09112)。你可以点击这个网页最上面那个按钮 “Open in Colab”，就可以在 Google 的 Colab 服务中打开，并使用免费的 GPU 进行训练。所有的东西加起来大概有 75 行代码，我将在这篇博文中尽可能地详细解释。
### 第一步：准备数据
首先，我们要下载数据。我使用的是<ruby> 古登堡项目 <rt> Project Gutenberg </rt></ruby>中的这个数据：[Hans Christian Anderson’s fairy tales](https://www.gutenberg.org/cache/epub/27200/pg27200.txt)。
```
!wget -O fairy-tales.txt
```
这个是准备数据的代码。我使用 `fastai` 库中的 `Vocab` 类进行数据处理，它能将一堆字母转换成“词表”，然后用这个“词表”把字母变成数字。
之后我们就得到了一个大的数字数组（`training_set`），我们可以用于训练我们的模型。
```
from fastai.text import *
text = unidecode.unidecode(open('fairy-tales.txt').read())
v = Vocab.create((x for x in text), max_vocab=400, min_freq=1)
training_set = torch.Tensor(v.numericalize([x for x in text])).type(torch.LongTensor).cuda()
num_letters = len(v.itos)
```
### 第二步：定义模型
这个是 PyTorch 中 `LSTM` 类的封装。除了封装 `LSTM` 类以外，它还做了三件事：
1. 对输入向量进行 one-hot 编码，使得它们具有正确的维度。
2. 在 `LSTM` 层后一层添加一个线性变换，因为 `LSTM` 输出的是一个长度为 `hidden_size` 的向量，我们需要的是一个长度为 `input_size` 的向量这样才能把它变成一个字符。
3. 把 `LSTM` 隐藏层的输出向量（实际上有 2 个向量）保存成实例变量，然后在每轮运行结束后执行 `.detach()` 函数。（我很难解释清 `.detach()` 的作用，但我的理解是，它在某种程度上“结束”了模型的求导计算）（LCTT 译注：`detach()` 函数是将该张量的 `requires_grad` 参数设置为 `False`，即反向传播到该张量就结束。）
```
class MyLSTM(nn.Module):
def __init__(self, input_size, hidden_size):
super().__init__()
self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
self.h2o = nn.Linear(hidden_size, input_size)
self.input_size=input_size
self.hidden = None
def forward(self, input):
input = torch.nn.functional.one_hot(input, num_classes=self.input_size).type(torch.FloatTensor).cuda().unsqueeze(0)
if self.hidden is None:
l_output, self.hidden = self.lstm(input)
else:
l_output, self.hidden = self.lstm(input, self.hidden)
self.hidden = (self.hidden[0].detach(), self.hidden[1].detach())
return self.h2o(l_output)
```
这个代码还做了一些比较神奇但是不太明显的功能。如果你的输入是一个向量（比如 `[1,2,3,4,5,6]`），对应六个字母，那么我的理解是 `nn.LSTM` 会在内部使用[沿时间反向传播](https://en.wikipedia.org/wiki/Backpropagation_through_time)更新隐藏向量 6 次。
### 第三步：编写训练代码
模型不会自己训练的！
我最开始的时候尝试用 `fastai` 库中的一个辅助类（也是 PyTorch 中的封装）。我有点疑惑因为我不知道它在做什么，所以最后我自己编写了模型训练代码。
下面这些代码（`epoch()` 方法）就是有关于一轮训练过程的基本信息。基本上就是重复做下面这几件事情：
1. 往 RNN 模型中传入一个字符串，比如 `and they ought not to teas`。（要以数字向量的形式传入）
2. 得到下一个字母的预测结果
3. 计算 RNN 模型预测结果和真实的下一个字母之间的损失函数（`e`，因为 `tease` 这个单词是以 `e` 结尾的）
4. 计算梯度（用 `loss.backward()` 函数）
5. 沿着梯度下降的方向修改模型中参数的权重（用 `self.optimizer.step()` 函数）
```
class Trainer():
def __init__(self):
self.rnn = MyLSTM(input_size, hidden_size).cuda()
self.optimizer = torch.optim.Adam(self.rnn.parameters(), amsgrad=True, lr=lr)
def epoch(self):
i = 0
while i < len(training_set) - 40:
seq_len = random.randint(10, 40)
input, target = training_set[i:i+seq_len],training_set[i+1:i+1+seq_len]
i += seq_len
# forward pass
output = self.rnn(input)
loss = F.cross_entropy(output.squeeze()[-1:], target[-1:])
# compute gradients and take optimizer step
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
```
### 使用 nn.LSTM 沿着时间反向传播，不要自己写代码
开始的时候我自己写代码每次传一个字母到 LSTM 层中，之后定期计算导数，就像下面这样：
```
for i in range(20):
input, target = next(iter)
output, hidden = self.lstm(input, hidden)
loss = F.cross_entropy(output, target)
hidden = hidden.detach()
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
```
这段代码每次传入 20 个字母，每次一个，并且在最后训练了一次。这个步骤就被称为[沿时间反向传播](https://en.wikipedia.org/wiki/Backpropagation_through_time)，Karpathy 在他的博客中就是用这种方法。
这个方法有些用处，我编写的损失函数开始能够下降一段时间，但之后就会出现峰值。我不知道为什么会出现这种现象，但之后我改为一次传入 20 个字符到 LSTM 之后（按 `seq_len` 维度），再进行反向传播，情况就变好了。
### 第四步：训练模型！
我在同样的数据上重复执行了这个训练代码大概 300 次，直到模型开始输出一些看起来像英文的文本。差不多花了一个多小时吧。
这种情况下我也不关注模型是不是过拟合了，但是如果你在真实场景中训练模型，应该要在验证集上验证你的模型。
### 第五步：生成输出！
最后一件要做的事就是用这个模型生成一些输出。我写了一个辅助方法从这个训练好的模型中生成文本（`make_preds` 和 `next_pred`）。这里主要是把向量的维度对齐，重要的一点是：
```
output = rnn(input)
prediction_vector = F.softmax(output/temperature)
letter = v.textify(torch.multinomial(prediction_vector, 1).flatten(), sep='').replace('_', ' ')
```
基本上做的事情就是这些：
1. RNN 层为字母表中的每一个字母或者符号输出一个数值向量（`output`）。
2. 这个 `output` 向量**并不是**一个概率向量，所以需要 `F.softmax(output/temperature)` 操作，将其转换为概率值（也就是所有数值加起来和为 1）。`temperature` 某种程度上控制了对更高概率的权重，在限制范围内，如果设置 `temperature=0.0000001`，它将始终选择概率最高的字母。
3. `torch.multinomial(prediction_vector)` 用于获取概率向量，并使用这些概率在向量中选择一个索引（如 `12`）。
4. `v.textify` 把 `12` 转换为字母。
如果我们想要处理的文本长度为 300，那么只需要重复这个过程 300 次就可以了。
### 结果！
我把预测函数中的参数设置为 `temperature = 1` 得到了下面的这些由模型生成的结果。看起来有点像英语，这个结果已经很不错了，因为这个模型要从头开始“学习”英语，并且是在字符序列的级别上进行学习的。
虽然这些话没有什么*含义*，但我们也不知道到底想要得到什么输出。
>
> “An who was you colotal said that have to have been a little crimantable and beamed home the beetle. “I shall be in the head of the green for the sound of the wood. The pastor. “I child hand through the emperor’s sorthes, where the mother was a great deal down the conscious, which are all the gleam of the wood they saw the last great of the emperor’s forments, the house of a large gone there was nothing of the wonded the sound of which she saw in the converse of the beetle. “I shall know happy to him. This stories herself and the sound of the young mons feathery in the green safe.”
>
>
> “That was the pastor. The some and hand on the water sound of the beauty be and home to have been consider and tree and the face. The some to the froghesses and stringing to the sea, and the yellow was too intention, he was not a warm to the pastor. The pastor which are the faten to go and the world from the bell, why really the laborer’s back of most handsome that she was a caperven and the confectioned and thoughts were seated to have great made
>
>
>
下面这些结果是当 `temperature=0.1` 时生成的，它选择字符的方式更接近于“每次都选择出现概率最高的字符”。这就使得输出结果有很多是重复的。
>
> ole the sound of the beauty of the beetle. “She was a great emperor of the sea, and the sun was so warm to the confectioned the beetle. “I shall be so many for the beetle. “I shall be so many for the beetle. “I shall be so standen for the world, and the sun was so warm to the sea, and the sun was so warm to the sea, and the sound of the world from the bell, where the beetle was the sea, and the sound of the world from the bell, where the beetle was the sea, and the sound of the wood flowers and the sound of the wood, and the sound of the world from the bell, where the world from the wood, and the sound of the
>
>
>
这段输出对这几个单词 `beetles`、`confectioners`、`sun` 和 `sea` 有着奇怪的执念。
### 总结！
至此，我的结果远不及 Karpathy 的好，可能有一下几个原因：
1. 没有足够多的训练数据。
2. 训练了一个小时之后我就没有耐心去查看 Colab 笔记本上的信息。
3. Karpathy 使用了两层LSTM，包含了更多的参数，而我只使用了一层。
4. 完全是另一回事。
但我得到了一些大致说得过去的结果！还不错！
---
via: <https://jvns.ca/blog/2020/11/30/implement-char-rnn-in-pytorch/>
作者：[Julia Evans](https://jvns.ca/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[zhangxiangping](https://github.com/zxp93) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 gedit 文本编辑器优化你的 GNOME 体验 | Seth Kenlon | https://opensource.com/article/20/12/gedit | 它是一个可以完成工作的简约编辑器，并以隐藏的增强功能使得事情更简单。 | /data/attachment/album/202012/19/110419snchihpnjn8juxqc.jpg.thumb.jpg | /data/attachment/album/202012/19/110419snchihpnjn8juxqc.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"gedit"
] | 分享 | {
"viewnum": 3570,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12930,
"displayorder": 0
},
{
"raid": 12938,
"displayorder": 0
}
] | 它是一个可以完成工作的简约编辑器，并以隐藏的增强功能使得事情更简单。 | 2020-12-19T11:05:06 | 2020-12-19T11:05:06 | 12,933 | /article-12933-1.html |
>
> 它是一个可以完成工作的简约编辑器，并以隐藏的增强功能使得事情更简单。
>
>
>
作为默认的文本编辑器是一项吃力不讨好的工作。人们通常把默认文本编辑器几乎看作是一个演示应用、一个稍微好一点的 “hello World” 示例，说明应用在该平台上的是如何运行的。在极少数情况下，当用户需要将一些文本保存到一个可能永远不会再看的文件中时，用户会找到默认文本编辑器。对于“严肃”的工作，他们会转向文字处理器或 IDE，或终端中的编辑器，或者至少是一个不同的文本编辑器，必须像“真正的”应用一样下载和安装。
很奇怪，默认的文本编辑器很难被人重视，然而 GNOME 桌面的编辑器 gedit 却被广泛认为是一个真正有价值的文本编辑器，超越了它所在的桌面。它被用作网页设计课程的必备文本编辑器，是新手开发者和系统管理员的推荐工具，也是许多桌面 Linux 用户最喜欢的可靠伙伴。
### 安装 gedit
如果你运行的是 GNOME 桌面，你可能已经安装了 gedit，尽管它可能只作为“文本编辑器”出现在你的应用菜单中。如果你不确定，只需在你的活动界面中输入 `gedit`，然后在打开的文本编辑器中进入 “About” 菜单项。
在 Windows 上，你可以[从微软商店下载并安装 gedit](https://www.microsoft.com/en-nz/p/gedit)。
在 Mac 上，你可以[使用 Homebrew](https://opensource.com/article/20/6/homebrew-mac)或 [MacPorts](https://opensource.com/article/20/11/macports) 安装 gedit。
### 使用 gedit
当你第一次启动 gedit 时，你会看到一个简约的界面，包括一个文本输入面板、一个标题栏和一个位于窗口底部的状态面板。底部的状态面板提供了一些常用的设置：你想使用哪种语法高亮模式、你喜欢的制表符宽度、以及一些流行的偏好，如行号、文本换行等等。这些选项中的大部分也可以在 “Preferences” 菜单中进行全局设置，它可在应用程序右上角的 “汉堡” 样式的菜单中找到。
### gedit 的隐藏功能
从表面上看，gedit 正是它所标榜的那样：一个不起眼的文本编辑器，它不会妨碍你的工作，因此你可以在屏幕上的框中输入字母。但是，这个简单的文本编辑器却隐藏着一些你可能不知道的令人兴奋的功能，即使你已经使用它多年。
这些键盘功能在 gedit 中并没有被记录下来：
* `Ctrl+D` 删除当前行。这对于编码者或以标记格式（如 Asciidoc、reST 或 CommonMark）写作的人特别有用。
* `Ctrl+I` 会弹出 “Go to Line” 下拉框。输入一个数字，你就会立即跳到该行。
* `Alt+向上箭头` 或 `Alt+向下箭头` 会抓取当前行，并将它在文档中向上或向下移动。
* `Alt+向左箭头` 或 `Alt+向右箭头` 抓取最近的单词（在光标左侧）并将其向左或向右移动。
* 要输入特殊的 Unicode 字符，请按下 `Shift+Ctrl+U` 并松开，然后输入 Unicode 字符代码。你通常必须查找字符代码（除非你已经记住了一些，但谁有记性来记住这些字符代码？）例如，要打出一只企鹅，按下 `Shift+Ctrl+U` 然后松开。当你松开按键后，你会看到一个带下划线的 U，然后输入 `1F427`，后面跟一个空格，你的 Unicode 字符就会变成一个友好的 `?`。诚然，这并不完全是 gedit 所独有的，但这是个很有用的技巧，而且它在 gedit 中也确实有效。
### 稳定简单
Gedit 很像 GNOME 本身。它客观上比许多同类软件（比如 KDE 的 Kate）更简单，但它仍然能够满足你日常 80% 或 90% 的期望。
当然，可能会有一些任务 gedit 不是最佳工具。你可能会发现自己要深入研究一些独特的日志文件，或者需要一个精确的解析器或代码检查器，你会转向专门的应用。这没关系。gedit 并不意味着对所有用户都适用。但对于那些需要文本编辑器的人来说，它是一个很好的文本编辑器，有时这就是所需要的。在 Linux 或者在任何你正在使用的平台上，试一下 gedit，因为它很有可能是一个比默认应用的更好的选择。
---
via: <https://opensource.com/article/20/12/gedit>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何使用 Python 绘制 COVID-19 的全球扩散图 | Anuraggupta | https://opensource.com/article/20/4/python-map-covid-19 | 使用这些开源框架创建一个彩色地图，显示病毒的可能的传播路径。 | /data/attachment/album/202012/20/005146t8voetski8ocm5c2.jpg.thumb.jpg | /data/attachment/album/202012/20/005146t8voetski8ocm5c2.jpg | true | false | true | lujun9972 | zxp93 | wxy | false | [
"地图",
"Pandas"
] | 软件开发 | {
"viewnum": 4523,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 使用这些开源框架创建一个彩色地图，显示病毒的可能的传播路径。 | 2020-12-20T00:52:00 | 2020-12-20T00:52:00 | 12,935 | /article-12935-1.html |
>
> 使用这些开源框架创建一个彩色地图，显示病毒的可能的传播路径。
>
>
>
对于一个全球旅行司空见惯的世界来说，疾病的传播是一个真正令人担忧的问题。一些组织会跟踪重大的流行病（还有所有普遍的流行病），并将他们的跟踪工作获得的数据公开出来。不过，这些原始的数据对人来说可能很难处理，这就是为什么数据科学如此重要的原因。比如，用 Python 和 Pandas 可视化 COVID-19 在全球范围内的传播路径可能对这些数据的分析有所帮助。
最开始，当面对如此大数量的原始数据时可能难以下手。但当你开始处理数据之后，慢慢地就会发现一些处理数据的方式。下面是用于处理 COVID-19 数据的一些常见的情况：
1. 从 GitHub 上下载 COVID-19 的国家每日传播数据，保存为一个 Pandas 中的 DataFrame 对象。这时你需要使用 Python 中的 Pandas 库。
2. 处理并清理下载好的数据，使其满足可视化数据的输入格式。所下载的数据的情况很好（数据规整）。这个数据有一个问题是它用国家的名字来标识国家，但最好是使用三位数的 ISO 3 码（国家代码表）来标识国家。为了生成 ISO 3 码，可是使用 `pycountry` 这个 Python 库。生成了这些代码之后，可以在原有的 DataFrame 上增加一列，然后用这些代码填充进去。
3. 最后为了实现可视化，使用 Plotly 库中的 `express` 模块。这篇文章是使用名为choropleth 的地图（可在 Plotly 库中获得）来可视化该疾病在全球的传播。
### 第一步：Corona 数据
从下面这个网站上下载最新的 corona 数据（LCTT 译注：2020-12-14 仍可访问，有墙）：
* <https://raw.githubusercontent.com/datasets/covid-19/master/data/countries-aggregated.csv>
我们之间将这个下载好的数据载入为 Pandas 的 DataFrame。Pandas 提供了一个函数， `read_csv()`，可以直接使用 URL 读取数据，并返回一个 DataFrame 对象，具体如下所示：
```
import pycountry
import plotly.express as px
import pandas as pd
URL_DATASET = r'https://raw.githubusercontent.com/datasets/covid-19/master/data/countries-aggregated.csv'
df1 = pd.read_csv(URL_DATASET)
print(df1.head(3)) # Get first 3 entries in the dataframe
print(df1.tail(3)) # Get last 3 entries in the dataframe
```
在 Jupyter 上的输出截图：
从这个输出可以看到这个 DataFrame（`df1`）包括以下几列数据：
1. `Date`
2. `Country`
3. `Confirmed`
4. `Recovered`
5. `Dead`
之后还可以看到 `Date` 这一列包含了从 1 月 22 日到 3 月 31 日的条目信息。这个数据是每天更新的，所以你会得到你当天的值。
### 第二步：清理和修改 DataFrame
我们要往这个 DataFrame 中增加一列数据，就是那个包含了 ISO 3 编码。可以通过以下三步完成这个任务：
1. 创建一个包含所有国家的列表。因为在 `df1` 的 `Country` 列中，国家都是每个日期就重复一次。所以实际上 `Country` 列中对每个国家就会有多个条目。我使用 `unique().tolist()` 函数完成这个任务。
2. 我使用 `d_country_code` 字典对象（初始为空），然后将其键设置为国家的名称，然后它的值设置为其对应的 ISO 3 编码。
3. 我使用 `pycountry.countries.search_fuzzy(country)` 为每个国家生成 ISO 3 编码。你需要明白的是这个函数的返回值是一个 `Country` 对象的列表。我将这个函数的返回值赋给 `country_data` 对象。以这个对象的第一个元素（序号 `0`）为例。这个 `\` 对象有一个 `alpha_3` 属性。所以我使用 `country_data[0].alpha_3` 就能“获得”第一个元素的 ISO 3 编码。然而，在这个 DataFrame 中有些国家的名称可能没有对应的 ISO 3 编码（比如有争议的领土）。那么对这些“国家/地区”，我就用一个空白字符串来替代 ISO 3 编码。你也可以用一个 `try-except` 代码来替换这部分。`except` 中的语句可以写：`print(‘could not add ISO 3 code for ->', country)`。这样就能在找不到这些“国家/地区”对应的 ISO 3 编码时给出一个输出提示。实际上，你会发现这些“国家/地区”会在最后的输出中用白色来表示。
4. 在获得了每个国家的 ISO 3 编码（有些是空白字符串）之后，我把这些国家的名称（作为键）还有国家对应的 ISO 3 编码（作为值）添加到之前的字典 `d_country_code` 中。可以使用 Python 中字典对象的 `update()` 方法来完成这个任务。
5. 在创建好了一个包含国家名称和对应 ISO 3 编码的字典之后，我使用一个简单的循环将他们加入到 DataFrame 中。
### 第三步：使用 Plotly 可视化传播路径
choropleth 地图是一个由彩色多边形组成的地图。它常常用来表示一个变量在空间中的变化。我们使用 Plotly 中的 `px` 模块来创建 choropleth 图，具体函数为：`px.choropleth`。
这个函数的所包含的参数如下：
```
plotly.express.choropleth(data_frame=None, lat=None, lon=None, locations=None, locationmode=None, geojson=None, featureidkey=None, color=None, hover_name=None, hover_data=None, custom_data=None, animation_frame=None, animation_group=None, category_orders={}, labels={}, color_discrete_sequence=None, color_discrete_map={}, color_continuous_scale=None, range_color=None, color_continuous_midpoint=None, projection=None, scope=None, center=None, title=None, template=None, width=None, height=None)
```
`choropleth()` 这个函数还有几点需要注意：
1. `geojson` 是一个 `geometry` 对象（上面函数第六个参数）。这个对象有点让人困扰，因为在函数文档中没有明确地提到这个对象。你可以提供，也可以不提供 `geojson` 对象。如果你提供了 `geojson` 对象，那么这个对象就会被用来绘制地球特征，如果不提供 `geojson` 对象，那这个函数默认就会使用一个内建的 `geometry` 对象。（在我们的实验中，我们使用内建的 `geometry` 对象，因此我们不会为 `geojson` 参数提供值）
2. DataFrame 对象有一个 `data_frame` 属性，在这里我们先前就提供了一个我们创建好的`df1`。
3. 我们用 `Confirmed`（确诊数）来决定每个国家多边形的颜色。
4. 最后，我们 `Date` 列创建一个 `animation_frame`。这样我们就能通过日期来划分数据，国家的颜色会随着 `Confirmed` 的变化而变化。
最后完整的代码如下：
```
import pycountry
import plotly.express as px
import pandas as pd
# ----------- Step 1 ------------
URL_DATASET = r'https://raw.githubusercontent.com/datasets/covid-19/master/data/countries-aggregated.csv'
df1 = pd.read_csv(URL_DATASET)
# print(df1.head) # Uncomment to see what the dataframe is like
# ----------- Step 2 ------------
list_countries = df1['Country'].unique().tolist()
# print(list_countries) # Uncomment to see list of countries
d_country_code = {} # To hold the country names and their ISO
for country in list_countries:
try:
country_data = pycountry.countries.search_fuzzy(country)
# country_data is a list of objects of class pycountry.db.Country
# The first item ie at index 0 of list is best fit
# object of class Country have an alpha_3 attribute
country_code = country_data[0].alpha_3
d_country_code.update({country: country_code})
except:
print('could not add ISO 3 code for ->', country)
# If could not find country, make ISO code ' '
d_country_code.update({country: ' '})
# print(d_country_code) # Uncomment to check dictionary
# create a new column iso_alpha in the df
# and fill it with appropriate iso 3 code
for k, v in d_country_code.items():
df1.loc[(df1.Country == k), 'iso_alpha'] = v
# print(df1.head) # Uncomment to confirm that ISO codes added
# ----------- Step 3 ------------
fig = px.choropleth(data_frame = df1,
locations= "iso_alpha",
color= "Confirmed", # value in column 'Confirmed' determines color
hover_name= "Country",
color_continuous_scale= 'RdYlGn', # color scale red, yellow green
animation_frame= "Date")
fig.show()
```
你可以从这里下载并运行[完整代码](https://github.com/ag999git/jupyter_notebooks/blob/master/corona_spread_visualization)。
最后，这里还有一些关于 Plotly 绘制 choropleth 图的不错的资源。
* <https://github.com/plotly/plotly.py/blob/master/doc/python/choropleth-maps.md>
* <https://plotly.com/python/reference/#choropleth>
---
via: <https://opensource.com/article/20/4/python-map-covid-19>
作者：[AnuragGupta](https://opensource.com/users/999anuraggupta) 选题：[lujun9972](https://github.com/lujun9972) 译者：[zhangxiangping](https://github.com/zxp93) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 LVM 为你的 Fedora 系统添加存储 | Tim Bosse | https://fedoramagazine.org/add-storage-to-your-fedora-system-with-lvm/ | LVM 的好处之处在于它相当灵活。有几种方法可以添加一块磁盘。这篇文章介绍了一种方法。 | /data/attachment/album/202012/20/100519bj1df01ffhdw831k.jpg.thumb.jpg | /data/attachment/album/202012/20/100519bj1df01ffhdw831k.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"LVM"
] | 系统运维 | {
"viewnum": 4129,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | LVM 的好处之处在于它相当灵活。有几种方法可以添加一块磁盘。这篇文章介绍了一种方法。 | 2020-12-20T10:05:18 | 2020-12-20T10:05:18 | 12,936 | /article-12936-1.html | 
有时需要在系统中添加另一块磁盘。这就是<ruby> 逻辑卷管理 <rt> Logical Volume Management </rt></ruby>（LVM）的用武之地。LVM 的好处之处在于它相当灵活。有几种方法可以添加一块磁盘。这篇文章介绍了一种方法。
### 注意！
这篇文章并不包括将新的磁盘物理地安装到系统中的过程。请查阅你的系统和磁盘文档，了解如何正确地进行安装。
**重要：** 一定要确保你已经备份重要数据。如果新磁盘已有数据，那么本文中描述的步骤将破坏数据。
### 最好了解
本文并没有深入介绍 LVM 的每一个功能，重点是添加磁盘。但基本上你要了解，LVM 有<ruby> 卷组 <rt> volume group </rt></ruby>（VG），它由一个或多个分区和/或磁盘组成。你把这些分区或磁盘以<ruby> 物理卷 <rt> physical volume </rt></ruby>（PV）的方式添加到卷组。一个卷组可以分成许多<ruby> 逻辑卷 <rt> logical volume </rt></ruby>（LV）。逻辑卷可以作为文件系统、ramdisk 等其他存储使用。更多信息可以在[这里](https://en.wikipedia.org/wiki/Logical_Volume_Manager_(Linux))中找到。
可以看作是，把物理卷形成一个存储池（一个卷组），然后从这个存储池中划分出逻辑卷，供你的系统直接使用。
### 准备
确保你能看到你要添加的磁盘。在添加磁盘之前使用 `lsblk` 查看哪些存储空间已经可用或正在使用。
```
$ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
zram0 251:0 0 989M 0 disk [SWAP]
vda 252:0 0 20G 0 disk
├─vda1 252:1 0 1G 0 part /boot
└─vda2 252:2 0 19G 0 part
└─fedora_fedora-root 253:0 0 19G 0 lvm /
```
本文使用的是带有虚拟存储的虚拟机，因此设备名称以 `vda` 开头代表第一个磁盘，`vdb` 代表第二个磁盘，以此类推。你的设备名称可能不同。许多系统会将 `sda` 作为第一个物理磁盘，`sdb` 代表第二个磁盘，以此类推。
当已连接新磁盘，并且你的系统已备份且正在运行，再次使用 `lsblk` 来查看新的块设备。
```
$ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
zram0 251:0 0 989M 0 disk [SWAP]
vda 252:0 0 20G 0 disk
├─vda1 252:1 0 1G 0 part /boot
└─vda2 252:2 0 19G 0 part
└─fedora_fedora-root 253:0 0 19G 0 lvm /
vdb 252:16 0 10G 0 disk
```
现在有一个名为 `vdb` 的新设备。该设备的位置是 `/dev/vdb`。
```
$ ls -l /dev/vdb
brw-rw----. 1 root disk 252, 16 Nov 24 12:56 /dev/vdb
```
我们可以看到磁盘，但我们还不能用 LVM 来使用它。如果你运行 `blkid`，你应该不会看到它被列出。对于这个和之后的命令，你需要确保你的系统[已配置好，这样你可以使用 sudo](https://fedoramagazine.org/howto-use-sudo/)：
```
$ sudo blkid
/dev/vda1: UUID="4847cb4d-6666-47e3-9e3b-12d83b2d2448" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="830679b8-01"
/dev/vda2: UUID="k5eWpP-6MXw-foh5-Vbgg-JMZ1-VEf9-ARaGNd" TYPE="LVM2_member" PARTUUID="830679b8-02"
/dev/mapper/fedora_fedora-root: UUID="f8ab802f-8c5f-4766-af33-90e78573f3cc" BLOCK_SIZE="4096" TYPE="ext4"
/dev/zram0: UUID="fc6d7a48-2bd5-4066-9bcf-f062b61f6a60" TYPE="swap"
```
### 将磁盘添加到 LVM 中
使用 `pvcreate` 初始化磁盘。你需要传递设备的完整路径。在这个例子中，它是 `/dev/vdb`。在你的系统中，它可能是 `/dev/sdb` 或其他设备名。
```
$ sudo pvcreate /dev/vdb
Physical volume "/dev/vdb" successfully created.
```
当你运行 `blkid` 时，你应该看到磁盘已经被初始化为一个 `LVM2_member`：
```
$ sudo blkid
/dev/vda1: UUID="4847cb4d-6666-47e3-9e3b-12d83b2d2448" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="830679b8-01"
/dev/vda2: UUID="k5eWpP-6MXw-foh5-Vbgg-JMZ1-VEf9-ARaGNd" TYPE="LVM2_member" PARTUUID="830679b8-02"
/dev/mapper/fedora_fedora-root: UUID="f8ab802f-8c5f-4766-af33-90e78573f3cc" BLOCK_SIZE="4096" TYPE="ext4"
/dev/zram0: UUID="fc6d7a48-2bd5-4066-9bcf-f062b61f6a60" TYPE="swap"
/dev/vdb: UUID="4uUUuI-lMQY-WyS5-lo0W-lqjW-Qvqw-RqeroE" TYPE="LVM2_member"
```
你可以使用 `pvs` 列出当前所有可用的物理卷：
```
$ sudo pvs
PV VG Fmt Attr PSize PFree
/dev/vda2 fedora_fedora lvm2 a-- <19.00g 0
/dev/vdb lvm2 --- 10.00g 10.00g
```
`/dev/vdb` 被列为一个 PV （物理卷），但还没有分配到一个 VG （卷组）。
### 将物理卷添加到一个卷组
你可以使用 `vgs` 找到可用的卷组列表：
```
$ sudo vgs
VG #PV #LV #SN Attr VSize VFree
fedora_fedora 1 1 0 wz--n- 19.00g 0
```
在本例中，只有一个卷组可用。接下来，将物理卷添加到 `fedora_fedora`：
```
$ sudo vgextend fedora_fedora /dev/vdb
Volume group "fedora_fedora" successfully extended
```
你现在应该看到物理卷已被添加到卷组中：
```
$ sudo pvs
PV VG Fmt Attr PSize PFree
/dev/vda2 fedora_fedora lvm2 a– <19.00g 0
/dev/vdb fedora_fedora lvm2 a– <10.00g <10.00g
```
看一下卷组：
```
$ sudo vgs
VG #PV #LV #SN Attr VSize VFree
fedora_fedora 2 1 0 wz–n- 28.99g <10.00g
```
你也可以获得具体卷组和物理卷的详细列表：
```
$ sudo vgdisplay fedora_fedora
--- Volume group ---
VG Name fedora_fedora
System ID
Format lvm2
Metadata Areas 2
Metadata Sequence No 3
VG Access read/write
VG Status resizable
MAX LV 0
Cur LV 1
Open LV 1
Max PV 0
Cur PV 2
Act PV 2
VG Size 28.99 GiB
PE Size 4.00 MiB
Total PE 7422
Alloc PE / Size 4863 / 19.00 GiB
Free PE / Size 2559 / 10.00 GiB
VG UUID C5dL2s-dirA-SQ15-TfQU-T3yt-l83E-oI6pkp
```
看下物理卷：
```
$ sudo pvdisplay /dev/vdb
--- Physical volume ---
PV Name /dev/vdb
VG Name fedora_fedora
PV Size 10.00 GiB / not usable 4.00 MiB
Allocatable yes
PE Size 4.00 MiB
Total PE 2559
Free PE 2559
Allocated PE 0
PV UUID 4uUUuI-lMQY-WyS5-lo0W-lqjW-Qvqw-RqeroE
```
现在我们已经添加了磁盘，我们可以为逻辑卷 （LV） 分配空间：
```
$ sudo lvs
LV VG Attr LSize Pool Origin Data% Meta% Move Log Cpy%Sync Convert
root fedora_fedora -wi-ao---- 19.00g
```
看一下逻辑卷。下面是详细的逻辑卷信息：
```
$ sudo lvdisplay fedora_fedora/root
--- Logical volume ---
LV Path /dev/fedora_fedora/root
LV Name root
VG Name fedora_fedora
LV UUID yqc9cw-AvOw-G1Ni-bCT3-3HAa-qnw3-qUSHGM
LV Write Access read/write
LV Creation host, time fedora, 2020-11-24 11:44:36 -0500
LV Status available
LV Size 19.00 GiB
Current LE 4863
Segments 1
Allocation inherit
Read ahead sectors auto
- currently set to 256
Block device 253:0
```
查看根文件系统（`/`）的大小，并将它与逻辑卷大小进行比较。
```
$ df -h /
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/fedora_fedora-root 19G 1.4G 17G 8% /
```
逻辑卷和文件系统大小都为 19G。让我们给根逻辑卷（`root`）增加 5G。
```
$ sudo lvresize -L +5G fedora_fedora/root
Size of logical volume fedora_fedora/root changed from 19.00 GiB (4863 extents) to 24.00 GiB (6143 extents).
Logical volume fedora_fedora/root successfully resized.
```
我们现在有 24G 的逻辑卷可用。看看根文件系统（`/`）。
```
$ df -h /
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/fedora_fedora-root 19G 1.4G 17G 8% /
```
我们仍然显示只有 19G 的空闲空间，这是因为逻辑卷与文件系统不一样。要使用增加到逻辑卷的新空间，请调整文件系统的大小。
```
$ sudo resize2fs /dev/fedora_fedora/root
resize2fs 1.45.6 (20-Mar-2020)
Filesystem at /dev/fedora_fedora/root is mounted on /; on-line resizing required
old_desc_blocks = 3, new_desc_blocks = 3
The filesystem on /dev/fedora_fedora/root is now 6290432 (4k) blocks long.
```
看看文件系统的大小。
```
$ df -h /
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/fedora_fedora-root 24G 1.4G 21G 7% /
```
正如你所看到的，根文件系统（`/`）已经占用了逻辑卷上的所有可用空间，而且不需要重新启动。
现在你已经将一个磁盘初始化为物理卷，并使用新的物理卷扩展了卷组。之后，你增加了逻辑卷的大小，并调整了文件系统的大小，以使用逻辑卷的新空间。
---
via: <https://fedoramagazine.org/add-storage-to-your-fedora-system-with-lvm/>
作者：[Tim Bosse](https://fedoramagazine.org/author/maztaim/) 选题：[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/) 荣誉推出
|
让 medit 成为你的下一个 Linux 代码编辑器 | Seth Kenlon | https://opensource.com/article/20/12/medit | 这款经典的文本编辑器提供了所有的基本功能和一些让你自定义你的体验的令人兴奋的功能。 | /data/attachment/album/202012/21/103921rqtvtsyvyvy5bsq7.jpg.thumb.jpg | /data/attachment/album/202012/21/103921rqtvtsyvyvy5bsq7.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"编辑器"
] | 分享 | {
"viewnum": 4464,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12933,
"displayorder": 0
},
{
"raid": 12942,
"displayorder": 0
}
] | 这款经典的文本编辑器提供了所有的基本功能和一些让你自定义你的体验的令人兴奋的功能。 | 2020-12-21T10:40:00 | 2020-12-21T10:40:00 | 12,938 | /article-12938-1.html |
>
> 这款经典的文本编辑器提供了所有的基本功能和一些让你自定义你的体验的令人兴奋的功能。
>
>
>
有了 [XEDIT](/article-12930-1.html)、jEdit、NEdit、[gedit](/article-12933-1.html)，最后还有 [medit](http://mooedit.sourceforge.net/)。
在我开始搜索我还没有尝试过的编辑器之前，我还没有听说过 medit，但我很高兴发现了它。如果你正在寻找经典的 gedit 体验（大约是 Gnome 2 上），那么 medit 可能无意间提供了一种出色且现代的近似体验。它也有许多额外的功能，比如可以使用 Python、Lua 或 C 语言编写插件，以及甚至可以将 shell 脚本集成到菜单系统。所有其他常用的功能也都在这里：标签式界面、一个即时的 shell、缩进管理、语法高亮等等。
### 安装 medit
你可以从 [mooedit.sourceforge.net](https://sourceforge.net/projects/mooedit/files/medit/) 下载 medit。它确认可以在 Linux 和 Windows 上工作。如果你使用的是 Linux，你也可以在你的仓库中找到它。在 Slackware 上，我从 [slackbuilds.org](https://slackbuilds.org/repository/14.2/development/medit) 安装了它。
### 使用 medit
medit 宣称自己是一个“为编程和围绕编程”打造的编辑器，事实上，它的诞生是作为一个名为 GAP（<ruby> <a href="https://www.gap-system.org/"> 群组、算法、编程 </a> <rt> Groups、Algorithms、Programming </rt></ruby>）的更大项目的一部分。它的大部分功能都是针对典型的开发者的期望而开发。例如，在 **Edit** 菜单中，有增加和减少缩进的选项，这对于任何试图以可视方式指示范围的程序员来说都是一个常见的任务（对于 Python 程序员来说也是一个明文要求），还有注释或取消注释文本块的选项。
有些功能对普通用户也很有用。medit 有一个易于使用的标签式界面（既在窗口顶部，也在侧面的弹出式列表中），一个用于快速浏览文件系统的侧面板，在文件中添加书签的功能等等。它还具有针对两种编程语言以及标记语言和 Markdown 的语法高亮显示功能，因此它是可以用于编辑代码和普通文本的编辑器。
### 颜色方案
当编辑没有语法关联的纯文本或像 Asciidoc 这样的格式时，medit 没有预设的高亮方案，编辑器会采用你的系统默认值。我使用的是深色主题，所以 medit 在深灰色背景上显示白色文本。
不过对于语法高亮，文本会根据每个单词在其结构化语言中扮演的角色而变成彩色。一开始，我对 medit 的一些选择有些沮丧，很多颜色在我的深色背景下太暗，无法辨认，而且我觉得所有重要的元素都不够显眼。如果你不喜欢 medit 选择的方案，这个问题的答案在 **Preferences** 中，你可以更改颜色主题。我把我的颜色改成了 Tango，它呈现出一个日光照射的颜色阵列，在我的深色编辑器背景下非常出色，甚至给在 medit 主题下保持白色的元素添加了颜色。
### 弹出式 Python 控制台
在 medit 窗口的底部，有一个弹出的终端，用于快速访问 shell。这是一个很好的功能，但坦率地说，在你体验过 Emacs 和 [Kate](https://opensource.com/article/20/12/kate-text-editor)之后，这感觉很普通。medit 让我惊讶的是它的弹出式 Python 控制台，它从 **Tools** 菜单中启动，并预先导入了 **moo** 和 **gtk** 模块。换句话说，当你启动 medit 的 Python shell 时，你可以查看 medit 构建自身部分的 Python 和 GTK 模块。这是一个很好的功能，也许会给你写插件的灵感（这个弹出终端的是一个用 Python 编写的插件，所以你也可以通过它的代码来了解一个插件是如何编写的）。
### 经典编辑
medit 是一款出色的基于 GTK 的编辑器，它具有所有重要的基本功能和一些诱人的额外功能，可以帮助你扩展应用并使其成为你自己的。因为它接受 C、Python、Lua 和 Bash，所以你可以将它用于这几种用途。如果你正在为你的写作寻找一个有用的编辑器，无论是代码还是 Markdown 或介于两者之间的东西，给 medit 一个机会。
---
via: <https://opensource.com/article/20/12/medit>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
如何在 Ubuntu/Debian Linux 上编写、编译和运行一个 C 程序 | Abhishek Prakash | https://itsfoss.com/run-c-program-linux/ | 你是如何在 Linux 上使用 C 编写你的程序的？它确实是非常简单的，由三个简单的步骤组成。 | /data/attachment/album/202012/21/185003c5upl6pibr5lllrl.png.thumb.jpg | /data/attachment/album/202012/21/185003c5upl6pibr5lllrl.png | true | false | true | lujun9972 | robsean | wxy | false | [
"编程"
] | 软件开发 | {
"viewnum": 14628,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 你是如何在 Linux 上使用 C 编写你的程序的？它确实是非常简单的，由三个简单的步骤组成。 | 2020-12-21T18:50:03 | 2020-12-21T18:50:03 | 12,939 | /article-12939-1.html | 
你是如何在 Linux 上使用 C 编写你的程序的？它确实是非常简单的，由三个简单的步骤组成。
**步骤 1**: 编写你的 C 程序，并使用一个 `.c` 的扩展名进行保存。例如，`my_program.c` 。
**步骤 2**: 在一个终端中使用 `gcc` 编译器来编译程序并生成目标文件，像这样：
```
gcc -o my_program my_program.c
```
**步骤 3**: 在 Linux 中，你可以以运行生成的对象文件的方式来运行你的 C 程序：
```
./my_program
```
这只是如何在 Linux 中编译和运行 C 程序的简要总结。假设你是 C 语言或 Linux 系统的新手，我将仔细演示这些步骤，以便你能在 Linux 环境中舒服地编写 C 程序。
事实上，我将讨论如何在 Linux 终端中以及在代码编辑器中运行 C 程序的两种方式。
### 方法 1: 在 Linux 终端中运行 C 程序
为了在 Linux 中运行一个 C 程序，你需要在你的系统上有一个 C 编译器。最流行的编译器是 `gcc`（<ruby> <a href="https://gcc.gnu.org/"> GNU 编译器套件 </a> <rt> GNU Compiler Collection </rt></ruby>）。
你可以使用你发行版的软件包管理器来安装 `gcc` 。在基于 Debian 和 Ubuntu 的 Linux 发行版中，使用 `apt` 命令：
```
sudo apt install gcc
```
切换到保存你的 C 程序的目录（或者提供路径），然后通过编译程序生成对象文件：
```
gcc -o my_program my_program.c
```
记住，提供输出对象文件（`-o my_program`）是可选的。如果你不提供，那么将自动生成一个名称为 `a.out` 的对象文件。但是这样并不好，因为编译每个 C 程序都会覆盖它，而且你也不知道这个 `a.out` 对象文件究竟属于哪个程序。
在你的对象文件生成后，运行它来运行 C 程序。它已经能够执行了。像这样简单地使用它：
```
./my_program
```
接下来，如果你的程序是正确的，它将显示出你所期望的输出。正如你所看到的，这和 [在 Linux 中运行 C++ 程序](https://itsfoss.com/c-plus-plus-ubuntu/) 没什么不同。
*每更改一次你的程序，你都必须先重新编译它，然后再次运行生成的对象文件来运行这个新的 C 程序。*
### 方法 2: 如何在 Linux 中使用一个诸如 VSCode 之类的代码编辑器来运行 C 程序
并不是每一个人都能适应命令行和终端，我完全理解这一点。
你可以使用一个诸如 Eclipse 或 Code Blocks 之类的真正的 C/C++ IDE ，但是它们是很重量级的程序，通常更适合于大型的项目。
我建议使用一个开源的代码编辑器，像 VSCode 或 Atom 。它们基本上是文本编辑器，但是你可以通过安装附加组件来直接在图形化的代码编辑器中编译和运行程序。
在这个示例中，我使用 [VSCode](https://code.visualstudio.com) 编辑器。它是一个来自微软的 [非常流行的开源的代码编辑器](https://itsfoss.com/best-modern-open-source-code-editors-for-linux/) 。
首先，在 Ubuntu 的 [软件中心中安装 VSCode](https://itsfoss.com/install-visual-studio-code-ubuntu/) 。对于其它发行版来说，请检查你的 Linux 发行版的软件包管理器或软件中心。你可以参看它的官方网站来查看更多的信息。
启动 VSCode ，打开或创建一个工程，在这里创建你的 C 程序。我使用一个简单的 Hello World 程序作为示例。
你必须确保你已经在你的 Linux 系统上安装了 `gcc` 编译器。
```
sudo apt install gcc
```
接下来你要做的事是使用一个允许你运行 C 代码的扩展。微软可能会提示你安装它的 C/C++ 程序扩展，但它的设置很复杂，因此我不推荐。
相反，我建议你使用 Code Runner 扩展。它是一个简单直接的扩展，你可以在不使用额外配置的情况下轻松地运行 C 和 C++ 代码。
转到扩展标签页，在其中搜索和安装 “Code Runner” 。
重新启动 VSCode 。现在，你能够使用下面方法中的其中一个来运行 C 代码：
* 使用快捷键 `Ctrl+Alt+N` 。
* 按下 `F1` ，接下来选择或输入 “Run Code” 。
* 在文本编辑器中右键单击，从上下文菜单中单击 “Run code” 。
当你运行这个 C 程序时，它将会被自动编译和运行。你可以在编辑器底部打开的终端中看到输出。还有比这更好的事情吗？
你更喜欢哪一种方法？
在 Linux 命令行中运行一些 C 程序是没有问题的，但是使用一个代码编辑器会更容易一些，而且会节省时间。你不觉得吗？
你可以自己决定想使用哪一种方法。
---
via: <https://itsfoss.com/run-c-program-linux/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[robsean](https://github.com/robsean) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
2020 年微服务现状 | Isabella Ferreira, Mark Shan | https://www.linux.com/news/the-state-of-the-art-of-microservices-in-2020/ | 本文将帮助你了解什么是微服务，以及目前的公司如何使用它的。 | /data/attachment/album/202012/22/122634t2hwh2hh12bvrbsd.jpg.thumb.jpg | /data/attachment/album/202012/22/122634t2hwh2hh12bvrbsd.jpg | true | false | true | lujun9972 | zxp93 | wxy | false | [
"微服务"
] | 观点 | {
"viewnum": 10894,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "1.119.144.186",
"message": "好东西，最近正在研究微服务呢",
"username": "robin [Chrome 86.0|Windows 10]",
"date": "2020-12-31T17:11:32"
}
] | [] | 本文将帮助你了解什么是微服务，以及目前的公司如何使用它的。 | 2020-12-22T12:30:39 | 2020-12-22T12:30:39 | 12,941 | /article-12941-1.html | 
>
> “微服务架构风格是一种将 **单个应用程序** 开发为一套 **小型服务** 的方法，每个服务都在 **自己的进程中运行，并使用轻量级的通信机制（通常是 HTTP 类型的 API）进行通信**。这些服务是围绕 **业务能力** 构建的，并且可以通过 **全自动化的部署机制** 进行 **独立部署**。目前对这些服务几乎没有集中的管理，这些服务可以用 **不同的编程语言** 编写，也能使用 **不同的数据存储技术**。”
>
>
> —— James Lewis 和 Martin Fowler (2014) <sup class="footnote-ref"> <a href="#fn1" id="fnref1"> [1] </a></sup>
>
>
>
### 介绍
预计在 2020 年，全球云端的微服务市场将以 22.5% 的速度增长，其中美国市场预计将保持 27.4% 的增长率<sup class="footnote-ref"> <a href="#fn2" id="fnref2"> [2] </a></sup>。目前的趋势是，开发人员将从本地托管的应用程序转移到云端。这将有助于企业最大限度地减少停机时间、优化资源并降低基础设施成本。同时专家们还预测，到了 2022 年，90% 的应用程序将会使用微服务架构进行开发<sup class="footnote-ref"> <a href="#fn2" id="fnref2:1"> [2:1] </a></sup>。本文将帮助你了解什么是微服务，以及目前的公司如何使用它的。
### 什么是微服务？
微服务已经在全球范围内被广泛使用。但是，微服务到底是什么？微服务是一种基于许多小型、互联服务的体系结构模式。它们基于 **单一责任原则**。根据 Robert C. Martin 的说法，“将因相同原因而变化的事物聚集起来，将因不同原因而变化的事物分离开来”。<sup class="footnote-ref"> <a href="#fn3" id="fnref3"> [3] </a></sup>微服务架构也被扩展到了 **松耦合服务** 中，可以 **独立地开发、部署和维护**<sup class="footnote-ref"> <a href="#fn3" id="fnref3:1"> [3:1] </a></sup>。
### 远离单体架构
微服务通常和传统的单体软件架构做对比。在单体架构中，软件是被设计为自足的，也就是说，这个程序中的各个组件都是互相连通和互相依赖的，而不是松散耦合的。在一个紧耦合的架构中（<ruby> 单体 <rt> monolithic </rt></ruby>），每个组件和它相关联的组件必须按照指定的顺序组合起来，才能被执行或编译<sup class="footnote-ref"> <a href="#fn4" id="fnref4"> [4] </a></sup>。当其中有一个组件需要更新时，整个应用都要被重写。
而这个现象在使用微服务架构的应用中就不会出现。因为每一个模块都是独立的，每个模块都可以更新修改而不影响程序的其他部分。因此，降低了对更改一个组件会对其他组件造成影响的风险。
如果公司的架构很难升级，或者维护过于复杂和昂贵，那么他们可能会遇到麻烦，不能扩展单体架构的应用<sup class="footnote-ref"> <a href="#fn5" id="fnref5"> [5] </a></sup>。把一个复杂的任务分解成小组件，彼此独立工作，就是解决这个问题的方法。
*单一体系架构 vs. 微服务架构 （图片来自 <sup class="footnote-ref"> <a href="#fn6" id="fnref6"> [6] </a></sup>）*
### 开发者如何构建属于自己的微服务
微服务以提高*可扩展性*和*性能*而闻名。然而，这些是世界各地的开发者开发属于他们自己的微服务的主要原因吗？《微服务 2020 研究现状》<sup class="footnote-ref"> <a href="#fn7" id="fnref7"> [7] </a></sup>披露了全球开发者如何构建他们的微服务，以及他们对微服务的看法。这份报告是在来自欧洲、北美、中南美洲、中东、东南亚、澳大利亚和新西兰的 660 名微服务专家的帮助下完成的。下表列出了微服务成熟度相关问题的平均评分<sup class="footnote-ref"> <a href="#fn7" id="fnref7:1"> [7:1] </a></sup>：
| **分类** | **平均得分（满分为5分）** |
| --- | --- |
| 创建新项目 | 3.8 |
| 维护与调试 | 3.4 |
| 工作效率 | 3.9 |
| 解决可扩展性问题 | 4.3 |
| 解决性能问题 | 3.9 |
| 团队合作 | 3.9 |
从上表可知，大部分专家都对使用微服务来解决可扩展性问题感到满意。与之相反的是，维护与调试对他们来说似乎是一个挑战。
从他们所使用的架构技术来说，大部分专家使用 Javascript/Typescript （大约 ⅔ 的微服务是使用这些语言构建的），其次使用的是 Java。
尽管有很多部署微服务的选择，但大多数专家使用 AWS（49%），其次是他们自己的服务器。另外，有 62% 的人更喜欢用 AWS Lambda 作为无服务器解决方案。
这些人所使用的大多数微服务都使用 HTTP 进行通信，其次是 events 和 gRPC。此外，大多数专家将 RabbitMQ 用于消息代理，其次是 Kafka 和 Redis。
而且，大多数人使用微服务持续集成（CI）。在报告中，87% 的受访者使用诸如 GitLab CI、Jenkins 或 GitHub Actions 等 CI 解决方案。
在 86% 的受访者中，最受欢迎的调试解决方案是日志，其中 27% 的受访者**只**使用日志。
最后，大多数人认为微服务架构将成为更复杂的系统或后端开发的标准。
### 微服务的成功案例
许多公司已经从单体架构转向微服务架构。
#### 亚马逊
在 2001 年，开发延迟、编码挑战和服务相互依赖性使得<ruby> 亚马逊 <rt> Amazon </rt></ruby>无法满足其不断增长的用户群的可扩展性需求。由于需要从头开始重构他们的单体架构，亚马逊将其单体架构应用程序拆分为小型的、独立的、针对服务的应用程序<sup class="footnote-ref"> <a href="#fn6" id="fnref6:1"> [6:1] </a></sup><sup class="footnote-ref"> <a href="#fn8" id="fnref8"> [8] </a></sup>。
2001 年，在微服务这个词开始流行之前的几年，亚马逊决定改用微服务。这一变化使得亚马逊开发了好几种支持微服务架构的解决方案，比如亚马逊 AWS。随着对微服务的快速增长和适应，亚马逊成为全球市值最高的公司，截至 2020 年 7 月 1 日，亚马逊市值为 1.433 万亿美元<sup class="footnote-ref"> <a href="#fn9" id="fnref9"> [9] </a></sup>。
#### 奈飞
<ruby> 奈飞 <rt> Netflix </rt></ruby>于 2007 年开始提供电影流媒体服务，到了 2008 年，它也面临着规模扩张的挑战。期间，他们经历了一次严重的数据库损坏，在三天之内，他们不能将 DVD 发送给他们的会员<sup class="footnote-ref"> <a href="#fn10" id="fnref10"> [10] </a></sup>。这一事故使他们意识到需要将单点故障（如关系数据库）转向云中更可伸缩和更可靠的分布式系统。于是 2009 年，奈飞开始将其单体架构的应用重构为微服务。他们首先将其非面向客户的电影编码平台迁移到云端作为独立的微服务运行<sup class="footnote-ref"> <a href="#fn11" id="fnref11"> [11] </a></sup>。在改用微服务之后，使奈飞能够解决扩展性挑战和服务中断的问题。并且它还允许他们按照每个流数据而不是数据中心的成本来降低成本<sup class="footnote-ref"> <a href="#fn10" id="fnref10:1"> [10:1] </a></sup>。今天，奈飞每天向 190 个国家的 1.39 亿订户发送约 2.5 亿小时的内容<sup class="footnote-ref"> <a href="#fn11" id="fnref11:1"> [11:1] </a></sup>。
#### Uber
在推出 Uber 服务之后，他们在开发和发布新功能、修复 bug，以及迅速整合新的变化方面遇到了困难。因此，他们决定改用微服务，并将应用程序结构拆分为基于云的微服务。换句话说，Uber 为每个功能创建了一个微服务，比如乘客管理和出行管理。转向微服务给 Uber 带来了很多好处，比如对每项服务的所有权都有一个清晰的概念。这提高了服务访问的速度和质量，通过允许团队只关注他们需要扩展的服务，在更新虚拟服务的同时而不中断其他服务，实现了更可靠的容错，从而促进了快速扩展<sup class="footnote-ref"> <a href="#fn11" id="fnref11:2"> [11:2] </a></sup>。
### 这就是可扩展性！
关于如何提供可伸缩性的一个很好的例子是看看中国。中国人口众多，必须通过创造和试验新的解决方案来适应规模化的新挑战。统计数据显示，中国目前为大约 9 亿互联网用户提供服务<sup class="footnote-ref"> <a href="#fn12" id="fnref12"> [12] </a></sup>。2019 年“双十一”期间（相当于国外的黑色星期五），阿里巴巴旗下各购物平台的交易峰值为每秒 544000 笔交易。阿里云处理的数据总量约为 970 PB<sup class="footnote-ref"> <a href="#fn13" id="fnref13"> [13] </a></sup>。那么，这些数量的用户在技术上意味着什么呢？
为了解决可伸缩性问题，许多技术应运而生。例如，[Tars](https://tarscloud.org/foundation/index) 由腾讯于 2008 年创建，[2018 年贡献给 Linux 基金会](https://www.linuxfoundation.org/press-release/2018/06/tars-and-tseer-form-open-source-project-communities-under-the-linux-foundation-to-expand-adoption-and-pace-of-development/)。它也在被大规模使用，并在 10 年内得到了很大的提升<sup class="footnote-ref"> <a href="#fn14" id="fnref14"> [14] </a></sup>。TARS 是开源的，许多组织都在大力贡献和扩展框架的特性和价值<sup class="footnote-ref"> <a href="#fn14" id="fnref14:1"> [14:1] </a></sup>。TARS 支持多种编程语言，包括 C++、Golang、java、node.js、PHP 和 Python；它可以快速构建系统并自动生成代码，使开发人员能够专注于业务逻辑，从而有效地提高操作效率。TARS 已广泛应用于腾讯的 QQ、微信社交网络、金融服务、边缘计算、汽车、视频、网络游戏、地图、应用市场、安全等诸多核心业务。[在 2020 三月，TARS 项目转变为 TARS 基金会](https://www.linuxfoundation.org/blog/2020/03/the-tars-foundation-the-formation-of-a-microservices-ecosystem/)，这是一个开源微服务基金会，在建立开放式微服务平台的社区方面中，致力于提升社区贡献和成员的快速增长<sup class="footnote-ref"> <a href="#fn14" id="fnref14:2"> [14:2] </a></sup>。
**一定要看看 Linux 基金会新的免费培训课程**：《[用 TARS 构建微服务平台](https://www.edx.org/course/building-microservice-platforms-with-tars)》
*关于作者：*
*Isabella Ferreira 是 Linux 基金会旗下的开源微服务基金会 TARS 基金会的布道师*
*Mark Shan（单致豪）是腾讯开源联盟的主席，也是 TARS 基金会的董事会主席。*
>
> 本篇 Linux 基金会白金赞助商内容由腾讯贡献。
>
>
>
---
1. <https://martinfowler.com/articles/microservices.html#footnote-etymology> [↩︎](#fnref1)
2. <https://www.charterglobal.com/five-microservices-trends-in-2020/> [↩︎](#fnref2) [↩︎](#fnref2:1)
3. <https://medium.com/hashmapinc/the-what-why-and-how-of-a-microservices-architecture-4179579423a9> [↩︎](#fnref3) [↩︎](#fnref3:1)
4. <https://whatis.techtarget.com/definition/monolithic-architecture> [↩︎](#fnref4)
5. <https://www.leanix.net/en/blog/a-brief-history-of-microservices> [↩︎](#fnref5)
6. <https://www.plutora.com/blog/understanding-microservices> [↩︎](#fnref6) [↩︎](#fnref6:1)
7. <https://tsh.io/state-of-microservices/#ebook> [↩︎](#fnref7) [↩︎](#fnref7:1)
8. <https://thenewstack.io/led-amazon-microservices-architecture/> [↩︎](#fnref8)
9. <https://ycharts.com/companies/AMZN/market_cap> [↩︎](#fnref9)
10. <https://media.netflix.com/en/company-blog/completing-the-netflix-cloud-migration> [↩︎](#fnref10) [↩︎](#fnref10:1)
11. <https://blog.dreamfactory.com/microservices-examples/> [↩︎](#fnref11) [↩︎](#fnref11:1) [↩︎](#fnref11:2)
12. <https://www.statista.com/statistics/265140/number-of-internet-users-in-china/> [↩︎](#fnref12)
13. <https://interconnected.blog/china-scale-technology-sandbox/> [↩︎](#fnref13)
14. <https://www.linuxfoundation.org/blog/2020/03/the-tars-foundation-the-formation-of-a-microservices-ecosystem/> [↩︎](#fnref14) [↩︎](#fnref14:1) [↩︎](#fnref14:2)
---
via: <https://www.linux.com/news/the-state-of-the-art-of-microservices-in-2020/>
作者：[Linux.com](https://www.linux.com/author/linuxdotcom/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[zhangxiangping](https://github.com/zxp93) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
为什么 Java 开发者喜欢 jEdit 文本编辑器 | Seth Kenlon | https://opensource.com/article/20/12/jedit | 这款编辑器打包了 Java 的功能，并提供了大量的插件来简化你的工作流程。 | /data/attachment/album/202012/22/133305j08dxrqx2fmp6s12.jpg.thumb.jpg | /data/attachment/album/202012/22/133305j08dxrqx2fmp6s12.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Java",
"jEdit"
] | 分享 | {
"viewnum": 3247,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12938,
"displayorder": 0
},
{
"raid": 12947,
"displayorder": 0
}
] | 这款编辑器打包了 Java 的功能，并提供了大量的插件来简化你的工作流程。 | 2020-12-22T13:33:27 | 2020-12-22T13:33:27 | 12,942 | /article-12942-1.html |
>
> 这款编辑器打包了 Java 的功能，并提供了大量的插件来简化你的工作流程。
>
>
>
Java 是一门强大的语言。也许因为它经常被看作是一种“工业级”的工具，你可能不会想到它会成为文本编辑器的基础。毕竟，对于如此能力，文本编辑几乎是太容易了。事实上，在大多数现代编程工具包中，接受文本输入的组件是一个预编程的小部件。使用 Java 工具箱，一个简单的文本编辑器可以用 100 行左右的代码编写出来。那么 [jEdit](http://jedit.org) 能提供什么来证明它的存在价值呢？
嗯，实际上，它有很多功能！jEdit 应用是一个令人耳目一新的提醒，提醒人们 Java 对于日常桌面应用是多么的实用和有用。它巧妙地展示了它的基础技术的活力，并且永远忠于 Java 的永恒承诺，在*所有*的平台上都能运作。
### 安装 jEdit
jEdit 是用 Java 编写的，所以它适用于任何平台。[下载](http://www.jedit.org/index.php?page=download)通用安装程序或为所选的操作系统下载自定义安装程序。下载完成后（它很小，因此不会花费很长时间），请运行安装程序。
如果你没有安装 Java，请学习如何在 [Linux](/article-11614-1.html)、[Mac 或 Windows](http://adoptopenjdk.org) 上安装 Java。
### 使用 jEdit
在 jEdit 中编辑文本的方式和在任何桌面文本编辑器中编辑文本的方式是一样的。如果你使用过编辑器，那么你基本上已经会使用 jEdit 了。所有常用的键盘快捷键和惯例都适用。也有一些通常针对开发者的功能，如行号、折叠（该部分文本被隐藏，这样你就可以把注意力放在其他部分）和语法高亮。
但是，想象一下，从 [简单的 Vim](https://opensource.com/article/20/12/vi-text-editor) 到 [复杂的 Emacs](/article-12923-1.html)的各种文本编辑器中，你会发现 jEdit 与 Emacs 类似。虽然编辑组件和任何典型桌面编辑应用一样，但 jEdit 的附加功能包括插件、可以在编辑会话中实时录制的宏、特定于某些编辑模式的功能、缓冲区选项等。这是一个积极鼓励你把它变成你自己的编辑器。
你可以在三个地方对 jEdit 进行自定义：缓冲区选项、全局选项和插件管理器。
缓冲区选项（在 “Utilities” 菜单中）使你可以调整与当前文档关联的设置。通常，jEdit 会自动检测用于你正在执行的操作的适当模式。例如，编写 XML 会触发 jEdit 的 XML 高亮显示。但是，有时你想覆盖 jEdit 已检测到或未能检测到的内容。你还可以打开“显式折叠”模式，该模式允许你手动定义希望 jEdit 视为可折叠部分的文本。
全局选项（在 “Utilities” 菜单中）提供了数十种首选项，这些首选项被视为 jEdit 的默认值。这包括从外观到自定义快捷方式的所有内容。
插件可以扩展出来 jEdit 的开发者从未想过的功能。插件提供的工作方式对 jEdit 而言并非“常规”，但可能会将繁琐的任务转变为简单甚至有趣的事情。它以其出色的 XML 解析、可停靠的 Sidekick 面板中的 Outline 插件和 XSLT 集成，实际上改变了 XML 工作流程。如果我不是已经使用了 Netbeans 来编写 Java 代码，我想我可以使用 jEdit 来代替。
### 面向程序员的 jEdit
选择哪种文本编辑器取决于你打算在编辑器中做的事。它称自己为“程序员的文本编辑器”，并且我认为它是严肃的 Java 和 XML 开发的有力竞争者。但是，在编辑 Lua 代码和 Bash 脚本时，它的功能不就没有这么强了。例如，与 Emacs 之类相比，jEdit 的代码折叠不那么灵活（我无法在没有附加标记的情况下折叠 Lua 函数）。尽管确实有丰富的插件选择，但我找不到用于 AsciiDoc 和其他非代码格式工作的特别有说服力的东西。
对我来说，jEdit 最吸引人的特点是它是以 Java 为基础。因为它在 JVM 中运行，所以你可以确信能够使用它，而无论你使用的平台是什么，也可以不管你是否有权限在自己的主目录之外安装应用。Java 是一种流行且活跃的语言，因此 jEdit 的功能和插件维护得很好。
如果你是一致性的忠实拥护者、Java 开发人员，或者只是 XML 极客而拼命试图摆脱 oXygen，那么你应该试试 jEdit。它很容易上手，并且探索起来很有趣。
---
via: <https://opensource.com/article/20/12/jedit>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
关于华为的新发行版 OpenEuler，你有什么想知道的 | 小白 | 如果你对于 openEuler 有什么问题，欢迎你在下方留言，我们将选出其中的好问题，带到现场，和胡欣蔚一起聊一聊。 | /data/attachment/album/202012/22/223135fkh4v4d1sz9g98hj.jpg.thumb.jpg | /data/attachment/album/202012/22/223135fkh4v4d1sz9g98hj.jpg | true | false | false | false | [
"openEuler"
] | 新闻 | {
"viewnum": 4910,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "58.62.191.240",
"message": "他是基于centos?为什么安装过程那么像",
"username": "来自广东广州的 Chrome Mobile 78.0|Android 10 用户",
"date": "2020-12-24T03:45:20"
},
{
"postip": "223.104.246.107",
"message": "只是采用了和centos一样的安装系统软件。",
"username": "来自223.104.246.107的 Chrome Mobile 76.0|Android 用户",
"date": "2020-12-24T07:43:01"
}
] | [
{
"raid": 13282,
"displayorder": 0
}
] | 如果你对于 openEuler 有什么问题，欢迎你在下方留言，我们将选出其中的好问题，带到现场，和胡欣蔚一起聊一聊。 | 2020-12-22T22:32:06 | 2020-12-22T22:32:06 | 12,944 | /article-12944-1.html | 
华为去年发布的新的 Linux 发行版 [openEuler](https://openeuler.org/zh/) 在过去的一年里发生了巨大的变化，而明天，openEuler 的年度社区盛会 —— [openEuler Summit](https://openeuler.org/zh/interaction/summit-list/) 将会盛大召开。
作为**国内著名开源社区、Linux 爱好者聚集地**，[Linux 中国](https://linux.cn/)也受邀前往参与本次的 openEuler 大会。不仅如此，我们特别向大会组委会申请，希望可以采访到 openEuler 团队的开发者，和 openEuler 的开发者们一起聊聊开源，讨论讨论 Linux 发行版。
经过组委会协调，我们将会和 **openEuler 的技术委员会主席，来自华为中央软件院的胡欣蔚**一起坐下来，畅聊**开源、Linux 和 OpenEuler**。
如果你对于 openEuler 有什么问题，欢迎你在下方留言，我们将选出其中的好问题，带到现场，和胡欣蔚一起聊一聊。
如果你希望来到现场，参与到 openEuler 大会，体验 openEuler 的新奇特性，可以长按识别下方二维码，报名参加本次活动！
|
||||
真相：为什么红帽为了 CentOS Stream 而抛弃 CentOS？ | Steven J. Vaughan-nichols | https://www.zdnet.com/article/why-red-hat-dumped-centos-for-centos-stream/ | 不，这不是 IBM 在发号施令。这个决定是红帽内部出于商业上的原因做出的，而且这个决定由来已久。 | /data/attachment/album/202012/23/001915taaox1ghpxhyyzy9.jpg.thumb.jpg | /data/attachment/album/202012/23/001915taaox1ghpxhyyzy9.jpg | true | false | true | wxy | wxy | true | [
"CentOS"
] | 观点 | {
"viewnum": 33105,
"commentnum": 15,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "123.139.156.190",
"message": "我觉得红帽说的对，！！！“CentOS 的“客户”为 CentOS 贡献了多少？我说的不是钱。我说的是代码、文档和支持。所有这些开源社区应该回馈的东西。”把人家红帽当了傻逼了吧",
"username": "来自陕西西安的 Chrome 83.0|GNU/Linux 用户",
"date": "2020-12-23T09:04:47"
},
{
"postip": "122.226.157.170",
"message": "此处省略一万字。。。",
"username": "来自浙江台州的 Firefox 84.0|Windows 10 用户",
"date": "2020-12-23T09:13:23"
},
{
"postip": "61.153.170.162",
"message": "还好早就从rpm系转到deb系",
"username": "来自浙江台州的 Firefox 78.0|GNU/Linux 用户",
"date": "2020-12-23T17:53:00"
},
{
"postip": "112.229.11.36",
"message": "确实如此，大部分的使用者只是使用，几乎没有多少人为它添砖加瓦",
"username": "来自山东济南的 Chrome 88.0|Windows 10 用户",
"date": "2021-01-28T09:19:21"
},
{
"postip": "114.255.249.129",
"message": "扌喿！！！ 完蛋了。",
"username": "来自北京的 Chrome 88.0|Mac 10.14 用户",
"date": "2021-01-31T00:02:21"
},
{
"postip": "106.121.134.124",
"message": "......",
"username": "来自北京的 QQ Browser 10.7|Windows 10 用户",
"date": "2021-02-02T10:09:42"
},
{
"postip": "222.215.68.135",
"message": "哈哈哈哈 贡献了一下宣传",
"username": "来自四川自贡的 Chrome 89.0|Windows 10 用户",
"date": "2021-03-17T17:55:04"
},
{
"postip": "111.199.184.127",
"message": "红帽有为gnu linux贡献了多少了",
"username": "来自北京的 Chrome 78.0|Windows 10 用户",
"date": "2021-03-22T22:09:02"
},
{
"postip": "111.199.184.127",
"message": "不是红帽想开源，是它是在自由软件上构建的。它必须支持开源协议",
"username": "来自北京的 Chrome 78.0|Windows 10 用户",
"date": "2021-03-22T22:11:32"
},
{
"postip": "114.225.28.150",
"message": "6666",
"username": "来自江苏无锡的 Sogou Explorer 2|Windows 10 用户",
"date": "2021-03-26T13:53:13"
},
{
"postip": "125.120.226.127",
"message": "要多少有多少。",
"username": "来自浙江杭州的 Chrome 90.0|Fedora 用户",
"date": "2021-05-23T17:28:36"
},
{
"postip": "120.231.180.40",
"message": "wu li bo qi zhao",
"username": "来自120.231.180.40的 Firefox 45.0|GNU/Linux 用户",
"date": "2021-07-04T12:50:51"
},
{
"postip": "112.64.138.18",
"message": "centos是一个产品, 而我们是用户, 我们很多公司愿意使用这个产品, 就是对它最大的支持. 这种道理都不懂吗?",
"username": "来自上海的 Firefox 95.0|Windows 10 用户",
"date": "2021-12-28T09:25:22"
},
{
"postip": "124.205.41.226",
"message": "资本无情，把开源就当成了白嫖。我TM玩盗版游戏，当我真心喜欢这个游戏也会去补票。而资本就只会吸血。",
"username": "来自北京的 Chrome 99.0|Windows 10 用户",
"date": "2022-03-22T10:10:26"
},
{
"postip": "218.89.222.166",
"message": "红帽没错，开源不等于白嫖",
"username": "来自四川成都的 Firefox 113.0|Ubuntu 用户",
"date": "2023-05-30T11:03:03"
}
] | [
{
"raid": 12902,
"displayorder": 0
},
{
"raid": 12908,
"displayorder": 1
},
{
"raid": 12910,
"displayorder": 2
}
] | 不，这不是 IBM 在发号施令。这个决定是红帽内部出于商业上的原因做出的，而且这个决定由来已久。 | 2020-12-23T00:19:32 | 2020-12-23T00:19:32 | 12,945 | /article-12945-1.html |
>
> 不，这不是 IBM 在发号施令。这个决定是红帽内部出于商业上的原因做出的，而且这个决定由来已久。
>
>
>
当 CentOS 的 Linux 母公司红帽宣布将重点从 <ruby> <a href="https://www.redhat.com/en/technologies/linux-platforms/enterprise-linux"> 红帽企业 Linux </a> <rp> （ </rp> <rt> Red Hat Enterprise Linux </rt> <rp> ） </rp></ruby>（RHEL）的重建版 CentOS Linux [转移](/article-12902-1.html)到 [CentOS Stream](https://www.centos.org/centos-stream/)上，而 CentOS Stream 的跟踪时间刚好在当前 RHEL 版本之前时，很多 CentOS 用户简直要昏倒了。
在 [Hacker News](https://news.ycombinator.com/) 上，最主要的评论是，“想象一下，如果你正在经营一家企业，并[基于 10 年寿命的承诺部署了 CentOS 8](https://news.ycombinator.com/item?id=25347904) 。现在你全完蛋了，而红帽知道这一切。他们究竟为什么不从 CentOS 9 开始做这个转换？？！让我们不要粉饰这个问题。他们背叛了我们。”
在 [Reddit/Linux](https://www.reddit.com/r/linux/) 上，另一个人咆哮道：“从 CentOS 4 以来，我们的开源项目都是基于最新的 CentOS 版本的，[我们的旗舰产品运行在 CentOS 8 上，我们**已然**把一切都押注在了他们承诺的 2029 年 5 月 31 日生命周期上](https://www.reddit.com/r/linux/comments/k95dt7/centos_project_shifts_focus_to_centos_stream/gf33s2z/?utm_source=reddit&utm_medium=web2x&context=3)。”
[自称 “Unix 宇宙中最好的 Linux 博客”，nixcraft](https://twitter.com/nixcraft?lang=en)，一个拥有超过 20 万订阅者的账号发布的热门推特说：Oracle 收购了 Sun 公司， Solaris Unix、Sun 服务器/工作站和 MySQL 被转到了 /dev/null。[IBM 买下红帽：CentOS 去了 >/dev/null](https://twitter.com/nixcraft/status/1336348208184741888)。请注意。如果有一天 Oracle、IBM、MS 等大厂商购买了你喜欢的软件，请尽快启动迁移。”
其他许多人也加入了这个令人恼火的 CentOS 用户吐槽团，认为他们最喜欢的 Linux 被夺走是 IBM 的错。还有一些人则尖声叫骂红帽在背叛开源本身。
红帽为什么要这么做？红帽的首席技术官 Chris Wright 在推出 CentOS Stream 时说：“[开发者......需要更早地[在 2019 年 9 月]访问代码](https://www.zdnet.com/article/red-hat-introduces-rolling-release-centos-stream/)，与更广泛的合作伙伴社区进行改进和更透明的合作，并能够影响新的 RHEL 版本的方向。CentOS Stream 正是为了解决这些需要而出现。”
简而言之，一个原因是开放红帽企业 Linux（RHEL）的代码。原 CentOS 董事会成员、长期的 [Fedora Linux](https://getfedora.org/) 贡献者、红帽高级社区架构师 Karsten Wade 在一篇博客文章中进行了更进一步的解释：
>
> RHEL 本身的开发仍然封闭在红帽的防火墙之后。 这种情况已经持续了近二十年。对于开源开发生态系统来说，这一直是一个重要的，而且经常是痛苦的缺口 —— 这仍然是和 2003 年一样的开放性缺口。
>
>
> 这就是我们今天所处的境地。将项目的重点转移到 CentOS Stream 上的举动，就是为了在一些关键的方面填补这个开放性缺口。本质上，红帽是通过将 CentOS 的位置从 RHEL 的下游转移到 RHEL 的上游，来填补 Fedora 和 RHEL 之间存在的开发和贡献缺口。
>
>
>
是的，这是真的。部分原因是红帽在 Fedora 和 RHEL 开放之间做最后的、重要的步骤。另一个部分的官方原因是，正如 Wright 所说，CentOS Stream 作为 RHEL 下一步的“滚动预览”，无论是在内核还是功能上都可以用于当今容器化、云原生的 IT 世界。毕竟，Facebook 已经在 CentOS Stream 衍生的 Linux 操作系统上运行了其数百万台服务器。
因此，Wright 继续说道，虽然“CentOS Stream 并不是 CentOS Linux 的替代品，相反，它是一个自然的、不可避免的下一步发展，旨在实现该项目进一步推动企业 Linux 创新的目标。”是的，CentOS Stream 不是一个你可以运行多年、稳定版本的 Linux 服务器发行版，但它是以云为中心的公司所需要的，以部署“容器化应用和云原生服务，以快速的硬件创新和生态系统转向软件即服务（SaaS）。......这就是我们认为的 CentOS Stream 优势所在。它为社区层面的快速创新提供了一个平台，但又有足够稳定的基础来了解生产动态。”
是的，这也是事实。但是，它们不是故事的全部。以下是红帽将老式的定期发布的 CentOS 放任自流的真正原因。
红帽公司根本没有怎么谈论这方面的问题，但是红帽公司 Linux 工程副总裁 Mike McGrath 在 [ITPro Today](https://www.itprotoday.com/) 上接受 Christine Hall 的采访时，却把秘密泄露了出来。“我想说的是，对我们来说，最大的问题是 [CentOS 本身其实并没有给红帽提供那么大的用处](https://www.itprotoday.com/linux/community-concerns-prompt-red-hat-drop-centos-centos-stream)。我们建立的大多数社区，比如 Fedora，确实有很多双向的社区参与。不幸的是，CentOS 从来就不是这样的。它一直是一个用户社区，所以那种贡献模式大多是单向的。”
让我再重复一遍，“**CentOS 本身其实并没有给红帽提供那么大的用处。**” 它从来没有。而且，有很多红帽的资深人士从第一天开始就知道这一点，他们一点也不喜欢它。
你知道谁在使用 CentOS 吗？一份简短的名单包括迪士尼、GoDaddy、Rackspace、丰田和 Verizon。此外，还有几十家公司围绕 CentOS 打造产品。这些公司包括 GE、Riverbed、F5、Juniper 和 Fortinet。红帽从这些 CentOS 的“客户”身上赚了多少钱？零！
在 CentOS 博客上，一位不满的用户说：“整个前提，也是[唯一有人使用 CentOS 的原因，就是因为它重构了 RHEL](https://blog.centos.org/2020/12/future-is-centos-stream/#comment-183627)。恭喜你破坏了这一点，笨蛋。”
没错，这也是 CentOS 要为 CentOS Stream 让位的最大原因。
红帽公司没有人愿意公开说这句话，但众多红帽公司的高管告诉我，情况就是这样。
有一位说：“这与 IBM 几乎无关。在 2018 年秋季收购的消息还没有传来之前，我们就在详细地讨论这个问题。有两个内部原因。首先，工程和销售部门无论如何也想不出如何在各自的产品组合中定位 CentOS。而且，把 CentOS 变成上游的想法始于 2014 年，当时 Jim Perrin [前红帽开发人员和 CentOS 董事会成员，现为微软首席项目经理]在 2014 年巴西的 [Fórum Internacional de Software Livre（FISL）](http://fisl.softwarelivre.org/)演讲中谈到了这种可能性。结果就出现了 CentOS 特别兴趣小组（SIG），这是 CentOS Stream 之路的开始。”
一位前红帽高管坦言：“CentOS 在挖销售的墙角。客户的看法是‘它来自红帽，是 RHEL 的克隆，所以它很好用！ ’其实不然。它是一个二流的拷贝。”以他的立场看，“这 100% 是防守，以避免 CentOS 造成更多损失。”
还有一位前红帽官员说。如果不是因为 CentOS，在红帽成为十亿美元的企业之前，红帽就已经是一家百亿美元的公司了。
而另一位红帽员工指出：“看看 [CentOS 的 FAQ](https://wiki.centos.org/FAQ/General)，它就在那里写着 ——
>
> [CentOS Linux **不受** Red Hat 公司的任何支持](https://wiki.centos.org/FAQ/General#What_is_CentOS.27s_relationship_with_Red_Hat.2BAK4.2C_Inc._or_RHEL.3F)。
> CentOS Linux **不是** Red Hat Linux，**不是** Fedora Linux，也**不是** Red Hat Enterprise Linux，它**不是** RHEL。CentOS Linux **不**包含 Red Hat® Linux、Fedora 或 Red Hat® Enterprise Linux。
> CentOS Linux **不是** Red Hat® Enterprise Linux 的克隆。
> CentOS Linux 是由 Red Hat, Inc 为 Red Hat Enterprise Linux 提供的公开源代码，在一个完全不同的（CentOS 项目维护的）构建系统中构建的。
>
>
>
我们不欠你什么。”
这可能会让你们中的一些人对红帽非常生气。不过，在你们发火之前，让我先问你们一些问题。CentOS 的“客户”为 CentOS 贡献了多少？我说的不是钱。我说的是代码、文档和支持。所有这些开源社区应该回馈的东西。答案是：几乎没有，接近于无。
在 CentOS 从事安全工作的 Dick Morrell 在推特上写道：“[社区[是]由合作和互动定义的](https://twitter.com/ThatPodcastChap/status/1337030501874479104)。如果 [@CentOSProject](https://twitter.com/CentOSProject) 是一个社区建设的住宅开发项目，它将享受那些受益和使用其设施的人所贡献的扩建、楼层和功能。” Morrell 继续说道：“然而 @CentOSProject 一直是不断给予的仁慈礼物，而现在那些抱怨的人从来没有站出来用砖头、水泥或玻璃来扩建这个物产。”
你真的能责怪红帽做了一个企业应该做的事情吗？赚钱的同时而为他们的付费社区服务？我明白为什么人们对红帽感到生气。这是沟通不畅的问题。仅仅用一年的警告就切断了对 CentOS 8 的支持，这理所当然地换来了很多人的不满。 但如果你是那些现在对红帽愤怒的人之一，在你太过自以为是之前，你可能要先自我反思一下，想想你对 CentOS 的回报有多少。
最后，如果你还是无法忍受红帽对 CentOS 的做法，还有其他的 Linux 替代品。而且，至少有两个“经典”的 CentOS 构建版本，CloudLinux 的 Project Lenix 和 Rocky Linux 可供你考虑。
---
via: <https://www.zdnet.com/article/why-red-hat-dumped-centos-for-centos-stream/>
作者：[Steven J. Vaughan-Nichols](https://www.zdnet.com/meet-the-team/us/steven-j-vaughan-nichols/) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
初识 Vi 文本编辑器 | Seth Kenlon | https://opensource.com/article/20/12/vi-text-editor | Vi 是典型的 Unix 文本编辑器。来了解一下它或它的各种化身：Vim、Neovim、gVim、nvi 或 Elvis，它适用于 Linux、macOS、Windows 或 BSD。 | /data/attachment/album/202012/23/222122wc8resp5zpo2yrcm.jpg.thumb.jpg | /data/attachment/album/202012/23/222122wc8resp5zpo2yrcm.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Vi"
] | 技术 | {
"viewnum": 4106,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12942,
"displayorder": 0
},
{
"raid": 12952,
"displayorder": 0
}
] | Vi 是典型的 Unix 文本编辑器。来了解一下它或它的各种化身：Vim、Neovim、gVim、nvi 或 Elvis，它适用于 Linux、macOS、Windows 或 BSD。 | 2020-12-23T22:22:17 | 2020-12-23T22:22:17 | 12,947 | /article-12947-1.html |
>
> Vi 是典型的 Unix 文本编辑器。来了解一下它或它的各种化身：Vim、Neovim、gVim、nvi 或 Elvis，它适用于 Linux、macOS、Windows 或 BSD。
>
>
>
不管你用的是 Vim、Neovim、gVim、nvi，甚至是 Elvis，其实都是这个典型的 Unix 编辑器 Vi。可能每一个 Linux 和 BSD 发行版中都包含了 Vi，Vi 是一个轻量级的简约型文本编辑器，由于其简单简洁的键盘快捷键和双模式设计，很多用户都喜欢它。
最初的 Vi 编辑器是由 [C shell](https://opensource.com/article/20/8/tcsh) 的创建者 Bill Joy 编写的应用程序。现代 Vi 的化身已经[增加了许多功能](https://vimhelp.org/vi_diff.txt.html#vi-differences)，包括多级撤销、插入模式下更好的导航、行折叠、语法高亮、插件支持等等。Vim 被认为是它的最流行的现代实现，大多数人在提到 Vi 时实际上是指 Vim。
所有这些化身都是为了同一个目标，所以本文将从通用的场景来探讨 Vi。你的计算机上的版本可能略有不同，但你仍然可以从 Vi 编辑文本的方式中获益。
### 安装 Vi
如果你运行的是 Linux、macOS 或 BSD，那么你已经安装了 `vi` 命令。如果你在 Windows 上，你可以[下载 Vim 和 gVim](https://www.vim.org/download.php)。
在 [NetBSD](https://opensource.com/article/19/3/netbsd-raspberry-pi)上，nvi 是 Vi 的常见替代品，而 Slackware 则提供了 [Elvis](https://github.com/mbert/elvis)（和 Vim），流行的 [Neovim](http://neovim.io) 复刻旨在帮助用户用 [Lua](https://opensource.com/article/20/2/lua-cheat-sheet) 扩展 Vim。
### 启动 Vi
在终端中用 `vi` 命令启动 Vi 或 Vim。如果在你的系统中没有找到 `.vimrc` 文件，那么 Vim 就会以 Vi 兼容模式启动（也可以用 `-C` 选项强制启动该模式）。如果你想使用 gVim 以拥有一个图形用户界面（GUI），你可以从桌面的应用程序菜单中启动它。
如果你是一个刚刚学习 Vi 的新用户，使用图形用户界面是一个很好的方法，可以在你可能期望的文本编辑器的行为和 Vi 的设计行为之间提供一个缓冲带。图形用户界面版本有一个菜单栏，一些鼠标集成，一个工具栏和其他功能，这可以帮助你找到你可能认为在典型的文本编辑器中理所当然的基本功能，但还不知道如何在 Vi 中做。
### 如何使用 Vi
学习 Vi 最简单的方法可能是使用 `vimtutor`，这是一个与 Vim 打包在一起的交互式教程。要开始学习该教程，启动 `vimtutor` 并阅读说明，尝试每个练习。正如教程中所说，学好 Vi 不是记住什么键做什么，而是建立肌肉记忆，以在输入时调用常用的动作。
#### Esc 键
学习 Vi 的第一件重要的事就是掌握 `Esc` 键。`Esc` 是激活*命令模式*的工具，很快你就会明白，在 Vi 中，只要你不确定，就按 `Esc`。在命令模式下，你按下的任何键都不会被输入到你正在处理的文本文档中，而是被 Vi 解释为一条命令。例如，要将光标向左移动，你可以按键盘上的 `H` 键。如果你处于*插入*模式，那么按 `H` 键就会输入字母 H，就像你期望的那样。但在*命令*模式下，按 `H` 向左移动，`L` 向右移动，`J` 向下移动，`K` 向上移动。
命令模式和插入模式的分离与其他文本编辑器的工作方式形成了鲜明的对比，由于这种设计，这可能是 Vi 最显著的差异化。不过有趣的是，理论上来说，它与你可能已有的工作方式并没有太大的区别。毕竟，当你把手从键盘上拿开，用鼠标选择文本时，你基本上是将自己置于一种命令模式中。在 Vi 中，你不需要把手从键盘上移开来移动鼠标，也不需要按功能键或 `Ctrl` 键，而是将*编辑器*放入一种特殊的操作模式中，使你的按键重新分配到命令上，而不是文字输入。
#### 扩展 Vi
在 Vim 8.0 版本之前，Vi 在很大程度上“只是”一个文本编辑器。它有插件，但安装插件是一个手动的过程，很多用户从未想过要这么做。幸运的是，Vim 8 及以上版本提供了对插件管理的支持，使得安装和加载插件变得轻而易举。
安装 Vim 的插件可以通过 `vim-plug` 功能来完成。例如，要安装 Vi 文件浏览器 [NERDTree](https://www.vim.org/scripts/script.php?script_id=1658)：
```
:PlugInstall NERDTree
```
你也可以更新插件：
```
:PlugUpdate NERDTree
```
关于使用 `vim-plug` 和手动安装插件和主题的更多信息，请阅读我的文章《[如何安装 Vim 插件](https://opensource.com/article/20/2/how-install-vim-plugins)》。
### 默认 Vi
Vi 不仅仅流行，它还是一个 [POSIX](https://opensource.com/article/19/7/what-posix-richard-stallman-explains) 标准。它是每个系统管理员都应该知道如何使用的应用程序，即使他们不打算每天使用它。它也是一个快速而简单的编辑器，所以一旦你熟练掌握了它，它可能就是你一直在寻找的编辑器。
---
via: <https://opensource.com/article/20/12/vi-text-editor>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
如何在 Linux 终端查看图像 | Magesh Maruthamuthu | https://www.2daygeek.com/how-to-view-display-images-from-linux-terminal/ | Linux 有很多用于查看图像的 GUI 应用。但我从来没有尝试过用任何命令行应用来查看它。 | /data/attachment/album/202012/23/233513zcgmggmxfd0wf9g1.png.thumb.jpg | /data/attachment/album/202012/23/233513zcgmggmxfd0wf9g1.png | true | false | true | lujun9972 | geekpi | wxy | false | [
"终端",
"图像"
] | 技术 | {
"viewnum": 20651,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | Linux 有很多用于查看图像的 GUI 应用。但我从来没有尝试过用任何命令行应用来查看它。 | 2020-12-23T23:36:26 | 2020-12-23T23:36:26 | 12,948 | /article-12948-1.html | 
Linux 有很多用于查看图像的 GUI 应用。但我从来没有尝试过用任何命令行应用来查看它。
幸运的是，在使用 [ImageMagick 工具](https://www.2daygeek.com/resize-convert-images-from-linux-command-line/)时，我得到了一个从终端查看图像的命令。命令名是 `“display`，它是 ImageMagick 工具的一部分。这是一个很好的工具，允许类 UNIX 用户从终端查看图像。
此外，我还为此用途得到了另一个很好的工具，叫做 FIM。
我们将向你展示如何安装并使用它从 Linux 终端查看图像。这些命令使用系统的<ruby> 帧缓冲 <rt> framebuffer </rt></ruby>直接从命令行显示图像。
### 如何使用 display 命令从终端查看图像
[ImageMagick](https://imagemagick.org/) 是一个自由开源、功能丰富、基于命令行的图像处理工具。它用于创建、编辑、合成或转换位图图像。它可以读取和写入各种格式（超过 200 种）的图像，包括 PNG、JPEG、GIF、PDF、SVG 等。它可以调整图像的大小、镜像、旋转、转换图像、调整图像颜色、应用各种特殊效果等。它支持批处理，允许你一次处理所有图像。
### 如何安装 ImageMagick？
ImageMagick 软件包包含在大多数 Linux 发行版的官方仓库中。使用发行版软件包管理器来安装它。
\*\*需要注意的是：\*\*确保你的 Linux 系统上已经安装了 “[Development Tools](https://www.2daygeek.com/install-development-tools-on-ubuntu-debian-arch-linux-mint-fedora-centos-rhel-opensuse/)” 包，这是安装的前提条件。
对于 RHEL/CentOS 6/7 系统，请使用 [yum 命令](https://www.2daygeek.com/linux-yum-command-examples-manage-packages-rhel-centos-systems/) 安装 ImageMagick：
```
$ sudo yum install -y ImageMagick ImageMagick-devel
```
在 RHEL/CentOS 8 和 Fedora 系统，使用 [dnf 命令](https://www.2daygeek.com/linux-dnf-command-examples-manage-packages-fedora-centos-rhel-systems/) 安装 ImageMagick：
```
$ sudo dnf install -y ImageMagick ImageMagick-devel
```
对于 Debian/Ubuntu 系统，使用 [apt 命令](https://www.2daygeek.com/apt-command-examples-manage-packages-debian-ubuntu-systems/) 或 [apt-get 命令](https://www.2daygeek.com/apt-get-apt-cache-command-examples-manage-packages-debian-ubuntu-systems/) 安装 ImageMagick：
```
$ sudo apt-get update
$ sudo apt-get install imagemagick
```
对于 openSUSE 系统，使用 [zypper 命令](https://www.2daygeek.com/zypper-command-examples-manage-packages-opensuse-system/) 安装 ImageMagick：
```
$ sudo zypper install -y ImageMagick
```
要查看任何图像文件，请运行 `display` 命令，如下所示。你可以按下 `Esc`/`q` 按钮关闭图像：
```
$ display bird.jpg
```
如果你想用指定的窗口大小打开图像，请使用 `-geometry` 标志：
```
$ display -geometry 1000x600 ~/Downloads/bird.jpg
```
你也可以通过 `display` 命令输入图像的位置信息。下面的命令可以从桌面的距顶部 800 像素和据左上角 800 像素处打开图像：
```
$ display -geometry 1000x600+800+800 ~/Downloads/bird.jpg
```
如果你想用 `display` 命令调整图像的大小，请使用以下格式：
```
$ display -resize 600x400 ~/Downloads/bird.jp
```
另外，你也可以使用百分比来调整图片的大小：
```
$ display -resize 50% ~/Downloads/bird.jpg
```
### 如何使用 fim 命令从终端查看图像
[FIM](https://www.nongnu.org/fbi-improved/#docs) 是一个专门为 Linux 设计的轻量级全局图像查看器。但它并不局限于 Linux，它也可配置在其他操作系统上运行，如 MS-Windows。
对于熟悉 VIM 文本编辑器等软件的用户来说，它是高度可定制和可脚本化的图像查看器。它可以全屏显示图像，并且可以使用键盘快捷键轻松控制。它是一款非常轻量级的工具，因为它只依赖于某些库。
它可以打开许多文件格式，它可以在以下视频模式下显示图像：
* 使用 Linux 帧缓冲设备图形化。
* 在 X/Xorg 下，使用 SDL 库图形化
* 在 X/Xorg 下，使用 Imlib2 库图形化。
* 使用 AAlib 库，在任意文本控制台中以 ASCII 艺术形式呈现。
运行时自动检测或选择正确的视频模式，如果需要，可以在构建前配置时选择加入或去除。
FIM 是 “Fbi IMproved” 的缩写，是 Fbi Image Viewer 的复刻版本。
FIM 可以很容易地安装在基于 Debian/Ubuntu 的系统上，因为该软件包在发行版的官方仓库中是可用的。对于其他发行版，你可能需要从源码编译它：
```
$ sudo apt install fim
```
安装完毕后，你可以使用以下命令显示图像：
```
$ fim bird.jpg
```
你可以使用 `-a` 选项自动缩放图像：
```
$ fim -a bird.jpg
```
如果你要打开当前目录中的多个图像文件，请使用通配符将它们全部打开。使用 `PageUp`/`PageDown` 键盘快捷键移动到下一张或上一张图像：
```
$ fim -a *.jpg
```
要以 ASCII 格式查看图像，可以使用 `-t` 标志：
```
$ fim -t bird.jpg
```
下面的键盘快捷键可以让你控制图像：
* `PageUp`/`PageDown`：上一张/下一张图片。
* `+`/`-`：放大/缩小
* `a`：自动缩放
* `w`：适应宽度
* `ESC`/`q`：退出
---
via: <https://www.2daygeek.com/how-to-view-display-images-from-linux-terminal/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
《代码英雄》第三季（6）：Bash Shell 中的英雄 | Red Hat | https://www.redhat.com/en/command-line-heroes/season-3/heroes-in-a-bash-shell | Brian J. Fox 讲述了他在自由软件基金会的工作，他需要创建一个自由的 Bourne shell 版本。它必须兼容但不使用任何原始源代码的元素。这个 Bourne-Again Shell，即 Bash | /data/attachment/album/202012/24/164517puraibr9z9gtbwzb.png.thumb.jpg | /data/attachment/album/202012/24/164517puraibr9z9gtbwzb.png | true | false | true | bestony | JonnieWayy | acyanbird, wxy | false | [
"Bash",
"代码英雄"
] | 代码英雄 | {
"viewnum": 9921,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12909,
"displayorder": 0
},
{
"raid": 13027,
"displayorder": 0
}
] | Brian J. Fox 讲述了他在自由软件基金会的工作，他需要创建一个自由的 Bourne shell 版本。它必须兼容但不使用任何原始源代码的元素。这个 Bourne-Again Shell，即 Bash | 2020-12-24T16:45:16 | 2020-12-24T16:45:16 | 12,951 | /article-12951-1.html |
>
> 代码英雄讲述了开发人员、程序员、黑客、极客和开源反叛者如何彻底改变技术前景的真实史诗。
>
>
>
>
> **什么是《代码英雄》**
>
>
> <ruby> 代码英雄 <rt> Command Line Heroes </rt></ruby>是世界领先的企业开源软件解决方案供应商红帽（Red Hat）精心制作的原创音频播客，讲述开发人员、程序员、黑客、极客和开源反叛者如何彻底改变技术前景的真实史诗。该音频博客邀请到了谷歌、NASA 等重量级企业的众多技术大牛共同讲述开源、操作系统、容器、DevOps、混合云等发展过程中的动人故事。
>
>
>
本文是《[代码英雄](https://www.redhat.com/en/command-line-heroes)》系列播客[《代码英雄》第三季（6）：Bash Shell 中的英雄](https://www.redhat.com/en/command-line-heroes/season-3/heroes-in-a-bash-shell)的[音频](https://cdn.simplecast.com/audio/a88fbe/a88fbe81-5614-4834-8a78-24c287debbe6/1a66178b-d531-4b54-b217-6c0db423325c/CLH_S3_EP6_Heroes_in_a_Bash_Shell_vFINAL_1_tc.mp3)脚本。
>
> 导语：Shell 使得大规模 IT 成为可能。它们是现代计算的必要组成部分。但是，如果没有<ruby> 自由软件基金会 <rt> Free Software Foundation </rt></ruby>一位名叫 Brian Fox 的开发者的辛勤工作，它可能不会变成这样。现在，世界上几乎每台电脑都有 Bash shell。
>
>
> 在上世纪 70 年代，<ruby> 贝尔实验室 <rt> Bell Labs </rt></ruby>希望将重复的、复杂的命令序列自动化。Chet Ramey 描述了贝尔实验室是如何开发出几个 shell 的 —— 但 UNIX 只能有一个官方支持的 shell。获选的是 Bourne shell。尽管 Bourne shell 是这些之中最好的一个 shell，但它也有其局限性。而且它只有在受到限制的 UNIX 许可证下才能使用。Brian J. Fox 讲述了他在自由软件基金会的工作，他需要创建一个自由的 Bourne shell 版本。它必须兼容但不使用任何原始源代码的元素。这个 Bourne-Again Shell，即 Bash，可能是这个星球上使用最广泛的软件。而 Taz Brown 描述了它是如何成为一个开发者可以学习使用的最重要的工具之一。
>
>
>
**00:00:07 - Saron Yitbarek**：
那是 1987 年。里根总统治下的美国正蓬勃发展，一个怀揣远大梦想的人正驱车前往他位于<ruby> 圣巴巴拉 <rt> Santa Barbara </rt></ruby>的新家。这个人名叫 Brian Fox，27 岁，是高中辍学生。在他车的后备箱里，有两盒巨大的磁带，里面载满了他当时正在编写的代码。
**00:00:28**：
Fox 多年来一直以程序员的身份工作在所谓的自由软件运动中。他相信他锁在这个后备箱里的代码，可以带来一场革命，这是一种全新的软件范例。他的社区正在一点一点地使之成为现实。
**00:00:49**：
那年，<ruby> 理查德•斯托曼 <rt> Richard Stallman </rt></ruby>（RMS）的<ruby> 自由软件基金会 <rt> Free Software Foundation </rt></ruby>的一组程序员，正在想尽办法给计算机界带来自由。他们想要构建一个 UNIX 的替代品，以取代自从 70 年代以来就主导编程的 UNIX 操作系统。他们的 GNU（表示 GNU's not UNIX）将成为公众的操作系统，任何人都可以使用它，无需担心许可费用或版权问题。
**00:01:18**：
多年以来，基金会一直在努力制造这个崭新的系统。那么 Brian Fox 汽车后备箱里的那两盒装着代码的巨型磁带是什么？它们存储着这个系统一个至关重要的组成部分。这是一个自由的，而且可更改的 shell，它能够使 GNU 操作系统变得完整。这是 Brian Fox 送给自由软件运动的礼物。他称之为 Bash。
**00:01:46**：
我是 Saron Yitbarek，这里是<ruby> 代码英雄 <rt> Command Line Heroes </rt></ruby>，一档来自<ruby> 红帽 <rt> Red Hat </rt></ruby>的原创播客节目。在这一集中，我们将来看看 Bash shell 中的英雄们。我们将探索 shell 的历史，以及它们为什么对我们如今的工作如此重要。大家可以将 shell 看作要给演员的剧本。它们提供了完整的命令序列，然后 shell 可以快速地运行，就像演员可以一行接一行地读她的台词一样。这是对于实现重复且复杂的代码的，是最终的解决方案，也是自动化的关键。你可能会说，shell 脚本是我们开发的一大助力。但是，是否可以编写一个，能给所有人带来帮助的 shell？这就是挑战所在。
>
> **00:02:38 - Ken Thompson**：
>
>
> 让我们回到 1969 年。那时候贝尔实验室的几位计算机科学家，正在根据自己的需求开发程序。
>
>
>
**00:02:48 - Saron Yitbarek**：
这位是代码英雄先驱 Ken Thompson。由贝尔实验室设计的 UNIX 操作系统，在一开始确实是供他们个人使用的。最初，它只是一个内部系统。UNIX 鼓励程序员之间进行密切的交流，不过目的并不是要改变整个世界，而是改变贝尔实验室。
>
> **00:03:13 - Ken Thompson**：
>
>
> 到现在，几乎整个贝尔实验室都在使用这个系统。我们公司拥有近两万个计算机终端，其中大多数使用 UNIX 系统。
>
>
>
**00:03:25 - Saron Yitbarek**：
一款由 Ken Thompson 所设计的 UNIX shell 在 1971 年发布。 虽然 Thompson shell 被设计为命令行解释器，但是它却不能很好地支持脚本。所以直到六年后的 1977 年，脚本才开始兴起。
**00:03:44 - Chet Ramey**：
Shell 参数、特殊参数以及我们如今认为理所当然的变量，起源于 Steve Bourne 和 Bourne shell。
**00:03:57 - Saron Yitbarek**：
这位是 Chet Ramey，Case Western Reserve 大学的 IT 架构师。Chet 致力于维护 Bash，他也为我们讲述了许多 Bash 的起源故事。他描述了贝尔实验室当时研究 UNIX shell 样子时的情景。
**00:04:13 - Chet Ramey**：
我们如今使用的编程结构起源于 Steve Bourne，他的 shell 赢得了这场比赛。当时有大量使用 Mashey shell 的用户社区，也有大量用户开始使用 Bourne shell。那时候成立了一个委员会来决定哪一个将会获胜，哪一个将会成为从那时候起得到官方支持的 UNIX shell， Bourne 的 shell 赢了。而其他的 shell，正如他们所说，成为了历史。
**00:04:54 - Saron Yitbarek**：
不过，这还不是历史的终结。当然，Bourne shell 是一个巨大的飞跃。它打开了一扇通向更高自动化水平的大门。但是尽管有一段时间 Bourne 占据了上风，但是 Bourne shell 并不能解决我们所有的脚本需求。
**00:05:14 - Chet Ramey**：
Bourne 撰写自己的 shell 时所受到的限制，几乎是现在的你我难以想象的。显然，当你遇到这些限制时，你不得不放弃很多东西，Bourne 就放弃了很多。考虑到他所处理的空间、内存和 CPU 限制，他能够让 Bourne shell 包含那么多东西，这相当了不起。
**00:05:42 - Saron Yitbarek**：
请记住，Bourne shell 仍然是贝尔实验室 UNIX 系统的一部分。它仍然与 UNIX 许可证绑定。这意味着它不是自由的，不是开放的。这款 shell 是私有的。
**00:05:55 - Chet Ramey**：
如果你不在大学里，获取 UNIX 源码将会非常困难。显然，这对 Berkeley UNIX 的普及产生了影响。Berkeley UNIX 始于大学中，在大学社区中成长，并走了一条阻力最小的道路。因此，如果你在正确的地方，访问到 Bourne shell 的源码并不困难，但是总的来说，这并不是大众都能够认可的方案。
**00:06:36 - Saron Yitbarek**：
Chet Ramey 是 Bash shell 的维护者。
**00:06:41**：
因此，我们有了 shell 的雏形，可以着手写这些关键的组成部分，但是目前为止，最好的 shell 的许可证却有个大大的问题，它是闭源的。对于理查德•斯托曼和他的自由软件基金会而言，这是绝对无法接受的事情。我们所需要的是一个不与任何公司绑定的 shell，一个面向所有人的 shell。
**00:07:05**：
但这就带来了问题。这意味着我们需要编写某种，能做到 Bourne shell 所能做到的一切，而又不会侵犯到版权的东西。如果逐字复制 Bourne shell 的代码，你会被起诉。
**00:07:20**：
为了使人们摆脱 Bourne shell 的束缚，你必须找到一位能在没看过 Bourne shell 任何源代码的情况下，编写这款复杂程序的程序员。你必须找到这样的一位局外人天才。而理查德•斯托曼找到了完成这项工作的程序员。
**00:07:46**：
Brian Fox 是一名 20 来岁的高中辍学生，比贝尔实验室的大多数人更懂代码。他从来没有见过任何 Bourne shell 的源代码，这使得他非常适合手头的任务。
**00:08:02 - Brian Fox**：
我是 Brian Fox。
**00:08:04 - Saron Yitbarek**：
为什么不直接问问这个年轻人，这个故事是什么样的呢？现如今，Fox 是一位开源倡导者以及 Opus Logica 的 CEO。但是早在 80 年代后期，他只是一个信仰开源软件运动的年轻人。我们聊了聊过去的日子，以及 Bash 是如何从那时演变过来的。
**00:08:23**：
所以那时候理查德•斯托曼请你为 UNIX 开发一款 shell。那将会是一款自由的 shell，并且是 Bourne shell 的替代品。你是如何回应的呢？
**00:08:38 - Brian Fox**：
“我们就不能做个更棒的吗？”
**00:08:41 - Saron Yitbarek**：
我喜欢这个。再多跟我说说。
**00:08:45 - Brian Fox**：
我为斯托曼所做的第一件事，其实就是编写个信息技术文档系统。我让理查德惊讶于我做这种编程的速度。他是个优秀的程序员而且工作的很快，但是他不认为其他人也能写得那么快。
**00:09:00 - Brian Fox**：
因此，在第一周内，我完成了一款名为 GNU Info 的程序的第一版实现，理查德对此有点儿震惊。我说：“我的下一个项目是什么？我的下一个项目是什么？”他说：“好吧，现在给它做个编译器吧。”我就做了，一周时间之内就完成了。然后我说：“我的下一个项目是什么？我的下一个项目是什么？”他说：“好吧，另一个家伙一直在研究那个 shell，但他还没有太多进展。”我说了“好的”，九个月后， Bourne shell 的替代品完成了。
**00:09:29 - Saron Yitbarek**：
九个月，哇。再多告诉我一些。为什么它如此具有挑战性？
**00:09:33 - Brian Fox**：
这真是个有趣的问题。它之所以如此具有挑战性，是因为我们必须忠实地模仿 Stephen Bourne 最初的 Bourne shell 的所有行为，同时对其进行扩展，让它成为人们能使用的、更好的工具。
**00:09:51**：
那时候，我和 Korn shell 的作者 David Korn 私下进行了秘密争论。POSIX 委员会，也就是规定了什么是标准 UNIX 的委员会，他们也参与了进来，并说：“哦，很好，我们需要知道 shell 到底要包含些什么。”而这方面最重要的两个人是我和 David Korn。David Korn 已经写了一个名为 KSH 的 shell。对于他所加入到 KSH 中的每一个功能，他都说：“这应该是一个标准功能。”是这样吗？对他来说这比起拥有最完美的 POSIX shell 要容易得多，如果这仅仅是他的 shell 的话。
**00:10:31**：
其中的一些功能并不是很好的功能，不是很好的选择，而且使得这款 shell 与 Bourne shell 有些不兼容，或者我觉得缺少功能，对此我们进行了一些讨论和争论，因此构建一个兼容 POSIX 的 shell 与过去为 Bourne shell 所编写的每个 shell 脚本都完全兼容花了超过 3 个月时间。
**00:10:54 - Saron Yitbarek**：
因此，如果你正在设计的产品不仅可以取代 Bourne shell，而且还试图模仿 Bourne shell 的每个部分，听起来你可能会遇到一些版权问题。你是如何处理的？
**00:11:08 - Brian Fox**：
为了构建真正开源而自由的软件，你必须得在一个干净的空间里，开始做这项工作。你不能从查看别人的代码开始然后重新实现它。因此，我从未见过与任何贝尔的系统、UNIX 或者甚至 Berkeley UNIX 相关的任何软件，也从未见过这些东西的源代码。
**00:11:29**：
当我开始构建 Bash shell 时，我使用了一个名为 Bison 的解析器，理查德已经将其整合到自由软件基金会里，并且与之前任何的其他程序完全不同。因此，我已经知道我所要构建的东西，绝对不会侵犯任何先前构建的东西的版权。
**00:11:55 - Saron Yitbarek**：
创建 Bash 的工作有很多小插曲，对于那些硬核的代码英雄来说，这只是其中一个例子。
**00:12:03 - Brian Fox**：
有一次，我正致力于在 shell 中实现<ruby> 通配扩展 <rt> globbing </rt></ruby>。举例来说，这是允许你匹配大量文件的通配符扩展。你可以给出 `*.c`，而这会匹配所有带有 `.c` 扩展名的文件。
**00:12:17**：
因此我在通配扩展上忙活了几个小时，并且使其生效了，对此我感到很兴奋。这是一个很好的实现。而在创建这一版实现的过程中，我在我的目录里创建了一个名为 `*.c` 的文件，然后我想：“好吧，我应该删掉这个文件”，然后我输入了 RM、空格、引号、星号点 C、闭合引号，在现代 shell 中当你使用了括号，这意味着“不要扩展这个”，然后我按下了回车，提示符过了很长时间才重新出现，因为我们正在使用 Sun 350s，运行缓慢。我意识到，之所以花了很长时间是因为它要删除这个目录里的所有源文件。
**00:12:58 - Saron Yitbarek**：
哦，不！
**00:12:59 - Brian Fox**：
是的。所以我当时删掉了 Bash 的源代码。
**00:13:01 - Saron Yitbarek**：
哦，不要。
**00:13:04 - Brian Fox**：
这 ——
**00:13:05 - Saron Yitbarek**：
哦我的天哪，嗯。
**00:13:06 - Brian Fox**：
这件事让我笑了很久，笑的很大声。我甚至没有感到一丝沮丧。然后在接下来的几天里，我重新输入了全部。这份代码在我脑海里是完全是崭新的。
**00:13:20 - Saron Yitbarek**：
哇。
**00:13:20 - Brian Fox**：
问题解决了。只需将其记录到文件中即可。
**00:13:25 - Saron Yitbarek**：
好的。因此，大多数人会在那一刻完全惊慌失措。而你笑了，只是说：“哦，我想我必须重新做一遍了。”为什么你当时那么冷静呢？
**00:13:35 - Brian Fox**：
这让我感到疯狂很荒唐，也非常好笑，我正在打造这个工具，而要确保自己能搞好，确保该工具正常工作，你得在构建它的过程中就使用它。但是该工具无法正常工作。我还没有实现引号，并且因为我还没实现引号，所以我输入的命令没有按照我所预期的去执行，我觉得这真的很滑稽。
**00:14:06 - Saron Yitbarek**：
太神奇了。
**00:14:08**：
不过，甚至是关于错误的这个故事也能说明 Fox 的才华。他们说莫扎特在头脑中完成了交响曲，然后只需要在完成后写下来即可。Fox 也有类似的天赋。
**00:14:23**：
因此，当你最终完成并交付 Bash 时，感觉如何呢？
**00:14:27 - Brian Fox**：
呵，其实感觉很壮观。那么这里有一个故事，其实我一般不讲的。构建这款 shell 花了大约 8 个月的时候，当时我知道，我大概还需要大约一个月时间才能完成工作，然后另一个 shell 发布了 —— ASH，一个开源的 shell 被发布了，我很沮丧，因为我们还没有向任何人发布 Bash shell，所以只有少数人在使用它。我知道这还需一个月的工作量，于是我想：“哦，这太糟糕了。我投入的全部能量和精力都不会得到赞许，甚至可能都不会被看见。”所以我非常沮丧。这次我没有笑。
**00:15:13 - Saron Yitbarek**：
然而，布丁好不好，吃了才知道。GNU 的 Bash 发布于 1989 年并且变成了 Linux 的默认 shell。如今，它是计算机中不可或缺的一部分。
**00:15:25**：
它无处不在。如此多的人每天都在使用它。它遍布于每一台计算机上。作为 Bash 的作者感觉如何？
**00:15:34 - Brian Fox**：
大多数时候，我甚至都没有注意到 Bash 是比工具更加重要的东西。我真的没有经常想这件事。每隔一段时间，我会走进一家苹果商店，环顾四周然后想：“哇，这里的每台计算机不仅运行着我 27 年前编写的软件，甚至上面还包含有我的名字。”然后我想：“互联网上的每台计算机、每台服务器都在运行着 Bash shell，并且其中包含有我的名字。”然后 Windows 在去年还是前年推出了 Power shell，就是 Bash，当时我想：“哦，天哪。我的名字遍及地球上的每台计算机了。”
**00:16:21 - Saron Yitbarek**：
不过，我想让你们能仔细听听 Fox 接下来告诉我的内容，因为它是很重要。他从未想过，它的程序会这样统治全球。他试图提供帮助，试图帮助他所置身其中的编程文化。
**00:16:37 - Brian Fox**：
我并没有打算去实现出现在每个人的计算机上这样的宏伟目标。我对此一点都不感兴趣。我想制作一款有用的软件，我希望它有典型的 3 到 5 年软件寿命，而不是像现在这样疯狂的 30 年的寿命。
**00:16:58 - Saron Yitbarek**：
难道你对于你在计算机领域有如此巨大影响力的事情，一直反应那么平淡吗？
**00:17:06 - Brian Fox**：
我为自己写了 Bash 而感到骄傲，而且它让我意识到了我的价值，所以有时候我会做一些事情，诸如接受播客邀约谈论 shell 之类的事情。
**00:17:14 - Saron Yitbarek**：
非常感谢你。
**00:17:15 - Brian Fox**：
谢谢。但这不是存在于我日常生活中的东西。幸运的是，我只是一个默默无闻的人，对吧？的确，我的软件正运行在每家每户的计算机上，不过也确实没有人知道这一点，对吧？因此我保持了许多个人隐私，而这个 shell 以及某个住在圣芭芭拉的人编写了它这一事实正越来越广为人知，我开始在生活中越来越多地注意到它。人们有时候来看我演奏音乐，然后告诉我说：“你是写了 shell 的那个家伙。”我感觉有点儿像 Keanu Reeves。
**00:17:54 - Saron Yitbarek**：
很酷。所以你说过你不指望 Bash 出现在每台计算机上。你打算做的是什么呢？你对 Bash 有什么期望？
**00:18:04 - Brian Fox**：
一个有用的替代工具，成为 GNU 项目的一部分，并帮助创建这个自由的开源操作系统。我实际上以为一旦我们完成了该开源操作系统的创建，该系统上的软件就可以升级，并且我将有机会创建自己想要创建的那种 shell，以帮助人们在某种程度上促进计算机科学的发展。
**00:18:35 - Brian Fox**：
我最终意识到，Bash 被创建的原因实际上是与已经存在的 UNIX 世界向后兼容，并且这种势头使其保持了活力，这是另一个独一无二的地位，你的工具如此基础，几乎是一副不可或缺的螺母和螺栓。
**00:19:01 - Saron Yitbarek**：
确实是这样。
**00:19:01 - Brian Fox**：
知道我创造了世界上某种有价值的、别人仍然还在使用的东西，这真的是一种很棒的感觉。然后当我注意到这是怎么回事时，我意识到，更重要的是，“自由软件”和“开源”这些词存在于日常英语和全世界的日常语言之中了，而最初并不是这样的。这是我和理查德•斯托曼还有其他人所投入努力的产物。作为这一运动的一部分，我很幸运能这么早参与，但让我回过头来看时，也感到非常满意，我想：“哇，开源软件已经存在，而且我就是其中的一部分。”
**00:19:50 - Saron Yitbarek**：
Brian Fox 是 Bash shell 的创建者和 Opus Logica 的 CEO。
**00:20:01 - Steve Bourne**：
事实上，我确实听说过 Bash。
**00:20:03 - Saron Yitbarek**：
这位就是被 Brian Fox 的工作所替代的 Bourne shell 的创建者 Steve Bourne。我们想知道 Bourne 对 Fox 的工作有何看法。他是否将重生的 shell Bash 视为自己作品的开源复制品？我的意思是，他觉得 Bash 怎么样？
**00:20:20 - Steve Bourne**：
有一天，写了 Bash 的那个人在一次会议上找我，给了我一件 T 恤，前面印着 “Bourne again” 的字样。
**00:20:26 - Saron Yitbarek**：
那就是 Brian Fox。
**00:20:29 - Steve Bourne**：
那是一种友好的情绪，当时是：“好吧，希望您不介意，但我只是重写了您的 shell”，而我说：“听起来不错”，然后他给了我一件 T 恤。
**00:20:38 - Saron Yitbarek**：
如果我在编程领域学到了一件事，那就是每个人都喜欢意外之喜。事实证明，Stephen Bourne 认为 Bash 是他和其他人在贝尔实验室所做工作的必要扩展。一点儿都不为此苦恼。
**00:20:52 - Steve Bourne**：
曾经有一些人们想要，但是我没做的特性，例如变量替换和字符串管理，但是这些都被加入到了 Bash 中，现如今人们经常会用到。Bash 和原始 shell 之间的关系，我当时的印象是，它只是对语言的重新实现，并且随着时间的推移，它确实添加了功能，因此它确实取得了超越我所写作品的进步，当然是在字符串管理领域。我现在一直在用它。
**00:21:21 - Saron Yitbarek**：
Steve Bourne 是 Bourne shell 的创建者和 Rally Ventures 的 CTO。
**00:21:32 - Saron Yitbarek**：
自从 Bash 在前往圣芭芭拉的长途车程中被塞进 Brian Fox 的卡车以来，已经过去了很多年。 2019 年，版本 5.0 被发布，就像 Fox 提到的那样，Bash 现在被内置进了 Linux 中、macOS 中，甚至微软 Windows 中。Bash 已经成了开源世界中脚本编写的基石。这是我们自动化的基础。
**00:22:02 - Taz Brown**：
随着组织规模的扩大，使用能够使我们更快完成工作的工具变得至关重要。它成为了必需品。
**00:22:16 - Saron Yitbarek**：
Taz Brown 是 Red Hat 的资深 Ansible 自动化顾问，因此她非常了解 Bash 的价值。
**00:22:24 - Taz Brown**：
我绝对认为人们在职业生涯初期就应该使用 Bash。与其使用 GUI 或者说是图形用户界面，不如将自己视为管理员或 DevOps 人员。
**00:22:39 - Saron Yitbarek**：
而这是因为作为一名 Bash 程序员，你将会掌握能让你晋升的核心价值。
**00:22:45 - Taz Brown**：
学习写脚本有一定的价值，因为这可以让你从自动化的角度，为程序的长期运行做打算。你可以看到脚本的运行方式，然后可以说：“好吧，我可以做到，我可以使这项任务自动化执行。”它开始使你成为与之前不一样的思想家和技术专家。
**00:23:09 - Saron Yitbarek**：
对于运维而言，自动化已经变得不可或缺。复杂的程序、应用和工具均由优雅的 Bash 代码实现。
**00:23:21 - Taz Brown**：
如果你愿意的话，你不必重复造轮子。你可以从 GitHub 库或是其他任何你存储这些特定文件的地方拉取它们。Bash 允许你这么做。Bash 允许你执行这些常见任务，并且可以从 10 台服务器扩展到 1000 台服务器。
**00:23:42**：
关于自动化的伟大之处在于，一旦你制定了计划，就可以以一种非常有效的方式执行。它允许你执行那些，无法手动执行的操作。
**00:23:56 - Saron Yitbarek**：
最近 Taz Brown 所从事开发的 Ansible® 这样的最新产品可以始终与 Bash 集成在一起，完成了工作。
**00:24:04 - Taz Brown**：
虽然时代在不停前进，但是我认为 Bash 永远都会是管理员会去选择使用的工具，特别是他们想要快速自动化的情况下。
**00:24:14 - Saron Yitbarek**：
最后，这一切的成功，都可以追溯到它是一个自由的、允许所有人加以改进的软件这件事上。它是 Brian Fox 提供给世界的，某种没有许可证和限制的东西。满足了人们一直的需求，所以是 Bash 成功的关键。实际上，他甚至已经不再主管 Bash 开发已经很长一段时间了。这位是 Chet Ramey，他维护了 Bash 数十年。
**00:24:38 - Chet Ramey**：
我想，Brian 在发布 1.05 版本后就已经决定了他想要继续去从事其他工作。他曾在自由软件基金会负责过其他任务，他想做除了 Bash 以外的事情，而我是 Bash 最活跃的贡献者。他和我一起开发了许多新功能。我们共同努力解决了许多 bug，因此当到了需要其他人接手时，我是最佳人选。
**00:25:16 - Saron Yitbarek**：
就像 Fox 一样，Ramey 也必须继续努力，因为 Bash 比任何一位维护者都重要。
**00:25:25 - Chet Ramey**：
我是从 23 岁开始贡献的，有点儿像是我和 Bash 共同成长。在某些时刻，我会需要征集一个团队。我需要征集那些愿意并且有能力投入时间推动 shell 发展向前的人们。
**00:25:46 - Saron Yitbarek**：
Bash，这款再次降生的 shell 明年将迎来 30 岁（LCTT 译注：Bash 发布于 1989 年，至本译文发表时，已经 31 岁了），并且没有衰老的迹象。Bash 乘着自由软件浪潮，然后是开源浪潮，直到传播至编程世界的每个角落。但曾经，它只是存储在 Brian Fox 汽车后备箱里磁带上的代码。它只是一些程序员，想要带给大家的 shell 语言。几乎偶然的，Brian Fox 在此过程中成为了一名伟大的代码英雄。
**00:26:23**：
顺便说一句，有些事情始终困扰着我， Brian Fox 驱车将所有 Bash 代码载到了 Santa Barbara。为什么要转移呢？我的意思是，他在某家科技公司找到了新工作吗？
**00:26:34 - Brian Fox**：
我想要继续我的音乐生涯，而我认为做到这一点的最佳去处就是气温总在 72 华氏度左右、天空没有乌云、海滩很美的地方。
**00:26:45 - Saron Yitbarek**：
很好，我更喜欢这个理由。
**00:26:49**：
现在让我们向 Wayne A. Lee 致敬，是他向我们建议了这一集标题《Bash Shell 中的英雄》。干得好，Wayne。
**00:26:57**：
在下一集中，我们对于自动化的兴趣，将提升到一个全新的高度，并且着眼于 AI 语言，特别是 John McCarthy 创造的 LISP。
**00:27:11**：
《代码英雄》是 Red Hat 的原创播客节目。如果你访问节目的网站 [redhat.com/commandlineheroes](file:///Users/xingyuwang/develop/LCRH-wxy/translated/www.redhat.com/en/command-line-heroes)，你将更深入了解到有关 Bash 或是我们本季所介绍的任何编程语言的故事。
**00:27:28 - Saron Yitbarek**：
我是 Saron Yitbarek。下棋之前，坚持编程。
>
> **什么是 LCTT SIG 和 LCTT LCRH SIG**
>
>
> LCTT SIG 是 LCTT <ruby> 特别兴趣小组 <rt> Special Interest Group </rt></ruby>，LCTT SIG 是针对特定领域、特定内容的翻译小组，翻译组成员将遵循 LCTT 流程和规范，参与翻译，并获得相应的奖励。LCRH SIG 是 LCTT 联合红帽（Red Hat）发起的 SIG，当前专注任务是《代码英雄》系列播客的脚本汉化，已有数十位贡献者加入。敬请每周三、周五期待经过我们精心翻译、校对和发布的译文。
>
>
> 欢迎[加入 LCRH SIG](/article-12436-1.html) 一同参与贡献，并领取红帽（Red Hat）和我们联合颁发的专属贡献者证书。
>
>
>
---
via: <https://www.redhat.com/en/command-line-heroes/season-3/heroes-in-a-bash-shell>
作者：[Red Hat](https://www.redhat.com/en/command-line-heroes) 选题：[bestony](https://github.com/bestony) 译者：[JonnieWayy](https://github.com/JonnieWayy) 校对：[acyanbird](https://github.com/acyanbird), [wxy](https://github.com/wxy)
本文由 [LCRH](https://github.com/LCTT/LCRH) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Web 开发人员喜欢 Brackets 文本编辑器的原因 | Seth Kenlon | https://opensource.com/article/20/12/brackets | 这个基础的编辑器是面向 Web 开发人员的，它支持多种编程语言，并提供了大量的扩展，使其成为你自己的编辑器。 | /data/attachment/album/202012/25/092259zy4xvxs4axmysuf9.jpg.thumb.jpg | /data/attachment/album/202012/25/092259zy4xvxs4axmysuf9.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Brackets",
"编辑器"
] | 分享 | {
"viewnum": 3297,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12947,
"displayorder": 0
},
{
"raid": 12955,
"displayorder": 0
}
] | 这个基础的编辑器是面向 Web 开发人员的，它支持多种编程语言，并提供了大量的扩展，使其成为你自己的编辑器。 | 2020-12-25T09:23:36 | 2020-12-25T09:23:36 | 12,952 | /article-12952-1.html |
>
> 这个基础的编辑器是面向 Web 开发人员的，它支持多种编程语言，并提供了大量的扩展，使其成为你自己的编辑器。
>
>
>
Brackets 文本编辑器是主要面向 Web 开发人员的编辑器。恰如其分的是，它的“编辑”菜单中充满了对 Web 编程语言用户特别有用的功能，主要是 HTML、CSS 和 Javascript 的经典组合。
但是，它还支持许多与互联网相关的语言和格式，包括 XML、Markdown、YAML 和 JSON、PHP、Lua、Java 和 Python，以及一些常见的通用语言，例如 C、C++，甚至是 `diff` 命令的输出。
### 安装 Brackets
Brackets 可以从 [Brackets 网站](http://brackets.io/)安装到 Linux、Windows 和 macOS 上。
另外，在 Linux 上，你可以从 [flathub.org](https://flathub.org/apps/details/io.brackets.Brackets) 以 Flatpak 安装。
### 使用 Brackets
在大多数时候，Brackets 是一个“普通”的文本编辑器，其功能类似于 [jEdit](/article-12942-1.html) 或 [Medit](/article-12938-1.html)。有语法高亮、可配置的制表符间距、字符编码设置等等。这些都可以在窗口底部的状态栏中找到。
在“视图”菜单中，有主题设置、行号、自动换行，甚至还有分割窗口的选项，这样你可以在一个窗口中看到两个文件。
然而，在“编辑”菜单中，有一些的特别用于编程的功能。以下是我最喜欢的一些功能：
* 使用 `Ctrl+[` 或 `Ctrl+]` 键盘快捷键来缩进和取消缩进文本块，这不仅对保持 HTML、CSS 和 Javascript 的整洁很有用，而且对 Python 代码也很重要。
* 用 `Ctrl+/` 把一行变成注释。Brackets 标记注释的方式取决于你所使用的语言，所以无论你的文档是否使用斜线、破折号、箭头、井号或其他任何类型注释，这个功能都可以使用。
* 用 `Shift+Ctrl+Up` 或 `Shift+Ctrl+Down` 在文档中将一行向上或向下移动。
* 用 `Shift+Ctrl+D` 删除整个一行。
* 用 `Ctrl+D` 复制整个一行。
这些都是看似小众的功能，你可能认为不会经常使用，但一旦你拥有了它们，你就会对它们产生依赖。
### 扩展
Brackets 还可以接受扩展，因此你和其他编码者可以添加扩展到功能中。要查看有哪些可用的扩展，请单击“文件”菜单并选择“扩展管理器”。有各种各样的扩展，包括用于调整代码格式的 Beautify、用于其他语言的多个支持包、用于转到标签开头或结尾的功能等等。
无论编辑器是否适合你，扩展可以使一个编辑器变得不同，所以如果你尝试 Brackets 并享受它的一切，但缺少一些重要的功能，在你放弃它之前，请浏览一下可用的扩展。
### 尝试 Brackets
Brackets 是一个有点低调的编辑器。虽然它宣传自己是 “Web 代码编辑器”，但实际上它是一个不错的通用编辑器，并为常见的 Web 工具链加入了一些额外的功能。如果你喜欢 Brackets 的外观和它所提供的功能，不妨一试！
---
via: <https://opensource.com/article/20/12/brackets>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
除了操作系统，openEuler 还可以是什么 | Bestony | openEuler 的过去，是我们熟悉的 Linux 发行版，是我们所不熟悉的创新平台。而未来，openEuler 可能是什么？ | /data/attachment/album/202012/25/192009frxqrnvxi9yr7q4y.jpg.thumb.jpg | /data/attachment/album/202012/25/192009frxqrnvxi9yr7q4y.jpg | true | false | false | false | [
"openEuler"
] | 观点 | {
"viewnum": 7349,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | openEuler 的过去，是我们熟悉的 Linux 发行版，是我们所不熟悉的创新平台。而未来，openEuler 可能是什么？ | 2020-12-25T19:26:00 | 2020-12-25T19:26:00 | 12,954 | /article-12954-1.html | 
openEuler 是什么？在 2019 年 7 月 19 日，华为宣布要在年底正式开源 openEuler 操作系统；在半年后的 12 月 31 日，华为正式[开源了 openEuler 操作系统](/article-11787-1.html)，邀请社区开发者共同来贡献。
一年后，截止到 2020 年12 月 25日，[openEuler](https://openeuler.org/) 已经拥有了 3 万社区用户，2 万多个合入的<ruby> 拉取请求 <rp> （ </rp> <rt> Pull Request </rt> <rp> ） </rp></ruby>，2000 多名社区贡献者，7032 款社区软件，75 个特别兴趣组（SIG）以及 7 个商业发行版。不仅如此，openEuler 还在系统主体之外，开源了虚拟化平台 StratoVirt、[容器引擎 iSula](/article-12789-1.html) 等重量级软件。
### openEuler 是发行版，还是...
和其他发行版不同，openEuler 的开场并不是以发行版开场的，而是从一个更加深刻的问题开始的——“**操作系统有创新么？**”。这个答案是肯定的，近些年来，无论是内核的架构还是应用组织的方式，都在不断的发生着创新和变化。但这些创新又好似离我们很遥远，也没有听到谁在实际生产环境中应用。这背后不是开发者的不努力，而是操作系统开发和交付的问题。
openEuler 技术委员会主席胡欣蔚拿线下的物流供应链举例，一条供应链是以满足客户需求为目的，包含了所有与满足客户需求相关的环节，从生产、运输、仓储、零售一直到最终的顾客，而与之类比的软件开发供应链，则由软件组成的相互依赖（构建、运行、代码的复制粘贴、定制化）形成的复杂关系网络被称为软件供应链。过去的开源软件把软件的交付终结于某一个特定的发行版，这带来了一些便利，简化了供应链的管理，相应的，也为软件开发的整体流程带来了单点故障的可能。
为了解决这个问题，openEuler 不是先做操作系统，而是**先对软件开发供应链进行梳理，并将整个供应链梳理开源出来**，让开发者的软件可以更好的交付给用户，让用户可以更好的把需求反馈到开源软件的上游社区。整个生态中开发者的需求、用户的需求都可以在这个供应链中得到满足。
而也正是这样的供应链，为 openEuler 带来了更多的可能，各个开源社区、合作伙伴，可以根据自己的需求，结合所在的行业和领域，打造出一款专精于领域的发行版。
不仅如此，供应链的思维，也让胡欣蔚可以重新思考云原生这个问题——“**只有云才需要云原生么？**”，答案显然是否定的。所有的数字化转型领域，都会需要云原生的这些特性。如何让这些边缘计算设备、端设备享受到云原生中的交付、迭代的性能，也是 openEuler 在关注的。**openEuler 所特有的供应链，让操作系统的打包和精简变的更简单**，可以根据设备不同的类型、场景整合出适合相应场景的操作系统，从而让这些新特性，可以不只交付给云，更可以交付给边和端，云边端一体为行业和业务创造价值。
### openEuler 是操作系统，还是....
openEuler 广为人知的是一个新的发行版，一个 Linux 操作系统，但对于 openEuler 自己来说，操作系统不过是一个创新的产品的承载平台。在胡欣蔚来看，如果一个平台没有创新，则这个平台没有未来；如果一个创新没有好的平台去落地，那这个创新不过是无根浮萍，毫无意义。对于开发者来说，**openEuler 就是这样一个孵化和培养创新的平台**。
胡欣蔚做了个比喻，“**openEuler 就是 Apache 基金会 + CentOS 操作系统**”。 CentOS 操作系统是一个著名的服务器系统，而 Apache 基金会是一个非常善于对新项目进行培育的基金会。openEuler 的操作系统，只是为了让创新可以有一个落地的平台，让创新有价值，而 openEuler 背后，是一个创新的平台、一个创新的土壤。
在这片土壤中，诞生了一些非常有意思，同时有具备使用价值的特性，比如跟随 openEuler 一同开源的 A-Tune，将 AI 的技术引入到系统的调教和优化过程中，用机器智能进行优化；比如开源的容器引擎 iSula ，让容器的运行可以更加的轻量和简单，从过去的只能运行于 x86 服务器，到现在可以应用在不同的边缘计算设备；比如 Bisheng JDK ，基于 specjbb 基准测试，相对 openJDK 性能提升了 20%；比如 StratoVirt，是基于 rust 语言开发的轻量级虚拟机，相对 QEMU 资源占用减少了80%，启动速度提升了 10 倍。
这些小的创新，让 openEuler 从一个普通的发行版，变成了一个远超过去的操作系统；而 openEuler 的孵化机制，可以让更多的有用的特性，从需求的收集，到发布到用户端，更加快速和方便。
行业在演进，操作系统和应用之间的分界线，开始变的更加的模糊，操作系统要做什么？应用要做什么？很难有一个一概而论的回答，但可以肯定的是，无论什么样的变更，都是希望这个行业可以有更大的进展，每一个行业中的开发者，都可以有更多的时间和精力去做更加核心的业务逻辑的开发。
### openEuler 是软件，还是....
openEuler 不仅仅是一款软件产品，为什么 openEuler 会出现？有了数百款发行版的 Linux 世界，真的缺这样一款操作系统么？
答案是肯定的。
提及 openEuler 的诞生，胡欣蔚回顾了自己的过去，早在 2013 年，他就开始参与 ARM 服务器的构建，彼时 Linus Torvalds 对于 ARM v7 架构的评价刚刚过去不久，ARM 芯片应用在通用计算领域也只是刚刚开始，整个行业方兴未艾。他通过研究发现，整个行业的操作系统都存在一个普遍的问题：只适配于自家的芯片和计算平台，这使得应用开发者在开发的时候，需要根据不同的芯片来进行适配，大大的降低了开发者的效率，将更多的精力放在适配，而不是业务逻辑的研发上。
在他看来，这样薄的操作系统，无法为业务创新和行业的创新提供价值，而想要促进行业的前进，操作系统的变厚、变强是必不可少的，必须要像 x86 服务器一样，一个版本足以支撑所有厂商的 ARM 服务器，才能真正的促进 ARM 在通用计算领域的蓬勃发展。
也正是因为从那时开始的努力，经过了多年的耕耘，如今在 openEuler 上可以有所收获，当年的选择也无疑是正确的。如今的 openEuler 可以完美的运行在华为自家的鲲鹏处理器上，更是可以支撑多家的 ARM 服务器。不仅如此，一些科研院所，比如国科大的“一生一芯”项目，也被 openEuler 很好的支持了。对于开发者来说，使用的是 RISC-V 架构的芯片，也可以完美的支持 openEuler。未来，openEuler 将会从系统软件的角度，打通不同算力，让软件开发者可以在一个更加简单的操作系统之上，进行技术的创新。
### openEuler 还可以是什么？
**openEuler 的过去，是我们熟悉的 Linux 发行版，是我们所不熟悉的创新平台**。而未来，openEuler 可能是什么？
胡欣蔚也向我们介绍了他的一些想法，在未来，openEuler 会在当前已有的基础之上，投入更多的精力去做一些普通开发者、厂商所无法实现的特性。比如在操作系统层面，提供秒级内核切换能力，让那些过去不敢升级、不愿升级内核的老旧系统，可以通过 openEuler 提供的特性，实现秒级的内核切换。在系统几乎不受影响的情况下，完成底层内核的切换，让老系统也可以享受到新内核提供的特性。也会花更多的精力，在 openEuler 社区的治理上，让 openEuler 社区可以有更多的用户，以及更多的开发者，让 openEuler 造福更多的企业和个人用户。
未来，openEuler 会出现在我们所熟悉的云计算和边缘计算上，到时候，我们再来看看，openEuler 还可以是什么。
|
||||
为什么 Vim 用户会喜欢 Kakoune 文本编辑器？ | Seth Kenlon | https://opensource.com/article/20/12/kakoune | 这个编辑器可能会让人联想到 Vim，但它也提供了很多自己独特的功能和特性。 | /data/attachment/album/202012/25/233039wpnwnwakzn1zwa33.jpg.thumb.jpg | /data/attachment/album/202012/25/233039wpnwnwakzn1zwa33.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Kakoune"
] | 分享 | {
"viewnum": 3179,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "86.58.47.7",
"message": "好像kakoune只支持英文。",
"username": "来自斯洛文尼亚的 Firefox 83.0|Ubuntu 用户",
"date": "2020-12-30T18:07:21"
}
] | [
{
"raid": 12952,
"displayorder": 0
},
{
"raid": 12961,
"displayorder": 0
}
] | 这个编辑器可能会让人联想到 Vim，但它也提供了很多自己独特的功能和特性。 | 2020-12-25T23:32:00 | 2020-12-25T23:32:00 | 12,955 | /article-12955-1.html |
>
> 这个编辑器可能会让人联想到 Vim，但它也提供了很多自己独特的功能和特性。
>
>
>
[Kakoune](https://kakoune.org/) 文本编辑器的灵感来源于 Vi。它拥有简约的界面、简短的键盘快捷键以及独立的编辑和插入模式，乍一看确实[看起来和感觉很像 Vi](/article-12947-1.html)。然而，Kakoune 编辑器在设计和功能上都有自己独特的风格，与其说是另一个 Vim，不如说是它是它自己。
### 安装
在 Linux 和 BSD 上，你可以从你的发行版的软件仓库或 port 树上安装 Kakoune。例如，在 Fedora、CentOS 或 RHEL 上：
```
$ sudo dnf install kakoune
```
在 Debian、Ubuntu 或类似的系统上：
```
$ sudo apt install kakoune
```
在 macOS 上，你可以使用 Homebrew：
```
$ brew install kakoune
```
或者，你也可以[从源码构建](https://github.com/mawww/kakoune)。
启动 Kakoune 的命令是 `kak`。你可以启动 Kakoune 打开空文件，也可以在启动时包含文件名让它打开：
```
$ kak example.txt
```
### 使用 Kakoune
当你启动 Kakoune（不带文件名）时，除了在窗口底部有一个小的状态栏外，它在你的终端中打开的大部分是空的缓冲区。像 Vim 一样，Kakoune 以“正常”模式启动，它把按键作为命令，不向缓冲区输入文本。要进入*插入模式*，你必须按 `i`（代表<ruby> 插入 <rt> Insert </rt></ruby>）或 `a`（代表<ruby> 追加 <rt> Append </rt></ruby>）。
在插入模式下，Kakoune 的操作和其他编辑器一样。你在键盘上输入，然后你输入的字符就会显示在缓冲区里。在插入模式下，你可以使用方向键来浏览缓冲区。
### 正常模式
在正常模式下，你可以发出导航和文本编辑命令。这是从 Vi 传统中借用的最明显的功能。编辑命令包括复制、剪切（在传统的 Unix 编辑术语中，称为 “<ruby> 猛拉 <rt> yank </rt></ruby>”）、粘贴单词和行、撤销、转换字符大小写等功能。下面是一些基础：
* `d`：复制并删除当前选择（现代术语中的“剪切”）
* `c`：复制并删除当前选择，并进入插入模式
* `Esc+Alt+d`：删除当前选择
* `y`：复制选择
* `p`：粘贴
* `<`：取消所选行的缩进
* `u`：撤消
* `U`：重做
* `：转为小写
* `~`：转换为大写
### 选择
在 Kakoune 中，你的光标是一个单字符的移动选区。除非你扩展你的选区，否则任何影响选区的命令都只适用当前光标位置。例如，如果你的光标悬停在字母 `n` 上，那么复制命令（正常模式下的 `c`）会将字母 `n` 复制到剪贴板，而粘贴命令（正常模式下的 `p`）则会将字母 `n` 粘贴到缓冲区。
从单个字符扩展选区的最简单方法是进入正常模式，按下 `Shift` 键，同时用方向键移动光标。然而，有几种方法可以根据某些标准来扩展选区。例如，`Alt+l` 将选区从光标扩展到当前行的末端。
完整的文档可以在 <https://github.com/mawww/kakoune/blob/master/README.asciidoc> 中找到。
### 函数
除了这些基本的交互，你还可以执行命令来调用 Kakoune 的内置功能。要访问 Kakoune 的命令行，在普通模式下输入 `:`。在命令行中，你可以执行命令，包括打开文件的 `edit` 命令，保存缓冲区到文件的 `write` 命令，当然还有退出应用的 `quit`。
还有更多的函数，包括针对特定编程语言和文件格式的特殊选项、使用 [Ranger 文件浏览器](https://opensource.com/article/20/3/ranger-file-navigator)浏览文件系统的选项、改变颜色主题、搜索和替换文本等等。
### 尝试 Kakoune
如果你是一个有经验的 Vim 用户，或者甚至是一个只是略知一二的人，你可能会发现 Kakoune 一开始会让你感到迷惑。它与 Vim 的相似度足以让你陷入一种虚假的熟悉感。一切都与 Vim 一模一样，直到你发现了完全不同的地方。不过，如果你是一个刚接触 Vim 编辑器的新手，或者你是一个正在寻找新挑战的 Vim 用户，那么 Kakoune 可能是你的理想编辑器。
你自己试试吧！
---
via: <https://opensource.com/article/20/12/kakoune>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
在 Ubuntu Linux 上安装 Deb 文件的 3 种方法 | Abhishek Prakash | https://itsfoss.com/install-deb-files-ubuntu | 这篇初学者文章解释了如何在 Ubuntu 中安装 deb 软件包。它稍后也向你展示如何移除这些 deb 软件包。 | /data/attachment/album/202012/25/234722wyxuanovuv2xvgey.png.thumb.jpg | /data/attachment/album/202012/25/234722wyxuanovuv2xvgey.png | true | false | true | lujun9972 | robsean | wxy | false | [
"deb"
] | 技术 | {
"viewnum": 65359,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "211.97.126.216",
"message": "几个方法里面提到的几个工具，用apt安装<br />\r\n那直接sudo apt install deb文件路径（如果是当前路径必须加./）不就能安装了吗，还能解决依赖问题",
"username": "来自福建的 Chrome 87.0|Windows 10 用户",
"date": "2020-12-26T00:05:10"
}
] | [] | 这篇初学者文章解释了如何在 Ubuntu 中安装 deb 软件包。它稍后也向你展示如何移除这些 deb 软件包。 | 2020-12-25T23:47:20 | 2020-12-25T23:47:20 | 12,956 | /article-12956-1.html |
>
> 这篇初学者文章解释了如何在 Ubuntu 中安装 deb 软件包。它稍后也向你展示如何移除这些 deb 软件包。
>
>
>
这是 Ubuntu 初学者系列的另一篇文章。如果你对 Ubuntu 很陌生，你可能会想知道 [如何安装应用程序](https://itsfoss.com/remove-install-software-ubuntu/)。
最简单的方法是使用 Ubuntu 软件中心。在软件中心中搜索应用程序的名称并安装它。如果你能在软件中心中找到所有的应用程序，那么生活就太惬意了。但是，不幸的是，这是不可能的发生的。
一些软件包可以通过 DEB 软件包的形式获得。它们是以 .deb 扩展名为结尾的存档文件。你可以把 .deb 文件看作为 Windows 中的 .exe 文件。在 Windows 中，你双击 .exe 文件，它将开始安装过程。DEB 软件包也是非常类似的。
你可以从软件提供商网站的下载区域找到这些 DEB 软件包。例如，如果你想 [在 Ubuntu 上安装 Google Chrome](https://itsfoss.com/install-chrome-ubuntu/) ，你可以从它的网站下载 Chrome 的 DEB 软件包。
现在问题产生了，你将如何安装 deb 文件呢？在 Ubuntu 中有多种安装 DEB 软件包的方法。在这篇教程中，我将向你依次地展示它们。
### 在 Ubuntu 和基于 Debian 的 Linux 发行版中安装 .deb 文件
你可以选择一个 GUI 工具或一个命令行工具来安装一个 deb 软件包。你拥有选择权。
让我们继续看看如何安装 deb 文件。
#### 方法 1: 使用默认的软件中心
在 Ubuntu 中，最简单的方法是使用默认的软件中心。在这里你不必要做任何特别的事。只需要转到你所下载的 .deb 文件的文件夹下（它应该是 Downloads 文件夹），并在这个文件上双击。
在已下载的 .deb 文件上双击以开始安装。
它将打开软件中心，并且你将看到安装软件时的选项。你所需要做的全部工作就是：点击安装按钮并输入你的登录密码。
.deb 文件的安装将通过软件中心来执行。
看，它甚至比在 Windows 中安装一个 .exe 文件更简单，不是吗？
#### 方法 2: 使用 Gdebi 应用程序来安装 deb 软件包及其依赖项
再提一次，如果事情总是进展顺利，生活可能会更简单一些。但是生活并不是我们熟知的那样。
现在，你已经知道 .deb 文件可以简单地通过软件中心来安装，接下来，让我告诉你一些软件包可能会遇到的依赖项的错误。
发生错误的原因是，一个程序可能依赖于另外一个软件包（库）。当开发者为你准备 DEB 软件包时，他/她可能会假设你的系统中已经有了所依赖的软件包（库）。
但是如果情况并不是这样的，你的系统没有这些所需要的软件包（库），你将遇到臭名昭著的“依赖项错误”。
软件中心不能处理这样的错误，因此你不得不使用另外一个名称为 [gdebi](https://itsfoss.com/gdebi-default-ubuntu-software-center/) 的工具。
gdebi 是一个轻量级的 GUI 应用程序，它只有安装 deb 软件包的一个用途。
它将识别依赖项，并尝试在安装 .deb 文件的同时安装这些依赖项。
就我个人而言，我更喜欢使用 gdebi 而不是使用软件包中心来安装 deb 文件。它是一个轻量级应用程序，因此安装过程看起来更快一点。更多的信息，你可以阅读[使用 gDebi ，并使其成为安装 DEB 软件包的默认设置](https://itsfoss.com/gdebi-default-ubuntu-software-center/)。
你可以从软件中心或使用下面的命令来安装 gdebi ：
```
sudo apt install gdebi
```
#### 方法 3: 在命令行中使用 dpkg 安装 .deb 文件
如果你想在命令行中安装 deb 软件包，你可以使用 `apt` 命令或者 `dpkg` 命令。实际上，`apt` 命令在底层上使用 [dpkg](https://help.ubuntu.com/lts/serverguide/dpkg.html.en) 命令，但是 `apt` 却更流行和易于使用。
如果你想对 deb 文件使用 `apt` 命令，像这样使用它：
```
sudo apt install path_to_deb_file
```
如果你想对将要安装的 deb 软件包使用 `dpkg` 命令，在这里是如何完成它：
```
sudo dpkg -i path_to_deb_file
```
在这两个命令中，你应该使用你已下载的 deb 文件的路径和名称来替换 `path_to_deb_file` 。
如果你在安装 deb 软件包的过程中得到一个依赖项的错误，你可以使用下面的命令来修复依赖项的问题：
```
sudo apt install -f
```
### 如何移除 deb 软件包
移除一个 deb 软件包也不是一件什么大事。并且，你不需要用于安装程序的原始的 deb 文件。
#### 方法 1: 使用 apt 命令移除 deb 软件包
你所需要的全部东西就是你所已安装程序的名称，接下来你可以使用 `apt` 或 `dpkg` 来移除这个程序。
```
sudo apt remove program_name
```
现在，问题来了，在移除命令中，你如何找到你所需要使用的准确的程序名称？为此，`apt` 命令也有一个解决方案。
你可以使用 `apt` 命令找到所有已安装文件的列表，但是手动完成这一过程将会是一件令人头疼的事。因此，你可以使用 `grep` 命令来搜索你的软件包。
例如，在先前的部分中，我已安装 AppGrid 应用程序，但是如果我想知道准确的程序名称，我可以像这样使用一些东西：
```
sudo apt list --installed | grep grid
```
这将给予我全部的名称中含有 “grid” 的软件包，从这里，我可以得到准确的程序名称。
```
apt list --installed | grep grid
WARNING: apt does not have a stable CLI interface. Use with caution in scripts.
appgrid/now 0.298 all [installed,local]
```
正如你所看到的，一个名称为 “appgrid” 的软件包已经安装。现在，你可以在 `apt remove` 命令中使用这个程序名称。
#### 方法2: 使用 dpkg 命令移除 deb 软件包
你可以使用 `dpkg` 来找到已安装程序的名称：
```
dpkg -l | grep grid
```
该输出将给予所有的名称中有 “grid” 的软件包。
```
dpkg -l | grep grid
ii appgrid 0.298 all Discover and install apps for Ubuntu
```
在上面的命令输出中的 `ii` 意味着软件包已经被正确地安装。
现在，你有了程序名称，你可以使用 `dpkg` 命令来移除它：
```
dpkg -r program_name
```
**提示：更新 deb 软件包**
一些 deb 软件包 （像 Chrome）通过系统更新来提供其更新，但是对于大多数的其它的程序，你将不得不先移除已存在的程序，并在接下来安装更新的版本。
我希望这篇初学者指南能够帮助你在 Ubuntu 上安装 deb 软件包。我添加了移除部分，以便你可以更好地控制你所安装的程序。
---
via: <https://itsfoss.com/install-deb-files-ubuntu>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[robsean](https://github.com/robsean) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Fedora Linux 上安装 RPM 文件 | Abhishek Prakash | https://itsfoss.com/install-rpm-files-fedora/ | 这篇初学者文章介绍如何在 Fedora 和 Red Hat Linux 上安装 RPM 软件包。它也随后向你展示如何移除这些 RPM 软件包。 | /data/attachment/album/202012/26/182851bxi1lstdz13siuif.jpg.thumb.jpg | /data/attachment/album/202012/26/182851bxi1lstdz13siuif.jpg | true | false | true | lujun9972 | robsean | wxy | false | [
"RPM"
] | 技术 | {
"viewnum": 5512,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 这篇初学者文章介绍如何在 Fedora 和 Red Hat Linux 上安装 RPM 软件包。它也随后向你展示如何移除这些 RPM 软件包。 | 2020-12-26T18:29:04 | 2020-12-26T18:29:04 | 12,958 | /article-12958-1.html |
>
> 这篇初学者文章介绍如何在 Fedora 和 Red Hat Linux 上安装 RPM 软件包。它也随后向你展示如何移除这些 RPM 软件包。
>
>
>
当你开始使用 Red Hat 系的 Fedora Linux 时，你早晚会偶然发现 .rpm 文件。就像在 Windows 中的 .exe 文件，以及在 Ubuntu 和 Debian 中的 .deb 文件一样，一个 rpm 文件能够使你在 [Fedora](https://getfedora.org/) 上快速安装一个软件。
你可以从软件中心中找到并安装大量的软件，特别是 [如果你在 Fedora 中启用附加的存储库的话](https://itsfoss.com/fedora-third-party-repos/)。但是有时你会在它们的网站上找到可用的 RPM 格式的软件包。
就像在 Windows 中的 .exe 文件一样，你可以通过 **下载 .rpm 文件并双击它来安装**。不用担心，我将向你展示详细的步骤。
### 在 Fedora 和 Red Hat Linux 上安装 RPM 文件
我将向你展示安装 RPM 文件的三个方法：
* [使用软件中心安装 RPM 文件](file:///Users/xingyuwang/develop/TranslateProject-wxy/translated/tech/tmp.TvkJtlRJ6T#gui-method)（GUI 方法）
* [使用 DNF 命令安装 RPM 文件](file:///Users/xingyuwang/develop/TranslateProject-wxy/translated/tech/tmp.TvkJtlRJ6T#use-dnf)（CLI 方法）
* [使用 Yum 命令安装 RPM 文件](file:///Users/xingyuwang/develop/TranslateProject-wxy/translated/tech/tmp.TvkJtlRJ6T#use-yum)（Red Hat 的 CLI 方法）
#### 方法 1: 使用软件中心
在 Fedora 中使用默认的软件中心是最简单的方法。它真地很简单。转到你下载的 .rpm 文件的文件夹位置。它通常在 “Downloads” 文件夹。
只需要 **双击 RPM 文件，它将会在软件中心中打开**。
或者，你可以在 RPM 文件上右键单击并选择通过软件中心来安装它。
当它在软件中心打开时，你应该会看到“安装”选项。只需要点击“安装”按钮并在提示时输入你的账号密码。
它很简单，对吗？
#### 方法 2: 使用 DNF 命令来安装 RPM 文件
这是命令行方法。Fedora 使用新的 `dnf` [软件包管理器](https://itsfoss.com/package-manager/) ，你也可以使用它来安装下载的 RPM 文件。
打开一个终端并切换到你下载 RPM 文件的目录下。你也可以通过到 RPM 文件的路径。像这样使用 `dnf` 命令：
```
sudo dnf install rpm_file_name
```
这是一个我 [在 Fedora 上使用 dnf 命令安装 Google Chrome](https://itsfoss.com/install-google-chrome-fedora/) 屏幕截图：
#### 方法 3: 在 Red Hat 中使用 Yum 命令安装 RPM 文件
不像 Fedora ，Red Hat 仍然使用很好的旧式的 Yum 软件包管理器。在这里你还不能找到 `dnf` 命令。
这个过程与 `dnf` 命令相同。转到 RPM 文件所在的目录或提供它的路径。
```
sudo yum install path_to_RPM_file
```
就是这样。没有一点异常花哨的东西。
### 如何移除 RPM 软件包
移除一个 RPM 软件包也不是一个什么大的问题。并且，你不需要原始的用来安装程序的 rpm 文件。
你可以在软件中心中找到已安装的软件包，并从其中移除应用程序。
或者，你可以使用带有 `remove` 选项的 `dnf` 或 `yum` 命令。
使用 `dnf` ，使用这个命令：
```
sudo dnf remove rpm_package_name
```
使用 `yum` ，使用这个命令：
```
sudo yum remove rpm_package_name
```
你可能不记得准确的软件包名称，没有关系。你可以做的是输入软件包的前几个字母，然后敲击 `tab` 按键。这是假设你已经启用 `tab` 按键补全，通常是这样的。
这就是你需要做的全部。相当简单，对吧？作为一个初学者，你可能会为这样一个简单的任务而挣扎，我希望像这样的快速教程会让你对 Fedora 更自信一些。
---
via: <https://itsfoss.com/install-rpm-files-fedora/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[robsean](https://github.com/robsean) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
初次登录 Linux 服务器马上要做的 9 件事 | Gaurav Kamathe | https://opensource.com/article/20/12/linux-server | 在将新配置的服务器投入工作之前，请确保你知道你正在使用什么。 | /data/attachment/album/202012/27/112042zuz1lpudkypeppeu.jpg.thumb.jpg | /data/attachment/album/202012/27/112042zuz1lpudkypeppeu.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Linux"
] | 系统运维 | {
"viewnum": 8979,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "223.223.188.146",
"message": "很实用，虽然有些命令如lshw没有找。马克<br />\r\n（另外本文是基于红帽系列linux系统的，作者应该说明一下）",
"username": "Mr.Wang [Firefox 84.0|Mac 10.15]",
"date": "2020-12-29T11:11:50"
}
] | [] | 在将新配置的服务器投入工作之前，请确保你知道你正在使用什么。 | 2020-12-27T11:21:06 | 2020-12-27T11:21:06 | 12,959 | /article-12959-1.html |
>
> 在将新配置的服务器投入工作之前，请确保你知道你正在使用什么。
>
>
>
当我在 Linux 上测试软件时（这是我工作中的一个常规部分），我需要使用多台运行 Linux 的不同架构的服务器。我整备机器，安装所需的软件包，运行我的测试，收集结果，并将机器返回到仓库中，以便其他人可以使用它进行测试。
由于我经常这样做（甚至一天多次），我初次登录 Linux 服务器的前 10 分钟内的工作已经成为每天的仪式。当我初次登录 Linux 服务器时，我会使用命令来收集我需要的信息来寻找某些东西。我将在本文中介绍我的过程，但请注意，在大多数情况下，我只给出命令名称，所以你需要确定这些命令的具体选项，以获得你需要的信息。阅读命令的手册页是一个很好的起点。
### 1、第一次接触
当我登录到一台服务器时，我做的第一件事就是检查它是否拥有我将要运行的测试所需的操作系统、内核和硬件架构。我经常会检查一台服务器已经运行了多久。虽然这对测试系统来说并不重要，因为它会被多次重启，但我还是发现这些信息很有帮助。
使用下面的命令来获取这些信息。我主要使用 Red Hat Linux 进行测试，所以如果你使用其他 Linux 发行版，请在文件名中使用 `*-release` 而不是 `redhat-release`：
```
cat /etc/redhat-release
uname -a
hostnamectl
uptime
```
### 2、有人登录在上面吗？
一旦我知道这台机器符合我的测试需求，我需要确保没有其他人同时登录该系统运行他们自己的测试。虽然考虑到整备系统会帮我处理好这个问题，这种可能性很小，但偶尔检查一下还是有好处的 —— 尤其是当我第一次登录服务器的时候。我还会检查是否有其他用户（除了 root）可以访问系统。
使用下面的命令来查找这些信息。最后一条命令是查找 `/etc/passwd` 文件中具有 shell 访问权限的用户；它会跳过文件中没有 shell 访问权限或 shell 设置为 `nologin` 的其他服务：
```
who
who -Hu
grep sh$ /etc/passwd
```
### 3、物理机还是虚拟机
现在我有了属于自己的机器，我需要确定它是一台物理机还是一台虚拟机（VM）。如果是我自己整备的这台机器，我可以确定这是我要求的东西。但是，如果你使用的是一台不是你自己整备的机器，你应该检查该机器是物理机还是虚拟机。
使用以下命令来识别这些信息。如果是物理系统，你会看到供应商的名称（如 HP、IBM 等）以及服务器的品牌和型号；而在虚拟机中，你应该看到 KVM、VirtualBox 等，这取决于创建虚拟机时使用了什么虚拟化软件：
```
dmidecode -s system-manufacturer
dmidecode -s system-product-name
lshw -c system | grep product | head -1
cat /sys/class/dmi/id/product_name
cat /sys/class/dmi/id/sys_vendor
```
### 4、硬件
因为我经常测试连接到 Linux 机器的硬件，所以我通常使用物理服务器，而不是虚拟机。在物理机器上，我的下一步是确定服务器的硬件能力 —— 例如，运行的是什么类型的 CPU，它有多少个核心，启用了哪些标志，以及有多少内存可用于运行测试。如果我正在运行网络测试，我会检查连接到服务器的以太网或其他网络设备的类型和容量。
使用以下命令来显示连接到 Linux 服务器的硬件。其中一些命令在新的操作系统版本中可能会被废弃，但你仍然可以从 yum 存储库中安装它们或切换到它们的等效新命令：
```
lscpu or cat /proc/cpuinfo
lsmem or cat /proc/meminfo
ifconfig -a
ethtool <devname>
lshw
lspci
dmidecode
```
### 5、已安装的软件
测试软件总是需要安装额外的依赖包、库等。然而，在安装任何东西之前，我都会检查已经安装了什么（包括是什么版本），以及配置了哪些存储库，这样我就知道软件来自哪里，并可以调试任何软件包安装问题。
使用下面的命令来确定安装了什么软件：
```
rpm -qa
rpm -qa | grep <pkgname>
rpm -qi <pkgname>
yum repolist
yum repoinfo
yum install <pkgname>
ls -l /etc/yum.repos.d/
```
### 6、运行的进程和服务
检查了安装的软件之后，自然就会检查系统上有哪些进程在运行。当在系统上运行性能测试时，这一点至关重要 —— 如果一个正在运行的进程、守护进程、测试软件等占用了大部分 CPU/RAM，那么在运行测试之前停止该进程是有意义的。这也可以检查测试所需的进程或守护进程是否已经启动并运行。例如，如果测试需要 `httpd` 运行，那么即使安装了软件包，启动守护进程的服务也可能没有运行。
使用以下命令来识别系统上正在运行的进程和已启用的服务：
```
pstree -pa 1
ps -ef
ps auxf
systemctl
```
### 7、网络连接
如今的机器网络化程度很高，它们需要与网络上的其他机器或服务进行通信。我会识别服务器上哪些端口是开放的，是否有到测试机器的任何网络连接，是否启用了防火墙，如果启用了，是否屏蔽了任何端口，以及机器与哪些 DNS 服务器对话。
使用以下命令来识别网络服务相关信息。如果一个过时的命令不可用，请从 yum 存储库中安装它或使用等效的新命令：
```
netstat -tulpn
netstat -anp
lsof -i
ss
iptables -L -n
cat /etc/resolv.conf
```
### 8、内核
在进行系统测试时，我发现了解内核相关的信息是很有帮助的，比如内核版本和加载了哪些内核模块。我还会列出任何[可调整的内核参数](https://www.oreilly.com/library/view/red-hat-enterprise/9781785283550/ch10s05.html)以及它们的设置，并检查启动运行中的内核时使用的选项。
使用以下命令来识别这些信息：
```
uname -r
cat /proc/cmdline
lsmod
modinfo <module>
sysctl -a
cat /boot/grub2/grub.cfg
```
### 9、日志
现在，我已经对服务器有了很好的了解，包括安装了哪些软件，运行了哪些进程。还有一件事我无法逃避，那就是日志文件 —— 我需要知道在哪里可以查看不断更新的信息。
使用以下命令查看系统的日志：
```
dmesg
tail -f /var/log/messages
journalctl
```
### 接下来的步骤
虽然命令和实用程序会发生变化，但它们所显示的基本信息大致不变。在你专注于掌握哪些命令之前，你需要对你要寻找的信息以及它属于什么类别有一个宏观的看法。
由于 Linux 将大部分信息保存在文件中，这些命令基本上是从文件中读取信息，并以一种易于理解的方式呈现出来。下一步的好做法是找出每个命令用来获取信息显示的文件。一个提示：寻找这些信息的方法是 `strace` 命令。
---
via: <https://opensource.com/article/20/12/linux-server>
作者：[Gaurav Kamathe](https://opensource.com/users/gkamathe) 选题：[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/) 荣誉推出
|
了解如何使用 Norka 编辑器阅读文本 | Seth Kenlon | https://opensource.com/article/20/12/norka | 这是一个素颜朝天的文本编辑器，旨在让你的写作能被更好地阅读和理解。 | /data/attachment/album/202012/28/003505f3h3pppkg7enpxi9.jpg.thumb.jpg | /data/attachment/album/202012/28/003505f3h3pppkg7enpxi9.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"编辑器"
] | 分享 | {
"viewnum": 2868,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12955,
"displayorder": 0
},
{
"raid": 12964,
"displayorder": 0
}
] | 这是一个素颜朝天的文本编辑器，旨在让你的写作能被更好地阅读和理解。 | 2020-12-28T00:35:38 | 2020-12-28T00:35:38 | 12,961 | /article-12961-1.html |
>
> 这是一个素颜朝天的文本编辑器，旨在让你的写作能被更好地阅读和理解。
>
>
>
有些文本编辑器是为编程而设计的，有些是为专门的文本格式而设计的，有些是为文档设计而设计的。Norka 文本编辑器是为阅读而设计的。创建一个为*阅读*而设计的文本编辑器似乎很奇怪，但实际上，如果你仔细想想，这是很有意义的。你的文字已经写了一次或三次，这取决于你个人对迭代的容忍度，但它的目的是为了在未来几年内被阅读。Norka 让你轻松地专注于你的文字如何被阅读。
### 安装
Norka 文本编辑器是 MIT 授权的，可以[作为 Flatpak 包安装在 Linux上](https://flathub.org/apps/details/com.github.tenderowl.norka)。它是开源的，所以如果你想尝试在不同的平台上安装它，你可以[克隆它的 Github 仓库](https://github.com/TenderOwl/Norka)。
### Norka 的界面
Norka 的界面很简单。一个回到 Norka 文档集的按钮，一个导出按钮和一个偏好菜单。窗口的其余部分是供你写文字的空白空间，在右下角，有一个阅读时间计算器来帮助你了解读者可能需要多长时间才能看完你写的东西。
这几乎就是 Norka 的全部内容。没有分页符或行号，没有代码折叠或正则搜索。这是一个用于文字书写的编辑器，而不设置文档样式或跟踪复杂的数据模式。
当然，它还有一些额外的功能。如预期那样，可以使用 `Ctrl+C` 和 `Ctrl+V` 复制和粘贴。你可以用 `Ctrl+Z` 撤销，用 `Ctrl+F` 查找。你甚至可以用 `Ctrl+:` 插入表情符号。
#### 样式文本
虽然 Norka 绝对没有兴趣帮你设计，比如说，一本小册子或传单，但它确实有一些能力来指示你想要的文本样式。它通过 [Markdown](https://opensource.com/article/19/9/introduction-markdown) 来实现这一点，这是一个简单的纯文本书写的约定，但用特殊的符号来指示文本应该如何在 HTML、EPUB 或 PDF 或任何你的目标格式中呈现。
在大多数编辑器中，你必须知道 Markdown 才能使用 Markdown，但 Norka 翻译了常见的文字处理器键盘快捷键来为你生成 Markdown。例如，要使一个单词加粗，你可以按 `Ctrl+B`，它会在光标的两边插入四个星号。当你输入下一个单词时，它的两边都会有两个星号，这就是 Markdown 对粗体（默认为粗体）文本的标记。你可以在 Norka 窗口右上角的汉堡样式的菜单中查看所有的 Markdown 快捷方式。
#### 保存和导出
你可以把 Norka 想象成一个笔记本。你在 Norka 中打开的所有文档都会保留在 Norka 的内部数据库中，所有的文档都会默认自动保存。要在 Norka 外使用文件，你可以在打开的文件中点击右上角的**共享**按钮。另外，你也可以在 Norka 的文件视图中右击任何文件，选择**导出**。你可以将文档导出（或**共享**，Norka 可互换使用这两个术语）为**文本**、**HTML** 或 **Markdown**。
### 尝试 Norka
Norka 便于尝试，也易于使用。它通过保持界面简单，几乎到了受限的程度，帮助你专注于写作。但限制有时也是一种强大的创意工具。
Norka 可能不是你进行大量修改或文本处理的最佳选择。它没有让人激动的功能，比如大小写转换、集成 `sed` 命令、字符交换等等。它是一个为读者服务的文本编辑器。如果你觉得有用，那么你可能正是 Norka 正在寻找的受众。
感谢你花 2 分 39 秒阅读本文！
---
via: <https://opensource.com/article/20/12/norka>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
通过编写互动游戏学习 Bash | Jim Hall | https://opensource.com/article/20/12/learn-bash | 编程一个简单的游戏是练习一门新语言并与其他你掌握的语言进行比较的好方法。 | /data/attachment/album/202012/28/010432yq3vgsqtiol9zzi6.jpg.thumb.jpg | /data/attachment/album/202012/28/010432yq3vgsqtiol9zzi6.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Bash",
"游戏"
] | 软件开发 | {
"viewnum": 4964,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "211.138.116.72",
"message": "请教一下 ， 为什么要使用 0$guess 这样的形式？ 直接用 $guess 不行么？",
"username": "来自浙江杭州的 Firefox 78.0|Windows 10 用户",
"date": "2020-12-28T08:24:05"
},
{
"postip": "150.242.169.84",
"message": "可能是为了预防用户输入空值",
"username": "来自150.242.169.84的 Chrome 81.0|Windows 7 用户",
"date": "2020-12-29T11:15:31"
}
] | [
{
"raid": 12973,
"displayorder": 0
}
] | 编程一个简单的游戏是练习一门新语言并与其他你掌握的语言进行比较的好方法。 | 2020-12-28T01:04:43 | 2020-12-28T01:04:43 | 12,962 | /article-12962-1.html |
>
> 编程一个简单的游戏是练习一门新语言并与其他你掌握的语言进行比较的好方法。
>
>
>
学习一门新的编程语言是很有趣的。每当我尝试学习一门新的语言时，我都会专注于定义变量、编写语句和评估表达式。一旦我对这些概念有了大致的了解，我通常可以自己弄清楚其余的概念。大多数编程语言都有一些相似之处，所以一旦你了解了一种编程语言，学习下一种编程语言就是要弄清楚其独特的细节，认识到其中的差异。
为了帮助我练习一种新的编程语言，我喜欢写一些测试程序。我经常写的一个示例程序是一个简单的“猜数字”程序，电脑在 1 到 100 之间选一个数字，让我猜这个数字。程序会一直循环，直到我猜对为止。
“猜数字”程序锻炼了编程语言中的几个概念：如何给变量赋值，如何写语句，如何进行条件判断和循环。对于学习一门新的编程语言来说，这是一个很好的实践实验。
### 用 Bash 猜数字
[Bash](https://en.wikipedia.org/wiki/Bash_(Unix_shell)) 是大多数 Linux 系统的标准 shell。除了提供丰富的命令行用户界面外，Bash 还以*脚本*的形式支持完整的编程语言。
如果你对 Bash 不熟悉，我推荐你看这些介绍：
* [什么是 Bash？](https://opensource.com/resources/what-bash)。
* [开始使用 Bash 编程](https://opensource.com/article/20/4/bash-programming-guide)
* [系统管理员的 Bash 脚本入门](https://opensource.com/article/20/4/bash-sysadmins-ebook)
* [如何在 Bash 中编写函数](https://opensource.com/article/20/6/bash-functions)
* [阅读更多关于 Bash 的信息](https://opensource.com/tags/bash)
你可以通过编写一个 Bash 版本的“猜数字”游戏来探索它。这是我的实现：
```
#!/bin/bash
number=$(( $RANDOM % 100 + 1 ))
echo "Guess a number between 1 and 100"
guess=0
while [ "0$guess" -ne $number ] ; do
read guess
[ "0$guess" -lt $number ] && echo "Too low"
[ "0$guess" -gt $number ] && echo "Too high"
done
echo "That's right!"
exit 0
```
### 拆解这个脚本
脚本中的第一行，`#!/bin/bash` 告诉 Linux 使用 Bash shell 来运行这个脚本。每个脚本都以 `#!` 字符对（LCTT 译注：释伴）开始，这表示它是一个 shell 脚本。紧跟在`#!` 后面的是要运行的 shell。在本例中，`/bin/bash` 是指 Bash shell。
要给一个变量赋值，在变量名后面列出 `=` 号。例如，语句 `guess=0` 给 `guess` 变量分配一个零值。
你也可以使用 `read` 语句提示用户输入一个值。如果你写了 `read guess` 语句，Bash 会等待用户输入一些文本，然后把这个值存储在 `guess` 变量中。
要引用一个变量的值，在变量名前使用 `$`。所以, 在 `guess` 变量中存储了一个值后, 你可以使用 `$guess` 来检索它。
你可以使用任何你喜欢的变量名称，但是 Bash 为自己保留了一些特殊的变量名称。一个特殊的变量是 `RANDOM`，每次引用它都会产生一个很大的随机数。
如果你想在存储一个值的同时执行一个操作，你需要用特殊的括号把语句括起来。这将告诉 Bash 先执行该语句，而 `=` 则将结果值存储在变量中。要评估一个数学表达式，使用 `$(())` 围在你的语句上。双括号表示一个*算术表达式*。在我的例子中，`number=$(( $RANDOM % 100 + 1 ))` 评估表达式 `$RANDOM % 100 + 1`，然后将值存储在 `number` 变量中。
标准的算术运算符，如 `+`（加）、`-`（减）、`*`（乘）、`/`（除）和 `%`（模）都适用。
这意味着语句 `number=$(( $RANDOM % 100 + 1 ))` 产生一个 1 到 100 之间的随机数。模数运算符（`%`）返回两个数相除后的余数。在这种情况下，Bash 将一个随机数除以 100，剩下的余数范围是 0 到 99，通过在这个值上加 1，你可以得到一个介于 1 和 100 之间的随机数。
Bash 支持像循环这样的*条件表达式*和*流程控制*。在“猜数字”的游戏中，只要 `guess` 中的值不等于 `number`，Bash 就会继续循环。如果猜的数小于随机数，Bash 就会打印“太低”，如果猜的数大于数字，Bash 就会打印“太高”。
### 它是如何工作的
现在你已经写好了你的 Bash 脚本，你可以运行它来玩“猜数字”游戏。一直猜，直到你找到正确的数字：
```
Guess a number between 1 and 100
50
Too high
30
Too high
20
Too high
10
Too low
15
Too high
13
Too low
14
That's right!
```
每次运行这个脚本，Bash 都会随机选择一个不同的数字。
这个“猜数字”游戏是学习新的编程语言时的一个很好的入门程序，因为它以一种很直接的方式锻炼了几个常见的编程概念。通过在不同的编程语言中实现这个简单的游戏，你可以展示一些核心概念，并比较每种语言的细节。
你有喜欢的编程语言吗？你会如何用它来写“猜数字”游戏呢？请关注本系列文章，看看你可能感兴趣的其他编程语言的例子。
---
via: <https://opensource.com/article/20/12/learn-bash>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 选题：[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/) 荣誉推出
|
如何使用这个 KDE Plasma 文本编辑器？ | Seth Kenlon | https://opensource.com/article/20/12/kwrite-kde-plasma | 作为流行的 KDE Plasma 桌面的一部分，KWrite 在一个简单易用的界面中隐藏了大量有用的功能。 | /data/attachment/album/202012/29/010557o53b649j66a1snjv.jpg.thumb.jpg | /data/attachment/album/202012/29/010557o53b649j66a1snjv.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"KDE",
"KWrite",
"编辑器"
] | 分享 | {
"viewnum": 3636,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "1.192.90.183",
"message": "轻量版的 kate ？不过感觉标签页功能还是需要的",
"username": "来自河南郑州的 Firefox 84.0|GNU/Linux 用户",
"date": "2020-12-29T10:28:31"
},
{
"postip": "117.182.23.191",
"message": "有个KWrite，又有个kate",
"username": "来自117.182.23.191的 Chrome 87.0|Windows 10 用户",
"date": "2021-01-01T10:35:01"
},
{
"postip": "123.161.114.30",
"message": "kate慢死了",
"username": "来自河南南阳的 Chrome Mobile 94.0|Android 11 用户",
"date": "2021-10-15T16:59:12"
}
] | [
{
"raid": 12961,
"displayorder": 0
},
{
"raid": 12978,
"displayorder": 0
}
] | 作为流行的 KDE Plasma 桌面的一部分，KWrite 在一个简单易用的界面中隐藏了大量有用的功能。 | 2020-12-29T01:06:25 | 2020-12-29T01:06:25 | 12,964 | /article-12964-1.html |
>
> 作为流行的 KDE Plasma 桌面的一部分，KWrite 在一个简单易用的界面中隐藏了大量有用的功能。
>
>
>
KWrite 是一款适用于 KDE Plasma 桌面的文本编辑器。它的目的是成为一个通用的应用，任何人都可以在他们需要快速做笔记、写一篇学校论文、做一些编程，和/或任何其他你能想到的文本编辑器能做的事时用上它。它使用 [Kate 编辑器](https://opensource.com/article/20/12/kate-text-editor)的组件来创建一个简单的界面，但它利用这些相同的组件来提供了大量有用的功能。
### 安装
KWrite 不可用于所有环境，它是 [KDE Plasma 桌面](https://opensource.com/article/19/12/linux-kde-plasma)的一个组件，所以如果你正在运行 Plasma，那么你已经有了 KWrite。
如果你没有运行 Plasma，那么你可以安装 Plasma，这样你可以将它和 KWrite 一起开始使用，或者根据需要使用 KWrite。然而，它是作为 Plasma 桌面的默认文本编辑器，所以如果你真的想把它作为一个独立应用使用，那么安装 Kate 可能更容易。
### 使用 KWrite
当你启动 KWrite 时，你会看到期望的编辑器的样子：一大块用于输入的区域，顶部有一个菜单栏和工具栏，底部有一个状态栏。这就是你在开始之前需要了解的全部内容。KWrite 是一个直观的应用，工具栏按钮用于重要的动作，如打开和保存文件，简单的菜单系统用于更高级的编辑任务。
KWrite 的许多功能都是潜在的，不需要你自己去激活它们就会发生。例如，如果你打开一个用 HTML 编写的文件，那么 KWrite 会高亮显示关键字（如 `class` 和 `id`）和识别代码标签（如 `<p>` 或 `<div>`），并将它们与自然语言的单词区别对待。当你加载一个用 Python 编写的文件时，也会发生同样的情况，而对于主要用自然语言编写的文件，则不会发生任何事情。
当然，你不必只选择 HTML、Python 和你的母语。KWrite 支持很多语言和格式（对于很多语言和格式，它甚至有自动完成选项）。
对于那些想要除了自动加载功能之外更多功能的用户，在编辑、视图和工具菜单中都有一些选项。例如，你可以激活动态的拼写检查、运行脚本、调出命令行、注释或取消注释一行、调整缩进、显示行号等等。
当从终端启动 KWrite 时，也有一些有趣的选项。例如，如果你知道要到文件中的哪一行，你可以用行号参数启动 KWrite：
```
$ kwrite --line 101 example.txt
```
你也可以使用 `--stdin` （或简写 `-i`）选项方便地将命令的输出通过管道到 KWrite。例如，这个命令下载 [example.com](http://example.com) 的首页，并在一个新的 KWrite 窗口中显示 HTML：
```
$ curl http://example.com | kwrite --stdin
```
### 尝试 KWrite
我一直觉得 KDE 的优势之一就是它的复杂性很灵活。如果你想要一个简单的桌面，你基本上可以选择忽略任何你不想要的功能。KWrite 就是这种灵活性也适用于开发人员的一个例子。由于 Kate 具有许多功能，所以开发者有能够重用这些功能的一个子集来创建一个更干净、更专注的应用版本。
KWrite 是一个单文档编辑器。它没有标签，也没有任何“项目”的意识。它的目的是为那些想一次只处理一个文档的人准备的，他们希望基本的功能在默认情况下是激活的，在需要的时候可以选择强大的编辑工具。安装优秀的 Plasma 桌面，今天就来试试吧！
---
via: <https://opensource.com/article/20/12/kwrite-kde-plasma>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linux 内核如何处理中断 | Stephan Avenwedde | https://opensource.com/article/20/10/linux-kernel-interrupts | 中断是计算机处理数据的关键部分。 | /data/attachment/album/202012/29/063805o5taf82ftgz85e22.jpg.thumb.jpg | /data/attachment/album/202012/29/063805o5taf82ftgz85e22.jpg | true | false | true | lujun9972 | mengxinayan | wxy | false | [
"中断",
"CPU"
] | 技术 | {
"viewnum": 6003,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 中断是计算机处理数据的关键部分。 | 2020-12-29T06:38:25 | 2020-12-29T06:38:25 | 12,965 | /article-12965-1.html |
>
> 中断是计算机处理数据的关键部分。
>
>
>
中断是现代 CPU 工作方式中重要的部分。例如：当你每次在键盘上按下一个按键后，CPU 会被中断以使得 PC 读取用户键盘的输入。这个过程发生得相当快，以致于在使用体验上你不会感到任何变化或损害。
此外，键盘并不是导致中断的唯一组件。一般来说，有三种类型的事件会导致 CPU 发生中断：硬件中断、软件中断和异常。在具体介绍不同类型的中断前，我需要先定义一些术语。
### 定义
<ruby> 中断请求 <rt> interrupt request </rt></ruby>（IRQ）是由<ruby> 可编程的中断控制器 <rt> programmable interrupt controlle </rt></ruby>（PIC）发起的，其目的是为了中断 CPU 和执行<ruby> 中断服务程序 <rt> interrupt service routine </rt></ruby>（ISR）。中断服务程序（ISR）是一个小的程序，用来处理具体的数据，其具体的处理方式依赖于造成中断请求（IRQ）的原因。之前正在运行的进程在中断服务程序（ISR）运行结束前都会被中断。
在过去，中断请求由单独的芯片处理（中断控制器芯片 PIC），I/O 设备直接与中断控制器（PIC）相连。中断控制器（PIC）管理着多种硬件的中断请求（IRQ），并且可以直接与 CPU 通信。当一个中断请求（IRQ）产生后，中断控制器（PIC）向 CPU 写入数据，并且触发中断请求引脚（INTR）。
现如今，中断请求（IRQ）由 CPU 中的<ruby> 高级可编程中断控制器 <rt> advanced programmable interrupt controller </rt></ruby>（APIC）部分来处理。每个核中都拥有属于自己的高级可编程中断控制器。
### 中断的类型
正如我前文中提到的，中断可以根据其来源分为三种类型。
#### 硬件中断
当一个硬件设备想要告诉 CPU 某一需要处理的数据已经准备好后（例如：当键盘被按下或者一个数据包到了网络接口处），它将会发送一个中断请求（IRQ）来告诉 CPU 数据是可用的。接下来会调用在内核启动时设备驱动注册的对应的中断服务程序（ISR）。
#### 软件中断
当你在播放一个视频时，音频和视频是同步播放是相当重要的，这样音乐的速度才不会变化。这是由软件中断实现的，由精确的计时器系统（称为 [jiffies](https://elinux.org/Kernel_Timer_Systems)）重复发起的。这个计时器会使得你的音乐播放器同步。软件中断也可以被特殊的指令所调用，来读取或写入数据到硬件设备。
当系统需要实时性时（例如在工业应用中），软件中断会变得重要。你可以在 Linux 基金会的文章中找到更多相关信息：[面向嵌入式开发者的实时 Linux 介绍](https://www.linuxfoundation.org/blog/2013/03/intro-to-real-time-linux-for-embedded-developers/)。
#### 异常
<ruby> 异常 <rt> exception </rt></ruby>是你可能之前就知道的中断类型。当 CPU 执行一些将会导致除零或缺页错误的指令时，任何其他运行中的程序都会被中断。在这种情况下，你会被一个弹窗提醒，或在控制台输出中看到\*\*<ruby> 段错误 <rt> segmentation fault </rt></ruby>（<ruby> 核心已转储 <rt> core dumped </rt></ruby>）\*\*。但并不是所有异常都是由指令错误引起的。
异常可以进一步分为<ruby> 错误 <rt> Fault </rt></ruby>、<ruby> 陷阱 <rt> Trap </rt></ruby>和<ruby> 终止 <rt> Abort </rt></ruby>。
* **错误**：错误是系统可以纠正的异常。例如当一个进程尝试访问某个已经被换出到硬盘的页时。当请求的地址在进程的地址空间中，并且满足访问权限时，如果页不在内存（RAM）中，将会产生一个中断请求（IRQ），并开始启用**缺页异常处理程序**把所需的页加载到内存中。如果操作成功执行，程序将继续运行。
* **陷阱**：陷阱主要用在调试中。如果你在某个程序中设置了一个断点，你就插入了一条可以触发陷阱执行的特殊指令。陷阱可以触发上下文切换来允许你的调试器读取和展示局部变量的值。之后程序可以继续运行。陷阱同样也是运行系统调用的方式（如杀死一个进程）
* **终止**：终止是由系统表中的硬件错误或值不一致而导致的。终止不会报告造成异常的指令的所在位置。这是最严重的中断，终止将会调用系统的**终止异常处理程序**来结束造成异常的进程。
### 动手实践
中断请求按照高级可编程中断控制器（APIC）中的优先级高低排序（0是最高优先级）。前 32 个中断（0~31）是由 CPU 指定的固定序列。你可以在 [OsDev 异常](https://wiki.osdev.org/Exceptions) 页面找到关于它们的概述。随后的中断请求可以以不同的方式进行分配。<ruby> 中断描述表 <rt> interrupt descriptor table </rt></ruby>（IDT）中记录了中断请求（IRQ）和中断服务程序（ISR）的对应关系。Linux 中定义了从 0 到 256 的 IRQ 向量。
为了打印出在你的系统中已注册的中断，打开一个终端并输入：
```
cat /proc/interrupts
```
你应该会看到类似如下图的结果：
*内核版本为5.6.6中注册的中断 (Stephan Avenwedde, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/))*
从左到右各列的含义依次为：中断向量号、每个 CPU（0~n）中断发生次数、硬件来源、硬件源通道信息、以及造成中断请求的设备名。
在表的末尾，有一些非数字的中断。它们是特定于体系结构的中断，如<ruby> 本地计时器中断 <rt> local timer interrupt </rt></ruby>（LOC）的中断请求（IRQ）号为 236。其中一些在 Linux 内核源树中的[Linux IRQ 向量布局](https://github.com/torvalds/linux/blob/master/arch/x86/include/asm/irq_vectors.h)中指定。
*特定于体系结构的中断 (Stephan Avenwedde, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/))*
如果要实时获取该表，请运行如下命令：
```
watch -n1 "cat /proc/interrupts"
```
### 总结
正确的中断请求（IRQ）处理对于硬件、驱动和软件的正常交互是必要的。幸运地是，Linux 内核很好地完成了它，一个 PC 的普通用户几乎不会注意到内核的整个中断处理过程。
中断相当复杂，本文仅仅是一个关于中断的概述。如果想要深入了解该主题可以阅读 [Linux Inside 电子书](https://0xax.gitbooks.io/linux-insides/content/Interrupts/)（CC BY-NC-SA 4.0）和 [Linux 内核教程](https://linux-kernel-labs.github.io/refs/heads/master/lectures/interrupts.html#) 仓库。
---
via: <https://opensource.com/article/20/10/linux-kernel-interrupts>
作者：[Stephan Avenwedde](https://opensource.com/users/hansic99) 选题：[lujun9972](https://github.com/lujun9972) 译者：[萌新阿岩](https://github.com/mengxinayan) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
2020 年企业采用开源的 4 个原因 | Chris Grams | https://opensource.com/article/20/12/open-source-survey | 根据 Tidelift 的第三次开源管理调查，根据公司规模，出现了差异。 | /data/attachment/album/202012/30/062849dn8amhiait1cvnne.jpg.thumb.jpg | /data/attachment/album/202012/30/062849dn8amhiait1cvnne.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"开源"
] | 观点 | {
"viewnum": 2800,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
} | [] | [] | 根据 Tidelift 的第三次开源管理调查，根据公司规模，出现了差异。 | 2020-12-30T06:29:00 | 2020-12-30T06:29:00 | 12,967 | /article-12967-1.html |
>
> 根据 Tidelift 的第三次开源管理调查，根据公司规模，出现了差异。
>
>
>
Tidelift 的[第三次开源管理调查](https://www.tidelift.com/subscription/2020-managed-open-source-survey)发现，企业在大流行期间正在转向开源，44% 的组织报告他们将增加使用开源进行应用开发。
我们以前见过类似现象。在以前的经济衰退中，组织转向开源[以节省成本](https://blog.tidelift.com/the-third-wave-of-open-source-migration?utm_source=opensource&utm_medium=referral&utm_campaign=2020-survey)，并因[其它一些转型收益](https://blog.tidelift.com/theres-one-thing-stopping-developers-from-using-open-source-even-more?utm_source=opensource&utm_medium=referral&utm_campaign=2020-survey)而留下来。我们想了解哪些长期收益对不同规模的组织最有帮助。以下是我们发现的摘要。
**开源正在推动成本和时间的节约，同时提高效率。**68% 的组织提到的一个关键驱动力是节约资金和开发时间，因为使用开源减少了开发人员从头开始编写新代码的时间。近半数（48%）报告称，它提高了应用开发和维护效率。拥有超过 1000 名员工的组织更有可能将此作为鼓励使用更多开源的原因（61%，而少于 1000 人的组织为 41%）。
*（Tidelift ©2020）*
**在组织使用更多的开源的原因中，消除供应商锁定是一个重要原因。** 我们发现 40％ 的受访者将这视为主要原因。用开源软件取代昂贵的专有软件，可以确保组织更加灵活，避免对供应商的依赖。同样，规模较大的组织也倾向于这个原因。在拥有 1000 名以上员工的组织中，有 50% 的组织将此作为主要优势。
**增加开发人员的满意度是使用更多开源的另一个原因，有 31% 的组织提到了这一点。** 随着企业对人才的激烈竞争，他们了解确保开发人员在工作中和使用的工具中感到快乐的价值。调查发现，开发人员使用的前三种语言是 JavaScript（78%）、Python（52%）和 Java（41%）。
**此外，随着开源使用量的增加，83% 的组织继续对其贡献，近一半的组织制定了管理贡献的政策。** 这些政策包括：在工作时间对组织使用但不赞助或管理的项目的贡献、对他们赞助或管理的项目的贡献、在个人时间对与工作无关的（个人）项目的贡献、以及在工作时间对与工作无关的（个人）项目的贡献。
虽然向开源的长期迁移仍在继续，但很明显，COVID-19 的影响可能正在加速这一进程，组织继续从使用和贡献中获得更深层次的价值。
更多信息，请查看 [2020 年开源管理调查](https://www.tidelift.com/subscription/2020-managed-open-source-survey)的所有调查结果。
---
via: <https://opensource.com/article/20/12/open-source-survey>
作者：[Chris Grams](https://opensource.com/users/cgrams) 选题：[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/) 荣誉推出
|
Font Manager：一个简单的 GTK+ 桌面的开源应用 | Ankush Das | https://itsfoss.com/font-manager/ | 一个非常简单的字体管理器应用，让你专注于调整 Linux 系统上的字体。 | /data/attachment/album/202012/30/065754mx4363qxabe8y9z0.jpg.thumb.jpg | /data/attachment/album/202012/30/065754mx4363qxabe8y9z0.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"字体"
] | 分享 | {
"viewnum": 4389,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "221.232.69.131",
"message": "挺不错，gtk+简洁明了，也越来越成熟了。",
"username": "来自湖北武汉的 Chrome 87.0|Windows 10 用户",
"date": "2021-01-04T12:25:49"
}
] | [] | 一个非常简单的字体管理器应用，让你专注于调整 Linux 系统上的字体。 | 2020-12-30T06:58:02 | 2020-12-30T06:58:02 | 12,968 | /article-12968-1.html | 
>
> 一个非常简单的字体管理器应用，让你专注于调整 Linux 系统上的字体。
>
>
>
如果你是一个有经验的 Linux 用户，你可能会利用终端或 [调整工具](https://itsfoss.com/gnome-tweak-tool/)来管理你的 Linux 系统的字体。
老实说，不管 GNOME 调整工具有多有用，但是用来管理字体可能会不太够用。因此，一个单独的应用可以很好地帮助你管理字体。
### Font Manager：一个帮助管理字体的开源应用
Font Manager（这就是应用的字面名称）是一个专门帮助你管理字体的应用。
你可以获得字体族的详细信息、可用的变体，以及根据字体的高度、宽度、间距等进行过滤和调整的功能。考虑到它是一个简单的应用，因此你找不到很多功能，但是我将在下面简要介绍一些功能。
### Font Manager 的功能
* 可以添加字体
* 可以删除字体
* 根据字体族、供应商、间距、高度等因素轻松筛选字体
* 调整字体的缩放系数
* 调整字体的抗锯齿（软度/锐度）
* 添加字体源，以便在安装前进行预览
* 提供快速管理的键盘快捷键
* 开箱即用的谷歌字体集成
* 获取关于字体族中可用字符的详细信息、许可证、字体大小、供应商、文件类型、间距、宽度和样式
总的来说，你可以轻松安装或删除字体。但是，当你管理字体时，你会得到很多帮助，如上面的截图所示。
### 在 Linux 上安装 Font Manager
你有多种选择（取决于你使用的 Linux 发行版）进行安装。
如果你使用的是基于 Ubuntu 的发行版，你可以通过下面的命令轻松添加 PPA 来安装 Font Manager：
```
sudo add-apt-repository ppa:font-manager/staging
sudo apt update
sudo apt install font-manager
```
如果你不喜欢 [PPA](https://itsfoss.com/ppa-guide/)（我更喜欢这样安装），你也可以在任何 Linux 发行版上安装一个[可用的 Flatpak 包](https://flathub.org/apps/details/org.gnome.FontManager)。
你只需要在你的 Linux 系统上启用 Flatpak，然后在你的软件中心搜索它（如果它支持 Flatpak 集成的话），或者直接输入下面的命令安装它：
```
flatpak install flathub org.gnome.FontManager
```
如果你是 Arch 用户，你可以在 [AUR](https://itsfoss.com/aur-arch-linux/) 中找到[包](https://aur.archlinux.org/packages/font-manager/)。
更多的安装说明，你可以参考它的[官网](https://fontmanager.github.io/)和 [GitHub 页面](https://github.com/FontManager/font-manager)。
* [下载 Font Manager](https://fontmanager.github.io/)
### 总结
Font Manager 是一个简单的解决方案，适用于任何基于 GTK+ 的桌面环境。主要用于 GNOME，但你在其他桌面环境使用它。
你可以得到很多有用的信息，同时可以添加或删除字体，我想这显然是一个真正的字体管理器。
你对 Font Manager 有什么看法？在下面的评论中告诉我你的想法吧!
---
via: <https://itsfoss.com/font-manager/>
作者：[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/) 荣誉推出
|
20 分钟建立一个 Ansible 实验室 | Mike Calizo | https://opensource.com/article/20/12/ansible-lab | 建立一个支持学习和实验新软件的环境。 | /data/attachment/album/202012/31/112636h6ck5qd60d44t0mm.jpg.thumb.jpg | /data/attachment/album/202012/31/112636h6ck5qd60d44t0mm.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Ansible"
] | 技术 | {
"viewnum": 3963,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 建立一个支持学习和实验新软件的环境。 | 2020-12-31T11:27:21 | 2020-12-31T11:27:21 | 12,970 | /article-12970-1.html |
>
> 建立一个支持学习和实验新软件的环境。
>
>
>
能够构建和拆解公有云环境是非常有用的，但我们大多数人都不能轻松访问公有云。退而求其次的最好办法就是在本地机器上建立一个实验室，但即使在本地机器上运行也会带来性能、灵活性和其他挑战。大多数时候，本地机器上额外的工作负载会干扰我们日常的工作，它们当然也会影响你提供一个现成的环境来玩耍和实验新软件。
几年前，当我和我的团队开始学习 [Ansible](https://opensource.com/resources/what-ansible) 时，我们就遇到了这个挑战。我们找不到一个可以单独使用的环境，我们对这种情况的失望导致我们中的一些人停止了实验。我们知道需要找到一个解决方案。
我们花了很多时间研究各种方案，得出了一套工具，使我们的好奇心能够在我们完全控制的环境中学习。我们可以在本地机器上轮换和拆解实验室环境，而不需要访问内部实验室或公共云。
本文将解释如何在 20 分钟内以完全自动化的方式在本地机器上部署自己的实验室环境。
你可以在我的 [GitHub 仓库](https://github.com/mikecali/ansible-labs-101)中找到这个练习的所有代码。
### 工具和软件
本方案使用以下工具和软件：
* [Ansible](https://www.ansible.com/) 是我们选择的自动化工具，因为它易于使用，而且足够灵活，可以满足实验室的要求。
* [Vagrant](https://www.vagrantup.com/) 易于使用，用于构建和维护虚拟机。
* [VirtualBox](https://www.virtualbox.org/) 是一个托管管理程序，可以在 Windows 和 Linux 环境中使用。
* [Fedora v30+](https://getfedora.org/) 是我本地机器上的操作系统。
你必须进行以下设置才能建立环境：
* 一个互联网连接
* 在 BIOS 中启用虚拟化技术支持（以下是在我的联想笔记本上的[过程](https://support.lenovo.com/pt/en/solutions/ht500006)）
* Vagrant v2.2.9
* 最新版本的 Ansible
* 最新版本的 VirtualBox
* Fedora v30+ 宿主机操作系统
### 这个实验室环境有什么？
这个项目旨在部署一个带有 Ansible 引擎和多个 Linux 节点的 Ansible 主机，以及一些预加载和预配置的应用程序（httpd 和 MySQL）。它还启用了 [Cockpit](https://opensource.com/article/20/11/cockpit-server-management)，这样你就可以在测试过程中监控虚拟机（VM）的状态。使用预部署的应用程序的原因是为了提高效率（所以你不必花时间安装这些组件）。这样你就可以专注于创建角色和剧本，并针对上述工具部署的环境进行测试。
我们确定，对于我们的用例来说，最好的方案是多机 Vagrant 环境。Vagrant 文件创建了三个 CentOS 虚拟机，以模拟两个目标主机和一个 Ansible 控制机。
* Host1: 没有图形用户界面（GUI），安装 httpd 和 MySQL
* Host2: 没有 GUI，安装了 httpd 和 MySQL
* Ansible-host：没有 GUI，安装了 Ansible 引擎
### 启用多个管理程序
如果使用了多个管理程序，一些管理程序可能不允许你拉起虚拟机。要解决这个问题，请遵循以下步骤（基于 Vagrant 的[安装](https://www.vagrantup.com/docs/installation)说明）。
首先，找出管理程序的名称：
```
$ lsmod | grep kvm
kvm_intel 204800 6
kvm 593920 1 kvm_intel
irqbypass 16384 1 kvm
```
我感兴趣的是 `kvm_intel`，但你可能需要另一个（比如 `kvm_amd`）。
以 root 身份运行以下内容，将该管理程序列入黑名单：
```
$ echo 'blacklist kvm-intel' >> /etc/modprobe.d/blacklist.conf
```
重新启动你的机器并尝试再次运行 Vagrant。
### Vagrant 文件
```
cat Vagrantfile
```
```
# -*- mode: ruby -*-
# vi: set ft=ruby :
Vagrant.configure("2") do |config|
# Define VMs with static private IP addresses, vcpu, memory and vagrant-box.
boxes = [
{
:name => "web1.demo.com", ⇒ Host1 this is one of the target nodes
:box => "centos/8", ⇒ OS version
:ram => 1024, ⇒ Allocated memory
:vcpu => 1, ⇒ Allocated CPU
:ip => "192.168.29.2" ⇒ Allocated IP address of the node
},
{
:name => "web2.demo.com", ⇒ Host2 this is one of the target nodes
:box => "centos/8",
:ram => 1024,
:vcpu => 1,
:ip => "192.168.29.3"
},
{
:name => "ansible-host", ⇒ Ansible Host with Ansible Engine
:box => "centos/8",
:ram => 8048,
:vcpu => 1,
:ip => "192.168.29.4"
}
]
# Provision each of the VMs.
boxes.each do |opts|
config.vm.define opts[:name] do |config|
# Only Enable this if you are connecting to Proxy server
# config.proxy.http = "http://usernam:[email protected]:80"⇒ Needed if you have a proxy
# config.proxy.https = "http://usernam:[email protected]:80"
# config.proxy.no_proxy = "localhost,127.0.0.1"
config.vm.synced_folder ".", "/vagrant", id: "vagrant-root", disabled: true
config.ssh.insert_key = false
config.vm.box = opts[:box]
config.vm.hostname = opts[:name]
config.vm.provider :virtualbox do |v| ⇒ Defines the vagrant provider
v.memory = opts[:ram]
v.cpus = opts[:vcpu]
end
config.vm.network :private_network, ip: opts[:ip]
config.vm.provision :file do |file|
file.source = './keys/vagrant' ⇒ vagrant keys to allow access to the nodes
file.destination = '/tmp/vagrant' ⇒ the location to copy the vagrant key
end
config.vm.provision :shell, path: "bootstrap-node.sh" ⇒ script that copy hosts entry
config.vm.provision :ansible do |ansible| ⇒ declaration to run ansible playbook
ansible.verbose = "v"
ansible.playbook = "playbook.yml" ⇒ the playbook used to configure the hosts
end
end
end
end
```
这些是你需要注意的重要文件。
* `inventory-test.yaml`：连接到节点的清单文件
* `playbook.yaml`：Vagrant 供应者调用的用于配置节点的剧本文件
* `Vagrantfile'：Vagrant 用来部署环境的文件
* Vagrant 密钥文件：连接实验室环境中各节点的 Vagrant 密钥
你可以根据你的需要调整这些文件。Ansible 的灵活性使你有能力根据你的需要声明性地改变你的环境。
### 部署你的实验室环境
首先，克隆这个 [GitHub 仓库](https://github.com/mikecali/ansible-labs-101.git) 中的代码：
```
$ git clone https://github.com/mikecali/ansible-labs-101.git
Cloning into 'ansible-labs-101'...
remote: Enumerating objects: 15, done.
remote: Counting objects: 100% (15/15), done.
remote: Compressing objects: 100% (13/13), done.
remote: Total 15 (delta 2), reused 10 (delta 0), pack-reused 0
Unpacking objects: 100% (15/15), 6.82 KiB | 634.00 KiB/s, done.
```
接下来，将你的目录改为 `vagrant-session-2`，并查看其内容：
```
$ ls
Bootstrap-node.sh inventory keys playbook.yml README.md Vagrantfile
```
现在你已经拥有了实验室环境所需的所有工件和配置文件。要部署环境，请运行：
```
$ vagrant up
```
只要有一个像样的网络连接，只需要 20 分钟左右就可以得到一个运行环境：
```
$ vagrant up
Bringing machine 'web1.demo.com' up with 'virtualbox' provider...
Bringing machine 'web2.demo.com' up with 'virtualbox' provider...
Bringing machine 'ansible-host' up with 'virtualbox' provider...
==> web1.demo.com: Importing base box 'centos/8'...
==> web1.demo.com: Matching MAC address for NAT networking...
==> web1.demo.com: Checking if box 'centos/8' version '1905.1' is up to date...
==> web1.demo.com: Setting the name of the VM: ansible-labs_web1democom_1606434176593_70913
==> web1.demo.com: Clearing any previously set network interfaces...
==> web1.demo.com: Preparing network interfaces based on configuration...
web1.demo.com: Adapter 1: nat
web1.demo.com: Adapter 2: hostonly
==> web1.demo.com: Forwarding ports...
web1.demo.com: 22 (guest) => 2222 (host) (adapter 1)
==> web1.demo.com: Running 'pre-boot' VM customizations...
==> web1.demo.com: Booting VM...
==> web1.demo.com: Waiting for machine to boot. This may take a few minutes...
web1.demo.com: SSH address: 127.0.0.1:2222
web1.demo.com: SSH username: vagrant
web1.demo.com: SSH auth method: private key
[...]
```
一旦该剧本执行完成，你会看到这样的输出：
```
PLAY RECAP *********************************
Ansible-host : ok=20 changed=11 unreachable=0 failed=0 skipped=0 rescued=0 ignored=3
Real 18m14.288s
User 2m26.978s
Sys 0m26.849s
```
确认所有虚拟机都在运行：
```
$ vagrant status
Current machine states:
Web1.demo.com running (virtualbox)
Web2.demo.com running (virtualbox)
ansible-host running (virtualbox)
[...]
```
你可以通过登录其中一个虚拟机进一步调查。访问 `ansible-host`：
```
> vagrant ssh ansible-host
Activate the web console with: systemctl enable --now cockpit.socket
Last login: Thu Nov 26 12:21:23 2020 from 10.0.2.2
[vagrant@ansible-host ~] uptime
16:46:42 up 1:24, 1 user, load average: 0.00, 0.01, 0.04
```
最后，你可以使用 Ansible 模块来 ping 你创建的其他节点：
```
[vagrant@ansible-host]$ ansible -i inventory-test.yaml \
webservers -m ping -u vagrant
192.168.29.2 | SUCCESS => {
"Ansible-facts": {
"Discovered_interpreter_python": "/usr/libexec/platform-python"
},
"Changed": false;
"Ping": "pong"
}
[...]
```
### 清理
运行如下命令来清理环境：
```
$ vagrant destroy [vagrant machine name]
```
你的输出会像这样：
### 有创意的学习
在自己的实验室里利用自己的时间学习 Ansible 这样的软件是一个好习惯，但由于受到无法控制的限制，可能会很困难。
有时候，你需要发挥创意，找到另一种方法。在开源社区中，你可以选择很多方案；我们选择这些工具的主要原因之一是，它们是许多人常用和熟悉的。
另外，请注意，这些剧本并没有按照我的要求进行优化。请随时改进它们，并在评论中分享你的工作。
---
via: <https://opensource.com/article/20/12/ansible-lab>
作者：[Mike Calizo](https://opensource.com/users/mcalizo) 选题：[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/) 荣誉推出
|
COPR 仓库中 4 个很酷的新项目（2020.12） | Jakub Kadlčík | https://fedoramagazine.org/4-cool-new-projects-to-try-in-copr-from-december/ | 本文介绍了 COPR 中一些有趣的新项目。 | /data/attachment/album/202012/31/121320eq7cfcj5vdjufvfg.jpg.thumb.jpg | /data/attachment/album/202012/31/121320eq7cfcj5vdjufvfg.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"COPR"
] | 分享 | {
"viewnum": 2377,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 本文介绍了 COPR 中一些有趣的新项目。 | 2020-12-31T12:13:18 | 2020-12-31T12:13:18 | 12,971 | /article-12971-1.html | 
COPR 是个人软件仓库[集合](https://copr.fedorainfracloud.org/)，它不在 Fedora 中。这是因为某些软件不符合轻松打包的标准；或者它可能不符合其他 Fedora 标准，尽管它是自由而开源的。COPR 可以在 Fedora 套件之外提供这些项目。COPR 中的软件不受 Fedora 基础设施的支持，或者是由项目自己背书的。但是，这是一种尝试新的或实验性的软件的一种巧妙的方式。
本文介绍了 COPR 中一些有趣的新项目。如果你第一次使用 COPR，请参阅 [COPR 用户文档](https://docs.pagure.org/copr.copr/user_documentation.html)。
### Blanket
[Blanket](https://github.com/rafaelmardojai/blanket) 是一款播放背景声音的应用，它可能会提高你的注意力，提高你的工作效率。另外，它还可以帮助你在嘈杂的环境中放松和入睡。无论何时何地，Blanket 都可以让你在鸟鸣中醒来，在咖啡店聊天声或远离城市交通喧嚣的友好氛围下工作，然后在外面淅淅沥沥的雨声中像木头一样沉睡在壁炉旁边。还有其他流行的背景音选择，如粉色和白色噪音。
#### 安装说明
目前[仓库](https://copr.fedorainfracloud.org/coprs/tuxino/blanket/)为 Fedora 32 和 33 提供了 Blanket。要安装它，请使用以下命令：
```
sudo dnf copr enable tuxino/blanket
sudo dnf install blanket
```
### k9s
[k9s](https://k9scli.io/) 是一个管理 Kubernetes 集群的命令行工具。它可以让你列出正在运行的 pod 并与之交互，读取它们的日志，挖掘已使用的资源，并总体上使操作 Kubernetes 更轻松。通过插件和可定制的用户界面的可扩展性，k9s 受到有经验用户的欢迎。
有关[更多预览截图](https://k9scli.io/#-previews)，请参见[项目页面](https://k9scli.io/)。
#### 安装说明
目前[仓库](https://copr.fedorainfracloud.org/coprs/luminoso/k9s/)为 Fedora 32、33、Fedora Rawhide 以及 EPEL 7、8、Centos Stream 等提供 k9s。要安装它，请使用以下命令：
```
sudo dnf copr enable luminoso/k9s
sudo dnf install k9s
```
### rhbzquery
[rhbzquery](https://github.com/juhp/rhbzquery) 是一个简单的查询 Fedora Bugzilla 的工具。它提供了一个指定搜索查询的界面，但它并不在命令行中列出结果，而是由 rhbzquery 生成 Bugzilla 的 URL，并在浏览器中打开。
#### 安装说明
目前[仓库](https://copr.fedorainfracloud.org/coprs/petersen/rhbzquery/)为 Fedora 32、33 和 Fedora Rawhide 提供 rhbzquery。要安装它，请使用以下命令：
```
sudo dnf copr enable petersen/rhbzquery
sudo dnf install rhbzquery
```
### gping
[gping](https://github.com/orf/gping) 是一个比标准的 `ping` 命令更有视觉吸引力的选择，因为它以图表的形式显示结果。也可以同时 ping 多个主机，以方便比较它们的响应时间。
#### 安装说明
目前[仓库](https://copr.fedorainfracloud.org/coprs/atim/gping)为 Fedora 32、33、Fedora Rawhide 以及 EPEL 7 和 8 提供了 gping。要安装它，请使用以下命令：
```
sudo dnf copr enable atim/gping
sudo dnf install gping
```
---
via: <https://fedoramagazine.org/4-cool-new-projects-to-try-in-copr-from-december/>
作者：[Jakub Kadlčík](https://fedoramagazine.org/author/frostyx/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
编写一个简单的游戏来学习 Python | Moshe Zadka | https://opensource.com/article/20/12/learn-python | 通过编写一个“猜数字”游戏来探索 Python（和其他编程语言）。 | /data/attachment/album/202101/01/105156uwwgx3tw2otntoow.jpg.thumb.jpg | /data/attachment/album/202101/01/105156uwwgx3tw2otntoow.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Python"
] | 软件开发 | {
"viewnum": 3630,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12962,
"displayorder": 0
},
{
"raid": 12979,
"displayorder": 0
}
] | 通过编写一个“猜数字”游戏来探索 Python（和其他编程语言）。 | 2021-01-01T10:52:00 | 2021-01-01T10:52:00 | 12,973 | /article-12973-1.html |
>
> 通过编写一个“猜数字”游戏来探索 Python（和其他编程语言）。
>
>
>
在这个系列中，我们要用不同的编程语言编写相同的应用，以比较各种语言是如何工作的，并说明使用标准测试程序是学习新编程好方法。
当你学习一门新的编程语言时，关注它们的共同点是件好事。变量、表达式和语句是大多数编程语言的基础。一旦你理解了这些概念，你就可以开始弄清楚其余的东西。
因为编程语言有许多相似之处，一旦你知道一种语言，你通常可以通过观察它与你所知道的语言的不同之处来学习另一种语言的基础知识。使用你用其他语言编写的标准测试程序，可以让你专注于语言，而不是程序的逻辑。
为了证明这点，我们正在测试如何用多种语言编写一个“猜数字”程序。计算机选择一个 1 到 100 之间的数字，然后让你猜。程序循环，直到你猜出正确答案。
“猜数字”程序练习了编程语言的几个概念：
* 变量
* 输入
* 输出
* 条件判断
* 循环
这是一个很好的学习新编程语言的实践实验。
### 用 Python 猜数字
用 [Python 软件基金会](https://docs.python.org/3/faq/general.html#general-information)的话来说。“Python 是一种解释性的、交互式的、面向对象的程序设计语言，它包含了模块、异常、动态类型、非常高层的动态数据类型和类。”它是一种很好的通用编程语言，从简单的脚本到复杂的 GUI 应用都很适用。
你可以通过编写一个版本的“猜数字”游戏来探索 Python。这是我的实现：
```
import random as randomlib
random = randomlib.randint(1, 100)
print("Guess a number between 1 and 100")
while True:
guess = int(input())
if guess < random:
print("Too low")
elif guess > random:
print("Too high")
else:
print("That's right!")
break
```
要给一个变量赋值，请列出变量的名称，然后是 `=` 号。例如，语句 `random = 0` 给 `random` 变量分配了一个零值。
脚本的第一行就导入了 `random` 模块。由于本系列中的所有程序都使用 `random` 作为变量的名称，你可以使用 `import random as randomlib` 以别名导入它，以避免命名冲突。
很少有函数被内置到 Python 中，大多数函数必须从标准库中显式导入。`random` 标准库模块有生成各种随机值的功能。
脚本的第二行读取函数 `randint()` 的结果，并将其赋值给名为 `random` 的变量。函数需要两个参数：一个最小值和一个最大值。在本例中，范围是 `1` 到 `100`，以使游戏具有足够的挑战性。
你可以使用 `input()` 函数提示用户输入一个值。如果你写 `guess = int(input())`，Python 会等待用户输入一些文本，将其转换为一个整数，然后将值存储在 `guess` 变量中。
Python 支持条件表达式和循环等流程控制。在“猜数字”游戏中，只要 `guess` 中的值不等于 `random`，Python 就会继续循环。
如果猜测值小于随机数，Python 会打印 `Too low`，如果猜测值大于这个数字，Python 会打印 `Too high`。
### 示例输出
现在你已经写好了 Python 程序，运行它来玩“猜数字”游戏。每次运行程序，Python 都会随机选取一个不同的数字。为了完成这个游戏，你需要猜测，直到找到正确的数字：
```
$ python guess.py
Guess a number between 1 and 100
50
Too high
25
Too high
12
Too high
7
Too high
3
Too low
5
Too low
6
That's right!
```
在学习一门新的编程语言时，这个“猜数字”游戏是一个很好的入门程序，因为它以一种相当直接的方式练习了几个常见的编程概念。通过在不同的编程语言中实现这个简单的游戏，你可以展示不同编程语言的一些核心概念，并比较每种语言的细节。
你有喜欢的编程语言吗？你会如何编写“猜数字”游戏？请关注本系列文章，看看你可能感兴趣的其他编程语言的例子吧！
---
via: <https://opensource.com/article/20/12/learn-python>
作者：[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/) 荣誉推出
|
用 Linux 让旧 MacBook 重获新生 | Eric D. Schabell | https://opensource.com/article/20/12/linux-macbook | 花上一小时，用 Fedora 让一台过时的 Mac 重新有用。 | /data/attachment/album/202101/02/102156tjj8g7r272j74huj.jpg.thumb.jpg | /data/attachment/album/202101/02/102156tjj8g7r272j74huj.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"MacBook"
] | 技术 | {
"viewnum": 6438,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "183.192.28.92",
"message": "第一张图明显是带bar的MacBook Pro",
"username": "来自上海的 Chrome 87.0|Mac 11.1 用户",
"date": "2021-01-03T01:25:59"
},
{
"postip": "115.206.112.211",
"message": "看不懂看不懂",
"username": "来自浙江杭州的 Chrome 88.0|Windows 10 用户",
"date": "2021-01-27T14:10:50"
}
] | [] | 花上一小时，用 Fedora 让一台过时的 Mac 重新有用。 | 2021-01-02T10:22:12 | 2021-01-02T10:22:12 | 12,976 | /article-12976-1.html |
>
> 花上一小时，用 Fedora 让一台过时的 Mac 重新有用。
>
>
>
最近，我偶然找到了一台 2011 年底的老款 13 英寸 MacBook Pro，有 125GB SSD 和 8GB 内存。我曾带着这台机器去世界各地旅行，当年，我开了很多场会议、研讨会或演示，分享 JBoss 技术带来的各种 AppDev 优势。
在验证了它的电池能用，充了电，重新安装了一个新的 OS X 之后，我发现 Safari 浏览器的版本受限于旧的安全规范，这意味着它现在无法连接到很多 HTTPS 网站。这就使得这个解决方案失效了。
这个老伙计该怎么处理呢？
自从我作为开发人员专门在 Linux 工作站上工作以来已经有几年了。我只使用 Fedora，所以我决定尝试在这台 MacBook Pro 上安装它的最新版本。
我只花了一个多小时就用下面的步骤让 [Fedora 33](https://getfedora.org/en/) 在这台笔记本上工作了。
### 下载 Fedora 33 并创建一个临场 USB
第一步是找到正确的安装 Fedora 的方法。这台机器有一个 CD 插槽，所以可以刻录一个 ISO 并从它启动，但我选择直接使用可启动的 USB 方式。
我登上了另一台 MacBook，访问了 [Fedora Workstation 网站](https://getfedora.org/en/workstation/download/)，它有 Fedora Media Writer 的链接。点击你的机器类型的图标（在我的例子中是苹果标志），你会得到一个安装包。
开始安装，可以看到一个引导你完成安装过程的图形用户界面（GUI）。选择 Fedora Workstation 33 选项。
接下来，选择右上角的“Create Live USB”选项。
镜像将开始下载，你将看到一个下拉菜单来选择安装位置。
插入一个有足够空间的 U 盘，下载完成后，就可以选择它并在上面安装镜像。完成后，关闭 GUI，取出 U 盘。
### 安装 Linux
将你创建的 U 盘插入 MacBook Pro 左侧的端口，并按住 `Cmd` 键左侧的 `Option`（或 `Alt`）键的同时重新启动。这将打开一个启动机器的选项菜单：使用 EFI 选项，因为那是 USB 镜像。
笔记本电脑将从 USB 设备启动，你可以按照[正常的 Fedora 安装](https://docs.fedoraproject.org/en-US/fedora/f33/install-guide/install/Booting_the_Installation/)过程进行。如果你能将 MacBook Pro 插入网线连接，会有帮助，因为它的 Broadcom WiFi 设备无法开箱即用。
你现在也可以将 Fedora 安装到你的硬盘上，并将它永久地放在你的机器上。
一旦安装程序完成，重新启动机器，Fedora 33 现在应该是启动选项。
唯一缺少的就是 WiFi 驱动，所以要保持网线连接，安装你正在运行的内核的开发包，并为该内核构建 `broadcom-wl` 驱动。
验证你需要用于 WiFi 的卡。
```
$ lspci -vnn -d 14e4:
```
在输出中会有几项，包括如下内容：
```
Network controller [0280]: Broadcom Inc. and subsidiaries....
Subsystem: Apple Inc. AirPort Extreme...
```
安装一个仓库来拉取 Broadcom 相关的部分：
```
$ su -c 'dnf install -y http://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm'
```
接下来的部分很有趣：如果你查看正在运行的内核时，你会看到 `v5.9.8-200.fc33`，但是你要使用开发内核包来构建你的 Broadcom 无线驱动。所以，你需要安装 `v5.8.15-301.fc33`（在写这篇文章的时候可用）。使用 `uname -r` 检查它们，并使用 `sudo dnf list kernel` 列出已安装的内核包：
```
$ sudo dnf list kernel
kernel.x86_64 5.8.15-301.fc33
kernel.x86_64 5.9.8-200.fc33
```
安装开发包：
```
$ sudo dnf install -y akmods kernel-devel-5.8.15-301.fc33
```
安装 Broadcom 无线软件包：
```
$ sudo dnf install -y broadcom-wl
```
构建内核模块：
```
$ sudo akmods
```
重新启动你的机器，你应该可以看到无线驱动（`wl`）。
```
$ lsmod | grep wl
```
在 Fedora 中设置你的无线连接：
这篇文章对我来说有些出乎意料，但我希望它能帮助别人在周末享受一些老硬件的乐趣！
>
> 现在要走不寻常路了……在 2011 年的 Macbook Pro 上安装 [#Fedora](https://twitter.com/hashtag/Fedora?src=hash&ref_src=twsrc%5Etfw)。祝我好运! [pic.twitter.com/zlsESnq2Px](https://t.co/zlsESnq2Px)。
>
>
> * Eric D. Schabell (@ericschabell) [2020 年 11 月 22 日](https://twitter.com/ericschabell/status/1330434517883121665?ref_src=twsrc%5Etfw)
>
>
>
*此文原载于 [Schabell.org](https://www.schabell.org/2020/11/installing-fedora33-on-macbook-pro-13inch-late-2011.html)，经许可转载。*
---
via: <https://opensource.com/article/20/12/linux-macbook>
作者：[Eric D. Schabell](https://opensource.com/users/eschabell) 选题：[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/) 荣誉推出
|
如何使用 heredoc 作为一个文本编辑器 | Seth Kenlon | https://opensource.com/article/20/12/heredoc | 这个不起眼的终端功能在紧要关头提供一个文本编辑器。 | /data/attachment/album/202101/03/094710uucu3150at905t15.jpg.thumb.jpg | /data/attachment/album/202101/03/094710uucu3150at905t15.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"编辑器"
] | 技术 | {
"viewnum": 3676,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12964,
"displayorder": 0
},
{
"raid": 12982,
"displayorder": 0
}
] | 这个不起眼的终端功能在紧要关头提供一个文本编辑器。 | 2021-01-03T09:47:26 | 2021-01-03T09:47:26 | 12,978 | /article-12978-1.html |
>
> 这个不起眼的终端功能在紧要关头提供一个文本编辑器。
>
>
>
在 Linux 和 Unix 的 shell 中有一个不为人知的功能，它能让你用 [cat](https://opensource.com/article/19/2/getting-started-cat-command) 命令打开一个 do-while 循环。它被称为 heredoc，无论你使用什么 shell，它都能让你或多或少地拥有一个文本编辑器。它的语法是：
```
$ cat << EOF >> example.txt
```
中间的字符串（`EOF`），本质上是一个停止循环的条件。也就是说，如果你在一行中单独输入它，循环就会结束。在循环过程中，无论你在终端中输入什么，都会被管道传送到目标文件中（在本例中）。
### 安装
只要你有一个终端，你就能够启动 heredoc。我在 [Bash](https://opensource.com/article/20/4/bash-sysadmins-ebook)、[tsh](https://opensource.com/article/20/8/tcsh) 和 Korn shell 中使用过这个语法技巧。
### 使用 heredoc
要打开一个 heredoc “会话”，你可以使用带重定向的 `cat` 命令。首先用终止字符串（常见约定是 `EOF`，代表 “End Of File”，但它实际上可以是任何字符串）指向 `cat` 命令。在终止字符串之后，将输出重定向到一个目标文件。然后，你就可以直接在终端中输入了，可以使用最常见的 shell 键盘快捷键来处理你的工作。当你在一行上输入你指定的终止字符串时，你的会话就结束了。你可以通过唯一的提示符（通常是 `>`）知道你是在一个 heredoc 循环中。
```
$ cat << EOF >> example.txt
> Everything you type here will be placed into example.txt when I type EOF on a line by itself. Until then, you can type...
>
> whatever...
>
> you want to type.
>
> EOF
$
```
在终端等待 `EOF` 时，你输入的所有内容都会被放入目标文件中，提示符被忽略，`EOF` 本身也不是文件的一部分。
```
Everything you type here will be placed into example.txt when I type EOF on a line by itself. Until then, you can type...
whatever...
you want to type.
```
在现实中，你可能不会用 heredoc 语法来代替一个正常的文本编辑器。它是一个很好的快速处理方式，可以输入多行，但超过 10 行左右就开始限制它的作用了。例如，如果不触发你 shell 的 [history](https://opensource.com/article/20/6/bash-history-commands) 功能，你就不能编辑以前的行。根据你的 shell 和配置，你可能需要先按向上键，然后按向下键来找回你的文本，然后用 `Ctrl+B` 来后退。
你的 shell 的大部分功能都能正常工作，但可能没有撤销功能，也没有什么错误恢复功能。
此外，即使是最简安装的系统，可能也至少安装了 [Vi](https://opensource.com/article/19/3/getting-started-vim) 或 [ed](https://opensource.com/article/20/12/gnu-ed)。
然而 heredoc 还是很有用的！它比 `echo` 更灵活，当你在编写 shell 脚本时，它是不可缺少的。例如，想象一下你正在编写一个安装脚本，以便你可以自动安装一组自定义应用。其中一个应用没有生成 `.dekstop` 文件，所以它不会出现在你的应用菜单中。为了解决这个问题，你决定在安装时生成一个 `.desktop` 文件。
与其编写一个 `.desktop` 文件，然后作为安装脚本的外部依赖，不如在安装脚本中使用 heredoc：
```
#!/bin/sh
VERSION=${VERSION:-x.y.z}
PKGNAM=${VERSION:-example}
PKG="${PKGNAM}"-"${VERSION}"-`arch`.tgz
# download package
wget "${PKG}"
tar txvf "${PKG}"
# use here doc to create missing .desktop file
cat << EOF >> $HOME/.local/share/applications/example.desktop
[Desktop Entry]
Version=1.0
Type=Application
Name="${PKGNAM}"
Comment="${PKGNAM}"
Exec="${PKGNAM}" %F
EOF
# insert the rest of an install script...
```
你自动地将文本输入到了一个文件中，而不需要文本编辑器（当然，除了你用来写脚本的那个）。下面是生成的 `.desktop` 文件的样子：
```
[Desktop Entry]
Version=1.0
Type=Application
Name=example
Comment=example
Exec=example %F
```
正如你所看到的，你可以在 heredoc 中使用变量，而且它们得到了正确的解析。`EOF` 字符串并没有出现在文件中，它只是标志着 heredoc 的结束。
### 比 echo 更好
heredoc 技术通常被认为比 `echo` 或 [printf](https://opensource.com/article/20/8/printf) 更容易，因为一旦你“进入”了文档，你就可以自由地做任何你想做的事情。从这个意义上说，它是自由的，但与合适的文本编辑器相比，它是有限的。
使用 heredoc 来做快速笔记和 shell 脚本，再也不用为如何动态生成配置文件而烦恼了。
---
via: <https://opensource.com/article/20/12/heredoc>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
通过编写一个简单的游戏来学习 Rust | Moshe Zadka | https://opensource.com/article/20/12/learn-rust | 你可以尝试以多种语言编程一个简单的游戏来开始编程之路。 | /data/attachment/album/202101/03/101054axmmaxrpmsmopkac.png.thumb.jpg | /data/attachment/album/202101/03/101054axmmaxrpmsmopkac.png | true | false | true | lujun9972 | wxy | wxy | false | [
"Rust"
] | 软件开发 | {
"viewnum": 4836,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12973,
"displayorder": 0
},
{
"raid": 12985,
"displayorder": 0
}
] | 你可以尝试以多种语言编程一个简单的游戏来开始编程之路。 | 2021-01-03T10:10:52 | 2021-01-03T10:10:52 | 12,979 | /article-12979-1.html |
>
> 你可以尝试以多种语言编程一个简单的游戏来开始编程之路。
>
>
>
当你想学习一门新的编程语言时，不妨关注一下编程语言的共同点。
* 变量
* 表达式
* 语句
这些概念是大多数编程语言的基础。一旦你理解了它们，你就可以开始弄清楚其余的东西。
因为编程语言通常具有相似性，一旦你懂了一种语言，你就可以通过理解其差异来学习另一种语言的基础知识。
学习新语言的一个好方法是使用一个你可以用来练习的标准程序。这可以让你专注于语言，而不是程序的逻辑。我在这一系列文章中使用了一个“猜数字”的程序，在这个程序中，电脑会在 1 到 100 之间选一个数字让你猜。程序一直循环，直到你猜对数字为止。
这个程序锻炼了编程语言的几个概念:
* 变量
* 输入
* 输出
* 条件评估
* 循环
这是学习一门新编程语言的很好的实践实验。
### 安装 Rust
你可以[使用 Rustup 安装一个 Rust 工具链](https://www.rust-lang.org/learn/get-started)，或者你可以[在线尝试 Rust](https://play.rust-lang.org/) 而不在本地安装它。
如果你在本地安装，你应该定期用 `rustup update` 来更新它，以保持你的工具链的新鲜，并使用 `cargo update` 来保持你的库的最新版本。
### Rust 语言版本的猜数字
[Rust](https://www.rust-lang.org/) 是一门赋予任何人构建可靠和高效的软件能力的语言。你可以通过编写一个 Rust 版本的“猜数字”游戏来探索 Rust。
第一步是编写一个 `Cargo.toml` 文件。你可以使用 `cargo new` 命令生成一个骨架 `Cargo.toml`。这几乎是开始一个 Rust 项目的最佳方式。
```
$ cargo new guess
$ cd guess
$ ls -1
Cargo.toml
src/
```
`Cargo.toml` 文件为你的包命名，并给它一些元数据，最重要的是，指明了它依赖于 `rand` [crate](https://doc.rust-lang.org/book/ch07-01-packages-and-crates.html)。
```
[package]
name = "guess"
version = "2020.11.0"
authors = ["Moshe Zadka <[email protected]>"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
rand = "*"
```
Rust 中的许多东西不是由语言或标准库提供的。取而代之的是，你可以从某个外部 crate 得到它们，这些 crate 可以做许多事情。
程序逻辑在 `src/main.rs` 中：
```
use rand::Rng;
use std::io::BufRead;
fn main() {
let mut rng = rand::thread_rng();
let random = rng.gen_range(1..101);
println!("Guess a number between 1 and 100");
for line in std::io::stdin().lock().lines() {
let parsed = line.ok().as_deref().map(str::parse::<i64>);
if let Some(Ok(guess)) = parsed {
match guess {
_ if guess < random => println!("Too low"),
_ if guess > random => println!("Too high"),
_ => {
println!("That's right");
break;
}
}
}
}
}
```
代码的前两行声明你要做什么。在本例中，`rand::Rng` 生成一个猜测值，而 [trait](https://doc.rust-lang.org/rust-by-example/trait.html) `std::io::BufRead` 使得可以从标准输入中读取。
Rust 代码的入口在 `main()` 函数中，所以下一步就是定义 `main()`。
要给一个变量赋值，先放 `let`，再放变量的名字，后面放 `=` 号。这样就创建了一个[不可变](https://en.wikipedia.org/wiki/Immutable_object)变量。
Rust 中大多数变量都是不可变的，但是 `rng` 对象必须是可变的（`mut`）。例如，语句 `let random = 0` 给`random` 变量分配一个零值。
函数的第一行创建了一个线程安全的 `Rng` 对象，并将其分配给变量 `rng`。Rust 是建立在线程和内存安全的基础上的，所以你必须在开始写代码时就考虑到这些事情。
程序的下一行读取函数 `gen_range()` 的结果，并将其分配给名为 `random` 的变量。该函数取一个最小值（包含）和一个上界（不包含）。为了也包含上界，你可以用一个等号来标记较大的数字（例如，`1...=100`），或者你也可以像我在代码中做的那样，将上界设置为比你的预期最大值大 1。在这种情况下，该范围是 `1` 到 `100`，使得游戏刚好有足够的挑战性。
中央循环在 `std::io::stdin()` 中迭代行。由于有各种可能导致行不能读取的例外情况，Rust 要求你用一个 `Result` 来包裹一行。有时候可能无法将一行解析为一个整数。
这段代码使用条件模式匹配来忽略所有会导致错误的行：
```
let parsed = line.ok().as_deref().map(str::parse::<i64>);
if let Some(Ok(guess)) = parsed {
// ...
}
```
第一行创建了一个 `Result<Option<i64>, ...>` 对象，因为它可能在读取或解析步骤中失败。由于下一行只在 `Some(Ok(guess))` 上匹配，每当一行的结果是一个不匹配的值时，它就会跳过 `if` 语句。这是一种强大的忽略错误的方法。
Rust 支持条件表达式和流程控制，比如循环。在“猜数字”游戏中，只要猜中的值不等于 `random`，Rust 就会继续循环。
`if` 语句的主体包含一个 Rust 的 `match` 语句的三向分支。虽然 `match` 最常用于模式匹配，但它也可以检查任意条件。在这种情况下是打印一个适当的信息，如果猜测是正确的，则中断（`break`）循环。
### 示例输出
现在你已经写好了你的 Rust 程序，你可以运行它来玩“猜数字”游戏。每次运行程序时，Rust 都会选择一个不同的随机数，所以继续猜，直到找到正确的数字。
```
$ cargo run
Compiling guess v2020.11.0 (/Users/mzadka/src/guess)
Finished dev [unoptimized + debuginfo] target(s) in 0.70s
Running `target/debug/guess`
Guess a number between 1 and 100
50
Too high
25
Too high
12
Too low
18
Too high
15
Too high
13
Too low
14
That's right
```
典型的做法是用 `cargo run` 来测试程序。最终，你可能会使用 `cargo build` 分成两个独立的步骤[构建一个可执行文件并运行它](https://opensource.com/article/20/3/rust-cargo)。
### 学习 Rust
这个“猜数字”游戏是学习一门新的编程语言的一个很好的入门程序，因为它以一种相当直接的方式锻炼了几个常见的编程概念。通过在不同的编程语言中实现这个简单的游戏，你可以展示语言的一些核心概念，并比较它们的细节。
你有喜欢的编程语言吗？你会如何用它来写“猜数字”游戏呢？请关注本系列文章，看看你可能感兴趣的其他编程语言的例子吧！
---
via: <https://opensource.com/article/20/12/learn-rust>
作者：[Moshe Zadka](https://opensource.com/users/moshez) 选题：[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/) 荣誉推出
|
让你爱上 Git 的 10 篇文章 | Joshua Allen Holm | https://opensource.com/article/20/12/git | 你对 Git 了解得越多，使用 Git 就会越容易。一起来回顾下年度最佳 Git 文章。 | /data/attachment/album/202101/04/120824ue7jvn9nj4n2s4vh.jpg.thumb.jpg | /data/attachment/album/202101/04/120824ue7jvn9nj4n2s4vh.jpg | true | false | true | lujun9972 | lxbwolf | wxy | false | [
"Git"
] | 软件开发 | {
"viewnum": 4523,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11797,
"displayorder": 0
},
{
"raid": 12231,
"displayorder": 1
},
{
"raid": 12244,
"displayorder": 2
},
{
"raid": 12450,
"displayorder": 3
},
{
"raid": 12621,
"displayorder": 4
},
{
"raid": 12894,
"displayorder": 5
}
] | 你对 Git 了解得越多，使用 Git 就会越容易。一起来回顾下年度最佳 Git 文章。 | 2021-01-04T12:09:36 | 2021-01-04T12:09:36 | 12,981 | /article-12981-1.html |
>
> 你对 Git 了解得越多，使用 Git 就会越容易。一起来回顾下年度最佳 Git 文章。
>
>
>
Git 是开源开发者工具箱中最基本的工具。这个强大的版本控制系统有很多复杂的功能。使用 Git 不需要了解它所有的功能，但是对 Git 了解得越多，使用 Git 就会越容易。
下面每篇文章都提供了一些奇技淫巧来提升和增强你的 Git 技能。
### 怎么解决 git 合并时的冲突
Brian Breniser 的这篇教程从 `git merge` 的定义以及解释什么是冲突开始。然后他详细解释了在合并时如果有冲突[如何解决冲突](https://opensource.com/article/20/4/git-merge-conflict)。Breniser 还提了一些能学习更多关于解决冲突和其他 Git 功能的建议。
### 4 个不可或缺的 Git 脚本
Vince Power 分享了他[最重要的 Git 脚本](/article-12180-1.html)。这些脚本可以从 Git Extras 包中获得，该包提供了 60 多个 Git 增强脚本。Power 最爱的脚本有：在无需打开文本编辑器的情况下编辑 `.git-ignore` 的 `git-ignore` ；用于提供 Git 仓库的摘要的 `git-info`；用来处理 GitLab 的合并请求（MR）和 GitHub 的拉取请求（PR）的 `git-pr`；把 Git 的提交（`commit`）、标签（`tag`）和推送（`push`）合为一体的 `git-release`。
### 完美生活：git rebase -i
在 Dave Neary 的这篇文章中可以学习[使用 git rebase -i 来修改你的 Git 提交历史](/article-12231-1.html)。Neary 从解释 Git 是如何把提交历史记录到仓库中的以及 `git commit` 和 `git rebase` 的区别。之后，他又解释了如何使用 `git rebase -i` 让 Git 仓库的提交历史变得简洁。这个命令能让你把“修复书写错误”的提交合进其它提交里，把几个相似的小提交合并成一个大的提交。
### Git Cola 让使用 Git 变得简单
Seth Kenlon 演示了[如何使用 Git Cola](https://opensource.com/article/20/3/git-cola)。Git 是个命令行工具，这对于有些人来说是有学习门槛的。Git Cola 提供了一个图形界面，因此不习惯用命令行的用户也可以使用 Git。在此文中，Kenlon 展示了如何安装 Git Cola，并使用 Git Cola 的图形用户界面完成了很多 Git 提交任务。
### 6 个在团队中使用 Git 的最佳实践
从设计上讲，Git 是个协同工具，但是关于如何协同的很多细节是由团队自行决定的。Ravi Chandran 提了一些建议，团队应该采用这些建议[更高效地使用 Git](/article-12621-1.html)。Chandran 在文中列出的 6 个最佳实践是：“使约定正式化”，“正确地合并修改”，“经常变基你的功能分支”，“在合并之前把压扁你的提交”，“使用标签”，“让软件的可执行程序打印标签”。
### 改变我使用 Git 工作方式的七个技巧
Rajeev Bera 分享了 [7 个 Git 技巧](/article-12894-1.html)，这些技巧能提升 Git 的用户体验。文章探讨了 Git 的自动更正、提交计数、仓库优化、备份未追踪的文件、了解 `.git` 目录、在另一个分支查看文件以及在 Git 下搜索。
### 使用 tmux 和 Git 定制化我的 Linux 终端
Moshe Zadka 展示了他是如何[使用 tmux 和 Git](/article-12450-1.html)定制化他的 Linux 终端的。Zadka 的文章是个人工作流的优秀探索。他使用 GNOME 终端，用 tmux 和一些能让他快速查看 Git 仓库状态的功能来增强终端。他只需要用一个字母就可以提交文件或把提交推送到远程仓库。
### 使用 Lazygit 让复杂的 Git 任务简单化
Jesse Duffield 解释了如何使用[Lazygit，一个能让使用 Git 变得简单的终端界面](https://opensource.com/article/20/3/lazygit)。Lazygit 的开发者 Duffield 详细阐述了如何使用这个界面来暂存文件、以交互方式变基、进行筛选、搜索提交以及创建一个 PR。
### 使用子模块和子树来管理 Git 项目
子模块和子树是两种在 Git 仓库中引入嵌套的子项目的方式。在[使用子模块和子树来管理 Git 项目](/article-12244-1.html)中，Manaswini Das 解释了两个选项的工作原理和区别。
### 不喜欢 diff？那么试试 Meld
Ben Nuttall 展示了如何[使用 Meld 代替 diff](/article-12067-1.html)来进行对比和合并修改。Meld 是图形化的 `diff`，输出更容易理解。Nuttall 演示了使用 `diff` 和 Meld 进行对比的区别。他还解释了 Meld 是如何识别 Git 项目的，这意味着在 Git 中一个文件被提交之后，可以用 Meld 来搜索修改。
你想学习关于 Git 的什么内容？请在评论去分享你的想法。
---
via: <https://opensource.com/article/20/12/git>
作者：[Joshua Allen Holm](https://opensource.com/users/holmja) 选题：[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/) 荣誉推出
|
试试 GNU nano，一个轻量级的 Vim 替代品 | Seth Kenlon | https://opensource.com/article/20/12/gnu-nano | 轻巧而直接，nano 提供了一个简单、直观的编辑器，没有额外的麻烦。 | /data/attachment/album/202101/04/124300oklykg26z6wyhjey.jpg.thumb.jpg | /data/attachment/album/202101/04/124300oklykg26z6wyhjey.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"nano"
] | 分享 | {
"viewnum": 5498,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12978,
"displayorder": 0
},
{
"raid": 12992,
"displayorder": 0
}
] | 轻巧而直接，nano 提供了一个简单、直观的编辑器，没有额外的麻烦。 | 2021-01-04T12:43:48 | 2021-01-04T12:43:48 | 12,982 | /article-12982-1.html |
>
> 轻巧而直接，nano 提供了一个简单、直观的编辑器，没有额外的麻烦。
>
>
>
许多 Linux 发行版都捆绑了 [Vim](https://opensource.com/article/20/12/vi-text-editor) 作为默认的文本编辑器。这吸引了很多长期使用 Linux 的用户，反正那些不喜欢它的用户也可以在安装后及时更换。不过 Vim 是一个很有趣的编辑器，因为它是少数几个打开时的模式不允许输入文字的编辑器之一。这对任何用户来说都是一个令人费解的选择，对一个新用户来说也是很困惑的。
多亏了 GNU nano，才有了 Vim 之外的另一种轻量级终端文本编辑器，而且使用起来非常方便 —— 它的窗口底部列出了最重要的命令。
### 安装
在 Linux 和 macOS 上，你可能已经安装了 GNU nano。你可以用 `which` 命令来验证：
```
$ which nano
/bin/nano
```
如果你没有安装它，你可以从你的软件库中安装，或者你可以自己[下载它的源代码并编译](http://nano-editor.org)。
在 Windows 上，你可以使用 [Chocolatey](https://opensource.com/article/20/3/chocolatey) 来 [安装 GNU nano](https://opensource.com/article/20/12/%C2%A0https://chocolatey.org/packages/nano)。
### 启动 nano
从终端启动 nano，要么单独打开它：
```
$ nano
```
或者你也可以在你的命令后面加上一个文件的路径来打开一个特定的文件。如果你命名的文件还不存在，它就会被创建：
```
$ nano example.txt
```
### 使用 nano
nano，是个只要稍看一下，就会发现它是一个非常自明的东西。当你启动它的时候，nano 会打开一个空的缓冲区或者你要打开的文件。在屏幕下方，有一个功能列表和相应的键盘快捷键。更多的功能可以按 `Ctrl+G` 获取帮助。
以下是最重要的应用程序命令：
* `Ctrl+S` 保存你的工作
* `Ctrl+W` 另存为
* `Ctrl+R` 加载文件（读取）
* `Ctrl+X` 退出
* `Ctrl+G` 获得帮助
以下是最常用的编辑命令：
* `Alt+A` 选择（标记）一个区域
* `Ctrl+K` 剪切标记的文字
* `Ctrl+U` 粘贴（不剪切）
* `Alt+F` 撤销
* `Alt+E` 重做
### 可定制
nano 不像 Emacs 或 Vim 那样可扩展，但你可以在一个名为 `~/.nanorc` 的文件中进行一些重要的定制。在这个文件中，你可以设置全局的偏好，包括文字折行设置、颜色方案、行号等。你也可以创建你自己的键绑定，所以如果你想用 `Ctrl+V` 来代替 nano 默认的 `Ctrl+U` 来粘贴，你可以改变分配给 `paste` 函数的绑定。
```
bind ^V paste all
```
你可以在 [GNU nano 文档](https://www.nano-editor.org/dist/latest/nanorc.5.html)中获得所有可用函数的列表。
### 简单而有效
GNU nano 是一款简单明了的文本编辑器。它易于使用，并提供了你所期望的所有文本编辑器的功能。试试吧，享受直观编辑的简单性。
---
via: <https://opensource.com/article/20/12/gnu-nano>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
Go 通道是糟糕的，你应该也觉得很糟糕 | Jtolds | https://www.jtolio.com/2016/03/go-channels-are-bad-and-you-should-feel-bad | 如果你在大街上问一个有名的程序员，Go 有什么特别之处？ 她很可能会告诉你 Go 最出名的是通道和 goroutine。 | /data/attachment/album/202101/05/101049y2995vz8l9mdg4bz.jpg.thumb.jpg | /data/attachment/album/202101/05/101049y2995vz8l9mdg4bz.jpg | true | false | true | lujun9972 | gxlct008 | wxy | false | [
"Go"
] | 软件开发 | {
"viewnum": 6830,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "58.240.29.114",
"message": "golang:看我理你吧",
"username": "来自江苏南京的 Chrome 87.0|Windows 10 用户",
"date": "2021-01-06T16:50:57"
},
{
"postip": "58.240.29.114",
"message": "自己用不习惯就来黑golang，不喜欢不要用啊，",
"username": "来自江苏南京的 Chrome 87.0|Windows 10 用户",
"date": "2021-01-06T16:52:32"
}
] | [] | 如果你在大街上问一个有名的程序员，Go 有什么特别之处？ 她很可能会告诉你 Go 最出名的是通道和 goroutine。 | 2021-01-05T10:12:53 | 2021-01-05T10:12:53 | 12,984 | /article-12984-1.html | 
更新：如果你是从一篇题为 《[糟糕的 Go 语言](https://github.com/ksimka/go-is-not-good)》 的汇编文章看到这篇博文的话，那么我想表明的是，我很惭愧被列在这样的名单上。Go 绝对是我使用过的最不糟糕的的编程语言。在我写作本文时，我是想遏制我所看到的一种趋势，那就是过度使用 Go 的一些较复杂的部分。我仍然认为 <ruby> 通道 <rt> Channel </rt></ruby>可以更好，但是总体而言，Go 很棒。这就像你最喜欢的工具箱中有 [这个工具](https://blog.codinghorror.com/content/images/uploads/2012/06/6a0120a85dcdae970b017742d249d5970d-800wi.jpg)；它可以有用途（甚至还可能有更多的用途），它仍然可以成为你最喜欢的工具箱！
更新 2：如果我没有指出这项对真实问题的优秀调查，那我将是失职的：《[理解 Go 中的实际并发错误](https://songlh.github.io/paper/go-study.pdf)》。这项调查的一个重要发现是...Go 通道会导致很多错误。
从 2010 年中后期开始，我就断断续续地在使用 Google 的 [Go 编程语言](https://golang.org/)，自 2012 年 1 月开始（在 Go 1.0 之前！），我就用 Go 为 [Space Monkey](http://www.spacemonkey.com/) 编写了合规的产品代码。我对 Go 的最初体验可以追溯到我在研究 Hoare 的 [通信顺序进程](https://en.wikipedia.org/wiki/Communicating_sequential_processes) 并发模型和 [Matt Might](http://matt.might.net) 的 [UCombinator 研究组](http://www.ucombinator.org/) 下的 [π-演算](https://en.wikipedia.org/wiki/%CE%A0-calculus) 时，作为我（[现在已重定向](https://www.jtolio.com/writing/2015/11/research-log-cell-states-and-microarrays/)）博士工作的一部分，以更好地支持多核开发。Go 就是在那时发布的（多么巧合啊！），我当即就开始学习尝试了。
它很快就成为了 Space Monkey 开发的核心部分。目前，我们在 Space Monkey 的生产系统有超过 42.5 万行的纯 Go 代码（*不* 包括我们所有的 vendored 库中的代码量，这将使它接近 150 万行），所以也并不是你见过的最多的 Go 代码，但是对于相对年轻的语言，我们是重度用户。我们之前 [写了我们的 Go 使用情况](https://www.jtolio.com/writing/2014/04/go-space-monkey/)。也开源了一些使用率很高的库；许多人似乎是我们的 [OpenSSL 绑定](https://godoc.org/github.com/spacemonkeygo/openssl)（比 [crypto/tls](https://golang.org/pkg/crypto/tls/) 更快，但请保持 openssl 本身是最新的！）、我们的 [错误处理库](https://godoc.org/github.com/spacemonkeygo/errors)、[日志库](https://godoc.org/github.com/spacemonkeygo/spacelog) 和 [度量标准收集库/zipkin 客户端](https://godoc.org/gopkg.in/spacemonkeygo/monitor.v1) 的粉丝。我们使用 Go、我们热爱 Go、我们认为它是目前为止我们使用过的最不糟糕的、符合我们需求的编程语言。
尽管我也不认为我能说服自己不要提及我的广泛避免使用 [goroutine-local-storage 库](https://github.com/jtolds/gls) （尽管它是一个你不应该使用的魔改技巧，但它是一个漂亮的魔改），希望我的其他经历足以证明我在解释我故意煽动性的帖子标题之前知道我在说什么。
### 等等，什么？
如果你在大街上问一个有名的程序员，Go 有什么特别之处？ 她很可能会告诉你 Go 最出名的是<ruby> 通道 <rt> Channels </rt></ruby> 和 goroutine。 Go 的理论基础很大程度上是建立在 Hoare 的 CSP（<ruby> 通信顺序进程 <rt> Communicating Sequential Processes </rt></ruby>）模型上的，该模型本身令人着迷且有趣，我坚信，到目前为止，它产生的收益远远超过了我们的预期。
CSP（和 π-演算）都使用通信作为核心同步原语，因此 Go 会有通道是有道理的。Rob Pike 对 CSP 着迷（有充分的理由）[相当深](https://en.wikipedia.org/wiki/Newsqueak) 已经有一段时间了。（[当时](https://en.wikipedia.org/wiki/Alef_%28programming_language%29) 和 [现在](https://en.wikipedia.org/wiki/Limbo_%28programming_language%29)）。
但是从务实的角度来看（也是 Go 引以为豪的），Go 把通道搞错了。在这一点上，通道的实现在我的书中几乎是一个坚实的反模式。为什么这么说呢？亲爱的读者，让我细数其中的方法。
#### 你可能最终不会只使用通道
Hoare 的 “通信顺序进程” 是一种计算模型，实际上，唯一的同步原语是在通道上发送或接收的。一旦使用 <ruby> 互斥量 <rt> mutex </rt></ruby>、<ruby> 信号量 <rt> semaphore </rt></ruby> 或 <ruby> 条件变量 <rt> condition variable </rt></ruby>、bam，你就不再处于纯 CSP 领域。 Go 程序员经常通过高呼 “[通过交流共享内存](https://blog.golang.org/share-memory-by-communicating)” 的 [缓存的思想](https://lesswrong.com/lw/k5/cached_thoughts/) 来宣扬这种模式和哲学。
那么，让我们尝试在 Go 中仅使用 CSP 编写一个小程序！让我们成为高分接收者。我们要做的就是跟踪我们看到的最大的高分值。如此而已。
首先，我们将创建一个 `Game` 结构体。
```
type Game struct {
bestScore int
scores chan int
}
```
`bestScore` 不会受到<ruby> 互斥量 <rt> mutex </rt></ruby>的保护！这很好，因为我们只需要一个 goroutine 来管理其状态并通过通道来接收新的分值即可。
```
func (g *Game) run() {
for score := range g.scores {
if g.bestScore < score {
g.bestScore = score
}
}
}
```
好的，现在我们将创建一个有用的构造函数来开始 `Game`。
```
func NewGame() (g *Game) {
g = &Game{
bestScore: 0,
scores: make(chan int),
}
go g.run()
return g
}
```
接下来，假设有人给了我们一个可以返回分数的 `Player`。它也可能会返回错误，因为可能传入的 TCP 流可能会死掉或发生某些故障，或者玩家退出。
```
type Player interface {
NextScore() (score int, err error)
}
```
为了处理 `Player`，我们假设所有错误都是致命的，并将获得的比分向下传递到通道。
```
func (g *Game) HandlePlayer(p Player) error {
for {
score, err := p.NextScore()
if err != nil {
return err
}
g.scores <- score
}
}
```
好极了！现在我们有了一个 `Game` 类型，可以以线程安全的方式跟踪 `Player` 获得的最高分数。
你圆满完成了自己的开发工作，并开始拥有客户。你将这个游戏服务器公开，就取得了令人难以置信的成功！你的游戏服务器上也许正在创建许多游戏。
很快，你发现人们有时会离开你的游戏。许多游戏不再有任何玩家在玩，但没有任何东西可以阻止游戏运行的循环。死掉的 `(*Game).run` goroutines 让你不知所措。
**挑战：** 在无需互斥量或 panics 的情况下修复上面的 goroutine 泄漏。实际上，可以滚动到上面的代码，并想出一个仅使用通道来解决此问题的方案。
我等着。
就其价值而言，它完全可以只通过通道来完成，但是请观察以下解决方案的简单性，它甚至没有这个问题：
```
type Game struct {
mtx sync.Mutex
bestScore int
}
func NewGame() *Game {
return &Game{}
}
func (g *Game) HandlePlayer(p Player) error {
for {
score, err := p.NextScore()
if err != nil {
return err
}
g.mtx.Lock()
if g.bestScore < score {
g.bestScore = score
}
g.mtx.Unlock()
}
}
```
你想选择哪一个？不要被欺骗了，以为通道的解决方案可以使它在更复杂的情况下更具可读性和可理解性。<ruby> 拆解 <rt> Teardown </rt></ruby>是非常困难的。这种拆解若用<ruby> 互斥量 <rt> mutex </rt></ruby>来做那只是小菜一碟，但最困难的是只使用 Go 专用通道来解决。另外，如果有人回复说发送通道的通道更容易推理，我马上就是感到头疼。
重要的是，这个特殊的情况可能真的 **很容易** 解决，而通道有一些运行时的帮助，而 Go 没有提供！不幸的是，就目前的情况来看，与 Go 的 CSP 版本相比，使用传统的<ruby> 同步原语 <rt> synchronization primitives </rt></ruby>可以更好地解决很多问题，这是令人惊讶的。稍后，我们将讨论 Go 可以做些什么来简化此案例。
**练习：** 还在怀疑？ 试着让上面两种解决方案（只使用通道与只使用互斥量channel-only vs mutex-only）在一旦 `bestScore` 大于或等于 100 时，就停止向 `Players` 索要分数。继续打开你的文本编辑器。这是一个很小的玩具问题。
这里的总结是，如果你想做任何实际的事情，除了通道之外，你还会使用传统的同步原语。
#### 通道比你自己实现要慢一些
Go 如此重视 CSP 理论，我认为其中一点就是，运行时应该可以通过通道做一些杀手级的调度优化。也许通道并不总是最直接的原语，但肯定是高效且快速的，对吧？
正如 [Dustin Hiatt](https://twitter.com/HiattDustin) 在 [Tyler Treat’s post about Go](http://bravenewgeek.com/go-is-unapologetically-flawed-heres-why-we-use-it/) 上指出的那样，
>
> 在幕后，通道使用锁来序列化访问并提供线程安全性。 因此，通过使用通道同步对内存的访问，你实际上就是在使用锁。 被包装在线程安全队列中的锁。 那么，与仅仅使用标准库 `sync` 包中的互斥量相比，Go 的花式锁又如何呢？ 以下数字是通过使用 Go 的内置基准测试功能，对它们的单个集合连续调用 Put 得出的。
>
>
>
```
> BenchmarkSimpleSet-8 3000000 391 ns/op
> BenchmarkSimpleChannelSet-8 1000000 1699 ns/o
>
```
无缓冲通道的情况与此类似，甚至是在争用而不是串行运行的情况下执行相同的测试。
也许 Go 调度器会有所改进，但与此同时，良好的旧互斥量和条件变量是非常好、高效且快速。如果你想要提高性能，请使用久经考验的方法。
#### 通道与其他并发原语组合不佳
好的，希望我已经说服了你，有时候，你至少还会与除了通道之外的原语进行交互。标准库似乎显然更喜欢传统的同步原语而不是通道。
你猜怎么着，正确地将通道与互斥量和条件变量一起使用，其实是有一定的挑战性的。
关于通道的一个有趣的事情是，通道发送是同步的，这在 CSP 中是有很大意义的。通道发送和通道接收的目的是为了成为同步屏蔽，发送和接收应该发生在同一个虚拟时间。如果你是在执行良好的 CSP 领域，那就太好了。
实事求是地说，Go 通道也有多种缓冲方式。你可以分配一个固定的空间来考虑可能的缓冲，以便发送和接收是不同的事件，但缓冲区大小是有上限的。Go 并没有提供一种方法来让你拥有任意大小的缓冲区 —— 你必须提前分配缓冲区大小。 *这很好*，我在邮件列表上看到有人在争论，*因为无论如何内存都是有限的*。
What。
这是个糟糕的答案。有各种各样的理由来使用一个任意缓冲的通道。如果我们事先知道所有的事情，为什么还要使用 `malloc` 呢？
没有任意缓冲的通道意味着在 *任何* 通道上的幼稚发送可能会随时阻塞。你想在一个通道上发送，并在互斥下更新其他一些记账吗？小心！你的通道发送可能被阻塞！
```
// ...
s.mtx.Lock()
// ...
s.ch <- val // might block!
s.mtx.Unlock()
// ...
```
这是哲学家晚餐大战的秘诀。如果你使用了锁，则应该迅速更新状态并释放它，并且尽可能不要在锁下做任何阻塞。
有一种方法可以在 Go 中的通道上进行非阻塞发送，但这不是默认行为。假设我们有一个通道 `ch := make(chan int)`，我们希望在其上无阻塞地发送值 `1`。以下是在不阻塞的情况下你必须要做的最小量的输入：
```
select {
case ch <- 1: // it sent
default: // it didn't
}
```
对于刚入门的 Go程序员来说，这并不是自然而然就能想到的事情。
综上所述，因为通道上的很多操作都会阻塞，所以需要对哲学家及其就餐仔细推理，才能在互斥量的保护下，成功地将通道操作与之并列使用，而不会造成死锁。
#### 严格来说，回调更强大，不需要不必要的 goroutines
每当 API 使用通道时，或者每当我指出通道使某些事情变得困难时，总会有人会指出我应该启动一个 goroutine 来读取该通道，并在读取该通道时进行所需的任何转换或修复。
呃，不。如果我的代码位于热路径中怎么办？需要通道的实例很少，如果你的 API 可以设计为使用<ruby> 互斥量 <rt> mutexes </rt></ruby>、<ruby> 信号量 <rt> semaphores </rt></ruby>和<ruby> 回调 <rt> callbacks </rt></ruby>，而不使用额外的 goroutine （因为所有事件边缘都是由 API 事件触发的），那么使用通道会迫使我在资源使用中添加另一个内存分配堆栈。是的，goroutine 比线程轻得多，但更轻量并不意味着是最轻量。
正如我以前 [在一篇关于使用通道的文章的评论中争论过的](http://www.informit.com/articles/article.aspx?p=2359758#comment-2061767464)（呵呵，互联网），如果你使用回调而不是通道，你的 API *总是* 可以更通用，*总是* 更灵活，而且占用的资源也会大大减少。“总是” 是一个可怕的词，但我在这里是认真的。有证据级的东西在进行。
如果有人向你提供了一个基于回调的 API，而你需要一个通道，你可以提供一个回调，在通道上发送，开销不大，灵活性十足。
另一方面，如果有人提供了一个基于通道的 API 给你，而你需要一个回调，你必须启动一个 goroutine 来读取通道，*并且* 你必须希望当你完成读取时，没有人试图在通道上发送更多的东西，这样你就会导致阻塞的 goroutine 泄漏。
对于一个超级简单的实际例子，请查看 [context 接口](https://godoc.org/golang.org/x/net/context)（顺便说一下，它是一个非常有用的包，你应该用它来代替 [goroutine 本地存储](https://github.com/jtolds/gls)）。
```
type Context interface {
...
// Done returns a channel that closes when this work unit should be canceled.
// Done 返回一个通道，该通道在应该取消该工作单元时关闭。
Done() <-chan struct{}
// Err returns a non-nil error when the Done channel is closed
// 当 Done 通道关闭时，Err 返回一个非 nil 错误
Err() error
...
}
```
想象一下，你要做的只是在 `Done()` 通道触发时记录相应的错误。你该怎么办？如果你没有在通道中选择的好地方，则必须启动 goroutine 进行处理：
```
go func() {
<-ctx.Done()
logger.Errorf("canceled: %v", ctx.Err())
}()
```
如果 `ctx` 在不关闭返回 `Done()` 通道的情况下被垃圾回收怎么办？哎呀！这正是一个 goroutine 泄露！
现在假设我们更改了 `Done` 的签名：
```
// Done calls cb when this work unit should be canceled.
Done(cb func())
```
首先，现在日志记录非常容易。看看：`ctx.Done(func() { log.Errorf ("canceled:%v", ctx.Err()) })`。但是假设你确实需要某些选择行为。你可以这样调用它：
```
ch := make(chan struct{})
ctx.Done(func() { close(ch) })
```
瞧！通过使用回调，不会失去表现力。 `ch` 的工作方式类似于用于返回的通道 `Done()`，在日志记录的情况下，我们不需要启动整个新堆栈。我必须保留堆栈跟踪信息（如果我们的日志包倾向于使用它们）；我必须避免将其他堆栈分配和另一个 goroutine 分配给调度程序。
下次你使用通道时，问问你自己，如果你用互斥量和条件变量代替，是否可以消除一些 goroutine ？ 如果答案是肯定的，那么修改这些代码将更加有效。而且，如果你试图使用通道只是为了在集合中使用 `range` 关键字，那么我将不得不请你放下键盘，或者只是回去编写 Python 书籍。
#### 通道 API 不一致，只是 cray-cray
在通道已关闭的情况下，执行关闭或发送消息将会引发 panics！为什么呢？ 如果想要关闭通道，你需要在外部同步它的关闭状态（使用互斥量等，这些互斥量的组合不是很好！），这样其他写入者才不会写入或关闭已关闭的通道，或者只是向前冲，关闭或写入已关闭的通道，并期望你必须恢复所有引发的 panics。
这是多么怪异的行为。 Go 中几乎所有其他操作都有避免 panic 的方法（例如，类型断言具有 `, ok =` 模式），但是对于通道，你只能自己动手处理它。
好吧，所以当发送失败时，通道会出现 panic。我想这是有一定道理的。但是，与几乎所有其他带有 nil 值的东西不同，发送到 nil 通道不会引发 panic。相反，它将永远阻塞！这很违反直觉。这可能是有用的行为，就像在你的除草器上附加一个开罐器，可能有用（在 Skymall 可以找到）一样，但这肯定是意想不到的。与 nil 映射（执行隐式指针解除引用），nil 接口（隐式指针解除引用），未经检查的类型断言以及其他所有类型交互不同，nil 通道表现出实际的通道行为，就好像为该操作实例化了一个全新的通道一样。
接收的情况稍微好一点。在已关闭的通道上执行接收会发生什么？好吧，那会是有效操作——你将得到一个零值。好吧，我想这是有道理的。奖励！接收允许你在收到值时进行 `, ok =` 样式的检查，以确定通道是否打开。谢天谢地，我们在这里得到了 `, ok =`。
但是，如果你从 nil 渠道接收会发生什么呢？ *也是永远阻塞！* 耶！不要试图利用这样一个事实：如果你关闭了通道，那么你的通道是 nil！
### 通道有什么好处？
当然，通道对于某些事情是有好处的（毕竟它们是一个通用容器），有些事情你只能用它们来做（比如 `select`）。
#### 它们是另一种特殊情况下的通用数据结构
Go 程序员已经习惯于对泛型的争论，以至于我一提起这个词就能感觉到 PTSD（创伤后应激障碍）的到来。我不是来谈论这件事的，所以擦擦额头上的汗，让我们继续前进吧。
无论你对泛型的看法是什么，Go 的映射、切片和通道都是支持泛型元素类型的数据结构，因为它们已经被特殊封装到语言中了。
在一种不允许你编写自己的泛型容器的语言中，任何允许你更好地管理事物集合的东西都是有价值的。在这里，通道是一个支持任意值类型的线程安全数据结构。
所以这很有用！我想这可以省去一些陈词滥调。
我很难把这算作是通道的胜利。
#### Select
使用通道可以做的主要事情是 `select` 语句。在这里，你可以等待固定数量的事件输入。它有点像 epoll，但你必须预先知道要等待多少个套接字。
这是真正有用的语言功能。如果不是 `select`，通道将被彻底清洗。但是我的天呐，让我告诉你，第一次决定可能需要在多个事物中选择，但是你不知道有多少项，因此必须使用 `reflect.Select`。
### 通道如何才能更好？
很难说 Go 语言团队可以为 Go 2.0 做的最具战术意义的事情是什么（Go 1.0 兼容性保证很好，但是很费劲），但这并不能阻止我提出一些建议。
#### 在条件变量上的 Select ！
我们可以不需要通道！这是我提议我们摆脱一些“<ruby> 圣牛 <rt> sacred cows </rt></ruby>”（LCTT 译注：神圣不可质疑的事物）的地方，但是让我问你，如果你可以选择任何自定义同步原语，那会有多棒？（答：太棒了。）如果有的话，我们根本就不需要通道了。
#### GC 可以帮助我们吗？
在第一个示例中，如果我们能够使用定向类型的通道垃圾回收（GC）来帮助我们进行清理，我们就可以轻松地解决通道的高分服务器清理问题。
如你所知，Go 具有定向类型的通道。 你可以使用仅支持读取的通道类型（`<-chan`）和仅支持写入的通道类型（`chan<-`）。 这太棒了！
Go 也有垃圾回收功能。 很明显，某些类型的记账方式太繁琐了，我们不应该让程序员去处理它们。 我们清理未使用的内存！ 垃圾回收非常有用且整洁。
那么，为什么不帮助清理未使用或死锁的通道读取呢？ 与其让 `make(chan Whatever)` 返回一个双向通道，不如让它返回两个单向通道（`chanReader, chanWriter:= make(chan Type)`）。
让我们重新考虑一下最初的示例：
```
type Game struct {
bestScore int
scores chan<- int
}
func run(bestScore *int, scores <-chan int) {
// 我们不会直接保留对游戏的引用，因为这样我们就会保留着通道的发送端。
for score := range scores {
if *bestScore < score {
*bestScore = score
}
}
}
func NewGame() (g *Game) {
// 这种 make(chan) 返回风格是一个建议
scoreReader, scoreWriter := make(chan int)
g = &Game{
bestScore: 0,
scores: scoreWriter,
}
go run(&g.bestScore, scoreReader)
return g
}
func (g *Game) HandlePlayer(p Player) error {
for {
score, err := p.NextScore()
if err != nil {
return err
}
g.scores <- score
}
}
```
如果垃圾回收关闭了一个通道，而我们可以证明它永远不会有更多的值，那么这个解决方案是完全可行的。是的，是的，`run` 中的评论暗示着有一把相当大的枪瞄准了你的脚，但至少现在这个问题可以很容易地解决了，而以前确实不是这样。此外，一个聪明的编译器可能会做出适当的证明，以减少这种脚枪造成的损害。
#### 其他小问题
* **Dup 通道吗？** —— 如果我们可以在通道上使用等效于 `dup` 的系统调用，那么我们也可以很容易地解决多生产者问题。 每个生产者可以关闭自己的 `dup` 版通道，而不会破坏其他生产者。
* **修复通道 API！** —— 关闭不是幂等的吗？ 在已关闭的通道上发送信息引起的 panics 没有办法避免吗？ 啊！
* **任意缓冲的通道** —— 如果我们可以创建没有固定的缓冲区大小限制的缓冲通道，那么我们可以创建非阻塞的通道。
### 那我们该怎么向大家介绍 Go 呢？
如果你还没有，请看看我目前最喜欢的编程文章：《[你的函数是什么颜色](http://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/)》。虽然不是专门针对 Go，但这篇博文比我更有说服力地阐述了为什么 goroutines 是 Go 最好的特性（这也是 Go 在某些应用程序中优于 Rust 的方式之一）。
如果你还在使用这样的一种编程语言写代码，它强迫你使用类似 `yield` 关键字来获得高性能、并发性或事件驱动的模型，那么你就是活在过去，不管你或其他人是否知道这一点。到目前为止，Go 是我所见过的实现 M：N 线程模型（非 1：1 ）的语言中最好的入门者之一，而且这种模型非常强大。
所以，跟大家说说 goroutines 吧。
如果非要我选择 Go 的另一个主要特性，那就是接口。静态类型的 <ruby> <a href="https://en.wikipedia.org/wiki/Duck_typing"> 鸭子模型 </a> <rt> duck typing </rt></ruby> 使得扩展、使用你自己或他人的项目变得如此有趣而令人惊奇，这也许值得我改天再写一组完全不同的文章来介绍它。
### 所以…
我一直看到人们争先恐后冲进 Go，渴望充分利用通道来发挥其全部潜力。这是我对你的建议。
**够了！**
当你在编写 API 和接口时，尽管“绝不”的建议可能很糟糕，但我非常肯定，通道从来没有什么时候好过，我用过的每一个使用通道的 Go API，最后都不得不与之抗争。我从来没有想过“哦 太好了，这里是一个通道；”它总是被一些变体取代，***这是什么新鲜的地狱？***
所以，*请在适当的地方，并且只在适当的地方使用通道。*
在我使用的所有 Go 代码中，我可以用一只手数出有多少次通道真的是最好的选择。有时候是这样的。那很好！那就用它们吧。但除此之外，就不要再使用了。
*特别感谢我的校对读者 Jeff Wendling、[Andrew Harding](https://github.com/azdagron)、[George Shank](https://twitter.com/taterbase) 和 [Tyler Treat](http://bravenewgeek.com) 提供的宝贵反馈。*
如果你想和我们一起用 Go 在 Space Monkey 项目工作，请[给我打个招呼](https://www.jtolio.com/contact/)！
---
via: <https://www.jtolio.com/2016/03/go-channels-are-bad-and-you-should-feel-bad>
作者：[jtolio.com](https://www.jtolio.com/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[gxlct008](https://github.com/gxlct008) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
编写一个简单的游戏来练习用 C++ 编程 | Seth Kenlon | https://opensource.com/article/20/12/learn-c-game | C++ 语言很复杂，但它可以教会你很多关于数据类型、内存管理和代码链接的知识。 | /data/attachment/album/202101/05/110821dwzztxchazhto8ko.jpg.thumb.jpg | /data/attachment/album/202101/05/110821dwzztxchazhto8ko.jpg | true | false | true | lujun9972 | wxy | wxy | false | [] | 软件开发 | {
"viewnum": 6634,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12979,
"displayorder": 0
},
{
"raid": 13000,
"displayorder": 0
}
] | C++ 语言很复杂，但它可以教会你很多关于数据类型、内存管理和代码链接的知识。 | 2021-01-05T11:08:35 | 2021-01-05T11:08:35 | 12,985 | /article-12985-1.html |
>
> C++ 语言很复杂，但它可以教会你很多关于数据类型、内存管理和代码链接的知识。
>
>
>
学习一门编程语言有几种方法。如果你是编码新手，你通常会学习一些基本的计算机编码概念，并尝试应用它们。如果你已经知道如何用另一种语言进行编码，你可以重新学习编码概念在新语言中是如何表达的。
不管是哪种情况，学习这些新原理的便捷方法是创建一个简单的猜谜游戏。这会迫使你了解一门语言如何接收输入和发送输出，如何比较数据，如何控制程序的流程，以及如何利用条件来影响结果。它还确保你知道一门语言是如何组织其代码的；例如，Lua 或 [Bash](https://opensource.com/article/20/12/learn-bash) 可以很容易地作为脚本运行，而 [Java](https://opensource.com/article/20/12/learn-java-writing-guess-number-game) 则需要你创建一个类。
在本文中，我将演示如何用 [C++](https://www.cplusplus.com/) 在终端上实现猜谜游戏。
### 安装依赖关系
要跟上本文的步伐，你需要 C++ 和一个编译器。
在 Linux 上，你可以通过从你的发行版软件仓库中安装 Qt Creator IDE 来获得你所需要的一切。
在 Fedora、CentOS 或 RHEL 上：
```
$ sudo dnf install qt-creator
```
在 Debian、Ubuntu、Chromebook 或类似的系统上：
```
$ sudo apt install qtcreator
```
本文并没有使用 Qt Creator IDE，但它是一个安装你所需要的一切的简单方法，对于复杂的 C++ 项目（包括那些带有 GUI 的项目），它是一个必不可少的工具。在 macOS 或 Windows 上，按照 Qt 网站上的[安装说明](https://www.qt.io/product/development-tools)进行安装。
### 设置包含和命名空间
C++ 的核心语言是精简的。即使是一个简单的应用程序也需要使用额外的库。这个应用程序使用 [iostream](http://www.cplusplus.com/reference/iostream/) 来获得对 `cout` 和 `cin` 关键字的访问。
另外，确保程序使用 `std` 命名空间：
```
#include <iostream>
using namespace std;
```
这并不是绝对必要，但如果不将命名空间设置为 `std`，所有来自 `iostream` 库的关键字都需要一个命名空间前缀。例如，我不能写作 `cout`，而是要写作 `std::cout`。
C++ 中的语句以分号结束。
### 创建一个函数
每个 C++ 应用程序至少需要一个函数。一个 C++ 应用程序的主函数必须称为 `main`，它必须返回一个整数（`int`），这符合 [POSIX](https://opensource.com/article/19/7/what-posix-richard-stallman-explains) 的期望，即一个进程在成功时返回 0，而在失败时返回其他值。你可以通过为它提供返回类型和名称来创建一个新函数。
```
int main() {
// code goes here
}
```
### 实现程序逻辑
游戏代码必须首先产生一个随机数供玩家猜测。在 C++ 中，你可以通过建立一个用于生成伪随机数的*种子*来实现。一个简单的种子就是当前的时间。一旦有了种子，你就可以得到一个在 1 和 100 之间的数字。通过调用 `rand` 函数，并设置上限值 100 来产生一个从 0 到 99 的随机数，所以无论选择了什么数字都要加 1，并将结果分配给一个名为 `number` 的变量。你还必须声明一个变量来保存玩家的猜测值。为了清楚起见，我称这个变量为 `guess`。
这个示例代码还包括一个调试语句，告诉你随机数到底是什么。这对于猜测游戏来说不是很好，但它使测试速度快了很多。以后，你可以删除这一行，或者直接在行前面用 `//` 注释出来：
```
srand (time(NULL));
int number = rand() % 100+1;
int guess = 0;
cout << number << endl; //debug
```
### 增加 do-while 和 if 语句
C++ 中的 `do-while` 语句以关键字 `do` 开头，并将你希望 C++ 做的所有事情用括号括起来。用 `while` 关键字结束语句，后面是必须满足的条件（括号内）：
```
do {
// code here
} while ( number != guess );
```
游戏代码出现在 `if`、`else if` 和 `else` 语句之间，为玩家提供提示。
首先，用 `cout` 语句提示玩家猜测。`cout` 函数将输出打印到 `stdout` 上。因为 `cout` 语句没有连着 `endl`（endline）函数，所以没有换行。紧接着这个 `cout` 语句，通过使用 `cin` 函数告诉 C++ 等待输入。正如你所猜测的那样，`cin` 等待来自 `stdin` 的输入。
接下来，程序进入 `if` 控制语句。如果玩家的猜测大于 `number` 变量中包含的伪随机数，那么程序就会打印出一个提示，后面是一个换行符。这就中断了 `if` 语句，但 C++ 仍然被困在 `do-while` 循环中，因为它的条件（`number` 变量等于 `guess`）还没有满足。
如果玩家的猜测小于 `number` 变量中包含的伪随机数，那么程序就会打印出一个提示，后面是一个换行符。这再次中断了 `if` 语句，但程序仍然被困在 `do-while` 循环中。
当 `guess` 等于 `number` 时，最终满足关键条件，触发 `else` 语句，`do-while` 循环结束，程序结束：
```
do {
cout << "Guess a number between 1 and 100: ";
cin >> guess;
if ( guess > number) { cout << "Too high.\n" << endl; }
else if ( guess < number ) { cout << "Too low.\n" << endl; }
else {
cout << "That's right!\n" << endl;
exit(0);
} // fi
} while ( number != guess );
return 0;
} // main
```
### 构建代码和玩游戏
你可以用 GCC 构建你的应用程序：
```
$ g++ -o guess.bin guess.cpp
```
运行二进制文件试试：
```
$ ./guess.bin
74
Guess a number between 1 and 100: 76
Too high.
Guess a number between 1 and 100: 1
Too low.
Guess a number between 1 and 100: 74
That's right!
```
成功了！
### 试试 C++ 吧
C++ 语言很复杂。为终端编写 C++ 应用程序可以让你学到很多关于数据类型、内存管理和代码链接的知识。试着用 C++ 编写一个有用的实用程序，看看你能发现什么！
---
via: <https://opensource.com/article/20/12/learn-c-game>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
如何在基于 Ubuntu 或 Debian 的 Linux 发行版中查看一个软件包的依赖 | Abhishek Prakash | https://itsfoss.com/check-dependencies-package-ubuntu/ | 但如果你想在安装一个软件包之前或之后知晓这个软件包的依赖，那该怎么办呢？ | /data/attachment/album/202101/06/112738sv0dmjojmjokpxt0.jpg.thumb.jpg | /data/attachment/album/202101/06/112738sv0dmjojmjokpxt0.jpg | true | false | true | lujun9972 | FSSlc | wxy | false | [
"软件包",
"依赖"
] | 技术 | {
"viewnum": 9096,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 但如果你想在安装一个软件包之前或之后知晓这个软件包的依赖，那该怎么办呢？ | 2021-01-06T11:28:49 | 2021-01-06T11:28:49 | 12,987 | /article-12987-1.html | 
在 Ubuntu 或 Debian 中通过命令行来安装应用是一件很简单的事，你只需要执行 `apt install package_name` 就可以了。
但如果你想在安装一个软件包之前或之后知晓这个软件包的依赖，那该怎么办呢？
在本教程中，我将向你展示多种方法来在 Ubuntu 或其他使用 [APT 包管理器](https://wiki.debian.org/Apt) 的 Debian 系 Linux 发行版中查看一个软件包的依赖。
### 什么是 Ubuntu 中的包依赖？
当你在 Linux 中安装一个软件包，有时这个软件包还需要其他的软件包来使它工作正常。这些额外的软件包就叫作这个包的依赖。假如这些软件包之前没有在系统中被安装，那么这些依赖在安装这个软件包的同时会被自动安装上。
举个例子，用来转换视频格式的 GUI 工具 [HandBrake](https://itsfoss.com/handbrake/) 需要 [FFmpeg](https://ffmpeg.org/)、[GStreamer](https://gstreamer.freedesktop.org/) 软件包。所以对于 HandBrake 来说， FFmpeg 和 GStreamer 就是它的包依赖。
假如在你的系统上这些软件包没有被安装，则当你 [在 Ubuntu 上安装 HandBrake](https://itsfoss.com/install-handbrake-ubuntu/) 时，就会自动安装上它们。
### 在 Ubuntu 和基于 Debian 的发行版中查看一个软件包的依赖
正如在 Linux 上经常发生的那样，有多种方法来达到相同的目标。下面让我们一起瞧瞧查看一个软件包依赖的多种方法。
#### 使用 apt show 来查看依赖
你可以使用 [apt show 命令](https://itsfoss.com/apt-search-command/) 来展示一个包的详细信息。其中依赖信息就是其中一部分，你可以在以 “Depends” 打头的那些行中看到它们。
例如，下面展示的是使用 `apt show` 展示 [ubuntu-restricted-extras](https://itsfoss.com/install-media-codecs-ubuntu/) 这个包的详细信息：
```
abhishek@itsfoss:~$ apt show ubuntu-restricted-extras
Package: ubuntu-restricted-extras
Version: 67
Priority: optional
Section: multiverse/metapackages
Origin: Ubuntu
Maintainer: Ubuntu Developers <[email protected]>
Bugs: https://bugs.launchpad.net/ubuntu/+filebug
Installed-Size: 14.3 kB
Depends: ubuntu-restricted-addons
Recommends: libavcodec-extra, ttf-mscorefonts-installer, unrar
Download-Size: 3,200 B
APT-Manual-Installed: yes
APT-Sources: http://us.archive.ubuntu.com/ubuntu focal/multiverse amd64 Packages
Description: Commonly used media codecs and fonts for Ubuntu
This collection of packages includes:
- MP3 and other audio codec software to play various audio formats
(GStreamer plugins)
- software to install the Microsoft Web fonts
- the Adobe Flash plugin
- LAME, software to create compressed audio files.
.
This software does not include libdvdcss2, and will not let you play
encrypted DVDs. For more information, see
https://help.ubuntu.com/community/RestrictedFormats/PlayingDVDs
.
These software packages are from the Multiverse channel, restricted by
copyright or legal issues in some countries. For more information, see
http://www.ubuntu.com/ubuntu/licensing
```
如你所见，`ubuntu-restricted-extras` 包依赖于 `ubuntu-restricted-addons` 这个软件包。
但你得小心的是依赖包还可能依赖于其他包，这样一直循环往复直到尽头。但幸好 APT 包管理器可以为你处理这些复杂的依赖关系，自动地安装所有的依赖（大多数情况下）。
>
> **什么是推荐包？**
>
>
> 你注意到了上面结果输出中以 “Recommends” 开头的那些行了吗？
>
>
> 推荐包不是软件包的直接依赖，但它们可以开启软件包的一些额外功能。
>
>
> 正如你上面看到的那样， `ubuntu-restricted-extras` 包有 `ttf-mscorefonts-installer` 这个推荐包，用来在 Ubuntu 上安装 Microsoft 的字体。
>
>
> 这些推荐包也会默认被一同安装上，假如你想显式地禁止这些推荐包的安装，你可以像下面这样使用 `–-no-install-recommends` 选项。
>
>
>
> ```
> sudo apt install --no-install-recommends package_name
>
> ```
>
>
#### 使用 apt-cache 来直接获取依赖信息
上面通过 `apt show` 的方式会获取到大量信息，假如你想在脚本中获取到依赖信息，那么 `apt-cache` 命令将会给你一个更好且更简洁的输出结果。
```
apt-cache depends package_name
```
下面的输出看起来更加干净，不是吗？
#### 使用 dpkg 来查看一个 DEB 文件的依赖
`apt` 和 `apt-cache` 都作用于软件仓库中的软件包，但假如你下载了一个 DEB 文件，那么这两个命令就不起作用了。
在这种情形下，你可以使用 `dpkg` 命令的 `-I` 或 `--info` 选项。
```
dpkg -I path_to_deb_file
```
依赖信息就可以在以 “Depends” 开头的那些行中找到。
#### 使用 apt-rdepends 来查看依赖及依赖的依赖
假如你想查看更多关于依赖的信息，那么你可以使用 `apt-rdepends` 工具。这个工具可以创建完整的依赖树。这样你就可以得到一个软件包的依赖以及这些依赖的依赖。
它不是一个常规的 `apt` 命令，所以你需要从 universe 软件仓库中安装上它：
```
sudo apt install apt-rdepends
```
这个命令的输出通常很多，取决于依赖树的大小。
```
Reading package lists... Done
Building dependency tree
Reading state information... Done
shutter
Depends: procps
Depends: xdg-utils
imagemagick
Depends: imagemagick-6.q16 (>= 8:6.9.2.10+dfsg-2~)
imagemagick-6.q16
Depends: hicolor-icon-theme
Depends: libc6 (>= 2.4)
Depends: libmagickcore-6.q16-6 (>= 8:6.9.10.2)
Depends: libmagickwand-6.q16-6 (>= 8:6.9.10.2)
hicolor-icon-theme
libc6
Depends: libcrypt1 (>= 1:4.4.10-10ubuntu4)
Depends: libgcc-s1
libcrypt1
Depends: libc6 (>= 2.25)
```
`apt-rdepends` 工具的功能非常多样，它还可以用来计算反向依赖。这意味着你可以查看某个特定的包被哪些软件包依赖。
```
apt-rdepends -r package_name
```
输出可能会非常多，因为它将打印出反向依赖树。
```
abhishek@itsfoss:~$ apt-rdepends -r ffmpeg
Reading package lists... Done
Building dependency tree
Reading state information... Done
ffmpeg
Reverse Depends: ardour-video-timeline (>= 1:5.12.0-3ubuntu4)
Reverse Depends: deepin-screen-recorder (5.0.0-1build2)
Reverse Depends: devede (4.15.0-2)
Reverse Depends: dvd-slideshow (0.8.6.1-1)
Reverse Depends: green-recorder (>= 3.2.3)
```
我希望这个快速的教程可以帮助你提高一点儿你的命令行知识。为了知晓更多类似小知识点，请保持关注。
---
via: <https://itsfoss.com/check-dependencies-package-ubuntu/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[FSSlc](https://github.com/FSSlc) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用 Loki 和 fzf 进阶你的 Shell 历史记录 | Ed Welch | https://opensource.com/article/20/10/shell-history-loki-fzf | Loki 扩展了 Prometheus 用于度量监测和日志聚合的模型。 | /data/attachment/album/202101/06/155012r4khll9zlqgx79fs.jpg.thumb.jpg | /data/attachment/album/202101/06/155012r4khll9zlqgx79fs.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"日志"
] | 系统运维 | {
"viewnum": 6489,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "1.192.90.183",
"message": "太重了",
"username": "来自河南郑州的 Firefox 84.0|GNU/Linux 用户",
"date": "2021-01-08T14:44:28"
}
] | [] | Loki 扩展了 Prometheus 用于度量监测和日志聚合的模型。 | 2021-01-06T15:50:00 | 2021-01-06T15:50:00 | 12,988 | /article-12988-1.html |
>
> Loki 扩展了 Prometheus 用于度量监测和日志聚合的模型。
>
>
>
[Loki](https://github.com/grafana/loki) 是一个 Apache 2.0 许可的开源日志聚合框架，由 Grafana 实验室设计，并在不断发展的社区的巨大支持之下建立。它也是我每天为之努力的项目。在这篇文章中，我将不只是谈论 Loki 如何工作，而是提供一个实际操作的介绍，以解决实际问题。
### 问题：一个持久的集中式 Shell 历史记录
我喜欢我的 shell 历史，一直是 `CTRL+R` 的狂热用户。大约一年前，我的终端生活发生了翻天覆地的变化，我的同行 Dieter Plaetinck 向我介绍了命令行模糊查找器 [fzf](https://github.com/junegunn/fzf)。
突然间，在命令中搜索就从这样：
变成了这样：
虽然 `fzf` 极大地提高了我的生活质量，但围绕着我的 shell 历史记录，还是缺少了一些片段：
* 终端突然关闭、电脑崩溃、死机、整盘加密密钥被遗忘等情况下会丢失 shell 历史记录。
* 想从我的所有电脑上访问我的 shell 历史记录。
我认为我的 shell 历史记录是文件：它是一个重要的故事，我不想失去。将 Loki 与我的 shell 历史结合起来，有助于解决这些问题和更多问题。
### 关于 Loki
Loki 采用了开源 [Prometheus](https://prometheus.io/) 项目用于度量的直观的标签模型，并将其扩展到日志聚合的世界。这使得开发人员和运维人员能够使用相同的标签集在他们的度量和日志之间无缝切换。即使你没有使用 Prometheus，也有很多理由说明 Loki 可能很适合你的日志存储需求：
* **低开销：** Loki 不做全文日志索引；它只创建你放在日志上的标签的索引。保持小的索引大大降低了 Loki 的运维要求。我在 [树莓派](https://www.raspberrypi.org/) 上运行我的 loki-shell 项目，该项目使用 Loki 来存储 shell 历史记录，只使用了 50MB 多一点的内存。
* \*成本低：\*\*日志内容被压缩并存储在对象存储中，如 Amazon S3、Google 云存储、Azure Blob，甚至可以直接存储在文件系统中。我们的目标是使用价格低廉且持久的存储。
* **灵活性：** Loki 以单个二进制文件的形式提供，可以直接下载并运行，也可以作为 Docker 镜像在任何容器环境中运行。在 Kubernetes 中可以用一个 [Helm 海图](https://helm.sh/docs/topics/charts/) 快速上手。如果你对日志工具的要求很高，可以看看运行在 Grafana 实验室的 [生产环境](https://grafana.com/docs/loki/latest/installation/tanka/)。它使用开源的 [Jsonnet](https://jsonnet.org) 和 [Tanka](https://tanka.dev/) 部署了同样的 Loki 镜像作为离散的构件，以实现大规模的水平扩展、高可用性、复制、读写路径的分别扩展、高度可并行的查询等。
总而言之，Loki 的方法是保留一个关于你的日志元数据的小索引（标签），并将未索引的、压缩的日志内容存储在廉价的对象存储中，以使操作更容易和更便宜。该应用程序被构建为单进程运行，并很容易演变成一个高可用的分布式系统。你可以通过并行化和查询的分片，在较大的日志工作负载上获得较高的查询性能 —— 有点像为你的日志设计的 MapReduce。
此外，这个功能是任何人都可以免费使用的。与其 [Grafana](https://grafana.com/) 开放观测性平台一样，Grafana 实验室致力于将 Loki 打造成一个任何人都可以使用的全功能、全开放的日志聚合软件。
### 开始吧
我在树莓派上运行 Loki，并将我的 shell 历史记录异地存储在 S3 bucket 中。
当我按下 `CTRL+R`，Loki 的 [LogCLI](https://grafana.com/docs/loki/latest/getting-started/logcli/) 命令行界面会发起几个批处理请求，传输至 `fzf`。下面是一个例子，上半部分显示的是树莓派上的 Loki 服务器日志。
准备试试？下面的指南将帮助你设置和运行 Loki，与你的 shell 历史记录集成。为了让本教程保持简洁，此设置将 Loki 本地运行在你的计算机上，并在文件系统上存储所有文件。
在 [loki-shell 的 GitHub 版本库](https://github.com/slim-bean/loki-shell)，你可以找到所有这一切，以及如何设置一个更复杂的安装的信息。
请注意，本教程不会改变任何围绕你的历史记录的现有行为，所以 *你现有的 shell 历史记录命令和历史记录设置不会被触动*。相反，这将用 Bash 中的 `$PROMPT_COMMAND` 和 Zsh 中的 `precmd` 复制命令历史记录到 Loki。在 `CTRL+R` 方面，它重载了 `fzf` 用来访问 `CTRL+R` 命令的函数。因此试一试是安全的，如果你觉得不喜欢它，只需按照 GitHub 版本库中的 [卸载步骤](https://github.com/slim-bean/loki-shell/blob/master/uninstall) 来删除所有痕迹。你的 shell 历史记录不会被触及。
#### 第一步：安装 fzf
安装 `fzf` 有几种方法，但我更喜欢 [Git 方法](https://github.com/junegunn/fzf#using-git)：
```
git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
~/.fzf/install
```
对所有的问题提示说 `yes`。
如果你已经安装了 `fzf`，确保你已经启用了键绑定（即，确保当你输入 `CTRL+R` 时，`fzf` 会弹出）。如果有必要的话，你可以重新运行 `fzf` 安装过程来启用键绑定。
#### 第二步：安装 loki-shell
和 `fzf` 一样，loki-shell 也有一个 Git 版本库和安装脚本：
```
git clone --depth 1 https://github.com/slim-bean/loki-shell.git ~/.loki-shell
~/.loki-shell/install
```
首先，该脚本创建了 `~/.loki-shell` 目录，所有的文件都将保存在该目录下（包括 Loki 数据），接下来，它将下载 [Promtail](https://grafana.com/docs/loki/latest/clients/promtail/)、LogCLI 和 Loki 的二进制文件。
然后它会问：
```
Do you want to install Loki? ([y]/n)
```
如果你已经为 Loki-shell 运行了一个集中化的 Loki，你可以回答 `n`；然而，对于本教程，回答 `y` 或按回车键。
在本地运行 Loki 有两种方式：作为一个 Docker 镜像或作为一个单一的二进制文件（支持添加为 systemd 服务）。如果可以，我建议使用 Docker，因为我认为它稍微简化了操作，但这两者都可以工作。
##### 使用 Docker 运行
将 Loki 作为 Docker 镜像运行：
```
[y] to run Loki in Docker, [n] to run Loki as a binary ([y]/n) y
Error: No such object: loki-shell
Error response from daemon: No such container: loki-shell
Error: No such container: loki-shell
54843ff3392f198f5cac51a6a5071036f67842bbc23452de8c3efa392c0c2e1e
```
如果这是你第一次运行这个安装程序，你可以忽略错误信息。这个脚本将停止和替换运行的 Loki 容器，如果版本不匹配，你可以重新运行此脚本升级 Loki。
就是这样！Loki 现在作为一个 Docker 容器运行了。
Loki 的数据将存储在 `~/.loki-shell/data` 中。
由于带着 `-restart=unless-stopped` 标志运行该镜像，所以它会在系统重启时重启该服务，但如果你运行 `docker stop loki-shell` 则会保持停止。
（如果你使用的是 Docker，你可以跳到 “Shell 集成”一节。）
##### 以二进制文件运行
在 Linux 系统上运行二进制文件的方法有很多。这个脚本可以安装一个 systemd 服务。如果你没有 systemd，你也可以使用二进制安装：
```
[y] to run Loki in Docker, [n] to run Loki as a binary ([y]/n) n
Run Loki with systemd? ([y]/n) n
This is as far as this script can take you
You will need to setup an auto-start for Loki
It can be run with this command: /home/username/.loki-shell/bin/loki -config.file=/home/username/.loki-shell/config/loki-binary-config.yaml
```
脚本会输出你需要用来运行 Loki 的命令，你可以自己设置一个 init 脚本或其他方法来自动启动它。
如果你想的话，你可以直接运行该命令，从你当前的 shell 运行 Loki。
如果你有 systemd，你可以选择让脚本安装 systemd 服务或显示出你自己运行它的命令：
```
Run Loki with systemd? ([y]/n) y
Installing the systemd service requires root permissions.
[y] to run these commands with sudo [n] to print out the commands and you can run them yourself. ([y]/n) n
sudo cp /home/ed/.loki-shell/config/loki-shell.service /etc/systemd/system/loki-shell.service
sudo systemctl daemon-reload
sudo systemctl enable loki-shell
sudo systemctl start loki-shell
Copy these commands and run them when the script finishes. (press enter to continue)
```
##### Shell 集成
无论你如何安装 Loki，你现在应该看到一个提示：
```
Enter the URL for your Loki server or press enter for default (http://localhost:4100)
```
如果你已经设置了一个中心化的 Loki，你应在这里输入其 URL。然而，这个演示只是使用了默认的 URL，所以你可以按回车键。
它会输出很多文本来解释添加到你的 `~.bashrc` 或 `~.zshrc`（或两者）的所有条目。
好了！
```
Finished. Restart your shell or reload config file.
source ~/.bashrc # bash
source ~/.zshrc # zsh
```
#### 第三步：试试吧!
开始使用你的 shell，并使用 `CTRL+R` 查看你的命令。
打开多个终端窗口，在一个窗口中输入命令，在另一个窗口中输入 `CTRL+R`，你会看到你的命令立即可用。
另外，请注意，当你在终端之间切换并输入命令时，使用 `CTRL+R` 可以立即使用它们，但向上箭头的操作在终端之间不受影响。（如果你安装了 Oh My Zsh，情况可能就不一样了，因为它会自动将所有命令追加到历史记录中。）
多次按下 `CTRL+R` 可以在按时间排序和按相关性排序之间切换。
请注意，此配置将只显示当前主机的查询历史记录，即使你正在从多个主机向 Loki 发送 shell 数据。我认为默认情况下这是最合理的。如果你想改变这种行为，有很多地方可以调整；请参见 loki-shell 版本库了解更多。
它还安装了一个名为 `hist` 的别名。
```
alias hist="$HOME/.loki-shell/bin/logcli --addr=$LOKI_URL"
```
LogCLI 可以用来直接在 Loki 上查询和搜索你的历史，也允许你搜索其他主机。查看 LogCLI 的入门指南，了解更多关于查询的信息。
Loki 的日志查询语言（LogQL）提供了度量查询，可以让你做一些有趣的事情，例如，我可以看到在过去 30 天里我发出了多少次 `kc` 命令（我对 `kubectl` 的别名）。
### 额外增强
安装 Grafana，摆弄一下你的 shell 历史记录。
```
docker run -d -p 3000:3000 --name=grafana grafana/grafana
```
打开 Web 浏览器，访问 `http://localhost:3000`，使用默认的 `admin`/`admin` 用户名和密码登录。
在左边，导航到“<ruby> 配置 <rt> Configuration </rt></ruby>-><ruby> 数据源 <rt> Datasources </rt></ruby>”，点击“<ruby> 添加数据源 <rt> Add Datasource </rt></ruby>”按钮，然后选择 “Loki”。
对于 URL，你应该可以使用 `http://localhost:4100`（然而，在我的 WSL2 机器上，我必须使用计算机的实际 IP 地址）。
单击“<ruby> 保存并测试 <rt> Save and Test </rt></ruby>”。你应该看到连接了数据源并找到了标签。
点击左边的“<ruby> 管理器 <rt> Explore </rt></ruby>”图标，确保选择 Loki 数据源，并尝试这个查询：
```
{job="shell"}
```
如果发送 shell 命令的主机较多，可以使用“<ruby> 主机 <rt> Host </rt></ruby>”标签将结果限制在某个主机上：
```
{job="shell", hostname="myhost"}.
```
你也可以用过滤表达式寻找特定的命令：
```
{job="shell"} |= "docker"
```
或者你可以从日志中探索度量的世界，看看你使用 shell 的频率：
```
rate({job="shell"}[1m])
```
想从一个事件中重建一个时间线？你可以通过特定的命令进行过滤，查看它的运行时间：
要想知道你还能做什么，并了解更多关于 Loki 查询语言的信息，请查看 LogQL 指南。
### 总结
更多的想法、故障排除和更新，请关注该 GitHub 版本库。这仍然是一项正在进行中的工作，所以请在那里报告发现的任何问题。
要了解更多关于 Loki 的信息，请查看文档、博客文章和该 GitHub 版本库，或者在 Grafana Cloud 中试用。
---
特别感谢我的同事 Jack Baldry 为这个想法播下的种子。我有 Loki 的知识来实现这个想法，但如果不是他的建议，我想我永远也不会做到这一点。
---
via: <https://opensource.com/article/20/10/shell-history-loki-fzf>
作者：[Ed Welch](https://opensource.com/users/ewelch) 选题：[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/) 荣誉推出
|
使用 tqdm 在 Python 应用中显示进度 | Moshe Zadka | https://opensource.com/article/20/12/tqdm-python | 如果你的程序需要一段时间才能显示结果，可通过显示它的进度来避免让用户感到沮丧。 | /data/attachment/album/202101/06/230842thi8skahe68dqa3m.jpg.thumb.jpg | /data/attachment/album/202101/06/230842thi8skahe68dqa3m.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Python"
] | 软件开发 | {
"viewnum": 3734,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 如果你的程序需要一段时间才能显示结果，可通过显示它的进度来避免让用户感到沮丧。 | 2021-01-06T23:08:54 | 2021-01-06T23:08:54 | 12,990 | /article-12990-1.html |
>
> 如果你的程序需要一段时间才能显示结果，可通过显示它的进度来避免让用户感到沮丧。
>
>
>
阿拉米语，希伯来语和阿拉伯语中的闪米特语根 *q-d-m* 通常与前进或进度有关。阿拉伯语 *taqaddum* （تقدّم）的意思是“进度”。进度是很重要的。正如每部感觉良好的电影都会告诉你，旅程和目的地同样重要。
大多数程序都有一个明确的目标，一个期望的最终状态。有时，计算这个最终状态可能需要很长的时间。虽然计算机没有感情不在乎，但人却在乎。人类并不乐意坐在原地等待，而看不到任何明显的进展迹象。疑问不断蔓延。程序崩溃了吗？磁盘性能是否抖动？操作系统是否把所有的计算资源都分配给了其他任务？
就像正义一样，进度必须被看到，而不仅仅是完成。Python 库 [tqdm](https://pypi.org/project/tqdm/) 有助于使进度变得明确。
`tqdm` 模块可在控制台下工作，但它也专门支持了我最喜欢的环境之一 Jupyter。要在 Jupyter 中使用 `tqdm`，你需要导入 `notebook` 子模块并安装 [ipywidgets](https://opensource.com/article/20/11/daily-journal-jupyter)。`notebook` 子模块与 `tqdm` 接口兼容。
这意味着你可以做一些导入时操作来导入正确的模块，同时保持 `tqdm` 的用法不变。诀窍是检查 `__main__` 模块是否具有全局变量 `get_ipython`。虽然这只是一个启发式的方法，但却是一个相当准确的方法：
```
import sys
if hasattr(sys.modules["__main__"], "get_ipython"):
from tqdm import notebook as tqdm
else:
import tqdm
```
最简单的情况是，某件事情需要运行一定的迭代次数（事先已知），而每一次迭代的时间都差不多。例如，有一个计算任何数字的平方根的算法，通过从 1 作为猜测值开始，然后计算出一个改进后的猜测值：
```
def improve_guess(rt, n):
return (rt + n/rt) / 2
```
一点点的改进可以让你更加接近该平方根。例如，你可以计算 2 的平方根：
```
guess = 1
target = 2
for i in tqdm.trange(10):
guess = improve_guess(guess, target)
```
精确了到小数点后 10 位！
```
round(2 - guess*guess, 10)
```
```
0.0
```
一个稍微复杂一点的例子是，当元素的数量是已知的，而处理每个元素需要类似的时间。例如，你可以计算一些数字的乘积。为此，你需要一些随机数：
```
import random
numbers = [random.uniform(0, 2.8) for i in range(100)]
numbers[:5]
```
```
[2.6575636572230916,
0.1286674965830302,
1.0634250104041332,
1.1760969844376505,
0.45192978568125486]
```
现在有了这些数字，可以将它们相乘了。使用 `tqdm` 最简单的方法是包装一个 Python 迭代函数。数值是一样的，但是 `tqdm` 会显示一个进度条：
```
result = 1
for num in tqdm.tqdm(numbers):
result *= num
result
```
```
2.4081854901728303
```
然而，并不是所有的事情都可以预测。最不容易预测的事情之一就是网络速度。当你下载一个大文件时，衡量进度的唯一方法就是检查已经下载了多少：
```
url = "https://www.python.org/ftp/python/3.9.0/Python-3.9.0.tgz"
import httpx
with httpx.stream("GET", url) as response:
total = int(response.headers["Content-Length"])
with tqdm.tqdm(total=total) as progress:
for chunk in response.iter_bytes():
progress.update(len(chunk))
```
有时，“嵌套”进度条是有意义的。例如，如果你要下载一个目录，你就需要一个进度条来跟踪文件，并为每个文件设置一个进度条。
下面是一个例子（但没有实际下载一个目录）：
```
files = [f"vid-{i}.mp4" for i in range(4)]
for fname in tqdm.tqdm(files, desc="files"):
total = random.randrange(10**9, 2 * 10**9)
with tqdm.tqdm(total=total, desc=fname) as progress:
current = 0
while current < total:
chunk_size = min(random.randrange(10**3, 10**5), total - current)
current += chunk_size
if random.uniform(0, 1) < 0.01:
time.sleep(0.1)
progress.update(chunk_size)
```
所以，如果你的程序需要一段时间才能显示最终结果，为避免让你的用户感到沮丧。请显示它的进度！
---
via: <https://opensource.com/article/20/12/tqdm-python>
作者：[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/) 荣誉推出
|
学习使用 Sed 文本编辑器 | Seth Kenlon | https://opensource.com/article/20/12/sed | Sed 缺少通常的文本框，而是按照用户的命令直接写入到文件上。 | /data/attachment/album/202101/07/002353st8vgivu78yzp77v.jpg.thumb.jpg | /data/attachment/album/202101/07/002353st8vgivu78yzp77v.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"sed"
] | 技术 | {
"viewnum": 17347,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "112.102.212.17",
"message": "这可能正是用S语言实现的jed为什么不叫sed的原因",
"username": "来自黑龙江哈尔滨的 Chrome 87.0|Windows 10 用户",
"date": "2021-01-08T16:19:59"
}
] | [
{
"raid": 12982,
"displayorder": 0
},
{
"raid": 12993,
"displayorder": 0
}
] | Sed 缺少通常的文本框，而是按照用户的命令直接写入到文件上。 | 2021-01-07T00:24:17 | 2021-01-07T00:24:17 | 12,992 | /article-12992-1.html |
>
> Sed 缺少通常的文本框，而是按照用户的命令直接写入到文件上。
>
>
>
`sed` 命令是为 AT&T 最初的 Unix 操作系统第 7 版创建的，此后，可能每一个 Unix 和 Linux 操作系统都包含了它。`sed` 应用程序是一个 *流编辑器*，与文本编辑器不同的是，它不会打开一个视觉缓冲区，将文件的数据加载到其中进行处理。相反，它根据在终端输入的命令或脚本中的一系列命令，逐行对文件进行操作。
### 安装
如果你使用的是 Linux、BSD 或 macOS，那么你已经安装了 GNU 或 BSD 版的 `sed`。这是两个不同的原始 `sed` 命令的重新实现，虽然它们很相似，但也有一些小的区别。GNU `sed` 通常被认为是功能最丰富的 `sed`，而且它在这些平台上都可以广泛使用。
如果你找不到 GNU `sed`（在非 Linux 系统上通常被称为 `gsed`），那么你可以[从 GNU 网站上下载它的源代码](http://www.gnu.org/software/sed/)。安装 GNU `sed` 的好处是，可以使用它的额外功能，但它也可以被限制为只符合 `sed` 的 [POSIX](https://opensource.com/article/19/7/what-posix-richard-stallman-explains) 规范，如果你需要移植性的话。
在 Windows 上，你可以用 [Chocolatey](https://opensource.com/article/20/3/chocolatey) 来[安装](https://chocolatey.org/packages/sed) GNU `sed`。
### Sed 如何工作
`sed` 应用程序一次只处理一行。因为它没有视觉显示，所以它在内存中创建了一个模式空间：一个包含输入流的当前行的空间（去掉任何尾部的换行符）。一旦填充了模式空间，你对 `sed` 的指令就会被执行。有时你的指令是有条件的，有时是无条件的，所以这些指令的结果取决于你如何使用 `sed`。
当命令结束时，`sed` 会将模式空间的内容打印到输出流中。默认的输出流是**标准输出**，但可以将其重定向到一个文件，甚至使用 `--in-place=.bak` 选项重定向到同一个文件中。
然后再从下一个输入行开始循环。
`sed`命令的语法是：
```
$ sed --options [optional SCRIPT] [INPUT FILE or STREAM]
```
#### 找到你要编辑的内容
在可视化编辑器中，你通常不需要考虑太多，就能在文本文件中找到你想要修改的内容。你的眼睛（或屏幕阅读器）会扫描文本，找到你想改变的单词或你想插入或删除文本的地方，然后你就可以开始输入了。而 `sed` 没有交互模式，所以你需要告诉它必须满足什么条件才能运行特定的命令。
在这些例子中，假设一个名为 `example.txt` 的文件包含了这样的文字：
```
hello
world
This is line three.
Here is the final line.
```
#### 行号
指定行号告诉 `sed` 只对文件中的那一行进行操作。
例如，下面这条命令选择文件的第 1 行并打印出来。因为 `sed` 在处理后的默认操作也是打印一行到**标准输出**，这样做的效果就是重复第一行：
```
$ sed '1p' example.txt
hello
hello
world
This is line three.
Here is the final line.
```
你也可以步进式指定行号。例如，`1~2` 表示每两行选择一行（“从第一行开始每两行选择一行”）。指令 `1~3` 表示从第一行开始，每三行选择一行：
```
$ sed '1p' example.txt
hello
hello
world
This is line three.
Here is the final line.
Here is the final line.
```
#### 行定位
你可以通过使用 `$` 作为选择器，只对文件的最后一行进行操作：
```
$ sed '$p' example.txt
hello
world
This is line three.
Here is the final line.
Here is the final line.
```
在 GNU `sed` 中，你可以选择多行（例如，`sed '1,$p'` 打印第一行和最后一行）。
#### 反转
任何数字或位置的选择，你都可以用感叹号（`!`）字符反转。下面这将选择除第一行以外的所有行：
```
$ sed '1!p' example.txt
hello
world
world
This is line three.
This is line three.
Here is the final line.
Here is the final line.
```
#### 模式匹配
你可以把模式匹配想象成文字处理器或浏览器中的**查找**操作。你提供一个词（一个 *模式*），然后选择了结果。模式匹配的语法是 `/pattern/`：
```
$ sed '/hello/p' example.txt
hello
hello
world
This is line three.
Here is the final line.
$ sed '/line/p' example.txt
hello
world
This is line three.
This is line three.
Here is the final line.
Here is the final line.
```
### 用 Sed 编辑
一旦你找到了你要编辑的内容，你就可以执行你想要的任何操作。你可以用 `sed` 中的命令来执行编辑。`sed` 中的命令不是 `sed` 命令本身。如果这样说有帮助的话，可以把它们看作是“动作”或“动词”或“指令”。
`sed` 中的命令是单个字母，例如前面例子中使用的**打印**命令的 `p`。它们一开始可能很难记忆，但和所有事情一样，你会随着练习而了解它们。
#### p 代表打印
`p` 指令打印当前模式空间中的任何内容。
#### d 用于删除
`d` 指令删除模式空间：
```
$ sed '$d' example.txt
hello
world
This is line three.
$ sed '1d' example.txt
world
This is line three.
Here is the final line.
```
#### s 用于搜索和替换
`s` 命令搜索一个模式并将其替换为其他东西。这可能是 `sed` 最流行和最随意的用法，而且它通常是用户学习的第一个（有时也是唯一的）`sed` 命令。几乎可以肯定它是文本编辑中最有用的命令：
```
$ sed 's/world/opensource.com/' example.txt
hello
opensource.com
This is line three.
Here is the final line.
```
在你的替换文本中，也可以使用一些特殊的功能。例如，`\L` 将替换文本转换为小写，`\l` 则只转换下一个字符。还有其他一些功能，列在 `sed` 文档中（你可以用 `info sed` 命令查看）。
替换子句中的特殊字符 `&` 指的是匹配到的模式：
```
$ sed 's/is/\U&/' example.txt
hello
world
ThIS is line three.
Here IS the final line.
```
你也可以通过特殊的标志来影响 `s` 如何处理它找到的内容。`g`（应该是指 *全局*）标志告诉 `s` 对行上找到的所有匹配项进行替换，而不仅仅是第一个匹配项：
```
$ sed 's/is/\U&/g' example.txt
hello
world
ThIS IS line three.
Here IS the final line.
```
其他重要的标志还包括用一个数字来表示要影响第几个出现的匹配模式：
```
$ sed 's/is/\U&/2' example.txt
hello
world
This IS line three.
Here is the final line.
```
`w` 标志，后面跟着一个文件名，\_只有\_在有变化的情况下，才会将匹配的行写入文件：
```
$ sed 's/is/\U&/w sed.log' example.txt
hello
world
ThIS is line three.
Here IS the final line.
$ cat sed.log
ThIS is line three.
Here IS the final line.
```
标志可以组合：
```
$ sed 's/is/\U&/2w sed.log' example.txt
hello
world
This IS line three.
Here is the final line.
$ cat sed.log
This IS line three.
```
### 脚本
有很多很棒的网站都有 `sed` “单行脚本”，它们给你提供了面向任务的 `sed` 命令来解决常见的问题。然而，自己学习 `sed` 可以让你写出自己的单行脚本，而且这些单行脚本可以根据你的具体需求来定制。
`sed` 的脚本可以在终端中写成一行，也可以保存到文件中，然后用 `sed` 本身执行。我倾向于把小脚本写成一个命令，因为我发现自己在现实生活中很少重复使用 `sed` 命令。当我写一个 `sed` 脚本时，通常都是针对一个文件的。例如，在写完这篇文章的初稿后，我用 `sed` 来规范 “sed” 的大小写，而这是我可能永远也不会再做的任务。
你可以向 `sed` 发出一系列不同的命令，用分号（`;`）分开。
```
$ sed '3t ; s/line/\U&/' example.txt
hello
world
This is LINE three.
This is the final line.
```
### 带括号的范围改变
你也可以用大括号（`{}`）限制哪些结果受到影响。当你将 `sed` 命令用大括号括起来时，它们只适用于特定的选择。例如，“line” 字出现在样本文本的两行中。你可以通过声明所需的匹配条件（`$` 表示最后一行），并将你希望执行的 `s` 命令放在紧随其后的括号中，强制 `sed` 只影响最后一行：
```
$ sed '$ {s/line/\U&/}' example.txt
hello
world
This is line three.
This is the final LINE.
```
### 学习 Sed
你可以用 `sed` 做的事情比本文所解释的多得多。我甚至还没有涉及到分支（`b`）、测试（`t`）、保留空格（`H`）和许多其他功能。就像 [ed](https://opensource.com/article/20/12/gnu-ed) 一样，`sed` 可能不是你要用来创建文档的文本编辑器，甚至不是你需要做的每一个脚本任务中使用的文本编辑器，但它是你作为 POSIX 用户的一个强大的选择。学习 `sed` 命令的结构以及如何编写简短的脚本可以快速修改大量的文本。阅读 GNU `sed` 的`info` 页面，或者 BSD `sed` 的手册页，看看 `sed` 能为你做什么。
---
via: <https://opensource.com/article/20/12/sed>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
学习在 Linux 上使用 JOE 文本编辑器 | Seth Kenlon | https://opensource.com/article/20/12/joe | Joe's Own Editor （JOE）是一款简单易学和使用的通用文本编辑器。 | /data/attachment/album/202101/07/233204ps2fl3fffgmxzxqg.jpg.thumb.jpg | /data/attachment/album/202101/07/233204ps2fl3fffgmxzxqg.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"joe",
"编辑器"
] | 分享 | {
"viewnum": 5658,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "160.20.52.131",
"message": "bisqwit直播写代码的时候用的就是JOE",
"username": "来自澳大利亚的 Chrome 87.0|Windows 10 用户",
"date": "2021-01-18T09:37:12"
}
] | [
{
"raid": 12992,
"displayorder": 0
},
{
"raid": 13002,
"displayorder": 0
}
] | Joe's Own Editor （JOE）是一款简单易学和使用的通用文本编辑器。 | 2021-01-07T23:32:38 | 2021-01-07T23:32:38 | 12,993 | /article-12993-1.html |
>
> Joe's Own Editor （JOE）是一款简单易学和使用的通用文本编辑器。
>
>
>
我很喜欢那些能让你轻松学会如何使用的文本编辑器。GNU nano 是我最喜欢的例子：你启动 nano，你会在整个会话的窗口底部看到一个最常用的命令列表。Joe's Own Editor（简称 `joe`）是另一个很好的例子。
`joe` 编辑器使用了一个基于终端的界面，提供了简单的文本编辑功能和一个易于访问的帮助屏幕。它用 C 语言编写，体积小，只对 libc 有硬性依赖（ncurses 是可选的），并且采用 GPL 许可证。
### 安装
在 Linux 上，你也许能在你的发行版软件仓库中找到 JOE。虽然它有点小众，并不是所有的发行版都打包了它。如果是这样的话，你可以从 [SourceForge](https://joe-editor.sourceforge.io/) 下载源码，然后自己编译。这是个简单的过程：
```
$ ./configure
$ make
$ sudo make install
```
### 使用 JOE
据其作者介绍，JOE 的灵感来自于一个叫 WordStar 的应用和 [GNU Emacs](https://opensource.com/article/20/12/emacs)。它的大部分基本编辑键都与 WordStar 的快捷键相同，编辑器本身也在努力向 WordStar 靠拢。JOE 也有 GNU Emacs 的一些键绑定和功能。这种两种灵感来源的混合有时会让人迷惑，但话又说回来，在任何情况下，让自己离开 Emacs（或你通常选择的文本编辑器）都会让人迷惑。重要的是，JOE 提供了帮助，而且很容易访问。
在 JOE 界面右上角，有一个持续的提示，你可以按 `Ctrl+K`，紧接着按 `H` 来查看帮助界面。这是一个切换键，所以一旦你激活它，帮助屏幕就会一直显示在你的编辑器窗口顶部，直到用同样的组合键（JOE 中的键盘符号为 `^KH`）解除。
### 键盘快捷键
尽管 JOE 的作者在模拟 WordStar 用户体验方面非常自豪，但我不得不承认，这对我来说是失落的。我从来没有听说过 WordStar，直到我在 JOE 的文档中读到了它，在我看来，它的键盘快捷键方案完全是任意的。有的用 `Ctrl+K` 作为转义序列的前缀，有的用 `Esc` 作为前缀，还有的完全不需要转义序列。我无法确定其中的逻辑。编辑操作和应用选项一样，都有可能需要或不需要转义序列，而且字母关联对我来说是没有什么意义（例如，`Ctrl+K D` 代表**另存为**）。
幸运的是，JOE 可以让你在键盘快捷键上作弊。安装后，JOE 会悄悄为 `joe` 可执行文件创建一些符号链接。包括：
* `jmacs` JOE 使用 Emacs 键绑定
* `jpico` JOE 使用 Pico （或 GNU nano） 键绑定
* `rjoe` JOE 的编辑只限于启动时传递给 JOE 的文件
* `jstar` JOE 使用 WordStar 键绑定
持久保留的帮助菜单仍然存在，所以如果你不清楚有哪些功能可以使用，可以通过屏幕右上方的帮助提示来参考。当然，在 Pico/nano 模式下，主要命令总是可见的。
### 尝试 JOE
JOE 并不是一个你永远不会离开的文本编辑器，它不会成为你的 IDE、电子邮件客户端、网络浏览器和文件管理器。事实上，它甚至可能不是你所有任务的主要文本编辑器。它专注于做好一件事，那就是成为一般的文本编辑。
JOE 拥有你所需要的所有基本功能，比如能够快速浏览你的文本、能够选择文本、复制和粘贴等等。试试 JOE 吧，使用你喜欢的符号链接。
---
via: <https://opensource.com/article/20/12/joe>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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 入门：术语基础 | Matthew Broberg | https://opensource.com/article/19/2/git-terminology | 想学习 Git？看看这个最重要的术语和命令的快速总结。 | /data/attachment/album/202101/08/171156gu9l8dvulxmxom6d.jpg.thumb.jpg | /data/attachment/album/202101/08/171156gu9l8dvulxmxom6d.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Git"
] | 软件开发 | {
"viewnum": 3873,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 想学习 Git？看看这个最重要的术语和命令的快速总结。 | 2021-01-08T17:12:05 | 2021-01-08T17:12:05 | 12,994 | /article-12994-1.html |
>
> 想学习 Git？看看这个最重要的术语和命令的快速总结。
>
>
>
如今，对于任何希望跟踪他们的变化的人来说，版本控制是一个重要的工具。它对程序员、系统管理员和<ruby> 网站可靠性工程师 <rt> site reliability engineers </rt></ruby>（SRE）都特别有用。确保可以从错误中恢复到已知的良好状态是一个巨大的胜利，比以前给复制的文件添加 `.old` 后缀的策略更友好。
但学习 Git 这件事往往被告诉大家“投身开源”的好心同行们过度简化了。在你还不明白之前，就有人要你给一个从<ruby> 上游 <rt> upstream </rt></ruby> <ruby> 变基 <rt> rebase </rt></ruby>的<ruby> 拉取请求 <rt> pull request </rt></ruby>（PR）或<ruby> 合并请求 <rt> merge request </rt></ruby>（MR），然后他们才能从你的<ruby> 远程版本库 <rt> remote </rt></ruby>合并 —— 而且一定会删除<ruby> 合并提交 <rt> merge commits </rt></ruby>。无论你想给开源项目做出什么好的贡献，当你看到这些你不认识的单词时，都会觉得难以融入。
* [下载](https://opensource.com/downloads/cheat-sheet-git) 我们的 Git 速查表。
如果你有一两个月的时间和足够的好奇心，[Git SCM](https://git-scm.com/about) 是你需要学习所有术语的权威来源。但如果你正在寻找来自实践的总结，请继续阅读。
### 提交就是提醒
对我来说，Git 最难理解的部分是 Git 最简单的概念：一个<ruby> 提交 <rt> commit </rt></ruby>就是一个内容的集合，包括一个关于描述的信息，以及之前的提交。没有固有的代码发布策略，甚至没有内置的明确建议。这个内容甚至不一定是代码 —— 可以是*任何*你想添加到版本库的东西。<ruby> 提交消息 <rt> commit message </rt></ruby>会对这些内容进行注释。
我喜欢把提交信息看作是给未来的自己的礼物：它可能会提到你编辑的文件，但更重要的是它提醒你修改这些文件的意图。添加更多关于你为什么编辑这些内容的信息，可以帮助任何使用你的版本库的人，即使那个人是你。
### origin/master 在哪里？
要知道自己在 Git 项目中的位置，首先把它想成一棵树。所有 Git 项目都有一个根目录，类似于文件系统的根目录。所有的提交都是这个根目录下的分支。这样一来，分支只是一个提交的指针。按照惯例，`master` 是根目录下默认的分支名称。（LCTT 译注：世界变得快，原文发表于 2019 年，而现在有些地方开始用 `main` 替代这个名字。）
由于 Git 是一个分布式的版本控制系统，同一个代码库分布在多个地方，所以人们经常用<ruby> 版本库 <rt> repository </rt></ruby>这个词来表示同一个项目的所有副本。（LCTT 译注：“repository” 英文原意是仓库、存储库，在计算机环境中，常用于版本控制、软件分发等方面，有时候会统一译作“仓库”、“存储库”。但我们认为，应该根据不同语境采用更有指向性的译法。在 Git 等版本控制语境中，采用“版本库”；在软件分发方面，采用“软件库”；其它泛指或不确定的语境中，可采用“仓库”、“存储库”译法。）有<ruby> 本地版本库 <rt> local repository </rt></ruby>，这是你编辑代码的地方（稍后会有更多的介绍），还有<ruby> 远程版本库 <rt> remote repository </rt></ruby>，这是你完成后想把代码发送到的地方。远程版本库可以在任何地方，甚至在你的本地版本库所在的同一台计算机上，但它们通常托管在 GitLab 或 GitHub 等版本库服务上。
### 我在哪里？
虽然不是官方的卖点，但迷路也是 Git 仓库的“乐趣”之一。你可以通过这套可靠的命令来找到自己的方向：
* `git branch` —— 找到你所在的分支。
* `git log` —— 查看你正在进行的提交。
* `git status` —— 查看自上次提交以来你所做的编辑。
* `git remote` —— 查看你正在跟踪的远程仓库。
用这些命令来定位自己的方向，当你被卡住的时候，会让你有一种方向感。
### 我是否已将我的提交暂存或缓存起来？
你电脑上的代码俗称为你的<ruby> 工作空间 <rt> workspace </rt></ruby>。但不是很明显的是，当你在 Git 仓库中时，你还有两个（是的，两个！）其他位置：<ruby> 索引 <rt> index </rt></ruby>和<ruby> 暂存 <rt> stash </rt></ruby>。当你写了一些内容，然后**添加**时，你是把它添加到索引中，也就是准备提交的缓存内容。有的时候，你的索引中的文件还没有准备好提交，但你想查看另一个分支。这时，暂存就派上用场了。你可以使用 `git stash` 将索引了但尚未提交的文件存储到暂存区中。当你准备好取回文件时，运行 `git stash pop` 将更改带回索引中。
下面是一些你需要使用暂存区和缓存区的命令：
* `git diff ...origin/master` —— 显示最近的本地提交和远程的 `origin` 版本库的 `master` 分支之间的差异。
* `git diff --cached` —— 显示最近的本地提交与添加到本地索引的内容之间的任何差异。
* `git stash` —— 将索引的（已添加但未提交的）文件放在暂存区堆栈中。
* `git stash list` —— 显示暂存区堆栈中的变化。
* `git stash pop` —— 将最近的变化从暂存库中删除。
### 无头骑士
Git 里面有各种比喻。当我想到 `HEAD` 是哪里的时候，我就会想到火车线路。如果你最终处于<ruby> 脱离的 HEAD <rt> detached HEAD </rt></ruby>模式，就意味着你已经脱离了这个隐喻的轨道。
`HEAD` 是指向当前签出分支中最近一次提交的指针。默认的“签出checkout”是指当你创建一个 Git 仓库并进入到 `master` 分支的时候。每次创建或修改到另一个分支时，你都会切换到该分支行。如果你在当前分支的某处进行 `git checkout <commit>`，`HEAD` 就会移动到该提交。如果没有提交历史记录将你的当前提交连接到已签出的提交，那么你将处于脱离的 `HEAD` 状态。如果你找不到 `HEAD` 的位置，你可以随时用 `git reset --hard origin/master` 来删除修改，回到已知状态。*警告：这将删除你上次推送到 `master` 后的任何改动。*
### 你是上游还是下游？
你的项目的本地副本被认为是你的本地版本库，它可能有也可能没有远程版本库 —— 远程版本库的副本是用于协作或保存的。也可能还有一个<ruby> 上游 <rt> upstream </rt></ruby>版本库，在那里，项目的第三个副本由不同的贡献者托管和维护。
例如，假设我想为 Kubernetes 做贡献。我会首先将 `kubernetes/kubernetes` 项目<ruby> 复刻 <rt> fork </rt></ruby>到我的账户下 `mbbroberg/kubernetes`。然后我会将我的项目克隆到我的本地工作区。在这种情况下，我的本地克隆是我的本地仓库，`mbbroberg/kubernetes` 是我的远程仓库，`kubernetes/kubernetes` 是上游。
### 合并的隐喻
当你深入 Git 分支时，根系统的视觉效果就会和火车轨道的形象合二为一。分支通常被用作开发一个新功能的方式，最终你想把它<ruby> 合并 <rt> merge </rt></ruby>到主分支中。当这样做时，Git 会按顺序保留共同的提交历史，然后将你的分支的新提交追加到历史中。这个过程有一大堆的细节：是否<ruby> 变基 <rt> rebase </rt></ruby>，是否添加一个<ruby> 合并提交 <rt> merge commit </rt></ruby>，[Brent Laster](https://opensource.com/users/bclaster) 在《[如何在 Git 中重置、恢复和返回之前的状态](https://opensource.com/article/18/6/git-reset-revert-rebase-commands)》中会有更详细的探讨。
### 我想现在就去 Git
要掌握 Git 命令的世界，有大量的术语和需要探索的地方。我希望这篇关于日常使用术语的第一人称探索能帮助你适应这一切。如果你觉得自己被卡住了或者遇到了挫折，欢迎在 Twitter [@mbbroberg](https://twitter.com/mbbroberg) 上联系我。
#### 回顾
* <ruby> 提交 <rt> Commit </rt></ruby> —— 将当前索引的内容保存在一个新的提交中，并附上用户描述更改的日志信息。
* <ruby> 分支 <rt> Branch </rt></ruby> —— 指向一个提交的指针。
* `master` —— 第一个分支的默认名称。
* `HEAD` —— 指向当前分支上最近一次提交的指针。
* <ruby> 合并 <rt> Merge </rt></ruby> —— 合并两个或多个提交的历史。
* <ruby> 工作空间 <rt> Workspace </rt></ruby> —— Git 仓库本地副本的通俗名称。
* <ruby> 工作树 <rt> Working tree </rt></ruby> —— 工作区中的当前分支；任何时候你都可以在 `git status` 的输出中看到这个。
* <ruby> 缓存 <rt> Cache </rt></ruby> —— 用于临时存储未提交的变更的空间。
* <ruby> 索引 <rt> Index </rt></ruby> —— 变更提交前存储其变化的缓存。
* 跟踪和未跟踪的文件 —— 没有被索引缓存的文件或尚未加入其中的文件。
* <ruby> 暂存 <rt> Stash </rt></ruby> —— 另一个缓存，作为一个堆栈，在这里可以存储更改而不需要提交它们。
* `origin` —— 远程版本库的默认名称。
* <ruby> 本地仓库 <rt> Local repository </rt></ruby> —— 也就是你在工作站上保存 Git 仓库副本的地方。
* <ruby> 远程存储库 <rt> Remote repository </rt></ruby> —— Git 存储库的第二副本，你可以在这里推送变更以便协作或备份。
* <ruby> 上游存储库 <rt> Upstream repository </rt></ruby> —— 你跟踪的远程存储库的通俗说法。
* <ruby> 拉取请求 <rt> Pull request </rt></ruby> —— 这是 GitHub 的专用术语，用于让其他人知道你推送到仓库分支的变化。
* <ruby> 合并请求 <rt> Merge request </rt></ruby> —— 这是 GitLab 的专用术语，用于让其他人知道你推送到仓库分支的变化。
* `origin/master` —— 远程版本库及其主要分支的默认名称。
后记：双关语是 Git 最好的部分之一，愿你喜欢。
---
via: <https://opensource.com/article/19/2/git-terminology>
作者：[Matthew Broberg](https://opensource.com/users/mbbroberg) 选题：[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/) 荣誉推出
|
2021 的 8 个开源软件速查表 | Jim Hall | https://opensource.com/article/21/1/cheat-sheets | 当那个讨厌的命令就在你的指间，但是就是想不起来，一个方便的速查表就可以拯救你。这份速查表清单涵盖了从编程语言到协作工具的各种内容。 | /data/attachment/album/202101/09/131938ktycoc99i2l6dlly.jpg.thumb.jpg | /data/attachment/album/202101/09/131938ktycoc99i2l6dlly.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"速查表"
] | 分享 | {
"viewnum": 6080,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
} | [] | [] | 当那个讨厌的命令就在你的指间，但是就是想不起来，一个方便的速查表就可以拯救你。这份速查表清单涵盖了从编程语言到协作工具的各种内容。 | 2021-01-09T13:19:53 | 2021-01-09T13:19:53 | 12,996 | /article-12996-1.html |
>
> 当那个讨厌的命令就在你的指间，但是就是想不起来，一个方便的速查表就可以拯救你。这份速查表清单涵盖了从编程语言到协作工具的各种内容。
>
>
>
有时候，你需要一个简短的提示。你知道自己想做什么，但就是想不起具体怎么做。这时候速查表就派上用场了。在这篇文章中，我给大家提供了 MariaDB 和 MySQL 的速查表。这个速查表对于偶尔使用数据库的人来说是非常有用的。接下来，我列出了两个树莓派速查表。第一张可以让你入门这台单板计算机。一旦你有了一定的基础知识，就可以把它变成一个家庭实验室，可以开始使用 Kubernetes 进行容器管理。一定要同时看看下一张速查表，因为它涵盖了 `kubectl` 工具。接下来，有一个很棒的 Emacs 的速查表，以及还有一个 C 编程语言的速查表。最后，这个列表以两个非常实用的速查表结束：协作工具和开源替代品。
下面是这份清单：
### MariaDB 和 MySQL 速查表
MariaDB 是一个企业级数据库。学习 MariaDB 是使用它来管理 Web 应用程序或编程语言库的重要一步。这个 [MariaDB 和 MySQL 速查表](https://opensource.com/downloads/mariadb-mysql-cheat-sheet)涵盖了连接到服务器、分析数据和其他关键活动的有用命令。本速查表上的命令对交互式提示符和 SQL 脚本有效，但很多内容推断可以用于编程库。
### 树莓派：如何入门
自 2012 年以来，树莓派一直是学习编程技能、构建硬件项目、进行家庭自动化和创建应用程序的必备工具。它实惠的价格使它对任何技能水平的开源爱好者都有吸引力。这本[可下载的指南](https://opensource.com/downloads/raspberry-pi-guide)将为你提供挑选树莓派、保持更新、使用它进行 Linux 游戏、为社区做贡献等方面的提示，让你获得成功。
### 在你的树莓派家庭实验室上运行 Kubernetes
由于树莓派单板计算机的经济性和多功能性，建立一个家庭实验室变得越来越容易。你可以用树莓派做成千上万的事情，包括实验 Kubernetes。在这本[电子书](https://opensource.com/downloads/kubernetes-raspberry-pi)中，作者 [Chris Collins](https://opensource.com/users/clcollins) 演示了如何开始在树莓派上运行 Kubernetes。本指南的每个部分都可以单独学习，也可以作为一个整体项目来学习。无论你的日常工作是什么，阅读这些教程并按照自己的节奏进行尝试，一定会提升你的云技术实力。
### kubectl 速查表
`kubectl` 是维护 Kubernetes 集群的强大命令行工具。这个 2 页的[速查表](https://opensource.com/downloads/kubectl-cheat-sheet)涵盖了常用的命令，让你超越一般的集群管理。它分为三个不同的部分，包括基本命令、故障排除命令和高级命令。掌握这九个关键的 `kubectl` 命令，可以帮助你排除故障和管理 Kubernetes 集群。
### Emacs 速查表
要记住每一个 Emacs 的快捷键几乎是不可能的。通过这个[速查表](https://opensource.com/downloads/emacs-cheat-sheet)，你可以熟悉最常见的组合，从而提高工作效率。当你有这个指南在身边时，你可以不用担心忘记 Emacs 键盘快捷键。通过学习这个速查表中演示的基本键盘快捷键，成为 Emacs 高手。
### C 语言编程速查表
C 是一种直接的编译编程语言。许多其他编程语言从 C 语言中借用了概念，如果你想学习 Lua、C++、Java 或 Go 等编程语言，C 语言是一个很好的起点。Jim Hall 的这份双面[速查表](https://opensource.com/downloads/c-programming-cheat-sheet)包含了所有的基础知识，因此你可以立即获得 C 语法的所有要领。通过下载这个速查表来学习 C 语言，并将语法要领随身携带。
### 5 个开源协作工具
[Kevin Sonney](https://opensource.com/users/ksonney) 的生产力指南通过[五个开源工具教程](https://opensource.com/downloads/collaboration-tools-ebook)让协作变得轻而易举。下载的速查表所涉及的工具包括开源邮件客户端、Google Docs 的替代方案等。让团队沟通不畅成为过去，迎接团队生产力的提升。
### 开放源码软件替代方案速查表
在我们广阔的开源世界里，有很多通用的专有软件工具的替代品。然而，有时要找到合适的开源替代品以满足你的特定需求是令人生畏的。这就是为什么我们整理了这一页的[速查表](https://opensource.com/downloads/open-source-software-alternatives-cheat-sheet)，涵盖了主要的软件工具类别，包括团队聊天、文件共享、文字处理等。我们并没有止步于办公工具。我们还包括游戏、社交媒体和个人理财的顶级开源应用。通过这个速查表，可以快速找到常见的专有软件工具的替代品。
### 总结
这个列表涵盖了很多主题。在我们的[下载页面](https://opensource.com/downloads/cheat-sheets)上可以查看更多的速查表和指南。请在下面的评论中告诉我们你最喜欢的是哪一个。不要忘了为你最喜欢的开源工具写和提交速查表。
---
via: <https://opensource.com/article/21/1/cheat-sheets>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 选题：[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/) 荣誉推出
|
使用 Nextcloud 中的 Markdown 编辑器应用 | Seth Kenlon | https://opensource.com/article/20/12/nextcloud-markdown | Nextcloud 拥有流行的 Markdown 文件的最流畅的编辑器之一，它有很多方便和直观的功能。 | /data/attachment/album/202101/09/164849mofte5zy5ryuewax.jpg.thumb.jpg | /data/attachment/album/202101/09/164849mofte5zy5ryuewax.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Markdown",
"Nextcloud"
] | 分享 | {
"viewnum": 5992,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | Nextcloud 拥有流行的 Markdown 文件的最流畅的编辑器之一，它有很多方便和直观的功能。 | 2021-01-09T16:49:02 | 2021-01-09T16:49:02 | 12,997 | /article-12997-1.html |
>
> Nextcloud 拥有流行的 Markdown 文件的最流畅的编辑器之一，它有很多方便和直观的功能。
>
>
>
纯文本的好处是，没有额外的针对计算机的信息会杂乱无章地出现在原本供人类阅读的文字中。计算机的好处是它们是可编程的，因此只要我们人类同意在写作时遵循非常特定的惯例，我们就可以对计算机进行编程，将人类可读的文本解释为秘密指令。例如，我们在一个词的周围打上两个星号，不仅可以给人类一个视觉上的提示，说明这个词很重要，我们还可给计算机编程让它用**粗体**显示这个词。
这正是 [Markdown](https://opensource.com/article/19/9/introduction-markdown) 背后的理论和实践，这种流行的纯文本格式向作者们承诺，只要\_他们\_使用特定的纯文本约定，那么他们的文本就会以特定的风格呈现。
传统中，这意味着作者用纯文本写作，直到文本被传给转换器应用（最初是 `markdown.pl`），才会看到漂亮的样式，但 Nextcloud 的 Markdown 编辑器应用改变了这一点。
通过 Nextcloud 的 Markdown 编辑器，你可以一边输入纯文本，一边看到它渲染后的样式。这对于那些要努力记住 Markdown 有时令人困惑的符号的作者们无异于是救星（方括号是在小括号中的超链接之前还是之后？）。而且更好的是，它运行在 Nextcloud 中，所以你可以在任何地方使用它。
### 安装
要使用 Nextcloud 的 Markdown 编辑器，你必须安装 Nextcloud。好消息是，Nextcloud 非常\_容易\_安装。我已经在树莓派、共享服务器、甚至作为一个本地应用安装了它（这是愚蠢的，不要这样做）。如果你不相信自己的能力，你甚至可以依靠 [Turnkey Linux](https://www.turnkeylinux.org/nextcloud) 来帮你完成这些难关，否则就直接从 [Nextcloud.com](http://nextcloud.com) 购买托管服务。在你安装 Nextcloud 后，添加应用就很简单了。点击 Nextcloud 界面右上角的用户图标，选择 **Apps**。找到 **Office and Text** 类别，点击安装并启用 **Markdown Editor**。
### 启动
激活后，Markdown 编辑器会与 Nextcloud 文件中任何以 .md 结尾的文件相关联，当你打开一个 Markdown 文件时，你就会启动 Markdown 编辑器。
### 使用 Markdown 编辑器
Markdown 编辑器包含了一个大的文本区域供你输入，以及一个沿着顶部的工具栏。
工具栏包含了文字处理器的基本功能：用粗体、斜体和删除线设计文本样式、创建标题和段落、列表等等。
如果你了解 Markdown，这些功能中的许多可以在你输入时自动调用。如果你不熟悉 Markdown，那么工具栏或常用的键盘快捷键（`Ctrl+B` 表示粗体，`Ctrl+I` 表示斜体等等）可以帮助你设计文本的样式。
Markdown 编辑器的工作方式的最好的一点是，它真正做到了使人人满意：如果你想以 Markdown 格式输入，那么它就会接受它并立即将其转化为视觉样式；如果你不想操心 Markdown 语法，那么当你使用键盘快捷键或工具栏按钮时，它就会为你生成样式。无论哪种方式，你永远不会看到 Markdown 语法格式，但你也永远不会失去它。这是一个完美的折中方案。
它也是一个非常聪明的编辑器。当你选择一个单词时，它会为你创建一个超链接，它能快速流畅地自动转换 Markdown，而且它知道一些不同“风格”的 Markdown 语法（主要是 Commonmark，但也有传统的 Markdown、Github Markdown，等等）。
### 尝试 Nextcloud
我用过几个 Markdown 预览应用，Nextcloud 的 Markdown 编辑器是最流畅的一个。它尊重用户，并为显示 Markdown 做了最基本的工作，所以它的转换速度很快，也很准确。因为它是 Nextcloud 中的一个应用，你还可以获得这样的好处：你的作品可以即时保存在自己的私有的开源云上，并进行版本控制。没有比这更好的文本编辑器了。
---
via: <https://opensource.com/article/20/12/nextcloud-markdown>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
为 Linux 爱好者打造的极简 Mac 终端 | Lisa Seelye | https://opensource.com/article/20/6/iterm2-mac | 以下是我如何通过很多微妙复杂的方式来保持终端的简单和我的点文件的安全。 | /data/attachment/album/202101/10/122050pyit2d9eelje9kfl.jpg.thumb.jpg | /data/attachment/album/202101/10/122050pyit2d9eelje9kfl.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"mac",
"iTerm2"
] | 技术 | {
"viewnum": 5240,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 以下是我如何通过很多微妙复杂的方式来保持终端的简单和我的点文件的安全。 | 2021-01-10T12:21:05 | 2021-01-10T12:21:05 | 12,999 | /article-12999-1.html |
>
> 以下是我如何通过很多微妙复杂的方式来保持终端的简单和我的点文件的安全。
>
>
>
我要向大家坦白。我成为 Mac 用户已经有 10 多年了。起初，鉴于我强大的 Linux 背景，我觉得有点惭愧，但 Mac 给了我一个类似 Unix 的 Shell 和一个伟大的窗口管理器。因为这段历史，我有一个合二为一的功能，它运行在 macOS 上，但又为 Linux 用户所熟悉。没有理由它不能移植到 Linux 上（而且它已经移植了！）。
### 在 Mac 上使用 iTerm2
很长时间以来，我首选的终端是基本的内置 Term.app，但我最近改用了 [iTerm2](https://www.iterm2.com/)，因为它有更好的自定义和配置文件支持。对我来说，它的一个主要优点是可以轻松地在 Mac 之间移植配置。对于日常使用，我更喜欢 Solarized Dark 主题；但对于演示文稿，我有一个单独的配置文件，可以放大文本，并使用色彩更鲜艳的纯黑色背景。
要使 iTerm2 可用，我首先要做的是配置 `Ctrl+Left` 和 `Ctrl+Right` 箭头，使其尊重经典的终端行为，即跳转到单词边界的开始和结束。要做到这一点，请导航到 “Preferences > Profiles > Your Profile > Keys” 并输入以下内容：
* 键盘快捷键：`^←`
* 行动：发送 Escape 序列
* Esc+：`b`
然后是另一个：
* 键盘快捷键：`^→`
* 行动：发送 Escape 序列
* Esc+：`f`
了解更多关于 [iTerm2](https://www.iterm2.com/documentation.html) 的内容，享受自定义体验。
### 一个简单的命令提示符
我是那种无聊的终端提示符用户。我不想在其中包含 Git 目录或退出代码，我也只用单行提示符。我唯一使用的花哨组件是 [kubectx](https://github.com/ahmetb/kubectx) ，它包括当前的 Kubernetes 上下文。作为一位 [OpenShift Dedicated](https://www.openshift.com/products/dedicated/) 的站点可靠性工程师（SRE），我必须在运行命令时有相应的上下文，而 `kubectx` 让我在打字时很容易知道自己在哪里。所以，我的 Bash PS1 就是无聊的 `username@host cwd $`，免除了 Kubernetes 上下文前缀。（LCTT 译注：如果想将 Kubernetes 上下文和名字空间显示在 PS1，可以看看 [kube-ps1](https://github.com/jonmosco/kube-ps1)。）
毫无疑问，与我见过的一些花哨的终端相比，我是偏向于极简的。有些人喜欢透明背景，有些人则喜欢他们的提示符上有很多信息 —— 从时间到退出代码以及其他一切。我觉得这些在我的终端上会让人分心，所以我很喜欢远离的那些设置。
### 精美复杂的点文件
与我的极简主义终端相比，很容易看出我在哪里投入了最大的努力：部署我的[点文件](https://opensource.com/article/19/3/move-your-dotfiles-version-control)，包括我的 `.bash_profile` 和我的整体 Mac 设置。
我使用通过 GitHub 托管的 [一系列 Makefile](https://github.com/lisa/mac-setup) 来管理我的 Mac 设置。这将会拉取我的[点文件专用部署机制](https://github.com/lisa/dotrc)，它也在 GitHub 上。你要问为什么要围绕安全做这些工具？IT 专业人士和业余爱好者都需要一种强大的方式来将安全的数据片段放在新系统上。也许你想要你的 SSH 配置是隐藏的，或者你通过第三方系统部署凭证。我发现把我的安全数据和其他一切数据放在一起是很有用的，我用 [Ansible Vault](https://docs.ansible.com/ansible/latest/user_guide/vault.html) 解决了这个问题。我所有的机密信息都存储在 Git 中，用 Ansible Vault 加密。解密是用 Makefile 处理的。
无论是第一次安装还是更新现有的点文件，我（当然）都必须有 Ansible Vault，为了避免到处安装，我把它放在一个用 Docker 运行的容器里，这样我就到处都安装好了。我把解密口令放到一个文件中， `run make`，然后用 `make clean` 清理一切。你可以通过[探索这些点文件](https://github.com/lisa/dotrc)来了解更多）。
我想说的是，这种管理方案可能过于夸张，而有些人喜欢复杂的终端提示。所以，也许在权衡之下，一切都会变得平衡。
---
via: <https://opensource.com/article/20/6/iterm2-mac>
作者：[Lisa Seelye](https://opensource.com/users/lisa) 选题：[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/) 荣誉推出
|
通过编写“猜数字”游戏学习 Lua | Seth Kenlon | https://opensource.com/article/20/12/lua-guess-number-game | 通过编写一个简单的游戏来认识 Lua，它是一种动态类型的、轻量级的、高效的、可嵌入的脚本语言。 | /data/attachment/album/202101/10/125405hgrqrigagbucpbqg.jpg.thumb.jpg | /data/attachment/album/202101/10/125405hgrqrigagbucpbqg.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Lua"
] | 软件开发 | {
"viewnum": 2975,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12985,
"displayorder": 0
},
{
"raid": 13013,
"displayorder": 0
},
{
"raid": 13292,
"displayorder": 0
}
] | 通过编写一个简单的游戏来认识 Lua，它是一种动态类型的、轻量级的、高效的、可嵌入的脚本语言。 | 2021-01-10T12:54:29 | 2021-01-10T12:54:29 | 13,000 | /article-13000-1.html |
>
> 通过编写一个简单的游戏来认识 Lua，它是一种动态类型的、轻量级的、高效的、可嵌入的脚本语言。
>
>
>
如果你是 Bash、Python 或 Ruby 等脚本语言的爱好者，你可能会发现 Lua 很有趣。Lua 是一种动态类型的、轻量级的、高效的、可嵌入的脚本语言，它有与 C 语言的 API 接口。它通过基于寄存器的虚拟机解释字节码来运行，它可以用于过程式编程、函数式编程和数据驱动编程等编程方式。它甚至可以通过巧妙地使用数组（即“<ruby> 表 <rt> table </rt></ruby>”）来模拟类，以用于面向对象的编程。
感受一门语言的好方法是通过编写一个你已经熟悉的简单应用。最近，一些作者已经演示了如何使用他们最喜欢的语言来创建一个“猜数字”游戏。[Lua](https://www.lua.org/) 是我最喜欢的语言之一，所以这是我的 Lua 版猜数字游戏。
### 安装 Lua
如果你是在 Linux 上，你可以从你的发行版仓库中安装 Lua。在 macOS 上，你可以从 [MacPorts](https://opensource.com/article/20/11/macports) 或 [Homebrew](https://opensource.com/article/20/6/homebrew-mac) 安装 Lua。在 Windows 上，你可以从 [Chocolatey](https://opensource.com/article/20/3/chocolatey) 安装 Lua。
安装 Lua 后，打开你最喜欢的文本编辑器，可以准备编写了。
### Lua 代码
首先，你必须设置一个伪随机数生成器，这样你的玩家就有一些不可预知的东西来尝试猜测。这是一个两个步骤的过程：首先，你根据当前的时间生成一个随机种子，然后在 1 到 100 的范围内选择一个数字：
```
math.randomseed(os.time())
number = math.random(1,100)
```
接下来，创建一个 Lua 所谓的<ruby> 表 <rt> table </rt></ruby>来表示你的玩家。表就像一个 [Bash 中的数组](https://opensource.com/article/20/6/associative-arrays-bash)或 Java 中的 `ArrayList`。你可以创建一个表，然后分配与该表相关的子变量。在这段代码中，`player` 是表，而 `player.guess` 是表中的一个条目：
```
player = {}
player.guess = 0
```
处于调试的需求，可以输出这个秘密数字。这对游戏并不合适，但对测试很有帮助。Lua 中的注释是在前面放双破折号：
```
print(number) --debug
```
接下来，设置一个 `while` 循环，当分配给 `player.guess` 的值不等于代码开始时建立的随机的 `number` 时，循环将永远运行。目前，`player.guess` 被设置为 0，所以它不等于 `number`。Lua 的不等式数学运算符是 `~=`，诚然这很独特，但过一段时间你就会习惯。
在这个无限循环的过程中，首先游戏会打印一个提示，让玩家明白游戏的内容。
接下来，Lua 会暂停，等待玩家输入猜测的数。Lua 使用 `io.read` 函数从文件和标准输入 （stdin） 中读取数据。你可以将 `io.read` 的结果分配到一个变量中，这个变量是在 `player` 表中动态创建的。处理玩家输入的问题是，即使它是一个数字，它也是作为一个字符串读取的。你可以使用 `tonumber()` 函数将这个输入转换为整数类型，将结果赋值回初始为 `0` 的 `player.guess` 变量：
```
while ( player.guess ~= number ) do
print("Guess a number between 1 and 100")
player.answer = io.read()
player.guess = tonumber(player.answer)
```
现在 `player.guess` 包含了一个新的值，它将与 `if` 语句中的随机数进行比较。Lua 使用关键字 `if`、`elseif` 和 `else`，并用关键字 `end` 来结束该语句：
```
if ( player.guess > number ) then
print("Too high")
elseif ( player.guess < number) then
print("Too low")
else
print("That's right!")
os.exit()
end
end
```
最后，函数 `os.exit()` 在成功后关闭应用，关键字 `end` 使用了两次：一次是结束 `if` 语句，另一次是结束 `while` 循环。
### 运行应用
在终端上运行游戏：
```
$ lua ./guess.lua
96
Guess a number between 1 and 100
1
Too low
Guess a number between 1 and 100
99
Too high
Guess a number between 1 and 100
96
That's right!
```
就是这样！
### 直观且一致
从这段代码中可以看出，Lua 是非常一致且相当直观的。它的表机制是一种令人耳目一新的数据关联方式，它的语法也是简约而高效的。Lua 代码中几乎没有浪费的行，事实上，这个例子中至少有两行可以进一步优化，但我想把数据转换作为它的步骤来演示（也许你可以找到我所指的两行，并对它们进行重构）。
Lua 非常易于使用，它的[文档阅读起来很愉快](https://www.lua.org/docs.html)，主要是因为它的内容实在是不多。你会在短时间内学会核心语言，然后你就可以自由地探索 [LuaRocks](https://opensource.com/article/19/11/getting-started-luarocks)，发现别人贡献的各种很棒的库。“Lua” 在葡萄牙语中的意思是“月亮”，所以今晚可以尝试一下。
---
via: <https://opensource.com/article/20/12/lua-guess-number-game>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
全屏文本编辑器 Focuswriter 提高关注力的六种方式 | Seth Kenlon | https://opensource.com/article/20/12/focuswriter | 这款全屏编辑器可以帮助你设定写作目标，并将干扰降到最低，从而实现你的目标。 | /data/attachment/album/202101/11/002729rqql2ll68wr8i8vz.png.thumb.jpg | /data/attachment/album/202101/11/002729rqql2ll68wr8i8vz.png | true | false | true | lujun9972 | wxy | wxy | false | [
"编辑器"
] | 分享 | {
"viewnum": 3788,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "223.223.188.146",
"message": "竟然没有osx",
"username": "Mr.Wang [Firefox 84.0|Mac 10.15]",
"date": "2021-01-11T10:34:29"
}
] | [
{
"raid": 12993,
"displayorder": 0
},
{
"raid": 13009,
"displayorder": 0
}
] | 这款全屏编辑器可以帮助你设定写作目标，并将干扰降到最低，从而实现你的目标。 | 2021-01-11T00:27:26 | 2021-01-11T00:27:26 | 13,002 | /article-13002-1.html |
>
> 这款全屏编辑器可以帮助你设定写作目标，并将干扰降到最低，从而实现你的目标。
>
>
>
计算机的好处是，它们真的很擅长一心多用。
计算机的坏处是，它们实在太擅长一心多用。
无论你认为自己作为一个人，在多任务处理方面是好是坏，有时你需要一点帮助来集中注意力，尤其是当你试图撰写清晰和简明的交流信息时。而这正是开发 Focuswriter 的原因。
### 安装
在 Linux 上，你可以从 [Flathub](https://flathub.org/apps/details/org.gottcode.FocusWriter) 以 Flatpak 包安装 Focuswriter。
在 Windows 或 Linux 上（如果你不使用 Flatpak），你可以[从它的网站安装 Focuswriter](https://gottcode.org/focuswriter/)。你也可以从源代码安装，它也可以从 Focuswriter 网站上获得。
### 使用 Focuswriter
不可否认，Focuswriter 实际上处于文本编辑器和文字处理器的重叠的地带。它的默认格式是 <ruby> 开放文档文本 <rt> Open Document Text </rt></ruby>（.odt）格式，所以它允许你设置文本样式和对齐文本、标记页眉，以及开启和关闭智能引号。但它的文字处理器功能也就到此为止，因为 Focuswriter 确实主要专注于\_写作\_，而不是对你所写的东西进行样式设计。
Focuswriter 以几种不同的方式鼓励专注力：
#### 吸引力
Focuswriter 看起来并不像你平常的电脑应用程序，更不像你平常的文本编辑器。当它启动时，它会在你的文档后面加载一个主题。主题一般是良性的 —— 默认是写字台，但也有星空、远方的风景等等。当然，你并不是要全神贯注于此主题，但它确实可以帮助你避免被徘徊于你的编辑器后面的其他应用窗口或电脑桌面分散注意力。因为它很容易定制，所以你几乎不大可能找不到你喜欢的主题。
#### 音效
Focuswriter 使用起来其实很有趣。除了视觉主题外，它还有一个\_可选的\_打字机音频主题。启用后，每按一次键都会发出机械打字机按键的声音。当你按下**回车键**时，回车的声音令人满意，这是对你完成一段文字（或一行文字，如果你为了改善版本控制而每行写一句话）的奖励。
这个音频主题完全是可选的，默认情况下是不开启的。你可能会怀疑它的效果，但你不应该低估发出这些生产力声音而有具有现代文本编辑能力所带来的满足感。
#### 全屏显示
Focuswriter 不仅在默认情况下启动全屏，而且还从视图中隐藏了其菜单和其他部件。要访问主菜单栏，你要将光标放在屏幕顶部，直到它出现。右边隐藏了一个滚动条，左边隐藏了一个文档切换器小部件，底部则隐藏着一个状态栏。
#### 极简主义
Focuswriter 的编辑功能并不多。它没有高级搜索选项，也没有代码格式化或语法高亮的专门选项。它的设计是让你在文档中写入文本，而不是其他的什么。即使是上下文右键菜单也只提供基本的编辑功能（复制、剪切、粘贴等）或拼写检查选项。
#### 聚焦一行
Focuswriter 的另一个可选功能是它能够“灰化”除了你的当前文本行之外的所有文本行。这可以帮助你的眼睛懒洋洋地定位你当前的文字行，如果你不是一个盲打打字员，或者如果你正在抄写一些你手写在纸张上的东西，眼睛必须经常远离屏幕，这可能特别有用。
#### 目标追踪
你可以在 Focuswriter 的首选项中为自己设置一个每日字数目标或定时目标。当你工作时，你的进度会被跟踪，并显示在屏幕底部的状态栏中。除非你将光标悬停在它上面，否则它是隐藏在你的视野中的，所以你不会被迫沉迷于它，但它足够方便，可以帮助你保持进度。
### 即使你认为它很傻，也请尝试一下 Focuswriter
以前也听说过全屏文本编辑器，但我一直不觉得全屏文本编辑器对我来说有什么重要意义。毕竟，几乎所有的应用程序都可以全屏显示，而我个人也没有任何关注力问题。
不过在尝试过 Focuswriter 之后，我明白了一个好的全屏“关注力优先”文本编辑器的魅力所在。也许没有必要，但话又说回来，开源是如此的兴盛，我们有大量的冗余应用，这些应用功能略有差异，但实现上差异很大。Focuswriter 让写作变得有趣，它让工作变得愉快。下载它，设定一个目标，然后开始写作吧！
---
via: <https://opensource.com/article/20/12/focuswriter>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
使用 Python 调整图像大小 | Dayo Ntwari | https://opensource.com/life/15/2/resize-images-python | 快速解释如何在 Python 中调整图像大小，同时保持相同的长宽比。 | /data/attachment/album/202101/11/121120pa77t6gpagggttzp.jpg.thumb.jpg | /data/attachment/album/202101/11/121120pa77t6gpagggttzp.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Python"
] | 软件开发 | {
"viewnum": 4043,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 快速解释如何在 Python 中调整图像大小，同时保持相同的长宽比。 | 2021-01-11T12:11:17 | 2021-01-11T12:11:17 | 13,003 | /article-13003-1.html |
>
> 快速解释如何在 Python 中调整图像大小，同时保持相同的长宽比。
>
>
>
我喜欢 [Python](http://python.org/ "Python Programming Language – Official Website")，而且我已经学了一段时间了。前段时间，我写了一个 Python 脚本，在这个脚本中，我需要调整一堆图片的大小，同时保持长宽比（比例）不变。于是我四处寻找，发现了 [Pillow](https://pypi.org/project/Pillow/ "Python Imaging Library")，这是一个 Python 图像库，也是一个叫做 PIL 的旧库的“友好复刻”。
要安装 Pillow，请使用 Python 的 `pip` 模块：
```
$ python3 -m pip install Pillow
```
### 按宽度缩放
这是一个使用 Pillow 模块来调整图片大小的基本脚本：
```
from PIL import Image
basewidth = 300
img = Image.open('fullsized_image.jpg')
wpercent = (basewidth / float(img.size[0]))
hsize = int((float(img.size[1]) * float(wpercent)))
img = img.resize((basewidth, hsize), Image.ANTIALIAS)
img.save('resized_image.jpg')
```
这几行 Python 代码使用 Pillow 将一张图片 （`fullsized_image.jpg`） 调整为 300 像素的宽度，宽度在变量 `basewidth` 中设置，高度则与新的宽度成比例。比例高度的计算方法是：确定 300 像素占原宽度 （`img.size[0]`） 的百分比，然后将原高度（`img.size[1]`） 乘以该百分比。所得的高度值保存在变量 `hsize` 中。
如果你需要不同的图片宽度，你可以将 `basewidth` 改为任何其他数字。另外，请注意，因为我想保留全尺寸的图片 （`fullsized_image.jpg`），因此我将调整后的图片以一个不同的名称 `resized_image.jpg` 保存。当然，你不必这么做。如果你想，你可以使用相同的文件名将调整后的图片覆盖全尺寸的图片。
### 按高度缩放
如果高度是固定的，而宽度是按比例变化的，那也基本差不多，你只需要把东西换一下：
```
from PIL import Image
baseheight = 560
img = Image.open('fullsized_image.jpg')
hpercent = (baseheight / float(img.size[1]))
wsize = int((float(img.size[0]) * float(hpercent)))
img = img.resize((wsize, baseheight), Image.ANTIALIAS)
img.save('resized_image.jpg')
```
注意 `basewidth` 现在换成了 `baseheight`，因为高度是固定的。在第三行中，我们在计算高度百分比，所以我们需要 `img.size[1]` 而不是 `img.size[0]`。`size` 属性是一个元组，包含宽度和高度，单位是像素，`size[0]` 指的是第一个元组元素，也就是宽度，`size[1]` 是第二个元素，也就是高度。第 4 行也有这样的切换，`size[0]` 代表宽度，`size[1]` 代表高度。
---
via: <https://opensource.com/life/15/2/resize-images-python>
作者：[Dayo Ntwari](https://opensource.com/users/dayontwari) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
光速！搜索、学习和实践 Linux 命令！！ | Sk | https://www.ostechnix.com/search-study-and-practice-linux-commands-on-the-fly/ | 如果你是中高级 Linux 用户，你可以通过一行命令或脚本在几秒钟/分钟内轻松完成这一任务。但是，如果你是一个不懂得太多 Linux 命令的菜鸟你可能就需要一些帮助了。 | /data/attachment/album/202101/12/094925yu3e0nn3qt00oo4c.png.thumb.jpg | /data/attachment/album/202101/12/094925yu3e0nn3qt00oo4c.png | true | false | true | lujun9972 | qfzy1233 | wxy | false | [
"TLDR"
] | 技术 | {
"viewnum": 4699,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 如果你是中高级 Linux 用户，你可以通过一行命令或脚本在几秒钟/分钟内轻松完成这一任务。但是，如果你是一个不懂得太多 Linux 命令的菜鸟你可能就需要一些帮助了。 | 2021-01-12T09:49:00 | 2021-01-12T09:49:00 | 13,005 | /article-13005-1.html | 
这一标题可能看起来很粗略且吸睛。请允许我解释一下我在本教程中将要阐释的内容。假设你想下载一个压缩文件，将其解压缩，并从命令行中将文件从一个位置移动到另一个位置。根据上面的场景，我们可能需要至少三个 Linux 命令，一个用于下载文件，一个用于提取下载的文件，一个用于移动文件。如果你是中高级 Linux 用户，你可以通过[一行命令](https://ostechnix.com/random-one-liner-linux-commands-part-1/)或脚本在几秒钟/分钟内轻松完成这一任务。但是，如果你是一个不懂得太多 Linux 命令的菜鸟你可能就需要一些帮助了。
当然，谷歌的快速搜索可能会找到很多结果。或者，你可以使用 [手册页](https://www.ostechnix.com/learn-use-man-pages-efficiently/)。但是有些手册页实在很长，很全面，但缺少有用的示例。当你在特定的标志/选项上寻找特定的信息时，你可能需要向下检索相当长的时间。值得庆幸的是，有一些 [好的手册页替代品](https://www.ostechnix.com/3-good-alternatives-man-pages-every-linux-user-know/)，它们主要关注于实用的命令。一个很好的选择是 **TLDR 手册**。使用 TLDR 手册，我们可以通过实际示例快速轻松地学习一个 Linux 命令。要使用 TLDR 手册，我们需要 TLDR 客户端。有很多客户。今天我们就来了解一个这样的客户端，名为 **“Tldr++”**。
Tldr++ 是一个快速和交互式的 Tldr 客户端，用 **Go** 编程语言编写。与其他 Tldr 客户端不同，它是完全交互式的。这意味着，你可以选择一个命令，读取所有示例，并立即运行任何命令，而不必在终端中重新键入或复制/粘贴每个命令。还是不明白？没有问题。请继续阅读，以便动态学习和实践 Linux 命令。
### 安装 Tldr++
安装 Tldr++ 非常简单。从 [发布页面](https://github.com/isacikgoz/tldr/releases) 下载 Tldr++ 最新版本。解压它并将 Tldr++ 二进制文件移动到你的 `$PATH` 中。
```
$ wget https://github.com/isacikgoz/tldr/releases/download/v0.5.0/tldr_0.5.0_linux_amd64.tar.gz
$ tar xzf tldr_0.5.0_linux_amd64.tar.gz
$ sudo mv tldr /usr/local/bin
$ sudo chmod +x /usr/local/bin/tldr
```
现在，运行 `tldr` 二进制代码将 TLDR 手册部署到本地系统中。
```
$ tldr
```
示例输出：
```
Enumerating objects: 6, done.
Counting objects: 100% (6/6), done.
Compressing objects: 100% (6/6), done.
Total 18157 (delta 0), reused 3 (delta 0), pack-reused 18151
Successfully cloned into: /home/sk/.local/share/tldr
```
Tldr++ 可以在 AUR 中使用。如果你使用 Arch Linux 上，你可以使用任何 AUR 助手来安装它，例如 [YaY](https://www.ostechnix.com/yay-found-yet-another-reliable-aur-helper/)。确保你已经从系统中删除了任何现有的 TLDR 客户端，并运行以下命令安装 Tldr++。
```
$ yay -S tldr++
```
或者，你也可以像下面描述的那样从源代码进行编译。因为 Tldr++ 是用 Go 语言编写的，所以请确保你 Linux 系统中已经安装了 Go 语言。如果还没有安装，请参考下面的指南。
* [如何在 Linux 系统中安装 Go 语言](https://www.ostechnix.com/install-go-language-linux/)
在安装好 Go 语言之后, 运行以下的命令来安装 Tldr++。
```
$ go get -u github.com/isacikgoz/tldr
```
该命令在当前工作目录中下载 `tldr` 代码库中的内容并存储到 `go` 文件夹中。
现在，运行 `tldr` 二进制代码将 TLDR 手册部署到本地系统中。
```
$ go/bin/tldr
```
示例输出：
最后，将 `tldr` 二进制文件复制到你的路径中。
```
$ sudo mv tldr /usr/local/bin
```
现在是时候看一些例子了。
### Tldr++ 用法
输入不带任何选项的 `tldr` 命令，以字母顺序显示所有命令示例。
使用 **向上/向下箭头** 来浏览命令，键入任何字母来搜索或键入命令名称来查看相应命令的示例。 `?` 以浏览更多消息，按 `Ctrl+c` 返回/退出。
要显示特定命令的示例命令，例如 `apt`，可以这样做:
```
$ tldr apt
```
从列表中选择任意示例命令并按回车键。在选定的命令前会看到一个 `*` 符号。例如，我选择第一个命令即 `sudo apt update`。现在，它会问你是否继续。如果命令正确，只需键入 `y` 继续，并输入 `sudo` 密码运行所选命令。
看到了吗？你不需要在终端中复制/粘贴或键入实际的命令。只需从列表中选择它，并极速运行！
Tldr 手册中有数百个 Linux 命令示例。你可以每天选择一个或两个命令，并彻底学习它们。每天坚持这样的练习，尽可能多的掌握。
### 使用 Tldr++ 动态学习和实践 Linux 命令
现在回到我在第一段中提到的场景。你需要下载一个文件，将其解压缩并将其移动到不同的位置，并使其可执行。让我们看看如何使用 Tldr++ 客户端进行交互。
#### 第一步 – 从网上下载文件
要使用命令行下载文件，我们主要使用 `curl` 或 `wget` 命令。让我使用 `wget` 下载文件。要打开 `wget` 命令的 TLDR 页面，只需执行以下命令：
```
$ tldr wget
```
下面是 `wget` 命令的示例。
你可以使用 **向上/向下箭头** 来浏览命令列表。一旦你选择了你所选择的命令，按回车键。这里我选择了第一个命令。
现在，输入路径来下载文件。
然后将要求你确认该命令是否正确。如果命令正确，只需键入 `yes` 或 `y` 就可以开始下载文件。
我们已经下载了文件。让我们继续解压这个文件。
#### 第二步 – 解压已下载的文件
我们下载了 tar.gz 文件。所以我将打开 TLDR 手册的 `tar` 页面。
```
$ tldr tar
```
你将看到示例命令列表。浏览这些示例，找出哪个命令适合提取 tar.gz（gzip 格式）文件，按回车键。在我们的例子中，它是第三个命令。
现在，系统将提示你输入 tar.gz 文件的路径。只需输入路径并按回车键。Tldr++ 支持智能文件提示。这意味着它会在你键入时自动补全文件名。只需按 `TAB` 键自动完成。
如果将文件下载到其他位置，只需键入完整路径，例如 `/home/sk/Downloads/tldr_0.5.0_linux_amd64.tar.gz`。
输入要解压的文件的路径后，按回车键，然后输入 `y` 进行确认。
#### 第三步 – 将文件从一个目录移动到另一个目录
我们解压了文件。现在我们需要将文件移动到另一个位置。为了将文件从一个位置移动到另一个位置，我们使用 `mv` 命令。所以，让我们打开 TLDR 手册的 `mv` 命令。
```
$ tldr mv
```
选择正确的命令将文件从一个位置移动到另一个位置。在我们的例子中，第一个命令可以工作，所以让我们选中它。
输入要移动的文件路径，并输入目标路径并按回车键。
**附注：** 输入 `y!` 或 `yes!` 来以 `sudo` 权限运行命令。
正如你在上面的截图中看到的，我将名为 ``tldr`的文件移动到`/usr/local/bin/`。
要了解更多细节，请参考项目最后给出的 GitHub 页面。
### 总结
别误会，毫无疑问 **手册页** 是伟大的！但是，正如我已经说过的，许多手册页都很全面，缺少有用的示例。我不可能记住带有复杂标志的冗长的所有命令。有时，我花了很多时间在手册页上，却还是一窍不通。Tldr 手册帮助我在几分钟内找到了我需要的东西。而且，我们偶尔会使用一些命令，然后就会完全忘记它们。另一方面，Tldr 手册实际上在使用那些使用率很低的命令时很有帮助。Tldr++ 客户端通过智能的用户交互使这个任务变得更容易。试试吧，在下面的评论区告诉我们你对这个工具的看法。
（LCTT 译注：我们也[开发](/article-10528-1.html)了一个 TLDR 客户端，是基于[微信小程序](/article-11989-1.html)的，大家在微信中搜索“**Linux**”小程序即可找到。虽然微信小程序版的 TLDR 客户端不能像这个客户端一样实际运行 Linux，但是它是中文的，而且中文翻译是由使用者来贡献和修正的。顺便说一句，全部一千多个命令已经翻译完毕，感谢我们的贡献者们！ ）
以上，更多的好的分享将会陆续推出，请继续保持关注！
祝好!
---
via: <https://www.ostechnix.com/search-study-and-practice-linux-commands-on-the-fly/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[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/) 荣誉推出
|
Kubernetes 资源配额使用指南 | Mike Calizo | https://opensource.com/article/20/12/kubernetes-resource-quotas | 资源配额控制应用的 CPU 或内存使用情况，防止资源被过量使用或被抢占。 | /data/attachment/album/202101/12/125309xr0kskdrqv33vn4q.jpg.thumb.jpg | /data/attachment/album/202101/12/125309xr0kskdrqv33vn4q.jpg | true | false | true | lujun9972 | larryzju | wxy | false | [
"Kubernetes",
"配额",
"限额"
] | 容器与云 | {
"viewnum": 5492,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
} | [] | [] | 资源配额控制应用的 CPU 或内存使用情况，防止资源被过量使用或被抢占。 | 2021-01-12T12:53:00 | 2021-01-12T12:53:00 | 13,006 | /article-13006-1.html |
>
> 资源配额控制应用的 CPU 或内存使用情况，防止资源被过量使用或被抢占。
>
>
>
当 Kubernetes 集群运行过一段时间或者在被开发者大量使用后，[Kubernetes](https://kubernetes.io/) 资源（例如 CPU 和内存）的控制的问题就会显现出来。而在大多情况下只有集群出问题后，我们才会意识到资源控制的重要性。
Kubernetes 部署过程如果没有能充分考虑到将来的扩展性，资源类问题将会非常常见，此类问题与集群的管理和部署团队的经验有关。
如果不加以合理控制，一个暴力的应用或者开发者可能影响到共享该集群的所有业务，大家因此会相互埋怨、指责并保护性地抢占资源。这对于集群管理和开发人员都是非常难以处理的场景。
在 Kubernetes 环境中控制应用的计算资源使用有多种方式。大部分情况下，我们可以使用“资源控制”和“限制范围”。注意存储管理不在我们讨论范围之内，存储管理可以通过<ruby> 持久卷 <rt> Persistent Volume </rt></ruby> 件，以实现针对不同的存储控制需求。
资源配额是一种控制 Kubernetes 计算资源的方法。本文告诉你如何使用该功能来管理开发人员行为并控制应用的资源使用。
### 什么是资源配额
简而言之，[资源配额](https://kubernetes.io/docs/concepts/policy/resource-quotas) 提供了限制每个命名空间资源消耗的约束条件，它们只能在命名空间级别上应用，这意味着它们可以应用于计算资源，并限制命名空间内的对象数量。
Kubernetes资源配额通过 `ResourceQuota` 对象来为每个命名空间设置资源配额，对以下对象类型的 CPU 和内存进行限制：
* <ruby> 吊舱 <rt> Pod </rt></ruby>
* <ruby> 服务 <rt> Service </rt></ruby>
* <ruby> 机密信息 <rt> Secret </rt></ruby>
* <ruby> 持久卷断言 <rt> Persistent Volume Claim </rt></ruby>（PVC）
* <ruby> 配置映射 <rt> ConfigMap </rt></ruby>
Kubernetes 通过 `request` 和 `limit` 两个参数对 CPU 和内存进行限制（参考 [LimitRange](https://kubernetes.io/docs/concepts/policy/limit-range/) 文档）。前者表示容器最小被保证资源，后者表示容器最大可用资源。实际上最大可用资源还受限于其它容器的实际使用情况。
下一张图片解释了配额中 `request` 和 `limit` 的区别：
下面我们就通过一个例子来说明如何设置资源配额来创建约束，将应用程序限制在某些资源上，它还展示了实现资源配额以获得对 Kubernetes 的控制的有用性。
### 准备环境
首先你需要一个 Kubernetes 环境。以下是我使用 Kubernetes 环境：
* [Minikube](https://opensource.com/article/18/10/getting-started-minikube) v1.14.2
* Fedora 33 操作系统
* 互联网接入
如果你想在 Linux 机器上通过 Minikube 搭建 Kubernetes 测试环境，可以参考 Bryant Son 的《[Minikube 入门](https://opensource.com/article/18/10/getting-started-minikube)》 一文。Window 或者 macOS 用户可以参考[这篇文章](https://www.liquidweb.com/kb/how-to-install-minikube/)。
### 设置资源配额
这里我们仅展示 CPU 配额设置步骤，配置内存配额或两者的组合与之类似。
在生产环境中，CPU 是最需要被控制的资源，尤其是在多应用的场景下特别需要注意防止某些应用消耗太多 CPU 而影响到其它应用。
首先我们创建一个命名空间，在其中设置 CPU 配额：
```
$ kubectl create namespace quota-test
namespace/quota-test created
```
准备 `cpu-quota.yaml` 文件，内容如下：
```
apiVersion: v1
kind: ResourceQuota
metadata:
name: test-cpu-quota
spec:
hard:
requests.cpu: "100m"
limits.cpu: "200m"
```
应用 CPU 配额到 Kubernetes 集群：
```
$ kubectl apply -f cpu-qouta.yaml
resourcequota/test-cpu-quota created
```
使用 `kubectl describe` 检查配额配置情况：
```
$ kubectl describe resourcequota/test-cpu-quota --namespace quota-test
Name: test-cpu-quota
Namespace: quota-test
Resource Used Hard
-------- ---- ----
limits.cpu 0 200m
requests.cpu 0 100m
```
在 `Used resources` 列中显示了当前情况，该列值会随着<ruby> 吊舱 <rt> Pod </rt></ruby>的部署而变化。
下面是我们来验证限额管理的场景。我们将在同一命名空间下部署三个不同的吊舱，为它们配置以不同的资源限制如下：
* PodA：第一个被实例化，使用 50% 可用 CPU 资源
* PodB：第二个被实例化，使用其余 50% 可用 CPU 资源
* PodC：没有可用 CPU 资源，因此不会被部署
#### 部署吊舱
PodA：
```
$ kubectl create -n quota-test -f - << EOF
apiVersion: v1
kind: Pod
metadata:
name: poda
spec:
containers:
- name: quota-test
image: busybox
imagePullPolicy: IfNotPresent
command: ['sh', '-c', 'echo Pod is Running ; sleep 5000']
resources:
requests:
cpu: "50m"
limits:
cpu: "100m"
restartPolicy: Never
EOF
```
部署 PodA 后，再次查看配额描述信息中的 `Used CPU` 信息：
```
$ kubectl describe resourcequota/test-cpu-quota --namespace quota-test
Name: test-cpu-quota
Namespace: quota-test
Resource Used Hard
-------- ---- ----
limits.cpu 100m 200m
requests.cpu 50m 100m
```
PodB：
```
$ kubectl create -n quota-test -f - << EOF
apiVersion: v1
kind: Pod
metadata:
name: podb
spec:
containers:
- name: quota-test
image: busybox
imagePullPolicy: IfNotPresent
command: ['sh', '-c', 'echo Pod is Running ; sleep 5000']
resources:
requests:
cpu: "50m"
limits:
cpu: "100m"
restartPolicy: Never
EOF
```
再次查看 CPU 资源使用，此时 PodB 启动后 CPU 限制已经达到上限：
```
$ kubectl describe resourcequota/test-cpu-quota --namespace quota-test
Name: test-cpu-quota
Namespace: quota-test
Resource Used Hard
-------- ---- ----
limits.cpu 200m 200m
requests.cpu 100m 100m
```
PodC：
试着创建 PodC，此时 CPU 配额已经被 PodA 和 PodB 用尽：
```
$ kubectl create -n quota-test -f - << EOF
apiVersion: v1
kind: Pod
metadata:
name: podc
spec:
containers:
- name: quota-test
image: busybox
imagePullPolicy: IfNotPresent
command: ['sh', '-c', 'echo Pod is Running ; sleep 5000']
resources:
requests:
cpu: "5m"
limits:
cpu: "10m"
restartPolicy: Never
EOF
```
正我们期望，第三个 Pod 无法被启动，配额限制了吊舱的创建：
```
Error from server (Forbidden): error when creating "STDIN": pods "podc" is forbidden: exceeded quota: test-cpu-quota, requested: limits.cpu=10m,requests.cpu=5m, used: limits.cpu=200m,requests.cpu=100m, limited: limits.cpu=200m,requests.cpu=100m
```
如我们的例子所示，定义合理的资源配额限制开发者行为对 Kubernetes 管理十分重要。
### 清理
删除刚才创建的命名空间 `quota-test`:
```
$ kubectl delete -n quota-test
```
### 规划资源配额
Kubernetes 中提供多种方式来控制资源的抢占和使用，合理的规划和配置配额、限制范围和其它原生参数对保持集群的稳定性十分必要。
你应该十分谨慎地控制计算资源的资源配额，特别是关键业务的生产应用环境。
在规划资源配额时，开发人员的参与很重要，需要他们预估并给出最合理的资源使用值。
---
via: <https://opensource.com/article/20/12/kubernetes-resource-quotas>
作者：[Mike Calizo](https://opensource.com/users/mcalizo) 选题：[lujun9972](https://github.com/lujun9972) 译者：[larryzju](https://github.com/larryzju) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 Atom 文本编辑器的 5 个理由 | Seth Kenlon | https://opensource.com/article/20/12/atom | Atom 是一个全面的环境，可以完成从基本到复杂的任务，适合从初学者到老用户。 | /data/attachment/album/202101/13/122223fnsn53dpzllwlclp.jpg.thumb.jpg | /data/attachment/album/202101/13/122223fnsn53dpzllwlclp.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"编辑器",
"Atom"
] | 分享 | {
"viewnum": 4301,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 13002,
"displayorder": 0
},
{
"raid": 13019,
"displayorder": 0
}
] | Atom 是一个全面的环境，可以完成从基本到复杂的任务，适合从初学者到老用户。 | 2021-01-13T12:22:00 | 2021-01-13T12:22:00 | 13,009 | /article-13009-1.html |
>
> Atom 是一个全面的环境，可以完成从基本到复杂的任务，适合从初学者到老用户。
>
>
>
现在漂亮的开源文本编辑器很常见，有 Adobe 的 [Brackets](https://opensource.com/article/20/12/brackets)、微软的 [VSCode](https://opensource.com/article/20/12/%C2%A0https://opensource.com/article/20/6/open-source-alternatives-vs-code) 和 GitHub 的 [Atom](https://opensource.com/article/17/5/atom-text-editor-packages-writers)。这些似乎都提供了类似的体验：现代化的界面、易于安装的插件，以及背后的一个大厂商支持。而且它们其实都很不错。那么 Atom 与其他超现代的文本编辑器有什么不同呢？与经典的老式编辑器如 [Vim](https://opensource.com/article/20/12/vi-text-editor) 或 [Emacs](https://opensource.com/article/20/12/emacs) 有何区别呢？
我用过很多文本编辑器，并且经过反思，我不得不承认，所有的文本编辑器基本上都差不多。在判断一个编辑器的功效时，只要它能做一件事：编辑文字，就能满足 80% 的要求。另外的 20% 则是额外的便利、额外的小玩意和花哨的功能。它们是很好的东西，但几乎不是必不可少的。
不过我经常回到 Atom，因为作为一个开源的用户，只要我愿意，我就可以奢侈地有很多应用使用。以下是我喜欢 Atom 的原因。
### 新手友好
我最喜欢 Atom 的一点是，它让人感觉很“正常”。我可以把 Atom 安装在任何人的电脑上，他们很快就可以开始输入了。没有新的键盘快捷键需要学习，没有严重偏离用户界面的惯例。如果我花几分钟时间向他们展示一些应用的强大功能，那么他们很快就会有能力安装新的插件，发现他们喜欢的有用功能。
它的独特之处在于让人感到与众不同，但又足够“安全”，足以让人相信（也确实如此）他们可以使用它。这是一条很难走的路线，但 Atom 做到了，我很欣赏它。
### 强大的扩展
当你启动应用就已经满足了大多数需求时，开源文本编辑器的一个主要“卖点”就是它的扩展。我习惯使用的编辑器是 [GNU Emacs](https://opensource.com/article/20/2/who-cares-about-emacs)，它的扩展功能多到令人瞠目结舌，可以提供从电子邮件客户端到视频游戏的所有功能。要做到这一点很难，老实说，我还没有看到其它能做到的编辑器。不过这说明了扩展是多么重要，而 Atom 有一套不错的插件。
有一些扩展可以为语言和格式添加语法高亮、添加动态格式检查、以及集成调试器、运行时环境、视频和音乐播放器控件等等。实际上，你可以让 Atom 成为你桌面的控制中心，你很少需要离开它。
### 语言和语法支持
我是 [Docbook](https://opensource.com/article/17/9/docbook) 的忠实粉丝。顺便说一下，也是它的简化前端 Asciidoc 的粉丝。当我评估一个编辑器时，Docbook 模式和 Asciidoc 支持是我的两个主要指标。虽然对 XML 的支持比较常见，但与特定模式的集成可能是一个高难度的任务，而且 Asciidoc 相对小众。Atom 的社区为我最喜欢的格式提供了很好的支持。
当然，我已经提到了 Atom 一般来说有很好的扩展，但无论你在输入什么语言，语法高亮都是一个重要的功能。再次感谢充满活力的社区，在 Atom 的软件包仓库中，丰富的语法高亮选项的是它的优点之一。
### 简单定制主题
Atom 让你制作自己的风格就像设计网站的风格一样简单，所以如果你会使用 CSS，你可以制作你自己的 Atom 主题。要创建你自己的主题，找到<ruby> 软件包 <rt> Package </rt></ruby>菜单。如果你没有看到<ruby> 软件包 <rt> Package </rt></ruby>菜单，先按 `Alt` 键，露出顶部菜单栏。在<ruby> 软件包 <rt> Package </rt></ruby>菜单中，将鼠标悬停在<ruby> 软件包生成器 <rt> Package Generator </rt></ruby> 上，然后选择<ruby> Generate Atom Syntax Theme <rt> 生成 Atom 语法主题 </rt></ruby>。这将打开一个新的项目，默认名为 “my-theme-syntax”。你可以把它命名为任何你想要的名字，但根据 Atom 惯例，它应该以 `-syntax` 结尾。
在你的新主题项目中，找到这些文件：`base.less`、`colors.less` 和 `syntax-variables.less`。这些文件定义了当语法激活时，特殊的关键字，甚至是背景和前景的颜色是如何显示的。因为它们都是从一个通用模板中继承的值，所以很容易修改。比如说：
```
// Syntax styles
.syntax--comment {
color: @light-gray;
}
.syntax--keyword {
color: @purple;
&.syntax--control {
color: @purple;
}
&.syntax--operator {
color: @syntax-text-color;
}
&.syntax--other.syntax--special-method {
color: @blue;
}
&.syntax--other.syntax--unit {
color: @orange;
}
}
```
以两个破折号结尾的值，如 `.syntax--keyword`，是语法高亮引擎识别的对象。当然，如果你想进一步开发你的自定义设置，你甚至可以创建你自己的语法定义（尽管这比 CSS 主题更费劲）。在 [flight-manual.atom.io](https://flight-manual.atom.io/) 上可以阅读所有关于修改 Atom 的方法。
### 灵活的工作流
Atom 有很多功能，默认情况下仅激活其中一部分。这意味着你可以决定你喜欢的工作方式，是否激活新的扩展并使用它们从根本上改变 Atom，还是只打开 Atom 的偏好并进行小的调整。你可以用 Atom 来写一本小说，也可以用它来写 Python 代码或技术文档或其他任何东西。
即使是它的 Git 集成也没有坚持让你使用可能会想到的显而易见的仓库（Github 赞助了 Atom）。它没有任何限制，而且它对每个人都同样有用，不管受众是谁。
### 安装
在 Linux、Windows 和 macOS 上，你可以 [从它的网站安装 Atom](https://atom.io)。
另外，在 Linux 上，你可以从 [Flathub](https://flathub.org/apps/details/io.atom.Atom) 中，以 Flatpak 安装 Atom。
如果你想自己构建 Atom，你也可以 [从 Github 上的源码编译它](https://github.com/atom)。
### 尝试 Atom
Atom 可以成为你的下一个文本编辑器、记事本和 IDE。它易于使用、易于配置、易于扩展，并提供了良好的用户体验。今天就下载 Atom，试试吧。
---
via: <https://opensource.com/article/20/12/atom>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
三种 Linux 下的 SSH 图形界面工具 | Jack Wallen | https://www.linux.com/blog/learn/intro-to-linux/2018/11/three-ssh-guis-linux | 对于许多系统管理员来说，没有什么比命令行更有效的了。但是，有些用户确实更喜欢 GUI 工具，尤其是从一台桌面台式机远程连接到服务器上工作时。 | /data/attachment/album/202101/13/151256qv3ob99lysz97ws1.jpg.thumb.jpg | /data/attachment/album/202101/13/151256qv3ob99lysz97ws1.jpg | true | false | true | lujun9972 | stevenzdg988 | wxy | false | [
"SSH"
] | 分享 | {
"viewnum": 11599,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 对于许多系统管理员来说，没有什么比命令行更有效的了。但是，有些用户确实更喜欢 GUI 工具，尤其是从一台桌面台式机远程连接到服务器上工作时。 | 2021-01-13T15:12:54 | 2021-01-13T15:12:54 | 13,010 | /article-13010-1.html | 
在你作为 Linux 系统管理员的职业生涯中，你可以使用 Secure Shell（SSH）远程访问 Linux 服务器或桌面系统。很有可能，你已经使用过了。在某些情况下，你会通过 SSH 一次性登录多个 Linux 服务器。实际上，SSH 很可能是 Linux 工具箱中最常用的工具之一。因此，你会希望操作尽可能高效。对于许多系统管理员来说，没有什么比命令行更有效的了。但是，有些用户确实更喜欢 GUI 工具，尤其是从一台桌面台式机远程连接到服务器上工作时。
如果你碰巧喜欢 GUI 工具，那么你肯定想了解一下 Linux 上的一些出色的 SSH 图形界面工具。将其与独特的终端窗口相结合，可以从同一窗口远程访问多台计算机，你便拥有了高效工作所需的一切。让我们看以下这三个工具，找出其中一个（或多个）是否完全适合你的需求。
我将在 [Elementary OS](https://elementary.io/) 上演示这些工具，但是大多数流行的发行版都可以使用它们。
### PuTTY
只要是久经沙场的人都知道 [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html)。 实际上，PuTTY 是从 Windows 环境通过 SSH 连接到 Linux 服务器的事实标准工具。但是 PuTTY 不仅适用于 Windows。实际上，从其标准存储库中，PuTTY 也可以安装到 Linux 上。 PuTTY 的功能列表包括：
* 保存会话
* 通过 IP 地址或主机名链接
* 定义备用 SSH 端口
* 链接类型定义
* 日志记录
* 键盘、响铃、外观、连接等选项
* 本地和远程隧道配置
* 支持代理
* 支持X11 隧道
PuTTY GUI 主要是一种保存 SSH 会话的方式，因此，你可以更轻松地管理那些你需要不断远程登录、登出的各种 Linux 服务器和桌面台式机。从 PuTTY 连接到 Linux 服务器后，你将拥有一个可以运行的终端窗口。此时，你可能会问自己，为什么不只在终端窗口中工作？对于某些人来说，保存会话的便捷性确实使 PuTTY 值得使用。
在 Linux 上安装 PuTTY 很简单。例如，你可以在基于 Debian 的发行版上执行命令：
```
sudo apt-get install -y putty
```
安装后，你可以从桌面菜单运行 PuTTY GUI 或执行命令 `putty`。在“<ruby> PuTTY 配置 <rt> PuTTY Configuration </rt></ruby>” 窗口（图 1）中，在 “<ruby> 主机名（或 IP 地址） <rt> HostName (or IP address) </rt></ruby>”位置键入主机名或 IP 地址，配置<ruby> 端口 <rt> Port </rt></ruby>”（如果不是默认值 22），从“<ruby> 连接类型 <rt> Connection type </rt></ruby>”中选择 “SSH” ，然后单击“<ruby> 打开 <rt> Open </rt></ruby>”。
*图 1：PuTTY 连接配置窗口。*
建立连接后，系统将提示你输入远程服务器上的用户凭据（图 2）。
*图 2：使用 PuTTY 登录到远程服务器。*
要保存会话（以便不必总是键入远程服务器信息），填写 IP 地址（或主机名），配置端口和连接类型，然后（在单击 “<ruby> 打开 <rt> Open </rt></ruby>” 之前），在 “<ruby> 保存会话 <rt> Saved Sessions </rt></ruby>” 顶部文本区域中键入链接的名称，然后单击 “<ruby> 保存 <rt> Save </rt></ruby>”。 这样将保存此会话的配置。若要连接到已保存的会话，请从 “<ruby> 已保存的会话 <rt> Saved Sessions </rt></ruby>” 窗口中选择它，单击 “<ruby> 加载 <rt> Load </rt></ruby>”，然后单击 “<ruby> 打开 <rt> Open </rt></ruby>”。 然后，系统将提示你输入远程服务器上的远程凭据登录远程服务器。
### EasySSH
尽管 [EasySSH](https://github.com/muriloventuroso/easyssh) 没有提供 PuTTY 中提供的大量配置选项，但是（顾名思义）它非常易于使用。 EasySSH 的最佳功能之一是提供标签式界面，因此你可以打开多个 SSH 连接并在它们之间快速切换。 EasySSH 的功能包括：
* 分组（你可以将选项卡分组以获得更高效的体验）。
* 保存用户名/密码。
* 外观选项。
* 支持本地和远程隧道。
在 Linux 桌面上安装 EasySSH 很简单，因为可以通过 flatpak 安装该应用程序（这意味着你必须在系统上安装 Flatpak ）。 安装 flatpak 后，使用以下命令添加 EasySSH ：
```
sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
sudo flatpak install flathub com.github.muriloventuroso.easyssh
```
使用以下命令运行 EasySSH ：
```
flatpak run com.github.muriloventuroso.easyssh
```
你可以在其中单击左上角的 “+” 按钮打开 EasySSH 应用程序。 在出现的窗口（图 3）中，根据需要配置 SSH 连接。
*图 3：在 EasySSH 中添加连接很简单。*
添加连接后，它将显示在主窗口的左侧导航中（图 4）。
*图 4：EasySSH 主窗口。*
要在 EasySSH 中连接到远程服务器，请从左侧导航中选择它，然后单击 “<ruby> 连接 <rt> Connect </rt></ruby>” 按钮（图 5）。
*图 5：使用 EasySSH 连接到远程服务器。*
EasySSH 的一个注意事项是你必须在连接配置中保存用户名和密码（否则连接将失败）。这意味着有权访问运行 EasySSH 的桌面的任何人都可以在不知道密码的情况下远程访问你的服务器。因此，你必须始终记得在外出时锁定桌面屏幕（并确保使用强密码）。你最不希望的就是避免服务器受到不必要的登录攻击。
### Terminator
Terminator 实际上不是 SSH GUI。相反，Terminator 的功能是作为一个单一窗口，使你可以一次运行多个终端（甚至一组终端）。实际上，你可以打开 Terminator，将窗口垂直和水平拆分（直到拥有所需的所有终端），然后通过标准 SSH 命令连接到所有远程 Linux 服务器（图 6）。
*图 6：Terminator 分为三个不同的窗口，每个窗口都连接到不同的 Linux 服务器。*
要安装 Terminator，请执行以下命令：
```
sudo apt-get install -y terminator
```
安装后，从桌面菜单或用命令 `terminator` 打开该工具。打开窗口后，你可以在 Terminator 内部右键单击，然后选择 “<ruby> 水平分割 <rt> Split Horizontally </rt></ruby>” 或 “<ruby> 垂直分割 <rt> Split Vertically </rt></ruby>”。继续拆分终端，直到你打开所需的终端为止，然后开始远程管理这些服务器。使用 Terminator 的注意事项是它不是标准的 SSH GUI 工具，因为它不会保存你的会话或使你可以快速访问这些服务器。换句话说，你将始终必须手动登录到远程 Linux 服务器。但是，能够并行查看远程 Secure Shell 会话确实使管理多个远程计算机变得容易得多。
### 少而精的选择
Linux 没有多少可用的 SSH GUI 工具。为什么呢？因为大多数管理员更喜欢简单地打开终端窗口，并使用标准命令行工具来远程访问服务器。但是，如果需要 GUI 工具，则有两个可靠的选择，和一个使登录多台计算机稍微容易一些的终端。尽管对于那些寻找 SSH GUI 工具的人来说只有少数选择，但是可用的那些肯定值得你花时间，根据需要尝试其中之一。
---
via: <https://www.linux.com/blog/learn/intro-to-linux/2018/11/three-ssh-guis-linux>
作者：[Jack Wallen](https://www.linux.com/users/jlwallen) 选题：[lujun9972](https://github.com/lujun9972) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
从 Linux 命令行进行打印 | Sandra Henry-stocker | https://www.networkworld.com/article/3373502/printing-from-the-linux-command-line.html | 在 Linux 命令行进行打印的内容比单单一个 lp 命令多得多，让我们来看一些可用选项。 | /data/attachment/album/202101/13/230317cm4cjuiti44pgv8o.jpg.thumb.jpg | /data/attachment/album/202101/13/230317cm4cjuiti44pgv8o.jpg | true | false | true | lujun9972 | stevenzdg988 | wxy | false | [
"打印",
"lp",
"CUPS"
] | 技术 | {
"viewnum": 7083,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 在 Linux 命令行进行打印的内容比单单一个 lp 命令多得多，让我们来看一些可用选项。 | 2021-01-13T23:03:17 | 2021-01-13T23:03:17 | 13,012 | /article-13012-1.html |
>
> 在 Linux 命令行进行打印的内容比单单一个 `lp` 命令多得多，让我们来看一些可用选项。
>
>
>
Linux 命令行打印很容易。你可以使用 `lp` 命令来请求打印，并使用 `lpq` 命令来查看队列中有哪些打印作业，但是当你要双面打印或使用纵向模式时，这些会变得有些复杂。你可能还需要做很多其他事情，例如打印多份文档副本或取消打印作业。让我们来看看一些选项，当你从命令行打印时，如何让你的打印输出看起来如你所愿。
### 显示打印机配置
要从命令行查看打印机设置，请使用 `lpoptions` 命令。 输出应如下所示：
```
$ lpoptions
copies=1 device-uri=dnssd://HP%20Color%20LaserJet%20CP2025dn%20(F47468)._pdl-datastream._tcp.local/ finishings=3 job-cancel-after=10800 job-hold-until=no-hold job-priority=50 job-sheets=none,none marker-change-time=1553023232 marker-colors=#000000,#00FFFF,#FF00FF,#FFFF00 marker-levels=18,62,62,63 marker-names='Black\ Cartridge\ HP\ CC530A,Cyan\ Cartridge\ HP\ CC531A,Magenta\ Cartridge\ HP\ CC533A,Yellow\ Cartridge\ HP\ CC532A' marker-types=toner,toner,toner,toner number-up=1 printer-commands=none printer-info='HP Color LaserJet CP2025dn (F47468)' printer-is-accepting-jobs=true printer-is-shared=true printer-is-temporary=false printer-location printer-make-and-model='HP Color LaserJet cp2025dn pcl3, hpcups 3.18.7' printer-state=3 printer-state-change-time=1553023232 printer-state-reasons=none printer-type=167964 printer-uri-supported=ipp://localhost/printers/Color-LaserJet-CP2025dn sides=one-sided
```
如果将其空格转换为回车符，输出可能会更人性化，请注意列出了多少设置选项。
注意：在下面的输出中，一些行被重新链接，以使输出更具可读性。
```
$ lpoptions | tr " " '\n'
copies=1
device-uri=dnssd://HP%20Color%20LaserJet%20CP2025dn%20(F47468)._pdl-datastream._tcp.local/
finishings=3
job-cancel-after=10800
job-hold-until=no-hold
job-priority=50
job-sheets=none,none
marker-change-time=1553023232
marker-colors=#000000,#00FFFF,#FF00FF,#FFFF00
marker-levels=18,62,62,63
marker-names='Black\ Cartridge\ HP\ CC530A,
Cyan\ Cartridge\ HP\ CC531A,
Magenta\ Cartridge\ HP\ CC533A,
Yellow\ Cartridge\ HP\ CC532A'
marker-types=toner,toner,toner,toner
number-up=1
printer-commands=none
printer-info='HP Color LaserJet CP2025dn (F47468)'
printer-is-accepting-jobs=true
printer-is-shared=true
printer-is-temporary=false
printer-location
printer-make-and-model='HP Color LaserJet cp2025dn pcl3, hpcups 3.18.7'
printer-state=3
printer-state-change-time=1553023232
printer-state-reasons=none
printer-type=167964
printer-uri-supported=ipp://localhost/printers/Color-LaserJet-CP2025dn
sides=one-sided
```
使用 `-v` 选项时，`lpinfo` 命令将列出驱动程序和相关信息：
```
$ lpinfo -v
network ipp
network https
network socket
network beh
direct hp
network lpd
file cups-brf:/
network ipps
network http
direct hpfax
network dnssd://HP%20Color%20LaserJet%20CP2025dn%20(F47468)._pdl-datastream._tcp.local/ <== printer
network socket://192.168.0.23 <== printer IP
```
`lpoptions` 命令将显示默认打印机的设置。使用 `-p` 选项指定其中一个可用打印机代号：
```
$ lpoptions -p LaserJet
```
`lpstat -p` 命令显示打印机的状态，而 `lpstat -p -d` 列出可用打印机列表。
```
$ lpstat -p -d
printer Color-LaserJet-CP2025dn is idle. enabled since Tue 19 Mar 2019 05:07:45 PM EDT
system default destination: Color-LaserJet-CP2025dn
```
### 非常有用的命令
要在默认打印机上打印文档，只需使用 `lp` 命令，后跟要打印的文件名即可。 如果文件名包含空格（在 Linux 系统上很少见），请将该名称放在引号中或开始输入文件名并按 `Tab` 键调用空格的转义标志（如下面的第二个示例所示）。
```
$ lp "never leave home angry"
$ lp never\ leave\ home\ angry
```
`lpq` 命令显示打印队列：
```
$ lpq
Color-LaserJet-CP2025dn is ready and printing
Rank Owner Job File(s) Total Size
active shs 234 agenda 2048 bytes
```
使用 `-n` 选项时，`lp` 命令可用来指定所需打印输出的份数：
```
$ lp -n 11 agenda
```
要取消打印作业，可以使用 `cancel` 或 `lprm` 命令。如果没来得及执行，则可能会看到以下信息：
```
$ cancel 229
cancel: cancel-job failed: Job #229 is already completed - can't cancel.
```
### 双面打印
要以双面模式打印，你可以在 `lp` 命令中使用 `sides` 选项，该选项不但表示了在纸张的正反面进行打印，还表示了从纸张的哪个边开始打印。这个设置代表了你期望以双面纵向文档的正常方式打印。
```
$ lp -o sides=two-sided-long-edge Notes.pdf
```
如果要所有文档以双面模式打印，则可以使用 `lpoptions` 命令更改 `sides` 设置以修改 `lp` 的设置。
```
$ lpoptions -o sides=two-sided-short-edge
```
要恢复为单面打印，可以使用如下命令：
```
$ lpoptions -o sides=one-sided
```
#### 横向打印
要以横向模式打印，可以在 `lp` 命令中使用 `landscape` 选项。
```
$ lp -o landscape penguin.jpg
```
### CUPS（Unix 通用打印系统）
Linux 系统上使用的打印系统是基于标准的开源打印系统，称为 **CUPS**，原意是<ruby> Unix 通用打印系统 <rt> Common Unix Printing System </rt></ruby>。 它允许计算机充当打印服务器。
---
via: <https://www.networkworld.com/article/3373502/printing-from-the-linux-command-line.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
通过编写一个简单的游戏学习 C 语言 | Jim Hall | https://opensource.com/article/21/1/learn-c | 当你学习一门新的编程语言时，这个“猜数字”游戏是一个很好的入门程序。下面是如何用 C 语言来编写它。 | /data/attachment/album/202101/13/232713lh91stdahcxfyfhe.jpg.thumb.jpg | /data/attachment/album/202101/13/232713lh91stdahcxfyfhe.jpg | true | false | true | lujun9972 | qfzy1233 | wxy | false | [
"猜数字"
] | 软件开发 | {
"viewnum": 5701,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "180.166.90.162",
"message": "当年我的老师在 APPLE II 上用 pascal 语言也写了一个猜数游戏，不过是由人来出一个四位数字，然后电脑来猜这个数是什么。",
"username": "来自上海的 Iron|Windows 7 用户",
"date": "2021-01-15T06:58:52"
}
] | [
{
"raid": 13000,
"displayorder": 0
},
{
"raid": 13087,
"displayorder": 0
}
] | 当你学习一门新的编程语言时，这个“猜数字”游戏是一个很好的入门程序。下面是如何用 C 语言来编写它。 | 2021-01-13T23:28:59 | 2021-01-13T23:28:59 | 13,013 | /article-13013-1.html |
>
> 当你学习一门新的编程语言时，这个“猜数字”游戏是一个很好的入门程序。下面是如何用 C 语言来编写它。
>
>
>
我在小学时就开始 [自学编程](https://opensource.com/article/20/8/learn-open-source)。我的第一个程序是在 Apple II 上编写的，但最终，我还是通过看书和编程练习学会了 C 语言。练习编程的最佳方法是编写示例程序，它能帮助你练习新知识。
在我学习一种新的编程语言时，我喜欢编写一个简单的“猜数字”游戏来练习。电脑从 1 到 100 中随机挑选一个数字，你必须通过猜测来算出来。在另一篇文章中，我展示了如何用 Bash 语言编写这个[“猜数字”游戏](/article-12962-1.html)，我的同事也写了一些文章，介绍如何用 [Java](https://opensource.com/article/20/12/learn-java)、[Julia](https://opensource.com/article/20/12/julia) 和其他计算机语言编写它。
“猜数字”游戏的伟大之处在于它践行了几个编程概念：如何使用变量、如何比较值、如何打印输出以及如何读取输入。
整个夏天，我录制了[一个系列视频](https://opensource.com/article/20/8/teaching-c)，教人们如何用 [C 语言](https://opensource.com/article/20/8/c-programming-cheat-sheet)编写程序。从那以后，我听到了很多人都在跟着它学习 C 语言编程的消息。所以，我想接着用 C 语言写一个“猜数字”的游戏。
### 去取一个随机数
从写一个函数来选择一个随机数字来开始“猜数字”游戏。在编写函数时，优秀的程序员会尽量使它们具有灵活性，这样他们就可以重用它们来解决略有不同的问题。因此，与其硬编码函数来选择 1 到 100 之间的一个随机数，不如编写函数来选择 1 到某个整数 `maxval` 之间的一个随机数：
```
#include <stdio.h>
#include <sys/random.h>
int
randnum(int maxval)
{
/* pick a random number from 1 to maxval */
int randval;
getrandom(&randval, sizeof(int), GRND_NONBLOCK);
/* could be negative, so ensure it's positive */
if (randval < 0) {
return (-1 * randval % maxval + 1);
}
else {
return (randval % maxval + 1);
}
}
```
该函数使用 Linux 的系统调用 `getrandom` 来生成一系列随机数。你可以在手册页中了解关于这个系统调用的更多信息，但请注意，`getrandom` 将用随机的 0 和 1 填充变量。这意味着最终值可以是正的，也可以是负的，因此你需要在之后进行测试，以确保 `randnum` 函数的结果是正值。
### 编写程序
你可以用这个函数来写你的“猜数字”程序:
```
#include <stdio.h>
#include <sys/random.h>
int
randnum(int maxval)
{
...
}
int
main(void)
{
int number;
int guess;
number = randnum(100);
puts("Guess a number between 1 and 100");
do {
scanf("%d", &guess);
if (guess < number) {
puts("Too low");
}
else if (guess > number) {
puts("Too high");
}
} while (guess != number);
puts("That's right!");
return 0;
}
```
程序首先使用 `randnum` 函数从 1 到 100 之间选择一个随机数。在向用户输出一个提示后，程序进入一个 `do-while` 循环，以便用户可以猜测数字。
在循环的每次迭代中，程序测试用户的猜测的数值。如果用户的猜测小于随机数，程序将输出“Too low”，如果猜测大于随机数，程序将输出“Too high”。循环继续，直到用户的猜测与随机数相同。
当循环退出时，程序输出 “That's right!”，然后立即结束：
```
$ gcc -o guess -Wall guess.c
$ ./guess
Guess a number between 1 and 100
50
Too high
30
Too low
40
Too low
45
Too high
42
Too low
43
Too low
44
That's right!
```
### 尝试动手
在学习一门新的编程语言时，这个“猜数字”游戏是一个很好的入门程序，因为它以一种非常直接的方式练习了几个常见的编程概念。通过用不同的编程语言实现这个简单的游戏，你可以演示一些核心概念，并比较每种语言的细节。
你有最喜欢的编程语言吗？你会如何用它来编写“猜数字”游戏呢？关注本系列文章，查看你可能感兴趣的其他编程语言的示例。
---
via: <https://opensource.com/article/21/1/learn-c>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 选题：[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/) 荣誉推出
|
用 Portainer.io 来监控和管理 Docker 容器（2） | Shashidhar Soppin | https://www.linuxtechi.com/monitor-manage-docker-containers-portainer-io-part-2/ | 作为第 1 部分的延续，本第 2 部分将介绍 Portainer 的其余功能。 | /data/attachment/album/202101/14/204401knuxjru53n5su6ns.jpg.thumb.jpg | /data/attachment/album/202101/14/204401knuxjru53n5su6ns.jpg | true | false | true | lujun9972 | Chao-zhi | wxy | false | [
"Portainer"
] | 容器与云 | {
"viewnum": 6258,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "218.29.112.89",
"message": "好是挺好 就是不支持中文啊..",
"username": "来自河南郑州的 Chrome 88.0|Windows 10 用户",
"date": "2021-01-21T09:39:44"
}
] | [
{
"raid": 12634,
"displayorder": 0
}
] | 作为第 1 部分的延续，本第 2 部分将介绍 Portainer 的其余功能。 | 2021-01-14T20:46:03 | 2021-01-14T20:46:03 | 13,015 | /article-13015-1.html | 
作为[第 1 部分](/article-12634-1.html)的延续，本第 2 部分将介绍 Portainer 的其余功能。
### 监控 docker 容器镜像
```
root@linuxtechi ~}$ docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
9ab9aa72f015 ubuntu "/bin/bash" 14 seconds ago Exited (0) 12 seconds ago suspicious_shannon
305369d3b2bb centos "/bin/bash" 24 seconds ago Exited (0) 22 seconds ago admiring_mestorf
9a669f3dc4f6 portainer/portainer "/portainer" 7 minutes ago Up 7 minutes 0.0.0.0:9000->9000/tcp trusting_keller
```
包括 `portainer`（docker 容器镜像），所有已退出和当前正在运行的 docker 镜像都会显示出来。下面的 Portainer GUI 屏幕截图显示了相同的情况。
### 监视事件
单击 portainer 网页中的“Events”选项，如下所示。
基于 docker 容器活动生成和创建的各种事件将被提取并显示在此页面中.
现在检查并验证“Events”部分是如何工作的。创建一个新的 docker 容器镜像 `redis`，如下所述，在 docker 命令行检查状态：`docker ps –a`：
```
root@linuxtechi ~}$ docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
cdbfbef59c31 redis "docker-entrypoint.s…" About a minute ago Up About a minute 6379/tcp angry_varahamihira
9ab9aa72f015 ubuntu "/bin/bash" 10 minutes ago Exited (0) 10 minutes ago suspicious_shannon
305369d3b2bb centos "/bin/bash" 11 minutes ago Exited (0) 11 minutes ago admiring_mestorf
9a669f3dc4f6 portainer/portainer "/portainer" 17 minutes ago Up 17 minutes 0.0.0.0:9000->9000/tcp trusting_keller
```
单击顶部的“Event List”刷新事件列表，
现在事件的页面也更新了这个变化，
### 主机状态
下面是 portainer 显示主机状态的屏幕截图。这是一个简单的窗口。这显示了主机 Linux 机器的基本信息，如“CPU”、“主机名”、“操作系统信息”等。这个页面在不需要登录主机命令行的情况下提供了非常有用的信息，以便快速浏览。
### Portainer 中的仪表板
到目前为止，我们已经在“Local”部分看到了基于 portainer 的各种特性。现在跳到所选 Docker 容器镜像的“Dashboard”部分。
在 Portainer 的网页中单击“EndPoint”选项时，会出现以下窗口：
对于主机容器镜像，此仪表板有许多状态和选项。
#### Stacks
单击此选项可提供任何堆栈（如果有的话）的状态。因为这里没有堆栈，所以显示为零。
#### Images
单击此选项可提供主机中可用的容器镜像。此选项将显示所有活动和退出的容器镜像。
例如，再创建一个“Nginx”容器并刷新此列表以查看更新：
```
root@linuxtechi ~}$ sudo docker run nginx
Unable to find image 'nginx:latest' locally
latest: Pulling from library/nginx
27833a3ba0a5: Pull complete
ea005e36e544: Pull complete
d172c7f0578d: Pull complete
Digest: sha256:e71b1bf4281f25533cf15e6e5f9be4dac74d2328152edf7ecde23abc54e16c1c
Status: Downloaded newer image for nginx:latest
```
下面是刷新后的镜像界面：
当 Nginx 镜像处于 `stopped`/`killed` 状态时，docker 的容器镜像会改变为 `unused` 状态。
**注**：你可以看到这里所有的镜像的细节都非常清楚，比如内存使用，创建日期和时间。与命令行选项相比，从这里维护和监视容器将非常容易。
#### Networks
此选项用于网络操作。例如分配 IP 地址、创建子网、提供 IP 地址范围、访问控制（管理员和普通用户）。下面的窗口提供了各种可能选项的详细信息。根据你的需要，可以进一步去自行研究这些选项。
输入所有各种网络参数后，单击“create network”按钮即可创建网络。
#### Container
此选项将提供容器状态。此列表将提供有关活动的和未运行的容器状态的详细信息。此输出类似于 docker ps 命令选项。
在该窗口中，通过选中复选框并选择上述按钮可以根据需要控制容器停止和启动。一个例子如下：
例如，“CentOS”和“Ubuntu”容器都处于停止状态，现在可以通过选中复选框并点击“Start”按钮来启动它们。
**注意：** 因为这两个都是 Linux 容器镜像，所以不会被启动。Portainer 尝试启动，但稍后又停止。试试启动“Nginx”，你会看到它变成了 `running` 状态。
#### Volume
参见本文章第一部分。
### Portainer 中的设置选项
到目前为止，我们已经在“Local”部分看到了基于 portainer 的各种特性。现在跳到所选 Docker 容器图像的“Settings”部分。
在 Portainer 的网页中单击“Settings”选项时，可以使用以下的配置选项：
#### Extensions
这是一个简单的 Portainer CE 订阅程序。详细信息和用途可以从附加的窗口中看到。这主要用于维护相应版本的许可证和订阅。
#### Users
此选项用于添加具有或不具有管理权限的“用户”。下面的示例提供了相同的示例。
在本例中输入你的想好的用户名比如“shashi”和你选择的密码，然后点击下面的“Create User”按钮。
类似地，可以通过选中复选框并点击 “remove” 按钮来删除刚刚创建的用户“shashi”。
#### Endpoints
此选项用于端点终端管理。终端可以添加和删除，如附加窗口中所示。
新终端“shashi”是使用如下所示的各种默认参数创建的，
类似地，可以通过单击复选框并单击移除按钮来移除此端点。
#### Registries
此选项用于注册管理。由于 docker hub 有各种镜像的注册，因此此功能可用于类似的目的。
使用默认选项就可以创建“shashi-registry”。
同样，如果不需要了，就可以移除它。
#### Settings
此选项用于设置以下各种选项，
* 设置快照间隔
* 设置自定义徽标
* 创建外部模板
* 安全功能，如：为非管理员禁用和启用 bin 挂载，为非管理员禁用/启用权限，启用主机管理功能
下面的屏幕截图显示了出于演示目的启用和禁用的一些选项。一旦全部完成点击“保存设置”按钮保存所有这些选项。
现在点开“Authentication settings”就会弹出 LDAP、Internal 和 OAuth（extension）选项，如下所示：
根据我们想要的环境安全特性级别，选择相应的选项。
以上就是本文的内容，我希望这些介绍 portainer 的文章能帮助你更有效地管理和监视容器。请分享你的反馈和意见。
---
via: <https://www.linuxtechi.com/monitor-manage-docker-containers-portainer-io-part-2/>
作者：[Shashidhar Soppin](https://www.linuxtechi.com/author/shashidhar/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Chao-zhi](https://github.com/Chao-zhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
我最喜欢的 3 个开源生产力应用 | Taz Brown | https://opensource.com/article/21/1/open-source-productivity-apps | 简化你的敏捷工作流程，提高你的工作效率。 | /data/attachment/album/202101/14/215039op8zl611f8p76vrf.jpg.thumb.jpg | /data/attachment/album/202101/14/215039op8zl611f8p76vrf.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"生产力"
] | 分享 | {
"viewnum": 6127,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "114.86.151.20",
"message": "我的<br />\r\nmpv<br />\r\nV2rayU<br />\r\niTerm2",
"username": "来自上海的 Chrome 87.0|Mac 11.1 用户",
"date": "2021-01-15T18:21:55"
}
] | [] | 简化你的敏捷工作流程，提高你的工作效率。 | 2021-01-14T21:50:47 | 2021-01-14T21:50:47 | 13,016 | /article-13016-1.html |
>
> 简化你的敏捷工作流程，提高你的工作效率。
>
>
>
生产力应用确实可以让你的工作流程变得更加轻松。在本文中，我将分享一些我用来简化工作流程、提高整体生产力的开源应用。本文中所有的生产力应用都是免费的 Linux 生产力应用。
### Tomboy/Gnote
[Tomboy](https://wiki.gnome.org/Apps/Tomboy) 是一款可以在 Linux、Windows 和 macOS 上使用的简单记事本应用。它是 GNU LGPLv2 下许可的开源软件。
Tomboy 使用起来非常简单。你写下一张纸条，选择是否将它贴在桌面上，完成后就可以删除它。
它（以及它的克隆版 [Gnote](https://wiki.gnome.org/Apps/Gnote)）是一个很好的快速记笔记的小程序。很多时候，当我在做某件事情的时候，会有一些想法或思路想要回忆。Tomboy 可以让我快速创建一个笔记，在我忘记之前把我的想法记下来。然后我就可以把这些想法转移到一个更长久的地方。
### Joplin
[Joplin](https://joplinapp.org/) 是一个开源的记事和待办事项应用。它是跨平台的，可以在 Linux、Windows、macOS、iOS 和 Android 上使用，并且采用 MIT 许可开源。
它可以使用 Dropbox、OneDrive、Nextcloud 等云同步服务进行同步。它很容易安装，可能就在你的 Linux 仓库里。当你在桌面上安装它时，它一个应用中实际包含了两个：你会得到一个标准的图形用户界面 （GUI），或者打开一个终端，在那里使用 Joplin。
桌面版有一个非常漂亮的界面。笔记被组织在笔记本中，这基本上使它们成为你的手册页。而且因为笔记是 Markdown 格式的，所以它们会被渲染，你可以实时编辑它们。我喜欢使用 Markdown，因为它让我写笔记的速度很快。你也可以导出或导入 Joplin 笔记。
### Evolution
[Evolution](https://wiki.gnome.org/Apps/Evolution) 是一款开源的个人信息管理应用，它与 Outlook 非常相似，但我认为更适合我使用。它具有电子邮件、工作、笔记、链接、日历和地址簿功能。它是 LGPL 和其他[许可证](https://gitlab.gnome.org/GNOME/evolution/-/blob/master/COPYING)下的开源软件。
我在运行 Fedora 的台式电脑上使用它。它的效率很高，绝对能帮助我度过繁忙的一天。它让我能够使用 Linux 开展业务；我还能要求什么呢？
要在 Fedora 中使用它，打开一个终端并输入以下命令：
```
sudo dnf remove evolution
sudo dnf update
sudo dnf install evolution
sudo dnf install evolution-ews
```
### 我的常用工具
这些工具是我的主力军，我已经依赖了一段时间。使用它们超越了它们的基本功能，使我更有效率、更有效果、更有生产力。作为一名技术产品经理和敏捷专家，我很自豪，我仍然使用 Linux 和其他开源软件，即使我工作的公司不这样做。
---
*本文原载于 [Course Hero](https://www.coursehero.com/file/74086904/Personal-productivity-using-open-source-software-tools/)，经授权转载。*
---
via: <https://opensource.com/article/21/1/open-source-productivity-apps>
作者：[Taz Brown](https://opensource.com/users/heronthecli) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
学习 Python 的好文章 | Matthew Broberg | https://opensource.com/article/19/12/learn-python | 无论你在 Python 编程过程中处于什么阶段，这些 Python 热门文章将会对你有很大帮助。 | /data/attachment/album/202101/15/231657xt8085wtyk5yvsz5.jpg.thumb.jpg | /data/attachment/album/202101/15/231657xt8085wtyk5yvsz5.jpg | true | false | true | lujun9972 | stevenzdg988 | wxy | false | [
"Python"
] | 软件开发 | {
"viewnum": 3491,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "113.85.28.57",
"message": "fgggggggggggggggg",
"username": "来自广东潮州的 Chrome 78.0|Windows 10 用户",
"date": "2021-01-17T01:25:42"
}
] | [] | 无论你在 Python 编程过程中处于什么阶段，这些 Python 热门文章将会对你有很大帮助。 | 2021-01-15T23:17:00 | 2021-01-15T23:17:00 | 13,018 | /article-13018-1.html |
>
> 无论你在 Python 编程过程中处于什么阶段，这些 Python 热门文章将会对你有很大帮助。
>
>
>
2019 年是 Python 的好年景。根据 [GitHub](https://octoverse.github.com/#top-languages) 和 [Stack Overflow](https://insights.stackoverflow.com/survey/2019) 的受欢迎资源程度来看，它正在成为全球第二大流行语言。（LCTT 译注：原文发表于 2019 年底，但是这里提及的文章并没有过时。）
>
> “在我们的调查中，Python 作为增长最快的程序设计语言，在程序设计语言中排名再次上升，今年排在 Java 之前，成为第二大最受欢迎的程序设计语言（仅次于 Rust ）。”
>
>
> — [Stack Overflow Insights](https://insights.stackoverflow.com/survey/2019)
>
>
>
同样，Python 的读者人数呈跳跃式激增。以下是按主题分组的 2019 年以来最热门的 Python 文章，供你仔细阅读。
### 为什么选择 Python ？
在众多的程序设计语言中，是什么使 Python 成为首选呢？从文章的阅读量来看，那就是因为它的灵活性。正如 Jigyasa Grover 解释的那样，Python 开发人员可以使用 [多种范例](https://opensource.com/article/19/10/python-programming-paradigms)，包括 Seth Kenlon 教程所展示的流行的 [面向对象程序设计](https://opensource.com/article/19/7/get-modular-python-classes)。
如果你是 Python 的长期用户，并且正在寻找 Python 为什么是完美的程序设计语言的高级例子，那么可以看 Moshe Zadka 的 [喜欢 Python 的 5 大理由](https://opensource.com/article/19/10/why-love-python)。如果这还不够的话，你也可以使用功能强大的工具来尝试，无需编写大量代码，例如 Parul Pandey 关于 [图像处理](/article-10679-1.html) 的教程。
### 配置 Python
随着 Python 的受欢迎程度不断提高，使用它的人越来越多。这些新手中的许多人都是在 Mac 操作系统上进行的，并且正在使用 Moshe 和我写的 [Python3 配置向导](https://opensource.com/article/19/5/python-3-default-mac)。
安装 Python 之后，接下来就是决定利用什么工具编写代码。关于文本编辑器和集成开发环境（IDE），有很多选择，但是读者似乎更喜欢图形界面，在有关该主题的文章中，Stephan Avenwedde 的关于 [Pythonic](https://opensource.com/article/19/5/graphically-programming-pythonic) 和我关于 [JupyterLab](https://opensource.com/article/19/5/jupyterlab-python-developers-magic) 的文章的读者最多。
在对程序设计语言充满信心的途径上，开发人员将不得不面对众多选择，来管理程序设计语言的版本和项目依赖。幸运的是，László Kiss Kollár 的文章 [Python 包管理](https://opensource.com/article/19/4/managing-python-packages) 让其变得更加容易。
当你准备好配置一个具有所有功能的 IDE，以最大限度地利用这门语言时，请一定尝试一下 [linter Black](/article-10864-1.html)，如 Moshe 说的，保持代码的清洁。
### 小结
无论你处在 Python 程序设计的哪个阶段，这些热门 Python 文章都将为你提供帮助。如果没有至少一次对测试重要性的认可，我无法对此进行总结，为此，Moshe 提供了另一篇 [关于 tox](https://opensource.com/article/19/5/python-tox) 的好文章。
---
via: <https://opensource.com/article/19/12/learn-python>
作者：[Matthew Broberg](https://opensource.com/users/mbbroberg) 选题：[lujun9972](https://github.com/lujun9972) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
我为什么喜欢 FED 文本编辑器 | Jim Hall | https://opensource.com/article/21/1/fed-editor | FED 编辑器让我可以轻松有效地对我的 FreeDOS 项目进行编码。学习如何充分利用这个灵活的 Linux、Windows 和 DOS 编辑器。 | /data/attachment/album/202101/16/114344hgra9oq4q45mgz9r.jpg.thumb.jpg | /data/attachment/album/202101/16/114344hgra9oq4q45mgz9r.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"编辑器"
] | 分享 | {
"viewnum": 3215,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 13009,
"displayorder": 0
}
] | FED 编辑器让我可以轻松有效地对我的 FreeDOS 项目进行编码。学习如何充分利用这个灵活的 Linux、Windows 和 DOS 编辑器。 | 2021-01-16T11:44:22 | 2021-01-16T11:44:22 | 13,019 | /article-13019-1.html |
>
> FED 编辑器让我可以轻松有效地对我的 FreeDOS 项目进行编码。学习如何充分利用这个灵活的 Linux、Windows 和 DOS 编辑器。
>
>
>
当我不[在我的 Linux 桌面上工作](https://opensource.com/article/19/9/business-creators-open-source-tools)的时候，我通常是在为一个旧版的 16 位系统写代码。[FreeDOS](https://opensource.com/article/19/6/freedos-anniversary) 是一个开源的 DOS 兼容操作系统，你可以用它来玩经典的 DOS 游戏，运行旧版的商业软件，或者开发嵌入式系统。任何在 MS-DOS 上运行的程序在 FreeDOS 上也应该可以运行。
我是和 DOS 一起长大的。我家的第一台个人电脑是一台 Apple II 兼容机，但我们最终升级到了一台运行 DOS 的 IBM PC。从 1980 年代早期到 1993 年我[发现 Linux](https://opensource.com/article/17/5/how-i-got-started-linux-jim-hall-freedos) 这段时间，我做了十多年的 DOS 用户。
Linux 和开源软件所提供的自由度给我留下了深刻的印象。所以当微软在 1994 年宣布 DOS 的终结，以及即将推出的 Windows 95 时，我决定编写自己的开源 DOS。这就是 [FreeDOS 的开始](https://opensource.com/article/17/5/how-i-got-started-linux-jim-hall-freedos)。
这么多年过去了，我还在继续研究 FreeDOS。它是一个很好的业余兴趣系统，在这里我可以运行我最喜欢的 DOS 应用和游戏。是的，我仍然在为 FreeDOS 写代码。
我最喜欢的 DOS 编程编辑器是 FED 编辑器。FED 是一个极简的文本编辑器，没有太多的视觉效果。这种精简的方法帮助我充分利用了 DOS 中标准的 80x25 屏幕。当编辑一个文件时，FED 会在屏幕底部显示一行状态行，让你在剩下的 24 行来编写你的代码。FED 还支持彩色语法高亮显示，以不同的颜色显示代码的不同部分，使你更容易发现错别字，以免它们变成错误。
*用 FED 写一个纸牌游戏*
当你需要菜单时，按下键盘上的 `Alt` 键，FED 就会在最上面一行显示一个菜单。FED 也支持键盘快捷键，但要注意默认值。例如，`Ctrl-C` 会关闭文件，`Ctrl-V` 会改变视图。如果你不喜欢这些默认键，你可以在 **Config** 菜单中更改键位映射。
*按下 Alt 键弹出菜单*
如果你不喜欢默认的白底黑字显示，你可以在 **Config** 菜单下更改颜色。我更喜欢蓝底白字的正文，关键词用亮白色，注释用亮蓝色，特殊字符用青色，数字用绿色。FED 可以很容易地设置你想要的颜色。
*我在 DOS 上编程时喜欢的颜色*
FED 也是一个折叠式文本编辑器，这意味着它可以折叠或展开我的部分代码，以便我可以看到更多的文件。在函数名上按下 `Ctrl-F`，FED 会折叠整个函数。折叠在其他代码上也可以使用。我也使用折叠来隐藏 `for` 和 `while` 循环或其他流程控制，如 `if` 和 `switch` 块。
*折叠函数可以让你看到更多的文件*
Shawn Hargreaves 从 1994 年至 2004 年编写并维护 FED。Robert Riebisch 从那时起就开始维护 FED。FED 在 GNU GPL 许可下发布，支持 DOS、Linux 和 Windows。
你可以在 <https://www.bttr-software.de/products/fed/> 下载 FED。
---
via: <https://opensource.com/article/21/1/fed-editor>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 选题：[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/) 荣誉推出
|
在树莓派集群中部署 Ceph | Aj Canlas | https://opensource.com/article/21/1/ceph-raspberry-pi | 使用 ceph-ansible 安装 Ceph 存储，并将其部署在树莓派集群中。 | /data/attachment/album/202101/16/135445mquduh2idu2pft22.jpg.thumb.jpg | /data/attachment/album/202101/16/135445mquduh2idu2pft22.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Ceph",
"树莓派"
] | 树莓派 | {
"viewnum": 10895,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "123.139.156.190",
"message": "MASTER单点故障如何解决",
"username": "来自陕西西安的 Chrome 87.0|GNU/Linux 用户",
"date": "2021-01-18T10:20:17"
}
] | [] | 使用 ceph-ansible 安装 Ceph 存储，并将其部署在树莓派集群中。 | 2021-01-16T13:55:49 | 2021-01-16T13:55:49 | 13,020 | /article-13020-1.html |
>
> 使用 ceph-ansible 安装 Ceph 存储，并将其部署在树莓派集群中。
>
>
>
[Ceph](https://ceph.io/) 是一个开源软件存储平台，它在统一的存储集群中提供对象、块和文件系统存储。我第一次使用 Ceph 是在 [OpenStack 中集成它](https://opensource.com/business/15/1/introduction-ceph-storage-openstack)的时候。一开始，我很困惑，既然存储设备广泛存在，为什么要使用 Ceph。但在使用了三年多之后，这个平台的稳定性和完整性一再证明了它的价值。
本文将告诉你如何使用 [ceph-ansible](https://docs.ceph.com/projects/ceph-ansible/en/latest/index.html#)（Ceph 官方支持的 Ansible playbook）安装 Ceph，并将其部署在树莓派集群中。
**材料：**
1. 树莓派 4B 4GB 型号四台。
2. 四张 32GB 的 microSD 卡（用于启动操作系统）
3. 四个树莓派外壳，带风扇和散热片（非常重要）
4. 四个树莓派充电器
5. 6 个 32GB U 盘（用于 Ceph OSD 节点）
**架构：**
关于配置：
* 前端和后端网络都在同一个子网中
* [Ceph Monitor](https://docs.ceph.com/en/latest/glossary/#term-Ceph-Monitor) 软件使用 4GB 内存的树莓派 4B。
* [Ceph OSD](https://docs.ceph.com/en/latest/glossary/#term-OSD) 节点使用相同的树莓派型号，但有两个 U 盘用于 OSD 磁盘
### 使用 ceph-ansible 部署 Ceph
使用 Ceph 的 Ansible 仓库可以让部署变得顺畅简单
#### 1、复制 ssh 密钥到所有服务器
我在所有的服务器上都有一个名为 `cephadmin` 的共同用户（在此背景下，每个树莓派都是一台服务器）。`cephadmin` 用户配置了无密码的 `sudo`，以方便工作。
使用 `ssh-keygen` 生成密钥后，使用 `ssh-copy-id` 部署所有密钥。
我使用了一个 Bash `for` 循环，因为我使用的是一致并递增的主机名：
```
$ for i in {0..3}; \
do ssh-copy-id cephadmin@rpi4b4-$i; \
done
```
你需要每个接受并输入密码，但你可以用 `expect` 来自动完成。
#### 2、克隆 ceph-ansible 并安装依赖
安装 Git 来克隆仓库：
```
$ sudo yum install git -y
```
克隆 ceph-ansible 仓库：
```
$ git clone https://github.com/ceph/ceph-ansible.git
$ cd ceph-ansible/
```
我使用的是 CentOS 7 的 AArch64 构建，所以在继续之前，我必须安装一些所需的包。
首先安装 Python `pip`：
```
$ sudo yum install python3-pip -y
```
接着是 ceph-ansible 需要的包：
```
$ sudo yum install python3-devel libffi-devel openssl-devel -y
```
最后，ceph-ansible 需要的依赖：
```
$ pip3 install -r requirements.txt --user
```
我收到了这个错误：
```
You are linking against OpenSSL 1.0.2, which is no longer supported by the OpenSSL project.
To use this version of cryptography you need to upgrade to a newer version of OpenSSL. For
this version only you can also set the environment variable
CRYPTOGRAPHY_ALLOW_OPENSSL_102 to allow OpenSSL 1.0.2.
```
这可能与架构有关，因为我无法在 CentOS 7 虚拟机中复现该错误。
部署时，将 `CRYPTOGRAPHY_ALLOW_OPENSSL_102` 导出为 `True`，这样 Ansible 就可以运行了。
```
$ export CRYPTOGRAPHY_ALLOW_OPENSSL_102=True
```
#### 3、配置 ceph-ansible 进行部署
现在你可以使用 ceph-ansible 部署 Ceph 了。
复制 `site.yml.sample` 到 `site.yml`：
```
$ mv site.yml.sample site.yml
```
在 `group_vars` 目录下创建 `all.yml`：
```
$ cat << EOF >> group_vars/all.yml
ceph_origin: repository
ceph_repository: community
ceph_repository_type: cdn
ceph_stable_release: nautilus
monitor_interface: wlan0
public_network: "192.168.100.0/24"
cluster_network: "192.168.100.0/24"
dashboard_enabled: false
configure_firewall: false
EOF
```
在 `group_vars` 目录下创建 `osds.yml`：
```
$ cat << EOF >> group_vars/all.yml
osd_scenario: collocated
devices:
- /dev/sda
- /dev/sdb
EOF
```
创建一个 `inventory` 文件：
```
$ cat << EOF >> inventory
[mons]
rpi4b4-0
[osds]
rpi4b4-1
rpi4b4-2
rpi4b4-3
EOF
```
在写这篇文章的时候，ceph-ansible 仓库里有一个 bug（根据这个 [bug 工单](https://tracker.ceph.com/issues/43430)）。你可以通过编辑角色的第 85 行和第 86 行来减轻这个 bug。
```
- (wait_for_all_osds_up.stdout | from_json)["osdmap"]["num_osds"] | int > 0
- (wait_for_all_osds_up.stdout | from_json)["osdmap"]["num_osds"] == (wait_for_all_osds_up.stdout | from_json)["osdmap"]["num_up_osds"]
```
#### 4、部署 Ceph
用你的 `inventory` 文件运行 Ansible 剧本：
```
$ ansible-playbook -i inventory site.yml
```
15-20 分钟后，你应该看到这个结果：
### 下面的步骤
之前，我在另一个树莓派集群中[手动部署](https://opensource.com/article/20/12/openstack-raspberry-pi)了一个 OpenStack 集群。我希望能将其与这个集群整合在一起。我也在研究用 [TripleO](https://wiki.openstack.org/wiki/TripleO) 部署。
树莓派、Ansible 和 OpenStack 的可能性是无穷的。开始做你自己的实验，并在评论中告诉我结果如何。
---
via: <https://opensource.com/article/21/1/ceph-raspberry-pi>
作者：[AJ Canlas](https://opensource.com/users/ajscanlas) 选题：[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/) 荣誉推出
|
CI/CD 平台迁移实践：从 Travis-CI 转移到 Github Action | Bestony | 自 2019 年 Github 推出了自家的 CI 工具 Github Action 后，我们就在考虑将 CI 从 Travis-CI 迁移到 Github，以降低维护和沟通的成本，并借助于 GitHub Action Marketplace 实现更强的功能。 | /data/attachment/album/202101/16/182851z3lmlblslo8vw984.jpg.thumb.jpg | /data/attachment/album/202101/16/182851z3lmlblslo8vw984.jpg | true | false | false | false | [
"GitHub",
"CI"
] | 技术 | {
"viewnum": 3550,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 自 2019 年 Github 推出了自家的 CI 工具 Github Action 后，我们就在考虑将 CI 从 Travis-CI 迁移到 Github，以降低维护和沟通的成本，并借助于 GitHub Action Marketplace 实现更强的功能。 | 2021-01-16T18:18:00 | 2021-01-16T18:18:00 | 13,022 | /article-13022-1.html | 
[LCTT](https://linux.cn/lctt/) 的 CI 已经在 Travis CI 上运转了多年，一致保持着良好的使用体验。自 2019 年 Github 推出了自家的 CI 工具 Github Action 后，我们就在考虑将 CI 从 Travis-CI 迁移到 Github，以降低维护和沟通的成本，并借助于 [GitHub Action Marketplace](https://github.com/marketplace?type=actions) 实现更强的功能。
最近，因为 TravisCI 屡屡部署出错，而我们的账户因为使用的较多，已经超出了免费使用的限制，以此为契机，将 CI 从 Travis CI 迁移到 GitHub Action。
### 项目介绍
[Translate Project](https://github.com/LCTT/TranslateProject) 是 [LCTT](https://linux.cn/lctt/) 翻译组的主要协作项目，几百位译者通过 GitHub 进行围绕开源、Linux、软件工程等领域的文章翻译，从 2013 年来，累计了大量的提交，致使项目下有非常多的文件。
[Translate Project](https://github.com/LCTT/TranslateProject) 借助于 CI 帮助译者对基本的文章格式和拉取请求进行检查；并定时执行命令，以进行所有的申请检查，对于超时未完成翻译的工作进行回收；对于文章的状态进行标记，生成相应的徽章。
### 迁移思路
Travis CI 和 Github Action 在使用方面，其实总体差异不会太大，都是基于 YAML 文件格式来编写配置文件。不过，和 Travis CI 不同的是，Github Action 支持多个不同的配置文件，因此，你可以根据不同的场景，设定不同的配置文件，降低单个配置的文件的复杂度。
此外，由于我们的脚本中依赖了一些 Travis CI 的环境变量，也需要将其替换为 Github Action 中的相应环境变量，从而确保脚本可以运转。
### 改造实践
#### 1. 分析之前的 CI 流程
我们在 TravisCI 上的 CI 配置文件如图：
总体可以分为三块：
1. 命令区：说明了安装阶段和执行阶段的操作有哪些
2. 条件区：指定了这个配置文件在哪些条件下会生效
3. 部署区：写明了构建产物如何进行部署
在命令区中，有预置的安装过程和后续的执行过程。在安装过程中，安装了一些依赖，并将当前的 pages 资源克隆到本地，以继承上一次构建生成的资料。
在条件区则指明了仅作用于 `master` 分支。
在部署区便是将前面命令区的执行结果进行部署。
在实际的执行过程中，还会根据环境变量不同，决定是否要执行特定的命令，这部分在后续的改造过程中，就可以调整部署，拆分到不同的文件中。
#### 2. 直接套用配置文件
在完成了基本的分析后，就可以建立新的 Action 配置文件了。由于基本的语法很类似，对于其中的不少内容可以进行直接套用。
比如，我们的配置文件在直接套用后，结果如下
直接套用的文件已经可以直接运行，不过，这里有很多不满足需要的地方，所以需要做一些修改。
#### 3. 恢复 Travis CI 的环境变量
由于我们使用的 Badge 等生成脚本并非我所编写，所以在这一次的迁移中，并不打算对齐进行调整，以避免出现故障。而脚本中依赖了一些变量，需要将其重新设置出来。
Github Action 提供了一些方法，可以让你手动设置环境变量。你可以在你的构建的步骤中，加入如下代码，从而在构建环境中设定 `TRAVIS_BRANCH` 和 `TRAVIS_EVENT_TYPE` 环境变量，确保你可以使用这个环境变量。
```
- name: Set ENV variables
run: |
echo "::set-env name=TRAVIS\_BRANCH::${TRAVIS\_BRANCH:-$(echo $GITHUB\_REF | awk 'BEGIN { FS = "/" } ; { print $3 }')}"
echo "::set-env name=TRAVIS\_EVENT\_TYPE::$(if [ "schedule" == "${{ github.event\_name }}" ]; then echo "cron"; else echo "${{ github.event\_name }}"; fi)"
```
此外，由于 `set-env` 这个方法相对比较危险，你还需要在环境变量中，开启危险函数的执行。
```
jobs:
build:
runs-on: ubuntu-latest
env:
ACTIONS\_ALLOW\_UNSECURE\_COMMANDS: true
```
#### 4. 拆分配置文件
Github Action 和 TravisCI 不同的一点是你可以将你的 CI 文件拆分成多个文件，从而降低每一个单独的配置文件的复杂度。
根据前面对于流程的分析，可以将我们的 CI 流程拆分成三个部分：
1. 生成 `badge` 文件，应当跟随每一次提交进行
2. 生成 `status` 文件，执行时间较长，可以定期执行
3. 根据拉取请求内容进行整理，做核验
则将我们的配置文件拆分成三个不同的文件：
也得益于拆分开，则在 `checker` 中就可以免于安装一些必要的依赖，从而精简 CI 流程，提升 CI 的执行时间。
#### 5. 测试 CI 的运行情况
在完成了配置文件的编写和拆分后，就可以进行本地的执行测试。Github Action 写完了，难免要执行一下，确保整个流程是正常的。
这个时候你可以安装工具（[https://github.com/nektos/act），来在本地执行](https://github.com/nektos/act%EF%BC%89%EF%BC%8C%E6%9D%A5%E5%9C%A8%E6%9C%AC%E5%9C%B0%E6%89%A7%E8%A1%8C) Action ，从而确认你的代码执行是正确的。
如果你是 macOS ，只需要执行 `brew install act` 就可以安装 `act` 工具，来完成 `act` 的安装。
安装完成 `act` ，就可以通过执行 `act` 命令来在本地执行 Action ，比如，执行 `act pull_request` 来触发 GitHub 的拉取请求事件
通过本地测试后，再将你的配置文件推送到 GitHub 上，进行生产环境的测试即可。
### 6. 移除 Travis-CI
通过上述的一些步骤，我们完成了从 Travis CI 到 GitHub Action 的迁移，此时，就可以移除项目根目录中的 `.travis.yml` 文件，彻底关闭 Travis CI。
### 7. 替换环境变量
在完成了基本的迁移后，需要对代码中的一些历史问题进行修复。在第三步中，我们对于 Travis-CI 的环境变量进行替换，但长期维护的项目应当尽量将这些未标注上下文的信息替换为有文档标注的，因此，我们需要将其替换。
替换环境变量主要依赖 Github 官方的环境变量说明，你可以参考[官方文档](https://docs.github.com/cn/actions/reference/environment-variables)。
简化后，配置文件从之前的 27 行，减少至 17 行，变得更加的精简、易懂。
```
name: LCTT Article Checker
on:
pull_request:
branches: [master]
jobs:
build:
runs-on: ubuntu-latest
env:
PULL_REQUEST_ID: ${{ github.event.number }}
steps:
- uses: actions/checkout@v2
with:
fetch-depth: 0
- name: "checkout master branch & return to pull request branch"
run: CURRENT=$(echo ${{github.ref}} | sed "s|refs/|refs/remotes/|") && git checkout master && git checkout $CURRENT
- name: run check
run: sh ./scripts/check.sh;
```
### 8. 修改 GitHub 的分支保护条件
为了确保修改符合标准，我们限制了新的拉取请求必须通过 CI 检查，才能合并进入 `master` 分支，因此，也需要修改相应的分支保护规则，确保设定相应的保护。
### 一些注意事项
#### 1. 环境变量不同
如果你依赖了环境变量，则需要进行相应的修改。或者可以像我一样，先通过 `set-env` 来让本地拥有临时的环境变量，后续再逐步进行迁移。
#### 2. Action 运行依赖要注意安全
Action 执行过程中会有两个部分。Action 本身流程依赖于 `master` 分支，但执行过程中调用的脚本是根据源决定的，因此，从安全角度来看，你应当尽可能将所有的流程放在 Action 中，而不是放在你的源码目录中。
#### 3. 如何触发 CI 的拉取请求检查？
在进行拉取请求测试的时候，需要不断触发不同的提交 ，你可以通过执行 `git commit --allow-empty -m "Trigger notification" && git push` 来触发一个空白的提交， 推送到 Github 后，就可以再次触发拉取请求的构建，提升构建的效率。
### 总结
通过对 TravisCI 的流程整理、代码修改等流程，我们将之前的 Travis-CI 迁移至速度更快、性能更好的 GitHub Action ，一方面可以优化我们的工作流，另一方面，也让我们的代码更加简洁明了。
对于还在使用 Travis CI 的项目来说，也可以考虑迁移到 GitHub Action 中，来优化自己的工作流。
### 参考阅读
* <https://mauricius.dev/run-and-debug-github-actions-locally/>
* <https://jeffrafter.com/working-with-github-actions/>
* <https://developer.okta.com/blog/2020/05/18/travis-ci-to-github-actions>
|
||||
容器开发仍然要考虑 Linux 发行版吗？ | Scott Mccarty | https://opensource.com/article/19/2/linux-distributions-still-matter-containers | 容器构建有两大趋势：使用基本镜像和从头开始构建。每个都有工程上的权衡。 | /data/attachment/album/202101/16/223919aubhguedlt8sk8i8.jpg.thumb.jpg | /data/attachment/album/202101/16/223919aubhguedlt8sk8i8.jpg | true | false | true | lujun9972 | Chao-zhi | wxy | false | [
"容器"
] | 观点 | {
"viewnum": 3548,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "1.192.90.183",
"message": "这翻译看着有点蓝瘦",
"username": "来自河南郑州的 Firefox 84.0|GNU/Linux 用户",
"date": "2021-01-19T11:02:23"
}
] | [] | 容器构建有两大趋势：使用基本镜像和从头开始构建。每个都有工程上的权衡。 | 2021-01-16T22:39:00 | 2021-01-16T22:39:00 | 13,023 | /article-13023-1.html |
>
> 容器构建有两大趋势：使用基本镜像和从头开始构建。每个都有工程上的权衡。
>
>
>
有人说 Linux 发行版不再与容器有关。像 distroless 和 scratch 容器等可替代的方法，似乎是风靡一时。看来，我们在考虑和做出技术决策时，更多的是基于时尚感和即时的情感满足，而不是考虑我们选择的次要影响。我们应该问这样的问题：这些选择将如何影响未来六个月的维护？工程权衡是什么？这种范式转换如何影响我们的大规模构建系统？
这真让人沮丧。如果我们忘记了工程是一个零和游戏，有可衡量的利弊权衡，有不同方法的成本和收益 —— 这样对我们自己不利，对雇主不利，对最终维护我们的代码的同事不利。最后，我们对所有的维护人员（[向维护人员致敬！](https://aeon.co/essays/innovation-is-overvalued-maintenance-often-matters-more) ）都是一种伤害，因为我们不欣赏他们所做的工作。
### 理解问题所在
为了理解这个问题，我们必须首先研究为什么我们使用 Linux 发行版。我将把原因分为两大类：内核和其他包。编译内核实际上相当容易。Slackware 和 Gentoo（ 我的小心脏还是有点害怕）教会了我们这一点。
另一方面，对于一个可用的 Linux 系统需要打包大量的开发软件和应用软件，这可能会让人望而生畏。此外，确保数百万个程序包可以一起安装和工作的唯一方法是使用旧的范例：即编译它并将它作为一个工件（即 Linux 发行版）一起发布。那么，为什么 Linux 发行版要将内核和所有包一起编译呢？很简单：确保事情协调一致。
首先，我们来谈谈内核。内核很特别。在没有编译好的内核的情况下引导 Linux 系统有点困难。它是 Linux 操作系统的核心，也是我们在系统启动时首先依赖的。内核在编译时有很多不同的配置选项，这些选项会对硬件和软件如何在一个内核上运行产生巨大影响。这方面中的第二个问题是，系统软件（如编译器 、C 库和解释器）必须针对内核中内置的选项进行调优。Gentoo 的维基以一种发自内心的方式教我们这一点，它把每个人都变成了一个微型的开发版维护者。
令人尴尬的是（因为我在过去五年里一直在使用容器），我必须承认我最近才编译过内核。我必须让嵌套的 KVM 在 RHEL7 上工作，这样我才能在笔记本电脑上的 KVM 虚拟机中运行 [OpenShift on OpenStack](https://blog.openshift.com/openshift-on-openstack-delivering-applications-better-together/) 虚拟机，以及我的 [Container Development Kit（CDK）](https://developers.redhat.com/blog/2018/02/13/red-hat-cdk-nested-kvm/)。我只想说，当时我在一个全新的 4.X 内核上启动了 RHEL7。和任何优秀的系统管理员一样，我有点担心自己错过了一些重要的配置选项和补丁。当然，我也的确错过了一些东西。比如睡眠模式无法正常工作，我的扩展底座无法正常工作，还有许多其他小的随机错误。但它在我的笔记本电脑上的一个 KVM 虚拟机上，对于 OpenStack 上的 OpenShift 的实时演示来说已经足够好了。来吧，这很有趣，对吧？但我离题了……
现在，我们来谈谈其他的软件包。虽然内核和相关的系统软件可能很难编译，但从工作负载的角度来看，更大的问题是编译成千上万的包，以提供一个可用的 Linux 系统。每个软件包都需要专业知识。有些软件只需要运行三个命令：`./configure`、`make` 和 `make install`。另一些则需要大量的专业知识，从在 `etc` 中添加用户和配置特定的默认值到运行安装后脚本和添加 systemd 单元文件。对于任何一个人来说，调试好你可能用得到的成千上万种不同软件所需要的一套技能都是令人望而生畏的。但是，如果你想要一个可以随时尝试新软件的可用系统，你必须学会如何编译和安装新软件，然后才能开始学习使用它。这就是没有 Linux 发行版的 Linux。当你放弃使用 Linux 发行版时，那么你就得自己编译软件。
关键是，你必须将所有内容构建在一起，以确保它能够以任何合理的可靠性级别协同工作，而且构建一个可用的包群需要大量的知识。这是任何一个开发人员或系统管理员都无法合理地学习和保留的知识。我描述的每个问题都适用于你的 [容器主机](https://developers.redhat.com/blog/2018/02/22/container-terminology-practical-introduction/#h.8tyd9p17othl)（内核和系统软件）和 [容器镜像](https://developers.redhat.com/blog/2018/02/22/container-terminology-practical-introduction/#h.dqlu6589ootw)（系统软件和所有其他包）——请注意：在容器镜像中还包含有编译器 、C 库、解释器和 JVM。
### 解决方案
所以你也看到了，其实使用 Linux 发行版就是解决方案。别再看了，给离你最近的软件包维护者（再次向维护人员致敬！）发张电子卡吧（等等，我是不是把我的年龄告诉别人了？）。不过说真的，这些人做了大量的工作，这真的是被低估了。Kubernetes、Istio、Prometheus，还有 Knative：我在看着你们。你们的时代要来了，到时候你们会进入维护模式，被过度使用，被低估。大约七到十年后，我将再次写这篇文章，可能是关于 Kubernetes 的。
### 容器构建的首要原则
从零开始构建和从基础镜像构建之间存在权衡。
#### 从基础镜像构建
从基础镜像构建的优点是，大多数构建操作只不过是安装或更新包。它依赖于 Linux 发行版中包维护人员所做的大量工作。它还有一个优点，即六个月甚至十年后的修补事件（使用 RHEL）是运维/系统管理员事件 （`yum update`），而不是开发人员事件（这需要通过代码找出某些函数参数不再工作的原因）。
你想想，应用程序代码依赖于许多库，从 JSON mung 库到对象关系映射器。与 Linux 内核和 Glibc 不同，这些类型的库很少改变 API 兼容性。这意味着三年后你的修补事件可能会变成代码更改事件，而不是 yum 更新事件。因此让他自己深入下去吧。开发人员，如果安全团队找不到防火墙黑客来阻止攻击，你将在凌晨 2 点收到短信。
从基础镜像构建不是完美的；还有一些缺点，比如所有被拖入的依赖项的大小。这几乎总是会使容器镜像比从头开始构建的镜像更大。另一个缺点是你并不总是能够访问最新的上游代码。这可能会让开发人员感到沮丧，尤其是当你只想使用依赖项中的一部分功能时，但是你仍然不得不将你根本用不着的东西一起打包带走，因为上游的维护人员一直在改变这个库。
如果你是一个 web 开发人员，正在对我翻白眼，我有一个词可以形容你：DevOps。那意味着你带着寻呼机，我的朋友。
#### Scratch 构建
Scratch 构建的优点是镜像非常小。当你不依赖容器中的 Linux 发行版时，你有很多控制权，这意味着你可以根据需要定制所有内容。这是一个最佳模型，在某些用例中是很有效的。另一个优势是你可以访问最新的软件包。你不必等待 Linux 发行版更新任何内容。是你自己在控制，所以你可以自行选择什么时候去费功夫纳入新的软件。
记住，控制一切都是有代价的。通常，更新到具有新特性的新库会拖如不必要的 API 更改，这意味着修复代码中的不兼容（换句话说，这就像[给牦牛剪毛](https://en.wiktionary.org/wiki/yak_shaving)）。在凌晨 2 点应用程序不起作用的时候给牦牛剪毛是不好玩的。幸运的是，使用容器，你可以在下一个工作日回滚并给牦牛剪毛，但它仍会占用你为业务提供新价值、为应用程序提供新功能的时间。欢迎来到系统管理员的生活。
好吧，也就是说，有些时候，Scratch 构建是有意义的。我完全承认，静态编译的 Golang 程序和 C 程序是 scratch/distorless 构建的两个不错的候选程序。对于这些类型的程序，每个容器构建都是一个编译事件。三年后你仍然需要担心 API 的损坏，但是如果你是一个 Golang 商店，你应该有能力随着时间的推移修复问题。
### 结论
基本上，Linux 发行版做了大量工作来节省你在常规 Linux 系统或容器上的时间。维护人员所拥有的知识是巨大的，而且没有得到真正的赞赏。容器的采用使得问题更加严重，因为它被进一步抽象了。
通过容器主机，Linux 发行版可以让你访问广泛的硬件生态系统，从微型 ARM 系统到 128 核 CPU x86 巨型机箱，再到云服务商的虚拟机。他们提供可工作的容器引擎和开箱即用的容器运行时环境，所以你只需启动你的容器，让其他人担心事情的进展。
对于容器镜像，Linux 发行版为你的项目提供了对大量软件的轻松访问。即使你从头开始构建，你也可能会看到一个包维护人员是如何构建和运送东西的 —— 一个好的艺术家是一个好的偷学者，所以不要低估这项工作的价值。
所以，感谢 Fedora、RHEL（Frantisek，你是我的英雄 ）、Debian、Gentoo 和其他 Linux 发行版的所有维护人员。我很感激你所做的工作，尽管我是个“容器工人”
---
via: <https://opensource.com/article/19/2/linux-distributions-still-matter-containers>
作者：[Scott McCarty](https://opensource.com/users/fatherlinux) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Chao-zhi](https://github.com/Chao-zhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
世界可写：这是 Unix/Linux 的世界 | 硬核老王 | Unix 世界只是 Unix 的世界（World），从来不是全球（Gloabl）。 | /data/attachment/album/202101/17/123419bjsnqy3nsiyarjs3.jpg.thumb.jpg | /data/attachment/album/202101/17/123419bjsnqy3nsiyarjs3.jpg | true | false | false | false | [
"Unix",
"权限"
] | 观点 | {
"viewnum": 7089,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "113.76.183.105",
"message": "一直以为所有发行版都是022的掩码,没想到ubuntu这么特立独行啊,脑子里装的啥呢",
"username": "来自广东珠海的 Firefox 84.0|GNU/Linux 用户",
"date": "2021-01-17T15:34:10"
},
{
"postip": "171.82.102.216",
"message": "从来都没有注意过呢",
"username": "来自湖北武汉的 Chrome Mobile iOS 87.0|iOS 14.3 用户",
"date": "2021-01-17T18:00:55"
},
{
"postip": "171.82.102.216",
"message": "从来都没有注意过呢",
"username": "来自湖北武汉的 Chrome Mobile iOS 87.0|iOS 14.3 用户",
"date": "2021-01-17T18:00:59"
}
] | [] | Unix 世界只是 Unix 的世界（World），从来不是全球（Gloabl）。 | 2021-01-17T12:32:00 | 2021-01-17T12:32:00 | 13,024 | /article-13024-1.html | 
昨天发的一篇[新闻点评](/article-13021-1.html)中，提及了在 Ubuntu 21.04 中准备修复一个十多年的 Bug：将用户主目录的默认的“世界可写”权限取消，并对这条新闻吐槽了一番。
不料，这条新闻引来了一些意料之外的吐槽，大家在公众号、知乎、今日头条上看到这篇内容后，纷纷表示“**世界可写**”是机翻，是误读，应该翻译为“<ruby> 全局 <rt> Global </rt></ruby>”。因此，我觉得有必要就此写点文字来说明一下。
说实话，我也是第一次看到“世界可写”这个翻译（这个翻译不是我发明的），初看之下有点诧异，但是细思之下，我认为，这个翻译还是颇有意思的。
<ruby> <a href="https://en.wikipedia.org/wiki/File-system_permissions#Traditional_Unix_permissions"> 传统的 Unix 权限 </a> <rt> traditional Unix permissions </rt></ruby>模型将用户分为三类：
* <ruby> <a href="https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_167"> 属主 </a> <rt> Owner </rt></ruby> 或 <ruby> 用户 <rt> User </rt></ruby>类（`u`）：文件/目录的所有者
* <ruby> <a href="https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_173"> 群组 </a> <rt> Group </rt></ruby>类（`g`）：除所有者之外的文件/目录所属用户组的成员
* <ruby> <a href="https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_173"> 其他 </a> <rt> Other </rt></ruby>类（`o`）：“世界”上除以上二者外的其他人
对于 `chmod` 命令来说，我们有时候需要给这三类人都统一赋予一些权限，这种情况下，我们采用 `a` 来代表“<ruby> 全部 <rt> All </rt></ruby>”，有时也称之为“<ruby> 世界 <rt> World </rt> ”。这在各种文献中 <a href="https://man7.org/linux/man-pages/man1/chmod.1.html"> 屡 </a> <a href="https://www.grymoire.com/Unix/Permissions.html"> 见 </a> <a href="https://kb.iu.edu/d/abdb"> 不 </a> <a href="https://www.ibm.com/support/pages/can-we-remove-world-writable-permissions-global-write-permission"> 鲜 </a> 。</ruby>
对于“<ruby> 世界 <rp> （ </rp> <rt> World </rt> <rp> ） </rp></ruby>”这个词汇，除看起来有点不太寻常，但是我觉得，这是一种 Unix 的古典黑客精神的幽默，可能是隐喻 Unix 机器里面就是一个世界吧，如果你连 Unix 用户都没有，那你就不是这个世界的。
Unix 世界只是 Unix 的<ruby> 世界 <rt> World </rt></ruby>，从来不是<ruby> 全球 <rt> Gloabl </rt></ruby>。
最后，“世界可写”万万要不得。022 赛高！
|
||||
Homura：基于 WINE 的 BSD 游戏启动器 | John Paul | https://itsfoss.com/homura-game-launcher-bsd/ | BSD 不只是用于服务器。人们也将其用于桌面，并执行通常任务，包括休闲游戏。为了帮助实现这一点，我们将看看一个能让你在 FreeBSD 上运行 Windows 游戏的应用。 | /data/attachment/album/202101/18/090813ku4ascavl4mmavpv.jpg.thumb.jpg | /data/attachment/album/202101/18/090813ku4ascavl4mmavpv.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"游戏",
"BSD"
] | 分享 | {
"viewnum": 3720,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | BSD 不只是用于服务器。人们也将其用于桌面，并执行通常任务，包括休闲游戏。为了帮助实现这一点，我们将看看一个能让你在 FreeBSD 上运行 Windows 游戏的应用。 | 2021-01-18T09:08:13 | 2021-01-18T09:08:13 | 13,026 | /article-13026-1.html | 
BSD 不只是用于服务器。人们也将其用于桌面，并执行通常任务，包括休闲游戏。为了帮助实现这一点，我们将看看一个能让你在 FreeBSD 上运行 Windows 游戏的应用。
### 什么是 Homura？
[Homura](https://codeberg.org/Alexander88207/Homura) 是一个能让你在 FreeBSD 上玩 Windows 游戏的工具。它的灵感来自于 [Lutris](https://lutris.net/)。它允许你安装和管理多个 Windows 游戏和游戏商店启动器。它主要使用 Wine，但也附带了一些修复和变通的方法来让游戏工作。
Homura 的创建者 [Alexander Vereeken](https://codeberg.org/Alexander88207) 说，他创建这个应用是因为“当我开始使用 FreeBSD 时，没有能用的可以在 Wine 中安装游戏或启动器的程序，所以我自己创建了一个”。当时，Wine 是唯一的选择。Linux 版本的 Steam 并不存在。
以下是你可以用 Homura 安装的清单：
* Anarchy Online
* Arc
* Bethesda 启动器
* 暴雪启动器
* 暗黑破坏神 II
* Discord
* 龙歌 OL
* GOG
* 建造乌托邦
* 英雄联盟
* Origin 启动器
* PokeMMO
* 精灵宝可梦 绿铀
* RuneScape
* Steam
* 地铁跑酷
* Teamspeak
* 猴岛大冒险 2
* UC 浏览器
* 育碧
* 战游游戏中心
* [Itch.io](http://Itch.io)
Homura 是以动画 [Madoka Magica](https://madoka.fandom.com/wiki/Puella_Magi_Madoka_Magica) 中的一个角色命名的。在创建者转移到 GitLab 之前，它最初托管在 GitHub 上。目前它被托管在 Codeberg 上。希望它现在还能留在那里。
### 在 BSD 上安装 Homura 游戏启动器
你可以用这个命令从 FreeBSD 仓库中安装 Homura：
```
pkg install games/homura
```
你也可以使用这个命令从 ports 构建并安装它：
```
cd /usr/ports/games/homura/ && make install clean
```
安装完成后，你可以从菜单中选择 Homura，或在命令行中输入 `Homura` 来运行它。（在终端中名字必须大写开头，否则将无法运行。）
如果你通过 Homura 安装 Steam，你需要从 Homura 启动它。如果你想从操作系统的菜单中启动它，它当前不会显示在那里。
Steam 的库和商店标签由内置的 Web 浏览器显示。由于某些原因，这在 FreeBSD 上是不行的。但如果你从 Homura 的菜单中启动 Steam，它将使用列表模式，工作没有问题。
### 体验
我在 GhostBSD 上安装了 Homura，并用它来安装 Steam。之后，我安装了几个游戏来测试它。并不是所有的游戏都能正常运行，主要是因为它们试图使用或安装一个不可用的 Windows 专用软件。然而，我能够玩我最喜欢的游戏之一，微软的“国家的崛起”，没有任何问题。（我的测试变成了几个小时的游戏。）
我也尝试安装 GOG 启动器。由于某些原因，它对我不起作用。加载页面会弹出，但什么都不会发生。我打算提交一个议题。我没有测试过任何安装程序/启动器，因为我没有使用它们。
### 总结
并不是所有的东西都能顺利地与 Homura 一起使用，但我可以玩一些我最喜欢的游戏。
这款应用是一个典型的用户有了需求，并决定去填补它的案例。通过这样做，他让其他人的生活变得更轻松。希望这个应用能让人们更容易地开始使用 FreeBSD 作为他们的操作系统。
---
via: <https://itsfoss.com/homura-game-launcher-bsd/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[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/) 荣誉推出
|
《代码英雄》第三季（7）：与机器对话 | Red Hat | https://www.redhat.com/en/command-line-heroes/season-3/talking-to-machines | 创造一台会思考的机器在 20 世纪 50 年代似乎是科幻小说。但 John McCarthy 决定把它变成现实。他从一种叫做 LISP 的语言开始。 | /data/attachment/album/202101/18/122208sbgevv2xekbg97zc.png.thumb.jpg | /data/attachment/album/202101/18/122208sbgevv2xekbg97zc.png | true | false | true | bestony | bestony | acyanbird, Northurland, wxy | false | [
"AI",
"代码英雄",
"LISP"
] | 代码英雄 | {
"viewnum": 8354,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12951,
"displayorder": 0
},
{
"raid": 13066,
"displayorder": 0
}
] | 创造一台会思考的机器在 20 世纪 50 年代似乎是科幻小说。但 John McCarthy 决定把它变成现实。他从一种叫做 LISP 的语言开始。 | 2021-01-18T12:22:00 | 2021-01-18T12:22:00 | 13,027 | /article-13027-1.html |
>
> 代码英雄讲述了开发人员、程序员、黑客、极客和开源反叛者如何彻底改变技术前景的真实史诗。
>
>
>
>
> **什么是《代码英雄》**
>
>
> <ruby> 代码英雄 <rt> Command Line Heroes </rt></ruby>是世界领先的企业开源软件解决方案供应商红帽（Red Hat）精心制作的原创音频播客，讲述开发人员、程序员、黑客、极客和开源反叛者如何彻底改变技术前景的真实史诗。该音频博客邀请到了谷歌、NASA 等重量级企业的众多技术大牛共同讲述开源、操作系统、容器、DevOps、混合云等发展过程中的动人故事。
>
>
>
本文是《[代码英雄](https://www.redhat.com/en/command-line-heroes)》系列播客[《代码英雄》第三季（7）：与机器对话](https://www.redhat.com/en/command-line-heroes/season-3/heroes-in-a-bash-shell)的[音频](https://cdn.simplecast.com/audio/a88fbe/a88fbe81-5614-4834-8a78-24c287debbe6/8e47deb9-b0ab-4d3b-a4be-7b0f1037ced0/CLH_S3_E7_Talking_to_Machines_LISP_and_the_Origins_of_A_I_vFINAL_tc.mp3)脚本。
>
> 导读：创造一台会思考的机器在 20 世纪 50 年代似乎是科幻小说。但 John McCarthy 决定把它变成现实。他从一种叫做 LISP 的语言开始。Colin Garvey 介绍了 McCarthy 是如何创造出第一种人工智能语言的。Sam Williams 介绍了早期人们对思考机器的兴趣是如何从学术界蔓延到商业界的，以及在某些项目没有兑现承诺之后，漫长的人工智能寒冬是如何最终到来的。Ulrich Drepper 解释说，人工智能的梦想超出了当时硬件所能提供的范围。
>
>
> 但硬件每天都在变得更强大。Chris Nicholson 指出，今天的机器有足够的处理能力来处理人工智能的资源需求 —— 以至于我们正处于人工智能研发的革命性复苏之中。最后，Rachel Thomas 确定了 LISP 之外的人工智能语言 —— 证明了人工智能现在正准备做的不同类型的任务。
>
>
>
>
> **00:00:05 - 播音员**：
>
>
> 卡斯帕罗夫非常慌乱。虽然已经拼尽全力，但是他意识到，他已经输了。
>
>
>
**00:00:12 - Saron Yitbarek**：
1997 年的春天，国际象棋冠军<ruby> 加里·卡斯帕罗夫 <rt> Garry Kasparov </rt></ruby>输给了计算机程序“深蓝”。对于机器智能来说，这是历史上的关键时刻。对于某些人来说，这是一次生存危机，是对人类智慧至上的挑战。但是，对于世界上的技术专家来说，这是另一种意味上的里程碑，是<ruby> 人工智能 <rt> artificial intelligence </rt></ruby>（AI）领域的一次飞跃。这表明，想要真正的智慧机器诞生，或许不是太过于疯狂的梦想。
>
> **00:00:47 - 播音员**：
>
>
> 去赋予一台机器思考的能力仍然还是梦想，距离实现梦想还需要很多年的努力。此外，还需要做出不少惊人的突破。
>
>
>
**00:00:56 - Saron Yitbarek**：
我们是如何抵达这一步的？是什么导致了卡斯帕罗夫那场著名的失败？我们从哪里来，又该到哪里去？我是 Saron Yitbarek，这里是《代码英雄》，一档来自红帽的原创播客节目。在本季，我们都在探索编程语言的奥秘，揭开他们的历史和发展潜力。这一期让我们关注人工智能。你会使用什么语言，来让你的机器拥有自己的思想呢？我们的编程语言如何帮助我们抵达“深蓝时刻”，甚至是更远的地方？什么样的编程语言能最适配会思考的机器？这是我们半个多世纪以来一直在尝试解决的问题。因此，我们的故事要追溯到 1940 年代，那时，人工智能这个词汇还没有被创造出来。
**00:01:59**:
回顾二战结束是如何结束的，我们有这样一种感觉，那就是技术帮助同盟国赢得了战争。人们乐观地认为，科技可以成就一切。整整一代人都相信计算机的力量。在这一代人中诞生了人工智能的教父，一位出色的数学家 —— <ruby> 约翰·麦卡锡 <rt> John McCarthy </rt></ruby>，他从根本上改变了我们与机器交谈的方式。我想知道他的思想的起源，以及范式的转变是如何发生的。我的意思是，对于初学者来说，当麦卡锡和他的同事们在想象智能机器的未来时，他们到底想象了什么？
**00:02:43 - Colin Garvey**：
哇，这是一个好问题。
**00:02:46 - Saron Yitbarek**：
我和 Colin Garvey 聊了聊。他是<ruby> 伦斯勒理工学院 <rt> Rensselaer Polytechnic Institute </rt></ruby>科学与技术研究系的历史学家。以下是我们的一些聊天内容：
**00:02:58 - Colin Garvey**：
麦卡锡对提出 AI 究竟是什么这件事情非常谨慎。不过，举个例子来说，他可能在他最著名但并未实现的程序中描述过（这只是一个思路），人工智能是一个<ruby> 接受建议者 <rt> advice taker </rt></ruby>。接受建议者这个说法由麦卡锡于 1960 年的名为《<ruby> 具有常识的程序 <rt> Programs with Common Sense </rt></ruby>》的论文中提出的。在开始的时候，你觉得接受建议者可能是一个会学习的机器人，这是它被发明的本意，它算是一个可以接受建议的家用机器人。你说：“不，你这样做是错误的，要那样做。”它就会明白你的意思。
**00:03:44 - Saron Yitbarek**：
那很有帮助。
**00:03:45 - Colin Garvey**：
可能会有帮助。那时候接受建议者要实现的目标是，从办公室导航到机场。换句话说，将从办公室去机场这个建议，正式化成接受建议者机器人能够接受的程序以达成目的，得出从办公室前往机场的一系列程序。它把人类的语言正式化为一系列的合乎逻辑的陈述，即需要根据现在的情况进行合适的抉择，以达到把当前情况转变为理想情况的目标。他将这些想法伪代码化，这实际上是 LISP 的起源。然后在接下来的几年里，LISP 作为他想法的实现，或者说实现他想法的语言出现了。
**00:04:39 - Saron Yitbarek**：
麦卡锡的 LISP 语言改变了游戏规则。它不仅能帮助机器理解命令，还能帮助机器理解一些常识性的逻辑。麦卡锡发现，他可以编写条件表达式，即体现规则的代码，而不是仅仅是直白的命令。实际上，LISP 有一堆重大的编程突破，条件表达式、垃圾回收、递归等等。LISP 在代码和数据中都使用了列表。这是一个简单但具有深远的影响的更改。这是语言范式的转变，所有这些为麦卡锡本人称之为“人工智能”的整个领域打开了大门。想象一下，在你和机器说话的时候，并不需要把每一个细节都给编写好。你可以让那台机器自己来进行推断和推理。麦卡锡希望通过他的 LISP 语言，给机器一种智慧。好了，回到我和 Colin Garvey 的聊天。
**00:05:41 - Colin Garvey**：
LISP 是人们编写高级计算机语言的尝试的过程中，诞生的精华。
**00:05:47 - Saron Yitbarek**：
这很有意思。因为我的下一个问题是 LISP 和人工智能之间的关系。接受建议者第一次描述了 AI 的功能，它听起来也像是 LISP 的开始。能跟我聊聊更多 LISP 和人工智能之间的关系吗？
**00:06:04 - Colin Garvey**：
当然。这些早期的人工智能研究人员面临着一件事，那就是他们还在使用打孔卡进行编程。也许这些早期的编程人员，知道如何进行机器码级别的编程，这是非常困难且耗时的工作。因此，你需要一个更高级的编程语言，以便你可以用更加接近人类语言的方式编程。所以，像 LISP 这样，用列表的形式给出指令的语言 —— 这也是其名称的来源，基于列表的处理（LCTT 译注，LISP 全称：“LISt Processing“）。从某种意义上来说，这样用列表给出的指令更加接近于人类语言，因为他们基本上都可以用通顺的逻辑去理解。因此，如果你可以读懂<ruby> 形式逻辑 <rt> formal logic </rt></ruby>，那么基本上可以看明白 LISP 程序，或者任何基于逻辑的编程语言的程序，并对于代码中发生的事情有着更好的了解。
**00:07:10 - Saron Yitbarek**：
所以 LISP 真的帮了大忙……嗯，我的意思是它帮助我们将我们的想法给予人工智能，让我们能够朝着实现人工智能努力，有朝一日总能达成这个梦想。不过这也让我想知道在那个时期，“智能”到底意味着什么？所以，如果我们回到 50 年代，在那个时间点上，什么是“智能”？人们是如何定义它的？因为 LISP 最初为 IBM 704 开发的，它每次做的其实只是一件事。看起来并不是很“智能”。当时的人们是如何看待“智能”的呢？
**00:07:43 - Colin Garvey**：
有关“智能”的定义，这自然非常有争议的。就我个人，从一个普通大众的角度而言，他们的概念是非常狭窄的。但是在当时，广泛认可的定义是：能够执行被认为有智力的举动的能力。但持这个观点的这些人实际上是数学家、逻辑学家和计算机程序员。我的意思是，说句粗俗的话，下棋的能力被认为是智力的明确标志。这一代早期的 AI 人更喜欢回避这个问题，并说，“嗯，哲学家们还没有就什么是‘智力’达成一致，但如果我们制造出一台能下棋的电脑，我想我们都同意这是‘智能’。“
**00:08:40 - Saron Yitbarek**：
不管怎样，这是一个起点。就像婴儿的第一步。
**00:08:45 - Colin Garvey**：
麦卡锡有一个梦想，让机器可以具有常识，并像人一样聪明。本质上来说，你可以和它们交谈。他开始创造一种程序语言来实现这个梦想。这就是 LISP。它模仿了人类思想的某些方面，尤其是逻辑思维能力，并使得利用计算机放大或扩展这些思想特征成为可能。所以从数学家的角度来看，他已经在实现智能机械的道路上走得很远了。
**00:09:32 - Saron Yitbarek**：
Colin Garvey 是伦斯勒理工学院科学技术研究系的历史学家。
随着 LISP 的推进，发展人工智能的新机会开始出现，LISP 是这一新领域的标准语言。麦卡锡离开麻省理工学院去斯坦福大学工作后，麻省理工学院的其他工程师继续从事 LISP 工作。他们把麦卡锡的语言改进成一种叫做 Maclisp 的方言版本，甚至开发了 LISP 操作系统。看起来麦卡锡对人工智能未来的梦想正在成为现实。1968 年，麦卡锡甚至和苏格兰国际象棋大师<ruby> 大卫·利维 <rt> David Levy </rt></ruby>打赌。麦卡锡打赌，10 年后，电脑将能够在国际象棋比赛中赢过利维。但是，如果事情进展得那么顺利，那就不是《代码英雄》的故事了。那时候麦卡锡还不知道，人工智能的冬天就要来了。
**00:10:45 - Saron Yitbarek**：
当麻省理工学院的那个基于 LISP 的操作系统，从学院衍生到公司后，情况开始发生变化。其中的一家公司 Symbolix 推出了 LISP 机器，甚至从 MIT 的 <ruby> AI 实验室 <rt> AI Lab </rt></ruby>雇用了 14 名员工，而且更不切实际的研究不再是重点。
**00:11:25 - Sam Williams**：
这些公司原本都来自 AI 实验室。
**00:11:31 - Saron Yitbarek**：
这是记者 Sam Williams，他写了一本名为《Arguing AI》的书。
**00:11:36 - Sam Williams**：
Symbolix 可能是最突出的一个。它得到了最多的关注、最多的风险投资。约翰·麦卡锡和他的门徒们推动了所有的创新。我想，这只是一个案例。在 70 年代末期，人们普遍认为：“好吧，我们已经在学术界做了我们能够做到的事情，让我们在商界脱颖而出，让私营企业为我们投资。”
**00:12:01 - Saron Yitbarek**：
这在当时的环境下可以理解。那时AI 似乎即将起飞，有利可图。
**00:12:07 - Sam Williams**：
那时候的算力便宜到中型企业也可以购买。因此，我认为许多公司看到了一个机会：“那里有一个富有潜力的市场，我们可以进入这个市场，我们可以把关于人工智能的产出卖给那些想要具有全球竞争力的企业。”他们让投资者为这个想法大肆投资。在 80 年代初期，大量的资金涌入该领域。
**00:12:29 - Saron Yitbarek**：
我们可以讨论一下为什么这个热潮后来干涸了。但是，我现在可以肯定的一点是，事情已经被大肆炒作了。
**00:12:39 - Sam Williams**：
大量资金流入。人们认为市场非常成熟。
**00:12:44 - Saron Yitbarek**：
从一定来说，大量热钱涌入人工智能领域造成的繁荣，就像世纪之交时网络泡沫的前奏。
**00:12:52 - Sam Williams**：
这在技术发展史上并不少见，人们过度投资，但最终公司未能兑现他们的希望。所以，资金供应陷入困境。公司必须通过老式的方式赚钱 —— 去拉客户，去生产东西。
**00:13:08 - Saron Yitbarek**：
所以那时，麦卡锡的梦想轰然崩溃，回归了现实。Williams 描述了随后的人工智能冬天。
**00:13:16 - Sam Williams**：
你会看到像 Symbolix 这样的公司市值上升到 1 亿美元，然后短短几年后就申请破产保护。在那时候有很多这样的人：“在 10 年内，我们将做到这一点，在 5 年内，你会看到这个。5 年后，你就会看到这个。”这些家伙是投机者，或者是想要从五角大楼或任何其他地方获取更多资金的学者。因为这种危险的炒作，过度炒作，让人工智能走上歧途。
**00:13:48 - Saron Yitbarek**：
人们对于人工智能的兴趣崩塌了。基础设施不到位，或许计算速度也不够高，这使一切努力都变成了徒然。但无论如何，这之中的指导思想是正确的，它只是生在了错误的时代。到了 80 年代末，人工智能研究日渐减少。
**00:14:06 - Sam Williams**：
我认为人们脱离人工智能这个领域的原因是，它失去了最初吸引他们进入其中时的冒险性。它曾处于技术领域的最前沿。在西海岸，很多人的精力被吸引到制造个人电脑上。从 40 年后的今天看来，试着让电脑进入美国每个家庭，比帮助财富 1000 强的企业做出更好的决策，是一个更引人注目的概念。
**00:14:39 - Saron Yitbarek**：
Sam Williams 是《Arguing AI》的作者。我们在这里描述的是一个计算机编程的世界，它被一分为二：一方面是约翰·麦卡锡这样的人，他们试图使用 LISP 等新型语言来探究智能的本质；另一方面，也不可避免地存在着另一群人，他们更专注于解决实际问题，试图让那些愿意为其服务付款的企业轻松一些。现实情况是，世界上的那些约翰·麦卡锡们，那些抽象的梦想家们，并没有太多机会在人工智能的可能性上进行深入探索。他们所拥有的设备甚至还比不上我们今天使用的手机。他们的愿景对于手头的硬件现实来说，真的太大了。
**00:15:36 - Ulrich Drepper**：
当初，我们在轰轰作响的庞大计算机上工作，和数不清的人、数不清的工作组抢夺它有限的性能。
**00:15:46 - Saron Yitbarek**：
这是红帽的杰出工程师 Ulrich Drepper。他解释了早期的人工智能梦想之所以失败，只是因为没有成功所需的基本工具。
**00:15:55 - Ulrich Drepper**：
我们有 PDP 10，PDP 11 之类的计算机（LCTT 译注：Digital Equipment Corporation 公司的大型计算机产品），但每一台都可能有另外 20 个人在同时使用。即使没有这些人将计算力分流走，它们也是真正的低能力机器，其性能不足以在支持 LISP 系统的必要功能的同时，运行一套机能齐全的用户界面。
**00:16:19 - Saron Yitbarek**：
随着时间的推移，新开发的硬件对 LISP 也不再友好。
**00:16:26 - Ulrich Drepper**：
我们不仅走了台式机的道路，也走了服务器的道路。在我们今天已经习惯的处理器类型中，我们的实现的一切都是基于 8 位的处理器，而我们可能有了 16 位处理器、32 位处理器之类的。想要在这样的机器上高效实现 LISP 系统，就必须绕不少圈才能成功。
**00:16:56 - Saron Yitbarek**：
因此，计算世界的外部现实对这个脆弱的人工智能领域产生了意想不到的抑制作用。
**00:17:06 - Ulrich Drepper**：
和大厂商生产的 CPU 相比，定制硬件的成本极为高昂，其发展也极为缓慢。
**00:17:21 - Saron Yitbarek**：
通过创建自定义的硬件解决方案，继续使用 LISP 朝着 AI 梦想前进并非不可能。但是，事实是，令人兴奋的新硬件将很多人的注意力推向了其他工作领域。
**00:17:35 - Ulrich Drepper**：
你只需要等待处理器的下一个版本，那个普通的处理器获得的改进，比你自己开发硬件求解，比如说实现一个 LISP 系统，所能达到的效果和收获要大得多。最终，硬件变得越来越复杂，自行定制硬件成为了一件近乎于不可能的事。
**00:18:03 - Saron Yitbarek**：
那么，约翰·麦卡锡的远景梦想是慢慢死去，还是只在那漫长的人工智能冬天里沉睡，等待时机？在 21 世纪的第一个十年里，约翰·麦卡锡的语言 LISP 的使用者不断地流失。但是，在同一时间，发生了一件惊人的事。尽管 LISP 本身逐渐消逝，与这门语言相连的梦想却被重新点燃了。人工智能的梦想重新活了起来。
**00:18:34 - Chris Nicholson**：
我想说的是，这次不一样。
**00:18:36 - Saron Yitbarek**：
这是 Chris Nicholson，开源 AI 软件公司 Skymind 的创始人兼 CEO。Chris 认为，在经历了大起大落之后，人工智能或许终于要进入一个可持续发展的长夏了。
**00:18:52 - Chris Nicholson**：
我们正处在人工智能的夏天，许多人都对 AI 可能的应用而激动不已。但是，这种兴奋是基于研究的真正进展，而这些进展是基于其他领域的进展。我们的硬件比当初好了太多太多，人们能用 GPU 替代 CPU，也能在大规模集群中使用这些 GPU 来训练巨大的机器学习模型，从而产生真正准确的预测。为了做到这一点，他们也使用了前所未有的巨大数据集，这样的数据量在 80 年代、90 年代或者之前都是闻所未闻、见所未见的。
**00:19:30 - Saron Yitbarek**：
对于 AI 语言，巨大的数据集的兴起是关键，因为它们代表了我们理解智能的方式的关键变化。AI 研究的重点转移到了<ruby> 深度学习 <rt> deep learning </rt></ruby>方面，而深度学习似乎成为了 AI 研究的全部。
**00:19:47 - Chris Nicholson**：
LISP 是为了操纵符号而设计的。在 LISP 诞生的时代，AI 意味着符号推理。当时，人们认为人类的思维和智力本身就是符号的操作。现代的人工智能，也就是让我们如此着迷的人工智能，远不止于此。现在的 AI，就机器学习而言，是一种可以从非结构化数据中学习的大型数据处理机器。因此，你可以让机器学习算法一点一滴地拾起文本和图像，在这个过程中，随着时间的推移，这些算法将变得越来越智能。LISP 不是那样设计的。它被设计为仅在人工干预的基础上发展。然而，对于现在的机器学习算法而言，其中的学习部分意味着它们会根据所接触的数据进行自我调整。
**00:20:40 - Saron Yitbarek**：
这就是让机器以它们自己的方式实现智能化。但是，你知道，不仅仅是我们的机器在学习以强大的新方式思考；开源工具也让人们提高了自己的水平。克里斯认为，开源的开发方式对防止另一个人工智能冬天的到来有很大的帮助。
**00:21:03 - Chris Nicholson**：
人工智能冬天发生的一个原因是，当创意在放缓时，网络就会崩溃，资金就会枯竭。有了现在这些免费的开源工具，我们看到的不是创意的放缓，而是一种加速。创意得以被及时地测试，得以被迅速地分享。所以，这不仅仅是工具，而是预先训练好的机器学习模型，一个研究小组可以与另一个研究小组分享，或者与广大公众分享。而创意本身也被发表在 ARXIV 这样的平台上。ARXIV 是由<ruby> 康奈尔大学 <rt> Cornell University </rt></ruby>主办的。所有这些因素汇合在一起，加快了创意流动的速度。对我来说，这是对人工智能冬天的一种保险。这些因素的交汇使得人工智能成为一个超级令人兴奋的领域，它们意味着人工智能的发展速度比炒作更快。
**00:22:03 - Saron Yitbarek**：
Chris Nicholson是 Skymind 的创始人兼 CEO。
所以，开源能将人工智能领域从旧的专有模式所催生的寒冬中解冻出来。AI 的新时代伴随着 GPU 的巨大改进而到来。与之一并到来的还有算法上的突破，它帮助我们训练 AI 学习数据中的模式。然后，数据本身，海量的数据集正在为今天的 AI 提供动力。这一点，比任何事情都重要，这就是为什么新语言得以继续 LISP 未能完成的征途。我们向 Fast AI 的联合创始人 Rachel Thomas 询问，哪些语言适合下一代 AI。
**00:22:50 - Rachel Thomas**：
我们目前正在探索将 Swift 用于 TensorFlow 的可能性。Swift 是 Chris Lattner 开发的一种语言，我知道也有人在使用 Julia，他们正促进着 Julia 的开发与发展。但是，就目前而言，Python 在深度学习领域有着无可比拟的巨大优势。
**00:23:03 - Saron Yitbarek**：
这是因为 Python 非常适合处理大型数据集。
**00:23:08 - Rachel Thomas**：
我认为过去 20 年中发生的最重要的改变是，数据量的增长和人们对于数据的越发重视。我认为，数十年前有关 AI 的许多早期工作更多地围绕一种符号系统，即某种抽象符号系统。我要说的是，目前 AI 领域中的许多工作都围绕着数据展开，例如识别图像里的某样东西，或者辨认一条影评是褒还是贬。这些都是基于数据的问题。所以，我认为，Python 成为赢家 —— 至少是早期的赢家 —— 的原因之一，是因为 NumPy、SciPy 和 pandas 的生态系统，以及 Python 中所有数据处理用的库都足够完善。
**00:24:02 - Saron Yitbarek**：
在约翰·麦卡锡的团队还在麻省理工学院工作时，人工智能事业确实只有世界级的精英学者才能参与。但是自那时以来，语言和计算环境已经发生了巨大的发展，时至今日，每个人都能参与到 AI 的领域中来。我们在本季的第 1 期中听说过，Python 是许多初学者的第一语言。它使新手程序员能够加入 AI 的世界。
**00:24:29 - Rachel Thomas**：
我只想告诉大家，实际上你只需要一年的编码经验。你不需要诸如“鬼才”这样的名号，也不必具有真正的声望或权威。但是，我们需要来自各个背景的人。实际上，不同背景的人才能够为这个领域提供许多新鲜的创意，你的创意也是我们所需要的。
**00:24:52 - Saron Yitbarek**：
Rachel Thomas 是 Fast AI 的联合创始人，也是旧金山大学数据研究所的教授。我喜欢她为我们提供的信息。
AI 的故事是发现截然不同的人们之间的共同语言的故事。这是我们真正的任务，为充满 AI 的世界开发语言解决方案，开发能使所有人共同努力以实现下一个突破的解决方案。
>
> **00:25:22 - 播音员 1**：
>
>
> 各位，你们看到了今天在这里创造的历史。AlphaGo 以伟大的风格赢得了比赛。
>
>
> **00:25:32 - 播音员 2**：
>
>
> 是的，它甚至向我们展示了它的代码。
>
>
> **00:25:34 - 发言者 7**：
>
>
> 甚至向我们展示了它的代码。我想要祝贺这个计划。
>
>
>
**00:25:40 - Saron Yitbarek**：
2015 年，就在<ruby> 加里·卡斯帕罗夫 <rt> Garry Kasparov </rt></ruby>在国际象棋比赛中输给深蓝的几十年后，围棋世界冠军李世乭被谷歌的 AlphaGo 击败。深蓝显示出的智力威力大半依托于蛮力，而 AlphaGo 的胜利之所以让人感到惊讶，是因为它依靠神经网络和强化学习赢得了那场比赛。换句话说，AlphaGo 已经成功地朝着真正的智慧迈出了下一步。如果没有开源对人工智能的推动，这一切都不可能发生。新的语言正朝着麦卡锡的梦想而逐渐发展。我们的语言正越来越适合于最大限度地提高机器的智能。好消息是，在开源世界中，我们可以共同实现这份梦想，共同应对它所带来的挑战。
**00:26:39 - Saron Yitbarek**：
《代码英雄》是红帽的原创播客节目。如果你希望更深入的了解 LISP 或者人工智能，你可以访问节目的网站 [redhat.com/commandlineheroes](file:///Users/xingyuwang/develop/LCRH-wxy/translated/www.redhat.com/en/command-line-heroes)。在这里，你也能看到每一集的额外内容。下一期将是本季的最终集。在下一期中，我们将对一门重量级语言进行探究，并揭露与之有关的许多惊人事实；这门语言对本季中迄今为止讨论过的几乎所有语言都产生过影响。这是我们对 C 的深入研究。我是 Saron Yitbarek，下期之前，编程不止。
>
> **什么是 LCTT SIG 和 LCTT LCRH SIG**
>
>
> LCTT SIG 是 LCTT <ruby> 特别兴趣小组 <rt> Special Interest Group </rt></ruby>，LCTT SIG 是针对特定领域、特定内容的翻译小组，翻译组成员将遵循 LCTT 流程和规范，参与翻译，并获得相应的奖励。LCRH SIG 是 LCTT 联合红帽（Red Hat）发起的 SIG，当前专注任务是《代码英雄》系列播客的脚本汉化，已有数十位贡献者加入。敬请每周三、周五期待经过我们精心翻译、校对和发布的译文。
>
>
> 欢迎[加入 LCRH SIG](/article-12436-1.html) 一同参与贡献，并领取红帽（Red Hat）和我们联合颁发的专属贡献者证书。
>
>
>
---
via: <https://www.redhat.com/en/command-line-heroes/season-3/talking-to-machines>
作者：[Red Hat](https://www.redhat.com/en/command-line-heroes) 选题：[bestony](https://github.com/bestony) 译者：[bestony](https://github.com/bestony) 校对：[acyanbird](https://github.com/acyanbird), [Northurland](https://github.com/Northurland%5B), [wxy](https://github.com/wxy)
本文由 [LCRH](https://github.com/LCTT/LCRH) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
5 个适用于 Linux 的流式音频播放器 | Jack Wallen | https://www.linux.com/blog/2019/2/5-streaming-audio-players-linux | 当我工作的时候，我会一直在后台播放音乐。 | /data/attachment/album/202101/18/220035k8mmbl1blmkb97f8.jpg.thumb.jpg | /data/attachment/album/202101/18/220035k8mmbl1blmkb97f8.jpg | true | false | true | lujun9972 | Chao-zhi | wxy | false | [
"流媒体"
] | 分享 | {
"viewnum": 4774,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 当我工作的时候，我会一直在后台播放音乐。 | 2021-01-18T22:00:44 | 2021-01-18T22:00:44 | 13,029 | /article-13029-1.html | 
当我工作的时候，我会一直在后台播放音乐。大多数情况下，这些音乐是以黑胶唱片的形式在转盘上旋转。但有时我不想用这种单纯的方法听音乐时，我会选择听流媒体音频应用程序的方式。然而，由于我工作在 Linux 平台上，所以我只可以使用在我的操作系统上运行良好的软件。幸运的是，对于想在 Linux 桌面听流式音频的人来说，有很多工具可以选择。
事实上，Linux 为音乐流媒体提供了许多可靠的产品，我将重点介绍我最喜欢的五种用于此任务的工具。警告一句，并不是所有的玩意都是开源的。但是如果你不介意在你的开源桌面上运行一个专有的应用程序，你有一些非常棒的选择。让我们来看看有什么可用的。
### Spotify
Linux 版的 Spotify 不是那种在你启动就闪退的愚蠢的、半生不熟的应用程序，也没有阉割什么功能。事实上，Spotify 的 Linux 版本与其他平台上的版本完全相同。使用 Spotify 流媒体客户端，你可以收听音乐和播客、创建播放列表、发现新的艺术家等等。Spotify 界面（图 1）非常易于导航和使用。
*图 1：Spotify 界面可以很容易地找到新的音乐和旧的收藏。*
你可以使用 snap（使用 `sudo snap install Spotify` 命令）安装 Spotify，也可以使用以下命令从官方存储库安装 Spotify：
```
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 931FF8E79F0876134EDDBDCCA87FF9DF48BF1C90
sudo echo deb http://repository.spotify.com stable non-free | sudo tee /etc/apt/sources.list.d/spotify.list
sudo apt-get update
sudo apt-get install spotify-client
```
一旦安装，你就可以登录你的 Spotify 帐户，这样你就可以开始听好听的音乐，以帮助激励你完成你的工作。如果你已在其他设备上安装了 Spotify（并登录到同一帐户），则可以指定音乐应该流式传输到哪个设备（通过单击 Spotify 窗口右下角附近的“可用设备”图标）。
### Clementine
Clementine 是 Linux 平台上最好的音乐播放器之一。Clementine 不仅允许用户播放本地存储的音乐，还可以连接到许多流媒体音频服务，例如：
* Amazon Cloud Drive
* Box
* Dropbox
* Icecast
* Jamendo
* Magnatune
* [RockRadio.com](http://RockRadio.com)
* [Radiotunes.com](http://Radiotunes.com)
* SomaFM
* SoundCloud
* Spotify
* Subsonic
* [Vk.com](http://Vk.com)
* 或其他有趣的电台
使用 Clementine 有两个注意事项。首先，你必须使用最新版本（因为某些软件库中可用的构建版本已过时，并且不会安装必要的流式处理插件）。第二，即使是最新的构建版本，一些流媒体服务也不会像预期的那样工作。例如，接入 Spotify 频道时，你只能使用最热门的曲目（而无法使用播放列表，或搜索歌曲的功能）。
使用 Clementine 互联网流媒体服务时，你会发现其中有很多你从来没有听说过的音乐家和乐队（图 2）。
*图 2：Clementine 互联网广播是寻找新音乐的好方法。*
### Odio
Odio 是一个跨平台的专有应用程序（可用于 Linux、MacOS 和 Windows），它允许你流式传输各种类型的互联网音乐站。广播的内容是取自 [www.radio-browser.info](http://www.radio-browser.info)，而应用程序本身在为你呈现流方面做了令人难以置信的工作（图 3）。
*图 3：Odio 接口是你能找到的最好的接口之一。*
Odio 让你很容易找到独特的互联网广播电台，甚至可以把你找到并收藏的电台添加到你的库中。目前，在 Linux 上安装 Odio 的唯一方法是通过 Snap。如果你的发行版支持 snap 软件包，请使用以下命令安装此流应用程序：
```
sudo snap install odio
```
安装后，你可以打开应用程序并开始使用它。无需登录（或创建）帐户。Odio 的设置非常有限。实际上，它只提供了在设置窗口中选择暗色主题或亮色主题的选项。然而，尽管它可能功能有限，但 Odio 是在 Linux 上播放互联网广播的最佳选择之一。
### StreamTuner2
Streamtuner2 是一个优秀的互联网电台 GUI 工具。使用它，你可以流式播放以下音乐：
* Internet radio stations
* Jameno
* MyOggRadio
* [Shoutcast.com](http://Shoutcast.com)
* SurfMusic
* TuneIn
* [Xiph.org](http://Xiph.org)
* YouTube
Streamtuner2 提供了一个很好的界面（如果不是有点过时的话），可以很容易地找到和播放你喜爱的音乐。StreamTuner2 的一个警告是，它实际上只是一个用于查找你想要听到的流媒体的 GUI。当你找到一个站点时，双击它打开与流相关的应用程序。这意味着你必须安装必要的应用程序，才能播放流媒体。如果你没有合适的应用程序，你就不能播放流媒体。因此，你将花费大量的时间来确定要为某些流媒体安装哪些应用程序（图 4）。
*图4：配置 Streamtuner2 需要一个坚强的心脏。*
### VLC
很长一段时间以来，VLC 一直被称为 Linux 最好的媒体播放工具。这是有充分理由的，因为几乎所有你丢给它的东西它都能播放。其中包括流媒体广播电台。虽然你无法让 VLC 连接到 Spotify 这样的网站，但你可以直接访问互联网广播，点击播放列表，而 VLC 毫无疑问可以打开它。考虑到目前有很多互联网广播电台，你在寻找适合自己口味的音乐方面不会有任何问题。VLC 还包括可视化工具、均衡器（图 5）等工具。
*图 5：VLC 可视化工具和均衡器特性。*
VLC 唯一需要注意的是，你必须有一个你希望听到的互联网广播的 URL，因为这个工具本身并不能进行管理。但是有了这些链接，你就找不到比 VLC 更好的媒体播放器了。
### 这些工具软件怎么来的
如果这五个工具都不太不适合你的需要，我建议你打开你发行版的应用商店，搜索一个适合你的。有很多工具可以制作流媒体音乐、播客等等，不仅可以在 Linux 上实现，而且很简单。
---
via: <https://www.linux.com/blog/2019/2/5-streaming-audio-players-linux>
作者：[Jack Wallen](https://www.linux.com/users/jlwallen) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Chao-zhi](https://github.com/Chao-zhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
配置一个简洁高效的 Zsh | Chao-zhi | https://www.insidentally.com/2020/10/config-zsh/ | 事实上 oh-my-zsh 并不好用，严重拖慢了 Zsh 的速度，反而让你的工作并不高效。 | /data/attachment/album/202101/19/230224fq7x7hu3u399r0z3.jpg.thumb.jpg | /data/attachment/album/202101/19/230224fq7x7hu3u399r0z3.jpg | true | false | false | false | [
"Zsh"
] | 技术 | {
"viewnum": 38842,
"commentnum": 4,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "115.214.73.176",
"message": "原来zsh-autosuggestions在apt源里就有，可能这就是做过头吧",
"username": "来自浙江宁波的 Firefox 84.0|Windows 10 用户",
"date": "2021-01-24T21:46:31"
},
{
"postip": "222.93.190.5",
"message": "博主配置的挺好看，可以把 ~/.zshrc 分享一下么？",
"username": "来自江苏苏州的 Chrome 94.0|Windows 10 用户",
"date": "2021-10-11T20:41:49"
},
{
"postip": "220.200.126.87",
"message": "感谢分享啊，洁癖用户是真的不想用OhMyZsh",
"username": "来自广西钦州的 Chrome Mobile 100.0|Android 12 用户",
"date": "2022-05-12T00:31:53"
},
{
"postip": "202.193.15.102",
"message": "建议将Ubuntu用apt安装powerlevel9k变成直接git clone powerlevel10k的项目到/usr/share即可",
"username": "来自广西桂林广西师范大学的 Chrome 101.0|GNU/Linux 用户",
"date": "2022-05-12T14:33:33"
}
] | [] | 事实上 oh-my-zsh 并不好用，严重拖慢了 Zsh 的速度，反而让你的工作并不高效。 | 2021-01-18T22:38:00 | 2021-01-18T22:38:00 | 13,030 | /article-13030-1.html | Shell 是类 Unix 系统中超级好用的工具，而 Zsh 是 shell 中的佼佼者，但是现在网上一搜索 Zsh 的配置方案，遍地都是的互相复制粘贴的 oh-my-zsh 配置方案。**事实上 oh-my-zsh 并不好用**，严重拖慢了 Zsh 的速度，反而让你的工作并不高效。现在将我自己的使用方案分享给大家，教大家配置一个高效好用的 Zsh。
### 安装 Zsh
我笔记本电脑使用的是 ArchLinux，服务器使用的是 Ubuntu。主要介绍这两个发行版的配置方法，红帽系的发行版请自行尝试。
我个人喜欢尽量从发行版的源里安装。从源安装具有方便，稳定，容易维护等优点。
#### 在 ArchLinux 安装 Zsh
终端里面输入：
```
sudo pacman -Sy zsh
```
#### 在 Ubuntu 安装 Zsh
终端里面输入：
```
sudo apt-get update
sudo apt-get install zsh
```
### 安装插件
我只需要两个插件：
* `zsh-autosuggestions`：这个是自动建议插件，能够自动提示你需要的命令。
* `zsh-syntax-highlighting`：这个是代码高亮插件，能够使你的命令行各个命令清晰明了。
还有一个主题：
* `zsh-theme-powerlevel10k` 这个主题提供漂亮的提示符，可以显示当前路径、时间、命令执行成功与否，还能够支持 git 分支显示等等。
同样是尽可能从源里面安装。
>
> Ubuntu 20.10 的源里面是 `powerlevel9k`，配置好后实际使用体验和 `powerlevel10k` 差别不大。
>
>
>
#### 在 ArchLinux 安装插件和主题
终端里面输入命令：
```
sudo pacman -S zsh-autosuggestions zsh-syntax-highlighting zsh-theme-powerlevel10k zsh-completions
```
#### 在 Ubuntu 安装插件和主题
终端里面输入命令：
```
sudo apt-get install zsh-autosuggestions zsh-syntax-highlighting zsh-theme-powerlevel9k
```
这样插件和主题就安装好了。
### 更改默认 shell，并配置插件和主题
安装好了之后就是启用 Zsh，并且配置插件和主题了。
#### 更改默认 shell
终端输入命令：
```
chsh -s /usr/bin/zsh
```
ArchLinux 和 Ubuntu 都是同样的操作，然后注销并重新登录，就启用了 Zsh。第一次进入 Zsh 会自动出现一个配置界面，这个界面可以根据需要自定义 Zsh。
在这里输入 `1` 就可以进入配置界面了。
配置界面中各个菜单代表的意思分别是：
* `1`：设置命令历史记录相关的选项
* `2`：设置命令补全系统
* `3`：设置热建
* `4`：选择各种常见的选项，只需要选择“On”或者“Off”
* `0`：退出，并使用空白（默认）配置
* `a`：终止设置并退出
* `q`：退出
这里根据提示，然后按照你自己的喜好配置就可以了。配置好后，会在你的用户目录下生成 `.zshrc` 文件。然后我们要去这个文件中启用插件和主题。
#### 配置插件和主题
Zsh 的配置文件是 `~/.zshrc` 文件，这个文件在你的用户目录下 `~/`。删掉了这个文件，再次进入 Zsh，又会触发 Zsh 的配置界面。
##### 在 ArchLinux 启用插件和主题
打开 `~/.zshrc` 文件，将以下行代码添加到其中：
```
source /usr/share/zsh/plugins/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh
source /usr/share/zsh/plugins/zsh-autosuggestions/zsh-autosuggestions.zsh
source /usr/share/zsh-theme-powerlevel10k/powerlevel10k.zsh-theme
```
##### 在 Ubuntu 启用插件和主题
打开 `~/.zshrc` 文件，将以下行代码添加到其中：
```
source /usr/share/powerlevel9k/powerlevel9k.zsh-theme
source /usr/share/zsh-autosuggestions/zsh-autosuggestions.zsh
source /usr/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh
```
这样就成功的启用了插件和主题，插件不需要额外的配置就很好用，有额外配置需求的可以自行研究。
而 `powerlevel10k` 主题在首次进入时，会触发一个配置界面。
然后根据提示和你的喜好一步步完成配置即可。
这里可以选择你喜欢的提示符。
**配置完成后就可以愉快的使用啦！**
|
|||
通过创建视频游戏来学习 Python | Seth Kenlon | https://opensource.com/article/20/10/learn-python-ebook | 使用我们的新电子书中的分步说明，以有趣的方式了解 Python。 | /data/attachment/album/202101/18/234525jdrrv6o6gkhkdq1k.jpg.thumb.jpg | /data/attachment/album/202101/18/234525jdrrv6o6gkhkdq1k.jpg | true | false | true | lujun9972 | stevenzdg988 | wxy | false | [
"Python",
"Pygame"
] | 软件开发 | {
"viewnum": 3963,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 使用我们的新电子书中的分步说明，以有趣的方式了解 Python。 | 2021-01-18T23:45:39 | 2021-01-18T23:45:39 | 13,031 | /article-13031-1.html |
>
> 使用我们的新电子书中的分步说明，以有趣的方式了解 Python。
>
>
>
Python 是目前最流行的程序设计语言之一。不管是为了工作还是娱乐为目的学习 Python，它都是一门功能强大且非常有用的编程语言。你可以创建应用程序来帮助你完成日常任务，创建你和朋友们喜欢玩的游戏，创建用于处理数据的脚本，创建用于生成或分析信息的应用程序等等。
无论你计划使用程序设计语言做什么，我们都认为通过创建游戏来学习比通过处理数字或变换字符串来学习更为有趣。然而，如果你完全是一个编程的新手，当你能看到代码在视频游戏等熟悉的环境中工作时，你会更容易理解为什么要用代码做某事。
你可能不会选择 [Python](https://www.python.org/) 作为最好的编程语言（每个人对此都有自己的答案），但它不是一门令人恐惧的编程语言。 Python 可以使用很多关键字（例如 `is` 和 `is not`）代替符号（例如 `=` 和 `!=`）。它还能管理许多低级任务，因此你通常不必担心数据类型和垃圾收集之类的事情。通常，这意味着你马上就可以开始编写代码，而不会像在 [C](https://opensource.com/article/20/8/c-programming-cheat-sheet) 或 [Java](https://opensource.com/resources/java) 那样的复杂编程语言面前遇到挫折。
为了帮助你学习 Python，我们编写了一本电子书，教你如何使用 Python 创建平台类视频游戏。在制作视频游戏的同时逐步通过课程学习 Python。另外一个好处是，你还将学习编程逻辑、语法、运算符等更多的内容。你可以在学习过程中立即看到结果，因此你学到的所有内容都会得到及时巩固。
### 一分钟上手 Python
Python 是一种用途广泛的编程语言，这意味着它（与大多数语言一样）提供了函数来对数字和字符做处理的“简单技巧”。Linux 操作系统用户已经安装了 Python。 Mac 操作系统用户使用的是较旧版本的 Python，但是你可以从 [Python.org](http://Python.org) 网站 [安装最新版本](https://www.python.org/downloads/mac-osx)。Windows 操作系统用户可以从这篇 [在 Windows 上安装 Python](https://opensource.com/article/19/8/how-install-python-windows) 的文章中学习如何安装 Python。
安装完成后，你可以启动交互式 Python Shell 进行算术运算：
```
$ python3
>>> 5+6
11
>>> 11/2
5.5
>>> 11//2
5
>>> 11%2
1
```
从该示例可以了解，需要一些特殊的符号，但学过数学的人都最熟悉不过了。也许你不喜欢数字，而更喜欢字母：
```
$ python3
>>> string = "hello world"
>>> print(string)
hello world
>>> print(string.upper())
HELLO WORLD
>>> print(string[0])
h
>>> print(string[1])
e
>>> print(string[2])
l
>>> print(string[3])
l
>>> print(string[4])
o
```
同样，相对地说基础的任务有特殊的符号表示法，但是即使没有说明，你也可能已经发现 `[0]` 和 `[1]` 符号表示法是将数据“切片”并且利用 `print` 函数将其中的数据显示在屏幕上。
### 五分钟用上 Pygame
如果你只想使用 Python 来创建一个视频游戏或任何超越基本计算的项目，这可能需要投入大量的学习、努力和时间。幸运的是，Python 诞生已有二十年了，开发者已经开发了代码库来帮助你（相对）轻松地完成典型的程序壮举。[Pygame](https://www.pygame.org/news) 是一套用于创建视频游戏的代码模块。它 [不是唯一的这种类库](https://opensource.com/article/18/4/easy-2d-game-creation-python-and-arcade)，但是它是最古老的（不论好坏），因此在线上有很多文档和示例。
首先学习 [推荐的 Python 虚拟环境工作流程](https://opensource.com/article/20/9/venv-python)：
```
$ python3 -m venv mycode/venv
$ cd mycode
$ source ./venv/bin/activate
(venv)$
```
进入虚拟环境后，可以安全地将 Pygame 安装到项目文件夹中：
```
(venv)$ echo "pygame" >> requirements.txt
(venv)$ python -m pip install -r requirements.txt
[...] Installing collected packages: pygame
Successfully installed pygame-x.y.z
```
现在你已经安装了 Pygame，就可以创建一个简单的演示应用程序。它比你想象的要容易。Python 可以进行所谓的面向对象编程（OOP），这是一个漂亮的计算机科学术语，用于描述当代码结构化时，就像你在使用代码创建物理对象一样。然而，程序员并没有受到迷惑。他们知道在编写代码时并不是真的在制造物理对象，但是这样有助于想象，因为这样你就可以了解编程世界的局限性。
例如，如果你被困在一个荒岛上并想要一杯咖啡，那么你就必须收集一些黏土，做一个杯子，然后烘烤它。如果你足够聪明，先创建一个模具，以便每当需要另一个杯子时，都可以从模板中快速创建一个新杯子。即使每个杯子都来自相同的模板，它们在物理上也是独立的：如果一个杯子破裂，你还会有另一个杯子。你可以通过添加颜色或蚀刻使每个咖啡杯显得独一无二。
在 Pygame 和许多编程任务中，你都会使用类似的逻辑。在定义之前，它不会出现在你的编程项目中。下面是如何在 Python 和 Pygame 程序中让咖啡杯出现。
#### 使用 Pygame 进行面向对象编程
创建一个名为 `main.py` 的文件，并输入以下代码用以启动 Pygame 模块，并使用 Pygame 模板创建一个窗口：
```
import pygame
pygame.init()
screen = pygame.display.set_mode((960,720))
```
就像你可能在现实生活中使用模板来创建对象一样，你也可以使用 Pygame 提供的模板来创建一个<ruby> 妖精 <rt> sprite </rt></ruby>（这是 Pygame 的视觉游戏对象术语）。在面向对象的编程中，`class` 表示对象的模板。在你的文档中输入以下代码：
```
class Cup(pygame.sprite.Sprite):
def __init__(self):
pygame.sprite.Sprite.__init__(self)
# image
img = pygame.image.load('coffeecup.png').convert()
self.image = img
# volume
self.rect = self.image.get_rect()
self.rect.x = 10
self.rect.y = 10
```
该代码块使用 Pygame 的 `sprite` 模板设计一个咖啡杯子妖精。由于 `self.image` 的存在，你的咖啡杯妖精有一个图像，而 `self.rect` 则赋予了它体积（宽度和高度）。这些是 Pygame 期望妖精拥有的属性，但是如果你要创建一个可玩的视频游戏，则可以为其指定任何其他所需的属性，例如健康点和得分。
到目前为止，你所要做的就是创建一个窗口和一个用于咖啡杯的 *模板* 。你的游戏实际上还没有一个杯子。
你的代码的最后一部分必须使用模板来生成杯子并将其添加到游戏世界中。如你所知，计算机运行速度非常快，因此从技术上讲，你到目前为止创建的代码只会运行一毫秒左右。编写图形计算机应用程序时，无论计算机是否认为已完成规定的任务，都必须强制其保持打开状态。程序员使用 *无限循环* 来执行此操作，该循环在 Python 中由 `while True` 语句表示（`True` 始终为真，因此循环永远不会结束）。
无限循环可以确保你的应用程序保持打开状态足够长的时间，以使计算机用户可以查看和使用该应用程序：
```
cup = Cup()
while True:
pygame.display.update()
screen.blit(cup.image, cup.rect)
```
此代码示例从模板 `Cup` 创建杯子，然后使用 Pygame 函数更新显示。最后，使用 Pygame 的 `blit` 函数在其边框内绘制杯子的图像。
#### 获取图形
在成功运行代码之前，你需要为咖啡杯准备一个图形。你可以在 [FreeSVG.org](http://freesvg.org) 上找到许多 [公用创作](https://opensource.com/article/20/1/what-creative-commons) 咖啡杯图形。我用了 [这个](https://freesvg.org/1548870028)。将图形保存在项目目录中，并将其命名为 `coffeecup.png`。
#### 运行游戏
启动应用程序：
```
(venv)$ python ./main.py
```
* [下载 Python 游戏电子书](https://opensource.com/downloads/python-gaming-ebook)
Pygame 是一个功能强大的框架，除了在屏幕上绘制咖啡杯之外，你还可以做更多的事情。[下载我们的免费电子书](https://opensource.com/downloads/python-gaming-ebook) 更好地了解 Pygame 和 Python。
---
via: <https://opensource.com/article/20/10/learn-python-ebook>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
ElementaryOS：使用这个轻量级 Linux 桌面提高你的工作效率 | Kevin Sonney | https://opensource.com/article/21/1/elementary-linux | ElementaryOS 提供了一个快速、轻量、高效的桌面，让你在新的一年里保持工作效率。 | /data/attachment/album/202101/19/235403miy29qe6rqvv2vl3.jpg.thumb.jpg | /data/attachment/album/202101/19/235403miy29qe6rqvv2vl3.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"ElementaryOS"
] | 分享 | {
"viewnum": 8585,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "120.85.78.84",
"message": "主",
"username": "来自广东广州的 Chrome 87.0|Windows 10 用户",
"date": "2021-01-20T23:40:49"
}
] | [
{
"raid": 13044,
"displayorder": 0
}
] | ElementaryOS 提供了一个快速、轻量、高效的桌面，让你在新的一年里保持工作效率。 | 2021-01-19T23:54:00 | 2021-01-19T23:54:00 | 13,033 | /article-13033-1.html |
>
> ElementaryOS 提供了一个快速、轻量、高效的桌面，让你在新的一年里保持工作效率。
>
>
>
在前几年，这个年度系列报道了各个应用程序。今年，我们将在 2021 年寻求帮助的策略之外，还将关注一站式解决方案。欢迎来到 2021 年 21 天生产力的第一天。
当寻求提高生产率的工具时，很容易将几乎能用但不能完全很好地发挥作用的应用集合在一起。在过去的几年里，我们已经谈到了单个的电子邮件应用、日历应用、记事本应用等等。不过，总会有些麻烦。要么需要自定义脚本，要么需要复杂的导出/导入步骤才能使一个工具工作。
[ElementaryOS](https://elementary.io/) 是一个完整的桌面，具有美观、实用、高效的环境。
*ElementaryOS 桌面 （Kevin Sonney， [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
ElementaryOS 是一个基于流行的 Ubuntu Linux 发行版的“按需付费”开源项目。对于过去安装过 Ubuntu 的人来说，初始设置和安装会非常熟悉。然而，一旦登录，体验就会很不一样。
ElementaryOS 使用 [Gala 窗口管理器](https://github.com/elementary/gala)和 Pantheon shell。这两个都是专门为 Elementary 开发的。安装后，桌面非常精简，它只提供了少量的轻量级应用。这些应用包括 Web 浏览器、终端、邮件客户端和日历客户端。它还有一个应用中心，允许你安装 Elementary 团队策划的免费和商业应用。
*ElementaryOS 的邮件和日历应用（Kevin Sonney， [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
[邮件](https://github.com/elementary/mail)和[日历](https://github.com/elementary/calendar)这两个应用看起来很熟悉，因为这两个应用已经被其他发行版使用了一段时间。邮件是作为 [Geary](https://wiki.gnome.org/Apps/Geary) 的复刻分支开始的，而日历在其他地方则被称为 [Maya](https://launchpad.net/maya)。两者的设置非常简单。两款应用默认仅使用用户名/密码认证，所以需要双因素认证的用户需要一些额外的步骤。两者的界面都异常轻巧快速。
*应用中心（Kevin Sonney，[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
ElementaryOS 默认不包含待办事项或记事本应用。这时，应用中心就可以发挥作用了。在应用中心中，有大量的应用可以填补空白。其中有两款应用真的很出色。第一个是 [Planner](https://appcenter.elementary.io/com.github.alainm23.planner/)，一款简洁、轻量级的待办事项管理器。它支持多个列表、计划和重复性任务、项目和子项目。它还可以与流行的在线应用 [Todoist](https://todoist.com/) 同步，但这不是必需的。
应用中心的第二款应用是 [Notes-Up](https://github.com/Philip-Scott/Notes-up)，这是一款使用 Markdown 写富文本格式的笔记应用。它允许用户在多个笔记本中创建多个笔记，并且有“查看”和“编辑”选项，这样你就可以预览最终文档的样子。同样，这款应用快速、轻量而且非常简约，与 ElementaryOS 的整体外观和感觉保持一致。
*Planner 和 Notes-up （Kevin Sonney，[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
如果你不喜欢默认应用，Elementary 基于 Ubuntu LTS，因此如果你需要使用其他应用，整个 Ubuntu 应用生态系统都可以使用。不过总的来说，ElementaryOS 默认提供了一个快速、轻量、高效的桌面，让你在新的一年里保持高效。
---
via: <https://opensource.com/article/21/1/elementary-linux>
作者：[Kevin Sonney](https://opensource.com/users/ksonney) 选题：[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/) 荣誉推出
|
如何在电池充满或低电量时获得电池状态通知 | Magesh Maruthamuthu | https://www.2daygeek.com/linux-low-full-charge-discharge-battery-notification/ | 充电时间长了会对电池造成损害，所以在电池 100% 充满时要拔掉电源线。电池充电或放电时没有默认的应用程序来通知，需要安装第三方应用来通知你。 | /data/attachment/album/202101/20/231310avo3kzv67vkm3tz7.jpg.thumb.jpg | /data/attachment/album/202101/20/231310avo3kzv67vkm3tz7.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"电池"
] | 桌面应用 | {
"viewnum": 5351,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 充电时间长了会对电池造成损害，所以在电池 100% 充满时要拔掉电源线。电池充电或放电时没有默认的应用程序来通知，需要安装第三方应用来通知你。 | 2021-01-20T23:14:00 | 2021-01-20T23:14:00 | 13,036 | /article-13036-1.html | 
对于类 Unix 用户来说，Linux 笔记本是不错的选择，但它经常会耗尽电池。我试过很多 Linux 操作系统，但没有像 Windows 那样电池寿命长。
充电时间长了会对电池造成损害，所以在电池 100% 充满时要拔掉电源线。电池充电或放电时没有默认的应用程序来通知，需要安装第三方应用来通知你。
为此，我通常会安装 [Battery Monitor](https://www.2daygeek.com/category/battery-monitor/)，但它已经被废弃，所以我创建了一个 shell 脚本来获取通知。
笔记本电池充放电状态可以通过以下两个命令来识别。
使用 `acpi` 命令。
```
$ acpi -b
Battery 0: Discharging, 71%, 00:58:39 remaining
```
使用 `upower` 命令。
```
$ upower -i /org/freedesktop/UPower/devices/battery_BAT0 | grep -w 'state|percentage' | awk '{print $2}'
discharging
64%
```
### 方法 1：当电池电量高于 95% 或低于 20% 时，用 Shell 脚本发送警报
这个脚本在启动时在后台运行，每分钟检查一次电池状态，然后在电池电量超过 95% 或放电时电量低于 20% 时发送通知。
警报会直到你的电池电量超过 20% 或低于 95% 时才会停止。
```
$ sudo vi /opt/scripts/battery-status.sh
```
```
#!/bin/bash
while true
do
battery_level=`acpi -b | grep -P -o '[0-9]+(?=%)'`
if [ $battery_level -ge 95 ]; then
notify-send "Battery Full" "Level: ${battery_level}%"
paplay /usr/share/sounds/freedesktop/stereo/suspend-error.oga
elif [ $battery_level -le 20 ]; then
notify-send --urgency=CRITICAL "Battery Low" "Level: ${battery_level}%"
paplay /usr/share/sounds/freedesktop/stereo/suspend-error.oga
fi
sleep 60
done
```
脚本完成后，设置可执行权限：
```
$ sudo chmod +x /opt/scripts/battery-status.sh
```
最后，将该脚本添加到用户配置文件的底部。对于全局范围来说，你需要在 `/etc/profile` 文件中添加该脚本。
```
$ vi /home/magi/.profile
/opt/scripts/battery-status.sh &
```
[重启你的 Linux 系统](https://www.2daygeek.com/6-commands-to-shutdown-halt-poweroff-reboot-the-linux-system/)来检查这点。
```
$ sudo reboot
```
### 方法 2：当电池充电（高于 95%）或放电（低于 20%）时发送通知的 Shell 脚本
这个脚本与上面的脚本类似，但它是由交流适配器负责。
如果你插上了交流适配器，而且电池的电量超过 95%，它就会发出一个带有声音的通知，但是这个通知不会停止，直到你拔掉交流适配器。
如果你拔掉交流适配器，你将永远不会再看到通知，直到你的电池电量下降到 20%。
```
$ sudo vi /opt/scripts/battery-status-1.sh
```
```
#!/bin/bash
while true
do
export DISPLAY=:0.0
battery_level=`acpi -b | grep -P -o '[0-9]+(?=%)'`
if on_ac_power; then
if [ $battery_level -ge 95 ]; then
notify-send "Battery Full" "Level: ${battery_level}% "
paplay /usr/share/sounds/freedesktop/stereo/suspend-error.oga
fi
else
if [ $battery_level -le 20 ]; then
notify-send --urgency=CRITICAL "Battery Low" "Level: ${battery_level}%"
paplay /usr/share/sounds/freedesktop/stereo/suspend-error.oga
fi
fi
sleep 60
done
```
脚本完成后，设置执行权限：
```
$ sudo chmod +x /opt/scripts/battery-status-1.sh
```
最后将脚本添加到用户配置文件的底部。对于全局范围来说，你需要在 `/etc/profile` 文件中添加该脚本。
```
$ vi /home/magi/.profile
/opt/scripts/battery-status-1.sh &
```
重启系统来检查：
```
$ sudo reboot
```
参考： [stackexchange](https://unix.stackexchange.com/questions/60778/how-can-i-get-an-alert-when-my-battery-is-about-to-die-in-linux-mint)
---
via: <https://www.2daygeek.com/linux-low-full-charge-discharge-battery-notification/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[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/) 荣誉推出
|
利用 ONLYOFFICE 将在线文档编辑器集成到 Python Web 应用程序中 | Aashima Sharma | https://opensourceforu.com/2019/09/integrate-online-documents-editors-into-a-python-web-app-using-onlyoffice/ | 通过 API，开发人员可以将 ONLYOFFICE 编辑器集成到网站和利用程序设计语言编写的应用程序中，并能配置和管理编辑器。 | /data/attachment/album/202101/21/104928pv6l5gcjo8gmzb5l.jpg.thumb.jpg | /data/attachment/album/202101/21/104928pv6l5gcjo8gmzb5l.jpg | true | false | true | lujun9972 | stevenzdg988 | wxy | false | [
"ONLYOFFICE"
] | 软件开发 | {
"viewnum": 5926,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 通过 API，开发人员可以将 ONLYOFFICE 编辑器集成到网站和利用程序设计语言编写的应用程序中，并能配置和管理编辑器。 | 2021-01-21T10:49:27 | 2021-01-21T10:49:27 | 13,037 | /article-13037-1.html | 
[ONLYOFFICE](https://www.onlyoffice.com/en/) 是根据 GNU AGPL v.3 许可证条款分发的开源协作办公套件。它包含三个用于文本文档、电子表格和演示文稿的编辑器，并具有以下功能:
* 查看，编辑和协同编辑 `.docx`、`.xlsx`、`.pptx` 文件。OOXML 作为一种核心格式，可确保与 Microsoft Word、Excel 和 PowerPoint 文件的高度兼容性。
* 通过内部转换为 OOXML，编辑其他流行格式（`.odt`、`.rtf`、`.txt`、`.html`、`.ods`、`.csv`、`.odp`）。
* 熟悉的选项卡式界面。
* 协作工具：两种协同编辑模式（快速和严谨），跟踪更改，评论和集成聊天。
* 灵活的访问权限管理：完全访问权限、只读、审阅、表单填写和评论。
* 使用 API 构建附加组件。
* 250 种可用语言和象形字母表。
通过 API，开发人员可以将 ONLYOFFICE 编辑器集成到网站和利用程序设计语言编写的应用程序中，并能配置和管理编辑器。
要集成 ONLYOFFICE 编辑器，我们需要一个集成应用程序来连接编辑器（ONLYOFFICE 文档服务器）和服务。 要在你的界面中使用编辑器，因该授予 ONLYOFFICE 以下权限：
* 添加并执行自定义代码。
* 用于下载和保存文件的匿名访问权限。这意味着编辑器仅与服务器端的服务通信，而不包括客户端的任何用户授权数据（浏览器 cookies）。
* 在用户界面添加新按钮（例如，“在 ONLYOFFICE 中打开”、“在 ONLYOFFICE 中编辑”）。
* 开启一个新页面，ONLYOFFICE 可以在其中执行脚本以添加编辑器。
* 能够指定文档服务器连接设置。
流行的协作解决方案的成功集成案例有很多，如 Nextcloud、ownCloud、Alfresco、Confluence 和 SharePoint，都是通过 ONLYOFFICE 提供的官方即用型连接器实现的。
实际的集成案例之一是 ONLYOFFICE 编辑器与以 C＃ 编写的开源协作平台的集成。该平台具有文档和项目管理、CRM、电子邮件聚合器、日历、用户数据库、博客、论坛、调查、Wiki 和即时通讯程序的功能。
将在线编辑器与 CRM 和项目模块集成，你可以：
* 文档关联到 CRM 时机和容器、项目任务和讨论，甚至创建一个单独的文件夹，其中包含与项目相关的文档、电子表格和演示文稿。
* 直接在 CRM 或项目模块中创建新的文档、工作表和演示文稿。
* 打开和编辑关联的文档，或者下载和删除。
* 将联系人从 CSV 文件批量导入到 CRM 中，并将客户数据库导出为 CSV 文件。
在“邮件”模块中，你可以关联存储在“文档模块”中的文件，或者将指向所需文档的链接插入到邮件正文中。 当 ONLYOFFICE 用户收到带有附件的文档的消息时，他们可以：下载附件、在浏览器中查看文件、打开文件进行编辑或将其保存到“文档模块”。 如上所述，如果格式不同于 OOXML ，则文件将自动转换为 `.docx`、`.xlsx`、`.pptx`，并且其副本也将以原始格式保存。
在本文中，你将看到 ONLYOFFICE 与最流行的编程语言之一的 Python 编写的文档管理系统的集成过程。 以下步骤将向你展示如何创建所有必要的部分，以使在 DMS（<ruby> 文档管理系统 <rt> Document Management System </rt></ruby>）界面内的文档中可以进行协同工作成为可能：查看、编辑、协同编辑、保存文件和用户访问管理，并可以作为服务的示例集成到 Python 应用程序中。
### 1、前置需求
首先，创建集成过程的关键组件：[ONLYOFFICE 文档服务器](https://www.onlyoffice.com/en/developer-edition.aspx) 和用 Python 编写的文件管理系统。
#### 1.1、ONLYOFFICE 文档服务器
要安装 ONLYOFFICE 文档服务器，你可以从多个安装选项中进行选择：编译 GitHub 上可用的源代码，使用 `.deb` 或 `.rpm` 软件包亦或 Docker 镜像。
我们推荐使用下面这条命令利用 Docker 映像安装文档服务器和所有必需的依赖。请注意，选择此方法，你需要安装最新的 Docker 版本。
```
docker run -itd -p 80:80 onlyoffice/documentserver-de
```
#### 1.2、利用 Python 开发 DMS
如果已经拥有一个，请检查它是否满足以下条件：
* 包含需要打开以查看/编辑的保留文件
* 允许下载文件
对于该应用程序，我们将使用 Bottle 框架。我们将使用以下命令将其安装在工作目录中：
```
pip install bottle
```
然后我们创建应用程序代码 `main.py` 和模板 `index.tpl`。
我们将以下代码添加到 `main.py` 文件中：
```
from bottle import route, run, template, get, static_file # connecting the framework and the necessary components
@route('/') # setting up routing for requests for /
def index():
return template('index.tpl') # showing template in response to request
run(host="localhost", port=8080) # running the application on port 8080
```
一旦我们运行该应用程序，点击 <http://localhost:8080> 就会在浏览器上呈现一个空白页面 。 为了使文档服务器能够创建新文档，添加默认文件并在模板中生成其名称列表，我们应该创建一个文件夹 `files` 并将3种类型文件（`.docx`、`.xlsx` 和 `.pptx`）放入其中。
要读取这些文件的名称，我们使用 `listdir` 组件（模块）：
```
from os import listdir
```
现在让我们为文件夹中的所有文件名创建一个变量：
```
sample_files = [f for f in listdir('files')]
```
要在模板中使用此变量，我们需要通过 `template` 方法传递它：
```
def index():
return template('index.tpl', sample_files=sample_files)
```
这是模板中的这个变量：
```
% for file in sample_files:
<div>
<span>{{file}}</span>
</div>
% end
```
我们重新启动应用程序以查看页面上的文件名列表。
使这些文件可用于所有应用程序用户的方法如下：
```
@get("/files/<filepath:re:.*\.*>")
def show_sample_files(filepath):
return static_file(filepath, root="files")
```
### 2、查看文档
所有组件准备就绪后，让我们添加函数以使编辑者可以利用应用接口操作。
第一个选项使用户可以打开和查看文档。连接模板中的文档编辑器 API ：
```
<script type="text/javascript" src="editor_url/web-apps/apps/api/documents/api.js"></script>
```
`editor_url` 是文档编辑器的链接接口。
打开每个文件以供查看的按钮：
```
<button onclick="view('files/{{file}}')">view</button>
```
现在我们需要添加带有 `id` 的 `div` 标签，打开文档编辑器：
```
<div id="editor"></div>
```
要打开编辑器，必须调用调用一个函数：
```
<script>
function view(filename) {
if (/docx$/.exec(filename)) {
filetype = "text"
}
if (/xlsx$/.exec(filename)) {
filetype = "spreadsheet"
}
if (/pptx$/.exec(filename)) {
filetype = "presentation",
title: filename
}
new DocsAPI.DocEditor("editor",
{
documentType: filetype,
document: {
url: "host_url" + '/' + filename,
title: filename
},
editorConfig: {mode: 'view'}
});
}
</script>
```
DocEditor 函数有两个参数：将在其中打开编辑器的元素 `id` 和带有编辑器设置的 `JSON`。 在此示例中，使用了以下必需参数：
* `documentType` 由其格式标识（`.docx`、`.xlsx`、`.pptx` 用于相应的文本、电子表格和演示文稿）
* `document.url` 是你要打开的文件链接。
* `editorConfig.mode`。
我们还可以添加将在编辑器中显示的 `title`。
接下来，我们可以在 Python 应用程序中查看文档。
### 3、编辑文档
首先，添加 “Edit”（编辑）按钮：
```
<button onclick="edit('files/{{file}}')">edit</button>
```
然后创建一个新功能，打开文件进行编辑。类似于查看功能。
现在创建 3 个函数：
```
<script>
var editor;
function view(filename) {
if (editor) {
editor.destroyEditor()
}
editor = new DocsAPI.DocEditor("editor",
{
documentType: get_file_type(filename),
document: {
url: "host_url" + '/' + filename,
title: filename
},
editorConfig: {mode: 'view'}
});
}
function edit(filename) {
if (editor) {
editor.destroyEditor()
}
editor = new DocsAPI.DocEditor("editor",
{
documentType: get_file_type(filename),
document: {
url: "host_url" + '/' + filename,
title: filename
}
});
}
function get_file_type(filename) {
if (/docx$/.exec(filename)) {
return "text"
}
if (/xlsx$/.exec(filename)) {
return "spreadsheet"
}
if (/pptx$/.exec(filename)) {
return "presentation"
}
}
</script>
```
`destroyEditor` 被调用以关闭一个打开的编辑器。
你可能会注意到，`edit()` 函数中缺少 `editorConfig` 参数，因为默认情况下它的值是：`{"mode":"edit"}`。
现在，我们拥有了打开文档以在 Python 应用程序中进行协同编辑的所有功能。
### 4、如何在 Python 应用中利用 ONLYOFFICE 协同编辑文档
通过在编辑器中设置对同一文档使用相同的 `document.key` 来实现协同编辑。 如果没有此键值，则每次打开文件时，编辑器都会创建编辑会话。
为每个文档设置唯一键，以使用户连接到同一编辑会话时进行协同编辑。 密钥格式应为以下格式：`filename +"_key"`。下一步是将其添加到当前文档的所有配置中。
```
document: {
url: "host_url" + '/' + filepath,
title: filename,
key: filename + '_key'
},
```
### 5、如何在 Python 应用中利用 ONLYOFFICE 保存文档
每次我们更改并保存文件时，ONLYOFFICE 都会存储其所有版本。 让我们仔细看看它是如何工作的。 关闭编辑器后，文档服务器将构建要保存的文件版本并将请求发送到 `callbackUrl` 地址。 该请求包含 `document.key`和指向刚刚构建的文件的链接。
`document.key` 用于查找文件的旧版本并将其替换为新版本。 由于这里没有任何数据库，因此仅使用 `callbackUrl` 发送文件名。
在 `editorConfig.callbackUrl` 的设置中指定 `callbackUrl` 参数并将其添加到 `edit()` 方法中：
```
function edit(filename) {
const filepath = 'files/' + filename;
if (editor) {
editor.destroyEditor()
}
editor = new DocsAPI.DocEditor("editor",
{
documentType: get_file_type(filepath),
document: {
url: "host_url" + '/' + filepath,
title: filename,
key: filename + '_key'
}
,
editorConfig: {
mode: 'edit',
callbackUrl: "host_url" + '/callback' + '&filename=' + filename // add file name as a request parameter
}
});
}
```
编写一种方法，在获取到 POST 请求发送到 `/callback` 地址后将保存文件：
```
@post("/callback") # processing post requests for /callback
def callback():
if request.json['status'] == 2:
file = requests.get(request.json['url']).content
with open('files/' + request.query['filename'], 'wb') as f:
f.write(file)
return "{\"error\":0}"
```
`# status 2` 是已生成的文件，当我们关闭编辑器时，新版本的文件将保存到存储器中。
### 6、管理用户
如果应用中有用户，并且你需要查看谁在编辑文档，请在编辑器的配置中输入其标识符（`id`和`name`）。
在界面中添加选择用户的功能：
```
<select id="user_selector" onchange="pick_user()">
<option value="1" selected="selected">JD</option>
<option value="2">Turk</option>
<option value="3">Elliot</option>
<option value="4">Carla</option>
</select>
```
如果在标记 `<script>` 的开头添加对函数 `pick_user()` 的调用，负责初始化函数自身 `id` 和 `name` 变量。
```
function pick_user() {
const user_selector = document.getElementById("user_selector");
this.current_user_name = user_selector.options[user_selector.selectedIndex].text;
this.current_user_id = user_selector.options[user_selector.selectedIndex].value;
}
```
使用 `editorConfig.user.id` 和 `editorConfig.user.name` 来配置用户设置。将这些参数添加到文件编辑函数中的编辑器配置中。
```
function edit(filename) {
const filepath = 'files/' + filename;
if (editor) {
editor.destroyEditor()
}
editor = new DocsAPI.DocEditor("editor",
{
documentType: get_file_type(filepath),
document: {
url: "host_url" + '/' + filepath,
title: filename
},
editorConfig: {
mode: 'edit',
callbackUrl: "host_url" + '/callback' + '?filename=' + filename,
user: {
id: this.current_user_id,
name: this.current_user_name
}
}
});
}
```
使用这种方法，你可以将 ONLYOFFICE 编辑器集成到用 Python 编写的应用程序中，并获得用于在文档上进行协同工作的所有必要工具。有关更多集成示例（Java、Node.js、PHP、Ruby），请参考官方的 [API 文档](https://api.onlyoffice.com/editors/basic)。
---
via: <https://opensourceforu.com/2019/09/integrate-online-documents-editors-into-a-python-web-app-using-onlyoffice/>
作者：[Aashima Sharma](https://opensourceforu.com/author/aashima-sharma/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 Java 构建你自己的文本编辑器 | Seth Kenlon | https://opensource.com/article/20/12/write-your-own-text-editor | 有时候，除你自己外，没有人能制作你所梦想的工具。以下是如何开始构建你自己的文本编辑器。 | /data/attachment/album/202101/21/134710uzumn6ej36u7t79j.jpg.thumb.jpg | /data/attachment/album/202101/21/134710uzumn6ej36u7t79j.jpg | true | false | true | lujun9972 | robsean | wxy | false | [
"编辑器"
] | 软件开发 | {
"viewnum": 6354,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 有时候，除你自己外，没有人能制作你所梦想的工具。以下是如何开始构建你自己的文本编辑器。 | 2021-01-21T13:48:20 | 2021-01-21T13:48:20 | 13,038 | /article-13038-1.html |
>
> 有时候，除你自己外，没有人能制作你所梦想的工具。以下是如何开始构建你自己的文本编辑器。
>
>
>
有很多文本编辑器。有运行在终端中、运行在 GUI 中、运行在浏览器和浏览器引擎中的。有很多是还不错，有一些则是极好的。但是有时候，毫无疑问，最令人满意的就是你自己构建的编辑器。
毫无疑问：构建一个真正优秀的文本编辑器比表面上看上去要困难得多。但话说回来，建立一个基本的文本编辑器也不像你担心的那样难。事实上，大多数编程工具包已经为你准备好了文本编辑器的大部分组件。围绕文本编辑的组件，例如菜单条，文件选择对话框等等，是很容易落到实处。因此，虽然是中级的编程课程，但构建一个基本的文本编辑器是出乎意料的有趣和简明。你可能会发现自己渴望使用一个自己构造的工具，而且你使用得越多，你可能会有更多的灵感来增加它的功能，从而更多地学习你正在使用的编程语言。
为了使这个练习切合实际，最好选择一种具有令人满意的 GUI 工具箱的语言。有很多种选择，包括 Qt 、FLTK 或 GTK ，但是一定要先评审一下它的文档，以确保它有你所期待的功能。对于这篇文章来说，我使用 Java 以及其内置的 Swing 小部件集。如果你想使用一种不同的语言或者一种不同的工具集，这篇文章在如何帮你处理这种问题的方面也仍然是有用的。
不管你选择哪一种，在任何主要的工具箱中编写一个文本编辑器都是惊人的相似。如果你是 Java 新手，需要更多关于开始的信息，请先阅读我的 [猜谜游戏文章](https://opensource.com/article/20/12/learn-java) 。
### 工程设置
通常，我使用并推荐像 [Netbeans](https://opensource.com/article/20/12/netbeans) 或 Eclipse 这样的 IDE，但我发现，当学习一种新的语言时，手工做一些工作是很有帮助的，这样你就能更好地理解使用 IDE 时被隐藏起来的东西。在这篇文章中，我假设你正在使用文本编辑器和终端进行编程。
在开始前，为你自己的工程创建一个工程目录。在工程文件夹中，创建一个名称为 `src` 的目录来容纳你的源文件。
```
$ mkdir -p myTextEditor/src
$ cd myTextEditor
```
在你的 `src` 目录中创建一个名称为 `TextEdit.java` 的空白的文件：
```
$ touch src/TextEditor.java
```
在你最喜欢的文本编辑器中打开这个空白的文件（我的意思是除你自己编写之外的最喜欢的一款文本编辑器），然后准备好编码吧！
### 包和导入
为确保你的 Java 应用程序有一个唯一的标识符，你必须声明一个 `package` 名称。典型的格式是使用一个反向的域名，如果你真的有一个域名的话，这就特别容易了。如果你没有域名的话，你可以使用 `local` 作为最顶层。像 Java 和很多语言一样，行以分号结尾。
在命名你的 Java 的 `package` 后，你必须告诉 Java 编译器（`javac`）使用哪些库来构建你的代码。事实上，这通常是你边编写代码边添加的内容，因为你很少事先知道你自己所需要的库。然而，这里有一些库是显而易见的。例如，你知道这个文本编辑器是基于 Swing GUI 工具箱的，因此，导入 `javax.swing.JFrame` 和`javax.swing.UIManager` 和其它相关的特定库。
```
package com.example.textedit;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JTextArea;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.filechooser.FileSystemView;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
```
对于这个练习的目标，你可以提前预知你所需要的所有的库。在真实的生活中，不管你喜欢哪一种语言，你都将在研究如何解决一些问题的时候发现库，然后，你将它导入到你的代码中，并使用它。不需要担心 —— 如果你忘记包含一个库，你的编译器或解释器将警告你！
### 主窗口
这是一个单窗口应用程序，因此这个应用程序的主类是一个 `JFrame` ，其附带有一个捕捉菜单事件的 `ActionListener` 。在 Java 中，当你使用一个现有的小部件元素时，你可以使用你的代码“扩展”它。这个主窗口需要三个字段：窗口本身（一个 `JFrame` 的实例）、一个用于文件选择器返回值的标识符和文本编辑器本身（`JTextArea`）。
```
public final class TextEdit extends JFrame implements ActionListener {
private static JTextArea area;
private static JFrame frame;
private static int returnValue = 0;
```
令人惊奇的是，这数行代码完成了实现一个基本文本编辑器的 80% 的工作，因为 `JtextArea` 是 Java 的文本输入字段。剩下的 80 行代码大部分用于处理辅助功能，比如保存和打开文件。
### 构建一个菜单
`JMenuBar` 小部件被设计到 JFrame 的顶部，它为你提供你想要的很多菜单项。Java 不是一种 拖放式的编程语言，因此，对于你所添加的每一个菜单，你都还必须编写一个函数。为保持这个工程的可控性，我提供了四个函数：创建一个新的文件，打开一个现有的文件，保存文本到一个文件，和关闭应用程序。
在大多数流行的工具箱中，创建一个菜单的过程基本相同。首先，你创建菜单条本身，然后创建一个顶级菜单（例如 “File” ），再然后创建子菜单项（例如，“New”、“Save” 等）。
```
public TextEdit() { run(); }
public void run() {
frame = new JFrame("Text Edit");
// Set the look-and-feel (LNF) of the application
// Try to default to whatever the host system prefers
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
Logger.getLogger(TextEdit.class.getName()).log(Level.SEVERE, null, ex);
}
// Set attributes of the app window
area = new JTextArea();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(area);
frame.setSize(640, 480);
frame.setVisible(true);
// Build the menu
JMenuBar menu_main = new JMenuBar();
JMenu menu_file = new JMenu("File");
JMenuItem menuitem_new = new JMenuItem("New");
JMenuItem menuitem_open = new JMenuItem("Open");
JMenuItem menuitem_save = new JMenuItem("Save");
JMenuItem menuitem_quit = new JMenuItem("Quit");
menuitem_new.addActionListener(this);
menuitem_open.addActionListener(this);
menuitem_save.addActionListener(this);
menuitem_quit.addActionListener(this);
menu_main.add(menu_file);
menu_file.add(menuitem_new);
menu_file.add(menuitem_open);
menu_file.add(menuitem_save);
menu_file.add(menuitem_quit);
frame.setJMenuBar(menu_main);
}
```
现在，所有剩余的工作是实施菜单项所描述的功能。
### 编程菜单动作
你的应用程序响应菜单选择，是因为你的 `JFrame` 有一个附属于它的 `ActionListener` 。在 Java 中，当你实施一个事件处理程序时，你必须“重写”其内建的函数。这只是听起来可怕。你不是在重写 Java；你只是在实现已经被定义但尚未实施事件处理程序的函数。
在这种情况下，你必须重写 `actionPerformed`方法。因为在 “File” 菜单中的所有条目都与处理文件有关，所以在我的代码中很早就定义了一个 `JFileChooser` 。代码其它部分被划分到一个 `if` 语句的子语句中，这起来像接收到什么事件就相应地执行什么动作。每个子语句都与其它的子语句完全不同，因为每个项目都标示着一些完全唯一的东西。最相似的是 “Open” 和 “Save”，因为它们都使用 `JFileChooser` 选择文件系统中的一个位置来获取或放置数据。
“New” 菜单会在没有警告的情况下清理 JTextArea ，“Quit” 菜单会在没有警告的情况下关闭应用程序。这两个 “功能” 都是不安全的，因此你应该想对这段代码进行一点改善，这是一个很好的开始。在内容还没有被保存前，一个友好的警告是任何一个好的文本编辑器都必不可少的一个功能，但是在这里为了简单，这是未来的一个功能。
```
@Override
public void actionPerformed(ActionEvent e) {
String ingest = null;
JFileChooser jfc = new JFileChooser(FileSystemView.getFileSystemView().getHomeDirectory());
jfc.setDialogTitle("Choose destination.");
jfc.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
String ae = e.getActionCommand();
if (ae.equals("Open")) {
returnValue = jfc.showOpenDialog(null);
if (returnValue == JFileChooser.APPROVE_OPTION) {
File f = new File(jfc.getSelectedFile().getAbsolutePath());
try{
FileReader read = new FileReader(f);
Scanner scan = new Scanner(read);
while(scan.hasNextLine()){
String line = scan.nextLine() + "\n";
ingest = ingest + line;
}
area.setText(ingest);
}
catch ( FileNotFoundException ex) { ex.printStackTrace(); }
}
// 保存
} else if (ae.equals("Save")) {
returnValue = jfc.showSaveDialog(null);
try {
File f = new File(jfc.getSelectedFile().getAbsolutePath());
FileWriter out = new FileWriter(f);
out.write(area.getText());
out.close();
} catch (FileNotFoundException ex) {
Component f = null;
JOptionPane.showMessageDialog(f,"File not found.");
} catch (IOException ex) {
Component f = null;
JOptionPane.showMessageDialog(f,"Error.");
}
} else if (ae.equals("New")) {
area.setText("");
} else if (ae.equals("Quit")) { System.exit(0); }
}
}
```
从技术上来说，这就是这个文本编辑器的全部。当然，并没有真正做什么，除此之外，在这里仍然有测试和打包步骤，因此仍然有很多时间来发现缺少的必需品。假设你没有注意到提示：在这段代码中 *肯定* 缺少一些东西。你现在知道缺少的是什么吗？（在 [猜谜游戏文章](http://www.google.com/search?hl=en&q=allinurl%3Adocs.oracle.com+javase+docs+api+component) 中被大量的提到。）
### 测试
你现在可以测试你的应用程序。从终端中启动你所编写的文本编辑器：
```
$ java ./src/TextEdit.java
error: can’t find main(String[]) method in class: com.example.textedit.TextEdit
```
它看起来像在代码中没有获得 `main` 方法。这里有一些方法来修复这个问题：你可以在 `TextEdit.java` 中创建一个 `main` 方法，并让它运行一个 `TextEdit` 类实例，或者你可以创建一个单独的包含 `main` 方法的文件。两种方法都可以工作，但从大型工程的预期来看，使用后者更为明智，因此，使用单独的文件与其一起工作使之成为一个完整的应用程序的方法是值得使用的。
在 `src` 中创建一个 `Main.java` 文件，并在最喜欢的编辑器中打开：
```
package com.example.textedit;
public class Main {
public static void main(String[] args) {
TextEdit runner = new TextEdit();
}
}
```
你可以再次尝试，但是现在有两个相互依赖的文件要运行，因此你必须编译代码。Java 使用 `javac` 编译器，并且你可以使用 `-d` 选项来设置目标目录：
```
$ javac src/*java -d .
```
这会在你的软件包名称 `com/example/textedit` 后创建一个准确地模型化的新的目录结构。这个新的类路径包含文件 `Main.class` 和 `TextEdit.class` ，这两个文件构成了你的应用程序。你可以使用 `java` 并通过引用你的 Main 类的位置和 *名称*（非文件名称）来运行它们：
```
$ java info/slackermedia/textedit/Main`
```
你的文本编辑器打开了，你可以在其中输入文字，打开文件，甚至保存你的工作。
### 以 Java 软件包的形式分享你的工作
虽然一些程序员似乎看起来认可以各种各样的源文件的形式分发软件包，并鼓励其他人来学习如何运行它，但是，Java 让打包应用程序变得真地很容易，以至其他人可以很容易的运行它。你已经有了必备的大部分结构体，但是你仍然需要一些元数据到一个 `Manifest.txt` 文件中：
```
$ echo "Manifest-Version: 1.0" > Manifest.txt
```
用于打包的 `jar` 命令，与 [tar](https://opensource.com/article/17/7/how-unzip-targz-file) 命令非常相似，因此很多选项对你来说可能会很熟悉。要创建一个 JAR 文件：
```
$ jar cvfme TextEdit.jar
Manifest.txt
com.example.textedit.Main
com/example/textedit/*.class
```
根据命令的语法，你可以推测出它会创建一个新的名称为 `TextEdit.jar` 的 JAR 文件，它所需要的清单数据位于 `Manifest.txt` 中。它的主类被定义为软件包名称的一个扩展，并且类自身是 `com/example/textedit/Main.class` 。
你可以查看 JAR 文件的内容：
```
$ jar tvf TextEdit.jar
0 Wed Nov 25 META-INF/
105 Wed Nov 25 META-INF/MANIFEST.MF
338 Wed Nov 25 com/example/textedit/textedit/Main.class
4373 Wed Nov 25 com/example/textedit/textedit/TextEdit.class
```
如果你想看看你的元数据是如何被集成到 `MANIFEST.MF` 文件中的，你甚至可以使用 `xvf` 选项来提取它。
使用 `java` 命令来运行你的 JAR 文件：
```
$ java -jar TextEdit.jar
```
你甚至可以 [创建一个桌面文件](https://opensource.com/article/18/1/how-install-apps-linux) ，这样，在单击应用程序菜单中的图标时，应用程序就会启动。
### 改进它
在当前状态下，这是一个非常基本的文本编辑器，最适合做快速笔记或简短自述文档。一些改进（比如添加垂直滚动条）只要稍加研究就能快速简单地完成，而另一些改进（比如实现一个广泛的偏好系统）则需要真正的工作。
但如果你一直在想学一种新的语言，这可能是一个完美的自我学习实用工程。创建一个文本编辑器，如你所见，它在代码方面并不难对付，它在一定范围是可控的。如果你经常使用文本编辑器，那么编写你自己的文本编辑器可能会使你满意和乐趣。因此打开你最喜欢的文本编辑器（你写的那个），开始添加功能吧！
---
via: <https://opensource.com/article/20/12/write-your-own-text-editor>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[robsean](https://github.com/robsean) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
GCC：优化 Linux、互联网和一切 | Margaret Lewis | https://www.linux.com/blog/2018/10/gcc-optimizing-linux-internet-and-everything | 处理运行时性能的问题上，即使是最有才华的开发人员也会受编译器的支配 —— 因为如果没有可靠的编译器工具链，就无法构建任何重要的东西。 | /data/attachment/album/202101/22/122155ujfd62u6zbx3i4b3.jpg.thumb.jpg | /data/attachment/album/202101/22/122155ujfd62u6zbx3i4b3.jpg | true | false | true | lujun9972 | Chao-zhi | wxy | true | [
"gcc",
"编译器",
"GNU"
] | 观点 | {
"viewnum": 7556,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 处理运行时性能的问题上，即使是最有才华的开发人员也会受编译器的支配 —— 因为如果没有可靠的编译器工具链，就无法构建任何重要的东西。 | 2021-01-22T12:22:12 | 2021-01-22T12:22:12 | 13,040 | /article-13040-1.html | 
软件如果不能被电脑运行，那么它就是无用的。而在处理<ruby> 运行时 <rt> run-time </rt></ruby>性能的问题上，即使是最有才华的开发人员也会受编译器的支配 —— 因为如果没有可靠的编译器工具链，就无法构建任何重要的东西。<ruby> GNU 编译器集合 <rt> GNU Compiler Collection </rt></ruby>（GCC）提供了一个健壮、成熟和高性能的工具，以帮助你充分发挥你代码的潜能。经过数十年成千上万人的开发，GCC 成为了世界上最受尊敬的编译器之一。如果你在构建应用程序是没有使用 GCC，那么你可能错过了最佳解决方案。
根据 [LLVM.org](http://LLVM.org) 的说法，GCC 是“如今事实上的标准开源编译器” <sup class="footnote-ref"> <a href="#fn1" id="fnref1"> [1] </a></sup>，也是用来构建完整系统的基础 —— 从内核开始。GCC 支持超过 60 种硬件平台，包括 ARM、Intel、AMD、IBM POWER、SPARC、HP PA-RISC 和 IBM Z，以及各种操作环境，包括 GNU、Linux、Windows、macOS、FreeBSD、NetBSD、OpenBSD、DragonFly BSD、Solaris、AIX、HP-UX 和 RTEMS。它提供了高度兼容的 C/C++ 编译器，并支持流行的 C 库，如 GNU C Library（glibc）、Newlib、musl 和各种 BSD 操作系统中包含的 C 库，以及 Fortran、Ada 和 GO 语言的前端。GCC 还可以作为一个交叉编译器，可以为运行编译器的平台以外的其他平台创建可执行代码。GCC 是紧密集成的 GNU 工具链的核心组件，由 GNU 项目产生，它包括 glibc、Binutils 和 GNU 调试器（GDB）。
“一直以来我最喜欢的 GNU 工具是 GCC，即 <ruby> GNU 编译器集合 <rt> GNU Compiler Collection </rt></ruby>。在开发工具非常昂贵的时候，GCC 是第二个 GNU 工具，也是使社区能够编写和构建所有其他工具的工具。这个工具一手改变了这个行业，导致了自由软件运动的诞生，因为一个好的、自由的编译器是一个社区软件的先决条件。”—— Red Hat 开源和标准团队的 Dave Neary。<sup class="footnote-ref"> <a href="#fn2" id="fnref2"> [2] </a></sup>
### 优化 Linux
作为 Linux 内核源代码的默认编译器，GCC 提供了可靠、稳定的性能以及正确构建内核所需的额外扩展。GCC 是流行的 Linux 发行版的标准组件，如 ArchLinux、CentOS、Debian、Fedora、openSUSE 和 Ubuntu 这些发行版中，GCC 通常用来编译支持系统的组件。这包括 Linux 使用的默认库（如 libc、libm、libintl、libssh、libssl、libcrypto、libexpat、libpthread 和 ncurses），这些库依赖于 GCC 来提供可靠性和高性能，并且使应用程序和系统程序可以访问 Linux 内核功能。发行版中包含的许多应用程序包也是用 GCC 构建的，例如 Python、Perl、Ruby、nginx、Apache HTTP 服务器、OpenStack、Docker 和 OpenShift。各个 Linux 发行版使用 GCC 构建的大量代码组成了内核、库和应用程序软件。对于 openSUSE 发行版，几乎 100% 的原生代码都是由 GCC 构建的，包括 6135 个源程序包、5705 个共享库和 38927 个可执行文件。这相当于每周编译 24540 个源代码包。<sup class="footnote-ref"> <a href="#fn3" id="fnref3"> [3] </a></sup>
Linux 发行版中包含的 GCC 的基本版本用于创建定义系统<ruby> 应用程序二进制接口 <rt> Application Binary Interface </rt></ruby>（ABI）的内核和库。<ruby> 用户空间 <rt> User space </rt></ruby>开发者可以选择下载 GCC 的最新稳定版本，以获得高级功能、性能优化和可用性改进。Linux 发行版提供安装说明或预构建的工具链，用于部署最新版本的 GCC 以及其他 GNU 工具，这些工具有助于提高开发人员的工作效率和缩短部署时间。
### 优化互联网
GCC 是嵌入式系统中被广泛采用的核心编译器之一，支持为日益增长的物联网设备开发软件。GCC 提供了许多扩展功能，使其非常适合嵌入式系统软件开发，包括使用编译器的内建函数、#语法、内联汇编和以应用程序为中心的命令行选项进行精细控制。GCC 支持广泛的嵌入式体系结构，包括 ARM、AMCC、AVR、Blackfin、MIPS、RISC-V、Renesas Electronics V850、NXP 和 Freescale Power 处理器，可以生成高效、高质量的代码。GCC提供的交叉编译能力对这个社区至关重要，而预制的交叉编译工具链 <sup class="footnote-ref"> <a href="#fn4" id="fnref4"> [4] </a></sup> 是一个主要需求。例如，GNU ARM 嵌入式工具链是经过集成和验证的软件包，其中包含 ARM 嵌入式 GCC 编译器、库和其它裸机软件开发所需的工具。这些工具链可用于在 Windows、Linux 和 macOS 主机操作系统上对流行的 ARM Cortex-R 和 Cortex-M 处理器进行交叉编译，这些处理器已装载于数百亿台支持互联网的设备中。<sup class="footnote-ref"> <a href="#fn5" id="fnref5"> [5] </a></sup>
GCC 为云计算赋能，为需要直接管理计算资源的软件提供了可靠的开发平台，如数据库和 Web 服务引擎以及备份和安全软件。GCC 完全兼容 C++ 11 和 C++ 14，为 C++ 17 和 C++ 2a 提供实验支持 <sup class="footnote-ref"> <a href="#fn6" id="fnref6"> [6] </a></sup>（LCTT 译注：本文原文发布于 2018 年），可以创建性能优异的对象代码，并提供可靠的调试信息。使用 GCC 的应用程序的一些例子包括：MySQL 数据库管理系统，它需要 Linux 的 GCC <sup class="footnote-ref"> <a href="#fn7" id="fnref7"> [7] </a></sup>；Apache HTTP 服务器，它建议使用 GCC <sup class="footnote-ref"> <a href="#fn8" id="fnref8"> [8] </a></sup>；Bacula，一个企业级网络备份工具，它需要 GCC。<sup class="footnote-ref"> <a href="#fn9" id="fnref9"> [9] </a></sup>
### 优化一切
对于<ruby> 高性能计算 <rt> High Performance Computing </rt></ruby>（HPC）中使用的科学代码的研究和开发，GCC 提供了成熟的 C、C++ 和 Fortran 前端，以及对 OpenMP 和 OpenACC API的支持，用于基于指令的并行编程。因为 GCC 提供了跨计算环境的可移植性，它使得代码能够更容易地在各种新的和传统的客户机和服务器平台上进行测试。GCC 为 C、C++ 和 Fortran 编译器提供了 OpenMP 4.0 的完整支持，为 C 和 C++ 编译器提供了 OpenMP 4.5 完整支持。对于 OpenACC、 GCC 支持大部分 2.5 规范和性能优化，并且是唯一提供 [OpenACC](https://www.openacc.org/tools) 支持的非商业、非学术编译器。
代码性能是这个社区的一个重要参数，GCC 提供了一个坚实的性能基础。Colfax Research 于 2017 年 11 月发表的一篇论文评估了 C++ 编译器在使用 OpenMP 4.x 指令并行化编译代码的速度和编译后代码的运行速度。图 1 描绘了不同编译器编译并使用单个线程运行时计算内核的相对性能。性能值经过了归一化处理，以 G++ 的性能为 1.0。
*图 1 为由不同编译器编译的每个内核的相对性能。（单线程，越高越好）。*
他的论文总结道：“GNU 编译器在我们的测试中也做得很好。G++ 在六种情况中的三种情况下生成的代码速度是第二快的，并且在编译时间方面是最快的编译器之一。”<sup class="footnote-ref"> <a href="#fn10" id="fnref10"> [10] </a></sup>
### 谁在用 GCC?
在 JetBrains 2018 年的开发者生态状况调查中，在接受调查的 6000 名开发者中，66% 的 C++ 程序员和 73% 的 C 程序员经常使用 GCC。<sup class="footnote-ref"> <a href="#fn11" id="fnref11"> [11] </a></sup> 以下简要介绍 GCC 的优点，正是这些优点使它在开发人员社区中如此受欢迎。
* 对于需要为各种新的和遗留的计算平台和操作环境编写代码的开发人员，GCC 提供了对最广泛的硬件和操作环境的支持。硬件供应商提供的编译器主要侧重于对其产品的支持，而其他开源编译器在所支持的硬件和操作系统方面则受到很大限制。<sup class="footnote-ref"> <a href="#fn12" id="fnref12"> [12] </a></sup>
* 有各种各样的基于 GCC 的预构建工具链，这对嵌入式系统开发人员特别有吸引力。这包括 GNU ARM 嵌入式工具链和 Bootlin 网站上提供的 138 个预编译交叉编译器工具链。<sup class="footnote-ref"> <a href="#fn13" id="fnref13"> [13] </a></sup> 虽然其他开源编译器（如 Clang/LLVM）可以取代现有交叉编译工具链中的 GCC，但这些工具集需要开发者完全重新构建。<sup class="footnote-ref"> <a href="#fn14" id="fnref14"> [14] </a></sup>
* GCC 通过成熟的编译器平台向应用程序开发人员提供可靠、稳定的性能。《在 AMD EPYC 平台上用 GCC 8/9 与 LLVM Clang 6/7 编译器基准测试》这篇文章提供了 49 个基准测试的结果，这些测试的编译器在三个优化级别上运行。使用 `-O3 -march=native` 级别的 GCC 8.2 RC1 在 34% 的时间里排在第一位，而在相同的优化级别 LLVM Clang 6.0 在 20% 的时间里赢得了第二位。<sup class="footnote-ref"> <a href="#fn15" id="fnref15"> [15] </a></sup>
* GCC 为编译调试 <sup class="footnote-ref"> <a href="#fn16" id="fnref16"> [16] </a></sup> 提供了改进的诊断方法，并为运行时调试提供了准确而有用的信息。GCC 与 GDB 紧密集成，GDB 是一个成熟且功能齐全的工具，它提供“不间断”调试，可以在断点处停止单个线程。
* GCC 是一个得到良好支持的平台，它有一个活跃的、有责任感的社区，支持当前版本和以前的两个版本。由于每年都有发布计划，这为一个版本提供了两年的支持。
### GCC：仍然在继续优化
GCC 作为一个世界级的编译器继续向前发展。GCC 的最新版本是 8.2，于 2018 年 7 月发布（LCTT 译注：本文原文发表于 2018 年），增加了对即将推出的 Intel CPU、更多 ARM CPU 的硬件支持，并提高了 AMD 的 ZEN CPU 的性能。增加了对 C17 的初步支持，同时也对 C++2A 进行了初步工作。诊断功能继续得到增强，包括更好的发射诊断，改进了定位、定位范围和修复提示，特别是在 C++ 前端。Red Hat 的 David Malcolm 在 2018 年 3 月撰写的博客概述了 GCC 8 中的可用性改进。<sup class="footnote-ref"> <a href="#fn17" id="fnref17"> [17] </a></sup>
新的硬件平台继续依赖 GCC 工具链进行软件开发，例如 RISC-V，这是一种自由开放的 ISA，机器学习、人工智能（AI）和物联网细分市场都对其感兴趣。GCC 仍然是 Linux 系统持续开发的关键组件。针对 Intel 架构的 Clear Linux 项目是一个为云、客户端和物联网用例构建的新兴发行版，它提供了一个很好的示例，说明如何使用和改进 GCC 编译器技术来提高基于 Linux 的系统的性能和安全性。GCC 还被用于微软 Azure Sphere 的应用程序开发，这是一个基于 Linux 的物联网应用程序操作系统，最初支持基于 ARM 的联发科 MT3620 处理器。在培养下一代程序员方面，GCC 也是树莓派的 Windows 工具链的核心组件，树莓派是一种运行基于 Debian 的 GNU/Linux 的低成本嵌入式板，用于促进学校和发展中国家的基础计算机科学教学。
GCC 由 GNU 项目的创始人<ruby> 理查德•斯托曼 <rt> Richard Stallman </rt></ruby>首次发布 于 1987 年 3 月 22 日，由于它是第一个作为自由软件发布的可移植的 ANSI C 优化编译器，因此它被认为是一个重大突破。GCC 由来自世界各地的程序员组成的社区在指导委员会的指导下维护，以确保对项目进行广泛的、有代表性的监督。GCC 的社区方法是它的优势之一，它形成了一个由开发人员和用户组成的庞大而多样化的社区，他们为项目做出了贡献并提供支持。根据 Open Hub 的说法，“GCC 是世界上最大的开源团队之一，在 Open Hub 上的所有项目团队中排名前 2%。”<sup class="footnote-ref"> <a href="#fn18" id="fnref18"> [18] </a></sup>
关于 GCC 的许可问题，人们进行了大量的讨论，其中大多数是混淆而不是启发。GCC 在 GNU 通用公共许可证（GPL）版本 3 或更高版本下发布，但运行时库例外。这是一个左版许可，这意味着衍生作品只能在相同的许可条款下分发。GPLv3 旨在保护 GCC，防止其成为专有软件，并要求对 GCC 代码的更改可以自由公开地进行。对于“最终用户”来说，这个编译器与其他编译器完全相同；使用 GCC 对你为自己的代码所选择的任何许可都没有区别。<sup class="footnote-ref"> <a href="#fn19" id="fnref19"> [19] </a></sup>
---
1. <http://clang.llvm.org/features.html#gcccompat> [↩︎](#fnref1)
2. <https://opensource.com/article/18/9/happy-birthday-gnu> [↩︎](#fnref2)
3. 由 SUSE 基于最近的构建统计提供的信息。在 openSUSE 中还有其他不生成可执行镜像的源码包，这些不包括在统计中。 [↩︎](#fnref3)
4. <https://community.arm.com/tools/b/blog/posts/gnu-toolchain-performance-in-2018> [↩︎](#fnref4)
5. <https://www.arm.com/products/processors/cortex-m> [↩︎](#fnref5)
6. <https://gcc.gnu.org/projects/cxx-status.html#cxx17> [↩︎](#fnref6)
7. <https://mysqlserverteam.com/mysql-8-0-source-code-improvements/> [↩︎](#fnref7)
8. <http://httpd.apache.org/docs/2.4/install.html> [↩︎](#fnref8)
9. <https://blog.bacula.org/what-is-bacula/system-requirements/> [↩︎](#fnref9)
10. <https://colfaxresearch.com/compiler-comparison/> [↩︎](#fnref10)
11. <https://www.jetbrains.com/research/devecosystem-2018/> [↩︎](#fnref11)
12. <http://releases.llvm.org/6.0.0/tools/clang/docs/UsersManual.html> [↩︎](#fnref12)
13. <https://bootlin.com/blog/free-and-ready-to-use-cross-compilation-toolchains/> [↩︎](#fnref13)
14. <https://clang.llvm.org/docs/Toolchain.html> [↩︎](#fnref14)
15. <https://www.phoronix.com/scan.php?page=article&item=gcclang-epyc-summer18&num=1> [↩︎](#fnref15)
16. <https://gcc.gnu.org/wiki/ClangDiagnosticsComparison> [↩︎](#fnref16)
17. <https://developers.redhat.com/blog/2018/03/15/gcc-8-usability-improvements/> [↩︎](#fnref17)
18. <https://www.openhub.net/p/gcc/factoids#FactoidTeamSizeVeryLarge> [↩︎](#fnref18)
19. <https://www.gnu.org/licenses/gcc-exception-3.1-faq.en.html> [↩︎](#fnref19)
---
via: <https://www.linux.com/blog/2018/10/gcc-optimizing-linux-internet-and-everything>
作者：[Margaret Lewis](https://www.linux.com/users/margaret-lewis) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Chao-zhi](https://github.com/Chao-zhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 Ubuntu 中安装 Apache、MySQL、PHP（LAMP）套件 | Sk | https://www.ostechnix.com/install-apache-mysql-php-lamp-stack-on-ubuntu-18-04-lts/ | LAMP 套件是一种流行的开源 Web 开发平台，可用于运行和部署动态网站和基于 Web 的应用程序。 | /data/attachment/album/202101/22/130445q11slzlkei4okeet.jpg.thumb.jpg | /data/attachment/album/202101/22/130445q11slzlkei4okeet.jpg | true | false | true | lujun9972 | stevenzdg988 | wxy | false | [
"LAMP"
] | 技术 | {
"viewnum": 9714,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | LAMP 套件是一种流行的开源 Web 开发平台，可用于运行和部署动态网站和基于 Web 的应用程序。 | 2021-01-22T13:04:44 | 2021-01-22T13:04:44 | 13,041 | /article-13041-1.html | 
**LAMP** 套件是一种流行的开源 Web 开发平台，可用于运行和部署动态网站和基于 Web 的应用程序。通常，LAMP 套件由 Apache Web 服务器、MariaDB/MySQL 数据库、PHP/Python/Perl 程序设计（脚本）语言组成。 LAMP 是 **L**inux，**M**ariaDB/**M**YSQL，**P**HP/**P**ython/**P**erl 的缩写。 本教程描述了如何在 Ubuntu 18.04 LTS 服务器中安装 Apache、MySQL、PHP（LAMP 套件）。
就本教程而言，我们将使用以下 Ubuntu 测试。
* **操作系统**：Ubuntu 18.04.1 LTS Server Edition
* **IP 地址** ：192.168.225.22/24
### 1. 安装 Apache Web 服务器
首先，利用下面命令更新 Ubuntu 服务器：
```
$ sudo apt update
$ sudo apt upgrade
```
然后，安装 Apache Web 服务器（命令如下）：
```
$ sudo apt install apache2
```
检查 Apache Web 服务器是否已经运行：
```
$ sudo systemctl status apache2
```
输出结果大概是这样的：
```
● apache2.service - The Apache HTTP Server
Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor preset: en
Drop-In: /lib/systemd/system/apache2.service.d
└─apache2-systemd.conf
Active: active (running) since Tue 2019-02-05 10:48:03 UTC; 1min 5s ago
Main PID: 2025 (apache2)
Tasks: 55 (limit: 2320)
CGroup: /system.slice/apache2.service
├─2025 /usr/sbin/apache2 -k start
├─2027 /usr/sbin/apache2 -k start
└─2028 /usr/sbin/apache2 -k start
Feb 05 10:48:02 ubuntuserver systemd[1]: Starting The Apache HTTP Server...
Feb 05 10:48:03 ubuntuserver apachectl[2003]: AH00558: apache2: Could not reliably
Feb 05 10:48:03 ubuntuserver systemd[1]: Started The Apache HTTP Server.
```
祝贺你！ Apache 服务已经启动并运行了！！
#### 1.1 调整防火墙允许 Apache Web 服务器
默认情况下，如果你已在 Ubuntu 中启用 UFW 防火墙，则无法从远程系统访问 Apache Web 服务器。 必须按照以下步骤开启 `http` 和 `https` 端口。
首先，使用以下命令列出 Ubuntu 系统上可用的应用程序配置文件：
```
$ sudo ufw app list
```
输出结果：
```
Available applications:
Apache
Apache Full
Apache Secure
OpenSSH
```
如你所见，Apache 和 OpenSSH 应用程序已安装 UFW 配置文件。你可以使用 `ufw app info "Profile Name"` 命令列出有关每个配置文件及其包含的规则的信息。
让我们研究一下 “Apache Full” 配置文件。 为此，请运行：
```
$ sudo ufw app info "Apache Full"
```
输出结果：
```
Profile: Apache Full
Title: Web Server (HTTP,HTTPS)
Description: Apache v2 is the next generation of the omnipresent Apache web
server.
Ports:
80,443/tcp
```
如你所见，“Apache Full” 配置文件包含了启用经由端口 **80** 和 **443** 的传输规则：
现在，运行以下命令配置允许 HTTP 和 HTTPS 传入通信：
```
$ sudo ufw allow in "Apache Full"
Rules updated
Rules updated (v6)
```
如果你不想允许 HTTP 通信，而只允许 HTTP（80） 通信，请运行：
```
$ sudo ufw app info "Apache"
```
#### 1.2 测试 Apache Web 服务器
现在，打开 Web 浏览器并导航到 <http://localhost/> 或 <http://IP-Address/> 来访问 Apache 测试页。
如果看到上面类似的显示内容，那就成功了。 Apache 服务器正在工作！
### 2. 安装 MySQL
在 Ubuntu 安装 MySQL 请运行：
```
$ sudo apt install mysql-server
```
使用以下命令验证 MySQL 服务是否正在运行：
```
$ sudo systemctl status mysql
```
输出结果：
```
● mysql.service - MySQL Community Server
Loaded: loaded (/lib/systemd/system/mysql.service; enabled; vendor preset: enab
Active: active (running) since Tue 2019-02-05 11:07:50 UTC; 17s ago
Main PID: 3423 (mysqld)
Tasks: 27 (limit: 2320)
CGroup: /system.slice/mysql.service
└─3423 /usr/sbin/mysqld --daemonize --pid-file=/run/mysqld/mysqld.pid
Feb 05 11:07:49 ubuntuserver systemd[1]: Starting MySQL Community Server...
Feb 05 11:07:50 ubuntuserver systemd[1]: Started MySQL Community Server.
```
MySQL 正在运行！
#### 2.1 配置数据库管理用户（root）密码
默认情况下，MySQL root 用户密码为空。你需要通过运行以下脚本使你的 MySQL 服务器安全：
```
$ sudo mysql_secure_installation
```
系统将询问你是否要安装 “VALIDATE PASSWORD plugin（密码验证插件）”。该插件允许用户为数据库配置强密码凭据。如果启用，它将自动检查密码的强度并强制用户设置足够安全的密码。**禁用此插件是安全的**。但是，必须为数据库使用唯一的强密码凭据。如果不想启用此插件，只需按任意键即可跳过密码验证部分，然后继续其余步骤。
如果回答是 `y`，则会要求你选择密码验证级别。
```
Securing the MySQL server deployment.
Connecting to MySQL using a blank password.
VALIDATE PASSWORD PLUGIN can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD plugin?
Press y|Y for Yes, any other key for No y
```
可用的密码验证有 “low（低）”、 “medium（中）” 和 “strong（强）”。只需输入适当的数字（0 表示低，1 表示中，2 表示强密码）并按回车键。
```
There are three levels of password validation policy:
LOW Length >= 8
MEDIUM Length >= 8, numeric, mixed case, and special characters
STRONG Length >= 8, numeric, mixed case, special characters and dictionary file
Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG:
```
现在，输入 MySQL root 用户的密码。请注意，必须根据上一步中选择的密码策略，为 MySQL root 用户使用密码。如果你未启用该插件，则只需使用你选择的任意强度且唯一的密码即可。
```
Please set the password for root here.
New password:
Re-enter new password:
Estimated strength of the password: 50
Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : y
```
两次输入密码后，你将看到密码强度（在此示例情况下为 50）。如果你确定可以，请按 `y` 继续提供的密码。如果对密码长度不满意，请按其他任意键并设置一个强密码。我现在的密码可以，所以我选择了`y`。
对于其余的问题，只需键入 `y` 并按回车键。这将删除匿名用户、禁止 root 用户远程登录并删除 `test`（测试）数据库。
```
Remove anonymous users? (Press y|Y for Yes, any other key for No) : y
Success.
Normally, root should only be allowed to connect from
'localhost'. This ensures that someone cannot guess at
the root password from the network.
Disallow root login remotely? (Press y|Y for Yes, any other key for No) : y
Success.
By default, MySQL comes with a database named 'test' that
anyone can access. This is also intended only for testing,
and should be removed before moving into a production
environment.
Remove test database and access to it? (Press y|Y for Yes, any other key for No) : y
- Dropping test database...
Success.
- Removing privileges on test database...
Success.
Reloading the privilege tables will ensure that all changes
made so far will take effect immediately.
Reload privilege tables now? (Press y|Y for Yes, any other key for No) : y
Success.
All done!
```
以上就是为 MySQL root 用户设置密码。
#### 2.2 更改 MySQL 超级用户的身份验证方法
默认情况下，Ubuntu 系统的 MySQL root 用户为 MySQL 5.7 版本及更新的版本使用插件 `auth_socket` 设置身份验证。尽管它增强了安全性，但是当你使用任何外部程序（例如 phpMyAdmin）访问数据库服务器时，也会变得更困难。要解决此问题，你需要将身份验证方法从 `auth_socket` 更改为 `mysql_native_password`。为此，请使用以下命令登录到你的 MySQL 提示符下：
```
$ sudo mysql
```
在 MySQL 提示符下运行以下命令，找到所有 MySQL 当前用户帐户的身份验证方法：
```
SELECT user,authentication_string,plugin,host FROM mysql.user;
```
输出结果：
```
+------------------|-------------------------------------------|-----------------------|-----------+
| user | authentication_string | plugin | host |
+------------------|-------------------------------------------|-----------------------|-----------+
| root | | auth_socket | localhost |
| mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost |
| mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost |
| debian-sys-maint | *F126737722832701DD3979741508F05FA71E5BA0 | mysql_native_password | localhost |
+------------------|-------------------------------------------|-----------------------|-----------+
4 rows in set (0.00 sec)
```
如你所见，Mysql root 用户使用 `auth_socket` 插件进行身份验证。
要将此身份验证更改为 `mysql_native_password` 方法，请在 MySQL 提示符下运行以下命令。 别忘了用你选择的强大唯一的密码替换 `password`。 如果已启用 VALIDATION 插件，请确保已根据当前策略要求使用了强密码。
```
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';
```
使用以下命令更新数据库：
```
FLUSH PRIVILEGES;
```
使用命令再次检查身份验证方法是否已更改：
```
SELECT user,authentication_string,plugin,host FROM mysql.user;
```
输出结果：
好！MySQL root 用户就可以使用密码进行身份验证来访问 `mysql shell`。
从 MySQL 提示符下退出：
```
exit
```
### 3. 安装 PHP
安装 PHP 请运行：
```
$ sudo apt install php libapache2-mod-php php-mysql
```
安装 PHP 后，在 Apache 文档根目录中创建 `info.php` 文件。通常，在大多数基于 Debian 的 Linux 发行版中，Apache 文档根目录为 `/var/www/html/` 或 `/var/www/`。Ubuntu 18.04 LTS 系统下，文档根目录是 `/var/www/html/`。
在 Apache 根目录中创建 `info.php` 文件：
```
$ sudo vi /var/www/html/info.php
```
在此文件中编辑如下内容：
```
<?php
phpinfo();
?>
```
然后按下 `ESC` 键并且输入 `:wq` 保存并退出此文件。重新启动 Apache 服务使更改生效。
```
$ sudo systemctl restart apache2
```
#### 3.1 测试 PHP
打开 Web 浏览器，然后导航到 URL [http://IP地址/info.php](http://xn--IP-im8ckc/info.php)。
你就将看到 PHP 测试页面。
通常，当用户向 Web 服务器发出请求时，Apache 首先会在文档根目录中查找名为 `index.html` 的文件。如果你想将 Apache 更改为 `php` 文件提供服务而不是其他文件，请将 `dir.conf` 配置文件中的 `index.php` 移至第一个位置，如下所示：
```
$ sudo vi /etc/apache2/mods-enabled/dir.conf
```
上面的配置文件（`dir.conf`） 内容如下：
```
<IfModule mod_dir.c>
DirectoryIndex index.html index.cgi index.pl index.php index.xhtml index.htm
</IfModule>
# vim: syntax=apache ts=4 sw=4 sts=4 sr noet
```
将 `index.php` 移动到最前面。更改后，`dir.conf` 文件内容看起来如下所示。
```
<IfModule mod_dir.c>
DirectoryIndex index.php index.html index.cgi index.pl index.xhtml index.htm
</IfModule>
# vim: syntax=apache ts=4 sw=4 sts=4 sr noet
```
然后按下 `ESC` 键并且输入 `:wq` 保存并关闭此文件。重新启动 Apache 服务使更改生效。
```
$ sudo systemctl restart apache2
```
#### 3.2 安装 PHP 模块
为了增加 PHP 的功能，可以安装一些其他的 PHP 模块。
要列出可用的 PHP 模块，请运行：
```
$ sudo apt-cache search php- | less
```
输出结果：
使用方向键浏览结果。要退出，请输入 `q` 并按下回车键。
要查找任意 `php` 模块的详细信息，例如 `php-gd`，请运行：
```
$ sudo apt-cache show php-gd
```
安装 PHP 模块请运行：
```
$ sudo apt install php-gd
```
安装所有的模块（虽然没有必要），请运行：
```
$ sudo apt-get install php*
```
安装任何 `php` 模块后，请不要忘记重新启动 Apache 服务。要检查模块是否已加载，请在浏览器中打开 `info.php` 文件并检查是否存在。
接下来，你可能需要安装数据库管理工具，以通过 Web 浏览器轻松管理数据库。如果是这样，请按照以下链接中的说明安装 `phpMyAdmin`。
祝贺你！我们已经在 Ubuntu 服务器中成功配置了 LAMP 套件。
---
via: <https://www.ostechnix.com/install-apache-mysql-php-lamp-stack-on-ubuntu-18-04-lts/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Btrfs 和 LVM-ext4 该如何选择？ | Troy Curtis Jr | https://fedoramagazine.org/choose-between-btrfs-and-lvm-ext4/ | 本指南旨在探索各自的高级特性，使得更容易在 Btrfs 和 LVM-ext4 之间进行选择。 | /data/attachment/album/202101/23/133137m2wfkiq8ykyvwyhv.jpg.thumb.jpg | /data/attachment/album/202101/23/133137m2wfkiq8ykyvwyhv.jpg | true | false | true | lujun9972 | Chao-zhi | wxy | false | [
"LVM",
"ext4",
"Btrfs"
] | 技术 | {
"viewnum": 7811,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "113.74.41.11",
"message": "亲测目前，Linux下使用btrfs且使用比如zstd的压缩的情况下，vbox虚拟机会一直不断的不定时突然死机",
"username": "来自广东珠海的 Chrome 88.0|Windows 10 用户",
"date": "2021-01-27T09:36:50"
},
{
"postip": "113.200.85.247",
"message": "btrfs被Oracle割韭菜了可咋整？还是比较信gpl一点点",
"username": "来自陕西西安的 Chrome Mobile 91.0|Android 10 用户",
"date": "2021-08-19T21:13:37"
}
] | [] | 本指南旨在探索各自的高级特性，使得更容易在 Btrfs 和 LVM-ext4 之间进行选择。 | 2021-01-23T13:31:51 | 2021-01-23T13:31:51 | 13,043 | /article-13043-1.html | 
[Fedora 33](https://fedoramagazine.org/announcing-fedora-33/) 在其各类桌面版本中引入了新的默认文件系统 [Btrfs](https://btrfs.wiki.kernel.org/index.php/Main_Page)。多年以来，Fedora 一直在 <ruby> <a href="https://man7.org/linux/man-pages/man8/lvm.8.html"> 逻辑卷管理 </a> <rt> Logical Volume Manager </rt></ruby>（LVM） 卷之上使用 [ext4](https://ext4.wiki.kernel.org/index.php/Main_Page)，引入 Brtfs 对 Fedora 来说是一个很大的转变。更改默认文件系统需要 [令人信服的原因](https://fedoraproject.org/wiki/Changes/BtrfsByDefault)。虽然 Btrfs 是令人兴奋的下一代文件系统，但 LVM 上的 ext4 是成熟而稳定的。本指南旨在探索各自的高级特性，使得更容易在 Btrfs 和 LVM-ext4 之间进行选择。
### 先说结论
最简单的建议是坚持使用默认值。全新安装的 Fedora 33 环境默认为 Btrfs，升级之前的 Fedora 版本将继续使用最初安装的设置，通常是 LVM-ext4。对于现有的 Fedora 用户来说，获取 Btrfs 的最简单方式是全新安装。然而，全新安装比简单升级更具破坏性。除非有特殊需要，否则这种干扰可能是不必要的。Fedora 开发团队仔细考虑了这两个默认值，因此对任何一个选择都要有信心。
### 那么其他文件系统呢？
现在有很多 [Linux 系统的文件系统](https://man7.org/linux/man-pages/man5/filesystems.5.html)。在加上卷管理器、加密方法和存储机制的组合后，这一数字呈爆炸式增长。那么，为什么要关注 btrfs 和 LVM-ext4 呢？对于 Fedora 的用户来说，这两种设置可能是最常见的。在 Fedora 11 中，LVM 之上的 ext4 成为了默认磁盘布局，在此之前则使用的是 ext3。
既然 Btrfs 是 Fedora 33 的默认设置，那么绝大多数现有用户会考虑是应该原地踏步还是向前跳跃。面对全新安装的 Fedora 33 环境，有经验的 Linux 用户可能会想知道是使用这个新的文件系统，还是退回到他们熟悉的文件系统。因此，在众多可能的存储选项中，许多 Fedora 用户会想知道如何在 Btrfs 和 LVM-ext4 之间进行选择。
### 两者的共性
尽管两个文件系统之间存在核心差异，但 Btrfs 和 LVM-ext4 实际上有很多共同之处。两者都是成熟且经过充分测试的存储技术。从 Fedora Core 的早期开始，就一直在使用 LVM，而 ext4 在 [2009 年成为 Fedora 11 的默认设置](https://docs.fedoraproject.org/en-US/Fedora/11/html/Release_Notes/index.html#sect-Release_Notes-Fedora_11_Overview)。Btrfs 在 2009 年并入 Linux 主线内核，并且 [Facebook 广泛使用了该文件系统](https://facebookmicrosites.github.io/btrfs/docs/btrfs-facebook.html)。SUSE Linux Enterprise 12 [在 2014 年使其成为默认文件系统](https://www.suse.com/releasenotes/x86_64/SUSE-SLES/12/#fate-317221)。因此，它在生产环境中也有着长久的运行时间。
这两个系统都能很好地防止因意外停电而导致的文件系统损坏，尽管它们的实现方式不同。它们支持的配置包括使用单盘设置和跨越多个设备，并且这两种配置都能够创建近乎即时的快照。有各种工具可以帮助管理这两种系统，包括命令行和图形界面。这两种解决方案在家用台式机和高端服务器上都同样有效。
### LVM-ext4 的优势
[ext4 文件系统](https://opensource.com/article/18/4/ext4-filesystem) 专注于高性能和可伸缩性，没有太多额外的花哨之处。它能有效地防止长时间后的碎片化，并当碎片化出现后提供了 [很好的工具](https://man7.org/linux/man-pages/man8/e4defrag.8.html)。ext4 之所以坚如磐石，是因为它构建在前代的 ext3 文件系统之上，带来了多年的系统内测试和错误修复。
LVM-ext4 环境中的大多数高级功能都来自 LVM 本身。LVM 位于文件系统的“下方”，这意味着它支持任何文件系统。<ruby> 逻辑卷 <rt> Logical volume </rt></ruby>（LV）是通用的块设备，因此 [虚拟机可以直接使用它们](https://libvirt.org/storage.html#StorageBackendLogical)。这种灵活性使得每个逻辑卷都可以使用合适的文件系统，用合适的选项应对各种情况。这种分层方法还遵循了“小工具协同工作”的 Unix 哲学。
从硬件抽象出来的<ruby> <a href="https://www.redhat.com/sysadmin/create-volume-group"> 卷组 </a> <rt> volume group </rt></ruby>（VG）允许 LVM 创建灵活的逻辑卷。每个逻辑卷都提取自同一个存储池，但具有自己的设置。调整卷的大小比调整物理分区的大小容易得多，因为没有数据有序放置的限制。LVM <ruby> <a href="https://www.redhat.com/sysadmin/create-physical-volume"> 物理卷 </a> <rt> physical volume </rt></ruby>（PV）可以是任意数量的分区，甚至可以在系统运行时在设备之间移动。
LVM 支持只读和读写的 [快照](https://tldp.org/HOWTO/LVM-HOWTO/snapshotintro.html)，这使得从活动系统创建一致的备份变得很容易。每个快照都有一个定义的大小，更改源卷或快照卷将占用其中的空间。又或者，逻辑卷也可以是<ruby> <a href="https://man7.org/linux/man-pages/man7/lvmthin.7.html"> 稀疏配置池 </a> <rt> thinly provisioned pool </rt></ruby>的一部分。这允许快照自动使用池中的数据，而不是使用在创建卷时定义的固定大小的块。
#### 有多个磁盘驱动器的 LVM
当有多个设备时，LVM 才真正大放异彩。它原生支持大多数 [RAID 级别](https://rhea.dev/articles/2018-08/LVM-RAID-on-Fedora)，每个逻辑卷可以具有不同的 RAID 级别。LVM 将自动为 RAID 配置选择适当的物理设备，或者用户可以直接指定它。基本的 RAID 支持包括用于性能的数据条带化（[RAID0](https://en.wikipedia.org/wiki/Standard_RAID_levels#RAID_0)）和用于冗余的镜像（[RAID1](https://en.wikipedia.org/wiki/Standard_RAID_levels#RAID_1)）。逻辑卷也可以使用 [RAID5](https://en.wikipedia.org/wiki/Standard_RAID_levels#RAID_5)、[RAID6](https://en.wikipedia.org/wiki/Standard_RAID_levels#RAID_6) 和 [RAID10](https://en.wikipedia.org/wiki/Non-standard_RAID_levels#Linux_MD_RAID_10) 等高级设置。LVM RAID 支持已经成熟，因为 LVM 在底层使用的 [设备映射器（dm）](https://man7.org/linux/man-pages/man8/dmsetup.8.html) 和 [多设备（md）](https://man7.org/linux/man-pages/man4/md.4.html) 内核支持， 与 [mdadm](https://fedoramagazine.org/managing-raid-arrays-with-mdadm/) 使用的一样。
对于具有快速和慢速驱动器的系统，逻辑卷也可以是 [缓存卷](https://man7.org/linux/man-pages/man7/lvmcache.7.html)。经典示例是 SSD 和传统磁盘驱动器的组合。缓存卷使用较快的驱动器来存储更频繁访问的数据（或用作写缓存），而慢速的驱动器则用于处理大量数据。
LVM 中大量稳定的功能以及 ext4 的可靠性在既往的使用中早已被证明了。当然，功能越多就越复杂。在配置 LVM 时，要找到合适的功能选项是很有挑战性的。对于单驱动器的台式机系统，LVM 的功能（例如 RAID 和缓存卷）不适用。但是，逻辑卷比物理分区更灵活，快照也很有用。对于正常的桌面使用，LVM 的复杂性会成为典型的用户可能遇到的问题恢复的障碍。
### Btrfs 的优势
从前几代文件系统中学到的经验指导了构建到 [Btrfs](https://btrfs.wiki.kernel.org/index.php/Main_Page) 的功能设计。与 ext4 不同，它可以直接跨越多个设备，因此它具有通常仅在卷管理器中才能找到的功能。它还具有 Linux 文件系统空间中独有的功能（[ZFS](https://en.wikipedia.org/wiki/ZFS) 具有相似的功能集，但[不要指望它在 Linux 内核中出现](https://itsfoss.com/linus-torvalds-zfs/)）。
#### Btrfs 的主要功能
也许最重要的功能是对所有数据进行<ruby> 校验和 <rt> checksumming </rt></ruby>。校验和与<ruby> <a href="https://en.wikipedia.org/wiki/Copy-on-write"> 写时复制 </a> <rt> copy-on-write </rt></ruby>（COW）一起，提供了在意外断电后确保文件系统完整性的 [关键方法](https://btrfs.wiki.kernel.org/index.php/FAQ#Can_I_have_nodatacow_.28or_chattr_.2BC.29_but_still_have_checksumming.3F)。更独特的是，校验和可以检测数据本身中的错误。悄然的数据损坏（有时也称为 [bitrot](https://arstechnica.com/information-technology/2014/01/bitrot-and-atomic-cows-inside-next-gen-filesystems/)）比大多数人意识到的更常见。如果没有主动验证，损坏最终可能会传播到所有可用的备份中。这使得用户没有有效的副本。通过透明地校验所有数据，Btrfs 能够立即检测到任何此类损坏。启用正确的 [dup 或 raid 选项](https://man7.org/linux/man-pages/man8/mkfs.btrfs.8.html#DUP_PROFILES_ON_A_SINGLE_DEVICE)，文件系统也可以透明地修复损坏。
写时复制也是 Btrfs 的基本功能，因为它在提供文件系统完整性和即时子卷快照方面至关重要。从公共子卷创建快照后，快照会自动共享底层数据。另外，事后的<ruby> <a href="https://btrfs.wiki.kernel.org/index.php/Deduplication"> 重复数据删除 </a> <rt> deduplication </rt></ruby> 使用相同的技术来消除相同的数据块。单个文件可以通过使用 `cp` 的 [reflink 选项](https://btrfs.wiki.kernel.org/index.php/UseCases#How_do_I_copy_a_large_file_and_utilize_COW_to_keep_it_from_actually_being_copied.3F) 来使用 COW 功能。reflink 副本对于复制大型文件（例如虚拟机镜像）特别有用，这些文件往往随着时间的推移具有大部分相同的数据。
Btrfs 支持跨越多个设备，而无需卷管理器。多设备支持可提供数据镜像功能以实现冗余和条带化以提高性能。此外，还实验性地支持更高级的 RAID 级别，例如 [RAID 5](https://en.wikipedia.org/wiki/Standard_RAID_levels#RAID_5) 和 [RAID 6](https://en.wikipedia.org/wiki/Standard_RAID_levels#RAID_6)。与标准 RAID 设置不同，Btrfs 的 RAID1 实际上允许奇数个设备。例如，它可以使用 3 个设备，即使它们的大小不同。
所有 RAID 和 dup 选项都是在文件系统级别指定的。因此，各个子卷不能使用不同的选项。请注意，使用多设备的 RAID1 选项意味着即使一个设备发生故障，卷中的所有数据都是可用的，并且校验功能可以保持数据本身的完整性。这超出了当前典型的 RAID 设置所能提供的范围。
#### 附加功能
Btrfs 还支持快速简便的远程备份。子卷快照可以 [发送到远程系统](https://fedoramagazine.org/btrfs-snapshots-backup-incremental/) 进行存储。通过利用文件系统中固有的 COW 元数据，这些传输通过仅发送先前发送的快照中的增量更改而非常有效。诸如 [snapper](http://snapper.io/) 之类的用户应用程序使管理这些快照变得容易。
另外，Btrfs 卷可以具有 [透明压缩](https://btrfs.wiki.kernel.org/index.php/Compression) 功能，并且 [chattr +c](https://www.man7.org/linux/man-pages/man1/chattr.1.html) 可以标记进行压缩的单个文件或目录。压缩不仅可以减少数据消耗的空间，还可以通过减少写入操作量来帮助延长 SSD 的寿命。压缩当然会带来额外的 CPU 开销，但是有很多选项就可以权衡取舍。
Btrfs 集成了文件系统和卷管理器功能，这意味着总体维护比 LVM-ext4 更简单。当然，这种集成的灵活性较低，但是对于大多数台式机甚至服务器而言，设置已足够。
### LVM 上使用 Btrfs
Btrfs 可以 [就地转换 ext3/ext4 文件系统](https://btrfs.wiki.kernel.org/index.php/Conversion_from_Ext3)。就地转换意味着无需将数据复制出来然后再复制回去。数据块本身甚至都不需要修改。因此，对于现有的 LVM-ext4 系统，一种选择是将 LVM 保留在原处，然后简单地将 ext4 转换为 Btrfs。虽然可行且受支持，但有一些原因使它不是最佳选择。
Btrfs 的吸引力之一是与卷管理器集成的文件系统所带来的更轻松的管理。要是在 LVM 之上运行，对于系统维护，仍然要对额外的卷管理器进行一些设置。同样，LVM 设置通常具有多个固定大小的逻辑卷，并具有独立文件系统。虽然 Btrfs 支持给定的计算机上的多个卷，但是许多不错的功能都需要单一卷具有多个子卷。如果每个 LVM 卷都有一个独立的 Btrfs 卷，则用户仍然需要手动管理固定大小的 LVM 卷。虽然能够收缩挂载的 Btrfs 文件系统的能力确实使处理固定大小的卷的工作变得更轻松。通过在线收缩功能，就无需启动 [实时镜像](https://fedoramagazine.org/reclaim-hard-drive-space-with-lvm/) 了。
在使用 Btrfs 的多设备支持时，必须仔细考虑逻辑卷的物理位置。对于 Btrfs 而言，每个逻辑卷都是一个单独的物理设备，如果实际情况并非如此，则某些数据可用性功能可能会做出错误的决定。例如，如果单个驱动器发生故障，对数据使用 RAID1 通常可以提供保护。如果实际逻辑卷在同一物理设备上，则没有冗余。
如果强烈需要某些特定的 LVM 功能，例如原始块设备或高速缓存的逻辑卷，则在 LVM 之上运行 Btrfs 是有意义的。在这种配置下，Btrfs 仍然提供其大多数优点，例如校验和和易于发送的增量快照。尽管使用 LVM 会产生一些操作开销，但 Btrfs 的这种开销并不比任何其他文件系统大。
### 总结
当尝试在 Btrfs 和 LVM-ext4 之间进行选择时，没有一个正确的答案。每个用户都有独特的要求，并且同一用户可能拥有具有不同需求的不同系统。看一下每个配置的功能集，并确定是否有令人心动的功能。如果没有，坚持默认值没有错。选择这两种设置都有很好的理由。
---
via: <https://fedoramagazine.org/choose-between-btrfs-and-lvm-ext4/>
作者：[Troy Curtis Jr](https://fedoramagazine.org/author/troycurtisjr/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Chao-zhi](https://github.com/Chao-zhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
2021 年要遵守的 3 条电子邮件规则 | Kevin Sonney | https://opensource.com/article/21/1/email-rules | 电子邮件不是即时通讯。通过遵循这些规则来防止电子邮件不断地打断你的工作。 | /data/attachment/album/202101/23/141931hsgz7762jn960nmh.jpg.thumb.jpg | /data/attachment/album/202101/23/141931hsgz7762jn960nmh.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"电子邮件"
] | 观点 | {
"viewnum": 3552,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 13033,
"displayorder": 0
},
{
"raid": 13056,
"displayorder": 0
}
] | 电子邮件不是即时通讯。通过遵循这些规则来防止电子邮件不断地打断你的工作。 | 2021-01-23T14:19:52 | 2021-01-23T14:19:52 | 13,044 | /article-13044-1.html |
>
> 电子邮件不是即时通讯。通过遵循这些规则来防止电子邮件不断地打断你的工作。
>
>
>
在前几年，这个年度系列涵盖了单个应用程序。今年，我们除了关注有助于 2021 年的策略外，还将关注一体化解决方案。欢迎来到“2021 年 21 天生产力”的第二天。
和许多人一样，我对电子邮件也是爱恨交加。电子邮件是早期互联网、企业局域网和拨号 BBS 生态系统中最早的通信手段之一。电子邮件过去是、现在仍然是电子通信的主要手段之一。它被用于商业通信、商务、通知、协作和一堆有用的东西。
*Mutt 邮件客户端, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/) by Kevin Sonney*
很多人对电子邮件有着不正确的认识。电子邮件不是一个即时通讯平台。有时候，当一个人发送一条信息，几乎立刻就会出现在世界的另一端，然后在几分钟内就会有回应，这看起来就像是电子邮件是即时通讯。正因为如此，我们可能会陷入一种思维定势，即我们需要随时激活电子邮件程序，一旦有东西进来，我们需要马上看一下，然后马上回复。
电子邮件的设计原则是：一个人发送一条信息，收件人会在方便的时候回复。是的，有高优先级和紧急邮件的标志，我们的电子邮件程序也有通知来告诉我们新邮件何时到达，但它们真的不是为了给今天的许多人造成压力。
*太！多！电子邮件了！ [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/) by Kevin Sonney*
一般说来，一个人每受到一次干扰，至少需要 15 分钟的时间让他们的思维过程重新集中到被打断的任务上。在工作场所（以及在家里！），电子邮件成为了这些中断之一已经是一种普遍现象。它不需要这样，也不是设计成这样的。我采用了一些规则来防止电子邮件成为让我无法完成任务的干扰。
**规则 1**：电子邮件不是一个警报平台。在技术领域，人们通常会配置监控和警报平台，将所有的通知发送到电子邮件。在过去的 15 年里，我几乎在每一个工作场所都遇到过这种情况，我会先花了几个月的时间来改变它。有很多好的平台和服务来管理警报。电子邮件不是其中之一。
**规则 2**：至少不要指望在 24 小时内得到答复。我们有多少人接到过电话，问我们是否收到电子邮件，并问我们是否有任何问题？我就遇到过。尽量在工作场所或与你经常发邮件的人设定一个期望值，回复有时会很快，有时不会。如果事情真的很紧急，他们应该使用其他的沟通方式。
**规则 3**：每隔几个小时检查一次电子邮件，而不是不断地检查。我承认这一条很难，但它能给我带来最安心的感觉。当我在工作或试图专注于写作等事情时，我会关闭我的电子邮件程序（或浏览器标签），并忽略它，直到我完成。没有通知，没有 20 条新邮件正在等待的指示，没有干扰。当我开始这样做的时候，我花了一些努力来克服我的 FOMO（害怕错过），但随着时间的推移，这已经变得容易了。我发现，当我再次打开我的电子邮件时，我可以专注于它，而不是担心我可以做什么，或应该做什么来代替。
希望这三条规则能像帮助我一样帮助你。在接下来的日子里，我会有更多可以帮助我处理电子邮件的方法分享给你。
---
via: <https://opensource.com/article/21/1/email-rules>
作者：[Kevin Sonney](https://opensource.com/users/ksonney) 选题：[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/) 荣誉推出
|
改进你的 Ansible 剧本的 4 行代码 | Jeff Warncia | https://opensource.com/article/21/1/improve-ansible-play | 只要付出一点点努力，你就可以帮助下一个人，不只是绘制出安全路径，还可以留下危险的警告。 | /data/attachment/album/202101/23/225612fowskoyyk1gtwtog.jpg.thumb.jpg | /data/attachment/album/202101/23/225612fowskoyyk1gtwtog.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Ansible"
] | 技术 | {
"viewnum": 3520,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 只要付出一点点努力，你就可以帮助下一个人，不只是绘制出安全路径，还可以留下危险的警告。 | 2021-01-23T22:56:32 | 2021-01-23T22:56:32 | 13,046 | /article-13046-1.html |
>
> 只要付出一点点努力，你就可以帮助下一个人，不只是绘制出安全路径，还可以留下危险的警告。
>
>
>
在博客圈里，人们对基础架构即代码、持续集成/持续交付（CI/CD）管道、代码审查和测试制度赞不绝口，但人们很容易忘记，这种精心设计的象牙塔只是一种理想，而不是现实。虽然不完美的系统困扰着我们，但我们必须交付一些东西。
在系统自动化的过程中，很少有比那些通过粘合 API 创建的象牙塔更脆弱的塔。这是一个脆弱的世界。要让它“工作起来”，交付它，然后继续前进，压力巨大。
### 要解决的问题
想象一个简单的功能请求：编写一些 [Ansible](https://www.ansible.com/) 代码，在外部系统中创建几条记录，以记录一个 VLAN 的一些详细信息。我最近很想做一些实验室的管理工作来完成这个任务。这个外部系统是一个常见的<ruby> 互联网协议地址管理 <rt> Internet Protocol Address Management </rt></ruby>（IPAM）工具，但对于一个更抽象的<ruby> 配置管理数据库 <rt> Configuration Management DataBase </rt></ruby>（CMDB）或一个与网络无关的记录来说，困难是一样的。在这个例子中，我创建一个记录的直接愿望就是让系统保存记录而已。
如果我们的目标是一个超紧凑的、直接的、笨拙的宏，那么它可能用 100 行代码就能写出来。如果我记得 API，我也许能在一个小时内把它敲出来，该代码的作用不会超过预期，除了确切的成品之外，什么也没留下。对它的目的而言是完美的，但是对未来的扩展毫无用处。
如今，我希望几乎每个人都能从一个<ruby> 角色 <rt> role </rt></ruby>和几个<ruby> 任务 <rt> task </rt></ruby>文件开始这项任务，准备扩展到十几个创建、读取、更新和删除（CRUD）操作。因为我不了解这个 API，我可能会花上几个小时到几天的时间，仅仅是摆弄它，弄清楚它的内部模式和工艺，弥和它的功能和我用代码编写出来的意图之间的差距。
在研究 API 的时候，我发现创建一个 VLAN 记录需要一个父对象引用 `vlan_view_ref`。这看起来像一个路径片段，里面有随机字符。也许它是一个哈希，也许它真的是随机的，我不确定。我猜想，许多在泥泞中挣扎的人，在迫在眉睫的截止日期前，可能会把这个任意的字符串复制粘贴到 Ansible 中，然后继续混下去。忽略这个<ruby> 角色 <rt> role </rt></ruby>的实现细节，显而易见这个<ruby> 剧本 <rt> playbook </rt></ruby>级的任务应该是这样：
```
- name: "Create VLAN"
include_role:
name: otherthing
tasks_from: vlan_create.yml
vars:
vlan_name: "lab-infra"
vlan_tag: 100
vlan_view_ref: "vlan_view/747f602d-0381"
```
不幸的是，除了通过 API，`vlan_view_ref` 标识符是不可用的，所以即使把它移到<ruby> 清单文件 <rt> inventory </rt></ruby>或额外的变量中也没有什么帮助。<ruby> 剧本 <rt> playbook </rt></ruby>的用户需要对系统有一些更深入的理解，才能找出正确的引用 ID。
在实验室建设的情况下，我会经常重新部署这个记录系统。因此，这个父对象引用 ID 每天都会发生变化，我不希望每次都要手动找出它。所以，我肯定要按名称搜索该引用。没问题：
```
- name: Get Lab vlan view reference
include_role:
name: otherthing
tasks_from: search_for.yml
vars:
_resource: vlan_view
_query: "name={{ vlan_parent_view_name }}"
```
最终，它进行了一个 REST 调用。这将“返回” 一个 JSON，按照惯例，为了便于在角色外访问，我把它填充进了 `_otherthing_search_result` 中，。`search_for.yml` 的实现是抽象的，它总是返回一个包含零或多个结果的字典。
正如我读过的几乎所有真实世界的 Ansible 代码所证明的那样，大多数 Ansible 开发者将会继续前进，好像一切都很好，并且可以直接访问预期的单个结果：
```
- name: Remember our default vlan view ref
set_fact:
_thatthig_vlan_view_ref: "{{ _otherthing_search_result[0]._ref }}"
- name: "Create VLAN"
include_role:
name: otherthing
tasks_from: vlan_create.yml
vars:
vlan_name: "lab-infra"
vlan_tag: 100
vlan_view_ref: "{{ vlan_parent_view_name }}"
```
但有时 `_otherthing_search_result[0]` 是未定义的，所以 `_thatthig_vlan_view_ref` 也将是未定义的。很有可能是因为代码运行在不同的真实环境中，而有人忘记了在清单中或在命令行中更新 `{{ vlan_parent_view_name }}`。或者，无论公平与否，也许有人进入了工具的图形用户界面（GUI），删除了记录或更改了它的名称什么的。
我知道你在想什么。
*“好吧，不要这样做。这是一个没有哑巴的场所。不要那么笨。”*。
也许我对这种情况还算满意，反驳道：“Ansible 会很正确的告诉你`错误是：list 对象没有元素 0`，甚至会带个行号。你还想怎样？”作为开发者，我当然知道这句话的意思 —— 我刚写的代码。我刚从三天的和 API 斗智斗勇中走出来，我的脑子很清醒。
### 明天是另一个故事
但是到了明天，我可能会忘记什么是父对象引用，我肯定会忘记第 30 行上的内容。如果一个月后出了问题，就算你能找到我，我也得花一个下午的时间重新解读 API 指南，才能搞清楚到底出了什么问题。
而如果我出门了呢？如果我把代码交给了一个运维团队，也许是一个实习生通过 [Tower](https://www.ansible.com/products/tower) 来运行，把 `vlan_view_name` 手动输入到表单之类的东西呢？那第 30 行出的问题是对他们没有帮助的。
你说，加注释吧! 嗯，是的。我可以在代码中写一些梗概，以帮助下周或下个月的开发人员。这对运行代码的人没有帮助，他的“工作”刚刚失败，当然对于企业也无济于事。
记住，我们此刻无所不能。在写代码或者跳过写代码的时候，我们是站在实力和知识的立场上进行的。我们花了几个小时，甚至几天的时间，研究了文档、现实、其他 bug、其他问题，我们留下了代码、注释，甚至可能还有文档。我们写的代码是分享成功的，而成功正是我们用户想要的。但是在这种学习中也有很多失败的地方，我们也可以留下这些。
### 在代码中留言
“第 30 行有错误”对任何人都没有帮助。至少，我可以用更好的错误信息来处理明显的错误情况：
```
- name: Fail if zero vlan views returned
fail:
msg: "Got 0 results from searching for VLAN view {{ vlan_parent_view_name }}. Please verify exists in otherthing, and is accessible by the service account."
when: _otherthing_search_result | length == 0
```
在这四行代码中（没有额外的思考），我把具体的、有用的建议留给了下一个人 —— 那个无助的运维团队成员，或者更有可能是一个月后的我 —— 这是关于现实世界中的问题，其实根本不是关于代码的。这条消息可以让任何人发现一个简单的复制/粘贴错误，或者记录系统发生了变化。不需要 Ansible 知识，不需要凌晨 3 点给开发人员发短信“看看第 30 行”。
但是等等！还有更多！
在了解 `otherthing` 的过程中，我了解到它在一个关键的方面，嗯，还挺笨的。它的许多记录类型（如果不是全部的话）没有唯一性约束，可能存在几个相同的记录。VLAN 视图被定义为有一个名称、一个开始 ID 和一个结束 ID；其他记录类型也同样简单，显然这应该是一个唯一的元组 —— 基于现实和数据库规范化的抽象概念。但 `otherthing` 允许重复的元组，尽管在概念上讲永远不可能。
在我的实验室里，我很乐意尝试并记住不要这样做。在企业生产环境中，我可能会写一个策略。不管是哪种方式，经验告诉我，系统会被破坏，会在倒霉的时候被破坏，而且可能需要很长时间才能让这些问题发酵成，嗯，一个问题。
对于 “第 30 行有错误”，一个本来有丰富经验的 Ansible 开发者可能会认识到这是“记录没有找到”，而不用知道其他的事情就足以解决这个问题。但如果 `_otherthing_search_result[0]` 只有有时是正确的 `vlan_view_ref`，那就糟糕多了，它让整个世界被破坏，而悄无声息。而这个错误可能完全表现在其他地方，也许六个月后的安全审计会将其标记为记录保存不一致，如果有多种工具和人工访问方式，可能需要几天或几周的时间才能发现这个特定代码出错的事实。
在几天对 API 的摸索中，我学到了这一点。我不是在找问题，如果有记录，我没有看到。所以我来到了这篇文章的重点。我没有因为它是一个实验室，修复它，然后继续前进而忽略了这种不可能的情况，而是花了两分钟留下了\_代码\_ —— 不是注释，不是心理笔记，不是文档 —— 而是会一直运行的代码，涵盖了这种不可能的情况：
```
- name: Fail if > 1 views returned
fail:
msg: "Got {{ _otherthing_search_result | length }} results from searching for VLAN view {{ vlan_parent_view_name }}. Otherthing allows this, but is not handled by this code."
when: _otherthing_search_result | length > 1
```
我手动创建了失败条件，所以我可以手动测试这个条件。我希望它永远不会在实际使用中运行，但我觉得它会。
如果（当）这个错误发生在生产环境中，那么有人可以决定该怎么做。我希望他们能修复坏数据。如果它经常发生，我希望他们能追踪到另一个损坏的系统。如果他们要求删除这段代码，而这段代码做了未定义和错误的事情，那是他们的特权，也是我不想工作的地方。代码是不完美的，但它是完整的。这是匠人的工作。
现实世界中的自动化是一个迭代的过程，它与不完美的系统进行斗争，并平等地使用。它永远不会处理所有的特殊情况。它甚至可能无法处理所有的正常情况。通过 Lint、代码审查和验收测试的工作代码是处理安全和所需路径的代码。只要付出一点点努力，你就可以帮助下一个人，不仅仅是绘制安全路径，还可以对你发现的危险留下警告。
---
via: <https://opensource.com/article/21/1/improve-ansible-play>
作者：[Jeff Warncia](https://opensource.com/users/jeffwarncia) 选题：[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/) 荣誉推出
|
利用 Python 爬取网站的新手指南 | Julia Piaskowski | https://opensource.com/article/20/5/web-scraping-python | 通过基本的 Python 工具获得爬取完整 HTML 网站的实践经验。 | /data/attachment/album/202101/24/093527skakhvc3kalnuxa1.jpg.thumb.jpg | /data/attachment/album/202101/24/093527skakhvc3kalnuxa1.jpg | true | false | true | lujun9972 | stevenzdg988 | wxy | false | [
"爬取"
] | 软件开发 | {
"viewnum": 6307,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 通过基本的 Python 工具获得爬取完整 HTML 网站的实践经验。 | 2021-01-24T09:35:40 | 2021-01-24T09:35:40 | 13,047 | /article-13047-1.html |
>
> 通过基本的 Python 工具获得爬取完整 HTML 网站的实践经验。
>
>
>
有很多很棒的书可以帮助你学习 Python ，但是谁真正读了这那些大部头呢？（剧透：反正不是我）。
许多人觉得教学书籍很有用，但我通常不会从头到尾地阅读一本书来学习。我是通过做一个项目，努力的弄清楚一些内容，然后再读另一本书来学习。因此，暂时丢掉书，让我们一起学习 Python。
接下来是我的第一个 Python 爬取项目的指南。它对 Python 和 HTML 的假定知识要求很低。这篇文章旨在说明如何使用 Python 的 [requests](https://requests.readthedocs.io/en/master/) 库访问网页内容，并使用 [BeatifulSoup4](https://beautiful-soup-4.readthedocs.io/en/latest/) 库以及 JSON 和 [pandas](https://pandas.pydata.org/) 库解析网页内容。我将简要介绍 [Selenium](https://www.selenium.dev/) 库，但我不会深入研究如何使用该库——这个主题值得有自己的教程。最终，我希望向你展示一些技巧和小窍门，以减少网页爬取过程中遇到的问题。
### 安装依赖
我的 [GitHub 存储库](https://github.com/jpiaskowski/pycas2020_web_scraping) 中提供了本指南的所有资源。如果需要安装 Python3 的帮助，请查看 [Linux](https://opensource.com/article/20/4/install-python-linux)、[Windows](https://opensource.com/article/19/8/how-install-python-windows) 和 [Mac](https://opensource.com/article/19/5/python-3-default-mac) 的教程。
```
$ python3 -m venv
$ source venv/bin/activate
$ pip install requests bs4 pandas
```
如果你喜欢使用 JupyterLab ，则可以使用 [notebook](https://github.com/jpiaskowski/pycas2020_web_scraping/blob/master/example/Familydollar_location_scrape-all-states.ipynb) 运行所有代码。[安装 JupyterLab](https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html) 有很多方法，这是其中一种：
```
# from the same virtual environment as above, run:
$ pip install jupyterlab
```
### 为网站抓取项目设定目标
现在我们已经安装了依赖项，但是爬取网页需要做什么？
让我们退一步，确保使目标清晰。下面是成功完成网页爬取项目需求列表：
* 我们收集的信息，是值得我们花大力气去建立一个有效的网页爬取器的。
* 我们所下载的信息是可以通过网页爬取器合法和道德地收集的。
* 对如何在 HTML 代码中找到目标信息有一定的了解。
* 利用恰当的工具：在此情况下，需要使用 BeautifulSoup 库和 requests 库。
* 知道（或愿意去学习）如何解析 JSON 对象。
* 有足够的 pandas 数据处理技能。
关于 HTML 的备注：HTML 是运行在互联网上的“猛兽”，但我们最需要了解的是标签的工作方式。标签是一对由尖括号包围关键词（一般成对出现，其内容在两个标签中间）。比如，这是一个假装的标签，称为 `pro-tip`：
```
<pro-tip> All you need to know about html is how tags work </pro-tip>
```
我们可以通过调用标签 `pro-tip` 来访问其中的信息（`All you need to know…`）。本教程将进一步介绍如何查找和访问标签。要进一步了解 HTML 基础知识，请查看 [本文](https://opensource.com/article/20/4/build-websites)。
### 网站爬取项目中要找的是什么
有些数据利用网站爬取采集比利用其他方法更合适。以下是我认为合适项目的准则：
没有可用于数据（处理）的公共 API。通过 API 抓取结构化数据会容易得多，（所以没有 API ）有助于澄清收集数据的合法性和道德性。而有相当数量的结构化数据，并有规律的、可重复的格式，才能证明这种努力的合理性。网页爬取可能会很痛苦。BeautifulSoup（bs4）使操作更容易，但无法避免网站的个别特殊性，需要进行定制。数据的相同格式化不是必须的，但这确实使事情变得更容易。存在的 “边际案例”（偏离规范）越多，爬取就越复杂。
免责声明：我没有参加过法律培训；以下内容无意作为正式的法律建议。
关于合法性，访问大量有价值信息可能令人兴奋，但仅仅因为它是可能的，并不意味着应该这样做。
值得庆幸的是，有一些公共信息可以指导我们的道德规范和网页爬取工具。大多数网站都有与该网站关联的 [robots.txt](https://www.contentkingapp.com/academy/robotstxt/) 文件，指出允许哪些爬取活动，哪些不被允许。它主要用于与搜索引擎（网页抓取工具的终极形态）进行交互。然而，网站上的许多信息都被视为公共信息。因此，有人将 `robots.txt` 文件视为一组建议，而不是具有法律约束力的文档。 `robots.txt` 文件并不涉及数据的道德收集和使用等主题。
在开始爬取项目之前，问自己以下问题：
* 我是否在爬取版权材料？
* 我的爬取活动会危害个人隐私吗？
* 我是否发送了大量可能会使服务器超载或损坏的请求？
* 爬取是否会泄露出我不拥有的知识产权？
* 是否有规范网站使用的服务条款，我是否遵循了这些条款？
* 我的爬取活动会减少原始数据的价值吗？（例如，我是否打算按原样重新打包数据，或者可能从原始来源中抽取网站流量）？
当我爬取一个网站时，请确保可以对所有这些问题回答 “否”。
要深入了解这些法律问题，请参阅 2018 年出版的 Krotov 和 Silva 撰写的[《Web 爬取的合法性和道德性》](https://www.researchgate.net/publication/324907302_Legality_and_Ethics_of_Web_Scraping) 和 Sellars 的[《二十年 Web 爬取和计算机欺诈与滥用法案》](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3221625)。
### 现在开始爬取网站
经过上述评估，我想出了一个项目。我的目标是爬取爱达荷州所有 Family Dollar 商店的地址。 这些商店在农村地区规模很大，因此我想了解有多少家这样的商店。
起点是 [Family Dollar 的位置页面](https://locations.familydollar.com/id/)
首先，让我们在 Python 虚拟环境中加载先决条件。此处的代码将被添加到一个 Python 文件（如果你想要个名称，则为 `scraper.py`）或在 JupyterLab 的单元格中运行。
```
import requests # for making standard html requests
from bs4 import BeautifulSoup # magical tool for parsing html data
import json # for parsing data
from pandas import DataFrame as df # premier library for data organization
```
接下来，我们从目标 URL 中请求数据。
```
page = requests.get("https://locations.familydollar.com/id/")
soup = BeautifulSoup(page.text, 'html.parser')
```
BeautifulSoup 将 HTML 或 XML 内容转换为复杂树对象。这是我们将使用的几种常见对象类型。
* `BeautifulSoup` —— 解析的内容
* `Tag` —— 标准 HTML 标记，这是你将遇到的 `bs4` 元素的主要类型
* `NavigableString` —— 标签内的文本字符串
* `Comment` —— NavigableString 的一种特殊类型
当我们查看 `requests.get()` 输出时，还有更多要考虑的问题。我仅使用 `page.text()` 将请求的页面转换为可读的内容，但是还有其他输出类型：
* `page.text()` 文本（最常见）
* `page.content()` 逐字节输出
* `page.json()` JSON 对象
* `page.raw()` 原始套接字响应（对你没啥用）
我只在使用拉丁字母的纯英语网站上操作。 `requests` 中的默认编码设置可以很好地解决这一问题。然而，除了纯英语网站之外，就是更大的互联网世界。为了确保 `requests` 正确解析内容，你可以设置文本的编码：
```
page = requests.get(URL)
page.encoding = 'ISO-885901'
soup = BeautifulSoup(page.text, 'html.parser')
```
仔细研究 `BeautifulSoup` 标签，我们看到:
* `bs4` 元素 `tag` 捕获的是一个 HTML 标记。
* 它具有名称和属性，可以像字典一样访问：`tag['someAttribute']`。
* 如果标签具有相同名称的多个属性，则仅访问第一个实例。
* 可通过 `tag.contents` 访问子标签。
* 所有标签后代都可以通过 `tag.contents` 访问。
* 你始终可以使用以下字符串：`re.compile("your_string")` 访问一个字符串的所有内容，而不是浏览 HTML 树。
### 确定如何提取相应内容
警告：此过程可能令人沮丧。
网站爬取过程中的提取可能是一个令人生畏的充满了误区的过程。我认为解决此问题的最佳方法是从一个有代表性的示例开始然后进行扩展（此原理对于任何编程任务都是适用的）。查看页面的 HTML 源代码至关重要。有很多方法可以做到这一点。
你可以在终端中使用 Python 查看页面的整个源代码（不建议使用）。运行此代码需要你自担风险：
```
print(soup.prettify())
```
虽然打印出页面的整个源代码可能适用于某些教程中显示的玩具示例，但大多数现代网站的页面上都有大量内容。甚至 404 页面也可能充满了页眉、页脚等代码。
通常，在你喜欢的浏览器中通过 “查看页面源代码” 来浏览源代码是最容易的（单击右键，然后选择 “查看页面源代码” ）。这是找到目标内容的最可靠方法（稍后我将解释原因）。
在这种情况下，我需要在这个巨大的 HTML 海洋中找到我的目标内容 —— 地址、城市、州和邮政编码。通常，对页面源（`ctrl+F`）的简单搜索就会得到目标位置所在的位置。一旦我实际看到目标内容的示例（至少一个商店的地址），便会找到将该内容与其他内容区分开的属性或标签。
首先，我需要在爱达荷州 Family Dollar 商店中收集不同城市的网址，并访问这些网站以获取地址信息。这些网址似乎都包含在 `href` 标记中。太棒了！我将尝试使用 `find_all` 命令进行搜索：
```
dollar_tree_list = soup.find_all('href')
dollar_tree_list
```
搜索 `href` 不会产生任何结果，该死。这可能是因为 `href` 嵌套在 `itemlist` 类中而失败。对于下一次尝试，请搜索 `item_list`。由于 `class` 是 Python 中的保留字，因此使用 `class_` 来作为替代。`soup.find_all()` 原来是 `bs4` 函数的瑞士军刀。
```
dollar_tree_list = soup.find_all(class_ = 'itemlist')
for i in dollar_tree_list[:2]:
print(i)
```
有趣的是，我发现搜索一个特定类的方法一般是一种成功的方法。通过找出对象的类型和长度，我们可以了解更多有关对象的信息。
```
type(dollar_tree_list)
len(dollar_tree_list)
```
可以使用 `.contents` 从 BeautifulSoup “结果集” 中提取内容。这也是创建单个代表性示例的好时机。
```
example = dollar_tree_list[2] # a representative example
example_content = example.contents
print(example_content)
```
使用 `.attr` 查找该对象内容中存在的属性。注意：`.contents` 通常会返回一个项目的精确的列表，因此第一步是使用方括号符号为该项目建立索引。
```
example_content = example.contents[0]
example_content.attrs
```
现在，我可以看到 `href` 是一个属性，可以像字典项一样提取它：
```
example_href = example_content['href']
print(example_href)
```
### 整合网站抓取工具
所有的这些探索为我们提供了前进的路径。这是厘清上面逻辑的一个清理版本。
```
city_hrefs = [] # initialise empty list
for i in dollar_tree_list:
cont = i.contents[0]
href = cont['href']
city_hrefs.append(href)
# check to be sure all went well
for i in city_hrefs[:2]:
print(i)
```
输出的内容是一个关于抓取爱达荷州 Family Dollar 商店 URL 的列表。
也就是说，我仍然没有获得地址信息！现在，需要抓取每个城市的 URL 以获得此信息。因此，我们使用一个具有代表性的示例重新开始该过程。
```
page2 = requests.get(city_hrefs[2]) # again establish a representative example
soup2 = BeautifulSoup(page2.text, 'html.parser')
```
地址信息嵌套在 `type="application/ld+json"` 里。经过大量的地理位置抓取之后，我开始认识到这是用于存储地址信息的一般结构。幸运的是，`soup.find_all()` 开启了利用 `type` 搜索。
```
arco = soup2.find_all(type="application/ld+json")
print(arco[1])
```
地址信息在第二个列表成员中！原来如此！
使用 `.contents` 提取（从第二个列表项中）内容（这是过滤后的合适的默认操作）。同样，由于输出的内容是一个列表，因此我为该列表项建立了索引：
```
arco_contents = arco[1].contents[0]
arco_contents
```
喔，看起来不错。此处提供的格式与 JSON 格式一致（而且，该类型的名称中确实包含 “json”）。 JSON 对象的行为就像是带有嵌套字典的字典。一旦你熟悉利用其去工作，它实际上是一种不错的格式（当然，它比一长串正则表达式命令更容易编程）。尽管从结构上看起来像一个 JSON 对象，但它仍然是 `bs4` 对象，需要通过编程方式转换为 JSON 对象才能对其进行访问：
```
arco_json = json.loads(arco_contents)
```
```
type(arco_json)
print(arco_json)
```
在该内容中，有一个被调用的 `address` 键，该键要求地址信息在一个比较小的嵌套字典里。可以这样检索：
```
arco_address = arco_json['address']
arco_address
```
好吧，请大家注意。现在我可以遍历存储爱达荷州 URL 的列表：
```
locs_dict = [] # initialise empty list
for link in city_hrefs:
locpage = requests.get(link) # request page info
locsoup = BeautifulSoup(locpage.text, 'html.parser')
# parse the page's content
locinfo = locsoup.find_all(type="application/ld+json")
# extract specific element
loccont = locinfo[1].contents[0]
# get contents from the bs4 element set
locjson = json.loads(loccont) # convert to json
locaddr = locjson['address'] # get address
locs_dict.append(locaddr) # add address to list
```
### 用 Pandas 整理我们的网站抓取结果
我们在字典中装载了大量数据，但是还有一些额外的无用项，它们会使重用数据变得比需要的更为复杂。要执行最终的数据组织，我们需要将其转换为 Pandas 数据框架，删除不需要的列 `@type` 和 `country`，并检查前五行以确保一切正常。
```
locs_df = df.from_records(locs_dict)
locs_df.drop(['@type', 'addressCountry'], axis = 1, inplace = True)
locs_df.head(n = 5)
```
确保保存结果！！
```
df.to_csv(locs_df, "family_dollar_ID_locations.csv", sep = ",", index = False)
```
我们做到了！所有爱达荷州 Family Dollar 商店都有一个用逗号分隔的列表。多令人兴奋。
### Selenium 和数据抓取的一点说明
[Selenium](https://www.selenium.dev/) 是用于与网页自动交互的常用工具。为了解释为什么有时必须使用它，让我们来看一个使用 Walgreens 网站的示例。 “检查元素” 提供了浏览器显示内容的代码：
虽然 “查看页面源代码” 提供了有关 `requests` 将获得什么内容的代码：
如果这两个不一致，是有一些插件可以修改源代码 —— 因此，应在将页面加载到浏览器后对其进行访问。`requests` 不能做到这一点，但是 Selenium 可以做到。
Selenium 需要 Web 驱动程序来检索内容。实际上，它会打开 Web 浏览器，并收集此页面的内容。Selenium 功能强大 —— 它可以通过多种方式与加载的内容进行交互（请阅读文档）。使用 Selenium 获取数据后，继续像以前一样使用 BeautifulSoup：
```
url = "https://www.walgreens.com/storelistings/storesbycity.jsp?requestType=locator&state=ID"
driver = webdriver.Firefox(executable_path = 'mypath/geckodriver.exe')
driver.get(url)
soup_ID = BeautifulSoup(driver.page_source, 'html.parser')
store_link_soup = soup_ID.find_all(class_ = 'col-xl-4 col-lg-4 col-md-4')
```
对于 Family Dollar 这种情形，我不需要 Selenium，但是当呈现的内容与源代码不同时，我确实会保留使用 Selenium。
### 小结
总之，使用网站抓取来完成有意义的任务时：
* 耐心一点
* 查阅手册（它们非常有帮助）
如果你对答案感到好奇：
美国有很多 Family Dollar 商店。
完整的源代码是：
```
import requests
from bs4 import BeautifulSoup
import json
from pandas import DataFrame as df
page = requests.get("https://www.familydollar.com/locations/")
soup = BeautifulSoup(page.text, 'html.parser')
# find all state links
state_list = soup.find_all(class_ = 'itemlist')
state_links = []
for i in state_list:
cont = i.contents[0]
attr = cont.attrs
hrefs = attr['href']
state_links.append(hrefs)
# find all city links
city_links = []
for link in state_links:
page = requests.get(link)
soup = BeautifulSoup(page.text, 'html.parser')
familydollar_list = soup.find_all(class_ = 'itemlist')
for store in familydollar_list:
cont = store.contents[0]
attr = cont.attrs
city_hrefs = attr['href']
city_links.append(city_hrefs)
# to get individual store links
store_links = []
for link in city_links:
locpage = requests.get(link)
locsoup = BeautifulSoup(locpage.text, 'html.parser')
locinfo = locsoup.find_all(type="application/ld+json")
for i in locinfo:
loccont = i.contents[0]
locjson = json.loads(loccont)
try:
store_url = locjson['url']
store_links.append(store_url)
except:
pass
# get address and geolocation information
stores = []
for store in store_links:
storepage = requests.get(store)
storesoup = BeautifulSoup(storepage.text, 'html.parser')
storeinfo = storesoup.find_all(type="application/ld+json")
for i in storeinfo:
storecont = i.contents[0]
storejson = json.loads(storecont)
try:
store_addr = storejson['address']
store_addr.update(storejson['geo'])
stores.append(store_addr)
except:
pass
# final data parsing
stores_df = df.from_records(stores)
stores_df.drop(['@type', 'addressCountry'], axis = 1, inplace = True)
stores_df['Store'] = "Family Dollar"
df.to_csv(stores_df, "family_dollar_locations.csv", sep = ",", index = False)
```
作者注释：本文改编自 2020 年 2 月 9 日在俄勒冈州波特兰的[我在 PyCascades 的演讲](https://2020.pycascades.com/talks/adventures-in-babysitting-webscraping-for-python-and-html-novices/)。
---
via: <https://opensource.com/article/20/5/web-scraping-python>
作者：[Julia Piaskowski](https://opensource.com/users/julia-piaskowski) 选题：[lujun9972](https://github.com/lujun9972) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
计算机正常运行最大的威胁是什么？是员工 | Andy Patrizio | https://www.networkworld.com/article/3444762/the-biggest-risk-to-uptime-your-staff.html | 一项新研究发现，人为失误是引发停机时间的首要原因。你想象一下那是什么场景。 | /data/attachment/album/202101/24/232105f20aa0mr0ax8xrz2.jpg.thumb.jpg | /data/attachment/album/202101/24/232105f20aa0mr0ax8xrz2.jpg | true | false | true | lujun9972 | sthwhl | wxy | false | [
"故障"
] | 观点 | {
"viewnum": 2756,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 一项新研究发现，人为失误是引发停机时间的首要原因。你想象一下那是什么场景。 | 2021-01-24T23:21:04 | 2021-01-24T23:21:04 | 13,049 | /article-13049-1.html |
>
> 一项新研究发现，人为失误是引发停机时间的首要原因。你想象一下那是什么场景。
>
>
>
之前有一个很老的笑话：“是人都会犯错，但是要真正把事情搞砸，你还缺台计算机。” 现在情况正好相反了，现如今，数据中心设备的可靠性已经得到了极大的提升，反而是使用设备的人员素质没能跟上，从而给计算机正常运行带来了很大的威胁。
<ruby> 正常运行时间协会 <rt> Uptime Institute </rt></ruby>对数千名 IT 专业人员一整年发生的故障事件进行了调查，得出结论表示绝大多数的数据中心故障是由于人为错误造成的，人为错误导致的故障率为 70%-75%。
而且有些故障很严重。调查发现，超过 30% 的 IT 服务与数据中心运营商经历了他们称之为是“严重服务退化”的停机事故。2019 年有 10% 的受访者称他们最近的事故造成的损失超过 100 万美元。
在正常运行时间协会在 2019 年 4 月的调查中，60% 的受访者认为，对于最近发生的重大停机事件，他们本可以通过更好的管理/流程或配置进行防止。而对于损失超过 100 万美元的故障事件，这一数字跃升至 74%。
正常运行时间协会认为，导致故障事件发生的最终的错误不一定是员工，而是令人失望的管理。
“这个行业仍然严重依赖于人工去完成一些最基础和最重要的工作，易受人为错误的影响，这一点无法避免，也许可做的防错/防灾措施很有限。”正常运行时间协会期刊的主编 Kevin Heslin 在一篇[博客文章](https://journal.uptimeinstitute.com/how-to-avoid-outages-try-harder/)中写道。
“然而，对这些故障问题的快速调查发现，故障持续存在的主要原因不是人为失误，而是由于管理失误导致，如针对员工培训投资不足，相关政策执行不力，管理程序老旧，低估一名合格员工的重要性，这一系列的管理问题导致了故障停机。” Heslin 继续写道。
正常运行时间协会指出，公司的 IT 基础设施越复杂，特别是分布式特性基础设施，可能会越容易增加简单的错误层出不穷而导致业务中断的风险。同时指出公司需要意识到基础设施越复杂所涉及的风险就越大。
并警告说，在人员配备方面，不要以超过公司吸引和应用资源来管理基础设施的速度扩大关键 IT 能力，并在影响关键任务操作之前意识到任何人员和技能短缺。
---
via: <https://www.networkworld.com/article/3444762/the-biggest-risk-to-uptime-your-staff.html>
作者：[Andy Patrizio](https://www.networkworld.com/author/Andy-Patrizio/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[sthwhl](https://github.com/sthwhl) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Haruna 视频播放器：一个 MPV GUI 前端 | Ankush Das | https://itsfoss.com/haruna-video-player/ | 一个基于 Qt 的 Linux 视频播放器，它可作为 mpv 的前端，并能使用 youtube-dl。 | /data/attachment/album/202101/25/000054gabm4ziiabhc2m1h.jpg.thumb.jpg | /data/attachment/album/202101/25/000054gabm4ziiabhc2m1h.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"MPV",
"视频"
] | 分享 | {
"viewnum": 7909,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 一个基于 Qt 的 Linux 视频播放器，它可作为 mpv 的前端，并能使用 youtube-dl。 | 2021-01-25T00:00:54 | 2021-01-25T00:00:54 | 13,050 | /article-13050-1.html |
>
> 一个基于 Qt 的 Linux 视频播放器，它可作为 mpv 的前端，并能使用 youtube-dl。
>
>
>
### Haruna Video Player：一个基于 Qt 的免费视频播放器
如果你还不知道 [mpv](https://mpv.io/)，它是一个基于命令行的自由开源的媒体播放器。好吧，它有一个[简约的 MPV GUI](https://itsfoss.com/mpv-video-player/)，但核心是命令行。
你可能还会找到几个[开源视频播放器](https://itsfoss.com/video-players-linux/)，它们基本上就是 mpv 的 GUI 前端。
Haruna 视频播放器就是其中之一，同时还可以[使用 youtube-dl](https://itsfoss.com/download-youtube-linux/)。你可以轻松播放本地媒体文件以及 YouTube 内容。
让我给你介绍一下这个播放器提供的功能。
### Haruna 视频播放器的功能
你可能会发现它与其他一些视频播放器有些不同。以下是你可以从 Haruna 视频播放器 获得的：
* 能够直接使用 URL 播放 YouTube 视频
* 支持播放列表，并且你可以轻松控制它们
* 能够根据字幕中的某些词语自动跳过
* 控制播放速度
* 使用 [youtube-dl](https://github.com/ytdl-org/youtube-dl) 改变播放格式（音频/视频）
* 大量的键盘快捷键
* 轻松地从视频中截屏
* 添加主要和次要字幕的选项
* 改变截图的文件格式
* 支持硬件解码
* 色彩调整以提高你的观看质量。
* 能够调整鼠标和键盘的快捷键，以便能够快速浏览和做你想做的事情
* 调整 UI（字体、主题）
### 在 Linux 上安装 Haruna 视频播放器
不幸的是（或者不是，取决于你的偏好），你只能[使用 Flatpak](https://itsfoss.com/flatpak-guide/) 安装它。你可以使用 [Flatpak 包](https://flathub.org/apps/details/com.georgefb.haruna)在任何 Linux 发行版上安装它。
如果你使用的是基于 Arch 的系统，你也可以在 [AUR](https://itsfoss.com/aur-arch-linux/) 中找到它。
但是，如果你不喜欢这样，你可以查看 [GitHub](https://github.com/g-fb/haruna) 上的源代码，看看你是否可以像普通的 Gentoo 用户一样自己构建它。
* [Haruna 视频播放器](https://github.com/g-fb/haruna)
### 总结
Haruna 视频播放器是一款简单实用的在 [libmpv](https://github.com/mpv-player/mpv/tree/master/libmpv) 之上的 GUI。能够在系统上播放 YouTube 视频以及各种文件格式绝对是很多用户所希望的。
用户界面很容易上手，它也提供了一些重要的自定义选项。
你尝试过这款视频播放器了吗？在下面的评论中让我知道你对它的看法。
---
via: <https://itsfoss.com/haruna-video-player/>
作者：[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/) 荣誉推出
|
利用 Shell 脚本让网站更具可读性 | Jim Hall | https://opensource.com/article/19/2/make-websites-more-readable-shell-script | 测算网站的文本和背景之间的对比度，以确保站点易于阅读。 | /data/attachment/album/202101/25/231152ce5ufhjtufxj1eeu.jpg.thumb.jpg | /data/attachment/album/202101/25/231152ce5ufhjtufxj1eeu.jpg | true | false | true | lujun9972 | stevenzdg988 | wxy | false | [
"对比度",
"可读性"
] | 技术 | {
"viewnum": 3825,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 测算网站的文本和背景之间的对比度，以确保站点易于阅读。 | 2021-01-25T23:14:00 | 2021-01-25T23:14:00 | 13,052 | /article-13052-1.html |
>
> 测算网站的文本和背景之间的对比度，以确保站点易于阅读。
>
>
>
如果希望人们发现你的网站实用，那么他们需要能够阅读它。为文本选择的颜色可能会影响网站的可读性。不幸的是，网页设计中的一种流行趋势是在打印输出文本时使用低对比度的颜色，就像在白色背景上的灰色文本。对于 Web 设计师来说，这也许看起来很酷，但对于许多阅读它的人来说确实很困难。
W3C 提供了《<ruby> Web 内容可访问性指南 <rt> Web Content Accessibility Guidelines </rt></ruby>》，其中包括帮助 Web 设计人员选择易于区分文本和背景色的指导。z这就是所谓的“<ruby> 对比度 <rt> contrast ratio </rt></ruby>”。 W3C 定义的对比度需要进行一些计算：给定两种颜色，首先计算每种颜色的相对亮度，然后计算对比度。对比度在 1 到 21 的范围内（通常写为 1:1 到 21:1）。对比度越高，文本在背景下的突出程度就越高。例如，白色背景上的黑色文本非常醒目，对比度为 21:1。对比度为 1:1 的白色背景上的白色文本不可读。
[W3C 说，正文](https://www.w3.org/TR/2008/REC-WCAG20-20081211/#visual-audio-contrast) 的对比度至少应为 4.5:1，标题至少应为 3:1。但这似乎是最低限度的要求。W3C 还建议正文至少 7:1，标题至少 4.5:1。
计算对比度可能比较麻烦，因此最好将其自动化。我已经用这个方便的 Bash 脚本做到了这一点。通常，脚本执行以下操作：
1. 获取文本颜色和背景颜色
2. 计算相对亮度
3. 计算对比度
### 获取颜色
你可能知道显示器上的每种颜色都可以用红色、绿色和蓝色（R、G 和 B）来表示。要计算颜色的相对亮度，脚本需要知道颜色的红、绿和蓝的各个分量。理想情况下，脚本会将这些信息读取为单独的 R、G 和 B 值。 Web 设计人员可能知道他们喜欢的颜色的特定 RGB 代码，但是大多数人不知道不同颜色的 RGB 值。作为一种替代的方法是，大多数人通过 “red” 或 “gold” 或 “maroon” 之类的名称来引用颜色。
幸运的是，GNOME 的 [Zenity](https://wiki.gnome.org/Projects/Zenity) 工具有一个颜色选择器应用程序，可让你使用不同的方法选择颜色，然后用可预测的格式 `rgb(R,G,B)` 返回 RGB 值。使用 Zenity 可以轻松获得颜色值：
```
color=$( zenity --title 'Set text color' --color-selection --color='black' )
```
如果用户（意外地）单击 “Cancel（取消）” 按钮，脚本将假定一种颜色：
```
if [ $? -ne 0 ] ; then
echo '** color canceled .. assume black'
color='rgb(0,0,0)'
fi
```
脚本对背景颜色值也执行了类似的操作，将其设置为 `$background`。
### 计算相对亮度
一旦你在 `$color` 中设置了前景色，并在 `$background` 中设置了背景色，下一步就是计算每种颜色的相对亮度。 [W3C 提供了一个算法](https://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef) 用以计算颜色的相对亮度。
>
> 对于 sRGB 色彩空间，一种颜色的相对亮度定义为：
>
>
> L = 0.2126 \* R + 0.7152 \* G + 0.0722 \* B
>
>
> R、G 和 B 定义为：
>
>
> if R<sub> sRGB</sub> <= 0.03928 then R = R<sub> sRGB</sub>/12.92
>
>
> else R = ((R<sub> sRGB</sub>+0.055)/1.055) <sup> 2.4</sup>
>
>
> if G<sub> sRGB</sub> <= 0.03928 then G = G<sub> sRGB</sub>/12.92
>
>
> else G = ((G<sub> sRGB</sub>+0.055)/1.055) <sup> 2.4</sup>
>
>
> if B<sub> sRGB</sub> <= 0.03928 then B = B<sub> sRGB</sub>/12.92
>
>
> else B = ((B<sub> sRGB</sub>+0.055)/1.055) <sup> 2.4</sup>
>
>
> R<sub> sRGB</sub>、G<sub> sRGB</sub> 和 B<sub> sRGB</sub> 定义为：
>
>
> R<sub> sRGB</sub> = R<sub> 8bit</sub>/255
>
>
> G<sub> sRGB</sub> = G<sub> 8bit</sub>/255
>
>
> B<sub> sRGB</sub> = B<sub> 8bit</sub>/255
>
>
>
由于 Zenity 以 `rgb(R,G,B)` 的格式返回颜色值，因此脚本可以轻松拉取分隔开的 R、B 和 G 的值以计算相对亮度。AWK 可以使用逗号作为字段分隔符（`-F,`），并使用 `substr()` 字符串函数从 `rgb(R,G,B)` 中提取所要的颜色值：
```
R=$( echo $color | awk -F, '{print substr($1,5)}' )
G=$( echo $color | awk -F, '{print $2}' )
B=$( echo $color | awk -F, '{n=length($3); print substr($3,1,n-1)}' )
```
*有关使用 AWK 提取和显示数据的更多信息，[查看 AWK 备忘表](https://opensource.com/article/18/7/cheat-sheet-awk)*
最好使用 BC 计算器来计算最终的相对亮度。BC 支持计算中所需的简单 `if-then-else`，这使得这一过程变得简单。但是由于 BC 无法使用非整数指数直接计算乘幂，因此需要使用自然对数替代它做一些额外的数学运算：
```
echo "scale=4
rsrgb=$R/255
gsrgb=$G/255
bsrgb=$B/255
if ( rsrgb <= 0.03928 ) r = rsrgb/12.92 else r = e( 2.4 * l((rsrgb+0.055)/1.055) )
if ( gsrgb <= 0.03928 ) g = gsrgb/12.92 else g = e( 2.4 * l((gsrgb+0.055)/1.055) )
if ( bsrgb <= 0.03928 ) b = bsrgb/12.92 else b = e( 2.4 * l((bsrgb+0.055)/1.055) )
0.2126 * r + 0.7152 * g + 0.0722 * b" | bc -l
```
这会将一些指令传递给 BC，包括作为相对亮度公式一部分的 `if-then-else` 语句。接下来 BC 打印出最终值。
### 计算对比度
利用文本颜色和背景颜色的相对亮度，脚本就可以计算对比度了。 [W3C 确定对比度](https://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef) 是使用以下公式：
>
> (L1 + 0.05) / (L2 + 0.05)，这里的 L1 是颜色较浅的相对亮度， L2 是颜色较深的相对亮度。
>
>
>
给定两个相对亮度值 `$r1` 和 `$r2`，使用 BC 计算器很容易计算对比度：
```
echo "scale=2
if ( $r1 > $r2 ) { l1=$r1; l2=$r2 } else { l1=$r2; l2=$r1 }
(l1 + 0.05) / (l2 + 0.05)" | bc
```
使用 `if-then-else` 语句确定哪个值（`$r1` 或 `$r2`）是较浅还是较深的颜色。BC 执行结果计算并打印结果，脚本可以将其存储在变量中。
### 最终脚本
通过以上内容，我们可以将所有内容整合到一个最终脚本。 我使用 Zenity 在文本框中显示最终结果：
```
#!/bin/sh
# script to calculate contrast ratio of colors
# read color and background color:
# zenity returns values like 'rgb(255,140,0)' and 'rgb(255,255,255)'
color=$( zenity --title 'Set text color' --color-selection --color='black' )
if [ $? -ne 0 ] ; then
echo '** color canceled .. assume black'
color='rgb(0,0,0)'
fi
background=$( zenity --title 'Set background color' --color-selection --color='white' )
if [ $? -ne 0 ] ; then
echo '** background canceled .. assume white'
background='rgb(255,255,255)'
fi
# compute relative luminance:
function luminance()
{
R=$( echo $1 | awk -F, '{print substr($1,5)}' )
G=$( echo $1 | awk -F, '{print $2}' )
B=$( echo $1 | awk -F, '{n=length($3); print substr($3,1,n-1)}' )
echo "scale=4
rsrgb=$R/255
gsrgb=$G/255
bsrgb=$B/255
if ( rsrgb <= 0.03928 ) r = rsrgb/12.92 else r = e( 2.4 * l((rsrgb+0.055)/1.055) )
if ( gsrgb <= 0.03928 ) g = gsrgb/12.92 else g = e( 2.4 * l((gsrgb+0.055)/1.055) )
if ( bsrgb <= 0.03928 ) b = bsrgb/12.92 else b = e( 2.4 * l((bsrgb+0.055)/1.055) )
0.2126 * r + 0.7152 * g + 0.0722 * b" | bc -l
}
lum1=$( luminance $color )
lum2=$( luminance $background )
# compute contrast
function contrast()
{
echo "scale=2
if ( $1 > $2 ) { l1=$1; l2=$2 } else { l1=$2; l2=$1 }
(l1 + 0.05) / (l2 + 0.05)" | bc
}
rel=$( contrast $lum1 $lum2 )
# print results
( cat<<EOF
Color is $color on $background
Contrast ratio is $rel
Contrast ratios can range from 1 to 21 (commonly written 1:1 to 21:1).
EOF
if [ ${rel%.*} -ge 4 ] ; then
echo "Ok for body text"
else
echo "Not good for body text"
fi
if [ ${rel%.*} -ge 3 ] ; then
echo "Ok for title text"
else
echo "Not good for title text"
fi
cat<<EOF
W3C 说明：
1.4.3 对比度（最小值）：文本和文本图像的视觉呈现方式的对比度至少为 4.5：1，但以下情况除外：（AA 级）
大文本：大文本和大文本图像的对比度至少为 3:1；
附带说明：作为非活动用户界面组件一部分，纯装饰的，任何人都不可见或图片的一部分包含特定的其他可视内容的文本或文本图像没有对比度要求。
小示意图：徽标或商标名称中的文本没有最低对比度要求。
1.4.6 对比度（增强）：文本和文本图像的视觉表示具有至少 7:1 的对比度，但以下情况除外：（AAA 级）
大文本：大文本和大文本图像的对比度至少为 4.5:1；
附带说明：作为非活动用户界面组件一部分，纯装饰的，任何人都不可见或图片的一部分包含特定的其他可视内容的文本或文本图像没有对比度要求。
小示意图：徽标或商标名称中的文本没有最低对比度要求。
EOF
) | zenity --text-info --title='Relative Luminance' --width=800 --height=600
```
最后，我希望提供有关 W3C 建议的参考信息，以提醒自己。
Zenity 颜色选择器完成了所有解释颜色的艰苦工作，用户可以通过单击色轮或输入值来选择颜色。 Zenity 接受网站上使用的标准十六进制颜色值，例如 `＃000000` 或 `＃000`或 `rgb(0,0,0)`（所有这些均为黑色）。这是白色背景上的黑色文本的示例计算：
Zenity 还识别标准的颜色名称，如“cadetblue”、“orange”或“gold”。在Zenity 中输入颜色名称，然后点击 `Tab` 键，Zenity 会将颜色名称转换为十六进制颜色值，如以下示例中对金色背景上的黑色文本的计算：
---
via: <https://opensource.com/article/19/2/make-websites-more-readable-shell-script>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 选题：[lujun9972](https://github.com/lujun9972) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
编写 Python 代码时要有所取舍 | Moshe Zadka | https://opensource.com/article/19/12/zen-python-trade-offs | 本文是 Python 之禅特别系列的一部分，重点此篇着眼于第七、八、九条原则：可读性、特殊情况和实用性。 | /data/attachment/album/202101/26/105645c1looxqxns12loen.jpg.thumb.jpg | /data/attachment/album/202101/26/105645c1looxqxns12loen.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Python"
] | 软件开发 | {
"viewnum": 3355,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 12087,
"displayorder": 0
},
{
"raid": 13058,
"displayorder": 0
}
] | 本文是 Python 之禅特别系列的一部分，重点此篇着眼于第七、八、九条原则：可读性、特殊情况和实用性。 | 2021-01-26T10:57:31 | 2021-01-26T10:57:31 | 13,053 | /article-13053-1.html |
>
> 本文是 Python 之禅特别系列的一部分，重点此篇着眼于第七、八、九条原则：可读性、特殊情况和实用性。
>
>
>
软件开发是一门充满了取舍的学科。每一个选择，都有一个同样合理但相反的选择。将一个方法私有化？你在鼓励复制粘贴。将一个方法公开？你在过早地对一个接口做出承诺。
软件开发者每时每刻都在做艰难的选择。虽然 [Python 之禅](https://www.python.org/dev/peps/pep-0020/) 中的所有原则都在一定程度上涵盖了权衡，但下面的原则对一些权衡进行了最艰难、最冷酷的审视。
### <ruby> 可读性很重要 <rt> Readability counts </rt></ruby>
从某种意义上说，这一中间原则确实是整个 Python 之禅的中心。这条原则与编写高效的程序无关。在大多数情况下，它甚至与编写健壮的程序也无关。它讲的是编写出*别人能读懂的程序*。
阅读代码，就其本质而言，发生在代码被添加到系统中之后。通常，它会发生在很久很久以后。忽略可读性是最简单的选择，因为它对现在没有伤害。无论添加新代码的原因是什么，它都会对现在造成影响，无论是一个令人痛苦的 bug 还是一个被强烈要求的功能。
如果面对巨大的压力，把可读性扔到一边，只管“解决问题”，而 Python 之禅提醒我们：可读性很重要。编写代码让它适合阅读，无论是对自己还是他人，都是一种慈悲。
### <ruby> 特殊情况不足以违反规则 <rt> Special cases aren't special enough to break the rules </rt></ruby>
总是有各种借口：这个 bug 特别麻烦，先简单处理一下吧；这个功能特别紧急，别管美观了；这种情况下所涉及的领域规则特别复杂，嵌套深点也没关系。
一旦我们对特例的借口妥协，大坝就会破裂，就丧失了原则；事情就会演变成一个疯狂麦克斯的荒诞症，每个程序员都会为自己试图找到最好的借口。
纪律需要承诺。只有当事情艰辛、有强烈的诱惑时，才是对一个软件开发人员的考验。总是有合理的借口来破坏规则，这就是为什么必须坚守规矩的原因。纪律就是向例外说不的艺术。没有任何解释可以改变这一点。
### <ruby> 虽然，实用性胜过纯洁性 <rt> Although, practicality beats purity </rt></ruby>
>
> “如果你只想着击打、弹跳、撞击、触碰敌人，你将无法真正打倒他。” —— 《宫本武藏：[水之卷](https://en.wikipedia.org/wiki/The_Book_of_Five_Rings#The_Book_of_Water)》
>
>
>
归根结底，软件开发是一门实用的学科。它的目标是解决真实的人所面临的实际问题。实用性比纯粹性更重要：首先，我们必须*解决问题*。如果我们只考虑可读性、简单性或美观性，我们将无法真正*解决问题*。
正如宫本武藏所说的，每一次代码修改的首要目标应该是*解决问题*。这个问题需要我们心心念念地去解决它。如果我们不以解决问题为目标，只想着 Python 之禅，我们就辜负了这些原则。这是 Python 之禅所固有的另一种矛盾。
---
via: <https://opensource.com/article/19/12/zen-python-trade-offs>
作者：[Moshe Zadka](https://opensource.com/users/moshez) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxys) 校对：[wxy](https://github.com/wxys)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
硬核观察 | Cookie 要被废弃，谷歌找到了更好给你推送精准广告的方法 | 硬核老王 | 更多：• 《自然》杂志评选出改变科学的 10 个计算机代码项目 • Mozilla 希望让社区接管 MDN 后续的维护工作 | /data/attachment/album/202101/26/160522rpjvvrp787xs57fs.jpg.thumb.jpg | /data/attachment/album/202101/26/160522rpjvvrp787xs57fs.jpg | true | false | false | false | [
"Cookie",
"科学",
"MDN"
] | 硬核观察 | {
"viewnum": 3239,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "113.200.204.21",
"message": "又改名了，终于知道把名字加标题上了，坚持住，这样屏蔽比较方便。别再把名字藏起来恶心人了。",
"username": "来自陕西西安的 Chrome Mobile 87.0|Android 8.0 用户",
"date": "2021-01-26T19:08:32"
},
{
"postip": "36.101.25.33",
"message": "不想看就别来。我们加上前缀只是为了突出，而不是考虑你这种恶心需求。",
"username": "linux [Chrome 87.0|Mac 10.14]",
"date": "2021-01-26T23:15:01"
},
{
"postip": "114.248.76.174",
"message": "丫的你有多大仇，哪都能看见你",
"username": "来自北京的 Chrome 88.0|GNU/Linux 用户",
"date": "2021-02-19T16:03:22"
}
] | [
{
"raid": 13057,
"displayorder": 0
}
] | 更多：• 《自然》杂志评选出改变科学的 10 个计算机代码项目 • Mozilla 希望让社区接管 MDN 后续的维护工作 | 2021-01-26T16:07:51 | 2021-01-26T16:07:51 | 13,054 | /article-13054-1.html | 
大家好，《新闻拍一拍》栏目已经运行了将近 9 个月了，从今天开始，这个栏目将改名为《硬核观察》。新的栏目将近距离观察开源领域和互联网技术界的新动向，并由 “Linux 中国”开源社区的创始人，也就是我 —— 硬核老王来发表辛辣点评（吐槽）。
虽然我是一名从业二十多年的互联网老兵，但是，我的观点也可能会有失偏颇，所掌握的知识也或有谬误。因此，如果有讲的不对的地方，大家尽管群嘲我~~
那么，请大家跟着我来看看今天有什么值得点评（吐槽）的事情吧。
#### Cookie 要被废弃，谷歌找到了更好给你推送精准广告的方法
几十年来，Cookie 一直是大多数广告商在网上锁定用户的主要方式。面对美国和欧洲对在线数据的隐私保护力度的提高，苹果和 Mozilla 等致力于使广告商更难追踪在线个人用户数据。而这招致了像谷歌、Facebook 等主要依赖数字广告收入的公司的强烈反对。
面对高达 3300 亿美元的互联网广告市场，谷歌一直在寻找一种既能保护隐私而又可以跟踪用户偏好的方式，以[替代 Cookie](https://hothardware.com/news/google-phase-out-third-party-cookies-chrome)，这就是他们在研究、测试的<ruby> <a href="https://blog.chromium.org/2021/01/privacy-sandbox-in-2021.html"> 联合组群学习 </a> <rt> Federated Learning of Cohorts </rt></ruby>（FLoC）技术，这是谷歌 Chrome 浏览器内的一个浏览器扩展 API。
据谷歌说，FLoC 会使用机器学习算法来分析用户数据，然后根据个人访问的网站创建一个由数千人组成的群体。从浏览器本地收集的数据永远不会被共享。相反，共享的来自更广泛数千人群体数据，然后用于精准的定向广告。
然而，我认为，FLoC 和 Cookie 技术没有本质区别，只是在去隐私化方面做的更好一些罢了，本质上还是广告商的立场。
#### 《自然》杂志评选出改变科学的 10 个计算机代码项目
如今的科学研究已经大量的依赖于计算机硬件和软件。近日，《自然》（Nature）杂志评选出了这几十年来改变科学研究的 [10 个关键的计算机项目](https://www.nature.com/articles/d41586-021-00075-2)：
* 语言先驱：Fortran 编译器（1957 年）
* 信号处理器：快速傅立叶变换 FFT（1965 年）
* 分子编目：生物数据库（1965 年）
* 预测领先者：大气环流模式（1969 年）
* 数字运算机：BLAS（1979 年）
* 显微镜必备：NIH Image（1987 年）
* 序列搜索器：BLAST（1990 年）
* 预印本平台：[arXiv.org](http://arxiv.org/)（1991 年）
* 数据浏览器：IPython Notebook （2011 年）
* 快速学习器：AlexNet（2012 年）
原本是用于科学研究的计算机及互联网已经遍及我们的生活各个角落。但作为一个互联网技术人员，我觉得如果是由计算机和互联网从业人员来评选 10 个最重要的计算机代码项目，可能和这个名单会相差很多。
#### Mozilla 希望让社区接管 MDN 后续的维护工作
在去年底 Mozilla 的大裁员中，很多非常有价值的项目要么被裁员，要么被分家出去。这其中除了 Rust 语言、Servo 浏览器引擎之外，还有一个非常重要的项目团队也被整个裁撤了，这就是 Mozilla 开发者网络（MDN）。对于 Web 开发者来说，MDN 文档是非常有用而权威的资源。Mozilla 随后将所有的 MDN 文档都放到了 Github 上。
现在，Mozilla 宣布成立 [Open Web Docs 组织](https://opencollective.com/open-web-docs)（OWD）来让社区接手该文档的维护。OWD 得到了微软、谷歌等的支持，包括资金的支持。
当然，这个项目也非常欢迎个人贡献者参与和成为支持者。大家感兴趣的可以去[看看](https://opencollective.com/open-web-docs)，有钱的出钱，有力的出力，哪怕只是几美金。
|
||||
用于基本社区管理任务自动化的 5 个 Python 脚本 | Rich Bowen | https://opensource.com/article/20/3/automating-community-management-python | 如果某些事情不得不重复做三遍，尝试使其自动化。 | /data/attachment/album/202101/27/000544aakdc4mnmn6tzj8y.jpg.thumb.jpg | /data/attachment/album/202101/27/000544aakdc4mnmn6tzj8y.jpg | true | false | true | lujun9972 | stevenzdg988 | wxy | false | [
"脚本"
] | 技术 | {
"viewnum": 4146,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 如果某些事情不得不重复做三遍，尝试使其自动化。 | 2021-01-27T00:06:00 | 2021-01-27T00:06:00 | 13,055 | /article-13055-1.html |
>
> 如果某些事情不得不重复做三遍，尝试使其自动化。
>
>
>
我 [之前写过关于社区管理员的工作](http://drbacchus.com/what-does-a-community-manager-do/)，如果你问 10 位社区管理员，你会得到 12 个不同的答案。不过，大多数情况下，你做的是社区需要你在任何特定时刻做的事情。而且很多事情可能是重复的。
当我还是系统管理员时，我遵循一个规则：如果某些事必须做三遍，我会尝试使其自动化。当然，如今，使用诸如 Ansible 这样的强大工具，就有了一整套科学的方法。
我每天或每周要做的一些事情涉及在一些地方查找内容，然后生成信息的摘要或报告，然后发布到别处。这样的任务是自动化的理想选择。这些并不是什么 [难事](https://6dollarshirts.com/rocket-surgery)，当我与同事共享其中一些脚本时，总是至少有一个能证明这是有用的。
[在 GitHub](https://github.com/rbowen/centos-community-tools/tree/master/scripts) 上，我有几个每周都要使用的脚本。它们都不是很复杂，但每次都为我节省几分钟。其中一些是用 Perl 写的，因为我快 50 岁了（这些是我早些年写的）。有些是用 Python 写的，因为几年前，我决定要学习 Python。
以下是概述：
### tshirts.py
这个简单的 [tshirts.py 脚本](https://github.com/rbowen/centos-community-tools/blob/master/scripts/tshirts.py)会根据你要定制的活动 T 恤的数量，然后告诉你尺寸分布是什么。它将这些尺寸分布在一条正态曲线（也称为 “钟形曲线”）上，以我的经验，这和一个正常的会议观众的实际需求非常吻合。如果在美国使用，则可能需要将脚本中的值调整的稍大一些；如果在欧洲使用，则可能需要将脚本中的值稍稍缩小一些。你的情况也许不同。
用法：
```
[rbowen@sasha:community-tools/scripts]$ ./tshirts.py
How many shirts? 300
For a total of 300 shirts, order:
30.0 small
72.0 medium
96.0 large
72.0 xl
30.0 2xl
```
### followers.py
[followers.py 脚本](https://github.com/rbowen/centos-community-tools/blob/master/scripts/followers.py)为我提供了我关心的 Twitter 账号的关注者数量。
该脚本只有 14 行，没什么复杂的，但是它可能节省我十分钟的加载网页和查找数字的时间。
你需要编辑 `feed` 数组以添加你关心的帐户：
```
feeds = [
'centosproject',
'centos'
];
```
注意：如果你在英语国家以外的地方运行它，则可能无法正常工作，因为它只是一个简单的屏幕抓取脚本，它读取 HTML 并查找其中包含的特定信息。因此，当输出使用其他语言时，正则表达式可能不匹配。
用法：
```
[rbowen@sasha:community-tools/scripts]$ ./followers.py
centosproject: 11,479 Followers
centos: 18,155 Followers
```
### get\_meetups
[get\_meetups 脚本](https://github.com/rbowen/centos-community-tools/blob/master/scripts/get_meetups)S 另一种类别的脚本 —— API脚本。这个特定的脚本使用 [meetup.com](http://meetup.com) 网站的 API 来寻找在特定区域和时间范围内特定主题的聚会，以便我可以将它报告给我的社区。你所依赖的许多服务都提供了 API，因此你的脚本可以查找信息，而无需手动查找网页。学习如何使用这些 API 既令人沮丧又耗时，但是最终将获得可以节省大量时间的技能。
*免责声明：[meetup.com](http://meetup.com) 已于 2019 年 8 月更改了他们的 API，我还没有将这个脚本更新到新的API，所以它现在实际上并没有工作。在接下来的几周内请关注此版本的修复版本。*
### centos-announcements.pl
[centos-announcements.pl 脚本](https://github.com/rbowen/centos-community-tools/blob/master/scripts/centos-announcements.pl)要复杂得多，而且对我的用例来说非常特殊，但你可能有类似的情况。在本例中该脚本查看邮件列表存档（`centos-announce` 邮件列表），并查找具有特定格式的邮件，然后生成这些邮件的报告。报告有两种不同的格式：一种用于我的每月新闻通讯，另一种用于安排 Twitter 信息（借助于 Hootsuite）。
我使用 Hootsuite 为 Twitter 安排内容，它们具有便捷的 CSV（逗号分隔值）格式，你可以一次批量安排整整一周的推文。从各种数据源（比如：邮件列表、博客、其他网页）自动生成 CSV 格式可以节省大量时间。但是请注意，这可能只应该用于初稿，然后你可以对其进行检查和编辑，以便最终不会自动发布你不想要内容的推文。
### reporting.pl
[reporting.pl 脚本](https://github.com/rbowen/centos-community-tools/blob/master/scripts/sig_reporting/reporting.pl)也是相当特定的，以满足我的特殊需求，但是这个概念本身是通用的。我每月向 [CentOS SIG](https://wiki.centos.org/SpecialInterestGroup)（特殊兴趣小组）发送邮件，这些邮件计划在给定的月份报告。该脚本只是告诉我本月有哪些 SIG，并记录需要发送给他们的电子邮件。
但是，因以下两个原因，实际上并未发送该电子邮件。第一，我希望在消息发送之前对其进行编辑。第二，虽然发送电子邮件的脚本在过去很有效，但如今，很可能被当做垃圾邮件而被过滤。
### 总结
在这个存储库中还有一些其他脚本，这些脚本或多或少是针对我的特定需求的，但是我希望其中至少有一个脚本对你有用，并且希望这些脚本的多样性能激励你去自动化一些你自己的东西。我也希望看到你的自动化脚本存储库；在评论中链接他们！
---
via: <https://opensource.com/article/20/3/automating-community-management-python>
作者：[Rich Bowen](https://opensource.com/users/rbowen) 选题：[lujun9972](https://github.com/lujun9972) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
3 个纯文本记事工具 | Kevin Sonney | https://opensource.com/article/21/1/plain-text | 记笔记很重要，而纯文本是一种简单、中性的方式。这里有三个工具，你可以在不失去纯文本的简易和便携性的前提下，给你的笔记加点东西。 | /data/attachment/album/202101/27/153329o0waw16448hq0avf.jpg.thumb.jpg | /data/attachment/album/202101/27/153329o0waw16448hq0avf.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"笔记",
"纯文本"
] | 分享 | {
"viewnum": 5080,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 13044,
"displayorder": 0
},
{
"raid": 13059,
"displayorder": 0
}
] | 记笔记很重要，而纯文本是一种简单、中性的方式。这里有三个工具，你可以在不失去纯文本的简易和便携性的前提下，给你的笔记加点东西。 | 2021-01-27T15:34:00 | 2021-01-27T15:34:00 | 13,056 | /article-13056-1.html |
>
> 记笔记很重要，而纯文本是一种简单、中性的方式。这里有三个工具，你可以在不失去纯文本的简易和便携性的前提下，给你的笔记加点东西。
>
>
>
在前几年，这个年度系列涵盖了单个的应用。今年，我们除了关注 2021 年的策略外，还将关注一体化解决方案。欢迎来到 2021 年 21 天生产力的第五天。
纯文本是最具弹性的文档格式。纯文本文档体积小，可以在机器之间快速传输，并且可以在*任意*设备上阅读。因此，在纯文本文档中做笔记是很有意义的。
然而，纯文本也仅是纯文本。我们生活在一个富文本世界中，我们仍然需要标题、列表以及区分一个章节和另一个章节的方法。幸运的是，我们有几种方法可以添加这些元素，而不需要在纯文本文档中添加复杂的标记。
### Markdown
*Markdown （Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
由 Aaron Schwartz 和 John Gruber 创建的 [Markdown](https://opensource.com/article/19/9/introduction-markdown)，是我如今每天使用最多的格式。从读写 README 文件、文档、记笔记，甚至源代码注释，Markdown 让我可以在不牺牲轻松阅读文档的能力的情况下添加格式。
此外，Markdown 还有几个“扩展版本”，以允许那些不属于原始设计的项目。特别是，[GitHub 风格的 Markdown](https://guides.github.com/features/mastering-markdown/#GitHub-flavored-markdown) 由于其在同名的源码控制网站中的使用而异常流行。
许多文件编辑器都支持 Markdown 高亮显示，不需要额外的附加组件或工作。
### AsciiDoc
*AsciiDoc （Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
由 Stuart Rackham 创建的 [AsciiDoc](https://asciidoc.org/) 是向纯文本文档添加富文本元素的另一种方式。AsciiDoc 有许多生成文档、书籍和论文的功能。然而，这并不意味着它不能被用来做笔记。有很多环境（特别是在教育和研究领域），能够快速将笔记转换为更“正式”的格式是很有帮助的。
AsciiDoc 也有很多工具可以将文本转换为其他格式进行协作。还有一些附加组件可以从不同的源导入数据，并将其放入最终的文档中，或者处理特殊的格式，如 MathML 或 LaTeX。
### Org 模式
*ORG-Mode （Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
说到文本格式，我不能不提 [Org 模式](https://orgmode.org/)。它最初是为 [GNU Emacs](https://www.gnu.org/software/emacs/) 设计的，现在已经成为笔记、待办事项、文档等常用的纯文本格式之一。Org 模式可以在包括 [Vim](https://opensource.com/article/19/1/productivity-tool-org-mode) 在内的众多文本编辑器中编写和使用。Org 模式简单、易学，是我最喜欢的笔记文本格式之一。
最后，选择 Markdown、AsciiDoc 或 Org 模式作为纯文本笔记，是确保它们可以在任何地方被阅读和更新的一种方式。如果你和我一样，你会发现自己在做纸质笔记的时候，也会使用同样的语法！
---
via: <https://opensource.com/article/21/1/plain-text>
作者：[Kevin Sonney](https://opensource.com/users/ksonney) 选题：[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/) 荣誉推出
|
硬核观察 | Fedora 率先停用了 Chromium 的谷歌数据同步 API | 硬核老王 | 更多：• GNOME 40 Alpha 版发布 • 开源磁盘分区工具 GParted 1.2 开始支持 exFAT 文件系统 | /data/attachment/album/202101/27/170951rcncvexeu8q7qui0.jpg.thumb.jpg | /data/attachment/album/202101/27/170951rcncvexeu8q7qui0.jpg | true | false | false | false | [
"GNOME",
"Chromium",
"exFAT"
] | 硬核观察 | {
"viewnum": 2965,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "183.192.27.153",
"message": "给Fedora点赞。",
"username": "来自上海的 Chrome 88.0|Mac 11.1 用户",
"date": "2021-01-28T00:00:48"
},
{
"postip": "171.43.48.235",
"message": "哎，我可能也要转FIreFox了，FIreFox就是插件太少了",
"username": "来自湖北的 Chrome 88.0|GNU/Linux 用户",
"date": "2021-01-29T17:04:14"
}
] | [
{
"raid": 13054,
"displayorder": 0
}
] | 更多：• GNOME 40 Alpha 版发布 • 开源磁盘分区工具 GParted 1.2 开始支持 exFAT 文件系统 | 2021-01-27T17:09:58 | 2021-01-27T17:09:58 | 13,057 | /article-13057-1.html | 
#### Fedora 率先停用了 Chromium 的谷歌数据同步 API
前段时间，谷歌宣布“经过慎重的调查和考虑，将于 3 月 15 日限制第三方浏览器对谷歌私有数据同步 API 的调用”。这一消息引来了开源社区的强烈反对，这意味着许多基于 Chromium 开发的浏览器将不能使用谷歌账户登录进行数据同步。有开发者表示，“除了强迫用户转投谷歌浏览器，该公司没有任何其它理由去这么做！”
对此，Fedora 项目予以了回应，发布了禁用谷歌数据同步功能的 Chromium 版本。并鼓励用户转投自由开源的 Mozilla Firefox。
已经垄断了浏览器市场份额的 Chrome，越来越露出了獠牙，不过，我觉得，谷歌还是想想怎么在产品能力上别被微软 Edge 超过吧。而另外一方面，Mozilla Firefox 才是自由开源软件世界的指望。
#### GNOME 40 Alpha 版发布
就如我们之前[知道](/article-12631-1.html)的，在这个版本号时代，GNOME 也觉得自己的[版本号](https://discourse.gnome.org/t/new-gnome-versioning-scheme/4235)太小了，于是 GNOME 从 3.38 一下跳到了 GNOME 40。
GNOME 40.0 计划在今年 3 月底推出，今天刚刚[发布了 Alpha 版本](https://mail.gnome.org/archives/devel-announce-list/2021-January/msg00001.html)，带来了许多新变化。但是由于这次变化太多了，所以像 Ubuntu 21.04 等最近将要发布的发行版不会马上跟进，至少会等到下个版本才能使用 GNOME 40。
在 GNOME 40 中，最重要的[变化](https://download.gnome.org/core/40/40.alpha/NEWS)有：
* 集成了[刚刚发布](/article-12929-1.html)不久的 GTK 4
* GNOME Shell 使用 GPU 渲染大多数阴影
* 对 XWayland 的修复和改进
除此以外，还有一个需要注意的变化是，由于 Google 更改了关于开源项目 API 密钥的服务条款，GNOME 的 Web 浏览器 Epiphany 已经禁用了安全浏览钓鱼保护功能。
#### 开源磁盘分区工具 GParted 1.2 开始支持 exFAT 文件系统
著名的 GUI 的磁盘分区工具 GParted 日前发布了最新的 [1.2](https://mail.gnome.org/archives/gnome-announce-list/2021-January/msg00007.html) 版，在这个版本中增加了 exFAT 的支持。说实话，我是没想到居然现在才增加对 exFAT 的支持。因为，不但微软早就提供了 exFAT 驱动代码，而且从 [Linux 内核 5.7](https://www.phoronix.com/scan.php?page=news_item&px=Linux-5.7-Features-Week-One) 开始，由三星提供的 exFAT 驱动取代了微软提供的驱动程序之后，这个驱动的表现也越来越好了。
|
||||
Python 处理错误的原则 | Moshe Zadka | https://opensource.com/article/19/12/zen-python-errors | 这是 Python 之禅特别系列的一部分，重点是第十和第十一条原则：沉默的错误（或不沉默）。 | /data/attachment/album/202101/27/223251q261j2ndoccajc16.jpg.thumb.jpg | /data/attachment/album/202101/27/223251q261j2ndoccajc16.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"错误",
"异常"
] | 软件开发 | {
"viewnum": 3599,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 13053,
"displayorder": 0
},
{
"raid": 13082,
"displayorder": 0
}
] | 这是 Python 之禅特别系列的一部分，重点是第十和第十一条原则：沉默的错误（或不沉默）。 | 2021-01-27T22:33:04 | 2021-01-27T22:33:04 | 13,058 | /article-13058-1.html |
>
> 这是 Python 之禅特别系列的一部分，重点是第十和第十一条原则：沉默的错误（或不沉默）。
>
>
>
处理“异常情况”是编程中争论最多的问题之一。这可能是因为风险很大：处理不当的错误值甚至可以使庞大的系统瘫痪。由于“异常情况”从本质上来说，是测试不足的，但发生的频率却令人不快，因此，是否正确处理它们往往可以将一个噩梦般的系统与一个“可以工作”的系统区分开来。
从 Java 的 `checked` 异常，到 Erlang 的故障隔离，再到 Haskell 的 `Maybe`，不同的语言对错误处理的态度截然不同。
这两条 [Python 之禅](https://www.python.org/dev/peps/pep-0020/)是 Python 对这个话题的冥思。
### <ruby> 错误绝不应该悄悄传递... <rt> Errors should never pass silently… </rt></ruby>
当 Python 之禅在 Tim Peters 眼里闪烁而出之前，在维基百科被俗称为“维基”之前，第一个维基网站 [C2](https://wiki.c2.com/) 就已经存在了，它是一个编程指南的宝库。这些原则大多来自于 [Smalltalk](https://en.wikipedia.org/wiki/Smalltalk) 编程社区。Smalltalk 的思想影响了许多面向对象的语言，包括 Python。
C2 维基定义了<ruby> 武士原则 <rt> Samurai Principle </rt></ruby>：“胜利归来，要么不归。”用 Python 人的术语来说，它鼓励摒弃<ruby> 哨兵值 <rt> sentinel value </rt></ruby>，比如用返回 `None` 或 `-1` 来表示无法完成任务，而是采用引发异常的方式。一个 `None` 是无声的：它看起来像一个值，可以放在一个变量中，然后到处传递。有时，它甚至是一个*有效*的返回值。
这里的原则是，如果一个函数不能完成它的契约，它应该“高调失败”：引发一个异常。所引发的异常永远不会看起来像是一个可能的值。它将跳过 `returned_value = call_to_function(parameter)` 行，并上升到调用栈中，可能使程序崩溃。
崩溃的调试是很直接的：有一个堆栈跟踪来指示问题以及调用堆栈。崩溃可能意味着程序的必要条件没有满足，需要人为干预。它可能意味着程序的逻辑有问题。无论是哪种情况，高调失败都比一个隐藏的、“缺失”的值要好。用 `None` 来感染程序的有效数据，直到它被用在某个地方，就如你可能已经知道的，错误信息会说 “**None 没有方法进行拆分**”。
### <ruby> 除非显式消除 <rt> Unless explicitly silenced </rt></ruby>
有时需要显式地捕获异常。我们可能会预见到文件中的某些行格式错误，并希望以特殊的方式来处理它们，也许可以把它们放在一个“需要人来看看的行”的文件中，而不是让整个程序崩溃。
Python 允许我们用 `except` 来捕获异常。这意味着错误可以被*显式*消除。这种明确性意味着 `except` 行在代码审查中是可见的。质疑为什么应该在这里显式消除异常并从异常中恢复，是有意义的。自问一下我们是否捕获了太多或太少的异常也是有意义的。
因为这些全都是明确的，所以有人可以阅读代码并了解哪些异常是可以恢复的。
---
via: <https://opensource.com/article/19/12/zen-python-errors>
作者：[Moshe Zadka](https://opensource.com/users/moshez) 选题：[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/) 荣誉推出
|
如何使用 KDE 的生产力套件 Kontact | Kevin Sonney | https://opensource.com/article/21/1/kde-kontact | KDE 很棒，但当你使用这个统一个人信息管理器 Kontact 时，它才真正发挥了作用。 | /data/attachment/album/202101/28/094146fyx79l7zwbwej7ym.jpg.thumb.jpg | /data/attachment/album/202101/28/094146fyx79l7zwbwej7ym.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"KDE"
] | 分享 | {
"viewnum": 3479,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 13056,
"displayorder": 0
},
{
"raid": 13062,
"displayorder": 0
}
] | KDE 很棒，但当你使用这个统一个人信息管理器 Kontact 时，它才真正发挥了作用。 | 2021-01-28T09:41:00 | 2021-01-28T09:41:00 | 13,059 | /article-13059-1.html |
>
> KDE 很棒，但当你使用这个统一个人信息管理器 Kontact 时，它才真正发挥了作用。
>
>
>
在前几年，这个年度系列涵盖了单个的应用。今年，我们除了关注 2021 年的策略外，还将关注一体化解决方案。欢迎来到 2021 年 21 天生产力的第六天。
在很久很久以前，当编译内核还是获取 WiFi 驱动的唯一途径时，图形环境主要是用来运行网页浏览器和打开大量终端窗口。其外观和感觉是由程序作者选择使用的各种工具箱组成的大杂烩。然后，在 1996 年 [Matthias Ettrich](https://en.wikipedia.org/wiki/Matthias_Ettrich) 提出并随后发布了第一个版本的 [KDE](https://kde.org/)。它是基于当时专有的 [Qt](https://en.wikipedia.org/wiki/Qt_(software)) 工具箱（后来成为自由而开源的）。这个版本引发了 Linux 上的桌面革命，同一时期出现的还有使用当时的自由开源软件 GTK 工具包所创建的 [GNOME 桌面](https://www.gnome.org/) 。不管是 KDE 还是 GNOME，Linux 从一个*只有电脑操作人员使用的 Linux 操作系统*变成了一个人人都能使用的强大桌面环境。
*Fedora KDE 版的默认桌面 （Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
KDE Plasma 5 是最新的 KDE 版本，它的功能非常丰富，可以提高你的工作效率。它包括了 Konqueror 网页浏览器、Dolphin 文件管理器和 Konsole 终端模拟器，所有这些都为这个桌面环境提供了一个很好的坚实基础，但是 KDE 真正提高生产力的方法是这个统一个人信息管理器：[Kontact](https://kontact.kde.org/)。
Kontact 为其他几个 KDE 程序提供了一个单一的界面，包括：KMail（电子邮件）、KOrganizer（日历、待办事项和日记）、KAddressBook（地址簿）、KNotes（笔记）、Akregator（RSS/ATOM 订阅阅读器）等。第一次启动时，Kontact 会引导你完成电子邮件提供商的设置，它支持本地和远程邮件配置。然后，Kontact 会进入一个仪表板，默认情况下，该仪表板会显示最近的电子邮件、日历事件、计划任务和最近的笔记。
*Kontact 概览页面 （Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
设置“流程”看起来有点奇怪，因为在内置的本地账户之外没有配置统一的单一账户。在 Kontact（通过 KMail）引导你完成邮件设置后，你就可以进入日历页面添加你的日历，这里也配置了待办事项和日记应用（对于某些提供商，还可以配置通讯录）。
邮件和日历组件非常简单明了，可以如你期望地正常工作。待办事项页面和日记是与日历绑定的，这对于一些不完全支持所有日历类型的日历提供商来说可能是个问题（Google，我说的是你）。如果你使用的是这些提供商中的一个，你将需要为日记和待办事项创建一个特定的本地日历。
*Kontact Calendar （Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
待办事项列表有很多功能。虽然它可以作为一个简单的任务清单与提醒，它也支持一些轻量级的项目管理功能。它有一个完成百分比的滑块，可以从主列表视图中更新，这样你就可以跟踪进度。它能够附加文件和分配 1-10 的优先级。最后，它可以像其他日历约会一样将用户添加到任务中。
创建一个日记条目本质上是在日历上给自己创建一个笔记。它是一段形式自由的文本，就像写在实体笔记本和计划手册的某一天上那样。如果你要记录工作，写下每天的日记，或只是需要个地方记录会议记录，这个功能是非常*方便*的（本系列后面有更多关于这个的内容）。
*Kontact Journal （Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
构成 Kontact 的这些程序非常强大，如果你愿意的话，也可以作为单独的应用运行。Kontact 通过给你提供一个集中的地方，在一个应用内找到你所有的信息，从而提升了它们的实用性。
大多数发行版都允许你在没有 KDE 的情况下安装 Kontact 和它所使用的组件，但当它作为 KDE 桌面的一部分使用时，它才会真正发挥其作用。KDE 在 Fedora KDE 版、KUbuntu、KDE Neon（基于 Ubuntu LTS）和其他几个发行版中都是默认桌面。
---
via: <https://opensource.com/article/21/1/kde-kontact>
作者：[Kevin Sonney](https://opensource.com/users/ksonney) 选题：[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/) 荣誉推出
|
硬核观察 | 阿里云的 CentOS 替代品 OpenAnolis 宣布成立理事会 | 硬核老王 | 更多：• sudo 被爆有史以来最重要的高危漏洞，可 root 提权 • 微软 Office 借助容器技术，可编辑和使用恶意文档 | /data/attachment/album/202101/28/120652fxwputbt9m1u5mr1.jpg.thumb.jpg | /data/attachment/album/202101/28/120652fxwputbt9m1u5mr1.jpg | true | false | false | false | [
"OpenAnolis",
"sudo",
"Office"
] | 硬核观察 | {
"viewnum": 4534,
"commentnum": 4,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "125.89.31.98",
"message": "看看统信加微信那套恶心人的做为，还是渣的状态就欺负人了，坚决不理会国内任何发行版，又不是真正的社区，让他们壮大了还不翻天？",
"username": "来自广东珠海的 Firefox 84.0|Windows 10 用户",
"date": "2021-01-28T13:33:08"
},
{
"postip": "123.138.232.208",
"message": "没有灵魂的发行版软件，用起来意义真不大。比如红旗，红×",
"username": "来自陕西西安的 Chrome 87.0|GNU/Linux 用户",
"date": "2021-01-28T15:37:20"
},
{
"postip": "223.73.144.55",
"message": "正经人谁会用国产Linux(＃°Д°)",
"username": "来自广东深圳的 Firefox 85.0|Windows 10 用户",
"date": "2021-01-28T18:27:11"
},
{
"postip": "125.47.32.252",
"message": "主力系统绝对不用国产linux发行版",
"username": "来自河南郑州的 Chrome 88.0|GNU/Linux 用户",
"date": "2021-01-29T23:09:57"
}
] | [] | 更多：• sudo 被爆有史以来最重要的高危漏洞，可 root 提权 • 微软 Office 借助容器技术，可编辑和使用恶意文档 | 2021-01-28T12:07:01 | 2021-01-28T12:07:01 | 13,061 | /article-13061-1.html | 
#### 阿里云的 CentOS 替代品 OpenAnolis 宣布成立理事会
在 2020 年 12 月 CentOS 项目组宣布 CentOS 8 将于 2021 年底结束支持后，几个公有云服务商纷纷宣布基于之前的内部使用的发行版推出 CentOS 替代发行版，这包括华为云的 [openEuler](/article-12954-1.html)、腾讯云的 [TencentOS](/article-13039-1.html)、阿里云的 OpenAnolis。
OpenAnolis 社区由阿里云于 2020 年 9 月发起，而近日 OpenAnolis 社区[宣布](https://mp.weixin.qq.com/s/8OBrdd4xobL6eBaLdNk-4A)正式成立理事会、技术委员会和运营委员会。首批理事成员单位包括阿里云、统信软件、飞腾、兆芯、龙芯等主流芯片厂家和国内领先云公司，以及以 Intel 等国外领先芯片厂家为代表的合作伙伴单位。
OpenAnolis 社区将于 2021 年第二季度发布 Anolis OS 8，和 CentOS 完全兼容。
虽然基于对这些云服务商的历史风评，开源和技术社区对他们推出的这些发行版有种种不同看法，但是我认为，还是应该对这些发行版的成长持乐观态度，我也认为，这对国内的开源生态和发行版生态有一定的促进作用。当然，目前看起来，这些发行版在社区治理、项目价值方面还没有公开的、明确的计划和思考，存在着发展上的隐忧。
#### sudo 被爆有史以来最重要的高危漏洞，可 root 提权
安全研究人员今日[披露](https://blog.qualys.com/vulnerabilities-research/2021/01/26/cve-2021-3156-heap-based-buffer-overflow-in-sudo-baron-samedit)了一个 sudo 的高危漏洞 CVE-2021-3156，可以据此漏洞提权至 root。更严重的是，这个漏洞已经出现了近 10 年之久了。
几乎目前所有在使用的 sudo 版本都受影响，这包括从 1.8.2 到 1.8.32p2 的经典版本，以及从 1.9.0 到 1.9.5p1 所有稳定版本。研究人员说，该漏洞“可被任何本地用户利用”，在不需要认证的情况下获得最高权限。在流行的 Ubuntu 20.04、Debian 10、Fedora 33 等 Linux 发行版上均可以获取完全的 root 权限。
各大发行版都在纷纷准备补丁，系统管理员们要及时更新，这个漏洞“可能是有史以来最重要的 sudo 漏洞”。
#### 微软 Office 借助容器技术，可编辑和使用恶意文档
微软[上线](https://techcommunity.microsoft.com/t5/microsoft-security-and/application-guard-for-office-now-generally-available/ba-p/2007539)了适用于微软 Office 的应用防护功能。该功能可以在用户打开来自不信任来源的文件之前，将其放置在容器中，以便于抵御恶意威胁。据微软说，它不仅可以让你的系统免受恶意文档的侵害，而且由于使用了基于 Hyper-V 的容器，你的文件也受到保护，不会受基于系统内核的攻击。并且，这与以只读模式打开文件的保护视图不同，你可以在不离开容器的情况下以有限的容量编辑和打印文件。
很早以前，文档都是无害的，但是随着要求文档加入各种自动和智能的功能，文档也成了恶意代码的潜伏地。我认为，微软的这种容器式沙盒模式很有意义，可以真正隔离风险。之前没有推出这样功能，可能是因为容器的运行成本比较高吧。但是随着现在容器技术的发展，微软也在 Windows 上支持了更多的容器技术，将容器技术应用到文档上是一个很好的创举。
|
||||
使用标签组织你的任务列表 | Kevin Sonney | https://opensource.com/article/21/1/labels | 文件夹的用途是存储信息和任务。使用标签来帮助你更好地组织这些文件夹中的内容。 | /data/attachment/album/202101/29/150011k9sz3n0q99mmkems.jpg.thumb.jpg | /data/attachment/album/202101/29/150011k9sz3n0q99mmkems.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"标签"
] | 分享 | {
"viewnum": 1952,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 13059,
"displayorder": 0
},
{
"raid": 13070,
"displayorder": 0
}
] | 文件夹的用途是存储信息和任务。使用标签来帮助你更好地组织这些文件夹中的内容。 | 2021-01-29T15:02:44 | 2021-01-29T15:02:44 | 13,062 | /article-13062-1.html |
>
> 文件夹的用途是存储信息和任务。使用标签来帮助你更好地组织这些文件夹中的内容。
>
>
>
在前几年，这个年度系列报道了诸如 Notmuch 和 Syncthing 之类的开源的组织应用程序。今年，我们除了关注 2021 年的策略外，还将关注一体化解决方案。欢迎来到 2021 年 21 天生产力的第九天。
我用我的电子邮件、待办列表和笔记来做这件事，有一天我决定我要把这些“组织起来”，重新安排我保存东西的方式和位置。有时我发现了一个新的程序，我必须（再次）从头开始配置。有时，当前的方法已经花了很多时间，与我使用系统的时间相比，我花了更多的时间在保持存储顺序最新。我去年测试一些待办列表软件时，最后一个软件让我有了一个非常重要的认识。
*所有事情都有存放的地方（Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
让我打个比方。一个任务（或电子邮件或笔记）就像你在一次活动中收到的那件很酷的 T 恤。它是黑色的，有一个很棒的图案，后面有一个标签，上面写着尺寸，领口有一个标签，上面写着洗涤说明。到了该收起来的时候，它该放在哪里呢？是和黑色的 T 恤放在一起吗？是和类似主题的衬衫放在一起吗？是按尺码放吗？是按需要洗涤的方式？还是按材质？
一件 T 恤只能放在*一*个地方，即使它可以有多种特质。我们需要以同样的方式对待任务、电子邮件和笔记。大型[电子邮件提供商](https://opensource.com/alternatives/gmail)已经允许我们把一个标签当作一个文件夹。一封邮件（或一个文档或一个任务）可以同时在两个文件夹中！或者三个！甚至 11 个！
*它高达 11 个（Seth Kenlon, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
我必须明智地决定不再这样做。文件夹不是标签，标签也不是文件夹。这让我找到了我目前整理待办事项清单（和笔记，以及电子邮件）的规则：
1. 一个任务只应该在一个文件夹里。文件夹是以“大事”来命名的，比如一个地方或组织。我目前有三个文件夹来存放任务。“工作”、“家庭”和 “爱好”。当我专注于其中一个领域时，我知道我在看什么任务。
2. 一个任务可以有任意个我需要的标签。我尽量保持在三个左右或更少。
3. 一个任务应该有一个明确的意义。也许是你要写的程序的名字。也许是一些通用的东西，比如“要读的书”或“账单”。但如果你记不起 “4rg8sn5” 就是“要支付的账单”，这就对你没有帮助。
利用这些规则，如果我有一个“写第 9 天文章”的任务，它就会进入”爱好“文件夹，我给它打上 “OSDC”、“文章”、“2021” 的标签。如果我想在我的 [Elementary Planner](https://opensource.com/article/21/1/elementary-linux) 中看到我所有的 2021 年的任务，我可以搜索这个标签。任务最终会出现在 “OSDC” 的搜索中，其中可能还包括一个对文章发表评论的待办事项，一个开始规划 2022 年系列的待办事项，还有一个跟进我认为有好文章想法的人。
我的“工作”文件夹里的东西通常是按项目标记的。“完成管理 CLI 文档”可能会被分为 “github”、“prod” 和 “admin”。“docs” 标签包含了“工作”和”爱好“文件夹中的项目，因为写文档是这两个文件夹都需要做的事情。
*文件夹和标签（Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
将“标签”和“文件夹”进行心理分离，帮助我将任务进行分组和分类，而不至于过度。这也意味着我可以更快地找到事情，花更少的时间去维护我的待办事项清单，而花更多的时间去做清单上的事情。
---
via: <https://opensource.com/article/21/1/labels>
作者：[Kevin Sonney](https://opensource.com/users/ksonney) 选题：[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/) 荣誉推出
|
如何实现 DevOps 工具链 | Tereza Denkova | https://opensource.com/article/21/1/devops-tool-chain | 一套完整启用的 DevOps 工具链可推动你的创新计划，实现快速部署并节约成本。 | /data/attachment/album/202101/29/153905o35h8u9zy5k58bll.jpg.thumb.jpg | /data/attachment/album/202101/29/153905o35h8u9zy5k58bll.jpg | true | false | true | lujun9972 | AnyISalIn | wxy | false | [
"DevOps"
] | 观点 | {
"viewnum": 3868,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 一套完整启用的 DevOps 工具链可推动你的创新计划，实现快速部署并节约成本。 | 2021-01-29T15:39:46 | 2021-01-29T15:39:46 | 13,063 | /article-13063-1.html |
>
> 一套完整启用的 DevOps 工具链可推动你的创新计划，实现快速部署并节约成本。
>
>
>
不同规模和不同行业组织都致力于为提高软件交付的速度和质量提供解决方案。这不仅保证了他们的生存，还令他们在全球市场取得了成功。DevOps 可以帮助他们规划出一条最佳路线。
DevOps 是一个系统，通过引入不同的工具链连接不同工作流程，以便及时交付项目并降低所需的开销。
在我工作的 IT 服务公司 [Accedia](https://accedia.com/services/operations/devops/)，我们会帮助客户落地一套完整的 DevOps 工具链，这套工具链能帮助他们达到甚至超越他们的业务目标。在这篇文章，我会分享目前为止从 DevOps 项目中汲取的经验。
### DevOps 工具链是什么？
一套完善的 DevOps 工具链可以在不同阶段中使用不同的 DevOps 工具来解决特定的业务带来的挑战。一条工具链能保证前端和后端开发者、质量测试人员、客户都能够从中获得收益。构建工具链的目的是为了自动化开发和部署过程，以确保快速、可靠、预算友好地交付与创新。
我们发现成功构建一套 DevOps 工具链不是一个简单的事情。它需要实验和不断的完善，保证必要的流程是完全自动化的。
### 为什么你需要 DevOps 工具链
DevOps 工具链自动化了工作流中的所有技术元素。它能让不同团队在一个平台上进行工作，因此可以使你专注于业务战略以推动组织走向未来。
我们总结了五个实现 DevOps 工具链所带来的好处。你可以让管理层相信，是值得为 DevOps 工具链的开发投入资源和时间的。
1. **更快、更高效的生产部署**：DevOps 工具自动化了大部分软件开发进程。这会使产品开发专注于创新，交付更加敏捷，更领先于竞争对手。
2. **预算和时间优化**：将手动的任务转变为自动化会使你的组织节省时间和资源。当没有人为的错误和时间管理不足带来的额外支出，预算自然会得到优化。
3. **高效的开发**：DevOps 工具链会减少开发工作中不必要的延时，提高开发效率。前端、后端、质量测试人员的工作是一致的，所以没有人需要协调不同团队之间人员的交付。
4. **更快的部署意味着更高的质量**：DevOps 工具链保证了缺陷能够很快被解决，并且迅速完成高质量的部署进程。怎么样？它可以生成有针对性的告警，并将重要的事件通知给你的团队。这会让你主动地发现并解决潜在的问题，从而规避故障的不断的升级从而导致的客户服务不可用。
5. **及时事件管理**：DevOps 工具链有助于优化事件管理记录。它能够识别 IT 事件并且逐渐升级事件级别，通知给指定团队的成员，直到问题被解决。这意味着消息的接受和处理会更加的迅速，因为它们发送给了正确的目标。
### DevOps 工具链的实践
对我的团队来说，DevOps 并不新鲜。我们已经敏捷开发很长时间了，并且我们总是热衷于探索最优的工作流。在我们的实践中，往往都是应用复杂性增加从而带来了自动化的需求。
这是我们为一个客户配置的工具链。这个项目包含了移动运营方案，连接了金融交易的所有参与者 （卖方、买方、银行）。这个客户需要动态响应用户反馈并且将故障时间缩短到最小，从而来提高用户体验。我的团队设计了一套工具链用于自动化应用的维护和部署新功能。
*(Accedia, [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/))*
1. 首先，我们团队编写了自动化测试，可以立即识别应用程序的变更。
2. 当新版本已经准备就绪的时候，代码将被提交到 Gitlab 中。
3. 通过 Gitlab，提交会自动触发 Jenkins 构建。
4. 在 **持续集成中**，新的代码版本通过 [Chai](https://www.chaijs.com/) 和 [Mocha](https://mochajs.org/) 进行了测试，以检测是否运行正常。
5. 当测试通过，**持续部署阶段** 将会开始并创建一个可用的 Docker 镜像并上传到 Sonatype 的 [Nexus](https://www.sonatype.com/nexus/repository-oss)。（这是 Sonatype 公司的的一个开源工具）
6. 最后，新版本应用会通过 Nexus 下载并且部署到线上环境中，例如 [Docker](https://opensource.com/resources/what-docker) 容器 （**持续部署阶段**）
简而言之，每当有人在仓库中创建一个新的提交，又或者团队上传新的代码版本、功能、升级、缺陷修复等，应用程序包都会自动更新并且交付给客户。
这套系统拥有良好的事故控制能力以保证快速部署，但不以牺牲质量为代价。它对于用户的反馈是动态的，意味着新功能和旧功能的和更新只需要之前一半的时间，同时将故障时间降低到最低。
### 把它封装起来
一套完整并且正确实施的 DevOps 工具链可以从始至终推动你的创新计划并且加速部署。
根据你的需求，你的工具链可能看起来和这些不一样，但是我希望我们的工作流能够让你了解如何将自动化作为一种解决方案。
---
via: <https://opensource.com/article/21/1/devops-tool-chain>
作者：[Tereza Denkova](https://opensource.com/users/tereza-denkova) 选题：[lujun9972](https://github.com/lujun9972) 译者：[AnyISalIn](https://github.com/AnyISalIn) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
硬核观察 | 微软 Defender 去年阻止了 300 亿次电子邮件威胁 | 硬核观察 | 更多：• Canonical 继续努力希望用 Wayland 取代 X.Org • Linux 内核维护团队考虑缩减 5.10 LTS 的支持周期为两年 | /data/attachment/album/202101/29/192125ljuuotdezlo8clj8.jpg.thumb.jpg | /data/attachment/album/202101/29/192125ljuuotdezlo8clj8.jpg | true | false | false | false | [
"Defender",
"Wayland",
"内核"
] | 硬核观察 | {
"viewnum": 2692,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 更多：• Canonical 继续努力希望用 Wayland 取代 X.Org • Linux 内核维护团队考虑缩减 5.10 LTS 的支持周期为两年 | 2021-01-29T19:21:43 | 2021-01-29T19:21:43 | 13,065 | /article-13065-1.html | 
#### 微软 Defender 去年阻止了 300 亿次电子邮件威胁
在很多人心目中，微软还是那个操作系统和 Office 软件巨头，但是现在，游戏和云业务才是拉动微软营收快速增长的主要驱动力。除此以外，微软的安全业务也得到了快速的发展，在 2020 年里安全业务的总营收超过 100 亿美元，同比增长了 40%。
微软和其他竞争对手的主要区别在于能够综合使用人工智能和自动化的方法，大量使用微软安全机制的客户每天都会与该公司分享他们的安全信号。在 24 小时内，微软能够收集到 8 万亿条安全信号。微软 Defender 每天会执行 25 亿次的云端检测，成功阻止超过 60 亿次的端点威胁。适用于 Office 365 的 Defender 阻止了超过 300 亿次的电子邮件威胁。
#### Canonical 继续努力希望用 Wayland 取代 X.Org
Canonical 宣布，在 Ubuntu 21.04 中将使用 Wayland 取代 X.Org 作为默认显示服务器。不过，由于某些持续存在的问题，英伟达用户仍将默认使用 X.Org 显示服务器，可能要等到下个版本才能使用 Wayland。
X.org 实在太老太破了，Canonical 一直都想将它替换为自己开发的 Wayland。早在 2017 年的 Ubuntu 17.10 中，就采用了 Wayland 作为该版本的默认显示服务器。不过由于 X.org 的历史包袱太重，在 Ubuntu 的 LTS 版本中一直没有将 Wayland 作为默认显示服务器。
Canonical 已经为此做了非常多的工作，预计在明年的 22.04 LTS 中就可以使用 Wayland 作为默认显示服务器了。
不过，以我看来，对于生产环境更重要的 LTS 版本，其实图形界面并不太重要，所以无论采用哪种显示服务器，都不要紧。但是，Canonical 积极推进 Wayland 替代的意义很重要。
#### Linux 内核维护团队考虑缩减 5.10 LTS 的支持周期为两年
2017 年，Linux 宣布拓展 LTS 版本的内核服务年限，从原先的 2 年拓展至 6 年。这意味着 5.4 LTS 持续支持到 2025 年，4.19 LTS 支持到 2024 年，甚至于 4.14 LTS 都支持到 2024 年年初。
最近 Linux 稳定版内核的维护者格雷在邮件列表中对 Linux 5.10 支持时间进行了讨论，如果没有太充足的理由，Linux Kernel 5.10 LTS 只能维持两年。格雷表示，他希望知道有多少公司依赖于 5.10 LTS，如果大家都不是很在意的话，那么 5.10 可能就支持两年了，到明年年底停止支持。
看来，内核维护团队对这么多要维护的内核有点不堪重负了，毕竟，除了非 LTS 的内核之外，LTS 的内核就有好几个，而现在的内核也越来越复杂和庞大了。
|
||||
《代码英雄》第三季（8）：C 语言之巨变 | Redhat | https://www.redhat.com/en/command-line-heroes/season-3/the-c-change | C 语言和 UNIX 是现代计算的根基。我们这一季介绍的许多语言都与 C 语言有关，或者至少受到 C 语言的影响。但是 UNIX 和 C 都只是贝尔实验室Bell Labs的几个开发人员作为秘密计划项目创造出来两个成果而已。 | /data/attachment/album/202101/30/110804k0doyzrqjqfoybny.png.thumb.jpg | /data/attachment/album/202101/30/110804k0doyzrqjqfoybny.png | true | false | true | bestony | QwQ2000 | Northurland, wxy | false | [
"C语言",
"UNIX",
"代码英雄"
] | 代码英雄 | {
"viewnum": 10226,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 13027,
"displayorder": 0
}
] | C 语言和 UNIX 是现代计算的根基。我们这一季介绍的许多语言都与 C 语言有关，或者至少受到 C 语言的影响。但是 UNIX 和 C 都只是贝尔实验室Bell Labs的几个开发人员作为秘密计划项目创造出来两个成果而已。 | 2021-01-30T11:08:04 | 2021-01-30T11:08:04 | 13,066 | /article-13066-1.html |
>
> 代码英雄讲述了开发人员、程序员、黑客、极客和开源反叛者如何彻底改变技术前景的真实史诗。
>
>
>
>
> **什么是《代码英雄》**
>
>
> <ruby> 代码英雄 <rt> Command Line Heroes </rt></ruby>是世界领先的企业开源软件解决方案供应商红帽（Red Hat）精心制作的原创音频播客，讲述开发人员、程序员、黑客、极客和开源反叛者如何彻底改变技术前景的真实史诗。该音频博客邀请到了谷歌、NASA 等重量级企业的众多技术大牛共同讲述开源、操作系统、容器、DevOps、混合云等发展过程中的动人故事。
>
>
>
本文是《[代码英雄](https://www.redhat.com/en/command-line-heroes)》系列播客[《代码英雄》第三季（8）：C 语言之巨变](https://www.redhat.com/en/command-line-heroes/season-3/the-c-change)的[音频](https://cdn.simplecast.com/audio/a88fbe/a88fbe81-5614-4834-8a78-24c287debbe6/3d99eb43-d06f-489e-928b-d73157459e67/CLH_S3_E8_The_C_Change_v0_1_tc.mp3)脚本。
>
> 导语：C 语言和 UNIX 是现代计算的根基。我们这一季介绍的许多语言都与 C 语言有关，或者至少受到 C 语言的影响。但是 UNIX 和 C 都只是<ruby> 贝尔实验室 <rt> Bell Labs </rt></ruby>的几个开发人员作为秘密计划项目创造出来两个成果而已。
>
>
> 贝尔实验室是二十世纪中期的一个创新中心。Jon Gertner 将其描述为一个“创意工厂”。他们在二十世纪 60 年代最大的项目之一是帮助建立一个名为 Multics 的<ruby> 分时 <rt> time-sharing </rt></ruby>操作系统。Joy Lisi Rankin 博士解释了当时关于分时系统的一些宣传，它被描述为有可能使计算成为一种公共服务。大型团队投入了数年的精力来构建 Multics —— 但这并不是他们所希望的成果。贝尔实验室在 1969 年正式远离了分时系统。但正如 Andrew Tanenbaum 所描述的那样，一个由英雄组成的小团队还是坚持了下来。C 语言和 UNIX 就是这样的结果。他们并不知道他们的工作会对技术的发展产生多大的影响。
>
>
>
>
> **00:00:00 - 发言人 1**：
>
>
> 我们掀起了新一波的研究浪潮。我们的创造力正在延伸。
>
>
> **00:00:10 - 发言人 2**：
>
>
> 噪音、噪音。
>
>
> **00:00:13 - 发言人 1**：
>
>
> 这些人是贝尔电话实验室的设计工程师。
>
>
>
**00:00:16 - Saron Yitbarek**：
在上世纪 60 年代，坐落于新泽西州默里山的贝尔实验室，是科技革新的中心。在那里，我们的未来科技迈出了第一步。在那里，贝尔实验室发明了激光与晶体管，它还是信息论的摇篮。在 1968 年，贝尔实验室的四名程序员创造了一种极具开拓性的工具，它根本地改变了我们世界运行的方式，也标志着贝尔实验室的种种创新达到了新的高峰。
**00:00:53**：
我是 Saron Yitbarek，这里是《代码英雄》—— 一款来自红帽公司的原创播客。在一整季的节目中，我们追寻着编程语言世界中最具影响力的一些故事，现在，我们终于迎来了这一季的结尾。我认为，我们把最好的故事留到了最后。这个故事中的编程语言使本季中提到的其他编程语言成为了可能。在正好 50 年以前，C 语言在贝尔实验室被设计出来，这是一种非常基础的通用程序设计语言。它是如此的基础，以至于我们有时候都会忘记，C 语言的发明是多么意义深远的成就。
**00:01:35**：
为了得到事件的全貌，我们需要回到上世纪 60 年代，正好在 C 语言的诞生之前。那是一个一切似乎都有可能的时代。
**00:01:46 - Jon Gertner**：
在上世纪 60 年代，贝尔实验室简直是研究人员的世外桃源。在今天，已经很难找到与贝尔实验室相似的企业研发实验室了。
**00:01:56 - Saron Yitbarek**：
这是 Jon Gertner，他是《<ruby> 创意工厂：贝尔实验室与美国革新大时代 <rt> The Idea Factory: Bell Labs and the Great Age of American Innovation </rt></ruby>》的作者。我们采访了 Jon，让他大家解释当时贝尔实验室的情况。为什么在上世纪 60 年代，贝尔实验室能够成为他所说的“创意工厂”呢？
**00:02:15 - Jon Gertner**：
我想今天我们都相信——“竞争带来伟大的科技革新”，但是我不能确定这种观点的正确性，并且，其实，贝尔实验室的成就在一定程度上是与这种观点相悖的。贝尔实验室的工程师和科学家们并没有特别大的压力，但是与此同时，由于贝尔实验室在诸多的研究实验室中的地位，它又确实可以雇佣到最优秀、最聪明的研究者，并给他们足够的时间去研究感兴趣的问题，同时提供大量的资助。如果你能证明你的研究项目符合这家电话公司（LCTT 译注：指 AT&T）的目标和理念，你就能够得到经费。
**00:03:00 - Saron Yitbarek**：
而 Jon 强调，虽然贝尔实验室是一个商业公司的产物，但它的价值观还是比较接近学术界的。通过让员工自行决定工作方式及内容，贝尔实验室实践了类似于开源社区的开放式领导原则。
**00:03:19 - Jon Gertner**：
这是诸如苹果、谷歌与微软这样的大公司出现前的时代。计算机的历史更多的聚焦在西海岸，聚焦于<ruby> 自制计算机俱乐部 <rt> Homebrew Computer Clum </rt></ruby>这样的组织，以及从其中发展而出的企业；但是我认为贝尔实验室和那些企业一样重要。贝尔实验室坐落于一个现在看来几乎不可思议的地方：新泽西的郊区。但是，这里曾聚集了对科技突破做出了巨大贡献的科学家、研究者和计算机工程师，他们的研究成果对全世界都有惊天动地般的显著影响。
**00:03:54 - Saron Yitbarek**：
“<ruby> 分时 <rt> time-sharing </rt></ruby>”就是这些惊天动地的项目之一。它的核心概念很简单，实现难度却极大。他们能构建一个能够同时由成百上千的用户使用的操作系统吗？这样的发明将会使当时的计算机领域为之震动。从 1964 年起，贝尔实验室的天才们，与<ruby> 通用电气 <rt> General Electric </rt></ruby>和麻省理工学院（MIT）合作，试图集体推进这项工作的进展。实际上，麻省理工学院在一年前已经有了相关的研究项目，即<ruby> MAC 计划 <rt> Project MAC </rt></ruby>；但是现在，所有这些顶级团队已经团结起来，开始着手钻研大型主机分时操作系统的构建方式。
**00:04:40**：
实际上早在 1959 年，<ruby> 约翰·麦卡锡 <rt> John McCarthy </rt></ruby>就提出了分时操作系统的概念。请收听我们 [第七集](/article-13027-1.html) 的节目获知更多细节。他设想了一种可以在多个用户之间切换其“注意力”的大型计算机。麦卡锡认定，这样的一种机器有潜力极大地拓展现有的计算机文化。让我们来设想一下吧，如果一千名用户能够同时在一台机器上工作，你就完成了对整个编程与计算机世界的民主化。现在，这支群星荟萃的团队准备着手将麦卡锡的梦想变成现实，并为他们想象中的操作系统起了一个名字 —— Multics（LCTT 译注：Multi- 前缀代表“多人的”）。
**00:05:23**：
Multics 团队为分时操作系统进行了多年的工作，但是该项目遇到了严重的资金困难，并且在十年之后，项目仍然看不到尽头。雪上加霜的是，项目的领导者 Bill Baker 是一个化学家，对贝尔实验室的计算机科学部门并不感兴趣。除此之外，我们仍然能找到一个新的问题 —— 自尊心问题。
**00:05:46 - Jon Gertner**：
在贝尔实验室，人们每天习以为常的一件事情就是独自工作。我的意思是，贝尔实验室的人们有一种感觉：他们认为自己拥有一切他们所需要的的人才和构思，并且拥有最先进的科技，当他们遇到值得解决的问题时，他们有能力去解决这样的问题。这种看法可能有一定合理性；但是 Multics 项目在贝尔实验室没有进展，在某种程度上也可能是因为像这样更加复杂的、合作性的工作在贝尔实验室的体系中运转不良，也不能让那里的高管们满意。
**00:06:20 - Saron Yitbarek**：
Jon Gertner 是<ruby> 《创意工厂》 <rt> The Idea Factory </rt></ruby>一书的作者，他刚刚发表的新书是<ruby> 《世界尽头的冰》 <rt> The Ice at the End of the World </rt></ruby>。
**00:06:32**：
贝尔实验室于 1969 年四月正式宣布放弃 Multics 项目，但这是否就是故事的结尾呢？就贝尔实验室而言，分时操作系统 Multics 之梦已经破灭。但是这个梦真的结束了吗？结果却并不是这样，并非所有贝尔实验室的研究人员都放弃了分时操作系统。四个顽固的拒不退让者在所有人都已放弃之后，继续坚持这一梦想，而那就是下一个故事了。
**00:07:08**：
说实话，有些梦想太美好了，这样的梦想是很难被人抛弃的。
**00:07:12 - Joy Lisi Rankin**：
这是一件大事业。
**00:07:14 - Saron Yitbarek**：
这位是 Joy Lisi Rankin，她是<ruby> 《美国计算机人物史》 <rt> A People's History of Computing in the United States </rt></ruby>一书的作者。Joy 将会和我聊聊分时操作系统的理想，以及为什么分时操作系统如此不可或缺。
**00:07:27 - Joy Lisi Rankin**：
开发分时操作系统是一件重要且极富雄心壮志的事，直到该项目开始之前，大部分上世纪 60 年代早期的分时系统在一台主机上都约有 40 至 50 个终端。因此，提升终端的数量是重要性很高的一件事，贝尔实验室的雄心很可能超出了大部分人的认知，这也是这个项目在实现最初目的的过程中碰到了不少困难的原因。但是，尽管如此，分时操作系统继续以不同的形态发展，并真正地走向繁荣；分时操作系统不仅仅在麻省理工学院得到发展，也走向了其他的地方。
**00:08:09 - Saron Yitbarek**：
是啊。那么，当我们谈起上世纪 60 年代，是谁在推动分时操作系统的需求？你提到了麻省理工学院、通用电气公司和贝尔实验室。那么我们的关注点是商业还是学术团体？谁才是真正的推动者？
**00:08:23 - Joy Lisi Rankin**：
我认为学术团体和商业团体共同推动了发展的进程，除此以外，一些<ruby> 科学 <rt> scientific </rt></ruby>团体也参与了这项事业，因为，正如我之前所说，分时操作系统是一种更加一对一、富有互动性的计算体验。但是从另一个角度来看，我也会说教育工作者也同样在推动这件事的发展。并且，从国家的层面上讲，当时也在进行关于创建全国性计算设施的对话。那么，基本上来说，所谓的全国性计算设施指的就是全国性的分时操作系统网络。真的，美国的思想领袖们也有这样的言论，他们认为这样的系统会是与供电、电话、供水一样的基础性服务。
**00:09:08 - Saron Yitbarek**：
哇哦。
**00:09:08 - Joy Lisi Rankin**：
对啊，我知道的！这确实很……
**00:09:09 - Saron Yitbarek**：
那可真是一项大事业。
**00:09:11 - Joy Lisi Rankin**：
那是一项非常大的事业。
**00:09:13 - Saron Yitbarek**：
Joy 让我想起了一件事。尽管这一期节目主要聚焦于创造了 C 语言和 UNIX 操作系统的团队，但是在贝尔实验室之外，对分时操作系统的推动是一项运动，比任何一个团队都大。将计算机视为公共设施是一个非常有意义的想法，在这项事业中，有许多优秀的人物，可惜我们不能请他们来到这里，比如 Bob Albrecht 和 Martin Greenberger ，以及其他的一些杰出人物。
**00:09:37**：
好的，在进行了一些预先说明之后，让我继续和 Joy 的对话吧。
**00:09:41 - Joy Lisi Rankin**：
那么，当约翰·麦卡锡在麻省理工大学的演讲上首次公开的谈论分时操作系统时，他明确的将其与电力进行了比较，并说：“这是一个让所有人都能使用计算机的方式，不仅仅是在学校里和商业活动中，还在每个人的家里。”回首过去，再阅读当时的文章与档案，许多人都确信，未来会出现一种能够被规范化管理的计算公共设施。因此，人们对这种全国性的分时基础设施充满了信心和支持。
**00:10:22 - Saron Yitbarek**：
非常有趣的一点是，在 1970 年，IBM 实际上已经退出了分时操作系统这一产业。即使是通用电气也出售了他们的大型主机部门，不过他们还仍然保留了一部分分时操作系统相关的业务。让我们简单地谈一谈这些吧，1970 年发生了什么？
**00:10:39 - Joy Lisi Rankin**：
我认为 1970 年已经一定程度上已经成为某种标志，这也许是人为假想的标志，这一年标志着公共计算设施与分时操作系统产业的失败。从某些角度上来说，这种观点是错误的。我认为在上世纪 60 年代末期，麻省理工和 Multics 项目明显在创建一个支持上千个终端的分时操作系统上遇到了困难，而这是一个知名度极高、影响力很大的项目。在同一时期，数十个基于分时计算模型的商业项目在美国兴起并繁荣发展。这是一个科技泡沫。随后，对于分时操作系统的热情走向衰落。这不完全是因为通用电气出售了他们的计算主机业务，他们在上世纪 70 年代至 80 年代间一直保留着他们的分时计算业务，并且这一业务盈利状况良好。除此以外，当时的大学，例如麻省理工学院，也继续运行着他们的分时操作系统，直到上世纪 80 年代。
**00:11:52**：
因此，依我之见，“分时系统只是一个在上世纪 70 年代破碎的科技泡沫”的公共记忆之所以产生，一定程度上是因为人们过多地关注了 Multics 的困境。然而，事实上来说，如果我们回到过去，看一看当时的人们如何使用分时操作系统，以及分时操作系统赢得了多少利润，了解一下分时操作系统的成功，我们就会发现，其实上世纪 70 年代正是分时系统繁荣的年代。
**00:12:17 - Saron Yitbarek**：
现在让我们把眼光放回到贝尔实验室，由四位技术专家组成的小组想要创造他们自己的分时操作系统。他们是<ruby> 肯·汤普逊 <rt> Ken Thompson </rt></ruby>、<ruby> 丹尼斯·里奇 <rt> Dennis Ritchie </rt></ruby>、<ruby> 道格拉斯·麦克劳伊 <rt> Doug McIlroy </rt></ruby>、<ruby> 约瑟夫·欧桑纳 <rt> J.F. Ossanna </rt></ruby>。不过他们并不想完成 Multics，他们想要越级跳过 Multics，制作一个不受过往拖累、功能更为强大的操作系统，他们称之为 UNIX（LCTT 译注：Uni- 这个前缀代表“单一的”）。
**00:12:39 - Joy Lisi Rankin**：
我认为 Multics 是 UNIX 的灵感来源，其原因在于，许多在 Multics 上工作的程序员是如此享受分时操作系统在编程上的优点，以至于在 Multics 陷入困境时，他们便想要创造一个属于他们自己的分时环境。这些来自贝尔实验室的程序员，他们决定构建他们自己的编程框架与分时操作系统，这就是 UNIX 的起源。
**00:13:20 - Saron Yitbarek**：
Joy Lisi Rankin 是<ruby> 《美国计算机人物史》 <rt> A People's History of Computing in the United States </rt> <ruby> 一书的作者。 </ruby></ruby>
**00:13:29**：
<ruby> 丹尼斯·里奇 <rt> Dennis Ritchie </rt></ruby>将自己和其他三名同事称为一个<ruby> 团队 <rt> fellowship </rt></ruby>。他们几个开发者想要作为一个紧密的四人小团体而工作，并且他们需要一种能够协调他们程序设计的硬件。但是贝尔实验室已经放弃了分时操作系统的梦想，即便它是一个学术研究的世外桃源，给已经放弃的项目拨款这件事也超出了他们的底线。因此他们拒绝了使用新硬件的提议。为此事购买新的硬件太过昂贵了，为什么要冒险呢？但研究员们还是坚持了下来。
**00:14:05**：
汤普逊和里奇要求得到一种类似 GE645 的机器，这是他们一直用来进行 Multics 相关工作的型号。当他们得知无法得到经费时，他们刚刚在纸上潦草地写下一些关于文件系统的想法。最后，他们在一个他们称之为“太空旅行”的游戏中成功地实现了他们的一些想法，这个游戏运行在 PDP7 机型上，这种机型基本上与 Commodore 64 是同一个级别的。没有贝尔实验室的支持，他们的开发是缓慢的，至少开始是这样的，是一个字节、一个字节地前进的。这四人组复活了分时操作系统之梦，以他们称之为 UNIX 的形式。
**00:14:47**：
不过这里就是问题所在了：UNIX 操作系统是用汇编语言写成的。也就是说，他们用纸带向 PDP7 传输文件；你可以想象到，他们在缺乏理想的工具与上级的支持的情况下，努力构建这个开创性的操作系统时所遇到的困难。UNIX 已经获得生命，但还没有一种合适的编程语言能够让它歌唱。
**00:15:23**：
开发者们初次尝试为 UNIX 设计的语言称为 B 语言，由<ruby> 肯·汤普逊 <rt> Ken Thompson </rt></ruby>编写。
**00:15:30 - Andy Tanenbaum**：
这是 BCPL（<ruby> 基础综合编程语言 <rt> Basic Combined Programming Language </rt></ruby>）的一种衍生语言。
**00:15:33 - Saron Yitbarek**：
这位是 <ruby> 安德鲁·塔能鲍姆 <rt> Andy Tanenbaum </rt></ruby>。他是阿姆斯特丹的一位计算机科学教授，也是许多书籍的作者，包括经典教材<ruby> 《计算机网络》 <rt> Computer Networks </rt></ruby>。让我们听听他讲解汤普逊的 B 语言背后的故事。
**00:15:48 - Saron Yitbarek**：
所以说， B 语言是 BCPL 的一种衍生物？
**00:15:51 - Andy Tanenbaum**：
BCPL 源于一种构建 CPL 编译器的企图，这种语言编写的编译器确实能够起到作用，而 CPL 基于 ALGOL 60，ALGOL 60 语言又源于 ALGOL 58。ALGOL 58 则源于对 Fortran 进行改进的尝试。
**00:16:01 - Saron Yitbarek**：
搞明白了吗？现在的问题就是，B 语言有许多历史包袱。B 语言和它的这些前身相比，并没有太多的突破性改变，因此，B 语言不能完成让 UNIX 歌唱的挑战。B 语言中没有变量类型，对于初学者来说这是一个问题。除此以外，B 语言对应的汇编代码仍然比 B 语言编译器的<ruby> 线程代码 <rt> threaded-code </rt></ruby>技术 <sup class="footnote-ref"> <a href="#fn1" id="fnref1"> [1] </a></sup> 要快。
**00:16:31 - Andy Tanenbaum**：
BCPL 和 B 语言只有一种数据类型，就是<ruby> 双字节类型 <rt> word </rt> <ruby> 。双字节类型在基于双字节类型开发的 IBM 的 704 和 709、7090、7094 机型上效果不错，但是从 360 和其它所有的小型电脑开始的机型都是基于 <ruby> 单字节类型 <rt> byte </rt> </ruby> 的。在这种情况下，双字节类型就不是一个好主意了，它和现代计算机的匹配程度极其糟糕。因此，显然 B 语言无法解决现有的问题。 </ruby></ruby>
**00:16:57 - Saron Yitbarek**：
那么，该团队之前工作使用过的所有机器都是基于双字节类型的，但是在基于单字节对象的操作上，这种类型的机器就不够好用了。幸运的是，在这个时间点上，贝尔实验室的领导们又回来加入了 UNIX 项目，他们意识到了这个团队中正在产生令人激动的进展。他们资助了一台价值 65000 美元的 PDP-11，并且这台机器不是基于双字节类型的，而是面向单字节的。现在，装备上了 PDP-11，丹尼斯·里奇能够在处理编程语言的难题时更进一步。
**00:17:36 - Andy Tanenbaum**：
丹尼斯，以及在肯的少量帮助下，决定编写一种更加结构化新编程语言，包含其它数据类型，比如说<ruby> 字符类型 <rt> char </rt> <ruby> 、 <ruby> 整数类型 <rt> int </rt> </ruby> 和 <ruby> 长整数类型 <rt> long </rt> </ruby> 等等。 </ruby></ruby>
**00:17:47 - Saron Yitbarek**：
因此，在 1971 年至 1973 年之间，<ruby> 丹尼斯·里奇 <rt> Dennis Ritchie </rt></ruby>一直在调整 B 语言。他增加了一种字符类型，并且构建了一个新的编译器，这样就不需要再使用线程代码技术了。两年结束时，B 语言已经变成了一种崭新的语言，这就是 C 语言。
**00:18:08**：
C 语言是一种功能强大的语言，结合了高级功能和底层特性，能够让使用者直接进行操作系统编程。它的一切都是如此的恰到好处。C 语言从机器层次中进行了足够的抽象，以至于它也可以移植到其他的机型。它并非一种只能用来写写应用的语言。它几乎是一种通用的编程工具，无论是在个人电脑还是超级计算机上都十分有效，而这一点极其重要，因为个人电脑革命当时已经近在眼前。
**00:18:49**：
团队的成员们在确定了 C 语言就是正确的道路之后，就立刻用它重写了 UNIX 内核和许多 UNIX 组件。因此，只要你想使用 UNIX，你就必须使用 C 语言。C 语言的成功与 UNIX 的成功紧密的结合在了一起。
**00:19:06 - Andy Tanenbaum**：
C 语言的流行，其实主要不是因为它是一门比 B 语言更优秀的语言 —— 当然它确实比 B 语言优秀 —— 而是因为，它是编写 UNIX 的语言，并且当 UNIX 广泛发行的时候，它自带了一个 C 语言编译器；甚至最后它还配备了两个 C 语言编译器。那么，UNIX 受到了广泛欢迎，每个使用它的人都有了 C 编译器，而且 UNIX 的一切都是由 C 语言写成的。而 C 语言是一种相当不错的语言，它又是与 UNIX 共同出现的，那为什么还要找其他的编程语言呢？
**00:19:33 - Saron Yitbarek**：
从这里开始， C 语言的价值开始显现。
**00:19:35 - Andy Tanenbaum**：
由于 UNIX 是用 C 语言写成的，并且带有一个 C 语言编译器，C 语言与 UNIX 从一开始就在一定程度上互相依赖，因此，它们也共同成长。在一个关键的时间点，C 语言在 UNIX 系统中已经足够流行时，像 Steve Johnson 这样的人开发了可移植的 C 语言编译器，这种编译器可以为其他型号的计算机产生机器码。最终，出现了面向其他操作系统的 C 语言编译器，人们开始用 C 语言编写各种各样的软件 —— 从数据库系统到……天知道什么奇奇怪怪的玩意儿，因为 C 语言在各种环境下都可用，并且十分有效，效率很高。
**00:20:07 - Saron Yitbarek**：
因此，不久以后，人们也开始用 C 语言编写与 UNIX 无关的程序，因为这门语言的优点是显而易见的。Andy 将为我们讲述，C 语言如何完全接管了整个编程世界。
**00:20:20 - Andy Tanenbaum**：
我想说的是，C 语言在正确的时间出现在了正确的地点。在上世纪 70 年代，计算机的普及范围远比现在要小。普通人不会拥有计算机，并且对计算机一无所知，但是在大学和大企业所拥有的计算机中，有许多都使用了 UNIX 操作系统以及随之而来的 C 语言，也就是说，这些大学和大企业都在使用 C 语言。这些大学与大企业发布了大量的软件，也产生了大量的程序员。如果一个企业想招聘一名 C 程序员，发布招聘广告后一定会有人来应聘。如果想招聘一名 B 语言程序员，没人会来面试。
**00:20:49 - Saron Yitbarek**：
在 C 语言的世界中，有许多基础设施 —— 软件、函数库、头文件等，这一切编程工具都构成了一个完美的闭环。
**00:20:59 - Andy Tanenbaum**：
因此，C 语言变得越来越流行。
**00:21:02 - Saron Yitbarek**：
现在，互联网的兴起导致了人们对 C 语言安全性的关注，这些问题在变种中得到了部分解决，比如 C#。有些时候我们会觉得，好像所有的兴奋点都在 Python 或 Go 等新语言上。但是我们希望能在播客中试图做的一件事就是让大家回忆起当下的我们与历史的紧密关联，而 C 语言的影响至今仍然是不可思议的。
**00:21:29**：
C 语言在现代最出名的产物就是 UNIX 的教子 —— Linux，而 Linux 的绝大部分都是用 C 编写的。就连 Linux 项目使用的标准编译器 GCC（<ruby> GNU 编译器集合 <rt> GNU Compiler Collection </rt></ruby>），也是用 C 语言写成的。虽然这一点可能不太引人注意，但是今天所有聚集在 Linux 上的开源编程者，都与一种在半个世纪以前的语言相联系，而 C 语言的统治也在年复一年的增强。
**00:22:02 - Andy Tanenbaum**：
以上这些事情的结果就是世界上占支配地位的两种操作系统的诞生。一个是运行在 Linux 操作系统上的安卓，而 Linux 是重写 UNIX 操作系统的产物。而 iOS，本质上来讲是一种 4.4 版的 Berkeley UNIX。因此，安卓和 iOS 从本质上说都是 UNIX。我怀疑几乎所有的服务器都是运行在 UNIX 或 Linux 的某个版本上的。这些服务器在幕后发挥着巨大的作用，并且任何运行 UNIX 的系统都源于 C 语言，为 UNIX 所编写的一切程序都使用了 C 语言。C 语言确实是无处不在的。
**00:22:41 - Saron Yitbarek**：
<ruby> 安德鲁·塔能鲍姆 <rt> Andy Tanenbaum </rt></ruby>是一名计算机科学教授，他是《计算机网络》一书的作者。说点有趣的题外话吧，他同时也是 MINIX，一个免费、开源版本的 UNIX 的作者，而 MINIX 事实上也是<ruby> 林纳斯•托瓦兹 <rt> Linus Torvalds </rt></ruby>开发 Linux 的灵感来源。当然，Andy 使用 C 语言编写 MINIX。
**00:23:03 - Saron Yitbarek**：
今天，C 语言存在于我们生活中的任何一个角落，从火星上的漫游车到台式电脑上的浏览器。它影响了许多我们在本季节目中提到的语言，例如 Go、Javascript 和 Perl。由于 C 语言与 UNIX 密不可分的联系，C 语言很可能是分布最广泛的编程语言。
>
> **00:23:28 - 发言人 7**：
>
>
> 1998 年美国国家科学奖的获得者是——来自朗讯科技公司贝尔实验室的<ruby> 肯·汤普逊 <rt> Kenneth L. Thompson </rt></ruby>与<ruby> 丹尼斯·里奇 <rt> Dennis M. Ritchie </rt></ruby> 的团队。
>
>
>
**00:23:40 - Saron Yitbarek**：
回望上世纪 60 年代，这四位贝尔实验室的员工——<ruby> 肯·汤普逊 <rt> Ken Thompson </rt></ruby>，<ruby> 丹尼斯·里奇 <rt> Dennis Ritchie </rt></ruby>，<ruby> 道格拉斯·麦克劳伊 <rt> Doug McIlroy </rt></ruby>和<ruby> 约瑟夫·欧桑纳 <rt> J.F. Ossanna </rt></ruby>——他们那时还不得不向上级乞求关注和资助。但是在 1998 年，汤普逊和里奇就收到了美国国家科学奖，这是为了表彰他们在 C 语言和 UNIX 上的工作。他们也共享了一百万美元的图灵奖奖金。历史的眼光是公正的。
**00:24:10**：
在一整季的节目中，我们一直在追寻那些我们最喜爱的编程语言的发展沿革与魅力。无论它们像 C 语言一样搭上了操作系统发展的便车，又或者是像 Go 语言一样在一种新的基础架构上发展，有一件事是永恒不变的：编程语言有它们自己的生命。它们是活着的。它们出生，成长，走向成熟。有时，编程语言也会变老，走向消亡。我们越多的了解这些语言，我们越会发现编程语言是一股重要的力量，它们总是在不断地变化，以切合时代的需要。我们的职责就是意识到这些变化，并且加以回应。我们的语言一直都是构建我们想要的世界的最佳工具。
**00:25:00**：
以上就是我们所有第三季的《代码英雄》节目。我希望大家喜欢收听我们的节目。节目的第四季已经在制作中，即将推出，敬请期待。
**00:25:13**：
《代码英雄》是来自红帽公司的原创播客。
**00:25:18**：
如果你想深入了解 C 语言或者本季节目中我们提到的任何其他编程语言的故事，欢迎访问 [redhat.com/commandlineheroes](file:///Users/xingyuwang/develop/LCRH-wxy/translated/en/command-line-heroes/season-4)。我是 Saron Yitbarek ，下期之前，编程不止。
---
1. <ruby> 线程代码 <rt> threaded-code </rt></ruby>技术：一种通过把一系列调用指令转换成一完整的地址表，然后使用恰当的方式调用的技术。线程代码最初被用来减少代码的占用空间，提高代码密度。通俗地讲，这种技术有点类似于在 C 语言中把一系列的 switch-case 语句转化为用函数指针数组实现的形式。 [↩︎](#fnref1)
>
> **什么是 LCTT SIG 和 LCTT LCRH SIG**
>
>
> LCTT SIG 是 LCTT <ruby> 特别兴趣小组 <rt> Special Interest Group </rt></ruby>，LCTT SIG 是针对特定领域、特定内容的翻译小组，翻译组成员将遵循 LCTT 流程和规范，参与翻译，并获得相应的奖励。LCRH SIG 是 LCTT 联合红帽（Red Hat）发起的 SIG，当前专注任务是《代码英雄》系列播客的脚本汉化，已有数十位贡献者加入。敬请每周三、周五期待经过我们精心翻译、校对和发布的译文。
>
>
> 欢迎[加入 LCRH SIG](/article-12436-1.html) 一同参与贡献，并领取红帽（Red Hat）和我们联合颁发的专属贡献者证书。
>
>
>
---
via: <https://www.redhat.com/en/command-line-heroes/season-3/the-c-change>
作者：[Red Hat](https://www.redhat.com/en/command-line-heroes) 选题：[bestony](https://github.com/bestony) 译者：[QwQ2000](https://github.com/QwQ2000) 校对：[Northurland](https://github.com/Northurland), [wxy](https://github.com/wxy)
本文由 [LCRH](https://github.com/LCTT/LCRH) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
超级生产力：一款集成了 GitHub 的超酷开源待办事项列表应用 | Ankush Das | https://itsfoss.com/super-productivity/ | “超级生产力”是一款很棒的开源待办事项应用，可以帮助你管理任务、跟踪事务和管理时间。 | /data/attachment/album/202101/30/120650stbmeepbp020bb0b.jpg.thumb.jpg | /data/attachment/album/202101/30/120650stbmeepbp020bb0b.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"代办事项"
] | 分享 | {
"viewnum": 4531,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "114.86.151.20",
"message": "这软件名字好中二。",
"username": "来自上海的 Chrome 88.0|Mac 11.1 用户",
"date": "2021-01-30T18:04:08"
}
] | [] | “超级生产力”是一款很棒的开源待办事项应用，可以帮助你管理任务、跟踪事务和管理时间。 | 2021-01-30T12:06:48 | 2021-01-30T12:06:48 | 13,067 | /article-13067-1.html |
>
> “超级生产力”是一款很棒的开源待办事项应用，可以帮助你管理任务、跟踪事务和管理时间。
>
>
>
无论你做什么，提高工作效率是大多数人的共同目标。通常，你总会尝试各种[待办事项列表应用](https://itsfoss.com/to-do-list-apps-linux/)或者[记事应用](https://itsfoss.com/note-taking-apps-linux/)来帮助自己组织和提醒事情，从而高效地跟上工作进度。
当然，你可以看看那些清单，根据自己的喜好去尝试其中的一些。在这里，我遇到了一些独特的东西，如果你想要一个具有可靠的用户界面、GitHub/GitLab 集成以及一系列基本功能的桌面待办事项应用，你也许可以尝试一下。
<ruby> 超级生产力 <rt> Super Productivity </rt></ruby>看起来是一个令人印象深刻的待办事项列表应用，并提供一些独特的功能。在本文中，我将让你简单了解它的一切。
### 超级生产力：一个简单的而有吸引力的开源待办事项应用程序
“超级生产力”是一款开源应用，它由 [Johannes Millan](https://github.com/johannesjo) 在 GitHub 上积极维护。
对我来说，用户体验是最重要的，“超级生产力”提供的用户界面给我留下了十分深刻的印象。
它还提供了一堆基本功能以及一些有趣的选项。让我们来看看它们。
### “超级生产力”的功能
* 添加待办事项、说明
* 追踪花费在任务和休息上的时间
* 项目管理（与 JIRA、GitHub 和 GitLab 整合）
* 安排任务的能力
* 语言选择选项
* 同步到 Dropbox、Google Drive 或任何其他 WebDAV 存储位置
* 导入/导出功能
* 自动备份功能
* 能够调整定时器和计数器的行为
* 黑暗模式
* 在任务中添加附件
* 完全免费的重复任务
* 跨平台支持
除了我提到的功能外，你还会发现更多详细的设置和调整配置。
尤其是与 [JIRA](https://www.atlassian.com/software/jira)、[GitHub](https://github.com/) 和 [GitLab](https://about.gitlab.com) 的整合。你可以自动分配要进行的工作任务，而不需要检查你的电子邮件以了解问题跟踪器或议题的最近更新。
与我目前使用过的许多收费版的待办事项 Web 服务相比，你会惊讶地发现许多有用的功能完全免费。
### 在 Linux 上安装“超级生产力”
它有各种安装方式。我下载了 AppImage 文件测试了一下。但是，你也可以得到基于 Debian 的发行版的 deb 包。
它也可以作为一个 [snap](https://snapcraft.io/superproductivity) 来安装。你可以在 [GitHub 的发布部分](https://github.com/johannesjo/super-productivity/releases)中找到所有的包。
如果你感兴趣，可以查看它的 [GitHub 页面](https://github.com/johannesjo/super-productivity)来了解它的更多信息。
* [下载超级生产力](https://github.com/johannesjo/super-productivity/releases)
### 总结
我发现“超级生产力”的用户体验非常棒。所提供的功能非常有用，考虑到你可以获得一些你通常从收费版的待办事项 Web 服务中才能获得的高级功能，它可以成为大多数用户的完美替代品。
你可以简单地使用 Google Drive、Dropbox 或任何其他 WebDAV 存储位置同步数据。
它也可以取代像 [ActivityWatch](https://itsfoss.com/activitywatch/) 这样的服务，帮助你追踪你工作任务和保持闲置的时间。所以，它可以成为你提高生产力的一体化解决方案！
听起来很不错，对吧？
你对“超级生产力”有什么看法？请在下面的评论区告诉我你的想法。
---
via: <https://itsfoss.com/super-productivity/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[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/) 荣誉推出
|
硬核观察 | 美国版贴吧 Reddit 加入以太坊基金会，打造以太坊上的社区积分应用 | 硬核老王 | 更多：• 第三方补丁服务赶在微软之前修复了 Windows 的重大错误 • FreeBSD 降低对 i386 架构的支持力度 | /data/attachment/album/202101/30/131412io1auv5uz622vu52.jpg.thumb.jpg | /data/attachment/album/202101/30/131412io1auv5uz622vu52.jpg | true | false | false | false | [
"以太坊",
"微软",
"i386"
] | 硬核观察 | {
"viewnum": 2978,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 更多：• 第三方补丁服务赶在微软之前修复了 Windows 的重大错误 • FreeBSD 降低对 i386 架构的支持力度 | 2021-01-30T13:14:37 | 2021-01-30T13:14:37 | 13,068 | /article-13068-1.html | 
#### 美国版贴吧 Reddit 加入以太坊基金会，打造以太坊上的社区积分应用
Reddit 宣布[加强和以太坊基金会的合作](https://www.coindesk.com/reddit-joins-with-ethereum-foundation-to-build-scaling-tools "https://www.coindesk.com/reddit-joins-with-ethereum-foundation-to-build-scaling-tools")，致力于开发<ruby> 二层 <rt> layer 2 </rt></ruby>扩展工具，将项目从原型推向生产环境。最终让 Reddit 的<ruby> 社区积分 <rt> Community Points </rt></ruby>功能这样的项目能够支持数百万用户（Reddit 的日活用户超过 5000 万）。
社区积分成为去中心的通证，并通过二层网络支持更丰富的使用场景，是一个很好的探索。无论存在多少不足，以太坊的生态还是最丰富、最有活力的生态。
#### 第三方补丁服务赶在微软之前修复了 Windows 的重大错误
由于庞大的生态，微软在提供补丁方面总是不太及时，甚至有时候你需要等很久。因此，有时候，一些第三方会提供补丁来解救补丁缺位的困扰。
近日，0patch 发布了一个严重漏洞的补丁，解决了 Windows 安装程序中的一个本地提权零日漏洞，而微软的官方修复还迟迟未到。这个漏洞是安全研究人员在去年圣诞节前披露的。而当本月的微软补丁星期二到来时，这个漏洞的补丁依然没有发布，因此，第三方补丁服务就有了足够的补位空间。0patch 的这个修复方法是免费提供给大家的。
我觉得，或许，微软该开源，让更多的社区贡献者来参与到缺陷的发现和解决当中。
#### FreeBSD 降低对 i386 架构的支持力度
FreeBSD 项目[宣布](https://lists.freebsd.org/pipermail/freebsd-announce/2021-January/002006.html "https://lists.freebsd.org/pipermail/freebsd-announce/2021-January/002006.html")，从 FreeBSD 13 起，已有 35 年历史的 i386 架构将降为二级支持架构，i386 架构特定的问题可能不会去修复。主要 Linux 发行版也都陆续停止了对该架构的支持。i386 目前仍然是 FreeBSD 11 和 12 的一级支持架构，未来发布的 14 有可能会进一步降低对它的支持。
i386 如日中天的时代已经一去不返，虽然依旧有很多老旧硬件在运行着 FreeBSD 和 Linux，但是继续维持对老旧硬件的支持，对各个开源项目来说，都是一种负担。
|
||||
理解 ARM64 内核中对 52 位虚拟地址的支持 | Bhupesh Sharma | https://opensource.com/article/20/12/52-bit-arm64-kernel | 随着 64 位硬件的引入，增加了处理更大地址空间的需求。 | /data/attachment/album/202101/30/170448rynbm9b6nmb90403.jpg.thumb.jpg | /data/attachment/album/202101/30/170448rynbm9b6nmb90403.jpg | true | false | true | lujun9972 | mengxinayan | wxy | false | [
"ARM"
] | 技术 | {
"viewnum": 6611,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 随着 64 位硬件的引入，增加了处理更大地址空间的需求。 | 2021-01-30T17:05:00 | 2021-01-30T17:05:00 | 13,069 | /article-13069-1.html |
>
> 随着 64 位硬件的引入，增加了处理更大地址空间的需求。
>
>
>
当 64 位硬件变得可用之后，处理更大地址空间（大于 2^32 字节）的需求变得显而易见。现如今一些公司已经提供 64TiB 或更大内存的服务器，x86\_64 架构和 arm64 架构现在允许寻址的地址空间大于 2^48 字节（可以使用默认的 48 位地址支持）。
x86\_64 架构通过让硬件和软件启用五级页表以支持这些用例。它允许寻址的地址空间等于 2^57 字节（详情见 [x86：在 4.12 内核中启用 5 级页表](https://lwn.net/Articles/716916/)）。它突破了过去虚拟地址空间 128PiB 和物理地址空间 4PiB 的上限。
arm64 架构通过引入两个新的体系结构 —— ARMv8.2 LVA（更大的虚拟寻址） 和 ARMv8.2 LPA（更大的物理地址寻址） —— 拓展来实现相同的功能。这允许使用 4PiB 的虚拟地址空间和 4PiB 的物理地址空间（即分别为 2^52 位）。
随着新的 arm64 CPU 中支持了 ARMv8.2 体系结构拓展，同时现在开源软件也支持了这两种新的硬件拓展。
从 Linux 5.4 内核开始， arm64 架构中的 52 位（大）虚拟地址（VA）和物理地址（PA）得到支持。尽管[内核文档](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/arm64/memory.rst)描述了这些特性和新的内核运行时对旧的 CPU（硬件层面不支持 52 位虚拟地址拓展）和新的 CPU（硬件层面支持 52 位虚拟地址拓展）的影响，但对普通用户而言，理解这些并且如何 “选择使用” 52 位的地址空间可能会很复杂。
因此，我会在本文中介绍下面这些比较新的概念：
1. 在增加了对这些功能的支持后，内核的内存布局如何“翻转”到 Arm64 架构
2. 对用户态应用的影响，尤其是对提供调试支持的程序（例如：kexec-tools、 makedumpfile 和 crash-utility）
3. 如何通过指定大于 48 位的 mmap 参数，使用户态应用“选择”从 52 位地址空间接受 VA？
### ARMv8.2 架构的 LVA 和 LPA 拓展
ARMv8.2 架构提供两种重要的拓展：大虚拟寻址（LVA）和大物理寻址（LPA）。
当使用 64 KB 转换粒度时，ARMv8.2-LVA 为每个翻译表基地址寄存器提供了一个更大的 52 位虚拟地址空间。
在 ARMv8.2-LVA 中允许：
* 当使用 64 KB 转换粒度时，中间物理地址（IPA）和物理地址空间拓展为 52 位。
* 如果使用 64 KB 转换粒度来实现对 52 位物理地址的支持，那么一级块将会覆盖 4TB 的地址空间。
*需要注意的是这些特性仅在 AArch64 架构中支持。*
目前下列的 Arm64 Cortex-A 处理器支持 ARMv8.2 拓展：
* Cortex-A55
* Cortex-A75
* Cortex-A76
更多细节请参考 [Armv8 架构参考手册](https://developer.arm.com/documentation/ddi0487/latest/)。
### Arm64 的内核内存布局
伴随着 ARMv8.2 拓展增加了对 LVA 地址的支持（仅当以页大小为 64 KB 运行时可用），在第一级转换中，描述符的数量会增加。
用户地址将 63-48 位位置为 0，然而内核地址将这些位设置为 1。TTBRx 的选择由虚拟地址的 63 位决定。`swapper_pg_dir` 仅包含内核（全局）映射，然而 `pgd` 仅包含用户（非全局）的映射。`swapper_pg_dir` 地址会写入 TTBR1，且永远不会写入 TTBR0。
**页面大小为 64 KB 和三个级别的（具有 52 位硬件支持）的 AArch64 架构下 Linux 内存布局如下：**
```
开始 结束 大小 用途
-----------------------------------------------------------------------
0000000000000000 000fffffffffffff 4PB 用户
fff0000000000000 fff7ffffffffffff 2PB 内核逻辑内存映射
fff8000000000000 fffd9fffffffffff 1440TB [间隙]
fffda00000000000 ffff9fffffffffff 512TB Kasan 阴影区
ffffa00000000000 ffffa00007ffffff 128MB bpf jit 区域
ffffa00008000000 ffffa0000fffffff 128MB 模块
ffffa00010000000 fffff81ffffeffff ~88TB vmalloc 区
fffff81fffff0000 fffffc1ffe58ffff ~3TB [保护区域]
fffffc1ffe590000 fffffc1ffe9fffff 4544KB 固定映射
fffffc1ffea00000 fffffc1ffebfffff 2MB [保护区域]
fffffc1ffec00000 fffffc1fffbfffff 16MB PCI I/O 空间
fffffc1fffc00000 fffffc1fffdfffff 2MB [保护区域]
fffffc1fffe00000 ffffffffffdfffff 3968GB vmemmap
ffffffffffe00000 ffffffffffffffff 2MB [保护区域]
```
**4 KB 页面的转换查询表如下：**
```
+--------+--------+--------+--------+--------+--------+--------+--------+
|63 56|55 48|47 40|39 32|31 24|23 16|15 8|7 0|
+--------+--------+--------+--------+--------+--------+--------+--------+
| | | | | |
| | | | | v
| | | | | [11:0] 页内偏移量
| | | | +-> [20:12] L3 索引
| | | +-----------> [29:21] L2 索引
| | +---------------------> [38:30] L1 索引
| +-------------------------------> [47:39] L0 索引
+-------------------------------------------------> [63] TTBR0/1
```
**64 KB 页面的转换查询表如下：**
```
+--------+--------+--------+--------+--------+--------+--------+--------+
|63 56|55 48|47 40|39 32|31 24|23 16|15 8|7 0|
+--------+--------+--------+--------+--------+--------+--------+--------+
| | | | |
| | | | v
| | | | [15:0] 页内偏移量
| | | +----------> [28:16] L3 索引
| | +--------------------------> [41:29] L2 索引
| +-------------------------------> [47:42] L1 索引 (48 位)
| [51:42] L1 索引 (52 位)
+-------------------------------------------------> [63] TTBR0/1
```
### 内核对 52 位虚拟地址的支持
因为支持 LVA 的较新的内核应该可以在旧的 CPU（硬件不支持 LVA 拓展）和新的 CPU（硬件支持 LVA 拓展）上都正常运行，因此采用的设计方法是使用单个二进制文件来支持 52 位（如果硬件不支持该特性，则必须在刚开始启动时能回退到 48 位）。也就是说，为了满足 52 位的虚拟地址以及固定大小的 `PAGE_OFFSET`，`VMEMMAP` 必须设置得足够大。
这样的设计方式要求内核为了新的虚拟地址空间而支持下面的变量：
```
VA_BITS 常量 *最大的* 虚拟地址空间大小
vabits_actual 变量 *实际的* 虚拟地址空间大小
```
因此，尽管 `VA_BITS` 设置了最大的虚拟地址空间大小，但实际上支持的虚拟地址空间大小由 `vabits_actual` 确定（具体取决于启动时的切换）。
#### 翻转内核内存布局
保持一个单一内核二进制文件的设计方法要求内核的 `.text` 位于高位地址中，因此它们对于 48/52 位虚拟地址是不变的。因为内核地址检测器（KASAN）区域仅占整个内核虚拟地址空间的一小部分，因此对于 48 位或 52 位的虚拟地址空间，KASAN 区域的末尾也必须在内核虚拟地址空间的上半部分。（从 48 位切换到 52 位，KASAN 区域的末尾是不变的，且依赖于 `~0UL`，而起始地址将“增长”到低位地址）
为了优化 `phys_to_virt()` 和 `virt_to_phys()`，页偏移量将被保持在 `0xFFF0000000000000` （对应于 52 位），这消除了读取额外变量的需求。在早期启动时将会计算 `physvirt` 和 `vmemmap` 偏移量以启用这个逻辑。
考虑下面的物理和虚拟 RAM 地址空间的转换：
```
/*
* 内核线性地址开始于虚拟地址空间的底部
* 测试区域开始处的最高位已经是一个足够的检查，并且避免了担心标签的麻烦
*/
#define virt_to_phys(addr) ({ \
if (!(((u64)addr) & BIT(vabits_actual - 1))) \
(((addr) & ~PAGE_OFFSET) + PHYS_OFFSET)
})
#define phys_to_virt(addr) ((unsigned long)((addr) - PHYS_OFFSET) | PAGE_OFFSET)
在上面的代码中：
PAGE_OFFSET — 线性映射的虚拟地址的起始位置位于 TTBR1 地址空间
PHYS_OFFSET — 物理地址的起始位置以及 vabits_actual — *实际的*虚拟地址空间大小
```
### 对用于调试内核的用户态程序的影响
有几个用户空间应用程序可以用于调试正在运行的/活动中的内核或者分析系统崩溃时的 vmcore 转储（例如确定内核奔溃的根本原因）：kexec-tools、makedumpfile 和 crash-utility。
当用它们来调试 Arm64 内核时，因为 Arm64 内核内存映射被“翻转”，因此也会对它们产生影响。这些应用程序还需要遍历转换表以确定与虚拟地址相应的物理地址（类似于内核中的完成方式）。
相应地，在将“翻转”引入内核内存映射之后，由于上游破坏了用户态应用程序，因此必须对其进行修改。
我已经提议了对三个受影响的用户态应用程序的修复；有一些已经被上游接受，但其他仍在等待中：
* [提议 makedumpfile 上游的修复](http://lists.infradead.org/pipermail/kexec/2020-September/021372.html)
* [提议 kexec-tools 上游的修复](http://lists.infradead.org/pipermail/kexec/2020-September/021333.html)
* [已接受的 crash-utility 的修复](https://github.com/crash-utility/crash/commit/1c45cea02df7f947b4296c1dcaefa1024235ef10)
除非在用户空间应用程序进行了这些修改，否则它们将仍然无法调试运行/活动中的内核或分析系统崩溃时的 vmcore 转储。
### 52 位用户态虚拟地址
为了保持与依赖 ARMv8.0 虚拟地址空间的最大为 48 位的用户空间应用程序的兼容性，在默认情况下内核会将虚拟地址从 48 位范围返回给用户空间。
通过指定大于 48 位的 mmap 提示参数，用户态程序可以“选择”从 52 位空间接收虚拟地址。
例如：
```
.mmap_high_addr.c
----
maybe_high_address = mmap(~0UL, size, prot, flags,...);
```
通过启用以下的内核配置选项，还可以构建一个从 52 位空间返回地址的调试内核：
```
CONFIG_EXPERT=y && CONFIG_ARM64_FORCE_52BIT=y
```
*请注意此选项仅用于调试应用程序，不应在实际生产中使用。*
### 结论
总结一下：
1. 内核版本从 5.14 开始，新的 Armv8.2 硬件拓展 LVA 和 LPA 在内核中得到良好支持。
2. 像 kexec-tools 和 makedumpfile 被用来调试内核的用户态应用程序现在无法支持新拓展，仍在等待上游接受修补。
3. 过去的用户态应用程序依赖于 Arm64 内核提供的 48 位虚拟地址将继续原样工作，而较新的用户态应用程序通构指定超过 48 位更大的 mmap 提示参数来 “选择加入”已接受来自 52 位的虚拟地址。
---
*这篇文章参考了 [AArch64 架构下的 Linux 内存布局](https://www.kernel.org/doc/html/latest/arm64/memory.html) 和 [Linux 5.9.12 内核文档](https://elixir.bootlin.com/linux/latest/source/arch/arm64/include/asm/memory.h)。它们均为 GPLv2.0 许可。*
---
via: <https://opensource.com/article/20/12/52-bit-arm64-kernel>
作者：[Bhupesh Sharma](https://opensource.com/users/bhsharma) 选题：[lujun9972](https://github.com/lujun9972) 译者：[萌新阿岩](https://github.com/mengxinayan) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
为什么写日记能提高效率 | Kevin Sonney | https://opensource.com/article/21/1/open-source-journal | 写日记有着悠久的历史。这里有三个开源工具，可以帮助你写日记变得更轻松。 | /data/attachment/album/202101/31/082622p6wgh7szzuvevug4.jpg.thumb.jpg | /data/attachment/album/202101/31/082622p6wgh7szzuvevug4.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"日记"
] | 观点 | {
"viewnum": 5287,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 13062,
"displayorder": 0
},
{
"raid": 13073,
"displayorder": 0
}
] | 写日记有着悠久的历史。这里有三个开源工具，可以帮助你写日记变得更轻松。 | 2021-01-31T08:26:34 | 2021-01-31T08:26:34 | 13,070 | /article-13070-1.html |
>
> 写日记有着悠久的历史。这里有三个开源工具，可以帮助你写日记变得更轻松。
>
>
>
在前几年，这个年度系列涵盖了单个的应用。今年，我们除了关注 2021 年的策略外，还将关注一体化解决方案。欢迎来到 2021 年 21 天生产力的第十天。
在我的小学时代，商业互联网还没有出现，老师经常会给我们班级布置一个让我们写日记的作业。有时会针对一些特定的内容，例如特定格式的虫子列表和说明，或者是公民课的每周新闻摘要。
几个世纪以来，人们一直在写日记。它们是一种方便的信息保存方式。它们有很多形式，比如意大利的 [Zibaldone](https://en.wikipedia.org/wiki/Zibaldone)、[备忘录](https://en.wikipedia.org/wiki/Commonplace_book)，或者记录今天做了什么的事件日记。
*（Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
为什么我们要写某种日记呢？第一个原因是为了让我们不至于把所有的事情都记在脑子里。我们中没有多少人有<ruby> <a href="https://en.wikipedia.org/wiki/Eidetic_memory"> 遗觉记忆 </a> <rt> Eidetic memory </rt></ruby>，维护运行日记或一组笔记可以让我们更容易地参考我们之前做的一些事情。日记也更容易分享，因为它们可以在聊天、邮件中复制/粘贴。正如 [Robert Boyce](https://en.wikipedia.org/wiki/Robert_Boyce) 的名言：“知识就是力量。知识共享使力量倍增。”知识的共享是开源的一个内在组成部分。
*今天的日记 （Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
在写事件日记的时候，有一个很关键的点就是要快速、简单、方便。最简单的方法是打开文档，添加一行当前日期和备注，然后保存。
有几个程序或附加软件可以让这一切变得更简单。[GNote 的 Note of the Day 插件](https://help.gnome.org/users/gnote/unstable/addin-noteoftheday.html.en)会自动创建一个以日期为标题的笔记，可以用来保存当天的内容。
Emacs Org 模式有一个热键组合，可以“捕捉”事物并将其放入文档中。结合 [org-journal](https://github.com/bastibe/org-journal) 附加组件，这将在文档中创建当天的条目。
Kontact 的 KNotes 组件会自动将日期和时间添加到新笔记中。
*查找笔记 （Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
写日记或记录事情是一种方便的方法，可以记录做了什么和怎么做的。它的作用不仅仅是“我做了什么”，它还可以包括阅读的书籍、吃过的食物、去过的地方，以及一大堆对未来有用的信息。
---
via: <https://opensource.com/article/21/1/open-source-journal>
作者：[Kevin Sonney](https://opensource.com/users/ksonney) 选题：[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/) 荣誉推出
|
硬核观察 | iPhone 活跃用户突破 10 亿，中国是苹果成功的源泉 | 硬核老王 | 更多：• 微软宣布收入增长 17%，得益于 Azure 增长了 50% • Facebook 已经开源 700 个代码库，有 130 万名粉丝 | /data/attachment/album/202101/31/102147p6yonsnoe6nlr6c4.jpg.thumb.jpg | /data/attachment/album/202101/31/102147p6yonsnoe6nlr6c4.jpg | true | false | false | false | [
"Facebook",
"iPhone",
"Azure"
] | 硬核观察 | {
"viewnum": 3518,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 更多：• 微软宣布收入增长 17%，得益于 Azure 增长了 50% • Facebook 已经开源 700 个代码库，有 130 万名粉丝 | 2021-01-31T10:22:00 | 2021-01-31T10:22:00 | 13,072 | /article-13072-1.html | 
#### iPhone 活跃用户突破 10 亿，中国是苹果成功的源泉
最近，在路透社的[采访中](https://www.reuters.com/article/us-apple-results/apple-tops-wall-street-expectations-on-record-iphone-revenue-china-sales-surge-idUSKBN29W2TD?il=0)，苹果 CEO 蒂姆•库克称，目前全球客户使用的 iPhone 已经超过 10 亿部，而在 2019 年是 9 亿部。这个新的里程碑是在该公司历史上首次单季度收入超过 1000 亿美元的情况下实现的。在上个季度苹果至少销售了 9010 万台手机，市场份额达到了 23.4%。库克称，苹果在中国的发展机遇是公司成功的源泉。
而另一方面，华为在美国的制裁中不断挣扎，其手机销量[仅有 3230 万台](https://news.softpedia.com/news/apple-number-one-phone-maker-thanks-to-phenomenal-performance-532039.shtml)，市场份额为 8.4%，跌至第五位。这比去年同期至少下降了 42.4%。
一声叹息。
#### 微软宣布收入增长 17%，得益于 Azure 增长了 50%
近日，微软公布了其 21 财年第二季度的财报，其中有些[数据](https://news.softpedia.com/news/microsoft-announces-17-revenue-increase-thanks-to-50-azure-growth-532027.shtml)颇为有趣。该财报披露，微软的营收达到 431 亿美元，增幅不低于 17%，营业利润则大涨 29%，达到 179 亿美元。
虽然 2020 年对整个世界来说是可怕的一年，但从典型的办公室迁移到远程办公的过程中，微软的云服务得到了巨大的增长。微软的智能云部门的营收达到 146 亿美元，增长 23%，其中 Azure 就增长了 50%。微软 CEO 纳德拉对云计算产品表现非常满意，纳德拉说，“在过去的一年里，我们所见证的是席卷每家公司和每个行业的第二波数字化转型的曙光。……微软正以全球最大、最全面的云平台来推动这一转变。”
但是与之形成鲜明对比的是，Windows OEM 的营收仅增长了 1%，而 Xbox 内容和服务收入增长 40%。我们可以看到，传统的操作系统公司，无论是微软，还是 Canonical 和红帽，都在努力地将自己转变成一家云服务商。而个人桌面和操作系统，会逐渐退化为云服务的一个角落。
#### Facebook 已经开源 700 个代码库，有 130 万名粉丝
Facebook 回顾了 2020 年该公司在[开源方面的成绩](https://www.zdnet.com/article/open-source-at-facebook-700-repositories-and-1-3-million-followers/)。Facebook 的开源代码库现已增长到 700 多个，仅 2020 年就有 200 多个项目公开发布，超过了 2019 年增加的 170 个。这其中大约 15％ 的贡献是由该公司外部的参与者进行的，而前一年外部贡献者承担了总贡献的三分之一。
虽然不是很喜欢 Facebook 这个公司，但是就其在开源方面的贡献和表现，还是值得称许的。
|
||||
3 个自动化电子邮件过滤器的技巧 | Kevin Sonney | https://opensource.com/article/21/1/email-filter | 通过这些简单的建议，减少你的电子邮件并让你的生活更轻松。 | /data/attachment/album/202102/01/103638ozdejmy6eycm6omx.jpg.thumb.jpg | /data/attachment/album/202102/01/103638ozdejmy6eycm6omx.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"电子邮件",
"过滤器"
] | 技术 | {
"viewnum": 2889,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 13070,
"displayorder": 0
},
{
"raid": 13077,
"displayorder": 0
}
] | 通过这些简单的建议，减少你的电子邮件并让你的生活更轻松。 | 2021-02-01T10:36:00 | 2021-02-01T10:36:00 | 13,073 | /article-13073-1.html |
>
> 通过这些简单的建议，减少你的电子邮件并让你的生活更轻松。
>
>
>
在前几年，这个年度系列涵盖了单个的应用。今年，我们除了关注 2021 年的策略外，还将关注一体化解决方案。欢迎来到 2021 年 21 天生产力的第十二天。
如果有一件事是我喜欢的，那就是自动化。只要有机会，我就会把小任务进行自动化。早起打开鸡舍的门？我买了一扇门，可以在日出和日落时开门和关门。每天从早到晚实时监控鸡群？用 Node-RED 和 [OBS-Websockets](https://opensource.com/article/20/6/obs-websockets-streaming) 稍微花点时间，就能搞定。
我们还有电子邮件。几天前，我写过关于处理邮件的文章，也写过关于标签和文件夹的文章。只要做一点前期的工作，你就可以在邮件进来的时候，你就可以自动摆脱掉大量管理邮件的开销。
*是的，我有很多过滤器。（Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
有两种主要方式来过滤你的电子邮件：在服务端或者客户端上。我更喜欢在服务端上做，因为我不断地在尝试新的和不同的电子邮件客户端。（不，真的，我光这个星期就已经使用了五个不同的客户端。我可能有问题。）
无论哪种方式，我都喜欢用电子邮件过滤规则做几件事，以使我的电子邮件更容易浏览，并保持我的收件箱不混乱。
1. 将不紧急的邮件移到“稍后阅读”文件夹中。对我而言，这包括来自社交网络、新闻简报和邮件列表的通知。
2. 按列表或主题给消息贴上标签。我属于几个组织，虽然它们经常会被放在“稍后阅读”文件夹中，但我会添加第二个或第三个标签，以说明该来源或项目的内容，以帮助搜索时找到相关的东西。
3. 不要把规则搞得太复杂。这个想法让我困难了一段时间。我想把邮件发送到某个文件夹的所有可能情况都加到一个规则里。如果有什么问题或需要添加或删除的东西，有一个大规则只是让它更难修复。
*点击它，点击它就行！（Kevin Sonney, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*
说了这么多，还有一件事我一直在做，它有助于减少我花在电子邮件上的时间：退订邮件。两年前我感兴趣的那个邮件列表已经不感兴趣了，所以就不订阅了。产品更新通讯是我去年停止使用的商品？退订！这一直在积极解放我。我每年都会试着评估几次列表中的邮件信息是否（仍然）有用。
过滤器和规则可以是非常强大的工具，让你的电子邮件保持集中，减少花在它们身上的时间。而点击取消订阅按钮是一种解放。试试就知道了！
---
via: <https://opensource.com/article/21/1/email-filter>
作者：[Kevin Sonney](https://opensource.com/users/ksonney) 选题：[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/) 荣誉推出
|
全功能的二进制文件分析工具 Radare2 指南 | Gaurav Kamathe | https://opensource.com/article/21/1/linux-radare2 | Radare2 是一个为二进制分析定制的开源工具。 | /data/attachment/album/202102/01/112611baw4gpqlch10ps1c.jpg.thumb.jpg | /data/attachment/album/202102/01/112611baw4gpqlch10ps1c.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"二进制分享"
] | 技术 | {
"viewnum": 16369,
"commentnum": 3,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "59.63.206.206",
"message": "十分感谢，介绍的很详细。 Radare2，分析二进制的工具。有时间的话，研究一下",
"username": "phoenix_wangxd [Chrome 88.0|Mac 11.1]",
"date": "2021-02-02T23:19:46"
},
{
"postip": "182.150.24.62",
"message": "你好，请教一下 ii 命令显示二进制所有导入的库，那个lib字段为啥全是空的？有什么办法把lib字段显示出来吗？",
"username": "来自四川成都的 Chrome 94.0|Windows 10 用户",
"date": "2021-11-30T16:32:11"
},
{
"postip": "110.245.142.188",
"message": "ret2libc",
"username": "来自河北承德的 Firefox 109.0|Windows 10 用户",
"date": "2023-02-07T21:29:53"
}
] | [] | Radare2 是一个为二进制分析定制的开源工具。 | 2021-02-01T11:26:33 | 2021-02-01T11:26:33 | 13,074 | /article-13074-1.html |
>
> Radare2 是一个为二进制分析定制的开源工具。
>
>
>
在《[Linux 上分析二进制文件的 10 种方法](/article-12187-1.html)》中，我解释了如何使用 Linux 上丰富的原生工具集来分析二进制文件。但如果你想进一步探索你的二进制文件，你需要一个为二进制分析定制的工具。如果你是二进制分析的新手，并且大多使用的是脚本语言，这篇文章《[GNU binutils 里的九种武器](/article-11441-1.html)》可以帮助你开始学习编译过程和什么是二进制。
### 为什么我需要另一个工具？
如果现有的 Linux 原生工具也能做类似的事情，你自然会问为什么需要另一个工具。嗯，这和你用手机做闹钟、做笔记、做相机、听音乐、上网、偶尔打电话和接电话的原因是一样的。以前，使用单独的设备和工具处理这些功能 —— 比如拍照的实体相机，记笔记的小记事本，起床的床头闹钟等等。对用户来说，有一个设备来做多件（但相关的）事情是*方便的*。另外，杀手锏就是独立功能之间的*互操作性*。
同样，即使许多 Linux 工具都有特定的用途，但在一个工具中捆绑类似（和更好）的功能是非常有用的。这就是为什么我认为 [Radare2](https://rada.re/n/) 应该是你需要处理二进制文件时的首选工具。
根据其 [GitHub 简介](https://github.com/radareorg/radare2)，Radare2（也称为 r2）是一个“类 Unix 系统上的逆向工程框架和命令行工具集”。它名字中的 “2” 是因为这个版本从头开始重写的，使其更加模块化。
### 为什么选择 Radare2？
有大量（非原生的）Linux 工具可用于二进制分析，为什么要选择 Radare2 呢？我的理由很简单。
首先，它是一个开源项目，有一个活跃而健康的社区。如果你正在寻找新颖的功能或提供着 bug 修复的工具，这很重要。
其次，Radare2 可以在命令行上使用，而且它有一个功能丰富的图形用户界面（GUI）环境，叫做 Cutter，适合那些对 GUI 比较熟悉的人。作为一个长期使用 Linux 的用户，我对习惯于在 shell 上输入。虽然熟悉 Radare2 的命令稍微有一点学习曲线，但我会把它比作 [学习 Vim](https://opensource.com/article/19/3/getting-started-vim)。你可以先学习基本的东西，一旦你掌握了它们，你就可以继续学习更高级的东西。很快，它就变成了肌肉记忆。
第三，Radare2 通过插件可以很好的支持外部工具。例如，最近开源的 [Ghidra](https://ghidra-sre.org/) 二进制分析和<ruby> 逆向工具 <rt> reversing tool </rt></ruby>很受欢迎，因为它的反编译器功能是逆向软件的关键要素。你可以直接从 Radare2 控制台安装 Ghidra 反编译器并使用，这很神奇，让你两全其美。
### 开始使用 Radare2
要安装 Radare2，只需克隆其存储库并运行 `user.sh` 脚本。如果你的系统上还没有一些预备软件包，你可能需要安装它们。一旦安装完成，运行 `r2 -v` 命令来查看 Radare2 是否被正确安装：
```
$ git clone https://github.com/radareorg/radare2.git
$ cd radare2
$ ./sys/user.sh
# version
$ r2 -v
radare2 4.6.0-git 25266 @ linux-x86-64 git.4.4.0-930-g48047b317
commit: 48047b3171e6ed0480a71a04c3693a0650d03543 build: 2020-11-17__09:31:03
$
```
#### 获取二进制测试样本
现在 `r2` 已经安装好了，你需要一个样本二进制程序来试用它。你可以使用任何系统二进制文件（`ls`、`bash` 等），但为了使本教程的内容简单，请编译以下 C 程序：
```
$ cat adder.c
```
```
#include <stdio.h>
int adder(int num) {
return num + 1;
}
int main() {
int res, num1 = 100;
res = adder(num1);
printf("Number now is : %d\n", res);
return 0;
}
```
```
$ gcc adder.c -o adder
$ file adder
adder: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=9d4366f7160e1ffb46b14466e8e0d70f10de2240, not stripped
$ ./adder
Number now is : 101
```
#### 加载二进制文件
要分析二进制文件，你必须在 Radare2 中加载它。通过提供文件名作为 `r2` 命令的一个命令行参数来加载它。你会进入一个独立的 Radare2 控制台，这与你的 shell 不同。要退出控制台，你可以输入 `Quit` 或 `Exit` 或按 `Ctrl+D`：
```
$ r2 ./adder
-- Learn pancake as if you were radare!
[0x004004b0]> quit
$
```
#### 分析二进制
在你探索二进制之前，你必须让 `r2` 为你分析它。你可以通过在 `r2` 控制台中运行 `aaa` 命令来实现：
```
$ r2 ./adder
-- Sorry, radare2 has experienced an internal error.
[0x004004b0]>
[0x004004b0]>
[0x004004b0]> aaa
[x] Analyze all flags starting with sym. and entry0 (aa)
[x] Analyze function calls (aac)
[x] Analyze len bytes of instructions for references (aar)
[x] Check for vtables
[x] Type matching analysis for all functions (aaft)
[x] Propagate noreturn information
[x] Use -AA or aaaa to perform additional experimental analysis.
[0x004004b0]>
```
这意味着每次你选择一个二进制文件进行分析时，你必须在加载二进制文件后输入一个额外的命令 `aaa`。你可以绕过这一点，在命令后面跟上 `-A` 来调用 `r2`；这将告诉 `r2` 为你自动分析二进制：
```
$ r2 -A ./adder
[x] Analyze all flags starting with sym. and entry0 (aa)
[x] Analyze function calls (aac)
[x] Analyze len bytes of instructions for references (aar)
[x] Check for vtables
[x] Type matching analysis for all functions (aaft)
[x] Propagate noreturn information
[x] Use -AA or aaaa to perform additional experimental analysis.
-- Already up-to-date.
[0x004004b0]>
```
#### 获取一些关于二进制的基本信息
在开始分析一个二进制文件之前，你需要一些背景信息。在许多情况下，这可以是二进制文件的格式（ELF、PE 等）、二进制的架构（x86、AMD、ARM 等），以及二进制是 32 位还是 64 位。方便的 `r2` 的 `iI` 命令可以提供所需的信息：
```
[0x004004b0]> iI
arch x86
baddr 0x400000
binsz 14724
bintype elf
bits 64
canary false
class ELF64
compiler GCC: (GNU) 8.3.1 20190507 (Red Hat 8.3.1-4)
crypto false
endian little
havecode true
intrp /lib64/ld-linux-x86-64.so.2
laddr 0x0
lang c
linenum true
lsyms true
machine AMD x86-64 architecture
maxopsz 16
minopsz 1
nx true
os linux
pcalign 0
pic false
relocs true
relro partial
rpath NONE
sanitiz false
static false
stripped false
subsys linux
va true
[0x004004b0]>
[0x004004b0]>
```
### 导入和导出
通常情况下，当你知道你要处理的是什么样的文件后，你就想知道二进制程序使用了什么样的标准库函数，或者了解程序的潜在功能。在本教程中的示例 C 程序中，唯一的库函数是 `printf`，用来打印信息。你可以通过运行 `ii` 命令看到这一点，它显示了该二进制所有导入的库：
```
[0x004004b0]> ii
[Imports]
nth vaddr bind type lib name
―――――――――――――――――――――――――――――――――――――
1 0x00000000 WEAK NOTYPE _ITM_deregisterTMCloneTable
2 0x004004a0 GLOBAL FUNC printf
3 0x00000000 GLOBAL FUNC __libc_start_main
4 0x00000000 WEAK NOTYPE __gmon_start__
5 0x00000000 WEAK NOTYPE _ITM_registerTMCloneTable
```
该二进制也可以有自己的符号、函数或数据。这些函数通常显示在 `Exports` 下。这个测试的二进制导出了两个函数：`main` 和 `adder`。其余的函数是在编译阶段，当二进制文件被构建时添加的。加载器需要这些函数来加载二进制文件（现在不用太关心它们）：
```
[0x004004b0]>
[0x004004b0]> iE
[Exports]
nth paddr vaddr bind type size lib name
――――――――――――――――――――――――――――――――――――――――――――――――――――――
82 0x00000650 0x00400650 GLOBAL FUNC 5 __libc_csu_fini
85 ---------- 0x00601024 GLOBAL NOTYPE 0 _edata
86 0x00000658 0x00400658 GLOBAL FUNC 0 _fini
89 0x00001020 0x00601020 GLOBAL NOTYPE 0 __data_start
90 0x00000596 0x00400596 GLOBAL FUNC 15 adder
92 0x00000670 0x00400670 GLOBAL OBJ 0 __dso_handle
93 0x00000668 0x00400668 GLOBAL OBJ 4 _IO_stdin_used
94 0x000005e0 0x004005e0 GLOBAL FUNC 101 __libc_csu_init
95 ---------- 0x00601028 GLOBAL NOTYPE 0 _end
96 0x000004e0 0x004004e0 GLOBAL FUNC 5 _dl_relocate_static_pie
97 0x000004b0 0x004004b0 GLOBAL FUNC 47 _start
98 ---------- 0x00601024 GLOBAL NOTYPE 0 __bss_start
99 0x000005a5 0x004005a5 GLOBAL FUNC 55 main
100 ---------- 0x00601028 GLOBAL OBJ 0 __TMC_END__
102 0x00000468 0x00400468 GLOBAL FUNC 0 _init
[0x004004b0]>
```
### 哈希信息
如何知道两个二进制文件是否相似？你不能只是打开一个二进制文件并查看里面的源代码。在大多数情况下，二进制文件的哈希值（md5sum、sha1、sha256）是用来唯一识别它的。你可以使用 `it` 命令找到二进制的哈希值：
```
[0x004004b0]> it
md5 7e6732f2b11dec4a0c7612852cede670
sha1 d5fa848c4b53021f6570dd9b18d115595a2290ae
sha256 13dd5a492219dac1443a816ef5f91db8d149e8edbf26f24539c220861769e1c2
[0x004004b0]>
```
### 函数
代码按函数分组；要列出二进制中存在的函数，请运行 `afl` 命令。下面的列表显示了 `main` 函数和 `adder` 函数。通常，以 `sym.imp` 开头的函数是从标准库（这里是 glibc）中导入的：
```
[0x004004b0]> afl
0x004004b0 1 46 entry0
0x004004f0 4 41 -> 34 sym.deregister_tm_clones
0x00400520 4 57 -> 51 sym.register_tm_clones
0x00400560 3 33 -> 32 sym.__do_global_dtors_aux
0x00400590 1 6 entry.init0
0x00400650 1 5 sym.__libc_csu_fini
0x00400658 1 13 sym._fini
0x00400596 1 15 sym.adder
0x004005e0 4 101 loc..annobin_elf_init.c
0x004004e0 1 5 loc..annobin_static_reloc.c
0x004005a5 1 55 main
0x004004a0 1 6 sym.imp.printf
0x00400468 3 27 sym._init
[0x004004b0]>
```
### 交叉引用
在 C 语言中，`main` 函数是一个程序开始执行的地方。理想情况下，其他函数都是从 `main` 函数调用的，在退出程序时，`main` 函数会向操作系统返回一个退出状态。这在源代码中是很明显的，然而，二进制程序呢？如何判断 `adder` 函数的调用位置呢？
你可以使用 `axt` 命令，后面加上函数名，看看 `adder` 函数是在哪里调用的；如下图所示，它是从 `main` 函数中调用的。这就是所谓的<ruby> 交叉引用 <rt> cross-referencing </rt></ruby>。但什么调用 `main` 函数本身呢？从下面的 `axt main` 可以看出，它是由 `entry0` 调用的（关于 `entry0` 的学习我就不说了，留待读者练习）。
```
[0x004004b0]> axt sym.adder
main 0x4005b9 [CALL] call sym.adder
[0x004004b0]>
[0x004004b0]> axt main
entry0 0x4004d1 [DATA] mov rdi, main
[0x004004b0]>
```
### 寻找定位
在处理文本文件时，你经常通过引用行号和行或列号在文件内移动；在二进制文件中，你需要使用地址。这些是以 `0x` 开头的十六进制数字，后面跟着一个地址。要找到你在二进制中的位置，运行 `s` 命令。要移动到不同的位置，使用 `s` 命令，后面跟上地址。
函数名就像标签一样，内部用地址表示。如果函数名在二进制中（未剥离的），可以使用函数名后面的 `s` 命令跳转到一个特定的函数地址。同样，如果你想跳转到二进制的开始，输入 `s 0`：
```
[0x004004b0]> s
0x4004b0
[0x004004b0]>
[0x004004b0]> s main
[0x004005a5]>
[0x004005a5]> s
0x4005a5
[0x004005a5]>
[0x004005a5]> s sym.adder
[0x00400596]>
[0x00400596]> s
0x400596
[0x00400596]>
[0x00400596]> s 0
[0x00000000]>
[0x00000000]> s
0x0
[0x00000000]>
```
### 十六进制视图
通常情况下，原始二进制没有意义。在十六进制模式下查看二进制及其等效的 ASCII 表示法会有帮助：
```
[0x004004b0]> s main
[0x004005a5]>
[0x004005a5]> px
- offset - 0 1 2 3 4 5 6 7 8 9 A B C D E F 0123456789ABCDEF
0x004005a5 5548 89e5 4883 ec10 c745 fc64 0000 008b UH..H....E.d....
0x004005b5 45fc 89c7 e8d8 ffff ff89 45f8 8b45 f889 E.........E..E..
0x004005c5 c6bf 7806 4000 b800 0000 00e8 cbfe ffff ..x.@...........
0x004005d5 b800 0000 00c9 c30f 1f40 00f3 0f1e fa41 [email protected]
0x004005e5 5749 89d7 4156 4989 f641 5541 89fd 4154 WI..AVI..AUA..AT
0x004005f5 4c8d 2504 0820 0055 488d 2d04 0820 0053 L.%.. .UH.-.. .S
0x00400605 4c29 e548 83ec 08e8 57fe ffff 48c1 fd03 L).H....W...H...
0x00400615 741f 31db 0f1f 8000 0000 004c 89fa 4c89 t.1........L..L.
0x00400625 f644 89ef 41ff 14dc 4883 c301 4839 dd75 .D..A...H...H9.u
0x00400635 ea48 83c4 085b 5d41 5c41 5d41 5e41 5fc3 .H...[]A\A]A^A_.
0x00400645 9066 2e0f 1f84 0000 0000 00f3 0f1e fac3 .f..............
0x00400655 0000 00f3 0f1e fa48 83ec 0848 83c4 08c3 .......H...H....
0x00400665 0000 0001 0002 0000 0000 0000 0000 0000 ................
0x00400675 0000 004e 756d 6265 7220 6e6f 7720 6973 ...Number now is
0x00400685 2020 3a20 2564 0a00 0000 0001 1b03 3b44 : %d........;D
0x00400695 0000 0007 0000 0000 feff ff88 0000 0020 ...............
[0x004005a5]>
```
### 反汇编
如果你使用的是编译后的二进制文件，则无法查看源代码。编译器将源代码转译成 CPU 可以理解和执行的机器语言指令；其结果就是二进制或可执行文件。然而，你可以查看汇编指令（的助记词）来理解程序正在做什么。例如，如果你想查看 `main` 函数在做什么，你可以使用 `s main` 寻找 `main` 函数的地址，然后运行 `pdf` 命令来查看反汇编的指令。
要理解汇编指令，你需要参考体系结构手册（这里是 x86），它的应用二进制接口（ABI，或调用惯例），并对堆栈的工作原理有基本的了解：
```
[0x004004b0]> s main
[0x004005a5]>
[0x004005a5]> s
0x4005a5
[0x004005a5]>
[0x004005a5]> pdf
; DATA XREF from entry0 @ 0x4004d1
┌ 55: int main (int argc, char **argv, char **envp);
│ ; var int64_t var_8h @ rbp-0x8
│ ; var int64_t var_4h @ rbp-0x4
│ 0x004005a5 55 push rbp
│ 0x004005a6 4889e5 mov rbp, rsp
│ 0x004005a9 4883ec10 sub rsp, 0x10
│ 0x004005ad c745fc640000. mov dword [var_4h], 0x64 ; 'd' ; 100
│ 0x004005b4 8b45fc mov eax, dword [var_4h]
│ 0x004005b7 89c7 mov edi, eax
│ 0x004005b9 e8d8ffffff call sym.adder
│ 0x004005be 8945f8 mov dword [var_8h], eax
│ 0x004005c1 8b45f8 mov eax, dword [var_8h]
│ 0x004005c4 89c6 mov esi, eax
│ 0x004005c6 bf78064000 mov edi, str.Number_now_is__:__d ; 0x400678 ; "Number now is : %d\n" ; const char *format
│ 0x004005cb b800000000 mov eax, 0
│ 0x004005d0 e8cbfeffff call sym.imp.printf ; int printf(const char *format)
│ 0x004005d5 b800000000 mov eax, 0
│ 0x004005da c9 leave
└ 0x004005db c3 ret
[0x004005a5]>
```
这是 `adder` 函数的反汇编结果：
```
[0x004005a5]> s sym.adder
[0x00400596]>
[0x00400596]> s
0x400596
[0x00400596]>
[0x00400596]> pdf
; CALL XREF from main @ 0x4005b9
┌ 15: sym.adder (int64_t arg1);
│ ; var int64_t var_4h @ rbp-0x4
│ ; arg int64_t arg1 @ rdi
│ 0x00400596 55 push rbp
│ 0x00400597 4889e5 mov rbp, rsp
│ 0x0040059a 897dfc mov dword [var_4h], edi ; arg1
│ 0x0040059d 8b45fc mov eax, dword [var_4h]
│ 0x004005a0 83c001 add eax, 1
│ 0x004005a3 5d pop rbp
└ 0x004005a4 c3 ret
[0x00400596]>
```
### 字符串
查看二进制中存在哪些字符串可以作为二进制分析的起点。字符串是硬编码到二进制中的，通常会提供重要的提示，可以让你将重点转移到分析某些区域。在二进制中运行 `iz` 命令来列出所有的字符串。这个测试二进制中只有一个硬编码的字符串：
```
[0x004004b0]> iz
[Strings]
nth paddr vaddr len size section type string
―――――――――――――――――――――――――――――――――――――――――――――――――――――――
0 0x00000678 0x00400678 20 21 .rodata ascii Number now is : %d\n
[0x004004b0]>
```
### 交叉引用字符串
和函数一样，你可以交叉引用字符串，看看它们是从哪里被打印出来的，并理解它们周围的代码：
```
[0x004004b0]> ps @ 0x400678
Number now is : %d
[0x004004b0]>
[0x004004b0]> axt 0x400678
main 0x4005c6 [DATA] mov edi, str.Number_now_is__:__d
[0x004004b0]>
```
### 可视模式
当你的代码很复杂，有多个函数被调用时，很容易迷失方向。如果能以图形或可视化的方式查看哪些函数被调用，根据某些条件采取了哪些路径等，会很有帮助。在移动到感兴趣的函数后，可以通过 `VV` 命令来探索 `r2` 的可视化模式。例如，对于 `adder` 函数：
```
[0x004004b0]> s sym.adder
[0x00400596]>
[0x00400596]> VV
```
*(Gaurav Kamathe, [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/))*
### 调试器
到目前为止，你一直在做的是静态分析 —— 你只是在看二进制文件中的东西，而没有运行它，有时你需要执行二进制文件，并在运行时分析内存中的各种信息。`r2` 的内部调试器允许你运行二进制文件、设置断点、分析变量的值、或者转储寄存器的内容。
用 `-d` 标志启动调试器，并在加载二进制时添加 `-A` 标志进行分析。你可以通过使用 `db <function-name>` 命令在不同的地方设置断点，比如函数或内存地址。要查看现有的断点，使用 `dbi` 命令。一旦你放置了断点，使用 `dc` 命令开始运行二进制文件。你可以使用 `dbt` 命令查看堆栈，它可以显示函数调用。最后，你可以使用 `drr` 命令转储寄存器的内容：
```
$ r2 -d -A ./adder
Process with PID 17453 started...
= attach 17453 17453
bin.baddr 0x00400000
Using 0x400000
asm.bits 64
[x] Analyze all flags starting with sym. and entry0 (aa)
[x] Analyze function calls (aac)
[x] Analyze len bytes of instructions for references (aar)
[x] Check for vtables
[x] Type matching analysis for all functions (aaft)
[x] Propagate noreturn information
[x] Use -AA or aaaa to perform additional experimental analysis.
-- git checkout hamster
[0x7f77b0a28030]>
[0x7f77b0a28030]> db main
[0x7f77b0a28030]>
[0x7f77b0a28030]> db sym.adder
[0x7f77b0a28030]>
[0x7f77b0a28030]> dbi
0 0x004005a5 E:1 T:0
1 0x00400596 E:1 T:0
[0x7f77b0a28030]>
[0x7f77b0a28030]> afl | grep main
0x004005a5 1 55 main
[0x7f77b0a28030]>
[0x7f77b0a28030]> afl | grep sym.adder
0x00400596 1 15 sym.adder
[0x7f77b0a28030]>
[0x7f77b0a28030]> dc
hit breakpoint at: 0x4005a5
[0x004005a5]>
[0x004005a5]> dbt
0 0x4005a5 sp: 0x0 0 [main] main sym.adder+15
1 0x7f77b0687873 sp: 0x7ffe35ff6858 0 [??] section..gnu.build.attributes-1345820597
2 0x7f77b0a36e0a sp: 0x7ffe35ff68e8 144 [??] map.usr_lib64_ld_2.28.so.r_x+65034
[0x004005a5]> dc
hit breakpoint at: 0x400596
[0x00400596]> dbt
0 0x400596 sp: 0x0 0 [sym.adder] rip entry.init0+6
1 0x4005be sp: 0x7ffe35ff6838 0 [main] main+25
2 0x7f77b0687873 sp: 0x7ffe35ff6858 32 [??] section..gnu.build.attributes-1345820597
3 0x7f77b0a36e0a sp: 0x7ffe35ff68e8 144 [??] map.usr_lib64_ld_2.28.so.r_x+65034
[0x00400596]>
[0x00400596]>
[0x00400596]> dr
rax = 0x00000064
rbx = 0x00000000
rcx = 0x7f77b0a21738
rdx = 0x7ffe35ff6948
r8 = 0x7f77b0a22da0
r9 = 0x7f77b0a22da0
r10 = 0x0000000f
r11 = 0x00000002
r12 = 0x004004b0
r13 = 0x7ffe35ff6930
r14 = 0x00000000
r15 = 0x00000000
rsi = 0x7ffe35ff6938
rdi = 0x00000064
rsp = 0x7ffe35ff6838
rbp = 0x7ffe35ff6850
rip = 0x00400596
rflags = 0x00000202
orax = 0xffffffffffffffff
[0x00400596]>
```
### 反编译器
能够理解汇编是二进制分析的前提。汇编语言总是与二进制建立和预期运行的架构相关。一行源代码和汇编代码之间从来没有 1:1 的映射。通常，一行 C 源代码会产生多行汇编代码。所以，逐行读取汇编代码并不是最佳的选择。
这就是反编译器的作用。它们试图根据汇编指令重建可能的源代码。这与用于创建二进制的源代码绝不完全相同，它是基于汇编的源代码的近似表示。另外，要考虑到编译器进行的优化，它会生成不同的汇编代码以加快速度，减小二进制的大小等，会使反编译器的工作更加困难。另外，恶意软件作者经常故意混淆代码，让恶意软件的分析人员望而却步。
Radare2 通过插件提供反编译器。你可以安装任何 Radare2 支持的反编译器。使用 `r2pm -l` 命令可以查看当前插件。使用 `r2pm install` 命令来安装一个示例的反编译器 `r2dec`：
```
$ r2pm -l
$
$ r2pm install r2dec
Cloning into 'r2dec'...
remote: Enumerating objects: 100, done.
remote: Counting objects: 100% (100/100), done.
remote: Compressing objects: 100% (97/97), done.
remote: Total 100 (delta 18), reused 27 (delta 1), pack-reused 0
Receiving objects: 100% (100/100), 1.01 MiB | 1.31 MiB/s, done.
Resolving deltas: 100% (18/18), done.
Install Done For r2dec
gmake: Entering directory '/root/.local/share/radare2/r2pm/git/r2dec/p'
[CC] duktape/duktape.o
[CC] duktape/duk_console.o
[CC] core_pdd.o
[CC] core_pdd.so
gmake: Leaving directory '/root/.local/share/radare2/r2pm/git/r2dec/p'
$
$ r2pm -l
r2dec
$
```
### 反编译器视图
要反编译一个二进制文件，在 `r2` 中加载二进制文件并自动分析它。在本例中，使用 `s sym.adder` 命令移动到感兴趣的 `adder` 函数，然后使用 `pdda` 命令并排查看汇编和反编译后的源代码。阅读这个反编译后的源代码往往比逐行阅读汇编更容易：
```
$ r2 -A ./adder
[x] Analyze all flags starting with sym. and entry0 (aa)
[x] Analyze function calls (aac)
[x] Analyze len bytes of instructions for references (aar)
[x] Check for vtables
[x] Type matching analysis for all functions (aaft)
[x] Propagate noreturn information
[x] Use -AA or aaaa to perform additional experimental analysis.
-- What do you want to debug today?
[0x004004b0]>
[0x004004b0]> s sym.adder
[0x00400596]>
[0x00400596]> s
0x400596
[0x00400596]>
[0x00400596]> pdda
; assembly | /* r2dec pseudo code output */
| /* ./adder @ 0x400596 */
| #include <stdint.h>
|
; (fcn) sym.adder () | int32_t adder (int64_t arg1) {
| int64_t var_4h;
| rdi = arg1;
0x00400596 push rbp |
0x00400597 mov rbp, rsp |
0x0040059a mov dword [rbp - 4], edi | *((rbp - 4)) = edi;
0x0040059d mov eax, dword [rbp - 4] | eax = *((rbp - 4));
0x004005a0 add eax, 1 | eax++;
0x004005a3 pop rbp |
0x004005a4 ret | return eax;
| }
[0x00400596]>
```
### 配置设置
随着你对 Radare2 的使用越来越熟悉，你会想改变它的配置，以适应你的工作方式。你可以使用 `e` 命令查看 `r2` 的默认配置。要设置一个特定的配置，在 `e` 命令后面添加 `config = value`：
```
[0x004005a5]> e | wc -l
593
[0x004005a5]> e | grep syntax
asm.syntax = intel
[0x004005a5]>
[0x004005a5]> e asm.syntax = att
[0x004005a5]>
[0x004005a5]> e | grep syntax
asm.syntax = att
[0x004005a5]>
```
要使配置更改永久化，请将它们放在 `r2` 启动时读取的名为 `.radare2rc` 的启动文件中。这个文件通常在你的主目录下，如果没有，你可以创建一个。一些示例配置选项包括：
```
$ cat ~/.radare2rc
e asm.syntax = att
e scr.utf8 = true
eco solarized
e cmd.stack = true
e stack.size = 256
$
```
### 探索更多
你已经看到了足够多的 Radare2 功能，对这个工具有了一定的了解。因为 Radare2 遵循 Unix 哲学，即使你可以从它的主控台做各种事情，它也会在下面使用一套独立的二进制来完成它的任务。
探索下面列出的独立二进制文件，看看它们是如何工作的。例如，用 `iI` 命令在控制台看到的二进制信息也可以用 `rabin2 <binary>` 命令找到：
```
$ cd bin/
$
$ ls
prefix r2agent r2pm rabin2 radiff2 ragg2 rarun2 rasm2
r2 r2-indent r2r radare2 rafind2 rahash2 rasign2 rax2
$
```
你觉得 Radare2 怎么样？请在评论中分享你的反馈。
---
via: <https://opensource.com/article/21/1/linux-radare2>
作者：[Gaurav Kamathe](https://opensource.com/users/gkamathe) 选题：[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/) 荣誉推出
|
硬核观察 | 瞠目结舌：为了重新启用 Flash 支持，南非税务局发布了自己的 Web 浏览器 | 硬核老王 | 更多：• 微软宣布开源可扩展存储引擎 ESE，几乎用在所有 Windows 之中 • 我们可能高估了每天的 COBOL 事务数量 | /data/attachment/album/202102/01/125419r51nw5noyowr0leo.jpg.thumb.jpg | /data/attachment/album/202102/01/125419r51nw5noyowr0leo.jpg | true | false | false | false | [
"Flash",
"微软",
"COBOL"
] | 硬核观察 | {
"viewnum": 3584,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "122.226.157.170",
"message": "说明一刀切在有些场景行不通。",
"username": "来自浙江台州的 Firefox 85.0|Windows 10 用户",
"date": "2021-02-01T15:05:40"
},
{
"postip": "222.174.80.98",
"message": "flash这个有定制个浏览器的功夫直接做个客户端好了，反正只能访问指定网站，跟客户端没什么区别了",
"username": "来自山东菏泽的 Firefox 78.0|Windows 10 用户",
"date": "2021-02-03T17:14:19"
}
] | [] | 更多：• 微软宣布开源可扩展存储引擎 ESE，几乎用在所有 Windows 之中 • 我们可能高估了每天的 COBOL 事务数量 | 2021-02-01T12:54:25 | 2021-02-01T12:54:25 | 13,075 | /article-13075-1.html | 
#### 瞠目结舌：为了重新启用 Flash 支持，南非税务局发布了自己的 Web 浏览器
据 [zdnet](https://www.zdnet.com/article/south-african-government-releases-its-own-browser-just-to-re-enable-flash-support/) 报道称，南非税务局发布这个定制浏览器的“唯一的目的是重新启用 Adobe Flash Player 支持，而不是将其现有的网站从使用 Flash 移植到基于 HTML 的网页表单中。”
该机构称自己“受到定时炸弹机制的影响”，从 Flash 停用的当天开始，该机构无法通过网站接收任何报税信息，而上传的表单被设计成 Flash 小部件。尽管有三年半的先机，南非税务局并没有选择将其 Flash 小部件移植到基本的 HTML 和 JS 表单中。相反，他们决定采取一个在 IT 决策史上最令人瞠目结舌的错误决定，[发布自己的 Web 浏览器](https://twitter.com/sarstax/status/1353699405912797184)。
该浏览器是 Chromium 浏览器的简化版，有两个功能：第一个是重新启用 Flash 支持。第二是让用户“能且只能”访问南非税务局的官方网站。并且，该浏览器只有 Windows 版本。
当然，这么有“创举”的事情，也绝非南非税务局一家，ZDnet 也提到了中国大连有了类似的“[解决方案](/article-13051-1.html)”。我觉得，很快就会有其它的机构“有样学样”……
#### 微软宣布开源可扩展存储引擎 ESE，几乎用在所有 Windows 之中
微软的 <ruby> <a href="https://github.com/microsoft/Extensible-Storage-Engine"> 可扩展存储引擎 </a> <rt> Extensible Storage Engine </rt></ruby>（ESE） 是一个非 SQL 数据库引擎。它最早在 Windows NT 3.51 中推出，并在 90 年代重写了两次，在此后的 20 年中进行了大量更新。微软使用它已有 25 年之久，它至今仍是微软的核心技术之一。
它运行在 Office 365 邮箱存储后台服务器的 10 万台机器和数百万块磁盘上。它还可以运行在带有 TB 级内存的大型 SMP 系统上运行，用于大型活动目录部署。
最重要的是，目前在每一台 Windows 客户端计算机都有多个 ESE 数据库实例运行在低内存模式下。ESE 自 Windows XP 以来一直用于 Windows 客户端产品之中，这包括超过 10 亿台 Windows 10 设备。
而最近，微软决定以 MIT 许可证[开源](https://github.com/microsoft/Extensible-Storage-Engine)它，并且开源的代码要比运行在 Windows 之中的还要新一些。我觉得，微软真是开源楷模，连这么重要、成熟的核心模块都开源出来了，给微软一个大大的赞！
#### 我们可能高估了每天的 COBOL 事务数量
据说“[每天有 300 亿个客户信息控制系统（CICS）/ COBOL 交易](https://web.archive.org/web/20010620220800/http://cobolreport.com/columnists/tscott/01082001.htm)”。这个数字后来被引用了无数次。然而，这可能[错误](https://developers.slashdot.org/story/21/01/30/2128205/are-we-overestimating-the-number-of-cobol-transactions-each-day)的。
据说，最初是 DataPro 在 1997 年对 421 家公司进行了一次[调查](https://books.google.de/books?id=IKbZ7dEVokwC&pg=PT68&dq=%22421+mainframe+shops%22&hl=de&sa=X&ved=2ahUKEwjc-L2jgIHuAhUylosKHZCiBBcQ6AEwAHoECAAQAg#v=onepage&q=%22421%20mainframe%20shops%22&f=false)，得出结论是：每天有 200 亿笔 CICS 交易。然后，这数字变成了 “300 亿 CICS 交易”。而在 2 年后，又莫名从 “CICS 交易”变成了 “COBOL 交易”。随后，随着 DataPro 于 1997 年被 Gartner 公司收购，这个数据就又变成了“来自 Gartner” 的了。
同样，还有一些无稽之谈或过时的数据也是来源于该报告：有 2000 亿行 COBOL 代码；这是世界上所有源代码的 60-80%；每年新写 50 亿行 COBOL 代码；世界上有 200 万名 COBOL 开发人员；COBOL 处理 95% 的柜台交易、ATM 刷卡或类似的交易。这些统统是有一定的误读或限制条件下的数据，也有的数据在二十多年后已经时过境迁了。
所以，不要随便引用数据，哪怕是来自于“权威”来源。
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.