title
stringlengths 5
75
| author
stringlengths 0
48
| fromurl
stringlengths 0
185
| summary
stringlengths 4
460
| pic
stringlengths 32
70
| largepic
stringlengths 0
69
| titlepic
bool 2
classes | thumb
bool 2
classes | islctt
bool 2
classes | selector
stringclasses 14
values | translator
stringlengths 0
45
| reviewer
stringclasses 27
values | editorchoice
bool 2
classes | tags
list | category
stringclasses 20
values | count
dict | comments_data
list | related
list | excerpt
stringlengths 4
460
| date
timestamp[s] | updated
timestamp[s] | id
int64 1
16.6k
| permalink
stringlengths 17
21
| content
stringlengths 116
82.2k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
在标准建立之前，软件所存在的问题
|
Andy Updegrove
|
https://opensource.com/article/17/7/software-standards
|
这背后的主要原因在于，开源社区的主流观点是：标准意味着限制、落后和多余。对于一个完整的堆栈中的单独一层来说，可能就是这样。但客户想要选择的自由、激烈的竞争，这就导致回到了之前的坏结果上，尽管多个厂商提供相似的集成堆栈，但却被锁定在一个技术上。
|
/data/attachment/album/201708/30/085019xvpgluu1vf22pl28.png.thumb.jpg
|
/data/attachment/album/201708/30/085019xvpgluu1vf22pl28.png
| true | false | true |
softpaopao
| false |
[
"标准",
"开源"
] |
观点
|
{
"viewnum": 3303,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这背后的主要原因在于，开源社区的主流观点是：标准意味着限制、落后和多余。对于一个完整的堆栈中的单独一层来说，可能就是这样。但客户想要选择的自由、激烈的竞争，这就导致回到了之前的坏结果上，尽管多个厂商提供相似的集成堆栈，但却被锁定在一个技术上。
| 2017-08-30T08:50:15 | 2017-08-30T08:50:15 | 8,822 |
/article-8822-1.html
|
>
> 开源项目需要认真对待交付成果中所包含的标准
>
>
>
无论以何种标准来衡量，开源软件作为传统的专有软件的替代品而崛起，取得了不错的效果。 如今，仅 Github 中就有着数以千万计的代码仓库，其中重要项目的数量也在快速增长。在本文撰写的时候，[Apache 软件基金会](https://www.apache.org/) 开展了超过 [300 个项目](https://projects.apache.org/)， [Linux 基金会](https://www.linuxfoundation.org/) 支持的项目也超过了 60 个。与此同时，[OpenStack 基金会](https://www.linuxfoundation.org/projects/directory) 在 180 多个国家拥有超过 60,000 名成员。
这样说来，这种情景下有什么问题么？
开源软件在面对用户的众多需求时，由于缺少足够的意识，而无法独自去解决全部需求。 更糟糕的是，许多开源软件社区的成员（业务主管以及开发者）对利用最合适的工具解决这一问题并不感兴趣。
让我们开始找出那些有待解决的问题，看看这些问题在过去是如何被处理的。
问题存在于：通常许多项目都在试图解决一个大问题当中重复的一小部分，而客户希望能够在竞争产品之间做出选择，不满意的话还能够轻松选择其他产品。但是现在看来都是不可能的，在这个问题被解决之前它将会阻碍开源软件的使用。
这已经不是一个新的问题或者没有传统解决方案的问题了。在一个半世纪以来，用户期望有更多的选择和自由来变换厂商，而这一直是通过标准的制定来实现的。在现实当中，你可以对螺丝钉、灯泡、轮胎、延长线的厂商做出无数多的选择，甚至于对独特形状的红酒杯也可以专注选择。因为标准为这里的每一件物品都提供了物理规格。而在健康和安全领域，我们的幸福也依赖于成千上万的标准，这些标准是由私营行业制定的，以确保在最大化的竞争中能够有完美的结果。
随着信息与通信技术（ICT）的发展，以同样类似的方式形成了一些重要的组织机构，例如：国际电信联盟（ITU）、国际电工委员会（IEC），以及电气与电子工程师学会标准协会（IEEE-SA）。近千家财团遵循 ICT 标准来进行开发、推广以及测试。
虽然并非是所有的 ICT 标准都形成了无缝对接，但如今在我们生活的科技世界里，成千上万的基本标准履行着这一承诺，这些标准包含了计算机、移动设备、Wi-Fi 路由器以及其他一切依赖电力来运行的东西。
关键的一点，在很长的一段时间里，由于客户对拥有种类丰富的产品、避免受制于供应商，并且享受全球范围内的服务的渴望，逐渐演变出了这一体系。
现在让我们来看看开源软件是如何演进的。
好消息是伟大的软件已经被创造出来了。坏消息是对于像云计算和虚拟化网络这样的关键领域，没有任何单独的基金会在开发整个堆栈。取而代之的是，单个项目开发单独的一层或者多层，依靠需要时才建立的善意的合作，这些项目最终堆叠成栈。当这一过程运行良好时，结果是好的，但也有可能形成与传统的专有产品同样的锁定。相反，当这一过程运行不良时，坏的结果就是它会浪费开发商、社区成员的时间和努力，同时也会辜负客户的期望。
最明确的解决方法的创建标准，允许客户避免被锁定，鼓励多个解决方案通过对附加服务和功能进行有益的竞争。当然也存在着例外，但这不是开源世界正在发生的情况。
这背后的主要原因在于，开源社区的主流观点是：标准意味着限制、落后和多余。对于一个完整的堆栈中的单独一层来说，可能就是这样。但客户想要选择的自由、激烈的竞争，这就导致回到了之前的坏结果上，尽管多个厂商提供相似的集成堆栈，但却被锁定在一个技术上。
在 Yaron Haviv 于 2017 年 6 月 14 日所写的 “[除非我们协作，否则我们将被困在专有云上](https://www.enterprisetech.com/2017/06/14/well-enslaved-proprietary-clouds-unless-collaborate/)” 一文中，就有对这一问题有着很好的描述。
>
> 在今天的开源生态系统当中存在一个问题，跨项目整合并不普遍。开源项目能够进行大型合作，构建出分层的模块化的架构，比如说 Linux — 已经一次又一次的证明了它的成功。但是与 Linux 的意识形成鲜明对比的就是如今许多开源社区的日常状态。
>
>
> 举个例子：大数据生态系统，就是依赖众多共享组件或通用 API 和层的堆叠来实现的。这一过程同样缺少标准的线路协议，同时，每个处理框架（看看 Spark、Presto 和 Flink）都拥有独立的数据源 API。
>
>
> 这种合作的缺乏正在造成担忧。缺少了合作，项目就会变得不通用，结果对客户产生了负面影响。因为每个人都不得不从头开始，重新开发，这基本上就锁定了客户，减缓了项目的发展。
>
>
>
Haviv 提出了两种解决方法：
* 项目之间更紧密的合作，联合多个项目消除重叠的部分，使堆栈内的整合更加密切；
* 开发 API ，使切换更加容易。
这两种方法都能达到目的。但除非事情能有所改变，我们将只会看到第一种方法，这就是前边展望中发现的技术锁定。结果会发现工业界，无论是过去 WinTel 的世界，或者纵观苹果的历史，相互竞争的产品都是以牺牲选择来换取紧密整合的。
同样的事情似乎很有可能发生在新的开源界，如果开源项目继续忽视对标准的需求，那么竞争会存在于层内，甚至是堆栈间。如果现在能够做到的话，这样的问题可能就不会发生了。
因为如果口惠无实开发软件优先、标准在后的话，对于标准的制定就没有真正的兴趣。主要原因是，大多数的商人和开发者对标准知之甚少。不幸的是，我们能够理解这些使事情变得糟糕的原因。这些原因有几个：
* 大学几乎很少对标准进行培训；
* 过去拥有专业的标准人员的公司遣散了这些部门，现在的部署工程师接受标准组织的培训又远远不够；
* 在建立雇主标准工作方面的专业知识方面几乎没有职业价值；
* 参与标准活动的工程师可能需要以他们认为是最佳技术解决方案为代价来延长雇主的战略利益；
* 在许多公司内部，专业的标准人员与开源开发者之间鲜有交流；
* 许多软件工程师将标准视为与 FOSS 定义的“四大自由”有着直接冲突。
现在，让我们来看看在开源界正在发生什么:
* 今天大多数的软件工程师鲜有不知道开源的；
* 工程师们每天都在享受着开源工具所带来的便利；
* 许多令人激动的最前沿的工作正是在开源项目中完成的；
* 在热门的开源领域，有经验的开发者广受欢迎，并获得了大量实质性的奖励；
* 在备受好评的项目中，开发者在软件开发过程中享受到了空前的自主权；
* 事实上，几乎所有的大型 ICT 公司都参与了多个开源项目，最高级别的成员当中，通常每个公司每年的合并成本（会费加上投入的雇员）都超过了一百万美元。
如果脱离实际的话，这个比喻似乎暗示着标准是走向 ICT 历史的灰烬。但现实却有很大差别。一个被忽视的事实是，开源开发是比常人所认为的更为娇嫩的花朵。这样比喻的原因是：
* 项目的主要支持者们可以撤回（已经做过的事情），这将导致一个项目的失败；
* 社区内的个性和文化冲突会导致社区的瓦解；
* 重要项目更加紧密的整合能力有待观察；
* 有时专有权在博弈中被削弱，高资助的开源项目在某些情况下会导致失败。
* 随着时间的推移，可能个别公司认为其开源策略没能给他们带来预期的回报；
* 对关键开源项目的失败引起过多关注，会导致厂商放弃一些投资中的新项目，并说服客户谨慎选择开源方案。
奇怪的是，最积极解决这些问题的协作单位是标准组织，部分原因是，他们已经感受到了开源合作的崛起所带来的威胁。他们的回应包括更新知识产权策略以允许在此基础上各种类型的合作，开发开源工具，包含开源代码的标准，以及在其他类型的工作项目中开发开源手册。
结果就是，这些标准组织调整自己成为一个近乎中立的角色，为完整方案的开发提供平台。这些方案能够包含市场上需要的各种类型的合作产品，以及混合工作产品。随着此过程的继续，很有可能使厂商们乐意推行一些包含了标准组织在内的举措，否则他们可能会走向开源基金。
重要的是，由于这些原因，开源项目开始认真对待项目交付所包含的标准，或者与标准开发商合作，共同为完整的方案做准备。这不仅会有更多的产品选择，对客户更少的限制，而且也给客户在开源方案上更大的信心，同时也对开源产品和服务有更多的需求。
倘若这一切不发生的话，将会是一个很大的遗憾，因为这是开源所导致的巨大损失。而这取决于如今的项目所做的决定，是供给市场所需，还是甘心于未来日趋下降的影响力，而不是持续的成功。
*本文源自 ConsortiumInfo.org的 [Standards Blog](http://www.consortiuminfo.org/standardsblog/article.php?story=20170616133415179)，并已获得出版许可*
（题图：opensource.com）
---
作者简介：
Andy Updegrove - Andy helps 的 CEO，管理团队，由他们的投资者建立的成功的组织。他曾作为一名先驱，自1979年起，就为高科技公司提供商业头脑的法律顾问和策略建议。在全球舞台上，他经常作为代表，帮助推动超过 135 部全球标准的制定，宣传开源，主张联盟，其中包括一些世界上最大，最具影响力的标准制定机构。
---
via: <https://opensource.com/article/17/7/software-standards>
作者：[Andy Updegrove](https://opensource.com/users/andrewupdegrove) 译者：[softpaopao](https://github.com/softpaopao) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
听说过时间表，但是你是否知道“哈希表”
|
Marty Jacobs
|
http://www.zeroequalsfalse.press/2017/02/20/hashtables/
|
探索哈希表（hash table）的世界并理解其底层的机制是非常有趣的，并且将会受益匪浅。所以，让我们了解它，并从头开始探索吧。
|
/data/attachment/album/201708/30/233911yju25o44rc53x49f.jpg.thumb.jpg
|
/data/attachment/album/201708/30/233911yju25o44rc53x49f.jpg
| true | false | true |
ucasFL
| false |
[
"哈希"
] |
软件开发
|
{
"viewnum": 5462,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "202.108.251.28",
"message": "我只回复好贴",
"username": "星火燎原 [Safari 10.1|Mac 10.12]",
"date": "2017-09-01T11:20:00"
},
{
"postip": "61.186.31.49",
"message": "感谢！",
"username": "linux [Chrome 60.0|Mac 10.11]",
"date": "2017-09-01T13:53:57"
}
] |
[] |
探索哈希表（hash table）的世界并理解其底层的机制是非常有趣的，并且将会受益匪浅。所以，让我们了解它，并从头开始探索吧。
| 2017-08-31T08:00:00 | 2017-08-31T08:00:00 | 8,824 |
/article-8824-1.html
|
探索<ruby> 哈希表 <rt> hash table </rt></ruby>的世界并理解其底层的机制是非常有趣的，并且将会受益匪浅。所以，让我们了解它，并从头开始探索吧。
哈希表是许多现代软件应用程序中一种常见的数据结构。它提供了类似字典的功能，使你能够在其中执行插入、删除和删除等操作。这么说吧，比如我想找出“苹果”的定义是什么，并且我知道该定义被存储在了我定义的哈希表中。我将查询我的哈希表来得到定义。它在哈希表内的记录看起来可能像：`"苹果" => "一种拥有水果之王之称的绿色水果"`。这里，“苹果”是我的关键字，而“一种拥有水果之王之称的水果”是与之关联的值。
还有一个例子可以让我们更清楚，哈希表的内容如下：
```
"面包" => "固体"
"水" => "液体"
"汤" => "液体"
"玉米片" => "固体"
```
我想知道*面包*是固体还是液体，所以我将查询哈希表来获取与之相关的值，该哈希表将返回“固体”给我。现在，我们大致了解了哈希表是如何工作的。使用哈希表需要注意的另一个重要概念是每一个关键字都是唯一的。如果到了明天，我拥有一个面包奶昔（它是液体），那么我们需要更新哈希表，把“固体”改为“液体”来反映哈希表的改变。所以，我们需要添加一条记录到字典中：关键字为“面包”，对应的值为“液体”。你能发现下面的表发生了什么变化吗？（LCTT 译注：不知道这个“面包奶昔”是一种什么食物，大约是一种面包做的奶昔，总之你就理解成作者把液体的“面包奶昔”当成一种面包吧。）
```
"面包" => "液体"
"水" => "液体"
"汤" => "液体"
"玉米片" => "固体"
```
没错，“面包”对应的值被更新为了“液体”。
**关键字是唯一的**，我的面包不能既是液体又是固体。但是，是什么使得该数据结构与其他数据结构相比如此特殊呢？为什么不使用一个[数组](https://en.wikipedia.org/wiki/Array_data_type)来代替呢？它取决于问题的本质。对于某一个特定的问题，使用数组来描述可能会更好，因此，我们需要注意的关键点就是，**我们应该选择最适合问题的数据结构**。例如，如果你需要做的只是存储一个简单的杂货列表，那么使用数组会很适合。考虑下面的两个问题，两个问题的本质完全不同。
1. 我需要一个水果的列表
2. 我需要一个水果的列表以及各种水果的价格（每千克）
正如你在下面所看到的，用数组来存储水果的列表可能是更好的选择。但是，用哈希表来存储每一种水果的价格看起来是更好的选择。
```
//示例数组
["苹果", "桔子", "梨子", "葡萄"]
//示例哈希表
{ "苹果" : 3.05,
"桔子" : 5.5,
"梨子" : 8.4,
"葡萄" : 12.4
}
```
实际上，有许多的机会需要[使用](https://en.wikipedia.org/wiki/Hash_table#Uses)哈希表。
### 时间以及它对你的意义
[这里有篇对时间复杂度和空间复杂度的一个复习](https://www.hackerearth.com/practice/basic-programming/complexity-analysis/time-and-space-complexity/tutorial/)。
平均情况下，在哈希表中进行搜索、插入和删除记录的时间复杂度均为 `O(1)` 。实际上，`O(1)` 读作“大 O 1”，表示常数时间。这意味着执行每一种操作的运行时间不依赖于数据集中数据的数量。我可以保证，查找、插入和删除项目均只花费常数时间，“当且仅当”哈希表的实现方式正确时。如果实现不正确，可能需要花费很慢的 `O(n)` 时间，尤其是当所有的数据都映射到了哈希表中的同一位置/点。
### 构建一个好的哈希表
到目前为止，我们已经知道如何使用哈希表了，但是如果我们想**构建**一个哈希表呢？本质上我们需要做的就是把一个字符串（比如 “狗”）映射到一个哈希代码（一个生成的数），即映射到一个数组的索引。你可能会问，为什么不直接使用索引呢？为什么要这么麻烦呢？因为通过这种方式我们可以直接查询 “狗” 并立即得到 “狗” 所在的位置，`String name = Array["狗"] // 名字叫拉斯`。而使用索引查询名称时，可能出现的情况是我们不知道名称所在的索引。比如，`String name = Array[10] // 该名字现在叫鲍勃` - 那不是我的狗的名字。这就是把一个字符串映射到一个哈希代码的益处（对应于一个数组的索引而言）。我们可以通过使用模运算符和哈希表的大小来计算出数组的索引：`index = hash_code % table_size`。
我们需要避免的另一种情况是两个关键字映射到同一个索引，这叫做**哈希碰撞**，如果哈希函数实现的不好，这很容易发生。实际上，每一个输入比输出多的哈希函数都有可能发生碰撞。通过下面的同一个函数的两个输出来展示一个简单的碰撞：
```
int cat_idx = hashCode("猫") % table_size; //cat_idx 现在等于 1
int dog_idx = hashCode("狗") % table_size; //dog_idx 也等于 1
```
我们可以看到，现在两个数组的索引均是 1 。这样将会出现两个值相互覆盖，因为它们被写到了相同的索引中。如果我们查找 “猫” 的值，将会返回 “拉斯” ，但是这并不是我们想要的。有许多可以[解决哈希碰撞](https://en.wikipedia.org/wiki/Hash_table#Collision_resolution)的方法，但是更受欢迎的一种方法叫做**链接**。链接的想法就是对于数组的每一个索引位置都有一个链表，如果碰撞发生，值就被存到链表中。因此，在前面的例子中，我们将会得到我们需要的值，但是我们需要搜索数组中索引为 1 的位置上的链表。伴有链接的哈希实现需要 `O(1 + α)` 时间，其中 α 是装载因子，它可以表示为 n/k，其中 n 是哈希表中的记录数目，k 是哈希表中可用位置的数目。但是请记住，只有当你给出的关键字非常随机时，这一结论才正确（依赖于 [SUHA](https://en.wikipedia.org/wiki/SUHA_(computer_science)）。
这是做了一个很大的假设，因为总是有可能任何不相等的关键字都散列到同一点。这一问题的一个解决方法是去除哈希表中关键字对随机性的依赖，转而把随机性集中于关键字是如何被散列的，从而减少矛盾发生的可能性。这被称为……
### 通用散列
这个观念很简单，从<ruby> 通用散列 <rt> universal hash </rt></ruby>家族集合随机选择一个哈希函数 h 来计算哈希代码。换句话来说，就是选择任何一个随机的哈希函数来散列关键字。通过这种方法，两个不同的关键字的散列结果相同的可能性将非常低（LCTT 译注：原文是“not be the same”，应是笔误）。我只是简单的提一下，如果不相信我那么请相信[数学](https://en.wikipedia.org/wiki/Universal_hashing#Mathematical_guarantees)。实现这一方法时需要注意的另一件事是如果选择了一个不好的通用散列家族，它会把时间和空间复杂度拖到 `O(U)`，其中 U 是散列家族的大小。而其中的挑战就是找到一个不需要太多时间来计算，也不需要太多空间来存储的哈希家族。
### 上帝哈希函数
追求完美是人的天性。我们是否能够构建一个*完美的哈希函数*，从而能够把关键字映射到整数集中，并且几乎*没有碰撞*。好消息是我们能够在一定程度上做到，但是我们的数据必须是静态的（这意味着在一定时间内没有插入/删除/更新）。一个实现完美哈希函数的方法就是使用 <ruby> 2 级哈希 <rt> 2-Level Hashing </rt></ruby>，它基本上是我们前面讨论过的两种方法的组合。它使用*通用散列*来选择使用哪个哈希函数，然后通过*链接*组合起来，但是这次不是使用链表数据结构，而是使用另一个哈希表。让我们看一看下面它是怎么实现的：
[](http://www.zeroequalsfalse.press/2017/02/20/hashtables/Diagram.png)
**但是这是如何工作的以及我们如何能够确保无需关心碰撞？**
它的工作方式与[生日悖论](https://en.wikipedia.org/wiki/Birthday_problem)相反。它指出，在随机选择的一堆人中，会有一些人生日相同。但是如果一年中的天数远远大于人数（平方以上），那么有极大的可能性所有人的生日都不相同。所以这二者是如何相关的？对于每一个链接哈希表，其大小均为第一级哈希表大小的平方。那就是说，如果有两个元素被散列到同一个点，那么链接哈希表的大小将为 4 。大多数时候，链接哈希表将会非常稀疏/空。
重复下面两步来确保无需担心碰撞：
* 从通用散列家族中选择一个哈希函数来计算
* 如果发生碰撞，那么继续从通用散列家族中选择另一个哈希函数来计算
字面上看就是这样（这是一个 `O(n^2)` 空间的解）。如果需要考虑空间问题，那么显然需要另一个不同的方法。但是值得庆幸的是，该过程平均只需要进行**两次**。
### 总结
只有具有一个好的哈希函数才能算得上是一个好的哈希表。在同时保证功能实现、时间和空间的提前下构建一个完美的哈希函数是一件很困难的事。我推荐你在解决问题的时候首先考虑哈希表，因为它能够为你提供巨大的性能优势，而且它能够对应用程序的可用性产生显著差异。哈希表和完美哈希函数常被用于实时编程应用中，并且在各种算法中都得到了广泛应用。你见或者不见，哈希表就在这儿。
---
via: <http://www.zeroequalsfalse.press/2017/02/20/hashtables/>
作者：[Marty Jacobs](http://www.zeroequalsfalse.press/about) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何管理开源产品的安全漏洞
|
Amber Ankerholz
|
https://www.linux.com/news/event/elcna/2017/2/how-manage-security-vulnerabilities-your-open-source-product
|
在开发开源软件时, 你需要考虑的安全漏洞也许会将你吞没。CVE ID、零日漏洞和其他漏洞似乎每天都在公布。随着这些信息洪流，你怎么能保持不掉队？
|
/data/attachment/album/201708/31/102941ewki56wetwwsadww.jpg.thumb.jpg
|
/data/attachment/album/201708/31/102941ewki56wetwwsadww.jpg
| true | false | true |
geekpi
| false |
[
"CVE",
"安全漏洞"
] |
观点
|
{
"viewnum": 3385,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在开发开源软件时, 你需要考虑的安全漏洞也许会将你吞没。CVE ID、零日漏洞和其他漏洞似乎每天都在公布。随着这些信息洪流，你怎么能保持不掉队？
| 2017-08-31T10:29:39 | 2017-08-31T10:29:39 | 8,825 |
/article-8825-1.html
|
在 ELC + OpenIoT 峰会上，英特尔安全架构师 Ryan Ware 将会解释如何应对漏洞洪流，并管理你产品的安全性。
在开发开源软件时, 你需要考虑的安全漏洞也许会将你吞没。<ruby> 常见漏洞及曝光 <rt> Common Vulnerabilities and Exposures </rt></ruby>（CVE）ID、零日漏洞和其他漏洞似乎每天都在公布。随着这些信息洪流，你怎么能保持不掉队？
英特尔安全架构师 Ryan Ware 表示：“如果你发布了基于 Linux 内核 4.4.1 的产品，该内核截止今日已经有 9 个针对该内核的 CVE。这些都会影响你的产品，尽管事实上当你配载它们时还不知道。”
在 [ELC](http://events.linuxfoundation.org/events/embedded-linux-conference) + [OpenIoT 峰会](http://events.linuxfoundation.org/events/openiot-summit)上，英特尔安全架构师 Ryan Ware 的演讲将介绍如何实施并成功管理产品的安全性的策略。在他的演讲中，Ware 讨论了最常见的开发者错误，跟上最新的漏洞的策略等等。
**Linux.com：让我们从头开始。你能否简要介绍一下常见漏洞和曝光（CVE），零日以及其他漏洞么？它们是什么，为什么重要？**
Ryan Ware：好问题。<ruby> 常见漏洞及曝光 <rt> Common Vulnerabilities and Exposures </rt></ruby>（CVE）是按美国政府的要求由 MITR Corporation（一个非营利组织）维护的数据库。其目前由美国国土安全部资助。它是在 1999 年创建的，以包含有关所有公布的安全漏洞的信息。这些漏洞中的每一个都有自己的标识符（CVE-ID），并且可以被引用。 CVE 这个术语，已经从指整个数据库逐渐演变成代表一个单独的安全漏洞： 一个 CVE 漏洞。
出现于 CVE 数据库中的许多漏洞最初是零日漏洞。这些漏洞出于不管什么原因没有遵循更有序的如“<ruby> 责任揭秘 <rt> Responsible Disclosure </rt></ruby>”这样的披露过程。关键在于，如果没有软件供应商能够通过某种类型的修复（通常是软件补丁）来进行响应，那么它们就成为了公开和可利用的。这些和其他未打补丁的软件漏洞至关重要，因为在修补软件之前，漏洞是可以利用的。在许多方面，发布 CVE 或者零日就像是开枪。在你比赛结束之前，你的客户很容易受到伤害。
**Linux.com：有多少漏洞？你如何确定那些与你的产品相关？**
Ryan：在探讨有多少之前，以任何形式发布软件的任何人都应该记住。即使你采取一切努力确保你发布的软件没有已知的漏洞，你的软件*也会*存在漏洞。它们只是不知道而已。例如，如果你发布了一个基于 Linux 内核 4.4.1 的产品，那么截止今日，已经有了 9 个CVE。这些都会影响你的产品，尽管事实上在你使用它们时不知道。
此时，CVE 数据库包含 80,957 个条目（截止至 2017 年 1 月 30 日），包括最早可追溯到 1999 年的所有记录，当时有 894 个已记录问题。迄今为止，一年中出现最大的数字的是 2014 年，当时记录了 7,946 个问题。也就是说，我认为过去两年该数字减少并不是因为安全漏洞的减少。这是我将在我的谈话中说到的东西。
**Linux.com：开发人员可以使用哪些策略来跟上这些信息？**
Ryan：开发人员可以通过各种方式跟上这些如洪水般涌来的漏洞信息。我最喜欢的工具之一是 [CVE Details](http://www.cvedetails.com/)。它以一种非常容易理解的方式展示了来自 MITRE 的信息。它最好的功能是创建自定义 RSS 源的能力，以便你可以跟踪你关心的组件的漏洞。那些具有更复杂的追踪需求的人可以从下载 MITR CVE 数据库（免费提供）开始，并定期更新。其他优秀工具，如 cvechecker，可以让你检查软件中已知的漏洞。
对于软件栈中的关键部分，我还推荐一个非常有用的工具：参与到上游社区中。这些是最理解你所使用的软件的人。世界上没有比他们更好的专家。与他们一起合作。
**Linux.com：你怎么知道你的产品是否解决了所有漏洞？有推荐的工具吗？**
Ryan：不幸的是，正如我上面所说，你永远无法从你的产品中移除所有的漏洞。上面提到的一些工具是关键。但是，我还没有提到一个对你发布的任何产品来说都是至关重要的部分：软件更新机制。如果你无法在当场更新产品软件，则当客户受到影响时，你无法解决安全问题。你的软件必须能够更新，更新过程越容易，你的客户将受到更好的保护。
**Linux.com：开发人员还需要知道什么才能成功管理安全漏洞？**
Ryan：有一个我反复看到的错误。开发人员总是需要牢记将攻击面最小化的想法。这是什么意思？在实践中，这意味着只包括你的产品实际需要的东西！这不仅包括确保你不将无关的软件包加入到你的产品中，而且还可以关闭不需要的功能的配置来编译项目。
这有什么帮助？想象这是 2014 年。你刚刚上班就看到 Heartbleed 的技术新闻。你知道你在产品中包含 OpenSSL，因为你需要执行一些基本的加密功能，但不使用 TLS 心跳，该问题与该漏洞相关。你愿意：
a. 花费时间与客户和合作伙伴合作，通过关键的软件更新来修复这个高度安全问题？
b. 只需要告诉你的客户和合作伙伴，你使用 “-DOPENSSL*NO*HEARTBEATS” 标志编译 OpenSSL 产品，他们不会受到损害，你就可以专注于新功能和其他生产活动。
最简单解决漏洞的方法是你不包含这个漏洞。
（题图：[Creative Commons Zero](https://www.linux.com/licenses/category/creative-commons-zero) Pixabay）
---
via: <https://www.linux.com/news/event/elcna/2017/2/how-manage-security-vulnerabilities-your-open-source-product>
作者：[AMBER ANKERHOLZ](https://www.linux.com/users/aankerholz) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Ubuntu Linux 的不同安装类型：服务器 vs 桌面
|
Chris Cottingham
|
http://www.radiomagonline.com/deep-dig/0005/linux-installation-types-server-vs-desktop/39123
|
之前我已经讲了获取与安装 Ubuntu Linux，这次我将讲桌面和服务器的安装。两类安装都满足某些需求。不同的安装包是从 Ubuntu 分开下载的。
|
/data/attachment/album/201708/31/110353mxfy52iyhns1zzif.jpg.thumb.jpg
|
/data/attachment/album/201708/31/110353mxfy52iyhns1zzif.jpg
| true | false | true |
geekpi
| false |
[
"服务器",
"桌面"
] |
技术
|
{
"viewnum": 24504,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "111.20.112.126",
"message": "本来就是一种商业化故意差异化。还是喜欢Debian Gnu/Linux的单一版本保持软件多样性发行版！！！尤其全镜像组件包ISO的发布。那才是方便用户的最有效保障。。。",
"username": "来自陕西西安的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-31T13:03:19"
}
] |
[] |
之前我已经讲了获取与安装 Ubuntu Linux，这次我将讲桌面和服务器的安装。两类安装都满足某些需求。不同的安装包是从 Ubuntu 分开下载的。
| 2017-08-31T11:04:20 | 2017-08-31T11:04:20 | 8,826 |
/article-8826-1.html
|
>
> 内核是任何 Linux 机器的核心
>
>
>
之前我已经讲了获取与安装 Ubuntu Linux，这次我将讲桌面和服务器的安装。两类安装都满足某些需求。不同的安装包是从 Ubuntu 分开下载的。你可以从 [Ubuntu.com/downloads](https://www.ubuntu.com/download) 选择你需要的。
无论安装类型如何，都有一些相似之处。
*可以从桌面系统图形用户界面或从服务器系统命令行添加安装包。*
两者都使用相同的内核和包管理器系统。软件包管理器系统是预编译为可在几乎任何 Ubuntu 系统运行的程序的仓库。程序分组成包，然后以安装包进行安装。安装包可以从桌面系统图形用户界面或从服务器系统命令行添加。
程序安装使用一个名为 `apt-get` 的程序。这是一个包管理器系统或程序管理器系统。最终用户只需输入命令行 `apt-get install (package-name)`，Ubuntu 就会自动获取软件包并进行安装。
软件包通常安装可以通过手册页访问的文档的命令（这本身就是一个主题）。它们可以通过输入 `man (command)` 来访问。这将打开一个描述该命令详细用法的页面。终端用户还可以 Google 任何的 Linux 命令或安装包，并找到大量关于它的信息。
例如，在安装网络连接存储套件后，可以通过命令行、GUI 或使用名为 Webmin 的程序进行管理。Webmin 安装了一个基于 Web 的管理界面，用于配置大多数 Linux 软件包，它受到了仅安装服务器版本的人群的欢迎，因为它安装为网页，不需要 GUI。它还允许远程管理服务器。
大多数（如果不是全部）基于 Linux 的软件包都有专门帮助你如何运行该软件包的视频和网页。只需在 YouTube 上搜索 “Linux Ubuntu NAS”，你就会找到一个指导你如何设置和配置此服务的视频。还有专门指导 Webmin 的设置和操作的视频。
内核是任何 Linux 安装的核心。由于内核是模块化的，它是非常小的（顾名思义）。我在一个 32MB 的小型闪存上运行 Linux 服务器。我没有打错 - 32MB 的空间！Linux 系统使用的大部分空间都是由安装的软件包使用的。
**服务器**
服务器安装 ISO 镜像是 Ubuntu 提供的最小的下载。它是针对服务器操作优化的操作系统的精简版本。此版本没有 GUI。默认情况下，它完全从命令行运行。
移除 GUI 和其他组件可简化系统并最大限度地提高性能。最初没有安装的必要软件包可以稍后通过命令行程序包管理器添加。由于没有 GUI，因此必须从命令行完成所有配置、故障排除和包管理。许多管理员将使用服务器安装来获取一个干净或最小的系统，然后只添加他们需要的某些包。这包括添加桌面 GUI 系统并制作精简桌面系统。
广播电台可以使用 Linux 服务器作为 Apache Web 服务器或数据库服务器。这些是真实需要消耗处理能力的程序，这就是为什么它们通常使用服务器形式安装以及没有 GUI 的原因。SNORT 和 Cacti 是可以在你的 Linux 服务器上运行的其他程序（这两个应用程序都在上一篇文章中介绍，可以在这里找到：[*http://tinyurl.com/yd8dyegu*](http://tinyurl.com/yd8dyegu)）。
**桌面**
桌面安装 ISO 镜像相当大，并且有多个在服务器安装 ISO 镜像上没有的软件包。此安装用于工作站或日常桌面使用。此安装类型允许自定义安装包（程序），或者可以选择默认的桌面配置。
*桌面安装 ISO 镜像相当大，并且有多个在服务器安装 ISO 镜像上没有的软件包。此安装包专为工作站或日常桌面使用设计。*
软件包通过 apt-get 包管理器系统安装，就像服务器安装一样。两者之间的区别在于，在桌面安装中，apt-get 包管理器具有不错的 GUI 前端。这允许通过点击鼠标轻松地从系统安装或删除软件包！桌面安装将设置一个 GUI 以及许多与桌面操作系统相关的软件包。
*通过 apt-get 包管理器系统安装软件包，就像服务器安装一样。两者之间的区别在于，在桌面安装中，apt-get 包管理器具有不错的 GUI 前端。*\*
这个系统安装后随时可用，可以很好的替代你的 Windows 或 Mac 台式机。它有很多包，包括 Office 套件和 Web 浏览器。
Linux 是一个成熟而强大的操作系统。无论哪种安装类型，它都可以配置为适合几乎所有需要。从功能强大的数据库服务器到用于网页浏览和写信给奶奶的基本台式机操作系统，天空有极限，而可用的安装包几乎是不竭的。如果你遇到一个需要计算机化解决方案的问题，Linux 可能会提供免费或低成本的软件来解决该问题。
通过提供两个安装版本，Ubuntu 做得很好，这让人们开始朝着正确的方向前进。
*Cottingham 是前无线电总工程师，现在从事流媒体工作。*
---
via: <http://www.radiomagonline.com/deep-dig/0005/linux-installation-types-server-vs-desktop/39123>
作者：[Chris Cottingham](http://www.radiomagonline.com/author/chris-cottingham) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
从这开始了解 OPNFV
|
Amar Kapadia
|
https://www.linux.com/blog/opnfv/2017/8/understanding-opnfv-starts-here
|
NFV 是颠覆的一代，其将彻底改变网络的建设和运营。而且，OPNFV 是一个领先的开源 NFV 项目，旨在加速这项技术的采用。
|
/data/attachment/album/201708/31/223444c3c5gdj6zd93k6l5.png.thumb.jpg
|
/data/attachment/album/201708/31/223444c3c5gdj6zd93k6l5.png
| true | false | true |
geekpi
| false |
[
"NFV",
"OPNFV"
] |
分享
|
{
"viewnum": 9254,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "111.20.112.126",
"message": "GNU应该有一本SDN手册啦！！！很期待",
"username": "来自陕西西安的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-01T11:01:06"
}
] |
[] |
NFV 是颠覆的一代，其将彻底改变网络的建设和运营。而且，OPNFV 是一个领先的开源 NFV 项目，旨在加速这项技术的采用。
| 2017-09-01T08:33:00 | 2017-09-01T08:33:00 | 8,828 |
/article-8828-1.html
|
如果电信运营商或企业今天从头开始构建网络，那么他们可能用软件定义资源的方式构建，这与 Google 或 Facebook 的基础设施类似。这是网络功能虚拟化 （NFV） 的前提。
NFV 是颠覆的一代，其将彻底改变网络的建设和运营。而且，[OPNFV](https://www.opnfv.org/) 是一个领先的开源 NFV 项目，旨在加速这项技术的采用。
你是想要知道有哪些开源项目可能会帮助你进行 NFV 转换计划的电信运营商或者相关的企业员工么？还是要将你的产品和服务推向新的 NFV 世界的技术提供商？或者，也许是一名想使用开源项目来发展你事业的工程师、网络运维或商业领袖？（例如 2013 年 Rackspace [提到](https://blog.rackspace.com/solving-the-openstack-talent-gap) 拥有 OpenStack 技能的网络工程师的平均工资比他们的同行高 13%）？如果这其中任何一个适用于你，那么 *理解 OPNFV* 一书是你的完美资源。
*“理解 OPNFV”一书高屋建瓴地提供了 OPNFV 的理解以及它如何帮助你和你们的组织。*
本书（由 Mirantis 、 Nick Chase 和我撰写）在 11 个易于阅读的章节和超过 144 页中介绍了从 NFV、NFV 转换、OPNFV 项目的各个方面到 VNF 入门的概述，涵盖了一系列主题。阅读本书后，你将对 OPNFV 是什么有一个高屋建瓴的理解以及它如何帮助你或你们的组织。这本书不是专门面向开发人员的，虽然有开发背景信息很有用。如果你是开发人员，希望作为贡献者参与 OPNFV 项目，那么 [wiki.opnfv.org](https://wiki.opnfv.org/) 仍然是你的最佳资源。
在本博客系列中，我们会向你展示本书的一部分内容 - 就是有些什么内容，以及你可能会学到的。
让我们从第一章开始。第 1 章，毫不奇怪，是对 NFV 的介绍。它从业务驱动因素（需要差异化服务、成本压力和敏捷需求）、NFV 是什么，以及你可从 NFV 可以获得什么好处的角度做了简要概述。
简而言之，NFV 可以在数据中心的计算节点上执行复杂的网络功能。在计算节点上执行的网络功能称为虚拟网络功能 （VNF）。因此，VNF 可以作为网络运行，NFV 还会添加机制来确定如何将它们链接在一起，以提供对网络中流量的控制。
虽然大多数人认为它用在电信，但 NFV 涵盖了广泛的使用场景，从基于应用或流量类型的按角色访问控制 （RBAC） 到用于管理网络内容的内容分发网络 （CDN） 网络（通常需要的地方），更明显的电信相关用例如演进分组核心 （EPC） 和 IP 多媒体系统（IMS）。
此外，一些主要收益包括增加收入、改善客户体验、减少运营支出 （OPEX）、减少资本支出 （CAPEX）和为新项目腾出资源。本节还提供了具体的 NFV 总体拥有成本 （TCO） 分析。这些话题的处理很简单，因为我们假设你有一些 NFV 背景。然而，如果你刚接触 NFV ，不要担心 - 介绍材料足以理解本书的其余部分。
本章总结了 NFV 要求 - 安全性、性能、互操作性、易操作性以及某些具体要求，如服务保证和服务功能链。不符合这些要求，没有 NFV 架构或技术可以真正成功。
阅读本章后，你将对为什么 NFV 非常重要、NFV是什么，以及 NFV 成功的技术要求有一个很好的概念。我们将在今后的博客文章中浏览下面的章节。
这本书已被证明是行业活动上最受欢迎的赠品，中文版正在进行之中！但是你现在可以[下载 PDF 格式的电子书](https://www.opnfv.org/resources/download-understanding-opnfv-ebook)，或者在亚马逊上下载[打印版本](https://www.amazon.com/dp/B071LQY724/ref=cm_sw_r_cp_ep_dp_pgFMzbM8YHJA9)。
（题图：[Creative Commons Zero](https://www.linux.com/licenses/category/creative-commons-zero)Pixabay）
---
via: <https://www.linux.com/blog/opnfv/2017/8/understanding-opnfv-starts-here>
作者：[AMAR KAPADIA](https://www.linux.com/users/akapadia) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在树莓派中开启激动人心的 Perl 之旅
|
Ian Kluft
|
https://opensource.com/article/17/3/perl-raspberry-pi
|
我最近在 SVPerl （硅谷 Perl 聚会）谈到在树莓派上运行 Perl 语言的时候，有人问我，“我听说树莓派应该使用 Python ，是这样吗？”。我非常乐意回答他，这是个常见误解。树莓派可以支持任何语言： Python、Perl 和其他树莓派官方软件 Raspbian Linux 初始安装的语言。
|
/data/attachment/album/201709/01/110033jt75udbas9zva5tm.jpg.thumb.jpg
|
/data/attachment/album/201709/01/110033jt75udbas9zva5tm.jpg
| true | false | true |
Taylor1024
| false |
[
"树莓派",
"Perl"
] |
树莓派
|
{
"viewnum": 8471,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "218.20.137.230",
"message": "刚装好了kali，就不折腾了",
"username": "来自广东广州的 Chrome 60.0|Mac 10.12 用户",
"date": "2017-09-01T12:56:58"
},
{
"postip": "123.149.111.133",
"message": "折腾了一圈，又回到了raspberry debian。",
"username": "来自河南郑州的 Chrome Mobile 40.0|Android 7.0 用户",
"date": "2017-09-07T00:18:58"
}
] |
[] |
我最近在 SVPerl （硅谷 Perl 聚会）谈到在树莓派上运行 Perl 语言的时候，有人问我，“我听说树莓派应该使用 Python ，是这样吗？”。我非常乐意回答他，这是个常见误解。树莓派可以支持任何语言： Python、Perl 和其他树莓派官方软件 Raspbian Linux 初始安装的语言。
| 2017-09-01T11:00:30 | 2017-09-01T11:00:30 | 8,829 |
/article-8829-1.html
|
>
> 树莓派，随心所欲。
>
>
>
我最近在 SVPerl （硅谷 Perl 聚会）谈到在树莓派上运行 Perl 语言的时候，有人问我，“我听说树莓派应该使用 Python ，是这样吗？”。我非常乐意回答他，这是个常见误解。树莓派可以支持任何语言： Python、Perl 和其他树莓派官方软件 Raspbian Linux 初始安装的语言。
看似很厉害，其实很简单。树莓派的创造者英国的计算机科学教授 Eben Upton 曾经说过，树莓派名字中的‘派’（pi），是想为了听起来像 Python，因为他喜欢这门语言。他选择了这门语言作为孩子们的启蒙语言。但是他和他的团队做了一个通用计算机。开源软件没给树莓派任何限制。我们想运行什么就运行什么，全凭自己心意。
我在 SVPerl 和这篇文章中还想讲第二点，就是介绍我的 “PiFlash” 脚本。虽然它是用 Perl 写的，但是不需要你有多了解 Perl 就可以在 Linux 下将树莓派系统自动化烧录到 SD 卡。这样对初学者就比较友好，避免他们在烧录 SD 卡时候，偶然擦除了整个硬盘。即使是高级用户也可以从它的自动化工作中受益，包括我，这也是我开发这个工具的原因。在 Windows 和 Mac 下也有类似的工具，但是树莓派网站没有介绍类似工具给 Linux 用户。不过，现在有了。
开源软件早就有自己造轮子的传统，因为他们总是崇尚“自痒自挠”去解决问题。这种方式在 Eric S 1997 年的论文和 1999 年的书籍《[大教堂与集市](http://www.catb.org/%7Eesr/writings/cathedral-bazaar/)》中早有提及，它定义了开源软件的方法论。我也是为了满足想我这样的 Linux 用户，所以写了这个脚本。
### 下载系统镜像
想要开启树莓派之旅，你首先需要为它下载一个操作系统。我们称之为“系统镜像”文件。一旦你把它下载到你的桌面、手提电脑，或者甚至是另一个树莓派中，我就需要写入或者称之为“烧录”进你的 SD卡。详细情况可以看在线文件。手动做这件事情需要一些功底，你要把系统镜像烧录到整个 SD卡，而不是其中一块分区。系统镜像必须独自包含至少一个分区，因为树莓派引导需要一个 FAT32文件系统分区，系统引导这里开始。除了引导分区，其他分区可以是操作系统内核支持的任何分区类型。
在大部分树莓派中，我们都运行的是某些使用 Linux 内核的发行版。已经有一系列树莓派中常用的系统镜像你可以下载使用。（当然，没什么能阻止你自己造轮子）
树莓派基金会向新手推荐的是“[NOOBS](https://www.raspberrypi.org/downloads/noobs/)”系统。它代表了 “New Out of the Box System”（新鲜出炉即开即用系统），显然它好像听起来像术语 “noob"”（小白），通俗点说就是 “newbie”（菜鸟）。NOOBS 是一个基于树莓派的 Linux 系统，它会给你一个菜单可以在你的树莓派上自动下载安装几个其它的系统镜像。
[Raspbian Linux](https://www.raspberrypi.org/downloads/raspbian/) 是 Debian Linux 发行版的树莓派定制版。它是为树莓派开发的正式 Linux 发行版，并且由树莓派基金会维护。几乎所有树莓派驱动和软件都会在 Raspbian 上先试用，然后才会放到其它发行版上。其默认安装博客 Perl。
Ubuntu Linux （还有其社区版的 Ubuntu MATE）也将树莓派作为其支持 ARM （Advanced RISC Machines）处理器的平台之一。RISC（Reduced Instruction Set Computer）Ubuntu 是一个 Debian Linux 的商业化支持的开源分支，它也使用 DEB 包管理器。Perl 也在其中。它仅仅支持 32 位 ARM7 或者 64 位 ARM8 处理器的树莓派 2 和 3。ARM6 的树莓派 1 和 Zero 从未被 Ubuntu 构建过程支持。
[Fedora Linux](https://fedoraproject.org/wiki/Raspberry_Pi#Downloading_the_Fedora_ARM_image) 支持树莓派2 ，而 Fedora 25 支持 3。 Fedora 是一个隶属于红帽（Red Hat）的开源项目。Fedora 是个基础，商业版的 RHEL（Red Hat Enterprise Linux）在其上增加了商业软件包和支持，所以其软件像所有的兼容红帽的发行版一样来自 RPM（Red Hat Package Manager） 软件包。就像其它发行版一样，也包括 Perl。
[RISC OS](https://www.riscosopen.org/content/downloads/raspberry-pi) 是一个特别针对 ARM 处理器的单用户操作系统。如果你想要一个比 Linux 系统更加简洁的小型桌面（功能更少），你可以考虑一下。它同样支持 Perl。
[RaspBSD](http://www.raspbsd.org/raspberrypi.html) 是一个 FreeBSD 的树莓派发行版。它是一个基于 Unix 的系统，而不是 Linux。作为开源 Unix 的一员，它延续了 Unix 的功能，而且和 Linux 有着众多相似之处。包括有类似的开源软件带来的相似的系统环境，包括 Perl。
[OSMC](https://osmc.tv/)，即开源多媒体中心，以及 [LibreElec](https://libreelec.tv/) 电视娱乐中心，它们都基于运行 Linux 内核之上的 Kodi 娱乐中心。它是一个小巧、特化的 Linux 系统，所以不要期望它能支持 Perl。
[Microsoft Windows IoT Core](http://ms-iot.github.io/content/en-US/Downloads.htm) 是仅运行在树莓派３上的新成员。你需要微软开发者身份才能下载。而作为一个 Linux 极客，我根本不看它。我的 PiFlash 脚本还不支持它，但如果你找的是它，你可以去看看。
### PiFlash 脚本
如果你想看看[树莓派 SD 卡烧录指导](https://www.raspberrypi.org/documentation/installation/installing-images/README.md)，你可以找到在 Windows 或者 Mac 系统下需要下载的工具来完成烧录任务。但是对于 Linux 系统，只有一系列手工操作建议。我已经手工做过这个太多次，这很容易引发一个开发者的本能去自动化这个过程，这就是 PiFlash 脚本的起源。这有点难，因为 Linux 有太多方法可以配置，但是它们都是基于 Linux 内核的。
我总是觉得，手工操作潜在最大的失误恐怕就是偶然错误地擦除了某个设备，而不是擦除了 SD 卡，然后彻底清除了我本想保留在硬盘的东西。我在 SVPerl 演讲中也说了，我很惊讶地发现在听众中有犯了这种错误（而且不害怕承认）的人。因此，PiFlash 其中一个目的就是保护新手的安全，不会擦除 SD 卡之外的设备。PiFlash 脚本还会拒绝覆写包含了已经挂载的文件系统的设备。
对于有经验的用户，包括我，PiFlash 脚本还提供提供一个简便的自动化服务。下载完系统镜像之后，我不需要必须从 zip格式中解压缩或者提取出系统镜像。PiFlash 可以直接提取它，不管是哪种格式，并且直接烧录到 SD 卡中。
我把 [PiFlash 及其指导](https://github.com/ikluft/ikluft-tools/tree/master/piflash)发布在了 GitHub 上。
命令行用法如下：
```
piflash [--verbose] input-file output-device
piflash [--verbose] --SDsearch
```
`input-file` 参数是你要写入的系统镜像文件，只要是你从树莓派发行版网站下载的镜像都行。`output-device` 参数是你要写入的 SD 卡的块设备路径。
你也可以使用 `--SDsearch` 参数列出挂载在系统中 SD 卡设备名称。
可选项 `--verbose` 可以输出所有的程序状态数据，它在你需要帮助时或者递送 bug 报告和自行排错时很有用。它就是我开发时用的。
下面的例子是我使用该脚本写入仍是 zip 存档的 Raspbian 镜像到位于 `/dev/mmcblk0` 的 SD 卡：
```
piflash 2016-11-25-raspbian-jessie.img.zip /dev/mmcblk0
```
如果你已经指定了 `/dev/mmcblk0p1` （SD 卡的第一分区），它会识别到这个分区不是一个正确的位置，并拒绝写入。
在不同的 Linux 系统中怎样去识别哪个设备是 SD 卡是一个技术活。像 mmcblk0 这种在我的笔记本上是基于 PCI 的 SD卡接口。如果我使用了 USB SD 卡接口，它就是 `/dev/sdb`，这在多硬盘的系统中不好区分。然而，只有少量的 Linux 块设备支持 SD 卡。PiFlash 在这两种情况下都会检查块设备的参数。如果全部失败，它会认为可写入、可移动的，并有着正确物理扇区数量的 USB 驱动器是 SD 卡。
我想这应该能涵盖大部分情况。但是，如果你使用了我不知道的 SD 卡接口呢？我乐意看到你的来信。请在输出信息中加上 `--verbos --SDsearch` 参数，以便让我可以知道你系统目前的环境。理想情况下，如果 PiFlash 脚本可以被广泛利用，我们可以构建一个开源社区去尽可能的帮助更多的树莓派用户。
### 树莓派的 CPAN 模块
[CPAN](http://www.cpan.org/)（Comprehensive Perl Archive Network）是一个世界范围内包含各种 Perl 模块的的下载镜像。它们都是开源的。大量 CPAN 中的模块都是历久弥坚。对于成千上百的任务，你不需要重复造轮子，只要利用别人已经发布的代码就可以了。然后，你还可以提交你的新功能。
尽管树莓派是个五脏俱全的 Linux 系统，支持大部分 CPAN 模块，但是这里我想强调一下专为树莓派硬件开发的东西。一般来说它们都用在测量、控制、机器人方面的嵌入式系统中。你可以通过 GPIO （General-Purpose Input/Output）针脚将你的树莓派连接到外部电子设备。
可以使用树莓派 GPIO 针脚的模块如下：[Device::SMBus](https://metacpan.org/pod/Device::SMBus)、[Device::I2C](https://metacpan.org/pod/Device::I2C)、[Rpi::PIGPIO](https://metacpan.org/pod/RPi::PIGPIO)、[Rpi::SPI](https://metacpan.org/pod/RPi::SPI)、[Rpi::WiringPi](https://metacpan.org/pod/RPi::WiringPi)、[Device::WebIO::RaspberryPI](https://metacpan.org/pod/Device::WebIO::RaspberryPi) 和 [Device::PiGlow](https://metacpan.org/pod/Device::PiGlow)。树莓派支持的嵌入式模块如下：[UAV::Pilot::Wumpus::Server::Backend::RaspberryPiI2C](https://metacpan.org/pod/UAV::Pilot::Wumpus::Server::Backend::RaspberryPiI2C)、[RPI::DHT11](https://metacpan.org/pod/RPi::DHT11)（温度/湿度）、[RPI::HCSR04](https://metacpan.org/pod/RPi::HCSR04)（超声波）、[App::RPI::EnvUI](https://metacpan.org/pod/App::RPi::EnvUI)、[RPi::DigiPot::MCP4XXXX](https://metacpan.org/pod/RPi::DigiPot::MCP4XXXX)、[RPI::ADC::ADS](https://metacpan.org/pod/RPi::ADC::ADS)、[Device::PaPiRus](https://metacpan.org/pod/Device::PaPiRus) 和 [Device::BCM2835::Timer](https://metacpan.org/pod/Device::BCM2835::Timer)。
### 例子
这里有些我们在树莓派上可以用 Perl 做的事情的例子。
#### 例一：在 OSMC 使用 PiFlash 播放视频
本例中，你将练习如何设置并运行使用 OSMC 操作系统的树莓派。
* 到 [RaspberryPi.Org](http://raspberrypi.org/) 下载区，下载最新的 OSMC 版本。
* 将空 SD 卡插入你的 Linux 电脑或者笔记本。树莓派第一代是全尺寸的 SD 卡，除此以外都在使用 microSD，你也许需要一个通用适配器才能插入它。
* 在插入前后分别运行 `cat /proc/partitions` 命令来看看系统分给硬件的设备名称。它可能像这样 `/dev/mmcblk0` 或者 `/dev/sdb`， 用如下命令将正确的系统镜像烧录到 SD 卡：`piflash OSMC_TGT_rbp2_20170210.img.gz /dev/mmcblk0`。
* 弹出 SD 卡，将它插入树莓派中，接上 HDMI 显示器，开机。
* 当 OSMC 设置完毕，插入一个 USB 设备，在里面放点视频。出于示范目的，我将使用 `youtube-dl` 程序下载两个视频。运行 `youtube-dl OHF2xDrq8dY` （彭博关于英国高新产业，包括树莓派的介绍）还有 `youtube-dl nAvZMgXbE9c` （CNet 发表的“排名前五的树莓派项目”) 。将它们下载到 USB 中，然后卸载移除设备。
* 将 USB 设备插入到 OSMC 树莓派。点击视频选项进入到外部设备。
* 只要你能在树莓派中播放视频，那么恭喜你，你已经完成了本次练习。玩的愉快。
#### 例二：随机播放目录中的视频的脚本
这个例子将使用一个脚本在树莓派上的目录中乱序播放视频。根据视频的不同和设备的摆放位置，这可以用作信息亭显示的用途。我写这个脚本用来展示室内体验视频。
* 设置树莓派引导 Raspbian Linux。连接到 HDMI 监视器。
* 从 GitHub 上下载 [do-video 脚本](https://github.com/ikluft/ikluft-tools/tree/master/perl-on-pi)。把它放到树莓派中。
* 跟随该页面的安装指导。最主要的事情就是安装 omxplayer 包，它可以使用树莓派硬件视频加速功能平滑地播放视频。
* 在家目录的 Videos 目录下放一些视频。
* 运行 `do-video` ，这样，应该就可以播放视频了
#### 例三：读取 GPS 数据的脚本
这个例子更加深入，更有针对性。它展示了 Perl 怎么从外部设备中读取数据。在先前例子中出现的我的 GitHub上 “[Perl on Pi](https://github.com/ikluft/ikluft-tools/tree/master/perl-on-pi)” 有一个 gps-read.pl 脚本。它可以通过一系列端口从 GPS 读取 NMEA（国家海洋电子协会）的数据。页面还有教程，包括构建它所使用的 AdaFruit Industries 部分，但是你可以使用任何能输出 NMEA 数据的 GPS。
通过这些任务，我想你应该可以在树莓派上像使用其他语言一样使用 Perl了。希望你喜欢。
---
作者简介：
Ian Kluft - 上学开始，Ian 就对喜欢编程和飞行。他一直致力于 Unix 的工作。在 Linux 内核发布后的六个月他转向了 Linux。他有计算机科学硕士学位，并且拥有 CSSLP 资格证（认证规范开发流程专家），另一方面，他还是引航员和认证的飞机指令长。作为一个超过二十五年的认证的无线电爱好者，在近些年，他在一些电子设备上陆续做了实验，包括树莓派。
---
via: <https://opensource.com/article/17/3/perl-raspberry-pi>
作者：[Ian Kluft](https://opensource.com/users/ikluft) 译者：[Taylor1024](https://github.com/Taylor1024) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
OpenStack 上的 OpenShift：更好地交付应用程序
|
Scott Mccarty
|
https://blog.openshift.com/openshift-on-openstack-delivering-applications-better-together/
|
传统的操作系统一直是关于硬件资源的展示和消耗 - 硬件提供资源，应用程序消耗它们，操作系统一直是交通警察。但传统的操作系统一直局限于单机。那么，在原生云的世界里，现在意味着这个概念扩展到包括多个操作系统实例。这就是 OpenStack 和 OpenShift 所在。
|
/data/attachment/album/201709/01/114318n2qi2asy2fqypsai.jpg.thumb.jpg
|
/data/attachment/album/201709/01/114318n2qi2asy2fqypsai.jpg
| true | false | true |
geekpi
| false |
[
"OpenStack",
"OpenShift"
] |
容器与云
|
{
"viewnum": 8139,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "180.172.89.51",
"message": "开源容器云OpenShift 构建基于Kubernetes的企业应用云平台:<br />\r\nhttps://pan.baidu.com/s/1t-q0GXL4WRi8G_SvrLmkgw",
"username": "xhuaustc [Chrome 73.0|Mac 10.13]",
"date": "2019-04-26T00:47:59"
}
] |
[] |
传统的操作系统一直是关于硬件资源的展示和消耗 - 硬件提供资源，应用程序消耗它们，操作系统一直是交通警察。但传统的操作系统一直局限于单机。那么，在原生云的世界里，现在意味着这个概念扩展到包括多个操作系统实例。这就是 OpenStack 和 OpenShift 所在。
| 2017-09-01T11:44:00 | 2017-09-01T11:44:00 | 8,830 |
/article-8830-1.html
|
你有没有问过自己，我应该在哪里运行 OpenShift？答案是任何地方 - 它可以在裸机、虚拟机、私有云或公共云中很好地运行。但是，这里有一些为什么人们正迁移到围绕全栈和资源消耗自动化相关的私有云和公有云的原因。传统的操作系统一直是关于[硬件资源的展示和消耗](https://docs.google.com/presentation/d/139_dxpiYc5JR8yKAP8pl-FcZmOFQCuV8RyDxZqOOcVE/edit) - 硬件提供资源，应用程序消耗它们，操作系统一直是交通警察。但传统的操作系统一直局限于单机<sup> 注1</sup> 。
那么，在原生云的世界里，现在意味着这个概念扩展到包括多个操作系统实例。这就是 OpenStack 和 OpenShift 所在。在原生云世界，虚拟机、存储卷和网段都成为动态配置的构建块。我们从这些构建块构建我们的应用程序。它们通常按小时或分钟付费，并在不再需要时被取消配置。但是，你需要将它们视为应用程序的动态配置能力。 OpenStack 在动态配置能力（展示）方面非常擅长，OpenShift 在动态配置应用程序（消费）方面做的很好，但是我们如何将它们结合在一起来提供一个动态的、高度可编程的多节点操作系统呢？
要理解这个，让我们来看看如果我们在传统的环境中安装 OpenShift 会发生什么 - 想像我们想要为开发者提供动态访问来创建新的应用程序，或者想象我们想要提供业务线，使其能够访问现有应用程序的新副本以满足合同义务。每个应用程序都需要访问持久存储。持久存储不是临时的，在传统的环境中，这通过提交一张工单实现。没关系，我们可以连到 OpenShift，每次需要存储时都会提交一张工单。存储管理员可以登录企业存储阵列并根据需要删除卷，然后将其移回 OpenShift 以满足应用程序。但这将是一个非常慢的手动过程，而且你可能会遇到存储管理员辞职。
在原生云的世界里，我们应该将其视为一个策略驱动的自动化流程。存储管理员变得更加战略性、设置策略、配额和服务级别（银、黄金等），但实际配置变得动态。
动态过程可扩展到多个应用程序 - 这可能是开发者测试的业务线甚至新应用程序。从 10 多个应用程序到 1000 个应用程序，动态配置提供原生云体验。
下面的演示视频展示了动态存储配置如何与 Red Hat OpenStack 平台（Cinder 卷）以及 Red Hat OpenShift 容器平台配合使用，但动态配置并不限于存储。想象一下，随着 OpenShift 的一个实例需要更多的容量、节点自动扩展的环境。想象一下，推送一个敏感的程序更改前，将网段划分为负载测试 OpenShift 的特定实例。这些是你为何需要动态配置 IT 构建块的原因。OpenStack 实际上是以 API 驱动的方式实现的。
OpenShift 和 OpenStack 一起更好地交付应用程序。OpenStack 动态提供资源，而 OpenShift 会动态地消耗它们。它们一起为你所有的容器和虚拟机需求提供灵活的原生云解决方案。
注1：高可用性集群和一些专门的操作系统在一定程度上弥合了这一差距，但在计算中通常是一个边缘情况。
---
via: <https://blog.openshift.com/openshift-on-openstack-delivering-applications-better-together/>
作者：[SCOTT MCCARTY](https://blog.openshift.com/author/smccartyredhat-com/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 LibreOffice Calc 管理你的财务
|
Scott Nesbitt
|
https://opensource.com/article/17/8/budget-libreoffice-calc
|
你想知道你的钱花在哪里？这个精心设计的电子表格可以一目了然地回答这个问题。
|
/data/attachment/album/201709/01/134951eodh9pykzey9aloj.png.thumb.jpg
|
/data/attachment/album/201709/01/134951eodh9pykzey9aloj.png
| true | false | true |
geekpi
| false |
[
"LibreOffice"
] |
桌面应用
|
{
"viewnum": 7241,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你想知道你的钱花在哪里？这个精心设计的电子表格可以一目了然地回答这个问题。
| 2017-09-01T13:49:47 | 2017-09-01T13:49:47 | 8,831 |
/article-8831-1.html
|
>
> 你想知道你的钱花在哪里？这个精心设计的电子表格可以一目了然地回答这个问题。
>
>
>
如果你像大多数人一样，没有一个无底般的银行帐户。你可能需要仔细观察你的每月支出。
有很多方法可以做到这一点，但是最快最简单的方法是使用电子表格。许多人创建一个非常基本的电子表格来完成这项工作，它由两长列组成，总计位于底部。这是可行的，但这有点傻。
我将通过使用 LibreOffice Calc 创建一个更便于细查的（我认为）以及更具视觉吸引力的个人消费电子表格。
你说不用 LibreOffice？没关系。你可以使用 [Gnumeric](http://www.gnumeric.org/)、[Calligra Sheets](https://www.calligra.org/sheets/) 或 [EtherCalc](https://ethercalc.net/) 等电子表格工具使用本文中的信息。
### 首先列出你的费用
先别费心 LibreOffice 了。坐下来用笔和纸，列出你的每月日常开支。花时间，翻遍你的记录，记下所有的事情，无论它多么渺小。不要担心你花了多少钱。重点放在你把钱花在哪里。
完成之后，将你的费用分组到最有意义的标题下。例如，将你的燃气、电气和水费放在“水电费”下。你也可能想要为我们每个月都会遇到的意外费用，使用一组名为“种种”。
### 创建电子表格
启动 LibreOffice Calc 并创建一个空的电子表格。在电子表格的顶部留下三个空白行。之后我们会回来。
你把你的费用归类是有原因的：这些组将成为电子表格上的块。我们首先将最重要的花费组（例如 “家庭”）放在电子表格的顶部。
在工作表顶部第四行的第一个单元格中输入该花费组的名称。将它放大（可以是 12 号字体）、加粗使得它显眼。
在该标题下方的行中，添加以下三列：
* 花费
* 日期
* 金额
在“花费”列下的单元格中输入该组内花费的名称。
接下来，选择日期标题下的单元格。单击 **Format** 菜单，然后选择 **Number Format > Date**。对“金额”标题下的单元格重复此操作，然后选择 **Number Format > Currency**。
你会看到这样：
这是一组开支的方式。不要为每个花费组创建新块, 而是复制你创建的内容并将其粘贴到第一个块旁边。我建议一行放三块, 在它们之间有一个空列。
你会看到这样：
对所有你的花费组做重复操作。
### 总计所有
查看所有个人费用是一回事，但你也可以一起查看每组费用的总额和所有费用。
我们首先总计每个费用组的金额。你可以让 LibreOffice Calc 自动做这些。高亮显示“金额”列底部的单元格，然后单击 “Formula” 工具栏上的 “Sum” 按钮。
单击金额列中的第一个单元格，然后将光标拖动到列中的最后一个单元格。然后按下 Enter。
现在让我们用你顶部留下的两三行空白行做一些事。这就是你所有费用的总和。我建议把它放在那里，这样无论何时你打开文件时它都是可见的。
在表格左上角的其中一个单元格中，输入类似“月总计”。然后，在它旁边的单元格中，输入 `=SUM()`。这是 LibreOffice Calc 函数，它可以在电子表格中添加特定单元格的值。
不要手动输入要添加的单元格的名称，请按住键盘上的 Ctrl。然后在电子表格上单击你在每组费用中总计的单元格。
### 完成
你有一张追踪一个月花费的表。拥有单个月花费的电子表格有点浪费。为什么不用它跟踪全年的每月支出呢？
右键单击电子表格底部的选项卡，然后选择 **Move or Copy Sheet**。在弹出的窗口中，单击 **-move to end position-**，然后按下 Enter 键。一直重复到你有 12 张表 - 每月一张。以月份重命名表格，然后使用像 *Monthly Expenses 2017.ods* 这样的描述性名称保存电子表格。
现在设置完成了，你可以使用电子表格了。使用电子表格跟踪你的花费本身不会坚实你的财务基础，但它可以帮助你控制每个月的花费。
（题图： opensource.com）
---
作者简介：
Scott Nesbitt - 我是一名长期使用自由/开源软件的用户，并为了乐趣和收益写了各种软件。我不会太严肃。你可以在网上这些地方找到我：Twitter、Mastodon、GitHub。
---
via: <https://opensource.com/article/17/8/budget-libreoffice-calc>
作者：[Scott Nesbitt](https://opensource.com/users/scottnesbitt) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么开源应该是云原生环境的首选
|
Elizabeth K. Joseph
|
https://opensource.com/article/17/8/open-sourcing-infrastructure
|
让我们回溯到上世纪 90 年代，当时专有软件大行其道，而开源才刚开始进入它自己的时代。是什么导致了这种转变？更重要的是，而今天我们转到云原生环境时，我们能从中学到什么?
|
/data/attachment/album/201709/02/202726r0qhkxkehf6qapoo.png.thumb.jpg
|
/data/attachment/album/201709/02/202726r0qhkxkehf6qapoo.png
| true | false | true |
wenzhiyi
| false |
[
"开源",
"OpenStack"
] |
观点
|
{
"viewnum": 4326,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
让我们回溯到上世纪 90 年代，当时专有软件大行其道，而开源才刚开始进入它自己的时代。是什么导致了这种转变？更重要的是，而今天我们转到云原生环境时，我们能从中学到什么?
| 2017-09-02T20:27:22 | 2017-09-02T20:27:22 | 8,832 |
/article-8832-1.html
|
>
> 基于 Linux 击败了专有软件一样的原因，开源应该成为云原生环境的首选。
>
>
>
让我们回溯到上世纪 90 年代，当时专有软件大行其道，而开源才刚开始进入它自己的时代。是什么导致了这种转变？更重要的是，而今天我们转到云原生环境时，我们能从中学到什么?
### 基础设施的历史经验
我将以一个高度武断的、开源的视角开始，来看看基础设施过去 30 年的历史。在上世纪 90 年代，Linux 只是大多数组织视野中一个微不足道的小光点而已——如果他们听说过它的话。你早早购入股票的那些公司们很快就发现了 Linux 的好处，它主要是作为专有的 Unix 的廉价替代品，而部署服务器的标准方式是使用专有的 Unix，或者日渐增多的使用 Microsoft Windows NT。
这种模式的专有本性为更专有的软件提供了一个肥沃的生态系统。软件被装在盒子里面放在商店出售。甚至开源软件也参与了这种装盒游戏；你可以在货架上买到 Linux，而不是用你的互联网连接免费下载。去商店和从你的软件供应商那里只是你得到软件的不同方式而已。
*Ubuntu 包装盒出现在百思买的货架上*
我认为，随着 LAMP 系列（Linux、Apache、MySQL 和 PHP / Perl / Python）的崛起，情况发生了变化。LAMP 系列非常成功。它是稳定的、可伸缩的和相对用户友好的。与此同时，我开始看到对专有解决方案的不满。一旦客户在 LAMP 系列中尝过了开源的甜头，他们就会改变他们对软件的期望，包括：
* 不愿被供应商绑架，
* 关注安全，
* 希望自己来修复 bug ，以及
* 孤立开发的软件意味着创新被扼杀。
在技术方面，我们也看到了各种组织在如何使用软件上的巨大变化。忽然有一天，网站的宕机变成不可接受的了。这就对扩展性和自动化有了更多的依赖。特别是在过去的十年里，我们看到了基础设施从传统的“宠物”模式到“群牛”模式的转变，在这种模式中，服务器可以被换下和替换，而不是一直运行和被指定。公司使用大量的数据，更注重数据留存和数据到用户的处理和返回速度。
开源和开源社区，以及来自大公司的日益增多的投入，为我们改变如何使用软件提供了基础。系统管理员的岗位要求开始 要求 Linux 技能和对开源技术和理念的熟悉。通过开源类似 Chef cookbooks 和 Puppet 模块这样东西，管理员可以分享他们的模式配置。我们不再单独配置和调优 MySQL；我们创建了一个掌控基础部分的系统，我们现在可以专注于更有趣的、可以给我们雇主带来更高价值的工程作业。
开源现在无处不在，围绕它的模式也无处不在。曾经仇视这个想法的公司不仅通过协同项目与外界拥抱开源，而且进一步地，还发布了他们自己的开源软件项目并且围绕它们构建了社区。
### 转向云端
今天，我们生活在一个 DevOps 和云端的世界里。我们收获了开源运动带来的创新成果。在公司内部采用开源软件开发实践的情况下， Tim O'reilly 所称的 “[内部开源](https://opensource.com/life/16/11/create-internal-innersource-community)” 有了明显增长。我们为云平台共享部署配置。像 Terraform 这样的工具甚至允许我们编写和分享我们如何部署特定的平台。
但这些平台本身呢？
>
> “大多数人想都不想就使用了云……许多用户将钱投入到根本不属于他们的基础设施中，而对放弃他们的数据和信息毫无顾虑。" —Edward Snowden, OpenStack Summit, May 9, 2017
>
>
>
现在是时候要更多地想想本能地转移或扩展到云上的事情了。
就像 Snowden 强调的那样，现在我们正面临着对我们的用户和客户的数据的失控风险。抛开安全不谈，如果我们回顾一下我们转向开源的原因，个中原因还包括被厂商绑架的担忧、创新难以推动、甚至修复 bug 的考虑。
在把你自己和/或你的公司锁定在一个专有平台之前，考虑以下问题：
* 我使用的服务是遵循开放标准，还是被厂商绑架的？
* 如果服务供应商破产或被竞争对手收购，什么是我可以依赖的？
* 关于停机、安全等问题，供应商与其客户沟通中是否有一个明确而真诚的历史过往？
* 供应商是否响应 bug 和特性请求，即使那是来自小客户？
* 供应商是否会在我不知情的情况下使用我们的数据（或者更糟，即便我们的客户协议所不同意）？
* 供应商是否有一个计划来处理长期的，不断上升的增长成本，特别是如果最初的成本很低呢？
您可以通过这个问卷，讨论每个要点，而仍然决定使用专有的解决方案。这很好，很多公司一直都在这么做。然而，如果你像我一样，宁愿找到一个更开放的解决方案而仍然受益于云，你确实有的选择。
### 基于私有云
当您寻找私有云解决方案时，您的首选是开源，投资一个云提供商，其核心运行在开源软件上。 [OpenStack](https://www.openstack.org/) 是行业领袖，在其 7 年的历史中，有 100 多个参与组织和成千上万的贡献者（包括我）。 OpenStack 项目已经证明，结合多个基于 OpenStack 云不仅是可行的，而且相对简单。云公司之间的 API 是相似的，所以您不必局限于特定的 OpenStack 供应商。作为一个开放源码项目，您仍然可以影响该基础设施的特性、bug 请求和发展方向。
第二种选择是继续在基础层面上使用私有云，但在一个开源容器编排系统中。无论您选择 [DC/OS](https://dcos.io/)（基于[Apache Mesos](http://mesos.apache.org/)) 、[Kubernetes](https://kubernetes.io/) 或 [Docker Swarm 模式](https://docs.docker.com/engine/swarm/) ，这些平台都允许您将私有云系统提供的虚拟机作为独立的 Linux 机器，并在此之上安装您的平台。您所需要的只是 Linux 而已，不会立即被锁定在特定云的工具或平台上。可以根据具体情况来决定是否使用特定的专属后端，但如果你这样做，就应该着眼于未来。
有了这两种选择，你也可以选择完全离开云服务商。您可以部署自己的 OpenStack 云，或者将容器平台内部架构移动到您自己的数据中心。
### 做一个登月计划
最后，我想谈一谈开源项目基础设施。今年 3 月，在召开的 [南加州 Linux 展会](https://www.socallinuxexpo.org/) 上，多个开放源码项目的参与者讨论了为他们的项目运行开源基础设施。（更多的，请阅读我的 [关于该会议的总结](https://opensource.com/article/17/3/growth-open-source-project-infrastructures)）我认为这些项目正在做的这个工作是基础设施开源的最后一步。除了我们现在正在做的基本分享之外，我相信公司和组织们可以在不放弃与竞争对手相区分的“独门秘方”的情况下，进一步充分利用他们的基础设施开源。
开源了他们的基础设施的开源项目，已经证明了允许多个公司和组织向他们的基础设施提交训练有素的 bug 报告，甚至是补丁和特定论文的价值。突然之间，你可以邀请兼职的贡献者。你的客户可以通过了解你的基础设施，“深入引擎盖子之下”，从而获得信心。
想要更多的证据吗？访问 [开源基础设施](https://opensourceinfra.org/) 的网站了解开源基础设施的项目（以及他们已经发布的大量基础设施）。
可以在 8 月 26 日在费城举办的 FOSSCON 大会上 Elizabeth K. Joseph 的演讲“[基础架构开源](https://fosscon.us/node/12637)”上了解更多。
（题图：[Jason Baker](https://opensource.com/users/jason-baker). [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/). Source: [Cloud](https://pixabay.com/en/clouds-sky-cloud-dark-clouds-1473311/), [Globe](https://pixabay.com/en/globe-planet-earth-world-1015311/). Both [CC0](https://creativecommons.org/publicdomain/zero/1.0/).）
---
via: <https://opensource.com/article/17/8/open-sourcing-infrastructure>
作者：[Elizabeth K. Joseph](https://opensource.com/users/pleia2) 译者：[wenzhiyi](https://github.com/wenzhiyi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Fedora 的 Yum 或将在一两年内退休
|
Michael Larabel
|
http://www.phoronix.com/scan.php?page=news_item&px=Fedora-Yum-Retirement
|
随着 DNF 软件包管理器在最近的 Fedora 版本里面工作日益工作良好，我们可以预见到 Yum 将在之后的 Fedora 版本中谢幕。
|
/data/attachment/album/201709/03/114024w0kg9ajhmc04cc16.jpg.thumb.jpg
|
/data/attachment/album/201709/03/114024w0kg9ajhmc04cc16.jpg
| true | false | true |
wxy
| false |
[
"DNF",
"Yum"
] |
新闻
|
{
"viewnum": 5903,
"commentnum": 5,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "203.59.16.142",
"message": "那麼問題來了，未來dnf的repository配置文件存在哪。<br />\r\n會不會因爲歷史遺留問題繼續存在`/etc/yum.repos.d/`裏。",
"username": "来自澳大利亚的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-09-03T15:57:53"
},
{
"postip": "125.71.65.34",
"message": "建立一个符号链接就是了。",
"username": "来自四川成都的 Chromium 60.0|Ubuntu 用户",
"date": "2017-09-03T16:46:37"
},
{
"postip": "117.182.155.0",
"message": "富依赖是什么？",
"username": "来自117.182.155.0的 Chrome 60.0|Windows 7 用户",
"date": "2017-09-03T18:52:20"
},
{
"postip": "210.186.247.137",
"message": "终于要退休了..",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-09-03T20:40:07"
},
{
"postip": "119.130.229.21",
"message": "其实为什么不继续用yum这个命令，只要把dnf改称yum其他的继续用就行了。改个名字就是为了说明升级优化了？",
"username": "来自广东广州的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-08T18:48:42"
}
] |
[
{
"raid": 3196,
"displayorder": 0
},
{
"raid": 5463,
"displayorder": 1
}
] |
随着 DNF 软件包管理器在最近的 Fedora 版本里面工作日益工作良好，我们可以预见到 Yum 将在之后的 Fedora 版本中谢幕。
| 2017-09-03T11:38:00 | 2017-09-03T11:38:00 | 8,833 |
/article-8833-1.html
|
随着 DNF 软件包管理器在最近的 Fedora 版本里面工作日益工作良好，我们可以预见到 Yum 将在之后的 Fedora 版本中谢幕。
当然，Yum 还一直广泛用在 RHEL 7 中，而在 Fedora 这边，估计在大约一年后的 Fedora 28 乃至 29 中正式退休。
在 Fedora 开发者邮件列表中有一个讨论 [Yum 退休](https://lists.fedoraproject.org/archives/list/devel@lists.fedoraproject.org/thread/GF6THFF5FXCNTKHVLVRRFHS46BTDPO5Y/)的新话题。看起来在 Fedora 28 或 29 的时候会移除 Yum。DNF 已经提供了与 Yum 一样的能力。Fedora 也在开发一个“富依赖”的支持，而这个功能 Yum 不支持，所以这也表明了 Yum 将在以后的 Fedora 系统中消失。
邮件列表中也提到了 Yum 和 DNF 还存在一些差异需要解决，但是看起来在 2018 年应该可以看到希望。
|
||
GNU GPL 许可证常见问题解答（二）
|
Fsf
|
https://www.gnu.org/licenses/gpl-faq.html
|
本文由高级咨询师薛亮据自由软件基金会（FSF）的英文原文翻译而成，这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
|
/data/attachment/album/201709/03/122923n2n20eonjsq2gh2o.png.thumb.jpg
|
/data/attachment/album/201709/03/122923n2n20eonjsq2gh2o.png
| true | false | true |
薛亮
| true |
[
"GPL",
"许可证"
] |
开源智慧
|
{
"viewnum": 12627,
"commentnum": 2,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "117.182.155.0",
"message": "2.49 GPL在天朝能够获得法律支持吗？",
"username": "来自117.182.155.0的 Chrome 60.0|Windows 7 用户",
"date": "2017-09-04T11:30:52"
},
{
"postip": "218.58.78.203",
"message": "好文！感谢！",
"username": "绿色圣光 [Firefox 54.0|GNU/Linux]",
"date": "2017-09-05T14:50:53"
}
] |
[
{
"raid": 8761,
"displayorder": 0
},
{
"raid": 9062,
"displayorder": 0
}
] |
本文由高级咨询师薛亮据自由软件基金会（FSF）的英文原文翻译而成，这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
| 2017-09-04T09:26:00 | 2017-09-04T09:26:00 | 8,834 |
/article-8834-1.html
|
本文由高级咨询师薛亮据自由软件基金会（FSF）的[英文原文](https://www.gnu.org/licenses/gpl-faq.html)翻译而成，这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
1. [关于 GNU 项目、自由软件基金会（FSF）及其许可证的基本问题](/article-8761-1.html)
2. 对于 GNU 许可证的一般了解
3. 在您的程序中使用 GNU 许可证
4. 依据 GNU 许可证分发程序
5. 在编写其他程序时采用依据 GNU 许可证发布的程序
6. 将作品与依据 GNU 许可证发布的代码相结合
7. 关于违反 GNU 许可证的问题
### **2、****对于** **GNU** **许可证的一般了解**
#### 2.1 为什么 GPL 允许用户发布其修改版本？
自由软件的一个关键特点是用户可以自由合作。绝对有必要允许希望彼此帮助的用户与其他用户分享他们对错误的修复和改进。
有些人提出了 GPL 的替代方案，需要原作者批准修改版本。只要原作者持续进行维护，这种做法在实践中可能会不错，但是如果作者停止维护（或多或少会）去做别的事情，或并不打算去满足所有用户的需求，这种替代方案就会失败。除了实践上的问题之外，该方案也不允许用户之间互相帮助。
有时候对修改版本的控制，是为了防止用户制作的各种版本之间造成混淆。根据我们的经验，这种混乱不是一个大问题。在 GNU 项目之外出现了许多版本的 Emacs，但用户仍可以将它们区分开。GPL 要求版本创造者将他/她的名字标注其上，以区别于其他版本，并保护其他维护者的声誉。
#### 2.2 GPL 是否要求将修改版本的源代码公开发布？
GPL 不要求您发布修改后的版本或其中的任何一部分。您可以自由地进行修改并私人使用它们，而无需进行发布。这也适用于组织（包括企业）；组织可以制作修改版本，在内部使用它，并且绝不将修改版本发布到组织之外。
但是，*如果*您以某种方式向公众发布修改后的版本，依据 GPL 许可证，GPL 要求您保证程序的用户可以获得修改后源代码。
因此，GPL 给你以某些特定方式发布修改后的程序的授权，而不是以其他方式发布；但是，是否发布修改版本的决定取决于您。
#### 2.3 我可以在同一台电脑上安装一个遵循 GPL 许可证的程序和一个不相关的非自由程序吗？
可以。
#### 2.4 如果我知道某些人有一个遵循 GPL 许可证的程序的副本，我可以要求他们给我一个副本吗？
不可以，GPL 给人们制作和再分发程序副本的授权，倘若有人选择这样做的话。那个人也有权选择不去再分发该程序。
#### 2.5 GPL v2 中的“<ruby> 书面文件 <rp> （ </rp> <rt> written offer </rt> <rp> ） </rp></ruby>对任何第三方有效”是什么意思？ 这是否意味着世界上每个人都可以获得任何遵循 GPL 许可证的程序的源代码？
如果您选择通过书面文件提供源代码，那么任何向您索求源代码的人都有权收到。
如果您对不附带源代码的二进制文件进行商业分发，GPL 要求您必须提供一份书面文件，表明将稍后分发源代码。当用户非商业性地再分发他们从您那里获取的二进制文件时，他们必须传递这份书面文件的副本。这意味着不能直接从您那里获取二进制文件的人，仍然可以收到源代码副本以及该书面文件。
我们要求书面文件对任何第三方有效的原因是，以这种方式间接收到二进制代码的人可以从您那里订购源代码。
#### 2.6 GPL v2 中规定，发布后的修改版本必须“授予…所有第三方许可”。这些第三方是谁？
第 2 节中规定，依据 GPL，您分发的修改版本必须授权给所有第三方。 “所有第三方”当然是指所有人，但这并不要求您为他们*做*任何事情。这仅仅意味着他们依据 GPL 从您那里获得了您的修改版本的许可。
#### 2.7 GPL 允许我出售程序的副本以获利吗？
是的，GPL 允许每个人这样做。[销售副本的权利](https://www.gnu.org/philosophy/selling.html)是自由软件定义的一部分。除了一种特殊情况之外，对您可以收取什么样的价格是没有限制的。（这种例外情况是：二进制版本必须附有表明将提供源代码的书面文件。）
#### 2.8 GPL 允许我从我的分发网站收取下载程序的费用吗？
允许。您可以对您分发程序副本收取任何您想收取的费用。如果您通过下载分发二进制文件，则必须提供“等同的访问权限”来让人们下载源代码，因此，下载源代码的费用可能不会超过下载二进制文件的费用。
#### 2.9 GPL 允许我要求任何接收软件的人必须向我支付费用和/或通知我吗？
不允许。实际上，这样的要求会使程序变成非自由软件。如果人们在获得程序副本时必须支付费用，或者他们必须特别通知任何人，那么这个程序就不是自由软件。请参阅[自由软件的定义](https://www.gnu.org/philosophy/free-sw.html)。
GPL 是自由软件许可证，因此允许人们使用甚至再分发软件，而不需要向任何人支付费用。
您可以向用户收取费用，[以获取您的副本](https://www.gnu.org/licenses/gpl-faq.html#DoesTheGPLAllowMoney)。当他们*从别人那里*获得副本时，您不能要求人们向您支付费用。
#### 2.10 如果我收费分发遵循 GPL 的软件，我是否还需要向公众免费提供？
不需要。不过，如果有人向您支付费用并获得副本，GPL 给予他们免费或收费向公众发布的自由。例如，有人可以向您支付费用，然后把他的副本放在一个网站上，让公众去获取。
#### 2.11 GPL 允许我根据保密协议分发副本吗？
不允许。GPL 规定，任何从您那里获取副本的人都有权再分发已修改或未修改的副本。您不得在任何更严格的基础上分发作品。
如果有人要求您签署保密协议（NDA），以获取来自 FSF 的遵循 GPL 的软件，请立即通知我们 <license-violation@fsf.org>。
如果违规行为涉及其他版权所有者的遵循 GPL 的代码，请通知该版权所有者，就像您对其他任何类型的 GPL 违规行为所做的工作一样。
#### 2.12 GPL 允许我根据保密协议分发程序的修改版或测试版吗？
不可以。GPL 规定，您的修改版本必须具备 GPL 中规定的所有自由。因此，从您那里获取您的版本副本的任何人都有权再分发该版本的副本（已修改或未修改）。您不得在更严格的基础上分发该作品的任何版本。
#### 2.13 GPL 是否允许我根据保密协议开发程序的修改版本？
可以。例如，您可以接受一份合同来开发修改版本，并同意不得发布*您的修改版本*，直到客户同意才可以发布。这是允许的，因为这种情况下不处于 GPL 协议之下的代码是依据 NDA 分发的。
您还可以依据 GPL 将您的修改版本发布给客户，但须同意不将其发布给其他任何人，除非客户同意。也同样在这种情况下，不处于 GPL 协议之下的代码是以保密协议或任何其他限制条款分发的。
GPL 将给予客户再分发您的版本的权利。在这种情况下，客户可能会选择不行使这项权利，但他确实*拥有*这项权利。
#### 2.14 为什么 GPL 要求程序的每个副本必须包含 GPL 许可证副本？
作品包含许可证副本至关重要，因此获得程序副本的每个人都可以知道他们的权利是什么。
包括一个指向许可证的 URL，而不是将许可证本身包含在内，这是一种看起来很诱人的做法。但是您不能确定该 URL 在五年或十年后仍然有效。二十年后，我们今天所知道的 URL 们可能已不复存在。
不管网络将发生什么样的变化，确保拥有该程序副本的人员能够继续看到 GPL 许可证的唯一方法是，将许可证的副本包含在该程序中。
#### 2.15 如果作品不是很长，那该怎么办？
如果整个软件包中只有很少的代码——我们使用的基准是不到 300 行，那么您可以使用一个宽松的许可证，而不是像 GNU GPL这样的 Copyleft 许可证（除非代码特别重要）。我们[建议这种情况使用 Apache License 2.0](https://www.gnu.org/licenses/license-recommendations.html#software)。
#### 2.16 我是否需要将我对遵循 GPL 的程序所做的修改声明版权？
您不需要对您的修改声明版权。不过，在大多数国家/地区，默认情况下会自动获得版权，因此，如果您不希望修改受到版权限制，您需要将修改明显地放置于公有领域。
无论您是否对您的修改声明版权，依据 GPL，您都必须将修改版本作为整体发布（参见：2.2 GPL 是否要求将修改版本的源代码公开发布？）。
#### 2.17 GPL 对于将某些代码翻译成不同的编程语言是如何规定的？
根据著作权法，翻译工作被认为是一种修改。因此，GPL 对修改版本的规定也适用于翻译版本。
#### 2.18 如果一个程序将公有领域代码与遵循 GPL 的代码相结合，我可以取出公有领域的部分，并作为公有领域代码来使用吗？
您可以这样做，如果您能弄清楚哪个部分是公有领域的部分，并将其与其他部分区分开。如果代码曾经由其开发人员放置在公有领域，那么它就是公有领域代码，无论它现在究竟在哪里。
#### 2.19 我想要因我的作品获得声誉。我想让人们知道我写了什么，如果我使用 GPL，我还能获得声誉吗？
您一定能获得这份作品的声誉。遵循 GPL 发布的程序的一部分是以您自己名义撰写的版权声明（假设您是版权所有者）。GPL 要求所有副本携带恰当的版权声明。
#### 2.20 GPL 允许我添加条款，要求在使用遵循 GPL 的软件或其输出物的研究论文中包含引用或致谢吗？
不可以，根据 GPL 的规定，这是不允许的。虽然我们认识到适当的引用是学术出版物的重要组成部分，但引用不能作为对 GPL 的附加要求。对使用 GPL 软件的研究论文要求包含引用，超出了 GPL v3 第 7（b）条中可接受的附加要求，因此将被视为对 GPL 第 7 节的额外限制。而且版权法也不允许您在[软件的输出物](https://www.gnu.org/licenses/gpl-faq.html#GPLOutput)中设置这样的要求，无论该软件是依据 GPL 还是其他许可证的条款获得许可。
#### 2.21 为了节省空间，我是否可以省略 GPL 的引言部分，或者省略如何在自己的程序上使用GPL的<ruby> 指导 <rp> （ </rp> <rt> instructions </rt> <rp> ） </rp></ruby>部分吗？
引言和指导是 GNU GPL 的组成部分，不能省略。事实上，GPL 是受版权保护的，其许可证规定只能逐字复制整个 GPL。（您可以使用法律条款制作[另一个许可证](https://www.gnu.org/licenses/gpl-faq.html#ModifyGPL)，但该许可证不再是 GNU GPL。）
引言和指导部分共约 1000 字，不到 GPL 总文字数量的 1/5。除非软件包本身很小，否则引言和指导不会对软件包的大小产生大幅度的改变。在软件包很小的情况下，您可以使用一个简单的<ruby> 全权 <rp> （ </rp> <rt> all-permissive </rt> <rp> ） </rp></ruby>许可证，而不是 GNU GPL。
#### 2.22 两个许可证“兼容”是指什么？
为了将两个程序（或它们的实质部分）组合成一个更大的作品，您需要有以组合方式使用这两个程序的权限。如果两个程序的许可证允许这种使用方式，则它们是兼容的。如果没有办法同时满足这两个许可证，则它们是不兼容的。
对于一些许可证，组合的方式可能会影响它们是否兼容，例如，它们可能允许将两个模块链接在一起，但不允许将其代码合并到一个模块中。
如果您只想在同一个系统中安装两个独立的程序，那么它们的许可证并不是必须兼容的，因为它们没有组合成更大的作品。
#### 2.23 许可证与 GPL 兼容是什么意思？
这意味着其他许可证和 GNU GPL 兼容；在一个更大的程序中，您可以将根据其他许可证发布的代码与根据 GNU GPL 发布的代码进行组合。
所有 GNU GPL 版本都允许进行这种组合；它们还允许分发这些组合，只要该组合在相同的 GNU GPL 版本下发布。其他许可证如果允许这样做，则其与 GPL 兼容。
与 GPL v2 相比，GPL v3 与更多的许可证兼容：它允许您与具有特定类型附加要求（GPL v3 本身不包含）的代码进行组合。GPL v3 第 7 节中有关于此问题的更多信息，包括了允许的附加要求的列表。
#### 2.24 为什么原始的 BSD 许可证与 GPL 不兼容？
因为它规定了 GPL 不包含的具体要求，即对程序广告的要求。GPL v2 第 6 节规定：
>
> *您不得对接受者行使本协议授予的权利施加进一步的限制。*
>
>
>
GPL v3 在第 10 节中提到类似的内容。广告条款正好提供了这样一个限制，因此与 GPL 不兼容。
修订的 BSD 许可证没有广告条款，从而消除了这个问题。
#### 2.25 “<ruby> 聚合 <rp> （ </rp> <rt> aggregate </rt> <rp> ） </rp></ruby>”与其他类型的“修改版本”有什么区别？
“聚合”由多个单独的程序组成，分布在同一个 CD-ROM或其他媒介中。GPL 允许您创建和分发聚合，即使其他软件的许可证不是自由许可证或与 GPL 不兼容。唯一的条件是，发布“聚合”所使用的许可证不能禁止用户去行使“聚合”中每个程序对应的许可证所赋予用户的权利。
两个单独的程序还是一个程序有两个部分，区分的界限在哪里？这是一个法律问题，最终由法官决定。我们认为，适当的判断标准取决于通信机制（exec、管道、rpc、共享地址空间内的函数调用等）和通信的语义（哪些信息被互换）。
如果模块们被包含在相同的可执行文件中，则它们肯定是被组合在一个程序中。如果模块们被设计为在共享地址空间中链接在一起运行，那么几乎肯定意味着它们组合成为一个程序。
相比之下，管道、套接字和命令行参数是通常在两个独立程序之间使用的通信机制。所以当它们用于通信时，模块们通常是单独的程序。但是，如果通信的语义足够亲密，交换复杂的内部数据结构，那么也可以视为这两个部分合并成了一个更大的程序。
#### 2.26 为什么 FSF 要求为 FSF拥有版权的程序做出贡献的贡献者将版权<ruby> 分配 <rp> （ </rp> <rt> assign </rt> <rp> ） </rp></ruby>给 FSF？如果我持有 GPL 程序的版权，我也应该这样做吗？如果是，怎么做？ （同1.11）
我们的律师告诉我们，为了最大限度地向法院要求违规者强制执行 GPL，我们应该让程序的版权状况尽可能简单。为了做到这一点，我们要求每个贡献者将贡献部分的版权分配给 FSF，或者放弃对贡献部分的版权要求。
我们也要求个人贡献者从雇主那里获得版权放弃声明（如果有的话），以确保雇主不会声称拥有这部分贡献的版权。
当然，如果所有的贡献者把他们的代码放在公共领域，也就没有用之来执行 GPL 许可证的版权了。所以我们鼓励人们为大规模的代码贡献分配版权，只把小规模的修改放在公共领域。
如果您想要在您的程序中执行 GPL，遵循类似的策略可能是一个好主意。如果您需要更多信息，请联系<licensing@gnu.org>。
#### 2.27 如果我使用遵循 GNU GPL 的软件，那么允许我将原始代码修改为新程序，然后在商业上分发和销售新程序吗？
您被允许在商业上出售修改程序的副本，但仅限于在 GNU GPL 的条款之下这么做。因此，例如，您必须依照 GPL 所述，使得程序用户可获取源代码，并且，用户也依照 GPL 所述，被允许再分发和修改程序。
这些要求是将遵循 GPL 的代码包含在您自己的程序中的条件。
#### 2.28 我可以将 GPL 应用于软件以外的其他作品吗？ （同1.6）
您可以将 GPL 应用于任何类型的作品，只需明确该作品的“源代码”构成即可。GPL 将“源代码”定义为作品的首选形式，以便在其中进行修改。
不过，对于手册和教科书，或更一般地，任何旨在教授某个主题的作品，我们建议使用 GFDL，而非 GPL。
#### 2.29 我想依据 GPL 授权我的代码，但我也想明确指出，它不能用于军事和/或商业用途。我可以这样做吗？
不可以，因为这两个目标相互矛盾。GNU GPL 被专门设计为防止添加进一步的限制。GPL v3 在第 7 节允许非常有限的一组附加限制，但是用户可以删除任何其他添加的限制。
#### 2.30 我可以依据 GPL 来对硬件进行许可吗？
任何可以受版权保护的<ruby> 材料 <rp> （ </rp> <rt> material </rt> <rp> ） </rp></ruby>都可以依据GPL进行许可。GPL v3 也可以用于受其他类似版权法的法律保护的材料，如半导体掩模。因此，作为一个例子，您可以依据 GPL 发布物理对象的图纸或电路。
在许多情况下，版权不涵盖依照图纸制作的物理硬件。在这种情况下，无论您使用什么许可证，您对图纸的许可都不能对制造或销售物理硬件施加任何控制。当版权不涵盖利用 IC 掩膜等进行硬件制作时，GPL 能以有效的方式处理这种情况。
#### 2.31 将遵循 GPL 的二进制文件<ruby> 预链接 <rp> （ </rp> <rt> prelinking </rt> <rp> ） </rp></ruby>到系统上的各种库，以优化其性能，将被视为修改吗？
不。<ruby> 预链接 <rp> （ </rp> <rt> prelinking </rt> <rp> ） </rp></ruby>是编译过程的一部分；与编译过程所涉及的其他各个方面相比，预链接没有引入更多的许可证要求。如果您被允许将程序链接到各种库，那么也可以预链接到各种库。如果您分发预链接后的目标码，则需要遵循第 6 节的条款。
#### 2.32 LGPL 如何与 Java 配合使用？
详情请参阅[这篇文章](https://www.gnu.org/licenses/lgpl-java.html)。LGPL 如同被设计、被预想、被期待的那样去工作。
#### 2.33 为什么你们在 GPL v3 中发明新的术语“<ruby> 传播 <rp> （ </rp> <rt> propagate </rt> <rp> ） </rp></ruby>”和“<ruby> 传递 <rp> （ </rp> <rt> convey </rt> <rp> ） </rp></ruby>”？
（译者注：convey 这个词汇在一个 GPL 译本中被翻译为“转发”，此处，我们认为“转发”一词在计算机领域存在一定的歧义，因此，采用“传递”的翻译。）
GPL v2 中使用的“分发”一词来自美国版权法。多年来，我们了解到，一些司法管辖区在自己的版权法中使用了同一个词，但却给出了不同的含义。我们发明了这些新术语，无论在何处对许可证进行解释，都使我们的意图尽可能清楚。这些新术语没有使用在世界上的任何版权法中，我们直接在许可证中提供了它们的定义。
#### 2.34 在GPL v3中的“<ruby> 传递 <rp> （ </rp> <rt> convey </rt> <rp> ） </rp></ruby>”与GPL v2中的“<ruby> 分发 <rp> （ </rp> <rt> distribute </rt> <rp> ） </rp></ruby>”意思一样吗？
是的，差不多是一个意思。在执行 GPL v2 的过程中，我们了解到一些司法管辖区在自己的版权法中使用了“分发”这个词，但给出了不同的含义。我们发明了一个新的术语，以使我们的意图清晰，避免这些差异可能引起的任何问题。
#### 2.35 如果我只复制遵循 GPL 的程序并运行它们，而不分发或传递给其他人，许可证对我施加什么要求？
没有要求。GPL 不对此活动附加任何条件。
2.36 GPL v3将“向公众提供”作为<ruby> 传播 <rp> （ </rp> <rt> propagate </rt> <rp> ） </rp></ruby>的一个例子。这是什么意思？ 是提供一种可获取的传递形式吗？
“向公众提供”的一个例子是将该软件放在公共网页或FTP服务器上。在您这样做之后，在任何人从您那里真正获取软件之前，可能会需要一段时间，但是由于这种情况可能会立即发生，您也需要能够立即履行 GPL 的义务。因此，我们将“<ruby> 传递 <rp> （ </rp> <rt> convey </rt> <rp> ） </rp></ruby>”定义为包括这一活动。
#### 2.37 鉴于分发和向公众提供作为传播形式，同样也构成了 GPL v3 中的“<ruby> 传递 <rp> （ </rp> <rt> conveying </rt> <rp> ） </rp></ruby>”，那么有哪些传播的例子不构成传递吗？
为自己制作软件的副本是不构成“传递”的主要传播形式。您可以依此在多台计算机上安装软件，或进行备份。
#### 2.38 GPL v3 如何让 BitTorrent 分发变得更容易？
因为 GPL v2 是在软件的点对点分发普及之前编写的，所以当您利用这种方式分享代码时，很难满足 GPL v2 的要求。在 BitTorrent 上分发 GPL v2 目标代码时，确保您合规的最佳方法是将所有相应的源代码包含在相同的<ruby> 种子文件 <rp> （ </rp> <rt> Torrent </rt> <rp> ） </rp></ruby>中，但这种方式代价高昂。
GPL v3 以两种方式解决了这个问题。首先，作为该过程的一部分，下载此种子文件并将数据发送给其他人的人不需要做任何事情。因为第 9 节规定：“受保护作品的辅助传播如果仅仅是使用点对点传输来接收副本，不需要接受[本许可证]。”
第二，通过告知接收人在公共网络服务器上哪里可获取，GPL v3 的第 6（e）节旨在给予分发者（最初制作种子文件的人）一种清晰、直观的方式来提供源代码。这样可以确保每个想要获取源代码的人都可以如此获取，而且分发者几乎不用担心。
#### 2.39 什么是 <ruby> TiVo化 <rp> （ </rp> <rt> tivoization </rt> <rp> ） </rp></ruby>？ GPL v3 对此如何防止？
一些设备使用可升级的自由软件，但被设计为用户不能修改该软件。有很多不同的方式可以做到这一点；例如，有时硬件校验所安装的软件，如果与预期签名不匹配，则关闭软件。制造商通过提供源代码来遵循GPL v2，但是您仍然无法自由修改您使用的软件。我们称这种做法为<ruby> TiVo 化 <rp> （ </rp> <rt> tivoization </rt> <rp> ） </rp></ruby>。
当人们分发包含遵循 GPL v3 软件的“<ruby> 用户产品 <rp> （ </rp> <rt> User Products </rt> <rp> ） </rp></ruby>”时，第 6 节要求他们为您提供修改该软件所需的信息。“用户产品”是该许可证特别定义的术语；“用户产品”的示例包括便携式音乐播放器、数字录像机和家庭安全系统。
#### 2.40 GPL v3 是否禁止 DRM？
不禁止，您可以使用遵循 GPL v3 发布的代码来开发您喜欢的任何类型的 DRM 技术。不过，如果您这样做，第 3 节规定，系统不会被视为一种有效的技术“保护”措施，这意味着如果有人破坏了 DRM，他也可以自由分发他的软件，不受《美国数字千禧版权法》（DMCA）和类似法律的限制。
像往常一样，GNU GPL 并不限制人们在软件中怎么做，只是阻止他们限制他人。
#### 2.41 GPL v3 是否要求投票人能够修改在投票机中运行的软件？
不要求。企业分发包含遵循 GPL v3 软件的设备，最多只需要为拥有目标代码副本的人提供软件的源代码和安装信息。使用投票机（如同任何其他信息亭一样）的选民不能拥有它，甚至不能暂时拥有，所以选民也不能拥有二进制软件。
不过，请注意，投票是一个非常特殊的情况。仅仅因为计算机中的软件是自由软件，并不意味着您可以信任计算机，并进行投票。我们认为电脑不值得信任，不能被用作投票。投票应在纸上进行。
#### 2.42 GPL v3 是否包含“专利报复条款”？
实际上，是的。第 10 节禁止传递该软件的人向其他被许可人发起专利诉讼。如果有人这样做，第 8 节解释他们将如何丧失许可证权益以及与之伴随的所有专利许可。
#### 2.43 在 GPL v3 和 AGPL v3中，当说到“尽管有本许可证的其他规定”时，是什么意思？
这仅仅意味着以下条款胜过许可证中可能与之冲突的其他任何内容。例如，如果没有该文本，有些人可能声称，您不能将遵循 GPL v3 的代码与遵循 AGPL v3 的代码结合在一起，因为 AGPL 的附加要求将被归类为 GPL v3 第 7 节下的“进一步限制”。该文本明确表示我们的预期解释是正确的，您可以进行组合。
该文本仅解决许可证不同条款之间的冲突。当两个条件之间没有冲突的时候，您必须同时满足它们。这些段落不允许您轻率地忽略许可证的其余部分，它们只是强调了一些非常有限的例外。
#### 2.44 在 AGPL v3 中，怎么才算是“通过计算机网络远程与[软件]进行交互”？
如果程序被明确设计为接受用户请求并通过网络发送响应，则它符合这些标准。属于此类程序的常见示例包括网络和邮件服务器、交互式网络应用程序和在线游戏的服务器。
如果程序没有被明确设计为通过网络与用户进行交互，而是恰好在这样做的环境中运行，那么它不属于此类。例如，仅仅因为用户通过 SSH 或远程 X 会话来运行的应用程序不需要提供源代码。
#### 2.45 GPL v3 中“<ruby> 您 <rp> （ </rp> <rt> you </rt> <rp> ） </rp></ruby>”的概念如何与 Apache License 2.0 中“<ruby> 法律实体 <rp> （ </rp> <rt> Legal Entity </rt> <rp> ） </rp></ruby>”的定义相比较？
它们是完全相同的。Apache License 2.0 中“法律实体”的定义在各种法律协议中是非常标准的，因此，如果法院在缺乏明确定义的情况下没有以同样的方式解释该术语，将会令人非常惊讶。我们完全期待他们在看 GPL v3 时也会如此，并考虑到谁有资格作为被许可人。
#### 2.46 在 GPL v3 中，“<ruby> 该程序 <rp> （ </rp> <rt> the Program </rt> <rp> ） </rp></ruby>”是指什么？ 是每个依据 GPL v3 发布的程序？
术语“该程序”是指依据 GPL v3 进行许可的特定作品，由特定被许可人从上游许可人或分发者那里接收。“该程序”是您在 GPL v3 许可的指定情境下接受到的特定软件作品。
“该程序”并不意味着“依据 GPL v3 进行许可的所有作品”；由于一些原因，这种解释没有任何意义。针对那些想要了解更多的人，我们已经发表了对“该程序”一词的[分析](https://www.gnu.org/licenses/gplv3-the-program.html)。
#### 2.47 如果某些网络客户端软件依据 AGPL v3 发布，是否必须能够向与之交互的服务器提供源代码？
AGPL v3 需要该程序向“所有通过计算机网络进行远程交互的用户”提供源代码。至于您将程序称为“客户端”还是“服务器”，那无关紧要。您需要询问的问题是，是否存在合理的期望让一个人通过网络远程与该程序交互。
#### 2.48 对于一个运行在代理服务器上的依据 AGPL 进行许可的软件来说，如何向与该软件交互的用户提供源代码书面文件？
对于代理服务器上的软件，您可以通过向此类代理的用户传递消息的常规方法来提供源代码书面文件。例如，Web 代理可以使用登录页。当用户最初开始使用代理时，您可以将他们引导到包含源代码书面文件以及您选择提供的任何其他信息的页面。
AGPL 规定，您必须向“所有用户”提供书面文件。如果您知道某个用户已经被展示过书面文件，对于当前版本的软件，您不必再重复向该用户提供。
|
||
Linux 系统开机启动项清理
|
David Both
|
https://www.linux.com/learn/cleaning-your-linux-startup-process
|
一般情况下，常规用途的 Linux 发行版在开机启动时拉起各种相关服务进程，包括许多你可能无需使用的服务。
|
/data/attachment/album/201709/03/163752hjzalg5ijiduamml.png.thumb.jpg
|
/data/attachment/album/201709/03/163752hjzalg5ijiduamml.png
| true | false | true |
penghuster
| false |
[
"Systemd",
"启动",
"服务"
] |
技术
|
{
"viewnum": 21330,
"commentnum": 7,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "111.199.187.72",
"message": "不错的文章，参照清理了一下服务",
"username": "来自北京的 Firefox 56.0|GNU/Linux 用户",
"date": "2017-09-03T18:12:54"
},
{
"postip": "111.20.112.126",
"message": "时间证明SYSTEMD是个好东西、GNOME也是个好东西。不过SYSTEMD还是需要具有良好的用户配置界面，二进制不是给人看滴！！！尤其在系统无法启动的时候！！！",
"username": "来自陕西西安的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-04T09:05:55"
},
{
"postip": "118.122.120.11",
"message": "所谓文本格式也是二进制，只是系统底层支持的好。说用文本格式比二进制方便的， 是因为那些工具方便，像 C 语言操作字符串，可不是那么方便。至于 Gnome 和 systemd 是个好东西，这个持保留意见，这两个软件部分组件比较好用。",
"username": "来自四川成都的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-04T09:17:27"
},
{
"postip": "124.74.75.206",
"message": "请问一下贵站用的什么富文本编辑器啊，还支持注解",
"username": "来自上海的 Chrome 59.0|Windows 7 用户",
"date": "2017-09-05T19:02:38"
},
{
"postip": "61.186.23.37",
"message": "这是我们自己加的功能，其实就是一个 H5 标签。",
"username": "linux [Chrome 60.0|Mac 10.11]",
"date": "2017-09-05T20:52:29"
},
{
"postip": "123.149.111.133",
"message": "今天刚学习完systemd，晚上就遇见文章了。哈，复习一遍systemd用法。",
"username": "来自河南郑州的 Chrome Mobile 40.0|Android 7.0 用户",
"date": "2017-09-07T00:14:47"
},
{
"postip": "119.36.213.110",
"message": "markdownx 可以。 你可以考虑下； 其中 h1,h2 这列东西；可以自己定义好样式；另外目录概要是 利用content 占行显示百分比; 通过 h1 或者 h2 bs4 提出索引; 挑转是根据 #div_id 跳转的，",
"username": "actanble [Chrome 60.0|Windows 10]",
"date": "2017-09-13T13:23:47"
}
] |
[] |
一般情况下，常规用途的 Linux 发行版在开机启动时拉起各种相关服务进程，包括许多你可能无需使用的服务。
| 2017-09-03T16:37:49 | 2017-09-03T16:37:49 | 8,835 |
/article-8835-1.html
|
一般情况下，常规用途的 Linux 发行版在开机启动时拉起各种相关服务进程，包括许多你可能无需使用的服务，例如<ruby> 蓝牙 <rt> bluetooth </rt></ruby>、Avahi、 <ruby> 调制解调管理器 <rt> ModemManager </rt></ruby>、ppp-dns（LCTT 译注：此处作者笔误 ppp-dns 应该为 pppd-dns) 等服务进程，这些都是什么东西？用于哪里，有何功能？
Systemd 提供了许多很好的工具用于查看系统启动情况，也可以控制在系统启动时运行什么。在这篇文章中，我将说明在 Systemd 类发行版中如何关闭一些令人讨厌的进程。
### 查看开机启动项
在过去，你能很容易通过查看 `/etc/init.d` 了解到哪些服务进程会在引导时启动。Systemd 以不同的方式展现，你可以使用如下命令罗列允许开机启动的服务进程。
```
$ systemctl list-unit-files --type=service | grep enabled
accounts-daemon.service enabled
anacron-resume.service enabled
anacron.service enabled
bluetooth.service enabled
brltty.service enabled
[...]
```
在此列表顶部，对我来说，蓝牙服务是冗余项，因为在该电脑上我不需要使用蓝牙功能，故无需运行此服务。下面的命令将停止该服务进程，并且使其开机不启动。
```
$ sudo systemctl stop bluetooth.service
$ sudo systemctl disable bluetooth.service
```
你可以通过下面命令确定是否操作成功。
```
$ systemctl status bluetooth.service
bluetooth.service - Bluetooth service
Loaded: loaded (/lib/systemd/system/bluetooth.service; disabled; vendor preset: enabled)
Active: inactive (dead)
Docs: man:bluetoothd(8)
```
停用的服务进程仍然能够被另外一个服务进程启动。如果你真的想在任何情况下系统启动时都不启动该进程，无需卸载该它，只需要把它掩盖起来就可以阻止该进程在任何情况下开机启动。
```
$ sudo systemctl mask bluetooth.service
Created symlink from /etc/systemd/system/bluetooth.service to /dev/null.
```
一旦你对禁用该进程启动而没有出现负面作用感到满意，你也可以选择卸载该程序。
通过执行命令可以获得如下服务列表：
```
$ systemctl list-unit-files --type=service
UNIT FILE STATE
accounts-daemon.service enabled
acpid.service disabled
alsa-restore.service static
alsa-utils.service masked
```
你不能启用或禁用静态服务，因为静态服务被其他的进程所依赖，并不意味着它们自己运行。
### 哪些服务能够禁止？
如何知道你需要哪些服务，而哪些又是可以安全地禁用的呢？它总是依赖于你的个性化需求。
这里举例了几个服务进程的作用。许多服务进程都是发行版特定的，所以你应该看看你的发行版文档（比如通过 google 或 StackOverflow）。
* **accounts-daemon.service** 是一个潜在的安全风险。它是 AccountsService 的一部分，AccountsService 允许程序获得或操作用户账户信息。我不认为有好的理由能使我允许这样的后台操作，所以我选择<ruby> 掩盖 <rt> mask </rt></ruby>该服务进程。
* **avahi-daemon.service** 用于零配置网络发现，使电脑超容易发现网络中打印机或其他的主机，我总是禁用它，别漏掉它。
* **brltty.service** 提供布莱叶盲文设备支持，例如布莱叶盲文显示器。
* **debug-shell.service** 开放了一个巨大的安全漏洞（该服务提供了一个无密码的 root shell ，用于帮助 调试 systemd 问题），除非你正在使用该服务，否则永远不要启动服务。
* **ModemManager.service** 该服务是一个被 dbus 激活的守护进程，用于提供移动<ruby> 宽频 <rt> broadband </rt></ruby>（2G/3G/4G）接口，如果你没有该接口，无论是内置接口，还是通过如蓝牙配对的电话，以及 USB 适配器，那么你也无需该服务。
* **pppd-dns.service** 是一个计算机发展的遗物，如果你使用拨号接入互联网的话，保留它，否则你不需要它。
* **rtkit-daemon.service** 听起来很可怕，听起来像是 rootkit。 但是你需要该服务，因为它是一个<ruby> 实时内核调度器 <rt> real-time kernel scheduler </rt></ruby>。
* **whoopsie.service** 是 Ubuntu 错误报告服务。它用于收集 Ubuntu 系统崩溃报告，并发送报告到 <https://daisy.ubuntu.com> 。 你可以放心地禁止其启动，或者永久的卸载它。
* **wpa\_supplicant.service** 仅在你使用 Wi-Fi 连接时需要。
### 系统启动时发生了什么？
Systemd 提供了一些命令帮助调试系统开机启动问题。该命令会重演你的系统启动的所有消息。
```
$ journalctl -b
-- Logs begin at Mon 2016-05-09 06:18:11 PDT,
end at Mon 2016-05-09 10:17:01 PDT. --
May 16 06:18:11 studio systemd-journal[289]:
Runtime journal (/run/log/journal/) is currently using 8.0M.
Maximum allowed usage is set to 157.2M.
Leaving at least 235.9M free (of currently available 1.5G of space).
Enforced usage limit is thus 157.2M.
[...]
```
通过命令 `journalctl -b -1` 可以复审前一次启动，`journalctl -b -2` 可以复审倒数第 2 次启动，以此类推。
该命令会打印出大量的信息，你可能并不关注所有信息，只是关注其中问题相关部分。为此，系统提供了几个过滤器，用于帮助你锁定目标。让我们以进程号为 1 的进程为例，该进程是所有其它进程的父进程。
```
$ journalctl _PID=1
May 08 06:18:17 studio systemd[1]: Starting LSB: Raise network interfaces....
May 08 06:18:17 studio systemd[1]: Started LSB: Raise network interfaces..
May 08 06:18:17 studio systemd[1]: Reached target System Initialization.
May 08 06:18:17 studio systemd[1]: Started CUPS Scheduler.
May 08 06:18:17 studio systemd[1]: Listening on D-Bus System Message Bus Socket
May 08 06:18:17 studio systemd[1]: Listening on CUPS Scheduler.
[...]
```
这些打印消息显示了什么被启动，或者是正在尝试启动。
一个最有用的命令工具之一 `systemd-analyze blame`，用于帮助查看哪个服务进程启动耗时最长。
```
$ systemd-analyze blame
8.708s gpu-manager.service
8.002s NetworkManager-wait-online.service
5.791s mysql.service
2.975s dev-sda3.device
1.810s alsa-restore.service
1.806s systemd-logind.service
1.803s irqbalance.service
1.800s lm-sensors.service
1.800s grub-common.service
```
这个特定的例子没有出现任何异常，但是如果存在系统启动瓶颈，则该命令将能发现它。
你也能通过如下资源了解 Systemd 如何工作：
* [理解和使用 Systemd](https://www.linux.com/learn/understanding-and-using-systemd)
* [介绍 Systemd 运行级别和服务管理命令](https://www.linux.com/learn/intro-systemd-runlevels-and-service-management-commands)
* [再次前行，另一个 Linux 初始化系统：Systemd 介绍](https://www.linux.com/learn/here-we-go-again-another-linux-init-intro-systemd)
---
via: <https://www.linux.com/learn/cleaning-your-linux-startup-process>
作者：[David Both](https://www.linux.com/users/cschroder) 译者：[penghuster](https://github.com/penghuster) 校对：[wxy](https://github.com/wxy)
本文由 LCTT 原创编译，Linux中国 荣誉推出
|
||
Linux 1.0 之旅：回顾这一切的开始
|
Jim Hall
|
https://opensource.com/article/17/8/linux-anniversary
|
通过安装 SLS 1.05 展示了 Linux 内核在这 26 年间走过了多远。
|
/data/attachment/album/201709/03/200233sptfve0p013twzdq.png.thumb.jpg
|
/data/attachment/album/201709/03/200233sptfve0p013twzdq.png
| true | false | true |
softpaopao
| false |
[
"Linux",
"SLS"
] |
观点
|
{
"viewnum": 8852,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通过安装 SLS 1.05 展示了 Linux 内核在这 26 年间走过了多远。
| 2017-09-03T20:02:29 | 2017-09-03T20:02:29 | 8,836 |
/article-8836-1.html
|
>
> 通过安装 SLS 1.05 展示了 Linux 内核在这 26 年间走过了多远。
>
>
>
我第一次安装 Linux 是在 1993 年。那时我跑的是 MS-DOS，但我真的很喜欢学校机房电脑的 Unix 系统，就在那里度过了我大学本科时光。 当我听说了 Linux，一个 Unix 的免费版本，可以在我家的 386 电脑上运行的时候，我立刻就想要试试。我的第一个 Linux 发行版是 [Softlanding Linux System](https://en.wikipedia.org/wiki/Softlanding_Linux_System) (SLS) 1.03，带有 11 级补丁的 0.99 alpha 版本的 Linux 内核。它要求高达 2 MB 的内存，如果你想要编译项目需要 4 MB，运行 X windows 则需要 8 MB。
我认为 Linux 相较于 MS-DOS 世界是一个巨大的进步。 尽管 Linux 缺乏运行在 MS-DOS 上的广泛的应用及游戏，但我发现 Linux 带给我的是巨大的灵活性。不像 MS-DOS ，现在我可以进行真正的多任务，同时运行不止一个程序。并且 Linux 提供了丰富的工具，包括一个 C 语言编译器，让我可以构建自己的项目。
一年后，我升级到了 SLS 1.05，它支持全新的 Linux 内核 1.0。 更重要的，Linux 引入了内核模块。通过内核模块，你不再需要为支持新硬件而编译整个内核；取而代之，只需要从包含 Linux 内核之内的 63 个模块里加载一个就行。在 SLS 1.05 的发行自述文件中包含这些关于模块的注释：
>
> 内核的模块化旨在正视减少并最终消除重新编译内核的要求，无论是变更、修改设备驱动或者为了动态访问不常用的驱动。也许更为重要的是，个别工作小组的工作不再影响到内核的正确开发。事实上，这让以二进制发布官方内核现在成为了可能。
>
>
>
在 8 月 25 日，Linux 内核将迎来它的第 26 周年（LCTT 译注：已经过去了 =.= ）。为了庆祝，我重新安装了 SLS 1.05 来提醒自己 Linux 1.0 内核是什么样子，去认识 Linux 自二十世纪 90 年代以来走了多远。和我一起踏上 Linux 的怀旧之旅吧！
### 安装
SLS 是第一个真正的 “发行版”，因为它包含一个安装程序。 尽管安装过程并不像现代发行版一样顺畅。 不能从 CD-ROM 启动安装，我需要从安装软盘启动我的系统，然后从 **login** 提示中运行安装程序。
在 SLS 1.05 中引入的一个漂亮的功能是支持彩色的文本模式安装器。当我选择彩色模式时，安装器切换到一个带有黑色文字的亮蓝色背景，不再是我们祖祖辈辈们使用的原始的普通黑白文本。
SLS 安装器是个简单的东西，文本从屏幕底部滚动而上，显示其做的工作。通过对一些简单的提示的响应，我能够创建一个 Linux 分区，挂载上 ext2 文件系统，并安装 Linux 。 安装包含了 X windows 和开发工具的 SLS 1.05，需要大约 85 MB 的磁盘空间。依照今天的标准这听起来可能不是很多，但在 Linux 1.0 出来的时候，120 MB 的硬件设备才是主流设备。
### 系统级别
当我第一次启动到 Linux 时，让我想起来了一些关于这个早期版本 Linux 系统的事情。首先，Linux 没有占据很多的空间。在启动系统之后运行一些程序来检查的时候，Linux 占用了不到 4 MB 的内存。在一个拥有 16MB 内存的系统中，这就意味着节省了很多内存用来运行程序。
熟悉的 `/proc` 元文件系统在 Linux 1.0 就存在了，尽管对比我们今天在现代系统上看到的，它并不能提供许多信息。在 Linux 1.0， `/proc` 包含一些接口来探测类似 `meminfo` 和 `stat` 之类的基本系统状态。
在这个系统上的 `/etc` 文件目录非常简单。值得一提的是，SLS 1.05 借用了来自 [BSD Unix](https://en.wikipedia.org/wiki/Berkeley_Software_Distribution) 的 **rc** 脚本来控制系统启动。 初始化是通过 **rc** 脚本进行的，由 `rc.local` 文件来定义本地系统的调整。后来，许多 Linux 发行版采用了来自 [Unix System V](https://en.wikipedia.org/wiki/UNIX_System_V) 的很相似的 **init** 脚本，后来又是 [systemd](https://en.wikipedia.org/wiki/Systemd) 初始化系统。
### 你能做些什么
随着我的系统的启动运行，接下来就可以使用了了。那么，在这样的早期 Linux 系统上你能做些什么？
让我们从基本的文件管理开始。 每次在你登录的时候，SLS 会让你使用 Softlanding 菜单界面（MESH），这是一个文件管理程序，现代的用户们可能觉得它和 [Midnight Commander](https://midnight-commander.org/) 很相似。 而二十世纪 90 年代的用户们可能会拿 MESH 与更为接近的 [Norton Commander](https://en.wikipedia.org/wiki/Norton_Commander) 相比，这个可以说是在 MS-DOS 上最流行的第三方文件管理程序。
除了 MESH 之外，在 SLS 1.05 中还少量包含了一些全屏应用程序。你可以找到熟悉的用户工具，包括 Elm 邮件阅读器、GNU Emacs 可编程编辑器，以及古老的 Vim 编辑器。
SLS 1.05 甚至包含了一个可以让你在终端玩的俄罗斯方块版本。
在二十世纪 90 年代，多数住宅的网络接入是通过拨号连接的，所以 SLS 1.05 包含了 Minicom 调制解调器拨号程序。Minicom 提供一个与调制解调器的直接连接，并需要用户通过贺氏调制解调器的 **AT** 命令来完成一些像是拨号或挂电话这样的基础功能。Minicom 同样支持宏和其他简单功能来使连接你的本地调制解调器池更容易。
但如果你想要写一篇文档时怎么办？ SLS 1.05 的存在要比 LibreOffice 或者 OpenOffice 早很长时间。在二十世纪 90 年代，Linux 还没有这些应用。相反，如果你想要使用一个文字处理器，可能需要引导你的系统进入 MS-DOS，然后运行你喜欢的文字处理器程序，如 WordPerfect 或者共享软件 GalaxyWrite。
但是所有的 Unix 系统都包含一套简单的文本格式化程序，叫做 nroff 和 troff。在 Linux 系统中，他们被合并成 GNU groff 包，而 SLS 1.05 包含了 groff 的一个版本。我在 SLS 1.05 上的一项测试就是用 nroff 生成一个简单的文本文档。
### 运行 X windows
获取安装 X windows 并不特别容易，如 SLS 安装文件承诺的那样：
>
> 在你的 PC 上获取安装 X windows 可能会有一些发人深省的体验，主要是因为 PC 的显示卡类型太多。Linux X11 仅支持 VGA 类型的显示卡，但在许多类型的 VGA 中仅有个别的某些类型是完全支持的。SLS 存在两种 X windows 服务器。全彩的 XFree86，支持一些或所有 ET3000、ET400、PVGA1、GVGA、Trident、S3、8514、Accelerated cards、ATI plus 等。
>
>
> 另一个服务器 XF86\_Mono，能够工作在几乎所有的 VGA 卡上，但只提供单色模式。因此，相比于彩色服务器，它会占用更少的内存并拥有更快的速度。当然就是看起来不怎么漂亮。
>
>
> X windows 的配置信息都堆放在目录 “/usr/X386/lib/X11/”。需要注意的是，“Xconfig” 文件为监视器和显示卡定义了时序。默认情况下，X windows 设置使用彩色服务器，如果彩色服务器出现问题，你可以切换到单色服务器 x386mono，因为它已经支持各种标准的 VGA。本质上，这只是将 /usr/X386/bin/X 链接到它。
>
>
> 只需要编辑 Xconfig 来设置鼠标驱动类型和时序，然后键入 “startx” 即可。
>
>
>
这些听起来令人困惑，但它就是这样。手工配置 X windows 真的可以是一个发人深省的体验。幸好，SLS 1.05 包含了 syssetup 程序来帮你确定系统组件的种类，包括了 X windows 的显示设置。在一些提示过后，经过一些实验和调整，最终我成功启动了 X windows！
但这是来自于 1994 年的 X windows，它仍然并没有桌面的概念。我可以从 FVWM （一个虚拟窗口管理器）或 TWM （选项卡式的窗口管理器）中选择。TWM 直观地设置提供一个功能简单的图形环境。
### 关机
我已经在我的 Linux 寻根之旅沉浸许久，是时候最终回到我的现代桌面上了。最初我跑 Linux 的是一台仅有 8MB 内存和 一个 120MB 硬盘驱动器的 32 位 386 电脑，而我现在的系统已经足够强大了。拥有双核 64 位 Intel Core i5 处理器，4 GB 内存和一个 128 GB 的固态硬盘，我可以在我的运行着 Linux 内核 4.11.11 的系统上做更多事情。那么，在我的 SLS 1.05 的实验结束之后，是时候离开了。
再见，Linux 1.0。很高兴看到你的茁壮成长。
（题图：图片来源：[litlnemo](https://www.flickr.com/photos/litlnemo/19777182/)。由 Opnesource.com 修改。[CC BY-SA 2.0.](https://creativecommons.org/licenses/by-sa/2.0/)）
---
via: <https://opensource.com/article/17/8/linux-anniversary>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 译者：[softpaopao](https://github.com/softpaopao) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 桌面市场份额首次突破 3%
|
老王
|
Windows 依旧保持在 90% 以上，苹果 MacOS 也略有下滑，占 5.94%，Linux 则自从上个月达到 2.53% 之后，首次突破到了 3.37%。其它操作系统份额可以忽略不计。
|
/data/attachment/album/201709/04/221008vxubu9tr9pjep9ko.jpg.thumb.jpg
|
/data/attachment/album/201709/04/221008vxubu9tr9pjep9ko.jpg
| true | false | false | false |
[
"Linux",
"桌面",
"份额"
] |
新闻
|
{
"viewnum": 10033,
"commentnum": 18,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "61.138.129.20",
"message": "可怜的BSD!",
"username": "Resel [Chrome 59.0|Windows 10]",
"date": "2017-09-05T09:49:12"
},
{
"postip": "101.81.76.109",
"message": "我不知道他们是怎么统计的，又没有算上我？",
"username": "来自上海的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-05T10:00:10"
},
{
"postip": "101.231.96.6",
"message": "感觉我也没被算上",
"username": "来自上海的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-05T10:06:36"
},
{
"postip": "211.102.192.66",
"message": "说句公道话哈，如果不是工作需要（比如编程等），其实还是用windows的时候多一些。从软件支持方面来说，还是windows上软件支持较多，游戏类就不说了，各种玩家几乎都是在windows上玩；各大银行的网银主要还是支持windows，支持linux的极少。从人群方面来说，除了软件行业的人用于工作之外，其他人用linux的很少，比如父母年纪的中老年人，主要用电脑看电视剧、电影啥的，再专业一点看看股票、期货啥的，这类软件还是在windows上操作简单些。所以说，windows的使用人群很庞大，linux一时是超过不了windows的，起码在中国是这样的。",
"username": "编程浪子 [Firefox 55.0|Ubuntu]",
"date": "2017-09-05T10:44:44"
},
{
"postip": "116.114.29.210",
"message": "deepin最有可能在中国开花结果",
"username": "来自内蒙古呼和浩特的 QQ Browser 9.6|Windows 10 用户",
"date": "2017-09-05T12:36:41"
},
{
"postip": "182.91.46.35",
"message": "贡献了一点力量，目前家里只有我一个人在用linux",
"username": "来自广西桂林的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-05T13:26:04"
},
{
"postip": "222.210.108.99",
"message": "用了一年多了，不错，如果政府给予一定支持，linux真的很不错～",
"username": "来自四川成都的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-05T13:48:39"
},
{
"postip": "14.130.112.60",
"message": "linux和BSD都在用啊。",
"username": "小刀弯弯 [Firefox 40.0|FreeBSD]",
"date": "2017-09-05T16:57:28"
},
{
"postip": "59.108.58.82",
"message": "说句公道话哈，如果不是工作需要（比如PS等），其实还是用Linux的时候多一些，从软件支持方面来说，linux下的开源软件已经足够办公、美术设计等，游戏类就不说了，一个steam打败了无数盗版exe游戏，看看steam上越来越多支持linux的游戏，G胖万岁，各大网银都可以手机解决，网上购物有短信接收验证码就够了。中老年人不想被各种全家桶逼疯天天麻烦子女的话，还是linux省事。所有说linux的潜力很大，但是中国人惯性很大，不愿意做出头鸟，不愿意宣传个性，所以linux一时是超过不了windows的，起码在中国是这样的。",
"username": "来自北京的 Firefox 55.0|Windows 7 用户",
"date": "2017-09-05T17:14:46"
},
{
"postip": "116.31.81.182",
"message": "一直搞不懂他们这个数据咋统计的，是否统计了虚拟机。 我们公司开发人员里用虚拟机装ubuntu的好多人，不知道算上了不，不过算上的话，市场份额可能加起来大于100%了。。。",
"username": "来自广东广州的 Firefox 57.0|GNU/Linux 用户",
"date": "2017-09-05T18:54:22"
},
{
"postip": "117.151.55.205",
"message": "最后一段才是真相吧",
"username": "来自湖北的 Chrome 60.0|Windows 10 用户",
"date": "2017-09-05T19:28:30"
},
{
"postip": "61.186.23.37",
"message": "他们是根据 WEB 访问日志里面的 agent 字符串判断的。",
"username": "linux [Chrome 60.0|Mac 10.11]",
"date": "2017-09-05T20:53:03"
},
{
"postip": "211.102.192.66",
"message": "就服你~~",
"username": "编程浪子 [Chrome 60.0|Windows 7]",
"date": "2017-09-06T09:33:18"
},
{
"postip": "222.210.108.99",
"message": "建议你这篇文章都不要看，呵呵",
"username": "来自四川成都的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-09-06T10:01:02"
},
{
"postip": "175.152.29.247",
"message": "Android也是Linux，敢拉通来比吗？",
"username": "fanbt [Firefox 55.0|Fedora]",
"date": "2017-09-07T11:53:43"
},
{
"postip": "119.61.28.66",
"message": "为啥我感觉macos越来越多呀",
"username": "来自北京的 Vivaldi 1.92|Windows 10 用户",
"date": "2017-09-08T08:26:44"
},
{
"postip": "119.129.70.173",
"message": "MACOS 看起来很多的样子，竟然只有5%",
"username": "来自广东广州的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-22T10:08:37"
},
{
"postip": "112.65.48.72",
"message": "为Linux说话的人用着windows系统 <br />\r\n为windows说话的人用着Linux系统",
"username": "来自上海的 Chrome 74.0|Windows 10 用户",
"date": "2019-05-31T16:53:25"
}
] |
[
{
"raid": 7538,
"displayorder": 0
},
{
"raid": 9041,
"displayorder": 0
},
{
"raid": 7913,
"displayorder": 1
}
] |
Windows 依旧保持在 90% 以上，苹果 MacOS 也略有下滑，占 5.94%，Linux 则自从上个月达到 2.53% 之后，首次突破到了 3.37%。其它操作系统份额可以忽略不计。
| 2017-09-05T07:54:00 | 2017-09-05T07:54:00 | 8,837 |
/article-8837-1.html
|
根据市场调研机构 Net Applications 的[统计](https://www.netmarketshare.com/operating-system-market-share.aspx?qprid=9&qpcustomb=0)，今年 8 月份 Linux 桌面市场份额首次突破了 3%。
Windows 依旧保持在 90% 以上，苹果 MacOS 也略有下滑，占 5.94%，Linux 则自从上个月达到 2.53% 之后，首次突破到了 3.37%。其它操作系统份额可以忽略不计。
根据 Net Applications 的历史数据，Linux 桌面份额是在 2009 年首次突破 1%，2016 年 6 月首次[突破](http://www.solidot.org/story?sid=50178) 2%，并基本上一直保持住了这个份额。显然从 2% 到 3% 的进度比 1% 到 2% 要快得多。
而据另外一家统计公司 StatCounter 的[统计数据](http://gs.statcounter.com/os-market-share/desktop/worldwide/)，Linux 的份额仅有 1% 多点，如果加上 ChromeOS 刚刚过了 2%。
|
||||
Oracle 终于干掉了 Sun！
|
Simon Phipps
|
https://meshedinsights.com/2017/09/03/oracle-finally-killed-sun/
|
随着 Solaris 团队的彻底完蛋，看起来 Sun 微系统公司最终连块骨头都没剩下。
|
/data/attachment/album/201709/05/161941p7lmxfechzfiowcp.jpg.thumb.jpg
|
/data/attachment/album/201709/05/161941p7lmxfechzfiowcp.jpg
| true | false | true |
wxy
| false |
[
"Sun",
"Oracle"
] |
新闻
|
{
"viewnum": 12905,
"commentnum": 6,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "116.114.29.210",
"message": "Solaris 12不重要，ZFS还在就行",
"username": "来自内蒙古呼和浩特的 QQ Browser 9.6|Windows 10 用户",
"date": "2017-09-05T12:39:04"
},
{
"postip": "210.13.56.34",
"message": "下一个被Oracle抛弃的会是谁？",
"username": "崖山一劫 [Firefox 56.0|GNU/Linux]",
"date": "2017-09-05T18:55:30"
},
{
"postip": "117.151.55.205",
"message": "JavaEE，然后MySQL，最后VBOX<br />\r\n手动滑稽",
"username": "来自湖北的 Chrome 60.0|Windows 10 用户",
"date": "2017-09-05T19:26:27"
},
{
"postip": "119.130.212.68",
"message": "埃里克森想搞什么，强势上云？",
"username": "文剑一飞 [Chrome 60.0|Windows 10]",
"date": "2017-09-06T17:41:30"
},
{
"postip": "119.130.229.21",
"message": "Oracle现在都是主推云服务，但是没有私有云，国企没法用，不知道以后怎么发展。",
"username": "来自广东广州的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-08T18:47:10"
},
{
"postip": "117.151.55.82",
"message": "JavaEE已经交给eclipse基金会了",
"username": "来自湖北的 Chrome 60.0|Windows 10 用户",
"date": "2017-09-14T10:19:50"
}
] |
[] |
随着 Solaris 团队的彻底完蛋，看起来 Sun 微系统公司最终连块骨头都没剩下。
| 2017-09-05T09:48:00 | 2017-09-05T09:48:00 | 8,839 |
/article-8839-1.html
|
>
> **随着 Solaris 团队的彻底完蛋，看起来 Sun 微系统公司最终连块骨头都没剩下。**
>
>
>
来自前 Sun 社区的消息表明，[一月份的传闻](http://www.mercurynews.com/2017/01/20/oracle-lays-off-450-employees/)（Oracle 裁员 450 人）成为了现实，上周五，[Oracle 裁掉了 Solaris 和 SPARC 团队的核心员工](https://twitter.com/drewfisher314/status/903804762373537793)，选择这个时候（<ruby> 美国劳动节 <rp> （ </rp> <rt> Labor Day </rt> <rp> ） </rp></ruby>前的周末）或许是希望这个消息被大众所忽略。
可以肯定，这意味着对于这些产品只会剩下骨架级的维护，特别是， [Solaris 12 也取消了](https://arstechnica.com/information-technology/2017/01/oracle-sort-of-confirms-demise-of-solaris-12-effort/)。这是一个典型的 Oracle 式的“<ruby> 无声结局 <rp> （ </rp> <rt> silent EOL </rt> <rp> ） </rp></ruby>”，无论他们怎么声称保证履行对富士通和其它客户的合同条款。
随着该硬件的淘汰，我估计这是最后一个被 Oracle 收购处置的 Sun 资产了。在收购 Sun 微系统公司之后，[Oracle 的埃里森对 Sun 的管理毫不留情](http://www.businessinsider.com/wow-larry-ellison-just-tore-ex-sun-ceo-jonathan-schwartz-a-new-one-2010-5?IR=T)，而且最大化地利用其手中的机会。那么，Sun 的资产都在 Oracle 手里都有什么遭遇呢？我并不是很关注 Oracle 的业务，但是可以从下列报告中一窥：
* Java 被称之为“皇冠上的宝石”，但是其买下 Java SE 的[真实原因](https://www.theguardian.com/technology/2012/apr/18/oracle-google-court-smartphone)其实是——试图起诉 Google 赔偿 80 亿美金，而且还两次败诉。
* 埃里森说 [Java 是中间件成功的关键](https://betanews.com/2009/04/20/industry-in-a-box-sun-acquisition-will-lead-to-oracle-java/)，但是现在 Java EE 正准备[交给一个开源基金会](https://www.redhat.com/en/blog/java-ee-moving-open-source-foundation)。
* Oracle 批评 Sun 没能从 Java 上挣到钱（忽略了 1996 - 2000 年 Java 使硬件市场获利的事实）并提出了一个根本不会产生收入的[免费模型](http://www.theregister.co.uk/2010/11/06/oracle_dueling_jvms/)。
* 他们 [拥抱了 NetBeans](https://www.infoworld.com/article/2627862/application-development/oracle-hails-java-but-kills-sun-cloud.html)，而现在它被捐献给了 Apache 基金会。
* 对 [MySQL 安全修复](http://www.bytebot.net/blog/archives/2012/07/20/security-fixes-in-mysql-critical-patch-updates)的官僚主义导致一部分社区成员转而和 MySQL 创始人 Monty 创建了 MariaDB 分支，而新分支已经足以支撑起[一家公司](http://mariadb.com/)。
* 埃里森说要[重建 Sun 的硬件业务](https://web.archive.org/web/20100516032914/http://abcnews.go.com:80/Business/wireStory?id=10630034)，但是[其负责人已经在一个月前离职了](https://www.theregister.co.uk/2017/08/02/oracle_john_fowler_bails/)，而剩下的员工也属于裁员的一部分。
* 尽管 Sun 的前老板 [McNealy 明白 Solaris 只有开源才能赢得市场](https://www.theregister.co.uk/2010/12/07/mcnealy_sun_and_open_source/?page=3)，Oracle 表示“你说的没错”，然后把 Solaris [弄死了](http://www.osnews.com/story/23683/Oracle_Kills_OpenSolaris_Moves_Development_Behind_Closed_Doors)。其结果就是，上周末的裁员——而这在今年一月份就已经有了传闻。
* [Hudson 处理失当](https://www.infoq.com/news/2011/01/hudson-jenkins2)，意味着其 CI 业务只能跟在 CloudBees 从 Hubson 分支而来的 Jenkins 后面。
* Oracle 放弃了 Sun 的身份管理项目，而现在 Forgerock 用它撑起了一个价值五亿美金的业务，为那些 Oracle 所不在意的客户服务。
* Oracle 决定 [取消 Sun Cloud](https://www.infoworld.com/article/2627862/application-development/oracle-hails-java-but-kills-sun-cloud.html) ，并拆除了 Solaris 中的云服务功能，然后现在是云服务的天下了。
* Oracle 重命名了 StarOffice，然后[宣布了一个云端版本](https://web.archive.org/web/20101217212955/http://www.oracle.com/us/corporate/press/195766)，但是没卵用。感觉该项目将走向末日，遭受到了严厉对待的社区决定另起锅灶去做 LibreOffice。
* 只有 VirtualBox 看起来还好。
也许这并不是 Sun 失败的真正原因——[在开源 Solaris 上花了太长时间](https://www.theregister.co.uk/2010/12/07/mcnealy_sun_and_open_source/?page=3)，并在 2000 - 2002 年间试图用以市场为主导的方式来替代 Sun 一贯的工程为主导的方式——埃里森指责那些承担力挽狂澜责任的、硕果仅存的领袖们 McNealy、Zander、Tolliver 和他们的团队。埃里森从来没有理解过 Schwartz 所采取的开创性做法，而是在[博客中嘲讽](https://web.archive.org/web/20100516032944/http://abcnews.go.com:80/Business/wirestory?id=10630034&page=2)和[取消所有正在进行中的“科学项目”](https://web.archive.org/web/20100516032949/http://abcnews.go.com:80/Business/wirestory?id=10630034&page=3)，拆除合作伙伴渠道，溯源开源社区。
与本周 HPE 将放弃的旧产品[卖给 Micro Focus](https://www.ft.com/content/16ce31c4-8d5e-11e7-9084-d0c17942ba93) ，让其照料这些产品的做法相反，Oracle 的做法更残酷。Oracle [说过它将“重振 Sun 品牌”](https://www.infoworld.com/article/2627785/m-a/oracle-s-ambitious-plans-for-integrating-sun-s-technology.html)，但是事实上他们杀死的产品比 Sun 管理层曾经管理过的都要多——毫无疑问，这是“交易的艺术”。今天，和许多前 Sun 同事一样，这件事使我非常悲伤。
*（本文由 [Patreon 赞助支持](https://patreon.com/webmink)， 欢迎你也成为支持者之一！）*
|
||
一周工作所用的日常 Git 命令
|
Sam Corcos
|
几乎每个开发人员都在使用 Git，当然很可能是 GitHub。但大多数开发者大概有 99％ 的时间只是使用这三个命令
|
/data/attachment/album/201709/05/142738ef9g209isze0fmv2.png.thumb.jpg
|
/data/attachment/album/201709/05/142738ef9g209isze0fmv2.png
| true | false | true |
firmianay
| true |
[
"Git",
"GitHub"
] |
软件开发
|
{
"viewnum": 10035,
"commentnum": 0,
"favtimes": 9,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
几乎每个开发人员都在使用 Git，当然很可能是 GitHub。但大多数开发者大概有 99％ 的时间只是使用这三个命令
| 2017-09-05T16:23:00 | 2017-09-05T16:23:00 | 8,841 |
/article-8841-1.html
|
像大多数新手一样，我一开始是在 StackOverflow 上搜索 Git 命令，然后把答案复制粘贴，并没有真正理解它们究竟做了什么。
*Image credit: [XKCD](https://xkcd.com/1597/)*
我曾经想过：“如果有一个最常见的 Git 命令的列表，以及它们的功能是什么，这不是极好的吗？”
多年之后，我编制了这样一个列表，并且给出了一些最佳实践，让新手们甚至中高级开发人员都能从中发现有用的东西。
为了保持实用性，我将这个列表与我过去一周实际使用的 Git 命令进行了比较。
几乎每个开发人员都在使用 Git，当然很可能是 GitHub。但大多数开发者大概有 99％ 的时间只是使用这三个命令：
```
git add --all
git commit -am "<message>"
git push origin master
```
如果你只是单枪匹马，或者参加一场黑客马拉松或开发一次性的应用时，它工作得很好，但是当稳定性和可维护性开始成为一个优先考虑的事情后，清理提交、坚持分支策略和提交信息的规范性就变得很重要。
我将从常用命令的列表开始，使新手更容易了解 Git 能做什么，然后进入更高级的功能和最佳实践。
### 经常使用的命令
要想在<ruby> 仓库 <rp> （ </rp> <rt> repo </rt> <rp> ） </rp></ruby>中初始化 Git，你只需输入以下命令即可。如果你没有初始化 Git，则不能在该仓库内运行任何其他的 Git 命令。
```
git init
```
如果你在使用 GitHub，而且正在将代码推送到在线存储的 GitHub 仓库中，那么你正在使用的就是<ruby> 远程 <rp> （ </rp> <rt> remote </rt> <rp> ） </rp></ruby>仓库。该远程仓库的默认名称（也称为别名）为 `origin`。如果你已经从 Github 复制了一个项目，它就有了一个 `origin`。你可以使用命令 `git remote -v` 查看该 `origin`，该命令将列出远程仓库的 URL。
如果你初始化了自己的 Git 仓库，并希望将其与 GitHub 仓库相关联，则必须在 GitHub 上创建一个，复制新仓库提供的 URL，并使用 `git remote add origin <URL>` 命令，这里使用 GitHub 提供的 URL 替换 `<URL>`。这样，你就可以添加、提交和推送更改到你的远程仓库了。
最后一条命令用在当你需要更改远程仓库时。如果你从其他人那里复制了一个仓库，并希望将远程仓库从原始所有者更改为你自己的 GitHub 帐户。除了改用 `set-url` 来更改远程仓库外，流程与 `git remote add origin` 相同。
```
git remote -v
git remote add origin <url>
git remote set-url origin <url>
```
复制仓库最常见的方式是使用 `git clone`，后跟仓库的 URL。
请记住，远程仓库将连接到克隆仓库原属于的帐户。所以，如果你克隆了一个属于别人的仓库，你将无法推送到 GitHub，除非你使用上面的命令改变了 `origin`。
```
git clone <url>
```
你很快就会发现自己正在使用分支。如果你还不理解什么是分支，有许多其他更深入的教程，你应该先阅读它们，再继续下面的操作。（[这里是一个教程](https://guides.github.com/introduction/flow/)）
命令 `git branch` 列出了本地机器上的所有分支。如果要创建一个新的分支，可以使用命令 `git branch <name>`，其中 `<name>` 表示分支的名字，比如说 `master`。
`git checkout <name>` 命令可以切换到现有的分支。你也可以使用 `git checkout -b` 命令创建一个新的分支并立即切换到它。大多数人都使用此命令而不是单独的 `branch` 和 `checkout` 命令。
```
git branch
git branch <name>
git checkout <name>
git checkout -b <name>
```
如果你对一个分支进行了一系列的更改，假如说此分支名为 `develop`，如果想要将该分支合并回主分支（`master`）上，则使用 `git merge <branch>` 命令。你需要先检出（`checkout`）主分支，然后运行 `git merge develop` 将 `develop` 合并到主分支中。
```
git merge <branch>
```
如果你正在与多个人进行协作，你会发现有时 GitHub 的仓库上已经更新了，但你的本地却没有做相应的更改。如果是这样，你可以使用 `git pull origin <branch>` 命令从远程分支中拉取最新的更改。
```
git pull origin <branch>
```
如果您好奇地想看到哪些文件已被更改以及哪些内存正在被跟踪，可以使用 `git status` 命令。如果要查看每个文件的更改，可以使用 `git diff` 来查看每个文件中更改的行。
```
git status
git diff --stat
```
### 高级命令和最佳实践
很快你会到达一个阶段，这时你希望你的提交看起来整洁一致。你可能还需要调整你的提交记录，使得提交更容易理解或者能还原一个意外的有破坏性的更改。
`git log` 命令可以输出提交的历史记录。你将使用它来查看提交的历史记录。
你的提交会附带消息和一个哈希值，哈希值是一串包含数字和字母的随机序列。一个哈希值示例如下：`c3d882aa1aa4e3d5f18b3890132670fbeac912f7`。
```
git log
```
假设你推送了一些可能破坏了你应用程序的东西。你最好回退一个提交然后再提交一次正确的，而不是修复它和推送新的东西。
如果你希望及时回退并从之前的提交中检出（`checkout`）你的应用程序，则可以使用该哈希作为分支名直接执行此操作。这将使你的应用程序与当前版本分离（因为你正在编辑历史记录的版本，而不是当前版本）。
```
git checkout c3d88eaa1aa4e4d5f
```
然后，如果你在那个历史分支中做了更改，并且想要再次推送，你必须使用强制推送。
**注意**：强制推送是危险的，只有在绝对必要的时候才能执行它。它将覆盖你的应用程序的历史记录，你将失去之后版本的任何信息。
```
git push -f origin master
```
在其他时候，将所有内容保留在一个提交中是不现实的。也行你想在尝试有潜在风险的操作之前保存当前进度，或者也许你犯了一个错误，但希望在你的版本历史中避免尴尬地留着这个错误。对此，我们有 `git rebase`。
假设你在本地历史记录上有 4 个提交（没有推送到 GitHub），你要回退这是个提交。你的提交记录看起来很乱很拖拉。这时你可以使用 `rebase` 将所有这些提交合并到一个简单的提交中。
```
git rebase -i HEAD~4
```
上面的命令会打开你计算机的默认编辑器（默认为 Vim，除非你将默认修改为其他的），提供了几个你准备如何修改你的提交的选项。它看起来就像下面的代码：
```
pick 130deo9 oldest commit message
pick 4209fei second oldest commit message
pick 4390gne third oldest commit message
pick bmo0dne newest commit message
```
为了合并这些提交，我们需要将 `pick` 选项修改为 `fixup`（如代码下面的文档所示），以将该提交合并并丢弃该提交消息。请注意，在 Vim 中，你需要按下 `a` 或 `i` 才能编辑文本，要保存退出，你需要按下 `Esc` 键，然后按 `shift + z + z`。不要问我为什么，它就是这样。
```
pick 130deo9 oldest commit message
fixup 4209fei second oldest commit message
fixup 4390gne third oldest commit message
fixup bmo0dne newest commit message
```
这将把你的所有提交合并到一个提交中，提交消息为 `oldest commit message`。
下一步是重命名你的提交消息。这完全是一个建议的操作，但只要你一直遵循一致的模式，都可以做得很好。这里我建议使用 [Google 为 Angular.js 提供的提交指南](https://github.com/angular/angular.js/blob/master/CONTRIBUTING.md#-git-commit-guidelines)。
为了更改提交消息，请使用 `amend` 标志。
```
git commit --amend
```
这也会打开 Vim，文本编辑和保存规则如上所示。为了给出一个良好的提交消息的例子，下面是遵循该指南中规则的提交消息：
```
feat: add stripe checkout button to payments page
- add stripe checkout button
- write tests for checkout
```
保持指南中列出的<ruby> 类型 <rp> （ </rp> <rt> type </rt> <rp> ） </rp></ruby>的一个优点是它使编写更改日志更加容易。你还可以在<ruby> 页脚 <rp> （ </rp> <rt> footer </rt> <rp> ） </rp></ruby>（再次，在指南中规定的）中包含信息来引用<ruby> 问题 <rp> （ </rp> <rt> issue </rt> <rp> ） </rp></ruby>。
**注意：**如果你正在协作一个项目，并将代码推送到了 GitHub，你应该避免重新引用（`rebase`）并压缩（`squash`）你的提交。如果你开始在人们的眼皮子底下更改版本历史，那么你可能会遇到难以追踪的错误，从而给每个人都带来麻烦。
Git 有无数的命令，但这里介绍的命令可能是您最初几年编程所需要知道的所有。
---
Sam Corcos 是 [Sightline Maps](http://sightlinemaps.com/) 的首席开发工程师和联合创始人，Sightline Maps 是最直观的 3D 打印地形图的平台，以及用于构建 Phoenix 和 React 的可扩展生产应用程序的中级高级教程网站 [LearnPhoenix.io](http://learnphoenix.io/)。使用优惠码：free*code*camp 取得 LearnPhoenix 的20美元。
（题图：[GitHub Octodex](https://octodex.github.com/)）
---
via: <https://medium.freecodecamp.org/git-cheat-sheet-and-best-practices-c6ce5321f52>
作者：[Sam Corcos](https://medium.freecodecamp.org/@SamCorcos?source=post_header_lockup) 译者：[firmianay](https://github.com/firmianay) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|||
使用 Ansible 部署无服务（serverless）应用
|
Ryan Scott Brown
|
https://opensource.com/article/17/8/ansible-serverless-applications
|
无服务是托管服务发展方向的又一步，并且与 Ansible 的无代理体系结构相得益彰。
|
/data/attachment/album/201709/05/223609d2d6dxaevxo2466a.jpg.thumb.jpg
|
/data/attachment/album/201709/05/223609d2d6dxaevxo2466a.jpg
| true | false | true |
geekpi
| false |
[
"serverless",
"无服务",
"Ansible"
] |
容器与云
|
{
"viewnum": 4961,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
无服务是托管服务发展方向的又一步，并且与 Ansible 的无代理体系结构相得益彰。
| 2017-09-06T08:25:00 | 2017-09-06T08:25:00 | 8,843 |
/article-8843-1.html
|
>
> <ruby> 无服务 <rt> serverless </rt></ruby>是<ruby> 托管服务 <rt> managed service </rt></ruby>发展方向的又一步，并且与 Ansible 的无代理体系结构相得益彰。
>
>
>
[Ansible](https://www.ansible.com/) 被设计为实际工作中的最简化的部署工具。这意味着它不是一个完整的编程语言。你需要编写定义任务的 YAML 模板，并列出任何需要自动完成的任务。
大多数人认为 Ansible 是一种更强大的“处于 for 循环中的 SSH”，在简单的使用场景下这是真的。但其实 Ansible 是*任务*，而非 SSH。在很多情况下，我们通过 SSH 进行连接，但它也支持 Windows 机器上的 Windows 远程管理（WinRM），以及作为云服务的通用语言的 HTTPS API 之类的东西。
在云中，Ansible 可以在两个独立的层面上操作：<ruby> 控制面 <rt> control plane </rt></ruby>和<ruby> 实例资源 <rt> on-instance resource </rt></ruby>。控制面由所有*没有*运行在操作系统上的东西组成。包括设置网络、新建实例、供给更高级别的服务，如亚马逊的 S3 或 DynamoDB，以及保持云基础设施安全和服务客户所需的一切。
实例上的工作是你已经知道 Ansible 可以做的：启动和停止服务、配置文件<ruby> 模版化 <rt> templating </rt></ruby>、安装软件包以及通过 SSH 执行的所有与操作系统相关的操作。
现在，什么是<ruby> <a href="https://en.wikipedia.org/wiki/Serverless_computing"> 无服务 </a> <rt> serverless </rt></ruby>呢？这要看你问谁，无服务要么是对公有云的无限延伸，或者是一个全新的范例，其中所有的东西都是 API 调用，以前从来没有这样做过。
Ansible 采取第一种观点。在 “无服务” 是专门术语之前，用户不得不管理和配置 EC2 实例、虚拟私有云 （VPC） 网络以及其他所有内容。无服务是托管服务方向迈出的另一步，并且与 Ansible 的无代理体系结构相得益彰。
在我们开始 [Lambda](https://aws.amazon.com/lambda/) 示例之前，让我们来看一个简单的配置 CloudFormation 栈任务：
```
- name: Build network
cloudformation:
stack_name: prod-vpc
state: present
template: base_vpc.yml
```
编写这样的任务只需要几分钟，但它是构建基础架构所涉及的最后的半手动步骤 - 点击 “Create Stack” - 这将 playbook 与其他放在一起。现在你的 VPC 只是在建立新区域时可以调用的另一项任务了。
由于云提供商是你帐户中发生些什么的真相来源，因此 Ansible 有许多方法来取回并使用 ID、名称和其他参数来过滤和查询运行的实例或网络。以 `cloudformation_facts` 模块为例，我们可以从我们刚刚创建的模板中得到子网 ID、网络范围和其他数据。
```
- name: Pull all new resources back in as a variable
cloudformation_facts:
stack_name: prod-vpc
register: network_stack
```
对于无服务应用，除了 DynamoDB 表，S3 bucket 和其他任何其他功能之外，你肯定还需要一个 Lambda 函数的补充。幸运的是，通过使用 `lambda` 模块， Lambda 函数可以以上次任务的堆栈相同的方式创建：
```
- lambda:
name: sendReportMail
zip_file: "{{ deployment_package }}"
runtime: python3.6
handler: report.send
memory_size: 1024
role: "{{ iam_exec_role }}"
register: new_function
```
如果你有其他想用来交付无服务应用的工具，这也是可以的。开源的[无服务框架](https://serverless.com/)有自己的 Ansible 模块，它也可以工作：
```
- serverless:
service_path: '{{ project_dir }}'
stage: dev
register: sls
- name: Serverless uses CloudFormation under the hood, so you can easily pull info back into Ansible
cloudformation_facts:
stack_name: "{{ sls.service_name }}"
register: sls_facts
```
这不是你需要的全部，因为无服务项目也必须存在，你将在那里大量的定义你的函数和事件源。对于此例，我们将制作一个响应 HTTP 请求的函数。无服务框架使用 YAML 作为其配置语言（和 Ansible 一样），所以这应该看起来很熟悉。
```
# serverless.yml
service: fakeservice
provider:
name: aws
runtime: python3.6
functions:
main:
handler: test_function.handler
events:
- http:
path: /
method: get
```
在 [AnsibleFest](https://www.ansible.com/ansiblefest?intcmp=701f2000000h4RcAAI) 中，我将介绍这个例子和其他深入的部署策略，以最大限度地利用你已经拥有的 playbook 和基础设施，还有新的无服务实践。无论你是否能到，我希望这些例子可以让你开始使用 Ansible，无论你是否有任何服务要管理。
*AnsibleFest 是一个单日会议，汇集了数百名 Ansible 用户、开发人员和行业合作伙伴。加入我们吧，这里有产品更新、鼓舞人心的交谈、技术深度潜水，动手演示和整天的网络。*
（题图： opensource.com）
---
via: <https://opensource.com/article/17/8/ansible-serverless-applications>
作者：[Ryan Scott Brown](https://opensource.com/users/ryansb) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
我对 Go 的错误处理有哪些不满，以及我是如何处理的
|
Andrew Morgan
|
https://opencredo.com/why-i-dont-like-error-handling-in-go
|
写 Go 的人往往对它的错误处理模式有一定的看法。按不同的语言经验，人们可能有不同的习惯处理方法。这就是为什么我决定要写这篇文章，尽管有点固执己见，但我认为听取我的经验是有用的。
|
/data/attachment/album/201709/06/093641llo033walz5k70pk.png.thumb.jpg
|
/data/attachment/album/201709/06/093641llo033walz5k70pk.png
| true | false | true |
geekpi
| false |
[
"Go",
"错误处理"
] |
软件开发
|
{
"viewnum": 4812,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "27.38.242.63",
"message": "其实习惯也就好了，go主张的思维是尽快处理错误，当有错误是立马处理，或者返回给上级处理",
"username": "sheepbao [Safari 10.1|Mac 10.12]",
"date": "2017-09-07T10:36:42"
},
{
"postip": "115.238.95.194",
"message": "错误处理的确很纠结",
"username": "xqbumu [Chrome 60.0|Windows 10]",
"date": "2017-09-14T15:29:53"
},
{
"postip": "63.216.63.36",
"message": "Go 错误处理的样板代码既视感确实很强。",
"username": "BruceAuyeung [Vivaldi 1.93|Windows 7]",
"date": "2017-09-30T16:59:36"
}
] |
[] |
写 Go 的人往往对它的错误处理模式有一定的看法。按不同的语言经验，人们可能有不同的习惯处理方法。这就是为什么我决定要写这篇文章，尽管有点固执己见，但我认为听取我的经验是有用的。
| 2017-09-06T09:36:00 | 2017-09-06T09:36:00 | 8,844 |
/article-8844-1.html
|
写 Go 的人往往对它的错误处理模式有一定的看法。按不同的语言经验，人们可能有不同的习惯处理方法。这就是为什么我决定要写这篇文章，尽管有点固执己见，但我认为听取我的经验是有用的。我想要讲的主要问题是，很难去强制执行良好的错误处理实践，错误经常没有堆栈追踪，并且错误处理本身太冗长。不过，我已经看到了一些潜在的解决方案，或许能帮助解决一些问题。
### 与其他语言的快速比较
[在 Go 中，所有的错误都是值](https://blog.golang.org/errors-are-values)。因为这点，相当多的函数最后会返回一个 `error`, 看起来像这样：
```
func (s *SomeStruct) Function() (string, error)
```
因此这导致调用代码通常会使用 `if` 语句来检查它们：
```
bytes, err := someStruct.Function()
if err != nil {
// Process error
}
```
另外一种方法，是在其他语言中，如 Java、C#、Javascript、Objective C、Python 等使用的 `try-catch` 模式。如下你可以看到与先前的 Go 示例类似的 Java 代码，声明 `throws` 而不是返回 `error`：
```
public String function() throws Exception
```
它使用的是 `try-catch` 而不是 `if err != nil`：
```
try {
String result = someObject.function()
// continue logic
}
catch (Exception e) {
// process exception
}
```
当然，还有其他的不同。例如，`error` 不会使你的程序崩溃，然而 `Exception` 会。还有其他的一些，在本篇中会专门提到这些。
### 实现集中式错误处理
退一步，让我们看看为什么要在一个集中的地方处理错误，以及如何做到。
大多数人或许会熟悉的一个例子是 web 服务 - 如果出现了一些未预料的的服务端错误，我们会生成一个 5xx 错误。在 Go 中，你或许会这么实现：
```
func init() {
http.HandleFunc("/users", viewUsers)
http.HandleFunc("/companies", viewCompanies)
}
func viewUsers(w http.ResponseWriter, r *http.Request) {
user // some code
if err := userTemplate.Execute(w, user); err != nil {
http.Error(w, err.Error(), 500)
}
}
func viewCompanies(w http.ResponseWriter, r *http.Request) {
companies = // some code
if err := companiesTemplate.Execute(w, companies); err != nil {
http.Error(w, err.Error(), 500)
}
}
```
这并不是一个好的解决方案，因为我们不得不重复地在所有的处理函数中处理错误。为了能更好地维护，最好能在一处地方处理错误。幸运的是，[在 Go 语言的官方博客中，Andrew Gerrand 提供了一个替代方法](https://blog.golang.org/error-handling-and-go)，可以完美地实现。我们可以创建一个处理错误的 Type：
```
type appHandler func(http.ResponseWriter, *http.Request) error
func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if err := fn(w, r); err != nil {
http.Error(w, err.Error(), 500)
}
}
```
这可以作为一个封装器来修饰我们的处理函数：
```
func init() {
http.Handle("/users", appHandler(viewUsers))
http.Handle("/companies", appHandler(viewCompanies))
}
```
接着我们需要做的是修改处理函数的签名来使它们返回 `errors`。这个方法很好，因为我们做到了 [DRY](https://en.wikipedia.org/wiki/Don't_repeat_yourself) 原则，并且没有重复使用不必要的代码 - 现在我们可以在单独一个地方返回默认错误了。
### 错误上下文
在先前的例子中，我们可能会收到许多潜在的错误，它们中的任何一个都可能在调用堆栈的许多环节中生成。这时候事情就变得棘手了。
为了演示这点，我们可以扩展我们的处理函数。它可能看上去像这样，因为模板执行并不是唯一一处会发生错误的地方：
```
func viewUsers(w http.ResponseWriter, r *http.Request) error {
user, err := findUser(r.formValue("id"))
if err != nil {
return err;
}
return userTemplate.Execute(w, user);
}
```
调用链可能会相当深，在整个过程中，各种错误可能在不同的地方实例化。[Russ Cox](https://research.swtch.com/go2017)的这篇文章解释了如何避免遇到太多这类问题的最佳实践：
>
> “在 Go 中错误报告的部分约定是函数包含相关的上下文，包括正在尝试的操作（比如函数名和它的参数）。”
>
>
>
这个给出的例子是对 OS 包的一个调用：
```
err := os.Remove("/tmp/nonexist")
fmt.Println(err)
```
它会输出：
```
remove /tmp/nonexist: no such file or directory
```
总结一下，执行后，输出的是被调用的函数、给定的参数、特定的出错信息。当在其他语言中创建一个 `Exception` 消息时，你也可以遵循这个实践。如果我们在 `viewUsers` 处理中坚持这点，那么几乎总是能明确错误的原因。
问题来自于那些不遵循这个最佳实践的人，并且你经常会在第三方的 Go 库中看到这些消息：
```
Oh no I broke
```
这没什么帮助 - 你无法了解上下文，这使得调试很困难。更糟糕的是，当这些错误被忽略或返回时，这些错误会被备份到堆栈中，直到它们被处理为止：
```
if err != nil {
return err
}
```
这意味着错误何时发生并没有被传递出来。
应该注意的是，所有这些错误都可以在 `Exception` 驱动的模型中发生 - 糟糕的错误信息、隐藏异常等。那么为什么我认为该模型更有用？
即便我们在处理一个糟糕的异常消息，*我们仍然能够了解它发生在调用堆栈中什么地方*。因为堆栈跟踪，这引发了一些我对 Go 不了解的部分 - 你知道 Go 的 `panic` 包含了堆栈追踪，但是 `error` 没有。我推测可能是 `panic` 会使你的程序崩溃，因此需要一个堆栈追踪，而处理错误并不会，因为它会假定你在它发生的地方做一些事。
所以让我们回到之前的例子 - 一个有糟糕错误信息的第三方库，它只是输出了调用链。你认为调试会更容易吗？
```
panic: Oh no I broke
[signal 0xb code=0x1 addr=0x0 pc=0xfc90f]
goroutine 1103 [running]:
panic(0x4bed00, 0xc82000c0b0)
/usr/local/go/src/runtime/panic.go:481 +0x3e6
github.com/Org/app/core.(_app).captureRequest(0xc820163340, 0x0, 0x55bd50, 0x0, 0x0)
/home/ubuntu/.go_workspace/src/github.com/Org/App/core/main.go:313 +0x12cf
github.com/Org/app/core.(_app).processRequest(0xc820163340, 0xc82064e1c0, 0xc82002aab8, 0x1)
/home/ubuntu/.go_workspace/src/github.com/Org/App/core/main.go:203 +0xb6
github.com/Org/app/core.NewProxy.func2(0xc82064e1c0, 0xc820bb2000, 0xc820bb2000, 0x1)
/home/ubuntu/.go_workspace/src/github.com/Org/App/core/proxy.go:51 +0x2a
github.com/Org/app/core/vendor/github.com/rusenask/goproxy.FuncReqHandler.Handle(0xc820da36e0, 0xc82064e1c0, 0xc820bb2000, 0xc5001, 0xc820b4a0a0)
/home/ubuntu/.go_workspace/src/github.com/Org/app/core/vendor/github.com/rusenask/goproxy/actions.go:19 +0x30
```
我认为这可能是 Go 的设计中被忽略的东西 - 不是所有语言都不会忽视的。
如果我们使用 Java 作为一个随意的例子，其中人们犯的一个最愚蠢的错误是不记录堆栈追踪：
```
LOGGER.error(ex.getMessage()) // 不记录堆栈追踪
LOGGER.error(ex.getMessage(), ex) // 记录堆栈追踪
```
但是 Go 似乎在设计中就没有这个信息。
在获取上下文信息方面 - Russ 还提到了社区正在讨论一些潜在的接口用于剥离上下文错误。关于这点，了解更多或许会很有趣。
### 堆栈追踪问题解决方案
幸运的是，在做了一些查找后，我发现了这个出色的 [Go 错误](https://github.com/go-errors/errors)库来帮助解决这个问题，来给错误添加堆栈跟踪：
```
if errors.Is(err, crashy.Crashed) {
fmt.Println(err.(*errors.Error).ErrorStack())
}
```
不过，我认为这个功能如果能成为语言的<ruby> 第一类公民 <rt> first class citizenship </rt></ruby>将是一个改进，这样你就不必做一些类型修改了。此外，如果我们像先前的例子那样使用第三方库，它可能没有使用 `crashy` - 我们仍有相同的问题。
### 我们对错误应该做什么？
我们还必须考虑发生错误时应该发生什么。[这一定有用，它们不会让你的程序崩溃](https://davidnix.io/post/error-handling-in-go/)，通常也会立即处理它们：
```
err := method()
if err != nil {
// some logic that I must do now in the event of an error!
}
```
如果我们想要调用大量方法，它们会产生错误，然后在一个地方处理所有错误，这时会发生什么？看上去像这样：
```
err := doSomething()
if err != nil {
// handle the error here
}
func doSomething() error {
err := someMethod()
if err != nil {
return err
}
err = someOther()
if err != nil {
return err
}
someOtherMethod()
}
```
这感觉有点冗余，在其他语言中你可以将多条语句作为一个整体处理。
```
try {
someMethod()
someOther()
someOtherMethod()
}
catch (Exception e) {
// process exception
}
```
或者只要在方法签名中传递错误：
```
public void doSomething() throws SomeErrorToPropogate {
someMethod()
someOther()
someOtherMethod()
}
```
我个人认为这两个例子实现了一件事情，只是 `Exception` 模式更少冗余，更加弹性。如果有什么的话，我觉得 `if err！= nil` 感觉像样板。也许有一种方法可以清理？
### 将失败的多条语句做为一个整体处理错误
首先，我做了更多的阅读，并[在 Rob Pike 写的 Go 博客中](https://blog.golang.org/errors-are-values)发现了一个比较务实的解决方案。
他定义了一个封装了错误的方法的结构体：
```
type errWriter struct {
w io.Writer
err error
}
func (ew *errWriter) write(buf []byte) {
if ew.err != nil {
return
}
_, ew.err = ew.w.Write(buf)
}
```
让我们这么做：
```
ew := &errWriter{w: fd}
ew.write(p0[a:b])
ew.write(p1[c:d])
ew.write(p2[e:f])
// and so on
if ew.err != nil {
return ew.err
}
```
这也是一个很好的方案，但是我感觉缺少了点什么 - 因为我们不能重复使用这个模式。如果我们想要一个含有字符串参数的方法，我们就不得不改变函数签名。或者如果我们不想执行写操作会怎样？我们可以尝试使它更通用：
```
type errWrapper struct {
err error
}
```
```
func (ew *errWrapper) do(f func() error) {
if ew.err != nil {
return
}
ew.err = f();
}
```
但是我们有一个相同的问题，如果我们想要调用含有不同参数的函数，它就无法编译了。然而你可以简单地封装这些函数调用：
```
w := &errWrapper{}
w.do(func() error {
return someFunction(1, 2);
})
w.do(func() error {
return otherFunction("foo");
})
err := w.err
if err != nil {
// process error here
}
```
这可以用，但是并没有太大帮助，因为它最终比标准的 `if err != nil` 检查带来了更多的冗余。如果有人能提供其他解决方案，我会很有兴趣听。或许这个语言本身需要一些方法来以不那么臃肿的方式传递或者组合错误 - 但是感觉似乎是特意设计成不那么做。
### 总结
看完这些之后，你可能会认为我在对 `error` 挑刺儿，由此推论我反对 Go。事实并非如此，我只是将它与我使用 `try catch` 模型的经验进行比较。它是一个用于系统编程很好的语言，并且已经出现了一些优秀的工具。仅举几例，有 [Kubernetes](https://kubernetes.io/)、[Docker](https://www.docker.com/)、[Terraform](https://www.terraform.io/)、[Hoverfly](http://hoverfly.io/en/latest/) 等。还有小型、高性能、本地二进制的优点。但是，`error` 难以适应。 我希望我的推论是有道理的，而且一些方案和解决方法可能会有帮助。
---
作者简介：
Andrew 是 OpenCredo 的顾问，于 2015 年加入公司。Andrew 在多个行业工作多年，开发基于 Web 的企业应用程序。
---
via: <https://opencredo.com/why-i-dont-like-error-handling-in-go>
作者：[Andrew Morgan](https://opencredo.com/author/andrew/) 译者：[geekpi](https://github.com/geekpi) 校对：[jasminepeng](https://github.com/jasminepeng)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
编译器简介： 在 Siri 前时代如何与计算机对话
|
Nicole Orchard
|
https://nicoleorchard.com/blog/compilers
|
简单说来，一个编译器（compiler）不过是一个可以翻译其他程序的程序。传统的编译器可以把源代码翻译成你的计算机能够理解的可执行机器代码。
|
/data/attachment/album/201709/07/093809kb68i4bnllnnsqyg.jpg.thumb.jpg
|
/data/attachment/album/201709/07/093809kb68i4bnllnnsqyg.jpg
| true | false | true |
ucasFL
| false |
[
"LLVM",
"编译器"
] |
软件开发
|
{
"viewnum": 5391,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
简单说来，一个编译器（compiler）不过是一个可以翻译其他程序的程序。传统的编译器可以把源代码翻译成你的计算机能够理解的可执行机器代码。
| 2017-09-07T09:41:00 | 2017-09-07T09:41:00 | 8,845 |
/article-8845-1.html
|
简单说来，一个<ruby> 编译器 <rt> compiler </rt></ruby>不过是一个可以翻译其他程序的程序。传统的编译器可以把源代码翻译成你的计算机能够理解的可执行机器代码。（一些编译器将源代码翻译成别的程序语言，这样的编译器称为源到源翻译器或<ruby> 转化器 <rt> transpilers </rt></ruby>。）[LLVM](http://llvm.org/) 是一个广泛使用的编译器项目，包含许多模块化的编译工具。
传统的编译器设计包含三个部分：
* <ruby> 前端 <rt> Frontend </rt></ruby>将源代码翻译为<ruby> 中间表示 <rt> intermediate representation </rt></ruby> (IR)\* 。[clang](http://clang.llvm.org/) 是 LLVM 中用于 C 家族语言的前端工具。
* <ruby> 优化器 <rt> Optimizer </rt></ruby>分析 IR 然后将其转化为更高效的形式。[opt](http://llvm.org/docs/CommandGuide/opt.html) 是 LLVM 的优化工具。
* <ruby> 后端 <rt> Backend </rt></ruby>通过将 IR 映射到目标硬件指令集从而生成机器代码。[llc](http://llvm.org/docs/CommandGuide/llc.html) 是 LLVM 的后端工具。
注：LLVM 的 IR 是一种和汇编类似的低级语言。然而，它抽离了特定硬件信息。
### Hello, Compiler
下面是一个打印 “Hello, Compiler!” 到标准输出的简单 C 程序。C 语法是人类可读的，但是计算机却不能理解，不知道该程序要干什么。我将通过三个编译阶段使该程序变成机器可执行的程序。
```
// compile_me.c
// Wave to the compiler. The world can wait.
#include <stdio.h>
int main() {
printf("Hello, Compiler!\n");
return 0;
}
```
### 前端
正如我在上面所提到的，`clang` 是 LLVM 中用于 C 家族语言的前端工具。Clang 包含 <ruby> C 预处理器 <rt> C preprocessor </rt></ruby>、<ruby> 词法分析器 <rt> lexer </rt></ruby>、<ruby> 语法解析器 <rt> parser </rt></ruby>、<ruby> 语义分析器 <rt> semantic analyzer </rt></ruby>和 <ruby> IR 生成器 <rt> IR generator </rt></ruby>。
**C 预处理器**在将源程序翻译成 IR 前修改源程序。预处理器处理外部包含文件，比如上面的 `#include <stdio.h>`。 它将会把这一行替换为 `stdio.h` C 标准库文件的完整内容，其中包含 `printf` 函数的声明。
通过运行下面的命令来查看预处理步骤的输出：
```
clang -E compile_me.c -o preprocessed.i
```
**词法分析器**（或<ruby> 扫描器 <rt> scanner </rt></ruby>或<ruby> 分词器 <rt> tokenizer </rt></ruby>）将一串字符转化为一串单词。每一个单词或<ruby> 记号 <rt> token </rt></ruby>，被归并到五种语法类别之一：标点符号、关键字、标识符、文字或注释。
compile\_me.c 的分词过程：
**语法分析器**确定源程序中的单词流是否组成了合法的句子。在分析记号流的语法后，它会输出一个<ruby> 抽象语法树 <rt> abstract syntax tree </rt></ruby>（AST）。Clang 的 AST 中的节点表示声明、语句和类型。
compile\_me.c 的语法树：
**语义分析器**会遍历抽象语法树，从而确定代码语句是否有正确意义。这个阶段会检查类型错误。如果 `compile_me.c` 的 main 函数返回 `"zero"`而不是 `0`， 那么语义分析器将会抛出一个错误，因为 `"zero"` 不是 `int` 类型。
**IR 生成器**将抽象语法树翻译为 IR。
对 compile\_me.c 运行 clang 来生成 LLVM IR：
```
clang -S -emit-llvm -o llvm_ir.ll compile_me.c
```
在 `llvm_ir.ll` 中的 main 函数：
```
; llvm_ir.ll
@.str = private unnamed_addr constant [18 x i8] c"Hello, Compiler!\0A\00", align 1
define i32 @main() {
%1 = alloca i32, align 4 ; <- memory allocated on the stack
store i32 0, i32* %1, align 4
%2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i32 0, i32 0))
ret i32 0
}
declare i32 @printf(i8*, ...)
```
### 优化程序
优化程序的工作是基于其对程序的运行时行为的理解来提高代码效率。优化程序将 IR 作为输入，然后生成改进后的 IR 作为输出。LLVM 的优化工具 `opt` 将会通过标记 `-O2`（大写字母 `o`，数字 2）来优化处理器速度，通过标记 `Os`（大写字母 `o`，小写字母 `s`）来减少指令数目。
看一看上面的前端工具生成的 LLVM IR 代码和运行下面的命令生成的结果之间的区别：
```
opt -O2 -S llvm_ir.ll -o optimized.ll
```
在 `optimized.ll` 中的 main 函数：
```
optimized.ll
@str = private unnamed_addr constant [17 x i8] c"Hello, Compiler!\00"
define i32 @main() {
%puts = tail call i32 @puts(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @str, i64 0, i64 0))
ret i32 0
}
declare i32 @puts(i8* nocapture readonly)
```
优化后的版本中， main 函数没有在栈中分配内存，因为它不使用任何内存。优化后的代码中调用 `puts` 函数而不是 `printf` 函数，因为程序中并没有使用 `printf` 函数的格式化功能。
当然，优化程序不仅仅知道何时可以把 `printf` 函数用 `puts` 函数代替。优化程序也能展开循环并内联简单计算的结果。考虑下面的程序，它将两个整数相加并打印出结果。
```
// add.c
#include <stdio.h>
int main() {
int a = 5, b = 10, c = a + b;
printf("%i + %i = %i\n", a, b, c);
}
```
下面是未优化的 LLVM IR：
```
@.str = private unnamed_addr constant [14 x i8] c"%i + %i = %i\0A\00", align 1
define i32 @main() {
%1 = alloca i32, align 4 ; <- allocate stack space for var a
%2 = alloca i32, align 4 ; <- allocate stack space for var b
%3 = alloca i32, align 4 ; <- allocate stack space for var c
store i32 5, i32* %1, align 4 ; <- store 5 at memory location %1
store i32 10, i32* %2, align 4 ; <- store 10 at memory location %2
%4 = load i32, i32* %1, align 4 ; <- load the value at memory address %1 into register %4
%5 = load i32, i32* %2, align 4 ; <- load the value at memory address %2 into register %5
%6 = add nsw i32 %4, %5 ; <- add the values in registers %4 and %5\. put the result in register %6
store i32 %6, i32* %3, align 4 ; <- put the value of register %6 into memory address %3
%7 = load i32, i32* %1, align 4 ; <- load the value at memory address %1 into register %7
%8 = load i32, i32* %2, align 4 ; <- load the value at memory address %2 into register %8
%9 = load i32, i32* %3, align 4 ; <- load the value at memory address %3 into register %9
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i32 0, i32 0), i32 %7, i32 %8, i32 %9)
ret i32 0
}
declare i32 @printf(i8*, ...)
```
下面是优化后的 LLVM IR：
```
@.str = private unnamed_addr constant [14 x i8] c"%i + %i = %i\0A\00", align 1
define i32 @main() {
%1 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i32 5, i32 10, i32 15)
ret i32 0
}
declare i32 @printf(i8* nocapture readonly, ...)
```
优化后的 main 函数本质上是未优化版本的第 17 行和 18 行，伴有变量值内联。`opt` 计算加法，因为所有的变量都是常数。很酷吧，对不对？
### 后端
LLVM 的后端工具是 `llc`。它分三个阶段将 LLVM IR 作为输入生成机器代码。
* **指令选择**是将 IR 指令映射到目标机器的指令集。这个步骤使用虚拟寄存器的无限名字空间。
* **寄存器分配**是将虚拟寄存器映射到目标体系结构的实际寄存器。我的 CPU 是 x86 结构，它只有 16 个寄存器。然而，编译器将会尽可能少的使用寄存器。
* **指令安排**是重排操作，从而反映出目标机器的性能约束。
运行下面这个命令将会产生一些机器代码：
```
llc -o compiled-assembly.s optimized.ll
```
```
_main:
pushq %rbp
movq %rsp, %rbp
leaq L_str(%rip), %rdi
callq _puts
xorl %eax, %eax
popq %rbp
retq
L_str:
.asciz "Hello, Compiler!"
```
这个程序是 x86 汇编语言，它是计算机所说的语言，并具有人类可读语法。某些人最后也许能理解我。
---
相关资源：
1. [设计一个编译器](https://www.amazon.com/Engineering-Compiler-Second-Keith-Cooper/dp/012088478X)
2. [开始探索 LLVM 核心库](https://www.amazon.com/Getting-Started-LLVM-Core-Libraries/dp/1782166920)
（题图：deviantart.net）
---
via: <https://nicoleorchard.com/blog/compilers>
作者：[Nicole Orchard](https://nicoleorchard.com/) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Minikube：使用 Kubernetes 进行本地开发
|
Aymen El Amri
|
https://medium.com/devopslinks/using-kubernetes-minikube-for-local-development-c37c6e56e3db
|
这篇博客文章介绍了 Kubernetes 在开发模式中的用法，它的灵感来自于一个视频教程，你可以在“无痛 Docker 教程”中找到它。
|
/data/attachment/album/201709/07/114634gfl4anlnlnnqh6wx.jpg.thumb.jpg
|
/data/attachment/album/201709/07/114634gfl4anlnlnnqh6wx.jpg
| true | false | true |
geekpi
| false |
[
"Docker",
"Kubernetes"
] |
容器与云
|
{
"viewnum": 11905,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "171.212.224.210",
"message": "我觉得还行。",
"username": "羊会飞的哦 [Safari 10.1|Mac 10.12]",
"date": "2017-09-14T14:28:31"
}
] |
[] |
这篇博客文章介绍了 Kubernetes 在开发模式中的用法，它的灵感来自于一个视频教程，你可以在“无痛 Docker 教程”中找到它。
| 2017-09-07T11:46:32 | 2017-09-07T11:46:32 | 8,847 |
/article-8847-1.html
|
如果你的运维团队在使用 Docker 和 Kubernetes，那么建议开发上采用相同或相似的技术。这将减少不兼容性和可移植性问题的数量，并使每个人都会认识到应用程序容器是开发和运维团队的共同责任。
这篇博客文章介绍了 Kubernetes 在开发模式中的用法，它的灵感来自于一个视频教程，你可以在“[无痛 Docker 教程](http://painlessdocker.com/)”中找到它。
Minikube 是一个允许开发人员在本地使用和运行 Kubernetes 集群的工具，从而使开发人员的生活变得轻松。
在这篇博客中，对于我测试的例子，我使用的是 Linux Mint 18，但其它 Linux 发行版在安装部分没有区别。
```
cat /etc/lsb-release
```
```
DISTRIB_ID=LinuxMint
DISTRIB_RELEASE=18.1
DISTRIB_CODENAME=serena
DISTRIB_DESCRIPTION=”Linux Mint 18.1 Serena”
```
### 先决条件
为了与 Minkube 一起工作，我们应该安装 Kubectl 和 Minikube 和一些虚拟化驱动程序。
* 对于 OS X，安装 [xhyve 驱动](https://git.k8s.io/minikube/docs/drivers.md#xhyve-driver)、[VirtualBox](https://www.virtualbox.org/wiki/Downloads) 或者 [VMware Fusion](https://www.vmware.com/products/fusion)，然后再安装 Kubectl 和 Minkube。
```
curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/darwin/amd64/kubectl
chmod +x ./kubectl
sudo mv ./kubectl /usr/local/bin/kubectl
curl -Lo minikube https://storage.googleapis.com/minikube/releases/v0.21.0/minikube-darwin-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/
```
* 对于 Windows，安装 [VirtualBox](https://www.virtualbox.org/wiki/Downloads) 或者 [Hyper-V](https://msdn.microsoft.com/en-us/virtualization/hyperv_on_windows/quick_start/walkthrough_install)，然后再安装 Kubectl 和 Minkube。
```
curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.7.0/bin/windows/amd64/kubectl.exe
```
将二进制文件添加到你的 PATH 中（这篇[文章](https://www.windows-commandline.com/set-path-command-line/)解释了如何修改 PATH）
下载 `minikube-windows-amd64.exe`，将其重命名为 `minikube.exe`，并将其添加到你的 PATH 中。[在这](https://github.com/kubernetes/minikube/releases)可以找到最新版本。
* 对于 Linux，安装 [VirtualBox](https://www.virtualbox.org/wiki/Downloads) 或者 [KVM](http://www.linux-kvm.org/)，然后再安装 Kubectl 和 Minkube。
```
curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl
chmod +x ./kubectl
sudo mv ./kubectl /usr/local/bin/kubectl
curl -Lo minikube https://storage.googleapis.com/minikube/releases/v0.21.0/minikube-linux-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/
```
### 使用 Minikube
我们先从这个 Dockerfile 创建一个镜像：
```
FROM busybox
ADD index.html /www/index.html
EXPOSE 8000
CMD httpd -p 8000 -h /www; tail -f /dev/null
```
添加你希望在 index.html 中看到的内容。
构建镜像：
```
docker build -t eon01/hello-world-web-server .
```
我们来运行容器来测试它：
```
docker run -d --name webserver -p 8000:8000 eon01/hello-world-web-server
```
这是 `docker ps` 的输出：
```
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
2ad8d688d812 eon01/hello-world-web-server "/bin/sh -c 'httpd..." 3 seconds ago Up 2 seconds 0.0.0.0:8000->8000/tcp webserver
```
让我们提交镜像并将其上传到公共 Docker Hub 中。你也可以使用自己的私有仓库：
```
docker commit webserver
docker push eon01/hello-world-web-server
```
删除容器，因为我们将与 Minikube 一起使用它。
```
docker rm -f webserver
```
启动 Minikube：
```
minkube start
```
检查状态：
```
minikube status
```
我们运行一个单一节点：
```
kubectl get node
```
运行 webserver：
```
kubectl run webserver --image=eon01/hello-world-web-server --port=8000
```
webserver 应该会暴露它的端口：
```
kubectl expose deployment webserver --type=NodePort
```
为了得到服务 url 输入：
```
minikube service webserver --url
```
使用下面的命令得到 Web 页面的内容：
```
curl $(minikube service webserver --url)
```
显示运行中集群的摘要：
```
kubectl cluster-info
```
更多细节：
```
kubectl cluster-info dump
```
我们还可以使用以下方式列出 pod：
```
kubectl get pods
```
使用下面的方式访问面板：
```
minikube dashboard
```
如果你想访问 Web 程序的前端，输入：
```
kubectl proxy
```
如果我们要在容器内部执行一个命令，请使用以下命令获取 pod id：
```
kubetctl get pods
```
然后像这样使用：
```
kubectl exec webserver-2022867364-0v1p9 -it -- /bin/sh
```
最后完成了，请删除所有部署：
```
kubectl delete deployments --all
```
删除所有 pod：
```
kubectl delete pods --all
```
并且停止 Minikube。
```
minikube stop
```
我希望你享受这个介绍。
### 更加深入
如果你对本文感到共鸣，您可以在[无痛 Docker 教程](http://painlessdocker.com/)中找到更多有趣的内容。
我们 [Eralabs](http://eralabs.io/) 将很乐意为你的 Docker 和云计算项目提供帮助，[联系我们](http://eralabs.io/)，我们将很乐意听到你的项目。
请订阅 [DevOpsLinks](http://devopslinks.com/)：成千上万的 IT 专家和 DevOps 爱好者在线社区。
你可能也有兴趣加入我们的新闻订阅 [Shipped](http://shipped.devopslinks.com/)，一个专注于容器，编排和无服务技术的新闻订阅。
你可以在 [Twitter](https://twitter.com/eon01)、[Clarity](https://clarity.fm/aymenelamri/) 或我的[网站](http://aymenelamri.com/)上找到我，你也可以看看我的书：[SaltStack For DevOps](http://saltstackfordevops.com/)。
不要忘记加入我的最后一个项目 [DevOps 的职位](http://jobsfordevops.com/)！
如果你喜欢本文，请推荐它，并与你的关注者分享。
---
作者简介：
Aymen El Amri - 云和软件架构师、企业家、作者、www.eralabs.io 的 CEO、www.devopslinks.com 的创始人，个人页面：www.aymenelamri.com
---
via: <https://medium.com/devopslinks/using-kubernetes-minikube-for-local-development-c37c6e56e3db>
作者：[Aymen El Amri](https://medium.com/@eon01) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
一个开源软件许可证合规的经济高效模式
|
Jeffrey Robert Kaufman
|
https://opensource.com/article/17/9/economically-efficient-model
|
使用开源的方式有利于你的盈亏底线以及开源生态系统。
|
/data/attachment/album/201709/07/124533d9gmnsrc0m9pij9c.png.thumb.jpg
|
/data/attachment/album/201709/07/124533d9gmnsrc0m9pij9c.png
| true | false | true |
geekpi
| false |
[
"开源",
"许可证"
] |
观点
|
{
"viewnum": 4867,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用开源的方式有利于你的盈亏底线以及开源生态系统。
| 2017-09-07T12:45:23 | 2017-09-07T12:45:23 | 8,849 |
/article-8849-1.html
|
>
> 使用开源的方式有利于你的盈亏底线以及开源生态系统。
>
>
>
“<ruby> 合规性工业联合体 <rt> The Compliance Industrial Complex </rt></ruby>” 是一个术语，它会唤起那些组织参与精心设计并且花费昂贵流程的以遵守开源许可条款的反乌托邦想象。由于“生活经常模仿艺术”，许多组织采用了这种做法，可惜的是它们剥夺了许多开源模型的好处。本文介绍了一种经济高效的开源软件许可证合规性方法。
开源许可证通常对从第三方授权的代码分发者有三个要求：
1. 提供开源许可证的副本
2. 包括版权声明
3. 对于 copyleft 许可证（如 GPL），将相应的源代码提供给接受者。
*（与任何一般性声明一样，可能会有例外情况，因此始终建议审查许可条款，如有需要，请咨询律师的意见。）*
因为源代码（以及任何相关的文件，例如：许可证、README）通常都包含所有这些信息，所以最简单的遵循方法就是随着二进制/可执行程序一起提供源代码。
替代方案更加困难并且昂贵，因为在大多数情况下，你仍然需要提供开源许可证的副本并保留版权声明。提取这些信息来结合你的二进制/可执行版本并不简单。你需要流程、系统和人员来从源代码和相关文件中复制此信息，并将其插入到单独的文本文件或文档中。
不要低估创建此文件的时间和费用。虽然有工具也许可以自动化部分流程，但这些工具通常需要人力资源（例如工程师、质量经理、发布经理）来准备代码来扫描并对结果进行评估（没有完美的工具，几乎总是需要审查）。你的组织资源有限，将其转移到此活动会增加机会成本。考虑到这笔费用，每个后续版本（主要或次要）的成本将需要进行新的分析和修订。
也有因不选择发布不能被很好识别的源码而导致增加的其他成本。这些根源在于不向开源项目的原始作者和/或维护者发布源代码, 这一活动称为上游化。独自上游化一般不满足大多数开源许可证的要求，这就是为什么这篇文章主张与你的二进制/可执行文件一起发布源代码。然而，上游化和提供源代码以及二进制/可执行文件都能提供额外的经济效益。这是因为你的组织不再需要保留随着每次发布合并开源代码修改而产生的私有分支 - 由于你的内部代码库与社区项目不同，这将是越来越消耗和凌乱的工作。上游化还增强了开源生态系统，它会鼓励社区创新，从中你的组织或许也会得到收益。
那么为什么大量的组织不会为其产品发布源代码来简化其合规性工作？在许多情况下，这是因为他们认为这可能会暴露他们竞争优势的信息。考虑到这些专有产品中的大量代码可能是开源代码的直接副本，以支持诸如 WiFi 或云服务这些当代产品的基础功能，这种信念可能是错误的。
即使对这些开源作品进行了修改来适配其专有产品，这些更改也往往是微不足道的，并包含了很少的新的版权部分或可用来专利的内容。因此，任何组织都应该通过这种方式来查看其代码，因为它可能会发现其代码库中绝大部分是开源的，只有一小部分是真正专有的、与竞争对手区分开来的部分。那么为什么不分发和向上游提交这些没有差别的代码呢？
考虑一下拒绝遵从工业联合体的思维方式, 以降低成本并大大简化合规性。使用开源的方式，并体验发布你的源代码的乐趣，以造福于你的盈亏底线和开源生态系统，从中你将继续收获更多的利益。
---
作者简介
Jeffrey Robert Kaufman - Jeffrey R. Kaufman 是全球领先的开源软件解决方案提供商红帽公司的开源知识产权律师。Jeffrey 还担任着 Thomas Jefferson 法学院的兼职教授。 在加入红帽前，Jeffrey 在高通担任专利法律顾问，为首席科学家办公室提供开源顾问。 Jeffrey 在 RFID、条形码、图像处理和打印技术方面拥有多项专利。[更多关于我](https://opensource.com/users/jkaufman)
（题图： opensource.com）
---
via: <https://opensource.com/article/17/9/economically-efficient-model>
作者：[Jeffrey Robert Kaufman](https://opensource.com/users/jkaufman) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Headless Chrome 入门
|
Eric Bidelman
|
https://developers.google.com/web/updates/2017/04/headless-chrome
|
在 Chrome 59 中开始搭载 Headless Chrome。这是一种在无需显示的环境下运行 Chrome 浏览器的方式。从本质上来说，就是不用 chrome 浏览器来运行 Chrome 的功能！它将 Chromium 和 Blink 渲染引擎提供的所有现代 Web 平台的功能都带入了命令行。
|
/data/attachment/album/201709/08/113337g9jjamqsizxmie3s.png.thumb.jpg
|
/data/attachment/album/201709/08/113337g9jjamqsizxmie3s.png
| true | false | true |
firmianay
| false |
[
"浏览器",
"Chrome",
"Headless"
] |
软件开发
|
{
"viewnum": 18172,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8861,
"displayorder": 0
}
] |
在 Chrome 59 中开始搭载 Headless Chrome。这是一种在无需显示的环境下运行 Chrome 浏览器的方式。从本质上来说，就是不用 chrome 浏览器来运行 Chrome 的功能！它将 Chromium 和 Blink 渲染引擎提供的所有现代 Web 平台的功能都带入了命令行。
| 2017-09-08T11:34:00 | 2017-09-08T11:34:00 | 8,850 |
/article-8850-1.html
|
### 摘要
在 Chrome 59 中开始搭载 [Headless Chrome](https://chromium.googlesource.com/chromium/src/+/lkgr/headless/README.md)。这是一种在<ruby> 无需显示 <rt> headless </rt></ruby>的环境下运行 Chrome 浏览器的方式。从本质上来说，就是不用 chrome 浏览器来运行 Chrome 的功能！它将 Chromium 和 Blink 渲染引擎提供的所有现代 Web 平台的功能都带入了命令行。
它有什么用？
<ruby> 无需显示 <rt> headless </rt></ruby>的浏览器对于自动化测试和不需要可视化 UI 界面的服务器环境是一个很好的工具。例如，你可能需要对真实的网页运行一些测试，创建一个 PDF，或者只是检查浏览器如何呈现 URL。
>
> **注意：** Mac 和 Linux 上的 Chrome 59 都可以运行无需显示模式。[对 Windows 的支持](https://bugs.chromium.org/p/chromium/issues/detail?id=686608)将在 Chrome 60 中提供。要检查你使用的 Chrome 版本，请在浏览器中打开 `chrome://version`。
>
>
>
### 开启<ruby> 无需显示 <rt> headless </rt></ruby>模式（命令行界面）
开启<ruby> 无需显示 <rt> headless </rt></ruby>模式最简单的方法是从命令行打开 Chrome 二进制文件。如果你已经安装了 Chrome 59 以上的版本，请使用 `--headless` 标志启动 Chrome：
```
chrome \
--headless \ # Runs Chrome in headless mode.
--disable-gpu \ # Temporarily needed for now.
--remote-debugging-port=9222 \
https://www.chromestatus.com # URL to open. Defaults to about:blank.
```
>
> **注意：**目前你仍然需要使用 `--disable-gpu` 标志。但它最终会不需要的。
>
>
>
`chrome` 二进制文件应该指向你安装 Chrome 的位置。确切的位置会因平台差异而不同。当前我在 Mac 上操作，所以我为安装的每个版本的 Chrome 都创建了方便使用的别名。
如果您使用 Chrome 的稳定版，并且无法获得测试版，我建议您使用 `chrome-canary` 版本：
```
alias chrome="/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome"
alias chrome-canary="/Applications/Google\ Chrome\ Canary.app/Contents/MacOS/Google\ Chrome\ Canary"
alias chromium="/Applications/Chromium.app/Contents/MacOS/Chromium"
```
在[这里](https://www.google.com/chrome/browser/canary.html)下载 Chrome Cannary。
### 命令行的功能
在某些情况下，你可能不需要[以脚本编程的方式](https://developers.google.com/web/updates/2017/04/headless-chrome#node)操作 Headless Chrome。可以使用一些[有用的命令行标志](https://cs.chromium.org/chromium/src/headless/app/headless_shell_switches.cc)来执行常见的任务。
#### 打印 DOM
`--dump-dom` 标志将打印 `document.body.innerHTML` 到标准输出：
```
chrome --headless --disable-gpu --dump-dom https://www.chromestatus.com/
```
#### 创建一个 PDF
`--print-to-pdf` 标志将页面转出为 PDF 文件：
```
chrome --headless --disable-gpu --print-to-pdf https://www.chromestatus.com/
```
#### 截图
要捕获页面的屏幕截图，请使用 `--screenshot` 标志：
```
chrome --headless --disable-gpu --screenshot https://www.chromestatus.com/
# Size of a standard letterhead.
chrome --headless --disable-gpu --screenshot --window-size=1280,1696 https://www.chromestatus.com/
# Nexus 5x
chrome --headless --disable-gpu --screenshot --window-size=412,732 https://www.chromestatus.com/
```
使用 `--screenshot` 标志运行 Headless Chrome 将在当前工作目录中生成一个名为 `screenshot.png` 的文件。如果你正在寻求整个页面的截图，那么会涉及到很多事情。来自 David Schnurr 的一篇很棒的博文已经介绍了这一内容。请查看 [使用 headless Chrome 作为自动截屏工具](https://medium.com/@dschnr/using-headless-chrome-as-an-automated-screenshot-tool-4b07dffba79a)。
#### REPL 模式 (read-eval-print loop)
`--repl` 标志可以使 Headless Chrome 运行在一个你可以使用浏览器评估 JS 表达式的模式下。执行下面的命令：
```
$ chrome --headless --disable-gpu --repl https://www.chromestatus.com/
[0608/112805.245285:INFO:headless_shell.cc(278)] Type a Javascript expression to evaluate or "quit" to exit.
>>> location.href
{"result":{"type":"string","value":"https://www.chromestatus.com/features"}}
>>> quit
```
### 在没有浏览器界面的情况下调试 Chrome
当你使用 `--remote-debugging-port=9222` 运行 Chrome 时，它会启动一个支持 [DevTools 协议](https://chromedevtools.github.io/devtools-protocol/)的实例。该协议用于与 Chrome 进行通信，并且驱动 Headless Chrome 浏览器实例。它也是一个类似 Sublime、VS Code 和 Node 的工具，可用于应用程序的远程调试。#协同效应
由于你没有浏览器用户界面可用来查看网页，请在另一个浏览器中输入 `http://localhost:9222`，以检查一切是否正常。你将会看到一个<ruby> 可检查的 <rt> inspectable </rt></ruby>页面的列表，可以点击它们来查看 Headless Chrome 正在呈现的内容：
*DevTools 远程调试界面*
从这里，你就可以像往常一样使用熟悉的 DevTools 来检查、调试和调整页面了。如果你以编程方式使用 Headless Chrome，这个页面也是一个功能强大的调试工具，用于查看所有通过网络与浏览器交互的原始 DevTools 协议命令。
### 使用编程模式 （Node）
#### Puppeteer 库 API
[Puppeteer](https://github.com/GoogleChrome/puppeteer) 是一个由 Chrome 团队开发的 Node 库。它提供了一个高层次的 API 来控制无需显示版（或 完全版）的 Chrome。它与其他自动化测试库，如 Phantom 和 NightmareJS 相类似，但是只适用于最新版本的 Chrome。
除此之外，Puppeteer 还可用于轻松截取屏幕截图，创建 PDF，页面间导航以及获取有关这些页面的信息。如果你想快速地自动化进行浏览器测试，我建议使用该库。它隐藏了 DevTools 协议的复杂性，并可以处理诸如启动 Chrome 调试实例等繁冗的任务。
安装：
```
yarn add puppeteer
```
**例子** - 打印用户代理：
```
const puppeteer = require('puppeteer');
(async() => {
const browser = await puppeteer.launch();
console.log(await browser.version());
browser.close();
})();
```
**例子** - 获取页面的屏幕截图：
```
const puppeteer = require('puppeteer');
(async() => {
const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.goto('https://www.chromestatus.com', {waitUntil: 'networkidle'});
await page.pdf({path: 'page.pdf', format: 'A4'});
browser.close();
})();
```
查看 [Puppeteer 的文档](https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md)，了解完整 API 的更多信息。
#### CRI 库
[chrome-remote-interface](https://www.npmjs.com/package/chrome-remote-interface) 是一个比 Puppeteer API 更低层次的库。如果你想要更接近原始信息和更直接地使用 [DevTools 协议](https://chromedevtools.github.io/devtools-protocol/)的话，我推荐使用它。
**启动 Chrome**
chrome-remote-interface 不会为你启动 Chrome，所以你要自己启动它。
在前面的 CLI 章节中，我们使用 `--headless --remote-debugging-port=9222` [手动启动了 Chrome](https://developers.google.com/web/updates/2017/04/headless-chrome#cli)。但是，要想做到完全自动化测试，你可能希望从你的应用程序中启动 Chrome。
其中一种方法是使用 `child_process`：
```
const execFile = require('child_process').execFile;
function launchHeadlessChrome(url, callback) {
// Assuming MacOSx.
const CHROME = '/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome';
execFile(CHROME, ['--headless', '--disable-gpu', '--remote-debugging-port=9222', url], callback);
}
launchHeadlessChrome('https://www.chromestatus.com', (err, stdout, stderr) => {
...
});
```
但是如果你想要在多个平台上运行可移植的解决方案，事情会变得很棘手。请注意 Chrome 的硬编码路径：
**使用 ChromeLauncher**
[Lighthouse](https://developers.google.com/web/tools/lighthouse/) 是一个令人称奇的网络应用的质量测试工具。Lighthouse 内部开发了一个强大的用于启动 Chrome 的模块，现在已经被提取出来单独使用。[chrome-launcher NPM 模块](https://www.npmjs.com/package/chrome-launcher) 可以找到 Chrome 的安装位置，设置调试实例，启动浏览器和在程序运行完之后将其杀死。它最好的一点是可以跨平台工作，感谢 Node！
默认情况下，**chrome-launcher 会尝试启动 Chrome Canary**（如果已经安装），但是你也可以更改它，手动选择使用的 Chrome 版本。要想使用它，首先从 npm 安装：
```
yarn add chrome-launcher
```
**例子** - 使用 `chrome-launcher` 启动 Headless Chrome：
```
const chromeLauncher = require('chrome-launcher');
// Optional: set logging level of launcher to see its output.
// Install it using: yarn add lighthouse-logger
// const log = require('lighthouse-logger');
// log.setLevel('info');
/**
* Launches a debugging instance of Chrome.
* @param {boolean=} headless True (default) launches Chrome in headless mode.
* False launches a full version of Chrome.
* @return {Promise<ChromeLauncher>}
*/
function launchChrome(headless=true) {
return chromeLauncher.launch({
// port: 9222, // Uncomment to force a specific port of your choice.
chromeFlags: [
'--window-size=412,732',
'--disable-gpu',
headless ? '--headless' : ''
]
});
}
launchChrome().then(chrome => {
console.log(`Chrome debuggable on port: ${chrome.port}`);
...
// chrome.kill();
});
```
运行这个脚本没有做太多的事情，但你应该能在任务管理器中看到启动了一个 Chrome 的实例，它加载了页面 `about:blank`。记住，它不会有任何的浏览器界面，我们是无需显示的。
为了控制浏览器，我们需要 DevTools 协议！
#### 检索有关页面的信息
>
> **警告：** DevTools 协议可以做一些有趣的事情，但是起初可能有点令人生畏。我建议先花点时间浏览 [DevTools 协议查看器](https://chromedevtools.github.io/devtools-protocol/)。然后，转到 `chrome-remote-interface` 的 API 文档，看看它是如何包装原始协议的。
>
>
>
我们来安装该库：
```
yarn add chrome-remote-interface
```
**例子** - 打印用户代理：
```
const CDP = require('chrome-remote-interface');
...
launchChrome().then(async chrome => {
const version = await CDP.Version({port: chrome.port});
console.log(version['User-Agent']);
});
```
结果是类似这样的东西：`HeadlessChrome/60.0.3082.0`。
**例子** - 检查网站是否有 [Web 应用程序清单](https://developers.google.com/web/fundamentals/engage-and-retain/web-app-manifest/)：
```
const CDP = require('chrome-remote-interface');
...
(async function() {
const chrome = await launchChrome();
const protocol = await CDP({port: chrome.port});
// Extract the DevTools protocol domains we need and enable them.
// See API docs: https://chromedevtools.github.io/devtools-protocol/
const {Page} = protocol;
await Page.enable();
Page.navigate({url: 'https://www.chromestatus.com/'});
// Wait for window.onload before doing stuff.
Page.loadEventFired(async () => {
const manifest = await Page.getAppManifest();
if (manifest.url) {
console.log('Manifest: ' + manifest.url);
console.log(manifest.data);
} else {
console.log('Site has no app manifest');
}
protocol.close();
chrome.kill(); // Kill Chrome.
});
})();
```
**例子** - 使用 DOM API 提取页面的 `<title>`：
```
const CDP = require('chrome-remote-interface');
...
(async function() {
const chrome = await launchChrome();
const protocol = await CDP({port: chrome.port});
// Extract the DevTools protocol domains we need and enable them.
// See API docs: https://chromedevtools.github.io/devtools-protocol/
const {Page, Runtime} = protocol;
await Promise.all([Page.enable(), Runtime.enable()]);
Page.navigate({url: 'https://www.chromestatus.com/'});
// Wait for window.onload before doing stuff.
Page.loadEventFired(async () => {
const js = "document.querySelector('title').textContent";
// Evaluate the JS expression in the page.
const result = await Runtime.evaluate({expression: js});
console.log('Title of page: ' + result.result.value);
protocol.close();
chrome.kill(); // Kill Chrome.
});
})();
```
### 使用 Selenium、WebDriver 和 ChromeDriver
现在，Selenium 开启了 Chrome 的完整实例。换句话说，这是一个自动化的解决方案，但不是完全无需显示的。但是，Selenium 只需要进行小小的配置即可运行 Headless Chrome。如果你想要关于如何自己设置的完整说明，我建议你阅读“[使用 Headless Chrome 来运行 Selenium](https://intoli.com/blog/running-selenium-with-headless-chrome/)”，不过你可以从下面的一些示例开始。
#### 使用 ChromeDriver
[ChromeDriver](https://sites.google.com/a/chromium.org/chromedriver/) 2.3.0 支持 Chrome 59 及更新版本，可与 Headless Chrome 配合使用。在某些情况下，你可能需要等到 Chrome 60 以解决 bug。例如，Chrome 59 中屏幕截图已知存在问题。
安装：
```
yarn add selenium-webdriver chromedriver
```
例子：
```
const fs = require('fs');
const webdriver = require('selenium-webdriver');
const chromedriver = require('chromedriver');
// This should be the path to your Canary installation.
// I'm assuming Mac for the example.
const PATH_TO_CANARY = '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary';
const chromeCapabilities = webdriver.Capabilities.chrome();
chromeCapabilities.set('chromeOptions', {
binary: PATH_TO_CANARY // Screenshots require Chrome 60\. Force Canary.
'args': [
'--headless',
]
});
const driver = new webdriver.Builder()
.forBrowser('chrome')
.withCapabilities(chromeCapabilities)
.build();
// Navigate to google.com, enter a search.
driver.get('https://www.google.com/');
driver.findElement({name: 'q'}).sendKeys('webdriver');
driver.findElement({name: 'btnG'}).click();
driver.wait(webdriver.until.titleIs('webdriver - Google Search'), 1000);
// Take screenshot of results page. Save to disk.
driver.takeScreenshot().then(base64png => {
fs.writeFileSync('screenshot.png', new Buffer(base64png, 'base64'));
});
driver.quit();
```
#### 使用 WebDriverIO
[WebDriverIO](http://webdriver.io/) 是一个在 Selenium WebDrive 上构建的更高层次的 API。
安装：
```
yarn add webdriverio chromedriver
```
例子：过滤 chromestatus.com 上的 CSS 功能：
```
const webdriverio = require('webdriverio');
const chromedriver = require('chromedriver');
// This should be the path to your Canary installation.
// I'm assuming Mac for the example.
const PATH_TO_CANARY = '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary';
const PORT = 9515;
chromedriver.start([
'--url-base=wd/hub',
`--port=${PORT}`,
'--verbose'
]);
(async () => {
const opts = {
port: PORT,
desiredCapabilities: {
browserName: 'chrome',
chromeOptions: {
binary: PATH_TO_CANARY // Screenshots require Chrome 60\. Force Canary.
args: ['--headless']
}
}
};
const browser = webdriverio.remote(opts).init();
await browser.url('https://www.chromestatus.com/features');
const title = await browser.getTitle();
console.log(`Title: ${title}`);
await browser.waitForText('.num-features', 3000);
let numFeatures = await browser.getText('.num-features');
console.log(`Chrome has ${numFeatures} total features`);
await browser.setValue('input[type="search"]', 'CSS');
console.log('Filtering features...');
await browser.pause(1000);
numFeatures = await browser.getText('.num-features');
console.log(`Chrome has ${numFeatures} CSS features`);
const buffer = await browser.saveScreenshot('screenshot.png');
console.log('Saved screenshot...');
chromedriver.stop();
browser.end();
})();
```
### 更多资源
以下是一些可以带你入门的有用资源：
文档
* [DevTools Protocol Viewer](https://chromedevtools.github.io/devtools-protocol/) - API 参考文档
工具
* [chrome-remote-interface](https://www.npmjs.com/package/chrome-remote-interface) - 基于 DevTools 协议的 node 模块
* [Lighthouse](https://github.com/GoogleChrome/lighthouse) - 测试 Web 应用程序质量的自动化工具；大量使用了协议
* [chrome-launcher](https://github.com/GoogleChrome/lighthouse/tree/master/chrome-launcher) - 用于启动 Chrome 的 node 模块，可以自动化
样例
* "[The Headless Web](https://paul.kinlan.me/the-headless-web/)" - Paul Kinlan 发布的使用了 Headless 和 api.ai 的精彩博客
### 常见问题
**我需要 `--disable-gpu` 标志吗？**
目前是需要的。`--disable-gpu` 标志在处理一些 bug 时是需要的。在未来版本的 Chrome 中就不需要了。查看 [https://crbug.com/546953#c152](https://bugs.chromium.org/p/chromium/issues/detail?id=546953#c152) 和 [https://crbug.com/695212](https://bugs.chromium.org/p/chromium/issues/detail?id=695212) 获取更多信息。
**所以我仍然需要 Xvfb 吗？**
不。Headless Chrome 不使用窗口，所以不需要像 Xvfb 这样的显示服务器。没有它你也可以愉快地运行你的自动化测试。
什么是 Xvfb？Xvfb 是一个用于类 Unix 系统的运行于内存之内的显示服务器，可以让你运行图形应用程序（如 Chrome），而无需附加的物理显示器。许多人使用 Xvfb 运行早期版本的 Chrome 进行 “headless” 测试。
**如何创建一个运行 Headless Chrome 的 Docker 容器？**
查看 [lighthouse-ci](https://github.com/ebidel/lighthouse-ci)。它有一个使用 Ubuntu 作为基础镜像的 [Dockerfile 示例](https://github.com/ebidel/lighthouse-ci/blob/master/builder/Dockerfile.headless)，并且在 App Engine Flexible 容器中安装和运行了 Lighthouse。
**我可以把它和 Selenium / WebDriver / ChromeDriver 一起使用吗？**
是的。查看 [Using Selenium, WebDrive, or ChromeDriver](https://developers.google.com/web/updates/2017/04/headless-chrome#drivers)。
**它和 PhantomJS 有什么关系？**
Headless Chrome 和 [PhantomJS](http://phantomjs.org/) 是类似的工具。它们都可以用来在无需显示的环境中进行自动化测试。两者的主要不同在于 Phantom 使用了一个较老版本的 WebKit 作为它的渲染引擎，而 Headless Chrome 使用了最新版本的 Blink。
目前，Phantom 提供了比 [DevTools protocol](https://chromedevtools.github.io/devtools-protocol/) 更高层次的 API。
**我在哪儿提交 bug？**
对于 Headless Chrome 的 bug，请提交到 [crbug.com](https://bugs.chromium.org/p/chromium/issues/entry?components=Blink&blocking=705916&cc=skyostil%40chromium.org&Proj=Headless)。
对于 DevTools 协议的 bug，请提交到 [github.com/ChromeDevTools/devtools-protocol](https://github.com/ChromeDevTools/devtools-protocol/issues/new)。
---
作者简介
[Eric Bidelman](https://developers.google.com/web/resources/contributors#ericbidelman) 谷歌工程师，Lighthouse 开发，Web 和 Web 组件开发，Chrome 开发
---
via: <https://developers.google.com/web/updates/2017/04/headless-chrome>
作者：[Eric Bidelman](https://developers.google.com/web/resources/contributors#ericbidelman) 译者：[firmianay](https://github.com/firmianay) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
ImageMagick 入门：使用命令行来编辑图片
|
Greg Pittman
|
https://opensource.com/article/17/8/imagemagick
|
ImageMagick 不仅仅是一个图像查看器，它还提供了大量的图像编辑工具和选项。本教程将详细介绍如何在 ImageMagick 中使用 display 命令和其他命令行工具。
|
/data/attachment/album/201709/08/132945zalli0apiaalll6l.png.thumb.jpg
|
/data/attachment/album/201709/08/132945zalli0apiaalll6l.png
| true | false | true |
geekpi
| false |
[
"ImageMagick",
"图像查看"
] |
桌面应用
|
{
"viewnum": 12543,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9611,
"displayorder": 0
}
] |
ImageMagick 不仅仅是一个图像查看器，它还提供了大量的图像编辑工具和选项。本教程将详细介绍如何在 ImageMagick 中使用 display 命令和其他命令行工具。
| 2017-09-08T13:29:37 | 2017-09-08T13:29:37 | 8,851 |
/article-8851-1.html
|
>
> 了解使用此轻量级图像编辑器查看和修改图像的常见方法。
>
>
>
在最近一篇关于[轻量级图像查看器](https://opensource.com/article/17/7/4-lightweight-image-viewers-linux-desktop)的文章中，作者 Scott Nesbitt 提到了 `display`，它是 [ImageMagick](https://www.imagemagick.org/script/index.php) 中的一个组件。ImageMagick 不仅仅是一个图像查看器，它还提供了大量的图像编辑工具和选项。本教程将详细介绍如何在 ImageMagick 中使用 `display` 命令和其他命令行工具。
现在有许多优秀的图像编辑器可用，你可能会想知道为什么有人会选择一个非 GUI 的、基于命令行的程序，如 ImageMagick。一方面，它非常可靠。但更大的好处是，它允许你建立一个以特定的方式编辑大量图像的方式。
这篇对于常见的 ImageMagick 命令的介绍应该让你入门。
### display 命令
让我们从 Scott 提到的命令开始：`display`。假设你有一个目录，其中有很多想要查看的图像。使用以下命令开始 `display`：
```
cd Pictures
display *.JPG
```
这将按照字母数字顺序顺序加载你的 JPG 文件，每张放在一个简单的窗口中。左键单击图像可以打开一个简单的独立菜单（ImageMagick 中唯一的 GUI 功能）。
你可以在 **display** 菜单中找到以下内容：
* **File** 包含选项 Open、Next、Former、Select、Save、Print、Delete、New、Visual Directory 和 Quit。 *Select* 来选择要显示的特定文件，*Visual Directory* 显示当前工作目录中的所有文件（而不仅仅是图像）。如果要滚动显示所有选定的图像，你可以使用 *Next* 和 *Former*，但使用键盘快捷键（下一张图像用空格键，上一张图像用退格）更容易。
* **Edit** 提供 Undo、Redo、Cut、Copy 和 Paste，它们只是辅助命令进行更具体的编辑过程。 当你进行不同的编辑功能看看它们做什么时 *Undo* 特别有用。
* **View** 有 Half Size、Original Size、Double Size、Resize、Apply、Refresh 和 Restore。这些大多是不用说明的，除非你在应用其中之一后保存图像，否则图像文件不会更改。*Resize* 会打开一个对话框，以像素为单位，带有或者不带尺寸限制，或者是百分比指定图片大小。我不知道 *Apply* 会做什么。
* **Transform** 显示 Crop、Chop、Flop、Flip、Rotate Right、Rotate Left、Rotate、Shear、Roll 和 Trim Edges。*Chop* 使用点击拖动操作剪切图像的垂直或水平部分，将边缘粘贴在一起。了解这些功能如何工作的最佳方法是操作它们，而不是看看。
* **Enhance** 提供 Hue、Saturation、Brightness、Gamma、Spiff、Dull、Contrast Stretch、Sigmoidal Contrast、Normalize、Equalize、Negate、Grayscale、Map 和 Quantize。这些是用于颜色和调整亮度和对比度的操作。
* **效果** 有 Despeckle、Emboss、Reduce Noise、Add Noise、Sharpen、Blur、Threshold、Edge Detect、Spread、Shade、Raise 和 Segment。这些是相当标准的图像编辑效果。
* **F/X** 选项有 Solarize、Sepia Tone、Swirl、Implode、Vignette、Wave、Oil Paint 和 Charcoal Draw，在图像编辑器中也是非常常见的效果。
* **Image Edit** 包含 Annotate、Draw、Color、Matte、Composite、Add Border、Add Frame、Comment、Launch 和 Region of Interest。*Launch \_ 将打开 GIMP 中的当前图像（至少在我的 Fedora 中是这样）。 \_Region of Interest* 允许你选择一个区域来应用编辑。按下 Esc 取消选择该区域。
* **Miscellany** 提供 Image Info、Zoom Image、Show Preview、Show Histogram、Show Matte、Background、Slide Show 和 Preferences。 *Show Preview* 似乎很有趣，但我努力让它工作。
* **Help** 有 Overview、Browse Documentation 和 About Display。 *Overview* 提供了大量关于 display 的基本信息，并且包含大量内置的键盘快捷键，用于各种命令和操作。在我的 Fedora 中，*Browse Documentation* 没有作用。
虽然 `display` 的 GUI 界面提供了一个称职的图像编辑器，但 ImageMagick 还提供了 89 个命令行选项，其中许多与上述菜单项相对应。例如，如果我显示的数码相片目录中的图像大于我的屏幕尺寸，我不用在显示后单独调整大小，我可以指定：
```
display -resize 50% *.JPG
```
上面菜单中的许多操作都可以通过在命令行中添加一个选项来完成。但是还有其他的选项在菜单中没有，包括 `-monochrome`，将图像转换为黑白（不是灰度），还有 `-colors`，你可以指定在图像中使用多少种颜色。例如，尝试这些：
```
display -resize 50% -monochrome *.JPG
```
```
display -resize 50% -colors 8 *.JPG
```
这些操作会创建有趣的图像。试试增强颜色或进行其他编辑后减少颜色。记住，除非你保存并覆盖它们，否则原始文件保持不变。
### convert 命令
`convert` 命令有 237 个选项 - 是的， 237 个！ - 它提供了你可以做的各种各样的事情（其中一些 `display` 也可以做）。我只会覆盖其中的几个，主要是图像操作。你可以用 `convert` 做的两件简单的事情是：
```
convert DSC_0001.JPG dsc0001.png
```
```
convert *.bmp *.png
```
第一个命令将单个文件（DSC\_0001）从 JPG 转换为 PNG 格式，而不更改原始文件。第二个将对目录中的所有 BMP 图像执行此操作。
如果要查看 ImageMagick 可以使用的格式，请输入：
```
identify -list format
```
我们来看几个用 `convert` 命令来处理图像的有趣方法。以下是此命令的一般格式：
```
convert inputfilename [options] outputfilename
```
你有多个选项，它们按照从左到右排列的顺序完成。
以下是几个简单的选项：
```
convert monochrome_source.jpg -monochrome monochrome_example.jpg
```
```
convert DSC_0008.jpg -charcoal 1.2 charcoal_example.jpg
```
`-monochrome` 选项没有关联的设置，但 `-charcoal` 变量需要一个相关因子。根据我的经验，它需要一个小的数字（甚至小于 1）来实现类似于炭笔绘画的东西，否则你会得到很大的黑色斑点。即使如此，图像中的尖锐边缘也是非常明显的，与炭笔绘画不同。
现在来看看这些：
```
convert DSC_0032.JPG -edge 3 edge_demo.jpg
```
```
convert DSC_0032.JPG -colors 4 reduced4_demo.jpg
```
```
convert DSC_0032.JPG -colors 4 -edge 3 reduced+edge_demo.jpg
```
原始图像位于左上方。在第一个命令中，我使用了一个 `-edge` 选项，设置为 3（见右上角的图像） - 对于我的喜好而言小于它的数字都太精细了。在第二个命令（左下角的图像）中，我们将颜色的数量减少到了 4 个，与原来没有什么不同。但是看看当我们在第三个命令中组合这两个时，会发生什么（右下角的图像）！也许这有点大胆，但谁能预期到从原始图像或任何一个选项变成这个结果？
`-canny` 选项提供了另外一个惊喜。这是另一种边缘检测器，称为“多阶算法”。单独使用 `-canny` 可以产生基本黑色的图像和一些白线。我后面跟着一个 `-negate` 选项：
```
convert DSC_0049.jpg -canny 0x1 -negate canny_egret.jpg
convert DSC_0023.jpg -canny 0x1 -negate canny_ship.jpg
```
这有点极简主义，但我认为它类似于一种笔墨绘画，与原始照片有相当显著的差异。它并不能用于所有图片。一般来说，它对有锐利线条的图像效果最好。不是焦点的元素可能会消失。注意白鹭图片中的背景沙滩没有显示，因为它是模糊的。同样注意下船舶图片，虽然大多数边缘显示得非常好，因为没有颜色，我们失去了图片的整体形象，所以也许这可以作为一些数字着色，甚至在印后着色的基础。
### montage 命令
最后，我想谈一下 `montage` （蒙太奇）命令。我已经在上面展示了这个例子，我将单个图像组合成复合图片。
这是我如何生成炭笔的例子（请注意，它们都在一行）：
```
montage -label %f DSC_0008.jpg charcoal_example.jpg -geometry +10+10
-resize 25% -shadow -title 'charcoal demo' charcoal_demo.jpg
```
`-label` 选项会在每个图像下方标记它的文件名(`%f`)。不用 `-geometry` 选项，所有的图像将是缩略图大小（120 像素宽），`+10+10` 负责边框大小。接下来，我调整了整个最终组合的大小（`-resize 25%`），并添加了一个阴影（没有设置，因此是默认值），最后为这次 montage 操作创建了一个标题（`-title`）。
你可以将所有图像名称放在最后，最后一个图像的名称将是 `montage` 操作所保存的文件名。这可用于为命令及其所有选项创建别名，然后我可以简单地键入该别名、输入适当的文件名即可。我偶尔会这么做来减少 `montage` 操作需要输入的命令长度。
在 `-canny` 的例子中，我对 4 张图像进行了蒙太奇操作。我添加了 `-tile` 选项，确切地说是 `-tile 2x`，它创建了有两列的蒙太奇。我可以指定一个 `matrix`、`-tile 2x2` 或 `-tile x2` 来产生相同的结果。
ImageMagick 还有更多可以了解，所以我打算写更多关于它的文章，甚至可能使用 [Perl](https://opensource.com/sitewide-search?search_api_views_fulltext=perl) 脚本运行 ImageMagick 命令。ImageMagick 具有丰富的[文档](https://imagemagick.org/script/index.php)，尽管该网站在示例或者显示结果上还不足，我认为最好的学习方式是通过实验和更改各种设置和选项来学习。
（题图： opensource.com）
---
作者简介：
Greg Pittman - Greg 是肯塔基州路易斯维尔的一名退休的神经科医生，对计算机和程序设计有着长期的兴趣，从 1960 年代的 Fortran IV 开始。当 Linux 和开源软件相继出现时，他开始学习更多，并最终做出贡献。他是 Scribus 团队的成员。
---
via: <https://opensource.com/article/17/8/imagemagick>
作者：[Greg Pittman](https://opensource.com/users/greg-p) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
GitHub 的 DNS 基础设施
|
Joe Williams
|
https://githubengineering.com/dns-infrastructure-at-github/
|
在 GitHub，我们最近从头改进了 DNS。这包括了我们如何与外部 DNS 提供商交互以及我们如何在内部向我们的主机提供记录。为此，我们必须设计和构建一个新的 DNS 基础设施，它可以随着 GitHub 的增长扩展并跨越多个数据中心。
|
/data/attachment/album/201709/09/165851b7yv8bkcv7jwm8ww.jpeg.thumb.jpg
|
/data/attachment/album/201709/09/165851b7yv8bkcv7jwm8ww.jpeg
| true | false | true |
geekpi
| true |
[
"GitHub",
"DNS"
] |
系统运维
|
{
"viewnum": 7853,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8967,
"displayorder": 0
}
] |
在 GitHub，我们最近从头改进了 DNS。这包括了我们如何与外部 DNS 提供商交互以及我们如何在内部向我们的主机提供记录。为此，我们必须设计和构建一个新的 DNS 基础设施，它可以随着 GitHub 的增长扩展并跨越多个数据中心。
| 2017-09-09T16:59:10 | 2017-09-09T16:59:10 | 8,852 |
/article-8852-1.html
|
在 GitHub，我们最近从头改进了 DNS。这包括了我们[如何与外部 DNS 提供商交互](https://githubengineering.com/enabling-split-authority-dns-with-octodns/)以及我们如何在内部向我们的主机提供记录。为此，我们必须设计和构建一个新的 DNS 基础设施，它可以随着 GitHub 的增长扩展并跨越多个数据中心。
以前，GitHub 的 DNS 基础设施相当简单直接。它包括每台服务器上本地的、只具备转发功能的 DNS 缓存服务器，以及一对被所有这些主机使用的缓存服务器和权威服务器主机。这些主机在内部网络以及公共互联网上都可用。我们在缓存守护程序中配置了<ruby> 区域 <rt> zone </rt></ruby><ruby> 存根 <rt> stub </rt></ruby>，以在本地进行查询，而不是在互联网上进行递归。我们还在我们的 DNS 提供商处设置了 NS 记录，它们将特定的内部<ruby> 域 <rt> domain </rt></ruby>指向这对主机的公共 IP，以便我们网络外部的查询。
这个配置使用了很多年，但它并非没有缺点。许多程序对于解析 DNS 查询非常敏感，我们遇到的任何性能或可用性问题在最好的情况下也会导致服务排队和性能降级，而最坏情况下客户会遭遇服务中断。配置和代码的更改可能会导致查询率发生大幅度的意外变化。因此超出这两台主机的扩展成为了一个问题。由于这些主机的网络配置，如果我们只是继续添加 IP 和主机的话存在一些本身的问题。在试图解决和补救这些问题的同时，由于缺乏测量指标和可见性，老旧的系统难以识别问题的原因。在许多情况下，我们使用 `tcpdump` 来识别有问题的流量和查询。另一个问题是在公共 DNS 服务器上运行，我们处于泄露内部网络信息的风险之下。因此，我们决定建立更好的东西，并开始确定我们对新系统的要求。
我们着手设计一个新的 DNS 基础设施，以改善上述包括扩展和可见性在内的运维问题，并引入了一些额外的需求。我们希望通过外部 DNS 提供商继续运行我们的公共 DNS 域，因此我们构建的系统需要与供应商无关。此外，我们希望该系统能够服务于我们的内部和外部域，这意味着内部域仅在我们的内部网络上可用，除非另有特别配置，而外部域也不用离开我们的内部网络就可解析。我们希望新的 DNS 架构不但可以[基于部署的工作流进行更改](https://githubengineering.com/enabling-split-authority-dns-with-octodns/)，并可以通过我们的仓库和配置系统使用 API 自动更改 DNS 记录。新系统不能有任何外部依赖，太依赖于 DNS 功能将会陷入级联故障，这包括连接到其他数据中心和其中可能有的 DNS 服务。我们的旧系统将缓存服务器和权威服务器在同一台主机上混合使用。我们想转到具有独立角色的分层设计。最后，我们希望系统能够支持多数据中心环境，无论是 EC2 还是裸机。
### 实现
为了构建这个系统，我们确定了三类主机：<ruby> 缓存主机 <rt> cache </rt></ruby>、<ruby> 边缘主机 <rt> edge </rt></ruby>和<ruby> 权威主机 <rt> authority </rt></ruby>。缓存主机作为<ruby> 递归解析器 <rt> recursive resolver </rt></ruby>和 DNS “路由器” 缓存来自边缘层的响应。边缘层运行 DNS 权威守护程序，用于响应缓存层对 DNS <ruby> 区域 <rt> zone </rt></ruby>的请求，其被配置为来自权威层的<ruby> 区域传输 <rt> zone transfer </rt></ruby>。权威层作为隐藏的 DNS <ruby> 主服务器 <rt> master </rt></ruby>，作为 DNS 数据的规范来源，为来自边缘主机的<ruby> 区域传输 <rt> zone transfer </rt></ruby>提供服务，并提供用于创建、修改或删除记录的 HTTP API。
在我们的新配置中，缓存主机存在于每个数据中心中，这意味着应用主机不需要穿过数据中心边界来检索记录。缓存主机被配置为将<ruby> 区域 <rt> zone </rt></ruby>映射到其<ruby> 地域 <rt> region </rt></ruby>内的边缘主机，以便将我们的内部<ruby> 区域 <rt> zone </rt></ruby>路由到我们自己的主机。未明确配置的任何<ruby> 区域 <rt> zone </rt></ruby>将通过互联网递归解析。
边缘主机是地域性的主机，存在我们的网络边缘 PoP（<ruby> 存在点 <rt> Point of Presence </rt></ruby>）内。我们的 PoP 有一个或多个依赖于它们进行外部连接的数据中心，没有 PoP 数据中心将无法访问互联网，互联网也无法访问它们。边缘主机对所有的权威主机执行<ruby> 区域传输 <rt> zone transfer </rt></ruby>，无论它们存在什么<ruby> 地域 <rt> region </rt></ruby>或<ruby> 位置 <rt> location </rt></ruby>，并将这些区域存在本地的磁盘上。
我们的权威主机也是地域性的主机，只包含适用于其所在<ruby> 地域 <rt> region </rt></ruby>的<ruby> 区域 <rt> zone </rt></ruby>。我们的仓库和配置系统决定一个<ruby> 区域 <rt> zone </rt></ruby>存放在哪个<ruby> 地域性权威主机 <rt> regional authority </rt></ruby>，并通过 HTTP API 服务来创建和删除记录。 OctoDNS 将区域映射到地域性权威主机，并使用相同的 API 创建静态记录，以及确保动态源处于同步状态。对于外部域 (如 github.com)，我们有另外一个单独的权威主机，以允许我们可以在连接中断期间查询我们的外部域。所有记录都存储在 MySQL 中。
### 可运维性
迁移到更现代的 DNS 基础设施的巨大好处是可观察性。我们的旧 DNS 系统几乎没有指标，只有有限的日志。决定使用哪些 DNS 服务器的一个重要因素是它们所产生的指标的广度和深度。我们最终用 [Unbound](https://unbound.net/) 作为缓存主机，[NSD](https://www.nlnetlabs.nl/projects/nsd/) 作为边缘主机，[PowerDNS](https://powerdns.com/) 作为权威主机，所有这些都已在比 GitHub 大得多的 DNS 基础架构中得到了证实。
当在我们的裸机数据中心运行时，缓存通过私有的<ruby> <a href="https://en.wikipedia.org/wiki/Anycast"> 任播 </a> <rt> anycast </rt></ruby> IP 访问，从而使之可以到达最近的可用缓存主机。缓存主机已经以机架感知的方式部署，在它们之间提供了一定程度的平衡负载，并且与一些电源和网络故障模式相隔离。当缓存主机出现故障时，通常将用其进行 DNS 查询的服务器现在将自动路由到下一个最接近的缓存主机，以保持低延迟并提供对某些故障模式的容错。任播允许我们扩展单个 IP 地址后面的缓存数量，这与先前的配置不同，使得我们能够按 DNS 需求量运行尽可能多的缓存主机。
无论地域或位置如何，边缘主机使用权威层进行区域传输。我们的<ruby> 区域 <rt> zone </rt></ruby>并没有大到在每个<ruby> 地域 <rt> region </rt></ruby>保留所有<ruby> 区域 <rt> zone </rt></ruby>的副本成为问题。（LCTT 译注：此处原文“Our zones are not large enough that keeping a copy of all of them in every region is a problem.”，根据上下文理解而翻译。）这意味着对于每个区域，即使某个地域处于脱机状态，或者上游服务提供商存在连接问题，所有缓存服务器都可以访问具备所有区域的本地副本的本地边缘服务器。这种变化在面对连接问题方面已被证明是相当有弹性的，并且在不久前本来会导致客户面临停止服务的故障期间帮助保持 GitHub 可用。
那些区域传输包括了内部和外部域从它们相应的权威服务器进行的传输。正如你可能会猜想像 github.com 这样的区域是外部的，像 github.net 这样的区域通常是内部的。它们之间的区别仅在于我们使用的类型和存储在其中的数据。了解哪些区域是内部和外部的，为我们在配置中提供了一些灵活性。
```
$ dig +short github.com
192.30.253.112
192.30.253.113
```
公共<ruby> 区域 <rt> zone </rt></ruby>被[同步](https://githubengineering.com/enabling-split-authority-dns-with-octodns/)到外部 DNS 提供商，并且是 GitHub 用户每天使用的 DNS 记录。另外，公共区域在我们的网络中是完全可解析的，而不需要与我们的外部提供商进行通信。这意味着需要查询 `api.github.com` 的任何服务都可以这样做，而无需依赖外部网络连接。我们还使用了 Unbound 的 `stub-first` 配置选项，它给了我们第二次查询的机会，如果我们的内部 DNS 服务由于某些原因在外部查询失败，则可以进行第二次查找。
```
$ dig +short time.github.net
10.127.6.10
```
大部分的 `github.net` 区域是完全私有的，无法从互联网访问，它只包含 [RFC 1918](http://www.faqs.org/rfcs/rfc1918.html) 中规定的 IP 地址。每个地域和站点都划分了私有区域。每个地域和/或站点都具有适用于该位置的一组子区域，子区域用于管理网络、服务发现、特定的服务记录，并且还包括在我们仓库中的配置主机。私有区域还包括 PTR 反向查找区域。
### 总结
用一个新系统替换可以为数百万客户提供服务的旧系统并不容易。使用实用的、基于需求的方法来设计和实施我们的新 DNS 系统，才能打造出一个能够迅速有效地运行、并有望与 GitHub 一起成长的 DNS 基础设施。
想帮助 GitHub SRE 团队解决有趣的问题吗？我们很乐意你加入我们。[在这申请](https://boards.greenhouse.io/github/jobs/669805#.WPVqJlPyvUI)。
---
via: <https://githubengineering.com/dns-infrastructure-at-github/>
作者：[Joe Williams](https://github.com/joewilliams) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Samba 系列（十五）：用 SSSD 和 Realm 集成 Ubuntu 到 Samba4 AD DC
|
Matei Cezar
|
https://www.tecmint.com/integrate-ubuntu-to-samba4-ad-dc-with-sssd-and-realm/
|
本教程将告诉你如何将 Ubuntu 桌面版机器加入到带有 SSSD 和 Realm 服务的 Samba4 活动目录域中，以在活动目录中认证用户。
|
/data/attachment/album/201709/09/181412dtnflmmtymtod5py.jpg.thumb.jpg
|
/data/attachment/album/201709/09/181412dtnflmmtymtod5py.jpg
| true | false | true |
XYenChi
| false |
[
"Samba",
"SSSD"
] |
系统运维
|
{
"viewnum": 12137,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8777,
"displayorder": 0
}
] |
本教程将告诉你如何将 Ubuntu 桌面版机器加入到带有 SSSD 和 Realm 服务的 Samba4 活动目录域中，以在活动目录中认证用户。
| 2017-09-09T18:14:00 | 2017-09-09T18:14:00 | 8,853 |
/article-8853-1.html
|
本教程将告诉你如何将 Ubuntu 桌面版机器加入到带有 SSSD 和 Realm 服务的 Samba4 活动目录域中，以在活动目录中认证用户。
### 要求：
1. [在 Ubuntu 上用 Samba4 创建一个活动目录架构](/article-8065-1.html)
### 第 1 步：初始配置
1、 在把 Ubuntu 加入活动目录前确保主机名被正确设置了。使用 `hostnamectl` 命令设置机器名字或者手动编辑 `/etc/hostname` 文件。
```
$ sudo hostnamectl set-hostname your_machine_short_hostname
$ cat /etc/hostname
$ hostnamectl
```
2、 接下来，编辑机器网络接口设置并且添加合适的 IP 设置，并将正确的 DNS IP 服务器地址指向 Samba 活动目录域控制器，如下图所示。
如果你已经配置了 DHCP 服务来为局域网机器自动分配包括合适的 AD DNS IP 地址的 IP 设置，那么你可以跳过这一步。
[](https://www.tecmint.com/wp-content/uploads/2017/07/Configure-Network-Interface.jpg)
*设置网络接口*
上图中，`192.168.1.254` 和 `192.168.1.253` 代表 Samba4 域控制器的 IP 地址。
3、 用 GUI（图形用户界面）或命令行重启网络服务来应用修改，并且对你的域名发起一系列 ping 请求来测试 DNS 解析如预期工作。 也用 `host` 命令来测试 DNS 解析。
```
$ sudo systemctl restart networking.service
$ host your_domain.tld
$ ping -c2 your_domain_name
$ ping -c2 adc1
$ ping -c2 adc2
```
4、 最后, 确保机器时间和 Samba4 AD 同步。安装 `ntpdate` 包并用下列指令和 AD 同步时间。
```
$ sudo apt-get install ntpdate
$ sudo ntpdate your_domain_name
```
### 第 2 步：安装需要的包
5、 这一步将安装将 Ubuntu 加入 Samba4 活动目录域控制器所必须的软件和依赖：Realmd 和 SSSD 服务。
```
$ sudo apt install adcli realmd krb5-user samba-common-bin samba-libs samba-dsdb-modules sssd sssd-tools libnss-sss libpam-sss packagekit policykit-1
```
6、 输入大写的默认 realm 名称，然后按下回车继续安装。
[](https://www.tecmint.com/wp-content/uploads/2017/07/Set-realm-name.png)
*输入 Realm 名称*
7、 接着，创建包含以下内容的 SSSD 配置文件。
```
$ sudo nano /etc/sssd/sssd.conf
```
加入下面的内容到 `sssd.conf` 文件。
```
[nss]
filter_groups = root
filter_users = root
reconnection_retries = 3
[pam]
reconnection_retries = 3
[sssd]
domains = tecmint.lan
config_file_version = 2
services = nss, pam
default_domain_suffix = TECMINT.LAN
[domain/tecmint.lan]
ad_domain = tecmint.lan
krb5_realm = TECMINT.LAN
realmd_tags = manages-system joined-with-samba
cache_credentials = True
id_provider = ad
krb5_store_password_if_offline = True
default_shell = /bin/bash
ldap_id_mapping = True
use_fully_qualified_names = True
fallback_homedir = /home/%d/%u
access_provider = ad
auth_provider = ad
chpass_provider = ad
access_provider = ad
ldap_schema = ad
dyndns_update = true
dyndsn_refresh_interval = 43200
dyndns_update_ptr = true
dyndns_ttl = 3600
```
确保你对应地替换了下列参数的域名：
```
domains = tecmint.lan
default_domain_suffix = TECMINT.LAN
[domain/tecmint.lan]
ad_domain = tecmint.lan
krb5_realm = TECMINT.LAN
```
8、 接着，用下列命令给 SSSD 配置文件适当的权限：
```
$ sudo chmod 700 /etc/sssd/sssd.conf
```
9、 现在，打开并编辑 Realmd 配置文件，输入下面这行：
```
$ sudo nano /etc/realmd.conf
```
`realmd.conf` 文件摘录：
```
[active-directory]
os-name = Linux Ubuntu
os-version = 17.04
[service]
automatic-install = yes
[users]
default-home = /home/%d/%u
default-shell = /bin/bash
[tecmint.lan]
user-principal = yes
fully-qualified-names = no
```
10、 最后需要修改的文件属于 Samba 守护进程。 打开 `/etc/samba/smb.conf` 文件编辑，然后在文件开头加入下面这块代码，在 `[global]` 之后的部分如下图所示。
```
workgroup = TECMINT
client signing = yes
client use spnego = yes
kerberos method = secrets and keytab
realm = TECMINT.LAN
security = ads
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/Configure-Samba-Server.jpg)
*配置 Samba 服务器*
确保你替换了域名值，特别是对应域名的 realm 值，并运行 `testparm` 命令检验设置文件是否包含错误。
```
$ sudo testparm
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/Test-Samba-Configuration.jpg)
*测试 Samba 配置*
11、 在做完所有必需的修改之后，用 AD 管理员帐号验证 Kerberos 认证并用下面的命令列出票据。
```
$ sudo kinit ad_admin_user@DOMAIN.TLD
$ sudo klist
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/Check-Kerberos-Authentication.jpg)
*检验 Kerberos 认证*
### 第 3 步： 加入 Ubuntu 到 Samba4 Realm
12、 键入下列命令将 Ubuntu 机器加入到 Samba4 活动目录。用有管理员权限的 AD DC 账户名字，以便绑定 realm 可以如预期般工作，并替换对应的域名值。
```
$ sudo realm discover -v DOMAIN.TLD
$ sudo realm list
$ sudo realm join TECMINT.LAN -U ad_admin_user -v
$ sudo net ads join -k
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/Join-Ubuntu-to-Samba4-Realm.jpg)
*加入 Ubuntu 到 Samba4 Realm*
[](https://www.tecmint.com/wp-content/uploads/2017/07/List-Realm-Domain-Info.jpg)
*列出 Realm Domain 信息*
[](https://www.tecmint.com/wp-content/uploads/2017/07/Add-User-to-Realm-Domain.jpg)
*添加用户到 Realm Domain*
[](https://www.tecmint.com/wp-content/uploads/2017/07/Add-Domain-to-Realm.jpg)
*添加 Domain 到 Realm*
13、 区域绑定好了之后，运行下面的命令确保所有域账户允许在这台机器上认证。
```
$ sudo realm permit -all
```
然后你可以使用下面举例的 `realm` 命令允许或者禁止域用户帐号或群组访问。
```
$ sudo realm deny -a
$ realm permit --groups ‘domain.tld\Linux Admins’
$ realm permit user@domain.lan
$ realm permit DOMAIN\\User2
```
14、 从一个 [安装了 RSAT 工具的](/article-8097-1.html) Windows 机器上你可以打开 AD UC 并浏览“<ruby> 电脑 <rt> computers </rt></ruby>”容器，并检验是否有一个使用你机器名的对象帐号已经创建。
[](https://www.tecmint.com/wp-content/uploads/2017/07/Confirm-Domain-Added.jpg)
*确保域被加入 AD DC*
### 第 4 步：配置 AD 账户认证
15、 为了在 Ubuntu 机器上用域账户认证，你需要用 root 权限运行 `pam-auth-update` 命令并允许所有 PAM 配置文件，包括为每个域账户在第一次注册的时候自动创建家目录的选项。
按 [空格] 键检验所有配置项并点击 ok 来应用配置。
```
$ sudo pam-auth-update
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/PAM-Configuration.jpg)
*PAM 配置*
16、 在系统上手动编辑 `/etc/pam.d/common-account` 文件，下面这几行是为了给认证过的域用户自动创建家目录。
```
session required pam_mkhomedir.so skel=/etc/skel/ umask=0022
```
17、 如果活动目录用户不能用 linux 命令行修改他们的密码，打开 `/etc/pam.d/common-password` 文件并在 `password` 行移除 `use_authtok` 语句，最后如下：
```
password [success=1 default=ignore] pam_winbind.so try_first_pass
```
18、 最后，用下面的命令重启并启用以应用 Realmd 和 SSSD 服务的修改：
```
$ sudo systemctl restart realmd sssd
$ sudo systemctl enable realmd sssd
```
19、 为了测试 Ubuntu 机器是是否成功集成到 realm ，安装 winbind 包并运行 `wbinfo` 命令列出域账户和群组，如下所示。
```
$ sudo apt-get install winbind
$ wbinfo -u
$ wbinfo -g
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/List-Domain-Accounts.jpg)
*列出域账户*
20、 同样，也可以针对特定的域用户或群组使用 `getent` 命令检验 Winbind nsswitch 模块。
```
$ sudo getent passwd your_domain_user
$ sudo getent group ‘domain admins’
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/check-Winbind-nsswitch.jpg)
*检验 Winbind Nsswitch*
21、 你也可以用 Linux `id` 命令获取 AD 账户的信息，命令如下：
```
$ id tecmint_user
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/Check-AD-User-Info.jpg)
*检验 AD 用户信息*
22、 用 `su -` 后跟上域用户名参数来认证 Ubuntu 主机的一个 Samba4 AD 账户。运行 `id` 命令获取该 AD 账户的更多信息。
```
$ su - your_ad_user
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/AD-User-Authentication.jpg)
*AD 用户认证*
用 `pwd` 命令查看你的域用户当前工作目录，和用 `passwd` 命令修改密码。
23、 在 Ubuntu 上使用有 root 权限的域账户，你需要用下面的命令添加 AD 用户名到 sudo 系统群组：
```
$ sudo usermod -aG sudo your_domain_user@domain.tld
```
用域账户登录 Ubuntu 并运行 `apt update` 命令来更新你的系统以检验 root 权限。
24、 给一个域群组 root 权限，用 `visudo` 命令打开并编辑 `/etc/sudoers` 文件，并加入如下行：
```
%domain\ admins@tecmint.lan ALL=(ALL:ALL) ALL
```
25、 要在 Ubuntu 桌面使用域账户认证，通过编辑 `/usr/share/lightdm/lightdm.conf.d/50-ubuntu.conf` 文件来修改 LightDM 显示管理器，增加以下两行并重启 lightdm 服务或重启机器应用修改。
```
greeter-show-manual-login=true
greeter-hide-users=true
```
域账户用“你的域用户”或“你的域用户@你的域” 格式来登录 Ubuntu 桌面。
26、 为使用 Samba AD 账户的简称格式，编辑 `/etc/sssd/sssd.conf` 文件，在 `[sssd]` 块加入如下几行命令。
```
full_name_format = %1$s
```
并重启 SSSD 守护进程应用改变。
```
$ sudo systemctl restart sssd
```
你会注意到 bash 提示符会变成了没有附加域名部分的 AD 用户名。
27、 万一你因为 `sssd.conf` 里的 `enumerate=true` 参数设定而不能登录，你得用下面的命令清空 sssd 缓存数据：
```
$ rm /var/lib/sss/db/cache_tecmint.lan.ldb
```
这就是全部了！虽然这个教程主要集中于集成 Samba4 活动目录，同样的步骤也能被用于把使用 Realm 和 SSSD 服务的 Ubuntu 整合到微软 Windows 服务器活动目录。
---
作者简介：
Matei Cezar - 我是一名网瘾少年，开源和基于 linux 系统软件的粉丝，有4年经验在 linux 发行版桌面、服务器和 bash 脚本。
---
via: <https://www.tecmint.com/integrate-ubuntu-to-samba4-ad-dc-with-sssd-and-realm/>
作者：[Matei Cezar](https://www.tecmint.com/author/cezarmatei/) 译者：[XYenChi](https://github.com/XYenChi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
LCTT 四岁了
|
Wxy
|
今天，Linux 中国旗下的翻译组 LCTT （Linux 中国翻译组 - Linux.Cn Translation Team）已经成立 4 年了！
作为这四年来，我日常参与的最重要的工作，也是我持续最长时间的一项活动，一时间竟然不知道该写点什么出来。
|
/data/attachment/album/201709/10/114210jwwl6ceqcj6jclz1.jpg.thumb.jpg
|
/data/attachment/album/201709/10/114210jwwl6ceqcj6jclz1.jpg
| true | false | false | false |
[
"LCTT"
] |
新闻
|
{
"viewnum": 6966,
"commentnum": 4,
"favtimes": 0,
"sharetimes": 2,
"likes": 0
}
|
[
{
"postip": "123.149.109.140",
"message": "生日快乐~：D",
"username": "softpaopao [Chrome 61.0|Windows 10]",
"date": "2017-09-10T15:02:20"
},
{
"postip": "116.31.81.182",
"message": "生日快乐 居然是教师节啊",
"username": "来自广东广州的 Firefox 57.0|GNU/Linux 用户",
"date": "2017-09-11T09:28:51"
},
{
"postip": "223.104.63.11",
"message": "感谢无私的奉献",
"username": "来自223.104.63.11的 Chrome Mobile 40.0|Android 6.0 用户",
"date": "2017-09-11T18:17:51"
},
{
"postip": "112.95.209.198",
"message": "感谢无私奉献的你们",
"username": "时未央 [Chrome 61.0|Windows 10]",
"date": "2017-09-13T15:38:59"
}
] |
[] |
今天，Linux 中国旗下的翻译组 LCTT （Linux 中国翻译组 - Linux.Cn Translation Team）已经成立 4 年了！
作为这四年来，我日常参与的最重要的工作，也是我持续最长时间的一项活动，一时间竟然不知道该写点什么出来。
| 2017-09-10T11:40:00 | 2017-09-10T11:40:00 | 8,854 |
/article-8854-1.html
|
今天，Linux 中国旗下的翻译组 LCTT （<ruby> <a href="https://linux.cn/lctt/"> Linux 中国翻译组 </a> <rp> （ </rp> <rt> Linux.Cn Translation Team </rt> <rp> ） </rp></ruby>）已经成立 4 年了！
作为这四年来，我日常参与的最重要的工作，也是我持续最长时间的一项活动，一时间竟然不知道该写点什么出来。
首先，我列点数据出来吧：
* 成立时间： [2013 年 9 月 10 日](/article-1970-1.html)
* 持续活动时间：[4 年（1461 天）](https://github.com/LCTT/TranslateProject/graphs/contributors)
* 贡献者： [293 人](https://github.com/LCTT/TranslateProject/graphs/contributors)
* 提交：[21556 个](https://github.com/LCTT/TranslateProject/commits/master)
* 星标：[689 个](https://github.com/LCTT/TranslateProject/stargazers)
* 复刻： [518 个](https://github.com/LCTT/TranslateProject/network)
* 拉取请求：[5925 个](https://github.com/LCTT/TranslateProject/pulls)
* 翻译文章：[2833 篇](https://github.com/LCTT/TranslateProject)
* 单人最高翻译篇数：[533 篇](https://linux.cn/lctt/geekpi)（[@geekpi](/article-8729-1.html)）
* 10 篇以上翻译人数：[59 人](https://linux.cn/lctt-list)
以上数据来自 LCTT 主要项目 [TranslateProject](https://github.com/LCTT/TranslateProject) ，其中没有包括 LCTT 的一些次要项目，如 [comic](https://github.com/LCTT/comic)、[LFS-BOOK](https://github.com/LCTT/LFS-BOOK) 等的数据。
下图是 LCTT [TranslateProject](https://github.com/LCTT/TranslateProject) 这 4 年间的提交情况：
*LCTT TranslateProject 的提交情况*
时光荏苒，几年来，我结识了许多朋友，也不断有新的小伙伴们加入到我们的团队中。我们翻译的文章也屡屡得到读者的好评，以至于在网络上被一再转载（虽然有些转载可耻地删除了作者和我们的译者姓名）。作为 LCTT 创始人，我对团队中的许多成员都耳熟能详，甚至有时候一看翻译的文风都可以可以猜测到译者是谁。虽然也有一些成员逐渐淡出了 LCTT，但是他们做下的功绩，却一直留存在网上，刻在 LCTT 的历史上。需要感谢的人太多，以至于我无法一一列出，我只说一句，愿所有志愿者的 LCTT 经历都是你的人生履历中一段鲜亮的色彩。
今年，我们还专门为 LCTT 开设了[主页](https://linux.cn/lctt)和[贡献排行榜](https://linux.cn/lctt-list)，也为每位译者创建了专属的专页，从他们的专页中，可以看到每位译者的贡献情况，我希望这个页面可以成为每位贡献者收藏到浏览器书签中的地址。
诚然，LCTT 作为一个运行了 4 年的开源志愿者组织，也存在一些问题。比如，翻译和校对的工作的不对等；没有细分几个不同的翻译方向；缺少一个直观的、掩盖了底层 GitHub 操作的流程界面；不能合理量化每位翻译者的贡献程度；次生项目的推进不力等等。我们也希望有更多的同仁一同来参与 LCTT 的建设，使之具有更活跃的生命力，更丰富的生态系统。
那么，这里是 LCTT => <https://linux.cn/lctt> ，你不来看看么？
|
||||
如何使用拉取请求（PR）来改善你的代码审查
|
Brent Beer, Peter Bell
|
https://www.oreilly.com/ideas/how-to-use-pull-requests-to-improve-your-code-reviews
|
通过使用 GitHub 的拉取请求（Pull Request）正确地进行代码审核，把时间更多的花在构建上，而在修复上少用点时间。
|
/data/attachment/album/201709/10/145704nfxpb1k1z9hkfumf.jpg.thumb.jpg
|
/data/attachment/album/201709/10/145704nfxpb1k1z9hkfumf.jpg
| true | false | true |
MonkeyDEcho
| false |
[
"PR",
"拉取请求",
"GitHub"
] |
软件开发
|
{
"viewnum": 5437,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通过使用 GitHub 的拉取请求（Pull Request）正确地进行代码审核，把时间更多的花在构建上，而在修复上少用点时间。
| 2017-09-10T14:57:02 | 2017-09-10T14:57:02 | 8,855 |
/article-8855-1.html
|
>
> 通过使用 GitHub 的<ruby> 拉取请求 <rt> Pull Request </rt></ruby>正确地进行代码审核，把时间更多的花在构建上，而在修复上少用点时间。
>
>
>
如果你不是每天编写代码，你可能不知道软件开发人员日常面临的一些问题。
* 代码中的安全漏洞
* 导致应用程序崩溃的代码
* 被称作 “技术债务” 和之后需要重写的代码
* 在某处你所不知道地方的代码已经被重写
<ruby> 代码审查 <rt> Code review </rt></ruby>可以允许其他的人或工具来检查代码，帮助我们改善所编写的软件。这种审查（也称为<ruby> 同行评审 <rt> peer review </rt></ruby>）能够通过自动化代码分析或者测试覆盖工具来进行，是软件开发过程中两个重要的部分，它能够节省数小时的手工工作。同行评审是开发人员审查彼此工作的一个过程。在软件开发的过程中，速度和紧迫性是两个经常提及的问题。如果你没有尽快的发布，你的竞争对手可能会率先发布新功能。如果你不能够经常发布新的版本，你的用户可能会怀疑您是否仍然关心改进你的应用程序。
### 权衡时间：代码审查与缺陷修复
如果有人能够以最小争议的方式汇集多种类型的代码审查，那么随着时间的推移，该软件的质量将会得到改善。如果认为引入新的工具或流程最先导致的不是延迟，那未免太天真了。但是代价更高昂的是：修复生产环境中的错误花费的时间，或者在放到生产环境之前改进软件所花费的时间。即使新工具延迟了新功能的发布和得到客户欣赏的时间，但随着软件开发人员提高自己的技能，该延迟会缩短，软件开发周期将会回升到以前的水平，而同时缺陷将会减少。
通过代码审查实现提升代码质量目标的关键之一就是使用一个足够灵活的平台，允许软件开发人员快速编写代码，置入他们熟悉的工具，并对彼此进行同行评审。 GitHub 就是这样的平台的一个很好的例子。然而，只是把你的代码放在 [GitHub](https://github.com/about) 上并不会魔术般地使代码审查发生；你必须使用<ruby> 拉取请求 <rt> Pull Request </rt></ruby>来开始这个美妙的旅程。
### 拉取请求：关于代码的现场讨论
<ruby> <a href="https://help.github.com/articles/about-pull-requests/"> 拉取请求 </a> <rt> Pull Request </rt></ruby>是 Github 上的一个工具，允许软件开发人员讨论并提出对项目的主要代码库的更改，这些更改稍后可以部署给所有用户看到。这个功能创建于 2008 年 2 月，其目的是在接受（合并）之前，对某人的建议进行更改，然后在部署到生产环境中，供最终用户看到这种变化。
拉取请求开始是以一种松散的方式让你为某人的项目提供更改，但是它们已经演变成：
* 关于你想要合并的代码的现场讨论
* 提升了所更改内容的可视功能
* 整合了你最喜爱的工具
* 作为受保护的分支工作流程的一部分可能需要显式的拉取请求评审
### 对于代码：URL 是永久的
看看上述的前两个点，拉取请求促成了一个正在进行的代码讨论，使代码变更可以更醒目，并且使您很容易在审查的过程中找到所需的代码。无论是对于新人还是有经验的开发人员，能够回顾以前的讨论，了解一个功能为什么以这种方式开发出来，或者与另一个相关功能的讨论相联系起来是无价的。当跨多个项目协调，并使每个人尽可能接近代码时，前后讨论的内容也非常重要。如果这些功能仍在开发中，重要的是能够看到上次审查以来更改了哪些内容。毕竟，[审查小的更改要比大的容易得多](https://blog.skyliner.io/ship-small-diffs-741308bec0d1)，但不可能全都是小功能。因此，重要的是能够找到你上次审查，并只看到从那时以来的变化。
### 集成工具：软件开发人员的偏执
再看下上述第三点，GitHub 上的拉取请求有很多功能，但开发人员总是偏好第三方工具。代码质量是个完整的代码审查领域，它涉及到其它组件的代码评审，而这些评审不一定是由人完成的。检测“低效”或缓慢的代码、具有潜在安全漏洞或不符合公司标准的代码是留给自动化工具的任务。类似 [SonarQube](https://github.com/integrations/sonarqube) 和 [Code Climatecan](https://github.com/integrations/code-climate) 这样工具可以分析你的代码，而像 [Codecov](https://github.com/integrations/codecov) 和 [Coveralls](https://github.com/integrations/coveralls) 的这样工具可以告诉你刚刚写的新代码还没有得到很好的测试。这些工具最令人称奇的是，它们可以集成到 GitHub 中，并把它们的发现汇报到拉取请求当中！这意味着该过程中不仅是人们在审查代码，而且工具也在会在那里报告情况。这样每个人都可以完全了解一个功能是如何开发的。
最后，根据您的团队的偏好，您可以利用[受保护的分支工作流](https://help.github.com/articles/about-protected-branches/)的<ruby> 必需状态 <rt> required status </rt></ruby>功能来要求进行工具审查和同行评审。
虽然您可能只是刚刚开始您的软件开发之旅，或者是一位希望知道项目正在做什么的业务利益相关者，抑或是一位想要确保项目的及时性和质量的项目经理，你都可以通过设置批准流程来参与到拉取请求中，并考虑集成更多的工具以确保质量，这在任何级别的软件开发中都很重要。
无论是为您的个人网站，贵公司的在线商店，还是想用最新的组合以获得最大的收获，编写好的软件都需要进行良好的代码审查。良好的代码审查涉及到正确的工具和平台。要了解有关 GitHub 和软件开发过程的更多信息，请参阅 O'Reilly 的 《[GitHub 简介](https://www.safaribooksonline.com/library/view/introducing-github/9781491949801/?utm_source=newsite&utm_medium=content&utm_campaign=lgen&utm_content=how-to-use-pull-requests-to-improve-your-code-reviews-lower)》 一书， 您可以在其中了解创建项目、启动拉取请求以及概要了解团队的软件开发流程。
---
作者简介：
**Brent Beer**
Brent Beer 通过大学的课程、对开源项目的贡献，以及担任专业网站开发人员使用 Git 和 GitHub 已经超过五年了。在担任 GitHub 上的培训师时，他也成为 O’Reilly 的 《GitHub 简介》的出版作者。他在阿姆斯特丹担任 GitHub 的解决方案工程师，帮助 Git 和 GitHub 向世界各地的开发人员提供服务。
**Peter Bell**
Peter Bell 是 Ronin 实验室的创始人以及 CTO。培训是存在问题的，我们通过技术提升培训来改进它！他是一位有经验的企业家、技术专家、敏捷教练和 CTO，专门从事 EdTech 项目。他为 O'Reilly 撰写了 《GitHub 简介》，为代码学校创建了“精通 GitHub ”课程，为 Pearson 创建了“ Git 和 GitHub 现场课”课程。他经常在国际和国际会议上发表 ruby、 nodejs、NoSQL（尤其是 MongoDB 和 neo4j ）、云计算、软件工艺、java、groovy、j 等的演讲。
---
via: <https://www.oreilly.com/ideas/how-to-use-pull-requests-to-improve-your-code-reviews>
作者：[Brent Beer](https://www.oreilly.com/people/acf937de-cdf4-4b0e-85bd-b559404c580e), [Peter Bell](https://www.oreilly.com/people/2256f119-7ea0-440e-99e8-65281919e952) 译者：[MonkeyDEcho](https://github.com/MonkeyDEcho) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
漫谈传统的 Linux 初始化系统的运行级别
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3222070/linux/maneuvering-around-run-levels-on-linux.html
|
了解运行级别是如何配置的，如何改变系统运行级别以及修改对应状态下运行的服务。
|
/data/attachment/album/201709/10/212729wmyh9hzy35umhp0d.jpg.thumb.jpg
|
/data/attachment/album/201709/10/212729wmyh9hzy35umhp0d.jpg
| true | false | true |
penghuster
| false |
[
"runlevel"
] |
系统运维
|
{
"viewnum": 7071,
"commentnum": 3,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.122.120.11",
"message": "原文好歹提一下 systemd 嘛，结果通篇没有。在 debian 都要上 wayland 的今天，介绍 runlevel，实在有些脱离现实。<br />\r\n<br />\r\nreadlink $(which runlevel)<br />\r\n../bin/systemctl",
"username": "来自四川成都的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-11T09:49:36"
},
{
"postip": "219.239.24.85",
"message": "runlevel有点过时啦!",
"username": "拿铁不加糖 [Chrome 61.0|Windows 10]",
"date": "2017-09-11T10:28:01"
},
{
"postip": "61.186.28.232",
"message": "我也不知道为什么会有这样一篇过时的文章——不过有些遗留系统还是用的这个。",
"username": "linux [Chrome 60.0|Mac 10.11]",
"date": "2017-09-11T10:33:55"
}
] |
[] |
了解运行级别是如何配置的，如何改变系统运行级别以及修改对应状态下运行的服务。
| 2017-09-11T08:26:00 | 2017-09-11T08:26:00 | 8,857 |
/article-8857-1.html
|
>
> 了解运行级别是如何配置的，如何改变系统运行级别以及修改对应状态下运行的服务。
>
>
>
在 Linux 系统中，<ruby> 运行级别 <rt> run level </rt></ruby>是指运维的级别，用于描述一种表明什么服务是可用的系统运行状态。
运行级别 1 是严格限制的，仅仅用于系统维护；该级别下，网络连接将不可操作，但是管理员可以通过控制台连接登录系统。
其他运行级别的系统允许任何人登录和使用，但是不同级别中可使用的服务不同。本文将探索如何配置运行级别，如何交互式改变系统运行级别以及修改该状态下可用的服务。
Linux 系统的默认运行状态是一个在系统开机时使用的运行级别（除非有其他的指示），它通常是在 `/etc/inittab` 文件中进行配置的，该文件内容通常如下：
```
id:3:initdefault
```
包括 Debian 系统在内的一些系统，默认运行级别为 2，而不是上述文件中的 3，甚至都没有 `/etc/inittab` 文件。
运行级别在默认情况下是如何被配置，其配置依赖于你所运行的 Linux 操作系统的具体发行版本。 例如，在某些系统中， 运行级别 2 是多用户模式，运行级别 3 是多用户模式并支持 NFS （网络文件系统）。 在另外一些系统，运行级别 2 - 5 基本相同，运行级别 1 是单用户模式。例如，Debian 系统的所用运行级别如下：
```
0 = 停机
1 = 单用户（维护模式）
2 = 多用户模式
3-5 = 同 2 一样
6 = 重启
```
在 Linux 系统上，运行级别 3 用于共享文件系统给其它系统，可以方便地只通过改变系统的运行级别来启动和停止文件系统共享。系统从运行级别 2 改变到 3 系统将允许文件系统共享，反之从运行级别 3 改变到 2 则系统不支持文件系统共享。
在某个运行级别中，系统运行哪些进程依赖于目录 `/etc/rc?.d` 目录的内容，其中 `?` 可以是 2、 3、 4 或 5 （对应于相应的运行级别）。
在以下示例中（Ubuntu 系统），由于这些目录的配置是相同的，我们将看见上述 4 个级别对应的目录中的内容是一致的。
```
/etc/rc2.d$ ls
README S20smartmontools S50saned S99grub-common
S20kerneloops S20speech-dispatcher S70dns-clean S99ondemand
S20rsync S20sysstat S70pppd-dns S99rc.local
/etc/rc2.d$ cd ../rc3.d
/etc/rc3.d$ ls
README S20smartmontools S50saned S99grub-common
S20kerneloops S20speech-dispatcher S70dns-clean S99ondemand
S20rsync S20sysstat S70pppd-dns S99rc.local
/etc/rc3.d$ cd ../rc4.d
/etc/rc4.d$ ls
README S20smartmontools S50saned S99grub-common
S20kerneloops S20speech-dispatcher S70dns-clean S99ondemand
S20rsync S20sysstat S70pppd-dns S99rc.local
/etc/rc4.d$ cd ../rc5.d
/etc/rc5.d$ ls
README S20smartmontools S50saned S99grub-common
S20kerneloops S20speech-dispatcher S70dns-clean S99ondemand
S20rsync S20sysstat S70pppd-dns S99rc.local
```
这些都是什么文件？它们都是指向 `/etc/init.d` 目录下用于启动服务的脚本符号连接。 这些文件的文件名是至关重要的， 因为它们决定了这些脚本文件的执行顺序，例如, S20 脚本是在 S50 脚本前面运行的。
```
$ ls -l
total 4
-rw-r--r-- 1 root root 677 Feb 16 2016 README
lrwxrwxrwx 1 root root 20 Aug 30 14:40 S20kerneloops -> ../init.d/kerneloops
lrwxrwxrwx 1 root root 15 Aug 30 14:40 S20rsync -> ../init.d/rsync
lrwxrwxrwx 1 root root 23 Aug 30 16:10 S20smartmontools -> ../init.d/smartmontools
lrwxrwxrwx 1 root root 27 Aug 30 14:40 S20speech-dispatcher -> ../init.d/speech-dispatcher
lrwxrwxrwx 1 root root 17 Aug 31 14:12 S20sysstat -> ../init.d/sysstat
lrwxrwxrwx 1 root root 15 Aug 30 14:40 S50saned -> ../init.d/saned
lrwxrwxrwx 1 root root 19 Aug 30 14:40 S70dns-clean -> ../init.d/dns-clean
lrwxrwxrwx 1 root root 18 Aug 30 14:40 S70pppd-dns -> ../init.d/pppd-dns
lrwxrwxrwx 1 root root 21 Aug 30 14:40 S99grub-common -> ../init.d/grub-common
lrwxrwxrwx 1 root root 18 Aug 30 14:40 S99ondemand -> ../init.d/ondemand
lrwxrwxrwx 1 root root 18 Aug 30 14:40 S99rc.local -> ../init.d/rc.local
```
如你所想，目录 `/etc/rc1.d` 因运行级别 1 的特殊而不同。它包含的符号链接指向非常不同的一套脚本。 同样也要注意到其中一些脚本以 `K` 开头命名，而另一些与其它运行级别脚本一样以 `S` 开头命名。这是因为当系统进入单用户模式时， 一些服务需要**停止**。 然而这些 K 开头的符号链接指向了其它级别 S 开头的符号链接的同一文件时， K（kill）表示这个脚本将以指示其停止的参数执行，而不是以启动的参数执行。
```
/etc/rc1.d$ ls -l
total 4
lrwxrwxrwx 1 root root 20 Aug 30 14:40 K20kerneloops -> ../init.d/kerneloops
lrwxrwxrwx 1 root root 15 Aug 30 14:40 K20rsync -> ../init.d/rsync
lrwxrwxrwx 1 root root 15 Aug 30 14:40 K20saned -> ../init.d/saned
lrwxrwxrwx 1 root root 23 Aug 30 16:10 K20smartmontools -> ../init.d/smartmontools
lrwxrwxrwx 1 root root 27 Aug 30 14:40 K20speech-dispatcher -> ../init.d/speech-dispatcher
-rw-r--r-- 1 root root 369 Mar 12 2014 README
lrwxrwxrwx 1 root root 19 Aug 30 14:40 S30killprocs -> ../init.d/killprocs
lrwxrwxrwx 1 root root 19 Aug 30 14:40 S70dns-clean -> ../init.d/dns-clean
lrwxrwxrwx 1 root root 18 Aug 30 14:40 S70pppd-dns -> ../init.d/pppd-dns
lrwxrwxrwx 1 root root 16 Aug 30 14:40 S90single -> ../init.d/single
```
你可以改变系统的默认运行级别，尽管这很少被用到。例如，通过修改前文中提到的 `/etc/inittab` 文件，你能够配置 Debian 系统的默认运行级别为 3 （而不是 2），以下是该文件示例：
```
id:3:initdefault:
```
一旦你修改完成并重启系统， `runlevel` 命令将显示如下：
```
$ runlevel
N 3
```
另外一种可选方式，使用 `init 3` 命令，你也能改变系统运行级别（且无需重启立即生效）， `runlevel` 命令的输出为：
```
$ runlevel
2 3
```
当然，除非你修改了系统默认级别的 `/etc/rc?.d` 目录下的符号链接，使得系统默认运行在一个修改的运行级别之下，否则很少需要通过创建或修改 `/etc/inittab` 文件改变系统的运行级别。
### 在 Linux 系统中如何使用运行级别？
为了扼要重述在系统中如何使用运行级别，下面有几个关于运行级别的快速问答问题：
**如何查询系统当前的运行级别？**
使用 `runlevel` 命令。
**如何查看特定运行级别所关联的服务进程？**
查看与该运行级别关联的运行级别开始目录（例如， `/etc/rc2.d` 对应于运行级别 2）。
**如何查看系统的默认运行级别？**
首先，查看 `/etc/inittab` 文件是否存在。如果不存在，就执行 `runlevel` 命令查询，你一般就已经处在该运行级别。
**如何改变系统运行级别？**
用 `init` 命令（例如 `init 3`）临时改变运行级别，通过修改或创建 `/etc/inittab` 文件永久改变其运行级别。
**能改变特定运行级别下运行的服务么？**
当然，通过改变对应的 `/etc/rc?.d` 目录下的符号连接即可。
**还有一些其他的什么需要考虑？**
当改变系统运行级别时，你应该特别小心，确保不影响到系统上正在运行的服务或者正在使用的用户。
（题图：[Vincent Desjardins](https://www.flickr.com/photos/endymion120/4824696883/in/photolist-8mkQi2-8vtyRx-8vvYZS-i31xQj-4TXTS2-S7VRNC-azimYK-dW8cYu-Sb5b7S-S7VRES-fpSVvo-61Zpn8-WxFwGi-UKKq3x-q6NSnC-8vsBLr-S3CPxn-qJUrLr-nDnpNu-8d7a6Q-T7mGpN-RE26wj-SeEXRa-5mZ7LG-Vp7t83-fEG5HS-Vp7sU7-6JpNBi-RCuR8P-qLzCL5-6WsfZx-5nU1tF-6ieGFi-3P5xwh-8mnxpo-hBXwSj-i3iCur-9dmrST-6bXk8d-8vtDb4-i2KLwU-5jhfU6-8vwbrN-ShAtNm-XgzXmb-8rad18-VfXm4L-8tQTrh-Vp7tcb-UceVDB) [(CC BY 2.0)](https://creativecommons.org/licenses/by/2.0/legalcode)）
---
via: <https://www.networkworld.com/article/3222070/linux/maneuvering-around-run-levels-on-linux.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 译者：[penghuster](https://github.com/penghuster) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Kubernetes 是什么？
|
Redhat.com
|
https://www.redhat.com/en/containers/what-is-kubernetes
|
Kubernetes，简称 k8s（k，8 个字符，s——明白了？）或者 “kube”，是一个开源的 Linux 容器自动化运维平台，它消除了容器化应用程序在部署、伸缩时涉及到的许多手动操作。
|
/data/attachment/album/201709/10/223444v5al5nfs70zm09gz.png.thumb.jpg
|
/data/attachment/album/201709/10/223444v5al5nfs70zm09gz.png
| true | false | true |
haoqixu
| true |
[
"Kubernetes"
] |
容器与云
|
{
"viewnum": 6042,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 7531,
"displayorder": 0
},
{
"raid": 8779,
"displayorder": 1
},
{
"raid": 8800,
"displayorder": 2
}
] |
Kubernetes，简称 k8s（k，8 个字符，s——明白了？）或者 “kube”，是一个开源的 Linux 容器自动化运维平台，它消除了容器化应用程序在部署、伸缩时涉及到的许多手动操作。
| 2017-09-11T09:33:00 | 2017-09-11T09:33:00 | 8,858 |
/article-8858-1.html
|
Kubernetes，简称 k8s（k，8 个字符，s——明白了？）或者 “kube”，是一个开源的 [Linux 容器](https://www.redhat.com/en/containers/whats-a-linux-container)自动化运维平台，它消除了容器化应用程序在部署、伸缩时涉及到的许多手动操作。换句话说，你可以将多台主机组合成集群来运行 Linux 容器，而 Kubernetes 可以帮助你简单高效地管理那些集群。构成这些集群的主机还可以跨越[公有云](https://www.redhat.com/en/topics/cloud-computing/what-is-public-cloud)、[私有云](https://www.redhat.com/en/topics/cloud-computing/what-is-private-cloud)以及混合云。
Kubernetes 最开始是由 Google 的工程师设计开发的。Google 作为 [Linux 容器技术的早期贡献者](https://en.wikipedia.org/wiki/Cgroups)之一，曾公开演讲介绍 [Google 如何将一切都运行于容器之中](https://speakerdeck.com/jbeda/containers-at-scale)（这是 Google 的云服务背后的技术）。Google 一周内的容器部署超过 20 亿次，全部的工作都由内部平台 [Borg](http://blog.kubernetes.io/2015/04/borg-predecessor-to-kubernetes.html) 支撑。Borg 是 Kubernetes 的前身，几年来开发 Borg 的经验教训也成了影响 Kubernetes 中许多技术的主要因素。
*趣闻: Kubernetes logo 中的七个辐条来源于项目原先的名称, “[Seven of Nine 项目](https://cloudplatform.googleblog.com/2016/07/from-Google-to-the-world-the-Kubernetes-origin-story.html)”（LCTT 译注：Borg 是「星际迷航」中的一个宇宙种族，Seven of Nine 是该种族的一名女性角色）。*
红帽作为最早与 Google 合作开发 Kubernetes 的公司之一（甚至早于 Kubernetes 的发行），已经是 Kubernetes 上游项目的[第二大贡献者](http://stackalytics.com/?project_type=kubernetes-group&metric=commits)。Google 在 2015 年把 Kubernetes 项目捐献给了新成立的 <ruby> <a href="https://www.cncf.io/"> 云计算基金会 </a> <rt> Cloud Native Computing Foundation </rt></ruby>（CNCF）。
### 为什么你需要 Kubernetes ？
真实的生产环境应用会包含多个容器，而这些容器还很可能会跨越多个服务器主机部署。Kubernetes 提供了为那些工作负载大规模部署容器的编排与管理能力。Kubernetes 编排让你能够构建多容器的应用服务，在集群上调度或伸缩这些容器，以及管理它们随时间变化的健康状态。
Kubernetes 也需要与网络、存储、安全、监控等其它服务集成才能提供综合性的容器基础设施。
当然，这取决于你如何在你的环境中使用容器。一个初步的 Linux 容器应用程序把容器视作高效、快速的虚拟机。一旦把它部署到生产环境或者扩展为多个应用，很显然你需要许多组托管在相同位置的容器合作提供某个单一的服务。随着这些容器的累积，你的运行环境中容器的数量会急剧增加，复杂度也随之增长。
Kubernetes 通过将容器分类组成 “pod” 来解决了容器增殖带来的许多常见问题。pod 为容器分组提供了一层抽象，以此协助你调度工作负载以及为这些容器提供类似网络与存储这类必要的服务。Kubernetes 的其它组件帮助你对 pod 进行负载均衡，以保证有合适数量的容器支撑你的工作负载。
正确实施的 Kubernetes，结合类似 [Atomic Registry](http://www.projectatomic.io/registry/)、[Open vSwitch](http://openvswitch.org/)、[heapster](https://github.com/kubernetes/heapster)、[OAuth](https://oauth.net/) 和 [SELinux](https://selinuxproject.org/page/Main_Page) 的开源项目，让你可以管理你自己的整个容器基础设施。
### Kubernetes 能做些什么？
在生产环境中使用 Kubernetes 的主要优势在于它提供了在物理机或虚拟机集群上调度和运行容器的平台。更宽泛地说，它能帮你在生产环境中实现可以依赖的基于容器的基础设施。而且，由于 Kubernetes 本质上就是运维任务的自动化平台，你可以执行一些其它应用程序平台或管理系统支持的操作，只不过操作对象变成了容器。
有了 Kubernetes，你可以：
* 跨主机编排容器。
* 更充分地利用硬件资源来最大化地满足企业应用的需求。
* 控制与自动化应用的部署与升级。
* 为有状态的应用程序挂载和添加存储器。
* 线上扩展或裁剪容器化应用程序与它们的资源。
* 声明式的容器管理，保证所部署的应用按照我们部署的方式运作。
* 通过自动布局、自动重启、自动复制、自动伸缩实现应用的状态检查与自我修复。
然而 Kubernetes 依赖其它项目来提供完整的编排服务。结合其它开源项目作为其组件，你才能充分感受到 Kubernetes 的能力。这些必要组件包括：
* 仓库：Atomic Registry、Docker Registry 等。
* 网络：OpenvSwitch 和智能边缘路由等。
* 监控：heapster、kibana、hawkular 和 elastic。
* 安全：LDAP、SELinux、 RBAC 与 支持多租户的 OAUTH。
* 自动化：通过 Ansible 的 playbook 进行集群的安装和生命周期管理。
* 服务：大量事先创建好的常用应用模板。
[红帽 OpenShift 为容器部署预先集成了上面这些组件。](https://www.redhat.com/en/technologies/cloud-computing/openshift)
### Kubernetes 入门
和其它技术一样，大量的专有名词有可能成为入门的障碍。下面解释一些通用的术语，希望帮助你理解 Kubernetes。
* **Master（主节点）：** 控制 Kubernetes 节点的机器，也是创建作业任务的地方。
* **Node（节点）：** 这些机器在 Kubernetes 主节点的控制下执行被分配的任务。
* **Pod：** 由一个或多个容器构成的集合，作为一个整体被部署到一个单一节点。同一个 pod 中的容器共享 IP 地址、进程间通讯（IPC）、主机名以及其它资源。Pod 将底层容器的网络和存储抽象出来，使得集群内的容器迁移更为便捷。
* **Replication controller（复制控制器）：** 控制一个 pod 在集群上运行的实例数量。
* **Service（服务）：** 将服务内容与具体的 pod 分离。Kubernetes 服务代理负责自动将服务请求分发到正确的 pod 处，不管 pod 移动到集群中的什么位置，甚至可以被替换掉。
* **Kubelet：** 这个守护进程运行在各个工作节点上，负责获取容器列表，保证被声明的容器已经启动并且正常运行。
* **kubectl：** 这是 Kubernetes 的命令行配置工具。
[上面这些知识就足够了吗？不，这仅仅是一小部分，更多内容请查看 Kubernetes 术语表。](https://kubernetes.io/docs/reference/)
### 生产环境中使用 Kubernetes
Kubernetes 是开源的，所以没有正式的技术支持机构为你的商业业务提供支持。如果在生产环境使用 Kubernetes 时遇到问题，你恐怕不会太愉快，当然你的客户也不会太高兴。
这就是[红帽 OpenShift](https://www.redhat.com/en/technologies/cloud-computing/openshift) 要解决的问题。OpenShift 是为企业提供的 Kubernetes ——并且集成了更多的组件。OpenShift 包含了强化 Kubernetes 功能、使其更适用于企业场景的额外部件，包括仓库、网络、监控、安全、自动化和服务在内。OpenShift 使得开发者能够在具有伸缩性、控制和编排能力的云端开发、托管和部署容器化的应用，快速便捷地把想法转变为业务。
而且，OpenShift 还是由头号开源领导公司红帽支持和开发的。
### Kubernetes 如何适用于你的基础设施
Kubernetes 运行在操作系统（例如 [Red Hat Enterprise Linux Atomic Host](https://www.redhat.com/en/technologies/linux-platforms/enterprise-linux/options)）之上，操作着该节点上运行的容器。Kubernetes 主节点（master）从管理员（或者 DevOps 团队）处接受命令，再把指令转交给附属的节点。这种带有大量服务的切换工作自动决定最适合该任务的节点，然后在该节点上分配资源并指派 pod 来完成任务请求。
所以从基础设施的角度，管理容器的方式发生了一点小小的变化。对容器的控制在更高的层次进行，提供了更佳的控制方式，而无需用户微观管理每个单独的容器或者节点。必要的工作则主要集中在如何指派 Kubernetes 主节点、定义节点和 pod 等问题上。
#### docker 在 Kubernetes 中的角色
[Docker](https://www.redhat.com/en/containers/what-is-docker) 技术依然执行它原本的任务。当 kubernetes 把 pod 调度到节点上，节点上的 kubelet 会指示 docker 启动特定的容器。接着，kubelet 会通过 docker 持续地收集容器的信息，然后提交到主节点上。Docker 如往常一样拉取容器镜像、启动或停止容器。不同点仅仅在于这是由自动化系统控制而非管理员在每个节点上手动操作的。
---
via: <https://www.redhat.com/en/containers/what-is-kubernetes>
作者：[www.redhat.com](https://www.redhat.com/) 译者：[haoqixu](https://github.com/haoqixu) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Headless Chrome 进行自动化测试
|
Eric bidelman
|
https://developers.google.com/web/updates/2017/06/headless-karma-mocha-chai
|
如果你想使用 Headless Chrome 进行自动化测试，那么就往下！这篇文章将让你完全使用 Karma 作为运行器（runner），并且使用 Mocha+Chai 来编撰测试。
|
/data/attachment/album/201709/12/150805oxtnywgwkgwct55k.png.thumb.jpg
|
/data/attachment/album/201709/12/150805oxtnywgwkgwct55k.png
| true | false | true |
firmianay
| false |
[
"Chrome",
"Headless"
] |
软件开发
|
{
"viewnum": 5283,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8850,
"displayorder": 0
}
] |
如果你想使用 Headless Chrome 进行自动化测试，那么就往下！这篇文章将让你完全使用 Karma 作为运行器（runner），并且使用 Mocha+Chai 来编撰测试。
| 2017-09-12T15:08:00 | 2017-09-12T15:08:00 | 8,861 |
/article-8861-1.html
|
如果你想使用 Headless Chrome 进行自动化测试，那么就往下！这篇文章将让你完全使用 Karma 作为<ruby> 运行器 <rt> runner </rt></ruby>，并且使用 Mocha+Chai 来编撰测试。
**这些东西是什么？**
Karma、Mocha、Chai、Headless Chrome，哦，我的天哪！
[Karma](https://karma-runner.github.io/) 是一个测试工具，可以和所有最流行的测试框架（[Jasmine](https://jasmine.github.io/)、[Mocha](https://mochajs.org/)、 [QUnit](https://qunitjs.com/)）配合使用。
[Chai](http://chaijs.com/) 是一个断言库，可以与 Node 和浏览器一起使用。这里我们需要后者。
[Headless Chrome](https://developers.google.com/web/updates/2017/04/headless-chrome) 是一种在没有浏览器用户界面的无需显示环境中运行 Chrome 浏览器的方法。使用 Headless Chrome（而不是直接在 Node 中测试） 的一个好处是 JavaScript 测试将在与你的网站用户相同的环境中执行。Headless Chrome 为你提供了真正的浏览器环境，却没有运行完整版本的 Chrome 一样的内存开销。
### 设置
#### 安装
使用 `yarn` 安装 Karma、相关插件和测试用例：
```
yarn add --dev karma karma-chrome-launcher karma-mocha karma-chai
yarn add --dev mocha chai
```
或者使用 `npm`：
```
npm i --save-dev karma karma-chrome-launcher karma-mocha karma-chai
npm i --save-dev mocha chai
```
在这篇文章中我使用 [Mocha](https://mochajs.org/) 和 [Chai](http://chaijs.com/)，但是你也可以选择自己最喜欢的在浏览器中工作的断言库。
#### 配置 Karma
创建一个使用 `ChromeHeadless` 启动器的 `karma.config.js` 文件。
**karma.conf.js**：
```
module.exports = function(config) {
config.set({
frameworks: ['mocha', 'chai'],
files: ['test/**/*.js'],
reporters: ['progress'],
port: 9876, // karma web server port
colors: true,
logLevel: config.LOG_INFO,
browsers: ['ChromeHeadless'],
autoWatch: false,
// singleRun: false, // Karma captures browsers, runs the tests and exits
concurrency: Infinity
})
}
```
>
> **注意：** 运行 `./node_modules/karma/bin/karma init karma.conf.js` 生成 Karma 的配置文件。
>
>
>
### 写一个测试
在 `/test/test.js` 中写一个测试：
**/test/test.js**：
```
describe('Array', () => {
describe('#indexOf()', () => {
it('should return -1 when the value is not present', () => {
assert.equal(-1, [1,2,3].indexOf(4));
});
});
});
```
### 运行你的测试
在我们设置好用于运行 Karma 的 `package.json` 中添加一个测试脚本。
**package.json**：
```
"scripts": {
"test": "karma start --single-run --browsers ChromeHeadless karma.conf.js"
}
```
当你运行你的测试（`yarn test`）时，Headless Chrome 会启动并将运行结果输出到终端：
### 创建你自己的 Headless Chrome 启动器
`ChromeHeadless` 启动器非常棒，因为它可以在 Headless Chrome 上进行测试。它包含了适合你的 Chrome 标志，并在端口 `9222` 上启动 Chrome 的远程调试版本。
但是，有时你可能希望将自定义的标志传递给 Chrome 或更改启动器使用的远程调试端口。要做到这一点，可以通过创建一个 `customLaunchers` 字段来扩展基础的 `ChromeHeadless` 启动器：
**karma.conf.js**：
```
module.exports = function(config) {
...
config.set({
browsers: ['Chrome', 'ChromeHeadless', 'MyHeadlessChrome'],
customLaunchers: {
MyHeadlessChrome: {
base: 'ChromeHeadless',
flags: ['--disable-translate', '--disable-extensions', '--remote-debugging-port=9223']
}
},
}
};
```
### 完全在 Travis CI 上运行它
在 Headless Chrome 中配置 Karma 运行测试是很困难的。而在 Travis 中持续集成就只有几种！
要在 Travis 中运行测试，请使用 `dist: trusty` 并安装稳定版 Chrome 插件：
**.travis.yml**：
```
language: node_js
node_js:
- "7"
dist: trusty # needs Ubuntu Trusty
sudo: false # no need for virtualization.
addons:
chrome: stable # have Travis install chrome stable.
cache:
yarn: true
directories:
- node_modules
install:
- yarn
script:
- yarn test
```
---
作者简介
[Eric Bidelman](https://developers.google.com/web/resources/contributors#ericbidelman) 谷歌工程师，Lighthouse 开发，Web 和 Web 组件开发，Chrome 开发
---
via: <https://developers.google.com/web/updates/2017/06/headless-karma-mocha-chai>
作者：[Eric Bidelman](https://developers.google.com/web/resources/contributors#ericbidelman) 译者：[firmianay](https://github.com/firmianay) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 OctoDNS 启用 DNS 分割权威
|
Ross Mcfarland
|
https://githubengineering.com/enabling-split-authority-dns-with-octodns/
|
大型 DNS 提供商在其服务中构建了多级冗余，出现导致中断的问题时，可以采取措施来减轻其影响。最佳选择之一是把你的区域的权威服务分割到多个服务提供商中。
|
/data/attachment/album/201709/12/231245jt2b2w77x0z8in21.png.thumb.jpg
|
/data/attachment/album/201709/12/231245jt2b2w77x0z8in21.png
| true | false | true |
geekpi
| false |
[
"DNS",
"GItHub"
] |
系统运维
|
{
"viewnum": 4595,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
大型 DNS 提供商在其服务中构建了多级冗余，出现导致中断的问题时，可以采取措施来减轻其影响。最佳选择之一是把你的区域的权威服务分割到多个服务提供商中。
| 2017-09-13T08:11:00 | 2017-09-13T08:11:00 | 8,863 |
/article-8863-1.html
|
构建一个健壮的系统需要为故障而设计。作为 GitHub 的网站可靠性工程师（SRE），我们一直在寻求通过冗余来帮助缓解问题，今天将讨论最近我们所做的工作，以便支持你通过 DNS 来查找我们的服务器。
大型 [DNS](https://en.wikipedia.org/wiki/Domain_Name_System) 提供商在其服务中构建了多级冗余，出现导致中断的问题时，可以采取措施来减轻其影响。最佳选择之一是把你的<ruby> 区域 <rt> zone </rt></ruby>的权威服务分割到多个服务提供商中。启用<ruby> 分割权威 <rt> split authority </rt></ruby>很简单，你只需在域名注册商配置两套或多套你区域的[名称服务器](https://en.wikipedia.org/wiki/Name_server)，然后 DNS 请求将分割到整个列表中。但是，你必须在多个提供商之间对这些区域的记录保持同步，并且，根据具体情况这可能要么设置复杂，要么是完全手动的过程。
```
$ dig NS github.com. @a.gtld-servers.net.
...
;; QUESTION SECTION:
;github.com. IN NS
;; AUTHORITY SECTION:
github.com. 172800 IN NS ns4.p16.dynect.net.
github.com. 172800 IN NS ns-520.awsdns-01.net.
github.com. 172800 IN NS ns1.p16.dynect.net.
github.com. 172800 IN NS ns3.p16.dynect.net.
github.com. 172800 IN NS ns-421.awsdns-52.com.
github.com. 172800 IN NS ns-1283.awsdns-32.org.
github.com. 172800 IN NS ns2.p16.dynect.net.
github.com. 172800 IN NS ns-1707.awsdns-21.co.uk.
...
```
上面的查询是向 [TLD 名称服务器](https://en.wikipedia.org/wiki/Top-level_domain) 询问 `github.com.` 的 `NS` 记录。它返回了在我们在域名注册商中配置的值，在本例中，一共有两个 DNS 服务提供商，每个四条记录。如果其中一个提供商发生中断，那么其它的仍有希望可以服务请求。我们在各个地方同步记录，并且可以安全地修改它们，而不必担心数据陈旧或状态不正确。
完整地配置分割权威的最后一部分是在两个 DNS 服务提供商中将所有名称服务器作为顶层 `NS` 记录添加到区域的根中。
```
$ dig NS github.com. @ns1.p16.dynect.net.
...
;; QUESTION SECTION:
;github.com. IN NS
;; ANSWER SECTION:
github.com. 551 IN NS ns1.p16.dynect.net.
github.com. 551 IN NS ns2.p16.dynect.net.
github.com. 551 IN NS ns-520.awsdns-01.net.
github.com. 551 IN NS ns3.p16.dynect.net.
github.com. 551 IN NS ns-421.awsdns-52.com.
github.com. 551 IN NS ns4.p16.dynect.net.
github.com. 551 IN NS ns-1283.awsdns-32.org.
github.com. 551 IN NS ns-1707.awsdns-21.co.uk.
```
在 GitHub，我们有几十个区域和数千条记录，而大多数这些区域并没有关键到需要冗余，因此我们只需要处理一部分。我们希望有能够在多个 DNS 服务提供商中保持这些记录同步的方案，并且更一般地管理内部和外部的所有 DNS 记录。所以今天我们宣布了 [OctoDNS](https://github.com/github/octodns/)。
### 配置
OctoDNS 能够让我们重新打造我们的 DNS 工作流程。我们的区域和记录存储在 Git 仓库的配置文件中。对它们的变更使用 [GitHub 流](https://guides.github.com/introduction/flow/)，并[像个站点一样用分支部署](https://githubengineering.com/deploying-branches-to-github-com/)。我们甚至可以做个 “空” 部署来预览哪些记录将在变更中修改。配置文件是 yaml 字典，每个区域一个，它的顶层的键名是记录名称，键值是 ttl、类型和类型特定的数据。例如，当包含在区域文件 `github.com.yaml` 中时，以下配置将创建 `octodns.github.com.` 的 `A` 记录。
```
octodns:
type: A
values:
- 1.2.3.4
- 1.2.3.5
```
配置的第二部分将记录数据的源映射到 DNS 服务提供商。下面的代码片段告诉 OctoDNS 从 `config` 提供程序加载区域 `github.com`，并将其结果同步到 `dyn` 和 `route53`。
```
zones:
github.com.:
sources:
- config
targets:
- dyn
- route53
```
### 同步
一旦我们的配置完成，OctoDNS 就可以评估当前的状态，并建立一个计划，其中列出将需要将目标状态与源相匹配的一组更改。在下面的例子中，`octodns.github.com` 是一个新的记录，所以所需的操作是在两者中创建记录。
```
$ octodns-sync --config-file=./config/production.yaml
...
********************************************************************************
* github.com.
********************************************************************************
* route53 (Route53Provider)
* Create <ARecord A 60, octodns.github.com., [u'1.2.3.4', '1.2.3.5']>
* Summary: Creates=1, Updates=0, Deletes=0, Existing Records=0
* dyn (DynProvider)
* Create <ARecord A 60, octodns.github.com., [u'1.2.3.4', '1.2.3.5']>
* Summary: Creates=1, Updates=0, Deletes=0, Existing Records=0
********************************************************************************
...
```
默认情况下 `octodns-sync` 处于模拟运行模式，因此不会采取任何行动。一旦我们审阅了变更，并对它们感到满意，我们可以添加 `--doit' 标志并再次运行命令。OctoDNS 将继续它的处理流程，这一次将在 Route53 和 Dynect 中进行必要的更改，以便创建新的记录。
```
$ octodns-sync --config-file=./config/production.yaml --doit
...
```
此刻，在两个 DNS 服务提供商里我们有了相同的数据记录，并可以轻松地分割我们的 DNS 请求给它们，并知道它们将提供准确的结果。当我们直接运行上面的 OctoDNS 命令时，我们的内部工作流程依赖于部署脚本和 chatops。你可以在 [README 的工作流程部分](https://github.com/github/octodns#workflow)中找到更多信息。
### 总结
我们认为大多数网站可以从分割权威中受益，并且希望用 [OctoDNS](https://github.com/github/octodns/)，其中最大的障碍已被扫除。即使对分割权威不感兴趣，OctoDNS 仍然值得一看，因为它将[基础设施即代码](https://en.wikipedia.org/wiki/Infrastructure_as_Code)的好处带给了 DNS。
想帮助 GitHub SRE 团队解决有趣的问题吗？我们很乐意加入我们。[在这里申请](https://boards.greenhouse.io/github/jobs/669805#.WPVqJlPyvUI)。
---
via: <https://githubengineering.com/enabling-split-authority-dns-with-octodns/>
作者：[Ross McFarland](https://github.com/ross) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Stack Overflow 报告：Python 正在令人难以置信地增长！
|
David Robinson
|
https://stackoverflow.blog/2017/09/06/incredible-growth-python/
|
就高收入国家而言，Python 的增长甚至要比 Stack Overflow Trends 等工具展现的或其他针对全球的软件开发的排名更高。
|
/data/attachment/album/201709/13/121049sgsq6s2tzt6sugow.jpg.thumb.jpg
|
/data/attachment/album/201709/13/121049sgsq6s2tzt6sugow.jpg
| true | false | true |
geekpi
| false |
[
"Python"
] |
观点
|
{
"viewnum": 6103,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "183.212.178.136",
"message": "为何C++和Java的增长这么有规律，一年一个周期，其他的就没有呢？",
"username": "来自江苏南京的 Chrome 63.0|GNU/Linux 用户",
"date": "2017-09-14T22:58:51"
},
{
"postip": "36.5.50.189",
"message": "实在是不喜欢python的代码缩进方式, 打开原文件动都不敢动一下,生怕哪里多缩进了一点",
"username": "来自安徽合肥的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-09-25T20:46:07"
}
] |
[] |
就高收入国家而言，Python 的增长甚至要比 Stack Overflow Trends 等工具展现的或其他针对全球的软件开发的排名更高。
| 2017-09-13T12:11:07 | 2017-09-13T12:11:07 | 8,865 |
/article-8865-1.html
|
我们[最近探讨](https://stackoverflow.blog/2017/08/29/tale-two-industries-programming-languages-differ-wealthy-developing-countries/?utm_source=so-owned&utm_medium=blog&utm_campaign=gen-blog&utm_content=blog-link&utm_term=incredible-growth-python)了那些世界银行定义为[高收入](https://en.wikipedia.org/wiki/World_Bank_high-income_economy)的富裕国家是如何倾向于使用与世界上其它地区不同的技术。这其中我们看到的最大的差异在于 Python 编程语言。就高收入国家而言，Python 的增长甚至要比 [Stack Overflow Trends](https://insights.stackoverflow.com/trends?tags=python%2Cjavascript%2Cjava%2Cc%23%2Cphp%2Cc%2B%2B&utm_source=so-owned&utm_medium=blog&utm_campaign=gen-blog&utm_content=blog-link&utm_term=incredible-growth-python) 等工具展现的或其他针对全球的软件开发的排名更高。
在本文中，我们将探讨在过去五年中 Python 编程语言的非凡增长，就如在高收入国家的 Stack Overflow 流量所示那样。“增长最快”一词[很难准确定义](https://xkcd.com/1102/)，但是我们认为 Python 确实可以称得上增长最快的主流编程语言。
这篇文章中讨论的所有数字都是针对高收入国家的。它们一般指的是美国、英国、德国、加拿大等国家的趋势，他们加起来占了 Stack Overflow 大约 64％ 的流量。许多其他国家，如印度、巴西、俄罗斯和中国，也为全球软件开发生态系统做出了巨大贡献，尽管我们也将看到 Python 在这方面有所增长，但本文对这些经济体的描述较少。
值得强调的是，一种语言的用户数量并不能衡量语言的品质：我们是在*描述*开发人员使用的语言，但没有规定任何东西。（完全披露：我[曾经](https://stackoverflow.com/search?tab=newest&q=user%3a712603%20%5bpython%5d)主要使用 Python 编程，尽管我已经完全切换到 R 了）。
### Python 在高收入国家的增长
你可以在 [Stack Overflow Trends](https://insights.stackoverflow.com/trends?tags=python%2Cjavascript%2Cjava%2Cc%23%2Cphp%2Cc%2B%2B&utm_source=so-owned&utm_medium=blog&utm_campaign=gen-blog&utm_content=blog-link&utm_term=incredible-growth-python) 中看到，Python 在过去几年中一直在快速增长。但是对于本文，我们将重点关注高收入国家，考虑的是问题的浏览量而不是提出的问题数量（这基本上结果是类似的，但是每个月都有所波动，特别是对于较小的标签分类）。
我们有关于 Stack Overflow 问题的查看数据可以追溯到 2011 年底，在这段时间内，我们可以研究下 Python 相对于其他五种主要编程语言的增长。（请注意，这比 Stack Overflow Trends 的时间范围更短，它可追溯到 2008 年）。这些目前是高收入国家里十大访问最高的 Stack Overflow 标签中的六个。我们没有包括的四个是 CSS、HTML、Android 和 JQuery。
2017 年 6 月，Python 是成为高收入国家里 Stack Overflow 访问量最高的标签的第一个月。这也是美国和英国最受欢迎的标签，以及几乎所有其他高收入国家的前两名（接着就是 Java 或 JavaScript）。这是特别令人印象深刻的，因为在 2012 年，它比其他 5 种语言的访问量小，比当时增长了 2.5 倍。
部分原因是因为 Java 流量的季节性。由于它[在本科课程中有很多课程](https://stackoverflow.blog/2017/02/15/how-do-students-use-stack-overflow/)，Java 流量在秋季和春季会上升，夏季则下降。到年底，它会再次赶上 Python 吗？我们可以尝试用一个叫做 [“STL” 的模型](http://otexts.org/fpp2/sec-6-stl.html)来预测未来两年的增长, 它将增长与季节性趋势结合起来，来预测将来的变化。
根据这个模型，Python 可能会在秋季保持领先地位或被 Java 取代（大致在模型预测的变化范围之内），但是 Python 显然会在 2018 年成为浏览最多的标签。STL 还表明，与过去两年一样，JavaScript 和 Java 在高收入国家中的流量水平将保持相似水平。
### 什么标签整体上增长最快？
上面只看了六个最受欢迎的编程语言。在其他重大技术中，哪些是目前在高收入国家中增长最快的技术？
我们以 2017 年至 2016 年流量的比例来定义增长率。在此分析中，我们决定仅考虑编程语言（如 Java 和 Python）和平台（如 iOS、Android、Windows 和 Linux），而不考虑像 [Angular](https://stackoverflow.com/questions/tagged/angular) 或 [TensorFlow](https://stackoverflow.com/questions/tagged/tensorflow) 这样的框架（虽然其中许多有显著的增长，可能在未来的文章中分析）。
由于上面[这个漫画](https://xkcd.com/1102/)中所描述的“最快增长”定义的激励，我们将增长与[平均差异图](https://en.wikipedia.org/wiki/Bland%E2%80%93Altman_plot)中的整体平均值进行比较。
Python 以 27％ 的年增长率成为了规模大、增长快的标签。下一个类似增长的最大标签是 R。我们看到，大多数其他大型标签的流量在高收入国家中保持稳定，浏览 Android、iOS 和 PHP 则略有下降。我们以前在 [Flash 之死这篇文章](https://stackoverflow.blog/2017/08/01/flash-dead-technologies-might-next/?utm_source=so-owned&utm_medium=blog&utm_campaign=gen-blog&utm_content=blog-link&utm_term=incredible-growth-python)中审查过一些正在衰减的标签，如 Objective-C、Perl 和 Ruby。我们还注意到，在函数式编程语言中，Scala 是最大的并且不断增长的，而 F# 和 Clojure 较小并且正在衰减，Haskell 则保持稳定。
上面的图表中有一个重要的遗漏：去年，有关 TypeScript 的问题流量增长了惊人的 142％，这使得我们需要去除它以避免压扁比例尺。你还可以看到，其他一些较小的语言的增长速度与 Python 类似或更快（例如 R、Go 和 Rust），而且还有许多标签，如 Swift 和 Scala，这些标签也显示出惊人的增长。它们随着时间的流量相比 Python 如何？
像 R 和 Swift 这样的语言的发展确实令人印象深刻，而 TypeScript 在更短的时间内显示出特别快速的扩张。这些较小的语言中，有许多从很少的流量成为软件生态系统中引人注目的存在。但是如图所示，当标签开始相对较小时，显示出快速增长更容易。
请注意，我们并不是说这些语言与 Python “竞争”。相反，这只是解释了为什么我们要把它们的增长分成一个单独的类别，这些是始于较低流量的标签。Python 是一个不寻常的案例，**既是 Stack Overflow 中最受欢迎的标签之一，也是增长最快的其中之一**。（顺便说一下，它也在加速！自 2013 年以来，每年的增长速度都会更快）。
### 世界其他地区
在这篇文章中，我们一直在分析高收入国家的趋势。Python 在世界其他地区，如印度、巴西、俄罗斯和中国等国家的增长情况是否类似？
确实如此。
在高收入国家之外，Python *仍旧*是增长最快的主要编程语言。它从较低的水平开始，两年后才开始增长（2014 年而不是 2012 年）。事实上，非高收入国家的 Python 同比增长率高于高收入国家。我们不会在这里研究它，但是 R （[其它语言的使用与 GDP 正相关](https://stackoverflow.blog/2017/08/29/tale-two-industries-programming-languages-differ-wealthy-developing-countries/?utm_source=so-owned&utm_medium=blog&utm_campaign=gen-blog&utm_content=blog-link&utm_term=incredible-growth-python)） 在这些国家也在增长。
在这篇文章中，许多关于高收入国家标签 (相对于绝对排名) 的增长和下降的结论，对世界其他地区都是正确的。两个部分增长率之间有一个 0.979 Spearman 相关性。在某些情况下，你可以看到类似于 Python 上发生的 “滞后” 现象，其中一个技术在高收入国家被广泛采用，一年或两年才能在世界其他地区扩大。（这是一个有趣的现象，这可能是未来文章的主题！）
### 下一次
我们不打算为任何“语言战争”提供弹药。一种语言的用户数量并不意味着它的质量，而且肯定不会让你知道哪种语言[更适合某种特定情况](https://stackoverflow.blog/2011/08/16/gorilla-vs-shark/?utm_source=so-owned&utm_medium=blog&utm_campaign=gen-blog&utm_content=blog-link&utm_term=incredible-growth-python)。不过，考虑到这点，我们认为值得了解什么语言构成了开发者生态系统，以及生态系统会如何变化。
本文表明 Python 在过去五年中，特别是在高收入国家，显示出惊人的增长。在我们的下一篇文章中，我们将开始研究*“为什么”*。我们将按国家和行业划分增长情况，并研究有哪些其他技术与 Python 一起使用（例如，估计多少增长是由于 Python 用于 Web 开发而不是数据科学)。
在此期间，如果你使用 Python 工作，并希望你的职业生涯中进入下一阶段，那么[在 Stack Overflow Jobs 上有些公司正在招聘 Python 开发](https://stackoverflow.com/jobs/developer-jobs-using-python?utm_source=so-owned&utm_medium=blog&utm_campaign=gen-blog&utm_content=blog-link&utm_term=incredible-growth-python)。
---
via: <https://stackoverflow.blog/2017/09/06/incredible-growth-python/>
作者：[David Robinson](https://stackoverflow.blog/authors/drobinson/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Docker 和 Kubernetes 将 MongoDB 作为微服务运行
|
Andrew Morgan
|
https://www.mongodb.com/blog/post/running-mongodb-as-a-microservice-with-docker-and-kubernetes
|
想在笔记本电脑上尝试 MongoDB？只需执行一个命令，你就会有一个轻量级的、独立的沙箱。完成后可以删除你所做的所有痕迹。
|
/data/attachment/album/201709/14/101344xin8en5887l55ebl.jpg.thumb.jpg
|
/data/attachment/album/201709/14/101344xin8en5887l55ebl.jpg
| true | false | true |
geekpi
| false |
[
"MongoDB",
"容器",
"Kubernetes"
] |
容器与云
|
{
"viewnum": 7410,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
想在笔记本电脑上尝试 MongoDB？只需执行一个命令，你就会有一个轻量级的、独立的沙箱。完成后可以删除你所做的所有痕迹。
| 2017-09-14T10:15:00 | 2017-09-14T10:15:00 | 8,867 |
/article-8867-1.html
|
### 介绍
想在笔记本电脑上尝试 MongoDB？只需执行一个命令，你就会有一个轻量级的、独立的沙箱。完成后可以删除你所做的所有痕迹。
想在多个环境中使用相同的<ruby> 程序栈 <rt> application stack </rt></ruby>副本？构建你自己的容器镜像，让你的开发、测试、运维和支持团队使用相同的环境克隆。
容器正在彻底改变整个软件生命周期：从最早的技术性实验和概念证明，贯穿了开发、测试、部署和支持。
编排工具用来管理如何创建、升级多个容器，并使之高可用。编排还控制容器如何连接，以从多个微服务容器构建复杂的应用程序。
丰富的功能、简单的工具和强大的 API 使容器和编排功能成为 DevOps 团队的首选，将其集成到连续集成（CI） 和连续交付 （CD） 的工作流程中。
这篇文章探讨了在容器中运行和编排 MongoDB 时遇到的额外挑战，并说明了如何克服这些挑战。
### MongoDB 的注意事项
使用容器和编排运行 MongoDB 有一些额外的注意事项：
* MongoDB 数据库节点是有状态的。如果容器发生故障并被重新编排，数据则会丢失（能够从副本集的其他节点恢复，但这需要时间），这是不合需要的。为了解决这个问题，可以使用诸如 Kubernetes 中的<ruby> 数据卷 <rt> volume </rt></ruby> 抽象等功能来将容器中临时的 MongoDB 数据目录映射到持久位置，以便数据在容器故障和重新编排过程中存留。
* 一个副本集中的 MongoDB 数据库节点必须能够相互通信 - 包括重新编排后。副本集中的所有节点必须知道其所有对等节点的地址，但是当重新编排容器时，可能会使用不同的 IP 地址重新启动。例如，Kubernetes Pod 中的所有容器共享一个 IP 地址，当重新编排 pod 时，IP 地址会发生变化。使用 Kubernetes，可以通过将 Kubernetes 服务与每个 MongoDB 节点相关联来处理，该节点使用 Kubernetes DNS 服务提供“主机名”，以保持服务在重新编排中保持不变。
* 一旦每个单独的 MongoDB 节点运行起来（每个都在自己的容器中），则必须初始化副本集，并添加每个节点到其中。这可能需要在编排工具之外提供一些额外的处理。具体来说，必须使用目标副本集中的一个 MongoDB 节点来执行 `rs.initiate` 和 `rs.add` 命令。
* 如果编排框架提供了容器的自动化重新编排（如 Kubernetes），那么这将增加 MongoDB 的弹性，因为这可以自动重新创建失败的副本集成员，从而在没有人为干预的情况下恢复完全的冗余级别。
* 应该注意的是，虽然编排框架可能监控容器的状态，但是不太可能监视容器内运行的应用程序或备份其数据。这意味着使用 [MongoDB Enterprise Advanced](https://www.mongodb.com/products/mongodb-enterprise-advanced) 和 [MongoDB Professional](https://www.mongodb.com/products/mongodb-professional) 中包含的 [MongoDB Cloud Manager](https://www.mongodb.com/cloud/) 等强大的监控和备份解决方案非常重要。可以考虑创建自己的镜像，其中包含你首选的 MongoDB 版本和 [MongoDB Automation Agent](https://docs.cloud.mongodb.com/tutorial/nav/install-automation-agent/)。
### 使用 Docker 和 Kubernetes 实现 MongoDB 副本集
如上节所述，分布式数据库（如 MongoDB）在使用编排框架（如 Kubernetes）进行部署时，需要稍加注意。本节将介绍详细介绍如何实现。
我们首先在单个 Kubernetes 集群中创建整个 MongoDB 副本集（通常在一个数据中心内，这显然不能提供地理冗余）。实际上，很少有必要改变成跨多个集群运行，这些步骤将在后面描述。
副本集的每个成员将作为自己的 pod 运行，并提供一个公开 IP 地址和端口的服务。这个“固定”的 IP 地址非常重要，因为外部应用程序和其他副本集成员都可以依赖于它在重新编排 pod 的情况下保持不变。
下图说明了其中一个 pod 以及相关的复制控制器和服务。
*图 1：MongoDB 副本集成员被配置为 Kubernetes Pod 并作为服务公开*
逐步介绍该配置中描述的资源：
* 从核心开始，有一个名为 `mongo-node1` 的容器。`mongo-node1` 包含一个名为 `mongo` 的镜像，这是一个在 [Docker Hub](https://hub.docker.com/_/mongo/) 上托管的一个公开可用的 MongoDB 容器镜像。容器在集群中暴露端口 `27107`。
* Kubernetes 的数据卷功能用于将连接器中的 `/data/db` 目录映射到名为 `mongo-persistent-storage1` 的永久存储上，这又被映射到在 Google Cloud 中创建的名为 `mongodb-disk1` 的磁盘中。这是 MongoDB 存储其数据的地方，这样它可以在容器重新编排后保留。
* 容器保存在一个 pod 中，该 pod 中有标签命名为 `mongo-node`，并提供一个名为 `rod` 的（任意）示例。
* 配置 `mongo-node1` 复制控制器以确保 `mongo-node1` pod 的单个实例始终运行。
* 名为 `mongo-svc-a` 的 `负载均衡` 服务给外部开放了一个 IP 地址以及 `27017` 端口，它被映射到容器相同的端口号上。该服务使用选择器来匹配 pod 标签来确定正确的 pod。外部 IP 地址和端口将用于应用程序以及副本集成员之间的通信。每个容器也有本地 IP 地址，但是当容器移动或重新启动时，这些 IP 地址会变化，因此不会用于副本集。
下一个图显示了副本集的第二个成员的配置。
*图 2：第二个 MongoDB 副本集成员配置为 Kubernetes Pod*
90％ 的配置是一样的，只有这些变化：
* 磁盘和卷名必须是唯一的，因此使用的是 `mongodb-disk2` 和 `mongo-persistent-storage2`
* Pod 被分配了一个 `instance: jane` 和 `name: mongo-node2` 的标签，以便新的服务可以使用选择器与图 1 所示的 `rod` Pod 相区分。
* 复制控制器命名为 `mongo-rc2`
* 该服务名为`mongo-svc-b`，并获得了一个唯一的外部 IP 地址（在这种情况下，Kubernetes 分配了 `104.1.4.5`）
第三个副本成员的配置遵循相同的模式，下图展示了完整的副本集：
*图 3：配置为 Kubernetes 服务的完整副本集成员*
请注意，即使在三个或更多节点的 Kubernetes 群集上运行图 3 所示的配置，Kubernetes 可能（并且经常会）在同一主机上编排两个或多个 MongoDB 副本集成员。这是因为 Kubernetes 将三个 pod 视为属于三个独立的服务。
为了在区域内增加冗余，可以创建一个附加的 *headless* 服务。新服务不向外界提供任何功能（甚至不会有 IP 地址），但是它可以让 Kubernetes 通知三个 MongoDB pod 形成一个服务，所以 Kubernetes 会尝试在不同的节点上编排它们。
*图 4：避免同一 MongoDB 副本集成员的 Headless 服务*
配置和启动 MongoDB 副本集所需的实际配置文件和命令可以在白皮书《[启用微服务：阐述容器和编排](https://www.mongodb.com/collateral/microservices-containers-and-orchestration-explained)》中找到。特别的是，需要一些本文中描述的特殊步骤来将三个 MongoDB 实例组合成具备功能的、健壮的副本集。
#### 多个可用区 MongoDB 副本集
上面创建的副本集存在风险，因为所有内容都在相同的 GCE 集群中运行，因此都在相同的<ruby> 可用区 <rt> availability zone </rt></ruby>中。如果有一个重大事件使可用区离线，那么 MongoDB 副本集将不可用。如果需要地理冗余，则三个 pod 应该在三个不同的可用区或地区中运行。
令人惊奇的是，为了创建在三个区域之间分割的类似的副本集（需要三个集群），几乎不需要改变。每个集群都需要自己的 Kubernetes YAML 文件，该文件仅为该副本集中的一个成员定义了 pod、复制控制器和服务。那么为每个区域创建一个集群，永久存储和 MongoDB 节点是一件很简单的事情。
*图 5：在多个可用区域上运行的副本集*
### 下一步
要了解有关容器和编排的更多信息 - 所涉及的技术和所提供的业务优势 - 请阅读白皮书《[启用微服务：阐述容器和编排](https://www.mongodb.com/collateral/microservices-containers-and-orchestration-explained)》。该文件提供了获取本文中描述的副本集，并在 Google Container Engine 中的 Docker 和 Kubernetes 上运行的完整的说明。
---
作者简介：
Andrew 是 MongoDB 的产品营销总经理。他在去年夏天离开 Oracle 加入 MongoDB，在 Oracle 他花了 6 年多的时间在产品管理上，专注于高可用性。他可以通过 @andrewmorgan 或者在他的博客（clusterdb.com）评论联系他。
---
via: <https://www.mongodb.com/blog/post/running-mongodb-as-a-microservice-with-docker-and-kubernetes>
作者：[Andrew Morgan](http://www.clusterdb.com/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Sublime Text 3.0 正式发布！提供 Linux 软件包仓库支持
|
老王
|
与上一个 beta 版本相比，3.0 带来了崭新的 UI 主题，新的颜色主题以及新的图标。此外，在格式高亮方面有较大改进，也支持 Windows 上的触摸板输入、支持 macOS 的 Touch Bar，以及为 Linux 提供了软件包仓库支持！
|
/data/attachment/album/201709/14/110645ssn4ahv25mcv57vc.png.thumb.jpg
|
/data/attachment/album/201709/14/110645ssn4ahv25mcv57vc.png
| true | false | false | false |
[
"SublimeText"
] |
新闻
|
{
"viewnum": 9434,
"commentnum": 9,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "219.239.24.85",
"message": "VS CODE免费",
"username": "拿铁不加糖 [Chrome 61.0|Windows 10]",
"date": "2017-09-14T13:20:23"
},
{
"postip": "113.46.59.240",
"message": "已叛逃到VsCode，不得不说微软的编辑器还是很良心的。",
"username": "枫落夜舞 [Chrome 61.0|Mac 10.12]",
"date": "2017-09-14T21:08:34"
},
{
"postip": "58.49.103.186",
"message": "单个授权80$还是很贵的，支持Sublime。但我真的买不起，Vim路过。",
"username": "来自湖北武汉的 Firefox 55.0|Windows 7 用户",
"date": "2017-09-14T21:28:56"
},
{
"postip": "14.130.112.50",
"message": "感谢开发者，但我用的是其他的。",
"username": "小刀弯弯 [Firefox 52.0|GNU/Linux]",
"date": "2017-09-15T10:56:34"
},
{
"postip": "124.204.47.66",
"message": "Linux下依旧不支持中文",
"username": "来自北京的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-15T14:25:41"
},
{
"postip": "125.84.1.17",
"message": "arch里面不过是stable还是Dev都还是2.几",
"username": "龙尘飘 [Firefox 55.0|GNU/Linux]",
"date": "2017-09-15T23:32:47"
},
{
"postip": "49.77.133.15",
"message": "干嘛不用开源的编辑器VSCODE、ATOM",
"username": "来自江苏南京的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-21T10:25:27"
},
{
"postip": "101.45.140.185",
"message": "linux平台不支持中文，说个几把",
"username": "来自上海的 Chrome 61.0|Windows 10 用户",
"date": "2017-09-25T08:47:51"
},
{
"postip": "218.4.110.82",
"message": "linux平台不支持中文？你是猴子派来的吧",
"username": "来自江苏苏州的 Chrome 61.0|Windows 7 用户",
"date": "2017-09-29T16:42:25"
}
] |
[] |
与上一个 beta 版本相比，3.0 带来了崭新的 UI 主题，新的颜色主题以及新的图标。此外，在格式高亮方面有较大改进，也支持 Windows 上的触摸板输入、支持 macOS 的 Touch Bar，以及为 Linux 提供了软件包仓库支持！
| 2017-09-14T11:04:00 | 2017-09-14T11:04:00 | 8,868 |
/article-8868-1.html
|
历经了 4 年半的开发，著名的 Sublime Text 编辑器的作者 Jon Skinner 宣布：**[Sublime Text 3.0](https://www.sublimetext.com/3) 正式版终于发布了！**
与上一个 beta 版本相比，3.0 带来了崭新的 UI 主题，新的颜色主题以及新的图标。此外，在格式高亮方面有较大改进，也支持 Windows 上的触摸板输入、支持 macOS 的 Touch Bar，以及为 Linux 提供了软件包仓库支持！
相对于 Sublime Text 2 而言，几乎在这个编辑器的每一个方面都有所变化，所以即便是主要变更列表也显得太长了，具体你可以关注下[这个页面](https://www.sublimetext.com/2to3)，希望你有耐心读完。
在 3.0 当中一些大的功能有：定义跳转、新的格式高亮引擎、新的用户界面和丰富的 API。在数百个改进当中，拼写检查得到了改进，自动缩进也更完善，自动换行能也更好的处理源代码，对高分屏支持更好，任意跳转也更加智能。
在 Sublime Text 3 中最令人骄傲的一点是性能：它比历史上发布过的任何一个 Sublime Text 2 版本都要快得多，启动快、打开文件快、甚至内容滚动都快。虽然它的体积比 2 要大，但是却更轻快。
### 下载地址
* [OS X](https://download.sublimetext.com/Sublime%20Text%20Build%203143.dmg) （要求 10.7 及以上）
* [Windows](https://download.sublimetext.com/Sublime%20Text%20Build%203143%20Setup.exe)，也提供[便携版](https://download.sublimetext.com/Sublime%20Text%20Build%203143.zip)
* [Windows 64 bit](https://download.sublimetext.com/Sublime%20Text%20Build%203143%20x64%20Setup.exe)，也提供[便携版](https://download.sublimetext.com/Sublime%20Text%20Build%203143%20x64.zip)
* [Linux 软件仓库](https://www.sublimetext.com/docs/3/linux_repositories.html) 及 [64 位](https://download.sublimetext.com/sublime_text_3_build_3143_x64.tar.bz2) 或 [32 位 tarball](https://download.sublimetext.com/sublime_text_3_build_3143_x32.tar.bz2)
在 Windows 和 OS X 平台上，Sublime Text 3 提供了自动更新机制，而针对 Linux 的各个发行版，Sublime Text 3 提供了软件仓库，通过它支持自动更新。
### 在 Linux 上安装
#### apt
安装 GPG 公钥：
```
wget -qO - https://download.sublimetext.com/sublimehq-pub.gpg | sudo apt-key add -
```
选择使用的频道：
**Stable**
```
echo "deb https://download.sublimetext.com/ apt/stable/" | sudo tee /etc/apt/sources.list.d/sublime-text.list
```
**Dev**
```
echo "deb https://download.sublimetext.com/ apt/dev/" | sudo tee /etc/apt/sources.list.d/sublime-text.list
```
更新 apt 源并安装 Sublime Text：
```
sudo apt-get update
sudo apt-get install sublime-text
```
#### pacman
安装 GPG 公钥：
```
curl -O https://download.sublimetext.com/sublimehq-pub.gpg && sudo pacman-key --add sublimehq-pub.gpg && sudo pacman-key --lsign-key 8A8F901A && rm sublimehq-pub.gpg
```
选择要使用的频道：
**Stable**
```
echo -e "\n[sublime-text]\nServer = https://download.sublimetext.com/arch/stable/x86_64" | sudo tee -a /etc/pacman.conf
```
**Dev**
```
echo -e "\n[sublime-text]\nServer = https://download.sublimetext.com/arch/dev/x86_64" | sudo tee -a /etc/pacman.conf
```
更新 pacman 并安装 Sublime Text：
```
sudo pacman -Syu sublime-text
```
#### yum
安装 GPG 公钥：
```
sudo rpm -v --import https://download.sublimetext.com/sublimehq-rpm-pub.gpg
```
选择要使用的频道：
**Stable**
```
sudo yum-config-manager --add-repo https://download.sublimetext.com/rpm/stable/x86_64/sublime-text.repo
```
**Dev**
```
sudo yum-config-manager --add-repo https://download.sublimetext.com/rpm/dev/x86_64/sublime-text.repo
```
更新 yum 并安装 Sublime Text：
```
sudo yum install sublime-text
```
#### dnf
安装 GPG 公钥：
```
sudo rpm -v --import https://download.sublimetext.com/sublimehq-rpm-pub.gpg
```
选择要使用的频道：
**Stable**
```
sudo dnf config-manager --add-repo https://download.sublimetext.com/rpm/stable/x86_64/sublime-text.repo
```
**Dev**
```
sudo dnf config-manager --add-repo https://download.sublimetext.com/rpm/dev/x86_64/sublime-text.repo
```
更新 dnf 并安装 Sublime Text：
```
sudo dnf install sublime-text
```
#### zypper
安装 GPG 公钥：
```
sudo rpm -v --import https://download.sublimetext.com/sublimehq-rpm-pub.gpg
```
选择要使用的频道：
**Stable**
```
sudo zypper addrepo -g -f https://download.sublimetext.com/rpm/stable/x86_64/sublime-text.repo
```
**Dev**
```
sudo zypper addrepo -g -f https://download.sublimetext.com/rpm/dev/x86_64/sublime-text.repo
```
更新zypper 并安装 Sublime Text：
```
sudo zypper install sublime-text
```
### 购买
需要说明的是，Sublime Text 不是自由软件，也不是免费软件，而是试用软件，虽然你可以一直试用下去，但是其是需要购买的。[单个许可证的费用是 $80 美金](https://www.sublimetext.com/buy?v=3.0)。
|
||||
函数式编程简介
|
Fraser Tweedale
|
https://opensource.com/article/17/4/introduction-functional-programming
|
我们来解释函数式编程的什么，它的优点是哪些，并且给出一些函数式编程的学习资源。
|
/data/attachment/album/201709/15/135403erbbhprllibyy6lr.png.thumb.jpg
|
/data/attachment/album/201709/15/135403erbbhprllibyy6lr.png
| true | false | true |
MonkeyDEcho
| false |
[
"函数式编程",
"Haskell"
] |
软件开发
|
{
"viewnum": 6783,
"commentnum": 5,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.247.6.64",
"message": "一直都不大懂",
"username": "二次元萌控森 [Sogou Explorer 2|Windows 10]",
"date": "2017-09-15T19:03:19"
},
{
"postip": "220.113.126.32",
"message": "函数式编程是所有编程模式的总结，取消一切对象设计，一切简化成过程，然后将所有的过程粘接起来，其实回到了 C 的世界，只不过简化了函数的定义与使用，应该说是取消了函数声明，采用“边写边用”，每一个过程都是匿名引用或显引用，然后在不同的 scope 域串接起来。<br />\r\n<br />\r\n这样的编程方式感觉上莫过于就是 JavaScript 的匿名（或命名） function 套匿名（或命名） function，然后链式、传递调用。<br />\r\n<br />\r\n这样的语言也是有缺陷的，很容易进 callback 坑，所以你看 Ocaml in 回车、然后继续 in 回车，写得像杨辉三角。<br />\r\n<br />\r\n其实 FP 可以认为是语言思想",
"username": "来自北京的 Safari 10.1|Mac 10.12 用户",
"date": "2017-09-16T01:26:08"
},
{
"postip": "220.113.126.32",
"message": "继续上文。。。<br />\r\n<br />\r\n其实 FP 可以认为是语言思想界里的【极简设计】，去掉 OO 臃肿的外壳，只留下它的目标精髓。但是过于骨感其实也不太好，所以我还是倾向于 Swift / Go。",
"username": "来自北京的 Safari 10.1|Mac 10.12 用户",
"date": "2017-09-16T01:27:15"
},
{
"postip": "220.249.72.210",
"message": "没研究过这个编程语言，要是用java示例就好了",
"username": "mistyos [Firefox 55.0|GNU/Linux]",
"date": "2017-09-18T23:07:32"
},
{
"postip": "61.186.31.157",
"message": "很快我们会发一篇用 javascript 来介绍函数式编程的。",
"username": "linux [Chrome 60.0|Mac 10.11]",
"date": "2017-09-19T13:28:40"
}
] |
[
{
"raid": 8992,
"displayorder": 0
}
] |
我们来解释函数式编程的什么，它的优点是哪些，并且给出一些函数式编程的学习资源。
| 2017-09-15T13:53:59 | 2017-09-15T13:53:59 | 8,869 |
/article-8869-1.html
|
>
> 我们来解释函数式编程的什么，它的优点是哪些，并且给出一些函数式编程的学习资源。
>
>
>
这要看您问的是谁， <ruby> 函数式编程 <rt> functional programming </rt></ruby>（FP）要么是一种理念先进的、应该广泛传播的程序设计方法；要么是一种偏学术性的、实际用途不多的编程方式。在这篇文章中我将讲解函数式编程，探究其优点，并推荐学习函数式编程的资源。
### 语法入门
本文的代码示例使用的是 [Haskell](https://wiki.haskell.org/Introduction) 编程语言。在这篇文章中你只需要了解的基本函数语法：
```
even :: Int -> Bool
even = ... -- 具体的实现放在这里
```
上述示例定义了含有一个参数的函数 `even` ，第一行是 *类型声明*，具体来说就是 `even` 函数接受一个 Int 类型的参数，返回一个 Bool 类型的值，其实现跟在后面，由一个或多个等式组成。在这里我们将忽略具体实现方法（名称和类型已经足够了）：
```
map :: (a -> b) -> [a] -> [b]
map = ...
```
这个示例，`map` 是一个有两个参数的函数：
1. `(a -> b)` ：将 `a` 转换成 `b` 的函数
2. `[a]`：一个 `a` 的列表，并返回一个 `b` 的列表。（LCTT 译注： 将函数作用到 `[a]` （List 序列对应于其它语言的数组）的每一个元素上，将每次所得结果放到另一个 `[b]` ，最后返回这个结果 `[b]`。）
同样我们不去关心要如何实现，我们只感兴趣它的定义类型。`a` 和 `b` 是任何一种的的 <ruby> 类型变量 <rt> type variable </rt></ruby> 。就像上一个示例中， `a` 是 `Int` 类型， `b` 是 `Bool` 类型:
```
map even [1,2,3]
```
这个是一个 Bool 类型的序列：
```
[False,True,False]
```
如果你看到你不理解的其他语法，不要惊慌；对语法的充分理解不是必要的。
### 函数式编程的误区
我们先来解释一下常见的误区：
* 函数式编程不是命令行编程或者面向对象编程的竞争对手或对立面，这并不是非此即彼的。
* 函数式编程不仅仅用在学术领域。这是真的，在函数式编程的历史中，如像 Haskell 和 OCaml 语言是最流行的研究语言。但是今天许多公司使用函数式编程来用于大型的系统、小型专业程序，以及种种不同场合。甚至还有一个[面向函数式编程的商业用户[33](http://cufp.org/)的年度会议；以前的那些程序让我们了解了函数式编程在工业中的用途，以及谁在使用它。
* 函数式编程与 [monad](https://www.haskell.org/tutorial/monads.html) 无关 ，也不是任何其他特殊的抽象。在这篇文章里面 monad 只是一个抽象的规定。有些是 monad，有些不是。
* 函数式编程不是特别难学的。某些语言可能与您已经知道的语法或求值语义不同，但这些差异是浅显的。函数式编程中有大量的概念，但其他语言也是如此。
### 什么是函数式编程?
核心是函数式编程是只使用*纯粹*的数学函数编程，函数的结果仅取决于参数，而没有副作用，就像 I/O 或者状态转换这样。程序是通过 <ruby> 组合函数 <rt> function composition </rt></ruby> 的方法构建的：
```
(.) :: (b -> c) -> (a -> b) -> (a -> c)
(g . f) x = g (f x)
```
这个<ruby> 中缀 <rt> infix </rt></ruby>函数 `(.)` 表示的是二个函数组合成一个，将 `g` 作用到 `f` 上。我们将在下一个示例中看到它的使用。作为比较，我们看看在 Python 中同样的函数：
```
def compose(g, f):
return lambda x: g(f(x))
```
函数式编程的优点在于：由于函数是确定的、没有副作用的，所以可以用结果替换函数，这种替代等价于使用使 <ruby> 等式推理 <rt> equational reasoning </rt></ruby> 。每个程序员都有使用自己代码和别人代码的理由，而等式推理就是解决这样问题不错的工具。来看一个示例。等你遇到这个问题：
```
map even . map (+1)
```
这段代码是做什么的？可以简化吗？通过等式推理，可以通过一系列替换来分析代码：
```
map even . map (+1)
map (even . (+1)) -- 来自 'map' 的定义
map (\x -> even (x + 1)) -- lambda 抽象
map odd -- 来自 'even' 的定义
```
我们可以使用等式推理来理解程序并优化可读性。Haskell 编译器使用等式推理进行多种程序优化。没有纯函数，等式推理是不可能的，或者需要程序员付出更多的努力。
### 函数式编程语言
你需要一种编程语言来做函数式编程吗？
在没有<ruby> 高阶函数 <rt> higher-order function </rt></ruby>（传递函数作为参数和返回函数的能力）、lambdas （匿名函数）和<ruby> 泛型 <rt> generics </rt></ruby>的语言中进行有意义的函数式编程是困难的。 大多数现代语言都有这些，但在不同语言中支持函数式编程方面存在差异。 具有最佳支持的语言称为<ruby> 函数式编程语言 <rt> functional programming language </rt></ruby>。 这些包括静态类型的 *Haskell*、*OCaml*、*F#* 和 *Scala* ，以及动态类型的 *Erlang* 和 *Clojure*。
即使是在函数式语言里，可以在多大程度上利用函数编程有很大差异。有一个<ruby> 类型系统 <rt> type system </rt></ruby>会有很大的帮助，特别是它支持 <ruby> 类型推断 <rt> type inference </rt></ruby> 的话（这样你就不用总是必须键入类型）。这篇文章中没有详细介绍这部分，但足以说明，并非所有的类型系统都是平等的。
与所有语言一样，不同的函数的语言强调不同的概念、技术或用例。选择语言时，考虑它支持函数式编程的程度以及是否适合您的用例很重要。如果您使用某些非 FP 语言，你仍然会受益于在该语言支持的范围内的函数式编程。
### 不要打开陷阱之门
回想一下，函数的结果只取决于它的输入。但是，几乎所有的编程语言都有破坏这一原则的“功能”。空值、<ruby> 实例类型 <rt> type case </rt></ruby>（`instanceof`）、类型转换、异常、<ruby> 边际效用 <rt> side-effect </rt></ruby>，以及无尽循环的可能性都是陷阱，它打破等式推理，并削弱程序员对程序行为正确性的理解能力。（所有语言里面，没有任何陷阱的语言包括 Agda、Idris 和 Coq。）
幸运的是，作为程序员，我们可以选择避免这些陷阱，如果我们受到严格的规范，我们可以假装陷阱不存在。 这个方法叫做<ruby> 轻率推理 <rt> fast and loose reasoning </rt></ruby> 。它不需要任何条件，几乎任何程序都可以在不使用陷阱的情况下进行编写，并且通过避免这些可以而获得等式推理、可组合性和可重用性。
让我们详细讨论一下。 这个陷阱破坏了等式推理，因为异常终止的可能性没有反映在类型中。（你可以庆幸文档中甚至没有提到能抛出的异常）。但是没有理由我们没有一个可以包含所有故障模式的返回类型。
避开陷阱是语言特征中出现很大差异的领域。为避免例外， <ruby> 代数数据类型 <rt> algebraic data type </rt></ruby>可用于模型错误的条件下，就像：
```
-- new data type for results of computations that can fail
--
data Result e a = Error e | Success a
-- new data type for three kinds of arithmetic errors
--
data ArithError = DivByZero | Overflow | Underflow
-- integer division, accounting for divide-by-zero
--
safeDiv :: Int -> Int -> Result ArithError Int
safeDiv x y =
if y == 0
then Error DivByZero
else Success (div x y)
```
在这个例子中的权衡你现在必须使用 Result ArithError Int 类型，而不是以前的 Int 类型，但这也是解决这个问题的一种方式。你不再需要处理异常，而能够使用轻率推理 ，总体来说这是一个胜利。
### 自由定理
大多数现代静态类型语言具有<ruby> 范型 <rt> generics </rt></ruby>（也称为<ruby> 参数多态性 <rt> parametric polymorphism </rt></ruby> ），其中函数是通过一个或多个抽象类型定义的。 例如，看看这个 List（序列）函数:
```
f :: [a] -> [a]
f = ...
```
Java 中的相同函数如下所示：
```
static <A> List<A> f(List<A> xs) { ... }
```
该编译的程序证明了这个函数适用于类型 `a` 的*任意*选择。考虑到这一点，采用轻率推理的方法，你能够弄清楚该函数的作用吗？知道类型有什么帮助？
在这种情况下，该类型并不能告诉我们函数的功能（它可以逆转序列、删除第一个元素，或许多其它的操作），但它确实告诉了我们很多信息。只是从该类型，我们可以推演出该函数的定理：
* 定理 1 ：输出中的每个元素也出现于输入中；不可能在输入的序列 `a` 中添加值，因为你不知道 `a` 是什么，也不知道怎么构造一个。
* 定理 2 ：如果你映射某个函数到列表上，然后对其应用 `f`，其等同于对映射应用 `f`。
定理 1 帮助我们了解代码的作用，定理 2 对于程序优化提供了帮助。我们从类型中学到了这一切！其结果，即从类型中获取有用的定理的能力，称之为<ruby> 参数化 <rt> parametricity </rt></ruby>。因此，类型是函数行为的部分（有时是完整的）规范，也是一种机器检查机制。
现在你可以利用参数化了。你可以从 `map` 和 `(.)` 的类型或者下面的这些函数中发现什么呢？
* `foo :: a -> (a, a)`
* `bar :: a -> a -> a`
* `baz :: b -> a -> a`
### 学习功能编程的资源
也许你已经相信函数式编程是编写软件不错的方式，你想知道如何开始？有几种学习功能编程的方法；这里有一些我推荐（我承认，我对 Haskell 偏爱）：
* UPenn 的 [CIS 194: 介绍 Haskell](https://www.cis.upenn.edu/%7Ecis194/fall16/) 是函数式编程概念和 Haskell 实际开发的不错选择。有课程材料，但是没有讲座（您可以用几年前 Brisbane 函数式编程小组的 [CIS 194 系列讲座](https://github.com/bfpg/cis194-yorgey-lectures)。
* 不错的入门书籍有 《[Scala 的函数式编程](https://www.manning.com/books/functional-programming-in-scala)》 、 《[Haskell 函数式编程思想](http://www.cambridge.org/gb/academic/subjects/computer-science/programming-languages-and-applied-logic/thinking-functionally-haskell)》 , 和 《[Haskell 编程原理](http://haskellbook.com/)》。
* [Data61 FP 课程](https://github.com/data61/fp-course) （即 *NICTA* 课程）通过<ruby> 类型驱动开发 <rt> type-driven development </rt></ruby>来教授基础的抽象概念和数据结构。这是十分困难，但收获也是丰富的，其起源于培训会，如果你有一名愿意引导你函数式编程的程序员，你可以尝试。
* 在你的工作学习中使用函数式编程书写代码，写一些纯函数（避免不确定性和异常的出现），使用高阶函数和递归而不是循环，利用参数化来提高可读性和重用性。许多人从体验和实验各种语言的美妙之处，开始走上了函数式编程之旅。
* 加入到你的地区中的一些函数式编程小组或者学习小组中，或者创建一个，也可以是参加一些函数式编程的会议（新的会议总是不断的出现）。
### 总结
在本文中，我讨论了函数式编程是什么以及不是什么，并了解到了函数式编程的优势，包括等式推理和参数化。我们了解到在大多数编程语言中都有一些函数式编程功能，但是语言的选择会影响受益的程度，而 Haskell 是函数式编程中语言最受欢迎的语言。我也推荐了一些学习函数式编程的资源。
函数式编程是一个丰富的领域，还有许多更深入（更神秘）的主题正在等待探索。我没有提到那些具有实际意义的事情，比如：
* lenses 和 prisms （是一流的设置和获取值的方式；非常适合使用嵌套数据）；
* 定理证明（当你可以证明你的代码正确时，为什么还要测试你的代码？）；
* 延迟评估（让您处理潜在的无数的数据结构）；
* 分类理论（函数式编程中许多美丽实用的抽象的起源）；
我希望你喜欢这个函数式编程的介绍，并且启发你走上这个有趣和实用的软件开发之路。
*本文根据 [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) 许可证发布。*
（题图: opensource.com）
---
作者简介：
红帽软件工程师。对函数式编程，分类理论，数学感兴趣。Crazy about jalapeños.
---
via: <https://opensource.com/article/17/4/introduction-functional-programming>
作者：[Fraser Tweedale](https://opensource.com/users/frasertweedale) 译者：[MonkeyDEcho](https://github.com/MonkeyDEcho) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
减少 curl 中内存分配操作（malloc）
|
Daniel Stenberg
|
https://daniel.haxx.se/blog/2017/04/22/fewer-mallocs-in-curl/
|
今天我在 libcurl 内部又做了一个小改动，使其做更少的 malloc。这一次，泛型链表函数被转换成更少的 malloc (这才是链表函数应有的方式，真的)。
|
/data/attachment/album/201709/16/115559adfoyopxdy6v95oc.jpg.thumb.jpg
|
/data/attachment/album/201709/16/115559adfoyopxdy6v95oc.jpg
| true | false | true |
geekpi
| false |
[
"curl",
"malloc"
] |
软件开发
|
{
"viewnum": 5367,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "101.47.19.74",
"message": "这才是软件工程世界的灵魂",
"username": "来自浙江杭州的 Microsoft Edge 14.14393|Windows 10 用户",
"date": "2017-09-17T11:10:26"
}
] |
[] |
今天我在 libcurl 内部又做了一个小改动，使其做更少的 malloc。这一次，泛型链表函数被转换成更少的 malloc (这才是链表函数应有的方式，真的)。
| 2017-09-16T11:55:51 | 2017-09-16T11:55:51 | 8,870 |
/article-8870-1.html
|
今天我在 libcurl 内部又做了[一个小改动](https://github.com/curl/curl/commit/cbae73e1dd95946597ea74ccb580c30f78e3fa73)，使其做更少的 malloc。这一次，泛型链表函数被转换成更少的 malloc (这才是链表函数应有的方式，真的)。
### 研究 malloc
几周前我开始研究内存分配。这很容易，因为多年前我们 curl 中就已经有内存调试和日志记录系统了。使用 curl 的调试版本，并在我的构建目录中运行此脚本：
```
#!/bin/sh
export CURL_MEMDEBUG=$HOME/tmp/curlmem.log
./src/curl http://localhost
./tests/memanalyze.pl -v $HOME/tmp/curlmem.log
```
对于 curl 7.53.1，这大约有 115 次内存分配。这算多还是少？
内存日志非常基础。为了让你有所了解，这是一个示例片段：
```
MEM getinfo.c:70 free((nil))
MEM getinfo.c:73 free((nil))
MEM url.c:294 free((nil))
MEM url.c:297 strdup(0x559e7150d616) (24) = 0x559e73760f98
MEM url.c:294 free((nil))
MEM url.c:297 strdup(0x559e7150d62e) (22) = 0x559e73760fc8
MEM multi.c:302 calloc(1,480) = 0x559e73760ff8
MEM hash.c:75 malloc(224) = 0x559e737611f8
MEM hash.c:75 malloc(29152) = 0x559e737a2bc8
MEM hash.c:75 malloc(3104) = 0x559e737a9dc8
```
### 检查日志
然后，我对日志进行了更深入的研究，我意识到在相同的代码行做了许多小内存分配。我们显然有一些相当愚蠢的代码模式，我们分配一个结构体，然后将该结构添加到链表或哈希，然后该代码随后再添加另一个小结构体，如此这般，而且经常在循环中执行。（我在这里说的是*我们*，不是为了责怪某个人，当然大部分的责任是我自己……）
这两种分配操作将总是成对地出现，并被同时释放。我决定解决这些问题。做非常小的（小于 32 字节）的分配也是浪费的，因为非常多的数据将被用于（在 malloc 系统内）跟踪那个微小的内存区域。更不用说堆碎片了。
因此，将该哈希和链表代码修复为不使用 malloc 是快速且简单的方法，对于最简单的 “curl http://localhost” 传输，它可以消除 20％ 以上的 malloc。
此时，我根据大小对所有的内存分配操作进行排序，并检查所有最小的分配操作。一个突出的部分是在 `curl_multi_wait()` 中，它是一个典型的在 curl 传输主循环中被反复调用的函数。对于大多数典型情况，我将其转换为[使用堆栈](https://github.com/curl/curl/commit/5f1163517e1597339d)。在大量重复的调用函数中避免 malloc 是一件好事。
### 重新计数
现在，如上面的脚本所示，同样的 `curl localhost` 命令从 curl 7.53.1 的 115 次分配操作下降到 80 个分配操作，而没有牺牲任何东西。轻松地有 26％ 的改善。一点也不差！
由于我修改了 `curl_multi_wait()`，我也想看看它实际上是如何改进一些稍微更高级一些的传输。我使用了 [multi-double.c](https://github.com/curl/curl/commit/5f1163517e1597339d) 示例代码，添加了初始化内存记录的调用，让它使用 `curl_multi_wait()`，并且并行下载了这两个 URL：
```
http://www.example.com/
http://localhost/512M
```
第二个文件是 512 兆字节的零，第一个文件是一个 600 字节的公共 html 页面。这是 [count-malloc.c 代码](https://gist.github.com/bagder/dc4a42cb561e791e470362da7ef731d3)。
首先，我使用 7.53.1 来测试上面的例子，并使用 `memanalyze` 脚本检查：
```
Mallocs: 33901
Reallocs: 5
Callocs: 24
Strdups: 31
Wcsdups: 0
Frees: 33956
Allocations: 33961
Maximum allocated: 160385
```
好了，所以它总共使用了 160KB 的内存，分配操作次数超过 33900 次。而它下载超过 512 兆字节的数据，所以它每 15KB 数据有一次 malloc。是好是坏？
回到 git master，现在是 7.54.1-DEV 的版本 - 因为我们不太确定当我们发布下一个版本时会变成哪个版本号。它可能是 7.54.1 或 7.55.0，它还尚未确定。我离题了，我再次运行相同修改的 multi-double.c 示例，再次对内存日志运行 memanalyze，报告来了：
```
Mallocs: 69
Reallocs: 5
Callocs: 24
Strdups: 31
Wcsdups: 0
Frees: 124
Allocations: 129
Maximum allocated: 153247
```
我不敢置信地反复看了两遍。发生什么了吗？为了仔细检查，我最好再运行一次。无论我运行多少次，结果还是一样的。
### 33961 vs 129
在典型的传输中 `curl_multi_wait()` 被调用了很多次，并且在传输过程中至少要正常进行一次内存分配操作，因此删除那个单一的微小分配操作对计数器有非常大的影响。正常的传输也会做一些将数据移入或移出链表和散列操作，但是它们现在也大都是无 malloc 的。简单地说：剩余的分配操作不会在传输循环中执行，所以它们的重要性不大。
以前的 curl 是当前示例分配操作数量的 263 倍。换句话说：新的是旧的分配操作数量的 0.37％ 。
另外还有一点好处，新的内存分配量更少，总共减少了 7KB（4.3％）。
### malloc 重要吗？
在几个 G 内存的时代里，在传输中有几个 malloc 真的对于普通人有显著的区别吗？对 512MB 数据进行的 33832 个额外的 malloc 有什么影响？
为了衡量这些变化的影响，我决定比较 localhost 的 HTTP 传输，看看是否可以看到任何速度差异。localhost 对于这个测试是很好的，因为没有网络速度限制，更快的 curl 下载也越快。服务器端也会相同的快/慢，因为我将使用相同的测试集进行这两个测试。
我相同方式构建了 curl 7.53.1 和 curl 7.54.1-DEV，并运行这个命令：
```
curl http://localhost/80GB -o /dev/null
```
下载的 80GB 的数据会尽可能快地写到空设备中。
我获得的确切数字可能不是很有用，因为它将取决于机器中的 CPU、使用的 HTTP 服务器、构建 curl 时的优化级别等，但是相对数字仍然应该是高度相关的。新代码对决旧代码！
7.54.1-DEV 反复地表现出更快 30％！我的早期版本是 2200MB/秒增加到当前版本的超过 2900 MB/秒。
这里的要点当然不是说它很容易在我的机器上使用单一内核以超过 20GB/秒的速度来进行 HTTP 传输，因为实际上很少有用户可以通过 curl 做到这样快速的传输。关键在于 curl 现在每个字节的传输使用更少的 CPU，这将使更多的 CPU 转移到系统的其余部分来执行任何需要做的事情。或者如果设备是便携式设备，那么可以省电。
关于 malloc 的成本：512MB 测试中，我使用旧代码发生了 33832 次或更多的分配。旧代码以大约 2200MB/秒的速率进行 HTTP 传输。这等于每秒 145827 次 malloc - 现在它们被消除了！600 MB/秒的改进意味着每秒钟 curl 中每个减少的 malloc 操作能额外换来多传输 4300 字节。
### 去掉这些 malloc 难吗？
一点也不难，非常简单。然而，有趣的是，在这个旧项目中，仍然有这样的改进空间。我有这个想法已经好几年了，我很高兴我终于花点时间来实现。感谢我们的测试套件，我可以有相当大的信心做这个“激烈的”内部变化，而不会引入太可怕的回归问题。由于我们的 API 很好地隐藏了内部，所以这种变化可以完全不改变任何旧的或新的应用程序……
（是的，我还没在版本中发布该变更，所以这还有风险，我有点后悔我的“这很容易”的声明……）
### 注意数字
curl 的 git 仓库从 7.53.1 到今天已经有 213 个提交。即使我没有别的想法，可能还会有一次或多次的提交，而不仅仅是内存分配对性能的影响。
### 还有吗？
还有其他类似的情况么？
也许。我们不会做很多性能测量或比较，所以谁知道呢，我们也许会做更多的愚蠢事情，我们可以收手并做得更好。有一个事情是我一直想做，但是从来没有做，就是添加所使用的内存/malloc 和 curl 执行速度的每日“监视” ，以便更好地跟踪我们在这些方面不知不觉的回归问题。
### 补遗，4/23
（关于我在 hacker news、Reddit 和其它地方读到的关于这篇文章的评论）
有些人让我再次运行那个 80GB 的下载，给出时间。我运行了三次新代码和旧代码，其运行“中值”如下：
旧代码：
```
real 0m36.705s
user 0m20.176s
sys 0m16.072s
```
新代码：
```
real 0m29.032s
user 0m12.196s
sys 0m12.820s
```
承载这个 80GB 文件的服务器是标准的 Apache 2.4.25，文件存储在 SSD 上，我的机器的 CPU 是 i7 3770K 3.50GHz 。
有些人也提到 `alloca()` 作为该补丁之一也是个解决方案，但是 `alloca()` 移植性不够，只能作为一个孤立的解决方案，这意味着如果我们要使用它的话，需要写一堆丑陋的 `#ifdef`。
---
via: <https://daniel.haxx.se/blog/2017/04/22/fewer-mallocs-in-curl/>
作者：[DANIEL STENBERG](https://daniel.haxx.se/blog/author/daniel/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Oracle 要将 Java EE 移交给 Eclipse 基金会
|
John K. Waters
|
https://adtmag.com/articles/2017/09/12/java-ee-moving-to-eclipse.aspx
|
Oracle 日前宣布，选择将 Eclipse 基金会作为 Java EE（Java 平台企业版）的新家。Oracle 是与 Java EE 的两个最大的贡献者 IBM 和 Red Hat 一同做出的该决定。
|
/data/attachment/album/201709/16/174433vhmq36h2zmv72vq2.jpg.thumb.jpg
|
/data/attachment/album/201709/16/174433vhmq36h2zmv72vq2.jpg
| true | false | true |
wxy
| false |
[
"Oracle",
"Java"
] |
新闻
|
{
"viewnum": 4968,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "113.240.201.81",
"message": "红帽：MMP",
"username": "来自湖南长沙的 QQ Browser 9.6|Windows 7 用户",
"date": "2017-09-16T18:39:05"
}
] |
[] |
Oracle 日前宣布，选择将 Eclipse 基金会作为 Java EE（Java 平台企业版）的新家。Oracle 是与 Java EE 的两个最大的贡献者 IBM 和 Red Hat 一同做出的该决定。
| 2017-09-16T17:44:41 | 2017-09-16T17:44:41 | 8,871 |
/article-8871-1.html
|
Oracle 日前宣布，选择将 [Eclipse 基金会](https://eclipse.org/org/foundation/)作为 Java EE（Java 平台企业版）的新家。Oracle 是与 Java EE 的两个最大的贡献者 IBM 和 Red Hat 一同做出的该决定。
Oracle 软件布道师 David Delabassee 在[博文](https://blogs.oracle.com/theaquarium/opening-up-ee-update)中说，“…… Eclipse 基金会积极参与了 Java EE 及相关技术的发展，具有丰富的经验。这能帮助我们快速移交 Java EE，创建社区友好的流程来推进该平台的发展，并充分利用如 MicroProfile 这样的互补项目。我们期待这一合作。”
Eclipse 基金会的执行总监 Mike Milinkovich 对这次移交持乐观态度，他说，这正是企业级 Java 所需要的，也是社区所期望的。
他说，“开源模式已经一再被时间所证实是成功创新和协作的最佳方式。随着企业更多地转向以云为中心的模式，很显然 Java EE 需要有更快速的创新步伐。移交给 Eclipse 基金会对于供应商来说是一次巨大的机会，他们并不总是有最好的合作机会。我们为个人、小型公司、企业和大型供应商提供开放合作的机会。这将为他们提供一个可靠的平台，让他们可以协作前进，并将支持 Java EE 所需的更快的创新步伐。”
Milinkovich 说，Java EE 成为获准项目也将经历所有的 Eclipse 项目的同样的获准流程。他期待 “Java EE” 融合为一个包含大量子项目的顶级项目。该平台现在包含近 40 个 Java JSR。
Delabassee 说，Oracle 计划将其主导的 Java EE 技术和相关的 GlassFish 技术重新授权给 Eclipse 基金会，包括参考实现、技术兼容性工具包（TCK）和“相关项目文档”。并计划给该平台“重新定名”，但此事尚未确定。
这一移交何时进行还未确定，但 Oracle 希望在 “Java EE 8 完成后尽快进行，以促进快速转型”，Delabassee 承诺，在移交期间，Oracle 将继续支持现有的 Java EE 许可用户，包括升级到 Java EE 8 的许可用户。该公司也将继续支持现有的 WebLogic 服务器版本中的 Java EE，包括之后的 WebLogic 服务器版本中的 Java EE 8。
Delabassee 写道，“我们相信这一计划将使我们可以继续支持现有的 Java EE 标准，同时将其演进为更开放的环境。还有许多工作需要去做，但我们相信正走在一条正确的道路上。”
|
||
微软在 Windows 10 上支持 Ubuntu 容器
|
Marius Nestor
|
http://news.softpedia.com/news/canonical-microsoft-enable-ubuntu-containers-with-hyper-v-isolation-on-windows-517734.shtml
|
Canonical 的 Dustin Kirkland 宣布该公司最近与微软合作让 Ubuntu 容器可以运行在带有 Hyper-V 隔离的 Windows 系统上。
|
/data/attachment/album/201709/17/093451xdx2e77nrh6bbe67.png.thumb.jpg
|
/data/attachment/album/201709/17/093451xdx2e77nrh6bbe67.png
| true | false | true |
wxy
| false |
[
"Windows",
"Canonical"
] |
新闻
|
{
"viewnum": 6079,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 7177,
"displayorder": 0
},
{
"raid": 8873,
"displayorder": 0
},
{
"raid": 7209,
"displayorder": 1
},
{
"raid": 7445,
"displayorder": 2
},
{
"raid": 7613,
"displayorder": 3
},
{
"raid": 8121,
"displayorder": 4
}
] |
Canonical 的 Dustin Kirkland 宣布该公司最近与微软合作让 Ubuntu 容器可以运行在带有 Hyper-V 隔离的 Windows 系统上。
| 2017-09-17T09:34:00 | 2017-09-17T09:34:00 | 8,872 |
/article-8872-1.html
|
Canonical 的 Dustin Kirkland 宣布该公司最近与微软合作让 Ubuntu 容器可以运行在带有 Hyper-V 隔离的 Windows 系统上。
如果你曾经想象过在 Windows 机器上使用你喜欢的 GNU/Linux 发行版（比如 Ubuntu）来运行 Linux 应用，那么现在有个好消息，你可以在 Windows 10 和 Windows 服务器上运行 Docker 容器了。
该技术利用 Ubuntu Linux 操作系统作为宿主基础，通过 Docker 容器镜像和 Hyper-V 虚拟化在 Windows 上运行 Linux 应用。你所需的只是一台 8GB 内存的 64 位 x86 PC，以及加入了 Windows Insider 计划。
“Canonical 和微软合作交付了一种真正特别的体验——在 Windows 10 和 Windows 服务器上运行带有 Hyper-V 隔离的 Ubuntu 容器，”Canonical 的 Ubuntu 产品与战略副总裁 Dustin Kirkland 说，“只需要一分钟就能跑起来！”
在他最近写的一篇[博客文章](https://insights.ubuntu.com/2017/09/13/running-ubuntu-containers-with-hyper-v-isolation/)中，Dustin Kirkland 分享了一篇教程，提供了简单易行的指南和截屏，对这种技术感兴趣的人可以去看看。不过该技术目前还只能运行在 Windows 10 和 Windows 服务器上。
根据这篇指南，你只需要在 Windows PowerShell 中运行 docker run -it ubuntu bash 即可启动带有 Hyper-V 隔离的 Ubuntu 容器。如果你在该教程中遇到了困难，你可以加入官方的 [Ubuntu Forums](https://ubuntuforums.org/) 或 [Ask Ubuntu](https://askubuntu.com/) 寻求支持。此外，在 Windows 10 上，[Ubuntu 也可以作为 app 从 Windows 商店上得到](http://news.softpedia.com/news/here-s-how-to-upgrade-your-old-ubuntu-on-windows-install-to-the-app-version-517332.shtml)。
|
||
如何在 Windows 上运行 Linux 容器
|
Ubuntu
|
https://tutorials.ubuntu.com/tutorial/tutorial-windows-ubuntu-hyperv-containers
|
现在能够在 Windows 10 和 Windows 服务器上运行 Docker 容器了，它是以 Ubuntu 作为宿主基础的。
想象一下，使用你喜欢的 Linux 发行版——比如 Ubuntu——在 Windows 上运行你自己的 Linux 应用。
|
/data/attachment/album/201709/17/105627lic1ifnc1ellldyq.png.thumb.jpg
|
/data/attachment/album/201709/17/105627lic1ifnc1ellldyq.png
| true | false | true |
wxy
| false |
[
"Ubuntu",
"Windows",
"Docker"
] |
容器与云
|
{
"viewnum": 12475,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 7177,
"displayorder": 0
},
{
"raid": 7209,
"displayorder": 1
},
{
"raid": 7445,
"displayorder": 2
},
{
"raid": 7613,
"displayorder": 3
},
{
"raid": 8872,
"displayorder": 4
}
] |
现在能够在 Windows 10 和 Windows 服务器上运行 Docker 容器了，它是以 Ubuntu 作为宿主基础的。
想象一下，使用你喜欢的 Linux 发行版——比如 Ubuntu——在 Windows 上运行你自己的 Linux 应用。
| 2017-09-17T10:56:00 | 2017-09-17T10:56:00 | 8,873 |
/article-8873-1.html
|
### 1、概述
现在能够在 Windows 10 和 Windows 服务器上运行 Docker 容器了，它是以 Ubuntu 作为宿主基础的。
想象一下，使用你喜欢的 Linux 发行版——比如 Ubuntu——在 Windows 上运行你自己的 Linux 应用。
现在，借助 Docker 技术和 Windows 上的 Hyper-V 虚拟化的力量，这一切成为了可能。
### 2、前置需求
你需要一个 8GB 内存的 64 位 x86 PC，运行 Windows 10 或 Windows Server。
只有加入了 [Windows 预览体验计划（Insider）](https://insider.windows.com/zh-cn/)，才能运行带有 Hyper-V 支持的 Linux 容器。该计划可以让你测试预发布软件和即将发布的 Windows。
如果你特别在意稳定性和隐私（Windows 预览体验计划允许微软收集使用信息），你可以考虑等待 2017 年 10 月发布的[Windows 10 Fall Creator update](https://www.microsoft.com/zh-cn/windows/upcoming-features)，这个版本可以让你无需 Windows 预览体验身份即可使用带有 Hyper-V 支持的 Docker 技术。
你也需要最新版本的 Docker，它可以从 [http://dockerproject.org](http://dockerproject.org/) 下载得到。
最后，你还需要确认你安装了 [XZ 工具](https://tukaani.org/xz/)，解压 Ubuntu 宿主容器镜像时需要它。
### 3、加入 Windows 预览体验计划（Insider）
如果你已经是 Windows 预览体验计划（Insider）成员，你可以跳过此步。否则在浏览器中打开如下链接：
<https://insider.windows.com/zh-cn/getting-started/>
要注册该计划，使用你在 Windows 10 中的微软个人账户登录，并在预览体验计划首页点击“注册”，接受条款并完成注册。
然后你需要打开 Windows 开始菜单中的“更新和安全”菜单，并在菜单左侧选择“Windows 预览体验计划”。
如果需要的话，在 Windows 提示“你的 Windows 预览体验计划账户需要关注”时，点击“修复”按钮。
### 4、 Windows 预览体验（Insider）的内容
从 Windows 预览体验计划面板，选择“开始使用”。如果你的微软账户没有关联到你的 Windows 10 系统，当提示时使用你要关联的账户进行登录。
然后你可以选择你希望从 Windows 预览体验计划中收到何种内容。要得到 Docker 技术所需要的 Hyper-V 隔离功能，你需要加入“快圈”，两次确认后，重启 Windows。重启后，你需要等待你的机器安装各种更新后才能进行下一步。
### 5、安装 Docker for Windows
从 [Docker Store](https://store.docker.com/editions/community/docker-ce-desktop-windows) 下载 Docker for Windows。
下载完成后，安装，并在需要时重启。
重启后，Docker 就已经启动了。Docker 要求启用 Hyper-V 功能，因此它会提示你启用并重启。点击“OK”来为 Docker 启用它并重启系统。
### 6、下载 Ubuntu 容器镜像
从 [Canonical 合作伙伴镜像网站](https://partner-images.canonical.com/hyper-v/linux-containers/xenial/current/)下载用于 Windows 的最新的 Ubuntu 容器镜像。
下载后，使用 XZ 工具解压：
```
C:\Users\mathi\> .\xz.exe -d xenial-container-hyper-v.vhdx.xz
C:\Users\mathi\>
```
### 7、准备容器环境
首先创建两个目录：
创建 `C:\lcow`*，*它将用于 Docker 准备容器时的临时空间。
再创建一个 `C:\Program Files\Linux Containers` ，这是存放 Ubuntu 容器镜像的地方。
你需要给这个目录额外的权限以允许 Docker 在其中使用镜像。在管理员权限的 Powershell 窗口中运行如下 Powershell 脚本：
```
param(
[string] $Root
)
# Give the virtual machines group full control
$acl = Get-Acl -Path $Root
$vmGroupRule = new-object System.Security.AccessControl.FileSystemAccessRule("NT VIRTUAL MACHINE\Virtual Machines", "FullControl","ContainerInherit,ObjectInherit", "None", "Allow")
$acl.SetAccessRule($vmGroupRule)
Set-Acl -AclObject $acl -Path $Root
```
将其保存为`set_perms.ps1`并运行它。
提示**，你也许需要运行** `Set-ExecutionPolicy -Scope process unrestricted` 来允许运行未签名的 Powershell 脚本。
```
C:\Users\mathi\> .\set_perms.ps1 "C:\Program Files\Linux Containers"
C:\Users\mathi\>
```
现在，将上一步解压得到的 Ubuntu 容器镜像（.vhdx）复制到 `C:\Program Files\Linux Containers` 下的 `uvm.vhdx`。
### 8、更多的 Docker 准备工作
Docker for Windows 要求一些预发布的功能才能与 Hyper-V 隔离相配合工作。这些功能在之前的 Docker CE 版本中还不可用，这些所需的文件可以从 [master.dockerproject.org](https://master.dockerproject.org/) 下载。
从 [master.dockerproject.org](https://master.dockerproject.org/) 下载 `dockerd.exe` 和 `docker.exe`，并将其放到安全的地方，比如你自己的文件夹中。它们用于在下一步中启动 Ubuntu 容器。
### 9、 在 Hyper-V 上运行 Ubuntu 容器
你现在已经准备好启动你的容器了。首先以管理员身份打开命令行（`cmd.exe`），然后以正确的环境变量启动 `dockerd.exe`。
```
C:\Users\mathi\> set LCOW_SUPPORTED=1
C:\Users\mathi\> .\dockerd.exe -D --data-root C:\lcow
```
然后，以管理员身份启动 Powershell 窗口，并运行 `docker.exe` 为你的容器拉取镜像：
```
C:\Users\mathi\> .\docker.exe pull ubuntu
```
现在你终于启动了容器，再次运行 `docker.exe`，让它运行这个新镜像：
```
C:\Users\mathi\> .\docker.exe run -it ubuntu
```
恭喜你！你已经成功地在 Windows 上让你的系统运行了带有 Hyper-V 隔离的容器，并且跑的是你非常喜欢的 Ubuntu 容器。
### 10、获取帮助
如果你需要一些 Hyper-V Ubuntu 容器的起步指导，或者你遇到一些问题，你可以在这里寻求帮助：
* [Ask Ubuntu](https://askubuntu.com/)
* [Ubuntu Forums](https://ubuntuforums.org/)
* [IRC-based support](https://wiki.ubuntu.com/IRC/ChannelList)
|
||
开发者定义的应用交付
|
Lee Calcote
|
https://www.oreilly.com/learning/developer-defined-application-delivery
|
负载均衡器如何帮助你解决分布式系统的复杂性。
|
/data/attachment/album/201709/17/171025edhgftby8xhybg4x.jpg.thumb.jpg
|
/data/attachment/album/201709/17/171025edhgftby8xhybg4x.jpg
| true | false | true |
geekpi
| false |
[
"负载均衡",
"原生云应用"
] |
观点
|
{
"viewnum": 3278,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
负载均衡器如何帮助你解决分布式系统的复杂性。
| 2017-09-17T17:10:23 | 2017-09-17T17:10:23 | 8,874 |
/article-8874-1.html
|
>
> 负载均衡器如何帮助你解决分布式系统的复杂性。
>
>
>
原生云应用旨在利用分布式系统的性能、可扩展性和可靠性优势。不幸的是，分布式系统往往以额外的复杂性为代价。由于你程序的各个组件跨网络分布，并且这些网络有通信障碍或者性能降级，因此你的分布式程序组件需要能够继续独立运行。
为了避免程序状态的不一致，分布式系统设计应该有一个共识，即组件会失效。没有什么比在网络中更突出了。因此，在其核心，分布式系统在很大程度上依赖于负载平衡——请求分布于两个或多个系统，以便在面临网络中断时具有弹性，并在系统负载波动时水平缩放时。
随着分布式系统在原生云程序的设计和交付中越来越普及，负载平衡器在现代应用程序体系结构的各个层次都影响了基础设施设计。在大多数常见配置中，负载平衡器部署在应用程序前端，处理来自外部世界的请求。然而，微服务的出现意味着负载平衡器可以在幕后发挥关键作用：即管理*服务*之间的流。
因此，当你使用原生云程序和分布式系统时，负载均衡器将承担其他角色：
* 作为提供缓存和增加安全性的**反向代理**，因为它成为外部客户端的中间人。
* 作为通过提供协议转换（例如 REST 到 AMQP）的 **API 网关**。
* 它可以处理**安全性**（即运行 Web 应用程序防火墙）。
* 它可能承担应用程序管理任务，如速率限制和 HTTP/2 支持。
鉴于它们的扩展能力远大于平衡流量，<ruby> 负载平衡器 <rt> load balancer </rt></ruby>可以更广泛地称为<ruby> 应用交付控制器 <rt> Application Delivery Controller </rt></ruby>（ADC）。
### 开发人员定义基础设施
从历史上看，ADC 是由 IT 专业人员购买、部署和管理的，最常见运行企业级架构的应用程序。对于物理负载平衡器设备（如 F5、Citrix、Brocade等），这种情况在很大程度上仍然存在。具有分布式系统设计和临时基础设施的云原生应用要求负载平衡器与它们运行时的基础设施 (如容器) 一样具有动态特性。这些通常是软件负载均衡器（例如来自公共云提供商的 NGINX 和负载平衡器）。云原生应用通常是开发人员主导的计划，这意味着开发人员正在创建应用程序（例如微服务器）和基础设施（Kubernetes 和 NGINX）。开发人员越来越多地对负载平衡 (和其他) 基础设施的决策做出或产生重大影响。
作为决策者，云原生应用的开发人员通常不会意识到企业基础设施需求或现有部署的影响，同时要考虑到这些部署通常是新的，并且经常在公共或私有云环境中进行部署。云技术将基础设施抽象为可编程 API，开发人员正在定义应用程序在该基础设施的每一层的构建方式。在有负载平衡器的情况下，开发人员会选择要使用的类型、部署方式以及启用哪些功能。它们以编程的方式对负载平衡器的行为进行编码 —— 随着程序在部署的生存期内增长、收缩和功能上进化时，它如何动态响应应用程序的需要。开发人员将基础设施定义为代码 —— 包括基础设施配置及其运维。
### 开发者为什么定义基础设施？
编写如何构建和部署应用程序的代码实践已经发生了根本性的转变，它体现在很多方面。简而言之，这种根本性的转变是由两个因素推动的：将新的应用功能推向市场所需的时间（*上市时间*）以及应用用户从产品中获得价值所需的时间（*获益时间*）。因此，新的程序写出来就被持续地交付（作为服务），无需下载和安装。
上市时间和获益时间的压力并不是新的，但由于其他因素的加剧，这些因素正在加强开发者的决策权力：
* 云：通过 API 将基础设施定义为代码的能力。
* 伸缩：需要在大型环境中高效运维。
* 速度：马上需要交付应用功能，为企业争取竞争力。
* 微服务：抽象框架和工具选择，进一步赋予开发人员基础设施决策权力。
除了上述因素外，值得注意的是开源的影响。随着开源软件的普及和发展，开发人员手中掌握了许多应用程序基础设施 - 语言、运行时环境、框架、数据库、负载均衡器、托管服务等。微服务的兴起使应用程序基础设施的选择民主化，允许开发人员选择最佳的工具。在选择负载平衡器的情况下，那些与云原生应用的动态特质紧密集成并响应的那些人将超人一等。
### 总结
当你在仔细考虑你的云原生应用设计时，请与我一起讨论“[在云中使用 NGINX 和 Kubernetes 进行负载平衡](http://www.oreilly.com/pub/e/3864?intcmp=il-webops-webcast-reg-webcast_new_site_developer_defined_application_delivery_body_text_cta)”。我们将检测不同公共云和容器平台的负载平衡功能，并通过一个宏应用的案例研究。我们将看看它是如何被变成较小的、独立的服务，以及 NGINX 和 Kubernetes 的能力是如何拯救它的。
---
作者简介：
Lee Calcote 是一位创新思想领袖，对开发者平台和云、容器、基础设施和应用的管理软件充满热情。先进的和新兴的技术一直是 Calcote 在 SolarWinds、Seagate、Cisco 和 Pelco 时的关注重点。他是技术会议和聚会的组织者、写作者、作家、演讲者，经常活跃在技术社区。
---
via: <https://www.oreilly.com/learning/developer-defined-application-delivery>
作者：[Lee Calcote](https://www.oreilly.com/people/7f693-lee-calcote) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
回锅开源情怀下的专利咸猪手
|
李可
|
从此事开始以及开源中国与专利申请人进行交涉的进展报告发出到现在，3 个多月过去了，没有进一步的实质性进展。笔者并不认为奇怪。为什么呢？
|
/data/attachment/album/201709/17/173847hcneggggglcg5u56.jpg.thumb.jpg
|
/data/attachment/album/201709/17/173847hcneggggglcg5u56.jpg
| true | false | false | false |
[
"专利"
] |
开源智慧
|
{
"viewnum": 5171,
"commentnum": 5,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "58.19.1.212",
"message": "可以表明，有的人是可以无耻到一定境界的",
"username": "mistyos [Firefox 55.0|GNU/Linux]",
"date": "2017-09-17T23:59:38"
},
{
"postip": "111.20.112.126",
"message": "GPLV3是个好东西！！！",
"username": "来自陕西西安的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-09-18T08:07:34"
},
{
"postip": "111.20.112.126",
"message": "是呀，所以读《笑傲江湖》真是一种别样的人生经历。越不群似的嘴脸隐藏的深。。。大理想往往是私利套现的遮羞布。当下讲情怀才能真正巩固私利，你说是为了私利，那很容易死在那些越不群手里！！！",
"username": "来自陕西西安的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-09-18T08:10:52"
},
{
"postip": "113.104.194.84",
"message": "gpl协议才是最好的开源协议",
"username": "来自广东深圳的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-18T09:22:53"
},
{
"postip": "118.122.120.11",
"message": "其实这个也不少见，王垠不是把自己的一个项目授权给改了吗？",
"username": "来自四川成都的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-18T09:25:49"
}
] |
[
{
"raid": 8765,
"displayorder": 0
}
] |
从此事开始以及开源中国与专利申请人进行交涉的进展报告发出到现在，3 个多月过去了，没有进一步的实质性进展。笔者并不认为奇怪。为什么呢？
| 2017-09-17T17:38:00 | 2017-09-17T17:38:00 | 8,875 |
/article-8875-1.html
|
### 引子：开源软件作者发出求救
约一个月前，笔者撰写了“[开源情怀遭遇专利咸猪手](/article-8765-1.html)”。现在我们回一下锅：看看事情的进展，分析可能的结果，以期开源人再碰到类似状况时，对可能的发展能多一点预期和准备，少一点盲目性和不确定性。
事情是这样开始的：按照[开源中国博客文章](https://my.oschina.net/xuxueli/blog/918201)，一名开源软件作者发出求救的呼声，指出知名公司将他的开源软件 XXL-JOB 申请成了专利。
XXL-JOB 作者于 2017 年 6 月在他人提醒之后，发现他的作品 XXL-JOB 被他人申请了中国专利（CN201610843823.X）。
依照开源中国的[另一篇博客文章](https://my.oschina.net/javayou/blog/918941)，XXL-JOB 作者委托开源中国与专利申请人进行交涉，作者的基本诉求包括：申请人撤回专利申请并发布声明加以澄清。开源中国与作者进一步希望，如，申请人从事实和技术角度加以澄清，并提出如果专利授权，应声明其与有关开源项目的关系，并“无偿开源”等。
如笔者在前文中指出的，此事件很典型，无论在国内还是国外都不是孤立性事件。事情的根本在于：开源软件的开发者仅对自己智力劳动成果的知识产权做了很少的保留，将软件基本开放、贡献给公众无偿使用。而开发者的无私奉献却被一些人窃取或搭便车谋利：包括但不限于通过专利咸猪手式的手段侵占公用领域开源软件的全部或一部分，或是针对某些典型应用场景设下埋伏，迫使公众在使用开源软件时有可能侵犯相关专利权而需向他们缴纳费用。
从此事开始以及开源中国与专利申请人进行交涉的进展报告发出到现在，3 个多月过去了，没有进一步的实质性进展。笔者并不认为奇怪。为什么呢？
### 如何发展？我们来抽丝剥茧……
没有进展，就是双方谈不拢。开源作者及开源中国一方的要求总结如下：
作者的诉求包括：
* 专利申请人向专利局申请撤销专利。
* 以公司名义发布正面声明，客观的描述此事。
开源中国与作者对声明内容的要求是：
1. 详细描述出现使用开源软件申请专利的管理不善问题，如果是在开源软件上做改进，那么应该详细描述改进的内容。
2. 在声明中表明将公开宣布主动申请撤销专利。
3. 如果专利撤销失败，已经授予，那么公司将发布另外声明，声明该专利基于某某开源项目，并将无偿开源。
从法律角度讲，双方对话行为属于民事行为，是基于双方自愿而进行的，任何一方都没有义务必须要进行对话协商。而如果对话不能进行，且当任何一方认为自己的正当权益受到对方损害时，可以向法院针对对方提起民事诉讼，也就是让法院做主。
专利申请人那头先按下不表，让我们看看作者一方的正当权益是否受到了损害。很遗憾，看来现在的主动权在专利申请人一边。
**开源作者的要求：专利申请人向专利局申请撤销专利。**
解读：如果专利申请是不正当的，上述要求是合理的。反之，则不合理。所以问题的关键是专利申请人所提出的专利申请是否正当。该问题随后再进行分析。
**开源作者的要求：（专利申请人）以公司名义发布正面声明，客观的描述此事。**
解读：公司就这个问题做出声明和澄清，从法律角度讲，公司可以自主做出决定，通常出于礼貌和善意的沟通，尤其不会产生负面影响时，公司会比较愿意进行。但法律方面没有强制要求，也就是说，专利申请人没有沟通或发出声明的义务，即使公司方面存在问题。而实际上，公司方面是否存在问题，即专利申请人所提出的专利申请是否正当，尚没有确定。
**开源中国与作者对声明内容的要求 1：详细描述出现使用开源软件申请专利的管理不善问题，如果是在开源软件上做改进，那么应该详细描述改进的内容。**
解读：“管理不善”应当是指专利申请人如果进行了不正当的专利申请，则是一个管理不善的问题。这就又转回到了那个关键问题：专利申请是否正当。
这句话是比较有意思的：“如果是在开源软件上做改进，那么应该详细描述改进的内容”。这句话字面之下似乎淡淡的有一层意思：如果专利申请针对的是在开源软件基础上做出的改进，那么专利申请可以是正当的。是否如此呢？答案基本上是肯定的。
如笔者前文中提到过的，按照专利制度的本意，任何人可以在现有的公知技术的基础上做出创新性的改进，然后就改进的内容去申请专利。这是正当的，也是受到鼓励和法律保护的。
### 关键问题的答案
所以，“专利申请是否正当”这个关键问题的答案就依赖于专利申请人是否做出了创新性的改进并就该改进来申请的专利，如果是，则专利申请是正当的；如果不是，就不正当。
接下来，就更加微妙了。开源方要求“细描述改进的内容”，仅就此要求而言，站在专利申请人立场上，是绝对不可以加以说明的。原因是：专利申请人就此内容的任何技术性说明都可能对申请人的专利构成不良影响。专利正在经受国家知识产权局的审查，审查的重点内容就是专利的新创性，也就是其对现有技术到底做出了什么样的改进，改进是否有新创性。专利申请人就此内容发表的任何意见，专利审查员都可以从中摘出对专利申请的新创性不利的内容，利用其来缩小专利的保护范围甚至驳回专利申请。
这种情形之下，申请人不针对“改进的内容”发表任何意见是明智、正当的。而开源方如果坚持要求申请人“细描述改进的内容”就显得强人所难，就不那么正当了。这时，开源方正确的做法是自己来完成开源软件作品与专利申请的比对，如果认为专利申请并未做出实质性的创新，可以将技术分析意见及相关支持性的技术文件按照第三方意见的形式通过正当程序提交给专利审查员。如果审查员认为开源方提出的意见是正确的，当然会加以采纳，相应会对专利申请加以合理限制或予以驳回。如果开源方对审查员的认定结果并不满意，后续还有行政和司法救济程序可以利用。
### 三点提示
这里提示的第一点是：不能简单因为专利申请当中涉及到的开源软件中采用的技术就直接认为专利申请中不存在新创性的技术改进。对新创性改进而得来的技术方案，在加以描述时要涉及到现有技术，这是正常的，不可避免的。
第二点：真正完成专利申请是否有实质性创新，专业性很强，成本很高；走行政和司法救济程序，成本就更高了。
第三点暂且不表。为什么事情还没有进展其实已经清楚了：专利申请人方面不表态是正当和必然的。至少要等到专利审查员做出授权或驳回的决定才有初步分晓。
**开源中国与作者对声明内容的要求：**
**2、在声明中表明将公开宣布主动申请撤销专利。**
**3、如果专利撤销失败，已经授予，那么公司将发布另外声明，声明该专利基于某某开源项目，并将无偿开源。**
解读：如果专利审查员做出授权决定，表明专利针对开源软件在内的现有技术做出了新创性改进，相应专利申请也就是正当的。既然是正当的，专利申请人想来不会撤销或放弃专利申请，也不会将辛苦得来的专利“开源”或开放给公众。如果专利审查员做出驳回决定，也就不存在专利申请人撤销或放弃专利申请的问题了。当然，如果有人发起后续行政、司法救济程序，则可能带来变数。
完整地讨论好问题，就要说到第三点：如果专利最终被行政或司法认定成没有新创性从而被驳回，是否就足以证明专利申请人恶意窃取开源软件的技术成果呢？如果没有充分的相关理由和证据，还真不好这么下结论。因为很可能专利申请人出于善意想做出发明，并认为自己已经做出了具有新创性的改进，而最终做出认定的国家知识产权局或法院对新创性的理解和要求与专利申请人不同，才得出了不具有新创性的结论。如果是这种情况，专利申请人只是犯了一个诚实的错误而并不具有恶意。
### 收尾，旧话重提
我看到，投身开源软件的有情怀的理想主义者，有一些在黑暗和不公的打击之下，愤而退出了开源事业。笔者非常理解他们。我还看到，更多的人无视这些打击，以不变的情怀和理想，在这条道路上继续栉风沐雨，砥砺前行。笔者非常敬佩他们。人间正道是沧桑。
---
作者：李可，江湖人称“可哥”，老牌专利代理人，集慧智佳知识产权咨询公司的知识产权高级咨询师。70 后文艺理工男，属牛，性子慢但踏实稳妥。
|
||||
React 许可证的五宗罪
|
Simon Phipps
|
https://opensource.com/article/17/9/5-reasons-facebooks-react-license-was-mistake
|
Facebook 公司的 BSD+专利许可证失败的原因不是因为许可证本身，而是因为它忽略了开源软件更深层次的本质。
|
/data/attachment/album/201709/18/104314bmonnfmtfma67mli.png.thumb.jpg
|
/data/attachment/album/201709/18/104314bmonnfmtfma67mli.png
| true | false | true |
薛亮
| false |
[
"Facebook",
"React"
] |
开源智慧
|
{
"viewnum": 6784,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8733,
"displayorder": 0
},
{
"raid": 8880,
"displayorder": 0
},
{
"raid": 8895,
"displayorder": 0
},
{
"raid": 8910,
"displayorder": 0
},
{
"raid": 8764,
"displayorder": 1
},
{
"raid": 8784,
"displayorder": 2
}
] |
Facebook 公司的 BSD+专利许可证失败的原因不是因为许可证本身，而是因为它忽略了开源软件更深层次的本质。
| 2017-09-18T10:43:00 | 2017-09-18T10:43:00 | 8,876 |
/article-8876-1.html
|
>
> Facebook 公司的 BSD+专利许可证失败的原因不是因为许可证本身，而是因为它忽略了开源软件更深层次的本质。
>
>
>
2017 年 7 月，Facebook 公司应用于 react 等项目的许可证组合[被 Apache 软件基金会禁止使用](https://meshedinsights.com/2017/07/16/apache-bans-facebooks-license-combo/)。该许可证组合曾被 Facebook 应用于其所有作为开源软件发布的项目，它使用了被 OSI 批准的广泛使用的[非互惠](https://meshedinsights.com/2017/04/04/permissive-and-copyleft-are-not-antonyms/)许可证 BSD 3-Clause，并且加入了宽泛的、非互惠的专利授权条款，但为了应对挑衅者，该许可证组合的终止规则同样宽泛。这种组合代表了一种新的开源许可证，我称之为“Facebook BSD+专利许可证”（FB + PL），在我看来，该许可证试图与 GPL v2 和 Apache v2 许可证保持兼容，以规避这些许可证所指称的不兼容性。
[使用 FB + PL 许可证的 Apache 项目仍在发挥作用](https://meshedinsights.com/2017/07/16/apache-bans-facebooks-license-combo/)，但是我认为 Facebook 所犯错误的原因可能不会立即被一贯秉持实用主义态度的软件开发人员们所注意到。例如，[由律师转行做程序员的 Dennis Walsh 针对这个问题表示](https://medium.com/@dwalsh.sdlr/react-facebook-and-the-revokable-patent-license-why-its-a-paper-25c40c50b562)：“它没有什么实质意义”。他的观点是，FB + PL 许可证仅对你所使用的适用该许可证的特定软件项目产生影响，专利授权撤回的后果对另一个专利持有者来说并不严重。他得出结论说：
>
> “Facebook 想要推广开源软件同时不被起诉——这是一个崇高的目标。为此，它可以使用一些苛刻的条款。但在这种情况下，由于上述实践和法律方面的原因，很难在被攻击之后发现是谁干的。”
>
>
>
Dennis 也许是对的，但这并不重要。Facebook 自出机杼地发明自己的开源许可证是一个坏主意。有一系列非直接风险或具体情境的重要因素需要考虑，Facebook 的许可证几乎将它们完全忽略了。
1. 许可证审批很重要
使用非 OSI 批准的许可证意味着，就像任何专有许可证一样，将其应用于企业用途时总是需要法律审查。[OSI 许可证审批之所以重要](https://meshedinsights.com/2017/07/12/why-osi-license-approval-matters/)，是因为它为开发人员提供了一种指示，即社区评估已经认可了该许可证，并认为它以不会产生不可接受风险的方式提供了软件自由。如果 Facebook 采取了寻求 OSI 批准的路线，那么很有可能一开始就会发现并且回避了他造成的问题。实际上有一种 OSI 批准的许可证能够实现 Facebook 的明确目标（[BSD + 专利许可证](https://opensource.org/licenses/BSDplusPatent)）。该许可证最近刚被提交和批准，这看起来是 Facebook 可以考虑采用的合理替代方案。
2. 较少的提前许可
不仅仅是许可证批准很重要。任何有关创新自由的不确定性都会阻碍开发人员使用代码。与使用相关的含糊条款在使用前需要消除歧义——该步骤相当于为了继续推进而寻求许可。出于同样的原因，[公共领域对于软件开发者来说是不利的](https://meshedinsights.com/2017/03/16/public-domain-is-not-open-source/)，因为使用条款规定了在采用之前需要寻求许可。由于需要向项目添加一个与 Facebook 相关的法律文件，每个企业开发人员现在都需要与法律顾问联系，才能继续推进。即使答案是“是的，可以”，他们仍然不得不停下来寻求许可。[正如 Aaron Williamson 指出的那样](https://github.com/facebook/react/issues/10191#issuecomment-316380810)，这可能不是他们的反应。
3. 不公平的比赛场
Facebook 使用的专利授权条款为其提供了特殊权利和保护，而项目中的其他人并不享有。这使得开源开发人员感到紧张，原因与<ruby> <a href="https://webmink.com/2010/09/01/copyright-aggregation/"> 贡献者协议 </a> <rp> （ </rp> <rt> contributor agreements </rt> <rp> ） </rp></ruby>一样。开源项目的软件自由的全部价值在于它创造了一个[安全的空间](https://meshedinsights.com/2017/05/03/is-the-gpl-really-declining/#safe)，在其中每个人都是平等的，它保护每个人免受他人动机的影响。刻意为自己设置额外权利是反社会的行为，可悲的是，开源社区有很多不平等权利最终被滥用的例子。
4. 隐含的授权无效
许多开源法律机构认为，通过对用于任何目的的软件使用授予许可，即使没有提及专利的许可证也隐含授予专利许可。通过添加任意形式的外部专利授权，Facebook 表示它不认为隐含授权足够（最好的情形）或存在（最差的情形）。专注于开源软件的律师们认为，这是 Facebook 毫无根据的扩大化解释。这也是[为什么 OSI 放弃了对 CC0 许可协议批准的原因](https://opensource.org/faq#cc-zero)。
5. Apache 基金会的规则
虽然我没有找到清晰和完整的理由，但 Apache 基金会似乎已经对 Facebook 的许可证组合做出了裁定，因为 Apache 基金会认为，Facebook 的专利授权比 Apache v2 许可证中的专利条款限制性更强。Apache 基金会希望自身是一个中立的软件来源——一个“万能供血者”，而对此产生妨害的条款很有可能违背其规则。对于旨在成为 Apache 生态系统一部分的组件，与 Apache 的许可证产生混乱的做法看起来不太明智。
所以争论这个问题没有什么意义，因为风险很小，问题微不足道。以一种忽视我上面列出的五个社区规范的方式行动无益于任何人，甚至也帮不了 Facebook。虽然 [Facebook 目前正在坚持己见](https://code.facebook.com/posts/112130496157735/explaining-react-s-license/)，但我希望它能够改正，我愿意提供帮助。
---
作者简介：Simon Phipps 是<ruby> “公开软件” <rp> （ </rp> <rt> Public Software </rt> <rp> ） </rp></ruby>开源项目的发起人，以志愿者身份担任 OSI 和<ruby> 文档基金会 <rp> （ </rp> <rt> The Document Foundation </rt> <rp> ） </rp></ruby>的理事。
**译者简介：**薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
WordPress 和 React 分手后，你支持使用哪种 JavaScript 框架替代？
|
Ahmad Awais
|
https://ahmadawais.com/wordpress-react-vue-preact-development/
|
其中， VueJS 和 Preact 的呼声最高。关于它们的优劣势分析如下：
|
/data/attachment/album/201709/18/130121lzzdydkl1mpmdrgp.jpg.thumb.jpg
|
/data/attachment/album/201709/18/130121lzzdydkl1mpmdrgp.jpg
| true | false | true |
wxy
| false |
[
"WordPress",
"React"
] |
观点
|
{
"viewnum": 6491,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "61.183.225.66",
"message": "劣势：依赖于关键人物<br />\r\n那Linux也别用了",
"username": "来自湖北武汉的 Firefox 55.0|GNU/Linux 用户",
"date": "2017-09-19T08:52:53"
}
] |
[] |
其中， VueJS 和 Preact 的呼声最高。关于它们的优劣势分析如下：
| 2017-09-18T13:01:00 | 2017-09-18T13:01:00 | 8,877 |
/article-8877-1.html
|
WordPress 和 ReactJS 分道扬镳了，WordPress 的共同创始人 Matt Mullenweg 在其博客中[宣布](https://ma.tt/2017/09/on-react-and-wordpress/)了这一消息。
关于 WordPress 之后将采用何种 JavaScript 框架，Matt 并未宣布，目前几个选择：
1. [VueJS](https://vuejs.org/)
2. [Preact](https://preactjs.com/)
3. 其它框架（[Angular](https://angularjs.org/)、 [Ember](https://www.emberjs.com/)、 [Polymer](https://www.polymer-project.org/)、 [Aurelia](http://aurelia.io/) 等等）
其中， VueJS 和 Preact 的呼声最高。关于它们的优劣势分析如下：
**[VueJS](https://vuejs.org/)：**
* **优势：易于学习**
* **优势：与 Laravel 一贯协作良好**
* **优势：比 Preact 更流行，支持的社区更多**
* **优势：贡献者比 Preact 更多**
* *劣势**：**依赖于关键人物*
* **状态：**Github 上有 [133](https://github.com/vuejs/vue/graphs/contributors) 个核心贡献者，[67152](https://github.com/vuejs/vue/stargazers) 个星标，做了 [209](https://github.com/vuejs/vue/releases) 次发布
* **资金支持：截止至本文写作，** 在社区的支持下，[VueJS 在 OpenCollective](https://opencollective.com/vuejs) 得到了每年 $9,895 的捐助，作者尤雨溪在 [Patreon](https://www.patreon.com/evanyou) 得到了每月 $8,815 的捐助。
我确信 WordPress 使用 VueJS 能够更好。VueJS 有大量的拥护者，而且初学者易于上手。如果采用 VueJS，这对于 WordPress 是极好的。我自己也在几个项目中使用 VueJS，我喜欢它。
此外，这个框架也可以用在 WordPress 之外的项目（比如 Vue 与 Laravel 的集成），这可以让开发者在 WordPress 项目和非 WordPress 项目中发挥其经验。 有很多开发者都同时参与 Laravel 和 WordPress 项目，所以如果使用同一个框架，有助于同时推动 Laravel、 VueJS 和 WordPress 的发展。
**[PreactJS](https://preactjs.com/)：**
* **优势：易于过渡**
* **优势：与 VueJS 大致相同的资金支持，不断推进的社区**
* **优势：基于 React 的子集库仍然被 Preact** 和 compat 支持
* *劣势：过渡也许导致代码混乱和困扰（针对初学者）*
* *劣势：依赖于关键人物*
* **状态：在 GitHub 上有** [100](https://github.com/developit/preact/graphs/contributors) 个核心贡献者， [14319](https://github.com/developit/preact/stargazers) 个星标，做了 [114](https://github.com/developit/preact/releases) 次发布
* **资金支持：**截止至本文写作，在社区的支持下， Preact 在 [OpenCollective](https://opencollective.com/preact) 得到了 $16,087 的捐助
PreactJS 有其优势，但我找不到合适的人咨询（我仅在两个项目中稍微使用过它）。不过看起来从 React 过渡到 Preact 非常容易。这也许会促使开发者选择 Preact，但是我认为这不是选择它的理由。这只会让开发者在采用这个新的 JavaScript 框架生态、node 模块、Webpack 时发生混淆，Preact 又不是 React 的别名！这会让代码味道难闻。
本文作者在几个平台上做了投票，欢迎参与你的意见：
* [Twitter 投票](https://twitter.com/MrAhmadAwais/status/908551927264305152)
* Facebook 讨论：Advanced WordPress Fb Group 的 [讨论](https://ahmda.ws/2h6skDa) & [投票](https://ahmda.ws/2h5ZPFD)
* GitHub Issue: [Choosing the JavaScript Framework for Gutenberg (~WordPress)](https://github.com/WordPress/gutenberg/issues/2733)
那么你的意见呢？
（题图：maxprog.net.pl）
|
||
创建更好的灾难恢复计划
|
Nikki Mcdonald, Tanya Reilly
|
https://www.oreilly.com/ideas/creating-better-disaster-recovery-plans
|
Tanya Reilly 的五个问题：相互依赖的服务如何使恢复更加困难，为什么有意并预先管理依赖是个好主意。
|
/data/attachment/album/201709/18/181034o77kf9ee9dpf9dpn.jpg.thumb.jpg
|
/data/attachment/album/201709/18/181034o77kf9ee9dpf9dpn.jpg
| true | false | true |
geekpi
| false |
[
"灾难恢复",
"备份"
] |
系统运维
|
{
"viewnum": 4873,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Tanya Reilly 的五个问题：相互依赖的服务如何使恢复更加困难，为什么有意并预先管理依赖是个好主意。
| 2017-09-19T09:09:00 | 2017-09-19T09:09:00 | 8,879 |
/article-8879-1.html
|
>
> Tanya Reilly 的五个问题：相互依赖的服务如何使恢复更加困难，为什么有意并预先管理依赖是个好主意。
>
>
>
我最近请 Google 的网站可靠性工程师 Tanya Reilly 分享了她关于如何制定更好的灾难恢复计划的想法。Tanya 将在 10 月 1 日到 4 日在纽约举行的 O'Reilly Velocity Conference 上发表了一个题为《[你有没有试着把它关闭之后再打开？](https://conferences.oreilly.com/velocity/vl-ny/public/schedule/detail/61400?intcmp=il-webops-confreg-reg-vlny17_new_site_creating_better_disaster_recovery_plans_body_text_cta)》的演讲。
### 1、 在计划备份系统策略时，人们最常犯的错误是什么？
经典的一条是“**你不需要备份策略，你需要一个恢复策略**”。如果你有备份，但你尚未测试恢复它们，那么你没有真正的备份。测试不仅仅意味着知道你可以获得数据，还意味着知道如何把它放回数据库，如何处理增量更改，甚至如果你需要的话，如何重新安装整个系统。这意味着确保你的恢复路径不依赖于与数据同时丢失的某些系统。
但测试恢复是枯燥的。这是人们在忙碌时会偷工减料的那类事情。这值得花时间使其尽可能简单、无痛、自动化，永远不要靠任何人的意志力！同时，你必须确保有关人员知道该怎么做，所以定期进行大规模的灾难测试是很好的。恢复演练是个好方法，可以找出该过程的文档是否缺失或过期，或者你是否没有足够的资源（磁盘、网络等）来传输和重新插入数据。
### 2、 创建<ruby> 灾难恢复 <rt> disaster recovery </rt></ruby> （DR） 计划最常见的挑战是什么？
我认为很多 DR 是一种事后的想法：“我们有这个很棒的系统，我们的业务依赖它……我猜我们应该为它做 DR？”而且到那时，系统会非常复杂，充满相互依赖关系，很难复制。
第一次安装的东西，它通常是由人手动调整才正常工作的，有时那是个具体特定的版本。当你构建*第二*个时，很难确定它是完全一样的。即使在具有严格的配置管理的站点中，你也可能丢了某些东西，或者过期了。
例如，如果你已经失去对解密密钥的访问权限，那么加密备份没有太多用处。而且任何只在灾难中使用的部分都可能从你上次检查它们过后就破环了。确保你已经涵盖了所有东西的唯一方法做认真地故障切换。当你准备好了的，就计划一下你的灾难（演练）吧！
如果你可以设计系统，以使灾难恢复模式成为正常运行的一部分，那么情况会更好。如果你的服务从一开始就被设计为可复制的，添加更多的副本就是一个常规的操作并可能是自动化的。没有新的方法，这只是一个容量问题。但是，系统中仍然存在一些只能在一个或两个地方运行的组件。偶然计划中的假灾难能够很好地将它们暴露出来。
顺便说一句，那些被遗忘的组件可能包括仅在一个人的大脑中的信息，所以如果你自己发现说：“我们不能在 X 休假回来前进行 DR 故障切换测试”，那么那个人是一个危险的单点失败。
仅在灾难中使用的部分系统需要最多的测试，否则在需要时会失败。这个部分越少越安全，且辛苦的测试工作也越少。
### 3、 为什么服务相互依赖使得灾难恢复更加困难？
如果你只有一个二进制文件，那么恢复它是比较容易的：你做个二进制备份就行。但是我们越来越多地将通用功能分解成单独的服务。微服务意味着我们有更多的灵活性和更少地重新发明轮子：如果我们需要一个后端做一些事情，并且有一个已经存在，那么很好，我们就可以使用它。但是一些需要保留很大的依赖关系，因为它很快会变得纠缠。
你可能知道你直接使用的后端，但是你可能不会注意到有新的后端添加到你使用的库中。你可能依赖于某个东西，它也间接依赖于你。在依赖中断之后，你可能会遇到一个死锁：两个系统都不能启动，直到另一个运行并提供一些功能。这是一个困难的恢复情况！
你甚至可以最终遇到间接依赖于自身的东西，例如你需要配置启动网络的设备，但在网络关闭时无法访问该设备。人们通常会提前考虑这些循环依赖，并且有某种后备计划，但是这些本质上是不太行得通的方式：它们只适用于极端情况，并且以不同的方式使用你的系统、进程或代码。这意味着，它们很可能有一个不会被发现的问题，直到你真的，真的需要它们的工作的时候才发现。
### 4、 你建议人们在感觉需要之前就开始有意管理其依赖关系，以防止潜在的灾难性系统故障。为什么这很重要，你有什么建议有效地做到这一点？
管理你的依赖关系对于确保你可以从灾难中恢复至关重要。它使操作系统更容易。如果你的依赖不可靠，那么你就不可靠，所以你需要知道它们是什么。
虽然在它们变得混乱后也可以开始管理依赖关系，但是如果你早点开始，它会变得更容易一些。你可以设置使用各种服务策略——例如，你必须在堆栈中的这一层依赖于这组系统。你可以通过使其成为设计文件审查的常规部分，引入考虑依赖关系的习惯。但请记住，依赖关系列表将很快变得陈旧。如果你有程序化的发现依赖关系的方式，甚至强制实施依赖，这是最好的。 [我的 Velocity 谈话](https://conferences.oreilly.com/velocity/vl-ny/public/schedule/detail/61400?intcmp=il-webops-confreg-reg-vlny17_new_site_creating_better_disaster_recovery_plans_body_text_cta)涵盖了我们如何做到这一点。
早期开始的另一个优点是，你可以将服务拆分为垂直“层”，每个层中的功能必须能够在下一个层启动之前完全在线。所以，例如，你可以说网络必须能够完全启动而不借助任何其他服务。然后说，你的存储系统应该仅仅依赖于网络，程序后端应该仅仅依赖于网络和存储，等等。不同的层次对于不同的架构是有意义的。
如果你提前计划，新服务更容易选择依赖关系。每个服务应该只依赖堆栈中较低的服务。你仍然可以结束循环，在相同的层次服务上批次依赖 —— 但是它们可以更加紧密地包含，并且在逐个基础上处理更容易。
### 5、 你对 Velocity NY 的其他部分感兴趣么？
我整个星期二和星期三的时间表都完成了！正如你可能收集的那样，我非常关心大型相互依赖的系统的可管理性，所以我期待听到 [Carin Meier 关于管理系统复杂性的想法](https://conferences.oreilly.com/velocity/vl-ny/public/schedule/detail/62779?intcmp=il-webops-confreg-reg-vlny17_new_site_creating_better_disaster_recovery_plans_body_text_cta)、[Sarah Wells 的微服务](https://conferences.oreilly.com/velocity/vl-ny/public/schedule/detail/61597?intcmp=il-webops-confreg-reg-vlny17_new_site_creating_better_disaster_recovery_plans_body_text_cta)和 [Baron 的可观察性](https://conferences.oreilly.com/velocity/vl-ny/public/schedule/detail/61630?intcmp=il-webops-confreg-reg-vlny17_new_site_creating_better_disaster_recovery_plans_body_text_cta) 的谈话。我非常着迷听到 [Jon Moore 关于 Comcast 如何从年度发布到每天发布的故事](https://conferences.oreilly.com/velocity/vl-ny/public/schedule/detail/62733?intcmp=il-webops-confreg-reg-vlny17_new_site_creating_better_disaster_recovery_plans_body_text_cta)。作为一个前系统管理员，我很期待听到 [Bryan Liles 对这个职位走向的看法](https://conferences.oreilly.com/velocity/vl-ny/public/schedule/detail/62893?intcmp=il-webops-confreg-reg-vlny17_new_site_creating_better_disaster_recovery_plans_body_text_cta)。
---
作者简介：
Nikki McDonald 是 O'Reilly Media，Inc. 的内容总监。她住在密歇根州的安娜堡市。
Tanya Reilly 自 2005 年以来一直是 Google 的系统管理员和站点可靠性工程师，致力于分布式锁、负载均衡和引导等底层基础架构。在加入 Google 之前，她是爱尔兰最大的 ISP eircom.net 的系统管理员，在这之前她担当了一个小型软件公司的整个 IT 部门。
---
via: <https://www.oreilly.com/ideas/creating-better-disaster-recovery-plans>
作者：[Nikki McDonald](https://www.oreilly.com/people/nikki-mcdonald), [Tanya Reilly](https://www.oreilly.com/people/5c97a-tanya-reilly) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
WordPress 弃用 React，并将进行重写
|
Matt Mullenweg
|
https://ma.tt/2017/09/on-react-and-wordpress/
|
开源网络出版软件 WordPress 的联合创始人 Matt Mullenweg 日前表示，出于对 Facebook 开源许可证中专利条款的担忧，WordPress 社区将不再使用 Facebook 的 React JavaScript 库。
|
/data/attachment/album/201709/18/232208x17gcatccufupuuj.jpg.thumb.jpg
|
/data/attachment/album/201709/18/232208x17gcatccufupuuj.jpg
| true | false | true |
薛亮
| false |
[
"WordPress",
"React"
] |
开源智慧
|
{
"viewnum": 5446,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8876,
"displayorder": 0
},
{
"raid": 8895,
"displayorder": 0
},
{
"raid": 8910,
"displayorder": 0
}
] |
开源网络出版软件 WordPress 的联合创始人 Matt Mullenweg 日前表示，出于对 Facebook 开源许可证中专利条款的担忧，WordPress 社区将不再使用 Facebook 的 React JavaScript 库。
| 2017-09-19T08:46:00 | 2017-09-19T08:46:00 | 8,880 |
/article-8880-1.html
|
开源网络出版软件 WordPress 的联合创始人 Matt Mullenweg 日前[表示](https://ma.tt/2017/09/on-react-and-wordpress/)，出于对 Facebook 开源许可证中专利条款的担忧，WordPress 社区将不再使用 Facebook 的 React JavaScript 库。
Mullenweg 在一篇[博客文章](https://ma.tt/2017/09/on-react-and-wordpress/)中对其决定做出了解释。几个星期之前，即便是在 Apache 基金会表示了[不再允许其项目使用 Facebook 许可证](https://issues.apache.org/jira/browse/LEGAL-303)后，Facebook 还是[决定保留](https://code.facebook.com/posts/112130496157735/explaining-react-s-license/)其在 React 许可证中附加的专利条款。Mullenweg 认为，试图去删除该专利条款将“增加他们在对抗无事实根据的诉讼方面所花费的时间和费用”。
Mullenweg 表示，他不是在评论 Facebook 或者认为 Facebook 错了。Facebook 的决定对于 Facebook 来说是正确的，这是他们的工作，Facebook 可以决定以任何他们想要的方式来授权其软件。但对于 Mullenweg 来说，Facebook 的意图已经非常明确了。
几年之前，[Automattic 将 React 作为基础来重写 WordPress.com 的前端 Calypso](https://developer.wordpress.com/calypso/)，这应该是基于 React 的最大的开源项目之一。正如 Automattic 的法律顾问所写，[Automattic 做出了最好不要牵涉到专利问题的决定](https://github.com/Automattic/wp-calypso/issues/650#issuecomment-235086367)，在今天仍是如此。
总体来说，Mullenweg 过去一直对 React 很满意。最近，WordPress 社区开始将 React 用于 [Gutenberg](https://make.wordpress.org/core/2017/02/17/dev-chat-summary-february-15th-4-7-3-week-3/) 项目，[这是该社区多年以来最大的核心项目](https://ma.tt/2017/08/we-called-it-gutenberg-for-a-reason/)。人们在 React 方面的经验以及 React 社区（包括 Calypso）的规模，是 WordPress 将 React 用于 Gutenberg 项目的考虑因素之一。这使得 React 成为 WordPress 以及为 WordPress 编写的数以万计插件的事实上的标准。
Mullenweg 在博客里表示，WordPress 曾准备了一份几千字的公告，阐述了 React 是多么伟大，WordPress 如何正式采用了 React，以及鼓励插件同样采用 React。在该公告中，Mullenweg 一直希望专利问题能够以一种让用户放心使用的方式解决。
但这份公告现在不会被公布了。Mullenweg 表示，Gutenberg 项目将会退而采用另外的库来进行重写。这使得 Gutenberg 项目至少要延迟几个星期，其发布日期可能要推到明年。
Automattic 还将采用另外的同样的库来重写 Calypso，这将需要更长的时间。Automattic 目前还未牵涉到专利条款的问题当中。虽然会对业务造成短期影响，但是从内核的长期一致性来考虑，重写是值得的。WordPress 的内核升级涉及到全部网页的四分之一以上，让它们全部继承专利条款问题令人担忧。
Mullenweg 认为，Facebook 的专利条款实际上比许多公司可以采取的其他方法更清晰，Facebook 已经成为不错的开源贡献者之一。让全世界夸赞 Facebook 专利条款不是 Automattic 的工作，而是 Facebook 自己的战斗。
Mullenweg 在博客中表示，采用哪个库来重写将会在另外的帖子中公布，这主要是技术性的决定。Automattic 将会寻求具备 React 的大部分优势，同时又没有给许多人造成混淆和威胁的专利条款包袱的替代选择，并请大家就这些问题提供反馈。目前针对替换的库已经有了[几个建议](/article-8877-1.html)，包括 VueJS 、Preact 等。
另据 [TechCrunch 报道](https://techcrunch.com/2017/09/15/wordpress-to-ditch-react-library-over-facebook-patent-clause-risk/)，针对 Facebook 公司的专利条款，一些最激烈的批评家认为其将“特洛伊木马”引入了开源社区。对于 Mullenweg 在博客中发布的决定，一位评论家称之为“艰难但重要的决定”，其他评论家则将其称为“明智”和“有益”的决定。
而另外一些评论则发出了警告：“不要过度反应。过去五六年来，WordPress 生态系统的动荡和流失已经足够多了。Facebook 的业务规模和范围使得该条款变得非常可怕。它们最终必须放弃。”
---
**译者简介：**薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
在 Kubernetes 集群中运行 WordPress
|
Gilbert Pellegrom
|
https://deliciousbrains.com/running-wordpress-kubernetes-cluster/
|
在这篇文章中，我们将会从一些简单的操作开始，了解一下 Kubernetes 平台，看看如何将一个 WordPress 网站部署在本地机器上的一个单节点集群中。
|
/data/attachment/album/201709/19/092435z39irasw73b99rqb.jpg.thumb.jpg
|
/data/attachment/album/201709/19/092435z39irasw73b99rqb.jpg
| true | false | true |
StdioA
| false |
[
"Kubernetes",
"WordPress",
"容器"
] |
容器与云
|
{
"viewnum": 6118,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇文章中，我们将会从一些简单的操作开始，了解一下 Kubernetes 平台，看看如何将一个 WordPress 网站部署在本地机器上的一个单节点集群中。
| 2017-09-19T09:24:31 | 2017-09-19T09:24:31 | 8,881 |
/article-8881-1.html
|
作为一名开发者，我会尝试留意那些我可能不会每天使用的技术的进步。了解这些技术至关重要，因为它们可能会间接影响到我的工作。比如[由 Docker 推动](http://www.zdnet.com/article/what-is-docker-and-why-is-it-so-darn-popular/)的、近期正在兴起的容器化技术，可用于上规模地托管 Web 应用。从技术层面来讲，我并不是一个 DevOps，但当我每天构建 Web 应用时，多去留意这些技术如何去发展，会对我有所裨益。
这种进步的一个绝佳的例子，是近一段时间高速发展的容器编排平台。它允许你轻松地部署、管理容器化应用，并对它们的规模进行调整。目前看来，容器编排的流行工具有 [Kubernetes （来自 Google）](https://kubernetes.io/)，[Docker Swarm](https://docs.docker.com/engine/swarm/) 和 [Apache Mesos](http://mesos.apache.org/)。如果你想较好的了解上面那些技术以及它们的区别，我推荐你看一下[这篇文章](https://mesosphere.com/blog/docker-vs-kubernetes-vs-apache-mesos/)。
在这篇文章中，我们将会从一些简单的操作开始，了解一下 Kubernetes 平台，看看如何将一个 WordPress 网站部署在本地机器上的一个单节点集群中。
### 安装 Kubernetes
在 [Kubernetes 文档](https://kubernetes.io/docs/tutorials/kubernetes-basics/)中有一个很好的互动教程，涵盖了很多东西。但出于本文的目的，我只会介绍在 MacOS 中 Kuberentes 的安装和使用。
我们要做的第一件事是在你的本地主机中安装 Kubernetes。我们将使用一个叫做 [MiniKube](https://kubernetes.io/docs/getting-started-guides/minikube/) 的工具，它专门用于在你的机器上方便地设置一个用于测试的 Kubernetes 集群。
根据 Minikube 文档，在我们开始之前，有一些先决条件。首先要保证你已经安装了一个 Hypervisor （我将会使用 Virtualbox）。接下来，我们需要[安装 Kubernetes 命令行工具](https://kubernetes.io/docs/tasks/tools/install-kubectl/)（也就是 `kubectl`）。如果你在用 Homebrew，这一步非常简单，只需要运行命令：
```
$ brew install kubectl
```
现在我们可以真正 [安装 Minikube](https://github.com/kubernetes/minikube/releases) 了：
```
$ curl -Lo minikube https://storage.googleapis.com/minikube/releases/v0.21.0/minikube-darwin-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/
```
最后，我们要[启动 Minicube](https://kubernetes.io/docs/getting-started-guides/minikube/#quickstart) 创建一个虚拟机，来作为我们的单节点 Kubernetes 集群。现在我要说一点：尽管我们在本文中只在本地运行它，但是在[真正的服务器](https://kubernetes.io/docs/tutorials/kubernetes-basics/)上运行 Kubernetes 集群时，后面提到的大多数概念都会适用。在多节点集群上，“主节点”将负责管理其它工作节点（虚拟机或物理服务器），并且 Kubernetes 将会在集群中自动进行容器的分发和调度。
```
$ minikube start --vm-driver=virtualbox
```
### 安装 Helm
现在，本机中应该有一个正在运行的（单节点）Kubernetes 集群了。我们现在可以用任何方式来与 Kubernetes 交互。如果你想现在可以体验一下，我觉得 [kubernetesbyexample.com](http://kubernetesbyexample.com/) 可以很好地向你介绍 Kubernetes 的概念和术语。
虽然我们可以手动配置这些东西，但实际上我们将会使用另外的工具，来将我们的 WordPress 应用部署到 Kubernetes 集群中。[Helm](https://docs.helm.sh/) 被称为“Kubernetes 的包管理工具”，它可以让你轻松地在你的集群中部署预构建的软件包，也就是“<ruby> 图表 <rt> chart </rt></ruby>”。你可以把图表看做一组专为特定应用（如 WordPress）而设计的容器定义和配置。首先我们在本地主机上安装 Helm：
```
$ brew install kubernetes-helm
```
然后我们需要在集群中安装 Helm。 幸运的是，只需要运行下面的命令就好：
```
$ helm init
```
### 安装 WordPress
现在 Helm 已经在我们的集群中运行了，我们可以安装 [WordPress 图表](https://kubeapps.com/charts/stable/wordpress)。运行：
```
$ helm install --namespace wordpress --name wordpress --set serviceType=NodePort stable/wordpress
```
这条命令将会在容器中安装并运行 WordPress，并在容器中运行 MariaDB 作为数据库。它在 Kubernetes 中被称为“Pod”。一个 [Pod](https://kubernetes.io/docs/tutorials/kubernetes-basics/explore-intro/) 基本上可视为一个或多个应用程序容器和这些容器的一些共享资源（例如存储卷，网络等）的组合的抽象。
我们需要给这个部署一个名字和一个命名空间，以将它们组织起来并便于查找。我们同样会将 `serviceType` 设置为 `NodePort` 。这一步非常重要，因为在默认设置中，服务类型会被设置为 `LoadBalancer`。由于我们的集群现在没有负载均衡器，所以我们将无法在集群外访问我们的 WordPress 站点。
在输出数据的最后一部分，你会注意到一些关于访问你的 WordPress 站点的有用的命令。运行那些命令，你可以获取到我们的 WordPress 站点的外部 IP 地址和端口：
```
$ export NODE_PORT=$(kubectl get --namespace wordpress -o jsonpath="{.spec.ports[0].nodePort}" services wordpress-wordpress)
$ export NODE_IP=$(kubectl get nodes --namespace wordpress -o jsonpath="{.items[0].status.addresses[0].address}")
$ echo http://$NODE_IP:$NODE_PORT/admin
```
你现在访问刚刚生成的 URL（忽略 `/admin` 部分），就可以看到 WordPress 已经在你的 Kubernetes 集群中运行了！
### 扩展 WordPress
Kubernetes 等服务编排平台的一个伟大之处，在于它将应用的扩展和管理变得易如反掌。我们看一下应用的部署状态：
```
$ kubectl get deployments --namespace=wordpress
```
[](https://cdn.deliciousbrains.com/content/uploads/2017/08/07120711/image4.png)
可以看到，我们有两个部署，一个是 Mariadb 数据库，一个是 WordPress 本身。现在，我们假设你的 WordPress 开始承载大量的流量，所以我们想将这些负载分摊在多个实例上。我们可以通过一个简单的命令来扩展 `wordpress-wordpress` 部署：
```
$ kubectl scale --replicas 2 deployments wordpress-wordpress --namespace=wordpress
```
再次运行 `kubectl get deployments`，我们现在应该会看到下面的场景：
[](https://cdn.deliciousbrains.com/content/uploads/2017/08/07120710/image2.png)
你刚刚扩大了你的 WordPress 站点规模！超级简单，对不对？现在我们有了多个 WordPress 容器，可以在它们之中对流量进行负载均衡。想了解 Kubernetes 扩展的更多信息，参见[这篇指南](https://kubernetes.io/docs/tutorials/kubernetes-basics/scale-intro/)。
### 高可用
Kubernetes 等平台的的另一大特色在于，它不单单能进行方便的扩展，还可以通过自愈组件来提供高可用性。假设我们的一个 WordPress 部署因为某些原因失效了，那 Kubernetes 会立刻自动替换掉这个部署。我们可以通过删除我们 WordPress 部署的一个 pod 来模拟这个过程。
首先运行命令，获取 pod 列表：
```
$ kubectl get pods --namespace=wordpress
```
[](https://cdn.deliciousbrains.com/content/uploads/2017/08/07120711/image3.png)
然后删除其中一个 pod：
```
$ kubectl delete pod wordpress-wordpress-876183909-jqc8s --namespace=wordpress
```
如果你再次运行 `kubectl get pods` 命令，应该会看到 Kubernetes 立刻换上了新的 pod （`3l167`）。
[](https://cdn.deliciousbrains.com/content/uploads/2017/08/07120709/image1.png)
### 更进一步
我们只是简单了解了 Kubernetes 能完成工作的表面。如果你想深入研究，我建议你查看以下功能：
* [平行扩展](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/)
* [自愈](https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller)
* [自动更新及回滚](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#what-is-a-deployment)
* [密钥管理](https://kubernetes.io/docs/concepts/configuration/secret/)
你在容器平台上运行过 WordPress 吗？有没有使用过 Kubernetes（或其它容器编排平台），有没有什么好的技巧？你通常会怎么扩展你的 WordPress 站点？请在评论中告诉我们。
---
作者简介：
Gilbert 喜欢构建软件。从 jQuery 脚本到 WordPress 插件，再到完整的 SaaS 应用程序，Gilbert 一直在创造优雅的软件。 他粗昂做的最有名的的产品，应该是 Nivo Slider.
---
via: <https://deliciousbrains.com/running-wordpress-kubernetes-cluster/>
作者：[Gilbert Pellegrom](https://deliciousbrains.com/author/gilbert-pellegrom/) 译者：[StdioA](https://github.com/StdioA) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
React 许可证虽严苛，但不必过度 react
|
Heather Meeker
|
https://opensource.com/article/17/9/facebook-patents-license
|
与实际情况相比，这个争议更具倾向性。事实上，这样做不太可能影响 React.js 的采用，对 BSD +专利许可证（FB + PL）的批评大多数不能在理性的审视下成立。
|
/data/attachment/album/201709/19/132525q8pgn8pdd8xu8uux.jpg.thumb.jpg
|
/data/attachment/album/201709/19/132525q8pgn8pdd8xu8uux.jpg
| true | false | true |
薛亮
| false |
[
"Facebook",
"许可证",
"React"
] |
开源智慧
|
{
"viewnum": 5543,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "183.212.160.225",
"message": "标题起的很好，一语双关。哈哈。",
"username": "来自江苏南京的 Firefox 54.0|Windows 10 用户",
"date": "2017-09-24T00:03:25"
}
] |
[
{
"raid": 8733,
"displayorder": 0
},
{
"raid": 8784,
"displayorder": 1
}
] |
与实际情况相比，这个争议更具倾向性。事实上，这样做不太可能影响 React.js 的采用，对 BSD +专利许可证（FB + PL）的批评大多数不能在理性的审视下成立。
| 2017-09-21T10:14:00 | 2017-09-21T10:14:00 | 8,882 |
/article-8882-1.html
|
>
> 对 Apache 基金会禁止将 BSD+专利许可证（FB + PL）用于其项目的批评，在理性的审视之下是无法成立的。
>
>
>
最近，Apache 基金会将 Facebook 公司 BSD + 专利许可证下的代码重新分类为 “X 类”，从而有效地阻止了其未来对 Apache 基金会项目的贡献。这一举动再度引发了对专利授权的[争议](/article-8733-1.html)，但是像开源社区的许多事件一样，与实际情况相比，这个争议更具倾向性。事实上，这样做不太可能影响 React.js 的采用，对 BSD +专利许可证（FB + PL）的批评大多数不能在理性的审视下成立。
官方名称为“[专利权的补充授权第二版](https://github.com/facebook/react/blob/master/PATENTS)”的 Facebook 专利授权条款已经生效多年。它用于非常受欢迎的 React.js 代码，该代码是一种用于呈现用户界面的 JavaScript 库。[使用该代码的主要技术公司的名单令人印象深刻](http://reactkungfu.com/2015/07/big-names-using-react-js/)，其中包括像 Netflix 这样面向消费者的巨头公司，当然还有 Facebook 自身。（LCTT 译注：国内包括百度、阿里云等顶级互联网公司也在使用它，但是据闻这些公司在纷纷考虑更换对该库的依赖。）
### **对旧授权的新反应**
对这个消息的反应是令人惊讶的，因为并行专利许可模式并不是什么新鲜事。 Facebook 在 2013 年发布了 BSD + 专利授权许可证（2015 年进行了修订）。而 Google 2010 年也在 WebM 编解码器上有些高调地使用了类似的模型。该许可模式涉及两个并列和同时授权的权利：软件版权的 BSD 许可，以及单独授予的执行该软件的专利授权。将两者合在一起意味着有两个独立和平行的授权权利。在这方面，它与 Apache 2.0 许可证非常相似，与 BSD 一样，Apache 2.0 是一个许可证，并且还包含与版权许可授权一起存在的防御性终止条款。
对 Apache 基金会通告的大部分反应造成了混乱，例如[有篇文章](https://www.theregister.co.uk/2017/07/17/apache_says_no_to_facebook_code_libraries/)误导性地称之为“陷阱”。**事实上，许多开源许可证都有防御性的终止条款，这些规定大多被认为是阻止专利诉讼的合理机制，而不是陷阱。**它们是规则而不是例外；所有具有专利授权的主要开源许可证也具有防御性的终止条款——虽然每个条款略有不同。在 Apache 所拒绝的 Facebook 专利授权与 Apache 对其项目所采取的 Apache 2.0 许可证之间，其中的区别比争议提出的更为微妙。
### **防御性终止条款有多种风格**
防御性终止条款在两个主要方面有所不同：终止条款的触发和权利终止的范围。
关于权利终止的范围，有两个阵营：仅终止专利授权（包括 Apache 2.0、Eclipse 公共许可证和 Facebook 专利授权）以及也同时终止版权许可（Mozilla 公共许可证和 GPL v3）。换句话说，对于大多数的许可证，提起专利侵权诉讼只能导致专利权的终止；对于其他许可证来说，提起专利诉讼能够同时导致版权许可的终止，即让某人停止使用该代码。版权许可终止是一个更强大的反专利机制，对于私营企业来说风险更大，因此导致一些私营公司拒绝使用 GPL v3 或 MPL 代码。
与大多数其他开源许可证相比，Facebook 专利授权触发终止的阈值不同。例如，在 Apache 2.0 中，专利授权的终止是由对该许可证下的软件提出指控的专利权利主张引发的。这个想法是为软件创建一个<ruby> “专利共同体” <rp> （ </rp> <rt> patent commons </rt> <rp> ） </rp></ruby>。大多数其他开源许可证大致遵循这个推演。（但在 Facebook 许可证中，）如果被许可人向 Facebook 或任何对 Facebook 产品提出指控的第三方提出权利主张，Facebook 专利许可也将终止。在这方面，终止触发机制类似于 IBM 多年前撰写的 Common Public License 1.0 （CPL）中的终止触发机制。（“如果接收者利用适用于本软件的专利对贡献者提出专利诉讼，则该贡献者根据本协议授予该接收者的任何专利许可，将在提起诉讼之日终止。”）
### **天下无新事**
Facebook 授权范围的防御性终止条款在开源场景之外的专利许可中很常见。如果被许可人向许可人提出专利权利主张，大多数专利许可将被终止。原因是许可人不想在专利战争中被单方面“解除武装”。大多数专利只有在竞争对手起诉专利所有人时才被防御性使用。A 起诉 B，然后 B 起诉 A，导致互相伤害。如果 B 在没有广泛的防御性终止条款的情况下以开源许可证发布其软件，则 B 可能没有追索权，并且为其开源代码的发布付出高昂的代价。A 在免费利用 B 的软件进行开发的同时，还起诉 B 专利侵权。
最后，Facebook 专利授权本身并不新鲜。该授权于 2013 年发布，自那时起，React.js 的受欢迎程度一直在增长。与许多开源许可证一样，行业忍受新许可证的意愿取决于其下发布的代码的质量。在 React.js 代码质量非常好的情况下，这个专利许可条款虽然是新的，但合理。
### **还是开源吗？**
有些人认为 BSD + 专利条款违反<ruby> <a href="https://opensource.org/osd-annotated"> “开源定义” </a> <rp> （ </rp> <rt> Open Source Definition </rt> <rp> ） </rp></ruby>。OSD 不接受歧视个人、团体或领域的许可证。但专利授权没有许可范围限制；如果被许可人有不当行为，许可就会终止，并且与其他人相比，针对代码作者的不当行为的触发门槛更低。因此，BSD + 专利许可似乎并不违反 OSD，而且 CPL 已经被 OSI 认可为合规的。如同 BSD + 专利许可一样，CPL 根据针对代码作者的专利诉讼，设定了一个较低的终止门槛。
### **结果是什么？**
Apache 基金会决定的实际结果尚不清楚。 遵循 X 类许可的代码不能包含在 Apache 基金会的存储库中（该类别还包括 GPL 等许可证）。Apache 的重新分类并不意味着任何人都不能使用 React.js——它只是不能在 Apache 项目中被提交。目前甚至不清楚 Apache 项目是否包含对 BSD + 专利许可代码的依赖。
同时，在私营企业中，根据 BSD + 专利条款使用代码几乎没有争议。大多数公司已经检查了该许可证与其他许可证（如 Apache 2.0）相比的边际法律风险，并认为没有需要特别注意的地方。除非公司决定起诉 Facebook（或指控其产品侵权），否则终止触发机制没有实际效果。如果您想要在开发和发布一大堆代码的公司中发起专利权利主张，将该代码从您的业务中删除似乎是一种合理的代价。
有些争议似乎起因于担心 Facebook 在许可条款中比其他人占优。但是，这与伤害开源社区是不一样的。与 Apache 2.0 一样，BSD + 专利授权以“专利共同体”为基准建立，但是为贡献者（Facebook）针对被许可人的软件专利权利主张提供了更多的保护。很奇怪的是，一个如此反对软件专利的社区会发现这是令人反感的，特别是考虑到过去使用的一系列防御性终止规定。
**请注意：此文章是关于 BSD + 专利许可，而不是关于 Facebook 公司。这篇文章仅代表作者的个人观点，而不是 Facebook 的观点。作者在开源事务上代表 Facebook，但作者没有起草 BSD + 专利许可证。**
（题图：techtimes.com）
---
作者简介：Heather Meeker 是 O’Melveny & Myers 硅谷办公室的合伙人，为客户提供技术交易和知识产权方面的建议，是国际知名的开源软件许可专家。Heather 于 2016 年获得加州律师协会知识产权先锋奖。<ruby> 《最佳律师》 <rp> （ </rp> <rt> Best Lawyers </rt> <rp> ） </rp></ruby>将她提名为 2018 年年度 IT 律师。
译者简介**：**薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
8 款适合树莓派使用的 IDE
|
Anand Nayyar
|
http://opensourceforu.com/2017/06/top-ides-raspberry-pi/
|
树莓派上拥有丰富的 IDE ，为程序员提供友好界面来开发源代码、应用程序以及系统程序。
|
/data/attachment/album/201709/20/112256xei2qtqgez2cd8gc.jpg.thumb.jpg
|
/data/attachment/album/201709/20/112256xei2qtqgez2cd8gc.jpg
| true | false | true |
softpaopao
| false |
[
"树莓派",
"IDE"
] |
树莓派
|
{
"viewnum": 59281,
"commentnum": 2,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.122.120.11",
"message": "树莓派当计算机用的话，更适合无人值守的低功耗微信服务器。开发什么的都不建议在上面进行，那上面更适合部署运行。",
"username": "来自四川成都的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-09-20T12:50:03"
},
{
"postip": "123.149.111.20",
"message": "有道理，那性能只适合轻量的项目",
"username": "来自河南郑州的 Chrome 61.0|Windows 10 用户",
"date": "2017-09-20T17:56:45"
}
] |
[] |
树莓派上拥有丰富的 IDE ，为程序员提供友好界面来开发源代码、应用程序以及系统程序。
| 2017-09-20T11:19:00 | 2017-09-20T11:19:00 | 8,885 |
/article-8885-1.html
|
树莓派是一种微型的单板电脑（SBC），已经在学校的计算机科学教学中掀起了一场革命，但同样，它也给软件开发者带来了福音。目前，树莓派获得的知名度远远超出了它原本的目标市场，而且正在应用于机器人项目中。
树莓派是一个可以运行 Linux 操作系统的微型开发板计算机，由英国树莓派基金会开发，用来在英国和发展中国家促进学校的基础计算机科学教育。树莓派拥有 USB 接口，能够支持多种即插即用外围设备，比如键盘、鼠标、打印机等。它包含了一个 HDMI（高清多媒体界面）端口，可以为用户提供视频输出。信用卡大小的尺寸使得树莓派非常便携且价格便宜。仅需一个 5V 的 micro-USB 电源供电，类似于给手机用的充电器一样。
多年来，树莓派基金会已经推出了几个不同版本的树莓派产品。 第一个版本是树莓派 1B 型，随后是一个相对简单便宜的 A 型。在 2014 年，基金会推出了一个增强版本 —— 树莓派 1B+。在 2015 年，基金会推出了全新设计的版本，售价为 5 美元，命名为树莓派 Zero。
在 2016 年 2 月，树莓派 3B 型发布，这也是现在可用的主要型号。在 2017 年，基金会发布了树莓派 Zero 的新型号树莓派 Zero W （W = wireless 无线）。
在不久的将来，一个提高了技术规格的型号将会到来，为嵌入式系统发烧友、研究员、爱好者和工程师们用其开发多种功能的实时应用提供一个稳健的平台。
*图 1 ：树莓派*
### 树莓派是一个高效的编程设备
在给树莓派供电后，启动运行 LXDE 窗口管理器，用户会获得一个完整的基于 Debian 的 Linux 操作系统，即 Raspbian。Raspbian 操作系统为用户提供了众多自由开源的程序，涵盖了程序设计、游戏、应用以及教育方面。
树莓派的官方编程语言是 Python ，并已预装在了 Paspbian 操作系统上。结合树莓派和 Python 的集成开发环境 IDLE3 ，可以让程序员能够开发各种基于 Python 的程序。
除了 Python ，树莓派还支持多种其它语言。并且可以使用一些自由开源的 IDE （集成开发环境）。允许程序员、开发者和应用工程师在树莓派上开发程序和应用。
### 树莓派上的最佳 IDE
作为一名程序员和开发者，你需要的首先就是有一个 IDE ，这是一个集成了开发者和程序员编写、编译和测试软件所需的的基本工具的综合软件套件。IDE 包含了代码编辑器、编译或解释程序和调试器，并允许开发者通过一个图形用户界面（GUI）来访问。IDE 的主要目的之一是提供一个整合单元来统一功能设置，减少组合多个开发工具的必要配置。
IDE 的用户界面与文字处理程序相似，在工具栏提供颜色编码、源代码格式化、错误诊断、报告以及智能代码补全工具。IDE 被设计用来整合第三方版本控制库如 GitHub 或 Apache Subversion 。一些 IDE 专注于特定的编程语言，支持一个匹配该编程语言的功能集，当然也有一些是支持多种语言的。
树莓派上拥有丰富的 IDE ，为程序员提供友好界面来开发源代码、应用程序以及系统程序。
就让我们来探索最适合树莓派的 IDE 吧。
#### BlueJ
*图 2 ：BlueJ 的 GUI 界面*
BlueJ 是一款致力于 Java 编程语言的 IDE ，主要是为教育目的而开发的。它也支持小型的软件开发项目。BlueJ 由澳大利亚的莫纳什大学的 Michael Kolling 和 John Rosenburg 在 2000 年作为 Blue 系统的继任者而开发的，后来在 2009 年 3 月成为自由开源软件。
BlueJ 提供一种学习面向对象的编程概念的高效的方式，图形用户界面为应用程序提供像 UML 图一样的类结构。每一个像类、对象和函数调用这样基于 OOPS 的概念，都可以通过基于交互的设计来表示。
**特性：**
* *简单的交互界面：* 与 NetBeans 或 Eclipse 这样的专业界面相比，BlueJ 的用户界面更加简易学。使开发者可以专注于编程而不是环境。
* *便携：* BlueJ 支持多种平台如 Windows、Linux 以及 Mac OS X ， 可以免安装直接运行。
* *新的创新：* BlueJ IDE 在对象工作台、代码块和范围着色方面有着大量的创新，使新手体验到开发的乐趣。
* *强大的技术支持：* BlueJ 拥有一个核心功能团队来解答疑问，并且在 24 小时内为开发者的各种问题提供解决方案。
**最新版本：** 4.0.1
#### Geany IDE
*图 3 ： Geany IDE 的 GUI 界面*
Geany IDE 使用了 Scintilla 和 GTK+ 的集成开发环境支持，被认为是一个非常轻量级的基于 GUI 的文本编辑器。 Geany 的独特之处在于它被设计为独立于特定的桌面环境，并且仅需要较少数量的依赖包。只需要 GTK2 运行库就可以运行。Geany IDE 支持多种编程语言如 C、C++、C#、Java、HTML、PHP、Python、Perl、Ruby、Erlang 和 LaTeX 。
**特性：**
* 代码自动补全和简单的代码导航。
* 高效的语法高亮和代码折叠。
* 支持嵌入式终端仿真器，拥有高度可扩展性，可以免费下载大量功能丰富的插件。
* 简单的项目管理并支持多种文件类型，包括 C、Java、PHP、HTML、Python、Perl 等。
* 高度定制的界面，可以添加或删除设置、栏及窗口。
**最新版本：** 1.30.1
#### Adafruit WebIDE
*图 4 ：Adafruit WebIDE 的 GUI 界面*
Adafruit WebIDE 为树莓派用户提供一个基于 Web 的界面来执行编程功能，并且允许开发者编译多种语言的源代码如 Python、Ruby、JavaScript 等。
Adafruit IDE 允许开发者把代码放在 GIT 仓库，这样就可以通过 GitHub 在任何地方进行访问。
**特性：**
* 可以通过 Web 浏览器的 8080 端口或 80 端口进行访问。
* 支持源代码的简单编译和运行。
* 配备一个调试器和可视器来进行正确追踪，代码导航以及测试源代码。
#### AlgoIDE
*图 5 ：AlgoIDE 的 GUI 界面*
AlgoIDE 结合了一个脚本语言和一个 IDE 环境，它被设计用来将编程与下一步的示例一起来运行。AlgoIDE 包含了一个强大的调试器、 实时范围管理器并且一步一步的执行代码。针对全年龄人群而设计，用来设计程序以及对算法进行大量的研究。
AlgoIDE 支持多种类型的语言如 C、C++、Python、Java、Smalltalk、Objective C、ActionScript 等。
**特性：**
* 代码自动缩进和补全。
* 高效的语法高亮和错误管理。
* 包含了一个调试器、范围管理器和动态帮助系统。
* 支持 GUI 和传统的 Logo 程序语言 Turtle 来进行源代码开发。
**最新版本：** 2016-12-08 （上次更新时间）
#### Ninja IDE
图 6 ：Ninja IDE 的 GUI 界面
Ninja IDE （“Ninja-IDE Is Not Just Another IDE”的缩写），由 Diego Sarmentero 、Horacio Duranm Gabriel Acosta 、Pedro Mourelle 和 Jose Rostango 设计，使用纯 Python 编写并且支持多种平台运行如 Linux 、Mac OS X 和 Windows 。Ninja IDE 被认为是一个跨平台的 IDE 软件，尤其是用来设计基于 Python 的应用程序。
Ninja IDE 是非常轻量级的，并能执行多种功能如文件处理、代码定位、跳转行、标签、代码自动缩进和编辑器缩放。除了 Python ，这款 IDE 也支持几种其他语言。
**特性：**
* *高效的代码编辑器：* Ninja-IDE 被认为是最有效的代码编辑器，因为它能执行多种功能如代码补全和缩进，以及助手功能。
* *错误和 PEP8 查找器：* 高亮显示文件中的静态和 PEP8 错误。
* *代码定位器：* 使用此功能，快速直接访问能够访问的文件。用户可以使用快捷键 “CTRL+K” 进行输入，IDE 会找到特定的文本。
* 独特的项目管理功能以及大量的插件使得具有 Ninja-IDE 高度可扩展性。
**最新版本：** 2.3
#### Lazarus IDE
图 7 ：Lazarus IDE 的 GUI 界面
Lazarus IDE 是由 Cliff Baeseman、Shane Miller 和 Michael A. Hess 于 1999 年 2 月 开发。它被视为是一款用于应用程序快速开发的基于 GUI 的跨平台 IDE ，使用的是 Free Pascal 编译器。Lazarus IDE 继承了 Free Pascal 的三个主要特性 —— 编译速度、执行速度和交叉编译。可以在多种操作系统上对应用程序进行交叉编译，如 Windows 、Linux 、Mac OS X 等。
这款 IDE 由 Lazarus 组件库组成。这些组件库以一个单一和带有不同的特定平台实现的统一接口的形式为开发者提供了多种配套设施。它支持“一次编写，随处编译”的原则。
**特性：**
* 强大而快速的处理各种类型的源代码，同时支持性能测试。
* 易用的 GUI ，支持组件拖拽功能。可以通过 Lazarus 包文件为 IDE 添加附加组件。
* 使用新功能加强的 Free Pascal ，可以用来开发 Android 应用。
* 高可扩展性、开放源代码并支持多种框架来编译其他语言。
**最新版本：** 1.6.4
#### Codeblock IDE
*图 8 ： Codeblock IDE 界面*
Codeblock IDE 是用 C++ 编写的，使用了 wxWidgets 作为 GUI 库，发布于 2005 年。它是一款自由开源、跨平台的 IDE ，支持多种类型的编译器如 GCC 、Clang 和 Visual C++ 。
Codeblock IDE 高度智能并且可以支持多种功能，如语法高亮、代码折叠、代码补全和缩进，同时也拥有一些扩展插件来进行定制。它可以在 Windows 、Mac OS X 和 Linux 操作系统上运行。
**特性：**
* 支持多种类型的编译器如 GCC 、Visual C++ 、Borland C++ 、Watcom 、Intel C++ 等。主要针对 C++ 而设计，不过现在也支持其他的一些语言。
* 智能的调试器，允许用户通过访问本地函数符号和参数显示，用户自定义监视、调用堆栈、自定义内存转储、线程切换以及 GNU 调试接口调试程序。
* 支持多种功能用来从 Dev-C++ 、Visual C++ 等平台迁移代码。
* 使用自定义系统和 XML 扩展文件来存储信息。
**最新版本：** 16.01
#### Greenfoot IDE
*图 9 ： Greenfoot IDE 界面*
Greenfoot IDE 是由肯特大学的 Michael Kolling 设计。它是一款基于 Java 的跨平台 IDE ，针对中学和大学教育目的而设计。Greenfoot IDE 的功能有项目管理、代码自动补全、语法高亮并提供一个简易的 GUI 界面。
Greenfoot IDE 编程包括两个主类的子类 —— World 和 Actor 。 World 表示主要执行发生的类，Actors 是已经存在且活动于 World 中的对象。
**特性：**
* 简单易用的 GUI ，比 BlueJ 和其他的 IDE 交互性更强。
* 易于新手和初学者上手。
* 在执行 Java 代码方面非常强大。
* 支持 GNOME/KDE/X11 图形环境。
* 其他功能包括项目管理、自动补全、语法高亮以及错误自动校正。
**最新版本：** 3.1.0
---
作者简介：
Anand Nayyar
作者是位于印度旁遮普邦的贾朗达尔学院计算机应用与 IT 系的教授助理。他热爱开源技术、嵌入式系统、云计算、无线传感器网络以及模拟器。可以在 [anand\_nayyar@yahoo.co.in](mailto:anand_nayyar@yahoo.co.in) 联系他。
---
via: <http://opensourceforu.com/2017/06/top-ides-raspberry-pi/>
作者：[Anand Nayyar](http://opensourceforu.com/author/anand-nayyar/) 译者：[softpaopao](https://github.com/softpaopao) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 文件系统概览
|
David Both
|
https://opensource.com/life/16/10/introduction-linux-filesystems
|
本文旨在高屋建瓴地来讨论 Linux 文件系统概念，而不是对某种特定的文件系统，比如 EXT4 是如何工作的进行具体的描述。另外，本文也不是一个文件系统命令的教程。
|
/data/attachment/album/201709/20/223948dyohb4oizo2kry2j.jpg.thumb.jpg
|
/data/attachment/album/201709/20/223948dyohb4oizo2kry2j.jpg
| true | false | true |
ucasFL
| true |
[
"文件系统"
] |
技术
|
{
"viewnum": 20885,
"commentnum": 2,
"favtimes": 6,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "117.37.97.55",
"message": "啦啦啦",
"username": "来自陕西咸阳的 Chrome Mobile 33.0|Android 4.4 用户",
"date": "2017-09-28T17:51:24"
},
{
"postip": "122.205.70.63",
"message": "赞一个",
"username": "来自湖北武汉华中农业大学的 Chrome 75.0|Windows 7 用户",
"date": "2019-08-05T17:51:53"
}
] |
[
{
"raid": 6132,
"displayorder": 0
},
{
"raid": 6907,
"displayorder": 1
},
{
"raid": 7669,
"displayorder": 2
},
{
"raid": 8289,
"displayorder": 3
},
{
"raid": 8757,
"displayorder": 4
}
] |
本文旨在高屋建瓴地来讨论 Linux 文件系统概念，而不是对某种特定的文件系统，比如 EXT4 是如何工作的进行具体的描述。另外，本文也不是一个文件系统命令的教程。
| 2017-09-21T09:35:00 | 2017-09-21T09:35:00 | 8,887 |
/article-8887-1.html
|
本文旨在高屋建瓴地来讨论 Linux 文件系统概念，而不是对某种特定的文件系统，比如 EXT4 是如何工作的进行具体的描述。另外，本文也不是一个文件系统命令的教程。
每台通用计算机都需要将各种数据存储在硬盘驱动器（HDD）或其他类似设备上，比如 USB 存储器。这样做有两个原因。首先，当计算机关闭以后，内存（RAM）会失去存于它里面的内容。尽管存在非易失类型的 RAM，在计算机断电以后还能把数据存储下来（比如采用 USB 闪存和固态硬盘的闪存），但是，闪存和标准的、易失性的 RAM，比如 DDR3 以及其他相似类型的 RAM 相比，要贵很多。
数据需要存储在硬盘驱动上的另一个原因是，即使是标准的 RAM 也要比普通硬盘贵得多。尽管 RAM 和硬盘的价格都在迅速下降，但是 RAM 的价格依旧在以字节为单位来计算。让我们进行一个以字节为单位的快速计算：基于 16 GB 大的 RAM 的价格和 2 TB 大的硬盘驱动的价格。计算显示 RAM 的价格大约比硬盘驱动贵 71 倍。今天，一个典型的 RAM 的价格大约是 0.000000004373750 美元/每字节。
直观的展示一下在很久以前 RAM 的价格，在计算机发展的非常早的时期，其中一种类型的 RAM 是基于在 CRT 屏幕上的点。这种 RAM 非常昂贵，大约 1 美元/每字节。
### 定义
你可能听过其他人以各种不同和令人迷惑的方式谈论过文件系统。文件系统这个单词本身有多重含义，你需要从一个讨论或文件的上下文中理解它的正确含义。
我将根据我所观察到的在不同情况下使用“文件系统”这个词来定义它的不同含义。注意，尽管我试图遵循标准的“官方”含义，但是我打算基于它的不同用法来定义这个术语（如下）。这就是说我将在本文的后续章节中进行更详细的探讨。
1. 始于顶层 root（`/`）目录的整个 Linux 目录结构。
2. 特定类型的数据存储格式，比如 EXT3、EXT4、BTRFS 以及 XFS 等等。Linux 支持近百种类型的文件系统，包括一些非常老的以及一些最新的。每一种文件系统类型都使用它自己独特的元数据结构来定义数据是如何存储和访问的。
3. 用特定类型的文件系统格式化后的分区或逻辑卷，可以挂载到 Linux 文件系统的指定挂载点上。
### 文件系统的基本功能
磁盘存储是文件系统必须的功能，它与之伴生的有一些有趣而且不可或缺的细节。很明显，文件系统是用来为非易失数据的存储提供空间，这是它的基本功能。然而，它还有许多从需求出发的重要功能。
所有文件系统都需要提供一个名字空间，这是一种命名和组织方法。它定义了文件应该如何命名、文件名的最大长度，以及所有可用字符集中可用于文件名中字符集子集。它也定义了一个磁盘上数据的逻辑结构，比如使用目录来组织文件而不是把所有文件聚集成一个单一的、巨大的文件混合体。
定义名字空间以后，元数据结构是为该名字空间提供逻辑基础所必须的。这包括所需数据结构要能够支持分层目录结构，同时能够通过结构来确定硬盘空间中的块是已用的或可用的，支持修改文件或目录的名字，提供关于文件大小、创建时间、最后访问或修改时间等信息，以及位置或数据所属的文件在磁盘空间中的位置。其他的元数据用来存储关于磁盘细分的高级信息，比如逻辑卷和分区。这种更高层次的元数据以及它所代表的结构包含描述文件系统存储在驱动器或分区中的信息，但与文件系统元数据无关，与之独立。
文件系统也需要一个应用程序接口（API），从而提供了对文件系统对象，比如文件和目录进行操作的系统功能调用的访问。API 也提供了诸如创建、移动和删除文件的功能。它也提供了算法来确定某些信息，比如文件存于文件系统中的位置。这样的算法可以用来解释诸如磁盘速度和最小化磁盘碎片等术语。
现代文件系统还提供一个安全模型，这是一个定义文件和目录的访问权限的方案。Linux 文件系统安全模型确保用户只能访问自己的文件，而不能访问其他用户的文件或操作系统本身。
最后一块组成部分是实现这些所有功能所需要的软件。Linux 使用两层软件实现的方式来提高系统和程序员的效率。
*图片 1：Linux 两层文件系统软件实现。*
这两层中的第一层是 Linux 虚拟文件系统。虚拟文件系统提供了内核和开发者访问所有类型文件系统的的单一命令集。虚拟文件系统软件通过调用特殊设备驱动来和不同类型的文件系统进行交互。特定文件系统的设备驱动是第二层实现。设备驱动程序将文件系统命令的标准集解释为在分区或逻辑卷上的特定类型文件系统命令。
### 目录结构
作为一个通常来说非常有条理的处女座，我喜欢将东西存储在更小的、有组织的小容器中，而不是存于同一个大容器中。目录的使用使我能够存储文件并在我想要查看这些文件的时候也能够找到它们。目录也被称为文件夹，之所以被称为文件夹，是因为其中的文件被类比存放于物理桌面上。
在 Linux 和其他许多操作系统中，目录可以被组织成树状的分层结构。在 [Linux 文件系统层次标准](http://www.pathname.com/fhs/)中定义了 Linux 的目录结构（LCTT 译注：可参阅[这篇](/article-6132-1.html)）。当通过目录引用来访问目录时，更深层目录名字是通过正斜杠（/）来连接，从而形成一个序列，比如 `/var/log` 和 `/var/spool/mail` 。这些被称为路径。
下表提供了标准的、众所周知的、预定义的顶层 Linux 目录及其用途的简要清单。
| 目录 | 描述 |
| --- | --- |
| **/ (root 文件系统)** | root 文件系统是文件系统的顶级目录。它必须包含在挂载其它文件系统前需要用来启动 Linux 系统的全部文件。它必须包含需要用来启动剩余文件系统的全部可执行文件和库。文件系统启动以后，所有其他文件系统作为 root 文件系统的子目录挂载到标准的、预定义好的挂载点上。 |
| **/bin** | `/bin` 目录包含用户的可执行文件。 |
| /boot | 包含启动 Linux 系统所需要的静态引导程序和内核可执行文件以及配置文件。 |
| **/dev** | 该目录包含每一个连接到系统的硬件设备的设备文件。这些文件不是设备驱动，而是代表计算机上的每一个计算机能够访问的设备。 |
| **/etc** | 包含主机计算机的本地系统配置文件。 |
| /home | 主目录存储用户文件，每一个用户都有一个位于 `/home` 目录中的子目录（作为其主目录）。 |
| **/lib** | 包含启动系统所需要的共享库文件。 |
| /media | 一个挂载外部可移动设备的地方，比如主机可能连接了一个 USB 驱动器。 |
| /mnt | 一个普通文件系统的临时挂载点（如不可移动的介质），当管理员对一个文件系统进行修复或在其上工作时可以使用。 |
| /opt | 可选文件，比如供应商提供的应用程序应该安装在这儿。 |
| **/root** | 这不是 root（`/`）文件系统。它是 root 用户的主目录。 |
| **/sbin** | 系统二进制文件。这些是用于系统管理的可执行文件。 |
| /tmp | 临时目录。被操作系统和许多程序用来存储临时文件。用户也可能临时在这儿存储文件。注意，存储在这儿的文件可能在任何时候在没有通知的情况下被删除。 |
| /usr | 该目录里面包含可共享的、只读的文件，包括可执行二进制文件和库、man 文件以及其他类型的文档。 |
| /var | 可变数据文件存储在这儿。这些文件包括日志文件、MySQL 和其他数据库的文件、Web 服务器的数据文件、邮件以及更多。 |
*表 1：Linux 文件系统层次结构的顶层*
这些目录以及它们的子目录如表 1 所示，在所有子目录中，粗体的目录组成了 root 文件系统的必需部分。也就是说，它们不能创建为一个分离的文件系统并且在开机时进行挂载。这是因为它们（特别是它们包含的内容）必须在系统启动的时候出现，从而系统才能正确启动。
`/media` 目录和 `/mnt` 目录是 root 文件系统的一部分，但是它们从来不包含任何数据，因为它们只是一个临时挂载点。
表 1 中剩下的非粗体的目录不需要在系统启动过程中出现，但会在之后挂载到 root 文件系统上，在开机阶段，它们为主机进行准备，从而执行有用的工作。
请参考官方 [Linux 文件系统层次标准](http://www.pathname.com/fhs/)（FHS）网页来了解这些每一个目录以及它们的子目录的更多细节。维基百科上也有关于 [FHS](https://en.wikipedia.org/wiki/Filesystem_Hierarchy_Standard) 的一个很好的介绍。应该尽可能的遵循这些标准，从而确保操作和功能的一致性。无论在主机上使用什么类型的文件系统，该层次目录结构都是相同的。
### Linux 统一目录结构
在一些非 Linux 操作系统的个人电脑上，如果有多个物理硬盘驱动器或多个分区，每一个硬盘或分区都会分配一个驱动器号。知道文件或程序位于哪一个硬盘驱动器上是很有必要的，比如 `C:` 或 `D:` 。然后，你可以在命令中使用驱动器号，以 `D:` 为例，为了进入 `D:` 驱动器，你可以使用 `cd` 命令来更改工作目录为正确的目录，从而定位需要的文件。每一个硬盘驱动器都有自己单独的、完整的目录树。
Linux 文件系统将所有物理硬盘驱动器和分区统一为一个目录结构。它们均从顶层 root 目录（`/`）开始。所有其它目录以及它们的子目录均位于单一的 Linux 根目录下。这意味着只有一棵目录树来搜索文件和程序。
因为只有一个文件系统，所以 `/home`、`/tmp`、`/var`、`/opt` 或 `/usr` 能够创建在和 root（`/`）文件系统不同的物理硬盘驱动器、分区或逻辑分区上，然后挂载到一个挂载点（目录）上，从而作为 root 文件系统树的一部分。甚至可移动驱动器，比如 USB 驱动器或一个外接的 USB 或 ESATA 硬盘驱动器均可以挂载到 root 文件系统上，成为目录树不可或缺的部分。
当从 Linux 发行版的一个版本升级到另一个版本或从一个发行版更改到另一个发行版的时候，就会很清楚地看到这样创建到不同分区的好处。通常情况下，除了任何像 Fedora 中的 `dnf-upgrade` 之类的升级工具，会明智地在升级过程中偶尔重新格式化包含操作系统的硬盘驱动来删除那些长期积累的垃圾。如果 `/home` 目录是 root 文件系统的一部分（位于同一个硬盘驱动器），那么它也会被格式化，然后需要通过之前的备份恢复。如果 /home 目录作为一个分离的文件系统，那么安装程序将会识别到，并跳过它的格式化。对于存储数据库、邮箱、网页和其它可变的用户以及系统数据的 `/var` 目录也是这样的。
将 Linux 系统目录树的某些部分作为一个分离的文件系统还有一些其他原因。比如，在很久以前，我还不知道将所有需要的 Linux 目录均作为 root（`/`）文件系统的一部分可能存在的问题，于是，一些非常大的文件填满了 `/home` 目录。因为 `/home` 目录和 `/tmp` 目录均不是分离的文件系统，而是 root 文件系统的简单子目录，整个 root 文件系统就被填满了。于是就不再有剩余空间可以让操作系统用来存储临时文件或扩展已存在数据文件。首先，应用程序开始抱怨没有空间来保存文件，然后，操作系统也开始异常行动。启动到单用户模式，并清除了 `/home` 目录中的多余文件之后，终于又能够重新工作了。然后，我使用非常标准的多重文件系统设置来重新安装 Linux 系统，从而避免了系统崩溃的再次发生。
我曾经遇到一个情况，Linux 主机还在运行，但是却不允许用户通过 GUI 桌面登录。我可以通过使用[虚拟控制台](https://en.wikipedia.org/wiki/Virtual_console)之一，通过命令行界面（CLI）本地登录，然后远程使用 SSH 。问题的原因是因为 `/tmp` 文件系统满了，因此 GUI 桌面登录时所需要的一些临时文件不能被创建。因为命令行界面登录不需要在 `/tmp` 目录中创建文件，所以无可用空间并不会阻止我使用命令行界面来登录。在这种情况下，`/tmp` 目录是一个分离的文件系统，在 `/tmp` 所位于的逻辑卷上还有大量的可用空间。我简单地[扩展了 /tmp 逻辑卷](https://opensource.com/business/16/9/linux-users-guide-lvm)的容量到能够容纳主机所需要的临时文件，于是问题便解决了。注意，这个解决方法不需要重启，当 `/tmp` 文件系统扩大以后，用户就可以登录到桌面了。
当我在一家很大的科技公司当实验室管理员的时候，遇到过另外一个故障。开发者将一个应用程序安装到了一个错误的位置（`/var`）。结果该应用程序崩溃了，因为 `/var` 文件系统满了，由于缺乏空间，存储于 `/var/log` 中的日志文件无法附加新的日志消息。然而，系统仍然在运行，因为 root 文件系统和 `/tmp` 文件系统还没有被填满。删除了该应用程序并重新安装在 `/opt` 文件系统后，问题便解决了。
### 文件系统类型
Linux 系统支持大约 100 种分区类型的读取，但是只能对很少的一些进行创建和写操作。但是，可以挂载不同类型的文件系统在同一个 root 文件系统上，并且是很常见的。在这样的背景下，我们所说的文件系统一词是指在硬盘驱动器或逻辑卷上的一个分区中存储和管理用户数据所需要的结构和元数据。能够被 Linux 系统的 `fdisk` 命令识别的文件系统类型的完整列表[在此](https://www.win.tue.nl/%7Eaeb/partitions/partition_types-1.html)，你可以感受一下 Linux 系统对许多类型的系统的高度兼容性。
Linux 支持读取这么多类型的分区系统的主要目的是为了提高兼容性，从而至少能够与一些其他计算机系统的文件系统进行交互。下面列出了在 Fedora 中创建一个新的文件系统时的所有可选类型：
* btrfs
* **cramfs**
* **ext2**
* **ext3**
* **ext4**
* fat
* gfs2
* hfsplus
* minix
* **msdos**
* ntfs
* reiserfs
* **vfat**
* xfs
其他发行版支持创建的文件系统类型不同。比如，CentOS 6 只支持创建上表中标为黑体的文件系统类型。
### 挂载
在 Linux 系统上“<ruby> 挂载 <rt> mount </rt></ruby>”文件系统的术语是指在计算机发展的早期，磁带或可移动的磁盘组需要需要物理地挂载到一个合适的驱动器设备上。当通过物理的方式放置到驱动器上以后，操作系统会逻辑地挂载位于磁盘上的文件系统，从而操作系统、应用程序和用户才能够访问文件系统中的内容。
一个挂载点简单的来说就是一个目录，就像任何其它目录一样，是作为 root 文件系统的一部分创建的。所以，比如，home 文件系统是挂载在目录 `/home` 下。文件系统可以被挂载到其他非 root 文件系统的挂载点上，但是这并不常见。
在 Linux 系统启动阶段的最初阶段，root 文件系统就会被挂载到 root 目录下（`/`）。其它文件系统在之后通过 SystemV 下的 `rc` 或更新一些的 Linux 发行版中的 `systemd` 等 Linux 启动程序挂载。在启动进程中文件系统的挂载是由 `/etc/fstab` 配置文件管理的。一个简单的记忆方法是，fstab 代表“<ruby> 文件系统表 <rt> file system table </rt></ruby>”，它包含了需要挂载的文件系统的列表，这些文件系统均指定了挂载点，以及针对特定文件系统可能需要的选项。
使用 `mount` 命令可以把文件系统挂载到一个已有的目录/挂载点上。通常情况下，任何作为挂载点的目录都应该是空的且不包含任何其他文件。Linux 系统不会阻止用户挂载一个已被挂载了文件系统的目录或将文件系统挂载到一个包含文件的目录上。如果你将文件系统挂载到一个已有的目录或文件系统上，那么其原始内容将会被隐藏，只有新挂载的文件系统的内容是可见的。
### 结论
我希望通过这篇文章，阐明了围绕文件系统这个术语的一些可能的模糊之处。我花费了很长的时间，以及在一个良师的帮助下才真正理解和欣赏到 Linux 文件系统的复杂性、优雅性和功能以及它的全部含义。
如果你有任何问题，请写到下面的评论中，我会尽力来回答它们。
### 下个月
Linux 的另一个重要概念是：[万物皆为文件](https://opensource.com/life/15/9/everything-is-a-file)。这个概念对用户和系统管理员来说有一些有趣和重要的实际应用。当我说完这个理由之后，你可能会想阅读我的文章：[万物皆为文件](https://opensource.com/life/15/9/everything-is-a-file)，这篇文章会在我下个月计划写的关于 `/dev` 目录的文章之前写完。（LCTT 译注，也可参阅[这篇](/article-7669-1.html)）
（题图 : wallup.net）
---
作者简介：
David Both 居住在美国北卡罗纳州的首府罗利，是一个 Linux 开源贡献者。他已经从事 IT 行业 40 余年，在 IBM 教授 OS/2 20 余年。1981 年，他在 IBM 开发了第一个关于最初的 IBM 个人电脑的培训课程。他也曾在 Red Hat 教授 RHCE 课程，也曾供职于 MCI worldcom，Cico 以及北卡罗纳州等。他已经为 Linux 开源社区工作近 20 年。
---
via: <https://opensource.com/life/16/10/introduction-linux-filesystems>
作者：[David Both](https://opensource.com/users/dboth) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Docker 引擎的 Swarm 模式：入门教程
|
Dedoimedo
|
http://www.dedoimedo.com/computers/docker-swarm-intro.html
|
简单来讲，如果你在用一个旧版本的 Docker，你必须手动配置 Swarm 来创建 Docker 集群。从 1.12 版开始，Docker 引擎集成了一个原生的实现来支持无缝的集群设置。
|
/data/attachment/album/201709/21/000157kapl2p7l32h2lyz2.jpg.thumb.jpg
|
/data/attachment/album/201709/21/000157kapl2p7l32h2lyz2.jpg
| true | false | true |
vizv
| false |
[
"Docker",
"Swarm",
"编排"
] |
容器与云
|
{
"viewnum": 13239,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8892,
"displayorder": 0
}
] |
简单来讲，如果你在用一个旧版本的 Docker，你必须手动配置 Swarm 来创建 Docker 集群。从 1.12 版开始，Docker 引擎集成了一个原生的实现来支持无缝的集群设置。
| 2017-09-21T08:54:00 | 2017-09-21T08:54:00 | 8,888 |
/article-8888-1.html
|
Swarm，听起来像是一个朋克摇滚乐队。但它确实是个新的编排机制，抑或者是，一个 [Docker](http://www.dedoimedo.com/computers/docker-guide.html) 现有编排体制的改进。简单来讲，如果你在用一个旧版本的 Docker，你必须手动配置 Swarm 来创建 Docker 集群。从 [1.12 版](https://blog.docker.com/2016/06/docker-1-12-built-in-orchestration/)开始，Docker 引擎集成了一个原生的实现（LCTT 译注：见下文）来支持无缝的集群设置。也就是为什么会有这篇文章。
在这篇教程中，我将带你体验一下编排后的 Docker 将能做的事情。这篇文章并不是包含所有细节（如 BnB 一般）或是让你对其全知全能，但它能带你踏上你的集群之路。在我的带领下开始吧。
### 技术概要
如果把 Docker 详细而又好用的文档照搬到这里那将太丢人了，所以我将简要概括下这个技术的概要。我们已经有了 Docker，对吧。现在，你想要更多的服务器作为 Docker 主机，但同时你希望它们属于同一个逻辑上的实体。也就是说，你想建立一个集群。
我们先从一个主机组成的集群开始。当你在一个主机上初始化一个 Swarm 集群，这台主机将成为这个集群的<ruby> 管理者 <rp> （ </rp> <rt> manager </rt> <rp> ） </rp></ruby>。从技术角度来讲，它成为了<ruby> 共识组 <rp> （ </rp> <rt> consensus group </rt> <rp> ） </rp></ruby>中的一个<ruby> 节点 <rt> node </rt></ruby>。其背后的数学逻辑建立在 [Raft](https://en.wikipedia.org/wiki/Raft_%28computer_science%29) 算法之上。<ruby> 管理者 <rp> （ </rp> <rt> manager </rt> <rp> ） </rp></ruby>负责调度任务。而具体的任务则会委任给各个加入了 Swarm 集群的<ruby> 工作者 <rp> （ </rp> <rt> worker </rt> <rp> ） </rp></ruby>节点。这些操作将由 Node API 所管理。虽说我讨厌 API 这个词汇，但我必须在这里用到它。
Service API 是这个实现中的第二个组件。它允许<ruby> 管理者 <rp> （ </rp> <rt> manager </rt> <rp> ） </rp></ruby>节点在所有的 Swarm 集群节点上创建一个分布式的服务。这个服务可以<ruby> 被复制 <rp> （ </rp> <rt> replicated </rt> <rp> ） </rp></ruby>，也就是说它们（LCTT 译注：指这些服务）会由平衡机制被分配到集群中（LCTT 译注：指 replicated 模式，多个容器实例将会自动调度任务到集群中的一些满足条件的节点），或者可以分配给全局（LCTT 译注：指 global 模式），也就是说每个节点都会运行一个容器实例。
此外还有更多的功课需要做，但这些信息已经足够你上路了。现在，我们开始整些实际的。我们的目标平台是 [CentOS 7.2](http://www.dedoimedo.com/computers/lenovo-g50-centos-xfce.html)，有趣的是在我写这篇教程的时候，它的软件仓库中只有 1.10 版的 Docker，也就是说我必须手动更新以使用 Swarm。我们将在另一篇教程中讨论这个问题。接下来我们还有一个跟进的指南，其中涵盖了如何将新的节点加入我们现有的集群（LCTT 译注：指刚刚建立的单节点集群），并且我们将使用 [Fedora](http://www.dedoimedo.com/computers/fedora-24-gnome.html) 进行一个非对称的配置。至此，请确保正确的配置已经就位，并有一个工作的集群启动并正在运行（LCTT 译注：指第一个节点的 Docker 已经安装并已进入 Swarm 模式，但到这里笔者并没有介绍如何初始化 Swarm 集群，不过别担心下章会讲）。
### 配置镜像和服务
我将尝试配置一个负载均衡的 [Apache](https://hub.docker.com/_/httpd/) 服务，并使用多个容器实例通过唯一的 IP 地址提供页面内容。挺标准的吧（LCTT 译注：指这个负载均衡的网页服务器）。这个例子同时也突出了你想要使用集群的大多数原因：可用性、冗余、横向扩展以及性能。当然，你同时需要考虑[网络](http://www.dedoimedo.com/computers/docker-networking.html)和[储存](http://www.dedoimedo.com/computers/docker-data-volumes.html)这两块，但它们超出了这篇指南所涉及的范围了。
这个 Dockerfile 模板其实可以在官方镜像仓库里的 httpd 下找到。你只需一个最简单的设置来起步。至于如何下载或创建自己的镜像，请参考我的入门指南，链接可以在这篇教程的顶部可以找到。
```
docker build -t my-apache2 .
Sending build context to Docker daemon 2.048 kB
Step 1 : FROM httpd:2.4
Trying to pull repository docker.io/library/httpd ...
2.4: Pulling from docker.io/library/httpd
8ad8b3f87b37: Pull complete
c95e1f92326d: Pull complete
96e8046a7a4e: Pull complete
00a0d292c371: Pull complete
3f7586acab34: Pull complete
Digest: sha256:3ad4d7c4f1815bd1c16788a57f81b413...a915e50a0d3a4
Status: Downloaded newer image for docker.io/httpd:2.4
---> fe3336dd034d
Step 2 : COPY ../public-html/ /usr/local/apache2/htdocs/
...
```
在你继续下面的步骤之前，你应该确保你能无错误的启动一个容器实例并能链接到这个网页服务器上（LCTT 译注：使用下面的命令）。一旦你确保你能连上，我们就可以开始着手创建一个分布式的服务。
```
docker run -dit --name my-running-app my-apache2
```
将这个 IP 地址输入浏览器，看看会出现什么。
### Swarm 初始化和配置
下一步就是启动 Swarm 集群了。你将需要这些最基础的命令来开始，它们与 Docker 博客中的例子非常相似：
```
docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
```
这里我们做了什么？我们创建了一个叫做 `frontent` 的服务，它有五个容器实例。同时我们还将主机的 80 端口和这些容器的 80 端口相绑定。我们将使用刚刚新创建的 Apache 镜像来做这个测试。然而，当你在自己的电脑上直接键入上面的指令时，你将看到下面的错误：
```
docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
Error response from daemon: This node is not a swarm manager. Use "docker swarm init" or "docker swarm join" to connect this node to swarm and try again.
```
这意味着你没有将你的主机（节点）配置成一个 Swarm <ruby> 管理者 <rp> （ </rp> <rt> manager </rt> <rp> ） </rp></ruby>。你可以在这台主机上初始化 Swarm 集群或是让它加入一个现有的集群。由于我们目前还没有一个现成的集群，我们将初始化它（LCTT 译注：指初始化 Swarm 集群并使当前节点成为 manager）：
```
docker swarm init
Swarm initialized: current node (dm58mmsczqemiikazbfyfwqpd) is now a manager.
```
为了向这个 Swarm 集群添加一个<ruby> 工作者 <rp> （ </rp> <rt> worker </rt> <rp> ） </rp></ruby>，请执行下面的指令：
```
docker swarm join \
--token SWMTKN-1-4ofd46a2nfyvrqwu8w5oeetukrbylyznxla
9srf9vxkxysj4p8-eu5d68pu5f1ci66s7w4wjps1u \
10.0.2.15:2377
```
为了向这个 Swarm 集群添加一个<ruby> 管理者 <rp> （ </rp> <rt> manager </rt> <rp> ） </rp></ruby>，请执行 `docker swarm join-token manager` 并按照指示操作。
操作后的输出不用解释已经很清楚明了。我们成功的创建了一个 Swarm 集群。新的节点们将需要正确的<ruby> 令牌 <rp> （ </rp> <rt> token </rt> <rp> ） </rp></ruby>来加入这个 Swarm 集群。如果你需要配置防火墙，你还需找到它的 IP 地址和端口（LCTT 译注：指 Docker 的 Swarm 模式通讯所需的端口，默认 2377）。此外，你还可以向 Swarm 集群中添加管理者节点。现在，重新执行刚刚的服务创建指令：
```
docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
6lrx1vhxsar2i50is8arh4ud1
```
### 测试连通性
现在，我们来验证下我们的服务是否真的工作了。从某些方面讲，这很像我们在 [Vagrant](http://www.dedoimedo.com/computers/vagrant-intro.html) 和 [coreOS](http://www.dedoimedo.com/computers/vagrant-coreos.html) 中做的事情那样。毕竟它们的原理几乎相同。相同指导思想的不同实现罢了（LCTT 译注：笔者观点，无法苟同）。首先需要确保 `docker ps` 能够给出正确的输出。你应该能看到所创建服务的多个容器副本。
```
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS
NAMES
cda532f67d55 my-apache2:latest "httpd-foreground"
2 minutes ago Up 2 minutes 80/tcp frontend.1.2sobjfchdyucschtu2xw6ms9a
75fe6e0aa77b my-apache2:latest "httpd-foreground"
2 minutes ago Up 2 minutes 80/tcp frontend.4.ag77qtdeby9fyvif5v6c4zcpc
3ce824d3151f my-apache2:latest "httpd-foreground"
2 minutes ago Up 2 minutes 80/tcp frontend.2.b6fqg6sf4hkeqs86ps4zjyq65
eda01569181d my-apache2:latest "httpd-foreground"
2 minutes ago Up 2 minutes 80/tcp frontend.5.0rmei3zeeh8usagg7fn3olsp4
497ef904e381 my-apache2:latest "httpd-foreground"
2 minutes ago Up 2 minutes 80/tcp frontend.3.7m83qsilli5dk8rncw3u10g5a
```
我也测试了不同的、非常规的端口，它们都能正常工作。对于你如何连接服务器和收取请求你将会有很多可配置的余地。你可以使用 localhost 或者 Docker 网络接口（笔者注：应该是指 Docker 的默认网桥 docker0，其网关为 172.17.0.1） 的 IP 地址的正确端口去访问。下面的例子使用了端口 1080：
至此，这是一个非常粗略、简单的开始。真正的挑战是创建一个优化过的、可扩展的服务，但是它们需要一个准确的技术用例。此外，你还会用到 `docker info` 和 `docker service`（还有 `inspect` 和 `ps`）命令来详细了解你的集群是如何工作的。
### 可能会遇到的问题
你可能会在把玩 Docker 和 Swarm 时遇到一些小的问题（也许没那么小）。比如 SELinux 也许会抱怨你正在执行一些非法的操作（LCTT 译注：指在强制访问控制策略中没有权限的操作）。然而，这些错误和警告应该不会对你造成太多阻碍。
* `docker service` 不是一条命令（`docker service is not a docker command`）
当你尝试执行必须的命令去创建一个<ruby> 复制模式 <rp> （ </rp> <rt> replicated </rt> <rp> ） </rp></ruby>的服务时，你可能会遇到一条错误说 `docker: 'service' is not a docker command`（LCTT 译注：见下面的例子）。这表示你的 Docker 版本不对（使用 `-v` 选项来检查）。我们将在将来的教程讨论如何修复这个问题。
```
docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
docker: 'service' is not a docker command.
```
* `docker tag` 无法识别（`docker tag not recognized`）
你也许会看到下面的错误：
```
docker service create -name frontend -replicas 5 -p 80:80/tcp my-apache2:latest
Error response from daemon: rpc error: code = 3 desc = ContainerSpec: "-name" is not a valid repository/tag
```
关于这个错误已经有多个相关的[讨论](https://github.com/docker/docker/issues/24192)和[帖子](http://stackoverflow.com/questions/38618609/docker-swarm-1-12-name-option-not-recognized)了。其实这个错误也许相当无辜。你也许是从浏览器粘贴的命令，在浏览器中的横线也许没被正确解析（笔者注：应该用 `--name` 而不是 `-name`）。就是这么简单的原因所导致的。
### 扩展阅读
关于这个话题还有很多可谈的，包含 1.12 版之前的 Swarm 集群实现（笔者注：旧的 Swarm 集群实现，下文亦作`独立版本`，需要 Consul 等应用提供服务发现），以及当前的 Docker 版本提供的（笔者注：新的 Swarm 集群实现，亦被称为 Docker 引擎的 Swarm 模式）。也就是说，请别偷懒花些时间阅读以下内容：
* Docker Swarm [概述](https://docs.docker.com/swarm/)（独立版本的 Swarm 集群安装）
* [构建](https://docs.docker.com/swarm/install-manual/)一个生产环境的 Swarm 集群（独立版本安装）
* [安装并创建](https://docs.docker.com/swarm/install-w-machine/)一个 Docker Swarm 集群（独立版本安装）
* Docker 引擎 Swarm [概述](https://docs.docker.com/engine/swarm/)（对于 1.12 版）
* [Swarm](https://docs.docker.com/engine/swarm/swarm-tutorial/) 模式入门（对于 1.12 版）
### 总结
你总算看到这里了。到这里仍然无法保证你学到了什么，但我相信你还是会觉得这篇文章有些用的。它涵盖了一些基础的概念，以及一个 Swarm 集群模式是如何工作的以及它能做什么的概述，与此同时我们也成功的下载了并创建了我们的网页服务器的镜像，并且在之后基于它运行了多个集群式的容器实例。虽然我们目前只在单一节点做了以上实验，但是我们会在将来解释清楚（LCTT 译注：以便解释清楚多节点的 Swarm 集群操作）。并且我们解决了一些常见的问题。
我希望你能认为这篇指南足够有趣。结合着我过去所写的关于 Docker 的文章，这些文章应该能给你一个像样的解释，包括：怎么样操作镜像、网络栈、储存、以及现在的集群。就当热身吧。的确，请享受并期待在新的 Docker 教程中与你见面。我控几不住我记几啊。
祝你愉快。
---
via: <http://www.dedoimedo.com/computers/docker-swarm-intro.html>
作者：[Dedoimedo](http://www.dedoimedo.com/computers/docker-swarm-intro.html) 译者：[Viz](https://github.com/vizv) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
我们为什么爱用 Linux？
|
Cyb3rpunk
|
https://cyb3rpunk.wordpress.com/2011/04/28/%C2%BFpor-que-gnulinux/
|
在我们内心深处，还保留着真正的原因没说。
我们用 Linux 是因为它很有趣。
|
/data/attachment/album/201709/21/090302kpkp8el81e581pe8.jpg.thumb.jpg
|
/data/attachment/album/201709/21/090302kpkp8el81e581pe8.jpg
| true | false | true |
vizv
| false |
[
"Linux"
] |
观点
|
{
"viewnum": 9194,
"commentnum": 11,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "222.210.108.99",
"message": "不错，应该是这样的",
"username": "来自四川成都的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-09-21T09:28:14"
},
{
"postip": "119.139.196.61",
"message": "Just for fun.",
"username": "来自广东深圳的 Android Browser|Android 5.0 用户",
"date": "2017-09-21T09:49:39"
},
{
"postip": "117.152.94.135",
"message": "yeah! I agree.",
"username": "来自117.152.94.135的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-09-21T11:55:29"
},
{
"postip": "116.231.182.61",
"message": "免费\\安全\\稳定",
"username": "粱小无拆 [QQ Browser 9.6|Windows 10]",
"date": "2017-09-21T14:29:43"
},
{
"postip": "220.165.92.42",
"message": "然并卵桌面还是失败的，虽然我也一直在用debian",
"username": "来自云南玉溪的 Firefox 52.0|Windows 7 用户",
"date": "2017-09-21T15:54:24"
},
{
"postip": "218.88.46.210",
"message": "成功的在内核，以及基于内核的 Android，然后基本就是服务器领域，至于嵌入式领域，并没有占据绝对领先地位。",
"username": "来自四川成都的 Chromium 60.0|Ubuntu 用户",
"date": "2017-09-21T19:08:49"
},
{
"postip": "117.151.52.66",
"message": "桌面有不能代表全部，windows也只有桌面市场了",
"username": "来自湖北的 Chrome 60.0|Windows 10 用户",
"date": "2017-09-22T07:24:05"
},
{
"postip": "1.204.10.178",
"message": "很好，很强大！",
"username": "张熙熙 [Firefox 55.0|Windows 10]",
"date": "2017-09-23T00:30:00"
},
{
"postip": "113.77.145.221",
"message": "说白了老子就是喜欢瞎折腾，爱咋咋的。。。",
"username": "nansion [Chrome 58.0|GNU/Linux]",
"date": "2017-09-25T09:42:03"
},
{
"postip": "113.57.179.98",
"message": "排版好奇怪哦",
"username": "来自湖北武汉的 Firefox 55.0|Fedora 用户",
"date": "2017-09-26T15:34:43"
},
{
"postip": "117.30.198.164",
"message": "很奇怪 你真的喜欢linux？",
"username": "来自福建厦门的 Chrome 60.0|Windows 7 用户",
"date": "2017-09-30T17:33:29"
}
] |
[] |
在我们内心深处，还保留着真正的原因没说。
我们用 Linux 是因为它很有趣。
| 2017-09-21T09:04:00 | 2017-09-21T09:04:00 | 8,889 |
/article-8889-1.html
|
国外有一位 Linux 粉丝做了一张[壁纸](https://cyb3rpunk.files.wordpress.com/2011/04/whylinux.jpg)，其中对“我们为什么爱用 Linux”说了大实话：
```
我们告诉人们用 Linux 是因为它很安全，或者因为它是免费的、因为它是可以定制的、因为它是自由的、因为它有一个强大的社区支持着……
但是上面的所有原因都是在扯淡。我们这么跟非 Linux 用户讲是因为他们没法了解真正的原因。而且我们说多了这些借口，我们自己也开始就这么相信了。
但是在我们内心深处，还保留着真正的原因没说。
我们用 Linux 是因为它很有趣。
折腾你的系统很有趣；修改所有的设置，把系统搞挂，然后进入回复模式去修复它很有趣；有上百个发行版供你选择很有趣；用命令行很有趣。
让我再重申一遍，用命令行很有趣。
难怪非 Linux 用户无法理解。
我是在说 Linux 的爱好者们用 Linux 是因为自己的缘故。当然，我们喜欢做好自己的工作；当然，我们喜欢避免染上病毒；当然，我们喜欢省钱。但是这些仅仅是副产品。我们真正喜欢的是把玩这个系统，瞎胡折腾，并且发现些隐藏在软件深处迷人的真相。
```
|
||
开发一个 Linux 调试器（七）：源码级断点
|
Simon Brand
|
https://blog.tartanllama.xyz/c++/2017/06/19/writing-a-linux-debugger-source-break/
|
这篇文章将会添加源码级断点到我们的调试器中。通过所有我们已经支持的功能，这要比起最初听起来容易得多。我们还将添加一个命令来获取符号的类型和地址，这对于定位代码或数据以及理解链接概念非常有用。
|
/data/attachment/album/201709/22/093850q8zlc89bpd1idpkc.jpg.thumb.jpg
|
/data/attachment/album/201709/22/093850q8zlc89bpd1idpkc.jpg
| true | false | true |
geekpi
| false |
[
"调试器"
] |
软件开发
|
{
"viewnum": 5119,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8813,
"displayorder": 0
},
{
"raid": 8930,
"displayorder": 0
}
] |
这篇文章将会添加源码级断点到我们的调试器中。通过所有我们已经支持的功能，这要比起最初听起来容易得多。我们还将添加一个命令来获取符号的类型和地址，这对于定位代码或数据以及理解链接概念非常有用。
| 2017-09-22T09:39:25 | 2017-09-22T09:39:25 | 8,890 |
/article-8890-1.html
|
在内存地址上设置断点虽然不错，但它并没有提供最方便用户的工具。我们希望能够在源代码行和函数入口地址上设置断点，以便我们可以在与代码相同的抽象级别中进行调试。
这篇文章将会添加源码级断点到我们的调试器中。通过所有我们已经支持的功能，这要比起最初听起来容易得多。我们还将添加一个命令来获取符号的类型和地址，这对于定位代码或数据以及理解链接概念非常有用。
### 系列索引
随着后面文章的发布，这些链接会逐渐生效。
1. [准备环境](/article-8626-1.html)
2. [断点](/article-8645-1.html)
3. [寄存器和内存](/article-8663-1.html)
4. [Elves 和 dwarves](/article-8719-1.html)
5. [源码和信号](/article-8812-1.html)
6. [源码级逐步执行](/article-8813-1.html)
7. [源码级断点](https://blog.tartanllama.xyz/c++/2017/06/19/writing-a-linux-debugger-source-break/)
8. [调用栈](https://blog.tartanllama.xyz/c++/2017/06/24/writing-a-linux-debugger-unwinding/)
9. 读取变量
10. 之后步骤
### 断点
#### DWARF
[Elves 和 dwarves](/article-8719-1.html) 这篇文章，描述了 DWARF 调试信息是如何工作的，以及如何用它来将机器码映射到高层源码中。回想一下，DWARF 包含了函数的地址范围和一个允许你在抽象层之间转换代码位置的行表。我们将使用这些功能来实现我们的断点。
#### 函数入口
如果你考虑重载、成员函数等等，那么在函数名上设置断点可能有点复杂，但是我们将遍历所有的编译单元，并搜索与我们正在寻找的名称匹配的函数。DWARF 信息如下所示：
```
< 0><0x0000000b> DW_TAG_compile_unit
DW_AT_producer clang version 3.9.1 (tags/RELEASE_391/final)
DW_AT_language DW_LANG_C_plus_plus
DW_AT_name /super/secret/path/MiniDbg/examples/variable.cpp
DW_AT_stmt_list 0x00000000
DW_AT_comp_dir /super/secret/path/MiniDbg/build
DW_AT_low_pc 0x00400670
DW_AT_high_pc 0x0040069c
LOCAL_SYMBOLS:
< 1><0x0000002e> DW_TAG_subprogram
DW_AT_low_pc 0x00400670
DW_AT_high_pc 0x0040069c
DW_AT_name foo
...
...
<14><0x000000b0> DW_TAG_subprogram
DW_AT_low_pc 0x00400700
DW_AT_high_pc 0x004007a0
DW_AT_name bar
...
```
我们想要匹配 `DW_AT_name` 并使用 `DW_AT_low_pc`（函数的起始地址）来设置我们的断点。
```
void debugger::set_breakpoint_at_function(const std::string& name) {
for (const auto& cu : m_dwarf.compilation_units()) {
for (const auto& die : cu.root()) {
if (die.has(dwarf::DW_AT::name) && at_name(die) == name) {
auto low_pc = at_low_pc(die);
auto entry = get_line_entry_from_pc(low_pc);
++entry; //skip prologue
set_breakpoint_at_address(entry->address);
}
}
}
}
```
这代码看起来有点奇怪的唯一一点是 `++entry`。 问题是函数的 `DW_AT_low_pc` 不指向该函数的用户代码的起始地址，它指向 prologue 的开始。编译器通常会输出一个函数的 prologue 和 epilogue，它们用于执行保存和恢复堆栈、操作堆栈指针等。这对我们来说不是很有用，所以我们将入口行加一来获取用户代码的第一行而不是 prologue。DWARF 行表实际上具有一些功能，用于将入口标记为函数 prologue 之后的第一行，但并不是所有编译器都输出它，因此我采用了原始的方法。
#### 源码行
要在高层源码行上设置一个断点，我们要将这个行号转换成 DWARF 中的一个地址。我们将遍历编译单元，寻找一个名称与给定文件匹配的编译单元，然后查找与给定行对应的入口。
DWARF 看上去有点像这样：
```
.debug_line: line number info for a single cu
Source lines (from CU-DIE at .debug_info offset 0x0000000b):
NS new statement, BB new basic block, ET end of text sequence
PE prologue end, EB epilogue begin
IS=val ISA number, DI=val discriminator value
<pc> [lno,col] NS BB ET PE EB IS= DI= uri: "filepath"
0x004004a7 [ 1, 0] NS uri: "/super/secret/path/a.hpp"
0x004004ab [ 2, 0] NS
0x004004b2 [ 3, 0] NS
0x004004b9 [ 4, 0] NS
0x004004c1 [ 5, 0] NS
0x004004c3 [ 1, 0] NS uri: "/super/secret/path/b.hpp"
0x004004c7 [ 2, 0] NS
0x004004ce [ 3, 0] NS
0x004004d5 [ 4, 0] NS
0x004004dd [ 5, 0] NS
0x004004df [ 4, 0] NS uri: "/super/secret/path/ab.cpp"
0x004004e3 [ 5, 0] NS
0x004004e8 [ 6, 0] NS
0x004004ed [ 7, 0] NS
0x004004f4 [ 7, 0] NS ET
```
所以如果我们想要在 `ab.cpp` 的第五行设置一个断点，我们将查找与行 (`0x004004e3`) 相关的入口并设置一个断点。
```
void debugger::set_breakpoint_at_source_line(const std::string& file, unsigned line) {
for (const auto& cu : m_dwarf.compilation_units()) {
if (is_suffix(file, at_name(cu.root()))) {
const auto& lt = cu.get_line_table();
for (const auto& entry : lt) {
if (entry.is_stmt && entry.line == line) {
set_breakpoint_at_address(entry.address);
return;
}
}
}
}
}
```
我这里做了 `is_suffix` hack，这样你可以输入 `c.cpp` 代表 `a/b/c.cpp` 。当然你实际上应该使用大小写敏感路径处理库或者其它东西，但是我比较懒。`entry.is_stmt` 是检查行表入口是否被标记为一个语句的开头，这是由编译器根据它认为是断点的最佳目标的地址设置的。
### 符号查找
当我们在对象文件层时，符号是王者。函数用符号命名，全局变量用符号命名，你得到一个符号，我们得到一个符号，每个人都得到一个符号。 在给定的对象文件中，一些符号可能引用其他对象文件或共享库，链接器将从符号引用创建一个可执行程序。
可以在正确命名的符号表中查找符号，它存储在二进制文件的 ELF 部分中。幸运的是，`libelfin` 有一个不错的接口来做这件事，所以我们不需要自己处理所有的 ELF 的事情。为了让你知道我们在处理什么，下面是一个二进制文件的 `.symtab` 部分的转储，它由 `readelf` 生成：
```
Num: Value Size Type Bind Vis Ndx Name
0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND
1: 0000000000400238 0 SECTION LOCAL DEFAULT 1
2: 0000000000400254 0 SECTION LOCAL DEFAULT 2
3: 0000000000400278 0 SECTION LOCAL DEFAULT 3
4: 00000000004002c8 0 SECTION LOCAL DEFAULT 4
5: 0000000000400430 0 SECTION LOCAL DEFAULT 5
6: 00000000004004e4 0 SECTION LOCAL DEFAULT 6
7: 0000000000400508 0 SECTION LOCAL DEFAULT 7
8: 0000000000400528 0 SECTION LOCAL DEFAULT 8
9: 0000000000400558 0 SECTION LOCAL DEFAULT 9
10: 0000000000400570 0 SECTION LOCAL DEFAULT 10
11: 0000000000400714 0 SECTION LOCAL DEFAULT 11
12: 0000000000400720 0 SECTION LOCAL DEFAULT 12
13: 0000000000400724 0 SECTION LOCAL DEFAULT 13
14: 0000000000400750 0 SECTION LOCAL DEFAULT 14
15: 0000000000600e18 0 SECTION LOCAL DEFAULT 15
16: 0000000000600e20 0 SECTION LOCAL DEFAULT 16
17: 0000000000600e28 0 SECTION LOCAL DEFAULT 17
18: 0000000000600e30 0 SECTION LOCAL DEFAULT 18
19: 0000000000600ff0 0 SECTION LOCAL DEFAULT 19
20: 0000000000601000 0 SECTION LOCAL DEFAULT 20
21: 0000000000601018 0 SECTION LOCAL DEFAULT 21
22: 0000000000601028 0 SECTION LOCAL DEFAULT 22
23: 0000000000000000 0 SECTION LOCAL DEFAULT 23
24: 0000000000000000 0 SECTION LOCAL DEFAULT 24
25: 0000000000000000 0 SECTION LOCAL DEFAULT 25
26: 0000000000000000 0 SECTION LOCAL DEFAULT 26
27: 0000000000000000 0 SECTION LOCAL DEFAULT 27
28: 0000000000000000 0 SECTION LOCAL DEFAULT 28
29: 0000000000000000 0 SECTION LOCAL DEFAULT 29
30: 0000000000000000 0 SECTION LOCAL DEFAULT 30
31: 0000000000000000 0 FILE LOCAL DEFAULT ABS init.c
32: 0000000000000000 0 FILE LOCAL DEFAULT ABS crtstuff.c
33: 0000000000600e28 0 OBJECT LOCAL DEFAULT 17 __JCR_LIST__
34: 00000000004005a0 0 FUNC LOCAL DEFAULT 10 deregister_tm_clones
35: 00000000004005e0 0 FUNC LOCAL DEFAULT 10 register_tm_clones
36: 0000000000400620 0 FUNC LOCAL DEFAULT 10 __do_global_dtors_aux
37: 0000000000601028 1 OBJECT LOCAL DEFAULT 22 completed.6917
38: 0000000000600e20 0 OBJECT LOCAL DEFAULT 16 __do_global_dtors_aux_fin
39: 0000000000400640 0 FUNC LOCAL DEFAULT 10 frame_dummy
40: 0000000000600e18 0 OBJECT LOCAL DEFAULT 15 __frame_dummy_init_array_
41: 0000000000000000 0 FILE LOCAL DEFAULT ABS /super/secret/path/MiniDbg/
42: 0000000000000000 0 FILE LOCAL DEFAULT ABS crtstuff.c
43: 0000000000400818 0 OBJECT LOCAL DEFAULT 14 __FRAME_END__
44: 0000000000600e28 0 OBJECT LOCAL DEFAULT 17 __JCR_END__
45: 0000000000000000 0 FILE LOCAL DEFAULT ABS
46: 0000000000400724 0 NOTYPE LOCAL DEFAULT 13 __GNU_EH_FRAME_HDR
47: 0000000000601000 0 OBJECT LOCAL DEFAULT 20 _GLOBAL_OFFSET_TABLE_
48: 0000000000601028 0 OBJECT LOCAL DEFAULT 21 __TMC_END__
49: 0000000000601020 0 OBJECT LOCAL DEFAULT 21 __dso_handle
50: 0000000000600e20 0 NOTYPE LOCAL DEFAULT 15 __init_array_end
51: 0000000000600e18 0 NOTYPE LOCAL DEFAULT 15 __init_array_start
52: 0000000000600e30 0 OBJECT LOCAL DEFAULT 18 _DYNAMIC
53: 0000000000601018 0 NOTYPE WEAK DEFAULT 21 data_start
54: 0000000000400710 2 FUNC GLOBAL DEFAULT 10 __libc_csu_fini
55: 0000000000400570 43 FUNC GLOBAL DEFAULT 10 _start
56: 0000000000000000 0 NOTYPE WEAK DEFAULT UND __gmon_start__
57: 0000000000400714 0 FUNC GLOBAL DEFAULT 11 _fini
58: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __libc_start_main@@GLIBC_
59: 0000000000400720 4 OBJECT GLOBAL DEFAULT 12 _IO_stdin_used
60: 0000000000601018 0 NOTYPE GLOBAL DEFAULT 21 __data_start
61: 00000000004006a0 101 FUNC GLOBAL DEFAULT 10 __libc_csu_init
62: 0000000000601028 0 NOTYPE GLOBAL DEFAULT 22 __bss_start
63: 0000000000601030 0 NOTYPE GLOBAL DEFAULT 22 _end
64: 0000000000601028 0 NOTYPE GLOBAL DEFAULT 21 _edata
65: 0000000000400670 44 FUNC GLOBAL DEFAULT 10 main
66: 0000000000400558 0 FUNC GLOBAL DEFAULT 9 _init
```
你可以在对象文件中看到用于设置环境的很多符号，最后还可以看到 `main` 符号。
我们对符号的类型、名称和值（地址）感兴趣。我们有一个该类型的 `symbol_type` 枚举，并使用一个 `std::string` 作为名称，`std::uintptr_t` 作为地址：
```
enum class symbol_type {
notype, // No type (e.g., absolute symbol)
object, // Data object
func, // Function entry point
section, // Symbol is associated with a section
file, // Source file associated with the
}; // object file
std::string to_string (symbol_type st) {
switch (st) {
case symbol_type::notype: return "notype";
case symbol_type::object: return "object";
case symbol_type::func: return "func";
case symbol_type::section: return "section";
case symbol_type::file: return "file";
}
}
struct symbol {
symbol_type type;
std::string name;
std::uintptr_t addr;
};
```
我们需要将从 `libelfin` 获得的符号类型映射到我们的枚举，因为我们不希望依赖关系破环这个接口。幸运的是，我为所有的东西选了同样的名字，所以这样很简单：
```
symbol_type to_symbol_type(elf::stt sym) {
switch (sym) {
case elf::stt::notype: return symbol_type::notype;
case elf::stt::object: return symbol_type::object;
case elf::stt::func: return symbol_type::func;
case elf::stt::section: return symbol_type::section;
case elf::stt::file: return symbol_type::file;
default: return symbol_type::notype;
}
};
```
最后我们要查找符号。为了说明的目的，我循环查找符号表的 ELF 部分，然后收集我在其中找到的任意符号到 `std::vector` 中。更智能的实现可以建立从名称到符号的映射，这样你只需要查看一次数据就行了。
```
std::vector<symbol> debugger::lookup_symbol(const std::string& name) {
std::vector<symbol> syms;
for (auto &sec : m_elf.sections()) {
if (sec.get_hdr().type != elf::sht::symtab && sec.get_hdr().type != elf::sht::dynsym)
continue;
for (auto sym : sec.as_symtab()) {
if (sym.get_name() == name) {
auto &d = sym.get_data();
syms.push_back(symbol{to_symbol_type(d.type()), sym.get_name(), d.value});
}
}
}
return syms;
}
```
### 添加命令
一如往常，我们需要添加一些更多的命令来向用户暴露功能。对于断点，我使用 GDB 风格的接口，其中断点类型是通过你传递的参数推断的，而不用要求显式切换：
* `0x<hexadecimal>` -> 断点地址
* `<line>:<filename>` -> 断点行号
* `<anything else>` -> 断点函数名
```
else if(is_prefix(command, "break")) {
if (args[1][0] == '0' && args[1][1] == 'x') {
std::string addr {args[1], 2};
set_breakpoint_at_address(std::stol(addr, 0, 16));
}
else if (args[1].find(':') != std::string::npos) {
auto file_and_line = split(args[1], ':');
set_breakpoint_at_source_line(file_and_line[0], std::stoi(file_and_line[1]));
}
else {
set_breakpoint_at_function(args[1]);
}
}
```
对于符号，我们将查找符号并打印出我们发现的任何匹配项：
```
else if(is_prefix(command, "symbol")) {
auto syms = lookup_symbol(args[1]);
for (auto&& s : syms) {
std::cout << s.name << ' ' << to_string(s.type) << " 0x" << std::hex << s.addr << std::endl;
}
}
```
### 测试一下
在一个简单的二进制文件上启动调试器，并设置源代码级别的断点。在一些 `foo` 函数上设置一个断点，看到我的调试器停在它上面是我这个项目最有价值的时刻之一。
符号查找可以通过在程序中添加一些函数或全局变量并查找它们的名称来进行测试。请注意，如果你正在编译 C++ 代码，你还需要考虑[名称重整](https://en.wikipedia.org/wiki/Name_mangling#C.2B.2B)。
本文就这些了。下一次我将展示如何向调试器添加堆栈展开支持。
你可以在[这里](https://github.com/TartanLlama/minidbg/tree/tut_source_break)找到这篇文章的代码。
---
via: <https://blog.tartanllama.xyz/c++/2017/06/19/writing-a-linux-debugger-source-break/>
作者：[Simon Brand](https://twitter.com/TartanLlama) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
安全债务是工程师的问题
|
Tc Currie
|
https://thenewstack.io/security-engineers-problem/
|
就像组织会形成技术债务一样，如果他们不相应地计划，也会形成一个名为“安全债务”的东西。
|
/data/attachment/album/201709/22/111321f3lklgc5v35no700.jpeg.thumb.jpg
|
/data/attachment/album/201709/22/111321f3lklgc5v35no700.jpeg
| true | false | true |
geekpi
| false |
[
"安全"
] |
观点
|
{
"viewnum": 2322,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
就像组织会形成技术债务一样，如果他们不相应地计划，也会形成一个名为“安全债务”的东西。
| 2017-09-22T11:13:00 | 2017-09-22T11:13:00 | 8,891 |
/article-8891-1.html
|
在上个月旧金山 Twitter 总部举办的 [WomenWhoCode Connect](http://connect2017.womenwhocode.com/) 活动中参会者了解到，就像组织会形成技术债务一样，如果他们不相应地计划，也会形成一个名为“安全债务”的东西。
甲骨文首席安全官 [Mary Ann Davidson](https://www.linkedin.com/in/mary-ann-davidson-235ba/) 与 [WomenWhoCode](https://www.womenwhocode.com/) 的 [Zassmin Montes de Oca](https://www.linkedin.com/in/zassmin/) 在一个面对开发人员的安全性的主题谈话中强调，安全性已经成为软件开发过程中每步的重要组成部分，
在过去，除银行外，安全性几乎被所有人忽视。但安全性比以往任何时候都更重要，因为现在有这么多接入点。我们已经进入[物联网](https://www.thenewstack.io/tag/Internet-of-Things)的时代，窃贼可以通过劫持你的冰箱而了解到你不在家的情况。
Davidson 负责 Oracle 的保障，“我们确保为建立的一切构建安全性，无论是内部部署产品、云服务，甚至是设备，我们在客户的网站建立有支持小组并报告数据给我们，帮助我们做诊断 - 每件事情都必须对其进行安全保护。”
AirBnB 的 [Keziah Plattner](https://twitter.com/ittskeziah) 在分组会议中回应了这个看法。她说：“大多数开发者并不认为安全是他们的工作，但这必须改变。”
她分享了工程师的四项基本安全原则。首先，安全债务是昂贵的。现在有很多人在谈论[技术债务](https://martinfowler.com/bliki/TechnicalDebt.html)，她认为这些谈话应该也包括安全债务。
Plattner 说：“历史上这个看法是‘我们会稍后考虑安全’”。当公司抓住软件效率和增长的唾手可得的成果时，他们忽视了安全性，但最初的不安全设计可能在未来几年会引发问题。
她说，很难为现有的脆弱系统增加安全性。即使你知道安全漏洞在哪里，并且有进行更改的时间和资源的预算，重新设计一个安全系统也是耗时和困难的。
她说，所以这就是关键，从一开始就建立安全性。将安全性视为技术债务的一部分以避免这个问题，并涵盖所有可能性。
根据 Plattner 说的，最重要的是难以让人们改变行为。没有人会自愿改变，她说，即使你指出新的行为更安全。他们也只不过是点点头而已。
Davidson 说，工程师们需要开始考虑他们的代码如何被攻击，并从这个角度进行设计。她说她只有两个规则。第一个从不信任任何未验证的数据；规则二参见规则一。
她笑着说：“人们一直这样做。他们说：‘我的客户端给我发送数据，所以没有问题’。千万不要……”。
Plattner说，安全的第二个关键是“永远不信任用户”。
Davidson 以另外一种说法表示：“我的工作是做专业的偏执狂。”她一直担心有人或许无意中会破坏她的系统。这不是学术性的考虑，最近已经有通过 IoT 设备的拒绝服务攻击。
### Little Bobby Tables
Plattner 说：“如果你安全计划的一部分是信任用户做正确的事情，那么无论你有什么其他安全措施，你系统本质上是不安全的。”
她解释说，重要的是要净化所有的用户输入，如 [XKCD 漫画](https://xkcd.com/327/)中的那样，一位妈妈干掉整个学校的数据库——因为她的儿子的中间名是 “DropTable Students”（LCTT 译注：看不懂的[点这里](https://www.explainxkcd.com/wiki/index.php/Little_Bobby_Tables)）。
所以净化所有的用户输入。你一定检查一下。
她展示了一个 JavaScript 开发者在开源软件中使用 eval 的例子。她警告说：“一个好的基本规则是‘从不使用 eval()’”。 [eval()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) 函数会执行 JavaScript 代码。“如果你这样做，你正在向任意用户开放你的系统。”
Davidson 警告说，她甚至偏执到将文档中的示例代码的安全测试也包括在内。她笑着说：“我们都知道没有人会去复制示例代码”。她强调指出，任何代码都应进行安全检查。
Plattner 的第三个建议：要使安全容易实施。她建议采取阻力最小的道路。
对外，使用户<ruby> 默认采用 <rt> option out </rt></ruby>安全措施而不是<ruby> 可选采用 <rt> option in </rt></ruby>，或者更好使其成为强制性的措施。她说，改变人们的行为是科技中最难的问题。一旦用户习惯以非安全的方式使用你的产品，让他们改进会变得非常困难。
在公司内部，她建议制定安全标准，因此这不是个别开发人员需要考虑的内容。例如，将数据加密作为服务，这样工程师可以只需要调用服务就可以加密或解密数据。
她说，确保公司注重安全环境。在让整个公司切换到好的安全习惯。
你的安全短板决定了你的安全水准，所以重要的是每个人都有良好的个人安全习惯，并具有良好的企业安全环境。
在 Oracle，他们已经全面覆盖安全的各个环节。Davidson 表示，她厌倦了向没有安全培训的大学毕业的工程师解释安全性，所以她写了 Oracle 的第一个编码标准，现在已经有数百个页面之多以及很多贡献者，还有一些课程是强制性的。它们具有符合安全要求的度量标准。这些课程不仅适用于工程师，也适用于文档作者。她说：“这是一种文化。”
没有提及密码的关于安全性的讨论怎么能是安全的？Plattner 说：“每个人都应该使用一个好的密码管理器，在工作中应该是强制性的，还有双重身份验证。”
她说，基本的密码原则应该是每个工程师日常生活的一部分。密码中最重要的是它们的长度和熵（使按键的集合尽可能地随机）。强健的密码熵检查器对此非常有用。她建议使用 Dropbox 开源的熵检查器 [zxcvbn](https://blogs.dropbox.com/tech/2012/04/zxcvbn-realistic-password-strength-estimation/)。
Plattner 说，另一个诀窍是在验证用户输入时使用一些故意减慢速度的算法，如 [bcrypt](https://en.wikipedia.org/wiki/Bcrypt)。慢速并不困扰大多数合法用户，但会让那些试图强行进行密码尝试的黑客难受。
Davidson 说：“所有这些都为那些想要进入技术安全领域的人提供了工作安全保障，我们在各种地方放了各种代码，这就产生了系统性风险。只要我们继续在技术领域做有趣的事情，我不认为任何人不想要在安全中工作。”
---
via: <https://thenewstack.io/security-engineers-problem/>
作者：[TC Currie](https://thenewstack.io/author/tc/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Docker 引擎的 Swarm 模式：添加工作者节点教程
|
Igor Ljubuncic
|
http://www.dedoimedo.com/computers/docker-swarm-adding-worker-nodes.html
|
我们学习了如何初始化以及启动 Docker 1.12 中内置的原生的集群以及编排功能。但是我们只有管理者manager节点还没有其它工作者worker节点。今天我们会展开讲述这个。
|
/data/attachment/album/201709/22/230527i8ifi9ps7pqy4eao.jpg.thumb.jpg
|
/data/attachment/album/201709/22/230527i8ifi9ps7pqy4eao.jpg
| true | false | true |
geekpi
| false |
[
"Docker",
"Swarm"
] |
容器与云
|
{
"viewnum": 6919,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8888,
"displayorder": 0
}
] |
我们学习了如何初始化以及启动 Docker 1.12 中内置的原生的集群以及编排功能。但是我们只有管理者manager节点还没有其它工作者worker节点。今天我们会展开讲述这个。
| 2017-09-23T09:04:00 | 2017-09-23T09:04:00 | 8,892 |
/article-8892-1.html
|
让我们继续几周前在 CentOS 7.2 中开始的工作。 在本[指南](/article-8888-1.html)中，我们学习了如何初始化以及启动 Docker 1.12 中内置的原生的集群以及编排功能。但是我们只有<ruby> 管理者 <rp> （ </rp> <rt> manager </rt> <rp> ） </rp></ruby>节点还没有其它<ruby> 工作者 <rp> （ </rp> <rt> worker </rt> <rp> ） </rp></ruby>节点。今天我们会展开讲述这个。
我将向你展示如何将不对称节点添加到 Sawrm 中，比如一个与 CentOS 相邻的 [Fedora 24](http://www.dedoimedo.com/computers/fedora-24-gnome.html)，它们都将加入到集群中，还有相关很棒的负载均衡等等。当然这并不是轻而易举的，我们会遇到一些障碍，所以它应该是非常有趣的。
### 先决条件
在将其它节点成功加入 Swarm 之前，我们需要做几件事情。理想情况下，所有节点都应该运行相同版本的 Docker，为了支持原生的编排功能，它的版本至少应该为 1.12。像 CentOS 一样，Fedora 内置的仓库没有最新的构建版本，所以你需要手动构建，或者使用 Docker 仓库手动[添加和安装](http://www.dedoimedo.com/computers/docker-centos-upgrade-latest.html)正确的版本，并修复一些依赖冲突。我已经向你展示了如何在 CentOS 中操作，经过是相同的。
此外，所有节点都需要能够相互通信。这就需要有正确的路由和防火墙规则，这样<ruby> 管理者 <rp> （ </rp> <rt> manager </rt> <rp> ） </rp></ruby>和<ruby> 工作者 <rp> （ </rp> <rt> worker </rt> <rp> ） </rp></ruby>节点才能互相通信。否则，你无法将节点加入 Swarm 中。最简单的解决方法是临时清除防火墙规则 （`iptables -F`），但这可能会损害你的安全。请确保你完全了解你正在做什么，并为你的节点和端口创建正确的规则。
>
> Error response from daemon: Timeout was reached before node was joined. The attempt to join the swarm will continue in the background. Use the "docker info" command to see the current swarm status of your node.
>
>
> 守护进程的错误响应：节点加入之前已超时。尝试加入 Swarm 的请求将在后台继续进行。使用 “docker info” 命令查看节点的当前 Swarm 状态。
>
>
>
你需要在主机上提供相同的 Docker 镜像。在上一个教程中我们创建了一个 Apache 映像，你需要在你的<ruby> 工作者 <rp> （ </rp> <rt> worker </rt> <rp> ） </rp></ruby>节点上执行相同操作，或者分发已创建的镜像。如果你不这样做，你会遇到错误。如果你在设置 Docker 上需要帮助，请阅读我的[介绍指南](http://www.dedoimedo.com/computers/docker-guide.html)和[网络教程](http://www.dedoimedo.com/computers/docker-networking.html)。
```
7vwdxioopmmfp3amlm0ulimcu \_ websky.11 my-apache2:latest
localhost.localdomain Shutdown Rejected 7 minutes ago
"No such image: my-apache2:lat&"
```
### 现在开始
现在我们有一台启动了 CentOS 机器，并成功地创建了容器。你可以使用主机端口连接到该服务，这一切都看起来很好。目前，你的 Swarm 只有<ruby> 管理者 <rp> （ </rp> <rt> manager </rt> <rp> ） </rp></ruby>。
### 加入<ruby> 工作者 <rp> （ </rp> <rt> worker </rt> <rp> ） </rp></ruby>
要添加新的节点，你需要使用 `join` 命令。但是你首先必须提供令牌、IP 地址和端口，以便<ruby> 工作者 <rp> （ </rp> <rt> woker </rt> <rp> ） </rp></ruby>节点能正确地对 Swarm 管理器进行身份验证。接着（在 Fedora 上）执行：
```
[root@localhost ~]# docker swarm join-token worker
To add a worker to this swarm, run the following command:
docker swarm join \
--token SWMTKN-1-0xvojvlza90nrbihu6gfu3qm34ari7lwnza ... \
192.168.2.100:2377
```
如果你不修复防火墙和路由规则，你会得到超时错误。如果你已经加入了 Swarm，重复 `join` 命令会收到错误：
```
Error response from daemon: This node is already part of a swarm. Use "docker swarm leave" to leave this swarm and join another one.
```
如果有疑问，你可以离开 Swarm，然后重试：
```
[root@localhost ~]# docker swarm leave
Node left the swarm.
docker swarm join --token
SWMTKN-1-0xvojvlza90nrbihu6gfu3qnza4 ... 192.168.2.100:2377
This node joined a swarm as a worker.
```
在<ruby> 工作者 <rp> （ </rp> <rt> worker </rt> <rp> ） </rp></ruby>节点中，你可以使用 `docker info` 来检查状态：
```
Swarm: active
NodeID: 2i27v3ce9qs2aq33nofaon20k
Is Manager: false
Node Address: 192.168.2.103
Likewise, on the manager:
Swarm: active
NodeID: cneayene32jsb0t2inwfg5t5q
Is Manager: true
ClusterID: 8degfhtsi7xxucvi6dxvlx1n4
Managers: 1
Nodes: 3
Orchestration:
Task History Retention Limit: 5
Raft:
Snapshot Interval: 10000
Heartbeat Tick: 1
Election Tick: 3
Dispatcher:
Heartbeat Period: 5 seconds
CA Configuration:
Expiry Duration: 3 months
Node Address: 192.168.2.100
```
### 创建或缩放服务
现在，我们需要看下 Docker 是否以及如何在节点间分发容器。我的测试展示了一个在非常轻的负载下相当简单的平衡算法。试了一两次之后，即使在我尝试缩放并更新之后，Docker 也没有将运行的服务重新分配给新的 worker。同样，有一次，它在<ruby> 工作者 <rp> （ </rp> <rt> worker </rt> <rp> ） </rp></ruby>节点上创建了一个新的服务。也许这是最好的选择。
*在新的<ruby> 工作者 <rp> （ </rp> <rt> worker </rt> <rp> ） </rp></ruby>节点上完整创建新的服务。*
过了一段时间，两个容器之间的现有服务有一些重新分配，但这需要一些时间。新服务工作正常。这只是一个前期观察，所以我现在不能说更多。现在是开始探索和调整的新起点。
*负载均衡过了一会工作了。*
### 总结
Docker 是一只灵巧的小野兽，它仍在继续长大，变得更复杂、更强大，当然也更优雅。它被一个大企业吃掉只是一个时间问题。当它带来了原生的编排功能时，Swarm 模式运行得很好，但是它不只是几个容器而已，而是充分利用了其算法和可扩展性。
我的教程展示了如何将 Fedora 节点添加到由 CentOS 运行的群集中，并且两者能并行工作。关于负载平衡还有一些问题，但这是我将在以后的文章中探讨的。总而言之，我希望这是一个值得记住的一课。我们已经解决了在尝试设置 Swarm 时可能遇到的一些先决条件和常见问题，同时我们启动了一堆容器，我们甚至简要介绍了如何缩放和分发服务。要记住，这只是一个开始。
干杯。
---
作者简介：
我是 Igor Ljubuncic。现在大约 38 岁，已婚但还没有孩子。我现在在一个大胆创新的云科技公司做首席工程师。直到大约 2015 年初时，我还在一个全世界最大的 IT 公司之一中做系统架构工程师，和一个工程计算团队开发新的基于 Linux 的解决方案，优化内核以及攻克 Linux 的问题。在那之前，我是一个为高性能计算环境设计创新解决方案的团队的技术领导。还有一些其他花哨的头衔，包括系统专家、系统程序员等等。所有这些都曾是我的爱好，但从 2008 年开始成为了我的付费工作。还有什么比这更令人满意的呢？
从 2004 年到 2008 年间，我曾通过作为医学影像行业的物理学家来糊口。我的工作专长集中在解决问题和算法开发。为此，我广泛地使用了 Matlab，主要用于信号和图像处理。另外，我得到了几个主要的工程方法学的认证，包括 MEDIC 六西格玛绿带、试验设计以及统计工程学。
我也开始写书，包括奇幻类和 Linux 上的技术性工作。彼此交融。
要查看我开源项目、出版物和专利的完整列表，请滚动到下面。
有关我的奖项，提名和 IT 相关认证的完整列表，请稍等一下。
---
via: <http://www.dedoimedo.com/computers/docker-swarm-adding-worker-nodes.html>
作者：[Igor Ljubuncic](http://www.dedoimedo.com/faq.html) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Facebook 放弃专利条款，下周将重新以 MIT 许可证发布 React 16
|
Wxy
|
就在几个小时前，Facebook 宣布，将在下周发布的 React 16 会以 MIT 许可证重新授权，以应对社区对之前的 BSD + 专利许可模式的不安。
|
/data/attachment/album/201709/23/122310ajremeaekl58aaa8.png.thumb.jpg
|
/data/attachment/album/201709/23/122310ajremeaekl58aaa8.png
| true | false | false | false |
[
"Facebook",
"许可证",
"React"
] |
新闻
|
{
"viewnum": 5770,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "117.151.50.107",
"message": "毕竟这是facebook，不是某甲骨文。。。",
"username": "来自湖北的 Chrome 60.0|Windows 10 用户",
"date": "2017-09-23T16:31:13"
}
] |
[
{
"raid": 8733,
"displayorder": 0
},
{
"raid": 8910,
"displayorder": 0
},
{
"raid": 8764,
"displayorder": 1
},
{
"raid": 8876,
"displayorder": 2
},
{
"raid": 8880,
"displayorder": 3
}
] |
就在几个小时前，Facebook 宣布，将在下周发布的 React 16 会以 MIT 许可证重新授权，以应对社区对之前的 BSD + 专利许可模式的不安。
| 2017-09-23T12:23:00 | 2017-09-23T12:23:00 | 8,895 |
/article-8895-1.html
|
就在几个小时前，Facebook [宣布](https://code.facebook.com/posts/300798627056246/relicensing-react-jest-flow-and-immutable-js/)，将在下周发布的 React 16 会以 MIT 许可证重新授权，以应对社区对之前的 BSD + 专利许可模式的不安。
Facebook 负责 React 和 GraphQL 等产品的产品架构组工程总监 Adam Wolff 写道：
>
> “下周，我们将以 MIT 许可证对我们的开源项目 React、Jest、Flow 和 Immutable.js 重新进行许可。我们重新许可这些项目是因为 React 是广泛的互联网开源软件生态的基石，我们并不想因非技术原因而阻碍其前行的道路。”
>
>
>
React.js 是 Facebook 推出的一个用来构建用户界面的 JavaScript 库，起源于 Facebook 的内部项目，用来架设 Instagram 的网站。
* 2013 年 5 月，[Facebook 将 React.js 开源](https://code.facebook.com/projects/176988925806765/react/)。
* 2016 年 7 月，React.js 开源许可协议中的附加专利条款引发争议。
* 2016 年 11 月，Facebook [发布官方问答](https://react-etc.net/entry/react-patents-facebook-license-faq-adoption-by-apple-and-microsoft)，对附加专利条款进行澄清。
* 2017 年 7 月，Apache 基金会禁止使用遵循 BSD 许可证 + 专利开源协议的 JAR 包。
在 Apache 基金会将 React 这样的采用 BSD 许可证 + 专利条款的软件列入“[X 类别](https://www.apache.org/legal/resolved.html#category-x)”之后，社区再次引发了对此问题[强烈关注](/article-8733-1.html)，并导致很多大型的互联网公司开始绸缪放弃和替换 React——尤其是在 [WordPress 宣布将重写其软件，剥离对 React 的依赖](/article-8880-1.html)之后达到了顶峰。而国内的互联网公司，如百度、阿里，也纷纷有传言将追随这一动作，弃用 React。
迫于这种压力，Facebook 决定对 React 等开源项目放弃其原有的 BSD 许可证 + 专利条款的许可模式，虽然他们认为“BSD 许可证 + 专利条款为项目的用户提供了一些好处”，但是他们也“承认没能说服社区接受这一许可模式”。
在感受到这一许可证的不确定性风险之后，许多团队开始[选择替代性的产品](/article-8877-1.html)。Facebook 对此感到抱歉，对 React 重新许可虽然不一定能赢得这些团队回心转意，但是还是“希望将这扇门继续打开”。
这一转变自然也会引起人们对 Facebook 其它的开源项目的质疑，因为目前 Facebook 许多流行的开源项目都采用的是 BSD 许可 + 专利条款方式。但是他们会“重新评估这些项目的许可证，而每个项目的情况有所不同，替换许可证取决于各种因素”。下周，除了 React 之外，Facebook 也将对 Jest、Flow 和 Immutable.js 等开源项目进行重新许可。
这一许可证的变化将随着下周即将发布的 React 16 一起更新。React 16 已经开发了一年，内部进行完全重写，解锁了强大的功能，让每个人都可以用它来构建大规模的用户界面。
Adam Wolff 表示，将许可证的讨论放到后面，无论大家用不用 React ，希望它都可以给开发者以灵感，毕竟，我们最关心的是：交付伟大的产品。
|
||||
为什么我们比以往更需要开放的领导人
|
Philip A Foster
|
https://opensource.com/open-organization/17/2/need-open-leaders-more-ever
|
不断变化的社会和文化条件正促使着开放的领导。
|
/data/attachment/album/201709/24/091921hgm7huhuz6kzdsok.png.thumb.jpg
|
/data/attachment/album/201709/24/091921hgm7huhuz6kzdsok.png
| true | false | true |
TimeBear
| false |
[
"开放组织"
] |
观点
|
{
"viewnum": 3698,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
不断变化的社会和文化条件正促使着开放的领导。
| 2017-09-24T09:19:00 | 2017-09-24T09:19:00 | 8,898 |
/article-8898-1.html
|
>
> 不断变化的社会和文化条件正促使着开放的领导。
>
>
>
领导力就是力量。更具体地说，领导力是影响他人行动的力量。 关于领导力的神话不仅可以让人联想到人类浪漫的一面而且还有人类境况险恶的一面。 我们最终决定如何领导才能决定其真正的本质。
现代许多对领导力的理解都是在战争中诞生的，在那里，领导力意味着熟练地执行命令和控制思想。 在现代商业的大部分时间里，我们都是以一个到达权力顶峰的伟大的男人或女人作为领导，并通过地位来发挥力量的。 这种传统的通过等级和报告关系的领导方式严重依赖于正式的权威。 这些结构中的权威通过垂直层次结构向下流动，并沿命令链的形式存在。
然而，在 20 世纪后期，一些东西开始改变。 新技术打开了全球化的大门，从而使团队更加分散。 我们投入人力资本的方式开始转变，永远地改变了人们之间的沟通方式。组织内部的人开始感觉得到了责任感，他们要求对自己的成功(和失败)拥有归属感。 领导者不再是权力的唯一拥有者。 21世纪的领导者带领 21 世纪的组织开始了解授权、协作、责任和清晰的沟通是一种新型权力的本质。 这些新领导人开始分享权力——他们无保留地信任他们的追随者。
随着组织继续变得更加开放，即使是没有“领导力”头衔的人也会感到有责任推动变革。 这些组织消除了等级制度的枷锁，让工人们以他们认为合适的方式去工作。 历史暴露了 20 世纪领导人倾向通过单边决策和单向信息流来扼杀敏捷性。 但是，新世纪的领导者却是确定一个组织，让由它授权的若干个体来完成一些事情。 重点是权力赋予若干个体——坦率地说，一个领导者不能在任何时候出现在所有的地方，做出所有的决定。
因此，领导人也开始变得开放。
### 控制
当旧式领导人专注于指挥和控制的地位权力时，一个开放的领导者通过新形式的组织管理方式、新技术和其他减少摩擦的方式，将组织控制权放在了其它人身上，这样可以更有效的方式实现集体行动的方式。 这些领导者了解信任的力量，相信追随者总是会表现出主动性、参与性和独立性。 而这种新的领导方式需要在战术上有所转变——从告诉人们如何去做，到向他们展示如何去做，并在路上指导他们。开放的领导人很快就发现，领导力不是影响我们发挥进步的力量，而是我们在组织成员中分配的力量和信心。 21 世纪的领导者专注于社区和对他人的教化。最后，开放的领导者并不是专注于自我，而是无私的。
### 交流
20 世纪的领导者人组织并控制整个组织的信息的流动。 然而，开放的领导者试图通过与团队成员共享信息和背景（以及权力）来组织一个组织。 这些领导人摧毁了领地，谦逊前行，分享着前所未有的力量。 集体赋权和参与的协作创造了灵活性，分担责任，所有权，尤其是幸福。 当一个组织的成员被授权做他们的工作时，他们比等级层次的同事更快乐（因而更有生产力）。
### 信任
开放的领导者接受不确定性，相信他们的追随者在正确的时间做正确的事情。 他们拥有比传统对手，有更高的吸引人力资本效率的能力。 再说一次：他们不会像命令和控制的微观管理者那样运作。 提高透明度，而不是暗箱操作，他们尽可能的把决策和行动放在公开场合，解释决策的基础，并假设员工对组织内的情况有高度的把握。开放领导者的操作的前提是，如果没有他们的持续干预，该组织的人力资本就更有能力取得成功。
### 自治权
在 20 世纪具有强大指挥和控制力的领导者专注于某些权力的时候，一个开放的领导者更多地关注组织内个人的实际活动。 当领导者专注于个人时，他们就能够更好地训练和指导团队成员。 从这个角度来看，一个开放的领导者关注的是与组织的愿景和使命一致的行为和行动。最后，一个开放的领导者被看作是团队中的一员，而不是团队的领导者。 这并不意味着领导人放弃了权力的地位，而是低估了这一点，以分享权力，并通过自主创造成果赋予个人权力。
### 赋权
开放的领导人把重点放在授予组织成员的权力上。 在这个过程中承认领导者在组织人力资本中的技能、能力和信任，从而为整个团队带来了积极的动力和意愿。 最终，赋权就是帮助追随者相信他们自己的能力。 那些相信自己拥有个人权力的追随者更有可能采取主动行动、制定和实现更高的目标，并在困难的环境下坚持下去。 最终，开放组织的概念是关于包容性，每个人都是属于自己的，个性和不同的观点对于成功是至关重要的。 一个开放的组织及其开放的领导者提供了一种社区的感觉，而成员则受到组织的使命或目的的驱动。 这会产生一种比个人更大的归属感。 个性创造了成员之间的幸福和工作满意度。 反过来，又实现了更高的效率和成功。
我们都应该为 21 世纪领导人所要求的开放性而努力。 这需要自我反省，好奇心，尤其是它正在进行的改变。 通过新的态度和习惯，我们逐渐发现了一个真正的开放领导者，并且希望我们在适应 21 世纪的领导风格的同时，也开始采纳这些理念。
是的，领导力就是力量。我们如何利用这种权力决定了我们组织的成败。 那些滥用权力的人不会持久，但那些分享权力和庆祝他人的人会更持久。 通过阅读 [这本书](https://opensource.com/open-organization/resources/leaders-manual)，你可以在开放组织及其领导的持续对话中开始发挥重要作用。 在[本卷](https://opensource.com/open-organization/resources/leaders-manual)的结论中，您将找到与开放组织社区联系的额外资源和机会，以便您也可以与我们聊天、思考和成长。 欢迎来到谈话——欢光临！
*这篇文章最初是作为《开放组织领导手册》的引言出现的，它现在可以[从 Opensource.com 中可获得](https://opensource.com/open-organization/resources/leaders-manual)。*
（ 题图：opensource.com）
---
作者简介：
Philip A Foster - Dr. Philip A. Foster 是一名领导/商业教练兼顾问兼兼职教授。 他是企业运营、组织发展、展望和战略领导层的著名思想领袖。 Dr. Foster 通过设计和实施战略、战略预见和规划来促进变革。
---
via: <https://opensource.com/open-organization/17/2/need-open-leaders-more-ever>
作者：[Philip A Foster](https://opensource.com/users/maximumchange) 译者：[TimeBear](https://github.com/TimeBear) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
IoT 边缘计算框架的新进展
|
Eric Brown
|
https://www.linux.com/blog/2017/7/iot-framework-edge-computing-gains-ground
|
开源项目 EdgeX Foundry 旨在开发一个标准化的互操作物联网边缘计算框架。
|
/data/attachment/album/201709/24/141225eno3vqcw5ziirfq7.png.thumb.jpg
|
/data/attachment/album/201709/24/141225eno3vqcw5ziirfq7.png
| true | false | true |
penghuster
| false |
[
"物联网"
] |
新闻
|
{
"viewnum": 4862,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 2,
"likes": 0
}
|
[
{
"postip": "222.73.196.18",
"message": "歪瓜人 就喜欢搞这个，总想搞一套标准出来,",
"username": "Linux一叶 [Chrome 60.0|Mac 10.11]",
"date": "2017-09-28T11:03:56"
}
] |
[] |
开源项目 EdgeX Foundry 旨在开发一个标准化的互操作物联网边缘计算框架。
| 2017-09-24T14:12:13 | 2017-09-24T14:12:13 | 8,899 |
/article-8899-1.html
|
>
> 开源项目 EdgeX Foundry 旨在开发一个标准化的互操作物联网边缘计算框架。
>
>
>
4 月份时， Linux 基金组织[启动](http://linuxgizmos.com/open-source-group-focuses-on-industrial-iot-gateway-middleware/)了一个开源项目 [EdgeX Foundry](https://www.edgexfoundry.org/) ，用于为物联网边缘计算开发一个标准化互操作框架。 就在最近， EdgeX Foundry 又[宣布](https://www.edgexfoundry.org/announcement/2017/07/17/edgex-foundry-builds-momentum-for-a-iot-interoperability-and-a-unified-marketplace-with-eight-new-members/)新增了 8 个成员，其总成员达到 58 位。
这些新成员是 Absolute、IoT Impact LABS、inwinStack、Parallel Machines、Queen's University Belfast、RIOT、Toshiba Digital Solutions Corporation 和 Tulip Interfaces。 其原有成员包括 AMD、Analog Devices、Canonical/Ubuntu、Cloud Foundry、Dell、Linaro、Mocana、NetFoundry、 Opto 22、RFMicron 和 VMWare 等其他公司或组织。
EdgeX Foundry 项目构建于戴尔早期的基于 Apache2.0 协议的 [FUSE](https://medium.com/@gigastacey/dell-plans-an-open-source-iot-stack-3dde43f24feb) 物联网中间件框架之上，其中包括十几个微服务和超过 12.5 万行代码。在 FUSE 合并了类同项目 AllJoyn-compliant IoTX 之后，Linux 基金会协同 Dell 创立了 EdgeX Foundry ，后者是由 EdgeX Foundry 现有成员 Two Bulls 和 Beechwood 发起的项目。
EdgeX Foundry 将创造一个互操作性的、即插即用组件的物联网边缘计算的生态系统。开源的 EdgeX 栈将协调各种传感器网络协议与多种云平台及分析平台。该框架旨在充分挖掘横跨边缘计算、安全、系统管理和服务等模块间的互操作性代码。
对于项目成员及其客户来说，其关键的好处是在于能将各种预先认证的软件集成到许多 IoT 网关和智能边缘设备上。 在 Linux.com 的一次采访中，[IoT Impact LABS](https://iotimpactlabs.com/) 的首席工程师 Dan Mahoney 说：“现实中，EdgeX Foundry 降低了我们在部署多供应商解决方案时所面对的挑战。”
在 Linux 基金会仍然将其 AllSeen Alliance 项目下的 AllJoyn 规范合并到 [IoTivity](https://www.linux.com/news/how-iotivity-and-alljoyn-could-combine) 标准的情况下，为什么会发起了另外一个物联网标准化项目（EdgeX Foundry） 呢？ 原因之一，EdgeX Foundry 不同于 IoTivity，IoTivity 主要解决工业物联网问题，而 EdgeX Foundry 旨在解决消费级和工业级物联网全部的问题。 更具体来说， EdgeX Foundry 旨在成为网关和智能终端的通用中间件。 EdgeX Foundry 与 IoTivity 的另一个不同在于，前者希望借助预认证的终端塑造一种新产品，后者更多解决现存产品之间的互操作性。
Linux 基金会 IoT 高级总监 Philip DesAutels 说：“IoTivity 提供实现设备之间无缝连接的协议， 而 EdgeX Foundry 提供了一个边缘计算框架。EdgeX Foundry 能够兼容如 IoTivity、 BacNet、 EtherCat 等任何协议设备，从而实现集成多协议通信系统的通用边缘计算框架，该项目的目标是为构建互操作组件的生态系统的过程中，降低不确定性，缩短市场化时间，更好地产生规模效应。”
上个月, 由 [Open Connectivity Foundation](https://openconnectivity.org/developer/specifications/international-standards) （OCF）和 Linux 基金组织共同发起的 IoTivity 项目发布了 [IoTivity 1.3](https://wiki.iotivity.org/release_note_1.3.0)，该版本增加了与其曾经的对手 AllJoyn spec 的纽带，也增加了对于 OCF 的 UPnP 设备发现标准的接口。 预计在 [IoTivity 2.0](https://www.linux.com/news/iotivity-20-whats-store) 中， IoTivity 和 AllJoyn 将会更进一步深入集成。
DesAutels 告诉 linux.com，IoTivity 和 EdgeX 是“高度互补的”，其“原因是 EdgeX Foundry 项目的几个成员也是 IoTivity 或 OCF 的成员，如此更强化了 IoTivity 和 EdgeX 的合作关系。”
尽管 IoTivity 和 EdgeX 都宣称是跨平台的，包括在 CPU 架构和 OS 方面，但是二者还是存在一定区别。 IoTivity 最初是基于 Linux 平台设计，兼容 Ubuntu、Tizen 和 Android 等 Linux 系列 OS，后来逐步扩展到 Windows 和 iOS 操作系统。与之对应的 EdgeX 设计之初就是基于跨平台的理念，其完美兼容于各种 CPU 架构，支持 Linux, Windows 和 Mac OS 等操作系统， 未来还将兼容于实时操作系统（RTOS）。”
EdgeX 的新成员 [RIOT](https://riot-os.org/) 提供了一个开源的面向物联网的项目 RIOT RTOS。RIOT 的主要维护者 Thomas Eichinger 在一次表彰讲话中说：“由于 RIOT 初衷就是致力于解决 linux 不太适应的问题， 故对于 RIOT 社区来说，参加和支持类似于 EdgeX Foundry 等边缘计算的开源组织的积极性是自然而然的。”
### 传感器集成的简化
IoT Impact LABS （即 Impact LABS 或直接称为 LABS）是另一个 EdgeX 新成员。 该公司推出了一个独特的业务模式，旨在帮助中小企业度过物联网解决方案的试用阶段。该公司的大部分客户，其中包括几个 EdgeX Foundry 的项目成员，是致力于建设智慧城市、基础设施再利用、提高食品安全，以及解决社会面临的自然资源缺乏的挑战。
Dan Mahoney 说：“在 LABS 我们花费了很多时间来调和试点客户的解决方案之间的差异性。 EdgeX Foundry 可以最小化部署边缘软件系统的工作量，从而使我们能够更快更好地部署高质量的解决方案。”
该框架在涉及多个供应商、多种类型传感器的场景尤其凸显优势。“Edgex Foundry 将为我们提供快速构建可以控制所有部署的传感器的网关的能力。” Mahoney 补充说到。传感器制造商将借助 EdgeX SDK 烧写应用层协议驱动到边缘设备，该协议能够兼容多供应商和解决方案。
### 边缘分析能力的构建
当我们问到， Mahoney 的公司希望见到 EdgeX Foundry 怎样的发展时，他说：“我们喜见乐闻的一个目标是有更多有效的工业协议成为设备服务，这是一个更清晰的边缘计算实现之路。”
在工业物联网和消费级物联网中边缘计算都呈现增长趋势。 在后者，我们已经看到如 Alexa 的智能声控以及录像分析等几个智能家居系统[集成了边缘计算分析](https://www.linux.com/news/smart-linux-home-hubs-mix-iot-ai)技术。 这减轻了云服务平台的计算负荷，但同时也带来了安全、隐私，以及由于供应商中断或延迟问题引起的服务中断问题。
对于工业物联网网关，延迟问题成为首要的问题。因此，在物联网网关方面出现了一些类似于云服务功能的扩展。 其中一个解决方案是，为了安全将一些云服务上的安全保障应用借助容器如 [RIOS 与 Ubuntu 内核快照机制](https://www.linux.com/news/future-iot-containers-aim-solve-security-crisis)等方式集成到嵌入式设备。 另一种方案是，开发 IoT 生态系统，迁移云功能到边缘计算上。上个月，Amazon 为基于 linux 的网关发布了实现 [AWS Greengrass](http://linuxgizmos.com/amazon-releases-aws-greengrass-for-local-iot-processing-on-linux-devices/) 物联网协议栈的 AWS lambda。 该软件能够使 AWS 计算、消息路由、数据缓存和同步能力在诸如物联网网关等联网设备上完成。
分析能力是 EdgeX Foundry 发展路线上的一个关键功能要点。 发起成员之一 Cloud Foundry 其旨在集成其主要的工业应用平台到边缘设备。 另一个新成员 [Parallel Machines](https://www.parallelmachines.com/) 则计划利用 EdgeX 将 AI 带到边缘设备。
EdgeX Foundry 仍然在项目早期， 软件仍然在 α 阶段，其成员在上个月（六月份）才刚刚进行了第一次全体成员大会。同时该项目已经为新开发者准备了一些初始训练课程，另外从[这里](https://wiki.edgexfoundry.org/)也能获取更多的信息。
---
via: <https://www.linux.com/blog/2017/7/iot-framework-edge-computing-gains-ground>
作者： [ERIC BROWN](https://www.linux.com/users/ericstephenbrown) 译者：[penghuster](https://github.com/penghuster) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
常用 GDB 命令中文速览
|
Fsf
|
https://sourceware.org/gdb/current/onlinedocs/gdb/
|
本文整理自《Debugging with GDB: the GNU Source-Level Debugger for GDB (GDB)》
|
/data/attachment/album/201709/24/150421z8qnabqpphbs1a8o.jpg.thumb.jpg
|
/data/attachment/album/201709/24/150421z8qnabqpphbs1a8o.jpg
| true | false | true |
robot527
| true |
[
"gdb",
"调试"
] |
软件开发
|
{
"viewnum": 8943,
"commentnum": 1,
"favtimes": 7,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "202.104.106.74",
"message": "Good",
"username": "来自广东深圳的 Chrome 61.0|Windows 7 用户",
"date": "2017-09-25T17:02:49"
}
] |
[] |
本文整理自《Debugging with GDB: the GNU Source-Level Debugger for GDB (GDB)》
| 2017-09-24T15:04:31 | 2017-09-24T15:04:31 | 8,900 |
/article-8900-1.html
|
### 目录
* break -- 在指定的行或函数处设置断点，缩写为 `b`
* info breakpoints -- 打印未删除的所有断点，观察点和捕获点的列表，缩写为 `i b`
* disable -- 禁用断点，缩写为 `dis`
* enable -- 启用断点
* clear -- 清除指定行或函数处的断点
* delete -- 删除断点，缩写为 `d`
* tbreak -- 设置临时断点，参数同 `break`，但在程序第一次停住后会被自动删除
* watch -- 为表达式（或变量）设置观察点，当表达式（或变量）的值有变化时，暂停程序执行
* step -- 单步跟踪，如果有函数调用，会进入该函数，缩写为 `s`
* reverse-step -- 反向单步跟踪，如果有函数调用，会进入该函数
* next -- 单步跟踪，如果有函数调用，不会进入该函数，缩写为 `n`
* reverse-next -- 反向单步跟踪，如果有函数调用，不会进入该函数
* return -- 使选定的栈帧返回到其调用者
* finish -- 执行直到选择的栈帧返回，缩写为 `fin`
* until -- 执行直到达到当前栈帧中当前行后的某一行（用于跳过循环、递归函数调用），缩写为 `u`
* continue -- 恢复程序执行，缩写为 `c`
* print -- 打印表达式 EXP 的值，缩写为 `p`
* x -- 查看内存
* display -- 每次程序停止时打印表达式 EXP 的值（自动显示）
* info display -- 打印早先设置为自动显示的表达式列表
* disable display -- 禁用自动显示
* enable display -- 启用自动显示
* undisplay -- 删除自动显示项
* help -- 打印命令列表（带参数时查找命令的帮助），缩写为 `h`
* attach -- 挂接到已在运行的进程来调试
* run -- 启动被调试的程序，缩写为 `r`
* backtrace -- 查看程序调用栈的信息，缩写为 `bt`
* ptype -- 打印类型 TYPE 的定义
---
### break
使用 `break` 命令（缩写 `b`）来设置断点。
用法：
* `break` 当不带参数时，在所选栈帧中执行的下一条指令处设置断点。
* `break <function-name>` 在函数体入口处打断点，在 C++ 中可以使用 `class::function` 或 `function(type, ...)` 格式来指定函数名。
* `break <line-number>` 在当前源码文件指定行的开始处打断点。
* `break -N` `break +N` 在当前源码行前面或后面的 `N` 行开始处打断点，`N` 为正整数。
* `break <filename:linenum>` 在源码文件 `filename` 的 `linenum` 行处打断点。
* `break <filename:function>` 在源码文件 `filename` 的 `function` 函数入口处打断点。
* `break <address>` 在程序指令的地址处打断点。
* `break ... if <cond>` 设置条件断点，`...` 代表上述参数之一（或无参数），`cond` 为条件表达式，仅在 `cond` 值非零时暂停程序执行。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Set-Breaks.html)。
### info breakpoints
查看断点，观察点和捕获点的列表。
用法：
* `info breakpoints [list...]`
* `info break [list...]`
* `list...` 用来指定若干个断点的编号（可省略），可以是 `2`， `1-3`， `2 5` 等。
### disable
禁用一些断点。参数是用空格分隔的断点编号。要禁用所有断点，不加参数。
禁用的断点不会被忘记，但直到重新启用才有效。
用法：
* `disable [breakpoints] [list...]`
* `breakpoints` 是 `disable` 的子命令（可省略），`list...` 同 `info breakpoints` 中的描述。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Disabling.html)。
### enable
启用一些断点。给出断点编号（以空格分隔）作为参数。没有参数时，所有断点被启用。
用法：
* `enable [breakpoints] [list...]` 启用指定的断点（或所有定义的断点）。
* `enable [breakpoints] once list...` 临时启用指定的断点。GDB 在停止您的程序后立即禁用这些断点。
* `enable [breakpoints] delete list...` 使指定的断点启用一次，然后删除。一旦您的程序停止，GDB 就会删除这些断点。等效于用 `tbreak` 设置的断点。
`breakpoints` 同 `disable` 中的描述。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Disabling.html)。
### clear
在指定行或函数处清除断点。参数可以是行号，函数名称或 `*` 跟一个地址。
用法：
* `clear` 当不带参数时，清除所选栈帧在执行的源码行中的所有断点。
* `clear <function>`, `clear <filename:function>` 删除在命名函数的入口处设置的任何断点。
* `clear <linenum>`, `clear <filename:linenum>` 删除在指定的文件指定的行号的代码中设置的任何断点。
* `clear <address>` 清除指定程序指令的地址处的断点。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Delete-Breaks.html)。
### delete
删除一些断点或自动显示表达式。参数是用空格分隔的断点编号。要删除所有断点，不加参数。
用法： `delete [breakpoints] [list...]`
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Delete-Breaks.html)。
### tbreak
设置临时断点。参数形式同 `break` 一样。
除了断点是临时的之外，其他同 `break` 一样，所以在命中时会被删除。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Set-Breaks.html)。
### watch
为表达式设置观察点。
用法： `watch [-l|-location] <expr>` 每当一个表达式的值改变时，观察点就会暂停程序执行。
如果给出了 `-l` 或者 `-location`，则它会对 `expr` 求值并观察它所指向的内存。例如，`watch *(int *)0x12345678` 将在指定的地址处观察一个 4 字节的区域（假设 int 占用 4 个字节）。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Set-Watchpoints.html)。
### step
单步执行程序，直到到达不同的源码行。
用法： `step [N]` 参数 `N` 表示执行 N 次（或由于另一个原因直到程序停止）。
警告：如果当控制在没有调试信息的情况下编译的函数中使用 `step` 命令，则执行将继续进行，直到控制到达具有调试信息的函数。 同样，它不会进入没有调试信息编译的函数。
要执行没有调试信息的函数，请使用 `stepi` 命令，详见后文。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Continuing-and-Stepping.html)。
### reverse-step
反向单步执行程序，直到到达另一个源码行的开头。
用法： `reverse-step [N]` 参数 `N` 表示执行 N 次（或由于另一个原因直到程序停止）。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Reverse-Execution.html)。
### next
单步执行程序，执行完子程序调用。
用法： `next [N]`
与 `step` 不同，如果当前的源代码行调用子程序，则此命令不会进入子程序，而是将其视为单个源代码行，继续执行。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Continuing-and-Stepping.html)。
### reverse-next
反向步进程序，执行完子程序调用。
用法： `reverse-next [N]`
如果要执行的源代码行调用子程序，则此命令不会进入子程序，调用被视为一个指令。
参数 `N` 表示执行 N 次（或由于另一个原因直到程序停止）。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Reverse-Execution.html)。
### return
您可以使用 `return` 命令取消函数调用的执行。如果你给出一个表达式参数，它的值被用作函数的返回值。
用法： `return <expression>` 将 `expression` 的值作为函数的返回值并使函数直接返回。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Returning.html)。
### finish
执行直到选定的栈帧返回。
用法： `finish` 返回后，返回的值将被打印并放入到值历史记录中。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Continuing-and-Stepping.html)。
### until
执行直到程序到达当前栈帧中当前行之后（与 [break](#break) 命令相同的参数）的源码行。此命令用于通过一个多次的循环，以避免单步执行。
用法：`until <location>` 或 `u <location>` 继续运行程序，直到达到指定的位置，或者当前栈帧返回。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Continuing-and-Stepping.html)。
### continue
在信号或断点之后，继续运行被调试的程序。
用法： `continue [N]` 如果从断点开始，可以使用数字 `N` 作为参数，这意味着将该断点的忽略计数设置为 `N - 1`(以便断点在第 N 次到达之前不会中断)。如果启用了非停止模式（使用 `show non-stop` 查看），则仅继续当前线程，否则程序中的所有线程都将继续。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Continuing-and-Stepping.html)。
### print
求值并打印表达式 EXP 的值。可访问的变量是所选栈帧的词法环境，以及范围为全局或整个文件的所有变量。
用法：
* `print [expr]` 或 `print /f [expr]` `expr` 是一个（在源代码语言中的）表达式。
默认情况下，`expr` 的值以适合其数据类型的格式打印；您可以通过指定 `/f` 来选择不同的格式，其中 `f` 是一个指定格式的字母；详见[输出格式](https://sourceware.org/gdb/current/onlinedocs/gdb/Output-Formats.html)。
如果省略 `expr`，GDB 再次显示最后一个值。
要以每行一个成员带缩进的格式打印结构体变量请使用命令 `set print pretty on`，取消则使用命令 `set print pretty off`。
可使用命令 `show print` 查看所有打印的设置。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Data.html)。
### x
检查内存。
用法： `x/nfu <addr>` 或 `x <addr>` `n`、`f` 和 `u` 都是可选参数，用于指定要显示的内存以及如何格式化。`addr` 是要开始显示内存的地址的表达式。
`n` 重复次数（默认值是 1），指定要显示多少个单位（由 `u` 指定）的内存值。
`f` 显示格式（初始默认值是 `x`），显示格式是 `print('x'，'d'，'u'，'o'，'t'，'a'，'c'，'f'，'s')` 使用的格式之一，再加 `i`（机器指令）。
`u` 单位大小，`b` 表示单字节，`h` 表示双字节，`w` 表示四字节，`g` 表示八字节。
例如：
`x/3uh 0x54320` 表示从地址 0x54320 开始以无符号十进制整数的格式，双字节为单位来显示 3 个内存值。
`x/16xb 0x7f95b7d18870` 表示从地址 0x7f95b7d18870 开始以十六进制整数的格式，单字节为单位显示 16 个内存值。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Memory.html)。
### display
每次程序暂停时，打印表达式 EXP 的值。
用法： `display <expr>`, `display/fmt <expr>` 或 `display/fmt <addr>` `fmt` 用于指定显示格式。像 [print](#print) 命令里的 `/f` 一样。
对于格式 `i` 或 `s`，或者包括单位大小或单位数量，将表达式 `addr` 添加为每次程序停止时要检查的内存地址。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Auto-Display.html)。
### info display
打印自动显示的表达式列表，每个表达式都带有项目编号，但不显示其值。
包括被禁用的表达式和不能立即显示的表达式（当前不可用的自动变量）。
### undisplay
取消某些表达式在程序暂停时的自动显示。参数是表达式的编号（使用 `info display` 查询编号）。不带参数表示取消所有自动显示表达式。
`delete display` 具有与此命令相同的效果。
### disable display
禁用某些表达式在程序暂停时的自动显示。禁用的显示项目不会被自动打印，但不会被忘记。 它可能稍后再次被启用。
参数是表达式的编号（使用 `info display` 查询编号）。不带参数表示禁用所有自动显示表达式。
### enable display
启用某些表达式在程序暂停时的自动显示。
参数是重新显示的表达式的编号（使用 `info display` 查询编号）。不带参数表示启用所有自动显示表达式。
### help
打印命令列表。
您可以使用不带参数的 `help`（缩写为 `h`）来显示命令的类别名的简短列表。
使用 `help <class>` 您可以获取该类中的各个命令的列表。使用 `help <command>` 显示如何使用该命令。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Help.html)。
### attach
挂接到 GDB 之外的进程或文件。该命令可以将进程 ID 或设备文件作为参数。
对于进程 ID，您必须具有向进程发送信号的权限，并且必须具有与调试器相同的有效的 uid。
用法： `attach <process-id>` GDB 在安排调试指定的进程之后做的第一件事是暂停该进程。
无论是通过 `attach` 命令挂接的进程还是通过 `run` 命令启动的进程，您都可以使用的 GDB 命令来检查和修改挂接的进程。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Attach.html)。
### run
启动被调试的程序。
可以直接指定参数，也可以用 [set args](https://sourceware.org/gdb/current/onlinedocs/gdb/Arguments.html) 设置（启动所需的）参数。
例如： `run arg1 arg2 ...` 等效于
```
set args arg1 arg2 ...
run
```
还允许使用 `>`、 `<` 或 `>>` 进行输入和输出重定向。
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Starting.html)。
### backtrace
打印整体栈帧信息。
* `bt` 打印整体栈帧信息，每个栈帧一行。
* `bt n` 类似于上，但只打印最内层的 n 个栈帧。
* `bt -n` 类似于上，但只打印最外层的 n 个栈帧。
* `bt full n` 类似于 `bt n`，还打印局部变量的值。
`where` 和 `info stack`(缩写 `info s`) 是 `backtrace` 的别名。调用栈信息类似如下：
```
(gdb) where
#0 vconn_stream_run (vconn=0x99e5e38) at lib/vconn-stream.c:232
#1 0x080ed68a in vconn_run (vconn=0x99e5e38) at lib/vconn.c:276
#2 0x080dc6c8 in rconn_run (rc=0x99dbbe0) at lib/rconn.c:513
#3 0x08077b83 in ofconn_run (ofconn=0x99e8070, handle_openflow=0x805e274 <handle_openflow>) at ofproto/connmgr.c:1234
#4 0x08075f92 in connmgr_run (mgr=0x99dc878, handle_openflow=0x805e274 <handle_openflow>) at ofproto/connmgr.c:286
#5 0x08057d58 in ofproto_run (p=0x99d9ba0) at ofproto/ofproto.c:1159
#6 0x0804f96b in bridge_run () at vswitchd/bridge.c:2248
#7 0x08054168 in main (argc=4, argv=0xbf8333e4) at vswitchd/ovs-vswitchd.c:125
```
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Backtrace.html)。
### ptype
打印类型 TYPE 的定义。
用法： `ptype[/FLAGS] TYPE-NAME | EXPRESSION`
参数可以是由 `typedef` 定义的类型名， 或者 `struct STRUCT-TAG` 或者 `class CLASS-NAME` 或者 `union UNION-TAG` 或者 `enum ENUM-TAG`。
根据所选的栈帧的词法上下文来查找该名字。
类似的命令是 `whatis`，区别在于 `whatis` 不展开由 `typedef` 定义的数据类型，而 `ptype` 会展开，举例如下：
```
/* 类型声明与变量定义 */
typedef double real_t;
struct complex {
real_t real;
double imag;
};
typedef struct complex complex_t;
complex_t var;
real_t *real_pointer_var;
```
这两个命令给出了如下输出：
```
(gdb) whatis var
type = complex_t
(gdb) ptype var
type = struct complex {
real_t real;
double imag;
}
(gdb) whatis complex_t
type = struct complex
(gdb) whatis struct complex
type = struct complex
(gdb) ptype struct complex
type = struct complex {
real_t real;
double imag;
}
(gdb) whatis real_pointer_var
type = real_t *
(gdb) ptype real_pointer_var
type = double *
```
详见[官方文档](https://sourceware.org/gdb/current/onlinedocs/gdb/Symbols.html)。
---
### 参考资料
* [Debugging with GDB](https://sourceware.org/gdb/current/onlinedocs/gdb/)
---
译者：[robot527](https://github.com/robot527) 校对：[mudongliang](https://github.com/mudongliang)， [wxy](https://github.com/wxy)
|
||
18 个开源的项目本地化翻译工具
|
Jeff Beatty
|
https://opensource.com/article/17/6/open-source-localization-tools
|
本地化（Localization，L10N）在适应项目方面为世界各地的用户发挥着关键作用。
|
/data/attachment/album/201709/25/234918mrrycuyjzumiycu3.png.thumb.jpg
|
/data/attachment/album/201709/25/234918mrrycuyjzumiycu3.png
| true | false | true |
TimeBear
| true |
[
"翻译",
"本地化"
] |
分享
|
{
"viewnum": 9658,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本地化（Localization，L10N）在适应项目方面为世界各地的用户发挥着关键作用。
| 2017-09-25T07:47:00 | 2017-09-25T07:47:00 | 8,901 |
/article-8901-1.html
|
>
> <ruby> 本地化 <rt> Localization </rt></ruby>（L10N）在适应项目方面为世界各地的用户发挥着关键作用。
>
>
>
本地化在定制开源项目以适应世界各地用户的需求方面发挥着核心作用。 除了代码之外，语言翻译也是世界各地人们贡献和参与开源项目的主要方式之一。
有专门针对语言服务行业特有的工具（听到这件事是不是很惊讶？），这使得高品质的本地化过程可以很顺畅。 本地化工具的类别包括:
* 计算机辅助翻译工具（CAT）
* 机器翻译引擎（MT）
* 翻译管理系统（TMS）
* 术语管理工具
* 本地化自动化工具
这些工具的专有版本可能相当昂贵。一个 SDL Trados Studio （领先的 CAT 工具）的许可证可能要花费数千欧元，即使这样，它只能一个人使用，并且定制功能也是有限的（注意，它们的费用也很高）。开源项目希望本地化到多种语言，简化本地化过程，所以希望找到开源工具来节省资金，并可以通过定制获得所需的灵活性。我对许多开源本地化工具项目进行了深入的调查，以帮助您决定使用什么。
### 计算机辅助翻译工具（CAT）
*OmegaT CAT 工具。在这里您可以发现翻译记忆（模糊匹配）和术语回顾（术语表）特性。OmegaT 在 GPL v3 许可证之下发布。*
CAT 工具是语言服务行业的主要工具。 顾名思义，CAT 工具可以帮助翻译人员尽快完成翻译、双语审查和单语审查的任务，并通过重用翻译内容（也称为翻译记忆），达到尽可能高的一致性。 <ruby> 翻译记忆 <rt> translation memory </rt></ruby>和<ruby> 术语回忆 <rt> terminology recall </rt></ruby>是 CAT 工具的两个主要特性。它们能够使译者在新项目中重用以前项目中翻译的内容。这使得他们可以在较短的时间内翻译大量的文字，同时通过术语和风格的一致性保持较高水平的质量。这对于本地化特别方便，因为许多软件和 web UI 中的文本在平台和应用程序中通常是相同的。 尽管 CAT 工具是独立的软件，但需要翻译人员在本地使用它们并合并到中央存储库。
**可用工具：**
* [OmegaT](http://www.omegat.org/)
* [OmegaT+](http://omegatplus.sourceforge.net/)
* [OpenTM2](http://opentm2.org/)
* [Anaphraseus](http://anaphraseus.sourceforge.net/)
* [字幕翻译器](http://www.mironto.sk/)
### 机器翻译引擎（MT）
机器翻译引擎自动将文本从一种语言翻译到另一种语言。机器翻译引擎被分成三种主要的方法：基于规则、统计式和神经网络式（这是新技术）。最广泛的机器翻译引擎方法是统计式，简而言之，通过使用 [*n*-gram 模型](https://en.wikipedia.org/wiki/N-gram#n-gram_models) 对带注释的双语语料库数据进行统计分析，得出关于两种语言之间的相互关联性。当将新的源语言短语引入到引擎进行翻译时，它会在其分析的语料库数据中查找与目标语言产生统计相关的对等物。机器翻译引擎可以作为翻译人员的生产力辅助工具，将他们的主要任务从将源文本转换为目标文本，改变为对机器翻译引擎的目标语言输出结果的后期编辑。我不建议在本地化工作中使用原始的机器翻译引擎输出结果，但是如果您的社区接受了后期编辑的培训，那么机器翻译引擎可以成为一个有用的工具，帮助他们做出大量的贡献。
**可用工具：**
* [Apertium](http://www.apertium.org/)
* [Moses](http://www.statmt.org/moses/)
### 翻译管理系统（TMS）
*如上是 Mozilla 的 Pontoon 翻译管理系统用户界面。使用所见即所得编辑方式，您可以在上下文根据语境翻译内容，在翻译的同时保证质量。 Pontoon 在 BSD 3 句版许可证（新款或修订版）之下发布。*
翻译管理系统工具是基于 web 的平台，允许您管理本地化项目，并使翻译人员和审阅人员能够做他们最擅长的事情。 大多数翻译管理系统工具旨在通过包括版本控制系统（VCS）集成、云服务集成、项目报告以及标准的翻译记忆和术语回忆功能，实现本地化过程中的许多手工部分的自动化。这些工具最适合于社区本地化或翻译项目，因为它们允许大量的翻译人员和审阅人员为一个项目做出贡献。一些人还使用所见即所得编辑器为他们的翻译者提供翻译语境。这种增加的语境可以提高翻译的准确性，减少译者在用户界面里翻译和审查翻译之间需要等待的时间。
**可用工具：**
* [Pontoon](http://pontoon.mozilla.org/)
* [Pootle](http://pootle.translatehouse.org/)
* [Weblate](https://weblate.org/)
* [Translate5](http://translate5.net/)
* [GlobalSight](http://www.globalsight.com/)
* [Zanata](http://zanata.org/)
* [Jabylon](http://jabylon.org/)
### 术语管理工具
*杨百翰大学 (Brigham Young University) 的 BaseTerm 工具显示了新术语条目的对话窗口。 BaseTerm 在 Eclipse 公共许可证之下发布。*
术语管理工具为您提供 GUI 来创建术语资源（称为术语库）以添加语境并确保翻译的一致性。这些资源在帮助翻译人员的翻译过程中用于 CAT 工具和 TMS 平台。 对于一个术语基于语境可以是名词或动词的语言，术语管理工具允许您添加标记其词性、方言、单语定义以及上下文线索的术语元数据。 术语管理通常是本地化过程中使用不多的部分，但也是同样重要的部分。 在开源软件和专有软件的生态系统中，只有少量的可选产品。
**查看工具**
* [BaseTerm](http://certsoftadmin.byu.edu/baseterm/termbase/search_all)
* [Terminator](https://github.com/translate/terminator)
### 自动本地化工具
*Okapi 框架的 Ratel 和 Rainbow 组件。 图片由 Okapi 框架提供。Okapi 框架在 Apache 许可证 2.0 之下发布。*
自动本地化工具便于您处理本地化数据。这可以包括文本提取、文件格式转换、标记化、VCS 同步、术语提取、预翻译和对通用的本地化标准文件格式的各种质量检查。在一些工具套件中，如 Okapi 框架，您可以创建用于执行各种本地化任务的自动化流程。这对于各种情况都非常有用，但是它们的主要功能是通过自动化许多任务来节省时间。它们还可以让你更接近一个根据连续的本地化流程。
**查看工具**
* [Okapi Framework](http://okapiframework.org/)
* [Mojito](http://www.mojito.global/)
### 为什么开源是关键
本地化在开源时是最强力有效的。 这些工具应该让您和您的社区能够将您的项目本地化为尽可能多的语言。
想了解更多吗? 看看这些附加资源：
* [自由/开源的机器翻译软件](http://fosmt.org/) 列表
* *[开放翻译工具](https://booki.flossmanuals.net/open-translation-tools/index)* 电子书
（题图： opensource.com）
---
作者简介：
Jeff Beatty - Jeff Beatty 是 Mozilla 公司本地化的负责人， Mozilla 是流行的开源 web 浏览器 Firefox 的制造商。 他拥有利默里克大学（University of Limerick）多语言计算和本地化专业硕士学位。 Jeff 还在全球知名刊物中担任本地化专家，如<ruby> 《经济学人》 <rp> （ </rp> <rt> The Economist </rt> <rp> ） </rp></ruby>、<ruby> 《世界报》 <rp> （ </rp> <rt> El Universal </rt> <rp> ） </rp></ruby>、多语种杂志等。 Jeff 旨在展示 Mozilla 的本地化程序，创建颠覆性的开源翻译技术，并充当传播桥梁。
---
via: <https://opensource.com/article/17/6/open-source-localization-tools>
作者：[Jeff Beatty](https://opensource.com/users/guerojeff) 译者：[TimeBear](https://github.com/TimeBear) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Kubernetes 为什么这么重要？
|
Tim Potter
|
https://opensource.com/article/17/6/introducing-kubernetes
|
从头开始构建基础设施和开发流程来开发和维护云原生应用程序是个不简单的、耗时的任务。Kubernetes 是一个相对较新的运行容器化负载的平台，它解决了这些问题。
|
/data/attachment/album/201709/26/104950yxa1sdysqwy70qhg.jpeg.thumb.jpg
|
/data/attachment/album/201709/26/104950yxa1sdysqwy70qhg.jpeg
| true | false | true |
geekpi
| false |
[
"Kubernetes",
"PaaS"
] |
容器与云
|
{
"viewnum": 7605,
"commentnum": 1,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "111.20.112.126",
"message": "如果openstack是一个新的TCP/IP协议栈。那么K8S就是这一协议栈的落地实现之一。分布式集群终于演进到了一个新的时期和阶段。。。这对于企业自身很重要。数据资产你不去保护，就是流失！！！",
"username": "来自陕西西安的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-09-26T19:50:56"
}
] |
[] |
从头开始构建基础设施和开发流程来开发和维护云原生应用程序是个不简单的、耗时的任务。Kubernetes 是一个相对较新的运行容器化负载的平台，它解决了这些问题。
| 2017-09-26T10:50:43 | 2017-09-26T10:50:43 | 8,902 |
/article-8902-1.html
|
>
> 在开发和部署云原生应用程序时，运行容器化负载的 Kubernetes 平台起到了重大作用。
>
>
>
自然而然的，开发和部署云原生应用程序已经变得非常受欢迎。对于一个允许快速部署和连续交付的 bug 修复和新功能的流程来说，它有明显的优势，但是没有人会谈到鸡和鸡蛋问题：怎样才能达成这样的目的呢？从头开始构建基础设施和开发流程来开发和维护云原生应用程序是个不简单的、耗时的任务。
[Kubernetes](https://kubernetes.io/) 是一个相对较新的运行容器化负载的平台，它解决了这些问题。它原本是 Google 内部的一个项目，Kubernetes 在 2015 年被捐赠给了[云原生计算基金会](https://www.cncf.io/)，并吸引了来自世界各地开源社区的开发人员。 Kubernetes 的设计基于 Google 15 年的在生产和开发环境运维的经验。由于它是开源的，任何人都可以下载并使用它，并实现其带来的优势。
那么为什么 Kubernetes 会有这么大的惊喜呢？我认为它在像 OpenStack 这样的基础架构即服务（IaaS）和完整的平台即服务 （PaaS）的资源之间达到了最佳平衡，它的底层运行时实现完全由供应商控制。Kubernetes 提供了两个优势：对管理基础设施的抽象，以及深入裸机进行故障排除的工具和功能。
### IaaS 与 PaaS
OpenStack 被大多数人归类为 IaaS 解决方案，其中物理资源池（如处理器、网络和存储）在不同用户之间分配和共享。它使用传统的基于硬件的虚拟化实现用户之间的隔离。
OpenStack 的 REST API 允许使用代码自动创建基础架构，但是这就是问题所在。IaaS 产品输出的也是基础设施。其创建后，支持和管理那些更多的基础设施的服务方式并不多。在一定程度上，OpenStack 生产的底层基础架构（如服务器和 IP 地址）成为管理工作的重中之重。一个众所周知的结果是虚拟机（VM）的无序蔓延，而同样的情况也出现于网络、加密密钥和存储卷方面。这样，开发人员建立和维护应用程序的时间就更少了。
像其它基于集群的解决方案一样，Kubernetes 以单个服务器级别的方式运行，以实现水平缩放。它可以轻松添加新的服务器，并立即在新硬件上安排负载。类似地，当服务器没有被有效利用或需要维护时，可以从集群中删除服务器。其它 Kubernetes 可以自动处理的其他任务是编排活动，如工作调度、健康监测和维护高可用性。
网络是另一个可能难以在 IaaS 环境中可靠编排的领域。微服务之间通过 IP 地址通信可能是很棘手的。Kubernetes 实现了 IP 地址管理、负载均衡、服务发现和 DNS 名称注册，以在集群内提供无痛、透明的网络环境。
### 专为部署而设计
一旦创建了运行应用程序的环境，部署就是一件小事了。可靠地部署一个应用程序是说起来容易做起来难的任务 —— 它并不是最简单的。Kubernetes 相对其他环境的巨大优势是，部署是一等公民。
使用一个单独的 Kubernetes 命令行界面（CLI）的命令，可以描述应用程序并将其安装在群集上。Kubernetes 从初始部署、推出新版本以及（当一个关键功能出现问题时）进行回滚，实现了应用程序的整个生命周期。运行中的部署也可以暂停和恢复。拥有现成的、内置的工具和支持应用程序部署，而不用自己构建部署系统，这是不容小觑的优点。Kubernetes 用户既不必重新发明应用程序部署的轮子，也不会发现这是一项艰巨的任务。
Kubernetes 还可以监控运行中的部署的状态。虽然你可以在 IaaS 环境中像编写部署过程一样编写这个功能，但这是一个非常困难的任务，而这样的情况还比比皆是。
### 专为 DevOps 而设计
随着你在开发和部署 Kubernetes 应用程序方面获得更多经验，你将沿着与 Google 和其他前行者相同的路径前行。你将发现有几种 Kubernetes 功能对于多服务应用程序的有效开发和故障排除是非常重要的。
首先，Kubernetes 能够通过日志或 SSH（安全 shell）轻松检查正在运行的服务的能力非常重要。通过一条命令行调用，管理员可以检查在 Kubernetes 下运行的服务的日志。这可能听起来像一个简单的任务，但在 IaaS 环境中，除非你已经做了一些工作，否则这并不容易。大型应用程序通常具有专门用于日志收集和分析的硬件和人员。在Kubernetes 中的日志可能不能替代完整功能的日志和指标解决方案，但它足以提供基本的故障排除。
第二，Kubernetes 提供内置的密钥管理。从头开发过自己的部署系统的团队知道的另一个问题是，将敏感数据（如密码和 API 令牌）安全地部署到虚拟机上很困难。通过将密钥管理变成一等公民，Kubernetes 可以避免你的团队发明自己的不安全的、错误的密钥分发系统或在部署脚本中硬编码凭据。
最后，Kubernetes 有一些用于自动进行缩放、负载均衡和重新启动应用程序的功能。同样，这些功能是开发人员在使用 IaaS 或裸机时要自己编写的。你的 Kubernetes 应用程序的缩放和运行状况检查在服务定义中进行声明，而 Kubernetes 会确保正确数量的实例健康运行。
### 总结
IaaS 和 PaaS 系统之间的差异是巨大的，包括 PaaS 可以节省大量的开发和调试时间。作为一种 PaaS，Kubernetes 实现了强大而有效的功能，可帮助你开发、部署和调试云原生应用程序。它的架构和设计代表了数十年的难得的经验，而你的团队能够免费获得该优势。
（题图：squarespace.com）
---
作者简介：
Tim Potter - Tim 是 Hewlett Packard Enterprise 的高级软件工程师。近二十年来，他一直致力于自由和开源软件的开发工作，其中包括 Samba、Wireshark、OpenPegasus 和 Docker 等多个项目。Tim 博客在 <https://elegantinfrastructure.com/> ，关于 Docker、Kubernetes 和其他基础设施相关主题。
---
via: <https://opensource.com/article/17/6/introducing-kubernetes>
作者：[Tim Potter](https://opensource.com/users/tpot) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
机器学习实践指南
|
Karlijn Willems
|
https://medium.freecodecamp.org/how-machines-learn-a-practical-guide-203aae23cafb
|
在今天的文档中，我会列出 7 个步骤（和 50 多个资源）帮助你开启这个令人兴奋的计算机科学领域的大门，并逐渐成为一个机器学习高手。
|
/data/attachment/album/201709/28/063459ft521u5xl7u2nfg5.png.thumb.jpg
|
/data/attachment/album/201709/28/063459ft521u5xl7u2nfg5.png
| true | false | true |
Flowsnow
| true |
[
"机器学习",
"Python",
"深度学习",
"人工智能"
] |
软件开发
|
{
"viewnum": 9789,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在今天的文档中，我会列出 7 个步骤（和 50 多个资源）帮助你开启这个令人兴奋的计算机科学领域的大门，并逐渐成为一个机器学习高手。
| 2017-09-28T06:34:58 | 2017-09-28T06:34:58 | 8,907 |
/article-8907-1.html
|
你可能在各种应用中听说过<ruby> 机器学习 <rt> machine learning </rt></ruby>（ML），比如垃圾邮件过滤、光学字符识别（OCR）和计算机视觉。
开启机器学习之旅是一个涉及多方面的漫长旅途。对于新手，有很多的书籍，有学术论文，有指导练习，有独立项目。在这些众多的选择里面，很容易迷失你最初想学习的目标。
所以在今天的文章中，我会列出 7 个步骤（和 50 多个资源）帮助你开启这个令人兴奋的计算机科学领域的大门，并逐渐成为一个机器学习高手。
请注意，这个资源列表并不详尽，只是为了让你入门。 除此之外，还有更多的资源。
### 1、 学习必要的背景知识
你可能还记得 DataCamp 网站上的[学习数据科学](https://www.datacamp.com/community/tutorials/learn-data-science-infographic)这篇文章里面的信息图：数学和统计学是开始机器学习（ML）的关键。 基础可能看起来很容易，因为它只有三个主题。 但不要忘记这些实际上是三个广泛的话题。
在这里需要记住两件非常重要的事情：
* 首先，你一定会需要一些进一步的指导，以了解开始机器学习需要覆盖哪些知识点。
* 其次，这些是你进一步学习的基础。 不要害怕花时间，有了这些知识你才能构建一切。
第一点很简单：学习线性代数和统计学是个好主意。这两门知识是必须要理解的。但是在你学习的同时，也应该尝试学习诸如最优化和高等微积分等主题。当你越来越深入 ML 的时候，它们就能派上用场。
如果是从零开始的，这里有一些入门指南可供参考：
* [Khan 学院](http://www.khanacademy.org/) 对于初学者是非常好的资源，可以考虑学习他们的线性代数和微积分课程。
* 在 [麻省理工学院 OpenCourseWare](https://ocw.mit.edu/index.htm) 网站上学习[线性代数](https://ocw.mit.edu/courses/mathematics/18-06-linear-algebra-spring-2010/) 课程。
* [Coursera course](https://www.coursera.org/learn/basic-statistics) 网站上对描述统计学、概率论和推论统计学的介绍内容。
*统计学是学习 ML 的关键之一*
如果你更多喜欢阅读书籍，请参考以下内容：
* <ruby> <a href="https://www.amazon.com/Linear-Algebra-Its-Applications-4th/dp/0030105676"> 线性代数及其应用 </a> <rt> Linear Algebra and Its Applications </rt></ruby>
* <ruby> <a href="https://www.amazon.com/Applied-Linear-Algebra-3rd-Noble/dp/0130412600"> 应用线性代数 </a> <rt> Applied Linear Algebra </rt></ruby>
* <ruby> <a href="https://www.amazon.de/Solved-Problems-Linear-Algebra-Schaums/dp/0070380236"> 线性代数解决的 3000 个问题 </a> <rt> 3,000 Solved Problems in Linear Algebra </rt></ruby>
* [麻省理工学院在线教材](https://ocw.mit.edu/courses/online-textbooks/)
然而，在大多数情况下，你已经对统计学和数学有了一个初步的了解。很有可能你已经浏览过上面列举的的那些资源。
在这种情况下，诚实地回顾和评价你的知识是一个好主意，是否有一些领域是需要复习的，或者现在掌握的比较好的？
如果你一切都准备好了，那么现在是时候使用 R 或者 Python 应用这些知识了。作为一个通用的指导方针，选择一门语言开始是个好主意。另外，你仍然可以将另一门语言加入到你的技能池里。
为什么这些编程知识是必需的？
嗯，你会看到上面列出的课程（或你在学校或大学学习的课程）将为你提供关于数学和统计学主题的更理论性的介绍（而不是应用性的）。 然而，ML 非常便于应用，你需要能够应用你所学到的所有主题。 所以最好再次复习一遍之前的材料，但是这次需要付诸应用。
如果你想掌握 R 和 Python 的基础，可以看以下课程：
* DataCamp 上关于 Python 或者 R 的介绍性课程： [Python 语言数据科学介绍](https://www.datacamp.com/courses/intro-to-python-for-data-science) 或者 [R 语言编程介绍](https://www.datacamp.com/courses/free-introduction-to-r)。
* Edx 上关于 Python 或者 R 的介绍性课程： [Python 语言数据科学介绍](https://www.edx.org/course/introduction-python-data-science-microsoft-dat208x-5) 和 [R 语言数据科学介绍](https://www.edx.org/course/introduction-r-data-science-microsoft-dat204x-4)。
* 还有很多其他免费的课程。查看 [Coursera](http://www.coursera.org/) 或者 [Codeacademy](https://www.codecademy.com/) 了解更多。
当你打牢基础知识后，请查看 DataCamp 上的博客 [Python 统计学：40+ 数据科学资源](https://www.datacamp.com/community/tutorials/python-statistics-data-science)。 这篇文章提供了统计学方面的 40 多个资源，这些资源都是你开始数据科学（以及 ML）需要学习的。
还要确保你查看了关于向量和数组的 [这篇 SciPy 教程](https://www.datacamp.com/community/tutorials/python-scipy-tutorial)文章，以及使用 Python 进行科学计算的[研讨会](http://www.math.pitt.edu/%7Esiam/workshops/python10/python.pdf)。
要使用 Python 和微积分进行实践，你可以了解下 [SymPy 软件包](http://docs.sympy.org/latest/tutorial/calculus.html)。
### 2、 不要害怕在 ML 的“理论”上浪费时间
很多人并不会花很多精力去浏览理论材料，因为理论是枯燥的、无聊的。但从长远来看，在理论知识上投入时间是至关重要的、非常值得的。 你将会更好地了解机器学习的新进展，也能和背景知识结合起来。 这将有助于你保持学习积极性。
此外，理论并不会多无聊。 正如你在介绍中所看到的，你可以借助非常多的资料深入学习。
书籍是吸收理论知识的最佳途径之一。 它们可以让你停下来想一会儿。 当然，看书是一件非常平静的事情，可能不符合你的学习风格。 不过，请尝试阅读下列书籍，看看它是否适合你：
* <ruby> <a href="http://www.cs.cmu.edu/%7Etom/mlbook.html"> 机器学习教程 </a> <rt> Machine Learning textbook </rt></ruby>， Tom Mitchell 著，书可能比较旧，但是却很经典。这本书很好的解释介绍了机器学习中最重要的课题，步骤详尽，逐层深入。
* <ruby> 机器学习: 使数据有意义的算法艺术和科学 <rt> Machine Learning: The Art and Science of Algorithms that Make Sense of Data </rt></ruby>（你可以在[这里](http://www.cs.bris.ac.uk/%7Eflach/mlbook/materials/mlbook-beamer.pdf)看到这本书的幻灯片版本）：这本书对初学者来说非常棒。 里面讨论了许多实践中的应用程序，其中有一些是在 Tom Mitchell 的书中缺少的。
* <ruby> <a href="http://www.mlyearning.org/"> 机器学习之向往 </a> <rt> Machine Learning Yearning </rt></ruby> ：这本书由<ruby> 吴恩达 <rt> Andrew Ng </rt></ruby>编写的，仍未完本，但对于那些正在学习 ML 的学生来说，这一定是很好的参考资料。
* <ruby> <a href="https://www.amazon.com/Algorithms-Data-Structures-Applications-Practitioner/dp/0134894286"> 算法与数据结构 </a> <rt> Algorithms and Data Structures </rt></ruby> 由 Jurg Nievergelt 和 Klaus Hinrichs 著。
* 也可以参阅 Matthew North 的<ruby> <a href="https://www.amazon.com/Data-Mining-Masses-Matthew-North/dp/0615684378"> 面向大众的数据挖掘 </a> <rt> Data Mining for the Masses </rt></ruby>。 你会发现这本书引导你完成一些最困难的主题。
* <ruby> <a href="http://alex.smola.org/drafts/thebook.pdf"> 机器学习介绍 </a> <rt> Introduction to Machine Learning </rt></ruby> 由 Alex Smola 和 S.V.N. Vishwanathan 著。
*花些时间看书并研究其中涵盖的资料*
视频和慕课对于喜欢边听边看来学习的人来说非常棒。 慕课和视频非常的多，多到可能你都很难找到适合你的。 下面列出了最知名的几个：
* [这个著名的机器学习慕课](https://www.coursera.org/learn/machine-learning)，是<ruby> 吴恩达 <rt> Andrew Ng </rt></ruby>讲的，介绍了机器学习及其理论。 别担心，这个慕课讲的非常好，一步一步深入，所以对初学者来说非常适用。
* [麻省理工学院 Open Courseware 的 6034 课程的节目清单](https://youtu.be/TjZBTDzGeGg?list=PLnvKubj2-I2LhIibS8TOGC42xsD3-liux)，已经有点前沿了。 在你开始本系列之前，你需要做一些 ML 理论方面的准备工作，但是你不会后悔的。
在这一点上，重要的是要将各种独立的技术融会贯通，形成整体的结构图。 首先了解关键的概念：<ruby> 监督学习 <rt> supervised learning </rt></ruby>和<ruby> 无监督学习 <rt> unsupervised learning </rt></ruby>的区别、分类和回归等。 手动（书面）练习可以派上用场，能帮你了解算法是如何工作的以及如何应用这些算法。 在大学课程里你经常会找到一些书面练习，可以看看波特兰州立大学的 [ML 课程](http://web.cecs.pdx.edu/%7Emm/MachineLearningSpring2017/)。
### 3、 开始动手
通过看书和看视频了解理论和算法都非常好，但是需要超越这一阶段，就要开始做一些练习。你要学着去实现这些算法，应用学到的理论。
首先，有很多介绍 Python 和 R 方面的机器学习的基础知识。当然最好的方法就是使用交互式教程：
* [Python 机器学习：Scikit-Learn 教程](https://www.datacamp.com/community/tutorials/machine-learning-python)，在这篇教程里面，你可以学到使用 Scikit-Learn 构建模型的 KMeans 和支持向量机（SVM）相关的知名算法。
* [给初学者的 R 语言机器学习教程](https://www.datacamp.com/community/tutorials/machine-learning-in-r) 用 R 中的类和 caret 包介绍机器学习。
* [Keras 教程：Python 深度学习[25](https://www.datacamp.com/community/tutorials/deep-learning-python) 涵盖了如何一步一步的为分类和回归任务构建多层感知器（MLP）。
还请查看以下静态的（非互动的）教程，这些需要你在 IDE 中操作：
* [循序渐进：Python 机器学习](http://machinelearningmastery.com/machine-learning-in-python-step-by-step/)： 一步一步地学习 Scikit-Learn。
* [循序渐进：使用 Keras 开发你的第一个神经网络](http://machinelearningmastery.com/tutorial-first-neural-network-python-keras/)： 按这个教程一步一步地使用 Keras 开发你的第一个神经网络。
* 你可以考虑看更多的教程，但是[机器学习精要](http://www.machinelearningmastery.com/)这篇教程是非常好的。
除了教程之外，还有一些课程。参加课程可以帮助你系统性地应用学到的概念。 经验丰富的导师很有帮助。 以下是 Python 和机器学习的一些互动课程：
* [用 scikit-learn 做监督学习](https://www.datacamp.com/courses/supervised-learning-with-scikit-learn)： 学习如何构建预测模型，调整参数，并预测在未知数据上执行的效果。你将使用 Scikit-Learn 操作真实世界的数据集。
* [用 Python 做无监督学习](https://www.datacamp.com/courses/unsupervised-learning-in-python)： 展示给你如何从未标记的数据集进行聚类、转换、可视化和提取关键信息。 在课程结束时，还会构建一个推荐系统。
* [Python 深度学习](https://www.datacamp.com/courses/deep-learning-in-python)： 你将获得如何使用 Keras 2.0 进行深度学习的实践知识，Keras 2.0 是前沿的 Python 深度学习库 Keras 的最新版本。
* [在 Python 中应用机器学习](https://www.coursera.org/learn/python-machine-learning)： 将学习者引入到机器学习实践中，更多地关注技术和方法，而不是这些方法背后的统计学知识。
*理论学习之后，花点时间来应用你所学到的知识。*
对于那些正在学习 R 语言机器学习的人，还有这些互动课程：
* [机器学习介绍](https://www.datacamp.com/courses/introduction-to-machine-learning-with-r) 可以让你宏观了解机器学习学科最常见的技术和应用，还可以更多地了解不同机器学习模型的评估和训练。这门课程剩下的部分重点介绍三个最基本的机器学习任务： 分类、回归和聚类。
* [R 语言无监督学习](https://www.datacamp.com/courses/unsupervised-learning-in-r) ，用 R 语言从 ML 角度提供聚类和降维的基本介绍。 可以让你尽快获得数据的关键信息。
* [实操机器学习](https://www.coursera.org/learn/practical-machine-learning)涵盖了构建和应用预测功能的基本组成部分，其重点是实际应用。
最后，还有很多书籍以偏向实践的方式介绍了 ML 主题。 如果你想借助书籍内容和 IDE 来学习，请查看这些书籍：
* <ruby> <a href="https://github.com/rasbt/python-machine-learning-book"> Python 机器学习 </a> <rt> Python Machine Learning Book </rt></ruby>，Sebastian Raschka 著。
* <ruby> <a href="https://github.com/rasbt/deep-learning-book"> 人工神经网络与深度学习导论：Python 应用实用指南 </a> <rt> Introduction to Artificial Neural Networks and Deep Learning: A Practical Guide with Applications in Python </rt></ruby>，Sebastian Raschka 著。
* <ruby> <a href="https://books.google.be/books/about/Machine_Learning_with_R.html?id=ZQu8AQAAQBAJ&amp;amp;amp;amp;amp;amp;source=kp_cover&amp;amp;amp;amp;amp;amp;redir_esc=y"> R 语言机器学习 </a> <rt> Machine Learning with R </rt></ruby>，Brett Lantz 著。
### 4、 练习
实践比使用 Python 进行练习和修改材料更重要。 这一步对我来说可能是最难的。 在做了一些练习后看看其他人是如何实现 ML 算法的。 然后，开始你自己的项目，阐述你对 ML 算法和理论的理解。
最直接的方法之一就是将练习的规模做得更大些。 要做一个更大的练习，就需要你做更多的数据清理和功能工程。
* 从 [Kaggle](http://www.kaggle.com/) 开始。 如果你需要额外的帮助来征服所谓的“数据恐惧”，请查看 [Kaggle 的 Python 机器学习教程](https://www.datacamp.com/community/open-courses/kaggle-python-tutorial-on-machine-learning) 和 [Kaggle 的 R 语言机器学习教程](https://www.datacamp.com/community/open-courses/kaggle-tutorial-on-machine-learing-the-sinking-of-the-titanic)。 这些将带给您快速的提升。
* 此后，你也可以自己开始挑战。 查看这些网站，您可以在其中找到大量的 ML 数据集：[UCI 机器学习仓库](http://archive.ics.uci.edu/ml/)，[用于机器学习的公开数据集](http://homepages.inf.ed.ac.uk/rbf/IAPR/researchers/MLPAGES/mldat.htm) 和 [data.world](https://data.world/)。
*熟能生巧。*
### 5、 项目
虽然做一些小的练习也不错，但是在最后，您需要做一个项目，可以在其中展示您对使用到的 ML 算法的理解。
最好的练习是实现你自己的 ML 算法。 您可以在以下页面中阅读更多关于为什么您应该做这样的练习，以及您可以从中学到什么内容：
* [为什么有许多先进的 API，比如 tensorflow，还需要自己手动实现机器学习的算法？](https://www.quora.com/Why-is-there-a-need-to-manually-implement-machine-learning-algorithms-when-there-are-many-advanced-APIs-like-tensorflow-available)
* [为什么要从头开始实现机器学习算法？](http://www.kdnuggets.com/2016/05/implement-machine-learning-algorithms-scratch.html)
* [使用 Python 从头开始实现一个分类器，我能从中学到什么？](http://www.jeannicholashould.com/what-i-learned-implementing-a-classifier-from-scratch.html)
接下来，您可以查看以下文章和仓库。 可以从中获得一些灵感，并且了解他们是如何实现 ML 算法的。
* [如何实现机器学习算法](http://machinelearningmastery.com/how-to-implement-a-machine-learning-algorithm/)
* [从头开始学习机器学习](https://github.com/eriklindernoren/ML-From-Scratch)
* [从头开始学习机器学习算法](https://github.com/madhug-nadig/Machine-Learning-Algorithms-from-Scratch)
*开始时项目可能会很难，但是可以极大增加你的理解。*
### 6、 不要停止
对 ML 的学习永远不能停止，即使你在这个领域工作了十年，总是有新的东西要学习，许多人都将会证实这一点。
例如，ML 趋势，比如<ruby> 深度学习 <rt> deep learning </rt></ruby>现在就很受欢迎。你也可以专注于那些现在不怎么火，但是将来会火的话题上。如果你想了解更多，可以看看[这个有趣的问题和答案](https://www.quora.com/Should-I-quit-machine-learning)。
当你苦恼于掌握基础知识时，你最先想到的可能不是论文。 但是它们是你紧跟最新研究的一个途径。 论文并不适合刚刚开始学习的人，但是绝对适合高级人员。
* [20 篇最新的机器学习和深度学习领域的顶级研究论文](http://www.kdnuggets.com/2017/04/top-20-papers-machine-learning.html)
* [机器学习研究杂志](http://www.jmlr.org/)
* [优秀的深度学习论文](https://github.com/terryum/awesome-deep-learning-papers)
* [机器学习的一些最好的研究论文和书籍](https://www.quora.com/What-are-some-of-the-best-research-papers-books-for-Machine-learning)
其他技术也是需要考虑的。 但是当你刚开始学习时，不要担心这些。 例如，您可以专注于 Python 或 R 语言 （取决于你已经知道哪一个），并把它到你的技能池里。 你可以通过这篇文章来查找一些感兴趣的资源。
如果您还想转向大数据，您可以考虑研究 Spark。 这里有一些有趣的资源：
* [在 R 语言中使用 sparklyr 来了解 Spark](https://www.datacamp.com/courses/introduction-to-spark-in-r-using-sparklyr)
* [Spark 数据科学与工程](https://www.edx.org/xseries/data-science-engineering-apache-spark)
* [介绍 Apache Spark](https://www.edx.org/course/introduction-apache-spark-uc-berkeleyx-cs105x)
* [Apache Spark 分布式机器学习](https://www.edx.org/course/distributed-machine-learning-apache-uc-berkeleyx-cs120x)
* [用 Apache Spark 进行大数据分析](https://www.edx.org/course/big-data-analysis-apache-spark-uc-berkeleyx-cs110x)
* [初学者指南：用 Python 操作 Apache Spark](https://www.datacamp.com/community/tutorials/apache-spark-python)
* [PySpark RDD 速查表](https://www.datacamp.com/community/blog/pyspark-cheat-sheet-python)
* [PySpark SQL 速查表](https://www.datacamp.com/community/blog/pyspark-sql-cheat-sheet)
其他编程语言，比如 Java、JavaScript、C 和 C++ 在 ML 中越来越重要。 从长远来看，您可以考虑将其中一种语言添加到学习列表中。 你可以使用这些博客文章来指导你选择：
* [机器学习和数据科学最流行的编程语言](https://fossbytes.com/popular-top-programming-languages-machine-learning-data-science/)
* [机器学习和数据科学最流行的语言是...](http://www.kdnuggets.com/2017/01/most-popular-language-machine-learning-data-science.html)
*学无止境。*
### 7、 利用一切可以利用的资源
机器学习是一个充满难度的话题，有时候可能会让你失去动力。 或者也许你觉得你需要点改变。 在这种情况下，请记住，有很多资源可以让你打消掉这种想法。 查看以下资源：
**播客**是可以让你继续你的 ML 旅程，紧跟这个领域最新的发展的伟大资源：
* [谈论机器](http://www.thetalkingmachines.com/)
* [数据怀疑论者](https://dataskeptic.com/)
* [线性化](http://lineardigressions.com/)
* [本周的机器学习及 AI](https://twimlai.com/)
* [机器学习 101](http://www.learningmachines101.com/)
当然，还有更多的播客。
**文档和软件包源代码**是深入了解 ML 算法的实现的两种方法。 查看这些仓库：
* [Scikit-Learn](https://github.com/scikit-learn/scikit-learn)：知名的 Python ML 软件包
* [Keras](http://www.github.com/fchollet/keras)： Python 深度学习软件包
* [caret](http://topepo/caret)： 非常受欢迎的用于分类和回归训练 R 软件包
**可视化**是深入 ML 理论的最新也是最流行的方式之一。 它们对初学者来说非常棒，但对于更高级的学习者来说也是非常有趣的。 你肯定会被下面这些可视化资源所吸引，它们能让你更加了解 ML 的工作原理：
* [机器学习的可视化介绍](http://www.r2d3.us/visual-intro-to-machine-learning-part-1/)
* [Distill](http://distill.pub/) 使 ML 研究清晰，动态和生动。
* 如果你想玩下神经网络架构，可以看下 [Tensorflow - 神经网络游乐场](http://playground.tensorflow.org/)。
* 更多的看这里：[机器学习算法最佳的可视化方法是什么？](https://www.quora.com/What-are-the-best-visualizations-of-machine-learning-algorithms)
*学习中的一些变化更加能激励你。*
### 现在你可以开始了
现在一切都取决于你自己了。学习机器学习是一个持续的过程，所以开始的越早就会越好。 运用你手边的一切工具开始吧。 祝你好运，并确保让我们知道你的进步。
*这篇文章是我基于 Quora 问题（[小白该如何开始机器学习](https://www.quora.com/How-does-a-total-beginner-start-to-learn-machine-learning/answer/Karlijn-Willems-1)）给出的答案。*
---
作者简介：
Karlijn Willems，数据科学记者
---
via: <https://medium.freecodecamp.org/how-machines-learn-a-practical-guide-203aae23cafb>
作者：[Karlijn Willems](https://medium.freecodecamp.org/@kacawi) 译者：[Flowsnow](https://github.com/Flowsnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
微软成为开源计划（OSI）白金赞助者
|
Marius Nestor
|
http://news.softpedia.com/news/it-s-official-microsoft-becomes-premium-sponsor-of-the-open-source-initiative-517832.shtml
|
OSI 总经理兼董事 Patrick Masson 说，“广义地说，这是 OSI 和开源软件运动的一个重要里程碑。我觉得没有比这个更能证明开源软件的成熟、生存能力、关注和成功，它不仅得到了微软的认可，而且是作为赞助商支持，以及他们作为贡献者参与这么多开放源项目和社区。”
|
/data/attachment/album/201709/28/070255mggbc8ku2bt05ggm.png.thumb.jpg
|
/data/attachment/album/201709/28/070255mggbc8ku2bt05ggm.png
| true | false | true |
wxy
| false |
[
"微软",
"OSI"
] |
新闻
|
{
"viewnum": 3330,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "111.20.112.126",
"message": "不会又像当年搞DOS那样，用户喜欢了开始搞收费吧",
"username": "来自陕西西安的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-09-28T08:21:10"
}
] |
[] |
OSI 总经理兼董事 Patrick Masson 说，“广义地说，这是 OSI 和开源软件运动的一个重要里程碑。我觉得没有比这个更能证明开源软件的成熟、生存能力、关注和成功，它不仅得到了微软的认可，而且是作为赞助商支持，以及他们作为贡献者参与这么多开放源项目和社区。”
| 2017-09-28T07:03:00 | 2017-09-28T07:03:00 | 8,908 |
/article-8908-1.html
|
旨在推行和保护开源软件的<ruby> 开源计划 <rp> （ </rp> <rt> Open Source Initiative </rt> <rp> ） </rp></ruby>（OSI）26 日[宣布](https://opensource.org/node/901)，微软最近成为了其白金赞助者。
OSI 的主要目标是通过培训和合作，以及通过基础设施来促进开源技术和开源软件项目发展。没有像 OSI 这样的开源组织，整个开源运动将没有机会成功地成为软件行业的一等公民，而现在专有软件仍占用有利地位。而现在，微软的加入将进一步促进开源软件的发展。
OSI 总经理兼董事 Patrick Masson 说，“广义地说，这是 OSI 和开源软件运动的一个重要里程碑。我觉得没有比这个更能证明开源软件的成熟、生存能力、关注和成功，它不仅得到了微软的认可，而且是作为赞助商支持，以及他们作为贡献者参与这么多开放源项目和社区。”
### 微软是开源软件项目的领先贡献者
据 OSI，微软是一个领先的贡献者。它对开源社区的贡献是众所周知的，包括与 Canonical 合作定制 Azure 的 ubuntu 内核， 以及 Windows 上的 Linux 子系统（WSL）。
微软也与 Red Hat 和 SUSE 以及 Linux 基金会在各种项目上展开了合作，并与 OSI 成员 FreeBSD 基金会合作，在该公司的 Azure 云平台上支持其 FreeBSD 操作系统。通过加入 OSI，微软会更多地在其产品中集成开源软件。
|
||
现在可以将 Atom 编辑器变成 IDE 啦！
|
Marius Nestor
|
http://news.softpedia.com/news/you-can-now-transform-the-atom-hackable-text-editor-into-an-ide-with-atom-ide-517804.shtml
|
上周 Atom 1.21 Beta 发布之后，GitHub 引入了语言服务器协议支持以集成其全新打造的 Atom-IDE 项目，它内置带有 5 个流行的语言服务器，包括 JavaScript、TypeScript、 PHP、Java、 C# 和 Flow，而更多的语言服务器正在赶来……
|
/data/attachment/album/201709/28/084142gd4qzw67kcwqe4c6.jpg.thumb.jpg
|
/data/attachment/album/201709/28/084142gd4qzw67kcwqe4c6.jpg
| true | false | true |
wxy
| false |
[
"Atom"
] |
桌面应用
|
{
"viewnum": 9716,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "180.173.136.232",
"message": "还是蛮喜欢这个编辑器的,但是安装插件很卡很慢,这一点vscode做的很好.",
"username": "粱小无拆 [QQ Browser 9.6|Windows 10]",
"date": "2017-09-28T13:40:30"
}
] |
[] |
上周 Atom 1.21 Beta 发布之后，GitHub 引入了语言服务器协议支持以集成其全新打造的 Atom-IDE 项目，它内置带有 5 个流行的语言服务器，包括 JavaScript、TypeScript、 PHP、Java、 C# 和 Flow，而更多的语言服务器正在赶来……
| 2017-09-28T08:41:00 | 2017-09-28T08:41:00 | 8,909 |
/article-8909-1.html
|
GitHub 和 Facebook 最近发起了一套工具集，它可以让你将你的可魔改 Atom 文本编辑器变身成为 IDE（集成开发环境），他们将这个项目叫做 Atom-IDE。
上周 [Atom 1.21 Beta 发布](http://blog.atom.io/2017/09/12/atom-1-20.html)之后，GitHub 引入了<ruby> 语言服务器协议 <rp> （ </rp> <rt> Language Server Protocol </rt> <rp> ） </rp></ruby>支持以集成其全新打造的 Atom-IDE 项目，它内置带有 5 个流行的语言服务器，包括 JavaScript、TypeScript、 PHP、Java、 C# 和 Flow，而更多的语言服务器正在赶来……
GitHub 的 Damien Guard [解释](http://blog.atom.io/2017/09/12/announcing-atom-ide.html)说：“该 IDE 的每个软件包都提供了基于底层的语言服务器的功能选择，并在打开它所支持的文件时激活。你至少需要安装两个包：Atom IDE 的用户界面和支持该语言的软件包。”
### 将 Atom 变成 Atom-IDE
如果你想要体验下 Atom 的 IDE 功能，在 Atom-IDE 项目的帮助下这很容易。你只需要在 Atom 的设置窗口中打开安装软件包对话框，并在其中搜索和安装 atom-ide-ui 软件包即可。
这将在你的 Atom 中呈现 IDE 界面，但是要成为一个完全可工作的 IDE ，你还需要安装你的语言服务器支持。目前，你可以从以下五种语言中选择：ide-typescript （TypeScript & JavaScript）、 ide-php （PHP）、 ide-java （Java）、 ide-csharp （C#）以及 ide-flowtype （Flow）。
当然，这些功能需要你安装使用 Atom 1.21 Beta 才能使用，它目前还是 Beta 版本，下个月才会发布正式版本。
|
||
React 16 发布，Facebook 如约解除了专利条款
|
Wxy
|
26 日，Facebook 发布了 React 16，并如之前承诺的，将 React 16 JavaScript 库以及 GraphQL 查询语言的许可证从原来的 BSD + 专利条款改为更受欢迎的 MIT 许可证。
|
/data/attachment/album/201709/28/104143xaah3a8h58zaaa58.jpg.thumb.jpg
|
/data/attachment/album/201709/28/104143xaah3a8h58zaaa58.jpg
| true | false | false | false |
[
"React",
"Facebook",
"专利"
] |
新闻
|
{
"viewnum": 4373,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "117.151.52.208",
"message": "而 React 16 中的服务器端渲染也要比之前的版本快得多，测试表明，其比 Node 4 快 2.4 倍，比 Node 6 快 3 倍，比 Node 8.4 快 3.8 倍。<br />\r\n<br />\r\n什么叫"比node快x倍"?<br />\r\n<br />\r\n应该是"比老版的React快x倍"吧",
"username": "来自湖北的 Chrome 61.0|Windows 10 用户",
"date": "2017-09-28T12:46:25"
}
] |
[
{
"raid": 8733,
"displayorder": 0
},
{
"raid": 8876,
"displayorder": 1
},
{
"raid": 8880,
"displayorder": 2
},
{
"raid": 8895,
"displayorder": 3
}
] |
26 日，Facebook 发布了 React 16，并如之前承诺的，将 React 16 JavaScript 库以及 GraphQL 查询语言的许可证从原来的 BSD + 专利条款改为更受欢迎的 MIT 许可证。
| 2017-09-28T10:41:48 | 2017-09-28T10:41:48 | 8,910 |
/article-8910-1.html
|
26 日，Facebook [发布](https://facebook.github.io/react/blog/2017/09/26/react-v16.0.html)了 [React 16](https://github.com/facebook/react)，并如[之前承诺](/article-8895-1.html)的，将 React 16 JavaScript 库以及 GraphQL 查询语言的许可证从原来的 BSD + 专利条款[改为更受欢迎的 MIT 许可证](https://github.com/facebook/react/commit/b765fb25ebc6e53bb8de2496d2828d9d01c2774b)。
正如 Facebook 工程总监 Adam Wolff 上周说的，“Facebook 未能说服开发者社区其 BSD + 专利条款的许可证是与开源需求所兼容的”，因此，在招致社区的抗议和抛弃，尤其是在发生了 [Apache 基金会将 React 的许可证列入“X 类别”](/article-8733-1-rel.html)和 [WordPress 弃用 React](/article-8880-1.html) 事件之后，Facebook 表示愿意将这个重要的 JavaScript 基础框架更换成大家更欢迎的 MIT 许可证。
作为最广泛使用的用于构建 Web 用户界面的基础框架，React 的这一许可证的修改得到了社区的强烈反响，虽然有些不同意见，但是大部分人还是表示喜闻乐见——一方面代表了社区的胜利，另外一方面也可以避免大量的采用 React 的项目重写。
不过，也有一些人对 Facebook 采用 MIT 许可证表达了不同的看法。RedMonk 的创始人 Stephen O'Grady [表示](http://redmonk.com/sogrady/2017/09/26/facebooks-bsd-patents/)，Facebook 采用不包括专利条款的 MIT 许可证，而没有采用包含了更弱的专利条款的 Apache 许可证，相比于原来的 BSD + 专利条款，按倒了葫芦起了瓢。“问题是，通过选择这种方式，Facebook 并没有像在 Apache 许可证下一样在 MIT 许可证中传达任何专利授权……如果 Facebook 在 React 申请了专利，换句话说，该软件的用户并没有被 MIT 许可证授予明确的许可，只有一个未经测试的隐含许可”。
此外，除了 React 16 换用了新的 MIT 之外， Facebook 也将前一天发布的 React 15.6.2 换用了 MIT 许可证，以便那些不方便升级 React 16 的用户使用。
而曾经被 [Gitlab 由于该许可证条款而放弃](https://www.theregister.co.uk/2017/09/20/gitlab_suspends_graphql_project_over_facebook_license_terms/)的 GraphQL [也被修改了许可证](https://medium.com/@leeb/relicensing-the-graphql-specification-e7d07a52301b)。作为一个用于规定实现标准的规范，其现在被放在<ruby> <a href="http://www.openwebfoundation.org/legal/the-owf-1-0-agreements/owfa-1-0"> 开放式网络基金会协议 </a> <rp> （ </rp> <rt> Open Web Foundation Agreement (OWFa) v1.0 </rt> <rp> ） </rp></ruby>之下，并且现在 Facebook 的 GraphQL 实现也采用了 MIT 许可证发布。
作为一个广泛使用 JavaScript 框架，这次 React 16 的升级只有很少的破坏性改变，虽然其中大部分库都[经过了重写](https://code.facebook.com/posts/1716776591680069/react-16-a-look-inside-an-api-compatible-rewrite-of-our-frontend-ui-library/)。而新的 React 16 支持异步渲染，允许处理大型组件树而不会阻塞主执行线程。此外，还增加了一些屡屡被要求而难以添加的功能，比如使用错误边界进行异常捕获，和从渲染器返回多个组件。
而 React 16 中的服务器端渲染也要比之前的版本快得多，[测试表明](https://medium.com/@aickin/whats-new-with-server-side-rendering-in-react-16-9b0d78585d67)，其比 Node 4 快 2.4 倍，比 Node 6 快 3 倍，比 Node 8.4 快 3.8 倍。
|
||||
KDE Plasma 5 已经基本准备好移植到 FreeBSD 了
|
Michael Larabel
|
https://www.phoronix.com/scan.php?page=news_item&px=Plasma-5-Desktop-Ready-FreeBSD
|
在距离 Linux 上的 KDE Plasma 5 初次发布已经三年之后，而其对 FreeBSD 的支持正在逐渐成型。
|
/data/attachment/album/201709/28/172107tq2qd4lyq2qqy24y.jpg.thumb.jpg
|
/data/attachment/album/201709/28/172107tq2qd4lyq2qqy24y.jpg
| true | false | true |
wxy
| false |
[
"FreeBSD",
"KDE"
] |
新闻
|
{
"viewnum": 6476,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在距离 Linux 上的 KDE Plasma 5 初次发布已经三年之后，而其对 FreeBSD 的支持正在逐渐成型。
| 2017-09-29T08:59:00 | 2017-09-29T08:59:00 | 8,912 |
/article-8912-1.html
|
在距离 Linux 上的 [KDE Plasma 5 初次发布](/article-3411-1.html)已经三年之后，而其对 FreeBSD 的支持正在逐渐成型。
一直领导该项工作的 KDE 贡献者 Adriaan de Groot 说，他现在已经将其 FreeBSD 桌面上切换到了 Plasma 。这标志着距离将 Plasma 5 软件包移植到 FreeBSD Ports 已经不远了，一旦移植完成，在 FreeBSD 桌面上运行 Plasma 5 就很容易了。
一些 KDE 应用已经移植到了 Ports，而另外一些还需要点工夫。不过有些令人头疼的问题，比如 KDE 4 和 KDE 5 的一些翻译和 Baloo 不能和平共处。此外，如果使用 FreeBSD 12-CURRENT 的话，有一些英特尔显卡在 KDE 下存在图形问题，而英伟达的显卡则没事。
KDE FreeBSD 小组希望这些包可以出现在 2017Q4 的正式 Ports 树之中，渴望尝鲜的伙伴们则现在就可以试试 [51 区](https://community.kde.org/FreeBSD/Setup/Area51)的体验包了。
更多关于 FreeBSD + KDE Plasma 5 的细节，可以看看 [Adriaan 的博客](https://euroquis.nl/bobulate/?p=1725)。
|
||
22 天迁移到公共云
|
Allie Coyne
|
https://www.itnews.com.au/news/a-public-cloud-migration-in-22-days-454186
|
在不到一个月内将你的核心业务从一个公共云迁移到另一个公共云看起来像是一个遥不可及的目标，但是英国化妆品巨头 Lush 认为可以做到这一点。
|
/data/attachment/album/201709/28/232428f411b7qcyosn5oby.jpg.thumb.jpg
|
/data/attachment/album/201709/28/232428f411b7qcyosn5oby.jpg
| true | false | true |
geekpi
| false |
[
"迁移",
"公有云"
] |
观点
|
{
"viewnum": 3436,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在不到一个月内将你的核心业务从一个公共云迁移到另一个公共云看起来像是一个遥不可及的目标，但是英国化妆品巨头 Lush 认为可以做到这一点。
| 2017-09-29T08:23:00 | 2017-09-29T08:23:00 | 8,915 |
/article-8915-1.html
|
>
> Lush 说这是可能的。
>
>
>
在不到一个月内将你的核心业务从一个公共云迁移到另一个公共云看起来像是一个遥不可及的目标，但是英国化妆品巨头 Lush 认为可以做到这一点。
去年九月 Lush —— 你也许知道它是那些糖果色的、好闻的沐浴和护肤产品背后的公司 —— 与已有的基础设施供应商 Acquia 的合同快要到期了。
Acquia 已经在 AWS 中托管了 Lush 的基于 Drupal 的电子商务环境好几年了，但该零售商想要退出合作。
根据 Lush 的首席数字官及公司的继承人 Jack Constantine（他的父母在 1995 年成立该公司）的说法，该安排是“尴尬”和僵硬的。
他今天在旧金山举行的 Google Cloud Next 会议上说：“我们不太满意那份合同，我们想看看我们还能做些什么。”
“那是一个非常封闭的环境，这使我们难于看清下一步做什么。”
“(我们) 可以再签署一年，在此期间想出一个有更多的控制权的长期计划，但是（我们）最终结束了这种挣扎。”
在淘遍市场后，Lush 目标放在 Google 的云平台上。该公司已经很熟悉 Google 了，已于 [2013 年底](https://cloud.googleblog.com/2013/12/google-apps-helps-eco-cosmetics-company.html)从 Scalix 迁移到 Google Apps（现称为 G Suite）上。
然而，只有几个月不到的时间进行迁移，要赶在 12 月 22 日现有合同截止前和圣诞节购物的关键时期前。
Constantine 说：“所以这不仅仅是有点关键的业务，我们要考虑高峰交易期，那时会有巨大的交易。”
Lush 摆脱了官僚主义意味着 Constantine 能够在选择供应商上快速决定。他说：“接着团队只要全力进行就行。”
他们还为这次迁移专门优先优化了用于迁移的 “一体化” Drupal 程序，而把 bug 修复推到以后。
Lush 12 月 1 日开始物理迁移，12 月 22 日完成。
团队“像其他迁移一样”遇到了挑战，Constantine 说：“你肯定会担心将数据从一个地方传输到另一个地方，你必须确保一致性，客户、产品数据等需要稳定。”
但是，这位 CDO 表示，让公司采用这个难以置信的紧张时间表是因为团队缺乏备选方案: 没有后备计划。
Constantine 说：“在截止日期前的一个星期，我的同事和我们的 Google 合作伙伴打了电话，他们对这是否会发生有点紧张，他们问我们 Plan B 是什么，我的同事说：Plan B 就是让 Plan A，就是这样”。
“当你抛出这样一个听起来有点难以置信的艰难的截止日期时，而（你需要保持）关注那些认为这是我们可在这个时间范围内可以实现的目标的人，而不是那些放置阻碍说‘我们必须要延期’的人。”
“是的，每个人都很紧张，但你实现了很多。你实际上完成并盯牢了它。你所要做的就是完成、完成。”
现在的重点是将该电子商务应用转移到微服务架构，同时研究各种 Google 工具，如 Kubernetes 容器管理系统和 Spanner 关系数据库。
Constantine 说，该零售商最近也建立了使用 GCP 和 Android 的原型 POS 系统。
（题图：Lush's Oxford St, UK store. Credit: Lush）
---
via: <https://www.itnews.com.au/news/a-public-cloud-migration-in-22-days-454186>
作者：[Allie Coyne](https://www.itnews.com.au/author/allie-coyne-461593) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
不要浪费时间写完美的代码
|
Jim Bird
|
https://dzone.com/articles/dont-waste-time-writing
|
系统可以持续运行 5 年、10 年甚至 20 年或者更多年。但是，特定的代码行的生命，即使是经过设计，通常要短得多：当你通过各种方式来迭代寻求解决方案时，它会有几个月、几天甚至几分钟的生命。
|
/data/attachment/album/201709/29/091515zsj4k68bgb61tbtn.jpg.thumb.jpg
|
/data/attachment/album/201709/29/091515zsj4k68bgb61tbtn.jpg
| true | false | true |
geekpi
| false |
[
"编程",
"代码"
] |
观点
|
{
"viewnum": 9610,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
系统可以持续运行 5 年、10 年甚至 20 年或者更多年。但是，特定的代码行的生命，即使是经过设计，通常要短得多：当你通过各种方式来迭代寻求解决方案时，它会有几个月、几天甚至几分钟的生命。
| 2017-09-29T09:15:31 | 2017-09-29T09:15:31 | 8,916 |
/article-8916-1.html
|
系统可以持续运行 5 年、10 年甚至 20 年或者更多年。但是，特定的代码行的生命，即使是经过设计，通常要短得多：当你通过各种方式来迭代寻求解决方案时，它会有几个月、几天甚至几分钟的生命。
### 一些代码比其他代码重要
通过研究[代码如何随时间变化](http://www.youtube.com/watch?v=0eAhzJ_KM-Q)，Michael Feathers 确定了[一个代码库的冥曲线](http://swreflections.blogspot.ca/2012/10/bad-things-happen-to-good-code.html)。每个系统都有代码，通常有很多是一次性写成，永远都不会改变。但是有少量的代码，包括最重要和最有用的代码，会一次又一次地改变、会有几次重构或者从头重写。
当你在一个系统、或者问题领域、体系结构方法中有更多经验时，会更容易了解并预测什么代码将一直改变，哪些代码将永远不会改变：什么代码重要，什么代码不重要。
### 我们应该尝试编写完美的代码么？
我们知道我们应该写[干净的代码](http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882)，代码应该一致、清晰也要尽可能简单。
有些人把这变成了极端，他们迫使自己写出[美丽](http://www.makinggoodsoftware.com/2011/03/27/the-obsession-with-beautiful-code-the-refactor-syndrome/)、优雅、接近[完美](http://stackoverflow.com/questions/1196405/how-to-keep-yourself-from-perfectionism-when-coding)的代码，[痴迷于重构](http://programmers.stackexchange.com/questions/43506/is-it-bad-to-have-an-obsessive-refactoring-disorder)并且纠结每个细节。
但是，如果代码只写一次而从不改变，或者如果在另一个极端下，它一直在改变的话，就如同尝试去写完美的需求和尝试做完美的前期设计那样，写完美的代码难道不是既浪费又没有必要（也不可能实现）的么？
>
> “你不能写出完美的软件。是不是收到了伤害？并不。把它作为生活的公理接受它、拥抱它、庆祝它。因为完美的软件不存在。在计算机的短暂历史中从没有人写过完美的软件。你不可能成为第一个。除非你接受这个事实，否则你最终会浪费时间和精力追逐不可能的梦想。”
>
>
> Andrew Hunt，[务实的程序员: 从熟练工到大师](https://pragprog.com/the-pragmatic-programmer)
>
>
>
一次性写的代码不需要美观优雅。但它必须是正确的、可以理解的 —— 因为绝不会改变的代码在系统的整个生命周期内可能仍然被阅读很多次。它不需要干净并紧凑 —— 只要干净就够了。代码中[复制和粘贴](http://swreflections.blogspot.com/2012/03/is-copy-and-paste-programming-really.html)和其他小的裁剪是允许的，至少在某种程度上是这样的。这些是永远不需要打磨的代码。即使周围的其他代码正在更改，这些也是不需要重构的代码（除非你需要更改它）。这是不值得花费额外时间的代码。
你一直在改变的代码怎么样了呢？纠结于代码风格以及提出最优雅的解决方案是浪费时间，因为这段代码可能会再次更改，甚至可能会在几天或几周内重写。因此，每当你进行更改时，都会[痴迷重构](http://programmers.stackexchange.com/questions/43506/is-it-bad-to-have-an-obsessive-refactoring-disorder)代码，或者没有重构没有改变的代码，因为它可能会更好。代码总是可以更好。但这并不重要。
重要的是：代码是否做了应该做的 —— 是正确的、可用的和高效的吗？它可以[处理错误和不良数据](http://swreflections.blogspot.com/2012/03/defensive-programming-being-just-enough.html)而不会崩溃 —— 或者至少可以[安全地失败](https://buildsecurityin.us-cert.gov/articles/knowledge/principles/failing-securely)？调试容易吗？改变是否容易且安全？这些不是美的主观方面。这些是成功与失败实际措施之间的差异。
### 务实编码和重构
<ruby> 精益开发 <rt> Lean Development </rt></ruby>的核心思想是：不要浪费时间在不重要的事情上。这应该提醒我们该如何编写代码，以及我们如何重构它、审查它、测试它。
为了让工作完成，只[重构你需要的](http://swreflections.blogspot.com/2012/04/what-refactoring-is-and-what-it-isnt.html) —— [Martin Fowler](http://martinfowler.com/articles/workflowsOfRefactoring/) 称之为<ruby> 机会主义重构 <rt> opportunistic refactoring </rt></ruby>（理解、清理、[童子军规则](http://programmer.97things.oreilly.com/wiki/index.php/The_Boy_Scout_Rule) ）和<ruby> 准备重构 <rt> preparatory refactoring </rt></ruby>。足够使改变更加容易和安全，而不是更多。如果你不改变那些代码，那么它并不会如看起来的那么重要。
在代码审查中，只聚焦在[重要的事上](http://randomthoughtsonjavaprogramming.blogspot.com/2014/08/building-real-software-dont-waste-time.html)。代码是否正确？有防御机制吗？是否安全？你能理解么？改变是否安全？
忘记代码风格（除非代码风格变成无法理解）。让你的 IDE 处理代码格式化。不要争议代码是否应该是“更多的 OO”。只要它有意义，它是否适当地遵循这种或那种模式并不重要。无论你喜欢还是不喜欢都没关系。你是否有更好的方式做到这一点并不重要 —— 除非你在教新接触这个平台或者语言的人，而且需要在做代码审查时做一部分指导。
写测试很重要。测试涵盖主要流程和重要的意外情况。测试让你用最少的工作获得最多的信息和最大的信心。[大面积覆盖测试，或小型针对性测试](http://swreflections.blogspot.com/2012/08/whats-better-big-fat-tests-or-little.html) —— 都没关系，只要一直在做这个工作，在编写代码之前或之后编写测试并不重要。
### （不只是）代码无关
建筑和工程方面的隐喻对软件从未有效过。我们不是设计和建造几年或几代将保持基本不变的桥梁或摩天大楼。我们构建的是更加弹性和抽象、更加短暂的东西。代码写来是被修改的 —— 这就是为什么它被称为“软件”。
>
> “经过五年的使用和修改，成功的软件程序的源码通常完全认不出它原来的样子，而一个成功建筑五年后几乎没有变化。”
>
>
> Kevin Tate，[可持续软件开发](http://www.amazon.com/Sustainable-Software-Development-Agile-Perspective/dp/0321286081)
>
>
>
我们需要将代码看作是我们工作的一个暂时的手工制品：
>
> 有时候面对更重要的事情时，我们会迷信代码。我们经常有一个错觉，让卖出的产品有价值的是代码，然而实际上可能是对该问题领域的了解、设计难题的进展甚至是客户反馈。
>
>
> Dan Grover，[Code and Creative Destruction](http://dangrover.com/2013/07/16/code-and-creative-destruction/)
>
>
>
迭代开发教会我们来体验和检验我们工作的结果 —— 我们是否解决了这个问题，如果没有，我们学到了什么，我们如何改进？软件构建从没有止境。即使设计和代码是正确的，它们也可能只是一段时间内正确，直到环境要求再次更改或替换为更好的东西。
我们需要编写好的代码：代码可以理解、正确、安全和可靠。我们需要重构和审查它，并写出好的有用的测试，同时知道这其中一些或者所有的代码，可能会很快被抛弃，或者它可能永远不会被再被查看，或者它可能根本不会用到。我们需要认识到，我们的一些工作必然会被浪费，并为此而进行优化。做需要做的，没有别的了。不要浪费时间尝试编写完美的代码。
---
作者简介：
Jim Bird
我是一名经验丰富的软件开发经理、项目经理和 CTO，专注于软件开发和维护、软件质量和安全性方面的困难问题。在过去 15 年中，我一直在管理建立全球证券交易所和投资银行电子交易平台的团队。我特别感兴趣的是，小团队在构建真正的软件中如何有效率：在可靠性，性能和适应性极限限制下的高质量，安全系统。
---
via: <https://dzone.com/articles/dont-waste-time-writing>
作者：[Jim Bird](https://dzone.com/users/722527/jim.bird.html) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
初创企业开源许可证管理九大法则
|
Heather Meeker
|
https://opensource.com/article/17/9/9-open-source-software-rules-startups
|
开源软件虽然可以免费使用，但就如同饲养一条幼犬一样（开始虽然花钱不多，后边越养越费钱）。在采用开源之前，确保能够了解其隐藏的成本和陷阱。
|
/data/attachment/album/201709/29/124535or7ej5yeirevef31.jpg.thumb.jpg
|
/data/attachment/album/201709/29/124535or7ej5yeirevef31.jpg
| true | false | true |
薛亮
| false |
[
"开源",
"免费",
"许可证"
] |
开源智慧
|
{
"viewnum": 4496,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8680,
"displayorder": 0
}
] |
开源软件虽然可以免费使用，但就如同饲养一条幼犬一样（开始虽然花钱不多，后边越养越费钱）。在采用开源之前，确保能够了解其隐藏的成本和陷阱。
| 2017-09-29T12:45:00 | 2017-09-29T12:45:00 | 8,917 |
/article-8917-1.html
|
>
> 开源软件虽然可以免费使用，但就如同饲养一条[幼犬一样](/article-8680-1.html)（开始虽然花钱不多，后边越养越费钱）。在采用开源之前，确保能够了解其隐藏的成本和陷阱。
>
>
>
对于初创公司来说，开源软件是一把双刃剑。它可以成为一家创业公司的生命线，因为开源软件可以帮助初创企业快速创新，而不必从头开始。不过，正如[有些人所说的](http://www.zdnet.com/article/open-source-is-free-like-a-puppy-is-free-says-sun-boss-3039202713/)，开源软件虽然可以免费使用，但就如同饲养一条[幼犬](/article-8680-1.html)一样，开始虽然花钱不多，后边越养越费钱。开源软件的真正代价是开源许可证合规成本。
滥用开源软件可能会造成获得投资的机遇被延迟或破坏。但是，如果遵守这些简单的法则，初创企业可以轻松地实现开源许可证合规。
### 法则一：不使用没有许可条款的软件
互联网上的一些软件不包含许可证通知，但这不意味它们可以自由使用。发布软件的人可能没有遵守上游许可条款。或者软件的作者可能尚未为其软件指定许可协议——无论是以开源方式亦或是其他方式。“没有许可条款”是指没有许可证：您应该避免使用该软件或要求作者为其该软件指定许可证。
### 法则二：不要违反开源许可证
开源软件的使用可能难以让其作者进行追踪，但并不意味着该软件的使用和不合规行为会被忽视。违反开源许可证可能会使初创公司面临法律责任和公众谴责，甚至可能会影响其被投资或收购。也可能导致潜在客户由于担心下游责任而拒绝购买您的产品。软件开发人员为实现其软件开源付出了巨大的努力，其中也包括上述的许可费用。滥用开源软件对这些开发人员是不公平的，并且损害了他们希望促成的创新。
### 法则三：跟踪您正在使用的软件
将来有一天您将必须提供您正在使用的开源软件的列表。及时维护该列表将会为您节约大量的时间和精力，因为潜在的投资者和收购方将会要求您提供该列表。大多数开源软件下载包中都包括一个 “license.txt” 或 “copy.txt” 文件。保留该许可证的副本，并记录其涵盖的软件。大多数创业公司都使用简单的电子表格跟踪软件许可情况。
### 法则四：了解<ruby> 宽松 <rp> （ </rp> <rt> permissive </rt> <rp> ） </rp></ruby>许可证和<ruby> 左版 <rp> （ </rp> <rt> copyleft </rt> <rp> ） </rp></ruby>许可证
开源许可证大致分为两种类型：宽松许可证（BSD、MIT 和 Apache）和左版许可证（GPL、LGPL、Eclipse 公共许可证、Mozilla 公共许可证以及<ruby> 通用开发和分发许可证 <rp> （ </rp> <rt> Common Development and Distribution License </rt> <rp> ） </rp></ruby>）。大多数公司及其客户对于使用遵循宽松许可证的软件没有什么法律上的担心。不过，遵循左版许可证需要更加谨慎，将软件保留为专有可能会与某些特定计划不一致。
### 法则五：遵守许可证<ruby> 通知 <rp> （ </rp> <rt> notice </rt> <rp> ） </rp></ruby>要求
无论是宽松许可证还是左版许可证，所有开源许可都有通知要求。通常，这意味着在分发开源软件时，您需要包含其所适用的许可证的副本，仅仅包括许可证的链接或缩略形式通常是不完备的。为了避免混淆或疏离您的客户，开发一个符合大多数开源许可证的通知传送策略非常重要。
### 法则六：了解哪些开源许可证与分布式软件兼容
除了 Affero GPL 之外，大多数开源许可证都没有涉及软件即服务（SaaS）的情境。对于 SaaS 和云系统的分布式组件（如 JavaScript）或分布式软件（包括移动 APP 和测试版），您可以使用遵循宽松许可证的软件，但在使用遵循左版许可证的软件之前，您需要特别小心。仅在其完全在自己的进程中执行并且没有链接的代码时才去使用遵循 GPL 的软件，而不要相信以下如何让 GPL 合规的谣传：动态链接至 GPL 代码或让客户下载 GPL 软件。仅将 LGPL 软件作为动态链接库进行使用。在不修改 API 的前提下使用遵循其它左版许可证的软件。遵循移动 APP 市场的分发规定也许与遵循某些特定的左版许可证有冲突（例如 GPL 或者 LGPL）。
### 法则七：在咨询律师之前不要贡献或发布开源软件
贡献和发布开源软件可能是公众的福音，但它可能不是您业务上的正确选择。一旦作出贡献或发布，您在软件中拥有的任何知识产权将不大可能构成您公司估值的依据。您的律师可以帮助您更好地理解在专有和开源软件之间如何选择，并对这一重要业务决策提供指导。
### 法则八：确保您的员工和第三方开发人员遵守这些规则
不管是由于您的员工或第三方承包商造成的开源违规行为，所引起的法律和宣传问题都将砸在您的头上。您可以通过适当的培训和跟踪开源软件来避免这些问题。
### 法则九：规划未来
初创公司业务模式可以快速变化。SaaS 模式可以快速转变为分布式软件模式。无论您当前的模式是什么，遵守分布式软件的规则将为您转变为分布式软件模式提供更大的灵活性，而无需删除某些开源软件并更改相关功能。
采用这些法则将有助于初创企业利用开源软件的优势，降低您在获取投资或收购时遇到的风险。对您的初创企业感兴趣的第三方想知道您如何应对开源软件问题，确保您做好准备，并能够为他们提供积极和专业的答案。
（题图：Beth Cortez-Neavel on [Flickr](https://www.flickr.com/photos/bethcortez-neavel/20699620022/in/photolist-xx9XSo-J67oFV-HgKMCn-HgzdGJ-bkUna-2wRkRj-7YyQVU-3qh3b-4NfW6z-hSgKH-4ptqkF-94f4rj-BTiPf-6xefv-HgzeVW-HgzfsC-Hgzhu3-HgKKZ2-HgKLfT-HgKKL6-HgKKt2-HgKMgv-HM7Aay-HgKN2D-J67umH-HM7AZE-J3NbSo-njSSUk-iR9Qu-5rL5ir-diemDY-8Z9WVL-p7WG5N-qzaAGY-CpEMP-8dfgUR-79XouB-nyeBRi-amefJV-skzdFQ-dC2WNi-JBvYCS-tiNzYh-rr4bkB-s6gMPL-dnJpcc-p1xZmV-4emQku-9SpCY6-e4wRz6). Public Domain. Modified by Opensource.com）
---
作者简介：Heather Meeker 是 O’Melveny & Myers 硅谷办公室的合伙人，为客户提供技术交易和知识产权方面的建议，是国际知名的开源软件许可专家。Heather 于 2016 年获得加州律师协会知识产权先锋奖。<ruby> 《最佳律师》 <rp> （ </rp> <rt> Best Lawyers </rt> <rp> ） </rp></ruby>将她提名为 2018 年年度 IT 律师。
译者简介：薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO 分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
极客漫画：HTTP2 服务器推送
|
Daniel Stori
|
http://turnoff.us/geek/http2-server-push-explained/
|
HTTP2 服务器推送会在一个请求中将用户请求的内容及相关内容一次性推送给用户——以避免用户再次发起请求。
|
/data/attachment/album/201709/30/161811ua7837fa33v738di.png.thumb.jpg
|
/data/attachment/album/201709/30/161811ua7837fa33v738di.png.large.jpg
| false | false | true |
wxy
| false |
[
"HTTP2"
] |
极客漫画
|
{
"viewnum": 7476,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.112.207.224",
"message": "匿名发帖纪念一下。",
"username": "来自四川成都的 Chromium 61.0|Ubuntu 用户",
"date": "2017-09-30T20:56:07"
}
] |
[] |
HTTP2 服务器推送会在一个请求中将用户请求的内容及相关内容一次性推送给用户——以避免用户再次发起请求。
| 2017-09-30T14:01:00 | 2017-09-30T14:01:00 | 8,918 |
/article-8918-1.html
|
HTTP2 服务器推送会在一个请求中将用户请求的内容及相关内容一次性推送给用户——以避免用户再次发起请求。
---
via: <http://turnoff.us/geek/http2-server-push-explained/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
极客漫画：Codeless 开发者
|
Daniel Stori
|
http://turnoff.us/geek/codeless/
|
而这位所谓的专家，什么都 “No” 和 “Less” 了，然后，就在办公室里面从早坐到晚，正在践行了“Codeless”（没代码）的日子。
|
/data/attachment/album/201709/29/141755mqsppxpp7qoqwktp.png.thumb.jpg
|
/data/attachment/album/201709/29/141755mqsppxpp7qoqwktp.png.large.jpg
| false | false | true |
wxy
| false |
[
"漫画",
"ServerLess",
"NOSQL"
] |
极客漫画
|
{
"viewnum": 12752,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
而这位所谓的专家，什么都 “No” 和 “Less” 了，然后，就在办公室里面从早坐到晚，正在践行了“Codeless”（没代码）的日子。
| 2017-10-02T14:16:00 | 2017-10-02T14:16:00 | 8,919 |
/article-8919-1.html
|
互联网世界新概念层出不穷，往往今天流行的概念和技术，明天就被取代和推翻。比如说，以前大家都说什么<ruby> 服务器 <rt> Server </rt></ruby>、<ruby> SQL 数据库 <rt> SQL Database </rt></ruby>和<ruby> 前端 <rt> Frontend </rt></ruby>，而现在已经开始流行 ServerLess、No-SQL 了。
当然，ServerLess 不是说不要服务器了，而是指一些运行在无状态的容器的服务器端逻辑，比如 AWS 的 Lambda 的 FaaS。而 No-SQL 则是一种非关系型数据库。
而这位所谓的专家，什么都 “No” 和 “Less” 了，然后，就在办公室里面从早坐到晚，正在践行了“Codeless”（没代码）的日子。
---
via: <http://turnoff.us/geek/codeless/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
探索传统 JavaScript 基准测试
|
Benedikt Meurer
|
http://benediktmeurer.de/2016/12/16/the-truth-about-traditional-javascript-benchmarks
|
现在看看另一方面，所有的静态性能测试——无论是微基准micro-benchmark还是大型应用的宏基准macro-benchmark，都注定要随着时间的推移变成噩梦！
|
/data/attachment/album/201709/29/153923vd38iudidk83zmt0.jpg.thumb.jpg
|
/data/attachment/album/201709/29/153923vd38iudidk83zmt0.jpg
| true | false | true |
OneNewLife
| false |
[
"JavaScript",
"基准测试"
] |
软件开发
|
{
"viewnum": 6607,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
现在看看另一方面，所有的静态性能测试——无论是微基准micro-benchmark还是大型应用的宏基准macro-benchmark，都注定要随着时间的推移变成噩梦！
| 2017-09-29T15:40:00 | 2017-09-29T15:40:00 | 8,920 |
/article-8920-1.html
|
可以很公平地说，[JavaScript](https://en.wikipedia.org/wiki/JavaScript) 是当下软件工程中*最重要的技术*。对于那些深入接触过编程语言、编译器和虚拟机的人来说，这仍然有点令人惊讶，因为在语言设计者们看来，JavaScript 不是十分优雅；在编译器工程师们看来，它没有多少可优化的地方；甚至还没有一个伟大的标准库。这取决于你和谁吐槽，JavaScript 的缺点你花上数周都枚举不完，而你总会找到一些你从所未知的奇怪的东西。尽管这看起来明显困难重重，不过 JavaScript 还是成为了当今 web 的核心，并且还（通过 [Node.js](https://nodejs.org/)）成为服务器端和云端的主导技术，甚至还开辟了进军物联网领域的道路。
那么问题来了，为什么 JavaScript 如此受欢迎？或者说如此成功？我知道没有一个很好的答案。如今我们有许多使用 JavaScript 的好理由，或许最重要的是围绕其构建的庞大的生态系统，以及现今大量可用的资源。但所有这一切实际上是发展到一定程度的后果。为什么 JavaScript 变得流行起来了？嗯，你或许会说，这是 web 多年来的通用语了。但是在很长一段时间里，人们极其讨厌 JavaScript。回顾过去，似乎第一波 JavaScript 浪潮爆发在上个年代的后半段。那个时候 JavaScript 引擎加速了各种不同的任务的执行，很自然的，这可能让很多人对 JavaScript 刮目相看。
回到过去那些日子，这些加速使用了现在所谓的传统 JavaScript 基准进行测试——从苹果的 [SunSpider 基准](https://webkit.org/perf/sunspider/sunspider.html)（JavaScript 微基准之母）到 Mozilla 的 [Kraken 基准](http://krakenbenchmark.mozilla.org/) 和谷歌的 V8 基准。后来，V8 基准被 [Octane 基准](https://developers.google.com/octane) 取代，而苹果发布了新的 [JetStream 基准](http://browserbench.org/JetStream)。这些传统的 JavaScript 基准测试驱动了无数人的努力，使 JavaScript 的性能达到了本世纪初没人能预料到的水平。据报道其性能加速达到了 1000 倍，一夜之间在网站使用 `<script>` 标签不再是与魔鬼共舞，做客户端不再仅仅是可能的了，甚至是被鼓励的。
[](https://www.youtube.com/watch?v=PvZdTZ1Nl5o)
（来源： [Advanced JS performance with V8 and Web Assembly](https://www.youtube.com/watch?v=PvZdTZ1Nl5o)， Chrome Developer Summit 2016, @s3ththompson。）
现在是 2016 年，所有（相关的）JavaScript 引擎的性能都达到了一个令人难以置信的水平，web 应用像原生应用一样快（或者能够像原生应用一样快）。引擎配有复杂的优化编译器，通过收集之前的关于类型/形状的反馈来推测某些操作（例如属性访问、二进制操作、比较、调用等），生成高度优化的机器代码的短序列。大多数优化是由 SunSpider 或 Kraken 等微基准以及 Octane 和 JetStream 等静态测试套件驱动的。由于有像 [asm.js](http://asmjs.org/) 和 [Emscripten](https://github.com/kripken/emscripten) 这样的 JavaScript 技术，我们甚至可以将大型 C++ 应用程序编译成 JavaScript，并在你的浏览器上运行，而无需下载或安装任何东西。例如，现在你可以在 web 上玩 [AngryBots](http://beta.unity3d.com/jonas/AngryBots)，无需沙盒，而过去的 web 游戏需要安装一堆诸如 Adobe Flash 或 Chrome PNaCl 的特殊插件。
这些成就绝大多数都要归功于这些微基准和静态性能测试套件的出现，以及与这些传统的 JavaScript 基准间的竞争的结果。你可以对 SunSpider 表示不满，但很显然，没有 SunSpider，JavaScript 的性能可能达不到今天的高度。好吧，赞美到此为止。现在看看另一方面，所有的静态性能测试——无论是<ruby> 微基准 <rt> micro-benchmark </rt></ruby>还是大型应用的<ruby> 宏基准 <rt> macro-benchmark </rt></ruby>，都注定要随着时间的推移变成噩梦！为什么？因为在开始摆弄它之前，基准只能教你这么多。一旦达到某个阔值以上（或以下），那么有益于特定基准的优化的一般适用性将呈指数级下降。例如，我们将 Octane 作为现实世界中 web 应用性能的代表，并且在相当长的一段时间里，它可能做得很不错，但是现在，Octane 与现实场景中的时间分布是截然不同的，因此即使眼下再优化 Octane 乃至超越自身，可能在现实世界中还是得不到任何显著的改进（无论是通用 web 还是 Node.js 的工作负载）。
[](https://youtu.be/xCx4uC7mn6Y)
（来源：[Real-World JavaScript Performance](https://youtu.be/xCx4uC7mn6Y)，BlinkOn 6 conference，@tverwaes）
由于传统 JavaScript 基准（包括最新版的 JetStream 和 Octane）可能已经背离其有用性变得越来越远，我们开始在 2016 年初寻找新的方法来测量现实场景的性能，为 V8 和 Chrome 添加了大量新的性能追踪钩子。我们还特意添加一些机制来查看我们在浏览 web 时的时间究竟开销在哪里，例如，是脚本执行、垃圾回收、编译，还是什么地方？而这些调查的结果非常有趣和令人惊讶。从上面的幻灯片可以看出，运行 Octane 花费了 70% 以上的时间去执行 JavaScript 和垃圾回收，而浏览 web 的时候，通常执行 JavaScript 花费的时间不到 30%，垃圾回收占用的时间永远不会超过 5%。在 Octane 中并没有体现出它花费了大量时间来解析和编译。因此，将更多的时间用在优化 JavaScript 执行上将提高你的 Octane 跑分，但不会对加载 [youtube.com](http://youtube.com/) 有任何积极的影响。事实上，花费更多的时间来优化 JavaScript 执行甚至可能有损你现实场景的性能，因为编译器需要更多的时间，或者你需要跟踪更多的反馈，最终在编译、垃圾回收和<ruby> 运行时桶 <rt> Runtime bucket </rt></ruby>等方面开销了更多的时间。
[](http://browserbench.org/Speedometer)
还有另外一组基准测试用于测量浏览器整体性能（包括 JavaScript 和 DOM 性能），最新推出的是 [Speedometer 基准](http://browserbench.org/Speedometer)。该基准试图通过运行一个用不同的主流 web 框架实现的简单的 [TodoMVC](http://todomvc.com/) 应用（现在看来有点过时了，不过新版本正在研发中）以捕获更真实的现实场景的性能。上述幻灯片中的各种测试 （Angular、Ember、React、Vanilla、Flight 和 Backbone）挨着放在 Octane 之后，你可以看到，此时此刻这些测试似乎更好地代表了现实世界的性能指标。但是请注意，这些数据收集在本文撰写将近 6 个月以前，而且我们优化了更多的现实场景模式（例如我们正在重构垃圾回收系统以显著地降低开销，并且 [解析器也正在重新设计](https://twitter.com/bmeurer/status/806927160300556288)）。还要注意的是，虽然这看起来像是只和浏览器相关，但我们有非常强有力的证据表明传统的峰值性能基准也不能很好的代表现实场景中 Node.js 应用性能。
[](https://youtu.be/xCx4uC7mn6Y)
（来源： [Real-World JavaScript Performance](https://youtu.be/xCx4uC7mn6Y)， BlinkOn 6 conference, @tverwaes.）
所有这一切可能已经路人皆知了，因此我将用本文剩下的部分强调一些具体案例，它们对关于我为什么认为这不仅有用，而且必须停止关注某一阈值的静态峰值性能基准测试对于 JavaScript 社区的健康是很关键的。让我通过一些例子说明 JavaScript 引擎怎样来玩弄基准的。
### 臭名昭著的 SunSpider 案例
一篇关于传统 JavaScript 基准测试的博客如果没有指出 SunSpider 那个明显的问题是不完整的。让我们从性能测试的最佳实践开始，它在现实场景中不是很适用：bitops-bitwise-and.js [性能测试](https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/bitops-bitwise-and.js)。
[](https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/bitops-bitwise-and.js)
有一些算法需要进行快速的 AND 位运算，特别是从 `C/C++` 转译成 JavaScript 的地方，所以快速执行该操作确实有点意义。然而，现实场景中的网页可能不关心引擎在循环中执行 AND 位运算是否比另一个引擎快两倍。但是再盯着这段代码几秒钟后，你可能会注意到在第一次循环迭代之后 `bitwiseAndValue` 将变成 `0`，并且在接下来的 599999 次迭代中将保持为 `0`。所以一旦你让此获得了好的性能，比如在差不多的硬件上所有测试均低于 5ms，在经过尝试之后你会意识到，只有循环的第一次是必要的，而剩余的迭代只是在浪费时间（例如 [loop peeling](https://en.wikipedia.org/wiki/Loop_splitting) 后面的死代码），那你现在就可以开始玩弄这个基准测试了。这需要 JavaScript 中的一些机制来执行这种转换，即你需要检查 `bitwiseAndValue` 是全局对象的常规属性还是在执行脚本之前不存在，全局对象或者它的原型上必须没有拦截器。但如果你真的想要赢得这个基准测试，并且你愿意全力以赴，那么你可以在不到 1ms 的时间内完成这个测试。然而，这种优化将局限于这种特殊情况，并且测试的轻微修改可能不再触发它。
好吧，那么 [bitops-bitwise-and.js](https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/bitops-bitwise-and.js) 测试彻底肯定是微基准最失败的案例。让我们继续转移到 SunSpider 中更逼真的场景——[string-tagcloud.js](https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/string-tagcloud.js) 测试，它基本上是运行一个较早版本的 `json.js polyfill`。该测试可以说看起来比位运算测试更合理，但是花点时间查看基准的配置之后立刻会发现：大量的时间浪费在一条 `eval` 表达式（高达 20% 的总执行时间被用于解析和编译，再加上实际执行编译后代码的 10% 的时间）。
[](https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/string-tagcloud.js#L199)
仔细看看，这个 `eval` 只执行了一次，并传递一个 JSON 格式的字符串，它包含一个由 2501 个含有 `tag` 和 `popularity` 属性的对象组成的数组：
```
([
{
"tag": "titillation",
"popularity": 4294967296
},
{
"tag": "foamless",
"popularity": 1257718401
},
{
"tag": "snarler",
"popularity": 613166183
},
{
"tag": "multangularness",
"popularity": 368304452任何
},
{
"tag": "Fesapo unventurous",
"popularity": 248026512
},
{
"tag": "esthesioblast",
"popularity": 179556755
},
{
"tag": "echeneidoid",
"popularity": 136641578
},
{
"tag": "embryoctony",
"popularity": 107852576
},
...
])
```
显然，解析这些对象字面量，为其生成本地代码，然后执行该代码的成本很高。将输入的字符串解析为 JSON 并生成适当的对象图的开销将更加低廉。所以，加快这个基准测试的一个小把戏就是模拟 `eval`，并尝试总是将数据首先作为 JSON 解析，如果以 JSON 方式读取失败，才回退进行真实的解析、编译、执行（尽管需要一些额外的黑魔法来跳过括号）。早在 2007 年，这甚至不算是一个坏点子，因为没有 [JSON.parse](https://tc39.github.io/ecma262/#sec-json.parse)，不过在 2017 年这只是 JavaScript 引擎的技术债，可能会让 `eval` 的合法使用遥遥无期。
```
--- string-tagcloud.js.ORIG 2016-12-14 09:00:52.869887104 +0100
+++ string-tagcloud.js 2016-12-14 09:01:01.033944051 +0100
@@ -198,7 +198,7 @@
replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(:?[eE][+\-]?\d+)?/g, ']').
replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
- j = eval('(' + this + ')');
+ j = JSON.parse(this);
return typeof filter === 'function' ? walk('', j) : j;
}
```
事实上，将基准测试更新到现代 JavaScript 会立刻会性能暴增，正如今天的 `V8 LKGR` 从 36ms 降到了 26ms，性能足足提升了 30%！
```
$ node string-tagcloud.js.ORIG
Time (string-tagcloud): 36 ms.
$ node string-tagcloud.js
Time (string-tagcloud): 26 ms.
$ node -v
v8.0.0-pre
$
```
这是静态基准和性能测试套件常见的一个问题。今天，没有人会正儿八经地用 `eval` 解析 `JSON` 数据（不仅是因为性能问题，还出于严重的安全性考虑），而是坚持为最近五年写的代码使用 [JSON.parse](https://tc39.github.io/ecma262/#sec-json.parse)。事实上，使用 `eval` 解析 JSON 可能会被视作产品级代码的的一个漏洞！所以引擎作者致力于新代码的性能所作的努力并没有反映在这个古老的基准中，相反地，而是使得 `eval` 不必要地~~更智能~~复杂化，从而赢得 `string-tagcloud.js` 测试。
好吧，让我们看看另一个例子：[3d-cube.js](https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/3d-cube.js)。这个基准测试做了很多矩阵运算，即便是最聪明的编译器对此也无可奈何，只能说执行而已。基本上，该基准测试花了大量的时间执行 `Loop` 函数及其调用的函数。
[](https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/3d-cube.js#L239)
一个有趣的发现是：`RotateX`、`RotateY` 和 `RotateZ` 函数总是调用相同的常量参数 `Phi`。
[](https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/tests/sunspider-1.0.2/3d-cube.js#L151)
这意味着我们基本上总是为 [Math.sin](https://tc39.github.io/ecma262/#sec-math.sin) 和 [Math.cos](https://tc39.github.io/ecma262/#sec-math.cos) 计算相同的值，每次执行都要计算 204 次。只有 3 个不同的输入值：
* 0.017453292519943295
* 0.05235987755982989
* 0.08726646259971647
显然，你可以在这里做的一件事情就是通过缓存以前的计算值来避免重复计算相同的正弦值和余弦值。事实上，这是 V8 以前的做法，而其它引擎例如 `SpiderMonkey` 目前仍然在这样做。我们从 V8 中删除了所谓的<ruby> 超载缓存 <rt> transcendental cache </rt></ruby>，因为缓存的开销在实际的工作负载中是不可忽视的，你不可能总是在一行代码中计算相同的值，这在其它地方倒不稀奇。当我们在 2013 和 2014 年移除这个特定的基准优化时，我们对 SunSpider 基准产生了强烈的冲击，但我们完全相信，为基准而优化并没有任何意义，并同时以这种方式批判了现实场景中的使用案例。
[](https://arewefastyet.com/#machine=12&view=single&suite=ss&subtest=cube&start=1343350217&end=1415382608)
（来源：[arewefastyet.com](https://arewefastyet.com/#machine=12&view=single&suite=ss&subtest=cube&start=1343350217&end=1415382608)）
显然，处理恒定正弦/余弦输入的更好的方法是一个内联的启发式算法，它试图平衡内联因素与其它不同的因素，例如在调用位置优先选择内联，其中<ruby> 常量叠算 <rt> constant folding </rt></ruby>可以是有益的，例如在 `RotateX`、`RotateY` 和 `RotateZ` 调用位置的案例中。但是出于各种原因，这对于 `Crankshaft` 编译器并不可行。使用 `Ignition` 和 `TurboFan` 倒是一个明智的选择，我们已经在开发更好的[内联启发式算法](https://docs.google.com/document/d/1VoYBhpDhJC4VlqMXCKvae-8IGuheBGxy32EOgC2LnT8)。
#### 垃圾回收（GC）是有害的
除了这些非常具体的测试问题，SunSpider 基准测试还有一个根本性的问题：总体执行时间。目前 V8 在适当的英特尔硬件上运行整个基准测试大概只需要 200ms（使用默认配置）。<ruby> 次垃圾回收 <rt> minor GC </rt></ruby>在 1ms 到 25ms 之间（取决于新空间中的存活对象和旧空间的碎片），而<ruby> 主垃圾回收 <rt> major GC </rt></ruby>暂停的话可以轻松减掉 30ms（甚至不考虑增量标记的开销），这超过了 SunSpider 套件总体执行时间的 10%！因此，任何不想因垃圾回收循环而造成减速 10-20% 的引擎，必须用某种方式确保它在运行 SunSpider 时不会触发垃圾回收。
[](https://github.com/WebKit/webkit/blob/master/PerformanceTests/SunSpider/resources/driver-TEMPLATE.html#L70)
就实现而言，有不同的方案，不过就我所知，没有一个在现实场景中产生了任何积极的影响。V8 使用了一个相当简单的技巧：由于每个 SunSpider 套件都运行在一个新的 `<iframe>` 中，这对应于 V8 中一个新的本地上下文，我们只需检测快速的 `<iframe>` 创建和处理（所有的 SunSpider 测试每个花费的时间小于 50ms），在这种情况下，在处理和创建之间执行垃圾回收，以确保我们在实际运行测试的时候不会触发垃圾回收。这个技巧运行的很好，在 99.9% 的案例中没有与实际用途冲突；除了时不时的你可能会受到打击，不管出于什么原因，如果你做的事情让你看起来像是 V8 的 SunSpider 测试驱动程序，你就可能被强制的垃圾回收打击到，这有可能对你的应用导致负面影响。所以谨记一点：**不要让你的应用看起来像 SunSpider！**
我可以继续展示更多 SunSpider 示例，但我不认为这非常有用。到目前为止，应该清楚的是，为刷新 SunSpider 评分而做的进一步优化在现实场景中没有带来任何好处。事实上，世界可能会因为没有 SunSpider 而更美好，因为引擎可以放弃只是用于 SunSpider 的奇淫技巧，或者甚至可以伤害到现实中的用例。不幸的是，SunSpider 仍然被（科技）媒体大量地用来比较他们眼中的浏览器性能，或者甚至用来比较手机！所以手机制造商和安卓制造商对于让 SunSpider（以及其它现在毫无意义的基准 FWIW） 上的 Chrome 看起来比较体面自然有一定的兴趣。手机制造商通过销售手机来赚钱，所以获得良好的评价对于电话部门甚至整间公司的成功至关重要。其中一些部门甚至在其手机中配置在 SunSpider 中得分较高的旧版 V8，将他们的用户置于各种未修复的安全漏洞之下（在新版中早已被修复），而让用户被最新版本的 V8 带来的任何现实场景的性能优势拒之门外！
[](https://www.engadget.com/2016/03/08/galaxy-s7-and-s7-edge-review/)
（来源：[www.engadget.com](https://www.engadget.com/2016/03/08/galaxy-s7-and-s7-edge-review/)）
作为 JavaScript 社区的一员，如果我们真的想认真对待 JavaScript 领域的现实场景的性能，我们需要让各大技术媒体停止使用传统的 JavaScript 基准来比较浏览器或手机。能够在每个浏览器中运行一个基准测试，并比较它的得分自然是好的，但是请使用一个与当今世界相关的基准，例如真实的 web 页面；如果你觉得需要通过浏览器基准来比较两部手机，请至少考虑使用 [Speedometer](http://browserbench.org/Speedometer)。
#### 轻松一刻
我一直很喜欢这个 [Myles Borins](https://twitter.com/thealphanerd) 谈话，所以我不得不无耻地向他偷师。现在我们从 SunSpider 的谴责中回过头来，让我们继续检查其它经典基准。
### 不是那么显眼的 Kraken 案例
Kraken 基准是 [Mozilla 于 2010 年 9 月 发布的](https://blog.mozilla.org/blog/2010/09/14/release-the-kraken-2)，据说它包含了现实场景应用的片段/内核，并且与 SunSpider 相比少了一个微基准。我不想在 Kraken 上花太多口舌，因为我认为它不像 SunSpider 和 Octane 一样对 JavaScript 性能有着深远的影响，所以我将强调一个特别的案例——[audio-oscillator.js](https://github.com/h4writer/arewefastyet/blob/master/benchmarks/kraken/tests/kraken-1.1/audio-oscillator.js) 测试。
[](https://github.com/h4writer/arewefastyet/blob/master/benchmarks/kraken/tests/kraken-1.1/audio-oscillator.js)
正如你所见，测试调用了 `calcOsc` 函数 500 次。`calcOsc` 首先在全局的 `sine` `Oscillator` 上调用 `generate`，然后创建一个新的 `Oscillator`，调用它的 `generate` 方法并将其添加到全局的 `sine` `Oscillator` 里。没有详细说明测试为什么是这样做的，让我们看看 `Oscillator` 原型上的 `generate` 方法。
[](https://github.com/h4writer/arewefastyet/blob/master/benchmarks/kraken/tests/kraken-1.1/audio-oscillator-data.js#L687)
让我们看看代码，你也许会觉得这里主要是循环中的数组访问或者乘法或者 [Math.round](https://tc39.github.io/ecma262/#sec-math.round) 调用，但令人惊讶的是 `offset % this.waveTableLength` 表达式完全支配了 `Oscillator.prototype.generate` 的运行。在任何的英特尔机器上的分析器中运行此基准测试显示，超过 20% 的时间占用都属于我们为模数生成的 `idiv` 指令。然而一个有趣的发现是，`Oscillator` 实例的 `waveTableLength` 字段总是包含相同的值——2048，因为它在 `Oscillator` 构造器中只分配一次。
[](https://github.com/h4writer/arewefastyet/blob/master/benchmarks/kraken/tests/kraken-1.1/audio-oscillator-data.js#L566)
如果我们知道整数模数运算的右边是 2 的幂，我们显然可以生成[更好的代码](https://graphics.stanford.edu/%7Eseander/bithacks.html#ModulusDivisionEasy)，完全避免了英特尔上的 `idiv` 指令。所以我们需要获取一种信息使 `this.waveTableLength` 从 `Oscillator` 构造器到 `Oscillator.prototype.generate` 中的模运算都是 2048。一个显而易见的方法是尝试依赖于将所有内容内嵌到 `calcOsc` 函数，并让 `load/store` 消除为我们进行的常量传播，但这对于在 `calcOsc` 函数之外分配的 `sine` `oscillator` 无效。
因此，我们所做的就是添加支持跟踪某些常数值作为模运算符的右侧反馈。这在 V8 中是有意义的，因为我们为诸如 `+`、`*` 和 `%` 的二进制操作跟踪类型反馈，这意味着操作者跟踪输入的类型和产生的输出类型（参见最近的圆桌讨论中关于[动态语言的快速运算](https://docs.google.com/presentation/d/1wZVIqJMODGFYggueQySdiA3tUYuHNMcyp_PndgXsO1Y)的幻灯片）。当然，用 `fullcodegen` 和 `Crankshaft` 挂接起来也是相当容易的，`MOD` 的 `BinaryOpIC` 也可以跟踪右边已知的 2 的冥。
```
$ ~/Projects/v8/out/Release/d8 --trace-ic audio-oscillator.js
[...SNIP...]
[BinaryOpIC(MOD:None*None->None) => (MOD:Smi*2048->Smi) @ ~Oscillator.generate+598 at audio-oscillator.js:697]
[...SNIP...]
$
```
事实上，以默认配置运行的 V8 （带有 Crankshaft 和 fullcodegen）表明 `BinaryOpIC` 正在为模数的右侧拾取适当的恒定反馈，并正确跟踪左侧始终是一个小整数（以 V8 的话叫做 `Smi`），我们也总是产生一个小整数结果。 使用 `--print-opt-code -code-comments` 查看生成的代码，很快就显示出，`Crankshaft` 利用反馈在 `Oscillator.prototype.generate` 中为整数模数生成一个有效的代码序列：
```
[...SNIP...]
;;; <@80,#84> load-named-field
0x133a0bdacc4a 330 8b4343 movl rax,[rbx+0x43]
;;; <@83,#86> compare-numeric-and-branch
0x133a0bdacc4d 333 3d00080000 cmp rax,0x800
0x133a0bdacc52 338 0f85ff000000 jnz 599 (0x133a0bdacd57)
[...SNIP...]
;;; <@90,#94> mod-by-power-of-2-i
0x133a0bdacc5b 347 4585db testl r11,r11
0x133a0bdacc5e 350 790f jns 367 (0x133a0bdacc6f)
0x133a0bdacc60 352 41f7db negl r11
0x133a0bdacc63 355 4181e3ff070000 andl r11,0x7ff
0x133a0bdacc6a 362 41f7db negl r11
0x133a0bdacc6d 365 eb07 jmp 374 (0x133a0bdacc76)
0x133a0bdacc6f 367 4181e3ff070000 andl r11,0x7ff
[...SNIP...]
;;; <@127,#88> deoptimize
0x133a0bdacd57 599 e81273cdff call 0x133a0ba8406e
[...SNIP...]
```
所以你看到我们加载 `this.waveTableLength`（`rbx` 持有 `this` 的引用）的值，检查它仍然是 2048（十六进制的 0x800），如果是这样，就只用适当的掩码 0x7ff（`r11` 包含循环感应变量 `i` 的值）执行一个位操作 AND ，而不是使用 `idiv` 指令（注意保留左侧的符号）。
#### 过度特定的问题
所以这个技巧酷毙了，但正如许多基准关注的技巧都有一个主要的缺点：太过于特定了！一旦右侧发生变化，所有优化过的代码就失去了优化（假设右手始终是不再处理的 2 的冥），任何进一步的优化尝试都必须再次使用 `idiv`，因为 `BinaryOpIC` 很可能以 `Smi * Smi -> Smi` 的形式报告反馈。例如，假设我们实例化另一个 `Oscillator`，在其上设置不同的 `waveTableLength`，并为 `Oscillator` 调用 `generate`，那么即使我们实际上感兴趣的 `Oscillator` 不受影响，我们也会损失 20% 的性能（例如，引擎在这里实行非局部惩罚）。
```
--- audio-oscillator.js.ORIG 2016-12-15 22:01:43.897033156 +0100
+++ audio-oscillator.js 2016-12-15 22:02:26.397326067 +0100
@@ -1931,6 +1931,10 @@
var frequency = 344.53;
var sine = new Oscillator(Oscillator.Sine, frequency, 1, bufferSize, sampleRate);
+var unused = new Oscillator(Oscillator.Sine, frequency, 1, bufferSize, sampleRate);
+unused.waveTableLength = 1024;
+unused.generate();
+
var calcOsc = function() {
sine.generate();
```
将原始的 `audio-oscillator.js` 执行时间与包含额外未使用的 `Oscillator` 实例与修改的 `waveTableLength` 的版本进行比较，显示的是预期的结果：
```
$ ~/Projects/v8/out/Release/d8 audio-oscillator.js.ORIG
Time (audio-oscillator-once): 64 ms.
$ ~/Projects/v8/out/Release/d8 audio-oscillator.js
Time (audio-oscillator-once): 81 ms.
$
```
这是一个非常可怕的性能悬崖的例子：假设开发人员编写代码库，并使用某些样本输入值进行仔细的调整和优化，性能是体面的。现在，用户读过了性能说明开始使用该库，但不知何故从性能悬崖下降，因为她/他正在以一种稍微不同的方式使用库，即特定的 `BinaryOpIC` 的某种污染方式的类型反馈，并且遭受 20% 的减速（与该库作者的测量相比），该库的作者和用户都无法解释，这似乎是随机的。
现在这种情况在 JavaScript 领域并不少见，不幸的是，这些悬崖中有几个是不可避免的，因为它们是由于 JavaScript 的性能是基于乐观的假设和猜测。我们已经花了 **大量** 时间和精力来试图找到避免这些性能悬崖的方法，而仍提供了（几乎）相同的性能。事实证明，尽可能避免 `idiv` 是很有意义的，即使你不一定知道右边总是一个 2 的幂（通过动态反馈），所以为什么 `TurboFan` 的做法有异于 `Crankshaft` 的做法，因为它总是在运行时检查输入是否是 2 的幂，所以一般情况下，对于有符整数模数，优化右手侧的（未知的） 2 的冥看起来像这样（伪代码）：
```
if 0 < rhs then
msk = rhs - 1
if rhs & msk != 0 then
lhs % rhs
else
if lhs < 0 then
-(-lhs & msk)
else
lhs & msk
else
if rhs < -1 then
lhs % rhs
else
zero
```
这产生更加一致和可预测的性能（使用 `TurboFan`）：
```
$ ~/Projects/v8/out/Release/d8 --turbo audio-oscillator.js.ORIG
Time (audio-oscillator-once): 69 ms.
$ ~/Projects/v8/out/Release/d8 --turbo audio-oscillator.js
Time (audio-oscillator-once): 69 ms.
$
```
基准和过度特定化的问题在于基准可以给你提示可以看看哪里以及该怎么做，但它不告诉你应该做到什么程度，不能保护合理优化。例如，所有 JavaScript 引擎都使用基准来防止性能回退，但是运行 Kraken 不能保护我们在 `TurboFan` 中使用的常规方法，即我们可以将 `TurboFan` 中的模优化降级到过度特定的版本的 `Crankshaft`，而基准不会告诉我们性能回退的事实，因为从基准的角度来看这很好！现在你可以扩展基准，也许以上面我们相同的方式，并试图用基准覆盖一切，这是引擎实现者在一定程度上做的事情，但这种方法不能任意缩放。即使基准测试方便，易于用来沟通和竞争，以常识所见你还是需要留下空间，否则过度特定化将支配一切，你会有一个真正的、非常好的可接受的性能，以及巨大的性能悬崖线。
Kraken 测试还有许多其它的问题，不过现在让我们继续讨论过去五年中最有影响力的 JavaScript 基准测试—— Octane 测试。
### 深入接触 Octane
[Octane](https://developers.google.com/octane) 基准是 V8 基准的继承者，最初由[谷歌于 2012 年中期发布](https://blog.chromium.org/2012/08/octane-javascript-benchmark-suite-for.html)，目前的版本 Octane 2.0 [于 2013 年年底发布](https://blog.chromium.org/2013/11/announcing-octane-20.html)。这个版本包含 15 个独立测试，其中对于 `Splay` 和 `Mandreel`，我们用来测试吞吐量和延迟。这些测试范围从 [微软 TypeScript 编译器](http://www.typescriptlang.org/) 编译自身到 `zlib` 测试测量原生的 [asm.js](http://asmjs.org/) 性能，再到 `RegExp` 引擎的性能测试、光线追踪器、2D 物理引擎等。有关各个基准测试项的详细概述，请参阅[说明书](https://developers.google.com/octane/benchmark)。所有这些测试项目都经过仔细的筛选，以反映 JavaScript 性能的方方面面，我们认为这在 2012 年非常重要，或许预计在不久的将来会变得更加重要。
在很大程度上 Octane 在实现其将 JavaScript 性能提高到更高水平的目标方面无比的成功，它在 2012 年和 2013 年引导了良性的竞争，Octane 创造了巨大的业绩和成就。但是现在将近 2017 年了，世界看起来与 2012 年真的迥然不同了。除了通常和经常被引用的批评，Octane 中的大多数项目基本上已经过时（例如，老版本的 `TypeScript`，`zlib` 通过老版本的 [Emscripten](https://github.com/kripken/emscripten) 编译而成，`Mandreel` 甚至不再可用等等），某种更重要的方式影响了 Octane 的用途：
我们看到大型 web 框架赢得了 web 种族之争，尤其是像 [Ember](http://emberjs.com/) 和 [AngularJS](https://angularjs.org/) 这样的重型框架，它们使用了 JavaScript 执行模式，不过根本没有被 Octane 所反映，并且经常受到（我们）Octane 具体优化的损害。我们还看到 JavaScript 在服务器和工具前端获胜，这意味着有大规模的 JavaScript 应用现在通常运行上数星期，如果不是运行上数年都不会被 Octane 捕获。正如开篇所述，我们有硬数据表明 Octane 的执行和内存配置文件与我们每天在 web 上看到的截然不同。
让我们来看看今天一些玩弄 Octane 基准的具体例子，其中优化不再反映在现实场景。请注意，即使这可能听起来有点负面回顾，它绝对不意味着这样！正如我已经说过好几遍，Octane 是 JavaScript 性能故事中的重要一章，它发挥了至关重要的作用。在过去由 Octane 驱动的 JavaScript 引擎中的所有优化都是善意地添加的，因为 Octane 是现实场景性能的好代理！每个年代都有它的基准，而对于每一个基准都有一段时间你必须要放手！
话虽如此，让我们在路上看这个节目，首先看看 `Box2D` 测试，它是基于 [Box2DWeb](https://github.com/hecht-software/box2dweb) （一个最初由 Erin Catto 编写的移植到 JavaScript 的流行的 2D 物理引擎）的。总的来说，很多浮点数学驱动了很多 JavaScript 引擎下很好的优化，但是，事实证明它包含一个可以肆意玩弄基准的漏洞（怪我，我发现了漏洞，并添加在这种情况下的漏洞）。在基准中有一个函数 `D.prototype.UpdatePairs`，看起来像这样：
```
D.prototype.UpdatePairs = function(b) {
var e = this;
var f = e.m_pairCount = 0,
m;
for (f = 0; f < e.m_moveBuffer.length; ++f) {
m = e.m_moveBuffer[f];
var r = e.m_tree.GetFatAABB(m);
e.m_tree.Query(function(t) {
if (t == m) return true;
if (e.m_pairCount == e.m_pairBuffer.length) e.m_pairBuffer[e.m_pairCount] = new O;
var x = e.m_pairBuffer[e.m_pairCount];
x.proxyA = t < m ? t : m;
x.proxyB = t >= m ? t : m;
++e.m_pairCount;
return true
},
r)
}
for (f = e.m_moveBuffer.length = 0; f < e.m_pairCount;) {
r = e.m_pairBuffer[f];
var s = e.m_tree.GetUserData(r.proxyA),
v = e.m_tree.GetUserData(r.proxyB);
b(s, v);
for (++f; f < e.m_pairCount;) {
s = e.m_pairBuffer[f];
if (s.proxyA != r.proxyA || s.proxyB != r.proxyB) break;
++f
}
}
};
```
一些分析显示，在第一个循环中传递给 `e.m_tree.Query` 的无辜的内部函数花费了大量的时间：
```
function(t) {
if (t == m) return true;
if (e.m_pairCount == e.m_pairBuffer.length) e.m_pairBuffer[e.m_pairCount] = new O;
var x = e.m_pairBuffer[e.m_pairCount];
x.proxyA = t < m ? t : m;
x.proxyB = t >= m ? t : m;
++e.m_pairCount;
return true
}
```
更准确地说，时间并不是开销在这个函数本身，而是由此触发的操作和内置库函数。结果，我们花费了基准调用的总体执行时间的 4-7% 在 [Compare` 运行时函数](https://github.com/v8/v8/blob/5124589642ba12228dcd66a8cb8c84c986a13f35/src/runtime/runtime-object.cc#L884)上，它实现了[抽象关系](https://tc39.github.io/ecma262/#sec-abstract-relational-comparison)比较的一般情况。
几乎所有对运行时函数的调用都来自 [CompareICStub](https://github.com/v8/v8/blob/5124589642ba12228dcd66a8cb8c84c986a13f35/src/x64/code-stubs-x64.cc#L2495)，它用于内部函数中的两个关系比较：
```
x.proxyA = t < m ? t : m;
x.proxyB = t >= m ? t : m;
```
所以这两行无辜的代码要负起 99% 的时间开销的责任！这怎么来的？好吧，与 JavaScript 中的许多东西一样，[抽象关系比较](https://tc39.github.io/ecma262/#sec-abstract-relational-comparison) 的直观用法不一定是正确的。在这个函数中，`t` 和 `m` 都是 `L` 的实例，它是这个应用的一个中心类，但不会覆盖 `Symbol.toPrimitive`、`“toString”`、`“valueOf”` 或 `Symbol.toStringTag` 属性，它们与抽象关系比较相关。所以如果你写 `t < m` 会发生什么呢？
1. 调用 [ToPrimitive](https://tc39.github.io/ecma262/#sec-toprimitive)(`t`, `hint Number`)。
2. 运行 [OrdinaryToPrimitive](https://tc39.github.io/ecma262/#sec-ordinarytoprimitive)(`t`, `"number"`)，因为这里没有 `Symbol.toPrimitive`。
3. 执行 `t.valueOf()`，这会获得 `t` 自身的值，因为它调用了默认的 [Object.prototype.valueOf](https://tc39.github.io/ecma262/#sec-object.prototype.valueof)。
4. 接着执行 `t.toString()`，这会生成 `"[object Object]"`，因为调用了默认的 [Object.prototype.toString](https://tc39.github.io/ecma262/#sec-object.prototype.toString)，并且没有找到 `L` 的 [Symbol.toStringTag](https://tc39.github.io/ecma262/#sec-symbol.tostringtag)。
5. 调用 [ToPrimitive](https://tc39.github.io/ecma262/#sec-toprimitive)(`m`, `hint Number`)。
6. 运行 [OrdinaryToPrimitive](https://tc39.github.io/ecma262/#sec-ordinarytoprimitive)(`m`, `"number"`)，因为这里没有 `Symbol.toPrimitive`。
7. 执行 `m.valueOf()`，这会获得 `m` 自身的值，因为它调用了默认的 [Object.prototype.valueOf](https://tc39.github.io/ecma262/#sec-object.prototype.valueof)。
8. 接着执行 `m.toString()`，这会生成 `"[object Object]"`，因为调用了默认的 [Object.prototype.toString](https://tc39.github.io/ecma262/#sec-object.prototype.toString)，并且没有找到 `L` 的 [Symbol.toStringTag](https://tc39.github.io/ecma262/#sec-symbol.tostringtag)。
9. 执行比较 `"[object Object]" < "[object Object]"`，结果是 `false`。
至于 `t >= m` 亦复如是，它总会输出 `true`。所以这里是一个漏洞——使用抽象关系比较这种方法没有意义。而利用它的方法是使编译器常数折叠，即给基准打补丁：
```
--- octane-box2d.js.ORIG 2016-12-16 07:28:58.442977631 +0100
+++ octane-box2d.js 2016-12-16 07:29:05.615028272 +0100
@@ -2021,8 +2021,8 @@
if (t == m) return true;
if (e.m_pairCount == e.m_pairBuffer.length) e.m_pairBuffer[e.m_pairCount] = new O;
var x = e.m_pairBuffer[e.m_pairCount];
- x.proxyA = t < m ? t : m;
- x.proxyB = t >= m ? t : m;
+ x.proxyA = m;
+ x.proxyB = t;
++e.m_pairCount;
return true
},
```
因为这样做会跳过比较以达到 13% 的惊人的性能提升，并且所有的属性查找和内置函数的调用都会被它触发。
```
$ ~/Projects/v8/out/Release/d8 octane-box2d.js.ORIG
Score (Box2D): 48063
$ ~/Projects/v8/out/Release/d8 octane-box2d.js
Score (Box2D): 55359
$
```
那么我们是怎么做呢？事实证明，我们已经有一种用于跟踪比较对象的形状的机制，比较发生于 `CompareIC`，即所谓的已知接收器映射跟踪（其中的映射是 V8 的对象形状+原型），不过这是有限的抽象和严格相等比较。但是我可以很容易地扩展跟踪，并且收集反馈进行抽象的关系比较：
```
$ ~/Projects/v8/out/Release/d8 --trace-ic octane-box2d.js
[...SNIP...]
[CompareIC in ~+557 at octane-box2d.js:2024 ((UNINITIALIZED+UNINITIALIZED=UNINITIALIZED)->(RECEIVER+RECEIVER=KNOWN_RECEIVER))#LT @ 0x1d5a860493a1]
[CompareIC in ~+649 at octane-box2d.js:2025 ((UNINITIALIZED+UNINITIALIZED=UNINITIALIZED)->(RECEIVER+RECEIVER=KNOWN_RECEIVER))#GTE @ 0x1d5a860496e1]
[...SNIP...]
$
```
这里基准代码中使用的 `CompareIC` 告诉我们，对于我们正在查看的函数中的 `LT`（小于）和 `GTE`（大于或等于）比较，到目前为止这只能看到 `RECEIVERs`（接收器，V8 的 JavaScript 对象），并且所有这些接收器具有相同的映射 `0x1d5a860493a1`，其对应于 `L` 实例的映射。因此，在优化的代码中，只要我们知道比较的两侧映射的结果都为 `0x1d5a860493a1`，并且没人混淆 `L` 的原型链（即 `Symbol.toPrimitive`、`"valueOf"` 和 `"toString"` 这些方法都是默认的，并且没人赋予过 `Symbol.toStringTag` 的访问权限），我们可以将这些操作分别常量折叠为 `false` 和 `true`。剩下的故事都是关于 `Crankshaft` 的黑魔法，有很多一部分都是由于初始化的时候忘记正确地检查 `Symbol.toStringTag` 属性：
[](https://codereview.chromium.org/1355113002)
最后，性能在这个特定的基准上有了质的飞跃：
我要声明一下，当时我并不相信这个特定的行为总是指向源代码中的漏洞，所以我甚至期望外部代码经常会遇到这种情况，同时也因为我假设 JavaScript 开发人员不会总是关心这些种类的潜在错误。但是，我大错特错了，在此我马上悔改！我不得不承认，这个特殊的优化纯粹是一个基准测试的东西，并不会有助于任何真实代码（除非代码是为了从这个优化中获益而写，不过以后你可以在代码中直接写入 `true` 或 `false`，而不用再总是使用常量关系比较）。你可能想知道我们为什么在打补丁后又马上回滚了一下。这是我们整个团队投入到 `ES2015` 实施的非常时期，这才是真正的恶魔之舞，我们需要在没有严格的回归测试的情况下将所有新特性（`ES2015` 就是个怪兽）纳入传统基准。
关于 `Box2D` 点到为止了，让我们看看 `Mandreel` 基准。`Mandreel` 是一个用来将 `C/C++` 代码编译成 JavaScript 的编译器，它并没有用上新一代的 [Emscripten](https://github.com/kripken/emscripten) 编译器所使用，并且已经被弃用（或多或少已经从互联网消失了）大约三年的 JavaScript 子集 [asm.js](http://asmjs.org/)。然而，Octane 仍然有一个通过 [Mandreel](http://www.mandreel.com/) 编译的[子弹物理引擎](http://bulletphysics.org/wordpress/)。`MandreelLatency` 测试十分有趣，它测试 `Mandreel` 基准与频繁的时间测量检测点。有一种说法是，由于 `Mandreel` 强制使用虚拟机编译器，此测试提供了由编译器引入的延迟的指示，并且测量检测点之间的长时间停顿降低了最终得分。这听起来似乎合情合理，确实有一定的意义。然而，像往常一样，供应商找到了在这个基准上作弊的方法。
[](https://bugzilla.mozilla.org/show_bug.cgi?id=1162272)
`Mandreel` 自带一个重型初始化函数 `global_init`，光是解析这个函数并为其生成基线代码就花费了不可思议的时间。因为引擎通常在脚本中多次解析各种函数，一个所谓的预解析步骤用来发现脚本内的函数。然后作为函数第一次被调用完整的解析步骤以生成基线代码（或者说字节码）。这在 V8 中被称为[懒解析](https://docs.google.com/presentation/d/1214p4CFjsF-NY4z9in0GEcJtjbyVQgU0A-UqEvovzCs)。V8 有一些启发式检测函数，当预解析浪费时间的时候可以立刻调用，不过对于 `Mandreel` 基准的 `global_init` 函数就不太清楚了，于是我们将经历这个大家伙“预解析+解析+编译”的长时间停顿。所以我们[添加了一个额外的启发式函数](https://codereview.chromium.org/1102523003)以避免 `global_init` 函数的预解析。
[](https://arewefastyet.com/#machine=29&view=single&suite=octane&subtest=MandreelLatency&start=1415924086&end=1446461709)
由此可见，在检测 `global_init` 和避免昂贵的预解析步骤我们几乎提升了 2 倍。我们不太确定这是否会对真实用例产生负面影响，不过保证你在预解析大函数的时候将会受益匪浅（因为它们不会立即执行）。
让我们来看看另一个稍有争议的基准测试：[splay.js](https://github.com/chromium/octane/blob/master/splay.js) 测试，一个用于处理<ruby> 伸展树 <rt> splay tree </rt></ruby>（二叉查找树的一种）和练习自动内存管理子系统（也被称为垃圾回收器）的数据操作基准。它自带一个延迟测试，这会引导 `Splay` 代码通过频繁的测量检测点，检测点之间的长时间停顿表明垃圾回收器的延迟很高。此测试测量延迟暂停的频率，将它们分类到桶中，并以较低的分数惩罚频繁的长暂停。这听起来很棒！没有 GC 停顿，没有垃圾。纸上谈兵到此为止。让我们看看这个基准，以下是整个伸展树业务的核心：
[](https://github.com/chromium/octane/blob/master/splay.js#L85)
这是伸展树结构的核心构造，尽管你可能想看完整的基准，不过这基本上是 `SplayLatency` 得分的重要来源。怎么回事？实际上，该基准测试是建立巨大的伸展树，尽可能保留所有节点，从而还原它原本的空间。使用像 V8 这样的代数垃圾回收器，如果程序违反了[代数假设](http://www.memorymanagement.org/glossary/g.html)，会导致极端的时间停顿，从本质上看，将所有东西从新空间撤回到旧空间的开销是非常昂贵的。在旧配置中运行 V8 可以清楚地展示这个问题：
```
$ out/Release/d8 --trace-gc --noallocation_site_pretenuring octane-splay.js
[20872:0x7f26f24c70d0] 10 ms: Scavenge 2.7 (6.0) -> 2.7 (7.0) MB, 1.1 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 12 ms: Scavenge 2.7 (7.0) -> 2.7 (8.0) MB, 1.7 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 14 ms: Scavenge 3.7 (8.0) -> 3.6 (10.0) MB, 0.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 18 ms: Scavenge 4.8 (10.5) -> 4.7 (11.0) MB, 2.5 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 22 ms: Scavenge 5.7 (11.0) -> 5.6 (16.0) MB, 2.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 28 ms: Scavenge 8.7 (16.0) -> 8.6 (17.0) MB, 4.3 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 35 ms: Scavenge 9.6 (17.0) -> 9.6 (28.0) MB, 6.9 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 49 ms: Scavenge 16.6 (28.5) -> 16.4 (29.0) MB, 8.2 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 65 ms: Scavenge 17.5 (29.0) -> 17.5 (52.0) MB, 15.3 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 93 ms: Scavenge 32.3 (52.5) -> 32.0 (53.5) MB, 17.6 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 126 ms: Scavenge 33.4 (53.5) -> 33.3 (68.0) MB, 31.5 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 151 ms: Scavenge 47.9 (68.0) -> 47.6 (69.5) MB, 15.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 183 ms: Scavenge 49.2 (69.5) -> 49.2 (84.0) MB, 30.9 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 210 ms: Scavenge 63.5 (84.0) -> 62.4 (85.0) MB, 14.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 241 ms: Scavenge 64.7 (85.0) -> 64.6 (99.0) MB, 28.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 268 ms: Scavenge 78.2 (99.0) -> 77.6 (101.0) MB, 16.1 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 298 ms: Scavenge 80.4 (101.0) -> 80.3 (114.5) MB, 28.2 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 324 ms: Scavenge 93.5 (114.5) -> 92.9 (117.0) MB, 16.4 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 354 ms: Scavenge 96.2 (117.0) -> 96.0 (130.0) MB, 27.6 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 383 ms: Scavenge 108.8 (130.0) -> 108.2 (133.0) MB, 16.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 413 ms: Scavenge 111.9 (133.0) -> 111.7 (145.5) MB, 27.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 440 ms: Scavenge 124.1 (145.5) -> 123.5 (149.0) MB, 17.4 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 473 ms: Scavenge 127.6 (149.0) -> 127.4 (161.0) MB, 29.5 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 502 ms: Scavenge 139.4 (161.0) -> 138.8 (165.0) MB, 18.7 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 534 ms: Scavenge 143.3 (165.0) -> 143.1 (176.5) MB, 28.5 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 561 ms: Scavenge 154.7 (176.5) -> 154.2 (181.0) MB, 19.0 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 594 ms: Scavenge 158.9 (181.0) -> 158.7 (192.0) MB, 29.2 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 622 ms: Scavenge 170.0 (192.5) -> 169.5 (197.0) MB, 19.5 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 655 ms: Scavenge 174.6 (197.0) -> 174.3 (208.0) MB, 28.7 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 683 ms: Scavenge 185.4 (208.0) -> 184.9 (212.5) MB, 19.4 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 715 ms: Scavenge 190.2 (213.0) -> 190.0 (223.5) MB, 27.7 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 743 ms: Scavenge 200.7 (223.5) -> 200.3 (228.5) MB, 19.7 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 774 ms: Scavenge 205.8 (228.5) -> 205.6 (239.0) MB, 27.1 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 802 ms: Scavenge 216.1 (239.0) -> 215.7 (244.5) MB, 19.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 833 ms: Scavenge 221.4 (244.5) -> 221.2 (254.5) MB, 26.2 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 861 ms: Scavenge 231.5 (255.0) -> 231.1 (260.5) MB, 19.9 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 892 ms: Scavenge 237.0 (260.5) -> 236.7 (270.5) MB, 26.3 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 920 ms: Scavenge 246.9 (270.5) -> 246.5 (276.0) MB, 20.1 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 951 ms: Scavenge 252.6 (276.0) -> 252.3 (286.0) MB, 25.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 979 ms: Scavenge 262.3 (286.0) -> 261.9 (292.0) MB, 20.3 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1014 ms: Scavenge 268.2 (292.0) -> 267.9 (301.5) MB, 29.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1046 ms: Scavenge 277.7 (302.0) -> 277.3 (308.0) MB, 22.4 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1077 ms: Scavenge 283.8 (308.0) -> 283.5 (317.5) MB, 25.1 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1105 ms: Scavenge 293.1 (317.5) -> 292.7 (323.5) MB, 20.7 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1135 ms: Scavenge 299.3 (323.5) -> 299.0 (333.0) MB, 24.9 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1164 ms: Scavenge 308.6 (333.0) -> 308.1 (339.5) MB, 20.9 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1194 ms: Scavenge 314.9 (339.5) -> 314.6 (349.0) MB, 25.0 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1222 ms: Scavenge 324.0 (349.0) -> 323.6 (355.5) MB, 21.1 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1253 ms: Scavenge 330.4 (355.5) -> 330.1 (364.5) MB, 25.1 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1282 ms: Scavenge 339.4 (364.5) -> 339.0 (371.0) MB, 22.2 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1315 ms: Scavenge 346.0 (371.0) -> 345.6 (380.0) MB, 25.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1413 ms: Mark-sweep 349.9 (380.0) -> 54.2 (305.0) MB, 5.8 / 0.0 ms (+ 87.5 ms in 73 steps since start of marking, biggest step 8.2 ms, walltime since start of marking 131 ms) finalize incremental marking via stack guard GC in old space requested
[20872:0x7f26f24c70d0] 1457 ms: Scavenge 65.8 (305.0) -> 65.1 (305.0) MB, 31.0 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1489 ms: Scavenge 69.9 (305.0) -> 69.7 (305.0) MB, 27.1 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1523 ms: Scavenge 80.9 (305.0) -> 80.4 (305.0) MB, 22.9 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1553 ms: Scavenge 85.5 (305.0) -> 85.3 (305.0) MB, 24.2 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1581 ms: Scavenge 96.3 (305.0) -> 95.7 (305.0) MB, 18.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1616 ms: Scavenge 101.1 (305.0) -> 100.9 (305.0) MB, 29.2 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1648 ms: Scavenge 111.6 (305.0) -> 111.1 (305.0) MB, 22.5 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1678 ms: Scavenge 116.7 (305.0) -> 116.5 (305.0) MB, 25.0 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1709 ms: Scavenge 127.0 (305.0) -> 126.5 (305.0) MB, 20.7 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1738 ms: Scavenge 132.3 (305.0) -> 132.1 (305.0) MB, 23.9 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1767 ms: Scavenge 142.4 (305.0) -> 141.9 (305.0) MB, 19.6 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1796 ms: Scavenge 147.9 (305.0) -> 147.7 (305.0) MB, 23.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1825 ms: Scavenge 157.8 (305.0) -> 157.3 (305.0) MB, 19.9 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1853 ms: Scavenge 163.5 (305.0) -> 163.2 (305.0) MB, 22.2 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1881 ms: Scavenge 173.2 (305.0) -> 172.7 (305.0) MB, 19.1 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1910 ms: Scavenge 179.1 (305.0) -> 178.8 (305.0) MB, 23.0 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1944 ms: Scavenge 188.6 (305.0) -> 188.1 (305.0) MB, 25.1 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 1979 ms: Scavenge 194.7 (305.0) -> 194.4 (305.0) MB, 28.4 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 2011 ms: Scavenge 204.0 (305.0) -> 203.6 (305.0) MB, 23.4 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 2041 ms: Scavenge 210.2 (305.0) -> 209.9 (305.0) MB, 23.8 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 2074 ms: Scavenge 219.4 (305.0) -> 219.0 (305.0) MB, 24.5 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 2105 ms: Scavenge 225.8 (305.0) -> 225.4 (305.0) MB, 24.7 / 0.0 ms allocation failure
[20872:0x7f26f24c70d0] 2138 ms: Scavenge 234.8 (305.0) -> 234.4 (305.0) MB, 23.1 / 0.0 ms allocation failure
[...SNIP...]
$
```
因此这里关键的发现是直接在旧空间中分配伸展树节点可基本避免在周围复制对象的所有开销，并且将次要 GC 周期的数量减少到最小（从而减少 GC 引起的停顿时间）。我们想出了一种称为<ruby> <a href="https://research.google.com/pubs/pub43823.html"> 分配场所预占 </a> <rt> allocation site pretenuring </rt></ruby>的机制，当运行到基线代码时，将尝试动态收集分配场所的反馈，以决定在此分配的对象的确切部分是否存在，如果是，则优化代码以直接在旧空间分配对象——即预占对象。
```
$ out/Release/d8 --trace-gc octane-splay.js
[20885:0x7ff4d7c220a0] 8 ms: Scavenge 2.7 (6.0) -> 2.6 (7.0) MB, 1.2 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 10 ms: Scavenge 2.7 (7.0) -> 2.7 (8.0) MB, 1.6 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 11 ms: Scavenge 3.6 (8.0) -> 3.6 (10.0) MB, 0.9 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 17 ms: Scavenge 4.8 (10.5) -> 4.7 (11.0) MB, 2.9 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 20 ms: Scavenge 5.6 (11.0) -> 5.6 (16.0) MB, 2.8 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 26 ms: Scavenge 8.7 (16.0) -> 8.6 (17.0) MB, 4.5 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 34 ms: Scavenge 9.6 (17.0) -> 9.5 (28.0) MB, 6.8 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 48 ms: Scavenge 16.6 (28.5) -> 16.4 (29.0) MB, 8.6 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 64 ms: Scavenge 17.5 (29.0) -> 17.5 (52.0) MB, 15.2 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 96 ms: Scavenge 32.3 (52.5) -> 32.0 (53.5) MB, 19.6 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 153 ms: Scavenge 61.3 (81.5) -> 57.4 (93.5) MB, 27.9 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 432 ms: Scavenge 339.3 (364.5) -> 326.6 (364.5) MB, 12.7 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 666 ms: Scavenge 563.7 (592.5) -> 553.3 (595.5) MB, 20.5 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 825 ms: Mark-sweep 603.9 (644.0) -> 96.0 (528.0) MB, 4.0 / 0.0 ms (+ 92.5 ms in 51 steps since start of marking, biggest step 4.6 ms, walltime since start of marking 160 ms) finalize incremental marking via stack guard GC in old space requested
[20885:0x7ff4d7c220a0] 1068 ms: Scavenge 374.8 (528.0) -> 362.6 (528.0) MB, 19.1 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 1304 ms: Mark-sweep 460.1 (528.0) -> 102.5 (444.5) MB, 10.3 / 0.0 ms (+ 117.1 ms in 59 steps since start of marking, biggest step 7.3 ms, walltime since start of marking 200 ms) finalize incremental marking via stack guard GC in old space requested
[20885:0x7ff4d7c220a0] 1587 ms: Scavenge 374.2 (444.5) -> 361.6 (444.5) MB, 13.6 / 0.0 ms allocation failure
[20885:0x7ff4d7c220a0] 1828 ms: Mark-sweep 485.2 (520.0) -> 101.5 (519.5) MB, 3.4 / 0.0 ms (+ 102.8 ms in 58 steps since start of marking, biggest step 4.5 ms, walltime since start of marking 183 ms) finalize incremental marking via stack guard GC in old space requested
[20885:0x7ff4d7c220a0] 2028 ms: Scavenge 371.4 (519.5) -> 358.5 (519.5) MB, 12.1 / 0.0 ms allocation failure
[...SNIP...]
$
```
事实上，这完全解决了 `SplayLatency` 基准的问题，并提高我们的得分至超过 250%！
[](https://arewefastyet.com/#machine=12&view=single&suite=octane&subtest=SplayLatency&start=1384889558&end=1415405874)
正如 [SIGPLAN 论文](https://research.google.com/pubs/pub43823.html) 中所提及的，我们有充分的理由相信，分配场所预占机制可能真的赢得了真实世界应用的欢心，并真正期待看到改进和扩展后的机制，那时将不仅仅是对象和数组字面量。但是不久后我们意识到[分配场所预占机制对真实世界应用产生了相当严重的负面影响](https://bugs.chromium.org/p/v8/issues/detail?id=3665)。我们实际上听到很多负面报道，包括 `Ember.js` 开发者和用户的唇枪舌战，虽然不仅是因为分配场所预占机制，不过它是事故的罪魁祸首。
分配场所预占机制的基本问题数之不尽，这在今天的应用中非常常见（主要是由于框架，同时还有其它原因），假设你的对象工厂最初是用于创建构成你的对象模型和视图的长周期对象的，它将你的工厂方法中的分配场所转换为永久状态，并且从工厂分配的所有内容都立即转到旧空间。现在初始设置完成后，你的应用开始工作，作为其中的一部分，从工厂分配临时对象会污染旧空间，最终导致开销昂贵的垃圾回收周期以及其它负面的副作用，例如过早触发增量标记。
我们开始重新考虑基准驱动的工作，并开始寻找现实场景驱动的替代方案，这导致了 [Orinoco](http://v8project.blogspot.de/2016/04/jank-busters-part-two-orinoco.html) 的诞生，它的目标是逐步改进垃圾回收器；这个努力的一部分是一个称为“<ruby> 统一堆 <rt> unified heap </rt></ruby>”的项目，如果页面中所有内容基本都存在，它将尝试避免复制对象。也就是说站在更高的层面看：如果新空间充满活动对象，只需将所有新空间页面标记为属于旧空间，然后从空白页面创建一个新空间。这可能不会在 `SplayLatency` 基准测试中得到相同的分数，但是这对于真实用例更友好，它可以自动适配具体的用例。我们还考虑<ruby> 并发标记 <rt> concurrent marking </rt></ruby>，将标记工作卸载到单独的线程，从而进一步减少增量标记对延迟和吞吐量的负面影响。
#### 轻松一刻
喘口气。
好吧，我想这足以强调我的观点了。我可以继续指出更多的例子，其中 Octane 驱动的改进后来变成了一个坏主意，也许改天我会接着写下去。但是今天就到此为止了吧。
### 结论
我希望现在应该清楚为什么基准测试通常是一个好主意，但是只对某个特定的级别有用，一旦你跨越了<ruby> 有用竞争 <rt> useful competition </rt></ruby>的界限，你就会开始浪费你们工程师的时间，甚至开始损害到你的真实世界的性能！如果我们认真考虑 web 的性能，我们需要根据真实世界的性能来测评浏览器，而不是它们玩弄一个四年前的基准的能力。我们需要开始教育（技术）媒体，可能这没用，但至少请忽略他们。
[](http://venturebeat.com/2016/10/25/browser-benchmark-battle-october-2016-chrome-vs-firefox-vs-edge/3/)
没人害怕竞争，但是玩弄可能已经坏掉的基准不像是在合理使用工程时间。我们可以尽更大的努力，并把 JavaScript 提高到更高的水平。让我们开展有意义的性能测试，以便为最终用户和开发者带来有意思的领域竞争。此外，让我们再对运行在 Node.js（ V8 或 `ChakraCore`）中的服务器端和工具端代码做一些有意义的改进！
结束语：不要用传统的 JavaScript 基准来比较手机。这是真正最没用的事情，因为 JavaScript 的性能通常取决于软件，而不一定是硬件，并且 Chrome 每 6 周发布一个新版本，所以你在三月份的测试结果到了四月份就已经毫不相关了。如果为手机中的浏览器做个排名不可避免，那么至少请使用一个现代健全的浏览器基准来测试，至少这个基准要知道人们会用浏览器来干什么，比如 [Speedometer 基准](http://browserbench.org/Speedometer)。
感谢你花时间阅读！
---
作者简介：
我是 Benedikt Meurer，住在 Ottobrunn（德国巴伐利亚州慕尼黑东南部的一个市镇）的一名软件工程师。我于 2007 年在锡根大学获得应用计算机科学与电气工程的文凭，打那以后的 5 年里我在编译器和软件分析领域担任研究员（2007 至 2008 年间还研究过微系统设计）。2013 年我加入了谷歌的慕尼黑办公室，我的工作目标主要是 V8 JavaScript 引擎，目前是 JavaScript 执行性能优化团队的一名技术领导。
---
via: <http://benediktmeurer.de/2016/12/16/the-truth-about-traditional-javascript-benchmarks>
作者：[Benedikt Meurer](http://benediktmeurer.de/) 译者：[OneNewLife](https://github.com/OneNewLife) 校对：[OneNewLife](https://github.com/OneNewLife), [wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
从 Node 到 Go：一个粗略的比较
|
John Stamatakos
|
https://medium.com/xo-tech/from-node-to-go-a-high-level-comparison-56c8b717324a#.byltlz535
|
这个帖子不是为了证明一种语言比另一种语言更好。由于各种原因，每种编程语言都在软件开发社区中占有一席之地。 我的意图是强调 Go 和 Node 之间的差异，并且促进展示一种新的 Web 开发语言。
|
/data/attachment/album/201709/30/210213z2e6jblskrsueuzr.jpg.thumb.jpg
|
/data/attachment/album/201709/30/210213z2e6jblskrsueuzr.jpg
| true | false | true |
trnhoe
| false |
[
"Node.JS",
"Golang"
] |
软件开发
|
{
"viewnum": 8233,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "58.19.1.26",
"message": "看不出来有什么意义的比较，Go的起源就是为解决服务器并发，借鉴了C/C++和JAVA的特性，天生的优势，不过话说回来，用GO怎么写GUI的问题还没解决",
"username": "mistyos [Firefox 55.0|GNU/Linux]",
"date": "2017-10-02T03:02:02"
}
] |
[] |
这个帖子不是为了证明一种语言比另一种语言更好。由于各种原因，每种编程语言都在软件开发社区中占有一席之地。 我的意图是强调 Go 和 Node 之间的差异，并且促进展示一种新的 Web 开发语言。
| 2017-10-01T08:46:00 | 2017-10-01T08:46:00 | 8,922 |
/article-8922-1.html
|
在 XO 公司，我们最初使用 Node 和 Ruby 构建相互连接的服务系统。我们享受 Node 带来的明显性能优势，以及可以访问已有的大型软件包仓库。我们也可以轻松地在公司内部发布并复用已有的插件和模块。极大地提高了开发效率，使得我们可以快速编写出可拓展的和可靠的应用。而且，庞大的 Node 社区使我们的工程师向开源软件贡献更加容易（比如 [BunnyBus](https://medium.com/xo-tech/bunnybus-building-a-data-transit-system-b9647f6283e5#.l64fdvfys) 和 [Felicity](https://medium.com/xo-tech/introducing-felicity-7b6d0b734ce#.hmloiiyx8)）。
虽然我在大学时期和刚刚工作的一些时间在使用更严谨的编译语言，比如 C++ 和 C#，而后来我开始使用 JavaScript。我很喜欢它的自由和灵活，但是我最近开始怀念静态和结构化的语言，因为当时有一个同事让我对 Go 语言产生了兴趣。
我从写 JavaScript 到写 Go，我发现两种语言有很多相似之处。两者学习起来都很快并且易于上手，都具有充满表现力的语法，并且在开发者社区中都有很多工作机会。没有完美的编程语言，所以你应该总是选择一个适合手头项目的语言。在这篇文章中，我将要说明这两种语言深层次上的关键区别，希望能鼓励没有用过 Go 语言的用户~~可以~~有机会使用 Go 。
### 大体上的差异
在深入细节之前，我们应该先了解一下两种语言之间的重要区别。
Go，或称 Golang，是 Google 在 2007 年创建的自由开源编程语言。它以快速和简单为设计目标。Go 被直接编译成机器码，这就是它速度的来源。使用编译语言调试是相当容易的，因为你可以在早期捕获大量错误。Go 也是一种强类型的语言，它有助于数据完整，并可以在编译时查找类型错误。
另一方面，JavaScript 是一种弱类型语言。除了忽略验证数据的类型和真值判断陷阱所带来的额外负担之外，使用弱类型语言也有自己的好处。比起使用<ruby> 接口 <rt> interfaces </rt></ruby>和<ruby> 范型 <rt> generics </rt></ruby>，<ruby> 柯里化 <rt> currying </rt></ruby>和<ruby> 可变的形参个数 <rt> flexible arity </rt></ruby>让函数变得更加灵活。JavaScript 在运行时进行解释，这可能导致错误处理和调试的问题。Node 是一款基于 Google V8 虚拟机的 JavaScript 运行库，这使它成为一个轻量和快速的 Web 开发平台。
### 语法
作为原来的 JavaScript 开发者，Go 简单和直观的语法很吸引我。由于两种语言的语法可以说都是从 C 语言演变而来的，所以它们的语法有很多相同之处。Go 被普遍认为是一种“容易学习的语言”。那是因为它的对开发者友好的工具、精简的语法和固守惯例（LCTT 译注：惯例优先）。
Go 包含大量有助于简化开发的内置特性。你可以用标准 Go 构建工具把你的程序用 `go build` 命令编译成二进制可执行文件。使用内置的测试套件进行测试只需要运行 `go test` 即可。 诸如原生支持的并发等特性甚至在语言层面上提供。
[Google 的 Go 开发者](https://golang.org/doc/faq)认为，现在的编程太复杂了，太多的“记账一样，重复劳动和文书工作”。这就是为什么 Go 的语法被设计得如此简单和干净，以减少混乱、提高效率和增强可读性。它还鼓励开发人员编写明确的、易于理解的代码。Go 只有 [25 个保留关键字](https://golang.org/ref/spec#Keywords)和一种循环（`for` 循环），而不像 JavaScript 有 [大约 84 个关键字](https://www.w3schools.com/js/js_reserved.asp)（包括保留关键字字、对象、属性和方法）。
为了说明语法的一些差异和相似之处，我们来看几个例子：
* 标点符号： Go 去除了所有多余的符号以提高效率和可读性。尽管 JavaScript 中需要符号的地方也不多（参见： [Lisp](https://en.wikipedia.org/wiki/Lisp_%28programming_language%29)），而且经常是可选的，但我更加喜欢 Go 的简单。
```
// JavaScript 的逗号和分号
for (var i = 0; i < 10; i++) {
console.log(i);
}
```
*JavaScript 中的标点*
```
// Go 使用最少数量标点
for i := 0; i < 10; i++ {
fmt.Println(i)
}
```
*Go 中的标点*
* 赋值：由于 Go 是强类型语言，所以你在初始化变量时可以使用 `:=` 操作符来进行类型推断，以避免[重复声明](https://golang.org/doc/faq#principles)，而 JavaScript 则在运行时声明类型。
```
// JavaScript 赋值
var foo = "bar";
```
*JavaScript 中的赋值*
```
// Go 的赋值
var foo string //不使用类型推导
foo = "bar"
foo := "bar" //使用类型推导
```
*Go 的赋值*
* 导出：在 JavaScript 中，你必须从某个模块中显式地导出。 在 Go 中，任何大写的函数将被默认导出。
```
const Bar = () => {};
module.exports = {
Bar
}
```
*JavaScript 中的导出*
```
// Go 中的导出
package foo // 定义包名
func Bar (s string) string {
// Bar 将被导出
}
```
*Go 中的导出*
* 导入：在 JavaScript 中 `required` 库是导入依赖项和模块所必需的，而 Go 则利用原生的 `import` 关键字通过包的路径导入模块。另一个区别是，与 Node 的中央 NPM 存储库不同，Go 使用 URL 作为路径来导入非标准库的包，这是为了从包的源码仓库直接克隆依赖。
```
// Javascript 的导入
var foo = require('foo');
foo.bar();
```
*JavaScript 的导入*
```
// Go 的导入
import (
"fmt" // Go 的标准库部分
"github.com/foo/foo" // 直接从仓库导入
)
foo.Bar()
```
*Go 的导入*
* 返回值：通过 Go 的多值返回特性可以优雅地传递和处理返回值和错误，并且通过传递引用减少了不正确的值传递。在 JavaScript 中需要通过一个对象或者数组来返回多个值。
```
// Javascript - 返回多值
function foo() {
return {a: 1, b: 2};
}
const { a, b } = foo();
```
*JavaScript 的返回*
```
// Go - 返回多值
func foo() (int, int) {
return 1, 2
}
a, b := foo()
```
*Go 的返回*
* 错误处理：Go 推荐在错误出现的地方捕获它们，而不是像 Node 一样在回调中让错误冒泡。
```
// Node 的错误处理
foo('bar', function(err, data) {
// 处理错误
}
```
*JavaScript 的错误处理*
```
//Go 的错误处理
foo, err := bar()
if err != nil {
// 用 defer、 panic、 recover 或 log.fatal 等等处理错误.
}
```
*Go 的错误处理*
* 可变参数函数：Go 和 JavaScript 的函数都支持传入不定数量的参数。
```
function foo (...args) {
console.log(args.length);
}
foo(); // 0
foo(1, 2, 3); // 3
```
*JavaScript 中的可变参数函数*
```
func foo (args ...int) {
fmt.Println(len(args))
}
func main() {
foo() // 0
foo(1,2,3) // 3
}
```
*Go 中的可变参数函数*
### 社区
当比较 Go 和 Node 提供的编程范式哪种更方便时，两边都有不同的拥护者。Node 在软件包数量和社区的大小上完全胜过了 Go。Node 包管理器（NPM），是世界上最大的软件仓库，拥有[超过 410,000 个软件包，每天以 555 个新软件包的惊人速度增长](http://www.modulecounts.com/)。这个数字可能看起来令人吃惊（确实是），但是需要注意的是，这些包许多是重复的，且质量不足以用在生产环境。 相比之下，Go 大约有 13 万个包。
*Node 和 Go 包的数量*
尽管 Node 和 Go 岁数相仿，但 JavaScript 使用更加广泛，并拥有巨大的开发者和开源社区。因为 Node 是为所有人开发的，并在开始的时候就带有一个强壮的包管理器，而 Go 是特地为 Google 开发的。下面的[Spectrum 排行榜](http://spectrum.ieee.org/static/interactive-the-top-programming-languages-2016)显示了当前流行的的顶尖 Web 开发语言。
*Web 开发语言排行榜前 7 名*
JavaScript 的受欢迎程度近年来似乎保持相对稳定，而 [Go 一直在保持上升趋势](http://www.tiobe.com/tiobe-index/)。
*编程语言趋势*
### 性能
如果你的主要关注点是速度呢？当今似乎人们比以前更重视性能的优化。用户不喜欢等待信息。 事实上，如果网页的加载时间超过 3 秒，[40％ 的用户会放弃访问您的网站](https://hostingfacts.com/internet-facts-stats-2016/)。
因为它的非阻塞异步 I/O，Node 经常被认为是高性能的语言。另外，正如我之前提到的，Node 运行在针对动态语言进行了优化的 Google V8 引擎上。而 Go 的设计也考虑到速度。[Google 的开发者们](https://golang.org/doc/faq)通过建立了一个“充满表现力而轻量级的类型系统；并发和垃圾回收机制；强制地指定依赖版本等等”，达成了这一目标。
我运行了一些测试来比较 Node 和 Go 之间的性能。这些测试注重于语言提供的初级能力。如果我准备测试例如 HTTP 请求或者 CPU 密集型运算，我会使用 Go 语言级别的并发工具（goroutines/channels）。但是我更注重于各个语言提供的基本特性（参见 [三种并发方法](https://medium.com/xo-tech/concurrency-in-three-flavors-51ed709876fb#.khvqrttxa) 了解关于 goroutines 和 channels 的更多知识）。
我在基准测试中也加入了 Python，所以无论如何我们对 Node 和 Go 的结果都很满意。
#### 循环/算术
迭代十亿项并把它们相加：
```
var r = 0;
for (var c = 0; c < 1000000000; c++) {
r += c;
}
```
*Node*
```
package main
func main() {
var r int
for c := 0; c < 1000000000; c++ {
r += c
}
}
```
*Go*
```
sum(xrange(1000000000))
```
*Python*
*结果*
这里的输家无疑是 Python，花了超过 7 秒的 CPU 时间。而 Node 和 Go 都相当高效，分别用了 900 ms 和 408 ms。
*修正：由于一些评论表明 Python 的性能还可以提高。我更新了结果来反映这些变化。同时，使用 PyPy 大大地提高了性能。当使用 Python 3.6.1 和 PyPy 3.5.7 运行时，性能提升到 1.234 秒，但仍然不及 Go 和 Node 。*
#### I/O
遍历一百万个数字并将其写入一个文件。
```
var fs = require('fs');
var wstream = fs.createWriteStream('node');
for (var c = 0; c < 1000000; ++c) {
wstream.write(c.toString());
}
wstream.end();
```
*Node*
```
package main
import (
"bufio"
"os"
"strconv"
)
func main() {
file, _ := os.Create("go")
b := bufio.NewWriter(file)
for c := 0; c < 1000000; c++ {
num := strconv.Itoa(c)
b.WriteString(num)
}
file.Close()
}
```
*Go*
```
with open("python", "a") as text_file:
for i in range(1000000):
text_file.write(str(i))
```
*Python*
*结果*
Python 以 7.82 秒再次排名第三。 这次测试中，Node 和 Go 之间的差距很大，Node 花费大约 1.172 秒，Go 花费了 213 毫秒。真正令人印象深刻的是，Go 大部分的处理时间花费在编译上。如果我们将代码编译，以二进制运行，这个 I/O 测试仅花费 78 毫秒——要比 Node 快 15 倍。
*修正：修改了 Go 代码以实现缓存 I/O。*
#### 冒泡排序
将含有十个元素的数组排序一千万次。
```
function bubbleSort(input) {
var n = input.length;
var swapped = true;
while (swapped) {
swapped = false;
for (var i = 0; i < n; i++) {
if (input[i - 1] > input [i]) {
[input[i], input[i - 1]] = [input[i - 1], input[i]];
swapped = true;
}
}
}
}
for (var c = 0; c < 1000000; c++) {
const toBeSorted = [1, 3, 2, 4, 8, 6, 7, 2, 3, 0];
bubbleSort(toBeSorted);
}
```
*Node*
```
package main
var toBeSorted [10]int = [10]int{1, 3, 2, 4, 8, 6, 7, 2, 3, 0}
func bubbleSort(input [10]int) {
n := len(input)
swapped := true
for swapped {
swapped = false
for i := 1; i < n; i++ {
if input[i-1] > input[i] {
input[i], input[i-1] = input[i-1], input[i]
swapped = true
}
}
}
}
func main() {
for c := 0; c < 1000000; c++ {
bubbleSort(toBeSorted)
}
}
```
*Go*
```
def bubbleSort(input):
length = len(input)
swapped = True
while swapped:
swapped = False
for i in range(1,length):
if input[i - 1] > input[i]:
input[i], input[i - 1] = input[i - 1], input[i]
swapped = True
for i in range(1000000):
toBeSorted = [1, 3, 2, 4, 8, 6, 7, 2, 3, 0]
bubbleSort(toBeSorted)
```
*Python*
*结果*
像刚才一样，Python 的表现是最差的，大约花费 15 秒完成了任务。 Go 完成任务的速度是 Node 的 16 倍。
#### 判决
Go 无疑是这三个测试中的赢家，而 Node 大部分表现都很出色。Python 也表现不错。要清楚，性能不是选择编程语言需要考虑的全部内容。如果您的应用不需要处理大量数据，那么 Node 和 Go 之间的性能差异可能是微不足道的。 有关性能的一些其他比较，请参阅以下内容：
* [Node Vs. Go](https://jaxbot.me/articles/node-vs-go-2014)
* [Multiple Language Performance Test](https://hashnode.com/post/comparison-nodejs-php-c-go-python-and-ruby-cio352ydg000ym253frmfnt70)
* [Benchmarks Game](https://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=go&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lang2=node)
### 结论
这个帖子不是为了证明一种语言比另一种语言更好。由于各种原因，每种编程语言都在软件开发社区中占有一席之地。 我的意图是强调 Go 和 Node 之间的差异，并且促进展示一种新的 Web 开发语言。 在为一个项目选择语言时，有各种因素需要考虑，比如开发人员的熟悉程度、花费和实用性。 我鼓励在决定哪种语言适合您时进行一次彻底的底层分析。
正如我们所看到的，Go 有如下的优点：接近底层语言的性能，简单的语法和相对简单的学习曲线使它成为构建可拓展和安全的 Web 应用的理想选择。随着 Go 的使用率和社区活动的快速增长，它将会成为现代网络开发中的重要角色。话虽如此，我相信如果 Node 被正确地实现，它正在向正确的方向努力，仍然是一种强大而有用的语言。它具有大量的追随者和活跃的社区，使其成为一个简单的平台，可以让 Web 应用在任何时候启动和运行。
### 资料
如果你对学习 Go 语言感兴趣，可以参阅下面的资源：
* [Golang 网站](https://golang.org/doc/#learning)
* [Golang Wiki](https://github.com/golang/go/wiki/Learn)
* [Golang Subreddit](https://www.reddit.com/r/golang/)
---
via: <https://medium.com/xo-tech/from-node-to-go-a-high-level-comparison-56c8b717324a#.byltlz535>
作者：[John Stamatakos](https://medium.com/@johnstamatakos?source=post_header_lockup) 译者：[trnhoe](https://github.com/trnhoe) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
2700 万美金：阿里巴巴领投 MariaDB
|
Jon Russell
|
https://techcrunch.com/2017/09/29/alibaba-mariadb/
|
据知情人士透露，这家中国的电子商务巨头同意对 MariaDB 领投 2290 万欧元（2700 万美元）
|
/data/attachment/album/201710/01/232254qf58x5ufed4uz407.jpg.thumb.jpg
|
/data/attachment/album/201710/01/232254qf58x5ufed4uz407.jpg
| true | false | true |
wxy
| false |
[
"MariaDB",
"阿里巴巴"
] |
新闻
|
{
"viewnum": 5411,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
据知情人士透露，这家中国的电子商务巨头同意对 MariaDB 领投 2290 万欧元（2700 万美元）
| 2017-10-01T23:23:00 | 2017-10-01T23:23:00 | 8,924 |
/article-8924-1.html
|
阿里巴巴在 2017 年一直努力推进其云计算业务，而现在它将首次对该领域的一家西方初创公司做出重大投资。
据知情人士透露，这家中国的电子商务巨头同意对 MariaDB 领投 2290 万欧元（2700 万美元）。MariaDB 是一家欧洲公司，其开发维护的 mariadb 数据库是最受欢迎的开源数据库之一。该交易仍未完成，但在本周 MariaDB 股东批准之后有望很快完成。
阿里巴巴和 MariaDB 均未对此置评。
据悉，阿里巴巴本次将投资 2000 万欧元，而剩余部分将由 MariaDB 现有股东追加投资。该交易将使 MariaDB 的估值达到 3 亿欧元（约合 3.54 亿美元），而阿里巴巴的云业务部门的首席工程师余锋将加入该公司董事会。
今年五月份 MariaDB 从欧洲投资银行[募集到的 2500 万欧元（当时价值 2700 万美元）](https://techcrunch.com/2017/05/08/open-source-database-developer-mariadb-picks-up-27m-from-the-eib/)，当时估值越 2 亿至 2.5 亿美元，此次估值较之前次大为提高。据悉阿里巴巴非常希望完成该笔投资，因此几乎允许 MariaDB 对其出让的股份自行开价。
MariaDB 最常用作流行的数据库 MySQL 的替代品，二者都是开源产品，但有些人对 MySQL 心存疑虑，因为它现在属于 Oracle 公司。
### 关于阿里巴巴
阿里巴巴的云计算业务是其增长最快的业务单元，在去年其达到了三位数的营收增长。
[我们今年早些时候的文章提到过](https://techcrunch.com/2017/02/27/alibaba-aliyun-cloud-computing/)，它现在正在努力与该行业最大的竞争对手，如 AWS、微软 Azure 和谷歌云展开竞争。虽然这还有一些路要走，但迹象表明还是有希望的。阿里云业务在最近一个财年的营收达到了 10 亿美元，前一个季度超过了 100 万个用户。该业务最近几个季度将可能达到收支平衡，虽然其目前只占了阿里巴巴全部业务营收的不到 5%。
云是阿里巴巴正在重点发展领域之一，因为它看起来将是新的收入来源之一，这可以让它摆脱对其核心的中国电子商务业务的依赖——[尽管它目前仍然带来了大量利润](https://techcrunch.com/2017/08/17/alibaba-profit-doubles-to-2-1b/)。
该公司也在其它领域展开了大量投资，比如对印度的独角兽公司 [Paytm](https://techcrunch.com/2017/03/06/alibaba-paytm-amazon-india/) 和东南亚的 [Lazada](https://techcrunch.com/2017/06/28/alibaba-ups-its-stake-in-southeast-asias-lazada-with-1-billion-investment/) 和 [Tokopedia](https://techcrunch.com/2017/08/17/alibaba-tokopedia/) 的投资，所以对更大范围的云和基础架构领域进行投资、以推进其战略也并不为奇。
对中国同领域的公司，如[云存储厂商七牛](http://www.avcj.com/avcj/news/3006331/yunfeng-alibaba-invest-usd152m-in-chinese-cloud-storage-firm)和[大数据公司数梦工场](http://technode.com/2017/06/12/chinas-cloud-industry-moving-to-new-era-with-emergence-of-unicorns/)进行投资，以及[加入微软的开源社区](https://venturebeat.com/2017/04/03/alibaba-cloud-adopts-microsofts-open-source-networking-software/)，甚至[在中国直接和 MariaDB 进行合作](http://diginomica.com/2017/04/12/alibaba-on-open-source-and-cloud-business-in-china-live-from-the-mariadb-user-conference/)，这些都使阿里巴巴在海外市场备受关注。
### 关于 MariaDB
以前名为 SkySQL 的 MariaDB 由于其在该行业的地位而备受阿里巴巴关注。它在瑞典和美国设有办事处，其声称已经服务了全球 1200 万数据库用户，这其中包括一些著名公司，如 Booking.com、HP、 Virgin Mobile 和维基。其解决方案用在私有云、公有云和混合云部署中，它是包括 Red Hat、Ubuntu 和 SUSE 在内的大量 Linux 发行版的默认数据库软件，这会为其进一步增加 6000 万用户。
SkySQL 最初创立于 2009 年，并于 2013 年与 Monty Program Ab 合并，后者是 Michael ‘Monty’ Widenius 在 2008 年将其公司 MySQL 以 10 亿美金卖给了太阳微系统公司（现在属于 Oracle）后创立的。由于担心 Oracle 对 MySQL 的一些做法，MariaDB 数据库后来从 MySQL 数据库中分支而来。
|
||
编排工具充分发挥了 Linux 容器技术优势
|
Scott Mccarty
|
https://www.infoworld.com/article/3205304/containers/orchestration-tools-enable-companies-to-fully-exploit-linux-container-technology.html
|
一旦公司越过了“让我们看看这些容器如何工作”的阶段，他们最终会在许多不同的地方运行容器
|
/data/attachment/album/201710/02/150503qcqfkhaaubkyu9q4.jpg.thumb.jpg
|
/data/attachment/album/201710/02/150503qcqfkhaaubkyu9q4.jpg
| true | false | true |
geekpi
| false |
[
"容器",
"编排"
] |
容器与云
|
{
"viewnum": 5050,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
一旦公司越过了“让我们看看这些容器如何工作”的阶段，他们最终会在许多不同的地方运行容器
| 2017-10-02T15:05:00 | 2017-10-02T15:05:00 | 8,925 |
/article-8925-1.html
|
>
> 一旦公司越过了“让我们看看这些容器如何工作”的阶段，他们最终会在许多不同的地方运行容器
>
>
>
需要快速、高效地交付程序的公司 —— 而今天，哪些公司不需要这样做？—— 是那些正在转向 Linux 容器的公司。他们还发现，一旦公司越过了“让我们看看这些容器如何工作”的阶段，他们最终会在许多不同的地方运行容器。
Linux 容器技术不是新技术，但它随着最初由 Docker 发明的创新性打包格式（现在的 [OCI](https://github.com/opencontainers/image-spec) 格式）以及新应用对持续开发和部署的需求开始变得流行。在 Red Hat 的 2016 年 5 月的 Forrester 研究中，有 48％ 的受访者表示已经在开发中使用容器，今年的数字预计将达到 53％。只有五分之一的受访者表示，他们在 2017 年不会在开发过程中利用容器。
像乐高积木一样，容器镜像可以轻松地重用代码和服务。每个容器镜像就像一个单独的、旨在做好一部分工作的乐高积木。它可能是数据库、数据存储、甚至预订服务或分析服务。通过单独包装每个组件，从而可以在不同的应用中使用。但是，如果没有某种程序定义（即<ruby> 指令手册 <rt> instruction booklet </rt></ruby>），则难以在不同环境中创建完整应用程序的副本。那就是容器编排的来由。
容器编排提供了像乐高系统这样的基础设施 —— 开发人员可以提供如何构建应用程序的简单说明。编排引擎将知道如何运行它。这使得可以轻松创建同一应用程序的多个副本，跨越开发人员电脑、CI/CD 系统，甚至生产数据中心和云提供商环境。
Linux 容器镜像允许公司在整个运行时环境（操作系统部件）中打包和隔离应用程序的构建块。在此基础上，通过容器编排，可以很容易地定义并运行所有的块，并一起构成完整的应用程序。一旦定义了完整的应用程序，它们就可以在不同的环境（开发、测试、生产等）之间移动，而不会破坏它们，且不改变它们的行为。
### 仔细调查容器
很明显，容器是有意义的，越来越多的公司像“对轮胎踹两脚”一样去研究容器。一开始，可能是一个开发人员使用一个容器工作，或是一组开发人员在使用多个容器。在后一种情况下，开发人员可能会随手编写一些代码来处理在容器部署超出单个实例之后快速出现的复杂性。
这一切都很好，毕竟他们是开发人员 —— 他们已经做到了。但即使在开发人员世界也会变得混乱，而且随手代码模式也没法跟着容器进入 QA 和生产环境下。
编排工具基本上做了两件事。首先，它们帮助开发人员定义他们的应用程序的表现 —— 一组用来构建应用程序实例的服务 —— 数据库、数据存储、Web 服务等。编排器帮助标准化应用程序的所有部分，在一起运行并彼此通信，我将这称之为标准化程序定义。其次，它们管理一个计算资源集群中启动、停止、升级和运行多个容器的过程，这在运行任何给定应用程序的多个副本时特别有用，例如持续集成 （CI） 和连续交付 （CD）。
想像一个公寓楼。居住在那里的每个人都有相同的街道地址，但每个人都有一个数字或字母或两者的组合，专门用来识别他或她。这是必要的，就像将正确的邮件和包裹交付给合适的租户一样。
同样，在容器中，只要你有两个容器或两个要运行这些容器的主机，你必须跟踪开发人员测试数据库连接或用户连接到正在运行的服务的位置。容器编排工具实质上有助于管理跨多个主机的容器的后勤。它们将生命周期管理功能扩展到由多个容器组成的完整应用程序，部署在一组机器上，从而允许用户将整个集群视为单个部署目标。
这真的很简单，又很复杂。编排工具提供了许多功能，从配置容器到识别和重新调度故障容器，将容器暴露给集群外的系统和服务，根据需要添加和删除容器等等。
虽然容器技术已经存在了一段时间，但容器编排工具只出现了几年。编排工具是 Google 从内部的高性能计算（HPC）和应用程序管理中吸取的经验教训开发的。在本质上，其要解决的就是在一堆服务器上运行一堆东西（批处理作业、服务等）。从那时起，编排工具已经进化到可以使公司能够战略性地利用容器。
一旦你的公司确定需要容器编排，下一步就是确定哪个平台对于业务是最有意义的。在评估容器编排时，请仔细查看（尤其）：
* 应用程序定义语言
* 现有能力集
* 添加新功能的速度
* 开源还是专有
* 社区健康度（成员的积极性/高效，成员提交的质量/数量，贡献者的个人和公司的多样性）
* 强化努力
* 参考架构
* 认证
* 产品化过程
有三个主要的容器编排平台，它们似乎领先于其他，每个都有自己的历史。
1. **Docker Swarm：** Swarm 是容器典范 Docker 的附件。Swarm 允许用户建立并管理 Docker 节点的集群为单个虚拟系统。Swarm 似乎正在成为一个单一供应商的项目。
2. **Mesos：** Mesos 是从 Apache 和高性能计算中成长起来的，因此是一个优秀的调度员。Mesos 的技术也非常先进，虽然与其他相比似乎没有发展速度或投资优势。
3. **Kubernetes：** 由 Google 开发，由其内部编排工具 Borg 经验而来，Kubernetes 被广泛使用，并拥有强大的社区。其实这是 GitHub 上排名第一的项目。Mesos 目前可能比 Kubernetes 略有技术优势，但是 Kubernetes 是一个快速发展的项目，这也是为了长期技术上的收益而进行的架构投资。在不久的将来，在技术能力上应该能赶超 Mesos。
### 编排的未来
展望未来，企业们可以期待看到编排工具在应用程序和服务为中心的方向上发展。因为在现实中，如今快速应用程序开发实际上是在快速地利用服务、代码和数据的组合。无论这些服务是开源的，还是由内部团队部署的抑或从云提供商处购买的，未来将会是两者的混合。由于今天的编排器也在处理应用程序定义方面的挑战，所以期望看到它们越来越多地应对外部服务的整合。
此时此刻，想要充分利用容器的公司必须利用容器编排。
（题图：Thinkstock）
---
via: <https://www.infoworld.com/article/3205304/containers/orchestration-tools-enable-companies-to-fully-exploit-linux-container-technology.html>
作者：[Scott McCarty](https://www.infoworld.com/author/Scott-McCarty/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
LFCS 基础：sed 命令
|
Jarret B
|
https://www.linux.org/threads/lfcs-sed-command.4561/
|
“sed” 命令是一个可以将文件作为流进行编辑的编辑器。流式传输文件的方法是从另一个命令使用管道（> 或 |）传递，或将其直接加载到 “sed” 中。
|
/data/attachment/album/201710/02/155653hvvvvdgfgzfv7isg.jpg.thumb.jpg
|
/data/attachment/album/201710/02/155653hvvvvdgfgzfv7isg.jpg
| true | false | true |
geekpi
| false |
[
"sed"
] |
技术
|
{
"viewnum": 4964,
"commentnum": 0,
"favtimes": 5,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
“sed” 命令是一个可以将文件作为流进行编辑的编辑器。流式传输文件的方法是从另一个命令使用管道（> 或 |）传递，或将其直接加载到 “sed” 中。
| 2017-10-02T15:57:20 | 2017-10-02T15:57:20 | 8,926 |
/article-8926-1.html
|
Linux 基金会认证系统管理员（LFCS）的另一个有用的命令是 “sed”，最初表示<ruby> “流式编辑器” <rp> （ </rp> <rt> Streaming EDitor </rt> <rp> ） </rp></ruby>。
“sed” 命令是一个可以将文件作为流进行编辑的编辑器。流式传输文件的方法是从另一个命令使用管道（`>` 或 `|`）传递，或将其直接加载到 “sed” 中。
该命令的工作方式与其他编辑器相同，只是文件不显示，也不允许可视化编辑。命令被传递给 “sed” 来操纵流。
用 “sed” 可以做五件基本的事。当然，“sed” 如此强大，还有其他高级的功能，但你只需要集中精力在五件基本的事上。五种功能类型如下：
1. 搜索
2. 替换
3. 删除
4. 添加
5. 改变/变换
在深入命令参数之前，我们需要看看基本的语法。
### 语法
“sed” 命令的语法是：
```
sed [选项] 命令 [要编辑的文件]
```
本文将在适当的部分中介绍这些“选项”。“命令”可以是正则表达式的搜索和替换模式。请继续阅读了解 “sed” 如何工作的并学习基本命令。正如我之前提到的，“sed” 是一个非常强大的工具，有更多的选项可用，我将在本文中介绍。
### 示例文件
如果你打开一个终端，那你可以创建一个用于 “sed” 示例的文件。执行以下命令：
```
cd ~
grep --help >grephelp.txt
```
你现在应该在 HOME 文件夹中有一个名为 `grephelp.txt` 的文件。该文件的内容是 `grep` 命令的帮助说明。
### 搜索
搜索特定字符串是编辑器的常见功能，在 “sed” 中执行搜索也不例外。
执行搜索以在文件中查找字符串。我们来看一下基本的搜索。
如果我们想在示例文件搜索 `PATTERN` 这个词，我们将使用如下命令：
```
sed -n 's/PATTERN/PATTERN/p' grephelp.txt
```
**注意：** 如果剪切粘贴命令，请确保将单引号替换为键盘上的标准单引号。
参数 `-n` 用于抑制每行的自动打印（除了用 `p` 命令指定的行）。默认情况下，流入 “sed” 的每一行将被打印到标准输出（stdout）。如果你不使用 “-n” 选项运行上述命令，你将看到原始文件的每一行以及匹配的行。
要搜索的文件名是我们在“示例文件”部分中创建的 “grephelp.txt”。
剩下的部分是 `'s/PATTERN/PATTERN/p'` 。这一段基本分为四个部分。第一部分的 `s` 指定执行替换，或搜索并替换。
剩下的第二部分和第三部分是模式。第一个是要搜索的模式，最后一个是替换流中匹配字符串的模式。此例中，我们找到字符串 `PATTERN`，并用 `PATTERN` 替换。通过查找和替换相同的字符串，我们完全不会更改文件，甚至在屏幕上也一样。
最后一个命令是 `p`。 它指定在替换后打印新行。当然，因为替换的是相同的字符串，所以没有改变。由于我们使用 `-n` 参数抑制打印行，所以更改的行将使用 `p` 命令打印。
这个完整的命令允许我们执行搜索并查看匹配的结果。
### 替换
当搜索特定字符串时，你可能希望用匹配的字符串替换新字符串。用另一个字符串替换是很常见的操作。
我们可以使用以下命令执行相同的搜索：
```
sed -n 's/PATTERN/Pattern/p' grephelp.txt
```
在这时，字符串 “PATTERN” 变为 “Pattern” 并显示。如果你使用命令 `cat grephelp.txt` 查看文件，你会看到该文件没有更改。该更改仅对屏幕上的输出进行。你可以使用以下命令将输出通过管道传输到另一个文件：
```
sed 's/PATTERN/Pattern/' grephelp.txt > grephelp1.txt
```
现在将存在一个名为 `grephelp1.txt` 的新文件，其中保存了更改的文件。如果 `p` 作为第四个选项留下，那么有个问题是被替换的字符串的每一行将在文件中重复两次。我们也可以删除 “-n” 参数以允许所有的行打印。
使用相同字符串替换字符串的另一种方法是使用 `&` 符号来表示搜索字符串。例如，命令 `s/PATTERN/&/p` 效果是一样的。我们可以添加字符串，例如添加 `S`，可以使用命令 `s/PATTERN/&S/p`。
如果我们希望在每一行中只替换某种模式呢？可以指定要替换的匹配项的特定出现。当然，每一行的替换都是一个特定的编号。例如，示例文件上有很多破折号。一些行至少有两条破折号，所以我们可以用另一个字符代替每一行的第二个破折号。每行用星号 `*` 替换第二个破折号 `-` 的命令将是：
```
sed 's/-/*/2' grephelp.txt
```
在这里，我们用最初的 `s` 来执行替换。字符 `-` 被替换为 `*`。`2` 表示我们想要替换每行上的第二个 `-`（如果存在）。如果我们忽略了命令 `2`，则替换第一次出现的破折号。只有第一个破折号而不是每行的破折号都被替换。
如果要搜索并替换带有星号的行上的所有破折号，请使用 `g` 命令：
```
sed 's/-/*/g' grephelp.txt
```
命令也可以组合。假设你想要替换从第二次开始出现的破折号，命令将是：
```
sed 's/-/*/2g' grephelp.txt
```
现在从第二个开始出现的破折号将被星号取代。
### 删除
搜索过程中有很多时候你可能想要完全删除搜索字符串。
例如，如果要从文件中删除所有破折号，你可以使用以下命令：
```
sed 's/-//g' grephelp.txt
```
替换字符串为空白，因此匹配的字符串将被删除。
### 添加
当找到匹配时，你可以添加一行特定的文本，来使这行在浏览或打印中突出。
如果要在匹配后插入新行，那么使用 `a` 命令，后面跟上新行的字符串。还包括要匹配的字符串。例如，我们可以找到一个 `--`，并在匹配的行之后添加一行。新行的字符串将是 `double dash before this line`。
```
sed '/--/ a "double dash before this line"' grephelp.txt
```
如果要在包含匹配字符串的行之前加上这行，请使用 `i` 命令，如下所示：
```
sed '/--/ i "double dash after this line"' grephelp.txt
```
### 改变/变换
如果需要改变/变换一行，则可以使用命令 `c`。
假设我们有个有一些私人信息的文档，我们需要更改包含特定字符串的行。`c` 命令将改变整行，而不仅仅是搜索字符串。
假设我们想要阻止示例文件中包含单词 `PATTERN` 的每一行。更改的行将显示为 `This line is Top Secret`。命令是：
```
sed '/PATTERN/ c This line is Top Secret' grephelp.txt
```
可以进行更改特定字母的大小写的转换。例如，我们可以使用命令 `y` 将所有小写 `a` 更改为大写 `A`，如下所示：
```
sed 'y/a/A/' grephelp.txt
```
可以指定多个字母，如 `abdg`，如下命令所示：
```
sed 'y/abdg/ABDG/' grephelp.txt
```
确保第二组字母与第一组字母的顺序相同，否则会被替换和转换。例如，字符串 `y/a/D/` 将用大写 `D` 替换所有小写的 `a`。
### 就地更改
如果你确实要更改所使用的文件，请使用 `-i` 选项。
例如，要将 `PATTERN` 改为 `Pattern`，并对文件进行更改，则命令为：
```
sed -i 's/PATTERN/Pattern/' grephelp.txt
```
现在文件 `grephelp.txt` 将被更改。`-i` 选项可以与上述任何命令一起使用来更改原始文件的内容。
练习这些命令，并确保你理解它们。“sed” 命令非常强大。
（题图：Pixabay，CC0）
---
via: <https://www.linux.org/threads/lfcs-sed-command.4561/>
作者：[Jarret B](https://www.linux.org/threads/lfcs-sed-command.4561/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
GitHub 的 MySQL 基础架构自动化测试
|
Tomkrouper，shlomi Noach
|
https://githubengineering.com/mysql-testing-automation-at-github/
|
我们建有基础架构来自动化测试这些操作，在这篇文章中，我们将分享几个例子，来说明我们是如何通过持续测试打造我们的基础架构的。这是让我们一梦到天亮的根本保障。
|
/data/attachment/album/201710/03/120948wz4d0xvwq4w0vwxi.jpg.thumb.jpg
|
/data/attachment/album/201710/03/120948wz4d0xvwq4w0vwxi.jpg
| true | false | true |
MonkeyDEcho
| false |
[
"MySQL",
"GitHub",
"测试"
] |
技术
|
{
"viewnum": 5533,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们建有基础架构来自动化测试这些操作，在这篇文章中，我们将分享几个例子，来说明我们是如何通过持续测试打造我们的基础架构的。这是让我们一梦到天亮的根本保障。
| 2017-10-03T12:10:00 | 2017-10-03T12:10:00 | 8,927 |
/article-8927-1.html
|
我们 MySQL 数据库基础架构是 Github 关键组件。 MySQL 提供 Github.com、 GitHub 的 API 和验证等等的服务。每一次的 `git` 请求都以某种方式触及 MySQL。我们的任务是保持数据的可用性，并保持其完整性。即使我们 MySQL 集群是按流量分配的，但是我们还是需要执行深度清理、即时更新、在线<ruby> 模式 <rt> schema </rt></ruby>迁移、集群拓扑重构、<ruby> 连接池化 <rt> pooling </rt></ruby>和负载平衡等任务。 我们建有基础架构来自动化测试这些操作，在这篇文章中，我们将分享几个例子，来说明我们是如何通过持续测试打造我们的基础架构的。这是让我们一梦到天亮的根本保障。
### 备份
没有比备份数据更重要的了，如果您没有备份数据库，在它出事前这可能并不是什么问题。Percona 的 [Xtrabackup](https://www.percona.com/software/mysql-database/percona-xtrabackup) 是我们一直用来完整备份 MySQL 数据库的工具。如果有专门需要备份的数据，我们就会备份到另一个专门备份数据的服务器上。
除了完整的二进制备份外，我们每天还会多次运行逻辑备份。这些备份数据可以让我们的工程师获取到最新的数据副本。有时候，他们希望从表中获取一整套数据，以便他们可以在一个生产级规模的表上测试索引的修改，或查看特定时间以来的数据。Hubot 可以让我们恢复备份的表，并且当表准备好使用时会通知我们。
**tomkrouper**
```
.mysql backup-list locations
```
**Hubot**
```
+-----------+------------+---------------+---------------------+---------------------+----------------------------------------------+
| Backup ID | Table Name | Donor Host | Backup Start | Backup End | File Name |
+-----------+------------+---------------+---------------------+---------------------+----------------------------------------------+
| 1699494 | locations | db-mysql-0903 | 2017-07-01 22:09:17 | 2017-07-01 22:09:17 | backup-mycluster-locations-1498593122.sql.gz |
| 1699133 | locations | db-mysql-0903 | 2017-07-01 16:11:37 | 2017-07-01 16:11:39 | backup-mycluster-locations-1498571521.sql.gz |
| 1698772 | locations | db-mysql-0903 | 2017-07-01 10:09:21 | 2017-07-01 10:09:22 | backup-mycluster-locations-1498549921.sql.gz |
| 1698411 | locations | db-mysql-0903 | 2017-07-01 04:12:32 | 2017-07-01 04:12:32 | backup-mycluster-locations-1498528321.sql.gz |
| 1698050 | locations | db-mysql-0903 | 2017-06-30 22:18:23 | 2017-06-30 22:18:23 | backup-mycluster-locations-1498506721.sql.gz |
| ...
| 1262253 | locations | db-mysql-0088 | 2016-08-01 01:58:51 | 2016-08-01 01:58:54 | backup-mycluster-locations-1470034801.sql.gz |
| 1064984 | locations | db-mysql-0088 | 2016-04-04 13:07:40 | 2016-04-04 13:07:43 | backup-mycluster-locations-1459494001.sql.gz |
+-----------+------------+---------------+---------------------+---------------------+----------------------------------------------+
```
**tomkrouper**
```
.mysql restore 1699133
```
**Hubot**
```
A restore job has been created for the backup job 1699133. You will be notified in #database-ops when the restore is complete.
```
**Hubot**
```
@tomkrouper: the locations table has been restored as locations_2017_07_01_16_11 in the restores database on db-mysql-0482
```
数据被加载到非生产环境的数据库，该数据库可供请求该次恢复的工程师访问。
我们保留数据的“备份”的最后一个方法是使用<ruby> <a href="https://dev.mysql.com/doc/refman/5.6/en/replication-delayed.html"> 延迟副本 </a> <rt> delayed replica </rt></ruby>。这与其说是备份，不如说是保护。对于每个生产集群，我们有一个延迟 4 个小时复制的主机。如果运行了一个不该运行的请求，我们可以在 chatops 中运行 `mysql panic` 。这将导致我们所有的延迟副本立即停止复制。这也将给值班 DBA 发送消息。从而我们可以使用延迟副本来验证是否有问题，并快速前进到二进制日志的错误发生之前的位置。然后，我们可以将此数据恢复到主服务器，从而恢复数据到该时间点。
备份固然好，但如果发生了一些未知或未捕获的错误破坏它们，它们就没有价值了。让脚本恢复备份的好处是它允许我们通过 cron 自动执行备份验证。我们为每个集群设置了一个专用的主机，用于运行最新备份的恢复。这样可以确保备份运行正常，并且我们能够从备份中检索数据。
根据数据集大小，我们每天运行几次恢复。恢复的服务器被加入到复制工作流，并通过复制保持数据更新。这测试不仅让我们得到了可恢复的备份，而且也让我们得以正确地确定备份的时间点，并且可以从该时间点进一步应用更改。如果恢复过程中出现问题，我们会收到通知。
我们还追踪恢复所需的时间，所以我们知道在紧急情况下建立新的副本或还原需要多长时间。
以下是由 Hubot 在我们的机器人聊天室中输出的自动恢复过程。
**Hubot**
```
gh-mysql-backup-restore: db-mysql-0752: restore_log.id = 4447
gh-mysql-backup-restore: db-mysql-0752: Determining backup to restore for cluster 'prodcluster'.
gh-mysql-backup-restore: db-mysql-0752: Enabling maintenance mode
gh-mysql-backup-restore: db-mysql-0752: Setting orchestrator downtime
gh-mysql-backup-restore: db-mysql-0752: Disabling Puppet
gh-mysql-backup-restore: db-mysql-0752: Stopping MySQL
gh-mysql-backup-restore: db-mysql-0752: Removing MySQL files
gh-mysql-backup-restore: db-mysql-0752: Running gh-xtrabackup-restore
gh-mysql-backup-restore: db-mysql-0752: Restore file: xtrabackup-notify-2017-07-02_0000.xbstream
gh-mysql-backup-restore: db-mysql-0752: Running gh-xtrabackup-prepare
gh-mysql-backup-restore: db-mysql-0752: Starting MySQL
gh-mysql-backup-restore: db-mysql-0752: Update file ownership
gh-mysql-backup-restore: db-mysql-0752: Upgrade MySQL
gh-mysql-backup-restore: db-mysql-0752: Stopping MySQL
gh-mysql-backup-restore: db-mysql-0752: Starting MySQL
gh-mysql-backup-restore: db-mysql-0752: Backup Host: db-mysql-0034
gh-mysql-backup-restore: db-mysql-0752: Setting up replication
gh-mysql-backup-restore: db-mysql-0752: Starting replication
gh-mysql-backup-restore: db-mysql-0752: Replication catch-up
gh-mysql-backup-restore: db-mysql-0752: Restore complete (replication running)
gh-mysql-backup-restore: db-mysql-0752: Enabling Puppet
gh-mysql-backup-restore: db-mysql-0752: Disabling maintenance mode
gh-mysql-backup-restore: db-mysql-0752: Setting orchestrator downtime
gh-mysql-backup-restore: db-mysql-0752: Restore process complete.
```
还有一件我们可以使用备份做的事情是向一组现有的 MySQL 服务器添加一个新的副本。我们初始化一个新的服务器，一旦我们得知它准备就绪，我们就可以开始恢复该特定集群的最新备份。我们有一个脚本，可以运行所有需要手动执行的恢复命令。我们的自动恢复系统基本上使用的是相同的脚本。这简化了系统构建过程，并允许我们在一个启动运行的主机上使用几个对话命令（chatops）来替代一堆手动执行命令。下面显示的是在该对话（chatops）中手动执行的恢复：
**jessbreckenridge**
```
.mysql backup-restore -H db-mysql-0007 -o -r magic_word=daily_rotating_word
```
**Hubot**
```
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Determining backup to restore for cluster 'mycluster'.
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: restore_log.id = 4449
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Enabling maintenance mode
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Setting orchestrator downtime
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Disabling Puppet
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Stopping MySQL
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Removing MySQL files
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Running gh-xtrabackup-restore
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Restore file: xtrabackup-mycluster-2017-07-02_0015.xbstream
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Running gh-xtrabackup-prepare
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Update file ownership
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Starting MySQL
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Upgrade MySQL
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Stopping MySQL
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Starting MySQL
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Setting up replication
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Starting replication
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Backup Host: db-mysql-0201
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Replication catch-up
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Replication behind by 4589 seconds, waiting 1800 seconds before next check.
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Restore complete (replication running)
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Enabling puppet
@jessbreckenridge gh-mysql-backup-restore: db-mysql-0007: Disabling maintenance mode
```
### 故障转移
[我们使用协调器](http://githubengineering.com/orchestrator-github/) 来为<ruby> 主服务器 <rt> master </rt></ruby>和<ruby> 中间服务器 <rt> intermediate master </rt></ruby>执行自动化故障切换。我们期望<ruby> 协调器 <rt> orchestrator </rt></ruby>能够正确检测主服务器故障，指定一个副本进行晋升，在所指定的副本下修复拓扑，完成晋升。我们预期 VIP（虚拟 IP）、连接池可以相应地进行变化、客户端进行重连、puppet 在晋升后的主服务器上运行基本组件等等。故障转移是一项复杂的任务，涉及到我们基础架构的许多方面。
为了建立对我们的故障转移的信赖，我们建立了一个*类生产环境*的测试集群，并且我们不断地崩溃它来观察故障转移情况。
这个*类生产环境*的测试集群是一套复制环境，与我们的生产集群的各个方面都相同：硬件类型、操作系统、MySQL 版本、网络环境、VIP、puppet 配置、[haproxy 设置](https://githubengineering.com/context-aware-mysql-pools-via-haproxy/) 等。与生产集群唯一不同的是它不发送/接收生产流量。
我们在测试集群上模拟写入负载，同时避免复制滞后。写入负载不会太大，但是有一些有意地写入相同数据集的竞争请求。这在正常情况下并不是很有用，但是事实证明这在故障转移中是有用的，我们将会稍后简要描述它。
我们的测试集群有来自三个数据中心的典型的服务器。我们希望故障转移能够从同一个数据中心内晋升替代副本。我们希望在这样的限制下尽可能多地恢复副本。我们要求尽可能地实现这两者。协调器对拓扑结构没有<ruby> 先验假定 <rt> prior assumption </rt></ruby>；它必须依据崩溃时的状态作出反应。
然而，我们有兴趣创建各种复杂而多变的故障恢复场景。我们的故障转移测试脚本为故障转移提供了基础：
* 它能够识别现有的主服务器
* 它能够重构拓扑结构，来代表主服务器下的所有的三个数据中心。不同的数据中心具有不同的网络延迟，并且预期会在不同的时间对主机崩溃做出反应。
* 能够选择崩溃方式。可以选择干掉主服务器（`kill -9`）或网络隔离（比较好的方式： `iptables -j REJECT` 或无响应的方式： `iptables -j DROP`）方式。
脚本通过选择的方法使主机崩溃，并等待协调器可靠地检测到崩溃然后执行故障转移。虽然我们期望检测和晋升在 30 秒钟内完成，但脚本会稍微放宽这一期望，并在查找故障转移结果之前休眠一段指定的时间。然后它将检查：
* 一个新的（不同的）主服务器是否到位
* 集群中有足够的副本
* 主服务器是可写的
* 对主服务器的写入在副本上可见
* 内部服务发现项已更新（如预期般识别到新的主服务器；移除旧的主服务器）
* 其他内部检查
这些测试可以证实故障转移是成功的，不仅是 MySQL 级别的，而是在更大的基础设施范围内成功的。VIP 被赋予；特定的服务已经启动；信息到达了应该去的地方。
该脚本进一步继续恢复那个失败的服务器：
* 从备份恢复它，从而隐含地测试了我们的备份/恢复过程
* 验证服务器配置是否符合预期（该服务器不再认为其是主服务器）
* 将其加入到复制集群，期望找到在主服务器上写入的数据
看一下以下可视化的计划的故障转移测试：从运行良好的群集，到在某些副本上发现问题，诊断主服务器（`7136`）是否死机，选择一个服务器（`a79d`）来晋升，重构该服务器下的拓扑，晋升它（故障切换成功），恢复失败的（原）主服务器并将其放回群集。
#### 测试失败怎么样?
我们的测试脚本使用了一种“停止世界”的方法。任何故障切换组件中的单个故障都将导致整个测试失败，因此在有人解决该问题之前，无法进行任何进一步的自动化测试。我们会得到警报，并检查状态和日志进行处理。
脚本将各种情况下失败，如不可接受的检测或故障转移时间；备份/还原出现问题；失去太多服务器；在故障切换后的意外配置等等。
我们需要确保协调器正确地连接服务器。这是竞争性写入负载有用的地方：如果设置不正确，复制很容易中断。我们会得到 `DUPLICATE KEY` 或其他错误提示出错。
这是特别重要的，因此我们改进协调器并引入新的行为，以允许我们在安全的环境中测试这些变化。
#### 出现：混乱测试
上面所示的测试程序将捕获（并已经捕获）我们基础设施许多部分的问题。这些够了吗？
在生产环境中总是有其他的东西。有些特定测试方法不适用于我们的生产集群。它们不具有相同的流量和流量方式，也不具有完全相同的服务器集。故障类型可能有所不同。
我们正在为我们的生产集群设计混乱测试。 混乱测试将会在我们的生产中，但是按照预期的时间表和充分控制的方式来逐个破坏我们的部分生产环境。 混乱测试在恢复机制中引入更高层次的信赖，并影响（因此测试）我们的基础设施和应用程序的更大部分。
这是微妙的工作：当我们承认需要混乱测试时，我们也希望可以避免对我们的服务造成不必要的影响。不同的测试将在风险级别和影响方面有所不同，我们将努力确保我们的服务的可用性。
### 模式迁移
[我们使用 gh-ost](http://githubengineering.com/gh-ost-github-s-online-migration-tool-for-mysql/)来运行实时<ruby> 模式迁移 <rt> schema migration </rt></ruby>。gh-ost 是稳定的，但也处于活跃开发中，重大新功能正在不断开发和计划中。
gh-ost 通过将数据复制到 ghost 表来迁移，将由二进制日志拦截的进一步更改应用到 ghost 表中，就如其正在写入原始表。然后它将 ghost 表交换代替原始表。迁移完成时，GitHub 继续使用由 gh-ost 生成和填充的表。
在这个时候，几乎所有的 GitHub 的 MySQL 数据都被 gh-ost 重新创建，其中大部分重新创建多次。我们必须高度信赖 gh-ost，让它一遍遍地操弄我们的数据，即使它还处于活跃开发中。下面是我们如何获得这种信赖的。
gh-ost 提供生产环境测试能力。它支持在副本上运行迁移，其方式与在主服务器上运行的方式大致相同： gh-ost 将连接到副本，并将其视为主服务器。它将采用与实际主机迁移相同的方式解析其二进制日志。但是，它将复制行并将二进制日志事件应用于副本，并避免对主服务器进行写入。
我们在生产环境中给 gh-ost 提供专用的副本。这些副本并不为生产环境提供服务。每个这样的副本将检索生产表的当前列表，并以随机顺序对其进行迭代。一个接一个地选择一个表并在该表上执行复制迁移。迁移实际上并不修改表结构，而是运行一个微不足道的 `ENGINE=InnoDB` 更改。该测试运行迁移时，如果表正在生产环境中使用，会复制实际的生产数据，并接受二进制日志之外的真实的生产环境流量。
这些迁移可以被审计。以下是我们如何从对话中（chatops）检查运行中的测试状态：
**ggunson**
```
.migration test-status
```
**Hubot**
```
# Migrating `prod`.`pull_requests`; Ghost table is `prod`.`_pull_requests_gho`
# Migrating ghost-db-mysql-0007:3306; inspecting ghost-db-mysql-0007:3306; executing on ghost-db-mysql-0007
# Migration started at Mon Jan 30 02:13:39 -0800 2017
# chunk-size: 2500; max-lag-millis: 1500ms; max-load: Threads_running=30; critical-load: Threads_running=1000; nice-ratio: 0.000000
# throttle-additional-flag-file: /tmp/gh-ost.throttle
# panic-flag-file: /tmp/ghost-test-panic.flag
# Serving on unix socket: /tmp/gh-ost.test.sock
Copy: 57992500/86684838 66.9%; Applied: 57708; Backlog: 1/100; Time: 3h28m38s(total), 3h28m36s(copy); streamer: mysql-bin.000576:142993938; State: migrating; ETA: 1h43m12s
```
当测试迁移完成表数据的复制时，它将停止复制并执行切换，使用 ghost 表替换原始表，然后交换回来。我们对实际替换数据并不感兴趣。相反，我们将留下原始的表和 ghost 表，它们应该是相同的。我们通过校验两个表的整个表数据来验证。
测试能以下列方式完成：
* *成功* ：一切顺利，校验和相同。我们期待看到这一结果。
* *失败* ：执行问题。这可能偶尔发生，因为迁移进程被杀死、复制问题等，并且通常与 gh-ost 自身无关。
* *校验失败* ：表数据不一致。对于被测试的分支，这个需要修复。对于正在进行的 master 分支测试，这意味着立即阻止生产迁移。我们不会遇到后者。
测试结果经过审核，发送到机器人聊天室，作为事件发送到我们的度量系统。下图中的每条垂直线代表成功的迁移测试:
这些测试不断运行。如果发生故障，我们会收到通知。当然，我们可以随时访问机器人聊天室（chatops），了解发生了什么。
#### 测试新版本
我们不断改进 gh-ost。我们的开发流程基于 git 分支，然后我们通过[拉取请求（PR）](https://github.com/github/gh-ost/pulls)来提供合并。
提交的 gh-ost 拉取请求（PR）通过持续集成（CI）进行基本的编译和单元测试。一旦通过，该 PR 在技术上就有资格合并，但更好的是它[有资格通过 Heaven 进行部署](https://githubengineering.com/deploying-branches-to-github-com/)。作为我们基础架构中的敏感组件，在其进入 master 分支前，我们会小心部署分支进行密集测试。
**shlomi-noach**
```
.deploy gh-ost/fix-reappearing-throttled-reasons to prod/ghost-db-mysql-0007
```
**Hubot**
```
@shlomi-noach is deploying gh-ost/fix-reappearing-throttled-reasons (baee4f6) to production (ghost-db-mysql-0007).
@shlomi-noach's production deployment of gh-ost/fix-reappearing-throttled-reasons (baee4f6) is done! (2s)
@shlomi-noach, make sure you watch for exceptions in haystack
```
**jonahberquist**
```
.deploy gh-ost/interactive-command-question to prod/ghost-db-mysql-0012
```
**Hubot**
```
@jonahberquist is deploying gh-ost/interactive-command-question (be1ab17) to production (ghost-db-mysql-0012).
@jonahberquist's production deployment of gh-ost/interactive-command-question (be1ab17) is done! (2s)
@jonahberquist, make sure you watch for exceptions in haystack
```
**shlomi-noach**
```
.wcid gh-ost
```
**Hubot**
```
shlomi-noach testing fix-reappearing-throttled-reasons 41 seconds ago: ghost-db-mysql-0007
jonahberquist testing interactive-command-question 7 seconds ago: ghost-db-mysql-0012
Nobody is in the queue.
```
一些 PR 很小，不影响数据本身。对状态消息，交互式命令等的更改对 gh-ost 应用程序的影响较小。而其他的 PR 对迁移逻辑和操作会造成重大变化，我们将严格测试这些，通过我们的生产表车队运行这些，直到其满足了这些改变不会造成数据损坏威胁的程度。
### 总结
在整个测试过程中，我们建立对我们的系统的信赖。通过自动化这些测试，在生产环境中，我们得到了一切都按预期工作的反复确认。随着我们继续发展我们的基础设施，我们还通过调整测试来覆盖最新的变化。
产品总会有令你意想不到的未被测试覆盖的场景。我们对生产环境的测试越多，我们对应用程序的期望越多，基础设施的能力就越强。
---
via: <https://githubengineering.com/mysql-testing-automation-at-github/>
作者：[tomkrouper](https://github.com/tomkrouper)， [Shlomi Noach](https://github.com/shlomi-noach) 译者：[MonkeyDEcho](https://github.com/MonkeyDEcho) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Adobe 软件的最佳 Linux 替代品
|
Toni Matthews-el
|
https://www.maketecheasier.com/adobe-alternatives-for-linux/
|
你是一名正在寻找 Adobe 的替代品的 Linux 用户吗？那你不是一个人。
|
/data/attachment/album/201710/03/233322wdysvjddh6mmvvsl.jpg.thumb.jpg
|
/data/attachment/album/201710/03/233322wdysvjddh6mmvvsl.jpg
| true | false | true |
geekpi
| false |
[
"Adobe",
"设计"
] |
分享
|
{
"viewnum": 27548,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "60.173.178.71",
"message": "挺好，选择很多",
"username": "来自安徽六安的 Firefox 66.0|Ubuntu 用户",
"date": "2019-04-19T09:19:51"
}
] |
[] |
你是一名正在寻找 Adobe 的替代品的 Linux 用户吗？那你不是一个人。
| 2017-10-03T23:33:00 | 2017-10-03T23:33:00 | 8,928 |
/article-8928-1.html
|
你是一名正在寻找 Adobe 的替代品的 Linux 用户吗？那你不是一个人。如果你是一个狂热的平面设计师，那么你可能很擅长避开昂贵的 Adobe 产品。不过，对于 Adobe 来说，Linux 用户通常是其支持最不利的。因此，Adobe 的替代品是必须的 —— 但是最好的选择是什么？
这最终要看具体的 Adobe 程序和你希望完成的事情。幸运的是，由于需求是所有发明之母，有人响应了这些号召。其结果是出现了一系列高效的 Adobe 替代品。
### Evince (Adobe Acrobat Reader)
就像 Adobe Acrobat Reader 一样，[Evince](https://wiki.gnome.org/Apps/Evince) 是一个“支持多种文档格式的文档查看器”。例如，用户可以使用 Evince 作为 PDF 查看器。它还支持各种漫画书格式（cbr、cbz、cb7 和 cbt）。你可以在 Evince 网站上找到[支持格式的完整列表](https://wiki.gnome.org/Apps/Evince/SupportedDocumentFormats)。
对于 Evince ，Linux 用户不用高估，也不用贬低，它就是个标准的查看器。你可以在需要时前往官方网站进行更新。
### Pixlr (Adobe Photoshop)
关于 [Pixlr](https://pixlr.com/) 的很棒的一点是这个 Adobe 替代品的各种工具可以在线获得。如果你有一个互联网连接，那么你就有一个强大的图像编辑工作区。
[Pixlr Editor](https://pixlr.com/editor/) 是 Photoshop 的一个功能强大的替代品，你可以使用图层和相关效果。它还有一些漂亮的绘图和颜色编辑工具。[Pixlr Express](https://pixlr.com/express/) 没有这么多功能，因为它主要用于图像增强、调整颜色和清晰度，并增加一些 Instagram 适用的效果！
你可以通过 Pixlr 完成的任务简直不可置信，而且完全免费的。
### Inkscape (Adobe Illustrator)
[Inkscape](https://inkscape.org/en/)是另一个值得推荐的免费 Adobe 替代品。它主要作为一个“专业的矢量图形编辑器”。除了 Illustrator，Inkscape 也与 Corel Draw、Freehand 和 Xara X 的功能差不多。
它的矢量设计工具可用于制作 logo 和“高可伸缩性”艺术品。Inkscape 包含绘图、形状和文本工具。图层工具允许你锁定、分组或隐藏单个图层。
### Pinegrow Web Editor (Adobe Dreamweaver)
[Pinegrow Web Editor](http://pinegrow.com/) 是 Dreamweaver 在 Linux 上的绝佳替代品。该程序可让你在桌面上直接制作 HTML 网站。
不仅是使用代码创建（而且需要稍后预览），Pinegrow 可以提供详细的可视化编辑体验。你可以直接查看和测试你的 HTML 项目，实时了解链接是否正常工作，或者图片是否在它该在的地方。Pinegrow 还附带了 WordPress 主题构建器。
免费试用 30 天。如果你喜欢，你可以一次性支付 $49 购买。
### Scribus (Adobe InDesign)
[Scribus](https://www.scribus.net/) 可能是最接近 Adobe InDesign 的替代品。根据开发者的说法，你应该[认真考虑使用](https://www.scribus.net/why-on-earth-should-i-use-scribus-2/) Scribus，因为它是可靠和免费的。
实际上，Scribus 不仅仅是一个出色的桌面出版工具，也是一个很好的自出版工具。当你可以自己做高质量的杂志和书籍时，为什么要依靠昂贵的商业软件来创建？Scribus 目前允许设计师使用一个 200 色的调色板，下一个稳定版中[承诺将会加倍颜色数](https://www.scribus.net/because-color-matters/)。
### digiKam (Adobe Lightroom)
[digiKam](http://digikam.org/) 也许是目前 Linux 用户最好的 Lightroom 替代品。功能包括导入照片、整理图片集、图像增强、创建幻灯片等功能。
它的时尚设计和先进的功能是真正用心之作。实际上，digiKam 背后的人是摄影师们。不仅如此，他们希望在 Linux 中完成在 Lightroom 能做的任何工作。
### Webflow (Adobe Muse)
[Webflow](https://webflow.com/) 是另一个可以证明你无需下载软件而可以完成很多事的网站。这是一个非常方便的 Adobe Muse 替代品，Webflow 是创建高响应式网站设计的理想选择。
Webflow 的最好的一方面是你不需要自己编写代码。你只需拖放图像并写入文本。Webflow 为你做了所有杂事。你可以从头开始构建网站，也可以使用各种模板。虽然是免费的，但是其高级版本还提供了额外的功能，如能够轻松地导出 HTML 和 CSS 以在其他地方使用。
### Tupi (Adobe Animate)
[Tupi](http://www.maefloresta.com/portal/) 是 Adobe Animate 的替代品，或者也可以用于那些[不太热衷于 Flash 的人](https://www.maketecheasier.com/sites-moving-away-flash/)。当然，Tupi 的作者说这并不是与 Flash 竞争。然而，其使用 HTML5 的能力使其成为了理想的替代品。
在 PC 或平板电脑上绘制 2D 动画。不确定如何开始？使用网站的 [YouTube 教程](https://www.youtube.com/user/maefloresta)了解如何制作剪贴画动画以及更多。
### Black Magic Fusion (Adobe After Effects)
[Black Magic Fusion](https://www.blackmagicdesign.com/) 注定是 Adobe After Effects 的替代者。这个视觉效果软件历经了大约 25 年的开发！Fusion 通常用于在好莱坞电影和电视节目中制造令人印象深刻的效果 —— 这靠的是其丰富而时尚的功能。
Fusion 通过使用节点，即那些“代表效果、过滤器和其他处理的小图标”工作。将这些节点连接在一起，创建一系列复杂的视觉效果。该程序包括许多功能，如图片修饰、对象跟踪和令人兴奋的 3D 效果。
你可以选择免费版或者 $995 的 Fusion Studio。为了帮助你决定，[你可以比较](https://www.blackmagicdesign.com/products/fusion/compare)免费和高级版的 Fusion 功能。
### 总结
如你所见，这些远不止于是 Adobe 替代品。由于开源的缘故，显著提升的替代品的不断地发布。我们很快就会看到一个仅为 Linux 用户创建的完整套件。在此之前，你可以随意选择这些替代品。
知道这里没有提到的其它有用的 Adobe 替代品吗？在下面的评论区分享软件建议。
---
via: <https://www.maketecheasier.com/adobe-alternatives-for-linux/>
作者：[Toni Matthews-El](https://www.maketecheasier.com/author/ttmatthe/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
详解 Ubuntu snap 包的制作过程
|
Mi Blog Lah!
|
https://blog.simos.info/how-to-create-a-snap-for-timg-with-snapcraft-on-ubuntu/
|
在这篇文章中，我们将看到如何为名为 timg 的实用程序制作对应的 snap 包。
|
/data/attachment/album/201710/04/005358bmfkk33gzwmfwtkf.jpg.thumb.jpg
|
/data/attachment/album/201710/04/005358bmfkk33gzwmfwtkf.jpg
| true | false | true |
Snapcrafter
| false |
[
"Snap"
] |
技术
|
{
"viewnum": 8021,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇文章中，我们将看到如何为名为 timg 的实用程序制作对应的 snap 包。
| 2017-10-04T09:29:00 | 2017-10-04T09:29:00 | 8,929 |
/article-8929-1.html
|
>
> 如果你看过译者以前翻译的 snappy 文章，不知有没有感觉相关主题都是浅尝辄止，讲得不够透彻，看得也不太过瘾？如果有的话，相信这篇详细讲解如何从零开始制作一个 snap 包的文章应该不会让你失望。
>
>
>
在这篇文章中，我们将看到如何为名为 [timg](https://github.com/hzeller/timg) 的实用程序制作对应的 snap 包。如果这是你第一次听说 snap 安装包，你可以先看看 [如何创建你的第一个 snap 包](https://tutorials.ubuntu.com/tutorial/create-your-first-snap)。
今天我们将学习以下有关使用 snapcraft 制作 snap 包的内容：
* [timg](https://github.com/hzeller/timg) 源码中的 Makefile 文件是手工编写，我们需要修改一些 [make 插件参数](https://snapcraft.io/docs/reference/plugins/make)。
* 这个程序是用 C++ 语言写的，依赖几个额外的库文件。我们需要把相关的代码添加到 snap 包中。
* [严格限制还是传统限制](https://snapcraft.io/docs/reference/confinement)？我们将会讨论如何在它们之间进行选择。
首先，我们了解下 [timg](https://github.com/hzeller/timg) 有什么用？
### 背景
Linux 终端模拟器已经变得非常炫酷，并且还能显示颜色！
除了标准的颜色，大多数终端模拟器（如上图显示的 GNOME 终端）都支持真彩色（1600 万种颜色）。
是的！终端模拟器已经支持真彩色了！从这个页面“ [多个终端和终端应用程序已经支持真彩色（1600 万种颜色）](https://gist.github.com/XVilka/8346728)” 可以获取 AWK 代码自己进行测试。你可以看到在代码中使用了一些 [转义序列](https://en.wikipedia.org/wiki/Escape_sequence) 来指定 RGB 的值（256 \* 256 \* 256 ~= 1600 万种颜色）。
### timg 是什么？
好了，言归正传，[timg](https://github.com/hzeller/timg) 有什么用？它能将输入的图片重新调整为终端窗口字符所能显示范围的大小（比如：80 x 25），然后在任何分辨率的终端窗口用彩色字符显示图像。
这幅图用彩色块字符显示了 [Ubuntu 的 logo](http://design.ubuntu.com/wp-content/uploads/ubuntu-logo112.png)，原图是一个 PNG 格式的文件。
这是 [@Doug8888 拍摄的花](https://www.flickr.com/photos/doug88888/5776072628/in/photolist-9WCiNQ-7U3Trc-7YUZBL-5DwkEQ-6e1iT8-a372aS-5F75aL-a1gbow-6eNayj-8gWK2H-5CtH7P-6jVqZv-86RpwN-a2nEnB-aiRmsc-6aKvwK-8hmXrN-5CWDNP-62hWM8-a9smn1-ahQqHw-a22p3w-a36csK-ahN4Pv-7VEmnt-ahMSiT-9NpTa7-5A3Pon-ai7DL7-9TKCqV-ahr7gN-a1boqP-83ZzpH-9Sqjmq-5xujdi-7UmDVb-6J2zQR-5wAGNR-5eERar-5KVDym-5dL8SZ-5S2Uut-7RVyHg-9Z6MAt-aiRiT4-5tLesw-aGLSv6-5ftp6j-5wAVBq-5T2KAP)。
如果你通过远程连接服务器来管理自己的业务，并想要查看图像文件，那么 [timg](https://github.com/hzeller/timg) 将会特别有用。
除了静态图片，[timg](https://github.com/hzeller/timg) 同样也可以显示 gif 动图。
那么让我们开始 snap 之旅吧！
### 熟悉 timg 的源码
[timg](https://github.com/hzeller/timg) 的源码可以在 <https://github.com/hzeller/timg> 找到。让我们试着手动编译它，以了解它有什么需求。
`Makefile` 在 `src/` 子文件夹中而不是项目的根文件夹中。在 github 页面上，他们说需要安装两个开发包（GraphicsMagic++ 和 WebP），然后使用 `make` 就能生成可执行文件。在截图中可以看到我已经将它们安装好了（在我读完相关的 Readme.md 文件后）。
因此，在编写 `snapcraft.yaml` 文件时已经有了四条腹稿：
1. `Makefile` 在 `src/` 子文件夹中而不是项目的根文件夹中。
2. 这个程序编译时需要两个开发库。
3. 为了让 timg 以 snap 包形式运行，我们需要将这两个库捆绑在 snap 包中（或者静态链接它们）。
4. [timg](https://github.com/hzeller/timg) 是用 C++ 编写的，所以需要安装 g++。在编译之前，让我们通过 `snapcraft.yaml` 文件来检查 `build-essential` 元包是否已经安装。
### 从 snapcraft 开始
让我们新建一个名为 `timg-snap/` 的文件夹，并在其中运行 `snapcraft init` 这条命令来创建 `snapcraft.yaml` 工作的框架。
```
ubuntu@snaps:~$ mkdir timg-snap
ubuntu@snaps:~$ cd timg-snap/
ubuntu@snaps:~/timg-snap$ snapcraft init
Created snap/snapcraft.yaml.
Edit the file to your liking or run `snapcraft` to get started
ubuntu@snaps:~/timg-snap$ cat snap/snapcraft.yaml
name: my-snap-name # you probably want to 'snapcraft register <name>'
version: '0.1' # just for humans, typically '1.2+git' or '1.3.2'
summary: Single-line elevator pitch for your amazing snap # 79 char long summary
description: |
This is my-snap's description. You have a paragraph or two to tell the most important story about your snap. Keep it under 100 words though, we live in tweetspace and your description wants to look good in the snap store.
grade: devel # must be 'stable' to release into candidate/stable channels
confinement: devmode # use 'strict' once you have the right plugs and slots
parts:
my-part:
# See 'snapcraft plugins'
plugin: nil
```
### 填充元数据
`snapcraft.yaml` 配置文件的上半部分是元数据。我们需要一个一个把它们填满，这算是比较容易的部分。元数据由以下字段组成：
1. `name` （名字）—— snap 包的名字，它将公开在 Ubuntu 商店中。
2. `version` （版本）—— snap 包的版本号。可以是源代码存储库中一个适当的分支或者标记，如果没有分支或标记的话，也可以是当前日期。
3. `summary` （摘要）—— 不超过 80 个字符的简短描述。
4. `description` （描述）—— 长一点的描述, 100 个字以下。
5. `grade` （等级）—— `stable` （稳定）或者 `devel` （开发）。因为我们想要在 Ubuntu 商店的稳定通道中发布这个 snap 包，所以在 snap 包能正常工作后，就把它设置成 `stable`。
6. `confinement` （限制）—— 我们首先设置为 `devmode` （开发模式），这样系统将不会以任何方式限制 snap 包。一旦它在 `devmode`下能正常工作，我们再考虑选择 `strict` （严格）还是 `classic` （传统）限制。
我们将使用 `timg` 这个名字：
```
ubuntu@snaps:~/timg-snap$ snapcraft register timg
Registering timg.
You already own the name 'timg'.
```
是的，这个名字我已经注册了 :-)。
接下来，我们应该选择哪个版本的 timg？
当在仓库中寻找分支或标记时，我们会发现有一个 v0.9.5 标签，其中有 2016 年 6 月 27 日最新提交的代码。
然而主分支（`master`）中有两个看起来很重要的提交。因此我们使用主分支而不用 `v0.9.5` 标签的那个。我们使用今天的日期—— `20170226` 做为版本号。
我们从仓库中搜集了摘要和描述。其中摘要的内容为 `A terminal image viewer`，描述的内容为 `A viewer that uses 24-Bit color capabilities and unicode character blocks to display images in the terminal`。
最后，将 `grade` （等级）设置为 `stable` （稳定），将 `confinement` 限制设置为 `devmode` （开发模式）（一直到 snap 包真正起作用）。
这是更新后的 `snapcraft.yaml`，带有所有的元数据：
```
ubuntu@snaps:~/timg-snap$ cat snap/snapcraft.yaml
name: timg
version: '20170226'
summary: A terminal image viewer
description: |
A viewer that uses 24-Bit color capabilities and unicode character blocks to display images in the terminal.
grade: stable
confinement: devmode
parts:
my-part:
# See 'snapcraft plugins'
plugin: nil
```
### 弄清楚 `parts:` 是什么
现在我们需要将上面已经存在的 `parts:` 部分替换成真实的 `parts:`。
*Git 仓库的 URL。*
*存在 Makefile，因此我们需要 make 插件。*
我们已经知道 git 仓库的 URL 链接，并且 timg 源码中已有了 `Makefile` 文件。至于 [snapcraft make 插件](https://snapcraft.io/docs/reference/plugins/make) 的 Makefile 命令，正如文档所言，这个插件总是会运行 `make` 后再运行 `make install`。为了确认 `make` 插件的用法，我查看了 [snapcraft 可用插件列表](https://snapcraft.io/docs/reference/plugins/)。
因此，我们将最初的配置：
```
parts:
my-part:
# See 'snapcraft plugins'
plugin: nil
```
修改为：
```
parts:
timg:
source: https://github.com/hzeller/timg.git
plugin: make
```
这是当前 `snapcraft.yaml` 文件的内容：
```
name: timg
version: '20170226'
summary: A terminal image viewer
description: |
A viewer that uses 24-Bit color capabilities and unicode character blocks
to display images in the terminal.
grade: stable
confinement: devmode
parts:
timg:
source: https://github.com/hzeller/timg.git
plugin: make
```
让我们运行下 `snapcraft prime` 命令看看会发生什么：
```
ubuntu@snaps:~/timg-snap$ snapcraft prime
Preparing to pull timg
Pulling timg
Cloning into '/home/ubuntu/timg-snap/parts/timg/src'...
remote: Counting objects: 144, done.
remote: Total 144 (delta 0), reused 0 (delta 0), pack-reused 144
Receiving objects: 100% (144/144), 116.00 KiB | 0 bytes/s, done.
Resolving deltas: 100% (89/89), done.
Checking connectivity... done.
Preparing to build timg
Building timg
make -j4
make: *** No targets specified and no makefile found. Stop.
Command '['/bin/sh', '/tmp/tmpem97fh9d', 'make', '-j4']' returned non-zero exit status 2
ubuntu@snaps:~/timg-snap$
```
我们可以看到 `snapcraft` 无法在源代码中找到 `Makefile` 文件，正如我们之前所暗示的，`Makefile` 位于 `src/` 子文件夹中。那么，我们可以让 `snapcraft` 使用 `src/` 文件夹中的 `Makefile` 文件吗？
每个 snapcraft 插件都有自己的选项，并且有一些通用选项是所有插件共享的。在本例中，我们希望研究那些[与源代码相关的 snapcraft 选项](https://snapcraft.io/docs/reference/plugins/source)。我们开始吧：
**source-subdir：path**
snapcraft 会<ruby> 检出 <rt> checkout </rt></ruby> `source` 关键字所引用的仓库或者解压归档文件到 `parts/<part-name>/src/` 中，但是它只会将特定的子目录复制到 `parts/<part-name>/build/` 中。
我们已经有了适当的选项，下面更新下 `parts`：
```
parts:
timg:
source: https://github.com/hzeller/timg.git
source-subdir: src
plugin: make
```
然后再次运行 `snapcraft prime`：
```
ubuntu@snaps:~/timg-snap$ snapcraft prime
The 'pull' step of 'timg' is out of date:
The 'source-subdir' part property appears to have changed.
Please clean that part's 'pull' step in order to continue
ubuntu@snaps:~/timg-snap$ snapcraft clean
Cleaning up priming area
Cleaning up staging area
Cleaning up parts directory
ubuntu@snaps:~/timg-snap$ snapcraft prime
Skipping pull timg (already ran)
Preparing to build timg
Building timg
make -j4
g++ `GraphicsMagick++-config --cppflags --cxxflags` -Wall -O3 -fPIC -c -o timg.o timg.cc
g++ -Wall -O3 -fPIC -c -o terminal-canvas.o terminal-canvas.cc
/bin/sh: 1: GraphicsMagick++-config: not found
timg.cc:33:22: fatal error: Magick++.h: No such file or directory
compilation terminated.
Makefile:10: recipe for target 'timg.o' failed
make: *** [timg.o] Error 1
make: *** Waiting for unfinished jobs....
Command '['/bin/sh', '/tmp/tmpeeyxj5kw', 'make', '-j4']' returned non-zero exit status 2
ubuntu@snaps:~/timg-snap$
```
从错误信息我们可以得知 snapcraft 找不到 GraphicsMagick++ 这个开发库文件。根据 [snapcraft 常见关键字](https://snapcraft.io/docs/reference/plugins/common) 可知，我们需要在 `snapcraft.yaml` 中指定这个库文件，这样 snapcraft 才能安装它。
**build-packages：[deb, deb, deb…]**
列出构建 part 前需要在主机中安装的 Ubuntu 包。这些包通常不会进入最终的 snap 包中，除非它们含有 snap 包中二进制文件直接依赖的库文件（在这种情况下，可以通过 `ldd` 发现它们），或者在 `stage-package` 中显式地指定了它们。
让我们寻找下这个开发包的名字：
```
ubuntu@snaps:~/timg-snap$ apt-cache search graphicsmagick++ | grep dev
graphicsmagick-libmagick-dev-compat/xenial 1.3.23-1build1 all
libgraphicsmagick++1-dev/xenial 1.3.23-1build1 amd64
format-independent image processing - C++ development files
libgraphicsmagick1-dev/xenial 1.3.23-1build1 amd64
format-independent image processing - C development files
ubuntu@snaps:~/timg-snap$
```
可以看到包名为 `libgraphicsmagick++1-dev`，下面是更新后的 `parts`：
```
parts:
timg:
source: https://github.com/hzeller/timg.git
source-subdir: src
plugin: make
build-packages:
- libgraphicsmagick++1-dev
```
再次运行 `snapcraft`：
```
ubuntu@snaps:~/timg-snap$ snapcraft
Installing build dependencies: libgraphicsmagick++1-dev
[...]
The following NEW packages will be installed:
libgraphicsmagick++-q16-12 libgraphicsmagick++1-dev libgraphicsmagick-q16-3
libgraphicsmagick1-dev libwebp5
[...]
Building timg
make -j4
g++ `GraphicsMagick++-config --cppflags --cxxflags` -Wall -O3 -fPIC -c -o timg.o timg.cc
g++ -Wall -O3 -fPIC -c -o terminal-canvas.o terminal-canvas.cc
g++ -o timg timg.o terminal-canvas.o `GraphicsMagick++-config --ldflags --libs`
/usr/bin/ld: cannot find -lwebp
collect2: error: ld returned 1 exit status
Makefile:7: recipe for target 'timg' failed
make: *** [timg] Error 1
Command '['/bin/sh', '/tmp/tmptma45jzl', 'make', '-j4']' returned non-zero exit status 2
ubuntu@snaps:~/timg-snap$
```
虽然只指定了开发库 `libgraphicsmagick+1-dev`，但 Ubuntu 还安装了一些代码库，包括 `libgraphicsmagick ++-q16-12`，以及动态代码库 `libwebp`。
这里仍然有一个错误，这个是因为缺少开发版本的 `webp` 库（一个静态库）。我们可以通过下面的命令找到它：
```
ubuntu@snaps:~/timg-snap$ apt-cache search libwebp | grep dev
libwebp-dev - Lossy compression of digital photographic images.
ubuntu@snaps:~/timg-snap$
```
上面安装的 `libwebp5` 包只提供了一个动态库（.so）。通过 `libwebp-dev` 包，我们可以得到相应的静态库（.a）。好了，让我们更新下 `parts:` 部分：
```
parts:
timg:
source: https://github.com/hzeller/timg.git
source-subdir: src
plugin: make
build-packages:
- libgraphicsmagick++1-dev
- libwebp-dev
```
下面是更新后的 `snapcraft.yaml` 文件的内容：
```
name: timg
version: '20170226'
summary: A terminal image viewer
description: |
A viewer that uses 24-Bit color capabilities and unicode character blocks
to display images in the terminal.
grade: stable
confinement: devmode
parts:
timg:
source: https://github.com/hzeller/timg.git
source-subdir: src
plugin: make
build-packages:
- libgraphicsmagick++1-dev
- libwebp-dev
```
让我们运行下 `snapcraft prime`：
```
ubuntu@snaps:~/timg-snap$ snapcraft prime
Skipping pull timg (already ran)
Preparing to build timg
Building timg
make -j4
g++ `GraphicsMagick++-config --cppflags --cxxflags` -Wall -O3 -fPIC -c -o timg.o timg.cc
g++ -Wall -O3 -fPIC -c -o terminal-canvas.o terminal-canvas.cc
g++ -o timg timg.o terminal-canvas.o `GraphicsMagick++-config --ldflags --libs`
make install DESTDIR=/home/ubuntu/timg-snap/parts/timg/install
install timg /usr/local/bin
install: cannot create regular file '/usr/local/bin/timg': Permission denied
Makefile:13: recipe for target 'install' failed
make: *** [install] Error 1
Command '['/bin/sh', '/tmp/tmptq_s1itc', 'make', 'install', 'DESTDIR=/home/ubuntu/timg-snap/parts/timg/install']' returned non-zero exit status 2
ubuntu@snaps:~/timg-snap$
```
我们遇到了一个新问题。由于 `Makefile` 文件是手工编写的，不符合 [snapcraft make 插件](https://snapcraft.io/docs/reference/plugins/make) 的参数设置，所以不能正确安装到 `prime/` 文件夹中。`Makefile` 会尝试安装到 `usr/local/bin` 中。
我们需要告诉 [snapcraft make 插件](https://snapcraft.io/docs/reference/plugins/make) 不要运行 `make install`，而是找到 `timg` 可执行文件然后把它放到 `prime/` 文件夹中。根据文档的描述：
```
- artifacts:
（列表）
将 make 生成的指定文件复制或者链接到 snap 包安装目录。如果使用，则 `make install` 这步操作将被忽略。
```
所以，我们需要将一些东西放到 `artifacts:` 中。但是具体是哪些东西？
```
ubuntu@snaps:~/timg-snap/parts/timg$ ls build/src/
Makefile terminal-canvas.h timg* timg.o
terminal-canvas.cc terminal-canvas.o timg.cc
ubuntu@snaps:~/timg-snap/parts/timg$
```
在 `build/` 子目录中，我们可以找到 `make` 的输出结果。由于我们设置了 `source-subdir:` 为 `src`，所以 `artifacts:` 的基目录为 `build/src`。在这里我们可以找到可执行文件 `timg`，我们需要将它设置为 `artifacts:` 的一个参数。通过 `artifacts:`，我们可以把 `make` 输出的某些文件复制到 snap 包的安装目录（在 `prime/` 中）。
下面是更新后 `snapcraft.yaml` 文件 `parts:` 部分的内容：
```
parts:
timg:
source: https://github.com/hzeller/timg.git
source-subdir: src
plugin: make
build-packages:
- libgraphicsmagick++1-dev
- libwebp-dev
artifacts: [timg]
```
让我们运行 `snapcraft prime`：
```
ubuntu@snaps:~/timg-snap$ snapcraft prime
Preparing to pull timg
Pulling timg
Cloning into '/home/ubuntu/timg-snap/parts/timg/src'...
remote: Counting objects: 144, done.
remote: Total 144 (delta 0), reused 0 (delta 0), pack-reused 144
Receiving objects: 100% (144/144), 116.00 KiB | 207.00 KiB/s, done.
Resolving deltas: 100% (89/89), done.
Checking connectivity... done.
Preparing to build timg
Building timg
make -j4
g++ `GraphicsMagick++-config --cppflags --cxxflags` -Wall -O3 -fPIC -c -o timg.o timg.cc
g++ -Wall -O3 -fPIC -c -o terminal-canvas.o terminal-canvas.cc
g++ -o timg timg.o terminal-canvas.o `GraphicsMagick++-config --ldflags --libs`
Staging timg
Priming timg
ubuntu@snaps:~/timg-snap$
```
我们还将继续迭代。
### 导出命令
到目前为止，snapcraft 生成了可执行文件，但没有导出给用户使用的命令。接下来我们需要通过 `apps:` 导出一个命令。
首先我们需要知道命令在 `prime/` 的哪个子文件夹中：
```
ubuntu@snaps:~/timg-snap$ ls prime/
meta/ snap/ timg* usr/
ubuntu@snaps:~/timg-snap$
```
它在 `prime/` 子文件夹的根目录中。现在，我们已经准备好要在 `snapcaft.yaml` 中增加 `apps:` 的内容：
```
ubuntu@snaps:~/timg-snap$ cat snap/snapcraft.yaml
name: timg
version: '20170226'
summary: A terminal image viewer
description: |
A viewer that uses 24-Bit color capabilities and unicode character blocks
to display images in the terminal.
grade: stable
confinement: devmode
apps:
timg:
command: timg
parts:
timg:
source: https://github.com/hzeller/timg.git
source-subdir: src
plugin: make
build-packages:
- libgraphicsmagick++1-dev
- libwebp-dev
artifacts: [timg]
```
让我们再次运行 `snapcraft prime`，然后测试下生成的 snap 包：
```
ubuntu@snaps:~/timg-snap$ snapcraft prime
Skipping pull timg (already ran)
Skipping build timg (already ran)
Skipping stage timg (already ran)
Skipping prime timg (already ran)
ubuntu@snaps:~/timg-snap$ snap try --devmode prime/
timg 20170226 mounted from /home/ubuntu/timg-snap/prime
ubuntu@snaps:~/timg-snap$
```
*图片来源： <https://www.flickr.com/photos/mustangjoe/6091603784/>*
我们可以通过 `snap try --devmode prime/` 启用该 snap 包然后测试 `timg` 命令。这是一种高效的测试方法，可以避免生成 .snap 文件，并且无需安装和卸载它们，因为 `snap try prime/` 直接使用了 `prime/` 文件夹中的内容。
### 限制 snap
到目前为止，snap 包一直是在不受限制的开发模式下运行的。让我们看看如何限制它的运行：
```
ubuntu@snaps:~/timg-snap$ snap list
Name Version Rev Developer Notes
core 16-2 1337 canonical -
timg 20170226 x1 devmode,try
ubuntu@snaps:~/timg-snap$ snap try --jailmode prime
timg 20170226 mounted from /home/ubuntu/timg-snap/prime
ubuntu@snaps:~/timg-snap$ snap list
Name Version Rev Developer Notes
core 16-2 1337 canonical -
timg 20170226 x2 jailmode,try
ubuntu@snaps:~/timg-snap$ timg pexels-photo-149813.jpeg
Trouble loading pexels-photo-149813.jpeg (Magick: Unable to open file (pexels-photo-149813.jpeg) reported by magick/blob.c:2828 (OpenBlob))
ubuntu@snaps:~/timg-snap$
```
通过这种方式，我们可以无需修改 `snapcraft.yaml` 文件就从开发模式（`devmode`）切换到限制模式（`jailmode`）（`confinement: strict`）。正如预期的那样，`timg` 无法读取图像，因为我们没有开放访问文件系统的权限。
现在，我们需要作出决定。使用限制模式，我们可以很容易授予某个命令访问用户 `$HOME` 目录中文件的权限，但是只能访问那里。如果图像文件位于其它地方，我们总是需要复制到 `$HOME` 目录并在 `$HOME` 的副本上运行 timg。如果我们觉得可行，那我们可以设置 `snapcraf.yaml` 为:
```
name: timg
version: '20170226'
summary: A terminal image viewer
description: |
A viewer that uses 24-Bit color capabilities and unicode character blocks
to display images in the terminal.
grade: stable
confinement: strict
apps:
timg:
command: timg
plugs: [home]
parts:
timg:
source: https://github.com/hzeller/timg.git
source-subdir: src
plugin: make
build-packages:
- libgraphicsmagick++1-dev
- libwebp-dev
artifacts: [timg]
```
另一方面，如果希望 timg snap 包能访问整个文件系统，我们可以设置传统限制来实现。对应的 `snapcraft.yaml` 内容如下：
```
name: timg
version: '20170226'
summary: A terminal image viewer
description: |
A viewer that uses 24-Bit color capabilities and unicode character blocks
to display images in the terminal.
grade: stable
confinement: classic
apps:
timg:
command: timg
parts:
timg:
source: https://github.com/hzeller/timg.git
source-subdir: src
plugin: make
build-packages:
- libgraphicsmagick++1-dev
- libwebp-dev
artifacts: [timg]
```
接下来我们将选择严格（`strict`）约束选项。因此，图像应该只能放在 $HOME 中。
### 打包和测试
让我们打包这个 snap，也就是制作 .snap 文件，然后在新安装的 Ubuntu 系统上对它进行测试。
```
ubuntu@snaps:~/timg-snap$ snapcraft
Skipping pull timg (already ran)
Skipping build timg (already ran)
Skipping stage timg (already ran)
Skipping prime timg (already ran)
Snapping 'timg' \
Snapped timg_20170226_amd64.snap
ubuntu@snaps:~/timg-snap$
```
我们如何在几秒钟内得到一个全新安装的 Ubuntu 系统来对 snap 包进行测试？
请查看 [尝试在 Ubuntu 上使用 LXD 容器](https://blog.simos.info/trying-out-lxd-containers-on-our-ubuntu/)，并在你的系统上设置 LXD。然后回到这里，尝试运行下面的命令：
```
$ lxc launch ubuntu:x snaptesting
Creating snaptesting
Starting snaptesting
$ lxc file push timg_20170226_amd64.snap snaptesting/home/ubuntu/
$ lxc exec snaptesting -- sudo su - ubuntu
To run a command as administrator (user "root"), use "sudo <command>".
See "man sudo_root" for details.
ubuntu@snaptesting:~$ ls
timg_20170226_amd64.snap
ubuntu@snaptesting:~$ snap install timg_20170226_amd64.snap
error: access denied (try with sudo)
ubuntu@snaptesting:~$ sudo snap install timg_20170226_amd64.snap
error: cannot find signatures with metadata for snap "timg_20170226_amd64.snap"
ubuntu@snaptesting:~$ sudo snap install timg_20170226_amd64.snap --dangerous
error: cannot perform the following tasks:
- Mount snap "core" (1337) ([start snap-core-1337.mount] failed with exit status 1: Job for snap-core-1337.mount failed. See "systemctl status snap-core-1337.mount" and "journalctl -xe" for details.
)
ubuntu@snaptesting:~$ sudo apt install squashfuse
[...]
Setting up squashfuse (0.1.100-0ubuntu1~ubuntu16.04.1) ...
ubuntu@snaptesting:~$ sudo snap install timg_20170226_amd64.snap --dangerous
timg 20170226 installed
ubuntu@snaptesting:~$ wget https://farm7.staticflickr.com/6187/6091603784_d6960c8be2_z_d.jpg
[...]
2017-02-26 22:12:18 (636 KB/s) - ‘6091603784_d6960c8be2_z_d.jpg’ saved [240886/240886]
ubuntu@snaptesting:~$ timg 6091603784_d6960c8be2_z_d.jpg
[it worked!]
ubuntu@snaptesting:~$
```
我们启动了一个名为 `snaptesting` 的 LXD 容器，并将 .snap 文件复制进去。然后，通过普通用户连接到容器，并尝试安装 snap 包。最初，我们安装失败了，因为在无特权的 LXD 容器中安装 snap 包需要使用 `sudo` 。接着又失败了，因为 .snap 没有经过签名（我们需要使用 `--dangerous` 参数）。然而还是失败了，这次是因为我们需要安装 `squashfuse` 包（Ubuntu 16.04 镜像中没有预装）。最后，我们成功安装了snap，并设法查看了图像。
在一个全新安装的 Linux 系统中测试 snap 包是很重要的，因为这样才能确保 snap 包中包含所有必须的代码库。在这个例子中，我们使用了静态库并运行良好。
### 发布到 Ubuntu 商店
这是 [发布 snap 包到 Ubuntu 商店的说明](https://snapcraft.io/docs/build-snaps/publish)。 在之前的教程中，我们已经发布了一些 snap 包。对于 `timg` 来说，我们设置了严格限制和稳定等级。因此，我们会将它发布到稳定通道。
```
$ snapcraft push timg_20170226_amd64.snap
Pushing 'timg_20170226_amd64.snap' to the store.
Uploading timg_20170226_amd64.snap [ ] 0%
Uploading timg_20170226_amd64.snap [=======================================] 100%
Ready to release!|
Revision 6 of 'timg' created.
$ snapcraft release timg 6 stable
Track Arch Series Channel Version Revision
latest amd64 16 stable 20170226 6
candidate ^ ^
beta 0.9.5 5
edge 0.9.5 5
The 'stable' channel is now open.
```
我们把 .snap 包推送到 Ubuntu 商店后，得到了一个 `Revision 6`。然后，我们将 timg `Revision 6` 发布到了 Ubuntu 商店的稳定通道。
在候选通道中没有已发布的 snap 包，它继承的是稳定通道的包，所以显示 `^` 字符。
在之前的测试中，我将一些较老版本的 snap 包上传到了测试和边缘通道。这些旧版本使用了 timg 标签为 `0.9.5` 的源代码。
我们可以通过将稳定版本发布到测试和边缘通道来移除旧的 0.9.5 版本的包。
```
$ snapcraft release timg 6 beta
Track Arch Series Channel Version Revision
latest amd64 16 stable 20170226 6
candidate ^ ^
beta 20170226 6
edge 0.9.5 5
$ snapcraft release timg 6 edge
Track Arch Series Channel Version Revision
latest amd64 16 stable 20170226 6
candidate ^ ^
beta 20170226 6
edge 20170226 6
```
### 使用 timg
让我们不带参数运行 `timg`：
```
ubuntu@snaptesting:~$ timg
Expected image filename.
usage: /snap/timg/x1/timg [options] <image> [<image>...]
Options:
-g<w>x<h> : Output pixel geometry. Default from terminal 80x48
-s[<ms>] : Scroll horizontally (optionally: delay ms (60)).
-d<dx:dy> : delta x and delta y when scrolling (default: 1:0).
-w<seconds>: If multiple images given: Wait time between (default: 0.0).
-t<seconds>: Only animation or scrolling: stop after this time.
-c<num> : Only Animation or scrolling: number of runs through a full cycle.
-C : Clear screen before showing image.
-F : Print filename before showing picture.
-v : Print version and exit.
If both -c and -t are given, whatever comes first stops.
If both -w and -t are given for some animation/scroll, -t takes precedence
ubuntu@snaptesting:~$
```
这里提到当前我们终端模拟器的缩放级别，即分辨率为：80 × 48。
让我们缩小一点，并最大化 GNOME 终端窗口。
```
-g<w>x<h> : Output pixel geometry. Default from terminal 635x428
```
这是一个更好的解决方案，但我几乎看不到字符，因为他们太小了。让我们调用前面的命令再次显示这辆车。
你所看到的是调整后的图像（1080p）。虽然它是用彩色文本字符显示的，但看起来依旧很棒。
接下来呢？`timg` 其实也可以播放 gif 动画哦！
```
$ wget https://m.popkey.co/9b7141/QbAV_f-maxage-0.gif -O JonahHillAmazed.gif$ timg JonahHillAmazed.gif
```
你可以试着安装 `timg` 来体验 gif 动画。要是不想自己动手，可以在 [asciinema](https://asciinema.org/a/dezbe2gpye84e0pjndp8t0pvh) 上查看相关记录 （如果视频看上去起伏不定的，请重新运行它）。
谢谢阅读！
---
译者简介：
经常混迹于 snapcraft.io，对 Ubuntu Core、Snaps 和 Snapcraft 有着浓厚的兴趣，并致力于将这些还在快速发展的新技术通过翻译或原创的方式介绍到中文世界。有兴趣的小伙伴也可以关注译者个人公众号： `Snapcraft`
---
via：<https://blog.simos.info/how-to-create-a-snap-for-timg-with-snapcraft-on-ubuntu/>
作者：[Mi blog lah!](https://blog.simos.info/) 译者：[Snapcrafter](https://github.com/Snapcrafter) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开发一个 Linux 调试器（八）：堆栈展开
|
Simon Brand
|
https://blog.tartanllama.xyz/c++/2017/06/24/writing-a-linux-debugger-unwinding/
|
有一个 backtrace 命令，它给你提供了程序当前的函数调用链。这篇文章将向你展示如何在 x86_64 上实现堆栈展开以生成这样的回溯。
|
/data/attachment/album/201710/04/165839gmb9iqdiee2bh3m5.jpg.thumb.jpg
|
/data/attachment/album/201710/04/165839gmb9iqdiee2bh3m5.jpg
| true | false | true |
geekpi
| false |
[
"调试"
] |
软件开发
|
{
"viewnum": 4565,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8890,
"displayorder": 0
},
{
"raid": 8936,
"displayorder": 0
}
] |
有一个 backtrace 命令，它给你提供了程序当前的函数调用链。这篇文章将向你展示如何在 x86_64 上实现堆栈展开以生成这样的回溯。
| 2017-10-04T16:59:47 | 2017-10-04T16:59:47 | 8,930 |
/article-8930-1.html
|
有时你需要知道的最重要的信息是什么，你当前的程序状态是如何到达那里的。有一个 `backtrace` 命令，它给你提供了程序当前的函数调用链。这篇文章将向你展示如何在 x86\_64 上实现堆栈展开以生成这样的回溯。
### 系列索引
这些链接将会随着其他帖子的发布而上线。
1. [准备环境](/article-8626-1.html)
2. [断点](/article-8645-1.html)
3. [寄存器和内存](/article-8663-1.html)
4. [ELF 和 DWARF](/article-8719-1.html)
5. [源码和信号](/article-8812-1.html)
6. [源码级逐步执行](/article-8813-1.html)
7. [源码级断点](/article-8890-1.html)
8. [堆栈展开](https://blog.tartanllama.xyz/c++/2017/06/24/writing-a-linux-debugger-unwinding/)
9. 读取变量
10. 之后步骤
用下面的程序作为例子：
```
void a() {
//stopped here
}
void b() {
a();
}
void c() {
a();
}
int main() {
b();
c();
}
```
如果调试器停在 `//stopped here' 这行，那么有两种方法可以达到：`main->b->a`或`main->c->a`。如果我们用 LLDB 设置一个断点，继续执行并请求一个回溯，那么我们将得到以下内容：
```
* frame #0: 0x00000000004004da a.out`a() + 4 at bt.cpp:3
frame #1: 0x00000000004004e6 a.out`b() + 9 at bt.cpp:6
frame #2: 0x00000000004004fe a.out`main + 9 at bt.cpp:14
frame #3: 0x00007ffff7a2e830 libc.so.6`__libc_start_main + 240 at libc-start.c:291
frame #4: 0x0000000000400409 a.out`_start + 41
```
这说明我们目前在函数 `a` 中，`a` 从函数 `b` 中跳转，`b` 从 `main` 中跳转等等。最后两个帧是编译器如何引导 `main` 函数的。
现在的问题是我们如何在 x86\_64 上实现。最稳健的方法是解析 ELF 文件的 `.eh_frame` 部分，并解决如何从那里展开堆栈，但这会很痛苦。你可以使用 `libunwind` 或类似的来做，但这很无聊。相反，我们假设编译器以某种方式设置了堆栈，我们将手动遍历它。为了做到这一点，我们首先需要了解堆栈的布局。
```
High
| ... |
+---------+
+24| Arg 1 |
+---------+
+16| Arg 2 |
+---------+
+ 8| Return |
+---------+
EBP+--> |Saved EBP|
+---------+
- 8| Var 1 |
+---------+
ESP+--> | Var 2 |
+---------+
| ... |
Low
```
如你所见，最后一个堆栈帧的帧指针存储在当前堆栈帧的开始处，创建一个链接的指针列表。堆栈依据这个链表解开。我们可以通过查找 DWARF 信息中的返回地址来找出列表中下一帧的函数。一些编译器将忽略跟踪 `EBP` 的帧基址，因为这可以表示为 `ESP` 的偏移量，并可以释放一个额外的寄存器。即使启用了优化，传递 `-fno-omit-frame-pointer` 到 GCC 或 Clang 会强制它遵循我们依赖的约定。
我们将在 `print_backtrace` 函数中完成所有的工作：
```
void debugger::print_backtrace() {
```
首先要决定的是使用什么格式打印出帧信息。我用了一个 lambda 来推出这个方法：
```
auto output_frame = [frame_number = 0] (auto&& func) mutable {
std::cout << "frame #" << frame_number++ << ": 0x" << dwarf::at_low_pc(func)
<< ' ' << dwarf::at_name(func) << std::endl;
};
```
打印输出的第一帧是当前正在执行的帧。我们可以通过查找 DWARF 中的当前程序计数器来获取此帧的信息：
```
auto current_func = get_function_from_pc(get_pc());
output_frame(current_func);
```
接下来我们需要获取当前函数的帧指针和返回地址。帧指针存储在 `rbp` 寄存器中，返回地址是从帧指针堆栈起的 8 字节。
```
auto frame_pointer = get_register_value(m_pid, reg::rbp);
auto return_address = read_memory(frame_pointer+8);
```
现在我们拥有了展开堆栈所需的所有信息。我只需要继续展开，直到调试器命中 `main`，但是当帧指针为 `0x0` 时，你也可以选择停止，这些是你在调用 `main` 函数之前调用的函数。我们将从每帧抓取帧指针和返回地址，并打印出信息。
```
while (dwarf::at_name(current_func) != "main") {
current_func = get_function_from_pc(return_address);
output_frame(current_func);
frame_pointer = read_memory(frame_pointer);
return_address = read_memory(frame_pointer+8);
}
}
```
就是这样！以下是整个函数：
```
void debugger::print_backtrace() {
auto output_frame = [frame_number = 0] (auto&& func) mutable {
std::cout << "frame #" << frame_number++ << ": 0x" << dwarf::at_low_pc(func)
<< ' ' << dwarf::at_name(func) << std::endl;
};
auto current_func = get_function_from_pc(get_pc());
output_frame(current_func);
auto frame_pointer = get_register_value(m_pid, reg::rbp);
auto return_address = read_memory(frame_pointer+8);
while (dwarf::at_name(current_func) != "main") {
current_func = get_function_from_pc(return_address);
output_frame(current_func);
frame_pointer = read_memory(frame_pointer);
return_address = read_memory(frame_pointer+8);
}
}
```
### 添加命令
当然，我们必须向用户公开这个命令。
```
else if(is_prefix(command, "backtrace")) {
print_backtrace();
}
```
### 测试
测试此功能的一个方法是通过编写一个测试程序与一堆互相调用的小函数。设置几个断点，跳到代码附近，并确保你的回溯是准确的。
我们已经从一个只能产生并附加到其他程序的程序走了很长的路。本系列的倒数第二篇文章将通过支持读写变量来完成调试器的实现。在此之前，你可以在[这里](https://github.com/TartanLlama/minidbg/tree/tut_unwind)找到这个帖子的代码。
---
via: <https://blog.tartanllama.xyz/c++/2017/06/24/writing-a-linux-debugger-unwinding/>
作者：[Simon Brand](https://twitter.com/TartanLlama) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
DevOps 的意义
|
Matt Micene
|
https://opensource.com/open-organization/17/5/what-is-the-point-of-DevOps
|
真正的组织文化变革有助于弥合你原以为无法跨过的鸿沟
|
/data/attachment/album/201710/05/165152tpv8dpzjlb8121jl.png.thumb.jpg
|
/data/attachment/album/201710/05/165152tpv8dpzjlb8121jl.png
| true | false | true |
zhousiyu325
| false |
[
"DevOps",
"开放式组织"
] |
观点
|
{
"viewnum": 5627,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
真正的组织文化变革有助于弥合你原以为无法跨过的鸿沟
| 2017-10-05T16:51:48 | 2017-10-05T16:51:48 | 8,931 |
/article-8931-1.html
|
>
> 真正的组织文化变革有助于弥合你原以为无法跨过的鸿沟
>
>
>
回想一下你最近一次尝试改掉一个个人习惯的事情，你可能遇到过这样的情形，你需要改变你思考的方式并且改掉之前的习惯。这很艰难，你只能试着改变*你自己的*思维方式。
所以你可能会试着让自己置身于新的环境。新的环境实际上可帮助我们养成*新的*习惯，它反过来又会促成新的思维方式。
那就是能否成功改变的所在：思考的越多，得到的越多。你需要知道你在改变的原因以及你的目的所在（而不仅仅你要怎么做），因为改变本身往往是短暂和短视的。
现在想想你的 IT 组织需要做出的改变。也许你正在考虑采用像 DevOps 这样的东西。这个我们称之为 “DevOps” 的东西有三个组件：人、流程和工具。人和流程是*任何*团体组织的基础。因此，采用 DevOps 需要对大多数组织的核心进行根本性的改变，而不仅仅是学习新的工具。
如同其它的改变一样，它也是短视的。如果您将注意力集中在将改变作为单点解决方案 —— 例如，“获得更好的报警工具” —— 你可能只是管中窥豹。这种思维方式或许可以提供一套拥有更多铃声、口哨以及可以更好地处理呼叫轮询的工具，但是它不能解决这样的实际问题：警报不能送达到正确的团队，或者故障得不到解决，因为实际上没有人知道如何修复服务。
新的工具（或者至少一个新工具的想法）创造了一个讨论潜在问题的机会，可以让你的团队讨论对监控的看法。新工具让你能够做出更大的改变 —— 信仰和做法的改变 —— 它们作为你组织的基础而显得更加重要。
创造更深层次的变革需要一种可以全新地改变观念的方法。要找到这种方法，我们首先需要更好的理解变革的驱动力。
### 清除栅栏
>
> 就改革而言，它不同于推翻。这是一条直白且简单的原则，这个原则或许被视作悖论。在这种情况下，存在某种制度或法律；这么说吧，为了简单起见，在一条路上架设了一个栅栏或门。当今的改革者们来到这儿，并说：“我看不到它的用处，让我们把它清除掉。”更聪明的改革者会很好地回答：“如果你看不到它的用处，我肯定不会让你清除它，回去想想，然后你可以回来告诉我你知道了它的用处，我也许会允许你摧毁它。” — G.K Chesterton, 1929
>
>
>
为了了解对 DevOps 的需求 —— 它试图将传统意义上分开的开发部门和运维部门进行重新组合 —— 我们首先必须明白这个分开是如何产生的。一旦我们"知道了它的用处"，然后我们就会知道将它们分开是为了什么，并且在必要的时候可以取消分开。
今天我们没有一个单一的管理理论，但是大多数现代管理理论的起源可以追溯到<ruby> 弗雷德里克·温斯洛·泰勒 <rt> Frederick Winslow Taylor </rt></ruby>。泰勒是一名机械工程师，他创建了一个衡量钢厂工人效率的系统。泰勒认为，他可以对工厂的劳动者运用科学分析的方法，不仅可以改进个人任务，也证明发现了有一个可以用来执行*任何*任务最佳方法。
我们可以很容易地画一个以泰勒为起源的历史树。从泰勒早在 18 世纪 80 年代后期的研究出现的时间运动研究和其他质量改进计划，跨越 20 世纪 20 年代一直到今天，我们可以从中看到六西格玛、精益，等等类似方法。自上而下、指导式管理，再加上研究过程的系统方法，主宰了今天主流商业文化。它主要侧重于把效率作为工人成功的测量标准。
如果泰勒是我们这颗历史树的根，那么我们主干上的下一个主叉将是 20 世纪 20 年代通用汽车公司的<ruby> 阿尔弗雷德·斯隆 <rt> Alfred P. Sloan </rt></ruby>。通用汽车公司创造的斯隆结构不仅持续强劲到 21 世纪初，而且在未来五十年的大部分时间里，都将成为该公司的主要模式。
1920 年，通用公司正经历一场管理危机，或者说是缺乏管理的危机。斯隆向董事会写了一份为通用汽车的多个部门提出了一个新的结构《组织研究》。这一新结构的核心概念是“集中管理下放业务”。与雪佛兰，凯迪拉克和别克等品牌相关的各个部门将独立运作，同时为中央管理层提供推动战略和控制财务的手段。
在斯隆的建议下（以及后来就任 CEO 的指导下），通用汽车在美国汽车工业中占据了主导地位。斯隆的计划把一个处于灾难边缘公司创造成了一个非常成功的公司。从中间来看，自治单位是黑盒子，激励和目标被设置在顶层，而团队在底层推动。
泰勒思想的“最佳实践” —— 标准、可互换和可重复的行为 —— 仍然在今天的管理理念中占有一席之地，与斯隆公司结构的层次模式相结合，主导了僵化部门的分裂和孤岛化以实现最大的控制。
我们可以指出几份管理研究来证明这一点，但商业文化不是通过阅读书籍而创造和传播的。组织文化是 *真实的* 人在 *实际的* 情形下执行推动文化规范的 *具体的* 行为的产物。这就是为何类似泰勒和斯隆这样的理论变得固化而不可动摇的原因。
技术部门投资就是一个例子。以下是这个周期是如何循环的：投资者只投资于他们认为可以实现 *他们的* 特定成功观点的公司。这个成功的模式并不一定源于公司本身（和它的特定的目标）；它来自董事会对一家成功的公司 *应该* 如何看待的想法。许多投资者来自从经营企业的尝试和苦难中幸存下来的公司，因此他们对什么会使一个公司成功有 *不同的* 理念。他们为那些能够被教导模仿他们的成功模式的公司提供资金，希望获得资金的公司学会模仿。这样，初创公司孵化器就是一种重现理想的结构和文化的*直接的*方式。
“开发”和“运维”的分开不是因为人的原因，也不是因为不同的技能，或者放在新员工头上的一顶魔法分院帽；它是泰勒和斯隆的理论的副产品。责任与人员之间的清晰而不可渗透的界线是一个管理功能，同时也注重员工的工作效率。管理上的分开可以很容易的落在产品或者项目界线上，而不是技能上，但是通过今天的业务管理理论的历史告诉我们，基于技能的分组是“最好”的高效方式。
不幸的是，那些界线造成了紧张局势，这些紧张局势是由不同的管理链出于不同的目标设定的相反目标的直接结果。例如：
* 敏捷 ⟷ 稳定
* 吸引新用户 ⟷ 现有用户的体验
* 让应用程序增加新功能 ⟷ 让应用程序保持可用
* 打败竞争对手 ⟷ 维持收入
* 修复出现的问题 ⟷ 在问题出现之前就进行预防
今天，我们可以看到组织的高层领导人越来越认识到，现有的商业文化（并扩大了它所产生的紧张局势）是一个严重的问题。在 2016 年的 Gartner 报告中，57％ 的受访者表示，文化变革是 2020 年之前企业面临的主要挑战之一。像作为一种影响组织变革的手段的敏捷和 DevOps 这样的新方法的兴起反映了这一认识。“[影子 IT](https://thenewstack.io/parity-check-dont-afraid-shadow-yet/)” 的出现更是事物的另一个方面；最近的估计有将近 30％ 的 IT 支出在 IT 组织的控制之外。
这些只是企业正在面临的一些“文化担忧”。改变的必要性是明确的，但前进的道路仍然受到昨天的决定的约束。
### 抵抗并不是没用的
>
> Bert Lance 认为如果他能让政府采纳一条简单的格言“如果东西还没损坏，那就别去修理它”，他就可以为国家节省三十亿。他解释说：“这是政府的问题：‘修复没有损坏的东西，而不是修复已经损坏了的东西。’” — Nation's Business, 1977.5
>
>
>
通常，改革是组织针对所出现的错误所做的应对。在这个意义上说，如果紧张局势（即使逆境）是变革的正常催化剂，那么对变化的 *抵抗* 就是成功的指标。但是过分强调成功的道路会使组织变得僵硬、衰竭和独断。重视有效结果的政策导向是这种不断增长的僵局的症状。
传统 IT 部门的成功加剧了 IT 孤岛的壁垒。其他部门现在变成了“顾客”，而不是伙伴。试图将 IT 从成本中心转移出来创建一个新的操作模式，它可以将 IT 与其他业务目标断开。这反过来又会对敏捷性造成限制，增加摩擦，降低反应能力。合作被搁置转而偏向“专家方向”。结果是一个孤立主义的观点，IT 只能带来更多的伤害而不是好处。
正如“软件吃掉世界”，IT 越来越成为组织整体成功的核心。具有前瞻性的 IT 组织认识到这一点，并且已经对其战略规划进行了有意义的改变，而不是将改变视为恐惧。
例如，Facebook 与人类学家<ruby> 罗宾·邓巴 <rt> Robin Dunbar </rt></ruby>就社会团体的方法进行了磋商，而且意识到这一点对公司成长的内部团体（不仅仅是该网站的外部用户）的影响。<ruby> 扎波斯 <rt> Zappos </rt></ruby>的文化得到了很多的赞誉，该组织创立了一个部门，专注于培养他人对于核心价值观和企业文化的看法。当然，这本书是 《开放式组织》的姊妹篇，那是一本描述被应用于管理的开放原则 —— 透明度、参与度和社区 —— 可以如何为我们快节奏的互联时代重塑组织。
### 决心改变
>
> “如果外界的变化率超过了内部的变化率，那末日就不远了。” — Jack Welch, 2004
>
>
>
一位同事曾经告诉我他可以只用 “[信息技术基础设施库（ITIL）](https://en.wikipedia.org/wiki/ITIL)” 框架里面的词汇向一位项目经理解释 DevOps。
虽然这些框架 *似乎* 是反面的，但实际上它们都集中在风险和变革管理上。它们简单地介绍了这种管理的不同流程和工具。在 IT 圈子外面谈论 DevOps 时，这一点需要注意。不要强调流程问题和故障，而是显示更小的变化引起的风险 *更小* 等等。这是强调改变团队文化的有益方式：专注于 *新的* 功能而不是老问题，是改变的有效中介，特别是当您采用别人的框架进行参考时。
改革不仅仅只是 *重构* 组织；它也是跨越历史上不可跨越的鸿沟的新途径 —— 通过拒绝把像“敏捷”和“稳定”这样的东西作为互相排斥的力量来解决我之前提到的那些紧张局势。建立注重 *结果* 胜过 *功能* 的跨部门团队是一个有效的策略。把不同的团队 —— 其中每个人的工作依赖于其他人 —— 聚集起来围绕一个项目或目标是最常见的方法之一。消除这些团队之间的摩擦和改善沟通能够产生巨大的改进 —— 即使在坚持铁仓管理结构时（如果可以掌握，则不需要拆除孤岛）。在这些情况下，对改革的 *抵抗* 不是成功的一个指标；而对改革的拥抱才是。
这些也不是“最佳实例”，它们只是一种检查你自己的栅栏的方式。每个组织都会有独特的、由他们内部人员创造的栅栏。一旦你“知道了它的用途”，你就可以决定它是需要拆解还是掌握。
*本文是 Opensource.com 即将推出的关于开放组织和 IT 文化指南的一部分。[你可以在这注册以便当它发布时收到通知](https://opensource.com/open-organization/resources/book-series)。*
（题图 : opensource.com）
---
作者简介：
Matt Micene 是 Red Hat 公司的 Linux 和容器传播者。从架构和系统设计到数据中心设计，他在信息技术方面拥有超过 15 年的经验。他对关键技术（如容器，云计算和虚拟化）有深入的了解。他目前的重点是宣传红帽企业版 Linux，以及操作系统如何与计算环境的新时代相关。
---
via: <https://opensource.com/open-organization/17/5/what-is-the-point-of-DevOps>
作者：[Matt Micene](https://opensource.com/users/matt-micene) 译者：[zhousiyu325](https://github.com/zhousiyu325) 校对：[apemost](https://github.com/apemost)，[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
OpenGL 与 Go 教程（一）Hello, OpenGL
|
Kylewbanks
|
https://kylewbanks.com/blog/tutorial-opengl-with-golang-part-1-hello-opengl
|
这个教程的目的是给你一个切入点，让你对 OpenGL 有个基本的了解，然后教你怎么用 Go 操作它。我们最终的目标是用 OpenGL 在桌面窗口绘制游戏面板，进而实现康威生命游戏。
|
/data/attachment/album/201710/05/212715clrssdrurc8nnras.jpg.thumb.jpg
|
/data/attachment/album/201710/05/212715clrssdrurc8nnras.jpg
| true | false | true |
BriFuture
| false |
[
"OpenGL"
] |
软件开发
|
{
"viewnum": 21833,
"commentnum": 3,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "101.44.2.90",
"message": "在macOS High Sierra上需要移动一下窗口才能看见三角形",
"username": "来自上海的 Chrome 71.0|Mac 10.14 用户",
"date": "2019-01-07T12:56:37"
},
{
"postip": "114.244.2.205",
"message": "go . opengl 绘制点 线 是这样写的 gl.COLOR = 0xff0000<br />\r\n gl.COLOR_ATTACHMENT3(1.0, 0.0, 0.0)<br />\r\n gl.BeginConditionalRender(aa, gl.POINTS)<br />\r\n gl.VertexAttrib2f(0, 0.0, 0.0)<br />\r\n gl.VertexAttrib2f(0, 0.1, 0.1)<br />\r\n gl.VertexAttrib2f(0, 0.1, 0.2)<br />\r\n gl.VertexAttrib2f(0, 0.1, 0.3)<br />\r\n gl.VertexAttrib2f(0, 0.1, 0.4)<br />\r\n gl.EndConditionalRender()<br />\r\n gl.Flush()",
"username": "来自北京的 Chrome 73.0|Mac 10.13 用户",
"date": "2019-04-15T15:14:35"
},
{
"postip": "183.14.29.152",
"message": "这是固定管线的写法。4.1的可编程管线，要用VBO传入顶点数据！",
"username": "来自广东深圳的 Chrome 100.0|Windows 10 用户",
"date": "2022-04-07T18:07:02"
}
] |
[
{
"raid": 8937,
"displayorder": 0
}
] |
这个教程的目的是给你一个切入点，让你对 OpenGL 有个基本的了解，然后教你怎么用 Go 操作它。我们最终的目标是用 OpenGL 在桌面窗口绘制游戏面板，进而实现康威生命游戏。
| 2017-10-05T21:27:00 | 2017-10-05T21:27:00 | 8,933 |
/article-8933-1.html
|
* [第一节: Hello, OpenGL](/article-8933-1.html)
* [第二节: 绘制游戏面板](/article-8937-1.html)
* [第三节：实现游戏功能](/article-8969-1.html)
这篇教程的所有源代码都可以在 [GitHub](https://github.com/KyleBanks/conways-gol) 上找到。
### 介绍
[OpenGL](https://www.opengl.org/) 是一门相当好的技术，适用于从桌面的 GUI 到游戏，到移动应用甚至 web 应用的多种类型的绘图工作。我敢保证，你今天看到的图形有些就是用 OpenGL 渲染的。可是，不管 OpenGL 多受欢迎、有多好用，与学习其它高级绘图库相比，学习 OpenGL 是要相当足够的决心的。
这个教程的目的是给你一个切入点，让你对 OpenGL 有个基本的了解，然后教你怎么用 [Go](https://golang.org/) 操作它。几乎每种编程语言都有绑定 OpenGL 的库，Go 也不例外，它有 [go-gl](https://github.com/go-gl/gl) 这个包。这是一个完整的套件，可以绑定 OpenGL ，适用于多种版本的 OpenGL。
这篇教程会按照下面列出的几个阶段进行介绍，我们最终的目标是用 OpenGL 在桌面窗口绘制游戏面板，进而实现[康威生命游戏](https://en.wikipedia.org/wiki/Conway's_Game_of_Life)。完整的源代码可以在 GitHub [github.com/KyleBanks/conways-gol](https://github.com/KyleBanks/conways-gol) 上获得，当你有疑惑的时候可以随时查看源代码，或者你要按照自己的方式学习也可以参考这个代码。
在我们开始之前，我们要先弄明白<ruby> 康威生命游戏 <rt> Conway's Game of Life </rt></ruby> 到底是什么。这里是 [Wikipedia](https://en.wikipedia.org/wiki/Conway's_Game_of_Life) 上面的总结：
>
> 《生命游戏》，也可以简称为 Life，是一个细胞自动变化的过程，由英国数学家 John Horton Conway 于 1970 年提出。
>
>
> 这个“游戏”没有玩家，也就是说它的发展依靠的是它的初始状态，不需要输入。用户通过创建初始配置文件、观察它如何演变，或者对于高级“玩家”可以创建特殊属性的模式，进而与《生命游戏》进行交互。
>
>
> `规则`
>
>
> 《生命游戏》的世界是一个无穷多的二维正交的正方形细胞的格子世界，每一个格子都有两种可能的状态，“存活”或者“死亡”，也可以说是“填充态”或“未填充态”（区别可能很小，可以把它看作一个模拟人类/哺乳动物行为的早期模型，这要看一个人是如何看待方格里的空白）。每一个细胞与它周围的八个细胞相关联，这八个细胞分别是水平、垂直、斜对角相接的。在游戏中的每一步，下列事情中的一件将会发生：
>
>
> 1. 当任何一个存活的细胞的附近少于 2 个存活的细胞时，该细胞将会消亡，就像人口过少所导致的结果一样
> 2. 当任何一个存活的细胞的附近有 2 至 3 个存活的细胞时，该细胞在下一代中仍然存活。
> 3. 当任何一个存活的细胞的附近多于 3 个存活的细胞时，该细胞将会消亡，就像人口过多所导致的结果一样
> 4. 任何一个消亡的细胞附近刚好有 3 个存活的细胞，该细胞会变为存活的状态，就像重生一样。
>
>
>
不需要其他工具，这里有一个我们将会制作的演示程序：
在我们的运行过程中，白色的细胞表示它是存活着的，黑色的细胞表示它已经死亡。
### 概述
本教程将会涉及到很多基础内容，从最基本的开始，但是你还是要对 Go 由一些最基本的了解 —— 至少你应该知道变量、切片、函数和结构体，并且装了一个 Go 的运行环境。我写这篇教程用的 Go 版本是 1.8，但它应该与之前的版本兼容。这里用 Go 语言实现没有什么特别新奇的东西，因此只要你有过类似的编程经历就行。
这里是我们在这个教程里将会讲到的东西：
* [第一节: Hello, OpenGL](https://kylewbanks.com/blog/tutorial-opengl-with-golang-part-1-hello-opengl)： 安装 OpenGL 和 [GLFW](http://www.glfw.org/)，在窗口上绘制一个三角形。
* [第二节: 绘制游戏面板](https://kylewbanks.com/blog/tutorial-opengl-with-golang-part-2-drawing-the-game-board)： 用三角形拼成方形，在窗口上用方形绘成格子。
* [第三节: 实现游戏功能](https://kylewbanks.com/blog/blog/tutorial-opengl-with-golang-part-3-implementing-the-game)： 实现 Conway 游戏
最后的源代码可以在 [GitHub](https://github.com/KyleBanks/conways-gol) 上获得，每一节的末尾有个*回顾*，包含该节相关的代码。如果有什么不清楚的地方或者是你感到疑惑的，看看每一节末尾的完整代码。
现在就开始吧！
### 安装 OpenGL 和 GLFW
我们介绍过 OpenGL，但是为了使用它，我们要有个窗口可以绘制东西。 [GLFW](http://www.glfw.org/) 是一款用于 OpenGL 的跨平台 API，允许我们创建并使用窗口，而且它也是 [go-gl](https://github.com/go-gl/glfw) 套件中提供的。
我们要做的第一件事就是确定 OpenGL 的版本。为了方便本教程，我们将会使用 `OpenGL v4.1`，但要是你的操作系统不支持最新的 OpenGL，你也可以用 `v2.1`。要安装 OpenGL，我们需要做这些事：
```
# 对于 OpenGL 4.1
$ go get github.com/go-gl/gl/v4.1-core/gl
# 或者 2.1
$ go get github.com/go-gl/gl/v2.1/gl
```
然后是安装 GLFW：
```
$ go get github.com/go-gl/glfw/v3.2/glfw
```
安装好这两个包之后，我们就可以开始了！先创建 `main.go` 文件，导入相应的包（我们待会儿会用到的其它东西）。
```
package main
import (
"log"
"runtime"
"github.com/go-gl/gl/v4.1-core/gl" // OR: github.com/go-gl/gl/v2.1/gl
"github.com/go-gl/glfw/v3.2/glfw"
)
```
接下来定义一个叫做 `main` 的函数，这是用来初始化 OpenGL 以及 GLFW，并显示窗口的：
```
const (
width = 500
height = 500
)
func main() {
runtime.LockOSThread()
window := initGlfw()
defer glfw.Terminate()
for !window.ShouldClose() {
// TODO
}
}
// initGlfw 初始化 glfw 并且返回一个可用的窗口。
func initGlfw() *glfw.Window {
if err := glfw.Init(); err != nil {
panic(err)
}
glfw.WindowHint(glfw.Resizable, glfw.False)
glfw.WindowHint(glfw.ContextVersionMajor, 4) // OR 2
glfw.WindowHint(glfw.ContextVersionMinor, 1)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
window, err := glfw.CreateWindow(width, height, "Conway's Game of Life", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
return window
}
```
好了，让我们花一分钟来运行一下这个程序，看看会发生什么。首先定义了一些常量， `width` 和 `height` —— 它们决定窗口的像素大小。
然后就是 `main` 函数。这里我们使用了 `runtime` 包的 `LockOSThread()`，这能确保我们总是在操作系统的同一个线程中运行代码，这对 GLFW 来说很重要，GLFW 需要在其被初始化之后的线程里被调用。讲完这个，接下来我们调用 `initGlfw` 来获得一个窗口的引用，并且推迟（`defer`）其终止。窗口的引用会被用在一个 `for` 循环中，只要窗口处于打开的状态，就执行某些事情。我们待会儿会讲要做的事情是什么。
`initGlfw` 是另一个函数，这里我们调用 `glfw.Init()` 来初始化 GLFW 包。然后我们定义了 GLFW 的一些全局属性，包括禁用调整窗口大小和改变 OpenGL 的属性。然后创建了 `glfw.Window`，这会在稍后的绘图中用到。我们仅仅告诉它我们想要的宽度和高度，以及标题，然后调用 `window.MakeContextCurrent`，将窗口绑定到当前的线程中。最后就是返回窗口的引用了。
如果你现在就构建、运行这个程序，你看不到任何东西。很合理，因为我们还没有用这个窗口做什么实质性的事。
定义一个新函数，初始化 OpenGL，就可以解决这个问题：
```
// initOpenGL 初始化 OpenGL 并且返回一个初始化了的程序。
func initOpenGL() uint32 {
if err := gl.Init(); err != nil {
panic(err)
}
version := gl.GoStr(gl.GetString(gl.VERSION))
log.Println("OpenGL version", version)
prog := gl.CreateProgram()
gl.LinkProgram(prog)
return prog
}
```
`initOpenGL` 就像之前的 `initGlfw` 函数一样，初始化 OpenGL 库，创建一个<ruby> 程序 <rt> program </rt></ruby>。“程序”是一个包含了<ruby> 着色器 <rt> shader </rt></ruby>的引用，稍后会用<ruby> 着色器 <rt> shader </rt></ruby>绘图。待会儿会讲这一点，现在只用知道 OpenGL 已经初始化完成了，我们有一个程序的引用。我们还打印了 OpenGL 的版本，可以用于之后的调试。
回到 `main` 函数里，调用这个新函数：
```
func main() {
runtime.LockOSThread()
window := initGlfw()
defer glfw.Terminate()
program := initOpenGL()
for !window.ShouldClose() {
draw(window, program)
}
}
```
你应该注意到了现在我们有 `program` 的引用，在我们的窗口循环中，调用新的 `draw` 函数。最终这个函数会绘制出所有细胞，让游戏状态变得可视化，但是现在它做的仅仅是清除窗口，所以我们只能看到一个全黑的屏幕：
```
func draw(window *glfw.Window, program uint32) {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.UseProgram(prog)
glfw.PollEvents()
window.SwapBuffers()
}
```
我们首先做的是调用 `gl.clear` 函数来清除上一帧在窗口中绘制的东西，给我们一个干净的面板。然后我们告诉 OpenGL 去使用我们的程序引用，这个引用还没有做什么事。最终我们告诉 GLFW 用 `PollEvents` 去检查是否有鼠标或者键盘事件（这一节里还不会对这些事件进行处理），告诉窗口去交换缓冲区 `SwapBuffers`。 [交换缓冲区](http://www.glfw.org/docs/latest/window_guide.html#buffer_swap) 很重要，因为 GLFW（像其他图形库一样）使用双缓冲，也就是说你绘制的所有东西实际上是绘制到一个不可见的画布上，当你准备好进行展示的时候就把绘制的这些东西放到可见的画布中 —— 这种情况下，就需要调用 `SwapBuffers` 函数。
好了，到这里我们已经讲了很多东西，花一点时间看看我们的实验成果。运行这个程序，你应该可以看到你所绘制的第一个东西：
完美！
### 在窗口里绘制三角形
我们已经完成了一些复杂的步骤，即使看起来不多，但我们仍然需要绘制一些东西。我们会以三角形绘制开始，可能这第一眼看上去要比我们最终要绘制的方形更难，但你会知道这样的想法是错的。你可能不知道的是三角形或许是绘制的图形中最简单的，实际上我们最终会用某种方式把三角形拼成方形。
好吧，那么我们想要绘制一个三角形，怎么做呢？我们通过定义图形的顶点来绘制图形，把它们交给 OpenGL 来进行绘制。先在 `main.go` 的顶部里定义我们的三角形：
```
var (
triangle = []float32{
0, 0.5, 0, // top
-0.5, -0.5, 0, // left
0.5, -0.5, 0, // right
}
)
```
这看上去很奇怪，让我们分开来看。首先我们用了一个 `float32` <ruby> 切片 <rt> slice </rt></ruby>，这是一种我们总会在向 OpenGL 传递顶点时用到的数据类型。这个切片包含 9 个值，每三个值构成三角形的一个点。第一行， `0, 0.5, 0` 表示的是 X、Y、Z 坐标，是最上方的顶点，第二行是左边的顶点，第三行是右边的顶点。每一组的三个点都表示相对于窗口中心点的 X、Y、Z 坐标，大小在 `-1` 和 `1` 之间。因此最上面的顶点 X 坐标是 `0`，因为它在 X 方向上位于窗口中央，Y 坐标是 `0.5` 意味着它会相对窗口中央上移 1/4 个单位（因为窗口的范围是 `-1` 到 `1`），Z 坐标是 0。因为我们只需要在二维空间中绘图，所以 Z 值永远是 `0`。现在看一看左右两边的顶点，看看你能不能理解为什么它们是这样定义的 —— 如果不能立刻就弄清楚也没关系，我们将会在屏幕上去观察它，因此我们需要一个完美的图形来进行观察。
好了，我们定义了一个三角形，但是现在我们得把它画出来。要画出这个三角形，我们需要一个叫做<ruby> 顶点数组对象 <rt> Vertex Array Object </rt></ruby>或者叫 vao 的东西，这是由一系列的点（也就是我们定义的三角形）创造的，这个东西可以提供给 OpenGL 来进行绘制。创建一个叫做 `makeVao` 的函数，然后我们可以提供一个点的切片，让它返回一个指向 OpenGL 顶点数组对象的指针：
```
// makeVao 执行初始化并从提供的点里面返回一个顶点数组
func makeVao(points []float32) uint32 {
var vbo uint32
gl.GenBuffers(1, &vbo)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, 4*len(points), gl.Ptr(points), gl.STATIC_DRAW)
var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
gl.EnableVertexAttribArray(0)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 0, nil)
return vao
}
```
首先我们创造了<ruby> 顶点缓冲区对象 <rt> Vertex Buffer Object </rt></ruby> 或者说 vbo 绑定到我们的 `vao` 上，`vbo` 是通过所占空间（也就是 4 倍 `len(points)` 大小的空间）和一个指向顶点的指针（`gl.Ptr(points)`）来创建的。你也许会好奇为什么它是 4 倍 —— 而不是 6 或者 3 或者 1078 呢？原因在于我们用的是 `float32` 切片，32 个位的浮点型变量是 4 个字节，因此我们说这个缓冲区以字节为单位的大小是点个数的 4 倍。
现在我们有缓冲区了，可以创建 `vao` 并用 `gl.BindBuffer` 把它绑定到缓冲区上，最后返回 `vao`。这个 `vao` 将会被用于绘制三角形！
回到 `main` 函数：
```
func main() {
...
vao := makeVao(triangle)
for !window.ShouldClose() {
draw(vao, window, program)
}
}
这里我们调用了 `makeVao` ，从我们之前定义的 `triangle` 顶点中获得 `vao` 引用，将它作为一个新的参数传递给 `draw` 函数：
func draw(vao uint32, window *glfw.Window, program uint32) {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.UseProgram(program)
gl.BindVertexArray(vao)
gl.DrawArrays(gl.TRIANGLES, 0, int32(len(triangle) / 3))
glfw.PollEvents()
window.SwapBuffers()
}
```
然后我们把 OpenGL 绑定到 `vao` 上，这样当我们告诉 OpenGL 三角形切片的顶点数（除以 3，是因为每一个点有 X、Y、Z 坐标），让它去 `DrawArrays` ，它就知道要画多少个顶点了。
如果你这时候运行程序，你可能希望在窗口中央看到一个美丽的三角形，但是不幸的是你还看不到。还有一件事情没做，我们告诉 OpenGL 我们要画一个三角形，但是我们还要告诉它*怎么*画出来。
要让它画出来，我们需要叫做<ruby> 片元着色器 <rt> fragment shader </rt></ruby>和<ruby> 顶点着色器 <rt> vertex shader </rt></ruby>的东西，这些已经超出本教程的范围了（老实说，也超出了我对 OpenGL 的了解），但 [Harold Serrano 在 Quora](https://www.quora.com/What-is-a-vertex-shader-and-what-is-a-fragment-shader/answer/Harold-Serrano?srid=aVb) 上对对它们是什么给出了完美的介绍。我们只需要理解，对于这个应用来说，着色器是它内部的小程序（用 [OpenGL Shader Language 或 GLSL](https://www.opengl.org/sdk/docs/tutorials/ClockworkCoders/glsl_overview.php) 编写的），它操作顶点进行绘制，也可用于确定图形的颜色。
添加两个 `import` 和一个叫做 `compileShader` 的函数：
```
import (
"strings"
"fmt"
)
func compileShader(source string, shaderType uint32) (uint32, error) {
shader := gl.CreateShader(shaderType)
csources, free := gl.Strs(source)
gl.ShaderSource(shader, 1, csources, nil)
free()
gl.CompileShader(shader)
var status int32
gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status)
if status == gl.FALSE {
var logLength int32
gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength)
log := strings.Repeat("\x00", int(logLength+1))
gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log))
return 0, fmt.Errorf("failed to compile %v: %v", source, log)
}
return shader, nil
}
```
这个函数的目的是以字符串的形式接受着色器源代码和它的类型，然后返回一个指向这个编译好的着色器的指针。如果编译失败，我们就会获得出错的详细信息。
现在定义着色器，在 `makeProgram` 里编译。回到我们的 `const` 块中，我们在这里定义了 `width` 和 `hegiht`。
```
vertexShaderSource = `
#version 410
in vec3 vp;
void main() {
gl_Position = vec4(vp, 1.0);
}
` + "\x00"
fragmentShaderSource = `
#version 410
out vec4 frag_colour;
void main() {
frag_colour = vec4(1, 1, 1, 1);
}
` + "\x00"
```
如你所见，这是两个包含了 GLSL 源代码字符串的着色器，一个是<ruby> 顶点着色器 <rt> vertex shader </rt></ruby>，另一个是<ruby> 片元着色器 <rt> fragment shader </rt></ruby>。唯一比较特殊的地方是它们都要在末尾加上一个空终止字符，`\x00` —— OpenGL 需要它才能编译着色器。注意 `fragmentShaderSource`，这是我们用 RGBA 形式的值通过 `vec4` 来定义我们图形的颜色。你可以修改这里的值来改变这个三角形的颜色，现在的值是 `RGBA(1, 1, 1, 1)` 或者说是白色。
同样需要注意的是这两个程序都是运行在 `#version 410` 版本下，如果你用的是 OpenGL 2.1，那你也可以改成 `#version 120`。这里 `120` 不是打错的，如果你用的是 OpenGL 2.1，要用 `120` 而不是 `210`！
接下来在 `initOpenGL` 中我们会编译着色器，把它们附加到我们的 `program` 中。
```
func initOpenGL() uint32 {
if err := gl.Init(); err != nil {
panic(err)
}
version := gl.GoStr(gl.GetString(gl.VERSION))
log.Println("OpenGL version", version)
vertexShader, err := compileShader(vertexShaderSource, gl.VERTEX_SHADER)
if err != nil {
panic(err)
}
fragmentShader, err := compileShader(fragmentShaderSource, gl.FRAGMENT_SHADER)
if err != nil {
panic(err)
}
prog := gl.CreateProgram()
gl.AttachShader(prog, vertexShader)
gl.AttachShader(prog, fragmentShader)
gl.LinkProgram(prog)
return prog
}
```
这里我们用顶点着色器（`vertexShader`）调用了 `compileShader` 函数，指定它的类型是 `gl.VERTEX_SHADER`，对片元着色器（`fragmentShader`）做了同样的事情，但是指定的类型是 `gl.FRAGMENT_SHADER`。编译完成后，我们把它们附加到程序中，调用 `gl.AttachShader`，传递程序（`prog`）以及编译好的着色器作为参数。
现在我们终于可以看到我们漂亮的三角形了！运行程序，如果一切顺利的话你会看到这些：
### 总结
是不是很惊喜！这些代码画出了一个三角形，但我保证我们已经完成了大部分的 OpenGL 代码，在接下来的章节中我们还会用到这些代码。我十分推荐你花几分钟修改一下代码，看看你能不能移动三角形，改变三角形的大小和颜色。OpenGL 可以令人心生畏惧，有时想要理解发生了什么很困难，但是要记住，这不是魔法 - 它只不过看上去像魔法。
下一节里我们讲会用两个锐角三角形拼出一个方形 - 看看你能不能在进入下一节前试着修改这一节的代码。不能也没有关系，因为我们在 [第二节](https://kylewbanks.com/blog/tutorial-opengl-with-golang-part-2-drawing-the-game-board) 还会编写代码， 接着创建一个有许多方形的格子，我们把它当做游戏面板。
最后，在[第三节](https://kylewbanks.com/blog/tutorial-opengl-with-golang-part-3-implementing-the-game) 里我们会用格子来实现 *Conway’s Game of Life*！
### 回顾
本教程 `main.go` 文件的内容如下：
```
package main
import (
"fmt"
"log"
"runtime"
"strings"
"github.com/go-gl/gl/v4.1-core/gl" // OR: github.com/go-gl/gl/v2.1/gl
"github.com/go-gl/glfw/v3.2/glfw"
)
const (
width = 500
height = 500
vertexShaderSource = `
#version 410
in vec3 vp;
void main() {
gl_Position = vec4(vp, 1.0);
}
` + "\x00"
fragmentShaderSource = `
#version 410
out vec4 frag_colour;
void main() {
frag_colour = vec4(1, 1, 1, 1.0);
}
` + "\x00"
)
var (
triangle = []float32{
0, 0.5, 0,
-0.5, -0.5, 0,
0.5, -0.5, 0,
}
)
func main() {
runtime.LockOSThread()
window := initGlfw()
defer glfw.Terminate()
program := initOpenGL()
vao := makeVao(triangle)
for !window.ShouldClose() {
draw(vao, window, program)
}
}
func draw(vao uint32, window *glfw.Window, program uint32) {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.UseProgram(program)
gl.BindVertexArray(vao)
gl.DrawArrays(gl.TRIANGLES, 0, int32(len(triangle)/3))
glfw.PollEvents()
window.SwapBuffers()
}
// initGlfw 初始化 glfw 并返回一个窗口供使用。
func initGlfw() *glfw.Window {
if err := glfw.Init(); err != nil {
panic(err)
}
glfw.WindowHint(glfw.Resizable, glfw.False)
glfw.WindowHint(glfw.ContextVersionMajor, 4)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
window, err := glfw.CreateWindow(width, height, "Conway's Game of Life", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
return window
}
// initOpenGL 初始化 OpenGL 并返回一个已经编译好的着色器程序
func initOpenGL() uint32 {
if err := gl.Init(); err != nil {
panic(err)
}
version := gl.GoStr(gl.GetString(gl.VERSION))
log.Println("OpenGL version", version)
vertexShader, err := compileShader(vertexShaderSource, gl.VERTEX_SHADER)
if err != nil {
panic(err)
}
fragmentShader, err := compileShader(fragmentShaderSource, gl.FRAGMENT_SHADER)
if err != nil {
panic(err)
}
prog := gl.CreateProgram()
gl.AttachShader(prog, vertexShader)
gl.AttachShader(prog, fragmentShader)
gl.LinkProgram(prog)
return prog
}
// makeVao 执行初始化并从提供的点里面返回一个顶点数组
func makeVao(points []float32) uint32 {
var vbo uint32
gl.GenBuffers(1, &vbo)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, 4*len(points), gl.Ptr(points), gl.STATIC_DRAW)
var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
gl.EnableVertexAttribArray(0)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 0, nil)
return vao
}
func compileShader(source string, shaderType uint32) (uint32, error) {
shader := gl.CreateShader(shaderType)
csources, free := gl.Strs(source)
gl.ShaderSource(shader, 1, csources, nil)
free()
gl.CompileShader(shader)
var status int32
gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status)
if status == gl.FALSE {
var logLength int32
gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength)
log := strings.Repeat("\x00", int(logLength+1))
gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log))
return 0, fmt.Errorf("failed to compile %v: %v", source, log)
}
return shader, nil
}
```
请在 Twitter [@kylewbanks](https://twitter.com/kylewbanks) 上告诉我这篇文章对你是否有帮助，或者点击下方的关注，以便及时获取最新文章！
---
via: <https://kylewbanks.com/blog/tutorial-opengl-with-golang-part-1-hello-opengl>
作者：[kylewbanks](https://twitter.com/kylewbanks) 译者：[GitFuture](https://github.com/GitFuture) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
关于 Linux 你可能不是非常了解的七件事
|
Phil Zona
|
http://opensourceforu.com/2017/09/top-7-things-linux-may-not-known-far/
|
使用 Linux 最酷的事情之一就是随着时间的推移，你可以不断获得新的知识。每天，你都可能会遇到一个新的实用工具，或者只是一个不太熟悉的奇技淫巧，但是却非常有用。这些零碎的东西并不总是能够改变生活，但是却是专业知识的基础。
|
/data/attachment/album/201710/05/220827fgbirkfifb5jrkab.jpg.thumb.jpg
|
/data/attachment/album/201710/05/220827fgbirkfifb5jrkab.jpg
| true | false | true |
ucasFL
| false |
[
"命令行"
] |
技术
|
{
"viewnum": 9688,
"commentnum": 1,
"favtimes": 7,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "61.186.24.180",
"message": "学习的快乐！",
"username": "观海台 [Safari 11.0|Mac 10.11]",
"date": "2017-10-07T10:26:13"
}
] |
[] |
使用 Linux 最酷的事情之一就是随着时间的推移，你可以不断获得新的知识。每天，你都可能会遇到一个新的实用工具，或者只是一个不太熟悉的奇技淫巧，但是却非常有用。这些零碎的东西并不总是能够改变生活，但是却是专业知识的基础。
| 2017-10-05T22:08:21 | 2017-10-05T22:08:21 | 8,934 |
/article-8934-1.html
|
使用 Linux 最酷的事情之一就是随着时间的推移，你可以不断获得新的知识。每天，你都可能会遇到一个新的实用工具，或者只是一个不太熟悉的奇技淫巧，但是却非常有用。这些零碎的东西并不总是能够改变生活，但是却是专业知识的基础。
即使是专家，也不可能事事皆知。无论你有多少经验，可能总会有更多的东西需要你去学习。所以，在这儿我列出了七件关于 Linux 你可能不知道的事情。
### 一个查找命令历史的交互模式
你可能对 `history` 命令非常熟悉，它会读取 bash 历史，然后以编号列表的方式输出到标准输出（`stdout`）。然而，如果你在 `curl` 命令的海洋里寻找一个特定的链接（URL），那么这个列表并不总是那么容易阅读的。
你还可以有另一个选择，Linux 有一个交互式的反向搜索可以帮助你解决这个问题。你可以通过快捷键 `ctrl+r`启动交互模式，然后进入一个交互提示中，它将会根据你提供的字符串来向后搜索 bash 历史，你可以通过再次按下 `ctrl+r` 向后搜索更老的命令，或者按下 `ctrl+s` 向前搜索。
注意，`ctrl+s` 有时会与 XON/XOFF 流控制冲突，即 XON/XOFF 流控制也会使用该快捷键。你可以通过运行 `stty -ixon` 命令来禁用该快捷键。在你的个人电脑上，这通常是有用的，但是在禁用前，确保你不需要 XON/XOFF 。
### Cron 不是安排任务的唯一方式
Cron 任务对于任何水平的系统管理员，无论是毫无经验的初学者，还是经验丰富的专家来说，都是非常有用的。但是，如果你需要安排一个一次性的任务，那么 `at` 命令为你提供了一个快捷的方式来创建任务，从而你不需要接触 crontab 。
`at` 命令的运行方式是在后面紧跟着你想要运行任务的运行时间。时间是灵活的，因为它支持许多时间格式。包括下面这些例子：
```
at 12:00 PM September 30 2017
at now + 1 hour
at 9:00 AM tomorrow
```
当你以带参数的方式输入 `at` 命令以后，将会提示你该命令将在你的 Linux 系统上运行。这可能是一个备份脚本，一套维护任务，或者甚至是一个普通的 bash 命令。如果要结束任务，可以按 `ctrl+d` 。
另外，你可以使用 `atq` 命令查看当前用户的所有任务，或者使用 `sudo atq` 查看所有用户的任务。它将会展示出所有排定好的任务，并且每个任务都伴有一个 ID 。如果你想取消一个排定好的任务，可以使用 `atrm` 命令，并且以任务 ID 作为参数。
### 你可以按照功能搜索命令，而不仅仅是通过名字
记住命令的名字非常困难，特别是对于初学者来说。幸运的是，Linux 附带了一个通过名字和描述来搜索 man 页面的工具。
下次，如果你没有记住你想要使用的工具的名称，你可以尝试使用 `apropos` 命令加上你想要干的事情的描述。比如，`apropos build filesystem` 将会返回一系列名字和描述包括了 “build” 和 “filesystem” 单词的工具。
`apropos` 命令接受一个或多个字符串作为参数，但同时它也有其他参数，比如你可以使用 `-r` 参数，从而通过正则表达式来搜索。
### 一个允许你来管理系统版本的替代系统
如果你曾进行过软件开发，你就会明白跨项目管理不同版本的语言的支持的重要性。许多 Linux 发行版都有工具可以来处理不同的内建版本。
可执行文件比如 `java` 往往符号链接到目录 `/etc/alternatives` 下。反过来，该目录会将符号链接存储为二进制文件并提供一个管理这些链接的接口。Java 可能是替代系统最常管理的语言，但是，经过一些配置，它也可以作为其他应用程序替代品，比如 NVM 和 RVM （NVM 和 RVM 分别是 NodeJS 和 Ruby 的版本管理器）。
在基于 Debian 的系统中，你可以使用 `update-alternatives` 命令创建和管理这些链接。在 CentOS 中，这个工具就叫做 `alternatives` 。通过更改你的 alternatives 文件中的链接，你便可以安装一个语言的多个版本，并且在不同的情况下使用不同的二进制。这个替代系统也提供了对任何你可能在命令行运行的程序的支持。
### `shred` 命令是更加安全的删除文件方式
我们大多数时候总是使用 `rm` 命令来删除文件。但是文件去哪儿了呢？真相是 `rm` 命令所做的事情并不是像你所想像的那样，它仅仅删除了文件系统和硬盘上的数据的硬链接。硬盘上的数据依旧存在，直到被另一个应用重写覆盖。对于非常敏感的数据来说，这会带来一个很大的安全隐患。
`shred` 命令是 `rm` 命令的升级版。当你使用 `shred` 命令删除一个文件之后，文件中的数据会被多次随机覆写。甚至有一个选项可以在随机覆写之后对所有的数据进行清零。
如果你想安全的删除一个文件并且以零覆盖，那么可以使用下面的命令：
`shred -u -z [file name]`
同时，你也可以使用 `-n` 选项和一个数字作为参数，从而指定在随机覆盖数据的时候迭代多少次。
### 通过自动更正来避免输入很长的无效文件路径
有多少次，你输入一个文件的绝对路径，然而却看到“没有该文件或目录”的消息。任何人都会明白输入一个很长的字符串的痛苦。幸运的是，有一个很简单的解决办法。
内建的 `shopt` 命令允许你设置不同的选项来改变 shell 的行为。设置 `cdspell` 选项是避免输入文件路径时一个字母出错的头痛的一个简单方式。你可以通过运行 `shopt -s cdspell` 命令来启用该选项。启用该选项后，当你想要切换目录时，会自动更正为最匹配的目录。
Shell 选项是节省时间的一个好方法（更不用说减少麻烦），此外还有许许多多的其他选项。如果想查看你的系统中所有选项的完整列表，可以运行不带参数的 `shopt` 命令。需要注意的是，这是 bash 的特性，如果你运行 zsh 或者其他可供选择的 shell，可能无法使用。
### 通过子 shell 返回到当前目录
如果你曾经配置过一个比较复杂的系统，那么你可能会发现你需要频繁的更换目录，从而很难跟踪你所在的位置。如果在运行完一个命令后自动返回到当前位置，不是很好吗？
Linux 系统实际上提供了一个解决该问题的方法，并且非常简单。如果你想通过 `cd` 命令进入另一个目录完成一些任务，然后再返回当前工作目录，那么你可以将命令置于括号中。你可以在你的 Linux 系统上尝试下面这个命令。记住你当前的工作目录，然后运行：
```
(cd /etc && ls -a)
```
该命令会输出 `/etc` 目录的内容。现在，检查你的当前工作目录。它和执行该命令前的目录一样，而不是 `/etc` 目录。
它是如何工作的呢？运行一个括号中的命令会创建一个子 shell 或一个当前 shell 进程的复刻副本。该子 shell 可以访问所有的父变量，反之则不行。所以请记住，你是在运行一个非常复杂的单行命令。
在并行处理中经常使用子 shell ，但是在命令行中，它也能为你带来同样的力量，从而使你在浏览文件系统时更加容易。
---
作者简介：
Phil Zona 是 Linux Academy 的技术作家。他编写了 AWS、Microsoft Azure 和 Linux 系统管理的指南和教程。他同时也管理着 Cloud Assessments 博客，该博客旨在帮助个人通过技术实现他们的事业目标。
---
via: <http://opensourceforu.com/2017/09/top-7-things-linux-may-not-known-far/>
作者：[PHIL ZONA](http://opensourceforu.com/author/phil-zona/) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
论 HTTP 性能，Go 与 .NET Core 一争雌雄
|
Gerasimos Maropoulos
|
https://hackernoon.com/go-vs-net-core-in-terms-of-http-performance-7535a61b67b8
|
如前面所提的，我们会比较它们相同的东西，比如应用程序、预期响应及运行时的稳定性，所以我们不会把像对 JSON 或者 XML 的编码、解码这些烦多的事情加入比较游戏中来，仅仅只会使用简单的文本消息。为了公平起见，我们会分别使用 Go 和 .NET Core 的 MVC 架构模式。
|
/data/attachment/album/201710/06/111305ltswozo3cmicl3z6.png.thumb.jpg
|
/data/attachment/album/201710/06/111305ltswozo3cmicl3z6.png
| true | false | true |
runningwater
| false |
[
"Golang",
".NET"
] |
软件开发
|
{
"viewnum": 21360,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如前面所提的，我们会比较它们相同的东西，比如应用程序、预期响应及运行时的稳定性，所以我们不会把像对 JSON 或者 XML 的编码、解码这些烦多的事情加入比较游戏中来，仅仅只会使用简单的文本消息。为了公平起见，我们会分别使用 Go 和 .NET Core 的 MVC 架构模式。
| 2017-10-06T11:13:00 | 2017-10-06T11:13:00 | 8,935 |
/article-8935-1.html
|
朋友们，你们好！
近来，我听到了大量的关于新出的 .NET Core 和其性能的讨论，尤其在 Web 服务方面的讨论更甚。
因为是新出的，我不想立马就比较两个不同的东西，所以我耐心等待，想等发布更稳定的版本后再进行。
本周一（8 月 14 日），微软[发布 .NET Core 2.0 版本](https://blogs.msdn.microsoft.com/dotnet/2017/08/14/announcing-net-core-2-0/)，因此，我准备开始。您们认为呢？
如前面所提的，我们会比较它们相同的东西，比如应用程序、预期响应及运行时的稳定性，所以我们不会把像对 JSON 或者 XML 的编码、解码这些烦多的事情加入比较游戏中来，仅仅只会使用简单的文本消息。为了公平起见，我们会分别使用 Go 和 .NET Core 的 [MVC 架构模式](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller)。
### 参赛选手
[Go](https://golang.org/) （或称 Golang）： 是一种[快速增长](http://www.tiobe.com/tiobe-index/)的开源编程语言，旨在构建出简单、快捷和稳定可靠的应用软件。
用于支持 Go 语言的 MVC web 框架并不多，还好我们找到了 Iris ，可胜任此工作。
[Iris](http://iris-go.com/)： 支持 Go 语言的快速、简单和高效的微型 Web 框架。它为您的下一代网站、API 或分布式应用程序奠定了精美的表现方式和易于使用的基础。
[C#](https://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29)： 是一种通用的、面向对象的编程语言。其开发团队由 [Anders Hejlsberg](https://twitter.com/ahejlsberg) 领导。
[.NET Core](https://www.microsoft.com/net/)： 跨平台，可以在极少时间内开发出高性能的应用程序。
可从 <https://golang.org/dl> 下载 Go ，从 <https://www.microsoft.com/net/core> 下载 .NET Core。
在下载和安装好这些软件后，还需要为 Go 安装 Iris。安装很简单，仅仅只需要打开终端，然后执行如下语句：
```
go get -u github.com/kataras/iris
```
### 基准
#### 硬件
* 处理器： Intel(R) Core(TM) i7–4710HQ CPU @ 2.50GHz 2.50GHz
* 内存： 8.00 GB
#### 软件
* 操作系统： 微软 Windows [10.0.15063 版本]， 电源计划设置为“高性能”
* HTTP 基准工具： <https://github.com/codesenberg/bombardier>， 使用最新的 1.1 版本。
* .NET Core： <https://www.microsoft.com/net/core>， 使用最新的 2.0 版本。
* Iris： <https://github.com/kataras/iris>， 使用基于 [Go 1.8.3](https://golang.org/) 构建的最新 8.3 版本。
两个应用程序都通过请求路径 “api/values/{id}” 返回文本“值”。
##### .NET Core MVC
Logo 由 [Pablo Iglesias](https://github.com/campusMVP/dotnetCoreLogoPack) 设计。
可以使用 `dotnet new webapi` 命令创建项目，其 `webapi` 模板会为您生成代码，代码包含 `GET` 请求方法的 `返回“值”`。
源代码：
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
namespace netcore_mvc
{
public class Program
{
public static void Main(string[] args)
{
BuildWebHost(args).Run();
}
public static IWebHost BuildWebHost(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseStartup<Startup>()
.Build();
}
}
```
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
namespace netcore_mvc
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvcCore();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
app.UseMvc();
}
}
}
```
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
namespace netcore_mvc.Controllers
{
// ValuesController is the equivalent
// `ValuesController` of the Iris 8.3 mvc application.
[Route("api/[controller]")]
public class ValuesController : Controller
{
// Get handles "GET" requests to "api/values/{id}".
[HttpGet("{id}")]
public string Get(int id)
{
return "value";
}
// Put handles "PUT" requests to "api/values/{id}".
[HttpPut("{id}")]
public void Put(int id, [FromBody]string value)
{
}
// Delete handles "DELETE" requests to "api/values/{id}".
[HttpDelete("{id}")]
public void Delete(int id)
{
}
}
}
```
运行 .NET Core web 服务项目：
```
$ cd netcore-mvc
$ dotnet run -c Release
Hosting environment: Production
Content root path: C:\mygopath\src\github.com\kataras\iris\_benchmarks\netcore-mvc
Now listening on: http://localhost:5000
Application started. Press Ctrl+C to shut down.
```
运行和定位 HTTP 基准工具：
```
$ bombardier -c 125 -n 5000000 http://localhost:5000/api/values/5
Bombarding http://localhost:5000/api/values/5 with 5000000 requests using 125 connections
5000000 / 5000000 [=====================================================] 100.00% 2m3s
Done!
Statistics Avg Stdev Max
Reqs/sec 40226.03 8724.30 161919
Latency 3.09ms 1.40ms 169.12ms
HTTP codes:
1xx - 0, 2xx - 5000000, 3xx - 0, 4xx - 0, 5xx - 0
others - 0
Throughput: 8.91MB/s
```
##### Iris MVC
Logo 由 [Santosh Anand](https://github.com/santoshanand) 设计。
源代码：
```
package main
import (
"github.com/kataras/iris"
"github.com/kataras/iris/_benchmarks/iris-mvc/controllers"
)
func main() {
app := iris.New()
app.Controller("/api/values/{id}", new(controllers.ValuesController))
app.Run(iris.Addr(":5000"), iris.WithoutVersionChecker)
}
```
```
package controllers
import "github.com/kataras/iris/mvc"
// ValuesController is the equivalent
// `ValuesController` of the .net core 2.0 mvc application.
type ValuesController struct {
mvc.Controller
}
// Get handles "GET" requests to "api/values/{id}".
func (vc *ValuesController) Get() {
// id,_ := vc.Params.GetInt("id")
vc.Ctx.WriteString("value")
}
// Put handles "PUT" requests to "api/values/{id}".
func (vc *ValuesController) Put() {}
// Delete handles "DELETE" requests to "api/values/{id}".
func (vc *ValuesController) Delete() {}
```
运行 Go web 服务项目：
```
$ cd iris-mvc
$ go run main.go
Now listening on: http://localhost:5000
Application started. Press CTRL+C to shut down.
```
运行和定位 HTTP 基准工具：
```
$ bombardier -c 125 -n 5000000 http://localhost:5000/api/values/5
Bombarding http://localhost:5000/api/values/5 with 5000000 requests using 125 connections
5000000 / 5000000 [======================================================] 100.00% 47s
Done!
Statistics Avg Stdev Max
Reqs/sec 105643.81 7687.79 122564
Latency 1.18ms 366.55us 22.01ms
HTTP codes:
1xx - 0, 2xx - 5000000, 3xx - 0, 4xx - 0, 5xx - 0
others - 0
Throughput: 19.65MB/s
```
想通过图片来理解的人，我也把我的屏幕截屏出来了！
请点击[这儿](https://github.com/kataras/iris/tree/master/_benchmarks/screens)可以看到这些屏幕快照。
#### 总结
* 完成 `5000000 个请求`的时间 - 越短越好。
* 请求次数/每秒 - 越大越好。
* 等待时间 — 越短越好。
* 吞吐量 — 越大越好。
* 内存使用 — 越小越好。
* LOC (代码行数) — 越少越好。
.NET Core MVC 应用程序，使用 86 行代码，运行 2 分钟 8 秒，每秒接纳 39311.56 个请求，平均 3.19ms 等待，最大时到 229.73ms，内存使用大约为 126MB（不包括 dotnet 框架）。
Iris MVC 应用程序，使用 27 行代码，运行 47 秒，每秒接纳 105643.71 个请求，平均 1.18ms 等待，最大时到 22.01ms，内存使用大约为 12MB。
>
> 还有另外一个模板的基准，滚动到底部。
>
>
>
**2017 年 8 月 20 号更新**
[Josh Clark](https://twitter.com/clarkis117) 和 [Scott Hanselman](https://twitter.com/shanselman)在此 [tweet 评论](https://twitter.com/shanselman/status/899005786826788865)上指出，.NET Core `Startup.cs` 文件中 `services.AddMvc();` 这行可以替换为 `services.AddMvcCore();`。我听从他们的意见，修改代码，重新运行基准，该文章的 .NET Core 应用程序的基准输出已经修改。
@topdawgevh @shanselman 他们也在使用 `AddMvc()` 而不是 `AddMvcCore()` ...，难道都不包含中间件？
— @clarkis117
@clarkis117 @topdawgevh Cool @MakisMaropoulos @ben*a*adams @davidfowl 我们来看看。认真学习下怎么使用更简单的性能默认值。
— @shanselman
@shanselman @clarkis117 @topdawgevh @ben*a*adams @davidfowl @shanselman @ben*a*adams @davidfowl 谢谢您们的反馈意见。我已经修改，更新了结果，没什么不同。对其它的建议，我非常欢迎。
— @MakisMaropoulos
>
> 它有点稍微的不同但相差不大（从 8.61MB/s 到 8.91MB/s）
>
>
>
想要了解跟 `services.AddMvc()` 标准比较结果的，可以点击[这儿](https://github.com/kataras/iris/blob/master/_benchmarks/screens/5m_requests_netcore-mvc.png)。
### 想再多了解点儿吗?
我们再制定一个基准，产生 `1000000 次请求`，这次会通过视图引擎由模板生成 `HTML` 页面。
#### .NET Core MVC 使用的模板
```
using System;
namespace netcore_mvc_templates.Models
{
public class ErrorViewModel
{
public string Title { get; set; }
public int Code { get; set; }
}
}
```
```
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using netcore_mvc_templates.Models;
namespace netcore_mvc_templates.Controllers
{
public class HomeController : Controller
{
public IActionResult Index()
{
return View();
}
public IActionResult About()
{
ViewData["Message"] = "Your application description page.";
return View();
}
public IActionResult Contact()
{
ViewData["Message"] = "Your contact page.";
return View();
}
public IActionResult Error()
{
return View(new ErrorViewModel { Title = "Error", Code = 500});
}
}
}
```
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
namespace netcore_mvc_templates
{
public class Program
{
public static void Main(string[] args)
{
BuildWebHost(args).Run();
}
public static IWebHost BuildWebHost(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseStartup<Startup>()
.Build();
}
}
```
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
namespace netcore_mvc_templates
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
/* An unhandled exception was thrown by the application.
System.InvalidOperationException: No service for type
'Microsoft.AspNetCore.Mvc.ViewFeatures.ITempDataDictionaryFactory' has been registered.
Solution: Use AddMvc() instead of AddMvcCore() in Startup.cs and it will work.
*/
// services.AddMvcCore();
services.AddMvc();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
app.UseStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
}
}
```
```
/*
wwwroot/css
wwwroot/images
wwwroot/js
wwwroot/lib
wwwroot/favicon.ico
Views/Shared/_Layout.cshtml
Views/Shared/Error.cshtml
Views/Home/About.cshtml
Views/Home/Contact.cshtml
Views/Home/Index.cshtml
These files are quite long to be shown in this article but you can view them at:
https://github.com/kataras/iris/tree/master/_benchmarks/netcore-mvc-templates
```
运行 .NET Core 服务项目：
```
$ cd netcore-mvc-templates
$ dotnet run -c Release
Hosting environment: Production
Content root path: C:\mygopath\src\github.com\kataras\iris\_benchmarks\netcore-mvc-templates
Now listening on: http://localhost:5000
Application started. Press Ctrl+C to shut down.
```
运行 HTTP 基准工具：
```
Bombarding http://localhost:5000 with 1000000 requests using 125 connections
1000000 / 1000000 [====================================================] 100.00% 1m20s
Done!
Statistics Avg Stdev Max
Reqs/sec 11738.60 7741.36 125887
Latency 10.10ms 22.10ms 1.97s
HTTP codes:
1xx — 0, 2xx — 1000000, 3xx — 0, 4xx — 0, 5xx — 0
others — 0
Throughput: 89.03MB/s
```
#### Iris MVC 使用的模板
```
package controllers
import "github.com/kataras/iris/mvc"
type AboutController struct{ mvc.Controller }
func (c *AboutController) Get() {
c.Data["Title"] = "About"
c.Data["Message"] = "Your application description page."
c.Tmpl = "about.html"
}
```
```
package controllers
import "github.com/kataras/iris/mvc"
type ContactController struct{ mvc.Controller }
func (c *ContactController) Get() {
c.Data["Title"] = "Contact"
c.Data["Message"] = "Your contact page."
c.Tmpl = "contact.html"
}
```
```
package models
// HTTPError a silly structure to keep our error page data.
type HTTPError struct {
Title string
Code int
}
```
```
package controllers
import "github.com/kataras/iris/mvc"
type IndexController struct{ mvc.Controller }
func (c *IndexController) Get() {
c.Data["Title"] = "Home Page"
c.Tmpl = "index.html"
}
```
```
package main
import (
"github.com/kataras/iris/_benchmarks/iris-mvc-templates/controllers"
"github.com/kataras/iris"
"github.com/kataras/iris/context"
)
const (
// templatesDir is the exactly the same path that .NET Core is using for its templates,
// in order to reduce the size in the repository.
// Change the "C\\mygopath" to your own GOPATH.
templatesDir = "C:\\mygopath\\src\\github.com\\kataras\\iris\\_benchmarks\\netcore-mvc-templates\\wwwroot"
)
func main() {
app := iris.New()
app.Configure(configure)
app.Controller("/", new(controllers.IndexController))
app.Controller("/about", new(controllers.AboutController))
app.Controller("/contact", new(controllers.ContactController))
app.Run(iris.Addr(":5000"), iris.WithoutVersionChecker)
}
func configure(app *iris.Application) {
app.RegisterView(iris.HTML("./views", ".html").Layout("shared/layout.html"))
app.StaticWeb("/public", templatesDir)
app.OnAnyErrorCode(onError)
}
type err struct {
Title string
Code int
}
func onError(ctx context.Context) {
ctx.ViewData("", err{"Error", ctx.GetStatusCode()})
ctx.View("shared/error.html")
}
```
```
/*
../netcore-mvc-templates/wwwroot/css
../netcore-mvc-templates/wwwroot/images
../netcore-mvc-templates/wwwroot/js
../netcore-mvc-templates/wwwroot/lib
../netcore-mvc-templates/wwwroot/favicon.ico
views/shared/layout.html
views/shared/error.html
views/about.html
views/contact.html
views/index.html
These files are quite long to be shown in this article but you can view them at:
https://github.com/kataras/iris/tree/master/_benchmarks/iris-mvc-templates
*/
```
运行 Go 服务项目：
```
$ cd iris-mvc-templates
$ go run main.go
Now listening on: http://localhost:5000
Application started. Press CTRL+C to shut down.
```
运行 HTTP 基准工具：
```
Bombarding http://localhost:5000 with 1000000 requests using 125 connections
1000000 / 1000000 [======================================================] 100.00% 37s
Done!
Statistics Avg Stdev Max
Reqs/sec 26656.76 1944.73 31188
Latency 4.69ms 1.20ms 22.52ms
HTTP codes:
1xx — 0, 2xx — 1000000, 3xx — 0, 4xx — 0, 5xx — 0
others — 0
Throughput: 192.51MB/s
```
#### 总结
* 完成 `1000000 个请求`的时间 - 越短越好。
* 请求次数/每秒 - 越大越好。
* 等待时间 — 越短越好。
* 内存使用 — 越小越好。
* 吞吐量 — 越大越好。
.NET Core MVC 模板应用程序，运行 1 分钟 20 秒，每秒接纳 11738.60 个请求，同时每秒生成 89.03M 页面，平均 10.10ms 等待，最大时到 1.97s，内存使用大约为 193MB（不包括 dotnet 框架）。
Iris MVC 模板应用程序，运行 37 秒，每秒接纳 26656.76 个请求，同时每秒生成 192.51M 页面，平均 1.18ms 等待，最大时到 22.52ms，内存使用大约为 17MB。
### 接下来呢？
[这里](https://github.com/kataras/iris/tree/master/_benchmarks)有上面所示的源代码，请下载下来，在您本地以同样的基准运行，然后把运行结果在这儿给大家分享。
想添加 Go 或 C# .net core WEB 服务框架到列表的朋友请向[这个仓库](https://github.com/kataras/iris)的 `_benchmarks` 目录推送 PR。
我也需要亲自感谢下 [dev.to](https://dev.to/kataras/go-vsnet-core-in-terms-of-http-performance) 团队，感谢把我的这篇文章分享到他们的 Twitter 账户。
感谢大家真心反馈，玩得开心！
#### 更新 : 2017 年 8 月 21 ，周一
很多人联系我，希望看到一个基于 .NET Core 的较低级别 Kestrel 的基准测试文章。
因此我完成了，请点击下面的[链接](https://medium.com/@kataras/iris-go-vs-net-core-kestrel-in-terms-of-http-performance-806195dc93d5)来了解 Kestrel 和 Iris 之间的性能差异，它还包含一个会话存储管理基准！
---
via: <https://hackernoon.com/go-vs-net-core-in-terms-of-http-performance-7535a61b67b8>
作者：[Gerasimos Maropoulos](https://hackernoon.com/@kataras?source=post_header_lockup) 译者：[runningwater](https://github.com/runningwater) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开发一个 Linux 调试器（九）：处理变量
|
Simon Brand
|
https://blog.tartanllama.xyz/writing-a-linux-debugger-variables/
|
变量是偷偷摸摸的。有时，它们会很高兴地呆在寄存器中，但是一转头就会跑到堆栈中。
|
/data/attachment/album/201710/06/180943lioqi6q6ortjfur0.jpg.thumb.jpg
|
/data/attachment/album/201710/06/180943lioqi6q6ortjfur0.jpg
| true | false | true |
geekpi
| false |
[
"调试",
"调试器"
] |
软件开发
|
{
"viewnum": 5489,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8930,
"displayorder": 0
},
{
"raid": 8943,
"displayorder": 0
}
] |
变量是偷偷摸摸的。有时，它们会很高兴地呆在寄存器中，但是一转头就会跑到堆栈中。
| 2017-10-06T18:10:00 | 2017-10-06T18:10:00 | 8,936 |
/article-8936-1.html
|
变量是偷偷摸摸的。有时，它们会很高兴地呆在寄存器中，但是一转头就会跑到堆栈中。为了优化，编译器可能会完全将它们从窗口中抛出。无论变量在内存中的如何移动，我们都需要一些方法在调试器中跟踪和操作它们。这篇文章将会教你如何处理调试器中的变量，并使用 `libelfin` 演示一个简单的实现。
### 系列文章索引
1. [准备环境](/article-8626-1.html)
2. [断点](/article-8645-1.html)
3. [寄存器和内存](/article-8663-1.html)
4. [ELF 和 DWARF](/article-8719-1.html)
5. [源码和信号](/article-8812-1.html)
6. [源码级逐步执行](/article-8813-1.html)
7. [源码级断点](/article-8890-1.html)
8. [堆栈展开](/article-8930-1.html)
9. [处理变量](https://blog.tartanllama.xyz/writing-a-linux-debugger-variables/)
10. [高级话题](https://blog.tartanllama.xyz/writing-a-linux-debugger-advanced-topics/)
在开始之前，请确保你使用的 `libelfin` 版本是[我分支上的 `fbreg`](https://github.com/TartanLlama/libelfin/tree/fbreg)。这包含了一些 hack 来支持获取当前堆栈帧的基址并评估位置列表，这些都不是由原生的 `libelfin` 提供的。你可能需要给 GCC 传递 `-gdwarf-2` 参数使其生成兼容的 DWARF 信息。但是在实现之前，我将详细说明 DWARF 5 最新规范中的位置编码方式。如果你想要了解更多信息，那么你可以从[这里](http://dwarfstd.org/)获取该标准。
### DWARF 位置
某一给定时刻的内存中变量的位置使用 `DW_AT_location` 属性编码在 DWARF 信息中。位置描述可以是单个位置描述、复合位置描述或位置列表。
* 简单位置描述：描述了对象的一个连续的部分（通常是所有部分）的位置。简单位置描述可以描述可寻址存储器或寄存器中的位置，或缺少位置（具有或不具有已知值）。比如，`DW_OP_fbreg -32`： 一个整个存储的变量 - 从堆栈帧基址开始的32个字节。
* 复合位置描述：根据片段描述对象，每个对象可以包含在寄存器的一部分中或存储在与其他片段无关的存储器位置中。比如， `DW_OP_reg3 DW_OP_piece 4 DW_OP_reg10 DW_OP_piece 2`：前四个字节位于寄存器 3 中，后两个字节位于寄存器 10 中的一个变量。
* 位置列表：描述了具有有限生存期或在生存期内更改位置的对象。比如：
+ `<loclist with 3 entries follows>`
- `[ 0]<lowpc=0x2e00><highpc=0x2e19>DW_OP_reg0`
- `[ 1]<lowpc=0x2e19><highpc=0x2e3f>DW_OP_reg3`
- `[ 2]<lowpc=0x2ec4><highpc=0x2ec7>DW_OP_reg2`
+ 根据程序计数器的当前值，位置在寄存器之间移动的变量。
根据位置描述的种类，`DW_AT_location` 以三种不同的方式进行编码。`exprloc` 编码简单和复合的位置描述。它们由一个字节长度组成，后跟一个 DWARF 表达式或位置描述。`loclist` 和 `loclistptr` 的编码位置列表，它们在 `.debug_loclists` 部分中提供索引或偏移量，该部分描述了实际的位置列表。
### DWARF 表达式
使用 DWARF 表达式计算变量的实际位置。这包括操作堆栈值的一系列操作。有很多 DWARF 操作可用，所以我不会详细解释它们。相反，我会从每一个表达式中给出一些例子，给你一个可用的东西。另外，不要害怕这些；`libelfin` 将为我们处理所有这些复杂性。
* 字面编码
+ `DW_OP_lit0`、`DW_OP_lit1`……`DW_OP_lit31`
- 将字面量压入堆栈
+ `DW_OP_addr <addr>`
- 将地址操作数压入堆栈
+ `DW_OP_constu <unsigned>`
- 将无符号值压入堆栈
* 寄存器值
+ `DW_OP_fbreg <offset>`
- 压入在堆栈帧基址找到的值，偏移给定值
+ `DW_OP_breg0`、`DW_OP_breg1`…… `DW_OP_breg31 <offset>`
- 将给定寄存器的内容加上给定的偏移量压入堆栈
* 堆栈操作
+ `DW_OP_dup`
- 复制堆栈顶部的值
+ `DW_OP_deref`
- 将堆栈顶部视为内存地址，并将其替换为该地址的内容
* 算术和逻辑运算
+ `DW_OP_and`
- 弹出堆栈顶部的两个值，并压回它们的逻辑 `AND`
+ `DW_OP_plus`
- 与 `DW_OP_and` 相同，但是会添加值
* 控制流操作
+ `DW_OP_le`、`DW_OP_eq`、`DW_OP_gt` 等
- 弹出前两个值，比较它们，并且如果条件为真，则压入 `1`，否则为 `0`
+ `DW_OP_bra <offset>`
- 条件分支：如果堆栈的顶部不是 `0`，则通过 `offset` 在表达式中向后或向后跳过
* 输入转化
+ `DW_OP_convert <DIE offset>`
- 将堆栈顶部的值转换为不同的类型，它由给定偏移量的 DWARF 信息条目描述
* 特殊操作
+ `DW_OP_nop`
- 什么都不做！
### DWARF 类型
DWARF 类型的表示需要足够强大来为调试器用户提供有用的变量表示。用户经常希望能够在应用程序级别进行调试，而不是在机器级别进行调试，并且他们需要了解他们的变量正在做什么。
DWARF 类型与大多数其他调试信息一起编码在 DIE 中。它们可以具有指示其名称、编码、大小、字节等的属性。无数的类型标签可用于表示指针、数组、结构体、typedef 以及 C 或 C++ 程序中可以看到的任何其他内容。
以这个简单的结构体为例：
```
struct test{
int i;
float j;
int k[42];
test* next;
};
```
这个结构体的父 DIE 是这样的：
```
< 1><0x0000002a> DW_TAG_structure_type
DW_AT_name "test"
DW_AT_byte_size 0x000000b8
DW_AT_decl_file 0x00000001 test.cpp
DW_AT_decl_line 0x00000001
```
上面说的是我们有一个叫做 `test` 的结构体，大小为 `0xb8`，在 `test.cpp` 的第 `1` 行声明。接下来有许多描述成员的子 DIE。
```
< 2><0x00000032> DW_TAG_member
DW_AT_name "i"
DW_AT_type <0x00000063>
DW_AT_decl_file 0x00000001 test.cpp
DW_AT_decl_line 0x00000002
DW_AT_data_member_location 0
< 2><0x0000003e> DW_TAG_member
DW_AT_name "j"
DW_AT_type <0x0000006a>
DW_AT_decl_file 0x00000001 test.cpp
DW_AT_decl_line 0x00000003
DW_AT_data_member_location 4
< 2><0x0000004a> DW_TAG_member
DW_AT_name "k"
DW_AT_type <0x00000071>
DW_AT_decl_file 0x00000001 test.cpp
DW_AT_decl_line 0x00000004
DW_AT_data_member_location 8
< 2><0x00000056> DW_TAG_member
DW_AT_name "next"
DW_AT_type <0x00000084>
DW_AT_decl_file 0x00000001 test.cpp
DW_AT_decl_line 0x00000005
DW_AT_data_member_location 176(as signed = -80)
```
每个成员都有一个名称、一个类型（它是一个 DIE 偏移量）、一个声明文件和行，以及一个指向其成员所在的结构体的字节偏移。其类型指向如下。
```
< 1><0x00000063> DW_TAG_base_type
DW_AT_name "int"
DW_AT_encoding DW_ATE_signed
DW_AT_byte_size 0x00000004
< 1><0x0000006a> DW_TAG_base_type
DW_AT_name "float"
DW_AT_encoding DW_ATE_float
DW_AT_byte_size 0x00000004
< 1><0x00000071> DW_TAG_array_type
DW_AT_type <0x00000063>
< 2><0x00000076> DW_TAG_subrange_type
DW_AT_type <0x0000007d>
DW_AT_count 0x0000002a
< 1><0x0000007d> DW_TAG_base_type
DW_AT_name "sizetype"
DW_AT_byte_size 0x00000008
DW_AT_encoding DW_ATE_unsigned
< 1><0x00000084> DW_TAG_pointer_type
DW_AT_type <0x0000002a>
```
如你所见，我笔记本电脑上的 `int` 是一个 4 字节的有符号整数类型，`float`是一个 4 字节的浮点数。整数数组类型通过指向 `int` 类型作为其元素类型，`sizetype`（可以认为是 `size_t`）作为索引类型，它具有 `2a` 个元素。 `test *` 类型是 `DW_TAG_pointer_type`，它引用 `test` DIE。
### 实现简单的变量读取器
如上所述，`libelfin` 将为我们处理大部分复杂性。但是，它并没有实现用于表示可变位置的所有方法，并且在我们的代码中处理这些将变得非常复杂。因此，我现在选择只支持 `exprloc`。请根据需要添加对更多类型表达式的支持。如果你真的有勇气，请提交补丁到 `libelfin` 中来帮助完成必要的支持！
处理变量主要是将不同部分定位在存储器或寄存器中，读取或写入与之前一样。为了简单起见，我只会告诉你如何实现读取。
首先我们需要告诉 `libelfin` 如何从我们的进程中读取寄存器。我们创建一个继承自 `expr_context` 的类并使用 `ptrace` 来处理所有内容：
```
class ptrace_expr_context : public dwarf::expr_context {
public:
ptrace_expr_context (pid_t pid) : m_pid{pid} {}
dwarf::taddr reg (unsigned regnum) override {
return get_register_value_from_dwarf_register(m_pid, regnum);
}
dwarf::taddr pc() override {
struct user_regs_struct regs;
ptrace(PTRACE_GETREGS, m_pid, nullptr, ®s);
return regs.rip;
}
dwarf::taddr deref_size (dwarf::taddr address, unsigned size) override {
//TODO take into account size
return ptrace(PTRACE_PEEKDATA, m_pid, address, nullptr);
}
private:
pid_t m_pid;
};
```
读取将由我们 `debugger` 类中的 `read_variables` 函数处理：
```
void debugger::read_variables() {
using namespace dwarf;
auto func = get_function_from_pc(get_pc());
//...
}
```
我们上面做的第一件事是找到我们目前进入的函数，然后我们需要循环访问该函数中的条目来寻找变量：
```
for (const auto& die : func) {
if (die.tag == DW_TAG::variable) {
//...
}
}
```
我们通过查找 DIE 中的 `DW_AT_location` 条目获取位置信息：
```
auto loc_val = die[DW_AT::location];
```
接着我们确保它是一个 `exprloc`，并请求 `libelfin` 来评估我们的表达式：
```
if (loc_val.get_type() == value::type::exprloc) {
ptrace_expr_context context {m_pid};
auto result = loc_val.as_exprloc().evaluate(&context);
```
现在我们已经评估了表达式，我们需要读取变量的内容。它可以在内存或寄存器中，因此我们将处理这两种情况：
```
switch (result.location_type) {
case expr_result::type::address:
{
auto value = read_memory(result.value);
std::cout << at_name(die) << " (0x" << std::hex << result.value << ") = "
<< value << std::endl;
break;
}
case expr_result::type::reg:
{
auto value = get_register_value_from_dwarf_register(m_pid, result.value);
std::cout << at_name(die) << " (reg " << result.value << ") = "
<< value << std::endl;
break;
}
default:
throw std::runtime_error{"Unhandled variable location"};
}
```
你可以看到，我根据变量的类型，打印输出了值而没有解释。希望通过这个代码，你可以看到如何支持编写变量，或者用给定的名字搜索变量。
最后我们可以将它添加到我们的命令解析器中：
```
else if(is_prefix(command, "variables")) {
read_variables();
}
```
### 测试一下
编写一些具有一些变量的小功能，不用优化并带有调试信息编译它，然后查看是否可以读取变量的值。尝试写入存储变量的内存地址，并查看程序改变的行为。
已经有九篇文章了，还剩最后一篇！下一次我会讨论一些你可能会感兴趣的更高级的概念。现在你可以在[这里](https://github.com/TartanLlama/minidbg/tree/tut_variable)找到这个帖子的代码。
---
via: <https://blog.tartanllama.xyz/writing-a-linux-debugger-variables/>
作者：[Simon Brand](https://www.twitter.com/TartanLlama) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
OpenGL 与 Go 教程（二）绘制游戏面板
|
Kylewbanks
|
https://kylewbanks.com/blog/tutorial-opengl-with-golang-part-2-drawing-the-game-board
|
你现在应该能够创造一个漂亮的白色三角形，但我们不会把三角形当成我们游戏的基本单元，是时候把三角形变成正方形了，然后我们会做出一个完整的方格。
|
/data/attachment/album/201710/07/223453r5tqot1qsp0s6ga6.jpg.thumb.jpg
|
/data/attachment/album/201710/07/223453r5tqot1qsp0s6ga6.jpg
| true | false | true |
GitFtuture
| false |
[
"OpenGL",
"Golang"
] |
软件开发
|
{
"viewnum": 6144,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "121.32.254.147",
"message": "makeCells()<br />\r\n第一行应该是<br />\r\ncells := make([][]*cell, rows, columns)<br />\r\n建议修改下，虽然结果一样的，这样好理解些",
"username": "来自广东广州的 Sogou Explorer 2|Windows 7 用户",
"date": "2022-04-07T15:05:26"
}
] |
[
{
"raid": 8933,
"displayorder": 0
},
{
"raid": 8969,
"displayorder": 1
}
] |
你现在应该能够创造一个漂亮的白色三角形，但我们不会把三角形当成我们游戏的基本单元，是时候把三角形变成正方形了，然后我们会做出一个完整的方格。
| 2017-10-07T22:35:00 | 2017-10-07T22:35:00 | 8,937 |
/article-8937-1.html
|
* [第一节: Hello, OpenGL](/article-8933-1.html)
* [第二节: 绘制游戏面板](/article-8937-1.html)
* [第三节：实现游戏功能](/article-8969-1.html)
这篇教程的所有源代码都可以在 [GitHub](https://github.com/KyleBanks/conways-gol) 上找到。
欢迎回到《OpenGL 与 Go 教程》。如果你还没有看过[第一节](/article-8933-1.html)，那就要回过头去看看那一节。
你现在应该能够创造一个漂亮的白色三角形，但我们不会把三角形当成我们游戏的基本单元，是时候把三角形变成正方形了，然后我们会做出一个完整的方格。
让我们现在开始做吧！
### 利用三角形绘制方形
在我们绘制方形之前，先把三角形变成直角三角形。打开 `main.go` 文件，把 `triangle` 的定义改成像这个样子：
```
triangle = []float32{
-0.5, 0.5, 0,
-0.5, -0.5, 0,
0.5, -0.5, 0,
}
```
我们做的事情是，把最上面的顶点 X 坐标移动到左边（也就是变为 `-0.5`），这就变成了像这样的三角形：
很简单，对吧？现在让我们用两个这样的三角形顶点做成正方形。把 `triangle` 重命名为 `square`，然后添加第二个倒置的三角形的顶点数据，把直角三角形变成这样的：
```
square = []float32{
-0.5, 0.5, 0,
-0.5, -0.5, 0,
0.5, -0.5, 0,
-0.5, 0.5, 0,
0.5, 0.5, 0,
0.5, -0.5, 0,
}
```
注意：你也要把在 `main` 和 `draw` 里面命名的 `triangle` 改为 `square`。
我们通过添加三个顶点，把顶点数增加了一倍，这三个顶点就是右上角的三角形，用来拼成方形。运行它看看效果：
很好，现在我们能够绘制正方形了！OpenGL 一点都不难，对吧？
### 在窗口中绘制方形格子
现在我们能画一个方形，怎么画 100 个吗？我们来创建一个 `cell` 结构体，用来表示格子的每一个单元，因此我们能够很灵活的选择绘制的数量：
```
type cell struct {
drawable uint32
x int
y int
}
```
`cell` 结构体包含一个 `drawable` 属性，这是一个顶点数组对象，就像我们在之前创建的一样，这个结构体还包含 X 和 Y 坐标，用来表示这个格子的位置。
我们还需要两个常量，用来设定格子的大小和形状：
```
const (
...
rows = 10
columns = 10
)
```
现在我们添加一个创建格子的函数：
```
func makeCells() [][]*cell {
cells := make([][]*cell, rows, rows)
for x := 0; x < rows; x++ {
for y := 0; y < columns; y++ {
c := newCell(x, y)
cells[x] = append(cells[x], c)
}
}
return cells
}
```
这里我们创建多维的<ruby> 切片 <rt> slice </rt></ruby>，代表我们的游戏面板，用名为 `newCell` 的新函数创建的 `cell` 来填充矩阵的每个元素，我们待会就来实现 `newCell` 这个函数。
在接着往下阅读前，我们先花一点时间来看看 `makeCells` 函数做了些什么。我们创造了一个切片，这个切片的长度和格子的行数相等，每一个切片里面都有一个<ruby> 细胞 <rt> cell </rt></ruby>的切片，这些细胞的数量与列数相等。如果我们把 `rows` 和 `columns` 都设定成 2，那么就会创建如下的矩阵：
```
[
[cell, cell],
[cell, cell]
]
```
还可以创建一个更大的矩阵，包含 `10x10` 个细胞：
```
[
[cell, cell, cell, cell, cell, cell, cell, cell, cell, cell],
[cell, cell, cell, cell, cell, cell, cell, cell, cell, cell],
[cell, cell, cell, cell, cell, cell, cell, cell, cell, cell],
[cell, cell, cell, cell, cell, cell, cell, cell, cell, cell],
[cell, cell, cell, cell, cell, cell, cell, cell, cell, cell],
[cell, cell, cell, cell, cell, cell, cell, cell, cell, cell],
[cell, cell, cell, cell, cell, cell, cell, cell, cell, cell],
[cell, cell, cell, cell, cell, cell, cell, cell, cell, cell],
[cell, cell, cell, cell, cell, cell, cell, cell, cell, cell],
[cell, cell, cell, cell, cell, cell, cell, cell, cell, cell]
]
```
现在应该理解了我们创造的矩阵的形状和表示方法。让我们看看 `newCell` 函数到底是怎么填充矩阵的：
```
func newCell(x, y int) *cell {
points := make([]float32, len(square), len(square))
copy(points, square)
for i := 0; i < len(points); i++ {
var position float32
var size float32
switch i % 3 {
case 0:
size = 1.0 / float32(columns)
position = float32(x) * size
case 1:
size = 1.0 / float32(rows)
position = float32(y) * size
default:
continue
}
if points[i] < 0 {
points[i] = (position * 2) - 1
} else {
points[i] = ((position + size) * 2) - 1
}
}
return &cell{
drawable: makeVao(points),
x: x,
y: y,
}
}
```
这个函数里有很多内容，我们把它分成几个部分。我们做的第一件事是复制了 `square` 的定义。这让我们能够修改该定义，定制当前的细胞位置，而不会影响其它使用 `square` 切片定义的细胞。然后我们基于当前索引迭代 `points` 副本。我们用求余数的方法来判断我们是在操作 X 坐标（`i % 3 == 0`），还是在操作 Y 坐标（`i % 3 == 1`）（跳过 Z 坐标是因为我们仅在二维层面上进行操作），跟着确定细胞的大小（也就是占据整个游戏面板的比例），当然它的位置是基于细胞在 `相对游戏面板的` X 和 Y 坐标。
接着，我们改变那些包含在 `square` 切片中定义的 `0.5`，`0`， `-0.5` 这样的点。如果点小于 0，我们就把它设置成原来的 2 倍（因为 OpenGL 坐标的范围在 `-1` 到 `1` 之间，范围大小是 2），减 1 是为了归一化 OpenGL 坐标。如果点大于等于 0，我们的做法还是一样的，不过要加上我们计算出的尺寸。
这样做是为了设置每个细胞的大小，这样它就能只填充它在面板中的部分。因为我们有 10 行 10 列，每一个格子能分到游戏面板的 10% 宽度和高度。
最后，确定了所有点的位置和大小，我们用提供的 X 和 Y 坐标创建一个 `cell`，并设置 `drawable` 字段与我们刚刚操作 `points` 得到的顶点数组对象（vao）一致。
好了，现在我们在 `main` 函数里可以移去对 `makeVao` 的调用了，用 `makeCells` 代替。我们还修改了 `draw`，让它绘制一系列的细胞而不是一个 `vao`。
```
func main() {
...
// vao := makeVao(square)
cells := makeCells()
for !window.ShouldClose() {
draw(cells, window, program)
}
}
func draw(cells [][]*cell, window *glfw.Window, program uint32) {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.UseProgram(program)
// TODO
glfw.PollEvents()
window.SwapBuffers()
}
```
现在我们要让每个细胞知道怎么绘制出自己。在 `cell` 里面添加一个 `draw` 函数：
```
func (c *cell) draw() {
gl.BindVertexArray(c.drawable)
gl.DrawArrays(gl.TRIANGLES, 0, int32(len(square) / 3))
}
```
这看上去很熟悉，它很像我们之前在 `vao` 里写的 `draw`，唯一的区别是我们的 `BindVertexArray` 函数用的是 `c.drawable`，这是我们在 `newCell` 中创造的细胞的 `vao`。
回到 main 中的 `draw` 函数上，我们可以循环每个细胞，让它们自己绘制自己：
```
func draw(cells [][]*cell, window *glfw.Window, program uint32) {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.UseProgram(program)
for x := range cells {
for _, c := range cells[x] {
c.draw()
}
}
glfw.PollEvents()
window.SwapBuffers()
}
```
如你所见，我们循环每一个细胞，调用它的 `draw` 函数。如果运行这段代码，你能看到像下面这样的东西：
这是你想看到的吗？我们做的是在格子里为每一行每一列创建了一个方块，然后给它上色，这就填满了整个面板！
注释掉 for 循环，我们就可以看到一个明显独立的细胞，像这样：
```
// for x := range cells {
// for _, c := range cells[x] {
// c.draw()
// }
// }
cells[2][3].draw()
```
这只绘制坐标在 `(X=2, Y=3)` 的格子。你可以看到，每一个独立的细胞占据着面板的一小块部分，并且负责绘制自己那部分空间。我们也能看到游戏面板有自己的原点，也就是坐标为 `(X=0, Y=0)` 的点，在窗口的左下方。这仅仅是我们的 `newCell` 函数计算位置的方式，也可以用右上角，右下角，左上角，中央，或者其它任何位置当作原点。
接着往下做，移除 `cells[2][3].draw()` 这一行，取消 for 循环的那部分注释，变成之前那样全部绘制的样子。
### 总结
好了，我们现在能用两个三角形画出一个正方形了，我们还有一个游戏的面板了！我们该为此自豪，目前为止我们已经接触到了很多零碎的内容，老实说，最难的部分还在前面等着我们！
在接下来的第三节，我们会实现游戏核心逻辑，看到很酷的东西！
### 回顾
这是这一部分教程中 `main.go` 文件的内容：
```
package main
import (
"fmt"
"log"
"runtime"
"strings"
"github.com/go-gl/gl/v4.1-core/gl" // OR: github.com/go-gl/gl/v2.1/gl
"github.com/go-gl/glfw/v3.2/glfw"
)
const (
width = 500
height = 500
vertexShaderSource = `
#version 410
in vec3 vp;
void main() {
gl_Position = vec4(vp, 1.0);
}
` + "\x00"
fragmentShaderSource = `
#version 410
out vec4 frag_colour;
void main() {
frag_colour = vec4(1, 1, 1, 1.0);
}
` + "\x00"
rows = 10
columns = 10
)
var (
square = []float32{
-0.5, 0.5, 0,
-0.5, -0.5, 0,
0.5, -0.5, 0,
-0.5, 0.5, 0,
0.5, 0.5, 0,
0.5, -0.5, 0,
}
)
type cell struct {
drawable uint32
x int
y int
}
func main() {
runtime.LockOSThread()
window := initGlfw()
defer glfw.Terminate()
program := initOpenGL()
cells := makeCells()
for !window.ShouldClose() {
draw(cells, window, program)
}
}
func draw(cells [][]*cell, window *glfw.Window, program uint32) {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.UseProgram(program)
for x := range cells {
for _, c := range cells[x] {
c.draw()
}
}
glfw.PollEvents()
window.SwapBuffers()
}
func makeCells() [][]*cell {
cells := make([][]*cell, rows, rows)
for x := 0; x < rows; x++ {
for y := 0; y < columns; y++ {
c := newCell(x, y)
cells[x] = append(cells[x], c)
}
}
return cells
}
func newCell(x, y int) *cell {
points := make([]float32, len(square), len(square))
copy(points, square)
for i := 0; i < len(points); i++ {
var position float32
var size float32
switch i % 3 {
case 0:
size = 1.0 / float32(columns)
position = float32(x) * size
case 1:
size = 1.0 / float32(rows)
position = float32(y) * size
default:
continue
}
if points[i] < 0 {
points[i] = (position * 2) - 1
} else {
points[i] = ((position + size) * 2) - 1
}
}
return &cell{
drawable: makeVao(points),
x: x,
y: y,
}
}
func (c *cell) draw() {
gl.BindVertexArray(c.drawable)
gl.DrawArrays(gl.TRIANGLES, 0, int32(len(square)/3))
}
// 初始化 glfw，返回一个可用的 Window
func initGlfw() *glfw.Window {
if err := glfw.Init(); err != nil {
panic(err)
}
glfw.WindowHint(glfw.Resizable, glfw.False)
glfw.WindowHint(glfw.ContextVersionMajor, 4)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
window, err := glfw.CreateWindow(width, height, "Conway's Game of Life", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
return window
}
// 初始化 OpenGL 并返回一个可用的着色器程序
func initOpenGL() uint32 {
if err := gl.Init(); err != nil {
panic(err)
}
version := gl.GoStr(gl.GetString(gl.VERSION))
log.Println("OpenGL version", version)
vertexShader, err := compileShader(vertexShaderSource, gl.VERTEX_SHADER)
if err != nil {
panic(err)
}
fragmentShader, err := compileShader(fragmentShaderSource, gl.FRAGMENT_SHADER)
if err != nil {
panic(err)
}
prog := gl.CreateProgram()
gl.AttachShader(prog, vertexShader)
gl.AttachShader(prog, fragmentShader)
gl.LinkProgram(prog)
return prog
}
// 初始化并返回由 points 提供的顶点数组
func makeVao(points []float32) uint32 {
var vbo uint32
gl.GenBuffers(1, &vbo)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, 4*len(points), gl.Ptr(points), gl.STATIC_DRAW)
var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
gl.EnableVertexAttribArray(0)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 0, nil)
return vao
}
func compileShader(source string, shaderType uint32) (uint32, error) {
shader := gl.CreateShader(shaderType)
csources, free := gl.Strs(source)
gl.ShaderSource(shader, 1, csources, nil)
free()
gl.CompileShader(shader)
var status int32
gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status)
if status == gl.FALSE {
var logLength int32
gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength)
log := strings.Repeat("\x00", int(logLength+1))
gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log))
return 0, fmt.Errorf("failed to compile %v: %v", source, log)
}
return shader, nil
}
```
让我知道这篇文章对你有没有帮助，在 Twitter [@kylewbanks](https://twitter.com/kylewbanks) 或者下方的连接，关注我以便获取最新的文章！
---
via: <https://kylewbanks.com/blog/tutorial-opengl-with-golang-part-2-drawing-the-game-board>
作者：[kylewbanks](https://twitter.com/kylewbanks) 译者：[GitFtuture](https://github.com/GitFuture) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
运行在树莓派和 Arduino 上的开源社交机器人套件
|
Eric Brown
|
http://linuxgizmos.com/open-source-social-robot-kit-runs-on-raspberry-pi-and-arduino/
|
Thecorpora 的发布的 “Q.bo One” 机器人基于 RPi 3 和 Arduino，并提供立体相机、麦克风、扬声器，以及视觉和语言识别。
|
/data/attachment/album/201710/08/114802qnyu7knmrfmk5yac.jpg.thumb.jpg
|
/data/attachment/album/201710/08/114802qnyu7knmrfmk5yac.jpg
| true | false | true |
geekpi
| false |
[
"树莓派",
"机器人"
] |
新闻
|
{
"viewnum": 5389,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Thecorpora 的发布的 “Q.bo One” 机器人基于 RPi 3 和 Arduino，并提供立体相机、麦克风、扬声器，以及视觉和语言识别。
| 2017-10-08T11:47:58 | 2017-10-08T11:47:58 | 8,941 |
/article-8941-1.html
|
>
> Thecorpora 的发布的 “Q.bo One” 机器人基于 RPi 3 和 Arduino，并提供立体相机、麦克风、扬声器，以及视觉和语言识别。
>
>
>
2010 年，作为一个开源概念验证和用于探索 AI 在多传感器、交互式机器人的能力的研究项目，机器人开发商 Francisco Paz 及它在巴塞罗那的 Thecorpora 公司推出了首款 [Qbo](http://linuxdevices.linuxgizmos.com/open-source-robot-is-all-eyes/) “Cue-be-oh” 机器人。在今年 2 月移动世界大会上的预览之后，Thecorpora 把它放到了 Indiegogo 上，与 Arrow 合作推出了第一个批量生产的社交机器人版本。
*Q.bo One 的左侧*
*Q.bo One 的顶部*
像原来一样，新的 Q.bo One 有一个带眼睛的球形头（双立体相机）、耳朵（3 个麦克风）和嘴（扬声器），并由 WiFi 和蓝牙控制。 Q.bo One 也同样采用开源 Linux 软件和开放规格硬件。然而，它不是使用基于 Intel Atom 的 Mini-ITX 板，而是在与 Arduino 兼容的主板相连的 Raspberry Pi 3 上运行 Raspbian。
*Q.bo One 侧视图*\*
Q.bo One 于 7 月中旬在 Indiegogo 上架，起价为 369 美元（早期买家）或 399 美元，有包括内置的树莓派 3 和基于 Arduino 的 “Qboard” 控制器板。它还有售价 $499 的完整套装。目前，Indiegogo 上的众筹目标是 $100,000，现在大概达成了 15%，并且它 12 月出货。
更专业的机器人工程师和嵌入式开发人员可能会想要使用价值 $99 的只有树莓派和 Qboard PCB 和软件的版本，或者提供没有电路板的机器人套件的 $249 版本。使用此版本，你可以用自己的 Arduino 控制器替换 Qboard，并将树莓派 3 替换为另一个 Linux SBC。该公司列出了 Banana Pi、BeagleBone、Tinker Board 以及[即将退市的 Intel Edison](http://linuxgizmos.com/intel-pulls-the-plug-on-its-joule-edison-and-galileo-boards/)，作为兼容替代品的示例。
*Q.bo One 套件*
与 2010 年的 Qbo 不同，Q.bo One 除了球面头部之外无法移动，它可以在双重伺服系统的帮助下在底座上旋转，以便跟踪声音和动作。Robotis Dynamixel 舵机同样开源，树莓派基于 [TurtleBot 3](http://linuxgizmos.com/ubuntu-driven-turtlebot-gets-a-major-rev-with-a-pi-or-joule-in-the-drivers-seat/) 机器人工具包，除了左右之外，还可以上下移动。
*Q.bo One 细节*
*Qboard 细节*
Q.bo One 类似于基于 Linux 的 [Jibo](http://linuxgizmos.com/cheery-social-robot-owes-it-all-to-its-inner-linux/) “社交机器人”，它于 2014 年在 Indiegogo 众筹，最后达到 360 万美元。然而，Jibo 还没有出货，[最近的推迟](https://www.slashgear.com/jibo-delayed-to-2017-as-social-robot-hits-more-hurdles-20464725/)迫使它在今年的某个时候发布一个版本。
*Q.bo One*
我们大胆预测 Q.bo One 将会在 2017 年接近 12 月出货。核心技术和 AI 软件已被证明，而树莓派和 Arduino 技术也是如此。Qboard 主板已经由 Arrow 制造和认证。
开源设计表明，即使是移动版本也不会有问题。这使它更像是滚动的人形生物 [Pepper](http://linuxgizmos.com/worlds-first-emotional-robot-runs-linux/)，这是一个来自 Softbank 和 Aldeberan 类似的人工智能对话机器人。
Q.bo One 自原始版以来添加了一些技巧，例如由 20 个 LED 组成的“嘴巴”， 它以不同的、可编程的方式在语音中模仿嘴唇开合。如果你想点击机器人获得关注，那么它的头上还有三个触摸传感器。但是，你其实只需要说话就行，而 Q.bo One 会像一个可卡犬一样转身并凝视着你。
接口和你在树莓派 3 上的一样，它在我们的 [2017 黑客电路板调查](http://linuxgizmos.com/2017-hacker-board-survey-raspberry-pi-still-rules-but-x86-sbcs-make-gains/)中消灭了其他对手。为树莓派 3 的 WiFi 和蓝牙安装了天线。
*Q.bo One 软件架构*
*Q.bo One 及 Scratch 编程*
Qboard（也称为 Q.board）在 Atmel ATSAMD21 MCU 上运行 Arduino 代码，并有三个麦克风、扬声器、触摸传感器、Dynamixel 控制器和用于嘴巴的 LED 矩阵。其他功能包括 GPIO、I2C接口和可连接到台式机的 micro-USB 口。
Q.bo One 可以识别脸部和追踪移动，机器人甚至可以在镜子中识别自己。在云连接的帮助下，机器人可以识别并与其他 Q.bo One 机器人交谈。机器人可以在自然语言处理的帮助下回答问题，并通过文字转语音朗读。
可以使用 Scratch 编程，它是机器人的主要功能，可以教孩子关于机器人和编程。机器人也是为教育者和制造者设计的，可以作为老年人的伴侣。
基于 Raspbian 的软件使用 OpenCV 进行视觉处理，并可以使用各种语言（包括 C++）进行编程。该软件还提供了 IBM Bluemix、NodeRED 和 ROS 的钩子。大概你也可以整合 [Alexa](http://linuxgizmos.com/how-to-add-alexa-to-your-raspberry-pi-3-gizmo/) 或 [Google Assistant](http://linuxgizmos.com/free-raspberry-pi-voice-kit-taps-google-assistant-sdk/)语音代理，虽然 Thecorpora 没有提及这一点。
**更多信息**
Q.bo One 在 7 月中旬在 Indiegogo 上架，起价为完整套件 $369 和完整组合 $499 。出货预计在 2017 年 12 月。更多信息请参见 [Q.bo One 的 Indiegogo 页面](https://www.indiegogo.com/projects/q-bo-one-an-open-source-robot-for-everyone#/) 和[Thecorpora 网站](http://thecorpora.com/)。
---
via: <http://linuxgizmos.com/open-source-social-robot-kit-runs-on-raspberry-pi-and-arduino/>
作者：[Eric Brown](http://linuxgizmos.com/open-source-social-robot-kit-runs-on-raspberry-pi-and-arduino/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用 Linux、Python 和树莓派酿制啤酒
|
Christopher Aedo
|
https://opensource.com/article/17/7/brewing-beer-python-and-raspberry-pi
|
容量提升到 10 加仑之后，我偶然看到了 StrangeBrew Elsinore ，我意识到我真正需要的是将整个酿酒过程转换成全电子化的，用树莓派来运行它。
|
/data/attachment/album/201710/08/213019kf6388tfx16chbgf.png.thumb.jpg
|
/data/attachment/album/201710/08/213019kf6388tfx16chbgf.png
| true | false | true |
hwlife
| false |
[
"树莓派",
"啤酒"
] |
树莓派
|
{
"viewnum": 9919,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
容量提升到 10 加仑之后，我偶然看到了 StrangeBrew Elsinore ，我意识到我真正需要的是将整个酿酒过程转换成全电子化的，用树莓派来运行它。
| 2017-10-08T21:30:12 | 2017-10-08T21:30:12 | 8,942 |
/article-8942-1.html
|
>
> 怎样在家用 Python 和树莓派搭建一个家用便携的自制酿啤酒装置
>
>
>
大约十年前我开始酿制自制啤酒，和许多自己酿酒的人一样，我开始在厨房制造提纯啤酒。这需要一些设备并且做出来后确实是好的啤酒，最终，我用一个放入了所有大麦的大贮藏罐作为我的麦芽浆桶。几年之后我一次酿制过 5 加仑啤酒，但是酿制 10 加仑时也会花费同样的时间和效用（只是容器比之前大些），之前我就是这么做的。容量提升到 10 加仑之后，我偶然看到了 [StrangeBrew Elsinore](http://dougedey.github.io/SB_Elsinore_Server/) ，我意识到我真正需要的是将整个酿酒过程转换成全电子化的，用树莓派来运行它。
建造自己的家用电动化酿酒系统需要大量这方面的技术信息，许多学习酿酒的人是在 [TheElectricBrewery.com](http://theelectricbrewery.com/) 这个网站起步的，只不过将那些控制版搭建在一起是十分复杂的，尽管最简单的办法在这个网站上总结的很好。当然你也能用[一个小成本的方法](http://www.instructables.com/id/Electric-Brewery-Control-Panel-on-the-Cheap/)并且依旧可以得到相同的结果 —— 用一个热水壶和热酒容器通过一个 PID 控制器来加热你的酿酒原料。但是我认为这有点太无聊（这也意味着你不能体验到完整的酿酒过程）。
### 需要用到的硬件
在我开始我的这个项目之前, 我决定开始买零件，我最基础的设计是一个可以将液体加热到 5500 瓦的热酒容器（HLT）和开水壶，加一个活底的麦芽浆桶，我通过一个 50 英尺的不锈钢线圈在热酒容器里让泵来再循环麦芽浆（["热量交换再循环麦芽浆系统, 也叫 HERMS](https://byo.com/hops/item/1325-rims-and-herms-brewing-advanced-homebrewing)）。同时我需要另一个泵来在热酒容器里循环水，并且把水传输到麦芽浆桶里，整个电子部件全部是用树莓派来控制的。
建立我的电子酿酒系统并且尽可能的自动化意味着我需要以下的组件：
* 一个 5500 瓦的电子加热酒精容器（HLT）
* 能够放入加热酒精容器里的 50 英尺（0.5 英寸）的不锈钢线圈（热量交换再循环麦芽浆系统）
* 一个 5500 瓦的电子加热水壶
* 多个固态继电器加热开关
* 2 个高温食品级泵
* 泵的开关用继电器
* 可拆除装置和一个硅管
* 不锈钢球阀
* 一个测量温度的探针
* 很多线
* 一个来容纳这些配件的电路盒子
*酿酒系统 (photo by Christopher Aedo. [CC BY-SA 4.0)](https://creativecommons.org/licenses/by-sa/4.0/)*
建立酿酒系统的电气化方面的细节 [The Electric Brewery](http://theelectricbrewery.com/) 这个网站概括的很好，这里我不再重复，当你计划用树莓派代替这个 PID 控制器的话，你可以读以下的建议。
一个重要的事情需要注意，固态继电器（SSR）信号电压，许多教程建议使用一个 12 伏的固态继电器来关闭电路，树莓派的 GPIO 针插口只支持 3 伏输出电压，然而，必须购买继电器将电压变为 3 伏。
*Inkbird SSR (photo by Christopher Aedo. [CC BY-SA 4.0)](https://creativecommons.org/licenses/by-sa/4.0/)*
要运行酿酒系统，你的树莓派必须做两个关键事情：测量来自几个不同位置的温度，用继电器开关来控制加热元件，树莓派很容易来处理这些任务。
这里有一些不同的方法来将温度传感器连到树莓派上，但是我找到了最方便的方法用[单总线](https://en.wikipedia.org/wiki/1-Wire)。这就可以让多个传感器分享相同的线路（实际上是三根线），这三根线可以使酿酒系统的多个设备更方便的工作，如果你要从网上找一个防水的 DS18B20 温度传感器，你可以会找到很多选择。我用的是[日立 DS18B20 防水温度传感器](https://smile.amazon.com/gp/product/B018KFX5X0/)。
要控制加热元件，树莓派包括了几个用来软件寻址的总线扩展器（GPIO），它会通过在某个文件写入 0 或者 1 让你发送3.3v 的电压到一个继电器，在我第一次了解树莓派是怎样工作的时候，这个[用 GPIO 驱动继电器的树莓派教程](http://www.susa.net/wordpress/2012/06/raspberry-pi-relay-using-gpio/)对我来说是最有帮助的，总线扩展器控制着多个固态继电器，通过酿酒软件来直接控制加热元件的开关。
我首先将所有部件放到这个电路盒子，因为这将成为一个滚动的小车，我要让它便于移动，而不是固定不动的，如果我有一个店（比如说在车库、工具房、或者地下室），我需要要用一个装在墙上的更大的电路盒，而现在我找到一个大小正好的[防水工程盒子](http://amzn.to/2hupFCr)，能放进每件东西，最后它成为小巧紧凑工具盒，并且能够工作。在左下角是和树莓派连接的为总线扩展器到单总线温度探针和[固态继电器](http://amzn.to/2hL8JDS)的扩展板。
要保持 240v 的固态继电器温度不高，我在盒子上切了个洞，在盒子的外面用 CPU 降温凝胶把[铜片散热片](http://amzn.to/2i4DYwy)安装到盒子外面的热槽之间。它工作的很好，盒子里没有温度上的问题了，在盒子盖上我放了两个开关为 120v 的插座，加两个240v 的 led 来显示加热元件是否通电。我用干燥器的插座和插头，所以可以很容易的断开电热水壶的连接。首次尝试每件事情都工作正常。（第一次绘制电路图必有回报）
这个照片来自“概念”版，最终生产系统应该有两个以上的固态继电器，以便 240v 的电路两个针脚能够切换，另外我将通过软件来切换泵的开关。现在通过盒子前面的物理开关控制它们，但是也很容易用继电器控制它们。
*控制盒子 (photo by Christopher Aedo. [CC BY-SA 4.0)](https://creativecommons.org/licenses/by-sa/4.0/)*
唯一剩下有点棘手的事情是温度探针的压合接头，这个探针安装在加热酒精容器和麦芽浆桶球形的最底部阀门前的 T 字型接头上。当液体流过温度传感器，温度可以准确显示。我考虑加一个套管到热水壶里，但是对于我的酿造工艺没有什么用。最后，我买到了[四分之一英寸的压合接头](https://www.brewershardware.com/CF1412.html)，它们工作完美。
### 软件
一旦硬件整理好，我就有时间来处理软件了，我在树莓派上跑了最新的 [Raspbian 发行版](https://www.raspberrypi.org/downloads/raspbian/)，操作系统方面没有什么特别的。
我开始使用 [Strangebrew Elsinore](https://github.com/DougEdey/SB_Elsinore_Server) 酿酒软件，当我的朋友问我是否我听说过 [Hosehead](https://brewtronix.com/)（一个基于树莓派的酿酒控制器），我找到了 [Strangebrew Elsinore](https://github.com/DougEdey/SB_Elsinore_Server) 。我认为 [Hosehead](https://brewtronix.com/) 很棒，但我并不是要买一个酿酒控制器，而是要挑战自己，搭建一个自己的。
设置 [Strangebrew Elsinore](https://github.com/DougEdey/SB_Elsinore_Server) 很简单，其[文档](http://dougedey.github.io/SB_Elsinore_Server/)直白，没有遇到任何的问题。尽管 Strangebrew Elsinore 工作的很好，但在我的一代树莓派上运行 java 有时是费力的，不止崩溃一次。我看到这个软件开发停顿也很伤心，似乎他们也没有更多贡献者的大型社区（尽管有很多人还在用它）。
#### CraftBeerPi
之后我偶然遇到了一个用 Python 写的 [CraftbeerPI](http://www.craftbeerpi.com/)，它有活跃的贡献者支持的开发社区。原作者（也是当前维护者） Manuel Fritsch 在贡献和反馈问题处理方面做的很好。克隆[这个仓库](https://github.com/manuel83/craftbeerpi)然后开始只用了我一点时间。其 README 文档也是一个连接 DS1820 温度传感器的好例子，同时也有关于硬件接口到树莓派或者[芯片电脑](https://www.nextthing.co/pages/chip) 的注意事项。
在启动的时候，CraftbeerPI 引导用户通过一个设置过程来发现温度探针是否可用，并且让你指定哪个 GPIO 总线扩展器指针来管理树莓派上哪个配件。
*CraftBeerPi (photo by Christopher Aedo. [CC BY-SA 4.0)](https://creativecommons.org/licenses/by-sa/4.0/)*
用这个系统进行自制酿酒是容易的，我能够依靠它掌握可靠的温度，我能输入多个温度段来控制麦芽浆温度，用CraftbeerPi 酿酒的日子有一点点累，但是我很高兴用传统的手工管理丙烷燃烧器的“兴奋”来换取这个系统的有效性和持续性。
CraftBeerPI 的用户友好性鼓舞我设置了另一个控制器来运行“发酵室”。就我来说，那是一个二手冰箱，我用了 50 美元加上放在里面的 25 美元的加热器。CraftBeerPI 很容易控制电器元件的冷热，你也能够设置多个温度阶段。举个例子，这个图表显示我最近做的 IPA 进程的发酵温度。发酵室发酵麦芽汁在 67F° 的温度下需要 4 天，然后每 12 小时上升一度直到温度到达 72F°。剩下两天温度保持不变是为了双乙酰生成。之后 5 天温度降到 65F°，这段时间是让啤酒变“干”，最后啤酒发酵温度直接降到 38F°。CraftBeerPI 可以加入各个阶段，让软件管理发酵更加容易。
*SIPA 发酵设置 (photo by Christopher Aedo. [CC BY-SA 4.0)](https://creativecommons.org/licenses/by-sa/4.0/)*
我也试验过用[液体比重计](https://tilthydrometer.com/)来对酵啤酒的比重进行监测，通过蓝牙连接的浮动传感器可以达到。有一个整合的计划能让 CraftbeerPi 很好工作，现在它记录这些比重数据到谷歌的电子表格里。一旦这个液体比重计能连接到发酵控制器，设置的自动发酵设置会基于酵母的活动性直接运行且更加容易，而不是在 4 天内完成主要发酵，可以在比重稳定 24 小时后设定温度。
像这样的一些项目，构想并计划改进和增加组件是很容易，不过，我很高兴今天经历过的事情。我用这种装置酿造了很多啤酒，每次都能达到预期的麦芽汁比率，而且啤酒一直都很美味。我的最重要的消费者 —— 就是我！很高兴我可以随时饮用。
*随时饮用 (photo by Christopher Aedo. [CC BY-SA 4.0)](https://creativecommons.org/licenses/by-sa/4.0/)*
这篇文章基于 Christopher 的开放的西部的讲话《用Linux、Python 和树莓派酿制啤酒》。
（题图：[Quinn Dombrowski](https://www.flickr.com/photos/quinndombrowski/). Modified by Opensource.com. [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）
---
作者简介：
Christopher Aedo 从他的学生时代就从事并且贡献于开源软件事业。最近他在 IBM 领导一个极棒的上游开发者团队，同时他也是开发者拥护者。当他不再工作或者实在会议室演讲的时候，他可能在波特兰市俄勒冈州用树莓派酿制和发酵一杯美味的啤酒。
---
via: <https://opensource.com/article/17/7/brewing-beer-python-and-raspberry-pi>
作者：[Christopher Aedo](https://opensource.com/users/docaedo) 译者：[hwlife](https://github.com/hwlife) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开发一个 Linux 调试器（十）：高级主题
|
Simon Brand
|
https://blog.tartanllama.xyz/writing-a-linux-debugger-advanced-topics/
|
我将对调试中的一些更高级的概念进行高层的概述：远程调试、共享库支持、表达式计算和多线程支持。这些想法实现起来比较复杂，所以我不会详细说明如何做
|
/data/attachment/album/201710/08/223932vag1ajxuusf9zjfo.jpg.thumb.jpg
|
/data/attachment/album/201710/08/223932vag1ajxuusf9zjfo.jpg
| true | false | true |
geekpi
| false |
[
"调试器",
"调试"
] |
软件开发
|
{
"viewnum": 5189,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8936,
"displayorder": 0
}
] |
我将对调试中的一些更高级的概念进行高层的概述：远程调试、共享库支持、表达式计算和多线程支持。这些想法实现起来比较复杂，所以我不会详细说明如何做
| 2017-10-12T10:38:00 | 2017-10-12T10:38:00 | 8,943 |
/article-8943-1.html
|
我们终于来到这个系列的最后一篇文章！这一次，我将对调试中的一些更高级的概念进行高层的概述：远程调试、共享库支持、表达式计算和多线程支持。这些想法实现起来比较复杂，所以我不会详细说明如何做，但是如果你有问题的话，我很乐意回答有关这些概念的问题。
### 系列索引
1. [准备环境](/article-8626-1.html)
2. [断点](/article-8645-1.html)
3. [寄存器和内存](/article-8663-1.html)
4. [Elves 和 dwarves](/article-8719-1.html)
5. [源码和信号](/article-8812-1.html)
6. [源码层逐步执行](/article-8813-1.html)
7. [源码层断点](/article-8890-1.html)
8. [调用栈](/article-8930-1.html)
9. [处理变量](/article-8936-1.html)
10. [高级主题](https://blog.tartanllama.xyz/writing-a-linux-debugger-advanced-topics/)
### 远程调试
远程调试对于嵌入式系统或对不同环境进行调试非常有用。它还在高级调试器操作和与操作系统和硬件的交互之间设置了一个很好的分界线。事实上，像 GDB 和 LLDB 这样的调试器即使在调试本地程序时也可以作为远程调试器运行。一般架构是这样的：
调试器是我们通过命令行交互的组件。也许如果你使用的是 IDE，那么在其上有另一个层可以通过*机器接口*与调试器进行通信。在目标机器上（可能与本机一样）有一个<ruby> 调试存根 <rt> debug stub </rt></ruby> ，理论上它是一个非常小的操作系统调试库的包装程序，它执行所有的低级调试任务，如在地址上设置断点。我说“在理论上”，因为如今调试存根变得越来越大。例如，我机器上的 LLDB 调试存根大小是 7.6MB。调试存根通过使用一些特定于操作系统的功能（在我们的例子中是 `ptrace`）和被调试进程以及通过远程协议的调试器通信。
最常见的远程调试协议是 GDB 远程协议。这是一种基于文本的数据包格式，用于在调试器和调试存根之间传递命令和信息。我不会详细介绍它，但你可以在[这里](https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html)进一步阅读。如果你启动 LLDB 并执行命令 `log enable gdb-remote packets`，那么你将获得通过远程协议发送的所有数据包的跟踪信息。在 GDB 上，你可以用 `set remotelogfile <file>` 做同样的事情。
作为一个简单的例子，这是设置断点的数据包：
```
$Z0,400570,1#43
```
`$` 标记数据包的开始。`Z0` 是插入内存断点的命令。`400570` 和 `1` 是参数，其中前者是设置断点的地址，后者是特定目标的断点类型说明符。最后，`#43` 是校验值，以确保数据没有损坏。
GDB 远程协议非常易于扩展自定义数据包，这对于实现平台或语言特定的功能非常有用。
### 共享库和动态加载支持
调试器需要知道被调试程序加载了哪些共享库，以便它可以设置断点、获取源代码级别的信息和符号等。除查找被动态链接的库之外，调试器还必须跟踪在运行时通过 `dlopen` 加载的库。为了达到这个目的，动态链接器维护一个 *交汇结构体*。该结构体维护共享库描述符的链表，以及一个指向每当更新链表时调用的函数的指针。这个结构存储在 ELF 文件的 `.dynamic` 段中，在程序执行之前被初始化。
一个简单的跟踪算法：
* 追踪程序在 ELF 头中查找程序的入口（或者可以使用存储在 `/proc/<pid>/aux` 中的辅助向量）。
* 追踪程序在程序的入口处设置一个断点，并开始执行。
* 当到达断点时，通过在 ELF 文件中查找 `.dynamic` 的加载地址找到交汇结构体的地址。
* 检查交汇结构体以获取当前加载的库的列表。
* 链接器更新函数上设置断点。
* 每当到达断点时，列表都会更新。
* 追踪程序无限循环，继续执行程序并等待信号，直到追踪程序信号退出。
我给这些概念写了一个小例子，你可以在[这里](https://github.com/TartanLlama/dltrace)找到。如果有人有兴趣，我可以将来写得更详细一点。
### 表达式计算
表达式计算是程序的一项功能，允许用户在调试程序时对原始源语言中的表达式进行计算。例如，在 LLDB 或 GDB 中，可以执行 `print foo()` 来调用 `foo` 函数并打印结果。
根据表达式的复杂程度，有几种不同的计算方法。如果表达式只是一个简单的标识符，那么调试器可以查看调试信息，找到该变量并打印出该值，就像我们在本系列最后一部分中所做的那样。如果表达式有点复杂，则可能将代码编译成中间表达式 （IR） 并解释来获得结果。例如，对于某些表达式，LLDB 将使用 Clang 将表达式编译为 LLVM IR 并将其解释。如果表达式更复杂，或者需要调用某些函数，那么代码可能需要 JIT 到目标并在被调试者的地址空间中执行。这涉及到调用 `mmap` 来分配一些可执行内存，然后将编译的代码复制到该块并执行。LLDB 通过使用 LLVM 的 JIT 功能来实现。
如果你想更多地了解 JIT 编译，我强烈推荐 [Eli Bendersky 关于这个主题的文章](http://eli.thegreenplace.net/tag/code-generation)。
### 多线程调试支持
本系列展示的调试器仅支持单线程应用程序，但是为了调试大多数真实程序，多线程支持是非常需要的。支持这一点的最简单的方法是跟踪线程的创建，并解析 procfs 以获取所需的信息。
Linux 线程库称为 `pthreads`。当调用 `pthread_create` 时，库会使用 `clone` 系统调用来创建一个新的线程，我们可以用 `ptrace` 跟踪这个系统调用（假设你的内核早于 2.5.46）。为此，你需要在连接到调试器之后设置一些 `ptrace` 选项：
```
ptrace(PTRACE_SETOPTIONS, m_pid, nullptr, PTRACE_O_TRACECLONE);
```
现在当 `clone` 被调用时，该进程将收到我们的老朋友 `SIGTRAP` 信号。对于本系列中的调试器，你可以将一个例子添加到 `handle_sigtrap` 来处理新线程的创建：
```
case (SIGTRAP | (PTRACE_EVENT_CLONE << 8)):
//get the new thread ID
unsigned long event_message = 0;
ptrace(PTRACE_GETEVENTMSG, pid, nullptr, message);
//handle creation
//...
```
一旦收到了，你可以看看 `/proc/<pid>/task/` 并查看内存映射之类来获得所需的所有信息。
GDB 使用 `libthread_db`，它提供了一堆帮助函数，这样你就不需要自己解析和处理。设置这个库很奇怪，我不会在这展示它如何工作，但如果你想使用它，你可以去阅读[这个教程](http://timetobleed.com/notes-about-an-odd-esoteric-yet-incredibly-useful-library-libthread_db/)。
多线程支持中最复杂的部分是调试器中线程状态的建模，特别是如果你希望支持[不间断模式](https://sourceware.org/gdb/onlinedocs/gdb/Non_002dStop-Mode.html)或当你计算中涉及不止一个 CPU 的某种异构调试。
### 最后！
呼！这个系列花了很长时间才写完，但是我在这个过程中学到了很多东西，我希望它是有帮助的。如果你有关于调试或本系列中的任何问题，请在 Twitter [@TartanLlama](https://twitter.com/TartanLlama)或评论区联系我。如果你有想看到的其他任何调试主题，让我知道我或许会再发其他的文章。
---
via: <https://blog.tartanllama.xyz/writing-a-linux-debugger-advanced-topics/>
作者：[Simon Brand](https://www.twitter.com/TartanLlama) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
进入 Linux 桌面之窗
|
Jonathan Terrasi
|
http://www.linuxinsider.com/story/84473.html
|
如果你想要的是闪电般快速的桌面体验且向高效妥协, 那么经典桌面中的窗口管理器可能适合你。
|
/data/attachment/album/201710/09/104530d2hwkpzr5hcipvie.jpg.thumb.jpg
|
/data/attachment/album/201710/09/104530d2hwkpzr5hcipvie.jpg
| true | false | true |
geekpi
| true |
[
"桌面环境",
"窗口管理器"
] |
观点
|
{
"viewnum": 8165,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 2,
"likes": 0
}
|
[] |
[] |
如果你想要的是闪电般快速的桌面体验且向高效妥协, 那么经典桌面中的窗口管理器可能适合你。
| 2017-10-09T10:45:45 | 2017-10-09T10:45:45 | 8,944 |
/article-8944-1.html
|
>
> “它能做什么 Windows 不能做的吗？”
>
>
>
这是许多人在考虑使用 Linux 桌面时的第一个问题。虽然支撑 Linux 的开源哲学对于某些人来说就是一个很好的理由，但是有些人想知道它在外观、感受和功能上有多么不同。在某种程度上，这取决于你是否选择桌面环境或窗口管理器。
如果你想要的是闪电般快速的桌面体验且向高效妥协, 那么经典桌面中的窗口管理器可能适合你。
### 事实之真相
“<ruby> 桌面环境 <rt> Desktop Environment </rt></ruby>（DE）”是一个技术术语，指典型的、全功能桌面，即你的操作系统的完整图形化布局。除了显示你的程序，桌面环境还包括应用程序启动器，菜单面板和小部件等组成部分。
在 Microsoft Windows 中，桌面环境包括开始菜单、显示打开的程序的任务栏和通知中心，还有与操作系统捆绑在一起的所有 Windows 程序，以及围绕这打开的程序的框架（包括右上角的最小按钮、最大按钮和关闭按钮）。
Linux 中有很多相似之处。
例如，Linux [Gnome](http://en.wikipedia.org/wiki/GNOME) 桌面环境的设计略有不同，但它共享了所有的 Microsoft Windows 的基本元素 - 从应用程序菜单到显示打开的应用程序的面板、通知栏、窗框式程序。
窗口程序框架依赖于一个组件来绘制它们，并允许你移动并调整大小：它被称为“<ruby> 窗口管理器 <rt> Window Manager </rt></ruby>（WM）”。因为它们都有窗口，所以每个桌面环境都包含一个窗口管理器。
然而，并不是每个窗口管理器都是桌面环境的一部分。你可以只运行窗口管理器，并且完全有这么做的需要。
### 离开你的环境
对本专栏而言，所谓的“窗口管理器”指的是可以那种独立进行的。如果在现有的 Linux 系统上安装了一个窗口管理器，你可以在不关闭系统的情况下注销，在登录屏幕上选择新的窗口管理器，然后重新登录。
不过, 在研究你的窗口管理器之前，你可能不想这么做，因为你将会看到一个空白屏幕和稀疏的状态栏，而且它或许能、或许不能点击。
通常情况下，可以直接在窗口管理器中直接启动终端，因为这是你编辑其配置文件的方式。在那里你会发现用来启动程序的按键和鼠标组合，你实际上也可以使用你的新设置。
例如，在流行的 i3 窗口管理器中，你可以通过按下 `Super` 键（即 `Windows` 键）加 `Enter` 键来启动终端，或者按 `Super + D` 启动<ruby> 应用程序启动器 <rt> app launcher </rt></ruby>。你可以在其中输入应用程序名称，然后按 `Enter` 键将其打开。所有已有的应用程序都可以通过这种方式找到，一旦选择后，它们将会全屏打开。
[](http://www.linuxinsider.com/article_images/2017/84473_1200x750.jpg)
i3 还是一个平铺式窗口管理器，这意味着它可以确保所有的窗口均匀地扩展到屏幕，既不重叠也不浪费空间。当弹出新窗口时，它会减少现有的窗口，将它们推到一边腾出空间。用户可以以垂直或水平相邻的方式打开下一个窗口。
### 功能亦敌亦友
当然，桌面环境有其优点。首先，它们提供功能丰富、可识别的界面。每个都有其特征鲜明的风格，但总体而言，它们提供了普适的默认设置，这使得桌面环境从一开始就可以使用。
另一个优点是桌面环境带有一组程序和媒体编解码器，允许用户立即完成简单的任务。此外，它们还包括一些方便的功能，如电池监视器、无线小部件和系统通知。
与桌面环境的完善相应的，是这种大型软件库和用户体验理念独一无二，这就意味着它们所能做的都是有限度的。这也意味着它们并不总是非常可配置。桌面环境强调的是漂亮的外表，很多时候是金玉其外的。
许多桌面环境对系统资源的渴求是众所周知的，所以它们不太喜欢低端硬件。因为在其上运行的视觉效果，还有更多的东西可能会出错。我曾经尝试调整与我正在运行的桌面环境无关的网络设置，然后整个崩溃了。而当我打开一个窗口管理器，我就可以改变设置。
那些优先考虑安全性的人可能希望不要桌面环境，因为更多的程序意味着更大的攻击面 —— 也就是坏人可以突破的入口点。
然而，如果你想尝试一下桌面环境，XFCE 是一个很好的起点，因为它的较小的软件库消除了一些臃肿，如果你不往里面塞东西，垃圾就会更少。
乍一看，它不是最漂亮的，但在下载了一些 GTK 主题包（每个桌面环境都可以提供这些主题或 Qt 主题，而 XFCE 在 GTK 阵营之中），并且在“外观”部分的设置中，你可以轻松地修改。你甚至可以在这个[集中式画廊](http://www.xfce-look.org/)中找到你最喜欢的主题。
### 时间就是生命
如果你想了解桌面环境之外可以做什么，你会发现窗口管理器给了你足够的回旋余地。
无论如何，窗口管理器都是与定制有关的。事实上，它们的可定制性已经催生了无数的画廊，承载着一个充满活力的社区用户，他们手中的调色板就是窗口管理器。
窗口管理器的少量资源需求使它们成为较低规格硬件的理想选择，并且由于大多数窗口管理器不附带任何程序，因此允许喜欢模块化的用户只添加所需的程序。
可能与桌面环境最为显著的区别是，窗口管理器通常通过鼠标移动和键盘热键来打开程序或启动器来聚焦效率。
键盘驱动的窗口管理器特别流畅，你可以启动新的窗口、输入文本或更多的键盘命令、移动它们，并再次关闭它们，这一切无需将手从<ruby> 键盘中间 <rt> home row </rt></ruby>移开。一旦你适应了其设计逻辑，你会惊讶于你能够如此快速地完成任务。
尽管它们提供了自由，窗口管理器也有其缺点。最显著的是，它们是赤裸裸的开箱即用。在你可以使用其中一个之前，你必须花时间阅读窗口管理器的文档以获取配置语法，可能还需要更多的时间来找到该语法的窍门。
如果你从桌面环境（这是最可能的情况）切换过来，尽管你会有一些用户程序，你也会缺少一些熟悉的东西，如电池指示器和网络小部件，并且需要一些时间来设置新的。
如果你想深入窗口管理器，i3 有[完整的文档](https://i3wm.org/docs/)和简明直白的配置语法。配置文件不使用任何编程语言 - 它只是每行定义一个变量值对。创建热键只要输入 `bindsym`、键盘绑定以及该组合启动的动作即可。
虽然窗口管理器不适合每个人，但它们提供了独特的计算体验，而 Linux 是少数允许使用它们的操作系统之一。无论你最终采用哪种模式，我希望这个概观能够给你足够的信息，以便对你所做的选择感到自信 —— 或者有足够的信心跨出您熟悉的区域来看看还有什么可用的。
---
作者简介：
Jonathan Terrasi - 自 2017 年以来一直是 ECT 新闻网专栏作家。他的主要兴趣是计算机安全（特别是 Linux 桌面）、加密和分析政治和时事。他是全职自由作家和音乐家。他的背景包括在芝加哥委员会发表的关于维护人权法案的文章中提供技术评论和分析。
---
via: <http://www.linuxinsider.com/story/84473.html>
作者：[Jonathan Terrasi](%5B1%5D:http://www.linuxinsider.com/story/84473.html?rss=1#) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
通过 SSH 实现 TCP / IP 隧道（端口转发）：使用 OpenSSH 可能的 8 种场景
|
Ahmad
|
https://wesharethis.com/2017/07/creating-tcp-ip-port-forwarding-tunnels-ssh-8-possible-scenarios-using-openssh/
|
我们还可以在这种加密后的连接上通过创建隧道（端口转发）的方式，来实现两个不同终端间的互联。凭借这种方式，只要我们能通过 SSH 创建连接，就可以绕开防火墙或者端口禁用的限制。
|
/data/attachment/album/201710/09/233056nkp8dbzv0qflqfbk.png.thumb.jpg
|
/data/attachment/album/201710/09/233056nkp8dbzv0qflqfbk.png
| true | false | true |
toutoudnf
| false |
[
"隧道",
"SSH"
] |
系统运维
|
{
"viewnum": 12390,
"commentnum": 1,
"favtimes": 10,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "123.125.146.66",
"message": "请问场景4和场景8的vncviewer命令是不是写错了？<br />\r\n interno2 $ internal vncviewer1::7900<br />\r\n好像应该是 <br />\r\n interno2 $ vncviewer interno1::7900",
"username": "来自北京的 Firefox 60.0|Mac 10.13 用户",
"date": "2019-02-25T00:12:16"
}
] |
[
{
"raid": 8947,
"displayorder": 0
}
] |
我们还可以在这种加密后的连接上通过创建隧道（端口转发）的方式，来实现两个不同终端间的互联。凭借这种方式，只要我们能通过 SSH 创建连接，就可以绕开防火墙或者端口禁用的限制。
| 2017-10-09T23:31:00 | 2017-10-09T23:31:00 | 8,945 |
/article-8945-1.html
|
对于 [Secure Shell (SSH)](http://en.wikipedia.org/wiki/Secure_Shell) 这样的网络协议来说，其主要职责就是在终端模式下访问一个远程系统。因为 SSH 协议对传输数据进行了加密，所以通过它在远端系统执行命令是安全的。此外，我们还可以在这种加密后的连接上通过创建隧道（端口转发）的方式，来实现两个不同终端间的互联。凭借这种方式，只要我们能通过 SSH 创建连接，就可以绕开防火墙或者端口禁用的限制。
这个话题在网络领域有大量的应用和讨论：
* [Wikipedia: SSH Tunneling](http://en.wikipedia.org/wiki/Tunneling_protocol#SSH_tunneling)
* [O’Reilly: Using SSH Tunneling](http://www.oreillynet.com/pub/a/wireless/2001/02/23/wep.html)
* [Ssh.com: Tunneling Explained](http://www.ssh.com/support/documentation/online/ssh/winhelp/32/Tunneling_Explained.html)
* [Ssh.com: Port Forwarding](http://www.ssh.com/support/documentation/online/ssh/adminguide/32/Port_Forwarding.html)
* [SecurityFocus: SSH Port Forwarding](http://www.securityfocus.com/infocus/1816)
* [Red Hat Magazine: SSH Port Forwarding](http://magazine.redhat.com/2007/11/06/ssh-port-forwarding/)
我们在接下来的内容中并不讨论端口转发的细节，而是准备介绍一个如何使用 [OpenSSH](http://www.openssh.com/) 来完成 TCP 端口转发的速查表，其中包含了八种常见的场景。有些 SSH 客户端，比如 [PuTTY](http://www.chiark.greenend.org.uk/%7Esgtatham/putty/)，也允许通过界面配置的方式来实现端口转发。而我们着重关注的是通过 OpenSSH 来实现的的方式。
在下面的例子当中，我们假设环境中的网络划分为外部网络（network1）和内部网络（network2）两部分，并且这两个网络之间，只能在 externo1 与 interno1 之间通过 SSH 连接的方式来互相访问。外部网络的节点之间和内部网络的节点之间是完全联通的。
### 场景 1
>
> 在 externo1 节点访问由 interno1 节点提供的 TCP 服务（本地端口转发 / 绑定地址 = localhost / 主机 = localhost ）
>
>
>
externo1 节点可以通过 OpenSSH 连接到 interno1 节点，之后我们想通过其访问运行在 5900 端口上的 VNC 服务。
我们可以通过下面的命令来实现：
```
externo1 $ ssh -L 7900:localhost:5900 user@interno1
```
现在，我们可以在 externo1 节点上确认下 7900 端口是否处于监听状态中：
```
externo1 $ netstat -ltn
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
...
Tcp 0 0 127.0.0.1:7900 0.0.0.0:* LISTEN
...
```
我们只需要在 externo1 节点上执行如下命令即可访问 internal 节点的 VNC 服务：
```
externo1 $ vncviewer localhost::7900
```
注意：在 [vncviewer 的 man 手册](http://www.realvnc.com/products/free/4.1/man/vncviewer.html)中并未提及这种修改端口号的方式。在 [About VNCViewer configuration of the output TCP port](http://www.realvnc.com/pipermail/vnc-list/2006-April/054551.html) 中可以看到。这也是 [the TightVNC vncviewer](http://www.tightvnc.com/vncviewer.1.html) 所介绍的的。
### 场景 2
>
> 在 externo2 节点上访问由 interno1 节点提供的 TCP 服务（本地端口转发 / 绑定地址 = 0.0.0.0 / 主机 = localhost）
>
>
>
这次的场景跟方案 1 的场景的类似，但是我们这次想从 externo2 节点来连接到 interno1 上的 VNC 服务：
正确的命令如下：
```
externo1 $ ssh -L 0.0.0.0:7900:localhost:5900 user@interno1
```
看起来跟方案 1 中的命令类似，但是让我们看看 `netstat` 命令的输出上的区别。7900 端口被绑定到了本地（`127.0.0.1`），所以只有本地进程可以访问。这次我们将端口关联到了 `0.0.0.0`，所以系统允许任何 IP 地址的机器访问 7900 这个端口。
```
externo1 $ netstat -ltn
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
...
Tcp 0 0 0.0.0.0:7900 0.0.0.0:* LISTEN
...
```
所以现在在 externo2 节点上，我们可以执行：
```
externo2 $ vncviewer externo1::7900
```
来连接到 interno1 节点上的 VNC 服务。
除了将 IP 指定为 `0.0.0.0` 之外，我们还可以使用参数 `-g`（允许远程机器使用本地端口转发），完整命令如下：
```
externo1 $ ssh -g -L 7900:localhost:5900 user@interno1
```
这条命令与前面的命令能实现相同效果：
```
externo1 $ ssh -L 0.0.0.0:7900:localhost:5900 user@interno1
```
换句话说，如果我们想限制只能连接到系统上的某个 IP，可以像下面这样定义：
```
externo1 $ ssh -L 192.168.24.80:7900:localhost:5900 user@interno1
externo1 $ netstat -ltn
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
...
Tcp 0 0 192.168.24.80:7900 0.0.0.0:* LISTEN
...
```
### 场景 3
>
> 在 interno1 上访问由 externo1 提供的 TCP 服务（远程端口转发 / 绑定地址 = localhost / 主机 = localhost）
>
>
>
在场景 1 中 SSH 服务器与 TCP 服务（VNC）提供者在同一个节点上。现在我们想在 SSH 客户端所在的节点上，提供一个 TCP 服务（VNC）供 SSH 服务端来访问：
将方案 1 中的命令参数由 `-L` 替换为 `-R`。
完整命令如下：
```
externo1 $ ssh -R 7900:localhost:5900 user@interno1
```
然后我们就能看到 interno1 节点上对 7900 端口正在监听：
```
interno1 $ netstat -lnt
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
...
Tcp 0 0 127.0.0.1:7900 0.0.0.0:* LISTEN
...
```
现在在 interno1 节点上，我们可以使用如下命令来访问 externo1 上的 VNC 服务：
```
interno1 $ vncviewer localhost::7900
```
### 场景 4
>
> interno2 使用 externo1 上提供的 TCP 服务（远端端口转发 / 绑定地址 = 0.0.0.0 / 主机 = localhost）
>
>
>
与场景 3 类似，但是现在我们尝试指定允许访问转发端口的 IP（就像场景 2 中做的一样）为 `0.0.0.0`，这样其他节点也可以访问 VNC 服务：
正确的命令是：
```
externo1 $ ssh -R 0.0.0.0:7900:localhost:5900 user@interno1
```
但是这里有个重点需要了解，出于安全的原因，如果我们直接执行该命令的话可能不会生效，因为我们需要修改 SSH 服务端的一个参数值 `GatewayPorts`，它的默认值是：`no`。
>
> GatewayPorts
>
>
> 该参数指定了远程主机是否允许客户端访问转发端口。默认情况下，sshd(8) 只允许本机进程访问转发端口。这是为了阻止其他主机连接到该转发端口。GatewayPorts 参数可用于让 sshd 允许远程转发端口绑定到非回环地址上，从而可以让远程主机访问。当参数值设置为 “no” 的时候只有本机可以访问转发端口；“yes” 则表示允许远程转发端口绑定到通配地址上；或者设置为 “clientspecified” 则表示由客户端来选择哪些主机地址允许访问转发端口。默认值是 “no”。
>
>
>
如果我们没有修改服务器配置的权限，我们将不能使用该方案来进行端口转发。这是因为如果没有其他的限制，用户可以开启一个端口（> 1024）来监听来自外部的请求并转发到 `localhost:7900`。
参照这个案例：[netcat](http://en.wikipedia.org/wiki/Netcat) ( [Debian # 310431: sshd\_config should warn about the GatewayPorts workaround.](http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=310431) )
所以我们修改 `/etc/ssh/sshd_config`，添加如下内容：
```
GatewayPorts clientspecified
```
然后，我们使用如下命令来重载修改后的配置文件（在 Debian 和 Ubuntu 上）。
```
sudo /etc/init.d/ssh reload
```
我们确认一下现在 interno1 节点上存在 7900 端口的监听程序，监听来自不同 IP 的请求：
```
interno1 $ netstat -ltn
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
...
Tcp 0 0 0.0.0.0:7900 0.0.0.0:* LISTEN
...
```
然后我们就可以在 interno2 节点上使用 VNC 服务了：
```
interno2 $ internal vncviewer1::7900
```
### 场景 5
>
> 在 externo1 上使用由 interno2 提供的 TCP 服务（本地端口转发 / 绑定地址 localhost / 主机 = interno2 ）
>
>
>
在这种场景下我们使用如下命令：
```
externo1 $ ssh -L 7900:interno2:5900 user@interno1
```
然后我们就能在 externo1 节点上，通过执行如下命令来使用 VNC 服务了：
```
externo1 $ vncviewer localhost::7900
```
### 场景 6
>
> 在 interno1 上使用由 externo2 提供的 TCP 服务（远程端口转发 / 绑定地址 = localhost / host = externo2）
>
>
>
在这种场景下，我们使用如下命令：
```
externo1 $ ssh -R 7900:externo2:5900 user@interno1
```
然后我们可以在 interno1 上通过执行如下命令来访问 VNC 服务：
```
interno1 $ vncviewer localhost::7900
```
### 场景 7
>
> 在 externo2 上使用由 interno2 提供的 TCP 服务（本地端口转发 / 绑定地址 = 0.0.0.0 / 主机 = interno2）
>
>
>
本场景下，我们使用如下命令：
```
externo1 $ ssh -L 0.0.0.0:7900:interno2:5900 user@interno1
```
或者：
```
externo1 $ ssh -g -L 7900:interno2:5900 user@interno1
```
然后我们就可以在 externo2 上执行如下命令来访问 vnc 服务：
```
externo2 $ vncviewer externo1::7900
```
### 场景 8
>
> 在 interno2 上使用由 externo2 提供的 TCP 服务（远程端口转发 / 绑定地址 = 0.0.0.0 / 主机 = externo2）
>
>
>
本场景下我们使用如下命令：
```
externo1 $ ssh -R 0.0.0.0:7900:externo2:5900 user@interno1
```
SSH 服务器需要配置为：
```
GatewayPorts clientspecified
```
就像我们在场景 4 中讲过的那样。
然后我们可以在 interno2 节点上执行如下命令来访问 VNC 服务：
```
interno2 $ internal vncviewer1::7900
```
如果我们需要一次性的创建多个隧道，使用配置文件的方式替代一个可能很长的命令是一个更好的选择。假设我们只能通过 SSH 的方式访问某个特定网络，同时又需要创建多个隧道来访问该网络内不同服务器上的服务，比如 VNC 或者 [远程桌面](http://en.wikipedia.org/wiki/Remote_Desktop_Services)。此时只需要创建一个如下的配置文件 `$HOME/redirects` 即可（在 SOCKS 服务器 上）。
```
# SOCKS server
DynamicForward 1080
# SSH redirects
LocalForward 2221 serverlinux1: 22
LocalForward 2222 serverlinux2: 22
LocalForward 2223 172.16.23.45:22
LocalForward 2224 172.16.23.48:22
# RDP redirects for Windows systems
LocalForward 3391 serverwindows1: 3389
LocalForward 3392 serverwindows2: 3389
# VNC redirects for systems with "vncserver"
LocalForward 5902 serverlinux1: 5901
LocalForward 5903 172.16.23.45:5901
```
然后我们只需要执行如下命令：
```
externo1 $ ssh -F $HOME/redirects user@interno1
```
---
via: <https://wesharethis.com/2017/07/creating-tcp-ip-port-forwarding-tunnels-ssh-8-possible-scenarios-using-openssh/>
作者：[Ahmad](https://wesharethis.com/author/ahmad/) 译者：[toutoudnf](https://github.com/toutoudnf) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
12 件可以用 GitHub 完成的很酷的事情
|
David Gilbertson
|
https://hackernoon.com/12-cool-things-you-can-do-with-github-f3e0424cf2f0
|
我希望这里至少有三件事是你此前并不知道的……
|
/data/attachment/album/201710/10/170748tur07mwv03qd23ow.jpg.thumb.jpg
|
/data/attachment/album/201710/10/170748tur07mwv03qd23ow.jpg
| true | false | true |
softpaopao
| true |
[
"GitHub"
] |
软件开发
|
{
"viewnum": 7207,
"commentnum": 0,
"favtimes": 6,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我希望这里至少有三件事是你此前并不知道的……
| 2017-10-10T17:08:00 | 2017-10-10T17:08:00 | 8,946 |
/article-8946-1.html
|
我不能为我的人生想出一个引子来，所以……
### #1 在 GitHub.com 上编辑代码
我想我要开始介绍的第一件事是多数人都已经知道的（尽管我一周之前还不知道）。
当你登录到 GitHub ，查看一个文件时（任何文本文件，任何版本库），右上方会有一只小铅笔。点击它，你就可以编辑文件了。 当你编辑完成后，GitHub 会给出文件变更的建议，然后为你<ruby> 复刻 <rt> fork </rt></ruby>该仓库并创建一个<ruby> 拉取请求 <rt> pull request </rt></ruby>（PR）。
是不是很疯狂？它为你创建了一个复刻！
你不需要自己去复刻、拉取，然后本地修改，再推送，然后创建一个 PR。
*不是一个真正的 PR*
这对于修改错误拼写以及编辑代码时的一些糟糕的想法是很有用的。
### #2 粘贴图像
在评论和<ruby> 工单 <rt> issue </rt></ruby>的描述中并不仅限于使用文字。你知道你可以直接从剪切板粘贴图像吗？ 在你粘贴的时候，你会看到图片被上传 (到云端，这毫无疑问)，并转换成 markdown 显示的图片格式。
棒极了。
### #3 格式化代码
如果你想写一个代码块的话，你可以用三个反引号（```）作为开始 —— 就像你在浏览 [精通 Markdown](https://guides.github.com/features/mastering-markdown/) 时所学到的一样 —— 而且 GitHub 会尝试去推测你所写下的编程语言。
但如果你粘贴的像是 Vue、Typescript 或 JSX 这样的代码，你就需要明确指出才能获得高亮显示。
在首行注明 ````jsx`：
…这意味着代码段已经正确的呈现：
（顺便说一下，这些用法也可以用到 gist。 如果你给一个 gist 用上 `.jsx` 扩展名，你的 JSX 语法就会高亮显示。）
这里是[所有被支持的语法](https://github.com/github/linguist/blob/fc1404985abb95d5bc33a0eba518724f1c3c252e/vendor/README.md)的清单。
### #4 用 PR 中的魔法词来关闭工单
比方说你已经创建了一个用来修复 `#234` 工单的拉取请求。那么你就可以把 `fixes #234` 这段文字放在你的 PR 的描述中（或者是在 PR 的评论的任何位置）。
接下来，在合并 PR 时会自动关闭与之对应的工单。这是不是很酷？
这里是[更详细的学习帮助](https://help.github.com/articles/closing-issues-using-keywords/)。
### #5 链接到评论
是否你曾经想要链接到一个特定的评论但却无从着手？这是因为你不知道如何去做到这些。不过那都过去了，我的朋友，我告诉你啊，点击紧挨着名字的日期或时间，这就是如何链接到一个评论的方法。
*嘿，这里有 gaearon 的照片！*
### #6 链接到代码
那么你想要链接到代码的特定行么。我了解了。
试试这个：在查看文件的时候，点击挨着代码的行号。
哇哦，你看到了么？URL 更新了，加上了行号！如果你按下 `Shift` 键并点击其他的行号，格里格里巴巴变！URL 再一次更新并且现在出现了行范围的高亮。
分享这个 URL 将会链接到这个文件的那些行。但等一下，链接所指向的是当前分支。如果文件发生变更了怎么办？也许一个文件当前状态的<ruby> 永久链接 <rt> permalink </rt></ruby>就是你以后需要的。
我比较懒，所以我已经在一张截图中做完了上面所有的步骤：
*说起 URL…*
### #7 像命令行一样使用 GitHub URL
使用 UI 来浏览 GitHub 有着很好的体验。但有些时候最快到达你想去的地方的方法就是在地址栏输入。举个例子，如果我想要跳转到一个我正在工作的分支，然后查看与 master 分支的差异，我就可以在我的仓库名称的后边输入 `/compare/branch-name` 。
这样就会访问到指定分支的 diff 页面。
然而这就是与 master 分支的 diff，如果我要与 develoment 分支比较，我可以输入 `/compare/development...my-branch`。
对于你这种键盘快枪手来说，`ctrl`+`L` 或 `cmd`+`L` 将会向上跳转光标进入 URL 那里（至少在 Chrome 中是这样）。这（再加上你的浏览器会自动补全）能够成为一种在分支间跳转的便捷方式。
专家技巧：使用方向键在 Chrome 的自动完成建议中移动同时按 `shift`+`delete` 来删除历史条目（例如，一旦分支被合并后）。
（我真的好奇如果我把快捷键写成 `shift + delete` 这样的话，是不是读起来会更加容易。但严格来说 ‘+’ 并不是快捷键的一部分，所以我并不觉得这很舒服。这一点纠结让 *我* 整晚难以入睡，Rhonda。）
### #8 在工单中创建列表
你想要在你的<ruby> 工单 <rt> issue </rt></ruby>中看到一个复选框列表吗？
你想要在工单列表中显示为一个漂亮的 “2 of 5” 进度条吗?
很好！你可以使用这些的语法创建交互式的复选框：
```
- [ ] Screen width (integer)
- [x] Service worker support
- [x] Fetch support
- [ ] CSS flexbox support
- [ ] Custom elements
```
它的表示方法是空格、破折号、再空格、左括号、填入空格（或者一个 `x` ），然后封闭括号，接着空格，最后是一些话。
然后你可以实际选中或取消选中这些框！出于一些原因这些对我来说看上去就像是技术魔法。你可以*选中*这些框! 同时底层的文本会进行更新。
他们接下来会想到什么魔法？
噢，如果你在一个<ruby> 项目面板 <rt> project board </rt></ruby>上有这些工单的话，它也会在这里显示进度：
如果在我提到“在一个项目面板上”时你不知道我在说些什么，那么你会在本页下面进一步了解。
比如，在本页面下 2 厘米的地方。
### #9 GitHub 上的项目面板
我常常在大项目中使用 Jira 。而对于个人项目我总是会使用 Trello 。我很喜欢它们两个。
当我学会 GitHub 的几周后，它也有了自己的项目产品，就在我的仓库上的 Project 标签，我想我会照搬一套我已经在 Trello 上进行的任务。
*没有一个是有趣的任务*
这里是在 GitHub 项目上相同的内容：
*你的眼睛最终会适应这种没有对比的显示*
出于速度的缘故，我把上面所有的都添加为 “<ruby> 备注 <rt> note </rt></ruby>” —— 意思是它们不是真正的 GitHub 工单。
但在 GitHub 上，管理任务的能力被集成在版本库的其他地方 —— 所以你可能想要从仓库添加已有的工单到面板上。
你可以点击右上角的<ruby> 添加卡片 <rt> Add Cards </rt></ruby>，然后找你想要添加的东西。在这里，特殊的[搜索语法](https://help.github.com/articles/searching-issues-and-pull-requests/)就派上用场了，举个例子，输入 `is:pr is:open` 然后现在你可以拖动任何开启的 PR 到项目面板上，或者要是你想清理一些 bug 的话就输入 `label:bug`。
亦或者你可以将现有的备注转换为工单。
再或者，从一个现有工单的屏幕上，把它添加到右边面板的项目上。
它们将会进入那个项目面板的分类列表，这样你就能决定放到哪一类。
在实现那些任务的同一个仓库下放置任务的内容有一个巨大（超大）的好处。这意味着今后的几年你能够在一行代码上做一个 `git blame`，可以让你找出最初在这个任务背后写下那些代码的根据，而不需要在 Jira、Trello 或其它地方寻找蛛丝马迹。
#### 缺点
在过去的三周我已经对所有的任务使用 GitHub 取代 Jira 进行了测试（在有点看板风格的较小规模的项目上) ，到目前为止我都很喜欢。
但是我无法想象在 scrum（LCTT 译注：迭代式增量软件开发过程）项目上使用它，我想要在那里完成正确的工期估算、开发速度的测算以及所有的好东西怕是不行。
好消息是，GitHub 项目只有很少一些“功能”，并不会让你花很长时间去评估它是否值得让你去切换。因此要不要试试，你自己看着办。
无论如何，我*听说过* [ZenHub](https://www.zenhub.com/) 并且在 10 分钟前第一次打开了它。它是对 GitHub 高效的延伸，可以让你估计你的工单并创建 epic 和 dependency。它也有 velocity 和<ruby> 燃尽图 <rt> burndown chart </rt></ruby>功能；这看起来*可能是*世界上最棒的东西了。
延伸阅读： [GitHub help on Projects](https://help.github.com/articles/tracking-the-progress-of-your-work-with-project-boards/)。
### #10 GitHub 维基
对于一堆非结构化页面（就像维基百科一样）， GitHub <ruby> 维基 <rt> wiki </rt></ruby>提供的（下文我会称之为 Gwiki）就很优秀。
结构化的页面集合并没那么多，比如说你的文档。这里没办法说“这个页面是那个页面的子页”，或者有像‘下一节’和‘上一节’这样的按钮。Hansel 和 Gretel 将会完蛋，因为这里没有面包屑导航（LCTT 译注：引自童话故事《糖果屋》）。
（边注，你有*读过*那个故事吗? 这是个残酷的故事。两个混蛋小子将饥肠辘辘的老巫婆烧死在*她自己的火炉*里。毫无疑问她是留下来收拾残局的。我想这就是为什么如今的年轻人是如此的敏感 —— 今天的睡前故事太不暴力了。)
继续 —— 把 Gwiki 拿出来接着讲，我输入一些 NodeJS 文档中的内容作为维基页面，然后创建一个侧边栏以模拟一些真实结构。这个侧边栏会一直存在，尽管它无法高亮显示你当前所在的页面。
其中的链接必须手动维护，但总的来说，我认为这已经很好了。如果你觉得有需要的话可以[看一下](https://github.com/davidgilbertson/about-github/wiki)。
它将不会与像 GitBook（它使用了 [Redux 文档](http://redux.js.org/)）或定制的网站这样的东西相比较。但它八成够用了，而且它就在你的仓库里。
我是它的一个粉丝。
我的建议：如果你已经拥有不止一个 `README.md` 文件，并且想要一些不同的页面作为用户指南或是更详细的文档，那么下一步你就需要停止使用 Gwiki 了。
如果你开始觉得缺少的结构或导航非常有必要的话，去切换到其他的产品吧。
### #11 GitHub 页面（带有 Jekyll）
你可能已经知道了可以使用 GitHub <ruby> 页面 <rt> Pages </rt></ruby> 来托管静态站点。如果你不知道的话现在就可以去试试。不过这一节确切的说是关于使用 Jekyll 来构建一个站点。
最简单的来说， GitHub 页面 + Jekyll 会将你的 `README.md` 呈现在一个漂亮的主题中。举个例子，看看我的 [关于 github](https://github.com/davidgilbertson/about-github) 中的 readme 页面:
点击 GitHub 上我的站点的<ruby> 设置 <rt> settings </rt></ruby>标签，开启 GitHub 页面功能，然后挑选一个 Jekyll 主题……
我就会得到一个 [Jekyll 主题的页面](https://davidgilbertson.github.io/about-github/)：
由此我可以构建一个主要基于易于编辑的 markdown 文件的静态站点，其本质上是把 GitHub 变成一个 CMS（LCTT 译注：内容管理系统）。
我还没有真正的使用过它，但这就是 React 和 Bootstrap 网站构建的过程，所以并不可怕。
注意，在本地运行它需要 Ruby （Windows 用户会彼此交换一下眼神，然后转头看向其它的方向。macOS 用户会发出这样这样的声音 “出什么问题了，你要去哪里？Ruby 可是一个通用平台！GEMS 万岁！”）。
（这里也有必要加上，“暴力或威胁的内容或活动” 在 GitHub 页面上是不允许的，因此你不能去部署你的 Hansel 和 Gretel 重启之旅了。）
#### 我的意见
为了这篇文章，我对 GitHub 页面 + Jekyll 研究越多，就越觉得这件事情有点奇怪。
“拥有你自己的网站，让所有的复杂性远离”这样的想法是很棒的。但是你仍然需要在本地生成配置。而且可怕的是需要为这样“简单”的东西使用很多 CLI（LCTT 译注：命令行界面）命令。
我只是略读了[入门部分](https://jekyllrb.com/docs/home/)的七页，给我的感觉像是*我才是*那个小白。此前我甚至从来没有学习过所谓简单的 “Front Matter” 的语法或者所谓简单的 “Liquid 模板引擎” 的来龙去脉。
我宁愿去手工编写一个网站。
老实说我有点惊讶 Facebook 使用它来写 React 文档，因为他们能够用 React 来构建他们的帮助文档，并且在一天之内[预渲染到静态的 HTML 文件](https://github.com/facebookincubator/create-react-app/blob/master/packages/react-scripts/template/README.md#pre-rendering-into-static-html-files)。
他们所需要做的就是利用已有的 Markdown 文件，就像跟使用 CMS 一样。
我想是这样……
### #12 使用 GitHub 作为 CMS
比如说你有一个带有一些文本的网站，但是你并不想在 HTML 的标记中储存那些文本。
取而代之，你想要把这堆文本存放到某个地方，以便非开发者也可以很容易地编辑。也许要使用某种形式的版本控制。甚至还可能需要一个审查过程。
这里是我的建议：在你的版本库中使用 markdown 文件存储文本。然后在你的前端使用插件来获取这些文本块并在页面呈现。
我是 React 的支持者，因此这里有一个 `<Markdown>` 插件的示例，给出一些 markdown 的路径，它就会被获取、解析，并以 HTML 的形式呈现。
（我正在使用 [marked](https://www.npmjs.com/package/marked) npm 包来将 markdown 解析为 HTML。）
这里是我的示例仓库 [/text-snippets](https://github.com/davidgilbertson/about-github/tree/master/text-snippets)，里边有一些 markdown 文件 。
（你也可以使用 GitHub API 来[获取内容](https://developer.github.com/v3/repos/contents/#get-contents) —— 但我不确定你是否能搞定。）
你可以像这样使用插件：
如此，GitHub 就是你的 CMS 了，可以说，不管有多少文本块都可以放进去。
上边的示例只是在浏览器上安装好插件后获取 markdown 。如果你想要一个静态站点那么你需要服务器端渲染。
有个好消息！没有什么能阻止你从服务器中获取所有的 markdown 文件 (并配上各种为你服务的缓存策略)。如果你沿着这条路继续走下去的话，你可能会想要去试试使用 GitHub API 去获取目录中的所有 markdown 文件的列表。
### 奖励环节 —— GitHub 工具！
我曾经使用过一段时间的 [Chrome 的扩展 Octotree](https://chrome.google.com/webstore/detail/octotree/bkhaagjahfmjljalopjnoealnfndnagc?hl=en-US)，而且现在我推荐它。虽然不是吐血推荐，但不管怎样我还是推荐它。
它会在左侧提供一个带有树状视图的面板以显示当前你所查看的仓库。
从[这个视频](https://www.youtube.com/watch?v=NhlzMcSyQek&index=2&list=PLNYkxOF6rcIB3ci6nwNyLYNU6RDOU3YyL)中我了解到了 [octobox](https://octobox.io/) ，到目前为止看起来还不错。它是一个 GitHub 工单的收件箱。这一句介绍就够了。
说到颜色，在上面所有的截图中我都使用了亮色主题，所以希望不要闪瞎你的双眼。不过说真的，我看到的其他东西都是黑色的主题，为什么我非要忍受 GitHub 这个苍白的主题呐？
这是由 Chrome 扩展 [Stylish](https://chrome.google.com/webstore/detail/stylish-custom-themes-for/fjnbnpbmkenffdnngjfgmeleoegfcffe/related?hl=en)（它可以在任何网站使用主题）和 [GitHub Dark](https://userstyles.org/styles/37035/github-dark) 风格的一个组合。要完全黑化，那黑色主题的 Chrome 开发者工具（这是内建的，在设置中打开） 以及 [Atom One Dark for Chrome 主题](https://chrome.google.com/webstore/detail/atom-one-dark-theme/obfjhhknlilnfgfakanjeimidgocmkim?hl=en)你肯定也需要。
### Bitbucket
这些内容不适合放在这篇文章的任何地方，但是如果我不称赞 Bitbucket 的话，那就不对了。
两年前我开始了一个项目并花了大半天时间评估哪一个 git 托管服务更适合，最终 Bitbucket 赢得了相当不错的成绩。他们的代码审查流程遥遥领先（这甚至比 GitHub 拥有的指派审阅者的概念要早很长时间）。
GitHub 后来在这次审查竞赛中追了上来，干的不错。不幸的是在过去的一年里我没有机会再使用 Bitbucket —— 也许他们依然在某些方面领先。所以，我会力劝每一个选择 git 托管服务的人考虑一下 Bitbucket 。
### 结尾
就是这样！我希望这里至少有三件事是你此前并不知道的，祝好。
修订：在评论中有更多的技巧；请尽管留下你自己喜欢的技巧。真的，真心祝好。
（题图：orig08.deviantart.net）
---
via: <https://hackernoon.com/12-cool-things-you-can-do-with-github-f3e0424cf2f0>
作者：[David Gilbertson](https://hackernoon.com/@david.gilbertson) 译者：[softpaopao](https://github.com/softpaopao) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
动态端口转发：安装带有 SSH 的 SOCKS 服务器
|
Ahmad
|
https://wesharethis.com/2017/07/15/dynamic-port-forwarding-mount-socks-server-ssh/
|
当我们谈论使用 SSH 进行动态端口转发时，我们说的是将 SSH 服务器转换为 SOCKS 服务器。
|
/data/attachment/album/201710/10/222722j7eum8e7kfbfk44m.jpg.thumb.jpg
|
/data/attachment/album/201710/10/222722j7eum8e7kfbfk44m.jpg
| true | false | true |
firmianay
| false |
[
"SOCKS",
"SSH"
] |
技术
|
{
"viewnum": 10407,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8945,
"displayorder": 0
}
] |
当我们谈论使用 SSH 进行动态端口转发时，我们说的是将 SSH 服务器转换为 SOCKS 服务器。
| 2017-10-10T22:27:37 | 2017-10-10T22:27:37 | 8,947 |
/article-8947-1.html
|
在上一篇文章（[通过 SSH 实现 TCP / IP 隧道（端口转发）：使用 OpenSSH 可能的 8 种场景](/article-8945-1.html)）中，我们看到了处理端口转发的所有可能情况，不过那只是静态端口转发。也就是说，我们只介绍了通过 SSH 连接来访问另一个系统的端口的情况。
在那篇文章中，我们未涉及动态端口转发，此外一些读者没看过该文章，本篇文章中将尝试补充完整。
当我们谈论使用 SSH 进行动态端口转发时，我们说的是将 SSH 服务器转换为 [SOCKS](https://wesharethis.com/goto/http://en.wikipedia.org/wiki/SOCKS) 服务器。那么什么是 SOCKS 服务器？
你知道 [Web 代理](https://wesharethis.com/goto/http://en.wikipedia.org/wiki/Proxy_server)是用来做什么的吗？答案可能是肯定的，因为很多公司都在使用它。它是一个直接连接到互联网的系统，允许没有互联网访问的[内部网](https://wesharethis.com/goto/http://en.wikipedia.org/wiki/Intranet)客户端让其浏览器通过代理来（尽管也有[透明代理](https://wesharethis.com/goto/http://en.wikipedia.org/wiki/Proxy_server#Transparent_and_non-transparent_proxy_server)）浏览网页。Web 代理除了允许输出到 Internet 之外，还可以缓存页面、图像等。已经由某客户端下载的资源，另一个客户端不必再下载它们。此外，它还可以过滤内容并监视用户的活动。当然了，它的基本功能是转发 HTTP 和 HTTPS 流量。
一个 SOCKS 服务器提供的服务类似于公司内部网络提供的代理服务器服务，但不限于 HTTP/HTTPS，它还允许转发任何 TCP/IP 流量（SOCKS 5 也支持 UDP）。
例如，假设我们希望在一个没有直接连接到互联网的内部网上通过 Thunderbird 使用 POP3 、 ICMP 和 SMTP 的邮件服务。如果我们只有一个 web 代理可以用，我们可以使用的唯一的简单方式是使用某个 webmail（也可以使用 [Thunderbird 的 Webmail 扩展](https://wesharethis.com/goto/http://webmail.mozdev.org/)）。我们还可以通过 [HTTP 隧道](https://wesharethis.com/goto/http://en.wikipedia.org/wiki/HTTP_tunnel_(software))来起到代理的用途。但最简单的方式是在网络中设置一个 SOCKS 服务器，它可以让我们使用 POP3、ICMP 和 SMTP，而不会造成任何的不便。
虽然有很多软件可以配置非常专业的 SOCKS 服务器，但用 OpenSSH 设置一个只需要简单的一条命令：
```
Clientessh $ ssh -D 1080 user@servidorssh
```
或者我们可以改进一下：
```
Clientessh $ ssh -fN -D 0.0.0.0:1080 user@servidorssh
```
其中：
* 选项 `-D` 类似于选项为 `-L` 和 `-R` 的静态端口转发。像那些一样，我们可以让客户端只监听本地请求或从其他节点到达的请求，具体取决于我们将请求关联到哪个地址：
```
-D [bind_address:] port
```
在静态端口转发中可以看到，我们使用选项 `-R` 进行反向端口转发，而动态转发是不可能的。我们只能在 SSH 客户端创建 SOCKS 服务器，而不能在 SSH 服务器端创建。
* 1080 是 SOCKS 服务器的典型端口，正如 8080 是 Web 代理服务器的典型端口一样。
* 选项 `-N` 防止实际启动远程 shell 交互式会话。当我们只用 `ssh` 来建立隧道时很有用。
* 选项 `-f` 会使 `ssh` 停留在后台并将其与当前 shell 分离，以便使该进程成为守护进程。如果没有选项 `-N`（或不指定命令），则不起作用，否则交互式 shell 将与后台进程不兼容。
使用 [PuTTY](https://wesharethis.com/goto/http://www.chiark.greenend.org.uk/%7Esgtatham/putty/download.html) 也可以非常简单地进行端口重定向。与 `ssh -D 0.0.0.0:1080` 相当的配置如下：
对于通过 SOCKS 服务器访问另一个网络的应用程序，如果应用程序提供了对 SOCKS 服务器的特别支持，就会非常方便（虽然不是必需的），就像浏览器支持使用代理服务器一样。作为一个例子，如 Firefox 或 Internet Explorer 这样的浏览器使用 SOCKS 服务器访问另一个网络的应用程序：
注意：上述截图来自 [IE for Linux](https://wesharethis.com/goto/http://www.tatanka.com.br/ies4linux/page/Main_Page) ：如果您需要在 Linux 上使用 Internet Explorer，强烈推荐！
然而，最常见的浏览器并不要求 SOCKS 服务器，因为它们通常与代理服务器配合得更好。
不过，Thunderbird 也支持 SOCKS，而且很有用：
另一个例子：[Spotify](https://wesharethis.com/goto/https://www.spotify.com/int/download/linux/) 客户端同样支持 SOCKS：
需要关注一下名称解析。有时我们会发现，在目前的网络中，我们无法解析 SOCKS 服务器另一端所要访问的系统的名称。SOCKS 5 还允许我们通过隧道传播 DNS 请求（ 因为 SOCKS 5 允许我们使用 UDP）并将它们发送到另一端：可以指定是本地还是远程解析（或者也可以两者都试试）。支持此功能的应用程序也必须考虑到这一点。例如，Firefox 具有参数 `network.proxy.socks_remote_dns`（在 `about:config` 中），允许我们指定远程解析。而默认情况下，它在本地解析。
Thunderbird 也支持参数 `network.proxy.socks_remote_dns`，但由于没有地址栏来放置 `about:config`，我们需要改变它，就像在 [MozillaZine:about:config](https://wesharethis.com/goto/http://kb.mozillazine.org/About:config) 中读到的，依次点击 工具 → 选项 → 高级 → 常规 → 配置编辑器（按钮）。
没有对 SOCKS 特别支持的应用程序可以被 <ruby> sock 化 <rt> socksified </rt></ruby>。这对于使用 TCP/IP 的许多应用程序都没有问题，但并不是全部。“sock 化” 需要加载一个额外的库，它可以检测对 TCP/IP 堆栈的请求，并修改请求，以通过 SOCKS 服务器重定向，从而不需要特别编程来支持 SOCKS 便可以正常通信。
在 Windows 和 [Linux](https://wesharethis.com/2017/07/10/linux-swap-partition/) 上都有 “Sock 化工具”。
对于 Windows，我们举个例子，SocksCap 是一种闭源，但对非商业使用免费的产品，我使用了很长时间都十分满意。SocksCap 由一家名为 Permeo 的公司开发，该公司是创建 SOCKS 参考技术的公司。Permeo 被 [Blue Coat](https://wesharethis.com/goto/http://www.bluecoat.com/) 买下后，它[停止了 SocksCap 项目](https://wesharethis.com/goto/http://www.bluecoat.com/products/sockscap)。现在你仍然可以在互联网上找到 `sc32r240.exe` 文件。[FreeCap](https://wesharethis.com/goto/http://www.freecap.ru/eng/) 也是面向 Windows 的免费代码项目，外观和使用都非常类似于 SocksCap。然而，它工作起来更加糟糕，多年来一直没有缺失维护。看起来，它的作者倾向于推出需要付款的新产品 [WideCap](https://wesharethis.com/goto/http://widecap.ru/en/support/)。
这是 SocksCap 的一个界面，可以看到我们 “sock 化” 了的几个应用程序。当我们从这里启动它们时，这些应用程序将通过 SOCKS 服务器访问网络：
在配置对话框中可以看到，如果选择了协议 SOCKS 5，我们可以选择在本地或远程解析名称：
在 Linux 上，如同往常一样，对某个远程命令我们都有许多替代方案。在 Debian/Ubuntu 中，命令行：
```
$ Apt-cache search socks
```
的输出会告诉我们很多。
最著名的是 [tsocks](https://wesharethis.com/goto/http://tsocks.sourceforge.net/) 和 [proxychains](https://wesharethis.com/goto/http://proxychains.sourceforge.net/)。它们的工作方式大致相同：只需用它们启动我们想要 “sock 化” 的应用程序就行。使用 `proxychains` 的 `wget` 的例子：
```
$ Proxychains wget http://www.google.com
ProxyChains-3.1 (http://proxychains.sf.net)
--19: 13: 20-- http://www.google.com/
Resolving www.google.com ...
DNS-request | Www.google.com
| S-chain | - <- - 10.23.37.3:1080-<><>-4.2.2.2:53-<><>-OK
| DNS-response | Www.google.com is 72.14.221.147
72.14.221.147
Connecting to www.google.com | 72.14.221.147 |: 80 ...
| S-chain | - <- - 10.23.37.3:1080-<><>-72.14.221.147:80-<><>-OK
Connected.
HTTP request sent, awaiting response ... 200 OK
Length: unspecified [text / html]
Saving to: `index.html '
[<=>] 6,016 24.0K / s in 0.2s
19:13:21 (24.0 KB / s) - `index.html 'saved [6016]
```
要让它可以工作，我们必须在 `/etc/proxychains.conf` 中指定要使用的代理服务器：
```
[ProxyList]
Socks5 clientessh 1080
```
我们也设置远程进行 DNS 请求：
```
# Proxy DNS requests - no leak for DNS data
Proxy_dns
```
另外，在前面的输出中，我们已经看到了同一个 `proxychains` 的几条信息性的消息， 非 `wget` 的行是标有字符串 `|DNS-request|`、`|S-chain|` 或 `|DNS-response|` 的。如果我们不想看到它们，也可以在配置中进行调整：
```
# Quiet mode (no output from library)
Quiet_mode
```
---
via: <https://wesharethis.com/2017/07/15/dynamic-port-forwarding-mount-socks-server-ssh/>
作者：[Ahmad](https://wesharethis.com/author/ahmad/) 译者：[firmianay](https://github.com/firmianay) 校对：[jasminepeng](https://github.com/jasminepeng)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么 DevOps 如我们所知道的那样，是安全的终结
|
Mike Barton
|
https://techbeacon.com/why-devops-end-security-we-know-it
|
Corman 谈论了安全和 DevOps 共同的价值，以及这些共同价值如何帮助组织更少地受到中断和攻击的影响。
|
/data/attachment/album/201710/10/232115x6vxixjd3dyx16d4.jpg.thumb.jpg
|
/data/attachment/album/201710/10/232115x6vxixjd3dyx16d4.jpg
| true | false | true |
geekpi
| false |
[
"DevOps",
"安全"
] |
观点
|
{
"viewnum": 3732,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Corman 谈论了安全和 DevOps 共同的价值，以及这些共同价值如何帮助组织更少地受到中断和攻击的影响。
| 2017-10-10T23:21:13 | 2017-10-10T23:21:13 | 8,948 |
/article-8948-1.html
|
安全难以推行。在企业管理者迫使开发团队尽快发布程序的大环境下，很难说服他们花费有限的时间来修补安全漏洞。但是鉴于所有网络攻击中有 84％ 发生在应用层，作为一个组织是无法承担其开发团队不包括安全性带来的后果。
DevOps 的崛起为许多安全负责人带来了困境。Sonatype 的前 CTO [Josh Corman](https://twitter.com/joshcorman) 说：“这是对安全的威胁，但这也是让安全变得更好的机会。” Corman 是一个坚定的[将安全和 DevOps 实践整合起来创建 “坚固的 DevOps”](https://techbeacon.com/want-rugged-devops-team-your-release-security-engineers)的倡导者。Business Insights 与 Corman 谈论了安全和 DevOps 共同的价值，以及这些共同价值如何帮助组织更少地受到中断和攻击的影响。
### 安全和 DevOps 实践如何互惠互利？
**Josh Corman：** 一个主要的例子是 DevOps 团队对所有可测量的东西进行检测的倾向。安全性一直在寻找更多的情报和遥测。你可以获取许多 DevOps 团队正在测量的信息，并将这些信息输入到你的日志管理或 SIEM （安全信息和事件管理系统）。
一个 OODA 循环（<ruby> 观察 <rt> observe </rt></ruby>、<ruby> 定向 <rt> orient </rt></ruby>、<ruby> 决定 <rt> decide </rt></ruby>、<ruby> 行为 <rt> act </rt></ruby>）的前提是有足够普遍的眼睛和耳朵，以注意到窃窃私语和回声。DevOps 为你提供无处不在的仪器。
### 他们有分享其他文化观点吗？
**JC：** “严肃对待你的代码”是一个共同的价值观。例如，由 Netflix 编写的软件工具 Chaos Monkey 是 DevOps 团队的分水岭。它是为了测试亚马逊网络服务的弹性和可恢复性而创建的，Chaos Monkey 使得 Netflix 团队更加强大，更容易为中断做好准备。
所以现在有个想法是我们的系统需要测试，因此，James Wickett 和我及其他人决定做一个邪恶的、带有攻击性的 Chaos Monkey，这就是 GAUNTLT 项目的来由。它基本上是一堆安全测试, 可以在 DevOps 周期和 DevOps 工具链中使用。它也有非常适合 DevOps 的API。
### 企业安全和 DevOps 价值在哪里相交？
**JC：** 这两个团队都认为复杂性是一切事情的敌人。例如，[安全人员和 Rugged DevOps 人员](https://techbeacon.com/rugged-devops-rsa-6-takeaways-security-ops-pros)实际上可以说：“看，我们在我们的项目中使用了 11 个日志框架 - 也许我们不需要那么多，也许攻击面和复杂性可能会让我们受到伤害或者损害产品的质量或可用性。”
复杂性往往是许多事情的敌人。通常情况下，你不会很难说服 DevOps 团队在架构层面使用更好的建筑材料：使用最新的、最不易受攻击的版本，并使用较少的组件。
### “更好的建筑材料”是什么意思？
**JC：** 我是世界上最大的开源仓库的保管人，所以我能看到他们在使用哪些版本，里面有哪些漏洞，何时他们没有修复漏洞，以及等了多久。例如，某些日志记录框架从不会修复任何错误。其中一些会在 90 天内修复了大部分的安全漏洞。人们越来越多地遭到攻击，因为他们使用了一个毫无安全的框架。
除此之外，即使你不知道日志框架的质量，拥有 11 个不同的框架会变得非常笨重、出现 bug，还有额外的工作和复杂性。你暴露在漏洞中的风险是非常大的。你想把时间花在修复大量的缺陷上，还是在制造下一个大的破坏性的事情上？
[Rugged DevOps 的关键是软件供应链管理](https://techbeacon.com/josh-corman-security-devops-how-shared-team-values-can-reduce-threats)，其中包含三个原则：使用更少和更好的供应商、使用这些供应商的最高质量的部分、并跟踪这些部分，以便在发生错误时，你可以有一个及时和敏捷的响应。
### 所以变更管理也很重要。
**JC：** 是的，这是另一个共同的价值。我发现，当一家公司想要执行诸如异常检测或净流量分析等安全测试时，他们需要知道“正常”的样子。让人们失误的许多基本事情与仓库和补丁管理有关。
我在 *Verizon 数据泄露调查报告*中看到，追踪去年被成功利用的漏洞后，其中 97％ 归结为 10 个 CVE（常见漏洞和风险），而这 10 个已经被修复了十多年。所以，我们羞于谈论高级间谍活动。我们没有做基本的补丁工作。现在，我不是说如果你修复这 10 个CVE，那么你就没有被利用，而是这占据了人们实际失误的最大份额。
[DevOps 自动化工具](https://techbeacon.com/devops-automation-best-practices-how-much-too-much)的好处是它们已经成为一个意外的变更管理数据库。其真实反应了谁在哪里什么时候做了变更。这是一个巨大的胜利，因为我们经常对安全性有最大影响的因素无法控制。你承受了 CIO 和 CTO 做出的选择的后果。随着 IT 通过自动化变得更加严格和可重复，你可以减少人为错误的机会，并且哪里发生了变化更加可追溯。
### 你认为什么是最重要的共同价值？
**JC：** DevOps 涉及到过程和工具链，但我认为定义这种属性的是文化，特别是同感。 DevOps 有用是因为开发人员和运维团队能够更好地了解彼此，并做出更明智的决策。不是在解决孤岛中的问题，而是为了活动流程和目标解决。如果你向 DevOps 的团队展示安全如何能使他们变得更好，那么作为回馈他们往往会问：“那么，我们是否有任何选择让你的生活更轻松？”因为他们通常不知道他们做的 X、Y 或 Z 的选择使它无法包含安全性。
对于安全团队，驱动价值的方法之一是在寻求帮助之前变得更有所帮助，在我们告诉 DevOps 团队要做什么之前提供定性和定量的价值。你必须获得 DevOps 团队的信任，并获得发挥的权利，然后才能得到回报。它通常比你想象的快很多。
---
via: <https://techbeacon.com/why-devops-end-security-we-know-it>
作者：[Mike Barton](https://twitter.com/intent/follow?original_referer=https%3A%2F%2Ftechbeacon.com%2Fwhy-devops-end-security-we-know-it%3Fimm_mid%3D0ee8c5%26cmp%3Dem-webops-na-na-newsltr_20170310&ref_src=twsrc%5Etfw®ion=follow_link&screen_name=mikebarton&tw_p=followbutton) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
关于 HTML5 你需要了解的基础知识
|
Palak Shah
|
http://opensourceforu.com/2017/06/introduction-to-html5/
|
HTML5 是第五个且是当前的 HTML 版本，它是用于在万维网上构建和呈现内容的标记语言。本文将帮助读者了解它。
|
/data/attachment/album/201710/12/090409dpfqygzrpzuhpnqd.jpg.thumb.jpg
|
/data/attachment/album/201710/12/090409dpfqygzrpzuhpnqd.jpg
| true | false | true |
geekpi
| false |
[
"HTML5",
"HTML"
] |
软件开发
|
{
"viewnum": 6466,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
HTML5 是第五个且是当前的 HTML 版本，它是用于在万维网上构建和呈现内容的标记语言。本文将帮助读者了解它。
| 2017-10-12T09:04:00 | 2017-10-12T09:04:00 | 8,950 |
/article-8950-1.html
|
>
> HTML5 是第五个且是当前的 HTML 版本，它是用于在万维网上构建和呈现内容的标记语言。本文将帮助读者了解它。
>
>
>
HTML5 通过 W3C 和<ruby> Web 超文本应用技术工作组 <rt> Web Hypertext Application Technology Working Group </rt></ruby>之间的合作发展起来。它是一个更高版本的 HTML，它的许多新元素可以使你的页面更加语义化和动态。它是为所有人提供更好的 Web 体验而开发的。HTML5 提供了很多的功能，使 Web 更加动态和交互。
HTML5 的新功能是：
* 新标签，如 `<header>` 和 `<section>`
* 用于 2D 绘图的 `<canvas>` 元素
* 本地存储
* 新的表单控件，如日历、日期和时间
* 新媒体功能
* 地理位置
HTML5 还不是正式标准（LCTT 译注：HTML5 已于 2014 年成为“推荐标准”），因此，并不是所有的浏览器都支持它或其中一些功能。开发 HTML5 背后最重要的原因之一是防止用户下载并安装像 Silverlight 和 Flash 这样的多个插件。
### 新标签和元素
* **语义化元素：** 图 1 展示了一些有用的语义化元素。
* **表单元素：** HTML5 中的表单元素如图 2 所示。
* **图形元素：** HTML5 中的图形元素如图 3 所示。
* **媒体元素：** HTML5 中的新媒体元素如图 4 所示。
[](http://opensourceforu.com/wp-content/uploads/2017/05/Figure-1-7.jpg)
*图 1：语义化元素*
[](http://opensourceforu.com/wp-content/uploads/2017/05/Figure-2-5.jpg)
*图 2：表单元素*
[](http://opensourceforu.com/wp-content/uploads/2017/05/Figure-3-2.jpg)
*图 3：图形元素*
[](http://opensourceforu.com/wp-content/uploads/2017/05/Figure-4-2.jpg)
*图 4：媒体元素*
### HTML5 的高级功能
#### 地理位置
这是一个 HTML5 API，用于获取网站用户的地理位置，用户必须首先允许网站获取他或她的位置。这通常通过按钮和/或浏览器弹出窗口来实现。所有最新版本的 Chrome、Firefox、IE、Safari 和 Opera 都可以使用 HTML5 的地理位置功能。
地理位置的一些用途是：
* 公共交通网站
* 出租车及其他运输网站
* 电子商务网站计算运费
* 旅行社网站
* 房地产网站
* 在附近播放的电影的电影院网站
* 在线游戏
* 网站首页提供本地标题和天气
* 工作职位可以自动计算通勤时间
**工作原理：** 地理位置通过扫描位置信息的常见源进行工作，其中包括以下：
* 全球定位系统（GPS）是最准确的
* 网络信号 - IP地址、RFID、Wi-Fi 和蓝牙 MAC地址
* GSM/CDMA 蜂窝 ID
* 用户输入
该 API 提供了非常方便的函数来检测浏览器中的地理位置支持：
```
if (navigator.geolocation) {
// do stuff
}
```
`getCurrentPosition` API 是使用地理位置的主要方法。它检索用户设备的当前地理位置。该位置被描述为一组地理坐标以及航向和速度。位置信息作为位置对象返回。
语法是：
```
getCurrentPosition(showLocation, ErrorHandler, options);
```
* `showLocation`：定义了检索位置信息的回调方法。
* `ErrorHandler`（可选）：定义了在处理异步调用时发生错误时调用的回调方法。
* `options` （可选）： 定义了一组用于检索位置信息的选项。
我们可以通过两种方式向用户提供位置信息：测地和民用。
1. 描述位置的测地方式直接指向纬度和经度。
2. 位置信息的民用表示法是人类可读的且容易理解。
如下表 1 所示，每个属性/参数都具有测地和民用表示。
[](http://opensourceforu.com/wp-content/uploads/2017/05/table-1.jpg)
图 5 包含了一个位置对象返回的属性集。
[](http://opensourceforu.com/wp-content/uploads/2017/05/Figure5-1.jpg)
*图5：位置对象属性*
#### 网络存储
在 HTML 中，为了在本机存储用户数据，我们需要使用 JavaScript cookie。为了避免这种情况，HTML5 已经引入了 Web 存储，网站利用它在本机上存储用户数据。
与 Cookie 相比，Web 存储的优点是：
* 更安全
* 更快
* 存储更多的数据
* 存储的数据不会随每个服务器请求一起发送。只有在被要求时才包括在内。这是 HTML5 Web 存储超过 Cookie 的一大优势。
有两种类型的 Web 存储对象：
1. 本地 - 存储没有到期日期的数据。
2. 会话 - 仅存储一个会话的数据。
**如何工作：** `localStorage` 和 `sessionStorage` 对象创建一个 `key=value` 对。比如： `key="Name"`， `value="Palak"`。
这些存储为字符串，但如果需要，可以使用 JavaScript 函数（如 `parseInt()` 和 `parseFloat()`）进行转换。
下面给出了使用 Web 存储对象的语法：
* 存储一个值：
+ `localStorage.setItem("key1", "value1");`
+ `localStorage["key1"] = "value1";`
* 得到一个值：
+ `alert(localStorage.getItem("key1"));`
+ `alert(localStorage["key1"]);`
* 删除一个值： -`removeItem("key1");`
* 删除所有值：
+ `localStorage.clear();`
#### 应用缓存（AppCache）
使用 HTML5 AppCache，我们可以使 Web 应用程序在没有 Internet 连接的情况下脱机工作。除 IE 之外，所有浏览器都可以使用 AppCache（截止至此时）。
应用缓存的优点是：
* 网页浏览可以脱机
* 页面加载速度更快
* 服务器负载更小
`cache manifest` 是一个简单的文本文件，其中列出了浏览器应缓存的资源以进行脱机访问。 `manifest` 属性可以包含在文档的 HTML 标签中，如下所示：
```
<html manifest="test.appcache">
...
</html>
```
它应该在你要缓存的所有页面上。
缓存的应用程序页面将一直保留，除非：
1. 用户清除它们
2. `manifest` 被修改
3. 缓存更新
#### 视频
在 HTML5 发布之前，没有统一的标准来显示网页上的视频。大多数视频都是通过 Flash 等不同的插件显示的。但 HTML5 规定了使用 video 元素在网页上显示视频的标准方式。
目前，video 元素支持三种视频格式，如表 2 所示。
[](http://opensourceforu.com/wp-content/uploads/2017/05/table-2.jpg)
下面的例子展示了 video 元素的使用：
```
<! DOCTYPE HTML>
<html>
<body>
<video src=" vdeo.ogg" width="320" height="240" controls="controls">
This browser does not support the video element.
</video>
</body>
</html>
```
例子使用了 Ogg 文件，并且可以在 Firefox、Opera 和 Chrome 中使用。要使视频在 Safari 和未来版本的 Chrome 中工作，我们必须添加一个 MPEG4 和 WebM 文件。
`video` 元素允许多个 `source` 元素。`source` 元素可以链接到不同的视频文件。浏览器将使用第一个识别的格式，如下所示：
```
<video width="320" height="240" controls="controls">
<source src="vdeo.ogg" type="video/ogg" />
<source src=" vdeo.mp4" type="video/mp4" />
<source src=" vdeo.webm" type="video/webm" />
This browser does not support the video element.
</video>
```
[](http://opensourceforu.com/wp-content/uploads/2017/05/Figure6-1.jpg)
*图6：Canvas 的输出*
#### 音频
对于音频，情况类似于视频。在 HTML5 发布之前，在网页上播放音频没有统一的标准。大多数音频也通过 Flash 等不同的插件播放。但 HTML5 规定了通过使用音频元素在网页上播放音频的标准方式。音频元素用于播放声音文件和音频流。
目前，HTML5 `audio` 元素支持三种音频格式，如表 3 所示。
[](http://opensourceforu.com/wp-content/uploads/2017/05/table-3.jpg)
`audio` 元素的使用如下所示：
```
<! DOCTYPE HTML>
<html>
<body>
<audio src=" song.ogg" controls="controls">
This browser does not support the audio element.
</video>
</body>
</html>
```
此例使用 Ogg 文件，并且可以在 Firefox、Opera 和 Chrome 中使用。要在 Safari 和 Chrome 的未来版本中使 audio 工作，我们必须添加一个 MP3 和 Wav 文件。
`audio` 元素允许多个 `source` 元素，它可以链接到不同的音频文件。浏览器将使用第一个识别的格式，如下所示：
```
<audio controls="controls">
<source src="song.ogg" type="audio/ogg" />
<source src="song.mp3" type="audio/mpeg" />
This browser does not support the audio element.
</audio>
```
#### 画布（Canvas）
要在网页上创建图形，HTML5 使用 画布 API。我们可以用它绘制任何东西，并且它使用 JavaScript。它通过避免从网络下载图像而提高网站性能。使用画布，我们可以绘制形状和线条、弧线和文本、渐变和图案。此外，画布可以让我们操作图像中甚至视频中的像素。你可以将 `canvas` 元素添加到 HTML 页面，如下所示：
```
<canvas id="myCanvas" width="200" height="100"></canvas>
```
画布元素不具有绘制元素的功能。我们可以通过使用 JavaScript 来实现绘制。所有绘画应在 JavaScript 中。
```
<script type="text/javascript">
var c=document.getElementById("myCanvas");
var cxt=c.getContext("2d");
cxt.fillStyle="blue";
cxt.storkeStyle = "red";
cxt.fillRect(10,10,100,100);
cxt.storkeRect(10,10,100,100);
</script>
```
以上脚本的输出如图 6 所示。
你可以绘制许多对象，如弧、圆、线/垂直梯度等。
### HTML5 工具
为了有效操作，所有熟练的或业余的 Web 开发人员/设计人员都应该使用 HTML5 工具，当需要设置工作流/网站或执行重复任务时，这些工具非常有帮助。它们提高了网页设计的可用性。
以下是一些帮助创建很棒的网站的必要工具。
* **HTML5 Maker：** 用来在 HTML、JavaScript 和 CSS 的帮助下与网站内容交互。非常容易使用。它还允许我们开发幻灯片、滑块、HTML5 动画等。
* **Liveweave：** 用来测试代码。它减少了保存代码并将其加载到屏幕上所花费的时间。在编辑器中粘贴代码即可得到结果。它非常易于使用，并为一些代码提供自动完成功能，这使得开发和测试更快更容易。
* **Font dragr：** 在浏览器中预览定制的 Web 字体。它会直接载入该字体，以便你可以知道看起来是否正确。也提供了拖放界面，允许你拖动字形、Web 开放字体和矢量图形来马上测试。
* **HTML5 Please：** 可以让我们找到与 HTML5 相关的任何内容。如果你想知道如何使用任何一个功能，你可以在 HTML Please 中搜索。它提供了支持的浏览器和设备的有用资源的列表，语法，以及如何使用元素的一般建议等。
* **Modernizr：** 这是一个开源工具，用于给访问者浏览器提供最佳体验。使用此工具，你可以检测访问者的浏览器是否支持 HTML5 功能，并加载相应的脚本。
* **Adobe Edge Animate：** 这是必须处理交互式 HTML 动画的 HTML5 开发人员的有用工具。它用于数字出版、网络和广告领域。此工具允许用户创建无瑕疵的动画，可以跨多个设备运行。
* **Video.js：** 这是一款基于 JavaScript 的 HTML5 视频播放器。如果要将视频添加到你的网站，你应该使用此工具。它使视频看起来不错，并且是网站的一部分。
* **The W3 Validator：** W3 验证工具测试 HTML、XHTML、SMIL、MathML 等中的网站标记的有效性。要测试任何网站的标记有效性，你必须选择文档类型为 HTML5 并输入你网页的 URL。这样做之后，你的代码将被检查，并将提供所有错误和警告。
* **HTML5 Reset：** 此工具允许开发人员在 HTML5 中重写旧网站的代码。你可以使用这些工具为你网站的访问者提供一个良好的网络体验。
---
Palak Shah
作者是高级软件工程师。她喜欢探索新技术，学习创新概念。她也喜欢哲学。你可以通过 [palak311@gmail.com](mailto:palak311@gmail.com) 联系她。
---
via: <http://opensourceforu.com/2017/06/introduction-to-html5/>
作者：[Palak Shah](http://opensourceforu.com/author/palak-shah/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用 C 语言对 Gtk+ 应用进行功能测试
|
Joël Krähemann
|
https://opensource.com/article/17/7/functional-testing
|
这个简单教程教你如何测试你应用的功能。
|
/data/attachment/album/201710/12/132540ni4mi77xmr2m27x2.png.thumb.jpg
|
/data/attachment/album/201710/12/132540ni4mi77xmr2m27x2.png
| true | false | true |
sugarfillet
| false |
[
"GTK",
"测试"
] |
软件开发
|
{
"viewnum": 4361,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这个简单教程教你如何测试你应用的功能。
| 2017-10-12T13:25:38 | 2017-10-12T13:25:38 | 8,951 |
/article-8951-1.html
|
>
> 这个简单教程教你如何测试你应用的功能。
>
>
>
自动化测试用来保证你程序的质量以及让它以预想的运行。单元测试只是检测你算法的某一部分，而并不注重各组件间的适应性。这就是为什么会有功能测试，它有时也称为集成测试。
功能测试简单地与你的用户界面进行交互，无论它是网站还是桌面应用。为了展示功能测试如何工作，我们以测试一个 Gtk+ 应用为例。为了简单起见，这个教程里，我们使用 Gtk+ 2.0 教程的示例。
### 基础设置
对于每一个功能测试，你通常需要定义一些全局变量，比如 “用户交互时延” 或者 “失败的超时时间”（也就是说，如果在指定的时间内一个事件没有发生，程序就要中断）。
```
#define TTT_FUNCTIONAL_TEST_UTIL_IDLE_CONDITION(f) ((TttFunctionalTestUtilIdleCondition)(f))
#define TTT_FUNCTIONAL_TEST_UTIL_REACTION_TIME (125000)
#define TTT_FUNCTIONAL_TEST_UTIL_REACTION_TIME_LONG (500000)
typedef gboolean (*TttFunctionalTestUtilIdleCondition)(gpointer data);
struct timespec ttt_functional_test_util_default_timeout = {
20,
0,
};
```
现在我们可以实现我们自己的超时函数。这里，为了能够得到期望的延迟，我们采用 `usleep` 函数。
```
void
ttt_functional_test_util_reaction_time()
{
usleep(TTT_FUNCTIONAL_TEST_UTIL_REACTION_TIME);
}
void
ttt_functional_test_util_reaction_time_long()
{
usleep(TTT_FUNCTIONAL_TEST_UTIL_REACTION_TIME_LONG);
}
```
直到获得控制状态，超时函数才会推迟执行。这对于一个异步执行的动作很有帮助，这也是为什么采用这么长的时延。
```
void
ttt_functional_test_util_idle_condition_and_timeout(
TttFunctionalTestUtilIdleCondition idle_condition,
struct timespec *timeout,
pointer data)
{
struct timespec start_time, current_time;
clock_gettime(CLOCK_MONOTONIC,
&start_time);
while(TTT_FUNCTIONAL_TEST_UTIL_IDLE_CONDITION(idle_condition)(data)){
ttt_functional_test_util_reaction_time();
clock_gettime(CLOCK_MONOTONIC,
¤t_time);
if(start_time.tv_sec + timeout->tv_sec < current_time.tv_sec){
break;
}
}
ttt_functional_test_util_reaction_time();
}
```
### 与图形化用户界面交互
为了模拟用户交互的操作， [Gdk 库](https://developer.gnome.org/gdk3/stable/) 为我们提供了一些需要的函数。要完成我们的工作，我们只需要如下 3 个函数：
* `gdk_display_warp_pointer()`
* `gdk_test_simulate_button()`
* `gdk_test_simulate_key()`
举个例子，为了测试按钮点击，我们可以这么做：
```
gboolean
ttt_functional_test_util_button_click(GtkButton *button)
{
GtkWidget *widget;
GdkWindow *window;
gint x, y;
gint origin_x, origin_y;
if(button == NULL ||
!GTK_IS_BUTTON(button)){
return(FALSE);
}
widget = button;
if(!GTK_WIDGET_REALIZED(widget)){
ttt_functional_test_util_reaction_time_long();
}
/* retrieve window and pointer position */
gdk_threads_enter();
window = gtk_widget_get_window(widget);
x = widget->allocation.x + widget->allocation.width / 2.0;
y = widget->allocation.y + widget->allocation.height / 2.0;
gdk_window_get_origin(window, &origin_x, &origin_y);
gdk_display_warp_pointer(gtk_widget_get_display(widget),
gtk_widget_get_screen(widget),
origin_x + x, origin_y + y);
gdk_threads_leave();
/* click the button */
ttt_functional_test_util_reaction_time();
gdk_test_simulate_button(window,
x,
y,
1,
GDK_BUTTON1_MASK,
GDK_BUTTON_PRESS);
ttt_functional_test_util_reaction_time();
gdk_test_simulate_button(window,
x,
y,
1,
GDK_BUTTON1_MASK,
GDK_BUTTON_RELEASE);
ttt_functional_test_util_reaction_time();
ttt_functional_test_util_reaction_time_long();
return(TRUE);
}
```
我们想要保证按钮处于激活状态，因此我们提供一个空闲条件函数：
```
gboolean
ttt_functional_test_util_idle_test_toggle_active(
GtkToggleButton **toggle_button)
{
gboolean do_idle;
do_idle = TRUE;
gdk_threads_enter();
if(*toggle_button != NULL &&
GTK_IS_TOGGLE_BUTTON(*toggle_button) &&
gtk_toggle_button_get_active(*toggle_button)){
do_idle = FALSE;
}
gdk_threads_leave();
return(do_idle);
}
```
### 测试场景
因为这个 Tictactoe 程序非常简单，我们只需要确保点击了一个 [**GtkToggleButton**](https://developer.gnome.org/gtk3/stable/GtkToggleButton.html) 按钮即可。一旦该按钮肯定进入了激活状态，功能测试就可以执行。为了点击按钮，我们使用上面提到的很方便的 `util` 函数。
如图所示，我们假设，填满第一行，玩家 A 就赢，因为玩家 B 没有注意，只填充了第二行。
```
GtkWindow *window;
Tictactoe *ttt;
void*
ttt_functional_test_gtk_main(void *)
{
gtk_main();
pthread_exit(NULL);
}
void
ttt_functional_test_dumb_player_b()
{
GtkButton *buttons[3][3];
guint i;
/* to avoid race-conditions copy the buttons */
gdk_threads_enter();
memcpy(buttons, ttt->buttons, 9 * sizeof(GtkButton *));
gdk_threads_leave();
/* TEST 1 - the dumb player B */
for(i = 0; i < 3; i++){
/* assert player A clicks the button successfully */
if(!ttt_functional_test_util_button_click(buttons[0][i])){
exit(-1);
}
functional_test_util_idle_condition_and_timeout(
ttt_functional_test_util_idle_test_toggle_active,
ttt_functional_test_util_default_timeout,
&buttons[0][i]);
/* assert player B clicks the button successfully */
if(!ttt_functional_test_util_button_click(buttons[1][i])){
exit(-1);
}
functional_test_util_idle_condition_and_timeout(
ttt_functional_test_util_idle_test_toggle_active,
ttt_functional_test_util_default_timeout,
&buttons[1][i]);
}
}
int
main(int argc, char **argv)
{
pthread_t thread;
gtk_init(&argc, &argv);
/* start the tictactoe application */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
ttt = tictactoe_new();
gtk_container_add(window, ttt);
gtk_widget_show_all(window);
/* start the Gtk+ dispatcher */
pthread_create(&thread, NULL,
ttt_functional_test_gtk_main, NULL);
/* launch test routines */
ttt_functional_test_dumb_player_b();
/* terminate the application */
gdk_threads_enter();
gtk_main_quit();
gdk_threads_leave();
return(0);
}
```
（题图：opensource.com）
---
作者简介：
Joël Krähemann - 精通 C 语言编程的自由软件爱好者。不管代码多复杂，它也是一点点写成的。作为高级的 Gtk+ 程序开发者，我知道多线程编程有多大的挑战性，有了多线程编程，我们就有了未来需求的良好基础。
摘自: <https://opensource.com/article/17/7/functional-testing>
作者：[Joël Krähemann](https://opensource.com/users/joel2001k) 译者：[sugarfillet](https://github.com/sugarfillet) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
当你只想将事情搞定时，为什么开放式工作这么难？
|
Jason Hibbets
|
https://opensource.com/open-organization/17/6/working-open-and-gsd
|
学习使用开放式决策框架来写一本书
|
/data/attachment/album/201710/13/064330gp5x5mjzml29klpp.png.thumb.jpg
|
/data/attachment/album/201710/13/064330gp5x5mjzml29klpp.png
| true | false | true |
explosic4
| false |
[
"开放式组织"
] |
观点
|
{
"viewnum": 3587,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
学习使用开放式决策框架来写一本书
| 2017-10-13T06:43:00 | 2017-10-13T06:43:00 | 8,954 |
/article-8954-1.html
|
>
> 学习使用开放式决策框架来写一本书
>
>
>
GSD（get stuff done 的缩写，即搞定）指导着我的工作方式。数年来，我将各种方法论融入我日常工作的习惯中，包括精益方法的反馈循环，和敏捷开发的迭代优化，以此来更好地 GSD（如果把 GSD 当作动词的话）。这意味着我必须非常有效地利用我的时间：列出清晰、各自独立的目标；标记已完成的项目；用迭代的方式地持续推进项目进度。但是当我们以开放为基础时仍然能够 GSD 吗？又或者 GSD 的方法完全行不通呢？大多数人都认为这会导致糟糕的状况，但我发现事实并不一定这样。
在开放的环境中工作，遵循<ruby> <a href="https://opensource.com/open-organization/resources/open-decision-framework"> 开放式决策框架 </a> <rt> Open Decision Framework </rt></ruby>中的指导，会让项目起步变慢。但是在最近的一个项目中，我们作出了一个决定，一个从开始就正确的决定：以开放的方式工作，并与我们的社群一起合作。
这是我们能做的最好的决定。
我们来看看这次经历带来的意想不到的结果，再看看我们如何将 GSD 思想融入开放式组织框架。
### 建立社区
2014 年 10 月，我接手了一个新的项目：当时红帽的 CEO Jim Whitehurst 即将推出一本新书<ruby> 《开放式组织》 <rt> The Open Organization </rt></ruby>，我要根据书中提出的概念，建立一个社区。“太棒了，这听起来是一个挑战，我加入了！”我这样想。但不久，[冒牌者综合征](https://opensource.com/open-organization/17/5/team-impostor-syndrome)便出现了，我又开始想：“我们究竟要做什么呢？怎样才算成功呢？”
让我剧透一下，在这本书的结尾处，Jim 鼓励读者访问 Opensource.com，继续探讨 21 世纪的开放和管理。所以，在 2015 年 5 月，我们的团队在网站上建立了一个新的板块来讨论这些想法。我们计划讲一些故事，就像我们在 Opensource.com 上常做的那样，只不过这次围绕着书中的观点与概念。之后，我们每周都发布新的文章，在 Twitter 上举办了一个在线的读书俱乐部，还将《开放式组织》打造成了系列书籍。
我们内部独自完成了该系列书籍的前三期，每隔六个月发布一期。每完成一期，我们就向社区发布。然后我们继续完成下一期的工作，如此循环下去。
这种工作方式，让我们看到了很大的成功。近 3000 人订阅了[该系列的新书](https://opensource.com/open-organization/resources/leaders-manual)：《开放式组织领袖手册》。我们用 6 个月的周期来完成这个项目，这样新书的发行日正好是前书的两周年纪念日。
在这样的背景下，我们完成这本书的方式是简单直接的：针对开放工作这个主题，我们收集了最好的故事，并将它们组织起来形成文章，招募作者填补一些内容上的空白，使用开源工具调整字体样式，与设计师一起完成封面，最终发布这本书。这样的工作方式使得我们能按照自己的时间线（GSD）全速前进。到[第三本书](https://opensource.com/open-organization/resources/leaders-manual)时，我们的工作流已经基本完善了。
然而这一切在我们计划开始《开放式组织》的最后一本书时改变了，这本书将重点放在开放式组织和 IT 文化的交融上。我提议使用开放式决策框架来完成这本书，因为我想通过这本书证明开放式的工作方法能得到更好的结果，尽管我知道这可能会完全改变我们的工作方式。时间非常紧张（只有两个半月），但我们还是决定试一试。
### 用开放式决策框架来完成一本书
开放式决策框架列出了组成开放决策制定过程的 4 个阶段。下面是我们在每个阶段中的工作情况（以及开放是如何帮助完成工作的）。
#### 1、 构思
我们首先写了一份草稿，罗列了对项目设想的愿景。我们需要拿出东西来和潜在的“顾客”分享（在这个例子中，“顾客”指潜在的利益相关者和作者）。然后我们约了一些领域专家面谈，这些专家能够给我们直接的诚实的意见。这些专家表现出的热情与他们提供的指导验证了我们的想法，同时提出了反馈意见使我们能继续向前。如果我们没有得到这些验证，我们会退回到我们最初的想法，再决定从哪里重新开始。
#### 2、 计划与研究
经过几次面谈，我们准备在 [Opensource.com 上公布这个项目](https://opensource.com/open-organization/17/3/announcing-it-culture-book)。同时，我们在 [Github 上也启动了这个项目](https://github.com/open-organization-ambassadors/open-org-it-culture)，提供了项目描述、预计的时间线，并阐明了我们所受的约束。这次公布得到了很好的效果，我们最初计划的目录中欠缺了一些内容，在项目公布之后的 72 小时内就被补充完整了。另外（也是更重要的），读者针对一些章节，提出了本不在我们计划中的想法，但是读者觉得这些想法能够补充我们最初设想的版本。
回顾过去，我觉得在项目的第一和第二个阶段，开放项目并不会影响我们搞定项目的能力。事实上，这样工作有一个很大的好处：发现并填补内容的空缺。我们不只是填补了空缺，我们是迅速地填补了空缺，并且还是用我们自己从未考虑过的点子。这并不一定要求我们做更多的工作，只是改变了我们的工作方式。我们动用有限的人脉，邀请别人来写作，再组织收到的内容，设置上下文，将人们导向正确的方向。
#### 3、 设计，开发和测试
项目的这个阶段完全围绕项目管理，管理一些像猫一样特立独行的人，并处理项目的预期。我们有明确的截止时间，我们提前沟通，频繁沟通。我们还使用了一个战略：列出了贡献者和利益相关者，在项目的整个过程中向他们告知项目的进度，尤其是我们在 Github 上标出的里程碑。
最后，我们的书需要一个名字。我们收集了许多反馈，指出书名应该是什么，更重要的是反馈指出了书名不应该是什么。我们通过 [Github 上的工单](https://github.com/open-organization-ambassadors/open-org-it-culture/issues/20)收集反馈意见，并公开表示我们的团队将作最后的决定。当我们准备宣布最后的书名时，我的同事 Bryan Behrenshausen 做了很好的工作，[分享了我们作出决定的过程](https://github.com/open-organization-ambassadors/open-org-it-culture/issues/20#issuecomment-297970303)。人们似乎对此感到高兴——即使他们不同意我们最后的书名。
书的“测试”阶段需要大量的[校对](https://github.com/open-organization-ambassadors/open-org-it-culture/issues/29)。社区成员真的参与到回答这个“求助”贴中来。我们在 GitHub 工单上收到了大约 80 条意见，汇报校对工作的进度（更不用说通过电子邮件和其他反馈渠道获得的许多额外的反馈）。
关于搞定任务：在这个阶段，我们亲身体会了 [Linus 法则](https://en.wikipedia.org/wiki/Linus%27s_Law)：“<ruby> 众目之下， <strong> 笔误 </strong> 无所遁形。 <rt> With more eyes, all <strong> typos </strong> are shallow. </rt></ruby>” 如果我们像前三本书一样自己独立完成，那么整个校对的负担就会落在我们的肩上（就像这些书一样）！相反，社区成员慷慨地帮我们承担了校对的重担，我们的工作从自己校对（尽管我们仍然做了很多工作）转向管理所有的 change requests。对我们团队来说，这是一个受大家欢迎的改变；对社区来说，这是一个参与的机会。如果我们自己做的话，我们肯定能更快地完成校对，但是在开放的情况下，我们在截止日期之前发现了更多的错误，这一点毋庸置疑。
#### 4、 发布
好了，我们现在推出了这本书的最终版本。（或者只是第一版？）
我们把发布分为两个阶段。首先，根据我们的公开的项目时间表，在最终日期之前的几天，我们安静地推出了这本书，以便让我们的社区贡献者帮助我们测试[下载表格](https://opensource.com/open-organization/resources/culture-change)。第二阶段也就是现在，这本书的[通用版](https://opensource.com/open-organization/resources/culture-change)的正式公布。当然，我们在发布后的仍然接受反馈，开源方式也正是如此。
### 成就解锁
遵循开放式决策框架是<ruby> 《IT 文化变革指南》 <rt> Guide to IT Culture Change </rt></ruby>成功的关键。通过与客户和利益相关者的合作，分享我们的制约因素，工作透明化，我们甚至超出了自己对图书项目的期望。
我对整个项目中的合作，反馈和活动感到非常满意。虽然有一段时间内没有像我想要的那样快速完成任务，这让我有一种焦虑感，但我很快就意识到，开放这个过程实际上让我们能完成更多的事情。基于上面我的概述这一点显而易见。
所以也许我应该重新考虑我的 GSD 心态，并将其扩展到 GMD：Get **More** Done，搞定**更多**工作，并且就这个例子说，取得更好的结果。
（题图：opensource.com）
---
作者简介：
Jason Hibbets - Jason Hibbets 是 Red Hat 企业营销中的高级社区传播者，也是 Opensource.com 的社区经理。 他自2003 年以来一直在 Red Hat，并且是开源城市基金会的创立者。之前的职位包括高级营销专员、项目经理、Red Hat 知识库维护人员和支持工程师。
---
via: <https://opensource.com/open-organization/17/6/working-open-and-gsd>
作者：[Jason Hibbets](https://opensource.com/users/jhibbets) 译者：[explosic4](https://github.com/explosic4) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
LEDE 和 OpenWrt 分裂之争
|
Nathan Willis
|
https://lwn.net/Articles/686767/
|
（2016 年）五月初，当一群 OpenWrt 核心开发者 宣布 他们将开始着手 OpenWrt 的一个副产品 （或者，可能算一个分支）叫 Linux 嵌入开发环境 （LEDE）时，OpenWrt 用户社区陷入一片巨大的混乱中。
|
/data/attachment/album/201710/13/151519npfoxfeh5xfrgwnk.jpg.thumb.jpg
|
/data/attachment/album/201710/13/151519npfoxfeh5xfrgwnk.jpg
| true | false | true |
XYenChi
| false |
[
"OpenWrt"
] |
观点
|
{
"viewnum": 15755,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
（2016 年）五月初，当一群 OpenWrt 核心开发者 宣布 他们将开始着手 OpenWrt 的一个副产品 （或者，可能算一个分支）叫 Linux 嵌入开发环境 （LEDE）时，OpenWrt 用户社区陷入一片巨大的混乱中。
| 2017-10-15T10:10:00 | 2017-10-15T10:10:00 | 8,955 |
/article-8955-1.html
|
对于家用 WiFi 路由器和接入点来说，[OpenWrt](https://openwrt.org/) 项目可能是最广为人知的 Linux 发行版；在 12 年以前，它产自现在有名的 Linksys WRT54G 路由器的源代码。（2016 年）五月初，当一群 OpenWrt 核心开发者 [宣布](https://lwn.net/Articles/686180/) 他们将开始着手 OpenWrt 的一个副产品 （或者，可能算一个分支）叫 [Linux 嵌入开发环境](https://www.lede-project.org/) （LEDE）时，OpenWrt 用户社区陷入一片巨大的混乱中。为什么产生分裂对公众来说并不明朗，而且 LEDE 宣言惊到了一些其他 OpenWrt 开发者也暗示这团队的内部矛盾。
LEDE 宣言被 Jo-Philipp Wich 于五月三日发往所有 OpenWrt 开发者列表和新 LEDE 开发者列表。它将 LEDE 描述为“OpenWrt 社区的一次重启” 和 “OpenWrt 项目的一个副产品” ，希望产生一个 “注重透明性、合作和权利分散”的 Linux 嵌入式开发社区。
给出的重启的原因是 OpenWrt 遭受着长期以来存在且不能从内部解决的问题 —— 换句话说，关于内部处理方式和政策。例如，宣言称，开发者的数目在不断减少，却没有接纳新开发者的方式（而且貌似没有授权委托访问给新开发者的方法）。宣言说到，项目的基础设施不可靠（例如，去年服务器挂掉在这个项目中也引发了相当多的矛盾），但是内部不合和单点错误阻止了修复它。内部和从这个项目到外面世界也存在着“交流、透明度和合作”的普遍缺失。最后，一些技术缺陷被引述：不充分的测试、缺乏常规维护，以及窘迫的稳固性与文档。
该宣言继续描述 LEDE 重启将怎样解决这些问题。所有交流频道都会打开供公众使用，决策将在项目范围内的投票决出，合并政策将放宽等等。更详细的说明可以在 LEDE 站点的[规则](https://www.lede-project.org/rules.html)页找到。其他细节中，它说贡献者将只有一个阶级（也就是，没有“核心开发者”这样拥有额外权利的群体），简单的少数服从多数投票作出决定，并且任何被这个项目管理的基础设施必须有三个以上管理员账户。在 LEDE 邮件列表， Hauke Mehrtens [补充](http://lists.infradead.org/pipermail/lede-dev/2016-May/000080.html)到，该项目将会努力把补丁投递到上游项目 —— 这是过去 OpenWrt 被批判的一点，尤其是对 Linux 内核。
除了 Wich，这个宣言被 OpenWrt 贡献者 John Crispin、 Daniel Golle、 Felix Fietkau、 Mehrtens、 Matthias Schiffer 和 Steven Barth 共同签署，并以给其他有兴趣参与的人访问 LEDE 站点的邀请作为了宣言结尾。
### 回应和问题
有人可能会猜想 LEDE 组织者预期他们的宣言会有或积极或消极的反响。毕竟，细读宣言中批判 OpenWrt 项目暗示了 LEDE 阵营发现有一些 OpenWrt 项目成员难以共事（例如，“单点错误” 或 “内部不和”阻止了基础设施的修复）。
并且，确实，有很多消极回应。OpenWrt 创立者之一 Mike Baker [回应](https://lwn.net/Articles/686988/) 了一些警告，反驳所有 LEDE 宣言中的结论并称“像‘重启’这样的词语都是含糊不清的，且具有误导性的，而且 LEDE 项目未能揭晓其真实本质。”与此同时，有人关闭了那些在 LEDE 宣言上署名的开发者的 @openwrt.org 邮件入口；当 Fietkau [提出反对](https://lwn.net/Articles/686989/)， Baker [回复](https://lwn.net/Articles/686990/)账户“暂时停用”是因为“还不确定 LEDE 能不能代表 OpenWrt。” 另一个 OpenWrt 核心成员 Imre Kaloz [写](https://lwn.net/Articles/686991/)到，他们现在所抱怨的 OpenWrt 的“大多数[破]事就是 LEDE 团队弄出来的”。
但是大多数 OpenWrt 列表的回应对该宣言表示困惑。邮件列表成员不明确 LEDE 团队是否将对 OpenWrt [继续贡献](https://lwn.net/Articles/686995/)，或导致了这次分裂的架构和内部问题的[确切本质](https://lwn.net/Articles/686996/)是什么。 Baker 的第一反应是对宣言中引述的那些问题缺乏公开讨论表示难过：“我们意识到当前的 OpenWrt 项目遭受着许多的问题，”但“我们希望有机会去讨论并尝试着解决”它们。 Baker 作出结论：
>
> 我们想强调，我们确实希望能够公开的讨论，并解决掉手头事情。我们的目标是与所有能够且希望对 OpenWrt 作出贡献的参与者共事，包括 LEDE 团队。
>
>
>
除了有关新项目的初心的问题之外，一些邮件列表订阅者提出了 LEDE 是否与 OpenWrt 有相同的使用场景定位，给新项目取一个听起来更一般的名字的疑惑。此外，许多人，像 Roman Yeryomin，对为什么这些问题需要 LEDE 团队的离开（来解决）[表示了疑惑](https://lwn.net/Articles/686992/)，特别是，与此同时，LEDE 团队由大部分活跃核心 OpenWrt 开发者构成。一些列表订阅者，像 Michael Richardson，甚至不清楚[谁还会继续开发](https://lwn.net/Articles/686993/) OpenWrt。
### 澄清
LEDE 团队尝试着深入阐释他们的境况。在 Fietkau 给 Baker 的回复中，他说在 OpenWrt 内部关于有目的地改变的讨论会很快变得“有毒，”因此导致没有进展。而且：
>
> 这些讨论的要点在于那些掌握着基础设施关键部分的人精力有限却拒绝他人的加入和帮助，甚至是面对无法及时解决的重要问题时也是这样。
>
>
> 这种像单点错误一样的事已经持续了很多年了，没有任何有意义的进展来解决它。
>
>
>
Wich 和 Fietkau 都没有明显指出具体的人，虽然在列表的其他人可能会想到这个基础设施和 OpenWrt 的内部决策问题要归咎于某些人。 Daniel Dickinson [陈述](https://lwn.net/Articles/686998/)到：
>
> 我的印象是 Kaloz (至少) 以基础设施为胁来保持控制，并且根本性的问题是 OpenWrt 是*不*民主的，而且忽视那些真正在 OpenWrt 工作的人想要的是什么，无视他们的愿望，因为他/他们把控着要害。
>
>
>
另一方面， Luka Perkov [指出](https://lwn.net/Articles/687001/) 很多 OpemWrt 开发者想从 Subversion 转移到 Git，但 Fietkau 却阻止这种变化。
看起来是 OpenWrt 的管理结构并非如预期般发挥作用，其结果导致个人冲突爆发，而且由于没有完好定义的流程，某些人能够简单的忽视或阻止提议的变化。明显，这不是一个能长期持续的模式。
五月六日，Crispin 在一个新的帖子中[写给](https://lwn.net/Articles/687003/) OpenWrt 列表，尝试着重构 LEDE 项目宣言。他说，这并不是意味着“敌对或分裂”行为，只是与结构失衡的 OpenWrt 做个清晰的划分并以新的方式开始。问题在于“不要归咎于一次单独的事件、一个人或者一次口水战”，他说，“我们想与过去自己造成的错误和多次作出的错误管理决定分开”。 Crispin 也承认宣言没有把握好，说 LEDE 团队 “弄糟了发起纲领。”
Crispin 的邮件似乎没能使 Kaloz 满意，她[坚持认为](https://lwn.net/Articles/687004/) Crispin（作为发行经理）和 Fietkau（作为领头开发者）可以轻易地在 OpenWrt 内部作出想要的改变。但是讨论的下文后来变得沉寂；之后 LEDE 或者 OpenWrt 哪边会发生什么还有待观察。
### 目的
对于那些想要探究 LEDE 所认为有问题的事情的更多细节的 OpenWrt 成员来说，有更多的信息来源可以为这个问题提供线索。在公众宣言之前，LEDE 组织花了几周谈论他们的计划，会议的 IRC 日志现已[发布](http://meetings.lede-project.org/lede-adm/2016/?C=M;O=A)。特别有趣的是，三月三十日的[会议](http://meetings.lede-project.org/lede-adm/2016/lede-adm.2016-03-30-11.05.log.html)包含了这个项目目标的细节讨论。
其中包括一些针对 OpenWrt 的基础设施的抱怨，像项目的 Trac 工单追踪器的缺点。它充斥着不完整的漏洞报告和“我也是”的评论，Wich 说，结果几乎没有贡献者使用它。此外，他们也在 Github 上追踪 bug，人们对这件事感到困惑，这使得工单应该在哪里讨论不明了。
这些 IRC 讨论也定下了开发流程本身。LEDE 团队想作出些改变，以使用会合并到主干的阶段开发分支为开端，与 OpenWrt 所使用的“直接提交到主干”方式不同。该项目也将提供基于时间的发行版，并通过只发行已被成功测试的二进制模块来鼓励用户测试，由社区而不是核心开发者在实际的硬件上进行测试。
最后，这些 IRC 讨论也确定了 LEDE 团队的目的不是用它的宣言吓唬 OpenWrt。Crispin 提到 LEDE 首先是“半公开的”并渐渐做得更公开。 Wich 解释说他希望 LEDE 是“中立的、专业的，并打开大门欢迎 OpenWrt 以便将来的合并”。不幸的是，前期发起工作并不是做得很好。
在一封邮件中， Fietkau 补充到 OpenWrt 核心开发者确实在任务中遇到瓶颈，像补丁复审和基础设施维护这些事情让他们完成不了其他工作，比如配置下载镜像和改良构建系统。在 LEDE 宣言之后短短几天内，他说，团队成功解决了镜像和构建系统任务，而这些已被搁置多年。
>
> 我们在 LEDE 所做的事情很多是基于转移到 Github 的去中心化软件包开发经验，并放弃了软件包应如何被维护的许多控制。这样最终有效减少了我们的工作量，而且我们有了很多更活跃的开发者。
>
>
> 我们真的希望为核心开发做一些类似的事，但是基于我们想作出更大改变的经验，我们觉得在 OpenWrt 项目内做不到。
>
>
>
修复基础设施也将收获其他好处，他说，就比如改进了用于管理签署发布版本的密码的系统。团队正在考虑在某些情况下非上游补丁的规则，像需要补丁的描述和为什么没有发送到上游的解释。他也提到很多留下的 OpenWrt 开发者表示有兴趣加入 LEDE，相关当事人正试图弄清楚他们是否会重新合并该项目。
有人希望 LEDE 更为扁平的管理模式和更为透明的分工会在困扰 OpenWrt 的方面取得成功。解决最初的宣言中被诟病的沟通方面的问题会是最大的障碍。如果那个过程处理得好，那么，未来 LEDE 和 OpenWrt 可能能够求同存异并协作。否则，之后两个团队可能一起被迫发展到比以前拥有更少资源的方向，这也许不是开发者或用户想看到的。
---
via: <https://lwn.net/Articles/686767/>
作者：[Nathan Willis](https://lwn.net/Articles/686767/) 译者：[XYenChi](https://github.com/XYenChi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在一个 U 盘上安装多个 Linux 发行版
|
Ambarish Kumar
|
https://itsfoss.com/multiple-linux-one-usb/
|
本教程介绍如何在一个 U 盘上安装多个 Linux 发行版。这样，你可以在单个 U 盘上享受多个现场版Linux 发行版了。
|
/data/attachment/album/201710/13/235401s37mueawuwd8z7z7.jpg.thumb.jpg
|
/data/attachment/album/201710/13/235401s37mueawuwd8z7z7.jpg
| true | false | true |
geekpi
| false |
[
"USB",
"发行版"
] |
技术
|
{
"viewnum": 13812,
"commentnum": 0,
"favtimes": 9,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本教程介绍如何在一个 U 盘上安装多个 Linux 发行版。这样，你可以在单个 U 盘上享受多个现场版Linux 发行版了。
| 2017-10-14T07:52:00 | 2017-10-14T07:52:00 | 8,957 |
/article-8957-1.html
|
>
> 本教程介绍如何在一个 U 盘上安装多个 Linux 发行版。这样，你可以在单个 U 盘上享受多个<ruby> 现场版 <rt> live </rt></ruby> Linux 发行版了。
>
>
>
我喜欢通过 U 盘尝试不同的 Linux 发行版。它让我可以在真实的硬件上测试操作系统，而不是虚拟化的环境中。此外，我可以将 USB 插入任何系统（比如 Windows 系统），做任何我想要的事情，以及享受相同的 Linux 体验。而且，如果我的系统出现问题，我可以使用 U 盘恢复！
创建单个[可启动的现场版 Linux USB](https://itsfoss.com/create-live-usb-of-ubuntu-in-windows/) 很简单，你只需下载一个 ISO 文件并将其刻录到 U 盘。但是，如果你想尝试多个 Linux 发行版呢？你可以使用多个 U 盘，也可以覆盖同一个 U 盘以尝试其他 Linux 发行版。但这两种方法都不是很方便。
那么，有没有在单个 U 盘上安装多个 Linux 发行版的方式呢？我们将在本教程中看到如何做到这一点。
### 如何创建有多个 Linux 发行版的可启动 USB
我们有一个工具正好可以做到*在单个 U 盘上保留多个 Linux 发行版*。你所需要做的只是选择要安装的发行版。在本教程中，我们将介绍*如何在 U 盘中安装多个 Linux 发行版*用于<ruby> 现场会话 <rt> live session </rt></ruby>。
要确保你有一个足够大的 U 盘，以便在它上面安装多个 Linux 发行版，一个 8 GB 的 U 盘应该足够用于三四个 Linux 发行版。
#### 步骤 1
[MultiBootUSB](http://multibootusb.org/) 是一个自由、开源的跨平台应用程序，允许你创建具有多个 Linux 发行版的 U 盘。它还支持在任何时候卸载任何发行版，以便你回收驱动器上的空间用于另一个发行版。
下载 .deb 包并双击安装。
[下载 MultiBootUSB](https://github.com/mbusb/multibootusb/releases/download/v8.8.0/python3-multibootusb_8.8.0-1_all.deb)
#### 步骤 2
推荐的文件系统是 FAT32，因此在创建多引导 U 盘之前，请确保格式化 U 盘。
#### 步骤 3
下载要安装的 Linux 发行版的 ISO 镜像。
#### 步骤 4
完成这些后，启动 MultiBootUSB。
主屏幕要求你选择 U 盘和你打算放到 U 盘上的 Linux 发行版镜像文件。
MultiBootUSB 支持 Ubuntu、Fedora 和 Debian 发行版的持久化，这意味着对 Linux 发行版的现场版本所做的更改将保存到 USB 上。
你可以通过拖动 MultiBootUSB 选项卡下的滑块来选择持久化大小。持久化为你提供了在运行时将更改保存到 U 盘的选项。
#### 步骤 5
单击“安装发行版”选项并继续安装。在显示成功的安装消息之前，需要一些时间才能完成。
你现在可以在已安装部分中看到发行版了。对于另外的操作系统，重复该过程。这是我安装 Ubuntu 16.10 和 Fedora 24 后的样子。
#### 步骤 6
下次通过 USB 启动时，我可以选择任何一个发行版。
只要你的 U 盘允许，你可以添加任意数量的发行版。要删除发行版，请从列表中选择它，然后单击卸载发行版。
### 最后的话
MultiBootUSB 真的很便于在 U 盘上安装多个 Linux 发行版。只需点击几下，我就有两个我最喜欢的操作系统的工作盘了，我可以在任何系统上启动它们。
如果你在安装或使用 MultiBootUSB 时遇到任何问题，请在评论中告诉我们。
---
via: <https://itsfoss.com/multiple-linux-one-usb/>
作者：[Ambarish Kumar](https://itsfoss.com/author/ambarish/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
促使项目团队作出改变的五步计划
|
Ron Mcfarland
|
https://opensource.com/open-organization/17/1/escape-the-cave
|
想象一群人困在洞穴中。没有一个人具备如何出去的全部知识，所以每个人要协作，心路常开，在想要做的事情上尽力配合。当（且仅当）组建了适当的工作团队之后，才能为实现团队的共同目标创造出合适的环境。
|
/data/attachment/album/201710/15/004535v6gsu6p1u2sbu2ud.jpeg.thumb.jpg
|
/data/attachment/album/201710/15/004535v6gsu6p1u2sbu2ud.jpeg
| true | false | true |
XYenChi
| false |
[
"团队"
] |
观点
|
{
"viewnum": 2783,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 2,
"likes": 0
}
|
[] |
[] |
想象一群人困在洞穴中。没有一个人具备如何出去的全部知识，所以每个人要协作，心路常开，在想要做的事情上尽力配合。当（且仅当）组建了适当的工作团队之后，才能为实现团队的共同目标创造出合适的环境。
| 2017-10-15T00:46:09 | 2017-10-15T00:46:09 | 8,960 |
/article-8960-1.html
|
目的是任何团队组建的首要之事。如果一个人足以实现那个目的，那么就没有必要组成团队。而且如果没有重要目标，你根本不需要一个团队。但只要任务需要的专业知识比一个人所拥有的更多，我们就会遇到集体参与的问题——如果处理不当，会使你脱离正轨。
想象一群人困在洞穴中。没有一个人具备如何出去的全部知识，所以每个人要协作，心路常开，在想要做的事情上尽力配合。当（且仅当）组建了适当的工作团队之后，才能为实现团队的共同目标创造出合适的环境。
但确实有人觉得待在洞穴中很舒适而且只想待在那里。在组织里，领导者们如何掌控那些实际上抵触改善、待在洞穴中觉得舒适的人？同时该如何找到拥有共同目标但是不在自己组织的人？
我从事指导国际销售培训，刚开始甚至很少有人认为我的工作有价值。所以，我想出一套使他们信服的战术。那个战术非常成功以至于我决定深入研究它并与各位[分享](http://www.slideshare.net/RonMcFarland1/creating-change-58994683)。
### 获得支持
为了建立公司强大的企业文化，有人会反对改变，并且从幕后打压任何改变的提议。他们希望每个人都待在那个舒适的洞穴里。例如，当我第一次接触到海外销售培训，我受到了一些关键人物的严厉阻挠。他们迫使其他人相信某个东京人做不了销售培训——只要基本的产品培训就行了。
尽管我最终解决了这个问题，但我那时候真的不知道该怎么办。所以，我开始研究顾问们在改变公司里抗拒改变的人的想法这个问题上该如何给出建议。从学者 [Laurence Haughton](http://www.laurencehaughton.com/) 的研究中，我发现一般对于改变的提议，组织中 83% 的人最开始不会支持你。大约 17% *会*从一开始就支持你，但是只要看到一个实验案例成功之后，他们觉得这个主意安全可行了，60% 的人会支持你。最后，有部分人会反对任何改变，无论它有多棒。
我研究的步骤：
* 从试验项目开始
* 开导洞穴人
* 快速跟进
* 开导洞穴首领
* 全局展开
### 1、 从试验项目开始
找到高价值且成功率较高的项目——而不是大的、成本高的、周期长的、全局的行动。然后，找到能看到项目价值、理解它的价值并能为之奋斗的关键人物。这些人不应该只是“老好人”或者“朋友”；他们必须相信项目的目标而且拥有推进项目的能力或经验。不要急于求成。只要足够支持你研究并保持进度即可。
个人而言，我在新加坡的一个小型车辆代理商那里举办了自己的第一场销售研讨会。虽然并不是特别成功，但足以让人们开始讨论销售训练会达到怎样的效果。那时候的我困在洞穴里（那是一份我不想做的工作）。这个试验销售训练是我走出困境的蓝图。
### 2、 开导洞穴人
洞穴（CAVE）实际上是我从 Laurence Haughton 那里听来的缩略词。它代表着 Citizens Against Virtually Everything。（LCTT 译注，此处一语双关前文提及的洞穴。）
你得辨别这些人，因为他们会暗地里阻挠项目的进展，特别是早期脆弱的时候。他们容易黑化：总是消极。他们频繁使用“但是”、“如果”和“为什么”，只是想推脱你。他们询问轻易不可得的细节信息。他们花费过多的时间在问题上，而不是寻找解决方案。他们认为每个失败都是一个趋势。他们总是对人而不是对事。他们作出反对建议的陈述却又不能简单确认。
避开洞穴人；不要让他们太早加入项目的讨论。他们固守成见，因为他们看不到改变所具有的价值。他们安居于洞穴，所以试着让他们去做些其他事。你应该找出我上面提到那 17% 的人群中的关键人物，那些想要改变的人，并且跟他们开一个非常隐秘的准备会。
我在五十铃汽车（股东之一是通用汽车公司）的时候，销售训练项目开始于一个销往世界上其他小国家的合资分销商，主要是非洲、南亚、拉丁美洲和中东。我的个人团队由通用汽车公司雪佛兰的人、五十铃产品经理和分公司的销售计划员工组成。隔绝其他任何人于这个圈子之外。
### 3、 快速跟进
洞穴人总是慢吞吞的，那么你就迅速行动起来。如果你在他们参与之前就有了小成就的经历，他们对你团队产生消极影响的能力将大大减弱——你要在他们提出之前就解决他们必然反对的问题。再一次，选择一个成功率高的试验项目，很快能出结果的。然后宣传成功，就像广告上的加粗标题。
当我在新加坡研讨会上所言开始流传时，其他地区开始意识到销售训练的好处。仅在新加坡研讨会之后，我就被派到马来西亚开展了四次以上。
### 4、 开导洞穴首领
只要你取得了第一个小项目的成功，就针对能影响洞穴首领的关键人物推荐项目。让团队继续该项目以告诉关键人物成功的经历。一线人员甚至顾客也能提供有力的证明。 洞穴管理者往往只着眼于销量和收益，那么就宣扬项目在降低开支、减少浪费和增加销量方面的价值。
自新加坡的第一次研讨会及之后，我向直接掌握了五十铃销售渠道的前线销售部门员工和通用汽车真正想看到进展的人极力宣传他们的成功。当他们接受了之后，他们会向上级提出培训请求并让其看到分公司销量的提升。
### 5、 全局展开
一旦一把手站在了自己这边，立马向整个组织宣告成功的试验项目。讨论项目的扩展。
用上面的方法，在 21 年的职业生涯中，我在世界各地超过 60 个国家举办了研讨会。我确实走出了洞穴——并且真的看到了广阔的世界。
---
作者简介：
Ron McFarland - Ron McFarland 已在日本工作 40 年，从事国际销售、销售管理和在世界范围内扩展销售业务 30 载有余。他曾去过或就职于 80 多个国家。在过去的 14 年里， Ron 为总部位于东京的日本硬件切割厂在美国和欧洲各地建立分销商。
---
via: <https://opensource.com/open-organization/17/1/escape-the-cave>
作者：[Ron McFarland](https://opensource.com/users/ron-mcfarland) 译者：[XYenChi](https://github.com/XYenChi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
阿里巴巴 CTO 行癫：开源有意思
|
老王
|
2017云栖大会，阿里巴巴集团 CTO 兼阿里云 CTO 行癫就开源谈了一番他的看法。
|
/data/attachment/album/201710/15/170526zm9ncv2urzpprwhm.jpeg.thumb.jpg
|
/data/attachment/album/201710/15/170526zm9ncv2urzpprwhm.jpeg
| true | false | false | false |
[
"阿里云",
"开源"
] |
观点
|
{
"viewnum": 5463,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
2017云栖大会，阿里巴巴集团 CTO 兼阿里云 CTO 行癫就开源谈了一番他的看法。
| 2017-10-15T17:06:09 | 2017-10-15T17:06:09 | 8,962 |
/article-8962-1.html
|
2017云栖大会，阿里巴巴集团 CTO 兼阿里云 CTO 行癫就开源谈了一番他的看法。
行癫在阿里历经了从技术到商业，又从商业到技术的过程，十多年的阿里生涯，让他对开源、技术和商业有了深刻了解。
### 开源的核心是连接，社区的根本是连接
行癫说，阿里巴巴的平台将“消费者和商家连接在了一起，这个平台不仅是个渠道，也从消费者获得了非常多一些反馈，能够快速的根据消费者的需求，来做出满足消费者要求的一些产品。我们回过头来想一下，开源社区，非常像这个模式。”
这个商业模式，其实就是将相关的人、物、关系连接到了一起，与开源的道理是一致的。
行癫认为“开源要做好，它最重要、最核心的一点，是把相关的一些开发者、用户，通过软件、工具和平台连接在一起了。”
纵观那些发展的比较好的开源软件，都是通过开源软件、通过开源的模式和开源的平台，将最优秀的开发者联系起来，将最有价值的软件用户连接起来。
互联网的本质是连接。没有互联网之前，所有的行为、所有的商业都是单向的；有互联网之后，非常非常多的连接就产生了。所以对于开源，行癫认为它“是根植于互联网的，有了互联网技术平台之后，开源能够做得更好。”
开源是生长于社区土壤中的，而社区就是一种将参与者连接起来的机制。首先通过将人连接起来，然后才能逐步考虑将来的发展，考虑如何发展和进行商业化发展。
一个开源软件在诞生之初，有可能只是表达一下对技术的理解和看法，也有可能只是解决某个痛点——大多数情况下是自己的痛点，还有可能只是好玩。至于将来能走多远，能否得到社区的迎合，能否发展出一个生态，甚至成为商业新动力，在最初往往并没有很远的计划和远景。
但是，在建立连接后，有了一个社区的土壤之后，就有了成长为一棵大树、一片森林的可能。“把人连接在一起，然后后面才是讨论核心问题，和怎么样进行商业化”。
而现在的云栖大会“也是一个连接”，通过网上直播，中国大概会有一千万左右的开发者会来参加这个云栖大会，所以“云栖大会把中国最具有活力的一群开发者，全部连接在一起了。今天这种形式的大会，本身就是一个对开发者来说，一个最重要的纽带。”
### 阿里为何拥抱开源
阿里巴巴最初是采用商用软件做解决方案，基于小型机、企业级的基础设施。阿里巴巴的平台三个比较大的特点，“互联网级的规模、金融级的稳定性、企业级的复杂程度。”在这种情况下，一方面，如果继续用 IOE 基础设施，随着业务规模的扩大，将来根本无法覆盖剧增的成本。另外一方面，商用软件的支持情况也难以满足业务的增长带来的各种需求。
因此，阿里巴巴发起了去 IOE 行动，全面投向开源解决方案，用开源软件构建了满足其体量和需求的基础设施。在这个过程中，阿里巴巴一方面大量采用开源软件替代传统的 IOE 基础设施，另外一方面也要面临一些前所未有的需求。
“阿里巴巴应该是最早把这么复杂的一个应用系统，全部放到开源社区的应用上的。”因此，在规模扩大了到开源软件原来很少涉及的数量级时，就会发现很多之前隐藏的场景问题。在这其中解决了无数的问题，因为面临的环境跟别人不一样，面临的要求也跟别人不一样。阿里做了非常多的工作，把他们的互联网的架构中现在社区不具备的一些功能，都纷纷补上去。自己开发了很多的中间件去满足这些功能需求。
### 积极回馈开源
在全面投入开源的怀抱后，阿里也积极回馈开源社区，真正使自己成为开源社区的一份子。这可以从近年来阿里加大对开源社区的赞助、代码的贡献、开源社区的扶持，以及鼓励技术人员走出去等举措上可以看出来。
在本次云栖大会上，阿里巴巴宣布了正式发布了 OpenMessaging 和 ApsaraCache 两个开源项目。此前，阿里巴巴捐赠的开源的 RocketMQ 已被 Apache 基金会接纳为全球顶级项目。
“开源和阿里巴巴都根植于互联网，有了互联网技术平台之后，开源和商业将在未来相当长的时间内保持平衡的发展。”行癫表示。
据悉， OpenMessaging 项目是由阿里巴巴发起，与雅虎、滴滴出行、 Streamlio 公司共同参与创立的分布式消息中间件、流处理领域的应用开发标准，目前已正式入驻 Linux 基金会，这也是国内首个在全球范围内发起的分布式消息领域的国际标准。
该标准可以不受编程语言限制，能满足企业对扩展性、伸缩性、隔离和安全的要求，可提供大规模的工业级支持，支持标准参照点的添加与标准化测试，开放接口便于对其他不同标准的接入，适用于金融、电商、物联网、工业互联网等行业。
“OpenMessaging 希望成为全球化、无国界、无公司边界、面向云和大数据、多行业领域的一站式方案标准，这也是阿里巴巴第一次在国际社区进行的主导和探索。” 项目负责人蒋江伟表示。
同时，在云栖大会现场，阿里云数据库负责人余锋与 Redis 创始人 Salvatore 共同宣布 ApsaraCache 在 Github 上正式开放下载。ApsaraCache 是阿里云数据库 Redis 版的分支，适用于更大的数据规模和更多的应用场景。
“ApsaraCache 项目开源是一件非常好的事情，将能够吸引全世界更多 Redis 核心专家参与，进一步提升产品的稳定性和可用性。” Salvatore 表示。
Mysql 之父、 MariaDB 创始人 Michael Widenius 已经连续三年参加云栖大会，年过 50 的他依然奋斗在代码第一线，Widenius 表示：“很多 MariaDB 的运用源自我们的开发者，维基百科用的就是 MariaDB，我们也从阿里巴巴中获得了很多开源的支持和贡献，确保能给大家提供功能丰富的数据库产品。”
*图为 Mysql 之父、 MariaDB 创始人 Michael Widenius*
近年来，阿里巴巴在技术领域投入不断加强，拥抱开源也由来已久，积极加入了包括自由软件基金会、Apache 软件基金会和 Linux 基金会在内的多家国际知名开源组织。目前，阿里巴巴开源和维护的开源项目超过 150 个，涵盖中间件、开发框架、数据库和各种工具类软件。在开源中国公布的“2016 年度最受欢迎中国开源软件评选 TOP20”榜单中，阿里巴巴独占 4 席。其中 Weex、Ant Design、Dubbo、Fastjson 在 GitHub 上的星标数已经破万，“Alibaba”组织在 GitHub 上星标数超过 170,000，组织排名进入前十。
### 开源之路
行癫认为，“开源我觉得有几个层次”，刚开始可能只是做了一个工具，这个工具做得非常好，可以解决一个非常确定性的问题。逐渐地，这个工具可能会变成一个产品、变成一个系统，慢慢延伸出一堆工具。“开源要成功，第一步要做好一个工具，第二步会变成全链的产品，我觉得最成功的就是变成新的一个生态。” 开源软件组成了一个生态，无数人为这个生态贡献了新的智慧、新的工具。融入这个生态的人，或许只用非常少的代价，就能够找到跟他的工作场景、业务场景相匹配的模式。到这个程度，“这个社区就发展得比较成熟了。这个可能是大多数开源软件必须要去走的一些路径。”
“今天要开源的其实不仅是软件，还有很多硬件”，行癫说。“今天的开源比以前的更复杂，有可能是端跟云端的结合。……互联网第一阶段的开源，是基于互联网的端建成的；互联网的第二个阶段是 IoT，我们希望所有的设备能够串起来。所以我认为接下去开源软件会与硬件结合，这就是从单纯的互联网向 IoT 时代发展非常重要的一个过程。”
### 结语
在近来几届云栖大会上，开源已经成为了永恒的主题，除了开源专场之外，在各个会场和论坛，充斥着各种热烈的开源气息，无数建筑于开源之上的产品、服务源源不断的开发出来，无数的技术人员和开源爱好者投身于开源世界。让我们期待云栖大会成为开源的大会，成为中国开源界和世界开源接轨的枢纽。
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.