mirror of
https://github.com/LCTT/TranslateProject.git
synced 2024-12-26 21:30:55 +08:00
Merge remote-tracking branch 'LCTT/master'
This commit is contained in:
Xingyu Wang
commit
df3896298d
@ -1,8 +1,8 @@
|
||||
[#]: collector: (lujun9972)
|
||||
[#]: translator: (wxy)
|
||||
[#]: reviewer: ( )
|
||||
[#]: publisher: ( )
|
||||
[#]: url: ( )
|
||||
[#]: reviewer: (wxy)
|
||||
[#]: publisher: (wxy)
|
||||
[#]: url: (https://linux.cn/article-11905-1.html)
|
||||
[#]: subject: (Customize your internet with an open source search engine)
|
||||
[#]: via: (https://opensource.com/article/20/2/open-source-search-engine)
|
||||
[#]: author: (Seth Kenlon https://opensource.com/users/seth)
|
||||
@ -12,17 +12,17 @@
|
||||
|
||||
> 上手开源的对等 Web 索引器 YaCy。
|
||||
|
||||
![Person using a laptop][1]
|
||||
|
||||
|
||||
很久以前，互联网很小，小到几个人就可以索引它们，这些人收集了所有网站的名称和链接，并按主题将它们分别列在页面或印刷书籍中。随着万维网网络的发展，“网络环”惯例得到了发展，在该惯例中，具有类似的内容、主题或敏感性的站点捆绑在一起，形成了通往每个成员的循环路径。环中任何站点的访问者都可以单击按钮以转到环中的下一个或上一个站点，以发现与其兴趣相关的新站点。
|
||||
很久以前，互联网很小，小到几个人就可以索引它们，这些人收集了所有网站的名称和链接，并按主题将它们分别列在页面或印刷书籍中。随着万维网网络的发展，形成了“网站环”形式，具有类似的内容、主题或敏感性的站点捆绑在一起，形成了通往每个成员的循环路径。环中任何站点的访问者都可以单击按钮以转到环中的下一个或上一个站点，以发现与其兴趣相关的新站点。
|
||||
|
||||
过了一段时间，互联网似乎变得臃肿不堪了。每个人都在线上，有很多冗余和垃圾邮件，多到让你无法找到任何东西。Yahoo 和 AOL、CompuServe 以及类似的服务各自采用了不同的方法来解决这个问题，但是直到谷歌出现后，现代的搜索模型才得以普及。按谷歌的做法，互联网应该通过搜索引擎进行索引、排序和排名。
|
||||
又过了一段时间，互联网似乎变得臃肿不堪了。每个人都在网络上，有很多冗余信息和垃圾邮件，多到让你无法找到任何东西。Yahoo 和 AOL、CompuServe 以及类似的服务各自采用了不同的方法来解决这个问题，但是直到谷歌出现后，现代的搜索模型才得以普及。按谷歌的做法，互联网应该通过搜索引擎进行索引、排序和排名。
|
||||
|
||||
### 为什么选择开源替代品？
|
||||
|
||||
像谷歌和 DuckDuckGo 这样的搜索引擎显然是卓有成效的。你可能是通过搜索引擎访问的本站。尽管对于因主机选择不遵循最佳实践来优化搜索引擎从而使内容陷入困境仍存在争论，但用于管理丰富的文化、知识和轻率的信息（即互联网）的现代解决方案是无情的索引。
|
||||
像谷歌和 DuckDuckGo 这样的搜索引擎显然是卓有成效的。你可能是通过搜索引擎访问的本站。尽管对于因主机没有选择遵循优化搜索引擎的最佳实践从而导致会内容陷入困境这件事仍存在争论，但用于管理丰富的文化、知识和轻率的信息（即互联网）的现代解决方案是冷冰冰的索引。
|
||||
|
||||
但是也许出于隐私方面的考虑，或者你希望为使互联网更加独立而做出的贡献，你或许不愿意使用谷歌或 DuckDuckGo。如果你对此感兴趣，那么可以考虑参加 [YaCy] [2]，这是一个对等互联网索引器和搜索引擎。
|
||||
但是也许出于隐私方面的考虑，或者你希望为使互联网更加独立而做出贡献，你或许不愿意使用谷歌或 DuckDuckGo。如果你对此感兴趣，那么可以考虑参加 [YaCy][2]，这是一个对等互联网索引器和搜索引擎。
|
||||
|
||||
### 安装 YaCy
|
||||
|
||||
@ -52,29 +52,29 @@ $ /opt/startYACY.sh &
|
||||
|
||||
如果你使用的是 Firefox Web 浏览器，则只需单击几下，即可在 Awesome Bar（Mozilla 给 URL 栏起的名称）中将 YaCy 设置为默认搜索引擎。
|
||||
|
||||
首先，如果尚未显示，在 Firefox 工具栏中使专用搜索栏显示出来（你不必使搜索栏保持一直可见；只需要激活它足够长的时间即可添加自定义搜索引擎）。Firefox 右上角的“汉堡”菜单中的“自定义”菜单中提供了搜索栏。在 Firefox 工具栏上的搜索栏可见后，导航至 `localhost:8090`，然后单击刚添加的 Firefox 搜索栏中的放大镜图标。单击选项将 YaCy 添加到你的 Firefox 搜索引擎。
|
||||
首先，如果尚未显示，在 Firefox 工具栏中使专用搜索栏显示出来（你不必使搜索栏保持一直可见；只需要激活它足够长的时间即可添加自定义搜索引擎）。Firefox 右上角的“汉堡”菜单中的“自定义”菜单中提供了搜索栏。在 Firefox 工具栏上的搜索栏可见后，导航至 `localhost:8090`，然后单击刚添加的 Firefox 搜索栏中的放大镜图标。单击选项将 YaCy 添加到你的 Firefox 的搜索引擎中。
|
||||
|
||||
![Adding YaCy to Firefox][7]
|
||||
|
||||
完成此操作后，你可以在 Firefox 首选项中将其标记为默认值，或者仅在 Firefox 搜索栏中执行的搜索中选择性地使用它。如果将其设置为默认搜索引擎，则可能不需要专用的搜索栏，因为 Awesome Bar 也使用默认引擎，因此可以将其从工具栏中删除。
|
||||
完成此操作后，你可以在 Firefox 首选项中将其标记为默认值，或者仅在 Firefox 搜索栏中执行的搜索中选择性地使用它。如果将其设置为默认搜索引擎，则可能不需要专用搜索栏，因为 Awesome Bar 也使用默认引擎，因此可以将其从工具栏中删除。
|
||||
|
||||
### 对等搜索引擎如何工作
|
||||
|
||||
YaCy 是一个开源的分布式搜索引擎。它是用 [Java][8] 编写的，因此可以在任何平台上运行，并且可以执行 Web 爬网、索引和搜索。这是一个对等（P2P）网络，因此每个运行 YaCy 的用户都将努力地不断跟踪互联网的变化情况。当然，没有单个用户能拥有整个互联网的完整索引，因为这将需要一个数据中心来容纳，但是该索引分布在所有 YaCy 用户中且是冗余的。它与 BitTorrent 非常相似（因为它使用分布式哈希表 DHT 来引用索引条目），只不过你所共享的数据是单词和 URL 关联的矩阵。通过混合哈希表返回的结果，没人能告诉谁搜索了哪些单词，因此所有搜索在功能上都是匿名的。这是用于无偏见、无广告、未跟踪和匿名搜索的有效系统，你只需要使用它就加入了它。
|
||||
YaCy 是一个开源的分布式搜索引擎。它是用 [Java][8] 编写的，因此可以在任何平台上运行，并且可以执行 Web 爬网、索引和搜索。这是一个对等（P2P）网络，因此每个运行 YaCy 的用户都将努力地不断跟踪互联网的变化情况。当然，没有单个用户能拥有整个互联网的完整索引，因为这将需要一个数据中心来容纳，但是该索引分布在所有 YaCy 用户中且是冗余的。它与 BitTorrent 非常相似（因为它使用分布式哈希表 DHT 来引用索引条目），只不过你所共享的数据是单词和 URL 关联的矩阵。通过混合哈希表返回的结果，没人能说出谁搜索了哪些单词，因此所有搜索在功能上都是匿名的。这是用于无偏见、无广告、未跟踪和匿名搜索的有效系统，你只需要使用它就加入了它。
|
||||
|
||||
### 搜索引擎和算法
|
||||
|
||||
索引互联网的行为是指将网页分成单个单词，然后将页面的 URL 与每个单词相关联。在搜索引擎中搜索一个或多个单词将获取与该查询关联的所有 URL。YaCy 客户端在运行时也是如此。
|
||||
|
||||
客户端要做的另一件事是为你的浏览器提供搜索界面。你可以将网络浏览器指向 `localhost:8090` 来搜索 YaCy，而不是在要搜索时导航到谷歌。你甚至可以将其添加到浏览器的搜索栏中（取决于浏览器的可扩展性），因此可以从 URL 栏中进行搜索。
|
||||
客户端要做的另一件事是为你的浏览器提供搜索界面。你可以将 Web 浏览器指向 `localhost:8090` 来搜索 YaCy，而不是在要搜索时导航到谷歌。你甚至可以将其添加到浏览器的搜索栏中（取决于浏览器的可扩展性），因此可以从 URL 栏中进行搜索。
|
||||
|
||||
### YaCy 的防火墙设置
|
||||
|
||||
首次开始使用 YaCy 时，它可能运行在“初级”模式下。这意味着你的客户端爬网的站点仅对你可用，因为其他 YaCy 客户端无法访问你的索引条目。要加入对等环境，必须在路由器的防火墙（或者你正在运行的软件防火墙）中打开端口 8090， 这称为“高级”模式。
|
||||
首次开始使用 YaCy 时，它可能运行在“初级”模式下。这意味着你的客户端爬网的站点仅对你可用，因为其他 YaCy 客户端无法访问你的索引条目。要加入对等环境，必须在路由器的防火墙（或者你正在运行的软件防火墙）中打开端口 8090，这称为“高级”模式。
|
||||
|
||||
如果你使用的是 Linux，则可以在《[使用防火墙让你的 Linux 更加强大][9]》中找到有关计算机防火墙的更多信息。 在其他平台上，请参考操作系统的文档。
|
||||
如果你使用的是 Linux，则可以在《[使用防火墙让你的 Linux 更加强大][9]》中找到有关计算机防火墙的更多信息。在其他平台上，请参考操作系统的文档。
|
||||
|
||||
互联网服务提供商（ISP）提供的路由器上几乎总是启用防火墙，并且这里有太多种类的防火墙无法准确说明。大多数路由器都提供了在防火墙中“打洞”的选项，因为许多流行的联网游戏都需要双向流量。
|
||||
互联网服务提供商（ISP）提供的路由器上几乎总是启用了防火墙，并且有太多种类的防火墙无法准确说明。大多数路由器都提供了在防火墙上“打洞”的选项，因为许多流行的联网游戏都需要双向流量。
|
||||
|
||||
如果你知道如何登录路由器（通常为 192.168.0.1 或 10.1.0.1，但可能因制造商的设置而异），则登录并查找配置面板来控制“防火墙”或“端口转发”或“应用”。
|
||||
|
||||
@ -90,7 +90,7 @@ YaCy 是一个开源的分布式搜索引擎。它是用 [Java][8] 编写的，
|
||||
|
||||
### 你的互联网
|
||||
|
||||
使用 YaCy 搜索引擎可以做的不仅仅是被动搜索。你可以强制抓取不太显眼的网站，可以请求对网站进行网络抓取，可以选择使用 YaCy 进行本地搜索，等等。你可以更好地控制*你的*互联网的外观。高级用户越多，索引的网站就越多。索引的网站越多，所有用户的体验就越好。加入吧！
|
||||
使用 YaCy 搜索引擎可以做的不仅仅是被动搜索。你可以强制抓取不太显眼的网站，可以请求对网站进行网络抓取，可以选择使用 YaCy 进行本地搜索等等。你可以更好地控制*你的*互联网的所呈现的一切。高级用户越多，索引的网站就越多。索引的网站越多，所有用户的体验就越好。加入吧！
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
@ -99,7 +99,7 @@ via: https://opensource.com/article/20/2/open-source-search-engine
|
||||
作者：[Seth Kenlon][a]
|
||||
选题：[lujun9972][b]
|
||||
译者：[wxy](https://github.com/wxy)
|
||||
校对：[校对者ID](https://github.com/校对者ID)
|
||||
校对：[wxy](https://github.com/wxy)
|
||||
|
||||
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||
|
||||
@ -0,0 +1,95 @@
|
||||
[#]: collector: (lujun9972)
|
||||
[#]: translator: ( )
|
||||
[#]: reviewer: ( )
|
||||
[#]: publisher: ( )
|
||||
[#]: url: ( )
|
||||
[#]: subject: (Minicomputers and The Soul of a New Machine)
|
||||
[#]: via: (https://opensource.com/article/20/2/minicomputers-and-soul-new-machine)
|
||||
[#]: author: (Matthew Broberg https://opensource.com/users/mbbroberg)
|
||||
|
||||
Minicomputers and The Soul of a New Machine
|
||||
======
|
||||
The new season of Command Line Heroes begins with a story of increases
|
||||
in memory, company politics, and a forgotten technology at the heart of
|
||||
our computing history.
|
||||
![Command Line Heroes season 4 episode 1 covers the rise of minicomputers][1]
|
||||
|
||||
The [Command Line Heroes podcast][2] is back, and this season it covers the machines that run all the programming languages [I covered last season][3]. As the podcast staff puts it:
|
||||
|
||||
"This season, we'll look at what happens when idealistic teams come together to build visionary machines. Machines made with leaps of faith and a lot of hard, often unrecognized, work in basements and stifling cubicles. Machines that brought teams together and changed us as a society in ways we could only dream of."
|
||||
|
||||
This first episode looks at the non-fiction book (and engineering classic), [_The Soul of a New Machine_][4], to look at a critical moment in computing history. It covers the transition from large, hulking mainframes to the intermediate step of the minicomputer, which will eventually lead us to the PC revolution that we're still living in the wake of.
|
||||
|
||||
### The rise of minicomputers
|
||||
|
||||
One of the most important machines on the path to modern machines, most of us have since forgotten: the minicomputer.
|
||||
|
||||
It was a crucial link in the evolution from mainframe to PC (aka microcomputer). It was also extremely important in the development of software that would fuel the PC revolution, chiefly the operating system. The PDP-7 and PDP-11—on which [UNIX was developed][5]—were examples of minicomputers. So was the machine at the heart of _The Soul of the New Machine_.
|
||||
|
||||
This episode takes us back to this important time in computing and explores this forgotten machine—both in terms of its hardware and software.
|
||||
|
||||
From 1963 to 1977, minicomputers were 12 to 16-bit machines from computing giants DEC ([PDP][6]) and rival upstart [Data General][7] ([Nova][8], [Eclipse][9]). But in October 1977, DEC unveiled the VAX 11/780, a 32-bit CPU built from transistor-transistor logic with a five megahertz cycle-time and 2 megabytes of memory. The VAX launched DEC [into second place][10] in the largest computer company in the world.
|
||||
|
||||
The jump from a 12-bit to a 32-bit CPU is a jump from 4,096 bytes to 4,294,967,296 bytes of data. That increase massively increased the potential for software to do complex tasks while drastically shrinking the size of the computer. And with a 32-bit CPU, the VAX was nearly as powerful as an IBM/360 mainframe—but much smaller and much, much less expensive.
|
||||
|
||||
[The episode][11] goes into the drama that unfolds as teams within Data General race to have the most marketable minicomputer while working through company politics and strong personalities.
|
||||
|
||||
### Revisiting _The Soul of a New Machine_
|
||||
|
||||
_The Soul of a New Machine_ was written in 1981 by Tracy Kidder, and chronicles a small group of engineers at the now-former tech company, Data General, as they attempt to compete with a rival internal group and create a 32-bit minicomputer as a skunkworks project known as "Eagle." For those okay with spoilers, the computer would eventually be known as the [Eclipse MV/8000][12].
|
||||
|
||||
Earlier this year, [Jessie Frazelle][13], of Docker, Go, and Kubernetes fame, and [Bryan Cantrill][14], known for [DTrace][15], Joyent, and many other technologies, publicly wrote about reading the non-fiction classic. As it's written, Cantrill mentioned the book to Frazelle, who read it and then wrote an enthusiastic [blog post][16] about the book. As Frazelle put it:
|
||||
|
||||
"Personally, I look back on the golden age of computers as the time when people were building the first personal computers in their garage. There is a certain whimsy of that time fueled with a mix of hard work and passion for building something crazy with a very small team. In today's age, at large companies, most engineers take jobs where they work on one teeny aspect of a machine or website or app. Sometimes they are not even aware of the larger goal or vision but just their own little world.
|
||||
|
||||
In the book, a small team built an entire machine… The team wasn't driven by power or greed, but by accomplishment and self-fulfillment. They put a part of themselves in the machine, therefore, producing a machine with a soul…The team was made up of programmers with the utmost expertise and experience and also with new programmers."
|
||||
|
||||
Inspired by Frazelle's reaction, Cantrill re-read it and wrote [a blog article][17] about it and writes this beautiful note:
|
||||
|
||||
"…_The Soul of a New Machine_ serves to remind us that the soul of what we build is, above all, shared — that we do not endeavor alone but rather with a group of like-minded individuals."
|
||||
|
||||
Frazelle's and Cantrill's reading of the book and blog [sparked a wave of people][18] exploring and talking about this text. While it remains on my book list, this dialogue-by-book-review is at the heart of the CLH season 4 as it explores the entire machine.
|
||||
|
||||
### Why did the minicomputer go the way of the Neanderthal?
|
||||
|
||||
As we all know, minicomputers are not a popular purchase in today's technology market. Minicomputers ended up being great technology for timesharing. The irony is that they unwittingly sealed their own fate. The Internet, which started off as ARPANET, was basically a new kind of timesharing. They were so good at timesharing that at one point, the DEC PDP 11 accounted for over 30% of the nodes on ARPANET. Minicomputers were powering their own demise.*
|
||||
|
||||
Minicomputers paved the way for smaller computers and for more and more people to have access to these powerful, society-changing machines. But I'm getting ahead of myself. Keep listening to the [new season of Command Line Heroes][2] to continue the story of machines in computing history.
|
||||
|
||||
* * *
|
||||
|
||||
What's your minicomputer story? I'd love to read them in the comments.
|
||||
|
||||
(There were, of course, other factors leading to the end of this era. Minicomputers were fighting at the low end of the market with the rise of microcomputers, while Unix systems continued to push into the midrange market. The rise of the Internet was perhaps its final blow.)
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://opensource.com/article/20/2/minicomputers-and-soul-new-machine
|
||||
|
||||
作者：[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/sites/default/files/styles/image-full-size/public/lead-images/command-line-heroes-minicomputers-s4-e1.png?itok=FRaff5i6 (Command Line Heroes season 4 episode 1 covers the rise of minicomputers)
|
||||
[2]: https://www.redhat.com/en/command-line-heroes
|
||||
[3]: https://opensource.com/article/19/6/command-line-heroes-python
|
||||
[4]: https://en.wikipedia.org/wiki/The_Soul_of_a_New_Machine
|
||||
[5]: https://opensource.com/19/9/command-line-heroes-bash
|
||||
[6]: https://en.wikipedia.org/wiki/PDP
|
||||
[7]: https://en.wikipedia.org/wiki/Data_General
|
||||
[8]: https://en.wikipedia.org/wiki/Data_General_Nova
|
||||
[9]: https://en.wikipedia.org/wiki/Data_General_Eclipse
|
||||
[10]: http://www.old-computers.com/history/detail.asp?n=20&t=3
|
||||
[11]: https://www.redhat.com/en/command-line-heroes/season-4/minicomputers
|
||||
[12]: https://en.wikipedia.org/wiki/Data_General_Eclipse_MV/8000
|
||||
[13]: https://twitter.com/jessfraz?lang=en
|
||||
[14]: https://en.wikipedia.org/wiki/Bryan_Cantrill
|
||||
[15]: https://en.wikipedia.org/wiki/DTrace
|
||||
[16]: https://blog.jessfraz.com/post/new-golden-age-of-building-with-soul/
|
||||
[17]: http://dtrace.org/blogs/bmc/2019/02/10/reflecting-on-the-soul-of-a-new-machine/
|
||||
[18]: https://twitter.com/search?q=jessfraz%20soul%20new%20machine&src=typed_query&f=live
|
||||
@ -0,0 +1,99 @@
|
||||
[#]: collector: (lujun9972)
|
||||
[#]: translator: ( )
|
||||
[#]: reviewer: ( )
|
||||
[#]: publisher: ( )
|
||||
[#]: url: ( )
|
||||
[#]: subject: (Building a community of practice in 5 steps)
|
||||
[#]: via: (https://opensource.com/article/20/2/building-community-practice-5-steps)
|
||||
[#]: author: (Tracy Buckner https://opensource.com/users/tracyb)
|
||||
|
||||
Building a community of practice in 5 steps
|
||||
======
|
||||
A community of practice can kickstart innovation in your organization.
|
||||
Here's how to build one—and ensure it thrives.
|
||||
![Blocks for building][1]
|
||||
|
||||
In the [first part of this series][2], we defined community as a fundamental principle in open organizations, where people often define their roles, responsibilities, and affiliations through shared interests and passions, [not title, role, or position on an organizational chart][3]. Then, in the [second part of the series][4], we explored the many benefits communities of practice bring to open organizations—including fostering learning, encouraging collaboration, and offering an opportunity for creative problem-solving and innovation.
|
||||
|
||||
Now you know you'd like to _start_ a community of practice, but you may still be unsure _where_ to start. This article will help define your roadmap and build a plan for a successful community of practice—in five simple steps (summarized in Figure 1).
|
||||
|
||||
![][5]
|
||||
|
||||
### Step 1: Obtain executive sponsorship
|
||||
|
||||
While having a community manager focused on the day-to-day execution of community matters is important, an executive sponsor is also integral to the success of the community of practice. Typically, an executive sponsor will shoulder higher-level responsibilities, such as focusing on strategy and creating conditions for success (rather than implementation).
|
||||
|
||||
An executive sponsor can help ensure the community's goals are aligned with the overall strategy of the organization. This person can also communicate those goals and gather support for the community from other senior executives (potentially instrumental in securing financial support and resources for the community!).
|
||||
|
||||
Finding the right sponsor is important for the success of the program. An executive leader committed to fostering open culture, transparency, and collaboration will be very successful. Alternatively, you may wish to tap an executive focused on finding new ways to grow and reskill high-potential employees.
|
||||
|
||||
### Step 2: Determine mission and goals
|
||||
|
||||
Once you've established a vision for the community, you'll need to develop its mission statement. This is critical to your success because the mission begins explaining _how you'll achieve that vision_. Primarily, your community's mission should be to share knowledge, promote learning in a particular area, and align that work with organizational strategy. However, the mission statement may also include references to the audience that the community will serve.
|
||||
|
||||
Here's one example mission statement:
|
||||
|
||||
> _To identify and address needs within the cloud infrastructure space in support of the organization’s mission of defining the next generation of open hybrid cloud._
|
||||
|
||||
After articulating a mission like this, you'll need to set specific goals for achieving it. The goals can be long- or short-term, but in either case, you'll need to provide a clear roadmap explaining to community members what the community is trying to achieve.
|
||||
|
||||
### Step 3: Build a core team
|
||||
|
||||
Building a core team is essential to the success of a community. In a typical community of practice—or "CoP," for short—you'll notice four main roles:
|
||||
|
||||
* CoP program manager
|
||||
* CoP manager
|
||||
* Core team members
|
||||
* Members
|
||||
|
||||
|
||||
|
||||
The **CoP program manager** is the face of the community. This person is primarily responsible for supporting the managers and core teams by resolving questions, issues, and concerns. The program manager also guides new communities and evangelizes the communities of practice program inside the organization.
|
||||
|
||||
The **CoP manager** determines community strategy based on business and community needs. This person makes the latest news, content, and events available to community members and ensures that the CoP remains focused on its goals. This person also schedules regular meetings for members and shares other events that may be of interest to them.
|
||||
|
||||
The **CoP core team** is responsible for managing community collateral and best practices to meet the community's goals. The core team supports CoP manager(s) and assists with preparing and leading community meetings.
|
||||
|
||||
**Members** of a community attend meetings, share relevant content and best practices, and support the core team and manager(s) in reaching community goals.
|
||||
|
||||
### Step 4: Promote knowledge management
|
||||
|
||||
Communities of practice produce information—and members must be able to easily access and share that information. So it's important to develop a knowledge-management system for storing that information in a way that keeps it relevant and timely.
|
||||
|
||||
Communities of practice produce information—and members must be able to easily access and share that information. So it's important to develop a knowledge-management system for storing that information in a way that keeps it relevant and timely.
|
||||
|
||||
Over time, your community of practice will likely generate a lot of content. Some of that content may be duplicated, outdated or simply no longer relevant to the community. So it's important to periodically conduct a ROT Analysis of the content validating that the content is not **R**edundant, **O**utdated, or **T**rivial. Consider conducting a ROT analysis every six months or so, in order to keep the content fresh and relevant.
|
||||
|
||||
A number of different content management tools can assist with maintaining and displaying the content for community members. Some organizations use an intranet, while others prefer more robust content management such as [AO Docs][6] or [Drupal][7].
|
||||
|
||||
### Step 5: Engage in regular communication
|
||||
|
||||
The secret to success in maintaining a community of practice is regular communication and collaboration. Communities that speak with each other frequently and share knowledge, ideas, and best practices are most likely to remain intact. CoP managers should schedule regular meetings, meet-ups, and content creation sessions to ensure that members are engaged in the community. It is recommended to have at least a monthly meeting to maintain communication with the community members.
|
||||
|
||||
Chat/messaging apps are also a great tool for facilitating regular communication in communities of practice. These apps offer teams across the globe the ability to communicate in real-time, removing some collaboration boundaries. Members can pose questions and receive answers immediately, without the delay of sending and receiving emails. And should the questions arise again, most messaging apps also provide an easy search mechanism that can help members discover answers.
|
||||
|
||||
### Building your community
|
||||
|
||||
Remember: A community of practice is a cost-effective way to foster learning, encourage collaboration, and promote innovation in an organization. In [_The Open Organization_][8], Jim Whitehurst argues that "the beauty of an open organization is that it is not about pedaling harder, but about tapping into new sources of power both inside and outside to keep pace with all the fast-moving changes in your environment." Building communities of practice are the perfect way to do just that: stop pedaling harder and to tap into new sources of power within your organization.
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://opensource.com/article/20/2/building-community-practice-5-steps
|
||||
|
||||
作者：[Tracy Buckner][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/tracyb
|
||||
[b]: https://github.com/lujun9972
|
||||
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/blocks_building.png?itok=eMOT-ire (Blocks for building)
|
||||
[2]: https://opensource.com/open-organization/19/11/what-is-community-practice
|
||||
[3]: https://opensource.com/open-organization/resources/open-org-definition
|
||||
[4]: https://opensource.com/open-organization/20/1/why-build-community-of-practice
|
||||
[5]: https://opensource.com/sites/default/files/resize/images/open-org/comm_practice_5_steps-700x440.png
|
||||
[6]: https://www.aodocs.com/
|
||||
[7]: https://www.drupal.org/
|
||||
[8]: https://opensource.com/open-organization/resources/what-open-organization
|
||||
@ -0,0 +1,69 @@
|
||||
[#]: collector: (lujun9972)
|
||||
[#]: translator: ( )
|
||||
[#]: reviewer: ( )
|
||||
[#]: publisher: ( )
|
||||
[#]: url: ( )
|
||||
[#]: subject: (Automating unit tests in test-driven development)
|
||||
[#]: via: (https://opensource.com/article/20/2/automate-unit-tests)
|
||||
[#]: author: (Alex Bunardzic https://opensource.com/users/alex-bunardzic)
|
||||
|
||||
Automating unit tests in test-driven development
|
||||
======
|
||||
What unit tests have in common with carpentry.
|
||||
![gears and lightbulb to represent innovation][1]
|
||||
|
||||
DevOps is a software engineering discipline focused on minimizing the lead time to achieve a desired business impact. While business stakeholders and sponsors have ideas on how to optimize business operations, those ideas need to be validated in the field. This means business automation (i.e., software products) must be placed in front of end users and paying customers. Only then will the business confirm whether the initial idea for improvement was fruitful or not.
|
||||
|
||||
Software engineering is a budding discipline, and it can get difficult to ship products that are defect-free. For that reason, DevOps resorts to maximizing automation. Any repeatable chore, such as testing implemented changes to the source code, should be automated by DevOps engineers.
|
||||
|
||||
This article looks at how to automate unit tests. These tests are focused on what I like to call "programming in the small." Much more important test automation (the so-called "programming in the large") must use a different discipline—integration testing. But that's a topic for another article.
|
||||
|
||||
### What is a unit?
|
||||
|
||||
When I'm teaching approaches to unit testing, often, my students cannot clearly determine what a testable unit is. Which is to say, the granularity of the processing is not always clear.
|
||||
|
||||
I like to point out that the easiest way to spot a valid unit is to think of it as a _unit of behavior_. For example (albeit a trivial one), when an authenticated customer begins online shopping, the unit of behavior is a cart that has zero items in it. Once we all agree that an empty shopping cart has zero items in it, we can focus on automating the unit test that will ensure that such a shopping cart always returns zero items.
|
||||
|
||||
### What is not a unit?
|
||||
|
||||
Any processing that involves more than a single behavior should not be viewed as a unit. For example, if shopping cart processing results in tallying up the number of items in the cart AND calculating the order total AND calculating sales tax AND calculating the suggested shipping method, that behavior is not a good candidate for unit testing. Such behavior is a good candidate for integration testing.
|
||||
|
||||
### When to write a unit test
|
||||
|
||||
There is a lot of debate about when to write a unit test. Received wisdom states that once the code has been written, it is a good idea to write automated scripts that will assert whether the implemented unit of behavior delivers functionality as expected. Not only does such a unit test (or a few unit tests) document the expected behavior, the collection of all unit tests ensures that future changes will not degrade quality. If a future change adversely affects the already implemented behavior, one or more unit tests will complain, which will alert developers that regression has occurred.
|
||||
|
||||
There is another way to look at software engineering. It is based on the traditional adage "measure twice, cut once." In that light, writing code before writing tests would be equivalent to cutting a part of some product (say, a chair leg) and measuring it only after it's cut. If the craftsperson doing the cutting is very skilled, that approach may work (kind of). But more likely than not, the chair legs cut this way would end up with unequal lengths. So, it is advisable to measure before cutting. What that means for the practice of software engineering is that the measurements are expressed in the unit tests. Once we measure the required values, we create a blueprint (a unit test). That blueprint is then used to guide the cutting of the code.
|
||||
|
||||
Common sense would suggest that it is more reasonable to measure first and, only then, do the cutting. According to that line of reasoning, writing unit tests before writing code is a recommended way to do proper software engineering. Technically speaking, this "measure twice, cut once" approach is called a "test-first" approach. The opposite approach, where we write the code first, is called "test-later." The test-first approach is the approach advocated by [test-driven development][2] (TDD) methodology. Writing tests later is called test-later development (TLD).
|
||||
|
||||
### Why is TLD harmful?
|
||||
|
||||
Cutting before measuring is not recommended. Even the most talented craftspeople will eventually make mistakes by cutting without doing so. A lack of measurement will eventually catch up with even the most experienced of us as we continue in our craft. So it's best to produce a blueprint (i.e., measurements) before cutting.
|
||||
|
||||
But that's not the only reason why the TLD approach is considered harmful. When we write code, we're simultaneously considering two separate concerns: the expected behavior of the code and the optimal structure of the code. These two concerns are very dissimilar. That fact makes it very challenging to do a proper job satisfying the expectations regarding both the desired behavior and the optimal (or at the very least, decent) code structure.
|
||||
|
||||
The TDD approach solves this conundrum by focusing undivided attention first on the expected desired behavior. We start by writing the unit test. In that test, we focus on _what_ we expect to happen. At this point, we don't care, in the least, _how_ the expected behavior is going to materialize.
|
||||
|
||||
Once we're done describing the _what_ (i.e., what manifest behavior are we expecting from the unit we are about to build?), we watch that expectation fail. It fails because the code that is concerned with _how_ the expected behavior is going to happen hasn't materialized yet. Now we are compelled to write the code that's going to take care of the _how_.
|
||||
|
||||
After we write the code responsible for how, we run the unit test(s) and see if the code we just wrote fulfills the expected behavior. If it does, we're done. Time to move on to fulfilling the next expectation. If it doesn't, we continue transforming the code until it succeeds in passing the test.
|
||||
|
||||
If we choose not to do TDD, but write code first and later write the unit test, we miss the opportunity to separate _what_ from _how_. In other words, we write the code while simultaneously taking care of what we expect the code to do _and_ how to structure the code to do it correctly.
|
||||
|
||||
As such, writing unit tests after we write code is considered harmful.
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://opensource.com/article/20/2/automate-unit-tests
|
||||
|
||||
作者：[Alex Bunardzic][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/alex-bunardzic
|
||||
[b]: https://github.com/lujun9972
|
||||
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/innovation_lightbulb_gears_devops_ansible.png?itok=TSbmp3_M (gears and lightbulb to represent innovation)
|
||||
[2]: https://opensource.com/article/20/1/test-driven-development
|
||||
@ -0,0 +1,133 @@
|
||||
[#]: collector: (lujun9972)
|
||||
[#]: translator: ( )
|
||||
[#]: reviewer: ( )
|
||||
[#]: publisher: ( )
|
||||
[#]: url: ( )
|
||||
[#]: subject: (Create web user interfaces with Qt WebAssembly instead of JavaScript)
|
||||
[#]: via: (https://opensource.com/article/20/2/wasm-python-webassembly)
|
||||
[#]: author: (Stephan Avenwedde https://opensource.com/users/hansic99)
|
||||
|
||||
Create web user interfaces with Qt WebAssembly instead of JavaScript
|
||||
======
|
||||
Get hands-on with Wasm, PyQt, and Qt WebAssembly.
|
||||
![Digital creative of a browser on the internet][1]
|
||||
|
||||
When I first heard about [WebAssembly][2] and the possibility of creating web user interfaces with Qt, just like I would in ordinary C++, I decided to take a deeper look at the technology.
|
||||
|
||||
My open source project [Pythonic][3] is completely Python-based (PyQt), and I use C++ at work; therefore, this minimal, straightforward WebAssembly tutorial uses Python on the backend and C++ Qt WebAssembly for the frontend. It is aimed at programmers who, like me, are not familiar with web development.
|
||||
|
||||
![Header Qt C++ frontend][4]
|
||||
|
||||
### TL;DR
|
||||
|
||||
|
||||
```
|
||||
git clone <https://github.com/hANSIc99/wasm\_qt\_example>
|
||||
|
||||
cd wasm_qt_example
|
||||
|
||||
python mysite.py
|
||||
```
|
||||
|
||||
Then visit <http://127.0.0.1:7000> with your favorite browser.
|
||||
|
||||
### What is WebAssembly?
|
||||
|
||||
WebAssembly (often shortened to Wasm) is designed primarily to execute portable binary code in web applications to achieve high-execution performance. It is intended to coexist with JavaScript, and both frameworks are executed in the same sandbox. [Recent performance benchmarks][5] showed that WebAssembly executes roughly 10–40% faster, depending on the browser, and given its novelty, we can still expect improvements. The downside of this great execution performance is its widespread adoption as the preferred malware language. Crypto miners especially benefit from its performance and harder detection of evidence due to its binary format.
|
||||
|
||||
### Toolchain
|
||||
|
||||
There is a [getting started guide][6] on the Qt wiki. I recommend sticking exactly to the steps and versions mentioned in this guide. You may need to select your Qt version carefully, as different versions have different features (such as multi-threading), with improvements happening with each release.
|
||||
|
||||
To get executable WebAssembly code, simply pass your Qt C++ application through [Emscripten][7]. Emscripten provides the complete toolchain, and the build script couldn't be simpler:
|
||||
|
||||
|
||||
```
|
||||
#!/bin/sh
|
||||
source ~/emsdk/emsdk_env.sh
|
||||
~/Qt/5.13.1/wasm_32/bin/qmake
|
||||
make
|
||||
```
|
||||
|
||||
Building takes roughly 10 times longer than with a standard C++ compiler like Clang or g++. The build script will output the following files:
|
||||
|
||||
* WASM_Client.js
|
||||
* WASM_Client.wasm
|
||||
* qtlogo.svg
|
||||
* qtloader.js
|
||||
* WASM_Client.html
|
||||
* Makefile (intermediate)
|
||||
|
||||
|
||||
|
||||
The versions on my (Fedora 30) build system are:
|
||||
|
||||
* emsdk: 1.38.27
|
||||
* Qt: 5.13.1
|
||||
|
||||
|
||||
|
||||
### Frontend
|
||||
|
||||
The frontend provides some functionalities based on [WebSocket][8].
|
||||
|
||||
![Qt-made frontend in browser][9]
|
||||
|
||||
* **Send message to server:** Send a simple string message to the server with a WebSocket. You could have done this also with a simple HTTP POST request.
|
||||
* **Start/stop timer:** Create a WebSocket and start a timer on the server to send messages to the client at a regular interval.
|
||||
* **Upload file:** Upload a file to the server, where the file is saved to the home directory (**~/**) of the user who runs the server.
|
||||
|
||||
|
||||
|
||||
If you adapt the code and face a compiling error like this:
|
||||
|
||||
|
||||
```
|
||||
error: static_assert failed due to
|
||||
requirement ‘bool(-1 == 1)’ “Required feature http for file
|
||||
../../Qt/5.13.1/wasm_32/include/QtNetwork/qhttpmultipart.h not available.”
|
||||
QT_REQUIRE_CONFIG(http);
|
||||
```
|
||||
|
||||
it means that the requested feature is not available for Qt Wasm.
|
||||
|
||||
### Backend
|
||||
|
||||
The server work is done by [Eventlet][10]. I chose Eventlet because it is lightweight and easy to use. Eventlet provides WebSocket functionality and supports threading.
|
||||
|
||||
![Decorated functions for WebSocket handling][11]
|
||||
|
||||
Inside the repository under **mysite/template**, there is a symbolic link to **WASM_Client.html** in the root path. The static content under **mysite/static** is also linked to the root path of the repository. If you adapt the code and do a recompile, you just have to restart Eventlet to update the content to the client.
|
||||
|
||||
Eventlet uses the Web Server Gateway Interface for Python (WSGI). The functions that provide the specific functionality are extended with decorators.
|
||||
|
||||
Please note that this is an absolute minimum server implementation. It doesn't implement any multi-user capabilities — every client is able to start/stop the timer, even for other clients.
|
||||
|
||||
### Conclusion
|
||||
|
||||
Take this example code as a starting point to get familiar with WebAssembly without wasting time on minor issues. I don't make any claims for completeness nor best-practice integration. I walked through a long learning curve until I got it running to my satisfaction, and I hope this gives you a brief look into this promising technology.
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://opensource.com/article/20/2/wasm-python-webassembly
|
||||
|
||||
作者：[Stephan Avenwedde][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/hansic99
|
||||
[b]: https://github.com/lujun9972
|
||||
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/browser_web_internet_website.png?itok=g5B_Bw62 (Digital creative of a browser on the internet)
|
||||
[2]: https://webassembly.org/
|
||||
[3]: https://github.com/hANSIc99/Pythonic
|
||||
[4]: https://opensource.com/sites/default/files/uploads/cpp_qt.png (Header Qt C++ frontend)
|
||||
[5]: https://pspdfkit.com/blog/2018/a-real-world-webassembly-benchmark/
|
||||
[6]: https://wiki.qt.io/Qt_for_WebAssembly#Getting_Started
|
||||
[7]: https://emscripten.org/docs/introducing_emscripten/index.html
|
||||
[8]: https://en.wikipedia.org/wiki/WebSocket
|
||||
[9]: https://opensource.com/sites/default/files/uploads/wasm_frontend.png (Qt-made frontend in browser)
|
||||
[10]: https://eventlet.net/
|
||||
[11]: https://opensource.com/sites/default/files/uploads/python_backend.png (Decorated functions for WebSocket handling)
|
||||
177
sources/tech/20200217 How to install Vim plugins.md
Normal file
177
sources/tech/20200217 How to install Vim plugins.md
Normal file
@ -0,0 +1,177 @@
|
||||
[#]: collector: (lujun9972)
|
||||
[#]: translator: ( )
|
||||
[#]: reviewer: ( )
|
||||
[#]: publisher: ( )
|
||||
[#]: url: ( )
|
||||
[#]: subject: (How to install Vim plugins)
|
||||
[#]: via: (https://opensource.com/article/20/2/how-install-vim-plugins)
|
||||
[#]: author: (Seth Kenlon https://opensource.com/users/seth)
|
||||
|
||||
How to install Vim plugins
|
||||
======
|
||||
Whether you install them manually or with a package manager, plugins can
|
||||
help you create the perfect Vim for your workflow.
|
||||
![Team checklist and to dos][1]
|
||||
|
||||
While [Vim][2] is fast and efficient, by default, it is but a mere text editor. At least, that's what it would be without plugins, which build upon Vim and add extra features to make it so much more than just a window for typing text. With the right mix of plugins, you can take control of your life and forge your own unique Vim experience. You can [customize your theme][3], and you can add syntax highlighting, code linting, version trackers, and much much more.
|
||||
|
||||
### How to install Vim plugins
|
||||
|
||||
Vim is extensible through plugins, but for a long time, there was no official method for installing them. As of the Vim 8.x series, however, there's a structure around how plugins are intended to be installed and loaded. You may encounter old instructions online or in project README files, but as long as you're running Vim 8 or greater, you should install according to Vim's [official plugin install method][4] or with a Vim package manager. You can use a package manager regardless of what version you run (including releases older than 8.x), which makes the install process easier than maintaining updates yourself.
|
||||
|
||||
Both the manual and automated methods are worth knowing, so keep reading to learn about both.
|
||||
|
||||
### Install plugins manually (Vim 8 and above)
|
||||
|
||||
A Vim package is a directory containing one or more plugins. By default, your Vim settings are contained in **~/.vim**, so that's where Vim looks for plugins when you launch it. (The examples below use the generic name **vendor** to indicate that the plugins are obtained from an entity that is not you.)
|
||||
|
||||
When you start Vim, it first processes your **.vimrc** file, and then it scans all directories in **~/.vim** for plugins contained in **pack/*/start**.
|
||||
|
||||
By default, your **~/.vim** directory (if you even have one) has no such file structure, so set that up with:
|
||||
|
||||
|
||||
```
|
||||
`$ mkdir -p ~/.vim/pack/vendor/start`
|
||||
```
|
||||
|
||||
Now you can place Vim plugins in **~/.vim/pack/vendor/start**, and they'll automatically load when you launch Vim.
|
||||
|
||||
For example, try installing [NERDTree][5], a text-based file manager for Vim. First, use Git to clone a snapshot of the NERDTree repository:
|
||||
|
||||
|
||||
```
|
||||
$ git clone --depth 1 \
|
||||
<https://github.com/preservim/nerdtree.git> \
|
||||
~/.vim/pack/vendor/start/nerdtree
|
||||
```
|
||||
|
||||
Launch Vim or gvim, and type this command:
|
||||
|
||||
|
||||
```
|
||||
`:NERDTree`
|
||||
```
|
||||
|
||||
A file tree will open along the left side of your Vim window.
|
||||
|
||||
![NERDTree plugin][6]
|
||||
|
||||
If you don't want a plugin to load automatically every time you launch Vim, you can create an **opt** directory within your **~/.vim/pack/vendor** directory:
|
||||
|
||||
|
||||
```
|
||||
`$ mkdir ~/.vim/pack/vendor/opt`
|
||||
```
|
||||
|
||||
Any plugins installed into **opt** are available to Vim but not loaded into memory until you add them to a session with the **packadd** command, e.g., for an imaginary plugin called foo:
|
||||
|
||||
|
||||
```
|
||||
`:packadd foo`
|
||||
```
|
||||
|
||||
Officially, Vim recommends that each plugin project gets its own directory within **~/.vim/pack**. For example, if you were to install the NERDTree plugin and the imaginary foo plugin, you would create this structure:
|
||||
|
||||
|
||||
```
|
||||
$ mkdir -p ~/.vim/pack/NERDTree/start/
|
||||
$ git clone --depth 1 \
|
||||
<https://github.com/preservim/nerdtree.git> \
|
||||
~/.vim/pack/NERDTree/start/NERDTree
|
||||
$ mkdir -p ~/.vim/pack/foo/start/
|
||||
$ git clone --depth 1 \
|
||||
<https://notabug.org/foo/foo.git> \
|
||||
~/.vim/pack/foo/start/foo
|
||||
```
|
||||
|
||||
Whether that's convenient is up to you.
|
||||
|
||||
### Using a Vim package manager (any Vim version)
|
||||
|
||||
Since Vim series 8, package managers have become less useful, but some users still prefer them because of their ability to auto-update several plugins. There are several package managers to choose from, and they're each different, but [vim-plug][7] has some great features and the best documentation of them all, which makes it easy to start with and to explore in depth later.
|
||||
|
||||
#### Installing plugins with vim-plug
|
||||
|
||||
Install vim-plug so that it auto-loads at launch with:
|
||||
|
||||
|
||||
```
|
||||
$ curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
|
||||
<https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim>
|
||||
```
|
||||
|
||||
Create a **~/.vimrc** file (if you don't have one already), and enter this text:
|
||||
|
||||
|
||||
```
|
||||
call plug#begin()
|
||||
Plug 'preservim/NERDTree'
|
||||
call plug#end()
|
||||
```
|
||||
|
||||
Each time you want to install a plugin, you must enter the name and location of the plugin between the **plug#begin()** and **plug#end** lines. (The NERDTree file manager is used above as an example.) If the plugin you want isn't hosted on GitHub, then you can provide the full URL instead of just the GitHub username and project ID. You can even "install" local plugins outside of your **~/.vim** directory.
|
||||
|
||||
Finally, start Vim and prompt vim-plug to install the plugins listed in **~/.vimrc**:
|
||||
|
||||
|
||||
```
|
||||
`:PlugInstall`
|
||||
```
|
||||
|
||||
Wait for the plugins to be downloaded.
|
||||
|
||||
#### Update plugins with vim-plug
|
||||
|
||||
Editing **~/.vimrc** and issuing a command to do the installation probably doesn't seem like much of a savings over the manual install process, but the real benefit to vim-plug is in updates. To update all installed plugins, issue this Vim command:
|
||||
|
||||
|
||||
```
|
||||
`:PlugUpdate`
|
||||
```
|
||||
|
||||
If you don't want to update all plugins, you can update any subset by adding the plugin's name:
|
||||
|
||||
|
||||
```
|
||||
`:PlugUpdate NERDTree`
|
||||
```
|
||||
|
||||
#### Restore plugins
|
||||
|
||||
Another vim-plug benefit is its export and recovery function. As any Vim user knows, the way Vim works is often unique to each user—in part because of plugins. Once you get the right blend of plugins installed and configured, the last thing you want is to lose track of them.
|
||||
|
||||
Vim-plug has this command to generate a script for restoring all current plugins:
|
||||
|
||||
|
||||
```
|
||||
`:PlugSnapshot ~/vim-plug.list`
|
||||
```
|
||||
|
||||
There are many other functions for vim-plug, so refer to its [project page][7] for the full documentation.
|
||||
|
||||
### Create the perfect Vim
|
||||
|
||||
When you spend all day in a program, you want every little detail to serve you the best it possibly can. Get to know Vim and its many plugins until you build the perfect application for what you do.
|
||||
|
||||
Got a favorite Vim plugin? Tell us all about it in the comments!
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
via: https://opensource.com/article/20/2/how-install-vim-plugins
|
||||
|
||||
作者：[Seth Kenlon][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/todo_checklist_team_metrics_report.png?itok=oB5uQbzf (Team checklist and to dos)
|
||||
[2]: https://www.vim.org/
|
||||
[3]: https://opensource.com/article/19/12/colors-themes-vim
|
||||
[4]: https://github.com/vim/vim/blob/03c3bd9fd094c1aede2e8fe3ad8fd25b9f033053/runtime/doc/repeat.txt#L515
|
||||
[5]: https://github.com/preservim/nerdtree
|
||||
[6]: https://opensource.com/sites/default/files/uploads/vim-nerdtree.jpg (NERDTree plugin)
|
||||
[7]: https://github.com/junegunn/vim-plug
|
||||
Loading…
Reference in New Issue
Block a user