document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2025-03-21 02:10:11 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #17 from LCTT/master

Browse Source 
更新 20190323
This commit is contained in:
Chang Liu 2019-03-23 14:59:02 +08:00 committed by GitHub
commit 3d80383b5b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
42 changed files with 3989 additions and 1048 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
translated/tech/20180330 Asynchronous rsync with Emacs, dired and tramp..md → published/20180330 Asynchronous rsync with Emacs, dired and tramp..md
View File

@ -1,8 +1,8 @@
[#]: collector: (lujun9972)
[#]: translator: (lujun9972)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-10639-1.html)
[#]: subject: (Asynchronous rsync with Emacs，dired and tramp。)
[#]: via: (https://vxlabs.com/2018/03/30/asynchronous-rsync-with-emacs-dired-and-tramp/)
[#]: author: (cpbotha https://vxlabs.com/author/cpbotha/)
@ -10,45 +10,44 @@
在 Emacs 的 dired 和 tramp 中异步运行 rsync
======
[Trần Xuân Trường][2] 写的 [tmtxt-dired-async][1] 是一个不为人知的 Emacs 包，它可以扩展 dired(Emacs 内置的文件管理器)，使之可以异步地运行 rsync 等其他命令 (例如 zip，unzip，downloading)。
[Trần Xuân Trường][2] 写的 [tmtxt-dired-async][1] 是一个不为人知的 Emacs 包，它可以扩展 dired（Emacs 内置的文件管理器），使之可以异步地运行 `rsync` 和其他命令 (例如压缩、解压缩和下载）。
这意味着你可以拷贝成 G 的目录而不影响 Emacs 的其他任务。
这意味着你可以拷贝上 GB 的目录而不影响 Emacs 的其他任务。
它的一个功能时让你可以通过 `C-c C-a` 从不同位置添加任意多的文件到一个等待列表中，然后按下 `C-c C-v` 异步地使用 rsync 将整个等待列表中的文件同步到目标目录中 . 光这个功能就值得一试了。
它的一个功能时让你可以通过 `C-c C-a` 从不同位置添加任意多的文件到一个等待列表中，然后按下 `C-c C-v` 异步地使用 `rsync` 将整个等待列表中的文件同步到目标目录中。光这个功能就值得一试了。
例如这里将 arduino 1.9 beta 存档同步到另一个目录中：
例如这里将 arduino 1.9 的 beta 存档同步到另一个目录中：
![][4]
[![][3]][4]
整个进度完成后，底部的窗口会在 5 秒后自动退出。下面是异步解压上面的 arduino 存档后出现的另一个会话：
整个进度完成后，底部的窗口会在 5 秒后自动退出。下面时异步解压上面的 arduino 存档后出现的另一个会话：
[![][5]][6]
![][6]
这个包进一步增加了我 dired 配置的实用性。
我刚刚贡献了 [一个 pull request 来允许 tmtxt-dired-async 同步到远程 tramp 目录中 ][7]，而且我立即使用该功能来将成 G 的新照片传输到 Linux 服务器上。
我刚刚贡献了 [一个拉取请求来允许 tmtxt-dired-async 同步到远程 tramp 目录中][7]，而且我立即使用该功能来将上 GB 的新照片传输到 Linux 服务器上。
若你想配置 tmtxt-dired-async，下载 [tmtxt-async-tasks.el][8] (被依赖的库) 以及 [tmtxt-dired-async.el][9]  (若你想让它支持 tramp，请确保我的 PR 以及被合并) 到 =~/.emacs.d/= 目录中，然后添加下面配置：
若你想配置 tmtxt-dired-async，下载 [tmtxt-async-tasks.el][8]（被依赖的库）以及 [tmtxt-dired-async.el][9]（若你想让它支持 tramp，请确保合并使用了我的拉取请求）到 `~/.emacs.d/` 目录中，然后添加下面配置：
```
;; no MELPA packages of this, so we have to do a simple check here
(setq dired-async-el (expand-file-name "~/.emacs.d/tmtxt-dired-async.el"))
(when (file-exists-p dired-async-el)
(load (expand-file-name "~/.emacs.d/tmtxt-async-tasks.el"))
(load dired-async-el)
(define-key dired-mode-map (kbd "C-c C-r") 'tda/rsync)
(define-key dired-mode-map (kbd "C-c C-z") 'tda/zip)
(define-key dired-mode-map (kbd "C-c C-u") 'tda/unzip)
(load (expand-file-name "~/.emacs.d/tmtxt-async-tasks.el"))
(load dired-async-el)
(define-key dired-mode-map (kbd "C-c C-r") 'tda/rsync)
(define-key dired-mode-map (kbd "C-c C-z") 'tda/zip)
(define-key dired-mode-map (kbd "C-c C-u") 'tda/unzip)
(define-key dired-mode-map (kbd "C-c C-a") 'tda/rsync-multiple-mark-file)
(define-key dired-mode-map (kbd "C-c C-e") 'tda/rsync-multiple-empty-list)
(define-key dired-mode-map (kbd "C-c C-d") 'tda/rsync-multiple-remove-item)
(define-key dired-mode-map (kbd "C-c C-v") 'tda/rsync-multiple)
(define-key dired-mode-map (kbd "C-c C-a") 'tda/rsync-multiple-mark-file)
(define-key dired-mode-map (kbd "C-c C-e") 'tda/rsync-multiple-empty-list)
(define-key dired-mode-map (kbd "C-c C-d") 'tda/rsync-multiple-remove-item)
(define-key dired-mode-map (kbd "C-c C-v") 'tda/rsync-multiple)
(define-key dired-mode-map (kbd "C-c C-s") 'tda/get-files-size)
(define-key dired-mode-map (kbd "C-c C-s") 'tda/get-files-size)
(define-key dired-mode-map (kbd "C-c C-q") 'tda/download-to-current-dir))
(define-key dired-mode-map (kbd "C-c C-q") 'tda/download-to-current-dir))
```
祝你开心！
@ -61,7 +60,7 @@ via: https://vxlabs.com/2018/03/30/asynchronous-rsync-with-emacs-dired-and-tramp
作者：[cpbotha][a]
选题：[lujun9972][b]
译者：[lujun9972](https://github.com/lujun9972)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

59
published/20190116 Get started with Cypht, an open source email client.md Normal file
View File

@ -0,0 +1,59 @@
[#]: collector: (lujun9972)
[#]: translator: (geekpi)
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-10642-1.html)
[#]: subject: (Get started with Cypht, an open source email client)
[#]: via: (https://opensource.com/article/19/1/productivity-tool-cypht-email)
[#]: author: (Kevin Sonney https://opensource.com/users/ksonney (Kevin Sonney))
开始使用 Cypht 吧，一个开源的电子邮件客户端
======
> 使用 Cypht 将你的电子邮件和新闻源集成到一个界面中，这是我们 19 个开源工具系列中的第 4 个，它将使你在 2019 年更高效。
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/email_mail_box_envelope_send_blue.jpg?itok=6Epj47H6)
每年年初似乎都有疯狂的冲动想提高工作效率。新年的决心，渴望开启新的一年，当然，“抛弃旧的，拥抱新的”的态度促成了这一切。通常这时的建议严重偏向闭源和专有软件，但事实上并不用这样。
这是我挑选出的 19 个新的（或者对你而言新的）开源工具中的第 4 个工具来帮助你在 2019 年更有效率。
### Cypht
我们花了很多时间来处理电子邮件，有效地[管理你的电子邮件][1]可以对你的工作效率产生巨大影响。像 Thunderbird、Kontact/KMail 和 Evolution 这样的程序似乎都有一个共同点：它们试图复制 Microsoft Outlook 的功能，这在过去 10 年左右并没有真正改变。在过去十年中，甚至像 Mutt 和 Cone 这样的[著名控制台程序][2]也没有太大变化。
![](https://opensource.com/sites/default/files/uploads/cypht-1.png)
[Cypht][3] 是一个简单、轻量级和现代的 Webmail 客户端，它将多个帐户聚合到一个界面中。除了电子邮件帐户，它还包括 Atom/RSS 源。在 “Everything” 中，不仅可以显示收件箱中的邮件，还可以显示新闻源中的最新文章，从而使得阅读不同来源的内容变得简单。
![](https://opensource.com/sites/default/files/uploads/cypht-2.png)
它使用简化的 HTML 消息来显示邮件，或者你也可以将其设置为查看纯文本版本。由于 Cypht 不会加载远程图像（以帮助维护安全性），HTML 渲染可能有点粗糙，但它足以完成工作。你将看到包含大量富文本邮件的纯文本视图 —— 这意味着很多链接并且难以阅读。我不会说是 Cypht 的问题，因为这确实是发件人所做的，但它确实降低了阅读体验。阅读新闻源大致相同，但它们与你的电子邮件帐户集成，这意味着可以轻松获取最新的（我有时会遇到问题）。
![](https://opensource.com/sites/default/files/uploads/cypht-3.png)
用户可以使用预配置的邮件服务器并添加他们使用的任何其他服务器。Cypht 的自定义选项包括纯文本与 HTML 邮件显示，它支持多个配置文件以及更改主题（并自行创建）。你要记得单击左侧导航栏上的“保存”按钮，否则你的自定义设置将在该会话后消失。如果你在不保存的情况下注销并重新登录，那么所有更改都将丢失，你将获得开始时的设置。因此可以轻松地实验，如果你需要重置，只需在不保存的情况下注销，那么在再次登录时就会看到之前的配置。
![](https://opensource.com/sites/default/files/pictures/cypht-4.png)
本地[安装 Cypht][4] 非常容易。虽然它不使用容器或类似技术，但安装说明非常清晰且易于遵循，并且不需要我做任何更改。在我的笔记本上，从安装开始到首次登录大约需要 10 分钟。服务器上的共享安装使用相同的步骤，因此它应该大致相同。
最后，Cypht 是桌面和基于 Web 的电子邮件客户端的绝佳替代方案，它有简单的界面，可帮助你快速有效地处理电子邮件。
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/1/productivity-tool-cypht-email
作者：[Kevin Sonney][a]
选题：[lujun9972][b]
译者：[geekpi](https://github.com/geekpi)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/ksonney (Kevin Sonney)
[b]: https://github.com/lujun9972
[1]: https://opensource.com/article/17/7/email-alternatives-thunderbird
[2]: https://opensource.com/life/15/8/top-4-open-source-command-line-email-clients
[3]: https://cypht.org/
[4]: https://cypht.org/install.html

60
published/20190117 Get started with CryptPad, an open source collaborative document editor.md Normal file
View File

@ -0,0 +1,60 @@
[#]: collector: (lujun9972)
[#]: translator: (geekpi)
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-10636-1.html)
[#]: subject: (Get started with CryptPad, an open source collaborative document editor)
[#]: via: (https://opensource.com/article/19/1/productivity-tool-cryptpad)
[#]: author: (Kevin Sonney https://opensource.com/users/ksonney (Kevin Sonney))
开始使用 CryptPad 吧，一个开源的协作文档编辑器
======
> 使用 CryptPad 安全地共享你的笔记、文档、看板等，这是我们在开源工具系列中的第 5 个工具，它将使你在 2019 年更高效。
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/web_browser_desktop_devlopment_design_system_computer.jpg?itok=pfqRrJgh)
每年年初似乎都有疯狂的冲动想提高工作效率。新年的决心，渴望开启新的一年，当然，“抛弃旧的，拥抱新的”的态度促成了这一切。通常这时的建议严重偏向闭源和专有软件，但事实上并不用这样。
这是我挑选出的 19 个新的（或者对你而言新的）开源工具中的第 5 个工具来帮助你在 2019 年更有效率。
### CryptPad
我们已经介绍过 [Joplin][1]，它能很好地保存自己的笔记，但是，你可能已经注意到，它没有任何共享或协作功能。
[CryptPad][2] 是一个安全、可共享的笔记应用和文档编辑器，它能够安全地协作编辑。与 Joplin 不同，它是一个 NodeJS 应用，这意味着你可以在桌面或其他服务器上运行它，并使用任何现代 Web 浏览器访问。它开箱即用，它支持富文本、Markdown、投票、白板，看板和 PPT。
![](https://opensource.com/sites/default/files/uploads/cryptpad-1.png)
它支持不同的文档类型且功能齐全。它的富文本编辑器涵盖了你所期望的所有基础功能，并允许你将文件导出为 HTML。它的 Markdown 的编辑能与 Joplin 相提并论，它的看板虽然不像 [Wekan][3] 那样功能齐全，但也做得不错。其他支持的文档类型和编辑器也很不错，并且有你希望在类似应用中看到的功能，尽管投票功能显得有些粗糙。
![](https://opensource.com/sites/default/files/uploads/cryptpad-2.png)
然而，CryptPad 的真正强大之处在于它的共享和协作功能。共享文档只需在“共享”选项中获取可共享 URL，CryptPad 支持使用 `<iframe>` 标签嵌入其他网站的文档。可以在“编辑”或“查看”模式下使用密码和会过期的链接共享文档。内置聊天能够让编辑者相互交谈（请注意，具有浏览权限的人也可以看到聊天但无法发表评论）。
![](https://opensource.com/sites/default/files/pictures/cryptpad-3.png)
所有文件都使用用户密码加密存储。服务器管理员无法读取文档，这也意味着如果你忘记或丢失了密码，文件将无法恢复。因此，请确保将密码保存在安全的地方，例如放在[密码保险箱][4]中。
![](https://opensource.com/sites/default/files/uploads/cryptpad-4.png)
当它在本地运行时，CryptPad 是一个用于创建和编辑文档的强大应用。当在服务器上运行时，它成为了用于多用户文档创建和编辑的出色协作平台。在我的笔记本电脑上安装它不到五分钟，并且开箱即用。开发者还加入了在 Docker 中运行 CryptPad 的说明，并且还有一个社区维护用于方便部署的 Ansible 角色。CryptPad 不支持任何第三方身份验证，因此用户必须创建自己的帐户。如果你不想运行自己的服务器，CryptPad 还有一个社区支持的托管版本。
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/1/productivity-tool-cryptpad
作者：[Kevin Sonney][a]
选题：[lujun9972][b]
译者：[geekpi](https://github.com/geekpi)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/ksonney (Kevin Sonney)
[b]: https://github.com/lujun9972
[1]: https://opensource.com/article/19/1/productivity-tool-joplin
[2]: https://cryptpad.fr/index.html
[3]: https://opensource.com/article/19/1/productivity-tool-wekan
[4]: https://opensource.com/article/18/4/3-password-managers-linux-command-line

57
translated/tech/20190124 ODrive (Open Drive) - Google Drive GUI Client For Linux.md → published/20190124 ODrive (Open Drive) - Google Drive GUI Client For Linux.md
View File

@ -1,40 +1,34 @@
[#]: collector: (lujun9972)
[#]: translator: (geekpi)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-10637-1.html)
[#]: subject: (ODrive (Open Drive) – Google Drive GUI Client For Linux)
[#]: via: (https://www.2daygeek.com/odrive-open-drive-google-drive-gui-client-for-linux/)
[#]: author: (Magesh Maruthamuthu https://www.2daygeek.com/author/magesh/)
ODrive（Open Drive） - Linux 中的 Google Drive 图形客户端
ODrive：Linux 中的 Google 云端硬盘图形客户端
======
这个我们已经多次讨论过。但是，我还要简要介绍一下它。
这个我们已经多次讨论过。但是，我还要简要介绍一下它。截至目前，还没有官方的 Google 云端硬盘的 Linux 客户端，我们需要使用非官方客户端。Linux 中有许多集成 Google 云端硬盘的应用。每个应用都提供了一组功能。
截至目前，还没有官方的 Google Drive 的 Linux 客户端，我们需要使用非官方客户端。
我们过去在网站上写过一些此类文章。
Linux 中有许多集成 Google Drive 的应用。
每个应用都提供了一组功能。
我们过去在网站上很少写过此类文章。
这些文章是 **[DriveSync][1]** 、**[Google Drive Ocamlfuse 客户端][2]** 和 **[在 Linux 中使用 Nautilus 文件管理器挂载 Google Drive][3]**。
这些文章是 [DriveSync][1] 、[Google Drive Ocamlfuse 客户端][2] 和 [在 Linux 中使用 Nautilus 文件管理器挂载 Google 云端硬盘][3]。
今天我们也将讨论相同的主题，程序名字是 ODrive。
### ODrive 是什么？
ODrive 代表 Open Drive。它是 Google Drive 的图形客户端，它用 electron 框架编写。
ODrive 意即 Open Drive。它是 Google 云端硬盘的图形客户端，它用 electron 框架编写。
它简单的图形界面能让用户几步就能集成 Google Drive。
它简单的图形界面能让用户几步就能集成 Google 云端硬盘。
### 如何在 Linux 上安装和设置 ODrive？
由于开发者提供了 AppImage 包，因此在 Linux 上安装 ODrive 没有任何困难。
只需使用 **wget 命令**从开发者的 github 页面下载最新的 ODrive AppImage 包。
只需使用 `wget` 命令从开发者的 GitHub 页面下载最新的 ODrive AppImage 包。
```
$ wget https://github.com/liberodark/ODrive/releases/download/0.1.3/odrive-0.1.3-x86_64.AppImage
@ -52,37 +46,47 @@ $ chmod +x odrive-0.1.3-x86_64.AppImage
$ ./odrive-0.1.3-x86_64.AppImage
```
运行上述命令时，可能会看到下面的窗口。只需按下**“下一步”**按钮即可进行进一步设置。
运行上述命令时，可能会看到下面的窗口。只需按下“下一步”按钮即可进行进一步设置。
![][5]
点击**`连接`**链接添加 Google Drive 帐户。
点击“连接”链接添加 Google 云端硬盘帐户。
![][6]
输入你要设置 Google Drive 帐户的电子邮箱。
输入你要设置 Google 云端硬盘帐户的电子邮箱。
![][7]
输入邮箱密码。
![][8]
允许 ODrive（Open Drive） 访问你的 Google 帐户。
允许 ODrive 访问你的 Google 帐户。
![][9]
默认情况下，它将选择文件夹位置。如果你要选择特定文件夹，则可以更改。
![][10]
最后点击**`同步`**按钮开始将文件从 Google Drive 下载到本地系统。
最后点击“同步”按钮开始将文件从 Google 下载到本地系统。
![][11]
同步正在进行中。
![][12]
同步完成后。它会显示所有已下载的文件。
![][13]
我看到所有文件都下载到上述目录中。
![][14]
如果要将本地系统中的任何新文件同步到 Google Drive。只需从应用菜单启动 `ODrive`，但它不会实际启动应用。但它将在后台运行，我们可以使用 ps 命令查看。
如果要将本地系统中的任何新文件同步到 Google 。只需从应用菜单启动 “ODrive”，但它不会实际启动应用。它将在后台运行，我们可以使用 `ps` 命令查看。
```
$ ps -df | grep odrive
@ -90,10 +94,11 @@ $ ps -df | grep odrive
![][15]
将新文件添加到 Google Drive 文件夹后，它会自动开始同步。从通知菜单中也可以看到。是的，我看到一个文件已同步到 Google Drive 中。
将新文件添加到 Google文件夹后，它会自动开始同步。从通知菜单中也可以看到。是的，我看到一个文件已同步到 Google 中。
![][16]
同步完成后图形界面没有加载，我不确定这个功能。我会向开发者之后，根据他的反馈更新。
同步完成后图形界面没有加载，我不确定这个功能。我会向开发者反馈之后，根据他的反馈更新。
--------------------------------------------------------------------------------
@ -102,14 +107,14 @@ via: https://www.2daygeek.com/odrive-open-drive-google-drive-gui-client-for-linu
作者：[Magesh Maruthamuthu][a]
选题：[lujun9972][b]
译者：[geekpi](https://github.com/geekpi)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.2daygeek.com/author/magesh/
[b]: https://github.com/lujun9972
[1]: https://www.2daygeek.com/drivesync-google-drive-sync-client-for-linux/
[2]: https://www.2daygeek.com/mount-access-google-drive-on-linux-with-google-drive-ocamlfuse-client/
[2]: https://linux.cn/article-10517-1.html
[3]: https://www.2daygeek.com/mount-access-setup-google-drive-in-linux/
[4]: data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7
[5]: https://www.2daygeek.com/wp-content/uploads/2019/01/odrive-open-drive-google-drive-gui-client-for-linux-1.png

55
translated/tech/20190214 Run Particular Commands Without Sudo Password In Linux.md → published/20190214 Run Particular Commands Without Sudo Password In Linux.md
View File

@ -1,8 +1,8 @@
[#]: collector: (lujun9972)
[#]: translator: (FSSlc)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-10641-1.html)
[#]: subject: (Run Particular Commands Without Sudo Password In Linux)
[#]: via: (https://www.ostechnix.com/run-particular-commands-without-sudo-password-linux/)
[#]: author: (SK https://www.ostechnix.com/author/sk/)
@ -10,7 +10,7 @@
在 Linux 中运行特定命令而无需 sudo 密码
======
我有一台部署在 AWS 上的 Ubuntu 系统，在它的里面有一个脚本，这个脚本的原有目的是以一定间隔（准确来说是每隔 1 分钟）去检查某个特定服务是否正在运行，如果这个服务因为某些原因停止了，就自动重启这个服务。 但问题是我需要 sudo 权限来开启这个服务。正如你所知道的那样，当我们以 sudo 用户运行命令时，我们应该提供密码，但我并不想这么做，实际上我想做的是以 sudo 用户的身份运行这个服务但无需提供密码。假如你曾经经历过这样的情形，那么我知道一个简单的方法来做到这点。今天，在这个简短的指南中，我将教你如何在类 Unix 的操作系统中运行特定命令而无需 sudo 密码。
我有一台部署在 AWS 上的 Ubuntu 系统，在它的里面有一个脚本，这个脚本的原有目的是以一定间隔（准确来说是每隔 1 分钟）去检查某个特定服务是否正在运行，如果这个服务因为某些原因停止了，就自动重启这个服务。但问题是我需要 sudo 权限来开启这个服务。正如你所知道的那样，当我们以 sudo 用户运行命令时，我们应该提供密码，但我并不想这么做，实际上我想做的是以 sudo 用户的身份运行这个服务但无需提供密码。假如你曾经经历过这样的情形，那么我知道一个简单的方法来做到这点。今天，在这个简短的指南中，我将教你如何在类 Unix 的操作系统中运行特定命令而无需 sudo 密码。
就让我们看看下面的例子吧。
@ -21,15 +21,15 @@ $ sudo mkdir /ostechnix
![][2]
正如上面的截图中看到的那样，当我在根目录（`/`）中创建一个名为 `ostechnix` 的目录时，我需要提供 sudo 密码。每当我们尝试以 sudo 特权执行一个命令时，我们必须输入密码。而在我的预想中，我不想提供 sudo 密码。下面的内容便是我如何在我的 Linux 机子上运行一个 sudo 命令而无需输入密码的过程。
正如上面的截图中看到的那样，当我在根目录（`/`）中创建一个名为 `ostechnix` 的目录时，我需要提供 sudo 密码。每当我们尝试以 sudo 特权执行一个命令时，我们必须输入密码。而在我的预想中，我不想提供 sudo 密码。下面的内容便是我如何在我的 Linux 机子上运行一个 `sudo` 命令而无需输入密码的过程。
### 在 Linux 中运行特定命令而无需 sudo 密码
基于某些原因，假如你想允许一个用户运行特定命令而无需提供 sudo 密码，则你需要在 **sudoers** 文件中添加上这个命令。
基于某些原因，假如你想允许一个用户运行特定命令而无需提供 sudo 密码，则你需要在 `sudoers` 文件中添加上这个命令。
假如我想让名为 **sk** 的用户去执行 **mkdir** 而无需提供 sudo 密码，下面就让我们看看该如何做到这点。
假如我想让名为 `sk` 的用户去执行 `mkdir` 而无需提供 sudo 密码，下面就让我们看看该如何做到这点。
使用下面的命令来编辑 sudoers 文件：
使用下面的命令来编辑 `sudoers` 文件：
```
$ sudo visudo
@ -43,15 +43,15 @@ sk ALL=NOPASSWD:/bin/mkdir
![][3]
其中 **sk** 是用户名。根据上面一行的内容，用户 **sk** 可以从任意终端执行 `mkdir` 命令而不必输入 sudo 密码。
其中 `sk` 是用户名。根据上面一行的内容，用户 `sk` 可以从任意终端执行 `mkdir` 命令而不必输入 sudo 密码。
你可以用逗号分隔的值来添加额外的命令（例如 **chmod**），正如下面展示的那样。
你可以用逗号分隔的值来添加额外的命令（例如 `chmod`），正如下面展示的那样。
```
sk ALL=NOPASSWD:/bin/mkdir,/bin/chmod
```
保存并关闭这个文件，然后注销（或重启）你的系统。现在以普通用户 `sk` 登录，然后试试使用 sudo 来运行这些命令，看会发生什么。
保存并关闭这个文件，然后注销（或重启）你的系统。现在以普通用户 `sk` 登录，然后试试使用 `sudo` 来运行这些命令，看会发生什么。
```
$ sudo mkdir /dir1
@ -59,11 +59,11 @@ $ sudo mkdir /dir1
![][4]
看到了吗？即便我以 sudo 特权运行 `mkdir` 命令，也不会弹出提示让我输入密码。从现在开始，当用户 **sk** 运行 `mkdir` 时，就不必输入 sudo 密码了。
看到了吗？即便我以 sudo 特权运行 `mkdir` 命令，也不会弹出提示让我输入密码。从现在开始，当用户 `sk` 运行 `mkdir` 时，就不必输入 sudo 密码了。
当运行除了添加到 sudoers 文件之外的命令时，你将被提示输入 sudo 密码。
当运行除了添加到 `sudoers` 文件之外的命令时，你将被提示输入 sudo 密码。
让我们用 sudo 来运行另一个命令。
让我们用 `sudo` 来运行另一个命令。
```
$ sudo apt update
@ -73,16 +73,16 @@ $ sudo apt update
看到了吗？这个命令将提示我输入 sudo 密码。
假如你不想让这个命令提示你输入 sudo 密码，请编辑 sudoers 文件：
假如你不想让这个命令提示你输入 sudo 密码，请编辑 `sudoers` 文件：
```
$ sudo visudo
```
像下面这样将 `apt` 命令添加到 visudo 文件中：
像下面这样将 `apt` 命令添加到 `sudoers` 文件中：
```
sk ALL=NOPASSWD: /bin/mkdir,/usr/bin/apt
sk ALL=NOPASSWD:/bin/mkdir,/usr/bin/apt
```
你注意到了上面命令中 `apt` 二进制执行文件的路径与 `mkdir` 的有所不同吗？是的，你必须提供一个正确的可执行文件路径。要找到任意命令的可执行文件路径，例如这里的 `apt`，可以像下面这样使用 `whichis` 命令来查看：
@ -92,11 +92,11 @@ $ whereis apt
apt: /usr/bin/apt /usr/lib/apt /etc/apt /usr/share/man/man8/apt.8.gz
```
如你所见，`apt` 命令的可执行文件路径为 **/usr/bin/apt**，所以我将这个路径添加到了 sudoers 文件中。
如你所见，`apt` 命令的可执行文件路径为 `/usr/bin/apt`，所以我将这个路径添加到了 `sudoers` 文件中。
正如我前面提及的那样，你可以添加任意多个以逗号分隔的命令。一旦你做完添加的动作，保存并关闭你的 sudoers 文件，接着注销，然后重新登录进你的系统。
正如我前面提及的那样，你可以添加任意多个以逗号分隔的命令。一旦你做完添加的动作，保存并关闭你的 `sudoers` 文件，接着注销，然后重新登录进你的系统。
现在就检验你是否可以直接运行以 sudo 开头的命令而不必使用密码：
现在就检验你是否可以直接运行以 `sudo` 开头的命令而不必使用密码：
```
$ sudo apt update
@ -104,9 +104,9 @@ $ sudo apt update
![][6]
看到了吗？`apt` 命令没有让我输入 sudo 密码，即便我用 sudo 来运行它。
看到了吗？`apt` 命令没有让我输入 sudo 密码，即便我用 `sudo` 来运行它。
下面展示另一个例子。假如你想运行一个特定服务，例如 `apache2`，那么就添加下面这条命令到 sudoers 文件中：
下面展示另一个例子。假如你想运行一个特定服务，例如 `apache2`，那么就添加下面这条命令到 `sudoers` 文件中：
```
sk ALL=NOPASSWD:/bin/mkdir,/usr/bin/apt,/bin/systemctl restart apache2
@ -116,24 +116,23 @@ sk ALL=NOPASSWD:/bin/mkdir,/usr/bin/apt,/bin/systemctl restart apache2
我可以再次让一个特别的命令提醒输入 sudo 密码吗？当然可以！只需要删除添加的命令，注销然后再次登录即可。
除了这种方法外，你还可以在命令的前面添加 **`PASSWD:`** 指令。让我们看看下面的例子：
除了这种方法外，你还可以在命令的前面添加 `PASSWD:` 指令。让我们看看下面的例子：
在 sudoers 文件中添加或者修改下面的一行：
在 `sudoers` 文件中添加或者修改下面的一行：
```
sk ALL=NOPASSWD:/bin/mkdir,/bin/chmod,PASSWD:/usr/bin/apt
```
在这种情况下，用户 **sk** 可以运行 `mkdir` 和 `chmod` 命令而不用输入 sudo 密码。然而，当他运行 `apt` 命令时，就必须提供 sudo 密码了。
在这种情况下，用户 `sk` 可以运行 `mkdir` 和 `chmod` 命令而不用输入 sudo 密码。然而，当他运行 `apt` 命令时，就必须提供 sudo 密码了。
**免责声明：** 本篇指南仅具有教育意义。在使用这个方法的时候，你必须非常小心。这个命令既可能富有成效但也可能带来摧毁性效果。例如，假如你允许用户执行 `rm` 命令而不输入 sudo 密码，那么他们可能无意或有意地删除某些重要文件。我警告过你了！
免责声明：本篇指南仅具有教育意义。在使用这个方法的时候，你必须非常小心。这个命令既可能富有成效但也可能带来摧毁性效果。例如，假如你允许用户执行 `rm` 命令而不输入 sudo 密码，那么他们可能无意或有意地删除某些重要文件。我警告过你了！
那么这就是全部的内容了。希望这个能够给你带来帮助。更多精彩内容即将呈现，请保持关注！
干杯！
--------------------------------------------------------------------------------
via: https://www.ostechnix.com/run-particular-commands-without-sudo-password-linux/
@ -141,7 +140,7 @@ via: https://www.ostechnix.com/run-particular-commands-without-sudo-password-lin
作者：[SK][a]
选题：[lujun9972][b]
译者：[FSSlc](https://github.com/FSSlc)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

78
translated/tech/20190218 SPEED TEST- x86 vs. ARM for Web Crawling in Python.md → published/20190218 SPEED TEST- x86 vs. ARM for Web Crawling in Python.md
View File

@ -1,8 +1,8 @@
[#]: collector: (lujun9972)
[#]: translator: (HankChow)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-10640-1.html)
[#]: subject: (SPEED TEST: x86 vs. ARM for Web Crawling in Python)
[#]: via: (https://blog.dxmtechsupport.com.au/speed-test-x86-vs-arm-for-web-crawling-in-python/)
[#]: author: (James Mawson https://blog.dxmtechsupport.com.au/author/james-mawson/)
@ -12,7 +12,7 @@ x86 和 ARM 的 Python 爬虫速度对比
![][1]
如果你的老板给你的任务是不断地访问竞争对手的网站，把对方商品的价格记录下来，而且要纯手工操作，恐怕你会想要把整个办公室都烧掉。
假如说，如果你的老板给你的任务是一次又一次地访问竞争对手的网站，把对方商品的价格记录下来，而且要纯手工操作，恐怕你会想要把整个办公室都烧掉。
之所以现在网络爬虫的影响力如此巨大，就是因为网络爬虫可以被用于追踪客户的情绪和趋向、搜寻空缺的职位、监控房地产的交易，甚至是获取 UFC 的比赛结果。除此以外，还有很多意想不到的用途。
@ -32,21 +32,21 @@ x86 和 ARM 的 Python 爬虫速度对比
ARM 是目前世界上最流行的 CPU 架构。
但 ARM 架构处理器在很多人眼中的地位只是作为一个节省成本的选择，而不是跑在生产环境中的处理器的首选。
但 ARM 架构处理器在很多人眼中的地位只是作为一个省钱又省电的选择，而不是跑在生产环境中的处理器的首选。
然而，诞生于英国剑桥的 ARM CPU，最初是用于昂贵的 [Acorn Archimedes][4] 计算机上的，这是当时世界上最强大的计算机，它的运算速度甚至比最快的 386 还要快好几倍。
然而，诞生于英国剑桥的 ARM CPU，最初是用于极其昂贵的 [Acorn Archimedes][4] 计算机上的，这是当时世界上最强大的桌面计算机，甚至在很长一段时间内，它的运算速度甚至比最快的 386 还要快好几倍。
Acorn 公司和 Commodore、Atari 的理念类似，他们认为一家伟大的计算机公司就应该制造出伟大的计算机，让人感觉有点目光短浅。而比尔盖茨的想法则有所不同，他力图在更多不同种类和价格的 x86 机器上使用他的 DOS 系统。
拥有大量用户基础的平台会让更多开发者开发出众多适应平台的软件，而软件资源丰富又让计算机更受用户欢迎。
拥有大量用户基数的平台会成为第三方开发者开发软件的平台，而软件资源丰富又会让你的计算机更受用户欢迎。
即使是苹果公司也在这上面吃到了苦头，不得不在 x86 芯片上投入大量的财力。最终，这些芯片不再仅仅用于专业的计算任务，走进了人们的日常生活中。
即使是苹果公司也几乎被打败。在 x86 芯片上投入大量的财力，最终，这些芯片被用于生产环境计算任务。
ARM 架构也并没有消失。基于 ARM 架构的芯片不仅运算速度快，同时也非常节能。因此诸如机顶盒、PDA、数码相机、MP3 播放器这些电子产品多数都会采用 ARM 架构的芯片，甚至在很多需要用电池、不配备大散热风扇的电子产品上，都可以见到 ARM 芯片的身影。
但 ARM 架构也并没有消失。基于 ARM 架构的芯片不仅运算速度快，同时也非常节能。因此诸如机顶盒、PDA、数码相机、MP3 播放器这些电子产品多数都会采用 ARM 架构的芯片，甚至在很多需要用电池或不配备大散热风扇的电子产品上，都可以见到 ARM 芯片的身影。
而 ARM 则脱离 Acorn 成为了一种独立的商业模式，他们不生产实物芯片，仅仅是向芯片生产厂商出售相关的知识产权。
而 ARM 则脱离 Acorn 成为了一种特殊的商业模式，他们不生产实物芯片，仅仅是向芯片生产厂商出售相关的知识产权。
因此，ARM 芯片被应用于很多手机和平板电脑上。当 Linux 被移植到这种架构的芯片上时，开源技术的大门就已经向它打开了，这才让我们今天得以在这些芯片上运行 web 爬虫程序。
因此，这或多或少是 ARM 芯片被应用于如此之多的手机和平板电脑上的原因。当 Linux 被移植到这种架构的芯片上时，开源技术的大门就已经向它打开了，这才让我们今天得以在这些芯片上运行 web 爬虫程序。
#### 服务器端的 ARM
@ -64,11 +64,11 @@ ARM 架构也并没有消失。基于 ARM 架构的芯片不仅运算速度快
#### Scaleway
Scaleway 自身的定位是“专为开发者设计”。我觉得这个定位很准确，对于开发原型来说，Scaleway 提供的产品确实可以作为一个很好的沙盒环境。
Scaleway 自身的定位是“专为开发者设计”。我觉得这个定位很准确，对于开发和原型设计来说，Scaleway 提供的产品确实可以作为一个很好的沙盒环境。
Scaleway 提供了一个简洁的页面，让用户可以快速地从主页进入 bash shell 界面。对于很多小企业、自由职业者或者技术顾问，如果想要运行 web 爬虫，这个产品毫无疑问是一个物美价廉的选择。
Scaleway 提供了一个简洁的仪表盘页面，让用户可以快速地从主页进入 bash shell 界面。对于很多小企业、自由职业者或者技术顾问，如果想要运行 web 爬虫，这个产品毫无疑问是一个物美价廉的选择。
ARM 方面我们选择 [ARM64-2GB][10] 这一款服务器，每月只需要 3 欧元。它带有 4 个 Cavium ThunderX 核心，是在 2014 年推出的第一款服务器级的 ARMv8 处理器。但现在看来它已经显得有点落后了，并逐渐被更新的 ThunderX2 取代。
ARM 方面我们选择 [ARM64-2GB][10] 这一款服务器，每月只需要 3 欧元。它带有 4 个 Cavium ThunderX 核心，这是在 2014 年推出的第一款服务器级的 ARMv8 处理器。但现在看来它已经显得有点落后了，并逐渐被更新的 ThunderX2 取代。
x86 方面我们选择 [1-S][11]，每月的费用是 4 欧元。它拥有 2 个英特尔 Atom C3995 核心。英特尔的 Atom 系列处理器的特点是低功耗、单线程，最初是用在笔记本电脑上的，后来也被服务器所采用。
@ -76,43 +76,45 @@ x86 方面我们选择 [1-S][11]，每月的费用是 4 欧元。它拥有 2 个
为了避免我不能熟练使用包管理器的尴尬局面，两方的操作系统我都会选择使用 Debian 9。
#### Amazon Web Services
#### Amazon Web Services（AWS）
当你还在注册 AWS 账号的时候，使用 Scaleway 的用户可能已经把提交信用卡信息、启动 VPS 实例、添加sudoer、安装依赖包这一系列流程都完成了。AWS 的操作相对来说比较繁琐，甚至需要详细阅读手册才能知道你正在做什么。
当你还在注册 AWS 账号的时候，使用 Scaleway 的用户可能已经把提交信用卡信息、启动 VPS 实例、添加 sudo 用户、安装依赖包这一系列流程都完成了。AWS 的操作相对来说比较繁琐，甚至需要详细阅读手册才能知道你正在做什么。
当然这也是合理的，对于一些需求复杂或者特殊的企业用户，确实需要通过详细的配置来定制合适的使用方案。
我们所采用的 AWS Graviton 处理器是 AWS EC2（Elastic Compute Cloud）的一部分，我会以按需实例的方式来运行，这也是最贵但最简捷的方式。AWS 同时也提供[竞价实例][12]，这样可以用较低的价格运行实例，但实例的运行时间并不固定。如果实例需要长时间持续运行，还可以选择[预留实例][13]。
我们所采用的 AWS Graviton 处理器是 AWS EC2（<ruby>弹性计算云<rt>Elastic Compute Cloud</rt></ruby>）的一部分，我会以按需实例的方式来运行，这也是最贵但最简捷的方式。AWS 同时也提供[竞价实例][12]，这样可以用较低的价格运行实例，但实例的运行时间并不固定。如果实例需要长时间持续运行，还可以选择[预留实例][13]。
看，AWS 就是这么复杂……
我们分别选择 [a1.medium][14] 和 [t2.small][15] 两种型号的实例进行对比，两者都带有 2GB 内存。这个时候问题来了，手册中提到的 vCPU 又是什么？两种型号的不同之处就在于此。
我们分别选择 [a1.medium][14] 和 [t2.small][15] 两种型号的实例进行对比，两者都带有 2GB 内存。这个时候问题来了，这里提到的 vCPU 又是什么？两种型号的不同之处就在于此。
对于 a1.medium 型号的实例，vCPU 是 AWS Graviton 芯片提供的单个计算核心。这个芯片由被亚马逊在 2015 收购的以色列厂商 Annapurna Labs 研发，是 AWS 独有的单线程 64 位 ARMv8 内核。它的按需价格为每小时 0.0255 美元。
而 t2.small 型号实例使用英特尔至强系列芯片，但我不确定具体是其中的哪一款。它每个核心有两个线程，但我们并不能用到整个核心，甚至整个线程。我们能用到的只是“20% 的基准性能，可以使用 CPU 积分突破这个基准”。这可能有一定的原因，但我没有弄懂。它的按需价格是每小时 0.023 美元。
而 t2.small 型号实例使用英特尔至强系列芯片，但我不确定具体是其中的哪一款。它每个核心有两个线程，但我们并不能用到整个核心，甚至整个线程。
我们能用到的只是“20% 的基准性能，可以使用 CPU 积分突破这个基准”。这可能有一定的原因，但我没有弄懂。它的按需价格是每小时 0.023 美元。
在镜像库中没有 Debian 发行版的镜像，因此我选择了 Ubuntu 18.04。
### Beavis and Butthead Do Moz’s Top 500
### 瘪四与大头蛋爬取 Moz 排行榜前 500 的网站
要测试这些 VPS 的 CPU 性能，就该使用爬虫了。一般来说都是对几个网站在尽可能短的时间里发出尽可能多的请求，但这种操作太暴力了，我的做法是只向大量网站发出少数几个请求。
要测试这些 VPS 的 CPU 性能，就该使用爬虫了。一个方法是对几个网站在尽可能短的时间里发出尽可能多的请求，但这种操作不太礼貌，我的做法是只向大量网站发出少数几个请求。
为此，我编写了 `beavs.py` 这个爬虫程序（致敬我最喜欢的物理学家和制片人 Mike Judge）。这个程序会将 Moz 上排行前 500 的网站都爬取 3 层的深度，并计算 “wood” 和 “ass” 这两个单词在 HTML 文件中出现的次数。
为此，我编写了 `beavis.py`（瘪四）这个爬虫程序（致敬我最喜欢的物理学家和制片人 Mike Judge）。这个程序会将 Moz 上排行前 500 的网站都爬取 3 层的深度，并计算 “wood” 和 “ass” 这两个单词在 HTML 文件中出现的次数。（LCTT 译注：beavis（瘪四）和 butt-head（大头蛋） 都是 Mike Judge 的动画片《瘪四与大头蛋》中的角色）
但我实际爬取的网站可能不足 500 个，因为我需要遵循网站的 `robot.txt` 协定，另外还有些网站需要提交 javascript 请求，也不一定会计算在内。但这已经是一个足以让 CPU 保持繁忙的爬虫任务了。
Python 的[全局解释器锁][16]机制会让我的程序只能用到一个 CPU 线程。为了测试多线程的性能，我需要启动多个独立的爬虫程序进程。
因此我还编写了 `butthead.py`，尽管 Butthead 很粗鲁，它也比 Beavis 要略胜一筹（译者注：beavis 和 butt-head 都是 Mike Judge 的动画片《Beavis and Butt-head》中的角色）。
因此我还编写了 `butthead.py`，尽管大头蛋很粗鲁，它也总是比瘪四要略胜一筹。
我将整个爬虫任务拆分为多个部分，这可能会对爬取到的链接数量有一点轻微的影响。但无论如何，每次爬取都会有所不同，我们要关注的是爬取了多少个页面，以及耗时多长。
### 在 ARM 服务器上安装 Scrapy
安装 Scrapy 的过程与芯片的不同架构没有太大的关系，都是安装 pip 和相关的依赖包之后，再使用 pip 来安装Scrapy。
安装 Scrapy 的过程与芯片的不同架构没有太大的关系，都是安装 `pip` 和相关的依赖包之后，再使用 `pip` 来安装 Scrapy。
据我观察，在使用 ARM 的机器上使用 pip 安装 Scrapy 确实耗时要长一点，我估计是由于需要从源码编译为二进制文件。
据我观察，在使用 ARM 的机器上使用 `pip` 安装 Scrapy 确实耗时要长一点，我估计是由于需要从源码编译为二进制文件。
在 Scrapy 安装结束后，就可以通过 shell 来查看它的工作状态了。
@ -143,7 +145,7 @@ Scrapy 的官方文档建议[将爬虫程序的 CPU 使用率控制在 80% 到 9
我使用了 [top][18] 工具来查看爬虫程序运行期间的 CPU 使用率。在任务刚开始的时候，两者的 CPU 使用率都达到了 100%，但 ThunderX 大部分时间都达到了 CPU 的极限，无法看出来 Atom 的性能会比 ThunderX 超出多少。
通过 top 工具，我还观察了它们的内存使用情况。随着爬取任务的进行，ARM 机器的内存使用率最终达到了 14.7%，而 x86 则最终是 15%。
通过 `top` 工具，我还观察了它们的内存使用情况。随着爬取任务的进行，ARM 机器的内存使用率最终达到了 14.7%，而 x86 则最终是 15%。
从运行日志还可以看出来，当 CPU 使用率到达极限时，会有大量的超时页面产生，最终导致页面丢失。这也是合理出现的现象，因为 CPU 过于繁忙会无法完整地记录所有爬取到的页面。
@ -156,19 +158,19 @@ Scrapy 的官方文档建议[将爬虫程序的 CPU 使用率控制在 80% 到 9
| a1.medium | 100m 39.900s | 41,294 | 24,612.725 | 1.03605 |
| t2.small | 78m 53.171s | 41,200 | 31,336.286 | 0.73397 |
为了方便比较，对于在 AWS 上跑的爬虫，我记录的指标和 Scaleway 上一致，但似乎没有达到预期的效果。这里我没有使用 top，而是使用了 AWS 提供的控制台来监控 CPU 的使用情况，从监控结果来看，我的爬虫程序并没有完全用到这两款服务器所提供的所有性能。
为了方便比较，对于在 AWS 上跑的爬虫，我记录的指标和 Scaleway 上一致，但似乎没有达到预期的效果。这里我没有使用 `top`，而是使用了 AWS 提供的控制台来监控 CPU 的使用情况，从监控结果来看，我的爬虫程序并没有完全用到这两款服务器所提供的所有性能。
a1.medium 型号的机器尤为如此，在任务开始阶段，它的 CPU 使用率达到了峰值 45%，但随后一直在 20% 到 30% 之间。
让我有点感到意外的是，这个程序在 ARM 处理器上的运行速度相当慢，但却远未达到 Graviton CPU 能力的极限，而在 Inter 处理器上则可以在某些时候达到 CPU 能力的极限。它们运行的代码是完全相同的，处理器的不同架构可能导致了对代码的不同处理方式。
让我有点感到意外的是，这个程序在 ARM 处理器上的运行速度相当慢，但却远未达到 Graviton CPU 能力的极限，而在 Intel Atom 处理器上则可以在某些时候达到 CPU 能力的极限。它们运行的代码是完全相同的，处理器的不同架构可能导致了对代码的不同处理方式。
个中原因无论是由于处理器本身的特性，还是而今是文件的编译，又或者是两者皆有，对我来说都是一个黑盒般的存在。我认为，既然在 AWS 机器上没有达到 CPU 处理能力的极限，那么只有在 Scaleway 机器上跑出来的性能数据是可以作为参考的。
个中原因无论是由于处理器本身的特性，还是二进制文件的编译，又或者是两者皆有，对我来说都是一个黑盒般的存在。我认为，既然在 AWS 机器上没有达到 CPU 处理能力的极限，那么只有在 Scaleway 机器上跑出来的性能数据是可以作为参考的。
t2.small 型号的机器性能让人费解。CPU 利用率大概 20%，最高才达到 35%，是因为手册中说的“20% 的基准性能，可以使用 CPU 积分突破这个基准”吗？但在控制台中可以看到 CPU 积分并没有被消耗。
为了确认这一点，我安装了 [stress][19] 这个软件，然后运行了一段时间，这个时候发现居然可以把 CPU 使用率提高到 100% 了。
显然，我需要调整一下它们的配置文件。我将 CONCURRENT_REQUESTS 参数设置为 5000，将 REACTOR_THREADPOOL_MAXSIZE 参数设置为 120，将爬虫任务的负载调得更大。
显然，我需要调整一下它们的配置文件。我将 `CONCURRENT_REQUESTS` 参数设置为 5000，将 `REACTOR_THREADPOOL_MAXSIZE` 参数设置为 120，将爬虫任务的负载调得更大。
| 机器种类 | 耗时 | 爬取页面数 | 每小时爬取页面数 | 每万页面费用（美元） |
| ----------------------- | ----------- | ---------- | ---------------- | -------------------- |
@ -182,7 +184,7 @@ a1.medium 型号机器的 CPU 使用率在爬虫任务开始后 5 分钟飙升
现在我们看到它们的性能都差不多了。但至强处理器的线程持续跑满了 CPU，Graviton 处理器则只是有一段时间如此。可以认为 Graviton 略胜一筹。
然而，如果 CPU 积分耗尽了呢？这种情况下的对比可能更为公平。为了测试这种情况，我使用 stress 把所有的 CPU 积分用完，然后再次启动了爬虫任务。
然而，如果 CPU 积分耗尽了呢？这种情况下的对比可能更为公平。为了测试这种情况，我使用 `stress` 把所有的 CPU 积分用完，然后再次启动了爬虫任务。
在没有 CPU 积分的情况下，CPU 使用率在 27% 就到达极限不再上升了，同时又出现了丢失页面的现象。这么看来，它的性能比负载较低的时候更差。
@ -190,7 +192,7 @@ a1.medium 型号机器的 CPU 使用率在爬虫任务开始后 5 分钟飙升
将爬虫任务分散到不同的进程中，可以有效利用机器所提供的多个核心。
一开始，我将爬虫任务分布在 10 个不同的进程中并同时启动，结果发现比仅使用 1 个进程的时候还要慢。
一开始，我将爬虫任务分布在 10 个不同的进程中并同时启动，结果发现比每个核心仅使用 1 个进程的时候还要慢。
经过尝试，我得到了一个比较好的方案。把爬虫任务分布在 10 个进程中，但每个核心只启动 1 个进程，在每个进程接近结束的时候，再从剩余的进程中选出 1 个进程启动起来。
@ -198,7 +200,7 @@ a1.medium 型号机器的 CPU 使用率在爬虫任务开始后 5 分钟飙升
想要预估某个域名的页面量，一定程度上可以参考这个域名主页的链接数量。我用另一个程序来对这个数量进行了统计，然后按照降序排序。经过这样的预处理之后，只会额外增加 1 分钟左右的时间。
结果，爬虫运行的总耗时找过了两个小时！毕竟把链接最多的域名都堆在同一个进程中也存在一定的弊端。
结果，爬虫运行的总耗时超过了两个小时！毕竟把链接最多的域名都堆在同一个进程中也存在一定的弊端。
针对这个问题，也可以通过调整各个进程爬取的域名数量来进行优化，又或者在排序之后再作一定的修改。不过这种优化可能有点复杂了。
@ -225,7 +227,9 @@ a1.medium 型号机器的 CPU 使用率在爬虫任务开始后 5 分钟飙升
### 结论
从上面的数据来看，不同架构的 CPU 性能和它们的问世时间没有直接的联系，AWS Graviton 是单线程情况下性能最佳的。
从上面的数据来看，对于性能而言，CPU 的架构并没有它们的问世时间重要，2018 年生产的 AWS Graviton 是单线程情况下性能最佳的。
你当然可以说按核心来比，Xeon 仍然赢了。但是，你不但需要计算美元的变化，甚至还要计算线程数。
另外在性能方面 2017 年生产的 Atom 轻松击败了 2014 年生产的 ThunderX，而 ThunderX 则在性价比方面占优。当然，如果你使用 AWS 的机器的话，还是使用 Graviton 吧。
@ -243,7 +247,7 @@ a1.medium 型号机器的 CPU 使用率在爬虫任务开始后 5 分钟飙升
要运行这些代码，需要预先安装 Scrapy，并且需要 [Moz 上排名前 500 的网站][21]的 csv 文件。如果要运行 `butthead.py`，还需要安装 [psutil][22] 这个库。
##### beavis.py
*beavis.py*
```
import scrapy
@ -347,7 +351,7 @@ if __name__ == '__main__':
print('Uh huhuhuhuh. It said wood ' + str(wood) + ' times.')
```
##### butthead.py
*butthead.py*
```
import scrapy, time, psutil
@ -494,7 +498,7 @@ via: https://blog.dxmtechsupport.com.au/speed-test-x86-vs-arm-for-web-crawling-i
作者：[James Mawson][a]
选题：[lujun9972][b]
译者：[HankChow](https://github.com/HankChow)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

70
published/20190303 How to boot up a new Raspberry Pi.md Normal file
View File

@ -0,0 +1,70 @@
[#]: collector: (lujun9972)
[#]: translator: (qhwdw)
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-10644-1.html)
[#]: subject: (How to boot up a new Raspberry Pi)
[#]: via: (https://opensource.com/article/19/3/how-boot-new-raspberry-pi)
[#]: author: (Anderson Silva https://opensource.com/users/ansilva)
树莓派使用入门：如何启动一个新的树莓派
======
> 在本系列文章的第三篇中，我们将教你开始使用树莓派，学习如何安装一个 Linux 操作系统。
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/programming_code_keyboard_orange_hands.png?itok=G6tJ_64Y)
如果你按顺序看我们本系列的文章，那么你已经 [选择][1] 和 [购买][2] 了你的树莓派和外围设备，现在，你将要去使用它。在第三篇文章中，我们来看一下你需要做些什么才能让它启动起来。
与你的笔记本、台式机、智能手机、或平板电脑不一样的是，树莓派上并没有内置存储。而是需要使用一个 Micro SD 卡去存储操作系统和文件。这么做的最大好处就是携带你的文件比较方便（甚至都不用带着树莓派）。不利之处是存储卡丢失和损坏的风险可能很高，这将导致你的文件丢失。因此，只要保护好你的 Micro SD 卡就没什么问题了。
你应该也知道，SD 卡的读写速度比起机械硬件或固态硬盘要慢很多，因此，你的树莓派的启动、读取、和写入的速度将不如其它设备。
### 如何安装 Raspbian
你拿到新树莓派的第一件事情就是将它的操作系统安装到一个 Micro SD 卡上。尽管树莓派上可用的操作系统很多（基于 Linux 的或非基于 Linux 的都有），但本系列课程将专注于 [Raspbian][3]，它是树莓派的官方 Linux 版本。
![](https://opensource.com/sites/default/files/uploads/raspbian.png)
安装 Raspbian 的最简单的方式是使用 [NOOBS][4]，它是 “New Out Of Box Software” 的缩写。树莓派官方提供了非常详细的 [NOOBS 文档][5]，因此，我就不在这里重复这些安装指令了。
NOOBS 可以让你选择安装以下的这些操作系统：
+ [Raspbian][6]
+ [LibreELEC][7]
+ [OSMC][8]
+ [Recalbox][9]
+ [Lakka][10]
+ [RISC OS][11]
+ [Screenly OSE][12]
+ [Windows 10 IoT Core][13]
+ [TLXOS][14]
再强调一次，我们在本系列的课程中使用的是 Raspbian，因此，拿起你的 Micro SD 卡，然后按照 NOOBS 文档去安装 Raspbian 吧。在本系列的第四篇文章中，我们将带你去看看，如何使用 Linux，包括你需要掌握的一些主要的命令。
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/3/how-boot-new-raspberry-pi
作者：[Anderson Silva][a]
选题：[lujun9972][b]
译者：[qhwdw](https://github.com/qhwdw)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/ansilva
[b]: https://github.com/lujun9972
[1]: https://linux.cn/article-10611-1.html
[2]: https://linux.cn/article-10615-1.html
[3]: https://www.raspbian.org/RaspbianFAQ
[4]: https://www.raspberrypi.org/downloads/noobs/
[5]: https://www.raspberrypi.org/documentation/installation/noobs.md
[6]: https://www.raspbian.org/RaspbianFAQ
[7]: https://libreelec.tv/
[8]: https://osmc.tv/
[9]: https://www.recalbox.com/
[10]: http://www.lakka.tv/
[11]: https://www.riscosopen.org/wiki/documentation/show/Welcome%20to%20RISC%20OS%20Pi
[12]: https://www.screenly.io/ose/
[13]: https://developer.microsoft.com/en-us/windows/iot
[14]: https://thinlinx.com/

148
sources/talk/20190319 6 steps to stop ethical debt in AI product development.md Normal file
View File

@ -0,0 +1,148 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (6 steps to stop ethical debt in AI product development)
[#]: via: (https://opensource.com/article/19/3/ethical-debt-ai-product-development)
[#]: author: (Lauren Maffeo https://opensource.com/users/lmaffeo)
6 steps to stop ethical debt in AI product development
======
Machine bias in artificial intelligence is a known and unavoidable problem—but it is not unmanageable.
![old school calculator][1]
It's official: artificial intelligence (AI) isn't the unbiased genius we want it to be.
Alphabet (Google's parent company) used its latest annual report [to warn][2] that ethical concerns about its products might hurt future revenue. Entrepreneur Joy Buolamwini established the [Safe Face Pledge][3] to prevent abuse of facial analysis technology.
And years after St. George's Hospital Medical School in London was found to have used AI that inadvertently [screened out qualified female candidates][4], Amazon scrapped a recruiting tool last fall after machine learning (ML) specialists found it [doing the same thing][5].
We've learned the hard way that technologies built with AI are biased like people. Left unchecked, the datasets used to train such products can pose [life-or-death consequences][6] for their end users.
For example, imagine a self-driving car that can't recognize commands from people with certain accents. If the dataset used to train the technology powering that car isn't exposed to enough voice variations and inflections, it risks not recognizing all its users as fully human.
Here's the good news: Machine bias in AI is unavoidable—but it is _not_ unmanageable. Just like product and development teams work to reduce technical debt, you can [reduce the risk of ethical debt][7] as well.
Here are six steps that your technical team can start taking today:
### 1\. Document your priorities upfront
Reducing ethical debt within your product will require you to answer two key questions in the product specification phase:
* Which methods of fairness will you use?
* How will you prioritize them?
If your team is building a product based on ML, it's not enough to reactively fix bugs or pull products from shelves. Instead, answer these questions [in your tech spec][8] so that they're included from the start of your product lifecycle.
### 2\. Train your data under fairness constraints
This step is tough because when you try to control or eliminate both direct and indirect bias, you'll find yourself in a Catch-22.
If you train exclusively on non-sensitive attributes, you eliminate direct discrimination but introduce or reinforce indirect bias.
However, if you train separate classifiers for each sensitive feature, you reintroduce direct discrimination.
Another challenge is that detection can occur only after you've trained your model. When this occurs, the only recourse is to scrap the model and retrain it from scratch.
To reduce these risks, don't just measure average strengths of acceptance and rejection across sensitive groups. Instead, use limits to determine what is or isn't included in the model you're training. When you do this, discrimination tests are expressed as restrictions and limitations on the learning process.
### 3\. Monitor your datasets throughout the product lifecycle
Developers build training sets based on data they hope the model will encounter. But many don't monitor the data their creations receive from the real world.
ML products are unique in that they're continuously taking in data. New data allows the algorithms powering these products to keep refining their results.
But such products often encounter data in deployment that differs from what they were trained on in production. It's also not uncommon for the algorithm to be updated without the model itself being revalidated.
This risk will decrease if you appoint someone to monitor the source, history, and context of the data in your algorithm. This person should conduct continuous audits to find unacceptable behavior.
Bias should be reduced as much as possible while maintaining an acceptable level of accuracy, as defined in the product specification. If unacceptable biases or behaviors are detected, the model should be rolled back to an earlier state prior to the first time you saw bias.
### 4\. Use tagged training data
We live in a world with trillions of images and videos at our fingertips, but most neural networks can't use this data for one reason: Most of it isn't tagged.
Tagging refers to which classes are present in an image and their locations. When you tag an image, you share which classes are present and where they're located.
This sounds simple—until you realize how much work it would take to draw shapes around every single person in a photo of a crowd or a box around every single person on a highway.
Even if you succeeded, you might rush your tagging and draw your shapes sloppily, leading to a poorly trained neural network.
The good news is that more products are coming to market so they can decrease the time and cost of tagging.
As one example, [Brain Builder][9] is a data annotation product from Neurala that uses open source frameworks like TensorFlow and Caffe. Its goal is to help users [manage and annotate their training data][10]. It also aims to bring diverse class examples to datasets—another key step in data training.
### 5\. Use diverse class examples
Training data needs positive and negative examples of classes. If you want specific classes of objects, you need negative examples as well. This (hopefully) mimics the data that the algorithm will encounter in the wild.
Consider the example of “homes” within a dataset. If the algorithm contains only images of homes in North America, it won't know to recognize homes in Japan, Morocco, or other international locations. Its concept of a “home” is thus limited.
Neurala warns, "Most AI applications require thousands of images to be tagged, and since data tagging cost is proportional to the time spent tagging, this step alone often costs tens to hundreds of thousands of dollars per project."
Luckily, 2018 saw a strong increase in the number of open source AI datasets. Synced has a helpful [roundup of 10 datasets][11]—from multi-label images to semantic parsing—that were open sourced last year. If you're looking for datasets by industry, GitHub [has a longer list][12].
### 6\. Focus on the subject, not the context
Tech leaders in monitoring ML datasets should aim to understand how the algorithm classifies data. That's because AI sometimes focuses on irrelevant attributes that are shared by several targets in the training set.
Let's start by looking at the biased training set below. Wolves were tagged standing in snow, but the model wasn't shown images of dogs. So, when dogs were introduced, the model started tagging them as wolves because both animals were standing in snow. In this case, the AI put too much emphasis on the context (a snowy backdrop).
![Wolves in snow][13]
Source: [Gartner][14] (full research available for clients)
By contrast, here is a training set from Brain Builder that is focused on the subject dogs. When monitoring your own training set, make sure the AI is giving more weight to the subject of each image. If you saw an image classifier state that one of the dogs below is a wolf, you would need to know which aspects of the input led to this misclassification. This is a sign to check your training set and confirm that the data is accurate.
![Dogs training set][15]
Source: [Brain Builder][16]
Reducing ethical debt isn't just the “right thing to do”—it also reduces _technical_ debt. Since programmatic bias is so tough to detect, working to reduce it, from the start of your lifecycle, will save you the need to retrain models from scratch.
This isn't an easy or perfect job; tech teams will have to make tradeoffs between fairness and accuracy. But this is the essence of product management: compromises based on what's best for the product and its end users.
Strategy is the soul of all strong products. If your team includes measures of fairness and algorithmic priorities from the start, you'll sail ahead of your competition.
* * *
_Lauren Maffeo will present_ [_Erase Unconscious Bias From Your AI Datasets_][17] _at[DrupalCon][18] in Seattle, April 8-12, 2019._
* * *
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/3/ethical-debt-ai-product-development
作者：[Lauren Maffeo][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/lmaffeo
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/math_money_financial_calculator_colors.jpg?itok=_yEVTST1 (old school calculator)
[2]: https://www.yahoo.com/news/google-warns-rise-ai-may-181710642.html?soc_src=mail&soc_trk=ma
[3]: https://www.safefacepledge.org/
[4]: https://futurism.com/ai-bias-black-box
[5]: https://uk.reuters.com/article/us-amazon-com-jobs-automation-insight/amazon-scraps-secret-ai-recruiting-tool-that-showed-bias-against-women-idUKKCN1MK08G
[6]: https://opensource.com/article/18/10/open-source-classifiers-ai-algorithms
[7]: https://thenewstack.io/tech-ethics-new-years-resolution-dont-build-software-you-will-regret/
[8]: https://eng.lyft.com/awesome-tech-specs-86eea8e45bb9
[9]: https://www.neurala.com/tech
[10]: https://www.roboticsbusinessreview.com/ai/brain-builder-neurala-video-annotation/
[11]: https://medium.com/syncedreview/2018-in-review-10-open-sourced-ai-datasets-696b3b49801f
[12]: https://github.com/awesomedata/awesome-public-datasets
[13]: https://opensource.com/sites/default/files/uploads/wolves_in_snow.png (Wolves in snow)
[14]: https://www.gartner.com/doc/3889586/control-bias-eliminate-blind-spots
[15]: https://opensource.com/sites/default/files/uploads/ai_ml_canine_recognition.png (Dogs training set)
[16]: https://www.neurala.com/
[17]: https://events.drupal.org/seattle2019/sessions/erase-unconscious-bias-your-ai-datasets
[18]: https://events.drupal.org/seattle2019

3
sources/tech/20170710 iWant - The Decentralized Peer To Peer File Sharing Commandline Application.md
View File

@ -1,3 +1,6 @@
Translating by MjSeven
iWant – The Decentralized Peer To Peer File Sharing Commandline Application
======

242
sources/tech/20180329 Python ChatOps libraries- Opsdroid and Errbot.md
View File

@ -1,242 +0,0 @@
tomjlw is translating
Python ChatOps libraries: Opsdroid and Errbot
======
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/idea_innovation_mobile_phone.png?itok=RqVtvxkd)
This article was co-written with [Lacey Williams Henschel][1].
ChatOps is conversation-driven development. The idea is you can write code that is executed in response to something typed in a chat window. As a developer, you could use ChatOps to merge pull requests from Slack, automatically assign a support ticket to someone from a received Facebook message, or check the status of a deployment through IRC.
In the Python world, the most widely used ChatOps libraries are Opsdroid and Errbot. In this month's Python column, let's chat about what it's like to use them, what each does well, and how to get started with them.
### Opsdroid
[Opsdroid][2] is a relatively young (since 2016) open source chatbot library written in Python. It has good documentation, a great tutorial, and includes plugins to help you connect to popular chat services.
#### What's built in
The library itself doesn't ship with everything you need to get started, but this is by design. The lightweight framework encourages you to enable its existing connectors (what Opsdroid calls the plugins that help you connect to chat services) or write your own, but it doesn't weigh itself down by shipping with connectors you may not need. You can easily enable existing Opsdroid connectors for:
+ The command line
+ Cisco Spark
+ Facebook
+ GitHub
+ Matrix
+ Slack
+ Telegram
+ Twitter
+ Websockets
Opsdroid calls the functions the chatbot performs "skills." Skills are `async` Python functions and use Opsdroid's matching decorators, called "matchers." You can configure your Opsdroid project to use skills from the same codebase your configuration file is in or import skills from outside public or private repositories.
You can enable some existing Opsdroid skills as well, including [seen][3], which tells you when a specific user was last seen by the bot, and [weather][4], which will report the weather to the user.
Finally, Opdroid allows you to configure databases using its existing database modules. Current databases with Opsdroid support include:
+ Mongo
+ Redis
+ SQLite
You configure databases, skills, and connectors in the `configuration.yaml` file in your Opsdroid project.
#### Opsdroid pros
**Docker support:** Opsdroid is meant to work well in Docker from the get-go. Docker instructions are part of its [installation documentation][5]. Using Opsdroid with Docker Compose is also simple: Set up Opsdroid as a service and when you run `docker-compose up`, your Opsdroid service will start and your chatbot will be ready to chat.
```
version: "3"
services:
  opsdroid:
    container_name: opsdroid
    build:
      context: .
      dockerfile: Dockerfile
```
**Lots of connectors:** Opsdroid supports nine connectors to services like Slack and GitHub out of the box; all you need to do is enable those connectors in your configuration file and pass necessary tokens or API keys. For example, to enable Opsdroid to post in a Slack channel named `#updates`, add this to the `connectors` section of your configuration file:
```
- name: slack
    api-token: "this-is-my-token"
    default-room: "#updates"
```
You will have to [add a bot user][6] to your Slack workspace before configuring Opsdroid to connect to Slack.
If you need to connect to a service that Opsdroid does not support, there are instructions for adding your own connectors in the [docs][7].
**Pretty good docs.** Especially for a young-ish library in active development, Opsdroid's docs are very helpful. The docs include a [tutorial][8] that leads you through creating a couple of different basic skills. The Opsdroid documentation on [skills][9], [connectors][7], [databases][10], and [matchers][11] is also clear.
The repositories for its supported skills and connectors provide helpful example code for when you start writing your own custom skills and connectors.
**Natural language processing:** Opsdroid supports regular expressions for its skills, but also several NLP APIs, including [Dialogflow][12], [luis.ai][13], [Recast.AI][14], and [wit.ai][15].
#### Possible Opsdroid concern
Opsdroid doesn't yet enable the full features of some of its connectors. For example, the Slack API allows you to add color bars, images, and other "attachments" to your message. The Opsdroid Slack connector doesn't enable the "attachments" feature, so you would need to write a custom Slack connector if those features were important to you. If a connector is missing a feature you need, though, Opsdroid would welcome your [contribution][16]. The docs could use some more examples, especially of expected use cases.
#### Example usage
`hello/__init__.py`
```
from opsdroid.matchers import match_regex
import random
@match_regex(r'hi|hello|hey|hallo')
async def hello(opsdroid, config, message):
    text = random.choice(["Hi {}", "Hello {}", "Hey {}"]).format(message.user)
    await message.respond(text)
```
`configuration.yaml`
```
connectors:
  - name: websocket
skills:
  - name: hello
    repo: "https://github.com/<user_id>/hello-skill"
```
### Errbot
[Errbot][17] is a batteries-included open source chatbot. Errbot was released in 2012 and has everything anyone would expect from a mature project, including good documentation, a great tutorial, and plenty of plugins to help you connect to existing popular chat services.
#### What's built in
Unlike Opsdroid, which takes a more lightweight approach, Errbot ships with everything you need to build a customized bot safely.
Errbot includes support for XMPP, IRC, Slack, Hipchat, and Telegram services natively. It lists support for 10 other services through community-supplied backends.
#### Errbot pros
**Good docs:** Errbot's docs are mature and easy to use.
**Dynamic plugin architecture:** Errbot allow you to securely install, uninstall, update, enable, and disable plugins by chatting with the bot. This makes development and adding features easy. For the security conscious, this can all be locked down thanks to Errbot's granular permission system.
Errbot uses your plugin docstrings to generate documentation for available commands when someone types `!help`, which makes it easier to know what each command does.
**Built-in administration and security:** Errbot allows you to restrict lists of users who have administrative rights and even has fine-grained access controls. For example, you can restrict which commands may be called by specific users and/or specific rooms.
**Extensive plugin framework:** Errbot supports hooks, callbacks, subcommands, webhooks, polling, and many [more features][18]. If those aren't enough, you can even write [Dynamic plugins][19]. This feature is useful if you want to enable chat commands based on what commands are available on a remote server.
**Ships with a testing framework:** Errbot supports [pytest][20] and ships with some useful utilities that make testing your plugins easy and possible. Its "[testing your plugins][21]" docs are well thought out and provide enough to get started.
#### Possible Errbot concerns
**Initial !:** By default, Errbot commands are issued starting with an exclamation mark (`!help` and `!hello`). Some people may like this, but others may find it annoying. Thankfully, this is easy to turn off.
**Plugin metadata:** At first, Errbot's [Hello World][22] plugin example seems easy to use. However, I couldn't get my plugin to load until I read further into the tutorial and discovered that I also needed a `.plug` file, a file Errbot uses to load plugins. This is a pretty minor nitpick, but it wasn't obvious to me until I dug further into the docs.
#### Example usage
`hello.py`
```
import random
from errbot import BotPlugin, botcmd
class Hello(BotPlugin):
    @botcmd
    def hello(self, msg, args):
        text = random.choice(["Hi {}", "Hello {}", "Hey {}"]).format(message.user)
        return text
```
`hello.plug`
```
[Core]
Name = Hello
Module = hello
[Python]
Version = 2+
[Documentation]
Description = Example "Hello" plugin
```
Have you used Errbot or Opsdroid? If so, please leave a comment with your impressions on these tools.
--------------------------------------------------------------------------------
via: https://opensource.com/article/18/3/python-chatops-libraries-opsdroid-and-errbot
作者：[Jeff Triplett][a]
译者：[tomjlw](https://github.com/tomjlw)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]:https://opensource.com/users/laceynwilliams
[1]:https://opensource.com/users/laceynwilliams
[2]:https://opsdroid.github.io/
[3]:https://github.com/opsdroid/skill-seen
[4]:https://github.com/opsdroid/skill-weather
[5]:https://opsdroid.readthedocs.io/en/stable/#docker
[6]:https://api.slack.com/bot-users
[7]:https://opsdroid.readthedocs.io/en/stable/extending/connectors/
[8]:https://opsdroid.readthedocs.io/en/stable/tutorials/introduction/
[9]:https://opsdroid.readthedocs.io/en/stable/extending/skills/
[10]:https://opsdroid.readthedocs.io/en/stable/extending/databases/
[11]:https://opsdroid.readthedocs.io/en/stable/matchers/overview/
[12]:https://opsdroid.readthedocs.io/en/stable/matchers/dialogflow/
[13]:https://opsdroid.readthedocs.io/en/stable/matchers/luis.ai/
[14]:https://opsdroid.readthedocs.io/en/stable/matchers/recast.ai/
[15]:https://opsdroid.readthedocs.io/en/stable/matchers/wit.ai/
[16]:https://opsdroid.readthedocs.io/en/stable/contributing/
[17]:http://errbot.io/en/latest/
[18]:http://errbot.io/en/latest/features.html#extensive-plugin-framework
[19]:http://errbot.io/en/latest/user_guide/plugin_development/dynaplugs.html
[20]:http://pytest.org/
[21]:http://errbot.io/en/latest/user_guide/plugin_development/testing.html
[22]:http://errbot.io/en/latest/index.html#simple-to-build-upon

58
sources/tech/20190116 Get started with Cypht, an open source email client.md
View File

@ -1,58 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: (geekpi)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Get started with Cypht, an open source email client)
[#]: via: (https://opensource.com/article/19/1/productivity-tool-cypht-email)
[#]: author: (Kevin Sonney https://opensource.com/users/ksonney (Kevin Sonney))
Get started with Cypht, an open source email client
======
Integrate your email and news feeds into one view with Cypht, the fourth in our series on 19 open source tools that will make you more productive in 2019.
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/email_mail_box_envelope_send_blue.jpg?itok=6Epj47H6)
There seems to be a mad rush at the beginning of every year to find ways to be more productive. New Year's resolutions, the itch to start the year off right, and of course, an "out with the old, in with the new" attitude all contribute to this. And the usual round of recommendations is heavily biased towards closed source and proprietary software. It doesn't have to be that way.
Here's the fourth of my picks for 19 new (or new-to-you) open source tools to help you be more productive in 2019.
### Cypht
We spend a lot of time dealing with email, and effectively [managing your email][1] can make a huge impact on your productivity. Programs like Thunderbird, Kontact/KMail, and Evolution all seem to have one thing in common: they seek to duplicate the functionality of Microsoft Outlook, which hasn't really changed in the last 10 years or so. Even the [console standard-bearers][2] like Mutt and Cone haven't changed much in the last decade.
![](https://opensource.com/sites/default/files/uploads/cypht-1.png)
[Cypht][3] is a simple, lightweight, and modern webmail client that aggregates several accounts into a single view. Along with email accounts, it includes Atom/RSS feeds. It makes reading items from these different sources very simple by using an "Everything" screen that shows not just the mail from your inbox, but also the newest articles from your news feeds.
![](https://opensource.com/sites/default/files/uploads/cypht-2.png)
It uses a simplified version of HTML messages to display mail or you can set it to view a plain-text version. Since Cypht doesn't load images from remote sources (to help maintain security), HTML rendering can be a little rough, but it does enough to get the job done. You'll get plain-text views with most rich-text mail—meaning lots of links and hard to read. I don't fault Cypht, since this is really the email senders' doing, but it does detract a little from the reading experience. Reading news feeds is about the same, but having them integrated with your email accounts makes it much easier to keep up with them (something I sometimes have issues with).
![](https://opensource.com/sites/default/files/uploads/cypht-3.png)
Users can use a preconfigured mail server and add any additional servers they use. Cypht's customization options include plain-text vs. HTML mail display, support for multiple profiles, and the ability to change the theme (and make your own). You have to remember to click the "Save" button on the left navigation bar, though, or your custom settings will disappear after that session. If you log out and back in without saving, all your changes will be lost and you'll end up with the settings you started with. This does make it easy to experiment, and if you need to reset things, simply logging out without saving will bring back the previous setup when you log back in.
![](https://opensource.com/sites/default/files/pictures/cypht-4.png)
[Installing Cypht][4] locally is very easy. While it is not in a container or similar technology, the setup instructions were very clear and easy to follow and didn't require any changes on my part. On my laptop, it took about 10 minutes from starting the installation to logging in for the first time. A shared installation on a server uses the same steps, so it should be about the same.
In the end, Cypht is a fantastic alternative to desktop and web-based email clients with a simple interface to help you handle your email quickly and efficiently.
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/1/productivity-tool-cypht-email
作者：[Kevin Sonney][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/ksonney (Kevin Sonney)
[b]: https://github.com/lujun9972
[1]: https://opensource.com/article/17/7/email-alternatives-thunderbird
[2]: https://opensource.com/life/15/8/top-4-open-source-command-line-email-clients
[3]: https://cypht.org/
[4]: https://cypht.org/install.html

58
sources/tech/20190117 Get started with CryptPad, an open source collaborative document editor.md
View File

@ -1,58 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: (geekpi)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Get started with CryptPad, an open source collaborative document editor)
[#]: via: (https://opensource.com/article/19/1/productivity-tool-cryptpad)
[#]: author: (Kevin Sonney https://opensource.com/users/ksonney (Kevin Sonney))
Get started with CryptPad, an open source collaborative document editor
======
Securely share your notes, documents, kanban boards, and more with CryptPad, the fifth in our series on open source tools that will make you more productive in 2019.
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/web_browser_desktop_devlopment_design_system_computer.jpg?itok=pfqRrJgh)
There seems to be a mad rush at the beginning of every year to find ways to be more productive. New Year's resolutions, the itch to start the year off right, and of course, an "out with the old, in with the new" attitude all contribute to this. And the usual round of recommendations is heavily biased towards closed source and proprietary software. It doesn't have to be that way.
Here's the fifth of my picks for 19 new (or new-to-you) open source tools to help you be more productive in 2019.
### CryptPad
We already talked about [Joplin][1], which is good for keeping your own notes but—as you may have noticed—doesn't have any sharing or collaboration features.
[CryptPad][2] is a secure, shareable note-taking app and document editor that allows for secure, collaborative editing. Unlike Joplin, it is a NodeJS app, which means you can run it on your desktop or a server elsewhere and access it with any modern web browser. Out of the box, it supports rich text, Markdown, polls, whiteboards, kanban, and presentations.
![](https://opensource.com/sites/default/files/uploads/cryptpad-1.png)
The different document types are robust and fully featured. The rich text editor covers all the bases you'd expect from a good editor and allows you to export files to HTML. The Markdown editor is on par with Joplin, and the kanban board, though not as full-featured as [Wekan][3], is really well done. The rest of the supported document types and editors are also very polished and have the features you'd expect from similar apps, although polls feel a little clunky.
![](https://opensource.com/sites/default/files/uploads/cryptpad-2.png)
CryptPad's real power, though, comes in its sharing and collaboration features. Sharing a document is as simple as getting the sharable URL from the "share" option, and CryptPad supports embedding documents in iFrame tags on other websites. Documents can be shared in Edit or View mode with a password and with links that expire. The built-in chat allows editors to talk to each other (note that people with View access can also see the chat but can't comment).
![](https://opensource.com/sites/default/files/pictures/cryptpad-3.png)
All files are stored encrypted with the user's password. Server administrators can't read the documents, which also means if you forget or lose your password, the files are unrecoverable. So make sure you keep the password in a secure place, like a [password vault][4].
![](https://opensource.com/sites/default/files/uploads/cryptpad-4.png)
When it's run locally, CryptPad is a robust app for creating and editing documents. When run on a server, it becomes an excellent collaboration platform for multi-user document creation and editing. Installation took less than five minutes on my laptop, and it just worked out of the box. The developers also include instructions for running CryptPad in Docker, and there is a community-maintained Ansible role for ease of deployment. CryptPad does not support any third-party authentication methods, so users must create their own accounts. CryptPad also has a community-supported hosted version if you don't want to run your own server.
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/1/productivity-tool-cryptpad
作者：[Kevin Sonney][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/ksonney (Kevin Sonney)
[b]: https://github.com/lujun9972
[1]: https://opensource.com/article/19/1/productivity-tool-joplin
[2]: https://cryptpad.fr/index.html
[3]: https://opensource.com/article/19/1/productivity-tool-wekan
[4]: https://opensource.com/article/18/4/3-password-managers-linux-command-line

61
sources/tech/20190125 Get started with Freeplane, an open source mind mapping application.md
View File

@ -1,61 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: (geekpi)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Get started with Freeplane, an open source mind mapping application)
[#]: via: (https://opensource.com/article/19/1/productivity-tool-freeplane)
[#]: author: (Kevin Sonney https://opensource.com/users/ksonney (Kevin Sonney))
Get started with Freeplane, an open source mind mapping application
======
Map your brainstorming sessions with Freeplane, the 13th in our series on open source tools that will make you more productive in 2019.
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/brain_data.png?itok=RH6NA32X)
There seems to be a mad rush at the beginning of every year to find ways to be more productive. New Year's resolutions, the itch to start the year off right, and of course, an "out with the old, in with the new" attitude all contribute to this. And the usual round of recommendations is heavily biased towards closed source and proprietary software. It doesn't have to be that way.
Here's the 13th of my picks for 19 new (or new-to-you) open source tools to help you be more productive in 2019.
### Freeplane
[Mind maps][1] are one of the more valuable tools I've used for quickly brainstorming ideas and capturing data. Mind mapping is a versatile process that helps show how things are related and can be used to quickly organize interrelated information. From a planning perspective, mind mapping allows you to quickly perform a brain dump around a single concept, idea, or technology.
![](https://opensource.com/sites/default/files/uploads/freeplane-1.png)
[Freeplane][2] is a desktop application that makes it easy to create, view, edit, and share mind maps. It is a redesign of [FreeMind][3], which was the go-to mind-mapping application for quite some time.
Installing Freeplane is pretty easy. It is a [Java][4] application and distributed as a ZIP file with scripts to start the application on Linux, Windows, and MacOS. At its first startup, its main window includes an example mind map with links to documentation about all the different things you can do with Freeplane.
![](https://opensource.com/sites/default/files/uploads/freeplane-2.png)
You have a choice of templates when you create a new mind map. The standard template (likely at the bottom of the list) works for most cases. Just start typing the idea or phrase you want to start with, and your text will replace the center text. Pressing the Insert key will add a branch (or node) off the center with a blank field where you can fill in something associated with the idea. Pressing Insert again will add another node connected to the first one. Pressing Enter on a node will add a node parallel to that one.
![](https://opensource.com/sites/default/files/uploads/freeplane-3.png)
As you add nodes, you may come up with another thought or idea related to the main topic. Using either the mouse or the Arrow keys, go back to the center of the map and press Insert. A new node will be created off the main topic.
If you want to go beyond Freeplane's base functionality, right-click on any of the nodes to bring up a Properties menu for that node. The Tool pane (activated under the View–>Controls menu) contains customization options galore, including line shape and thickness, border shapes, colors, and much, much more. The Calendar tab allows you to insert dates into the nodes and set reminders for when nodes are due. (Note that reminders work only when Freeplane is running.) Mind maps can be exported to several formats, including common images, XML, Microsoft Project, Markdown, and OPML.
![](https://opensource.com/sites/default/files/uploads/freeplane-4.png)
Freeplane gives you all the tools you'll need to create vibrant and useful mind maps, getting your ideas out of your head and into a place where you can take action on them.
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/1/productivity-tool-freeplane
作者：[Kevin Sonney][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/ksonney (Kevin Sonney)
[b]: https://github.com/lujun9972
[1]: https://en.wikipedia.org/wiki/Mind_map
[2]: https://www.freeplane.org/wiki/index.php/Home
[3]: https://sourceforge.net/projects/freemind/
[4]: https://java.com

2
sources/tech/20190205 Install Apache, MySQL, PHP (LAMP) Stack On Ubuntu 18.04 LTS.md
View File

@ -1,5 +1,5 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: translator: (ustblixin)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )

2
sources/tech/20190208 3 Ways to Install Deb Files on Ubuntu Linux.md
View File

@ -1,5 +1,5 @@
[#]: collector: (lujun9972)
[#]: translator: (sndnvaps)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )

84
sources/tech/20190301 Emacs for (even more of) the win.md Normal file
View File

@ -0,0 +1,84 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Emacs for (even more of) the win)
[#]: via: (https://so.nwalsh.com/2019/03/01/emacs)
[#]: author: (Norman Walsh https://so.nwalsh.com)
Emacs for (even more of) the win
======
I use Emacs every day. I rarely notice it. But when I do, it usually brings me joy.
>If you are a professional writer…Emacs outshines all other editing software in approximately the same way that the noonday sun does the stars. It is not just bigger and brighter; it simply makes everything else vanish.
I’ve been using [Emacs][1] for well over twenty years. I use it for writing almost anything and everything (I edit Scala and Java in [IntelliJ][2]). I read my email in it. If it can be done in Emacs, that’s where I prefer to do it.
Although I’ve used Emacs for literally decades, I realized around the new year that very little about my use of Emacs had changed in the past decade or more. New editing modes had come along, of course, I’d picked up a package or two, and I did adopt [Helm][3] a few years ago, but mostly it just did all the heavy lifting that I required of it, day in and day out without complaining or getting in my way. On the one hand, that’s a testament to how good it is. On the other hand, that’s an invitation to dig in and see what I’ve missed.
At about the same time, I resolved to improve several aspects of my work life:
* **Better meeting management.** I’m lead on a couple of projects at work and those projects have meetings, both regularly scheduled and ad hoc; some of them I run, some of them, I only attend.
I realized I’d become sloppy about my participation in meetings. It’s all too easy sit in a room where there’s a meeting going on but actually read email and work on other items. (I strongly oppose the “no laptops” rule in meetings, but that’s a topic for another day.)
There are a couple of problems with sloppy participation. First, it’s disrespectful to the person who convened the meeting and the other participants. That’s actually sufficient reason not to do it, but I think there’s another problem: it disguises the cost of meetings.
If you’re in a meeting but also answering your email and maybe fixing a bug, then that meeting didn’t cost anything (or as much). If meetings are cheap, then there will be more of them.
I want fewer, shorter meetings. I don’t want to disguise their cost, I want them to be perceived as damned expensive and to be avoided unless absolutely necessary.
Sometimes, they are absolutely necessary. And I appreciate that a quick meeting can sometimes resolve an issue quickly. But if I have ten short meetings a day, let’s not pretend that I’m getting anything else productive accomplished.
I resolved to take notes at all the meetings I attend. I’m not offering to take minutes, necessarily, but I am taking minutes of a sort. It keeps me focused on the meeting and not catching up on other things.
* **Better time management.** There are lots and lots of things that I need or want to do, both professionally and personally. I’ve historically kept track off some of them in issue lists, some in saved email threads (in Emacs and [Gmail][4], for slightly different types of reminders), in my calendar, on “todo lists” of various sorts on my phone, and on little scraps of paper. And probably other places as well.
I resolved to keep them all in one place. Not because I think there’s one place that’s uniformly best or better, but because I hope to accomplish two things. First, by having them all in one place, I hope to be able to develop a better and more holistic view of where I’m putting my energies. Second, because I want to develop a habitn. “A settled or regular tendency or practice, especially one that is hard to give up.” of recording, tracking, and preserving them.
* **Better accountability.** If you work in certain science or engineering disciplines, you will have developed the habit of keeping a [lab notebook][5]. Alas, I did not. But I resolved to do so.
I’m not interested in the legal aspects that encourage bound pages or scribing only in permanent marker. What I’m interested in is developing the habit of keeping a record. My goal is to have a place to jot down ideas and design sketches and the like. If I have sudden inspiration or if I think of an edge case that isn’t in the test suite, I want my instinct to be to write it in my journal instead of scribbling it on a scrap of paper or promising myself that I’ll remember it.
This confluence of resolutions led me quickly and more-or-less directly to [Org][6]. There is a large, active, and loyal community of Org users. I’ve played with it in the past (I even [wrote about it][7], at least in passing, a couple of years ago) and I tinkered long enough to [integrate MarkLogic][8] into it. (Boy has that paid off in the last week or two!)
But I never used it.
I am now using it. I take minutes in it, I record all of my todo items in it, and I keep a journal in it. I’m not sure there’s much value in me attempting to wax eloquent about it or enumerate all its features, you’ll find plenty of either with a quick web search.
If you use Emacs, you should be using Org. If you don’t use Emacs, I’m confident you wouldn’t be the first person who started because of Org. It does a lot. It takes a little time to learn your way around and remember the shortcuts, but I think it’s worth it. (And if you carry an [iOS][9] device in your pocket, I recommend [beorg][10] for recording items while you’re on the go.)
Naturally, I worked out how to [get XML out of it][11]⊕“Worked out” sure is a funny way to spell “hacked together in elisp.”. And from there, how to turn it back into the markup my weblog expects (and do so at the push of a button in Emacs, of course). So this is the first posting written in Org. It won’t be the last.
P.S. Happy birthday [little weblog][12].
--------------------------------------------------------------------------------
via: https://so.nwalsh.com/2019/03/01/emacs
作者：[Norman Walsh][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://so.nwalsh.com
[b]: https://github.com/lujun9972
[1]: https://en.wikipedia.org/wiki/Emacs
[2]: https://en.wikipedia.org/wiki/IntelliJ_IDEA
[3]: https://emacs-helm.github.io/helm/
[4]: https://en.wikipedia.org/wiki/Gmail
[5]: https://en.wikipedia.org/wiki/Lab_notebook
[6]: https://en.wikipedia.org/wiki/Org-mode
[7]: https://www.balisage.net/Proceedings/vol17/html/Walsh01/BalisageVol17-Walsh01.html
[8]: https://github.com/ndw/ob-ml-marklogic/
[9]: https://en.wikipedia.org/wiki/IOS
[10]: https://beorgapp.com/
[11]: https://github.com/ndw/org-to-xml
[12]: https://so.nwalsh.com/2017/03/01/helloWorld

69
sources/tech/20190303 How to boot up a new Raspberry Pi.md
View File

@ -1,69 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (How to boot up a new Raspberry Pi)
[#]: via: (https://opensource.com/article/19/3/how-boot-new-raspberry-pi)
[#]: author: (Anderson Silva https://opensource.com/users/ansilva)
How to boot up a new Raspberry Pi
======
Learn how to install a Linux operating system, in the third article in our guide to getting started with Raspberry Pi.
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/programming_code_keyboard_orange_hands.png?itok=G6tJ_64Y)
If you've been following along in this series, you've [chosen][1] and [bought][2] your Raspberry Pi board and peripherals and now you're ready to start using it. Here, in the third article, let's look at what you need to do to boot it up.
Unlike your laptop, desktop, smartphone, or tablet, the Raspberry Pi doesn't come with built-in storage. Instead, it uses a Micro SD card to store the operating system and your files. The great thing about this is it gives you the flexibility to carry your files (even if you don't have your Raspberry Pi with you). The downside is it may also increase the risk of losing or damaging the card—and thus losing your files. Just protect your Micro SD card, and you should be fine.
You should also know that SD cards aren't as fast as mechanical or solid state drives, so booting, reading, and writing from your Pi will not be as speedy as you would expect from other devices.
### How to install Raspbian
The first thing you need to do when you get a new Raspberry Pi is to install its operating system on a Micro SD card. Even though there are other operating systems (both Linux- and non-Linux-based) available for the Raspberry Pi, this series focuses on [Raspbian][3] , Raspberry Pi's official Linux version.
![](https://opensource.com/sites/default/files/uploads/raspbian.png)
The easiest way to install Raspbian is with [NOOBS][4], which stands for "New Out Of Box Software." Raspberry Pi offers great [documentation for NOOBS][5], so I won't repeat the installation instructions here.
NOOBS gives you the choice of installing the following operating systems:
+ [Raspbian][6]
+ [LibreELEC][7]
+ [OSMC][8]
+ [Recalbox][9]
+ [Lakka][10]
+ [RISC OS][11]
+ [Screenly OSE][12]
+ [Windows 10 IoT Core][13]
+ [TLXOS][14]
Again, Raspbian is the operating system we'll use in this series, so go ahead, grab your Micro SD and follow the NOOBS documentation to install it. I'll meet you in the fourth article in this series, where we'll look at how to use Linux, including some of the main commands you'll need to know.
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/3/how-boot-new-raspberry-pi
作者：[Anderson Silva][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/ansilva
[b]: https://github.com/lujun9972
[1]: https://opensource.com/article/19/3/which-raspberry-pi-choose
[2]: https://opensource.com/article/19/2/how-buy-raspberry-pi
[3]: https://www.raspbian.org/RaspbianFAQ
[4]: https://www.raspberrypi.org/downloads/noobs/
[5]: https://www.raspberrypi.org/documentation/installation/noobs.md
[6]: https://www.raspbian.org/RaspbianFAQ
[7]: https://libreelec.tv/
[8]: https://osmc.tv/
[9]: https://www.recalbox.com/
[10]: http://www.lakka.tv/
[11]: https://www.riscosopen.org/wiki/documentation/show/Welcome%20to%20RISC%20OS%20Pi
[12]: https://www.screenly.io/ose/
[13]: https://developer.microsoft.com/en-us/windows/iot
[14]: https://thinlinx.com/

366
sources/tech/20190305 5 Ways To Generate A Random-Strong Password In Linux Terminal.md
View File

@ -1,366 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: (leommxj)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (5 Ways To Generate A Random/Strong Password In Linux Terminal)
[#]: via: (https://www.2daygeek.com/5-ways-to-generate-a-random-strong-password-in-linux-terminal/)
[#]: author: (Magesh Maruthamuthu https://www.2daygeek.com/author/magesh/)
5 Ways To Generate A Random/Strong Password In Linux Terminal
======
Recently we had written an article about **[password strength and password score check][1]** in our website.
It will help you to validate your password strength and score.
We can manually create few passwords which we required but if you would like to generate a password for multiple users or servers, what will be the solution.
Yes, there are many utilities are available in Linux to fulfill this requirements. However, I’m going to include the best five password generators in this article.
These tools are generates a strong random passwords for you. Navigate to the following article if you would like to update the password on multiple users and servers.
These tools are easy to use, that’s why i preferred to go with it. By default it will generate a strong password and if you would like to generate a super strong password then use the available options.
It will help you to generate a super strong password in the following combination. It should have minimum 12-15 characters length, that includes Alphabets (Lower case & Upper case), Numbers and Special Characters.
These tools are below.
* `pwgen:` The pwgen program generates passwords which are designed to be easily memorized by humans, while being as secure as possible.
* `openssl:` The openssl program is a command line tool for using the various cryptography functions of OpenSSL’s crypto library from the shell.
* `gpg:` OpenPGP encryption and signing tool
* `mkpasswd:` generate new password, optionally apply it to a user
* `makepasswd:` makepasswd generates true random passwords using /dev/urandom, with the emphasis on security over pronounceability.
* `/dev/urandom file:` The character special files /dev/random and /dev/urandom (present since Linux 1.3.30) provide an interface to the kernel’s random number generator.
* `md5sum:` md5sum is a computer program that calculates and verifies 128-bit MD5 hashes.
* `sha256sum:` The program sha256sum is designed to verify data integrity using the SHA-256 (SHA-2 family with a digest length of 256 bits).
* `sha1pass:` sha1pass creates a SHA1 password hash. In the absence of a salt value on the command line, a random salt vector will be generated.
### How To Generate A Random Strong Password In Linux Using pwgen Command?
The pwgen program generates passwords which are designed to be easily memorized by humans, while being as secure as possible.
Human-memorable passwords are never going to be as secure as completely completely random passwords.
Use `-s` option to generate completely random, hard-to-memorize passwords. These should only be used for machine passwords as we can’t memorize.
For **`Fedora`** system, use **[DNF Command][2]** to install pwgen.
```
$ sudo dnf install pwgen
```
For **`Debian/Ubuntu`** systems, use **[APT-GET Command][3]** or **[APT Command][4]** to install pwgen.
```
$ sudo apt install pwgen
```
For **`Arch Linux`** based systems, use **[Pacman Command][5]** to install pwgen.
```
$ sudo pacman -S pwgen
```
For **`RHEL/CentOS`** systems, use **[YUM Command][6]** to install pwgen.
```
$ sudo yum install pwgen
```
For **`openSUSE Leap`** system, use **[Zypper Command][7]** to install pwgen.
```
$ sudo zypper install pwgen
```
### How To Use pwgen Command In Linux?
It’s a simple and straight forward method. Use one of the below preferred examples for you. By default, it generates a human memorable password.
To do so, simple run the `pwgen` command on your terminal. It generates 160 passwords in a single shot. These 160 passwords are printer with 20 rows and 8 columns.
```
$ pwgen
ameiK2oo aibi3Cha EPium0Ie aisoh1Ee Nidee9ae uNga0Bee uPh9ieM1 ahn1ooNg
oc5ooTea tai7eKid tae2yieS hiecaiR8 wohY2Ohk Uab2maed heC4aXoh Ob6Nieso
Shaeriu3 uy9Juk5u hoht7Doo Fah6yah3 faz9Jeew eKiek4ju as0Xuosh Eiwo4epo
oot8teeZ Ui1yoohi Aechae7A Ohdi2ael cae5Thoh Au1aeTei ais0aiC2 Cai2quin
Oox9ohz4 neev0Che ahza8AQu Ahz7eica meiBeeW0 Av3bo7ah quoiTu3f taeNg3ae
Aiko7Aiz SheiGh8E aesaeSh7 haet6Loo AeTel3oN Ath7zeer IeYah4ie UG3ootha
Ohch9Och Phuap6su iel5Xu7s diqui7Bu ieF2dier eeluHa1u Thagei0i Ceeth3oh
OCei1ahj zei2aiYo Jahgh1ia ooqu1Cej eez2aiPo Wahd5soo noo7Mei9 Hie5ashe
Uith4Or2 Xie3uh2b fuF9Eilu eiN2sha9 zae2YaSh oGh5ephi ohvao4Ae aixu6aeM
fo4Ierah iephei6A hae9eeGa eiBeiY3g Aic8Kee9 he8AheCh ohM4bid9 eemae3Zu
eesh2EiM cheiGa4j PooV2vii ahpeeg5E aezauX2c Xe7aethu Ahvaph7a Joh2heec
Ii5EeShi aij7Uo8e ooy2Ahth mieKe2ni eiQuu8fe giedaQu0 eiPhob3E oox1uo2U
eehia4Hu ga9Ahw0a ohxuZei7 eV4OoXio Kid2wu1n ku4Ahf5s uigh8uQu AhWoh0po
vo1Eeb2u Ahth7ve5 ieje4eiL ieci1Ach Meephie9 iephieY8 Eesoom7u eakai2Bo
uo8Ieche Zai3aev5 aGhahf0E Wowoo5th Oraeb0ah Gah3nah0 ieGhah0p aeCh0OhJ
ahQu2feZ ahQu0gah foik7Ush cei1Wai1 Aivi3ooY eephei5U MooZae3O quooRoh7
aequae5U pae6Ceiv eizahF1k ohmi7ETa ahyaeK1N Mohw2no8 ooc8Oone coo7Ieve
eePhei9h Weequ8eV Vie4iezu neeMiim4 ie6aiZoh Queegh2E shahwi3N Inichie8
Sid1aeji mohj4Ko7 lieDi0pe Zeemah6a thuevu2E phi4Ohsh paiKeix1 ooz1Ceph
ahV4yore ue2laePh fu1eThui qui7aePh Fahth1nu ohk9puLo aiBeez0b Neengai5
```
To generate a secure random password, use `-s` option with pwgen command.
```
$ pwgen -s
CU75lgZd 7HzzKgtA 2ktBJDpR F6XJVhBs UjAm3bNL zO7Dw7JJ pxn8fUvp Ka3lLilG
ywJX7iJl D9ajxb6N 78c1HOg2 g8vtWCra Jp6pBGBw oYuev9Vl gbA6gHV8 G6XQoVO5
uQN98IU4 50GgQfrX FrTsou2t YQorO4x6 UGer8Yi2 O7DB5nw1 1ax370UR 1xVRPkA1
RVaGDr2i Nt11ekUd 9Vm3D244 ck8Lnpd0 SjDt8uWn 5ERT4tf8 4EONFzyY Jc6T83jg
WZa6bKPW H4HMo1YU bsDDRik3 gBwV7LOW 9H1QRQ4x 3Ak7RcSe IJu2RBF9 e508xrLC
SzTrW191 AslxDa6E IkWWov2b iOb6EmTy qHt82OwG 5ZFO7B53 97zmjOPu A4KZuhYV
uQpoJR4D 0eKyOiUr Rz96smeO 3HTABu3N 6W0VmEls uPsp5zpw 8UD3VkMG YTct6Rd4
VKo0cVmq E07ZX7j9 kQSlvA69 Nm3fpv3i xWvF2xMu yEfcw8uA oQGVX3l9 grTzx7Xj
s4GVEYtM uJl5sYMe n3icRPiY ED3Mup4B k3M9KHI7 IkxqoSM0 dt2cxmMU yb2tUkut
2Q9wGZQx 8Rpo11s9 I13siOHu 7GV64Fjv 3VONzD8i SCDfVD3F oiPTx239 6BQakoiJ
XUEokiC4 ybL7VGmL el2RfvWk zKc7CLcE 3FqNBSyA NjDWrvZ5 KI3NSX4h VFyo6VPr
h4q3XeqZ FDYMoX6f uTU5ZzU3 6u4ob4Ep wiYPt05n CZga66qh upzH6Z9y RuVcqbe8
taQv11hq 1xsY67a8 EVo9GLXA FCaDLGb1 bZyh0YN8 0nTKo0Qy RRVUwn9t DuU8mwwv
x96LWpCb tFLz3fBG dNb4gCKf n6VYcOiH 1ep6QYFZ x8kaJtrY 56PDWuW6 1R0If4kV
2XK0NLQK 4XQqhycl Ip08cn6c Bnx9z2Bz 7gjGlON7 CJxLR1U4 mqMwir3j ovGXWu0z
MfDjk5m8 4KwM9SAN oz0fZ5eo 5m8iRtco oP5BpLh0 Z5kvwr1W f34O2O43 hXao1Sp8
tKoG5VNI f13fuYvm BQQn8MD3 bmFSf6Mf Z4Y0o17U jT4wO1DG cz2clBES Lr4B3qIY
ArKQRND6 8xnh4oIs nayiK2zG yWvQCV3v AFPlHSB8 zfx5bnaL t5lFbenk F2dIeBr4
C6RqDQMy gKt28c9O ZCi0tQKE 0Ekdjh3P ox2vWOMI 14XF4gwc nYA0L6tV rRN3lekn
lmwZNjz1 4ovmJAr7 shPl9o5f FFsuNwj0 F2eVkqGi 7gw277RZ nYE7gCLl JDn05S5N
```
If you would like to generate a strong five passwords with 14 characters length, use the following format.
```
$ pwgen -s 14 5
7YxUwDyfxGVTYD em2NT6FceXjPfT u8jlrljbrclcTi IruIX3Xu0TFXRr X8M9cB6wKNot1e
```
If you really want to generate a super strong random twenty passwords, use the following format.
```
$ pwgen -cnys 14 20
mQ3E=vfGfZ,5[B #zmj{i5|ZS){jg Ht_8i7OqJ%N`~2 443fa5iJ\W-L?] ?Qs$o=vz2vgQBR
^'Ry0Az|J9p2+0 t2oA/n7U_'|QRx EsX*%_(4./QCRJ ACr-,8yF9&eM[* !Xz1C'bw?tv50o
8hfv-fK(VxwQGS q!qj?sD7Xmkb7^ N#Zp\_Y2kr%!)~ 4*pwYs{bq]Hh&Y |4u=-Q1!jS~8=;
]{$N#FPX1L2B{h I|01fcK.z?QTz" l~]JD_,W%5bp.E +i2=D3;BQ}p+$I n.a3,.D3VQ3~&i
```
### How To Generate A Random Strong Password In Linux Using openssl Command?
The openssl program is a command line tool for using the various cryptography functions of OpenSSL’s crypto library from the shell.
Run the openssl command with the following format to generate a random strong password with 14 characters.
```
$ openssl rand -base64 14
WjzyDqdkWf3e53tJw/c=
```
If you would like to generate ten random strong password with 14 characters using openssl command then use the following for loop.
```
$ for pw in {1..10}; do openssl rand -base64 14; done
6i0hgHDBi3ohZ9Mil8I=
gtn+y1bVFJFanpJqWaA=
rYu+wy+0nwLf5lk7TBA=
xrdNGykIzxaKDiLF2Bw=
cltejRkDPdFPC/zI0Pg=
G6aroK6d4xVVYFTrZGs=
jJEnFoOk1+UTSx/wJrY=
TFxVjBmLx9aivXB3yxE=
oQtOLPwTuO8df7dIv9I=
ktpBpCSQFOD+5kIIe7Y=
```
### How To Generate A Random Strong Password In Linux Using gpg Command?
gpg is the OpenPGP part of the GNU Privacy Guard (GnuPG). It is a tool to provide digital encryption and signing services using the OpenPGP standard. gpg features complete key management and all the bells and whistles you would expect from a full OpenPGP implementation.
Run the gpg command with the following format to generate a random strong password with 14 characters.
```
$ gpg --gen-random --armor 1 14
or
$ gpg2 --gen-random --armor 1 14
jq1mtY4gBa6gIuJrggM=
```
If you would like to generate ten random strong password with 14 characters using gpg command then use the following for loop.
```
$ for pw in {1..10}; do gpg --gen-random --armor 1 14; done
or
$ for pw in {1..10}; do gpg2 --gen-random --armor 1 14; done
F5ZzLSUMet2kefG6Ssc=
8hh7BFNs8Qu0cnrvHrY=
B+PEt28CosR5xO05/sQ=
m21bfx6UG1cBDzVGKcE=
wALosRXnBgmOC6+++xU=
TGpjT5xRxo/zFq/lNeg=
ggsKxVgpB/3aSOY15W4=
iUlezWxL626CPc9omTI=
pYb7xQwI1NTlM2rxaCg=
eJjhtA6oHhBrUpLY4fM=
```
### How To Generate A Random Strong Password In Linux Using mkpasswd Command?
mkpasswd generates passwords and can apply them automatically to users. With no arguments, mkpasswd returns a new password. It’s part of an expect package so, you have to install expect package to use mkpasswd command.
For **`Fedora`** system, use **[DNF Command][2]** to install mkpasswd.
```
$ sudo dnf install expect
```
For **`Debian/Ubuntu`** systems, use **[APT-GET Command][3]** or **[APT Command][4]** to install mkpasswd.
```
$ sudo apt install expect
```
For **`Arch Linux`** based systems, use **[Pacman Command][5]** to install mkpasswd.
```
$ sudo pacman -S expect
```
For **`RHEL/CentOS`** systems, use **[YUM Command][6]** to install mkpasswd.
```
$ sudo yum install expect
```
For **`openSUSE Leap`** system, use **[Zypper Command][7]** to install mkpasswd.
```
$ sudo zypper install expect
```
Run the `mkpasswd` command in terminal to generate a random password.
```
$ mkpasswd
37_slQepD
```
Run the mkpasswd command with the following format to generate a random strong password with 14 characters.
```
$ mkpasswd -l 14
W1qP1uv=lhghgh
```
Run the mkpasswd command with the following format to generate a random strong password with 14 characters. It combinations of alphabetic (Lower & Upper case), Numeric number and special characters.
```
$ mkpasswd -l 14 -d 3 -C 3 -s 3
3aad!bMWG49"t,
```
If you would like to generate ten random strong password with 14 characters (It combination of alphabetic (Lower & Upper case), Numeric number and special characters) using mkpasswd command then use the following for loop.
```
$ for pw in {1..10}; do mkpasswd -l 14 -d 3 -C 3 -s 3; done
zmSwP[q9;P1r6[
E42zcvzM"i3%B\
8}1#[email protected]
0X:zB(mmU22?nj
0sqqL44M}ko(O^
43tQ(.6jG;ceRq
-jB6cp3x1GZ$e=
$of?Rj9kb2N(1J
9HCf,nn#gjO79^
Tu9m56+Ev_Yso(
```
### How To Generate A Random Strong Password In Linux Using makepasswd Command?
makepasswd generates true random passwords using /dev/urandom, with the emphasis on security over pronounceability. It can also encrypt plaintext passwords given on the command line.
Run the `makepasswd` command in terminal to generate a random password.
```
$ makepasswd
HdCJafVaN
```
Run the makepasswd command with the following format to generate a random strong password with 14 characters.
```
$ makepasswd --chars 14
HxJDv5quavrqmU
```
Run the makepasswd command with the following format to generate ten random strong password with 14 characters.
```
$ makepasswd --chars 14 --count 10
TqmKVWnRGeoVNr
mPV2P98hLRUsai
MhMXPwyzYi2RLo
dxMGgLmoFpYivi
8p0G7JvJjd6qUP
7SmX95MiJcQauV
KWzrh5npAjvNmL
oHPKdq1uA9tU85
V1su9GjU2oIGiQ
M2TMCEoahzLNYC
```
### How To Generate A Random Strong Password In Linux Using Multiple Commands?
Still if you are looking other options then you can use the following utilities to generate a random password in Linux.
**Using md5sum:** md5sum is a computer program that calculates and verifies 128-bit MD5 hashes.
```
$ date | md5sum
9baf96fb6e8cbd99601d97a5c3acc2c4 -
```
**Using /dev/urandom:** The character special files /dev/random and /dev/urandom (present since Linux 1.3.30) provide an interface to the kernel’s random number generator. File /dev/random has major device number 1 and minor device number 8. File /dev/urandom has major device number 1 and minor device number 9.
```
$ cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c 14
15LQB9J84Btnzz
```
**Using sha256sum:** The program sha256sum is designed to verify data integrity using the SHA-256 (SHA-2 family with a digest length of 256 bits).
```
$ date | sha256sum
a114ae5c458ae0d366e1b673d558d921bb937e568d9329b525cf32290478826a -
```
**Using sha1pass:** sha1pass creates a SHA1 password hash. In the absence of a salt value on the command line, a random salt vector will be generated.
```
$ sha1pass
$4$9+JvykOv$e7U0jMJL2yBOL+RVa2Eke8SETEo$
```
--------------------------------------------------------------------------------
via: https://www.2daygeek.com/5-ways-to-generate-a-random-strong-password-in-linux-terminal/
作者：[Magesh Maruthamuthu][a]
选题：[lujun9972][b]
译者：[leommx](https://github.com/leommxj)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.2daygeek.com/author/magesh/
[b]: https://github.com/lujun9972
[1]: https://www.2daygeek.com/how-to-check-password-complexity-strength-and-score-in-linux/
[2]: https://www.2daygeek.com/dnf-command-examples-manage-packages-fedora-system/
[3]: https://www.2daygeek.com/apt-get-apt-cache-command-examples-manage-packages-debian-ubuntu-systems/
[4]: https://www.2daygeek.com/apt-command-examples-manage-packages-debian-ubuntu-systems/
[5]: https://www.2daygeek.com/pacman-command-examples-manage-packages-arch-linux-system/
[6]: https://www.2daygeek.com/yum-command-examples-manage-packages-rhel-centos-systems/
[7]: https://www.2daygeek.com/zypper-command-examples-manage-packages-opensuse-system/

65
sources/tech/20190306 3 popular programming languages you can learn with Raspberry Pi.md
View File

@ -1,65 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (3 popular programming languages you can learn with Raspberry Pi)
[#]: via: (https://opensource.com/article/19/3/programming-languages-raspberry-pi)
[#]: author: (Anderson Silva https://opensource.com/users/ansilva)
3 popular programming languages you can learn with Raspberry Pi
======
Become more valuable on the job market by learning to program with the Raspberry Pi.
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/programming_language_c.png?itok=mPwqDAD9)
In the last article in this series, I shared some ways to [teach kids to program with Raspberry Pi][1]. In theory, there is absolutely nothing stopping an adult from using resources designed for kids, but you might be better served by learning the programming languages that are in demand in the job market.
Here are three programming languages you can learn with the Raspberry Pi.
### Python
[Python][2] has become one of the [most popular programming languages][3] in the open source world. Its interpreter has been packaged and made available in every popular Linux distribution. If you install Raspbian on your Raspberry Pi, you will see an app called [Thonny][4], which is a Python integrated development environment (IDE) for beginners. In a nutshell, an IDE is an application that provides all you need to get your code executed, often including things like debuggers, documentation, auto-completion, and emulators. Here is a [great little tutorial][5] to get you started using Thonny and Python on the Raspberry Pi.
![](https://opensource.com/sites/default/files/uploads/thonny.png)
### Java
Although arguably not as attractive as it once was, [Java][6] remains heavily used in universities around the world and deeply embedded in the enterprise. So, even though some will disagree that I'm recommending it as a beginner's language, I am compelled to do so; for one thing, it still very popular, and for another, there are a lot of books, classes, and other information available for you to learn Java. Get started on the Raspberry Pi by using the [BlueJ][7] Java IDE.
![](https://opensource.com/sites/default/files/uploads/bluejayide.png)
### JavaScript
"Back in my day…" [JavaScript][8] was a client-side language that basically allowed people to streamline and automate user events in a browser and modify HTML elements. Today, JavaScript has escaped the browser and is available for other types of clients like mobile apps and even server-side programming. [Node.js][9] is a popular runtime environment that allows developers to code beyond the client-browser paradigm. To learn more about running Node.js on the Raspberry Pi, check out [W3Schools tutorial][10].
### Other languages
If there's another language you want to learn, don't despair. There's a high likelihood that you can use your Raspberry Pi to compile or interpret any language of choice, including C, C++, PHP, and Ruby.
Microsoft's [Visual Studio Code][11] also [runs on the Raspberry Pi][12]. It's an open source code editor from Microsoft that supports several markup and programming languages.
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/3/programming-languages-raspberry-pi
作者：[Anderson Silva][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/ansilva
[b]: https://github.com/lujun9972
[1]: https://opensource.com/article/19/2/teach-kids-program-raspberry-pi
[2]: https://opensource.com/resources/python
[3]: https://www.economist.com/graphic-detail/2018/07/26/python-is-becoming-the-worlds-most-popular-coding-language
[4]: https://thonny.org/
[5]: https://raspberrypihq.com/getting-started-with-python-programming-and-the-raspberry-pi/
[6]: https://opensource.com/resources/java
[7]: https://www.bluej.org/raspberrypi/
[8]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
[9]: https://nodejs.org/en/
[10]: https://www.w3schools.com/nodejs/nodejs_raspberrypi.asp
[11]: https://code.visualstudio.com/
[12]: https://pimylifeup.com/raspberry-pi-visual-studio-code/

2
sources/tech/20190307 How to keep your Raspberry Pi updated.md
View File

@ -1,5 +1,5 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: translator: (geekpi)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )

2
sources/tech/20190309 Emulators and Native Linux games on the Raspberry Pi.md
View File

@ -1,5 +1,5 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: translator: (geekpi)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )

2
sources/tech/20190312 Do advanced math with Mathematica on the Raspberry Pi.md
View File

@ -1,5 +1,5 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: translator: (geekpi)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )

16
sources/tech/20190315 How To Parse And Pretty Print JSON With Linux Commandline Tools.md
View File

@ -1,11 +1,11 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (How To Parse And Pretty Print JSON With Linux Commandline Tools)
[#]: via: (https://www.ostechnix.com/how-to-parse-and-pretty-print-json-with-linux-commandline-tools/)
[#]: author: (EDITOR https://www.ostechnix.com/author/editor/)
[#]: collector: "lujun9972"
[#]: translator: "zhangxiangping "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
[#]: subject: "How To Parse And Pretty Print JSON With Linux Commandline Tools"
[#]: via: "https://www.ostechnix.com/how-to-parse-and-pretty-print-json-with-linux-commandline-tools/"
[#]: author: "EDITOR https://www.ostechnix.com/author/editor/"
How To Parse And Pretty Print JSON With Linux Commandline Tools
======

331
sources/tech/20190318 10 Python image manipulation tools.md Normal file
View File

@ -0,0 +1,331 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (10 Python image manipulation tools)
[#]: via: (https://opensource.com/article/19/3/python-image-manipulation-tools)
[#]: author: (Parul Pandey https://opensource.com/users/parul-pandey)
10 Python image manipulation tools
======
These Python libraries provide an easy and intuitive way to transform images and make sense of the underlying data.
![][1]
Today's world is full of data, and images form a significant part of this data. However, before they can be used, these digital images must be processed—analyzed and manipulated in order to improve their quality or extract some information that can be put to use.
Common image processing tasks include displays; basic manipulations like cropping, flipping, rotating, etc.; image segmentation, classification, and feature extractions; image restoration; and image recognition. Python is an excellent choice for these types of image processing tasks due to its growing popularity as a scientific programming language and the free availability of many state-of-the-art image processing tools in its ecosystem.
This article looks at 10 of the most commonly used Python libraries for image manipulation tasks. These libraries provide an easy and intuitive way to transform images and make sense of the underlying data.
### 1\. scikit-image
**[**scikit** -image][2]** is an open source Python package that works with [NumPy][3] arrays. It implements algorithms and utilities for use in research, education, and industry applications. It is a fairly simple and straightforward library, even for those who are new to Python's ecosystem. The code is high-quality, peer-reviewed, and written by an active community of volunteers.
#### Resources
scikit-image is very well [documented][4] with a lot of examples and practical use cases.
#### Usage
The package is imported as **skimage** , and most functions are found within the submodules.
Image filtering:
```
import matplotlib.pyplot as plt
%matplotlib inline
from skimage import data,filters
image = data.coins() # ... or any other NumPy array!
edges = filters.sobel(image)
plt.imshow(edges, cmap='gray')
```
![Image filtering in scikit-image][6]
Template matching using the [match_template][7] function:
![Template matching in scikit-image][9]
You can find more examples in the [gallery][10].
### 2\. NumPy
[**NumPy**][11] is one of the core libraries in Python programming and provides support for arrays. An image is essentially a standard NumPy array containing pixels of data points. Therefore, by using basic NumPy operations, such as slicing, masking, and fancy indexing, you can modify the pixel values of an image. The image can be loaded using **skimage** and displayed using Matplotlib.
#### Resources
A complete list of resources and documentation is available on NumPy's [official documentation page][11].
#### Usage
Using Numpy to mask an image:
```
import numpy as np
from skimage import data
import matplotlib.pyplot as plt
%matplotlib inline
image = data.camera()
type(image)
numpy.ndarray #Image is a NumPy array:
mask = image < 87
image[mask]=255
plt.imshow(image, cmap='gray')
```
![NumPy][13]
### 3\. SciPy
**[SciPy][14]** is another of Python's core scientific modules (like NumPy) and can be used for basic image manipulation and processing tasks. In particular, the submodule [**scipy.ndimage**][15] (in SciPy v1.1.0) provides functions operating on n-dimensional NumPy arrays. The package currently includes functions for linear and non-linear filtering, binary morphology, B-spline interpolation, and object measurements.
#### Resources
For a complete list of functions provided by the **scipy.ndimage** package, refer to the [documentation][16].
#### Usage
Using SciPy for blurring using a [Gaussian filter][17]:
```
from scipy import misc,ndimage
face = misc.face()
blurred_face = ndimage.gaussian_filter(face, sigma=3)
very_blurred = ndimage.gaussian_filter(face, sigma=5)
#Results
plt.imshow(<image to be displayed>)
```
![Using a Gaussian filter in SciPy][19]
### 4\. PIL/Pillow
**PIL** (Python Imaging Library) is a free library for the Python programming language that adds support for opening, manipulating, and saving many different image file formats. However, its development has stagnated, with its last release in 2009. Fortunately, there is [**Pillow**][20], an actively developed fork of PIL, that is easier to install, runs on all major operating systems, and supports Python 3. The library contains basic image processing functionality, including point operations, filtering with a set of built-in convolution kernels, and color-space conversions.
#### Resources
The [documentation][21] has instructions for installation as well as examples covering every module of the library.
#### Usage
Enhancing an image in Pillow using ImageFilter:
```
from PIL import Image,ImageFilter
#Read image
im = Image.open('image.jpg')
#Display image
im.show()
from PIL import ImageEnhance
enh = ImageEnhance.Contrast(im)
enh.enhance(1.8).show("30% more contrast")
```
![Enhancing an image in Pillow using ImageFilter][23]
[Image source code][24]
### 5\. OpenCV-Python
**OpenCV** (Open Source Computer Vision Library) is one of the most widely used libraries for computer vision applications. [**OpenCV-Python**][25] is the Python API for OpenCV. OpenCV-Python is not only fast, since the background consists of code written in C/C++, but it is also easy to code and deploy (due to the Python wrapper in the foreground). This makes it a great choice to perform computationally intensive computer vision programs.
#### Resources
The [OpenCV2-Python-Guide][26] makes it easy to get started with OpenCV-Python.
#### Usage
Using _Image Blending using Pyramids_ in OpenCV-Python to create an "Orapple":
![Image blending using Pyramids in OpenCV-Python][28]
[Image source code][29]
### 6\. SimpleCV
[**SimpleCV**][30] is another open source framework for building computer vision applications. It offers access to several high-powered computer vision libraries such as OpenCV, but without having to know about bit depths, file formats, color spaces, etc. Its learning curve is substantially smaller than OpenCV's, and (as its tagline says), "it's computer vision made easy." Some points in favor of SimpleCV are:
* Even beginning programmers can write simple machine vision tests
* Cameras, video files, images, and video streams are all interoperable
#### Resources
The official [documentation][31] is very easy to follow and has tons of examples and use cases to follow.
#### Usage
### [7-_simplecv.png][32]
![SimpleCV][33]
### 7\. Mahotas
**[Mahotas][34]** is another computer vision and image processing library for Python. It contains traditional image processing functions such as filtering and morphological operations, as well as more modern computer vision functions for feature computation, including interest point detection and local descriptors. The interface is in Python, which is appropriate for fast development, but the algorithms are implemented in C++ and tuned for speed. Mahotas' library is fast with minimalistic code and even minimum dependencies. Read its [official paper][35] for more insights.
#### Resources
The [documentation][36] contains installation instructions, examples, and even some tutorials to help you get started using Mahotas easily.
#### Usage
The Mahotas library relies on simple code to get things done. For example, it does a good job with the [Finding Wally][37] problem with a minimum amount of code.
Solving the Finding Wally problem:
![Finding Wally problem in Mahotas][39]
[Image source code][40]
![Finding Wally problem in Mahotas][42]
[Image source code][40]
### 8\. SimpleITK
[**ITK**][43] (Insight Segmentation and Registration Toolkit) is an "open source, cross-platform system that provides developers with an extensive suite of software tools for image analysis. **[SimpleITK][44]** is a simplified layer built on top of ITK, intended to facilitate its use in rapid prototyping, education, [and] interpreted languages." It's also an image analysis toolkit with a [large number of components][45] supporting general filtering operations, image segmentation, and registration. SimpleITK is written in C++, but it's available for a large number of programming languages including Python.
#### Resources
There are a large number of [Jupyter Notebooks][46] illustrating the use of SimpleITK for educational and research activities. The notebooks demonstrate using SimpleITK for interactive image analysis using the Python and R programming languages.
#### Usage
Visualization of a rigid CT/MR registration process created with SimpleITK and Python:
![SimpleITK animation][48]
[Image source code][49]
### 9\. pgmagick
[**pgmagick**][50] is a Python-based wrapper for the GraphicsMagick library. The [**GraphicsMagick**][51] image processing system is sometimes called the Swiss Army Knife of image processing. Its robust and efficient collection of tools and libraries supports reading, writing, and manipulating images in over 88 major formats including DPX, GIF, JPEG, JPEG-2000, PNG, PDF, PNM, and TIFF.
#### Resources
pgmagick's [GitHub repository][52] has installation instructions and requirements. There is also a detailed [user guide][53].
#### Usage
Image scaling:
![Image scaling in pgmagick][55]
[Image source code][56]
Edge extraction:
![Edge extraction in pgmagick][58]
[Image source code][59]
### 10\. Pycairo
[**Pycairo**][60] is a set of Python bindings for the [Cairo][61] graphics library. Cairo is a 2D graphics library for drawing vector graphics. Vector graphics are interesting because they don't lose clarity when resized or transformed. Pycairo can call Cairo commands from Python.
#### Resources
The Pycairo [GitHub repository][62] is a good resource with detailed instructions on installation and usage. There is also a [getting started guide][63], which has a brief tutorial on Pycairo.
#### Usage
Drawing lines, basic shapes, and radial gradients with Pycairo:
![Pycairo][65]
[Image source code][66]
### Conclusion
These are some of the useful and freely available image processing libraries in Python. Some are well known and others may be new to you. Try them out to get to know more about them!
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/3/python-image-manipulation-tools
作者：[Parul Pandey][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/parul-pandey
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/daisy_gimp_art_design.jpg?itok=6kCxAKWO
[2]: https://scikit-image.org/
[3]: http://docs.scipy.org/doc/numpy/reference/index.html#module-numpy
[4]: http://scikit-image.org/docs/stable/user_guide.html
[5]: /file/426206
[6]: https://opensource.com/sites/default/files/uploads/1-scikit-image.png (Image filtering in scikit-image)
[7]: http://scikit-image.org/docs/dev/auto_examples/features_detection/plot_template.html#sphx-glr-auto-examples-features-detection-plot-template-py
[8]: /file/426211
[9]: https://opensource.com/sites/default/files/uploads/2-scikit-image.png (Template matching in scikit-image)
[10]: https://scikit-image.org/docs/dev/auto_examples
[11]: http://www.numpy.org/
[12]: /file/426216
[13]: https://opensource.com/sites/default/files/uploads/3-numpy.png (NumPy)
[14]: https://www.scipy.org/
[15]: https://docs.scipy.org/doc/scipy/reference/ndimage.html#module-scipy.ndimage
[16]: https://docs.scipy.org/doc/scipy/reference/tutorial/ndimage.html#correlation-and-convolution
[17]: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.gaussian_filter.html
[18]: /file/426221
[19]: https://opensource.com/sites/default/files/uploads/4-scipy.png (Using a Gaussian filter in SciPy)
[20]: https://python-pillow.org/
[21]: https://pillow.readthedocs.io/en/3.1.x/index.html
[22]: /file/426226
[23]: https://opensource.com/sites/default/files/uploads/5-pillow.png (Enhancing an image in Pillow using ImageFilter)
[24]: http://sipi.usc.edu/database/
[25]: https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_setup/py_intro/py_intro.html
[26]: https://github.com/abidrahmank/OpenCV2-Python-Tutorials
[27]: /file/426236
[28]: https://opensource.com/sites/default/files/uploads/6-opencv.jpeg (Image blending using Pyramids in OpenCV-Python)
[29]: https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_pyramids/py_pyramids.html#pyramids
[30]: http://simplecv.org/
[31]: http://examples.simplecv.org/en/latest/
[32]: /file/426241
[33]: https://opensource.com/sites/default/files/uploads/7-_simplecv.png (SimpleCV)
[34]: https://mahotas.readthedocs.io/en/latest/
[35]: https://openresearchsoftware.metajnl.com/articles/10.5334/jors.ac/
[36]: https://mahotas.readthedocs.io/en/latest/install.html
[37]: https://blog.clarifai.com/wheres-waldo-using-machine-learning-to-find-all-the-waldos
[38]: /file/426246
[39]: https://opensource.com/sites/default/files/uploads/8-mahotas.png (Finding Wally problem in Mahotas)
[40]: https://mahotas.readthedocs.io/en/latest/wally.html
[41]: /file/426251
[42]: https://opensource.com/sites/default/files/uploads/9-mahotas.png (Finding Wally problem in Mahotas)
[43]: https://itk.org/
[44]: http://www.simpleitk.org/
[45]: https://itk.org/ITK/resources/resources.html
[46]: http://insightsoftwareconsortium.github.io/SimpleITK-Notebooks/
[47]: /file/426256
[48]: https://opensource.com/sites/default/files/uploads/10-simpleitk.gif (SimpleITK animation)
[49]: https://github.com/InsightSoftwareConsortium/SimpleITK-Notebooks/blob/master/Utilities/intro_animation.py
[50]: https://pypi.org/project/pgmagick/
[51]: http://www.graphicsmagick.org/
[52]: https://github.com/hhatto/pgmagick
[53]: https://pgmagick.readthedocs.io/en/latest/
[54]: /file/426261
[55]: https://opensource.com/sites/default/files/uploads/11-pgmagick.png (Image scaling in pgmagick)
[56]: https://pgmagick.readthedocs.io/en/latest/cookbook.html#scaling-a-jpeg-image
[57]: /file/426266
[58]: https://opensource.com/sites/default/files/uploads/12-pgmagick.png (Edge extraction in pgmagick)
[59]: https://pgmagick.readthedocs.io/en/latest/cookbook.html#edge-extraction
[60]: https://pypi.org/project/pycairo/
[61]: https://cairographics.org/
[62]: https://github.com/pygobject/pycairo
[63]: https://pycairo.readthedocs.io/en/latest/tutorial.html
[64]: /file/426271
[65]: https://opensource.com/sites/default/files/uploads/13-pycairo.png (Pycairo)
[66]: http://zetcode.com/gfx/pycairo/basicdrawing/

162
sources/tech/20190318 3 Ways To Check Whether A Port Is Open On The Remote Linux System.md Normal file
View File

@ -0,0 +1,162 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (3 Ways To Check Whether A Port Is Open On The Remote Linux System?)
[#]: via: (https://www.2daygeek.com/how-to-check-whether-a-port-is-open-on-the-remote-linux-system-server/)
[#]: author: (Magesh Maruthamuthu https://www.2daygeek.com/author/magesh/)
3 Ways To Check Whether A Port Is Open On The Remote Linux System?
======
This is an important topic, which is not only for Linux administrator and it will be very helpful for all.
I mean to say. It’s very useful for users who are working in IT Infra.
They have to check whether the port is open or not on Linux server before proceeding to next steps.
If it’s not open then they can directly ask the Linux admin to check on this.
If it’s open then we need to check with application team, etc,.
In this article, we will show you, how to check this using three methods.
It can be done using the following Linux commands.
* **`nc:`** Netcat is a simple Unix utility which reads and writes data across network connections, using TCP or UDP protocol.
* **`nmap:`** Nmap (“Network Mapper”) is an open source tool for network exploration and security auditing. It was designed to rapidly scan large networks.
* **`telnet:`** The telnet command is used for interactive communication with another host using the TELNET protocol.
### How To Check Whether A Port Is Open On The Remote Linux System Using nc (netcat) Command?
nc stands for netcat. Netcat is a simple Unix utility which reads and writes data across network connections, using TCP or UDP protocol.
It is designed to be a reliable “back-end” tool that can be used directly or easily driven by other programs and scripts.
At the same time, it is a feature-rich network debugging and exploration tool, since it can create almost any kind of connection you would need and has several interesting built-in capabilities.
Netcat has three main modes of functionality. These are the connect mode, the listen mode, and the tunnel mode.
**Common Syntax for nc (netcat):**
```
$ nc [-options] [HostName or IP] [PortNumber]
```
In this example, we are going to check whether the port 22 is open or not on the remote Linux system.
If it’s success then you will be getting the following output.
```
# nc -zvw3 192.168.1.8 22
Connection to 192.168.1.8 22 port [tcp/ssh] succeeded!
```
**Details:**
* **`nc:`** It’s a command.
* **`z:`** zero-I/O mode (used for scanning).
* **`v:`** For verbose.
* **`w3:`** timeout wait seconds
* **`192.168.1.8:`** Destination system IP.
* **`22:`** Port number needs to be verified.
If it’s fail then you will be getting the following output.
```
# nc -zvw3 192.168.1.95 22
nc: connect to 192.168.1.95 port 22 (tcp) failed: Connection refused
```
### How To Check Whether A Port Is Open On The Remote Linux System Using nmap Command?
Nmap (“Network Mapper”) is an open source tool for network exploration and security auditing. It was designed to rapidly scan large networks, although it works fine against single hosts.
Nmap uses raw IP packets in novel ways to determine what hosts are available on the network, what services (application name and version) those hosts are offering, what operating systems (and OS versions) they are running, what type of packet filters/firewalls are in use, and dozens of other characteristics.
While Nmap is commonly used for security audits, many systems and network administrators find it useful for routine tasks such as network inventory, managing service upgrade schedules, and monitoring host or service uptime.
**Common Syntax for nmap:**
```
$ nmap [-options] [HostName or IP] [-p] [PortNumber]
```
If it’s success then you will be getting the following output.
```
# nmap 192.168.1.8 -p 22
Starting Nmap 7.70 ( https://nmap.org ) at 2019-03-16 03:37 IST Nmap scan report for 192.168.1.8 Host is up (0.00031s latency).
PORT STATE SERVICE
22/tcp open ssh
Nmap done: 1 IP address (1 host up) scanned in 13.06 seconds
```
If it’s fail then you will be getting the following output.
```
# nmap 192.168.1.8 -p 80
Starting Nmap 7.70 ( https://nmap.org ) at 2019-03-16 04:30 IST
Nmap scan report for 192.168.1.8
Host is up (0.00036s latency).
PORT STATE SERVICE
80/tcp closed http
Nmap done: 1 IP address (1 host up) scanned in 13.07 seconds
```
### How To Check Whether A Port Is Open On The Remote Linux System Using telnet Command?
The telnet command is used for interactive communication with another host using the TELNET protocol.
**Common Syntax for telnet:**
```
$ telnet [HostName or IP] [PortNumber]
```
If it’s success then you will be getting the following output.
```
$ telnet 192.168.1.9 22
Trying 192.168.1.9...
Connected to 192.168.1.9.
Escape character is '^]'.
SSH-2.0-OpenSSH_5.3
^]
Connection closed by foreign host.
```
If it’s fail then you will be getting the following output.
```
$ telnet 192.168.1.9 80
Trying 192.168.1.9...
telnet: Unable to connect to remote host: Connection refused
```
We had found only the above three methods. If you found any other ways, please let us know by updating your query in the comments section.
--------------------------------------------------------------------------------
via: https://www.2daygeek.com/how-to-check-whether-a-port-is-open-on-the-remote-linux-system-server/
作者：[Magesh Maruthamuthu][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.2daygeek.com/author/magesh/
[b]: https://github.com/lujun9972

176
sources/tech/20190318 Building and augmenting libraries by calling Rust from JavaScript.md Normal file
View File

@ -0,0 +1,176 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Building and augmenting libraries by calling Rust from JavaScript)
[#]: via: (https://opensource.com/article/19/3/calling-rust-javascript)
[#]: author: (Ryan Levick https://opensource.com/users/ryanlevick)
Building and augmenting libraries by calling Rust from JavaScript
======
Explore how to use WebAssembly (Wasm) to embed Rust inside JavaScript.
![JavaScript in Vim][1]
In _[Why should you use Rust in WebAssembly?][2]_ , I looked at why you might want to write WebAssembly (Wasm), and why you might choose Rust as the language to do it in. Now I'll share what that looks like by exploring ways to embed Rust inside JavaScript.
This is something that separates Rust from Go, C#, and other languages with large runtimes that can compile to Wasm. Rust has a minimal runtime (basically just an allocator), making it easy to use Rust from JavaScript libraries. C and C++ have similar stories, but what sets Rust apart is its tooling, which we'll take a look at now.
### The basics
If you've never used Rust before, you'll first want to get that set up. It's pretty easy. First download [**Rustup**][3], which is a way to control versions of Rust and different toolchains for cross-compilation. This will give you access to [**Cargo**][4], which is the Rust build tool and package manager.
Now we have a decision to make. We can easily write Rust code that runs in the browser through WebAssembly, but if we want to do anything other than make people's CPU fans spin, we'll probably at some point want to interact with the Document Object Model (DOM) or use some JavaScript API. In other words: _we need JavaScript interop_ (aka the JavaScript interoperability API).
### The problem and the solutions
WebAssembly is an extremely simple machine language. If we want to be able to communicate with JavaScript, Wasm gives us only four data types to do it with: 32- and 64-bit floats and integers. Wasm doesn't have a concept of strings, arrays, objects, or any other rich data type. Basically, we can only pass around pointers between Rust and JavaScript. Needless to say, this is less than ideal.
The good news is there are two libraries that facilitate communication between Rust-based Wasm and JavaScript: [**wasm-bindgen**][5] and [**stdweb**][6]. The bad news, however, is these two libraries are unfortunately incompatible with each other. **wasm-bindgen** is lower-level than **stdweb** and attempts to provide full control over how JavaScript and Rust interact. In fact, there is even talk of [rewriting **stdweb** using **wasm-bindgen**][7], which would get rid of the issue of incompatibility.
Because **wasm-bindgen** is the lighter-weight option (and the option officially worked on by the official [Rust WebAssembly working group][8]), we'll focus at that.
### wasm-bindgen and wasm-pack
We're going to create a function that takes a string from JavaScript, makes it uppercase and prepends "HELLO, " to it, and returns it back to JavaScript. We'll call this function **excited_greeting**!
First, let's create our Rust library that will house this fabulous function:
```
$ cargo new my-wasm-library --lib
$ cd my-wasm-library
```
Now we'll want to replace the contents of **src/lib.rs** with our exciting logic. I think it's best to write the code out instead of copy/pasting.
```
// Include the `wasm_bindgen` attribute into the current namespace.
use wasm_bindgen::prelude::wasm_bindgen;
// This attribute makes calling Rust from JavaScript possible.
// It generates code that can convert the basic types wasm understands
// (integers and floats) into more complex types like strings and
// vice versa. If you're interested in how this works, check this out:
// <https://blog.ryanlevick.com/posts/wasm-bindgen-interop/>
#[wasm_bindgen]
// This is pretty plain Rust code. If you've written Rust before this
// should look extremely familiar. If not, why wait?! Check this out:
// <https://doc.rust-lang.org/book/>
pub fn excited_greeting(original: &str) -> String {
format!("HELLO, {}", original.to_uppercase())
}
```
Second, we'll have to make two changes to our **Cargo.toml** configuration file:
* Add **wasm_bindgen** as a dependency.
* Configure the type of library binary to be a **cdylib** or dynamic system library. In this case, our system is **wasm** , and setting this option is how we produce **.wasm** binary files.
```
[package]
name = "my-wasm-library"
version = "0.1.0"
authors = ["$YOUR_INFO"]
edition = "2018"
[lib]
crate-type = ["cdylib", "rlib"]
[dependencies]
wasm-bindgen = "0.2.33"
```
Now let's build! If we just use **cargo build** , we'll get a **.wasm** binary, but in order to make it easy to call our Rust code from JavaScript, we'd like to have some JavaScript code that converts rich JavaScript types like strings and objects to pointers and passes these pointers to the Wasm module on our behalf. Doing this manually is tedious and prone to bugs.
Luckily, in addition to being a library, **wasm-bindgen** also has the ability to create this "glue" JavaScript for us. This means in our code we can interact with our Wasm module using normal JavaScript types, and the generated code from **wasm-bindgen** will do the dirty work of converting these rich types into the pointer types that Wasm actually understands.
We can use the awesome **wasm-pack** to build our Wasm binary, invoke the **wasm-bindgen** CLI tool, and package all of our JavaScript (and any optional generated TypeScript types) into one nice and neat package. Let's do that now!
First we'll need to install **wasm-pack** :
```
$ cargo install wasm-pack
```
By default, **wasm-bindgen** produces ES6 modules. We'll use our code from a simple script tag, so we just want it to produce a plain old JavaScript object that gives us access to our Wasm functions. To do this, we'll pass it the **\--target no-modules** option.
```
$ wasm-pack build --target no-modules
```
We now have a **pkg** directory in our project. If we look at the contents, we'll see the following:
* **package.json** : useful if we want to package this up as an NPM module
* **my_wasm_library_bg.wasm** : our actual Wasm code
* **my_wasm_library.js** : the JavaScript "glue" code
* Some TypeScript definition files
Now we can create an **index.html** file that will make use of our JavaScript and Wasm:
```
<[html][9]>
<[head][10]>
<[meta][11] content="text/html;charset=utf-8" http-equiv="Content-Type" />
</[head][10]>
<[body][12]>
<!-- Include our glue code -->
<[script][13] src='./pkg/my_wasm_library.js'></[script][13]>
<!-- Include our glue code -->
<[script][13]>
window.addEventListener('load', async () => {
// Load the wasm file
await wasm_bindgen('./pkg/my_wasm_library_bg.wasm');
// Once it's loaded the `wasm_bindgen` object is populated
// with the functions defined in our Rust code
const greeting = wasm_bindgen.excited_greeting("Ryan")
console.log(greeting)
});
</[script][13]>
</[body][12]>
</[html][9]>
```
You may be tempted to open the HTML file in your browser, but unfortunately, this is not possible. For security reasons, Wasm files have to be served from the same domain as the HTML file. You'll need an HTTP server. If you have a favorite static HTTP server that can serve files from your filesystem, feel free to use that. I like to use [**basic-http-server**][14], which you can install and run like so:
```
$ cargo install basic-http-server
$ basic-http-server
```
Now open the **index.html** file through the web server by going to **<http://localhost:4000/index.html>** and check your JavaScript console. You should see a very exciting greeting there!
If you have any questions, please [let me know][15]. Next time, we'll take a look at how we can use various browser and JavaScript APIs from within our Rust code.
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/3/calling-rust-javascript
作者：[Ryan Levick][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/ryanlevick
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/javascript_vim.jpg?itok=mqkAeakO (JavaScript in Vim)
[2]: https://opensource.com/article/19/2/why-use-rust-webassembly
[3]: https://rustup.rs/
[4]: https://doc.rust-lang.org/cargo/
[5]: https://github.com/rustwasm/wasm-bindgen
[6]: https://github.com/koute/stdweb
[7]: https://github.com/koute/stdweb/issues/318
[8]: https://www.rust-lang.org/governance/wgs/wasm
[9]: http://december.com/html/4/element/html.html
[10]: http://december.com/html/4/element/head.html
[11]: http://december.com/html/4/element/meta.html
[12]: http://december.com/html/4/element/body.html
[13]: http://december.com/html/4/element/script.html
[14]: https://github.com/brson/basic-http-server
[15]: https://twitter.com/ryan_levick

107
sources/tech/20190318 How to host your own webfonts.md Normal file
View File

@ -0,0 +1,107 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (How to host your own webfonts)
[#]: via: (https://opensource.com/article/19/3/webfonts)
[#]: author: (Seth Kenlon (Red Hat, Community Moderator) https://opensource.com/users/seth)
How to host your own webfonts
======
### Customize your website by self-hosting openly licensed fonts.
![Open source fonts][1]
Fonts are often a mystery to many computer users. For example, have you designed a cool flyer and, when you take the file somewhere for printing, find all the titles rendered in Arial because the printer doesn't have the fancy font you used in your design? There are ways to prevent this, of course: you can convert words in special fonts into paths, bundle fonts into a PDF, bundle open source fonts with your design files, or—at least—list the fonts required. And yet it's still a problem because we're human and we're forgetful.
The web has the same sort of problem. If you have even a basic understanding of CSS, you've probably seen this kind of declaration:
```
h1 { font-family: "Times New Roman", Times, serif; }
```
This is a designer's attempt to define a specific font, provide a fallback if a user doesn't have Times New Roman installed, and offer yet another fallback if the user doesn't have Times either. It's better than using a graphic instead of text, but it's still an awkward, inelegant method of font non-management, However, in the early-ish days of the web, it's all we had to work with.
### Webfonts
Then webfonts happened, moving font management from the client to the server. Fonts on websites were rendered for the client by the server, rather than requiring the web browser to find a font on the user's system. Google and other providers even host openly licensed fonts, which designers can include on their sites with a simple CSS rule.
The problem with this free convenience, of course, is that it doesn't come without cost. It's $0 to use, but major sites like Google love to keep track of who references their data, fonts included. If you don't see a need to assist Google in building a record of everyone's activity on the web, the good news is you can host your own webfonts, and it's as simple as uploading fonts to your host and using one easy CSS rule. As a side benefit, your site may load faster, as you'll be making one fewer external call upon loading each page.
### Self-hosted webfonts
The first thing you need is an openly licensed font. This can be confusing if you're not used to thinking or caring about obscure software licenses, especially since it seems like all fonts are free. Very few of us have consciously paid for a font, and yet most people have high-priced fonts on their computers. Thanks to licensing deals, your computer may have shipped with fonts that [you aren't legally allowed to copy and redistribute][2]. Fonts like Arial, Verdana, Calibri, Georgia, Impact, Lucida and Lucida Grande, Times and Times New Roman, Trebuchet, Geneva, and many others are owned by Microsoft, Apple, and Adobe. If you purchased a computer preloaded with Windows or MacOS, you paid for the right to use the bundled fonts, but you don't own those fonts and are not permitted to upload them to a web server (unless otherwise stated).
Fortunately, the open source craze hit the font world long ago, and there are excellent collections of openly licensed fonts from collectives and projects like [The League of Moveable Type][3], [Font Library][4], [Omnibus Type][5], and even [Google][6] and [Adobe][7].
You can use most common font file formats, including TTF, OTF, WOFF, EOT, and so on. Since Sorts Mill Goudy includes a WOFF (Web Open Font Format, developed in part by Mozilla) version, I'll use it in this example. However, other formats work the same way.
Assuming you want to use [Sorts Mill Goudy][8] on your web page:
1. Upload the **GoudyStM-webfont.woff** file to your web server:
```
scp GoudyStM-webfont.woff seth@example.com:~/www/fonts/
```
Your host may also provide a graphical upload tool through cPanel or a similar web control panel.
2. In your site's CSS file, add an **@font-face** rule, similar to this:
```
@font-face {
  font-family: "titlefont";
  src: url("../fonts/GoudyStM-webfont.woff");
}
```
The **font-family** value is something you make up. It's a human-friendly name for whatever the font face represents. I am using "titlefont" in this example because I imagine this font will be used for the main titles on an imaginary site. You could just as easily use "officialfont" or "myfont."
The **src** value is the path to the font file. The path to the font must be appropriate for your server's file structure; in this example, I have the **fonts** directory alongside a **css** directory. You may not have your site structured that way, so adjust the paths as needed, remembering that a single dot means _this folder_ and two dots mean _a folder back_.
3. Now that you've defined the font face name and the location, you can call it for any given CSS class or ID you desire. For example, if you want **< h1>** to render in the Sorts Mill Goudy font, then make its CSS rule use your custom font name:
```
h1 { font-family: "titlefont", serif; }
```
You're now hosting and using your own fonts.
![Web fonts on a website][10]
_Thanks to Alexandra Kanik for teaching me about @font-face and most everything else I know about good web design._
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/3/webfonts
作者：[Seth Kenlon (Red Hat, Community Moderator)][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/seth
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/life_typography_fonts.png?itok=Q1jMys5G (Open source fonts)
[2]: https://docs.microsoft.com/en-us/typography/fonts/font-faq
[3]: https://www.theleagueofmoveabletype.com/
[4]: https://fontlibrary.org/
[5]: https://www.omnibus-type.com
[6]: https://github.com/googlefonts
[7]: https://github.com/adobe-fonts
[8]: https://www.theleagueofmoveabletype.com/sorts-mill-goudy
[9]: /file/426056
[10]: https://opensource.com/sites/default/files/uploads/webfont.jpg (Web fonts on a website)

108
sources/tech/20190318 Solus 4 ‘Fortitude- Released with Significant Improvements.md Normal file
View File

@ -0,0 +1,108 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Solus 4 ‘Fortitude’ Released with Significant Improvements)
[#]: via: (https://itsfoss.com/solus-4-release)
[#]: author: (Ankush Das https://itsfoss.com/author/ankush/)
Solus 4 ‘Fortitude’ Released with Significant Improvements
======
Finally, after a year of work, the much anticipated Solus 4 is here. It’s a significant release not just because this is a major upgrade, but also because this is the first major release after [Ikey Doherty (the founder of Solus) left the project][1] a few months ago.
Now that everything’s under control with the new _management_ , **Solus 4 Fortitude** with updated Budgie desktop and other significant improvements has officially released.
### What’s New in Solus 4
![Solus 4 Fortitude][2]
#### Core Improvements
Solus 4 comes loaded with **[Linux Kernel 4.20.16][3]** which enables better hardware support (like Touchpad support, improved support for Intel Coffee Lake and Ice Lake CPUs, and for AMD Picasso & Raven2 APUs).
This release also ships with the latest [FFmpeg 4.1.1][4]. Also, they have enabled the support for [dav1d][5] in [VLC][6] – which is an open source AV1 decoder. So, you can consider these upgrades to significantly improve the Multimedia experience.
It also includes some minor fixes to the Software Center – if you were encountering any issues while finding an application or viewing the description.
In addition, WPS Office has been removed from the listing.
#### UI Improvements
![Budgie 10.5][7]
The Budgie desktop update includes some minor changes and also comes baked in with the [Plata (Noir) GTK Theme.][8]
You will no longer observe same applications multiple times in the menu, they’ve fixed this. They have also introduced a “ **Caffeine** ” mode as applet which prevents the system from suspending, locking the screen or changing the brightness while you are working. You can schedule the time accordingly.
![Caffeine Mode][9]
The new Budgie desktop experience also adds quick actions to the app icons on the task bar, dubbed as “ **Icon Tasklist** “. It makes it easy to manage the active tabs on a browser or the actions to minimize and move it to a new workplace (as shown in the image below).
![Icon Tasklist][10]
As the [change log][11] mentions, the above pop over design lets you do more:
* _Close all instances of the selected application_
* _Easily access per-window controls for marking it always on top, maximizing / unmaximizing, minimizing, and moving it to various workspaces._
* _Quickly favorite / unfavorite apps_
* _Quickly launch a new instance of the selected application_
* _Scroll up or down on an IconTasklist button when a single window is open to activate and bring it into focus, or minimize it, based on the scroll direction._
* _Toggle to minimize and unminimize various application windows_
The notification area now groups the notifications from specific applications instead of piling it all up. So, that’s a good improvement.
In addition to these, the sound widget got some cool improvements while letting you personalize the look and feel of your desktop in an efficient manner.
To know about all the nitty-gritty details, do refer the official [release note][11]s.
### Download Solus 4
You can get the latest version of Solus from its download page below. It is available in the default Budgie, GNOME and MATE desktop flavors.
[Get Solus 4][12]
### Wrapping Up**
Solus 4 is definitely an impressive upgrade – without introducing any unnecessary fancy features but by adding only the useful ones, subtle changes.
What do you think about the latest Solus 4 Fortitude? Have you tried it yet?
Let us know your thoughts in the comments below.
--------------------------------------------------------------------------------
via: https://itsfoss.com/solus-4-release
作者：[Ankush Das][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://itsfoss.com/author/ankush/
[b]: https://github.com/lujun9972
[1]: https://itsfoss.com/ikey-leaves-solus/
[2]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/solus-4-featured.jpg?fit=800%2C450&ssl=1
[3]: https://itsfoss.com/kernel-4-20-release/
[4]: https://www.ffmpeg.org/
[5]: https://code.videolan.org/videolan/dav1d
[6]: https://www.videolan.org/index.html
[7]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/Budgie-desktop.jpg?resize=800%2C450&ssl=1
[8]: https://gitlab.com/tista500/plata-theme
[9]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/caffeine-mode.jpg?ssl=1
[10]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/IconTasklistPopover.jpg?ssl=1
[11]: https://getsol.us/2019/03/17/solus-4-released/
[12]: https://getsol.us/download/
[13]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/Budgie-desktop.jpg?fit=800%2C450&ssl=1
[14]: https://www.facebook.com/sharer.php?t=Solus%204%20%E2%80%98Fortitude%E2%80%99%20Released%20with%20Significant%20Improvements&u=https%3A%2F%2Fitsfoss.com%2Fsolus-4-release%2F
[15]: https://twitter.com/intent/tweet?text=Solus+4+%E2%80%98Fortitude%E2%80%99+Released+with+Significant+Improvements&url=https%3A%2F%2Fitsfoss.com%2Fsolus-4-release%2F&via=itsfoss2
[16]: https://www.linkedin.com/shareArticle?title=Solus%204%20%E2%80%98Fortitude%E2%80%99%20Released%20with%20Significant%20Improvements&url=https%3A%2F%2Fitsfoss.com%2Fsolus-4-release%2F&mini=true
[17]: https://www.reddit.com/submit?title=Solus%204%20%E2%80%98Fortitude%E2%80%99%20Released%20with%20Significant%20Improvements&url=https%3A%2F%2Fitsfoss.com%2Fsolus-4-release%2F

50
sources/tech/20190319 Blockchain 2.0- Blockchain In Real Estate -Part 4.md Normal file
View File

@ -0,0 +1,50 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Blockchain 2.0: Blockchain In Real Estate [Part 4])
[#]: via: (https://www.ostechnix.com/blockchain-2-0-blockchain-in-real-estate/)
[#]: author: (EDITOR https://www.ostechnix.com/author/editor/)
Blockchain 2.0: Blockchain In Real Estate [Part 4]
======
![](https://www.ostechnix.com/wp-content/uploads/2019/03/Blockchain-In-Real-Estate-720x340.png)
### Blockchain 2.0: Smart‘er’ Real Estate
The [**previous article**][1] of this series explored the features of blockchain which will enable institutions to transform and interlace **traditional banking** and **financing systems** with it. This part will explore – **Blockchain in real estate**. The real estate industry is ripe for a revolution. It’s among the most actively traded most significant asset classes known to man. However, filled with regulatory hurdles and numerous possibilities of fraud and deceit, it’s also one of the toughest to participate in. The distributed ledger capabilities of the blockchain utilizing an appropriate consensus algorithm are touted as the way forward for the industry which is traditionally regarded as conservative in its attitude to change.
Real estate has always been a very conservative industry in terms of its myriad operations. Somewhat rightfully so as well. A major economic crisis such as the 2008 financial crisis or the great depression from the early half of the 20th century managed to destroy the industry and its participants. However, like most products of economic value, the real estate industry is resilient and this resilience is rooted in its conservative nature.
The global real estate market comprises an asset class worth **$228 trillion dollars** [1]. Give or take. Other investment assets such as stocks, bonds, and shares combined are only worth **$170 trillion**. Obviously, any and all transactions implemented in such an industry is naturally carefully planned and meticulously executed, for the most part. For the most part, because real estate is also notorious for numerous instances of fraud and devastating loses which ensue them. The industry because of the very conservative nature of its operations is also tough to navigate. It’s heavily regulated with complex laws creating an intertwined web of nuances that are just too difficult for an average person to understand fully. This makes entry and participation near impossible for most people. If you’ve ever been involved in one such deal, you’ll know how heavy and long the paper trail was.
This hard reality is now set to change, albeit a slow and gradual transformation. The very reasons the industry has stuck to its hardy tested roots all this while can finally give way to its modern-day counterpart. The backbone of the real estate industry has always been its paper records. Land deeds, titles, agreements, rental insurance, proofs, and declarations etc., are just the tip of the iceberg here. If you’ve noticed the pattern here, this should be obvious, the distributed ledger technology that is blockchain, fits in perfectly with the needs here. Forget paper records, conventional database systems are also points of major failure. They can be modified by multiple participants, is not tamper proof or un-hackable, has a complicated set of ever-changing regulatory parameters making auditing and verifying data a nightmare. The blockchain perfectly solves all of these issues and more.
Starting with a trivial albeit an important example to show just how bad the current record management practices are in the real estate sector, consider the **Title Insurance business** [2], [3]. Title Insurance is used to hedge against the possibility of the land’s titles and ownership records being inadmissible and hence unenforceable. An insurance product such as this is also referred to as an indemnity cover. It is by law required in many cases that properties have title insurance, especially when dealing with property that has changed hands multiple times over the years. Mortgage firms might insist on the same as well when they back real estate deals. The fact that a product of this kind has existed since the 1850s and that it does business worth at least **$1.5 trillion a year in the US alone** is a testament to the statement at the start. A revolution in terms of how these records are maintained is imperative to have in this situation and the blockchain provides a sustainable solution. Title fraud averages around $100k per case on average as per the **American Land Title Association** and 25% of all titles involved in transactions have an issue regarding their documents[4]. The blockchain allows for setting up an immutable permanent database that will track the property itself, recording each and every transaction or investment that has gone into it. Such a ledger system will make life easier for everyone involved in the real estate industry including one-time home buyers and make financial products such as Title Insurance basically irrelevant. Converting a physical asset such as real estate to a digital asset like this is unconventional and is extant only in theory at the moment. However, such a change is imminent sooner rather than later[5].
Among the areas in which blockchain will have the most impact within real estate is as highlighted above in maintaining a transparent and secure title management system for properties. A blockchain based record of the property can contain information about the property, its location, history of ownership, and any related public record of the same[6]. This will permit closing real estate deals fast and obliviates the need for 3rd party monitoring and oversight. Tasks such as real estate appraisal and tax calculations become matters of tangible objective parameters rather than subjective measures and guesses because of reliable historical data which is publicly verifiable. **UBITQUITY** is one such platform that offers customized blockchain-based solutions to enterprise customers. The platform allows customers to keep track of all property details, payment records, mortgage records and even allows running smart contracts that’ll take care of taxation and leasing automatically[7].
This brings us to the second biggest opportunity and use case of blockchains in real estate. Since the sector is highly regulated by numerous 3rd parties apart from the counterparties involved in the trade, due-diligence and financial evaluations can be significantly time-consuming. These processes are predominantly carried out using offline channels and paperwork needs to travel for days before a final evaluation report comes out. This is especially true for corporate real estate deals and forms a bulk of the total billable hours charged by consultants. In case the transaction is backed by a mortgage, duplication of these processes is unavoidable. Once combined with digital identities for the people and institutions involved along with the property, the current inefficiencies can be avoided altogether and transactions can take place in a matter of seconds. The tenants, investors, institutions involved, consultants etc., could individually validate the data and arrive at a critical consensus thereby validating the property records for perpetuity[8]. This increases the accuracy of verification manifold. Real estate giant **RE/MAX** has recently announced a partnership with service provider **XYO Network Partners** for building a national database of real estate listings in Mexico. They hope to one day create one of the largest (as of yet) decentralized real estate title registry in the world[9].
However, another significant and arguably a very democratic change that the blockchain can bring about is with respect to investing in real estate. Unlike other investment asset classes where even small household investors can potentially participate, real estate often requires large hands-down payments to participate. Companies such as **ATLANT** and **BitOfProperty** tokenize the book value of a property and convert them into equivalents of a cryptocurrency. These tokens are then put for sale on their exchanges similar to how stocks and shares are traded. Any cash flow that the real estate property generates afterward is credited or debited to the token owners depending on their “share” in the property[4].
However, even with all of that said, Blockchain technology is still in very early stages of adoption in the real estate sector and current regulations are not exactly defined for it to be either[8]. Concepts such as distributed applications, distributed anonymous organizations, smart contracts etc., are unheard of in the legal domain in many countries. A complete overhaul of existing regulations and guidelines once all the stakeholders are well educated on the intricacies of the blockchain is the most pragmatic way forward. Again, it’ll be a slow and gradual change to go through, however a much-needed one nonetheless. The next article of the series will look at how **“Smart Contracts”** , such as those implemented by companies such as UBITQUITY and XYO are created and executed in the blockchain.
--------------------------------------------------------------------------------
via: https://www.ostechnix.com/blockchain-2-0-blockchain-in-real-estate/
作者：[EDITOR][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.ostechnix.com/author/editor/
[b]: https://github.com/lujun9972
[1]: https://www.ostechnix.com/blockchain-2-0-redefining-financial-services/

342
sources/tech/20190319 Five Commands To Use Calculator In Linux Command Line.md Normal file
View File

@ -0,0 +1,342 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Five Commands To Use Calculator In Linux Command Line?)
[#]: via: (https://www.2daygeek.com/linux-command-line-calculator-bc-calc-qalc-gcalccmd/)
[#]: author: (Magesh Maruthamuthu https://www.2daygeek.com/author/magesh/)
Five Commands To Use Calculator In Linux Command Line?
======
As a Linux administrator you may use the command line calculator many times in a day for some purpose.
I had used this especially when LVM creation using the PE values.
There are many commands available for this purpose and i’m going to list most used commands in this article.
These command line calculators are allow us to perform all kind of actions such as scientific, financial, or even simple calculation.
Also, we can use these commands in shell scripts for complex math.
In this article, I’m listing the top five command line calculator commands.
Those command line calculator commands are below.
* **`bc:`** An arbitrary precision calculator language
* **`calc:`** arbitrary precision calculator
* **`expr:`** evaluate expressions
* **`gcalccmd:`** gnome-calculator – a desktop calculator
* **`qalc:`**
* **`Linux Shell:`**
### How To Perform Calculation In Linux Using bc Command?
bs stands for Basic Calculator. bc is a language that supports arbitrary precision numbers with interactive execution of statements. There are some similarities in the syntax to the C programming language.
A standard math library is available by command line option. If requested, the math library is defined before processing any files. bc starts by processing code from all the files listed on the command line in the order listed.
After all files have been processed, bc reads from the standard input. All code is executed as it is read.
By default bc command has installed in all the Linux system. If not, use the following procedure to install it.
For **`Fedora`** system, use **[DNF Command][1]** to install bc.
```
$ sudo dnf install bc
```
For **`Debian/Ubuntu`** systems, use **[APT-GET Command][2]** or **[APT Command][3]** to install bc.
```
$ sudo apt install bc
```
For **`Arch Linux`** based systems, use **[Pacman Command][4]** to install bc.
```
$ sudo pacman -S bc
```
For **`RHEL/CentOS`** systems, use **[YUM Command][5]** to install bc.
```
$ sudo yum install bc
```
For **`openSUSE Leap`** system, use **[Zypper Command][6]** to install bc.
```
$ sudo zypper install bc
```
### How To Use The bc Command To Perform Calculation In Linux?
We can use the bc command to perform all kind of calculation right from the terminal.
```
$ bc
bc 1.07.1
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006, 2008, 2012-2017 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.
1+2
3
10-5
5
2*5
10
10/2
5
(2+4)*5-5
25
quit
```
Use `-l` flag to define the standard math library.
```
$ bc -l
bc 1.07.1
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006, 2008, 2012-2017 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.
3/5
.60000000000000000000
quit
```
### How To Perform Calculation In Linux Using calc Command?
calc is an arbitrary precision calculator. It’s a simple calculator that allow us to perform all kind of calculation in Linux command line.
For **`Fedora`** system, use **[DNF Command][1]** to install calc.
```
$ sudo dnf install calc
```
For **`Debian/Ubuntu`** systems, use **[APT-GET Command][2]** or **[APT Command][3]** to install calc.
```
$ sudo apt install calc
```
For **`Arch Linux`** based systems, use **[Pacman Command][4]** to install calc.
```
$ sudo pacman -S calc
```
For **`RHEL/CentOS`** systems, use **[YUM Command][5]** to install calc.
```
$ sudo yum install calc
```
For **`openSUSE Leap`** system, use **[Zypper Command][6]** to install calc.
```
$ sudo zypper install calc
```
### How To Use The calc Command To Perform Calculation In Linux?
We can use the calc command to perform all kind of calculation right from the terminal.
Intractive mode
```
$ calc
C-style arbitrary precision calculator (version 2.12.7.1)
Calc is open software. For license details type: help copyright
[Type "exit" to exit, or "help" for help.]
; 5+1
6
; 5-1
4
; 5*2
10
; 10/2
5
; quit
```
Non-Intractive mode
```
$ calc 3/5
0.6
```
### How To Perform Calculation In Linux Using expr Command?
Print the value of EXPRESSION to standard output. A blank line below separates increasing precedence groups. It’s part of coreutils so, we no need to install it.
### How To Use The expr Command To Perform Calculation In Linux?
Use the following format for basic calculations.
For addition
```
$ expr 5 + 1
6
```
For subtraction
```
$ expr 5 - 1
4
```
For division.
```
$ expr 10 / 2
5
```
### How To Perform Calculation In Linux Using gcalccmd Command?
gnome-calculator is the official calculator of the GNOME desktop environment. gcalccmd is the console version of Gnome Calculator utility. By default it has installed in the GNOME desktop.
### How To Use The gcalccmd Command To Perform Calculation In Linux?
I have added few examples on this.
```
$ gcalccmd
> 5+1
6
> 5-1
4
> 5*2
10
> 10/2
5
> sqrt(16)
4
> 3/5
0.6
> quit
```
### How To Perform Calculation In Linux Using qalc Command?
Qalculate is a multi-purpose cross-platform desktop calculator. It is simple to use but provides power and versatility normally reserved for complicated math packages, as well as useful tools for everyday needs (such as currency conversion and percent calculation).
Features include a large library of customizable functions, unit calculations and conversion, symbolic calculations (including integrals and equations), arbitrary precision, uncertainty propagation, interval arithmetic, plotting, and a user-friendly interface (GTK+ and CLI).
For **`Fedora`** system, use **[DNF Command][1]** to install qalc.
```
$ sudo dnf install libqalculate
```
For **`Debian/Ubuntu`** systems, use **[APT-GET Command][2]** or **[APT Command][3]** to install qalc.
```
$ sudo apt install libqalculate
```
For **`Arch Linux`** based systems, use **[Pacman Command][4]** to install qalc.
```
$ sudo pacman -S libqalculate
```
For **`RHEL/CentOS`** systems, use **[YUM Command][5]** to install qalc.
```
$ sudo yum install libqalculate
```
For **`openSUSE Leap`** system, use **[Zypper Command][6]** to install qalc.
```
$ sudo zypper install libqalculate
```
### How To Use The qalc Command To Perform Calculation In Linux?
I have added few examples on this.
```
$ qalc
> 5+1
5 + 1 = 6
> ans*2
ans * 2 = 12
> ans-2
ans - 2 = 10
> 1 USD to INR
It has been 36 day(s) since the exchange rates last were updated.
Do you wish to update the exchange rates now? y
error: Failed to download exchange rates from coinbase.com: Resolving timed out after 15000 milliseconds.
1 * dollar = approx. INR 69.638581
> 10 USD to INR
10 * dollar = approx. INR 696.38581
> quit
```
### How To Perform Calculation In Linux Using Linux Shell Command?
We can use the shell commands such as echo, awk, etc to perform the calculation.
For Addition using echo command.
```
$ echo $((5+5))
10
```
--------------------------------------------------------------------------------
via: https://www.2daygeek.com/linux-command-line-calculator-bc-calc-qalc-gcalccmd/
作者：[Magesh Maruthamuthu][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.2daygeek.com/author/magesh/
[b]: https://github.com/lujun9972
[1]: https://www.2daygeek.com/dnf-command-examples-manage-packages-fedora-system/
[2]: https://www.2daygeek.com/apt-get-apt-cache-command-examples-manage-packages-debian-ubuntu-systems/
[3]: https://www.2daygeek.com/apt-command-examples-manage-packages-debian-ubuntu-systems/
[4]: https://www.2daygeek.com/pacman-command-examples-manage-packages-arch-linux-system/
[5]: https://www.2daygeek.com/yum-command-examples-manage-packages-rhel-centos-systems/
[6]: https://www.2daygeek.com/zypper-command-examples-manage-packages-opensuse-system/

365
sources/tech/20190319 How To Set Up a Firewall with GUFW on Linux.md Normal file
View File

@ -0,0 +1,365 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (How To Set Up a Firewall with GUFW on Linux)
[#]: via: (https://itsfoss.com/set-up-firewall-gufw)
[#]: author: (Sergiu https://itsfoss.com/author/sergiu/)
How To Set Up a Firewall with GUFW on Linux
======
**UFW (Uncomplicated Firewall)** is a simple to use firewall utility with plenty of options for most users. It is an interface for the **iptables** , which is the classic (and harder to get comfortable with) way to set up rules for your network.
**Do you really need a firewall for desktop?**
![][1]
A **[firewall][2]** is a way to regulate the incoming and outgoing traffic on your network. A well-configured firewall is crucial for the security of servers.
But what about normal, desktop users? Do you need a firewall on your Linux system? Most likely you are connected to internet via a router linked to your internet service provider (ISP). Some routers already have built-in firewall. On top of that, your actual system is hidden behind NAT. In other words, you probably have a security layer when you are on your home network.
Now that you know you should be using a firewall on your system, let’s see how you can easily install and configure a firewall on Ubuntu or any other Linux distribution.
### Setting Up A Firewall With GUFW
**[GUFW][3]** is a graphical utility for managing [Uncomplicated Firewall][4] ( **UFW** ). In this guide, I’ll go over configuring a firewall using **GUFW** that suits your needs, going over the different modes and rules.
But first, let’s see how to install GUFW.
#### Installing GUFW on Ubuntu and other Linux
GUFW is available in all major Linux distributions. I advise using your distribution’s package manager for installing GUFW.
If you are using Ubuntu, make sure you have the Universe Repository enabled. To do that, open up a terminal (default hotkey**:** CTRL+ALT+T) and enter:
```
sudo add-apt-repository universe
sudo apt update -y
```
Now you can install GUFW with this command:
```
sudo apt install gufw -y
```
That’s it! If you prefer not touching the terminal, you can install it from the Software Center as well.
Open Software Center and search for **gufw** and click on the search result.
![Search for gufw in software center][5]
Go ahead and click **Install**.
![Install GUFW from the Software Center][6]
To open **gufw** , go to your menu and search for it.
![Start GUFW][7]
This will open the firewall application and you’ll be greeted by a “ **Getting Started** ” section.
![GUFW Interface and Welcome Screen][8]
#### Turn on the firewall
The first thing to notice about this menu is the **Status** toggle. Pressing this button will turn on/off the firewall ( **default:** off), applying your preferences (policies and rules).
![Turn on the firewall][9]
If turned on, the shield icon turn from grey to colored. The colors, as noted later in this article, reflect your policies. This will also make the firewall **automatically start** on system startup.
**Note:** _**Home** will be turned **off** by default. The other profiles (see next section) will be turned **on.**_
#### Understanding GUFW and its profiles
As you can see in the menu, you can select different **profiles**. Each profile comes with different **default policies**. What this means is that they offer different behaviors for incoming and outgoing traffic.
The **default profiles** are:
* Home
* Public
* Office
You can select another profile by clicking on the current one ( **default: Home** ).
![][10]
Selecting one of them will modify the default behavior. Further down, you can change Incoming and Outgoing traffic preferences.
By default, both in **Home** and in **Office** , these policies are **Deny Incoming** and **Allow Outgoing**. This enables you to use services such as http/https without letting anything get in ( **e.g.** ssh).
For **Public** , they are **Reject Incoming** and **Allow Outgoing**. **Reject** , similar to **deny** , doesn’t let services in, but also sends feedback to the user/service that tried accessing your machine (instead of simply dropping/hanging the connection).
Note
If you are an average desktop user, you can stick with the default profiles. You’ll have to manually change the profiles if you change the network.
So if you are travelling, set the firewall on public profile and the from here forwards, firewall will be set in public mode on each reboot.
#### Configuring firewall rules and policies [for advanced users]
All profiles use the same rules, only the policies the rules build upon will differ. Changing the behavior of a policy ( **Incoming/Outgoing** ) will apply the changes to the selected profile.
Note that the policies can only be changed while the firewall is active (Status: ON).
Profiles can easily be added, deleted and renamed from the **Preferences** menu.
##### Preferences
In the top bar, click on **Edit**. Select **Preferences**.
![Open Preferences Menu in GUFW][11]
This will open up the **Preferences** menu.
![][12]
Let’s go over the options you have here!
**Logging** means exactly what you would think: how much information does the firewall write down in the log files.
The options under **Gufw** are quite self-explanatory.
In the section under **Profiles** is where we can add, delete and rename profiles. Double-clicking on a profile will allow you to **rename** it. Pressing **Enter** will complete this process and pressing **Esc** will cancel the rename.
![][13]
To **add** a new profile, click on the **+** under the list of profiles. This will add a new profile. However, it won’t notify you about it. You’ll also have to scroll down the list to see the profile you created (using the mouse wheel or the scroll bar on the right side of the list).
**Note:** _The newly added profile will **Deny Incoming** and **Allow Outgoing** traffic._
![][14]
Clicking a profile highlight that profile. Pressing the **–** button will **delete** the highlighted profile.
![][15]
**Note:** _You can’t rename/remove the currently selected profile_.
You can now click on **Close**. Next, I’ll go into setting up different **rules**.
##### Rules
Back to the main menu, somewhere in the middle of the screen you can select different tabs ( **Home, Rules, Report, Logs)**. We already covered the **Home** tab (that’s the quick guide you see when you start the app).
![][16]
Go ahead and select **Rules**.
![][17]
This will be the bulk of your firewall configuration: networking rules. You need to understand the concepts UFW is based on. That is **allowing, denying, rejecting** and **limiting** traffic.
**Note:** _In UFW, the rules apply from top to bottom (the top rules take effect first and on top of them are added the following ones)._
**Allow, Deny, Reject, Limit:**These are the available policies for the rules you’ll add to your firewall.
Let’s see exactly what each of them means:
* **Allow:** allows any entry traffic to a port
* **Deny:** denies any entry traffic to a port
* **Reject:** denies any entry traffic to a port and informs the requester about the rejection
* **Limit:** denies entry traffic if an IP address has attempted to initiate 6 or more connections in the last 30 seconds
##### Adding Rules
There are three ways to add rules in GUFW. I’ll present all three methods in the following section.
**Note:** _After you added the rules, changing their order is a very tricky process and it’s easier to just delete them and add them in the right order._
But first, click on the **+** at the bottom of the **Rules** tab.
![][18]
This should open a pop-up menu ( **Add a Firewall Rule** ).
![][19]
At the top of this menu, you can see the three ways you can add rules. I’ll guide you through each method i.e. **Preconfigured, Simple, Advanced**. Click to expand each section.
**Preconfigured Rules**
This is the most beginner-friendly way to add rules.
The first step is choosing a policy for the rule (from the ones detailed above).
![][20]
The next step is to choose the direction the rule will affect ( **Incoming, Outgoing, Both** ).
![][21]
The **Category** and **Subcategory** choices are plenty. These narrow down the **Applications** you can select
Choosing an **Application** will set up a set of ports based on what is needed for that particular application. This is especially useful for apps that might operate on multiple ports, or if you don’t want to bother with manually creating rules for handwritten port numbers.
If you wish to further customize the rule, you can click on the **orange arrow icon**. This will copy the current settings (Application with it’s ports etc.) and take you to the **Advanced** rule menu. I’ll cover that later in this article.
For this example, I picked an **Office Database** app: **MySQL**. I’ll deny all incoming traffic to the ports used by this app.
To create the rule, click on **Add**.
![][22]
You can now **Close** the pop-up (if you don’t want to add any other rules). You can see that the rule has been successfully added.
![][23]
The ports have been added by GUFW, and the rules have been automatically numbered. You may wonder why are there two new rules instead of just one; the answer is that UFW automatically adds both a standard **IP** rule and an **IPv6** rule.
**Simple Rules**
Although setting up preconfigured rules is nice, there is another easy way to add a rule. Click on the **+** icon again and go to the **Simple** tab.
![][24]
The options here are straight forward. Enter a name for your rule and select the policy and the direction. I’ll add a rule for rejecting incoming SSH attempts.
![][25]
The **Protocols** you can choose are **TCP, UDP** or **Both**.
You must now enter the **Port** for which you want to manage the traffic. You can enter a **port number** (e.g. 22 for ssh), a **port range** with inclusive ends separated by a **:** ( **colon** ) (e.g. 81:89) or a **service name** (e.g. ssh). I’ll use **ssh** and select **both TCP and UDP** for this example. As before, click on **Add** to completing the creation of your rule. You can click the **red arrow icon** to copy the settings to the **Advanced** rule creation menu.
![][26]
If you select **Close** , you can see that the new rule (along with the corresponding IPv6 rule) has been added.
![][27]
**Advanced Rules**
I’ll now go into how to set up more advanced rules, to handle traffic from specific IP addresses and subnets and targeting different interfaces.
Let’s open up the **Rules** menu again. Select the **Advanced** tab.
![][28]
By now, you should already be familiar with the basic options: **Name, Policy, Direction, Protocol, Port**. These are the same as before.
![][29]
**Note:** _You can choose both a receiving port and a requesting port._
What changes is that now you have additional options to further specialize our rules.
I mentioned before that rules are automatically numbered by GUFW. With **Advanced** rules you specify the position of your rule by entering a number in the **Insert** option.
**Note:** _Inputting **position 0** will add your rule after all existing rules._
**Interface** let’s you select any network interface available on your machine. By doing so, the rule will only have effect on traffic to and from that specific interface.
**Log** changes exactly that: what will and what won’t be logged.
You can also choose IPs for the requesting and for the receiving port/service ( **From** , **To** ).
All you have to do is specify an **IP address** (e.g. 192.168.0.102) or an entire **subnet** (e.g. 192.168.0.0/24 for IPv4 addresses ranging from 192.168.0.0 to 192.168.0.255).
In my example, I’ll set up a rule to allow all incoming TCP SSH requests from systems on my subnet to a specific network interface of the machine I’m currently running. I’ll add the rule after all my standard IP rules, so that it takes effect on top of the other rules I have set up.
![][30]
**Close** the menu.
![][31]
The rule has been successfully added after the other standard IP rules.
##### Edit Rules
Clicking a rule in the rules list will highlight it. Now, if you click on the **little cog icon** at the bottom, you can **edit** the highlighted rule.
![][32]
This will open up a menu looking something like the **Advanced** menu I explained in the last section.
![][33]
**Note:** _Editing any options of a rule will move it to the end of your list._
You can now ether select on **Apply** to modify your rule and move it to the end of the list, or hit **Cancel**.
##### Delete Rules
After selecting (highlighting) a rule, you can also click on the **–** icon.
![][34]
##### Reports
Select the **Report** tab. Here you can see services that are currently running (along with information about them, such as Protocol, Port, Address and Application name). From here, you can **Pause Listening Report (Pause Icon)** or **Create a rule from a highlighted service from the listening report (+ Icon)**.
![][35]
##### Logs
Select the **Logs** tab. Here is where you’ll have to check for any errors are suspicious rules. I’ve tried creating some invalid rules to show you what these might look like when you don’t know why you can’t add a certain rule. In the bottom section, there are two icons. Clicking the **first icon copies the logs** to your clipboard and clicking the **second icon** **clears the log**.
![][36]
### Wrapping Up
Having a firewall that is properly configured can greatly contribute to your Ubuntu experience, making your machine safer to use and allowing you to have full control over incoming and outgoing traffic.
I have covered the different uses and modes of **GUFW** , going into how to set up different rules and configure a firewall to your needs. I hope that this guide has been helpful to you.
If you are a beginner, this should prove to be a comprehensive guide; even if you are more versed in the Linux world and maybe getting your feet wet into servers and networking, I hope you learned something new.
Let us know in the comments if this article helped you and why did you decide a firewall would improve your system!
--------------------------------------------------------------------------------
via: https://itsfoss.com/set-up-firewall-gufw
作者：[Sergiu][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://itsfoss.com/author/sergiu/
[b]: https://github.com/lujun9972
[1]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/firewall-linux.png?resize=800%2C450&ssl=1
[2]: https://en.wikipedia.org/wiki/Firewall_(computing)
[3]: http://gufw.org/
[4]: https://en.wikipedia.org/wiki/Uncomplicated_Firewall
[5]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/ubuntu_software_gufw-1.jpg?ssl=1
[6]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/ubuntu_software_install_gufw.jpg?ssl=1
[7]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/show_applications_gufw.jpg?ssl=1
[8]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw.jpg?ssl=1
[9]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_toggle_status.jpg?ssl=1
[10]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_select_profile-1.jpg?ssl=1
[11]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_open_preferences.jpg?ssl=1
[12]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_preferences.png?fit=800%2C585&ssl=1
[13]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_rename_profile.png?fit=800%2C551&ssl=1
[14]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_add_profile.png?ssl=1
[15]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_delete_profile.png?ssl=1
[16]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_home_tab.png?ssl=1
[17]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_rules_tab.png?ssl=1
[18]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_add_rule.png?ssl=1
[19]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_add_rules_menu.png?ssl=1
[20]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_preconfigured_rule_policy.png?ssl=1
[21]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_preconfigured_rule_direction.png?ssl=1
[22]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_preconfigured_add_rule.png?ssl=1
[23]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_preconfigured_rule_added.png?ssl=1
[24]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_add_simple_rules_menu.png?ssl=1
[25]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_simple_rule_name_policy_direction.png?ssl=1
[26]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_add_simple_rule.png?ssl=1
[27]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_simple_rule_added.png?ssl=1
[28]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_add_advanced_rules_menu.png?ssl=1
[29]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_advanced_rule_basic_options.png?ssl=1
[30]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_add_advanced_rule.png?ssl=1
[31]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_advanced_rule_added.png?ssl=1
[32]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_edit_highlighted_rule.png?ssl=1
[33]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_edit_rule_menu.png?ssl=1
[34]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_delete_rule.png?ssl=1
[35]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_report_tab.png?ssl=1
[36]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/gufw_log_tab-1.png?ssl=1
[37]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/firewall-linux.png?fit=800%2C450&ssl=1

107
sources/tech/20190319 How to set up a homelab from hardware to firewall.md Normal file
View File

@ -0,0 +1,107 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (How to set up a homelab from hardware to firewall)
[#]: via: (https://opensource.com/article/19/3/home-lab)
[#]: author: (Michael Zamot (Red Hat) https://opensource.com/users/mzamot)
How to set up a homelab from hardware to firewall
======
Take a look at hardware and software options for building your own homelab.
![][1]
Do you want to create a homelab? Maybe you want to experiment with different technologies, create development environments, or have your own private cloud. There are many reasons to have a homelab, and this guide aims to make it easier to get started.
There are three categories to consider when planning a home lab: hardware, software, and maintenance. We'll look at the first two categories here and save maintaining your computer lab for a future article.
### Hardware
When thinking about your hardware needs, first consider how you plan to use your lab as well as your budget, noise, space, and power usage.
If buying new hardware is too expensive, search local universities, ads, and websites like eBay or Craigslist for recycled servers. They are usually inexpensive, and server-grade hardware is built to last many years. You'll need three types of hardware: a virtualization server, storage, and a router/firewall.
#### Virtualization servers
A virtualization server allows you to run several virtual machines that share the physical box's resources while maximizing and isolating resources. If you break one virtual machine, you won't have to rebuild the entire server, just the virtual one. If you want to do a test or try something without the risk of breaking your entire system, just spin up a new virtual machine and you're ready to go.
The two most important factors to consider in a virtualization server are the number and speed of its CPU cores and its memory. If there are not enough resources to share among all the virtual machines, they'll be overallocated and try to steal each other's CPU cycles and memory.
So, consider a CPU platform with multiple cores. You want to ensure the CPU supports virtualization instructions (VT-x for Intel and AMD-V for AMD). Examples of good consumer-grade processors that can handle virtualization are Intel i5 or i7 and AMD Ryzen. If you are considering server-grade hardware, the Xeon class for Intel and EPYC for AMD are good options. Memory can be expensive, especially the latest DDR4 SDRAM. When estimating memory requirements, factor at least 2GB for the host operating system's memory consumption.
If your electricity bill or noise is a concern, solutions like Intel's NUC devices provide a small form factor, low power usage, and reduced noise, but at the expense of expandability.
#### Network-attached storage (NAS)
If you want a machine loaded with hard drives to store all your personal data, movies, pictures, etc. and provide storage for the virtualization server, network-attached storage (NAS) is what you want.
In most cases, you won't need a powerful CPU; in fact, many commercial NAS solutions use low-powered ARM CPUs. A motherboard that supports multiple SATA disks is a must. If your motherboard doesn't have enough ports, use a host bus adapter (HBA) SAS controller to add extras.
Network performance is critical for a NAS, so select a gigabit network interface (or better).
Memory requirements will differ based on your filesystem. ZFS is one of the most popular filesystems for NAS, and you'll need more memory to use features such as caching or deduplication. Error-correcting code (ECC) memory is your best bet to protect data from corruption (but make sure your motherboard supports it before you buy). Last, but not least, don't forget an uninterruptible power supply (UPS), because losing power can cause data corruption.
#### Firewall and router
Have you ever realized that a cheap router/firewall is usually the main thing protecting your home network from the exterior world? These routers rarely receive timely security updates, if they receive any at all. Scared now? Well, [you should be][2]!
You usually don't need a powerful CPU or a great deal of memory to build your own router/firewall, unless you are handling a huge throughput or want to do CPU-intensive tasks, like a VPN server or traffic filtering. In such cases, you'll need a multicore CPU with AES-NI support.
You may want to get at least two 1-gigabit or better Ethernet network interface cards (NICs), also, not needed, but recommended, a managed switch to connect your DIY-router to create VLANs to further isolate and secure your network.
![Home computer lab PfSense][4]
### Software
After you've selected your virtualization server, NAS, and firewall/router, the next step is exploring the different operating systems and software to maximize their benefits. While you could use a regular Linux distribution like CentOS, Debian, or Ubuntu, they usually take more time to configure and administer than the following options.
#### Virtualization software
**[KVM][5]** (Kernel-based Virtual Machine) lets you turn Linux into a hypervisor so you can run multiple virtual machines in the same box. The best thing is that KVM is part of Linux, and it is the go-to option for many enterprises and home users. If you are comfortable, you can install **[libvirt][6]** and **[virt-manager][7]** to manage your virtualization platform.
**[Proxmox VE][8]** is a robust, enterprise-grade solution and a full open source virtualization and container platform. It is based on Debian and uses KVM as its hypervisor and LXC for containers. Proxmox offers a powerful web interface, an API, and can scale out to many clustered nodes, which is helpful because you'll never know when you'll run out of capacity in your lab.
**[oVirt][9] (RHV)** is another enterprise-grade solution that uses KVM as the hypervisor. Just because it's enterprise doesn't mean you can't use it at home. oVirt offers a powerful web interface and an API and can handle hundreds of nodes (if you are running that many servers, I don't want to be your neighbor!). The potential problem with oVirt for a home lab is that it requires a minimum set of nodes: You'll need one external storage, such as a NAS, and at least two additional virtualization nodes (you can run it just on one, but you'll run into problems in maintenance of your environment).
#### NAS software
**[FreeNAS][10]** is the most popular open source NAS distribution, and it's based on the rock-solid FreeBSD operating system. One of its most robust features is its use of the ZFS filesystem, which provides data-integrity checking, snapshots, replication, and multiple levels of redundancy (mirroring, striped mirrors, and striping). On top of that, everything is managed from the powerful and easy-to-use web interface. Before installing FreeNAS, check its hardware support, as it is not as wide as Linux-based distributions.
Another popular alternative is the Linux-based **[OpenMediaVault][11]**. One of its main features is its modularity, with plugins that extend and add features. Among its included features are a web-based administration interface; protocols like CIFS, SFTP, NFS, iSCSI; and volume management, including software RAID, quotas, access control lists (ACLs), and share management. Because it is Linux-based, it has extensive hardware support.
#### Firewall/router software
**[pfSense][12]** is an open source, enterprise-grade FreeBSD-based router and firewall distribution. It can be installed directly on a server or even inside a virtual machine (to manage your virtual or physical networks and save space). It has many features and can be expanded using packages. It is managed entirely using the web interface, although it also has command-line access. It has all the features you would expect from a router and firewall, like DHCP and DNS, as well as more advanced features, such as intrusion detection (IDS) and intrusion prevention (IPS) systems. You can create multiple networks listening on different interfaces or using VLANs, and you can create a secure VPN server with a few clicks. pfSense uses pf, a stateful packet filter that was developed for the OpenBSD operating system using a syntax similar to IPFilter. Many companies and organizations use pfSense.
* * *
With all this information in mind, it's time for you to get your hands dirty and start building your lab. In a future article, I will get into the third category of running a home lab: using automation to deploy and maintain it.
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/3/home-lab
作者：[Michael Zamot (Red Hat)][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/mzamot
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/computer_keyboard_laptop_development_code_woman.png?itok=vbYz6jjb
[2]: https://opensource.com/article/18/5/how-insecure-your-router
[3]: /file/427426
[4]: https://opensource.com/sites/default/files/uploads/pfsense2.png (Home computer lab PfSense)
[5]: https://www.linux-kvm.org/page/Main_Page
[6]: https://libvirt.org/
[7]: https://virt-manager.org/
[8]: https://www.proxmox.com/en/proxmox-ve
[9]: https://ovirt.org/
[10]: https://freenas.org/
[11]: https://www.openmediavault.org/
[12]: https://www.pfsense.org/

121
sources/tech/20190320 4 cool terminal multiplexers.md Normal file
View File

@ -0,0 +1,121 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (4 cool terminal multiplexers)
[#]: via: (https://fedoramagazine.org/4-cool-terminal-multiplexers/)
[#]: author: (Paul W. Frields https://fedoramagazine.org/author/pfrields/)
4 cool terminal multiplexers
======
![][1]
The Fedora OS is comfortable and easy for lots of users. It has a stunning desktop that makes it easy to get everyday tasks done. Under the hood is all the power of a Linux system, and the terminal is the easiest way for power users to harness it. By default terminals are simple and somewhat limited. However, a _terminal multiplexer_ allows you to turn your terminal into an even more incredible powerhouse. This article shows off some popular terminal multiplexers and how to install them.
Why would you want to use one? Well, for one thing, it lets you logout of your system while _leaving your terminal session undisturbed_. It’s incredibly useful to logout of your console, secure it, travel somewhere else, then remotely login with SSH and continue where you left off. Here are some utilities to check out.
One of the oldest and most well-known terminal multiplexers is _screen._ However, because the code is no longer maintained, this article focuses on more recent apps. (“Recent” is relative — some of these have been around for years!)
### Tmux
The _tmux_ utility is one of the most widely used replacements for _screen._ It has a highly configurable interface. You can program tmux to start up specific kinds of sessions based on your needs. You’ll find a lot more about tmux in this article published earlier:
> [Use tmux for a more powerful terminal][2]
Already a tmux user? You might like [this additional article on making your tmux sessions more effective][3].
To install tmux, use the _sudo_ command along with _dnf_ , since you’re probably in a terminal already:
```
$ sudo dnf install tmux
```
To start learning, run the _tmux_ command. A single pane window starts with your default shell. Tmux uses a _modifier key_ to signal that a command is coming next. This key is **Ctrl+B** by default. If you enter **Ctrl+B, C** you’ll create a new window with a shell in it.
Here’s a hint: Use **Ctrl+B, ?** to enter a help mode that lists all the keys you can use. To keep things simple, look for the lines starting with _bind-key -T prefix_ at first. These are keys you can use right after the modifier key to configure your tmux session. You can hit **Ctrl+C** to exit the help mode back to tmux.
To completely exit tmux, use the standard _exit_ command or _Ctrl+D_ keystroke to exit all the shells.
### Dvtm
You might have recently seen the Magazine article on [dwm, a dynamic window manager][4]. Like dwm, _dvtm_ is for tiling window management — but in a terminal. It’s designed to adhere to the legacy UNIX philosophy of “do one thing well” — in this case managing windows in a terminal.
Installing dvtm is easy as well. However, if you want the logout functionality mentioned earlier, you’ll also need the _abduco_ package which handles session management for dvtm.
```
$ sudo dnf install dvtm abduco
```
The dvtm utility has many keystrokes already mapped to allow you to manage windows in the terminal. By default, it uses **Ctrl+G** as its modifier key. This keystroke tells dvtm that the following character is going to be a command it should process. For instance, **Ctrl+G, C** creates a new window and **Ctrl+G, X** removes it.
For more information on using dvtm, check out the dvtm [home page][5] which includes numerous tips and get-started information.
### Byobu
While _byobu_ isn’t truly a multiplexer on its own — it wraps _tmux_ or even the older _screen_ to add functions — it’s worth covering here too. Byobu makes terminal multiplexers better for novices, by adding a help menu and window tabs that are slightly easier to navigate.
Of course it’s available in the Fedora repos as well. To install, use this command:
```
$ sudo dnf install byobu
```
By default the _byobu_ command runs _screen_ underneath, so you might want to run _byobu-tmux_ to wrap _tmux_ instead. You can then use the **F9** key to open up a help menu for more information to help you get started.
### Mtm
The _mtm_ utility is one of the smallest multiplexers you’ll find. In fact, it’s only about 1000 lines of code! You might find it helpful if you’re in a limited environment such as old hardware, a minimal container, and so forth. To get started, you’ll need a couple packages.
```
$ sudo dnf install git ncurses-devel make gcc
```
Then clone the repository where mtm lives:
```
$ git clone https://github.com/deadpixi/mtm.git
```
Change directory into the _mtm_ folder and build the program:
```
$ make
```
You might receive a few warnings, but when you’re done, you’ll have the very small _mtm_ utility. Run it with this command:
```
$ ./mtm
```
You can find all the documentation for the utility [on its GitHub page][6].
These are just some of the terminal multiplexers out there. Got one you’d like to recommend? Leave a comment below with your tips and enjoy building windows in your terminal!
* * *
_Photo by _[ _Michael_][7]_ on [Unsplash][8]._
--------------------------------------------------------------------------------
via: https://fedoramagazine.org/4-cool-terminal-multiplexers/
作者：[Paul W. Frields][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://fedoramagazine.org/author/pfrields/
[b]: https://github.com/lujun9972
[1]: https://fedoramagazine.org/wp-content/uploads/2018/08/tmuxers-4-816x345.jpg
[2]: https://fedoramagazine.org/use-tmux-more-powerful-terminal/
[3]: https://fedoramagazine.org/4-tips-better-tmux-sessions/
[4]: https://fedoramagazine.org/lets-try-dwm-dynamic-window-manger/
[5]: http://www.brain-dump.org/projects/dvtm/#why
[6]: https://github.com/deadpixi/mtm
[7]: https://unsplash.com/photos/48yI_ZyzuLo?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText
[8]: https://unsplash.com/search/photos/windows?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText

97
sources/tech/20190320 Choosing an open messenger client- Alternatives to WhatsApp.md Normal file
View File

@ -0,0 +1,97 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Choosing an open messenger client: Alternatives to WhatsApp)
[#]: via: (https://opensource.com/article/19/3/open-messenger-client)
[#]: author: (Chris Hermansen (Community Moderator) https://opensource.com/users/clhermansen)
Choosing an open messenger client: Alternatives to WhatsApp
======
Keep in touch with far-flung family, friends, and colleagues without sacrificing your privacy.
![Team communication, chat][1]
Like many families, mine is inconveniently spread around, and I have many colleagues in North and South America. So, over the years, I've relied more and more on WhatsApp to stay in touch with people. The claimed end-to-end encryption appeals to me, as I prefer to maintain some shreds of privacy, and moreover to avoid forcing those with whom I communicate to use an insecure mechanism. But all this [WhatsApp/Facebook/Instagram "convergence"][2] has led our family to decide to vote with our feet. We no longer use WhatsApp for anything except communicating with others who refuse to use anything else, and we're working on them.
So what do we use instead? Before I spill the beans, I'd like to explain what other options we looked at and how we chose.
### Options we considered and how we evaluated them
There is an absolutely [crazy number of messaging apps out there][3], and we spent a good deal of time thinking about what we needed for a replacement. We started by reading Dan Arel's article on [five social media alternatives to protect privacy][4].
Then we came up with our list of core needs:
* Our entire family uses Android phones.
* One of us has a Windows desktop; the rest use Linux.
* Our main interest is something we can use to chat, both individually and as a group, on our phones, but it would be nice to have a desktop client available.
* It would also be nice to have voice and video calling as well.
* Our privacy is important. Ideally, the code should be open source to facilitate security reviews. If the operation is not pure peer-to-peer, then the organization operating the server components should not operate a business based on the commercialization of our personal information.
At that point, we narrowed the long list down to [Viber][5], [Line][6], [Signal][7], [Threema][8], [Wire][9], and [Riot.im][10]. While I lean strongly to open source, we wanted to include some closed source and paid solutions to make sure we weren't missing something important. Here's how those six alternatives measured up.
### Line
[Line][11] is a popular messaging application, and it's part of a larger Line "ecosystem"—online gaming, Taxi (an Uber-like service in Japan), Wow (a food delivery service), Today (a news hub), shopping, and others. For us, Line checks a few too many boxes with all those add-on features. Also, I could not determine its current security quality, and it's not open source. The business model seems to be to build a community and figure out how to make money through that community.
### Riot.im
[Riot.im][12] operates on top of the Matrix protocol and therefore lets the user choose a Matrix provider. It also appears to check all of our "needs" boxes, although in operation it looks more like Slack, with a room-oriented and interoperable/federated design. It offers desktop clients, and it's open source. Since the Matrix protocol can be hosted anywhere, any business model would be particular to the Matrix provider.
### Signal
[Signal][13] offers a similar user experience to WhatsApp. It checks all of our "needs" boxes, with solid security validated by external audit. It is open source, and it is developed and operated by a not-for-profit foundation, in principle similar to the Mozilla Foundation. Interestingly, Signal's communications protocol appears to be used by other messaging apps, [including WhatsApp][14].
### Threema
[Threema][15] is extremely privacy-focused. It checks some of our "needs" boxes, with decent external audit results of its security. It doesn't offer a desktop client, and it [isn't fully open source][16] though some of its core components are. Threema's business model appears to be to offer paid secure communications.
### Viber
[Viber][17] is a very popular messaging application. It checks most of our "needs" boxes; however, it doesn't seem to have solid proof of its security—it seems to use a proprietary encryption mechanism, and as far as I could determine, its current security mechanisms are not externally audited. It's not open source. The owner, Rakuten, seems to be planning for a paid subscription as a business model.
### Wire
[Wire][18] was started and is built by some ex-Skype people. It appears to check all of our "needs" boxes, although I am not completely comfortable with its security profile since it stores client data that apparently is not encrypted on its servers. It offers desktop clients and is open source. The developer and operator, Wire Swiss, appears to have a [pay-for-service track][9] as its future business model.
### The final verdict
In the end, we picked Signal. We liked its open-by-design approach, its serious and ongoing [privacy and security stance][7] and having a Signal app on our GNOME (and Windows) desktops. It performs very well on our Android handsets and our desktops. Moreover, it wasn't a big surprise to our small user community; it feels much more like WhatsApp than, for example, Riot.im, which we also tried extensively. Having said that, if we were trying to replace Slack, we'd probably move to Riot.im.
_Have a favorite messenger? Tell us about it in the comments below._
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/3/open-messenger-client
作者：[Chris Hermansen (Community Moderator)][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/clhermansen
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/talk_chat_team_mobile_desktop.png?itok=d7sRtKfQ (Team communication, chat)
[2]: https://www.cnbc.com/2018/03/28/facebook-new-privacy-settings-dont-address-instagram-whatsapp.html
[3]: https://en.wikipedia.org/wiki/Comparison_of_instant_messaging_clients
[4]: https://opensource.com/article/19/1/open-source-social-media-alternatives
[5]: https://en.wikipedia.org/wiki/Viber
[6]: https://en.wikipedia.org/wiki/Line_(software)
[7]: https://en.wikipedia.org/wiki/Signal_(software)
[8]: https://en.wikipedia.org/wiki/Threema
[9]: https://en.wikipedia.org/wiki/Wire_(software)
[10]: https://en.wikipedia.org/wiki/Riot.im
[11]: https://line.me/en/
[12]: https://about.riot.im/
[13]: https://signal.org/
[14]: https://en.wikipedia.org/wiki/Signal_Protocol
[15]: https://threema.ch/en
[16]: https://threema.ch/en/faq/source_code
[17]: https://www.viber.com/
[18]: https://wire.com/en/

130
sources/tech/20190320 Move your dotfiles to version control.md Normal file
View File

@ -0,0 +1,130 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Move your dotfiles to version control)
[#]: via: (https://opensource.com/article/19/3/move-your-dotfiles-version-control)
[#]: author: (Matthew Broberg https://opensource.com/users/mbbroberg)
Move your dotfiles to version control
======
Back up or sync your custom configurations across your systems by sharing dotfiles on GitLab or GitHub.
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/documents_papers_file_storage_work.png?itok=YlXpAqAJ)
There is something truly exciting about customizing your operating system through the collection of hidden files we call dotfiles. In [What a Shell Dotfile Can Do For You][1], H. "Waldo" Grunenwald goes into excellent detail about the why and how of setting up your dotfiles. Let's dig into the why and how of sharing them.
### What's a dotfile?
"Dotfiles" is a common term for all the configuration files we have floating around our machines. These files usually start with a **.** at the beginning of the filename, like **.gitconfig** , and operating systems often hide them by default. For example, when I use **ls -a** on MacOS, it shows all the lovely dotfiles that would otherwise not be in the output.
```
dotfiles on master
➜ ls
README.md  Rakefile   bin       misc    profiles   zsh-custom
dotfiles on master
➜ ls -a
.               .gitignore      .oh-my-zsh      README.md       zsh-custom
..              .gitmodules     .tmux           Rakefile
.gemrc          .global_ignore .vimrc           bin
.git            .gvimrc         .zlogin         misc
.gitconfig      .maid           .zshrc          profiles
```
If I take a look at one, **.gitconfig** , which I use for Git configuration, I see a ton of customization. I have account information, terminal color preferences, and tons of aliases that make my command-line interface feel like mine. Here's a snippet from the **[alias]** block:
```
87   # Show the diff between the latest commit and the current state
88   d = !"git diff-index --quiet HEAD -- || clear; git --no-pager diff --patch-with-stat"
89
90   # `git di $number` shows the diff between the state `$number` revisions ago and the current state
91   di = !"d() { git diff --patch-with-stat HEAD~$1; }; git diff-index --quiet HEAD -- || clear; d"
92
93   # Pull in remote changes for the current repository and all its submodules
94   p = !"git pull; git submodule foreach git pull origin master"
95
96   # Checkout a pull request from origin (of a github repository)
97   pr = !"pr() { git fetch origin pull/$1/head:pr-$1; git checkout pr-$1; }; pr"
```
Since my **.gitconfig** has over 200 lines of customization, I have no interest in rewriting it on every new computer or system I use, and either does anyone else. This is one reason sharing dotfiles has become more and more popular, especially with the rise of the social coding site GitHub. The canonical article advocating for sharing dotfiles is Zach Holman's [Dotfiles Are Meant to Be Forked][2] from 2008. The premise is true to this day: I want to share them, with myself, with those new to dotfiles, and with those who have taught me so much by sharing their customizations.
### Sharing dotfiles
Many of us have multiple systems or know hard drives are fickle enough that we want to back up our carefully curated customizations. How do we keep these wonderful files in sync across environments?
My favorite answer is distributed version control, preferably a service that will handle the heavy lifting for me. I regularly use GitHub and continue to enjoy GitLab as I get more experienced with it. Either one is a perfect place to share your information. To set yourself up:
1. Sign into your preferred Git-based service.
2. Create a repository called "dotfiles." (Make it public! Sharing is caring.)
3. Clone it to your local environment.*
4. Copy your dotfiles into the folder.
5. Symbolically link (symlink) them back to their target folder (most often **$HOME** ).
6. Push them to the remote repository.
* You may need to set up your Git configuration commands to clone the repository. Both GitHub and GitLab will prompt you with the commands to run.
![](https://opensource.com/sites/default/files/uploads/gitlab-new-project.png)
Step 4 above is the crux of this effort and can be a bit tricky. Whether you use a script or do it by hand, the workflow is to symlink from your dotfiles folder to the dotfiles destination so that any updates to your dotfiles are easily pushed to the remote repository. To do this for my **.gitconfig** file, I would enter:
```
$ cd dotfiles/
$ ln -nfs .gitconfig $HOME/.gitconfig
```
The flags added to the symlinking command offer a few additional benefits:
* **-s** creates a symbolic link instead of a hard link
* **-f** continues with other symlinking when an error occurs (not needed here, but useful in loops)
* **-n** avoids symlinking a symlink (same as **-h** for other versions of **ln** )
You can review the IEEE and Open Group [specification of **ln**][3] and the version on [MacOS 10.14.3][4] if you want to dig deeper into the available parameters. I had to look up these flags since I pulled them from someone else's dotfiles.
You can also make updating simpler with a little additional code, like the [Rakefile][5] I forked from [Brad Parbs][6]. Alternatively, you can keep it incredibly simple, as Jeff Geerling does [in his dotfiles][7]. He symlinks files using [this Ansible playbook][8]. Keeping everything in sync at this point is easy: you can cron job or occasionally **git push** from your dotfiles folder.
### Quick aside: What not to share
Before we move on, it is worth noting what you should not add to a shared dotfile repository—even if it starts with a dot. Anything that is a security risk, like files in your **.ssh/** folder, is not a good choice to share using this method. Be sure to double-check your configuration files before publishing them online and triple-check that no API tokens are in your files.
### Where should I start?
If Git is new to you, my [article about the terminology][9] and [a cheat sheet][10] of my most frequently used commands should help you get going.
There are other incredible resources to help you get started with dotfiles. Years ago, I came across [dotfiles.github.io][11] and continue to go back to it for a broader look at what people are doing. There is a lot of tribal knowledge hidden in other people's dotfiles. Take the time to scroll through some and don't be shy about adding them to your own.
I hope this will get you started on the joy of having consistent dotfiles across your computers.
What's your favorite dotfile trick? Add a comment or tweet me [@mbbroberg][12].
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/3/move-your-dotfiles-version-control
作者：[Matthew Broberg][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/mbbroberg
[b]: https://github.com/lujun9972
[1]: https://opensource.com/article/18/9/shell-dotfile
[2]: https://zachholman.com/2010/08/dotfiles-are-meant-to-be-forked/
[3]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/ln.html
[4]: https://www.unix.com/man-page/FreeBSD/1/ln/
[5]: https://github.com/mbbroberg/dotfiles/blob/master/Rakefile
[6]: https://github.com/bradp/dotfiles
[7]: https://github.com/geerlingguy/dotfiles
[8]: https://github.com/geerlingguy/mac-dev-playbook
[9]: https://opensource.com/article/19/2/git-terminology
[10]: https://opensource.com/downloads/cheat-sheet-git
[11]: http://dotfiles.github.io/
[12]: https://twitter.com/mbbroberg?lang=en

186
sources/tech/20190320 Nuvola- Desktop Music Player for Streaming Services.md Normal file
View File

@ -0,0 +1,186 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Nuvola: Desktop Music Player for Streaming Services)
[#]: via: (https://itsfoss.com/nuvola-music-player)
[#]: author: (Atharva Lele https://itsfoss.com/author/atharva/)
Nuvola: Desktop Music Player for Streaming Services
======
[Nuvola][1] is not like your usual music players. It’s different because it allows you to play a number of streaming services in a desktop music player.
Nuvola provides a runtime called [Nuvola Apps Runtime][2] which runs web apps. This is why Nuvola can support a host of streaming services. Some of the major players it supports are:
* Spotify
* Google Play Music
* YouTube, YouTube Music
* [Pandora][3]
* [SoundCloud][4]
* and many many more.
You can find the full list [here][1] in the Music streaming services section. Apple Music is not supported, if you were wondering.
Why would you use a streaming music service in a different desktop player when you can run it in a web browser? The advantage with Nuvola is that it provides tight integration with many [desktop environments][5].
Ideally it should work with all DEs, but the officially supported ones are GNOME, Unity, and Pantheon (elementary OS).
### Features of Nuvola Music Player
Let’s see some of the main features of the open source project Nuvola:
* Supports a wide variety of music streaming services
* Desktop integration with GNOME, Unity, and Pantheon.
* Keyboard shortcuts with the ability to customize them
* Support for keyboard’s multimedia keys (paid feature)
* Background play with notifications
* [GNOME Media Player][6] extension support
* App Tray indicator
* Dark and Light themes
* Enable or disable features
* Password Manager for web services
* Remote control over internet (paid feature)
* Available for a lot of distros ([Flatpak][7] packages)
Complete list of features is available [here][8].
### How to install Nuvola on Ubuntu & other Linux distributions
Installing Nuvola consists of a few more steps than simply adding a PPA and then installing the software. Since it is based on [Flatpak][7], you have to set up Flatpak first and then you can install Nuvola.
[Enable Flatpak Support][9]
The steps are pretty simple. You can follow the guide [here][10] if you want to install using the GUI, however I prefer terminal commands since they’re easier and faster.
**Warning: If already installed, remove the older version of Nuvola (Click to expand)**
If you have ever installed Nuvola before, you need to uninstall it to avoid issues. Run these commands in the terminal to do so.
```
sudo apt remove nuvolaplayer*
```
```
rm -rf ~/.cache/nuvolaplayer3 ~/.local/share/nuvolaplayer ~/.config/nuvolaplayer3 ~/.local/share/applications/nuvolaplayer3*
```
Once you have made sure that your system has Flatpak, you can install Nuvola using this command:
```
flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo
flatpak remote-add --if-not-exists nuvola https://dl.tiliado.eu/flatpak/nuvola.flatpakrepo
```
This is an optional step but I recommend you install this since the service allows you to commonly configure settings like shortcuts for each of the streaming service that you might use.
```
flatpak install nuvola eu.tiliado.Nuvola
```
Nuvola supports 29 streaming services. To get them, you need to add those services individually. You can find all the supported music services are available on this [page][10].
For the purpose of this tutorial, I’m going to go with [YouTube Music][11].
```
flatpak install nuvola eu.tiliado.NuvolaAppYoutubeMusic
```
After this, you should have the app installed and should be able to see the icon if you search for it.
![Nuvola App specific icons][12]
Clicking on the icon will pop-up the first time setup. You’ll have to accept the Privacy Policy and then continue.
![Terms and Conditions page][13]
After accepting terms and conditions, you should launch into the web app of the respective streaming service, YouTube Music in this case.
![YouTube Music web app running on Nuvola Runtime][14]
In case of installation on other distributions, specific guidelines are available on the [Nuvola website][15].
### My experience with Nuvola Music Player
Initially I thought that it wouldn’t be too different than simply running the web app in [Firefox][16], since many desktop environments like KDE support media controls and shortcuts for media playing in Firefox.
However, this isn’t the case with many other desktops environments and that’s where Nuvola comes in handy. Often, it’s also faster to access than loading the website on the browser.
Once loaded, it behaves pretty much like a normal web app with the benefit of keyboard shortcuts. Speaking of shortcuts, you should check out the list of must know [Ubuntu shortcuts][17].
![Viewing an Artist’s page][18]
Integration with the DE comes in handy when you quickly want to change a song or play/pause your music without leaving your current application. Nuvola gives you access in GNOME notifications as well as provides an app tray icon.
* ![Notification music controls][19]
* ![App tray music controls][20]
Keyboard shortcuts work well, globally as well as in-app. You get a notification when the song changes. Whether you do it yourself or it automatically switches to the next song.
![][21]
By default, very few keyboard shortcuts are provided. However you can enable them for almost everything you can do with the app. For example I set the song change shortcuts to Ctrl + Arrow keys as you can see in the screenshot.
![Keyboard Shortcuts][22]
All in all, it works pretty well and it’s fast and responsive. Definitely more so than your usual Snap app.
**Some criticism**
Some thing that did not please me as much was the installation size. Since it requires a browser back-end and GNOME integration it essentially installs a browser and necessary GNOME libraries for Flatpak, so that results in having to install almost 350MB in dependencies.
After that, you install individual apps. The individual apps themselves are not heavy at all. But if you just use one streaming service, having a 300+ MB installation might not be ideal if you’re concerned about disk space.
Nuvola also does not support local music, at least as far as I could find.
**Conclusion**
Hope this article helped you to know more about Nuvola Music Player and its features. If you like such different applications, why not take a look at some of the [lesser known music players for Linux][23]?
As always, if you have any suggestions or questions, I look forward to reading your comments.
--------------------------------------------------------------------------------
via: https://itsfoss.com/nuvola-music-player
作者：[Atharva Lele][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://itsfoss.com/author/atharva/
[b]: https://github.com/lujun9972
[1]: https://nuvola.tiliado.eu/
[2]: https://nuvola.tiliado.eu/#fn:1
[3]: https://itsfoss.com/install-pandora-linux-client/
[4]: https://itsfoss.com/install-soundcloud-linux/
[5]: https://itsfoss.com/best-linux-desktop-environments/
[6]: https://extensions.gnome.org/extension/55/media-player-indicator/
[7]: https://flatpak.org/
[8]: http://tiliado.github.io/nuvolaplayer/documentation/4/explore.html
[9]: https://itsfoss.com/flatpak-guide/
[10]: https://nuvola.tiliado.eu/nuvola/ubuntu/bionic/
[11]: https://nuvola.tiliado.eu/app/youtube_music/ubuntu/bionic/
[12]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/nuvola_youtube_music_icon.png?resize=800%2C450&ssl=1
[13]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/nuvola_eula.png?resize=800%2C450&ssl=1
[14]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/nuvola_youtube_music.png?resize=800%2C450&ssl=1
[15]: https://nuvola.tiliado.eu/index/
[16]: https://itsfoss.com/why-firefox/
[17]: https://itsfoss.com/ubuntu-shortcuts/
[18]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/nuvola_web_player.png?resize=800%2C449&ssl=1
[19]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/03/nuvola_music_controls.png?fit=800%2C450&ssl=1
[20]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/nuvola_web_player2.png?fit=800%2C450&ssl=1
[21]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/03/nuvola_song_change_notification-e1553077619208.png?ssl=1
[22]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/03/nuvola_shortcuts.png?resize=800%2C450&ssl=1
[23]: https://itsfoss.com/lesser-known-music-players-linux/

268
sources/tech/20190321 How To Setup Linux Media Server Using Jellyfin.md Normal file
View File

@ -0,0 +1,268 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (How To Setup Linux Media Server Using Jellyfin)
[#]: via: (https://www.ostechnix.com/how-to-setup-linux-media-server-using-jellyfin/)
[#]: author: (sk https://www.ostechnix.com/author/sk/)
How To Setup Linux Media Server Using Jellyfin
======
![Setup Linux Media Server Using Jellyfin][1]
We’ve already written about setting up your own streaming media server on Linux using [**Streama**][2]. Today, we will going to setup yet another media server using **Jellyfin**. Jellyfin is a free, cross-platform and open source alternative to propriety media streaming applications such as **Emby** and **Plex**. The main developer of Jellyfin forked it from Emby after the announcement of Emby transitioning to a proprietary model. Jellyfin doesn’t include any premium features, licenses or membership plans. It is completely free and open source project supported by hundreds of community members. Using jellyfin, we can instantly setup Linux media server in minutes and access it via LAN/WAN from any devices using multiple apps.
### Setup Linux Media Server Using Jellyfin
Jellyfin supports GNU/Linux, Mac OS and Microsoft Windows operating systems. You can install it on your Linux distribution as described below.
##### Install Jellyfin On Linux
As of writing this guide, Jellyfin packages are available for most popular Linux distributions, such as Arch Linux, Debian, CentOS, Fedora and Ubuntu.
On **Arch Linux** and its derivatives like **Antergos** , **Manjaro Linux** , you can install Jellyfin using any AUR helper tools, for example [**YaY**][3].
```
$ yay -S jellyfin-git
```
On **CentOS/RHEL** :
Download the latest Jellyfin rpm package from [**here**][4] and install it as shown below.
```
$ wget https://repo.jellyfin.org/releases/server/centos/jellyfin-10.2.2-1.el7.x86_64.rpm
$ sudo yum localinstall jellyfin-10.2.2-1.el7.x86_64.rpm
```
On **Fedora** :
Download Jellyfin for Fedora from [**here**][5].
```
$ wget https://repo.jellyfin.org/releases/server/fedora/jellyfin-10.2.2-1.fc29.x86_64.rpm
$ sudo dnf install jellyfin-10.2.2-1.fc29.x86_64.rpm
```
On **Debian** :
Install HTTPS transport for APT if it is not installed already:
```
$ sudo apt install apt-transport-https
```
Import Jellyfin GPG signing key:``
```
$ wget -O - https://repo.jellyfin.org/debian/jellyfin_team.gpg.key | sudo apt-key add -
```
Add Jellyfin repository:
```
$ sudo touch /etc/apt/sources.list.d/jellyfin.list
$ echo "deb [arch=amd64] https://repo.jellyfin.org/debian $( lsb_release -c -s ) main" | sudo tee /etc/apt/sources.list.d/jellyfin.list
```
Finally, update Jellyfin repository and install Jellyfin using commands:``
```
$ sudo apt update
$ sudo apt install jellyfin
```
On **Ubuntu 18.04 LTS** :
Install HTTPS transport for APT if it is not installed already:
```
$ sudo apt install apt-transport-https
```
Import and add Jellyfin GPG signing key:``
```
$ wget -O - https://repo.jellyfin.org/debian/jellyfin_team.gpg.key | sudo apt-key add -
```
Add the Jellyfin repository:
```
$ sudo touch /etc/apt/sources.list.d/jellyfin.list
$ echo "deb https://repo.jellyfin.org/ubuntu bionic main" | sudo tee /etc/apt/sources.list.d/jellyfin.list
```
For Ubuntu 16.04, just replace **bionic** with **xenial** in the above URL.
Finally, update Jellyfin repository and install Jellyfin using commands:``
```
$ sudo apt update
$ sudo apt install jellyfin
```
##### Start Jellyfin service
Run the following commands to enable and start jellyfin service on every reboot:
```
$ sudo systemctl enable jellyfin
$ sudo systemctl start jellyfin
```
To check if the service has been started or not, run:
```
$ sudo systemctl status jellyfin
```
Sample output:
```
● jellyfin.service - Jellyfin Media Server
Loaded: loaded (/lib/systemd/system/jellyfin.service; enabled; vendor preset: enabled)
Drop-In: /etc/systemd/system/jellyfin.service.d
└─jellyfin.service.conf
Active: active (running) since Wed 2019-03-20 12:20:19 UTC; 1s ago
Main PID: 4556 (jellyfin)
Tasks: 11 (limit: 2320)
CGroup: /system.slice/jellyfin.service
└─4556 /usr/bin/jellyfin --datadir=/var/lib/jellyfin --configdir=/etc/jellyfin --logdir=/var/log/jellyfin --cachedir=/var/cache/jellyfin --r
Mar 20 12:20:21 ubuntuserver jellyfin[4556]: [12:20:21] [INF] Loading Emby.Photos, Version=10.2.2.0, Culture=neutral, PublicKeyToken=null
Mar 20 12:20:21 ubuntuserver jellyfin[4556]: [12:20:21] [INF] Loading Emby.Server.Implementations, Version=10.2.2.0, Culture=neutral, PublicKeyToken=nu
Mar 20 12:20:21 ubuntuserver jellyfin[4556]: [12:20:21] [INF] Loading MediaBrowser.MediaEncoding, Version=10.2.2.0, Culture=neutral, PublicKeyToken=nul
Mar 20 12:20:21 ubuntuserver jellyfin[4556]: [12:20:21] [INF] Loading Emby.Dlna, Version=10.2.2.0, Culture=neutral, PublicKeyToken=null
Mar 20 12:20:21 ubuntuserver jellyfin[4556]: [12:20:21] [INF] Loading MediaBrowser.LocalMetadata, Version=10.2.2.0, Culture=neutral, PublicKeyToken=nul
Mar 20 12:20:21 ubuntuserver jellyfin[4556]: [12:20:21] [INF] Loading Emby.Notifications, Version=10.2.2.0, Culture=neutral, PublicKeyToken=null
Mar 20 12:20:21 ubuntuserver jellyfin[4556]: [12:20:21] [INF] Loading MediaBrowser.XbmcMetadata, Version=10.2.2.0, Culture=neutral, PublicKeyToken=null
Mar 20 12:20:21 ubuntuserver jellyfin[4556]: [12:20:21] [INF] Loading jellyfin, Version=10.2.2.0, Culture=neutral, PublicKeyToken=null
Mar 20 12:20:21 ubuntuserver jellyfin[4556]: [12:20:21] [INF] Sqlite version: 3.26.0
Mar 20 12:20:21 ubuntuserver jellyfin[4556]: [12:20:21] [INF] Sqlite compiler options: COMPILER=gcc-5.4.0 20160609,DEFAULT_FOREIGN_KEYS,ENABLE_COLUMN_M
```
If you see an output something, congratulations! Jellyfin service has been started.
Next, we should do some initial configuration.
##### Configure Jellyfin
Once jellyfin is installed, open the browser and navigate to – **http:// <domain-name>:8096** or **http:// <IP-Address>:8096** URL.
You will see the following welcome screen. Select your preferred language and click Next.
![][6]
Enter your user details. You can add more users later from the Jellyfin Dashboard.
![][7]
The next step is to select media files which we want to stream. To do so, click “Add media Library” button:
![][8]
Choose the content type (i.e audio, video, movies etc.,), display name and click plus (+) sign next to the Folders icon to choose the location where you kept your media files. You can further choose other library settings such as the preferred download language, country etc. Click Ok after choosing the preferred options.
![][9]
Similarly, add all of the media files. Once you have chosen everything to stream, click Next.
![][10]
Choose the Metadata language and click Next:
![][11]
Next, you need to configure whether you want to allow remote connections to this media server. Make sure you have allowed the remote connections. Also, enable automatic port mapping and click Next:
![][12]
You’re all set! Click Finish to complete Jellyfin configuration.
![][13]
You will now be redirected to Jellyfin login page. Click on the username and enter it’s password which we setup earlier.
![][14]
This is how Jellyfin dashboard looks like.
![][15]
As you see in the screenshot, all of your media files are shown in the dashboard itself under My Media section. Just click on the any media file of your choice and start watching it!!
![][16]
You can access this Jellyfin media server from any systems on the network using URL – <http://ip-address:8096>. You need not to install any extra apps. All you need is a modern web browser.
If you want to change anything or reconfigure, click on the three horizontal bars from the Home screen. Here, you can add users, media files, change playback settings, add TV/DVR, install plugins, change default port no and a lot more settings.
![][17]
For more details, check out [**Jellyfin official documentation**][18] page.
And, that’s all for now. As you can see setting up a streaming media server on Linux is no big-deal. I tested it on my Ubuntu 18.04 LTS VM. It worked fine out of the box. I can be able to watch the movies from other systems in my LAN. If you’re looking for easy, quick and free solution for hosting a media server, Jellyfin is a good choice.
Cheers!
--------------------------------------------------------------------------------
via: https://www.ostechnix.com/how-to-setup-linux-media-server-using-jellyfin/
作者：[sk][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.ostechnix.com/author/sk/
[b]: https://github.com/lujun9972
[1]: data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7
[2]: https://www.ostechnix.com/streama-setup-your-own-streaming-media-server-in-minutes/
[3]: https://www.ostechnix.com/yay-found-yet-another-reliable-aur-helper/
[4]: https://repo.jellyfin.org/releases/server/centos/
[5]: https://repo.jellyfin.org/releases/server/fedora/
[6]: http://www.ostechnix.com/wp-content/uploads/2019/03/jellyfin-1.png
[7]: http://www.ostechnix.com/wp-content/uploads/2019/03/jellyfin-2-1.png
[8]: http://www.ostechnix.com/wp-content/uploads/2019/03/jellyfin-3-1.png
[9]: http://www.ostechnix.com/wp-content/uploads/2019/03/jellyfin-4-1.png
[10]: http://www.ostechnix.com/wp-content/uploads/2019/03/jellyfin-5-1.png
[11]: http://www.ostechnix.com/wp-content/uploads/2019/03/jellyfin-6.png
[12]: http://www.ostechnix.com/wp-content/uploads/2019/03/jellyfin-7.png
[13]: http://www.ostechnix.com/wp-content/uploads/2019/03/jellyfin-8-1.png
[14]: http://www.ostechnix.com/wp-content/uploads/2019/03/jellyfin-9.png
[15]: http://www.ostechnix.com/wp-content/uploads/2019/03/jellyfin-10.png
[16]: http://www.ostechnix.com/wp-content/uploads/2019/03/jellyfin-11.png
[17]: http://www.ostechnix.com/wp-content/uploads/2019/03/jellyfin-12.png
[18]: https://jellyfin.readthedocs.io/en/latest/
[19]: https://github.com/jellyfin/jellyfin
[20]: http://feedburner.google.com/fb/a/mailverify?uri=ostechnix (Subscribe to our Email newsletter)
[21]: https://www.paypal.me/ostechnix (Donate Via PayPal)
[22]: http://ostechnix.tradepub.com/category/information-technology/1207/
[23]: https://www.facebook.com/ostechnix/
[24]: https://twitter.com/ostechnix
[25]: https://plus.google.com/+SenthilkumarP/
[26]: https://www.linkedin.com/in/ostechnix
[27]: http://feeds.feedburner.com/Ostechnix
[28]: https://www.ostechnix.com/how-to-setup-linux-media-server-using-jellyfin/?share=reddit (Click to share on Reddit)
[29]: https://www.ostechnix.com/how-to-setup-linux-media-server-using-jellyfin/?share=twitter (Click to share on Twitter)
[30]: https://www.ostechnix.com/how-to-setup-linux-media-server-using-jellyfin/?share=facebook (Click to share on Facebook)
[31]: https://www.ostechnix.com/how-to-setup-linux-media-server-using-jellyfin/?share=linkedin (Click to share on LinkedIn)
[32]: https://www.ostechnix.com/how-to-setup-linux-media-server-using-jellyfin/?share=pocket (Click to share on Pocket)
[33]: https://api.whatsapp.com/send?text=How%20To%20Setup%20Linux%20Media%20Server%20Using%20Jellyfin%20https%3A%2F%2Fwww.ostechnix.com%2Fhow-to-setup-linux-media-server-using-jellyfin%2F (Click to share on WhatsApp)
[34]: https://www.ostechnix.com/how-to-setup-linux-media-server-using-jellyfin/?share=telegram (Click to share on Telegram)
[35]: https://www.ostechnix.com/how-to-setup-linux-media-server-using-jellyfin/?share=email (Click to email this to a friend)
[36]: https://www.ostechnix.com/how-to-setup-linux-media-server-using-jellyfin/#print (Click to print)

151
sources/tech/20190321 How to add new disk in Linux.md Normal file
View File

@ -0,0 +1,151 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (How to add new disk in Linux)
[#]: via: (https://kerneltalks.com/hardware-config/how-to-add-new-disk-in-linux/)
[#]: author: (kerneltalks https://kerneltalks.com)
How to add new disk in Linux
======
* * *
_Step by step procedure to add disk in Linux machine_
![New disk addition in Linux][1]
In this article we will walk you through steps to add new disk in Linux machine. Adding raw disk to linux machine may very depending upon the type of server you have but once disk is presented to machine, procedure of getting it to mount points is almost same.
**Objective** : Add new 10GB disk to server and create 5GB mount point out of it using LVM and newly created volume group.
* * *
### Adding raw disk to Linux machine
If you are using AWS EC2 Linux server, you may [follow these steps][2] to add raw disk. If you are on VMware Linux VM you will have different set of steps to follow to add disk. If you are running physical rack mount/blade server then adding disk will be a physical task.
Now once the disk is attached to Linux machine physically/virtually, it will be identified by kernel and then our rally starts.
* * *
### Identifying newly added disk in Linux
After attachment of raw disk, you need to ask kernel to [scan new disk][3]. Mostly its done now automatically by kernel in new versions.
First thing is to identify newly added disk and its name in kernel. There are numerous ways to achieve this. I will list few –
* You can observer `lsblk` output before and after adding/scanning disk to get new disk name.
* Check newly created disk files in `/dev` filesystem. Match timestamp of file and disk addition time.
* Observer `fdisk -l` output before and after adding/scanning disk to get new disk name.
For our example I am using AWS EC2 server and I added 5GB disk to my server. here is my lsblk output –
```
[root@kerneltalks ~]# lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
xvda 202:0 0 10G 0 disk
├─xvda1 202:1 0 1M 0 part
└─xvda2 202:2 0 10G 0 part /
xvdf 202:80 0 10G 0 disk
```
You can see xvdf is our newly added disk. Full path for disk is `/dev/xvdf`.
* * *
### Add new disk in LVM
We are using LVM here since its widely used and flexible volume manager on Linux plateform. Make sure you have `lvm` or `lvm2` [package installed on your system][4]. If not, [install lvm/lvm2 package][5].
Now, we are going to add this RAW disk in Logical Volume Manager and create 10GB of mount point out of it. List of commands you need to follow are –
* [pvcreate][6]
* [vgcreate][7]
* [lvcreate][8]
If you are willing to add disk to existing mount point and use its space to [extend mount point][9] then `vgcreate` should be replaced by `vgextend`.
Sample outputs from my session –
```
[root@kerneltalks ~]# pvcreate /dev/xvdf
Physical volume "/dev/xvdf" successfully created.
[root@kerneltalks ~]# vgcreate vgdata /dev/xvdf
Volume group "vgdata" successfully created
[root@kerneltalks ~]# lvcreate -L 5G -n lvdata vgdata
Logical volume "lvdata" created.
```
Now, you have logical volume created. You need to format it with filesystem on your choice and mount it. We are choosing ext4 filesystem here and formatting using `mkfs.ext4` .
```
[root@kerneltalks ~]# mkfs.ext4 /dev/vgdata/lvdata
mke2fs 1.42.9 (28-Dec-2013)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
327680 inodes, 1310720 blocks
65536 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=1342177280
40 block groups
32768 blocks per group, 32768 fragments per group
8192 inodes per group
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912, 819200, 884736
Allocating group tables: done
Writing inode tables: done
Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information: done
```
* * *
### Mounting volume from new disk on mount point
Lets mount the logical volume of 5GB which we created and formatted on /data mount point using `mount` command.
```
[root@kerneltalks ~]# mount /dev/vgdata/lvdata /data
[root@kerneltalks ~]# df -Ph /data
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/vgdata-lvdata 4.8G 20M 4.6G 1% /data
```
Verify your mount point with df command as above and you are all done! You can always add an entry in [/etc/fstab][10] to make this mount persistent over reboots.
You have attached 10GB disk to Linux machine and created 5GB mount point out of it!
--------------------------------------------------------------------------------
via: https://kerneltalks.com/hardware-config/how-to-add-new-disk-in-linux/
作者：[kerneltalks][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://kerneltalks.com
[b]: https://github.com/lujun9972
[1]: https://i1.wp.com/kerneltalks.com/wp-content/uploads/2019/03/How-to-add-new-disk-in-Linux.png?ssl=1
[2]: https://kerneltalks.com/cloud-services/how-to-add-ebs-disk-on-aws-linux-server/
[3]: https://kerneltalks.com/disk-management/howto-scan-new-lun-disk-linux-hpux/
[4]: https://kerneltalks.com/tools/check-package-installed-linux/
[5]: https://kerneltalks.com/tools/package-installation-linux-yum-apt/
[6]: https://kerneltalks.com/disk-management/lvm-command-tutorials-pvcreate-pvdisplay/
[7]: https://kerneltalks.com/disk-management/lvm-commands-tutorial-vgcreate-vgdisplay-vgscan/
[8]: https://kerneltalks.com/disk-management/lvm-commands-tutorial-lvcreate-lvdisplay-lvremove/
[9]: https://kerneltalks.com/disk-management/extend-file-system-online-lvm/
[10]: https://kerneltalks.com/config/understanding-etcfstab-file/

235
translated/tech/20180329 Python ChatOps libraries- Opsdroid and Errbot.md Normal file
View File

@ -0,0 +1,235 @@
Python ChatOps 库: Opsdroid 和 Errbot
======
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/idea_innovation_mobile_phone.png?itok=RqVtvxkd)
这篇文章由笔者和 [Lacey Williams Henschel][1] 共同编写。
ChatOps 是基于会话导向而进行的开发。它的想法是你可以编写能够对聊天窗口中的某些输入进行回复的可执行代码。作为一个开发者，你能够用 ChatOps 从 Slack 合并拉取请求，自动从收到的 Facebook 消息中给某人分配支持票或者通过 IRC 检查开发状态。
在 Python 世界，最为广泛使用的 ChatOps 库是 Opsdroid 和 Errbot。在这个月的 Python 专栏，让我们一起聊聊使用它们是怎样的体验，它们各自适用于什么方面以及如何着手使用它们。
### Opsdroid
[Opsdroid][2] 是一个相对年轻的（始于 2016）Python 开源聊天机器人库。它有着良好的开发文档，不错的教程并且包含能够帮助你对接流行的聊天服务的插件。
#### 它内建了什么
库本身并没有自带所有你需要上手的东西，但这是故意的。轻量级的框架鼓励你去运用它现存的连接器（Opsdroid 所谓的帮你接入聊天服务的插件）或者去编写你自己的，但是它并不会因自带你所不需要的的连接器而自贬身价。你可以轻松使用现有的 Opsdroid 连接器来接入：
+ 命令行
+ Cisco Spark
+ Facebook
+ GitHub
+ Matrix
+ Slack
+ Telegram
+ Twitter
+ Websockets
Opsdroid 引用使聊天机器人能够展现它们的技能的函数。这些技能其实是 `异步` Python 函数并使用 Opsdroid 叫做“匹配器”的匹配装饰器。你可以设置你的 Opsdroid 项目，来使用同样从你设置文件所在的代码基地来的技能。你也可以从外面的公共或私人仓库调用这些技能。
你同样可以激活一些现存的 Opsdroid 技能包括 [seen][3]，它会告诉你什么时候一个特定用户被聊天机器人所看到以及 [weather][4]，会将天气报告给用户。
最后，Opdroid 允许你使用现存的数据库模块设置数据库。现在 Opdroid 支持的数据库包括：
+ Mongo
+ Redis
+ SQLite
你可以在你的 Opdroid 项目中的 `configuration.yaml` 文件设置数据库、技能和连接器。
#### Opsdroid 的优势
**Docker 支持：**从一开始 Opsdroid 就打算在 Docker 中良好运行。Docker 指导是它 [安装文档][5] 中的一部分。使用 Opsdroid 和 Docker Copmose 也很简单：将 Opsdroid 设置成一种服务，当你运行 `docker-compose up` 时，你的 Opsdroid 服务将会开启你的聊天机器人也将就绪。
```
version: "3"
services:
  opsdroid:
    container_name: opsdroid
    build:
      context: .
      dockerfile: Dockerfile
```
**丰富的连接器：** Opsdroid 支持九种从外部接入像 Slack 和 Github 等服务的连接器。你所要做的一切就是在你的设置文件中激活那些连接器然后把必须的口令或者 API 密匙传过去。比如为了激活 Opsdroid 以在一个叫做 `#updates` 的 Slack 频道发帖，你需要将以下代码加入你设置文件的 `connectors` 部分：
```
- name: slack
    api-token: "this-is-my-token"
    default-room: "#updates"
```
在设置 Opsdroid 以接入 Slack 之前你需要[添加一个机器人用户][6]。
如果你需要接入一个 Opsdroid 不支持的服务，在[文档][7]里有有添加你自己的连接器的教程。
**相当不错的文档：** 特别是对于一个在积极开发中的新兴库来说，Opsdroid 的文档十分有帮助。这些文档包括一篇带你创建几个不同的基本技能的[教程][8]。Opsdroid 在[技能][9]，[连接器][7]，[数据库][10]，以及[匹配器][11]方面的文档也十分清晰。
**自然语言处理：**它所支持的技能和连接器的仓库为它的技能提供了富有帮助的示范代码。它同样提供了几个包括 [Dialogflow][12]，[luis.ai][13]，[Recast.AI][14] 以及 [wit.ai][15] 的 NLP API。
#### 对 Opsdroid 可能的考虑
Opsdroid 对它的一部分连接器还没有激活全部的特性。比如说，Slack API 允许你向你的消息添加颜色柱，图片以及其他的“附件”。Opsdroid Slack 连接器并没有激活“附件”特性，所以如果那些特性对你来说很重要的话，你需要编写一个自定义的 Slack 连接器。如果连接器缺少一个你需要的特性，Opsdroid 将欢迎你的[贡献][16]。文档中可以使用更多的例子，特别是对于预料到的使用场景。
#### 示例用法
`hello/__init__.py`
```
from opsdroid.matchers import match_regex
import random
@match_regex(r'hi|hello|hey|hallo')
async def hello(opsdroid, config, message):
    text = random.choice(["Hi {}", "Hello {}", "Hey {}"]).format(message.user)
    await message.respond(text)
```
`configuration.yaml`
```
connectors:
  - name: websocket
skills:
  - name: hello
    repo: "https://github.com/<user_id>/hello-skill"
```
### Errbot
[Errbot][17] 是一个功能齐全的开源聊天机器人。Errbot 发行于2012年并且拥有人们从一个成熟的项目能期待的一切，包括良好的文档，优秀的教程以及许多帮你连入现存的流行聊天服务的插件。
#### 它内建了什么
不像采用了一个较轻量级途径的 Opsdroid，Errbot 安全地自带了你需要创建一个自定义机器人的一切东西。
Errbot 包括了对于本地 XMPP， IRC， Slack， Hipchat 以及 Telegram 服务的支持。它通过社区支持的后端列出了另外十种服务。
#### Errbot 的优势
**良好的文档：** Errbot 的文档成熟易读。
**动态插件架构：** Errbot 允许你通过和聊天机器人交谈安全安装，卸载，更新，激活以及禁用插件。这使得开发和添加特性十分简便。感谢 Errbot 的颗粒性授权系统，出于安全意识这所有的一切都可以被锁闭。
当某个人输入 `!help`，Errbot 使用你的插件文档字符串来为可获取的命令生成文档，这使得了解每行命令的作用更加简便。
**內建的管理和安全特性：** Errbot 允许你限制拥有管理员权限甚至细粒度访问控制用户列表。比如说你可以限制特定用户或房间访问特定命令。
**额外的插件框架：** Errbot 支持钩子，回调，子命令，webhook，轮询以及其它[多得多的特性][18]。如果那些还不够，你甚至可以编写[动态插件][19]。当你需要基于在远程服务器上什么命令可以获取来激活聊天命令时，这个特性十分有用。
**自带测试框架：** Errbot 支持 [pytest][20] 同时也自带一些能使测试插件变的可能且简便的有用设施。它“[测试你的插件][21]”的文档出于深思熟虑并提供足够的资料让你上手。
#### 对 Errbot 可能的考虑
**首先 !：** 默认情况下，Errbot 命令发出时以一个惊叹号打头（`!help` 以及 `!hello`）。一些人可能会喜欢这样，但是另一些人可能认为这让人烦恼。谢天谢地，这很容易关掉。
**插件元数据** 首先，Errbot 的 [Hello World][22] 插件示例看上去易于使用。然而我无法加载我的插件直到我进一步阅读了教程并发现我还需要一个 `.plug` 文档，一个 Errbot 用来加载插件的文档。这可能比较吹毛求疵了，但是在我深挖文档之前，这对我来说都不是显而易见的。
### 示例用法
`hello.py`
```
import random
from errbot import BotPlugin, botcmd
class Hello(BotPlugin):
    @botcmd
    def hello(self, msg, args):
        text = random.choice(["Hi {}", "Hello {}", "Hey {}"]).format(message.user)
        return text
```
`hello.plug`
```
[Core]
Name = Hello
Module = hello
[Python]
Version = 2+
[Documentation]
Description = Example "Hello" plugin
```
你用过 Errbot 或 Opsdroid 吗？如果用过请留下关于你对于这些工具印象的留言。
--------------------------------------------------------------------------------
via: https://opensource.com/article/18/3/python-chatops-libraries-opsdroid-and-errbot
作者：[Jeff Triplett][a]
译者：[tomjlw](https://github.com/tomjlw)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]:https://opensource.com/users/laceynwilliams
[1]:https://opensource.com/users/laceynwilliams
[2]:https://opsdroid.github.io/
[3]:https://github.com/opsdroid/skill-seen
[4]:https://github.com/opsdroid/skill-weather
[5]:https://opsdroid.readthedocs.io/en/stable/#docker
[6]:https://api.slack.com/bot-users
[7]:https://opsdroid.readthedocs.io/en/stable/extending/connectors/
[8]:https://opsdroid.readthedocs.io/en/stable/tutorials/introduction/
[9]:https://opsdroid.readthedocs.io/en/stable/extending/skills/
[10]:https://opsdroid.readthedocs.io/en/stable/extending/databases/
[11]:https://opsdroid.readthedocs.io/en/stable/matchers/overview/
[12]:https://opsdroid.readthedocs.io/en/stable/matchers/dialogflow/
[13]:https://opsdroid.readthedocs.io/en/stable/matchers/luis.ai/
[14]:https://opsdroid.readthedocs.io/en/stable/matchers/recast.ai/
[15]:https://opsdroid.readthedocs.io/en/stable/matchers/wit.ai/
[16]:https://opsdroid.readthedocs.io/en/stable/contributing/
[17]:http://errbot.io/en/latest/
[18]:http://errbot.io/en/latest/features.html#extensive-plugin-framework
[19]:http://errbot.io/en/latest/user_guide/plugin_development/dynaplugs.html
[20]:http://pytest.org/
[21]:http://errbot.io/en/latest/user_guide/plugin_development/testing.html
[22]:http://errbot.io/en/latest/index.html#simple-to-build-upon

61
translated/tech/20190125 Get started with Freeplane, an open source mind mapping application.md Normal file
View File

@ -0,0 +1,61 @@
[#]: collector: (lujun9972)
[#]: translator: (geekpi)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Get started with Freeplane, an open source mind mapping application)
[#]: via: (https://opensource.com/article/19/1/productivity-tool-freeplane)
[#]: author: (Kevin Sonney https://opensource.com/users/ksonney (Kevin Sonney))
开始使用 Freeplane，一款开源思维导图
======
使用 Freeplane 进行头脑风暴，这是我们开源工具系列中的第 13 个，它将使你在 2019 年更高效。
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/brain_data.png?itok=RH6NA32X)
每年年初似乎都有疯狂的冲动，想方设法提高工作效率。新年的决议，开始一年的权利，当然，“与旧的，与新的”的态度都有助于实现这一目标。通常的一轮建议严重偏向封闭源和专有软件。它不一定是这样。
这是我挑选出的 19 个新的（或者对你而言新的）开源工具中的第 13 个工具来帮助你在 2019 年更有效率。
### Freeplane
[思维导图][1]是我用于快速头脑风暴和捕捉数据的最有价值的工具之一。思维导图是一个灵活的过程，有助于显示事物的相关性，并可用于快速组织相互关联的信息。从规划角度来看，思维导图让你快速将大脑中的单个概念，想法或技术表达除了。
![](https://opensource.com/sites/default/files/uploads/freeplane-1.png)
[Freeplane][2] 是一款桌面应用，可以轻松创建、查看、编辑和共享思维导图。它是 [FreeMind][3] 这款很长时间内都是思维导图首选应用的重新设计。
安装 Freeplane 非常简单。它是一个 [Java][4] 应用，并使用 ZIP 文件分发，可使用脚本在 Linux、Windows 和 MacOS 上启动。在第一次启动它时，主窗口会包含一个示例思维导图，其中包含指向你可以使用 Freeplane 执行的所有不同操作的文档的链接。
![](https://opensource.com/sites/default/files/uploads/freeplane-2.png)
创建新思维导图时，你可以选择模板。标准模板（可能位于列表底部）适用于大多数情况。你只需开始输入开头的想法或短语，你的文本就会替换中心的文本。按“插入”键将从中心添加一个分支（或节点），其中包含一个空白字段，你可以在其中填写与该想法相关的内容。再次按“插入”将添加另一个节点到第一个上。在节点上按“回车”键将添加与该节点平行的节点。
![](https://opensource.com/sites/default/files/uploads/freeplane-3.png)
在添加节点时，你可能会想到与主题相关的另一个想法。使用鼠标或箭头键，返回到导图的中心，然后按“插入”键。这将在主题之外创建一个新节点。
如果你想使用 Freeplane 其他功能，请右键单击任何节点以显示该节点的“属性”菜单。工具窗口（在视图 ->控制菜单下激活）包含丰富的自定义选项，包括线条形状和粗细、边框形状、颜色等等。“日历”选项允许你在节点中插入日期，并为节点设置到期提醒。 （请注意，提醒仅在 Freeplane 运行时有效。）思维导图可以导出为多种格式，包括常见的图像、XML、Microsoft Project、Markdown 和 OPML。
![](https://opensource.com/sites/default/files/uploads/freeplane-4.png)
Freeplane 为你提供了创建生动和实用的思维导图所需的所有工具，让你表达头脑中的想法，并可采取行动。
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/1/productivity-tool-freeplane
作者：[Kevin Sonney][a]
选题：[lujun9972][b]
译者：[geekpi](https://github.com/geekpi)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/ksonney (Kevin Sonney)
[b]: https://github.com/lujun9972
[1]: https://en.wikipedia.org/wiki/Mind_map
[2]: https://www.freeplane.org/wiki/index.php/Home
[3]: https://sourceforge.net/projects/freemind/
[4]: https://java.com

367
translated/tech/20190305 5 Ways To Generate A Random-Strong Password In Linux Terminal.md Normal file
View File

@ -0,0 +1,367 @@
[#]: collector: (lujun9972)
[#]: translator: (leommxj)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (5 Ways To Generate A Random/Strong Password In Linux Terminal)
[#]: via: (https://www.2daygeek.com/5-ways-to-generate-a-random-strong-password-in-linux-terminal/)
[#]: author: (Magesh Maruthamuthu https://www.2daygeek.com/author/magesh/)
在 Linux 终端下生成随机/强密码的五种方法
======
最近我们在网站上发表过一篇关于 **[密码强度与密码分数检查][1]** 的文章。
它可以帮助你检查你的密码的强度和分数。
我们可以手工创建我们需要的密码。但如果你想要为多个用户或服务器生成密码，解决方案是什么呢？
是的，Linux 中有许多可用的工具能满足这个需求。本文中我将会介绍五种最好的密码生成器。
这些工具可以为你生成高强度随机密码。如果你想要为多个用户和服务器更新密码，请继续读下去。
这些工具易于使用，这也是我喜欢用它们的原因。默认情况下它们会生成一个足够强壮的密码，你也可以通过使用其他可用的选项来生成一个超强的密码。
它会帮助你生成符合下列要求的超强密码。密码长度至少有 12-15 个字符，包括字母（大写及小写），数字及特殊符号。
工具如下：
* `pwgen:` pwgen 程序生成易于人类记忆并且尽可能安全的密码。
* `openssl:` openssl 是一个用来从 shell 中调用 OpenSSL 加密库提供的多种密码学函数的命令行工具。
* `gpg:` OpenPGP 加密/签名工具。
* `mkpasswd:` 生成新密码，可以选择直接应用给一名用户。
* `makepasswd:` makepasswd 使用 /dev/urandom 生成真随机密码，比起好记它更重视安全性。
* `/dev/urandom file` 两个特殊的字符文件 /dev/random 和 /dev/urandom （自 Linux 1.3.30 起） 提供了内核随机数生成器的接口。
* `md5sum:` md5sum 是一个用来计算及校验 128-bit MD5 哈希的程序。
* `sha256sum:` sha256sum 被设计用来使用 SHA-256 算法（SHA-2系列，摘要长度为256位）校验数据完整性。
* `sha1pass:` sha1pass 生成一个 SHA1 密码哈希。在命令缺少盐值的情况下，将会生成一个随机的盐值向量。
### 怎么用 pwgen 命令在 linux 下生成一个随机的强壮密码？
pwgen 程序生成易于人类记忆并且尽可能安全的密码。
易于人类记忆的密码永远都不会像完全随机的密码一样安全。
使用 `-s` 选项来生成完全随机，难于记忆的密码。由于我们记不住，这些密码应该只用于机器。
在 **`Fedora`** 系统中，使用 **[DNF 命令][2]** 来安装 pwgen。
```
$ sudo dnf install pwgen
```
在 **`Debian/Ubuntu`** 系统中，使用 **[APT-GET 命令][3]** 或 **[APT 命令][4]** 来安装 pwgen。
```
$ sudo apt install pwgen
```
在 **`Arch Linux`** 系统中，使用 **[Pacman 命令][5]** 来安装 pwgen。
```
$ sudo pacman -S pwgen
```
在 **`RHEL/CentOS`** 系统中，使用 **[YUM 命令][6]** 来安装 pwgen。
```
$ sudo yum install pwgen
```
在 **`openSUSE Leap`** 系统中，使用 **[Zypper 命令][7]** 来安装pwgen。
```
$ sudo zypper install pwgen
```
### 在 Linux 下如何使用 pwgen 命令？
使用方法非常简单直接。使用下列示例中更适合你的那种。默认情况下，它会生成一个方便记忆的密码。
想要这样做，只要在你的终端中运行 `pwgen` 命令。将会一下生成160个密码以8列20行打印出来。
```
$ pwgen
ameiK2oo aibi3Cha EPium0Ie aisoh1Ee Nidee9ae uNga0Bee uPh9ieM1 ahn1ooNg
oc5ooTea tai7eKid tae2yieS hiecaiR8 wohY2Ohk Uab2maed heC4aXoh Ob6Nieso
Shaeriu3 uy9Juk5u hoht7Doo Fah6yah3 faz9Jeew eKiek4ju as0Xuosh Eiwo4epo
oot8teeZ Ui1yoohi Aechae7A Ohdi2ael cae5Thoh Au1aeTei ais0aiC2 Cai2quin
Oox9ohz4 neev0Che ahza8AQu Ahz7eica meiBeeW0 Av3bo7ah quoiTu3f taeNg3ae
Aiko7Aiz SheiGh8E aesaeSh7 haet6Loo AeTel3oN Ath7zeer IeYah4ie UG3ootha
Ohch9Och Phuap6su iel5Xu7s diqui7Bu ieF2dier eeluHa1u Thagei0i Ceeth3oh
OCei1ahj zei2aiYo Jahgh1ia ooqu1Cej eez2aiPo Wahd5soo noo7Mei9 Hie5ashe
Uith4Or2 Xie3uh2b fuF9Eilu eiN2sha9 zae2YaSh oGh5ephi ohvao4Ae aixu6aeM
fo4Ierah iephei6A hae9eeGa eiBeiY3g Aic8Kee9 he8AheCh ohM4bid9 eemae3Zu
eesh2EiM cheiGa4j PooV2vii ahpeeg5E aezauX2c Xe7aethu Ahvaph7a Joh2heec
Ii5EeShi aij7Uo8e ooy2Ahth mieKe2ni eiQuu8fe giedaQu0 eiPhob3E oox1uo2U
eehia4Hu ga9Ahw0a ohxuZei7 eV4OoXio Kid2wu1n ku4Ahf5s uigh8uQu AhWoh0po
vo1Eeb2u Ahth7ve5 ieje4eiL ieci1Ach Meephie9 iephieY8 Eesoom7u eakai2Bo
uo8Ieche Zai3aev5 aGhahf0E Wowoo5th Oraeb0ah Gah3nah0 ieGhah0p aeCh0OhJ
ahQu2feZ ahQu0gah foik7Ush cei1Wai1 Aivi3ooY eephei5U MooZae3O quooRoh7
aequae5U pae6Ceiv eizahF1k ohmi7ETa ahyaeK1N Mohw2no8 ooc8Oone coo7Ieve
eePhei9h Weequ8eV Vie4iezu neeMiim4 ie6aiZoh Queegh2E shahwi3N Inichie8
Sid1aeji mohj4Ko7 lieDi0pe Zeemah6a thuevu2E phi4Ohsh paiKeix1 ooz1Ceph
ahV4yore ue2laePh fu1eThui qui7aePh Fahth1nu ohk9puLo aiBeez0b Neengai5
```
生成安全的随机密码，使用 pwgen 命令的 `-s` 选项。
```
$ pwgen -s
CU75lgZd 7HzzKgtA 2ktBJDpR F6XJVhBs UjAm3bNL zO7Dw7JJ pxn8fUvp Ka3lLilG
ywJX7iJl D9ajxb6N 78c1HOg2 g8vtWCra Jp6pBGBw oYuev9Vl gbA6gHV8 G6XQoVO5
uQN98IU4 50GgQfrX FrTsou2t YQorO4x6 UGer8Yi2 O7DB5nw1 1ax370UR 1xVRPkA1
RVaGDr2i Nt11ekUd 9Vm3D244 ck8Lnpd0 SjDt8uWn 5ERT4tf8 4EONFzyY Jc6T83jg
WZa6bKPW H4HMo1YU bsDDRik3 gBwV7LOW 9H1QRQ4x 3Ak7RcSe IJu2RBF9 e508xrLC
SzTrW191 AslxDa6E IkWWov2b iOb6EmTy qHt82OwG 5ZFO7B53 97zmjOPu A4KZuhYV
uQpoJR4D 0eKyOiUr Rz96smeO 3HTABu3N 6W0VmEls uPsp5zpw 8UD3VkMG YTct6Rd4
VKo0cVmq E07ZX7j9 kQSlvA69 Nm3fpv3i xWvF2xMu yEfcw8uA oQGVX3l9 grTzx7Xj
s4GVEYtM uJl5sYMe n3icRPiY ED3Mup4B k3M9KHI7 IkxqoSM0 dt2cxmMU yb2tUkut
2Q9wGZQx 8Rpo11s9 I13siOHu 7GV64Fjv 3VONzD8i SCDfVD3F oiPTx239 6BQakoiJ
XUEokiC4 ybL7VGmL el2RfvWk zKc7CLcE 3FqNBSyA NjDWrvZ5 KI3NSX4h VFyo6VPr
h4q3XeqZ FDYMoX6f uTU5ZzU3 6u4ob4Ep wiYPt05n CZga66qh upzH6Z9y RuVcqbe8
taQv11hq 1xsY67a8 EVo9GLXA FCaDLGb1 bZyh0YN8 0nTKo0Qy RRVUwn9t DuU8mwwv
x96LWpCb tFLz3fBG dNb4gCKf n6VYcOiH 1ep6QYFZ x8kaJtrY 56PDWuW6 1R0If4kV
2XK0NLQK 4XQqhycl Ip08cn6c Bnx9z2Bz 7gjGlON7 CJxLR1U4 mqMwir3j ovGXWu0z
MfDjk5m8 4KwM9SAN oz0fZ5eo 5m8iRtco oP5BpLh0 Z5kvwr1W f34O2O43 hXao1Sp8
tKoG5VNI f13fuYvm BQQn8MD3 bmFSf6Mf Z4Y0o17U jT4wO1DG cz2clBES Lr4B3qIY
ArKQRND6 8xnh4oIs nayiK2zG yWvQCV3v AFPlHSB8 zfx5bnaL t5lFbenk F2dIeBr4
C6RqDQMy gKt28c9O ZCi0tQKE 0Ekdjh3P ox2vWOMI 14XF4gwc nYA0L6tV rRN3lekn
lmwZNjz1 4ovmJAr7 shPl9o5f FFsuNwj0 F2eVkqGi 7gw277RZ nYE7gCLl JDn05S5N
```
假设你想要生成五个14字符长的密码，方法如下。
```
$ pwgen -s 14 5
7YxUwDyfxGVTYD em2NT6FceXjPfT u8jlrljbrclcTi IruIX3Xu0TFXRr X8M9cB6wKNot1e
```
如果你真的想要生成20个超强随机密码，方法如下。
```
$ pwgen -cnys 14 20
mQ3E=vfGfZ,5[B #zmj{i5|ZS){jg Ht_8i7OqJ%N`~2 443fa5iJ\W-L?] ?Qs$o=vz2vgQBR
^'Ry0Az|J9p2+0 t2oA/n7U_'|QRx EsX*%_(4./QCRJ ACr-,8yF9&eM[* !Xz1C'bw?tv50o
8hfv-fK(VxwQGS q!qj?sD7Xmkb7^ N#Zp\_Y2kr%!)~ 4*pwYs{bq]Hh&Y |4u=-Q1!jS~8=;
]{$N#FPX1L2B{h I|01fcK.z?QTz" l~]JD_,W%5bp.E +i2=D3;BQ}p+$I n.a3,.D3VQ3~&i
```
### 如何在 Linux 下使用 openssl 命令生成随机强密码？
openssl 是一个用来从 shell 中调用 OpenSSL 加密库提供的多种密码学函数的命令行工具。
像下面这样运行 openssl 命令可以生成一个14字符长的随机强密码。
```
$ openssl rand -base64 14
WjzyDqdkWf3e53tJw/c=
```
如果你想要生成十个14字符长的随机强密码，将 openssl 命令与 for 循环结合起来使用。
```
$ for pw in {1..10}; do openssl rand -base64 14; done
6i0hgHDBi3ohZ9Mil8I=
gtn+y1bVFJFanpJqWaA=
rYu+wy+0nwLf5lk7TBA=
xrdNGykIzxaKDiLF2Bw=
cltejRkDPdFPC/zI0Pg=
G6aroK6d4xVVYFTrZGs=
jJEnFoOk1+UTSx/wJrY=
TFxVjBmLx9aivXB3yxE=
oQtOLPwTuO8df7dIv9I=
ktpBpCSQFOD+5kIIe7Y=
```
### 如何在 Linux 下使用 gpg 命令生成随机强密码？
gpg 是 Gnu Privacy Guard （GnuPG） 中的 OpenPGP 实现部分。它是一个提供 OpenPGP 标准的数字加密与签名服务的工具。gpg 具有完整的密钥管理功能和其他完整 OpenPGP 实现应该具备的全部功能。
下面这样执行 gpg 命令来生成一个14字符长的随机强密码。
```
$ gpg --gen-random --armor 1 14
or
$ gpg2 --gen-random --armor 1 14
jq1mtY4gBa6gIuJrggM=
```
如果想要使用 gpg 生成十个14字符长的随机强密码，像下面这样使用 for 循环。
```
$ for pw in {1..10}; do gpg --gen-random --armor 1 14; done
or
$ for pw in {1..10}; do gpg2 --gen-random --armor 1 14; done
F5ZzLSUMet2kefG6Ssc=
8hh7BFNs8Qu0cnrvHrY=
B+PEt28CosR5xO05/sQ=
m21bfx6UG1cBDzVGKcE=
wALosRXnBgmOC6+++xU=
TGpjT5xRxo/zFq/lNeg=
ggsKxVgpB/3aSOY15W4=
iUlezWxL626CPc9omTI=
pYb7xQwI1NTlM2rxaCg=
eJjhtA6oHhBrUpLY4fM=
```
### 如何在 Linux 下使用 mkpasswd 命令生成随机强密码？
mkpasswd 生成密码并可以自动将其应用在用户上。不加任何参数的情况下，mkpasswd 返回一个新的密码。它是 expect 软件包的一部分，所以想要使用 mkpasswd 命令，你需要安装 expect 软件包。
在 **`Fedora`** 系统中，使用 **[DNF 命令][2]** 来安装 mkpasswd。
```
$ sudo dnf install expect
```
在 **`Debian/Ubuntu`** 系统中，使用 **[APT-GET 命令][3]** 或 **[APT 命令][4]** 来安装 mkpasswd。
```
$ sudo apt install expect
```
在 **`Arch Linux`** 系统中，使用 **[Pacman 命令][5]** 来安装 mkpasswd。
```
$ sudo pacman -S expect
```
在 **`RHEL/CentOS`** 系统中，使用 **[YUM 命令][6]** 来安装 mkpasswd。
```
$ sudo yum install expect
```
在 **`openSUSE Leap`** 系统中，使用 **[Zypper 命令][7]** 来安装 mkpasswd。
```
$ sudo zypper install expect
```
在终端中执行 `mkpasswd` 命令来生成一个随机密码。
```
$ mkpasswd
37_slQepD
```
像下面这样执行 mkpasswd 命令可以生成一个14字符长的随机强密码。
```
$ mkpasswd -l 14
W1qP1uv=lhghgh
```
像下面这样执行 mkpasswd 命令 来生成一个14字符长，包含大小写字母、数字和特殊字符的随机强密码。
```
$ mkpasswd -l 14 -d 3 -C 3 -s 3
3aad!bMWG49"t,
```
如果你想要生成十个14字符长的随机强密码(包括大小写字母、数字和特殊字符)，使用 for 循环和 mkpasswd 命令。
```
$ for pw in {1..10}; do mkpasswd -l 14 -d 3 -C 3 -s 3; done
zmSwP[q9;P1r6[
E42zcvzM"i3%B\
8}1#[email protected]
0X:zB(mmU22?nj
0sqqL44M}ko(O^
43tQ(.6jG;ceRq
-jB6cp3x1GZ$e=
$of?Rj9kb2N(1J
9HCf,nn#gjO79^
Tu9m56+Ev_Yso(
```
### How To Generate A Random Strong Password In Linux Using makepasswd Command?
### 如何在 Linux 下使用 makepasswd 命令生成随机强密码？
makepasswd 使用 /dev/urandom 生成真随机密码，跟易于记忆相比它更注重安全性。它也可以加密命令行中给出的明文密码。
在终端中执行 `makepasswd` 命令来生成一个随机密码。
```
$ makepasswd
HdCJafVaN
```
在终端中像下面这样执行 makepasswd 命令来生成14字符长的随机强密码。
```
$ makepasswd --chars 14
HxJDv5quavrqmU
```
像下面这样执行 makepasswd 来生成十个14字符长的随机强密码。
```
$ makepasswd --chars 14 --count 10
TqmKVWnRGeoVNr
mPV2P98hLRUsai
MhMXPwyzYi2RLo
dxMGgLmoFpYivi
8p0G7JvJjd6qUP
7SmX95MiJcQauV
KWzrh5npAjvNmL
oHPKdq1uA9tU85
V1su9GjU2oIGiQ
M2TMCEoahzLNYC
```
### 如何在 Linux 系统中使用多个命令生成随机强密码？
如果你还在寻找其他的方案，下面的工具也可以用来在 Linux 中生成随机密码。
**使用 md5sum** md5sum 是一个用来计算及校验 128-bit MD5 哈希的程序。
```
$ date | md5sum
9baf96fb6e8cbd99601d97a5c3acc2c4 -
```
**使用 /dev/urandom:** 两个特殊的字符文件 /dev/random 和 /dev/urandom （自 Linux 1.3.30 起） 提供了内核随机数生成器的接口。/dev/random 的主设备号为1，次设备号为8。/dev/urandom 主设备号为1，次设备号为9。
```
$ cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c 14
15LQB9J84Btnzz
```
**使用 sha256sum:** sha256sum 被设计用来使用 SHA-256 算法（SHA-2系列，摘要长度为256位）校验数据完整性。
```
$ date | sha256sum
a114ae5c458ae0d366e1b673d558d921bb937e568d9329b525cf32290478826a -
```
**使用 sha1pass:** sha1pass 生成一个 SHA1 密码哈希。在命令缺少盐值的情况下，将会生成一个随机的盐值向量。
```
$ sha1pass
$4$9+JvykOv$e7U0jMJL2yBOL+RVa2Eke8SETEo$
```
--------------------------------------------------------------------------------
via: https://www.2daygeek.com/5-ways-to-generate-a-random-strong-password-in-linux-terminal/
作者：[Magesh Maruthamuthu][a]
选题：[lujun9972][b]
译者：[leommx](https://github.com/leommxj)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.2daygeek.com/author/magesh/
[b]: https://github.com/lujun9972
[1]: https://www.2daygeek.com/how-to-check-password-complexity-strength-and-score-in-linux/
[2]: https://www.2daygeek.com/dnf-command-examples-manage-packages-fedora-system/
[3]: https://www.2daygeek.com/apt-get-apt-cache-command-examples-manage-packages-debian-ubuntu-systems/
[4]: https://www.2daygeek.com/apt-command-examples-manage-packages-debian-ubuntu-systems/
[5]: https://www.2daygeek.com/pacman-command-examples-manage-packages-arch-linux-system/
[6]: https://www.2daygeek.com/yum-command-examples-manage-packages-rhel-centos-systems/
[7]: https://www.2daygeek.com/zypper-command-examples-manage-packages-opensuse-system/

65
translated/tech/20190306 3 popular programming languages you can learn with Raspberry Pi.md Normal file
View File

@ -0,0 +1,65 @@
[#]: collector: (lujun9972)
[#]: translator: (qhwdw)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (3 popular programming languages you can learn with Raspberry Pi)
[#]: via: (https://opensource.com/article/19/3/programming-languages-raspberry-pi)
[#]: author: (Anderson Silva https://opensource.com/users/ansilva)
可以使用树莓派学习的 3 种流行编程语言
======
通过树莓派学习编程，让你在就业市场上更值钱。
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/programming_language_c.png?itok=mPwqDAD9)
在本系列的上一篇文章中，我分享了 [教孩子们使用树莓派编程][1] 的一些方式。理论上，这些资源并不局限于只适用于孩子们，成人也是可以使用的。但是学习就业市场上急需的编程语言，可以让你得到更好的机会。
这里是你可以使用树莓派学习的三种编程语言。
### Python
[Python][2] 已经成为开源世界里 [最流行的编程语言][3]。它的解释器已经打包进每个流行的 Linux 发行版中。如果你在树莓派中安装的是 Raspbian，你就会看到一个名为 [Thonny][4] 的应用，它是为新手准备的 Python 集成开发环境。简单来说，一个集成开发环境就是能够提供让你的代码运行起来所需要的任何东西的一个应用程序，一般来说，包括调试器、文档、自动编译，和仿真程序。[这是一个在树莓派上使用 Thonny 和 Python 入门的非常好的小教程][5]。
![](https://opensource.com/sites/default/files/uploads/thonny.png)
### Java
虽然 [Java][6] 已经不像以前那样引人注目了，但它仍然在世界各地的大学和企业中占据着重要的地位。因此，即便是一些人对我建议新手学习 Java 持反对意见，但我仍然强烈推荐大家去学习 Java；之所以这么做，原因之一是，它仍然很流行，原因之二是，它有大量的便于你学习的图书、课程、和其它的可用信息。在树莓派上学习它，你可以从使用 Java 集成开发环境 [BlueJ][7] 开始。
![](https://opensource.com/sites/default/files/uploads/bluejayide.png)
### JavaScript
“我的黄金时代…" [JavaScript][8] 的本质是一个允许用户去组织和自动化浏览器中的用户事件以及修改 HTML 元素的客户端语言。目前，JavaScript 已经不仅限于浏览器中，它在其它类型的客户端（移动应用）中也是可以使用的，甚至也用在服务器端编程。[Node.js][9] 是一个流行的运行时环境，它允许开发者在客户端-浏览器范式之外写程序。想学习在树莓派上运行 Node.js 的更多知识，请查看 [W3Schools 教程][10]。
### 其它编程语言
如果这里没有列出你想学习的编程语言，别失望。你可以使用你的树莓派去编译或解释任何你选择的语言，包括 C、C++、PHP、和 Ruby，这种可能性还是很大的。
微软的 [Visual Studio Code][11] 也可以运行在 [树莓派][12] 上。它是来自微软的开源代码编辑器，它支持多种标记和编程语言。
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/3/programming-languages-raspberry-pi
作者：[Anderson Silva][a]
选题：[lujun9972][b]
译者：[qhwdw](https://github.com/qhwdw)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/ansilva
[b]: https://github.com/lujun9972
[1]: https://opensource.com/article/19/2/teach-kids-program-raspberry-pi
[2]: https://opensource.com/resources/python
[3]: https://www.economist.com/graphic-detail/2018/07/26/python-is-becoming-the-worlds-most-popular-coding-language
[4]: https://thonny.org/
[5]: https://raspberrypihq.com/getting-started-with-python-programming-and-the-raspberry-pi/
[6]: https://opensource.com/resources/java
[7]: https://www.bluej.org/raspberrypi/
[8]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
[9]: https://nodejs.org/en/
[10]: https://www.w3schools.com/nodejs/nodejs_raspberrypi.asp
[11]: https://code.visualstudio.com/
[12]: https://pimylifeup.com/raspberry-pi-visual-studio-code/