diff --git a/published/20190131 OOP Before OOP with Simula.md b/published/20190131 OOP Before OOP with Simula.md
new file mode 100644
index 0000000000..c5d9c97a84
--- /dev/null
+++ b/published/20190131 OOP Before OOP with Simula.md
@@ -0,0 +1,183 @@
+[#]: subject: "OOP Before OOP with Simula"
+[#]: via: "https://twobithistory.org/2019/01/31/simula.html"
+[#]: author: "Two-Bit History https://twobithistory.org"
+[#]: collector: "lujun9972"
+[#]: translator: "aREversez"
+[#]: reviewer: "wxy"
+[#]: publisher: "wxy"
+[#]: url: "https://linux.cn/article-14682-1.html"
+
+Simula 诞生之前的面向对象程序设计
+======
+
+想象一下，你坐在河边，河岸上如茵绿草，不远处湍急河流；午后的阳光慵懒惬意，使人陷入冥想哲思，不觉开始思考眼前的河流是否真实存在。诚然，几米外确实有河水奔流而下。不过，我们所称为“河流”的存在究竟是什么呢？毕竟，河水奔流不息，一直处于变化之中。似乎，“河流”这个词无法指代任何固定不变的事物。
+
+2009 年，Clojure 的创始人 里奇·希基 发表了 [一场精彩的演讲][1]，探讨了为什么上文那样的哲学窘境会给面向对象程序的编程范式带来难题。他认为，人们看待计算机程序中的对象与看待河流的逻辑是一样的：我们想象对象是固定不变的，即使对象的许多或者说全部的属性都无时无刻不处于变化之中。所以，这种逻辑并不正确，我们无法区分在不同状态下同一对象实例的不同之处。程序中没有明确的时间的概念。人们只是单纯地用着同一个名字，以期在引用对象时，对象能够处于预期的状态中。这样，我们也就难免会遇到 故障。
+
+希基总结道，这一难题的应对办法就是人们应该将世界建模成作用于不可变数据的 进程 的集合，而不是可变的对象的集合。换句话说，我们应把每个对象看作一条“河流”，因果相连。总结说来，你应该使用 Clojure 等函数式语言。
+
+![][2]
+
+_作者在远足途中思考面向对象程序设计的本体论问题。_
+
+自从希基发表演讲之后，人们对函数式编程语言的兴趣不断提升，主流的面向对象编程语言也大多都采用了函数式编程语言。尽管如此，大多数程序员依旧沿用自己的老一套，继续将对象实例化，不断改变其状态。这些人长此以往，很难做到用不同的视角看待编程。
+
+我曾经想写一篇关于 Simula 的文章，大概会写到我们今天所熟知的面向对象的理念是何时又是如何应用到程序语言之中的。但是，我觉得写当初的 Simula 与如今的面向对象程序设计的 _迥然不同之处_，会更有趣一些，这我敢打包票。毕竟，我们现在熟知的面向对象程序设计还未完全成型。Simula 有两个主要版本：Simula I 和 Simula 67。Simula 67 为世界带来了 类、 类的继承 以及 虚拟方法；但 Simula I 是一个初稿，它实验了如何能够将数据和进程捆绑起来的其他设想。Simula I 的模型不是希基提出的函数式模型，不过这一模型关注的是随时间展开的 _进程_，而非有着隐藏状态的对象之间的相互作用。如果 Simula 67 采用了 Simula I 的理念，那么我们如今所知的面向对象程序设计可能会大有不同——这类偶然性启示我们，不要想着现在的程序设计范式会一直占据主导地位。
+
+### 从 Simula 0 到 Simula 67
+
+Simula 是由两位挪威人 克里斯汀·尼加德 和 奥利-约翰·达尔 创建的。
+
+20 世纪 50 年代末，尼加德受雇于 挪威防务科学研究中心（NDRE），该研究中心隶属于挪威军方。在那里，他负责设计 蒙特卡洛模拟方法，用于核反应堆设计与操作研究。最初，那些模拟实验是由人工完成的；后来，实验在 Ferranti Mercury 电脑 [^1] 上编入程序运行。尼加德随后发现，将这些模拟实验输入电脑需要一种更有效的方式。
+
+尼加德设计的这种模拟实验就是人们所知的“离散事件模型”，这种模拟记录了一系列事件随着时间改变系统状态的进程。但是问题的关键在于模拟可以从一个事件跳跃到另一个事件中，因为事件是离散的，事件之间的系统不存在任何变化。根据尼加德和达尔在 1966 年发表的一篇关于 Simula 的论文，这种模型被迅速应用于“神经网络、通信系统、交通流量、生产系统、管理系统、社会系统等” [^2] 领域的分析。因此，尼加德认为，其他人描述模拟实验时，可能也需要更高层级的模型。于是他开始物色人才，帮助他完成他称之为“模拟语言”或者“蒙特卡洛编译器”的项目 [^3]。
+
+达尔当时也受雇于挪威防务科学研究中心，专攻语言设计，此时也加入了尼加德的项目，扮演“沃兹尼亚克”的角色（LCTT 译注：指苹果公司联合创始人斯蒂夫·盖瑞·沃兹尼亚克）。在接下来一年左右的时间，尼加德和达尔携手开发了 Simula 0 语言。[^4] 这一语言的早期版本仅仅是在 ALGOL 60 基础上进行的较小拓展，当时也只是打算将其用作预处理程序而已。当时的语言要比后来的编程语言抽象得多，其基本语言结构是“车站”与“乘客”，这些结构可以用于针对具体某些离散事件网络建立模型。尼加德和达尔给出了一个模拟飞机离港的例子。[^5] 但是尼加德和达尔最后想出了一个更加通用的语言结构，可以同时表示“车站”和“乘客”，也可以为更广泛的模拟建立模型。这是两个主要的概括，它改变了 Simula 作为 ALGOL 专属包的定位，使其转变为通用编程语言。
+
+Simula I 没有“车站”和“乘客”的语言结构，但它可以通过使用“进程”再现这些结构。（LCTT 译注：此处使用的“进程”，与当前计算机中用来指代一个已执行程序的实体的概念不同，大致上，你可以将本文中所说的“进程”理解为一种“对象”。）一个进程包含大量数据属性，这些属性与作为进程的 _操作规程_ 的单个行为相联系。你可能会把进程当作是只有单个方法的对象，比如 `run()` 之类的。不过，这种类比并不全面，因为每个进程的操作规程都可以随时暂停、随时恢复，因为这种操作规程属于 协程 的一种。Simula I 程序会将系统建立为一套进程的模型，在概念上这些进程并行运行。实际上，一个时间点上能称为“当前进程”的只有一个进程。但是，一旦某个进程暂停运行，那么下一个进程就会自动接替它的位置。随着模拟的运行，Simula 会保持一个 “事件通知” 的时间线，跟踪记录每个进程恢复的时间。为了恢复暂停运行的进程，Simula 需要记录多个 调用栈 的情况。这就意味着 Simula 无法再作为 ALGOL 的预处理程序了，因为 ALGOL 只有一个 调用栈。于是，尼加德和达尔下定决心，开始编写自己的编译器。
+
+尼加德和达尔在介绍该系统的论文中，借助图示，通过模拟一个可用机器数量有限的工厂，阐明了其用法。[^6] 在该案例中，进程就好比订单：通过寻找可用的机器，订单得以发出；如果没有可用的机器，订单就会搁置；而一旦有机器空出来，订单就会执行下去。有一个订单进程的定义，用来实例化若干种不同的订单实例，不过这些实例并未调用任何方法。该程序的主体仅仅是创建进程，并使其运行。
+
+历史上第一个 Simula I 编译器发布于 1965 年。尼加德和达尔在离开挪威防务科学研究中心之后，就进入了 挪威计算机中心 工作，Simula I 也是在这里日渐流行起来的。当时，Simula I 在 UNIVAC 公司的计算机和 Burroughs 公司的 B5500 计算机上均可执行。[^7] 尼加德和达尔两人与一家名为 ASEA 的瑞典公司达成了咨询协议，运用 Simula 模拟加工车间。但是，尼加德和达尔随后就意识到 Simula 也可以写一些和模拟完全不搭边的程序。
+
+奥斯陆大学教授 斯坦因·克罗达尔 曾写过关于 Simula 的发展史，称“真正能够促使新开发的通用语言快速发展的催化剂”就是 [一篇题为《记录处理》的论文][10]，作者是英国计算机科学家 查尔斯·安东尼·理查德·霍尔。[^8] 假如你现在读霍尔的这篇论文，你就不会怀疑这句话。当人们谈及面向对象语言的发展史时，一定会经常提起霍尔的大名。以下内容摘自霍尔的《记录处理》一文：
+
+> 该方案设想，在程序执行期间，计算机内部存在任意数量的记录，每条记录都代表着程序员在过去、现在或未来所需的某个对象。程序对现有记录的数量保持动态控制，并可以根据当前任务的要求创建新的记录或删除现有记录。
+>
+> 计算机中的每条记录都必须属于数量有限但互不重合的记录类型中的一类；程序员可以根据需要声明尽可能多的记录类型，并借助标识符为各个类型命名。记录类型的命名可能是普通词汇，比如“牛”、“桌子”以及“房子”，同时，归属于这些类型的记录分别代表一头“牛”、一张“桌子”以及一座“房子”。
+
+霍尔在这片论文中并未提到子类的概念，但是达尔由衷地感谢霍尔，是他引导了两人发现了这一概念。[^9] 尼加德和达尔注意到 Simula I 的进程通常具有相同的元素，所以引入父类来执行共同元素就会非常方便。这也强化了“进程”这一概念本身可以用作父类的可能性，也就是说，并非每种类型都必须用作只有单个操作规程的进程。这就是 Simula 语言迈向通用化的第二次飞跃，此时，Simula 67 真正成为了通用编程语言。正是如此变化让尼加德和达尔短暂地萌生了给 Simula 改名的想法，想让人们意识到 Simula 不仅仅可以用作模拟。[^10] 不过，考虑到 “Simula”这个名字的知名度已经很高了，另取名字恐怕会带来不小的麻烦。
+
+1967 年，尼加德和达尔与 控制数据公司 签署协议，着手开发Simula 的新版本：Simula 67。同年六月份的一场会议中，来自控制数据公司、奥斯陆大学以及挪威计算机中心的代表与尼加德和达尔两人会面，意在为这门新语言制定标准与规范。最终，会议发布了 [《Simula 67 通用基础语言》][14]，确定了该语言的发展方向。
+
+Simula 67 编译器的开发由若干家供应商负责。Simula 用户协会（ASU）也随后成立，并于每年举办年会。不久，Simula 67 的用户就遍及了 23 个国家。[^11]
+
+### 21 世纪的 Simula 语言
+
+人们至今还记得 Simula，是因为后来那些取代它的编程语言都受到了它的巨大影响。到了今天，你很难找到还在使用 Simula 写程序的人，但是这并不意味着 Simula 已经从这个世界上消失了。得益于 [GNU cim][16]，人们在今天依然能够编写和运行 Simula 程序。
+
+cim 编译器遵循 1986 年修订后的 Simula 标准，基本上也就是 Simula 67 版本。你可以用它编写类、子类以及虚拟方法，就像是在使用 Simula 67 一样。所以，用 Python 或 Ruby 轻松写出短短几行面向对象的程序，你照样也可以用 cim 写出来：
+
+```
+! dogs.sim ;
+Begin
+ Class Dog;
+ ! The cim compiler requires virtual procedures to be fully specified ;
+ Virtual: Procedure bark Is Procedure bark;;
+ Begin
+ Procedure bark;
+ Begin
+ OutText("Woof!");
+ OutImage; ! Outputs a newline ;
+ End;
+ End;
+
+ Dog Class Chihuahua; ! Chihuahua is "prefixed" by Dog ;
+ Begin
+ Procedure bark;
+ Begin
+ OutText("Yap yap yap yap yap yap");
+ OutImage;
+ End;
+ End;
+
+ Ref (Dog) d;
+ d :- new Chihuahua; ! :- is the reference assignment operator ;
+ d.bark;
+End;
+```
+
+你可以按照下面代码执行程序的编译与运行：
+
+```
+$ cim dogs.sim
+Compiling dogs.sim:
+gcc -g -O2 -c dogs.c
+gcc -g -O2 -o dogs dogs.o -L/usr/local/lib -lcim
+$ ./dogs
+Yap yap yap yap yap yap
+```
+
+（你可能会注意到，cim 先将 Simula 语言编译为 C 语言，然后传递给 C 语言编译器。）
+
+这就是 1967 年的面向对象程序设计，除了语法方面的不同，和 2019 年的面向对象程序设计并无本质区别。如果你同意我的这一观点，你也就懂得了为什么人们会认为 Simula 在历史上是那么的重要。
+
+不过，我更想介绍一下 Simula I 的核心概念——进程模型。Simula 67 保留了进程模型，不过只有在使用 `Process` 类 和 `Simulation` 块的时候才能调用。
+
+为了表现出进程是如何运行的，我决定模拟下述场景。想象一下，有这么一座住满了村民的村庄，村庄的旁边有条小河边，小河里有很多的鱼。但是，村里的村民却只有一条鱼竿。村民们胃口很大，每隔一个小时就饿了。他们一饿，就会拿着鱼竿去钓鱼。如果一位村民正在等鱼竿，另一位村民自然也用不了。这样一来，村民们就会为了钓鱼排起长长的队伍。假如村民要等五、六分钟才能钓到一条鱼，那么这样等下去，村民们的身体状况就会变得越来越差。再假如，一位村民已经到了骨瘦如柴的地步，最后他可能就会饿死。
+
+这个例子多少有些奇怪，虽然我也不说不出来为什么我脑袋里最先想到的是这样的故事，但是就这样吧。我们把村民们当作 Simula 的各个进程，观察在有着四个村民的村庄里，一天的模拟时间内会发生什么。
+
+完整程序可以通过此处 [GitHub Gist][17] 的链接获取。
+
+我把输出结果的最后几行放在了下面。我们来看看一天里最后几个小时发生了什么：
+
+```
+1299.45: 王五饿了，要了鱼竿。
+1299.45: 王五正在钓鱼。
+1311.39: 王五钓到了一条鱼。
+1328.96: 赵六饿了，要了鱼竿。
+1328.96: 赵六正在钓鱼。
+1331.25: 李四饿了，要了鱼竿。
+1340.44: 赵六钓到了一条鱼。
+1340.44: 李四饿着肚子等着鱼竿。
+1340.44: 李四在等鱼竿的时候饿死了。
+1369.21: 王五饿了，要了鱼竿。
+1369.21: 王五正在钓鱼。
+1379.33: 王五钓到了一条鱼。
+1409.59: 赵六饿了，要了鱼竿。
+1409.59: 赵六正在钓鱼。
+1419.98: 赵六钓到了一条鱼。
+1427.53: 王五饿了，要了鱼竿。
+1427.53: 王五正在钓鱼。
+1437.52: 王五钓到了一条鱼。
+```
+
+可怜的李四最后饿死了，但是他比张三要长寿，因为张三还没到上午 7 点就饿死了。赵六和王五现在一定过得很好，因为需要鱼竿的就只剩下他们两个了。
+
+这里，我要说明，这个程序最重要的部分只是创建了进程（四个村民），并让它们运行下去。各个进程操作对象（鱼竿）的方式与我们今天对对象的操作方式相同。但是程序的主体部分并没有调用任何方法，也没有修改进程的任何属性。进程本身具有内部状态，但是这种内部状态的改变只有进程自身才能做到。
+
+在这个程序中，仍然有一些字段发生了变化，这类程序设计无法直接解决纯函数式编程所能解决的问题。但是正如克罗达尔所注意到的那样，“这一机制引导进行模拟的程序员为底层系统建立模型，生成一系列进程，每个进程表示了系统内的自然事件顺序。”[^12] 我们不是主要从名词或行动者（对其他对象做事的对象）的角度来思考正在进行的进程。我们可以将程序的总控制权交予 Simula 的事件通知系统，克罗达尔称其为 “时间管理器”。因此，尽管我们仍然在适当地改变进程，但是没有任何进程可以假设其他进程的状态。每个进程只能间接地与其他进程进行交互。
+
+这种模式如何用以编写编译器、HTTP 服务器以及其他内容，尚且无法确定。（另外，如果你在 Unity 游戏引擎上编写过游戏，就会发现两者十分相似。）我也承认，尽管我们有了“时间管理器”，但这可能并不完全是希基的意思，他说我们在程序中需要一个明确的时间概念。（我认为，希基想要的类似于 [阿达·洛芙莱斯 用于区分一个变量随时间变化产生的不同数值的上标符号][19]。）尽管如此，我们可以发现，面向对象程序设计前期的设计方式与我们今天所习惯的面向对象程序设计并非完全一致，我觉得这一点很有意思。我们可能会理所当然地认为，面向对象程序设计的方式千篇一律，即程序就是对事件的一长串记录：某个对象以特定顺序对其他对象产生作用。Simula I 的进程系统表明，面向对象程序设计的方式不止一种。仔细想一下，函数式语言或许是更好的设计方式，但是 Simula I 的发展告诉我们，现代面向对象程序设计被取代也很正常。
+
+_如果你喜欢这篇文章，欢迎关注推特 [@TwoBitHistory][20]，也可通过 [RSS feed][21] 订阅，获取最新文章（每四周更新一篇）。_
+
+
+[^1]: Jan Rune Holmevik, “The History of Simula,” accessed January 31, 2019, .
+[^2]: Ole-Johan Dahl and Kristen Nygaard, “SIMULA—An ALGOL-Based Simulation Langauge,” Communications of the ACM 9, no. 9 (September 1966): 671, accessed January 31, 2019, [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.95.384&rep=rep1&type=pdf][24].
+[^3]: Stein Krogdahl, “The Birth of Simula,” 2, accessed January 31, 2019, .
+[^4]: 出处同上。
+[^5]: Ole-Johan Dahl and Kristen Nygaard, “The Development of the Simula Languages,” ACM SIGPLAN Notices 13, no. 8 (August 1978): 248, accessed January 31, 2019, .
+[^6]: Dahl and Nygaard (1966), 676.
+[^7]: Dahl and Nygaard (1978), 257.
+[^8]: Krogdahl, 3.
+[^9]: Ole-Johan Dahl, “The Birth of Object-Orientation: The Simula Languages,” 3, accessed January 31, 2019, .
+[^10]: Dahl and Nygaard (1978), 265.
+[^11]: Holmevik.
+[^12]: Krogdahl, 4.
+
+--------------------------------------------------------------------------------
+
+via: https://twobithistory.org/2019/01/31/simula.html
+
+作者：[Two-Bit History][a]
+选题：[lujun9972][b]
+译者：[aREversez](https://github.com/aREversez)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://twobithistory.org
+[b]: https://github.com/lujun9972
+[1]: https://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hickey
+[2]: https://twobithistory.org/images/river.jpg
+[10]: https://archive.computerhistory.org/resources/text/algol/ACM_Algol_bulletin/1061032/p39-hoare.pdf
+[14]: http://web.eah-jena.de/~kleine/history/languages/Simula-CommonBaseLanguage.pdf
+[16]: https://www.gnu.org/software/cim/
+[17]: https://gist.github.com/sinclairtarget/6364cd521010d28ee24dd41ab3d61a96
+[19]: https://twobithistory.org/2018/08/18/ada-lovelace-note-g.html
+[20]: https://twitter.com/TwoBitHistory
+[21]: https://twobithistory.org/feed.xml
+[22]: https://twitter.com/TwoBitHistory/status/1075075139543449600?ref_src=twsrc%5Etfw
+[24]: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.95.384&rep=rep1&type=pdf
diff --git a/published/20210104 10 ways Ansible is for everyone.md b/published/20210104 10 ways Ansible is for everyone.md
new file mode 100644
index 0000000000..a47695f268
--- /dev/null
+++ b/published/20210104 10 ways Ansible is for everyone.md
@@ -0,0 +1,75 @@
+[#]: collector: (lujun9972)
+[#]: translator: (Donkey-Hao)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-14739-1.html)
+[#]: subject: (10 ways Ansible is for everyone)
+[#]: via: (https://opensource.com/article/21/1/ansible)
+[#]: author: (James Farrell https://opensource.com/users/jamesf)
+
+分享 10 篇 Ansible 文章
+======
+
+> 通过这些 Ansible 文章扩展你的知识和技能。
+
+
+
+我希望能够激发刚刚接触 Ansible 的初学者的兴趣。这里有一系列总结文章，我已将其包括在内，以供你随意后续查阅。
+
+### 适合初学者的 Ansible
+
+这五篇文章对于 Ansible 新手来说是一个非常好的起点。前三篇文章由 Seth Kenlon 撰写。
+
+ * 如果你不了解 Ansible ，[现在可以做这 7 件事][2] 来入手。这是很好的入门指导，它收集了用于管理硬件、云、容器等的链接。
+ * 在 《[编排与自动化有何区别？][3]》 这篇文章中，你会学到一些术语和技术路线，将会激发你对 Ansible 感兴趣。
+ * 文章 《[如何用 Ansible 安装软件][4]》 覆盖了一些脚本概念和一些 Ansible 的好惯例，给出了一些本地或远程管理软件包的案例。
+ * 在 [我编写 Ansible 剧本时学到的 3 个教训][5] 中，使自己养成 Jeff Geerling 所传授的好习惯，他是一位真正的 Ansible 资深人士。源代码控制、文档、测试、简化和优化是自动化成功的关键。
+ * 《[我使用 Ansible 的第一天][6]》 介绍了记者 David Both 在解决重复性开发任务时的思考过程。这篇文章从 Ansible 的基础开始，并说明了一些简单的操作和任务。
+
+### 尝试 Ansible 项目
+
+一旦你掌握了基础和并拥有良好习惯，就可以开始一些具体主题和实例了。
+
+ * Ken Fallon 在 《[使用 Ansible 管理你的树莓派机群][7]》 一文中介绍了一个部署和管理树莓派设备机群的示例。它介绍了受限环境中的安全和维护概念。
+ * 在 《[将你的日历与 Ansible 融合以避免日程冲突][8]》一文中，Nicolas Leiva 快速介绍了如何使用前置任务和条件在自动日程安排中中强制执行隔离窗口
+ * Nicolas 在 《[创建一个整合你的谷歌日历的 Ansible 模块][9]》中完成了他的日历隔离的理念。他的文章深入探讨了在 Go 中编写自定义 Ansible 模块以实现所需的日历连接。 Nicolas 介绍了构建和调用 Go 程序并将所需数据传递给 Ansible 并接收所需输出的不同方法。
+
+### 提升你的 Ansible 技巧
+
+Kubernetes 是近来的热门话题，以下文章提供了一些很好的示例来学习新技能。
+
+ * 在 《[适用于 Kubernets 自动编排你的 Ansible 模块][10]》 文章中，Seth Kenlon 介绍了 Ansible Kubernetes 模块， 介绍了用于测试的基本 Minikube 环境，并提供了一些用于荚 控制的 `k8s` 模块的基本示例。
+ * Jeff Geerling 在 《[使用 Ansible 的 Helm 模块构建 Kubernetes Minecraft 服务器][11]》 中解释了 Helm Chart 应用程序、Ansible 集合以及执行一个有趣的项目以在 k8s 集群中设置你自己的 Minecraft 服务器的概念。
+
+我希望你的 Ansible 旅程已经开始，并能常从这些文章中充实自己。
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/21/1/ansible
+
+作者：[James Farrell][a]
+选题：[lujun9972][b]
+译者：[Donkey](https://github.com/Donkey-Hao)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/jamesf
+[b]: https://github.com/lujun9972
+[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/innovation_lightbulb_gears_devops_ansible.png?itok=TSbmp3_M (gears and lightbulb to represent innovation)
+[2]: https://opensource.com/article/20/9/ansible
+[3]: https://opensource.com/article/20/11/orchestration-vs-automation
+[4]: https://opensource.com/article/20/9/install-packages-ansible
+[5]: https://opensource.com/article/20/1/ansible-playbooks-lessons
+[6]: https://opensource.com/article/20/10/first-day-ansible
+[7]: https://opensource.com/article/20/9/raspberry-pi-ansible
+[8]: https://opensource.com/article/20/10/calendar-ansible
+[9]: https://opensource.com/article/20/10/ansible-module-go
+[10]: https://opensource.com/article/20/9/ansible-modules-kubernetes
+[11]: https://opensource.com/article/20/10/kubernetes-minecraft-ansible
+[12]: https://opensource.com/article/20/1/ansible-news-edition-six
+[13]: https://opensource.com/article/20/2/ansible-news-edition-seven
+[14]: https://opensource.com/article/20/3/ansible-news-edition-eight
+[15]: https://opensource.com/article/20/4/ansible-news-edition-nine
+[16]: https://opensource.com/article/20/5/ansible-news-edition-ten
+[17]: https://opensource.com/how-submit-article
diff --git a/published/20210131 How to teach open source beyond business.md b/published/20210131 How to teach open source beyond business.md
new file mode 100644
index 0000000000..1e8afecdf6
--- /dev/null
+++ b/published/20210131 How to teach open source beyond business.md
@@ -0,0 +1,73 @@
+[#]: collector: (lujun9972)
+[#]: translator: (duoluoxiaosheng)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-14686-1.html)
+[#]: subject: (How to teach open source beyond business)
+[#]: via: (https://opensource.com/article/21/1/open-source-beyond-business)
+[#]: author: (Irit Goihman https://opensource.com/users/iritgoihman)
+
+在商业之外，为学生们教授开源知识
+======
+
+> Beyond 计划连接起未来科技行业的人才和开源文化。
+
+
+
+那时，我还是一个大学生，我不明白人们为什么那么吹捧开源软件。我也使用 Linux 和开源软件，但是我不明白开源的运作模式，不知道如何参加一个开源项目，也不知道这对我未来的职业有什么好处。我的开发经验主要是家庭作业和学位需要的一个大型期末项目。
+
+所以，当我开始踏足科技行业时，我发现我还有很多知识需要学习。我需要了解如何加入一个既定的、可能很大并且分散在不同地方的团队，为一个正在进行中的项目工作。我还要学会正确的沟通以保证我付出的努力不白费。
+
+在这方面，我并不特别。我只是众多毕业生中的一员。
+
+### 开源让毕业生的起点更高
+
+作为一个工程师，一个管理者，从那时起我开始帮助刚入行的工程师。我发现，有开源经验的毕业生比没有开源经验的毕业生能更快的入门。
+
+通过将开源方法纳入学术研究，学生们可以获得相关的行业经验，学会利用他们自己的知识，并建立一个陈述观点和分享知识的平台。参与开源项目可以对学生的技术知识和经验产生积极影响。这可以帮助他们更好的规划自己的职业生涯。
+
+开源在科技行业的价值是公认的，它塑造了全球软件公司的文化。参与开源项目并采用 [开放组织文化][2] 正在成为行业普遍现象。公司寻求知道如何在开源领域工作并培养其文化的思想新颖、才华横溢的员工。因此，科技行业必须推动学术界将开源文化作为学习科技研究的基本方法之一。
+
+### 商业之上是开源文化
+
+当我遇到红帽的高级软件工程师 [Liora Milbaum][3] 时，我发现，我们对将开源文化和规则引入学术界有着共同的兴趣。Liora 之前创立了 [DevOps Loft][4], 在其中，她与有兴趣进入这个行业的人们分享了 DevOps 实践，并希望发起一个类似的项目，教授大学生开源。我们决定启动 [Beyond][5] 计划，将科技行业拥抱开源精神的人才与红帽的实践联系起来。
+
+我们在 [Tel Aviv-Yafo 技术学院][6] 开始了 Beyond 计划，在那里，我们受到了信息系统学院的热烈欢迎。我们从介绍 DevOps 技术栈的 “DevOps 入门” 开始。我们开始时最大的挑战是怎么讲明白开源是什么。答案似乎很简单：实践出真理。我们不想给学生们讲授什么老套的学院课程，相反，我们想让学生接触到行业标准。
+
+我们创建了一个包含常见的开源项目和工具的教学大纲来教授 DevOps 技术栈。该课程由工程师教授的讲座和实践组成。学生们被分成小组，每组都由一名工程师指导和支持。他们练习团队合作，分享知识（在团队内外），并有效的协作。
+
+在我们为计算机科学学院的通讯准备的高级课程 “开源开发的基础” 中，我们遇到了另外的困难。当我们的课程开始两周以后，随着新冠疫情在全球的流行，我们完全靠远程沟通。我们通过与学生一起使用我们在红帽日常工作中使用的相同远程协作工具解决了这个问题。我们惊讶于过渡的是如此简单和顺利。
+
+![Beyond teaching online][7]
+
+(Irit Goihman, [CC BY-SA 4.0][8])
+
+### 成果展示
+
+这两个课程取得了巨大的成功，我们甚至雇佣了我们最优秀的学生之一。我们收到了非常棒的反馈，同学们表示，我们对他们的知识、思维和软技能产生了积极影响。一些学生因为在课程期间的开源贡献而得到了他们第一份技术工作。
+
+其他学术机构对这些课程表达出了极大的兴趣，因此我们将这个项目扩展到了另外一所大学。
+
+很荣幸，在一群优秀工程师的参与下，与 Liora 一起领导这个成功的项目。我们一起助力开源社区的成长。
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/21/1/open-source-beyond-business
+
+作者：[Irit Goihman][a]
+选题：[lujun9972][b]
+译者：[duoluoxiaosheng](https://github.com/duoluoxiaosheng)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/iritgoihman
+[b]: https://github.com/lujun9972
+[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/osdc-lead-teacher-learner.png?itok=rMJqBN5G (Teacher or learner?)
+[2]: https://opensource.com/open-organization/resources/open-org-definition
+[3]: https://www.linkedin.com/in/lioramilbaum
+[4]: https://www.devopsloft.io/
+[5]: https://research.redhat.com/blog/2020/05/24/open-source-development-course-and-devops-methodology/
+[6]: https://www.int.mta.ac.il/
+[7]: https://opensource.com/sites/default/files/pictures/beyond_mta.png (Beyond teaching online)
+[8]: https://creativecommons.org/licenses/by-sa/4.0/
diff --git a/published/20210319 Create a countdown clock with a Raspberry Pi.md b/published/20210319 Create a countdown clock with a Raspberry Pi.md
new file mode 100644
index 0000000000..40f4299374
--- /dev/null
+++ b/published/20210319 Create a countdown clock with a Raspberry Pi.md
@@ -0,0 +1,369 @@
+[#]: subject: (Create a countdown clock with a Raspberry Pi)
+[#]: via: (https://opensource.com/article/21/3/raspberry-pi-countdown-clock)
+[#]: author: (Chris Collins https://opensource.com/users/clcollins)
+[#]: collector: (lujun9972)
+[#]: translator: (Donkey-Hao)
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-14731-1.html)
+
+使用树莓派做一个倒计时器
+======
+
+> 使用树莓派和电子纸显示屏开始倒计时你的下一个假期。
+
+
+
+[圆周率日][2]（3 月 14 日） 来了又走，留下美好的回忆以及 [许多树莓派项目][3] 等待我们去尝试。在任何令人精神振奋、充满欢乐的假期后回到工作中都很难，圆周率日也不例外。当我们回望三月的时候，渴望那些天的快乐。但是不用害怕，亲爱的圆周率日庆祝者们，我们开始下一个节日的漫长倒计时！
+
+好了，严肃点。我做了一个圆周率日倒计时器，你也可以！
+
+不久前，我购买了一个 [树莓派 Zero W][4]，并且用它来 [解决 WiFi 信号较差的原因][5] 。我也对使用电子纸来作为它的显示屏十分感兴趣。虽然我不知道该用它来干什么，但是！它看起来真的很有趣！我买了一个十分适合放在树莓派的顶部的 2.13 英寸的 [WaveShare 显示器][6] 。安装很简单：只需要将显示器接到树莓派的 GPIO 上即可。
+
+我使用 [树莓派操作系统][7] 来实现该项目，虽然其他的操作系统肯定也能完成。但是下面的 `raspi-config` 命令在树莓派系统上很容易使用。
+
+### 设置树莓派和电子纸显示屏
+
+设置树莓派和电子纸显示屏一起工作，需要你在树莓派软件中启用串行外设接口（SPI），安装 BCM2835 C 库（来访问树莓派上的博通 BCM 2835 芯片的 GPIO 功能），安装 Python GPIO 库来控制电子纸显示屏。最后，你需要安装 WaveShare 的库来使用 Python 控制这个 2.13 英寸的显示屏。
+
+下面是完成这些的步骤。
+
+#### 启用 SPI
+
+树莓派上启用 SPI 最简单的方式是使用 `raspi-config` 命令。SPI 总线允许与设备进行串行数据通信——在本例中，电子纸显示：
+
+```
+$ sudo raspi-config
+```
+
+从弹出的菜单中, 选择 “接口选项 -> SPI -> 是” 来启用 SPI 接口，然后启动。
+
+#### 安装 BCM2835 库
+
+如上所述，BCM2835 库是用于树莓派博通 BCM2385 芯片的软件，它允许访问 GPIO 引脚来控制设备。
+
+在我写这篇文章之时，用于树莓派的最新博通 BCM2385 库版本是 v1.68 。安装此库需要下载软件压缩包然后使用 `make` 来安装：
+
+```
+# 下载 BCM2853 库并解压
+$ curl -sSL http://www.airspayce.com/mikem/bcm2835/bcm2835-1.68.tar.g> -o - | tar -xzf -
+
+# 进入解压后的文件夹
+$ pushd bcm2835-1.68/
+
+# 配置、检查并安装 BCM2853 库
+$ sudo ./configure
+$ sudo make check
+$ sudo make install
+
+# 返回上级目录
+$ popd
+```
+
+#### 安装需要的 Python 库
+
+你用 Python 控制电子纸显示屏需要安装 Python 库 `RPi.GPIO`，还需要使用 `python3-pil` 包来画图。显然，PIL 包已经不行了，但 Pillow 可以作为代替方案。我还没有为该项目测试过 Pillow ，但它可行：
+
+```
+# 安装需要的 Python 库
+$ sudo apt-get update
+$ sudo apt-get install python3-pip python3-pil
+$ sudo pip3 install RPi.GPIO
+```
+
+_注意：这些是 Python3 的指令。你可以在 WaveShare 网站查到 Python2 的指令。_
+
+#### 下载 WaveShare 示例和 Python 库
+
+Waveshare 维护了一个 Python 和 C 的 Git 库，用于使用其电子纸显示屏和一些展示如何使用它们的示例。对这个倒计时时钟而言，你需要克隆这个库并使用用于 2.13 英寸显示屏的库：
+
+```
+# 克隆这个 WaveShare e-Paper git 库
+$ git clone https://github.com/waveshare/e-Paper.gi>
+```
+
+如果你用不同的显示器或者其他公司产品，需要使用适配软件。
+
+Waveshare 提供了很多指导：
+
+ * [WaveShare 电子纸设置指导][9]
+ * [WaveShare 电子纸库安装指导][10]
+
+#### 获得有趣的字体（选做）
+
+你可以随心所欲的使用显示器，为什么不搞点花样？找一个炫酷的字体！
+
+这有大量 [开放字体许可][11] 的字体可供选择。我十分喜爱 Bangers 字体。如果你看过 YouTube 那你见过这种字体了，它十分流行。你可以下载到本地的共享字体目录文件中，并且所有的应用都可以使用，包括这个项目：
+
+```
+# “Bangers” 字体是 Vernon Adams 使用 Google 字体开放许可授权的字体
+$ mkdir -p ~/.local/share/fonts
+$ curl -sSL https://github.com/google/fonts/raw/master/ofl/bangers/Bangers-Regular.ttf -o fonts/Bangers-Regular.ttf
+```
+
+### 创建一个圆周率日倒计时器
+
+现在你已经安装好了软件，可以使用带有炫酷字体的电子纸显示屏了。你可以创建一个有趣的项目：倒计时到下一个圆周率日！
+
+如果你想，你可以从该项目的 [GitHub 仓库][13] 直接下载 [countdown.py][12] 这个 Python 文件并跳到文章结尾。
+
+为了满足大家的好奇心，我将逐步讲解。
+
+#### 导入一些库
+
+```
+#!/usr/bin/python3
+# -*- coding:utf-8 -*-
+import logging
+import os
+import sys
+import time
+
+from datetime import datetime
+from pathlib import Path
+from PIL import Image,ImageDraw,ImageFont
+
+logging.basicConfig(level=logging.INFO)
+
+basedir = Path(__file__).parent
+waveshare_base = basedir.joinpath('e-Paper', 'RaspberryPi_JetsonNano', 'python')
+libdir = waveshare_base.joinpath('lib')
+```
+
+开始先导入一些标准库之后脚本中用。也需要你从 PIL 添加 `Image`、`ImageDraw` 和 `ImageFont`，你会用到这些来画一些简单的图形。最后，为本地 `lib` 目录设置一些变量，该目录包含了用于 2.13 英寸显示屏的 Waveshare Python 库，稍后你可以使用这些变量从本地目录加载库。
+
+#### 字体大小辅助函数
+
+下一部分是为你选择的 Bangers-Regular.ttf 字体建立一个修改大小的辅助函数。该函数将整型变量作为大小参数，并返回一个图形字体对象来用于显示：
+
+```
+def set_font_size(font_size):
+ logging.info("Loading font...")
+ return ImageFont.truetype(f"{basedir.joinpath('Bangers-Regular.ttf').resolve()}", font_size)
+```
+
+#### 倒计时逻辑
+
+接下来是计算这个项目的一个函数：距下次圆周率日还有多久。如果是在一月，那么计算剩余天数将很简单。但是你需要考虑是否今年的圆周率日是否已经过去了（允悲）。如果是的话，那么计算在你可以再次庆祝之前还有多少天：
+
+```
+def countdown(now):
+ piday = datetime(now.year, 3, 14)
+
+ # 如果错过了就增加一年
+ if piday < now:
+ piday = datetime((now.year + 1), 3, 14)
+
+ days = (piday - now).days
+
+ logging.info(f"Days till piday: {days}")
+ return day
+```
+
+#### 主函数
+
+最后，到了主函数，需要初始化显示屏并向它写数据。这时，你应该写一个欢迎语然后再开始倒计时。但是首先，你需要加载 Waveshare 库：
+
+```
+def main():
+
+ if os.path.exists(libdir):
+ sys.path.append(f"{libdir}")
+ from waveshare_epd import epd2in13_V2
+ else:
+ logging.fatal(f"not found: {libdir}")
+ sys.exit(1)
+```
+
+上面的代码片段检查以确保该库已下载到倒计时脚本旁边的目录中，然后加载`epd2in13_V2` 库。如果你使用不同的显示屏，则需要使用不同的库。如果你愿意，也可以自己编写。我发现阅读 Waveshare 随显示屏提供的 Python 代码很有趣，它比我想象的要简单得多。
+
+下一段代码创建一个 EPD（电子纸显示屏）对象以与显示器交互并初始化硬件：
+
+```
+ logging.info("Starting...")
+ try:
+ # 创建一个显示对象
+ epd = epd2in13_V2.EPD()
+
+ # 初始化并清空显示
+ # ePaper 保持它的状态处分更新
+ logging.info("Initialize and clear...")
+ epd.init(epd.FULL_UPDATE)
+ epd.Clear(0xFF)
+```
+
+关于电子纸的一个有趣之处：它仅在将像素从白色变为黑色或从黑色变为白色时才耗电。这意味着当设备断电或应用程序因任何原因停止时，屏幕上的任何内容都会保留下来。从功耗的角度来看，这很好，但这也意味着你需要在启动时清除显示，否则你的脚本只会覆盖屏幕上已有的内容。 因此，`epd.Clear(0xFF)` 用于在脚本启动时清除显示。
+
+接下来，创建一个“画布”来绘制剩余的显示输出：
+
+```
+ # 创建一个图形对象
+ # 注意："epd.heigh" 是屏幕的长边
+ # 注意："epd.width" 是屏幕的短边
+ # 真是反直觉…
+ logging.info(f"Creating canvas - height: {epd.height}, width: {epd.width}")
+ image = Image.new('1', (epd.height, epd.width), 255) # 255: clear the frame
+ draw = ImageDraw.Draw(image)
+```
+
+这与显示器的宽度和高度相匹配——但它有点反直觉，因为显示器的短边是宽度。我认为长边是宽度，所以这只是需要注意的一点。 请注意，`epd.height` 和 `epd.width` 由 Waveshare 库设置以对应于你使用的设备。
+
+#### 欢迎语
+
+接下来，你将开始画一些画。这涉及在你之前创建的“画布”对象上设置数据。这还没有将它绘制到电子纸显示屏上——你现在只是在构建你想要的图像。由你为这个项目绘制带有一块馅饼的图像，来创建一个庆祝圆周率日的欢迎信息：
+
+![画一块馅饼][14]
+
+很可爱，不是吗？
+
+```
+ logging.info("Set text text...")
+ bangers64 = set_font_size(64)
+ draw.text((0, 30), 'PI DAY!', font = bangers64, fill = 0)
+
+ logging.info("Set BMP...")
+ bmp = Image.open(basedir.joinpath("img", "pie.bmp"))
+ image.paste(bmp, (150,2))
+```
+最后，_真是是最后了_，你可以展示你画的图画：
+
+```
+ logging.info("Display text and BMP")
+ epd.display(epd.getbuffer(image))
+```
+
+上面那段话更新了显示屏，以显示你所画的图像。
+
+接下来，准备另一幅图像展示你的倒计时：
+
+#### 圆周率日倒计时
+
+首先，创建一个用来展示倒计时的图像对象。也需要设置数字的字体大小：
+
+```
+ logging.info("Pi Date countdown; press CTRL-C to exit")
+ piday_image = Image.new('1', (epd.height, epd.width), 255)
+ piday_draw = ImageDraw.Draw(piday_image)
+
+ # 设置字体大小
+ bangers36 = set_font_size(36)
+ bangers64 = set_font_size(64)
+```
+
+为了使它显示的时候更像一个倒计时，更新图像的一部分是更加有效的手段，仅更改已经改变的显示数据部分。下面的代码准备以这样方式运行：
+
+```
+ # 准备更新显示
+ epd.displayPartBaseImage(epd.getbuffer(piday_image))
+ epd.init(epd.PART_UPDATE)
+```
+
+最后，需要计时，开始一个无限循环来检查据下次圆周率日还有多久，并显示在电子纸上。如果到了圆周率日，你可以输出一些庆祝短语：
+
+```
+ while (True):
+ days = countdown(datetime.now())
+ unit = get_days_unit(days)
+
+ # 通过绘制一个填充有白色的矩形来清除屏幕的下半部分
+ piday_draw.rectangle((0, 50, 250, 122), fill = 255)
+
+ # 绘制页眉
+ piday_draw.text((10,10), "Days till Pi-day:", font = bangers36, fill = 0)
+
+ if days == 0:
+ # 绘制庆祝语
+ piday_draw.text((0, 50), f"It's Pi Day!", font = bangers64, fill = 0)
+ else:
+ # 绘制距下一次 Pi Day 的时间
+ piday_draw.text((70, 50), f"{str(days)} {unit}", font = bangers64, fill = 0)
+
+ # 渲染屏幕
+ epd.displayPartial(epd.getbuffer(piday_image))
+ time.sleep(5)
+```
+
+脚本最后做了一些错误处理，包括捕获键盘中断，这样你可以使用 `Ctrl + C` 来结束无限循环，以及一个根据计数来打印 `day` 或 `days` 的函数：
+
+```
+ except IOError as e:
+ logging.info(e)
+
+ except KeyboardInterrupt:
+ logging.info("Exiting...")
+ epd.init(epd.FULL_UPDATE)
+ epd.Clear(0xFF)
+ time.sleep(1)
+ epd2in13_V2.epdconfig.module_exit()
+ exit()
+
+def get_days_unit(count):
+ if count == 1:
+ return "day"
+
+ return "days"
+
+if __name__ == "__main__":
+ main()
+```
+
+现在你已经拥有一个倒计时并显示剩余天数的脚本！这是在我的树莓派上的显示（视频经过加速，我没有足够的磁盘空间来保存一整天的视频）：
+
+![Pi Day Countdown Timer In Action][16]
+
+#### 安装 systemd 服务（选做）
+
+如果你希望在系统打开时运行倒计时显示，并且无需登录并运行脚本，你可以将可选的 systemd 单元安装为 [systemd 用户服务][17]。
+
+将 GitHub 上的 [piday.service][18] 文件复制到 `${HOME}/.config/systemd/user`，如果该目录不存在，请先创建该目录。然后你可以启用该服务并启动它：
+
+```
+$ mkdir -p ~/.config/systemd/user
+$ cp piday.service ~/.config/systemd/user
+$ systemctl --user enable piday.service
+$ systemctl --user start piday.service
+
+# Enable lingering, to create a user session at boot
+# and allow services to run after logout
+$ loginctl enable-linger $USER
+```
+
+该脚本将输出到 systemd 日志，可以使用 `journalctl` 命令查看输出。
+
+### 它开始看起来像是圆周率日了！
+
+这就是你的作品！一个显示在电子纸显示屏上的树莓派 Zero W 圆周率日倒计时器！并在系统启动时使用 systemd 单元文件启动！现在距离我们可以再次相聚庆祝圆周率日还有好多天的奇妙设备———树莓派。通过我们的小项目，我们可以一目了然地看到确切的天数。
+
+但实际上，每个人都可以在每一天在心中庆祝圆周率日，因此请使用自己的树莓派创建一些有趣且具有教育意义的项目吧！
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/21/3/raspberry-pi-countdown-clock
+
+作者：[Chris Collins][a]
+选题：[lujun9972][b]
+译者：[Donkey](https://github.com/Donkey-Hao)
+校对：[wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/clcollins
+[b]: https://github.com/lujun9972
+[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/clocks_time.png?itok=_ID09GDk (Alarm clocks with different time)
+[2]: https://en.wikipedia.org/wiki/Pi_Day
+[3]: https://opensource.com/tags/raspberry-pi
+[4]: https://www.raspberrypi.org/products/raspberry-pi-zero-w/
+[5]: https://opensource.com/article/21/3/troubleshoot-wifi-go-raspberry-pi
+[6]: https://www.waveshare.com/product/displays/e-paper.htm
+[7]: https://www.raspberrypi.org/software/operating-systems/
+[8]: https://pypi.org/project/Pillow/
+[9]: https://www.waveshare.com/wiki/2.13inch_e-Paper_HAT
+[10]: https://www.waveshare.com/wiki/Libraries_Installation_for_RPi
+[11]: https://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=OFL
+[12]: https://github.com/clcollins/epaper-pi-ex/blob/main/countdown.py
+[13]: https://github.com/clcollins/epaper-pi-ex/
+[14]: https://opensource.com/sites/default/files/uploads/pie.png (drawing of a piece of pie)
+[15]: https://creativecommons.org/licenses/by-sa/4.0/
+[16]: https://opensource.com/sites/default/files/uploads/piday_countdown.gif (Pi Day Countdown Timer In Action)
+[17]: https://wiki.archlinux.org/index.php/systemd/User
+[18]: https://github.com/clcollins/epaper-pi-ex/blob/main/piday.service
diff --git a/translated/tech/20210405 How different programming languages do the same thing.md b/published/20210405 How different programming languages do the same thing.md
similarity index 63%
rename from translated/tech/20210405 How different programming languages do the same thing.md
rename to published/20210405 How different programming languages do the same thing.md
index 62ac87d02c..0d8a476397 100644
--- a/translated/tech/20210405 How different programming languages do the same thing.md
+++ b/published/20210405 How different programming languages do the same thing.md
@@ -3,37 +3,39 @@
[#]: author: "Jim Hall https://opensource.com/users/jim-hall"
[#]: collector: "lujun9972"
[#]: translator: "VeryZZJ"
-[#]: reviewer: " "
-[#]: publisher: " "
-[#]: url: " "
+[#]: reviewer: "wxy"
+[#]: publisher: "wxy"
+[#]: url: "https://linux.cn/article-14687-1.html"
+
不同编程语言是如何完成同一件事
======
-通过一个简单的小游戏比较13种编程语言
-![Developing code.][1]
+> 通过一个简单的小游戏比较 13 种编程语言。
+
+
当我开始学习一种新的编程语言时，会把重点放在定义变量、书写声明以及计算表达式，一旦对这些概念有一个大致的了解，通常就能够自己弄清剩下的部分。大多数编程语言都具有相似性，所以如果你掌握了一种编程语言，学习下一种语言的重点就是弄清楚独有的概念以及区分不同。
-我喜欢写一些测试程序来帮助练习新的编程语言。其中我经常写的是一个叫做“猜数字”的小游戏，计算机选出1到100里的任一数字，然后我来猜。程序循环进行，直到猜出正确数字。通过伪代码可以看出，这是个非常简单的程序：
+我喜欢写一些测试程序来帮助练习新的编程语言。其中我经常写的是一个叫做“猜数字”的小游戏，计算机选出 1 到 100 里的任一数字，然后我来猜。程序循环进行，直到猜出正确数字。通过伪代码可以看出，这是个非常简单的程序：
-* 计算机在1到100之间选出一个随机数字
+* 计算机在 1 到 100 之间选出一个随机数字
* 循环进行直到猜出该随机数字
+ 计算机读取我的猜测
+ 告诉我我的猜测过高还是过低
-Opensource.com 最近发表了一篇文章，用不同的语言写这个程序。这是一个比较不同语言做同样事情的有趣机会。大多数编程语言具有相似性，所以当你在学习下一种新的编程语言时，主要是学习它的独特之处。
+我们发表了一些文章，用不同的语言写这个程序。这是一个比较不同语言做同样事情的有趣机会。大多数编程语言具有相似性，所以当你在学习下一种新的编程语言时，主要是学习它的独特之处。
-C 语言由 Dennis Ritchie 于1972年在贝尔实验室创建，是一种早期的通用编程语言。C 语言非常受欢迎，并迅速成为 Unix 系统上的标准编程语言。正是因为它的流行，许多其他编程语言也采用了类似的编程语法。这就是为什么如果你已经知道如何使用 C 语言编程，学习 C++、Rust、Java、Groovy、JavaScript、awk 或 Lua 会更容易。
+C 语言由 Dennis Ritchie 于 1972 年在贝尔实验室创建，是一种早期的通用编程语言。C 语言非常受欢迎，并迅速成为 Unix 系统上的标准编程语言。正是因为它的流行，许多其他编程语言也采用了类似的编程语法。这就是为什么如果你已经知道如何使用 C 语言编程，学习 C++、Rust、Java、Groovy、JavaScript、awk 或 Lua 会更容易。
-接下来我们看看这些不同的编程语言是如何实现 "猜数字 "游戏的主要步骤。我将把重点放在基本元素的相似或不同，跳过一些外围代码，如分配临时变量。
+接下来我们看看这些不同的编程语言是如何实现 “猜数字” 游戏的主要步骤。我将把重点放在基本元素的相似或不同，跳过一些外围代码，如分配临时变量。
-### 计算机在1到100之间选出一个随机数字
+### 计算机在 1 到 100 之间选出一个随机数字
-你可以看到这里有许多相似之处。大多数编程语言使用类似`rand()` 的函数，你可以设定一个范围来生成随机数。而其他一些语言使用一个特殊的函数来设定范围生成随机数。
+你可以看到这里有许多相似之处。大多数编程语言使用类似 `rand()` 的函数，你可以设定一个范围来生成随机数。而其他一些语言使用一个特殊的函数来设定范围生成随机数。
-C
+C：
-```c
+```
// Using the Linux `getrandom` system call
getrandom(&randval, sizeof(int), GRND_NONBLOCK);
number = randval % maxval + 1;
@@ -42,97 +44,97 @@ number = randval % maxval + 1;
number = rand() % 100 + 1;
```
-C++
+C++：
-```cpp
+```
int number = rand() % 100+1;
```
-Rust
+Rust：
-```rust
+```
let random = rng.gen_range(1..101);
```
-Java
+Java：
-```java
+```
private static final int NUMBER = r.nextInt(100) + 1;
```
-Groovy
+Groovy：
-```groovy
+```
int randomNumber = (new Random()).nextInt(100) + 1
```
-JavaScript
+JavaScript：
-```javascript
+```
const randomNumber = Math.floor(Math.random() * 100) + 1
```
-awk
+awk：
-```awk
+```
randomNumber = int(rand() * 100) + 1
```
-Lua
+Lua：
-```lua
+```
number = math.random(1,100)
```
### 循环进行直到我猜出该随机数字
-循环通常是用控制流程来实现的，如`while` 或`do-while`。JavaScript 中的实现没有使用循环，而是 "实时 "更新 HTML 页面，直到用户猜出正确的数字。Awk 虽然支持循环，但是通过循环读取输入信息是没有意义的，因为 awk 是基于数据管道的，所以它从文件而不是直接从用户读取输入信息。
+循环通常是用控制流程来实现的，如 `while` 或 `do-while`。JavaScript 中的实现没有使用循环，而是 “实时 ”更新 HTML 页面，直到用户猜出正确的数字。Awk 虽然支持循环，但是通过循环读取输入信息是没有意义的，因为 Awk 是基于数据管道的，所以它从文件而不是直接从用户读取输入信息。
-C
+C：
-```c
+```
do {
…
} while (guess != number);
```
-C++
+C++：
-```cpp
+```
do {
…
} while ( number != guess );
```
-Rust
+Rust：
-```rust
+```
for line in std::io::stdin().lock().lines() {
…
break;
}
```
-Java
+Java：
-```java
+```
while ( guess != NUMBER ) {
…
}
```
-Groovy
+Groovy：
-```groovy
+```
while ( … ) {
…
break;
}
```
-Lua
+Lua：
-```lua
+```
while ( player.guess ~= number ) do
…
end
@@ -140,66 +142,68 @@ end
### 计算机读取我的猜测
-不同编程语言对输入的处理方式不同。例如，JavaScript 直接从 HTML 表单中读取数值，而 awk 则从数据管道中读取数据。
+不同编程语言对输入的处理方式不同。例如，JavaScript 直接从 HTML 表单中读取数值，而 Awk 则从数据管道中读取数据。
-```c
+C：
+
+```
scanf("%d", &guess);
```
-C++
+C++：
-```cpp
+```
cin >> guess;
```
-Rust
+Rust：
-```rust
+```
let parsed = line.ok().as_deref().map(str::parse::);
if let Some(Ok(guess)) = parsed {
…
}
```
-Java
+Java：
-```java
+```
guess = player.nextInt();
```
-Groovy
+Groovy：
-```groovy
+```
response = reader.readLine()
int guess = response as Integer
```
-JavaScript
+JavaScript：
-```javascript
+```
let myGuess = guess.value
```
-awk
+Awk：
-```awk
+```
guess = int($0)
```
-Lua
+Lua：
-```lua
+```
player.answer = io.read()
player.guess = tonumber(player.answer)
```
-### 告诉我我的猜测过高还是过低
+### 告诉我猜测过高还是过低
-在这些类 C 语言中，通常是通过`if`语句进行比较的。每种编程语言打印输出的方式有一些变化，但打印语句在每个样本中都是可识别的。
+在这些类 C 语言中，通常是通过 `if` 语句进行比较的。每种编程语言打印输出的方式有一些变化，但打印语句在每个样本中都是可识别的。
-C
+C：
-```c
+```
if (guess < number) {
puts("Too low");
}
@@ -210,9 +214,9 @@ else if (guess > number) {
puts("That's right!");
```
-C++
+C++：
-```cpp
+```
if ( guess > number) { cout << "Too high.\n" << endl; }
else if ( guess < number ) { cout << "Too low.\n" << endl; }
else {
@@ -221,9 +225,9 @@ else {
}
```
-Rust
+Rust：
-```rust
+```
_ if guess < random => println!("Too low"),
_ if guess > random => println!("Too high"),
_ => {
@@ -232,9 +236,9 @@ _ => {
}
```
-Java
+Java：
-```java
+```
if ( guess > NUMBER ) {
System.out.println("Too high");
} else if ( guess < NUMBER ) {
@@ -245,9 +249,9 @@ if ( guess > NUMBER ) {
}
```
-Groovy
+Groovy：
-```groovy
+```
if (guess < randomNumber)
print 'too low, try again: '
else if (guess > randomNumber)
@@ -258,9 +262,9 @@ else {
}
```
-JavaScript
+JavaScript：
-```javascript
+```
if (myGuess === randomNumber) {
feedback.textContent = "You got it right!"
} else if (myGuess > randomNumber) {
@@ -270,9 +274,9 @@ if (myGuess === randomNumber) {
}
```
-awk
+Awk：
-```awk
+```
if (guess < randomNumber) {
printf "too low, try again:"
} else if (guess > randomNumber) {
@@ -283,9 +287,9 @@ if (guess < randomNumber) {
}
```
-Lua
+Lua：
-```lua
+```
if ( player.guess > number ) then
print("Too high")
elseif ( player.guess < number) then
@@ -298,21 +302,21 @@ end
### 非类 C 编程语言会怎么样呢？
-非类 C 编程语言会有很大的不同，需要学习特定的语法来完成每一步。Racket 源于 Lisp 和 Scheme，所以它使用 Lisp 的前缀符和大量括号。Python 使用空格而不是括号来表示循环之类的块。Elixir 是一种函数式编程语言，有自己的语法。Bash 是基于 Unix 系统中的 Bourne shell，它本身借鉴了 Algol68，并支持额外的速记符，如`&&`作为 "and " 的变体。Fortran 是在使用打孔卡片输入代码的时期创建的，所以它依赖于一些重要列的80-列布局。
+非类 C 编程语言会有很大的不同，需要学习特定的语法来完成每一步。Racket 源于 Lisp 和 Scheme，所以它使用 Lisp 的前缀符和大量括号。Python 使用空格而不是括号来表示循环之类的块。Elixir 是一种函数式编程语言，有自己的语法。Bash 是基于 Unix 系统中的 Bourne shell，它本身借鉴了 Algol68，并支持额外的速记符，如 `&&` 作为 `and` 的变体。Fortran 是在使用打孔卡片输入代码的时期创建的，所以它依赖于一些重要列的 80 列布局。
-我将通过比较 "if "语句，举例表现这些编程语言的不同。if 判断一个值是否小于或大于另一个值，并向用户打印适当信息。
+我将通过比较 `if` 语句，举例表现这些编程语言的不同。`if` 判断一个值是否小于或大于另一个值，并向用户打印适当信息。
-Racket
+Racket：
-```racket
+```
(cond [(> number guess) (displayln "Too low") (inquire-user number)]
[(< number guess) (displayln "Too high") (inquire-user number)]
[else (displayln "Correct!")]))
```
-Python
+Python：
-```python
+```
if guess < random:
print("Too low")
elif guess > random:
@@ -321,9 +325,9 @@ else:
print("That's right!")
```
-Elixir
+Elixir：
-```elixir
+```
cond do
guess < num ->
IO.puts "Too low!"
@@ -336,16 +340,16 @@ cond do
end
```
-Bash
+Bash：
-```bash
+```
[ "0$guess" -lt $number ] && echo "Too low"
[ "0$guess" -gt $number ] && echo "Too high"
```
-Fortran
+Fortran：
-```fortran
+```
IF (GUESS.LT.NUMBER) THEN
PRINT *, 'TOO LOW'
ELSE IF (GUESS.GT.NUMBER) THEN
@@ -353,28 +357,28 @@ ELSE IF (GUESS.GT.NUMBER) THEN
ENDIF
```
-### Read more 更多
+### 更多
-当你在学习一种新的编程语言时"猜数字 "游戏是一个很友好的入门程序，通过一种简单的方式练习了几个常见的编程概念。通过不同编程语言实现这个简单游戏，你可以理解一些核心概念和每种语言的细节。
+当你在学习一种新的编程语言时 “猜数字” 游戏是一个很友好的入门程序，通过一种简单的方式练习了几个常见的编程概念。通过不同编程语言实现这个简单游戏，你可以理解一些核心概念和每种语言的细节。
-学习如何用 C 和类 C 语言编写 "猜数字 "游戏：
+学习如何用 C 和类 C 语言编写 “猜数字” 游戏：
-* [C][2], by Jim Hall
-* [C++][3], by Seth Kenlon
-* [Rust][4], by Moshe Zadka
-* [Java][5], by Seth Kenlon
-* [Groovy][6], by Chris Hermansen
-* [JavaScript][7], by Mandy Kendall
-* [awk][8], by Chris Hermansen
-* [Lua][9], by Seth Kenlon
+* [C][2]， Jim Hall
+* [C++][3]， Seth Kenlon
+* [Rust][4]， Moshe Zadka
+* [Java][5]， Seth Kenlon
+* [Groovy][6]， Chris Hermansen
+* [JavaScript][7]， Mandy Kendall
+* [awk][8]， Chris Hermansen
+* [Lua][9]， Seth Kenlon
其他语言：
-* [Racket][10], by Cristiano L. Fontana
-* [Python][11], by Moshe Zadka
-* [Elixir][12], by Moshe Zadka
-* [Bash][13], by Jim Hall
-* [Fortran][14], by Jim Hall
+* [Racket][10]， Cristiano L. Fontana
+* [Python][11]， Moshe Zadka
+* [Elixir][12]， Moshe Zadka
+* [Bash][13]， Jim Hall
+* [Fortran][14]， Jim Hall
--------------------------------------------------------------------------------
@@ -383,7 +387,7 @@ via: https://opensource.com/article/21/4/compare-programming-languages
作者：[Jim Hall][a]
选题：[lujun9972][b]
译者：[VeryZZJ](https://github.com/VeryZZJ)
-校对：[校对者ID](https://github.com/校对者ID)
+校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
diff --git a/published/20210531 Get started with Kubernetes using chaos engineering.md b/published/20210531 Get started with Kubernetes using chaos engineering.md
new file mode 100644
index 0000000000..2aaaaa83a7
--- /dev/null
+++ b/published/20210531 Get started with Kubernetes using chaos engineering.md
@@ -0,0 +1,72 @@
+[#]: subject: (Get started with Kubernetes using chaos engineering)
+[#]: via: (https://opensource.com/article/21/5/kubernetes-chaos)
+[#]: author: (Jessica Cherry https://opensource.com/users/cherrybomb)
+[#]: collector: (lujun9972)
+[#]: translator: (Donkey-Hao)
+[#]: reviewer: (turbokernel, wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-14743-1.html)
+
+在 Kubernetes 中使用混沌工程
+======
+
+> 在这篇文章中学习混沌工程的基础知识。
+
+
+
+混沌工程是由科学、规划以及实验组成的。它是一门在系统上进行实验的学科，用来建立系统在生产中承受混乱条件能力的信心。
+
+首先，我会在文章导论部分解释混沌系统如何工作。
+
+### 如何开始学习混沌系统呢？
+
+以我的经验，开始学习混沌系统的最好方式是触发一个此前生产中出现的事故来进行实验。使用过去的数据，制定一个计划，以相同的方式破坏你的系统，然后建立修复策略，并确认结果满足你预期。如果计划失败，你就有了一种新的实验方式，并朝着快速处理问题的新方式前进。
+
+最重要的是，你可以随时记录所有内容，这意味着，随着时间的推移，整个系统将被完整记录下来，任何人都可以值守而无需太多加码，每个人都可以在周末好好休息。
+
+### 你要在混沌工程中做什么？
+
+混沌系统实验运行背后有一些科学依据。我记录了其中一些步骤：
+
+1. **定义一个稳定状态：** 使用监控工具来搜集当系统没有问题或事故时，看起来功能正常的数据。
+2. **提出假设或使用先前的事故：** 现在你已经定义了一个稳定状态，请提出一个关于在事故或中断期间会发生（或发生过）的情况的假设。用这个假设来得出一系列将会发生的事故，以及如何解决问题的理论。然后你可以制定一个故意引发该问题的计划。
+3. **引发问题：** 用这个计划来破坏系统，并开始在真实环境中测试。收集破坏时的指标状态，按计划修复，并追踪提出解决方案所需时长。确保你把所有的东西都记录下来，以备将来发生故障时使用。
+4. **试图推翻你的假设：** 实验中最精彩的部分是尝试推翻你的思考或计划。你要创建一个不同的状态，看看你能走多远，并在系统中生成一个不同的稳定状态。
+
+确保在你在另一个系统中生成的破坏因素前，建立一个处于稳定状态的控制系统。这将使你更容易在实验前、期间和之后发现各种稳定状态的差异。
+
+### 混沌工程需要什么？
+
+这有一些初学混沌工程很好的工具：
+
+* 良好的文档编制方法
+* 一个捕捉你系统是否处于稳定状态的监控系统
+ * Grafana
+ * Prometheus
+* 混沌工程工具：
+ * Chaos mesh
+ * Litmus
+ * 之后的文章我会介绍更多
+* 一个假设
+* 一个计划
+
+### 去搞破坏吧
+
+现在你已经掌握了基础，是时候去安全的摧毁你的系统了。我计划每年制造四次混乱，然后努力实现每月一次的破坏。
+
+混沌工程是一种很好的实践，也是推进你的内部文档保持最新的好方法。此外，随着时间的推移，新升级或应用程序部署将更加顺畅，你的日常生活管理将通过 Kubernetes 变得更加轻松。
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/21/5/kubernetes-chaos
+
+作者：[Jessica Cherry][a]
+选题：[lujun9972][b]
+译者：[Donkey](https://github.com/Donkey-Hao)
+校对：[turbokernel](https://github.com/turbokernel), [wxy](https://github.com/wxy)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/cherrybomb
+[b]: https://github.com/lujun9972
+[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/brett-jordan-chaos-unsplash.jpg?itok=sApp5dVd (Scrabble letters spell out chaos for chaos engineering)
diff --git a/published/20210722 Write your first JavaScript code.md b/published/20210722 Write your first JavaScript code.md
new file mode 100644
index 0000000000..1cbb8f9f06
--- /dev/null
+++ b/published/20210722 Write your first JavaScript code.md
@@ -0,0 +1,186 @@
+[#]: subject: "Write your first JavaScript code"
+[#]: via: "https://opensource.com/article/21/7/javascript-cheat-sheet"
+[#]: author: "Seth Kenlon https://opensource.com/users/seth"
+[#]: collector: "lkxed"
+[#]: translator: "lkxed"
+[#]: reviewer: "wxy"
+[#]: publisher: "wxy"
+[#]: url: "https://linux.cn/article-14740-1.html"
+
+编写你的第一段 JavaScript 代码
+======
+
+> JavaScript 是为 Web 而生的，但它可以做的事远不止于此。本文将带领你了解它的基础知识，然后你可以下载我们的备忘清单，以便随时掌握详细信息。
+
+
+
+JavaScript 是一种充满惊喜的编程语言。许多人第一次遇到 JavaScript 时，它通常是作为一种 Web 语言出现的。所有主流浏览器都有一个 JavaScript 引擎；并且，还有一些流行的框架，如 JQuery、Cash 和 Bootstrap 等，它们可以帮助简化网页设计；甚至还有用 JavaScript 编写的编程环境。它似乎在互联网上无处不在，但事实证明，它对于 [Electron][2] 等项目来说也是一种有用的语言。Electron 是一个构建跨平台桌面应用程序的开源工具包，它使用的语言就是 JavaScript。
+
+JavaScript 语言的用途多到令人惊讶，它拥有各种各样的库，而不仅仅是用于制作网站。它的基础知识十分容易掌握，因此，它可以作为一个起点，助你跨出构建你想象中的东西的第一步。
+
+### 安装 JavaScript
+
+随着你的 JavaScript 水平不断提高，你可能会发现自己需要高级的 JavaScript 库和运行时环境。不过，刚开始学习的时候，你是根本不需要安装 JavaScript 环境的。因为所有主流的 Web 浏览器都包含一个 JavaScript 引擎来运行代码。你可以使用自己喜欢的文本编辑器编写 JavaScript，将其加载到 Web 浏览器中，接着你就能看到代码的作用。
+
+### 上手 JavaScript
+
+要编写你的第一个 JavaScript 代码，请打开你喜欢的文本编辑器，例如 [Atom][4] 或 [VSCode][5] 等。因为它是为 Web 开发的，所以 JavaScript 可以很好地与 HTML 配合使用。因此，我们先来尝试一些基本的 HTML：
+
+```
+
+
+ JS
+
+
+ Nothing here.
+
+
+```
+
+保存这个文件，然后在 Web 浏览器中打开它。
+
+![浏览器中显示的 HTML][6]
+
+要将 JavaScript 添加到这个简单的 HTML 页面，你可以创建一个 JavaScript 文件并在页面的 `` 中引用它，或者只需使用 `
+
+
+