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

Merge remote-tracking branch 'LCTT/master'

Browse Source
This commit is contained in:
Xingyu Wang 2020-01-07 22:26:46 +08:00
commit 6a4b89bc7f
7 changed files with 781 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
published/20200101 5 predictions for Kubernetes in 2020.md Normal file
View File

@ -0,0 +1,84 @@
[#]: collector: (lujun9972)
[#]: translator: (lxbwolf)
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-11758-1.html)
[#]: subject: (5 predictions for Kubernetes in 2020)
[#]: via: (https://opensource.com/article/20/1/kubernetes-2020)
[#]: author: (Scott McCarty https://opensource.com/users/fatherlinux)
2020 年对 Kubernetes 的 5 个预测
======
> 以及，对 2019 年最受欢迎的 Kubernetes 文章的回顾。
![](https://img.linux.net.cn/data/attachment/album/202001/07/094358qucr5o2lu2lo23od.jpg)
你是怎么追踪一个广受欢迎的项目（如 Kubernetes）的发展轨迹？你是怎么了解它发展到什么程度了？如果你在为这个项目作贡献或加入了特殊兴趣组（SIG），可能你会在潜移默化中了解到它的发展轨迹，但如果你的全日工作不涉及到为 Kubernetes 作贡献，那么你可能需要一点关于未来的预测来帮助你了解。对于一个诸如 Kubernetes 的快速发展的项目，年末是回顾过去的一年和展望新的一年的最好时机。
今年，Kubernetes 取得了很大的进展。除了去查看源码、文档、会议笔记，你也可以去浏览博客。为了深入了解，我在 Opensource.com 上找到了 Kubernetes 排名前十的文章。通过这些文章，我们能了解开发者们更喜欢读和写哪些话题的文章。我们开始吧！
- [为什么数据科学家喜欢Kubernetes][13]
- [Kubernetes 机密信息和 ConfigMap 简介][14]
- [怎样在 Kubernetes 上运行 PostgreSQL][15]（译文）
- [为什么说 Kubernetes 是一辆翻斗车][16]（译文）
- [安全扫描你的 DevOps 流程][17]
- [在 Kubernetes 上部署 InfluxDB 和 Grafana 以收集 Twitter 统计信息][18]
- [使用 Kubernetes 操作器扩展 PostgreSQL][19]
- [使用 Kubernetes 控制器减少系统管理员的工作量][20]
- [将 Kubernetes 带到裸金属边缘计算][21]
- [为什么你不必担心 Kubernetes][22]
首先，我要指明这些文章中有 5 篇是关于 Kubernetes 工作负载的扩展以及它们可以运行在什么场景。这些工作负载涵盖数据科学、PostgreSQL、InfluxDB、Grafana（不仅仅监控集群本身）和边缘计算。从历史角度看，Kubernetes 和容器都是在虚拟机上运行的，尤其是运行在由云提供的基础设施上时。抛开对于 Kubernetes 的兴趣因素，这也表明了终端用户们极度希望在裸机上安装 Kubernetes（参照 [用 OpenShift 在裸机环境运行 Kubernetes][2]）。
其次，也有很多开发者希望了解操作相关的知识以及 Kubernetes 的最佳实践。从 [Kubernetes 操作器][3] 到 [Kubernetes 控制器][4]，从 [机密信息][5] 到 [ConfigMaps][6]，开发者和运维人员都希望能找到简化部署和管理工作的最佳实践。我们经常纠结在怎么去修改配置文件或别人会怎么配置，而不去回头想想这些配置是怎么让应用部署运转的（不是怎么安装，也不是怎么运行 Kubernetes）。
最后，人们似乎对入门教程真的感兴趣。事实上，构建 Kubernetes 所需了解的信息太多了，以至于让人们望而却步，也使他们走了错误的路。流行度高的文章中有几篇讲述了为什么你需要了解用 Kubernetes 运行应用程序，而不仅仅是安装它。就像最佳实践类的文章一样，人们也通常不会回头分析在入门时他们应该在什么地方花费时间。我一直秉持的理念是，把有限的时间和金钱投入到如何使用某项技术上，而不是如何构建它。
### 2020 年对 Kubernetes 的 5 个预测
回顾了 2019 年的相关主题，这些主题告诉我们 2020 年将如何发展？结合这些文章中的观点，加上我自己的看法，我来分享下我对于 2020 年以及未来发展趋势的想法：
1. 工作负载扩展。我会关注高性能计算、AI/ML 以及使用操作器的有状态工作负载。
2. 更多的生产中的最佳实践，尤其是跟一些成熟的标准相关的，像 PCI、HIPAA、NIST 等等。
3. 提升免 root 和更安全的[运行时类][7]（如 [gVisor][8]、[Kata Containers][9] 等等）的安全性。
4. 在部署和开发者们共享应用时，把 Kubernetes 清单的更好的规范标准作为部署的核心要素。如 [podman 生成 kube][10]、[podman 运行 kube][11]，还有多合一 Kubernetes 环境，如 [CodeReady Containers (CRC)][12]
5. 一个前所未有的网络、存储和专业硬件（如 GPU 等等）供应商的生态系统，为 Kubernetes 提供 BoB（LCTT 译注：best of breed，单项最佳品牌）解决方案（在自由软件中，我们相信开放的生态系统好过垂直整合的解决方案）。
期待 Kubernetes 在新的一年里再创辉煌！
--------------------------------------------------------------------------------
via: https://opensource.com/article/20/1/kubernetes-2020
作者：[Scott McCarty][a]
选题：[lujun9972][b]
译者：[lxbwolf](https://github.com/lxbwolf)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/fatherlinux
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/coffee_tea_laptop_computer_work_desk.png?itok=D5yMx_Dr (Person drinking a hat drink at the computer)
[2]: https://blog.openshift.com/kubernetes-on-metal-with-openshift/
[3]: https://kubernetes.io/docs/concepts/extend-kubernetes/operator/
[4]: https://kubernetes.io/docs/concepts/architecture/controller/
[5]: https://kubernetes.io/docs/concepts/configuration/secret/
[6]: https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/
[7]: https://kubernetes.io/docs/concepts/containers/runtime-class/
[8]: https://gvisor.dev/
[9]: https://katacontainers.io/
[10]: https://developers.redhat.com/blog/2019/01/29/podman-kubernetes-yaml/
[11]: https://www.redhat.com/en/blog/rhel-81-minor-release-major-new-container-capabilities
[12]: https://developers.redhat.com/products/codeready-containers/overview
[13]: https://opensource.com/article/19/1/why-data-scientists-love-kubernetes
[14]: https://opensource.com/article/19/6/introduction-kubernetes-secrets-and-configmaps
[15]: https://linux.cn/article-10762-1.html
[16]: https://linux.cn/article-11011-1.html
[17]: https://opensource.com/article/19/7/security-scanning-your-devops-pipeline
[18]: https://opensource.com/article/19/2/deploy-influxdb-grafana-kubernetes
[19]: https://opensource.com/article/19/2/scaling-postgresql-kubernetes-operators
[20]: https://opensource.com/article/19/3/reducing-sysadmin-toil-kubernetes-controllers
[21]: https://opensource.com/article/19/3/bringing-kubernetes-bare-metal-edge
[22]: https://opensource.com/article/19/10/kubernetes-complex-business-problem

236
sources/talk/20200105 Friend of a Friend- The Facebook That Could Have Been.md Normal file
View File

@ -0,0 +1,236 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Friend of a Friend: The Facebook That Could Have Been)
[#]: via: (https://twobithistory.org/2020/01/05/foaf.html)
[#]: author: (Two-Bit History https://twobithistory.org)
Friend of a Friend: The Facebook That Could Have Been
======
> _I express my network in a FOAF file, and that is the start of the revolution._ —Tim Berners-Lee (2007)
The FOAF standard, or Friend of a Friend standard, is a now largely defunct/ignored/superseded[1][1] web standard dating from the early 2000s that hints at what social networking might have looked like had Facebook not conquered the world. Before we talk about FOAF though, I want to talk about the New York City Subway.
The New York City Subway is controlled by a single entity, the Metropolitan Transportation Agency, better known as the MTA. The MTA has a monopoly on subway travel in New York City. There is no legal way to travel in New York City by subway without purchasing a ticket from the MTA. The MTA has no competitors, at least not in the “subway space.”
This wasn’t always true. Surprisingly, the subway system was once run by two corporations that competed with each other. The Inter-borough Rapid Transit Company (IRT) operated lines that ran mostly through Manhattan, while the Brooklyn-Manhattan Transit Corporation (BMT) operated lines in Brooklyn, some of which extended into Manhattan also. In 1932, the City opened its own service called the Independent Subway System to compete with the IRT and BMT, and so for a while there were _three_ different organizations running subway lines in New York City.
One imagines that this was not an effective way to run a subway. It was not. Constructing interchanges between the various systems was challenging because the IRT and BMT used trains of different widths. Interchange stations also had to have at least two different fare-collection areas since passengers switching trains would have to pay multiple operators. The City eventually took over the IRT and BMT in 1940, bringing the whole system together under one operator, but some of the inefficiencies that the original division entailed are still problems today: Trains designed to run along lines inherited from the BMT (e.g. the A, C, or E) cannot run along lines inherited from the IRT (e.g. the 1, 2, or 3) because the IRT tunnels are too narrow. As a result, the MTA has to maintain two different fleets of mutually incompatible subway cars, presumably at significant additional expense relative to other subway systems in the world that only have to deal with a single tunnel width.
This legacy of the competition between the IRT and BMT suggests that subway systems naturally tend toward monopoly. It just makes more sense for there to be a single operator than for there to be competing operators. Average passengers are amply compensated for the loss of choice by never having to worry about whether they brought their IRT MetroCard today but forgot their BMT MetroCard at home.
Okay, so what does the Subway have to do with social networking? Well, I have wondered for a while now whether Facebook has, like the MTA, a natural monopoly. Facebook does seem to have _a_ monopoly, whether natural or unnatural—not over social media per se (I spend much more time on Twitter), but over my internet social connections with real people I know. It has a monopoly over, as they call it, my digitized “social graph”; I would quit Facebook tomorrow if I didn’t worry that by doing so I might lose many of those connections. I get angry about this power that Facebook has over me. I get angry in a way that I do not get angry about the MTA, even though the Subway is, metaphorically and literally, a sprawling trash fire. And I suppose I get angry because at root I believe that Facebook’s monopoly, unlike the MTA’s, is not a natural one.
What this must mean is that I think Facebook owns all of our social data now because they happened to get there first and then dig a big moat around themselves, not because a world with competing Facebook-like platforms is inefficient or impossible. Is that true, though? There are some good reasons to think it isn’t: Did Facebook simply get there first, or did they instead just do social networking better than everyone else? Isn’t the fact that there is only one Facebook actually convenient if you are trying to figure out how to contact an old friend? In a world of competing Facebooks, what would it mean if you and your boyfriend are now Facebook official, but he still hasn’t gotten around to updating his relationship status on VisageBook, which still says he is in a relationship with his college ex? Which site will people trust? Also, if there were multiple sites, wouldn’t everyone spend a lot more time filling out web forms?
In the last few years, as the disadvantages of centralized social networks have dramatically made themselves apparent, many people have attempted to create decentralized alternatives. These alternatives are based on open standards that could potentially support an ecosystem of inter-operating social networks (see e.g. [the Fediverse][2]). But none of these alternatives has yet supplanted a dominant social network. One obvious explanation for why this hasn’t happened is the power of network effects: With everyone already on Facebook, any one person thinking of leaving faces a high cost for doing so. Some might say this proves that social networks are natural monopolies and stop there; I would say that Facebook, Twitter, et al. chose to be walled gardens, and given that people have envisioned and even built social networks that inter-operate, the network effects that closed platforms enjoy tell us little about the inherent nature of social networks.
So the real question, in my mind, is: Do platforms like Facebook continue to dominate merely because of their network effects, or is having a single dominant social network more efficient in the same way that having a single operator for a subway system is more efficient?
Which finally brings me back to FOAF. Much of the world seems to have forgotten about the FOAF standard, but FOAF was an attempt to build a decentralized and open social network before anyone had even heard of Facebook. If any decentralized social network ever had a chance of occupying the redoubt that Facebook now occupies before Facebook got there, it was FOAF. Given that a large fraction of humanity now has a Facebook account, and given that relatively few people know about FOAF, should we conclude that social networking, like subway travel, really does lend itself to centralization and natural monopoly? Or does the FOAF project demonstrate that decentralized social networking was a feasible alternative that never became popular for other reasons?
### The Future from the Early Aughts
The FOAF project, begun in 2000, set out to create a universal standard for describing people and the relationships between them. That might strike you as a wildly ambitious goal today, but aspirations like that were par for the course in the late 1990s and early 2000s. The web (as people still called it then) had just trounced closed systems like America Online and [Prodigy][3]. It could only have been natural to assume that further innovation in computing would involve the open, standards-based approach embodied by the web.
Many people believed that the next big thing was for the web to evolve into something called the Semantic Web. [I have written about][4] what exactly the Semantic Web was supposed to be and how it was supposed to work before, so I won’t go into detail here. But I will sketch the basic vision motivating the people who worked on Semantic Web technologies, because the FOAF standard was an application of that vision to social networking.
There is an essay called [“How Google beat Amazon and Ebay to the Semantic Web”][5] that captures the lofty dream of the Semantic Web well. It was written by Paul Ford in 2002. The essay imagines a future (as imminent as 2009) in which Google, by embracing the Semantic Web, has replaced Amazon and eBay as the dominant e-commerce platform. In this future, you can search for something you want to purchase—perhaps a second-hand Martin guitar—by entering `buy:martin guitar` into Google. Google then shows you all the people near your zipcode selling Martin guitars. Google knows about these people and their guitars because Google can read RDF, a markup language and core Semantic Web technology focused on expressing relationships. Regular people can embed RDF on their web pages to advertise (among many other things) the items they have to sell. Ford predicts that as the number of people searching for and advertising products this way grows, Amazon and eBay will lose their near-monopolies over, respectively, first-hand and second-hand e-commerce. Nobody will want to search a single centralized database for something to buy when they could instead search the whole web. Even Google, Ford writes, will eventually lose its advantage, because in theory anyone could crawl the web reading RDF and offer a search feature similar to Google’s. At the very least, if Google wanted to make money from its Semantic Web marketplace by charging a percentage of each transaction, that percentage would probably by forced down over time by competitors offering a more attractive deal.
Ford’s imagined future was an application of RDF, or the Resource Description Framework, to e-commerce, but the exciting thing about RDF was that hypothetically it could be used for anything. The RDF standard, along with a constellation of related standards, once widely adopted, was supposed to blow open database-backed software services on the internet the same way HTML had blown open document publishing on the internet.
One arena that RDF and other Semantic Web technologies seemed poised to takeover immediately was social networking. The FOAF project, known originally as “RDF Web Ring” before being renamed, was the Semantic Web effort offshoot that sought to accomplish this. FOAF was so promising in its infancy that some people thought it would inevitably make all other social networking sites obsolete. A 2004 Guardian article about the project introduced FOAF this way:
> In the beginning, way back in 1996, it was SixDegrees. Last year, it was Friendster. Last week, it was Orkut. Next week, it could be Flickr. All these websites, and dozens more, are designed to build networks of friends, and they are currently at the forefront of the trendiest internet development: social networking. But unless they can start to offer more substantial benefits, it is hard to see them all surviving, once the Friend Of A Friend (FOAF) standard becomes a normal part of life on the net.[2][6]
The article goes on to complain that the biggest problem with social networking is that there are too many social networking sites. Something is needed that can connect all of the different networks together. FOAF is the solution, and it will revolutionize social networking as a result.
FOAF, according to the article, would tie the different networks together by doing three key things:
* It would establish a machine-readable format for social data that could be read by any social networking site, saving users from having to enter this information over and over again
* It would allow “personal information management programs,” i.e. your “Contacts” application, to generate a file in this machine-readable format that you could feed to social networking sites
* It would further allow this machine-readable format to be hosted on personal homepages and read remotely by social networking sites, meaning that you would be able to keep your various profiles up-to-date by just pushing changes to your own homepage
It is hard to believe today, but the problem in 2004, at least for savvy webizens and technology columnists aware of all the latest sites, was not the lack of alternative social networks but instead the proliferation of them. Given _that_ problem—so alien to us now—one can see why it made sense to pursue a single standard that promised to make the proliferation of networks less of a burden.
### The FOAF Spec
According to the description currently given on the FOAF project’s website, FOAF is “a computer language defining a dictionary of people-related terms that can be used in structured data.” Back in 2000, in a document they wrote to explain the project’s goals, Dan Brickley and Libby Miller, FOAF’s creators, offered a different description that suggests more about the technology’s ultimate purpose—they introduced FOAF as a tool that would allow computers to read the personal information you put on your homepage the same way that other humans do.[3][7] FOAF would “help the web do the sorts of things that are currently the proprietary offering of centralised services.”[4][8] By defining a standard vocabulary for people and the relationships between them, FOAF would allow you to ask the web questions such as, “Find me today’s web recommendations made by people who work for Medical organizations,” or “Find me recent publications by people I’ve co-authored documents with.”
Since FOAF is a standardized vocabulary, the most important output of the FOAF project was the FOAF specification. The FOAF specification defines a small collection of RDF _classes_ and RDF _properties_. (I’m not going to explain RDF here, but again see [my post about the Semantic Web][4] if you want to know more.) The RDF _classes_ defined by the FOAF specification represent subjects you might want to describe, such as people (the `Person` class) and organizations (the `Organization` class). The RDF _properties_ defined by the FOAF specification represent logical statements you might make about the different subjects. A person could have, for example, a first name (the `givenName` property), a last name (the `familyName` property), perhaps even a personality type (the `myersBriggs` property), and be near another person or location (the `based_near` property). The idea was that these classes and properties would be sufficient to represent the kind of the things people say about themselves and their friends on their personal homepage.
The FOAF specification gives the following as an example of a well-formed FOAF document. This example uses XML, though an equivalent document could be written using JSON or a number of other formats:
```
<foaf:Person rdf:about="#danbri" xmlns:foaf="http://xmlns.com/foaf/0.1/">
<foaf:name>Dan Brickley</foaf:name>
<foaf:homepage rdf:resource="http://danbri.org/" />
<foaf:openid rdf:resource="http://danbri.org/" />
<foaf:img rdf:resource="/images/me.jpg" />
</foaf:Person>
```
This FOAF document describes a person named “Dan Brickley” (one of the specification’s authors) that has a homepage at `http://danbri.org`, something called an “open ID,” and a picture available at `/images/me.jpg`, presumably relative to the base address of Brickley’s homepage. The FOAF-specific terms are prefixed by `foaf:`, indicating that they are part of the FOAF namespace, while the more general RDF terms are prefixed by `rdf:`.
Just to persuade you that FOAF isn’t tied to XML, here is a similar FOAF example from Wikipedia, expressed using a format called JSON-LD[5][9]:
```
{
"@context": {
"name": "http://xmlns.com/foaf/0.1/name",
"homepage": {
"@id": "http://xmlns.com/foaf/0.1/workplaceHomepage",
"@type": "@id"
},
"Person": "http://xmlns.com/foaf/0.1/Person"
},
"@id": "https://me.example.com",
"@type": "Person",
"name": "John Smith",
"homepage": "https://www.example.com/"
}
```
This FOAF document describes a person named John Smith with a homepage at `www.example.com`.
Perhaps the best way to get a feel for how FOAF works is to play around with [FOAF-a-matic][10], a web tool for generating FOAF documents. It allows you to enter information about yourself using a web form, then uses that information to create the FOAF document (in XML) that represents you. FOAF-a-matic demonstrates how FOAF could have been used to save everyone from having to enter their social information into a web form ever again—if every social networking site could read FOAF, all you’d need to do to sign up for a new site is point the site to the FOAF document that FOAF-a-matic generated for you.
Here is a slightly more complicated FOAF example, representing me, that I created using FOAF-a-matic:
```
<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:foaf="http://xmlns.com/foaf/0.1/"
xmlns:admin="http://webns.net/mvcb/">
<foaf:PersonalProfileDocument rdf:about="">
<foaf:maker rdf:resource="#me"/>
<foaf:primaryTopic rdf:resource="#me"/>
<admin:generatorAgent rdf:resource="http://www.ldodds.com/foaf/foaf-a-matic"/>
<admin:errorReportsTo rdf:resource="mailto:leigh@ldodds.com"/>
</foaf:PersonalProfileDocument>
<foaf:Person rdf:ID="me">
<foaf:name>Sinclair Target</foaf:name>
<foaf:givenname>Sinclair</foaf:givenname>
<foaf:family_name>Target</foaf:family_name>
<foaf:mbox rdf:resource="mailto:sinclairtarget@example.com"/>
<foaf:homepage rdf:resource="sinclairtarget.com"/>
<foaf:knows>
<foaf:Person>
<foaf:name>John Smith</foaf:name>
<foaf:mbox rdf:resource="mailto:johnsmith@example.com"/>
<rdfs:seeAlso rdf:resource="www.example.com/foaf.rdf"/>
</foaf:Person>
</foaf:knows>
</foaf:Person>
</rdf:RDF>
```
This example has quite a lot of preamble setting up the various XML namespaces used by the document. There is also a section containing data about the tool that was used to generate the document, largely so that, it seems, people know whom to email with complaints. The `foaf:Person` element describing me tells you my name, email address, and homepage. There is also a nested `foaf:knows` element telling you that I am friends with John Smith.
This example illustrates another important feature of FOAF documents: They can link to each other. If you remember from the previous example, my friend John Smith has a homepage at `www.example.com`. In this example, where I list John Smith as a `foaf:person` with whom I have a `foaf:knows` relationship, I also provide a `rdfs:seeAlso` element that points to John Smith’s FOAF document hosted on his homepage. Because I have provided this link, any program reading my FOAF document could find out more about John Smith by following the link and reading his FOAF document. In the FOAF document we have for John Smith above, John did not provide any information about his friends (including me, meaning, tragically, that our friendship is unidirectional). But if he had, then the program reading my document could find out not only about me but also about John, his friends, their friends, and so on, until the program has crawled the whole social graph that John and I inhabit.
This functionality will seem familiar to anyone that has used Facebook, which is to say that this functionality will seem familiar to you. There is no `foaf:wall` property or `foaf:poke` property to replicate Facebook’s feature set exactly. Obviously, there is also no slick blue user interface that everyone can use to visualize their FOAF social network; FOAF is just a vocabulary. But Facebook’s core feature—the feature that I have argued is key to Facebook’s monopoly power over, at the very least, myself—is here provided in a distributed way. FOAF allows a group of friends to represent their real-life social graph digitally by hosting FOAF documents on their own homepages. It allows them to do this without surrendering control of their data to a centralized database in the sky run by a billionaire android-man who spends much of his time apologizing before congressional committees.
### FOAF on Ice
If you visit the current FOAF project homepage, you will notice that, in the top right corner, there is an image of the character Fry from the TV series Futurama, stuck inside some sort of stasis chamber. This is a still from the pilot episode of Futurama, in which Fry gets frozen in a cryogenic tank in 1999 only to awake a millennium later in 2999. Brickley, whom I messaged briefly on Twitter, told me that he put that image there as a way communicating that the FOAF project is currently “in stasis,” though he hopes that there will be a future opportunity to resuscitate the project along with its early 2000s optimism about how the web should work.
FOAF never revolutionized social networking the way that the 2004 Guardian article about it expected it would. Some social networking sites decided to support the standard: LiveJournal and MyOpera are examples.[6][11] FOAF even played a role in Howard Dean’s presidential campaign in 2004—a group of bloggers and programmers got together to create a network of websites they called “DeanSpace” to promote the campaign, and these sites used FOAF to keep track of supporters and volunteers.[7][12] But today FOAF is known primarily for being one of the more widely used vocabularies of RDF, itself a niche standard on the modern web. If FOAF is part of your experience of the web today at all, then it is as an ancestor to the technology that powers Google’s “knowledge panels” (the little sidebars that tell you the basics about a person or a thing if you searched for something simple). Google uses vocabularies published by the schema.org project—the modern heir to the Semantic Web effort—to populate its knowledge panels.[8][13] The schema.org vocabulary for describing people seems to be somewhat inspired by FOAF and serves many of the same purposes.
So why didn’t FOAF succeed? Why do we all use Facebook now instead? Let’s ignore that FOAF is a simple standard with nowhere near as many features as Facebook—that’s true today, clearly, but if FOAF had enjoyed more momentum it’s possible that applications could have been built on top of it to deliver a Facebook-like experience. The interesting question is: Why didn’t this nascent form of distributed social networking catch fire when Facebook was not yet around to compete with it?
There probably is no single answer to that question, but if I had to pick one, I think the biggest issue is that FOAF only makes sense on a web where everyone has a personal website. In the late 1990s and early 2000s, it might have been easy to assume the web would eventually look like this, especially since so many of the web’s early adopters were, as far as I can tell, prolific bloggers or politically engaged technologists excited to have a platform. But the reality is that regular people don’t want to have to learn how to host a website. FOAF allows you to control your own social information and broadcast it to social networks instead of filling out endless web forms, which sounds pretty great if you already have somewhere to host that information. But most people in practice found it easier to just fill out the web form and sign up for Facebook than to figure out how to buy a domain and host some XML.
What does this mean for my original question about whether or not Facebook’s monopoly is a natural one? I think I have to concede that the FOAF example is evidence that social networking _does_ naturally lend itself to monopoly.
That people did not want to host their own data isn’t especially meaningful itself—modern distributed social networks like [Mastodon][14] have solved that problem by letting regular users host their profiles on nodes set up by more savvy users. It is a sign, however, of just how much people hate complexity. This is bad news for decentralized social networks, because they are inherently more complex under the hood than centralized networks in a way that is often impossible to hide from users.
Consider FOAF: If I were to write an application that read FOAF data from personal websites, what would I do if Sally’s FOAF document mentions a John Smith with a homepage at `example.com`, and Sue’s FOAF document mentions a John Smith with a homepage at `example.net`? Are we talking about a single John Smith with two websites or two entirely different John Smiths? What if the both FOAF documents list John Smith’s email as `johnsmith@gmail.com`? This issue of identity was an acute one for FOAF. In a 2003 email, Brickley wrote that because there does not exist and probably should not exist a “planet-wide system for identifying people,” the approach taken by FOAF is “pluralistic.”[9][15] Some properties of FOAF people, such as email addresses and homepage addresses, are special in that their values are globally unique. So these different properties can be used to merge (or, as Libby Miller called it, “smoosh”) FOAF documents about people together. But none of these special properties are privileged above the others, so it’s not obvious how to handle our John Smith case. Do we trust the homepages and conclude we have two different people? Or do we trust the email addresses and conclude we have a single person? Could I really write an application capable of resolving this conflict without involving (and inconveniencing) the user?
Facebook, with its single database and lack of political qualms, could create a “planet-wide system for identifying people” and so just gave every person a unique Facebook ID. Problem solved.
Complexity alone might not doom distributed social networks if people cared about being able to own and control their data. But FOAF’s failure to take off demonstrates that people have never valued control very highly. As one blogger has put it, “‘Users want to own their own data’ is an ideology, not a use case.”[10][16] If users do not value control enough to stomach additional complexity, and if centralized systems are more simple than distributed ones—and if, further, centralized systems tend to be closed and thus the successful ones enjoy powerful network effects—then social networks are indeed natural monopolies.
That said, I think there is still a distinction to be drawn between the subway system case and the social networking case. I am comfortable with the MTA’s monopoly on subway travel because I expect subway systems to be natural monopolies for a long time to come. If there is going to be only one operator of the New York City Subway, then it ought to be the government, which is at least nominally more accountable than a private company with no competitors. But I do not expect social networks to stay natural monopolies. The Subway is carved in granite; the digital world is writ in water. Distributed social networks may now be more complicated than centralized networks in the same way that carrying two MetroCards is more complicated than carrying one. In the future, though, the web, or even the internet, could change in fundamental ways that make distributed technology much easier to use.
If that happens, perhaps FOAF will be remembered as the first attempt to build the kind of social network that humanity, after a brief experiment with corporate mega-databases, does and always will prefer.
_If you enjoyed this post, more like it come out every four weeks! Follow [@TwoBitHistory][17] on Twitter or subscribe to the [RSS feed][18] to make sure you know when a new post is out._
_Previously on TwoBitHistory…_
> I know it's been too long since my last post, but my new one is here! I wrote almost 5000 words on John Carmack, Doom, and the history of the binary space partitioning tree.<https://t.co/SVunDZ0hZ1>
>
> — TwoBitHistory (@TwoBitHistory) [November 6, 2019][19]
1. Please note that I did not dare say “dead.” [↩︎][20]
2. Jack Schofield, “Let’s be Friendsters,” The Guardian, February 19, 2004, accessed January 5, 2020, <https://www.theguardian.com/technology/2004/feb/19/newmedia.media>. [↩︎][21]
3. Dan Brickley and Libby Miller, “Introducing FOAF,” FOAF Project, 2008, accessed January 5, 2020, <https://web.archive.org/web/20140331104046/http://www.foaf-project.org/original-intro>. [↩︎][22]
4. ibid. [↩︎][23]
5. Wikipedia contributors, “JSON-LD,” Wikipedia: The Free Encyclopedia, December 13, 2019, accessed January 5, 2020, <https://en.wikipedia.org/wiki/JSON-LD>. [↩︎][24]
6. “Data Sources,” FOAF Project Wiki, December 11 2009, accessed January 5, 2020, <https://web.archive.org/web/20100226072731/http://wiki.foaf-project.org/w/DataSources>. [↩︎][25]
7. Aldon Hynes, “What is Dean Space?”, Extreme Democracy, accessed January 5, 2020, <http://www.extremedemocracy.com/chapters/Chapter18-Hynes.pdf>. [↩︎][26]
8. “Understand how structured data works,” Google Developer Portal, accessed January 5, 2020, <https://developers.google.com/search/docs/guides/intro-structured-data>. [↩︎][27]
9. tef, “Why your distributed network will not work,” Progamming is Terrible, January 2, 2013, <https://programmingisterrible.com/post/39438834308/distributed-social-network>. [↩︎][28]
10. Dan Brickley, “Identifying things in FOAF,” rdfweb-dev Mailing List, July 10, 2003, accessed on January 5, 2020, <http://lists.foaf-project.org/pipermail/foaf-dev/2003-July/005463.html>. [↩︎][29]
--------------------------------------------------------------------------------
via: https://twobithistory.org/2020/01/05/foaf.html
作者：[Two-Bit History][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://twobithistory.org
[b]: https://github.com/lujun9972
[1]: tmp.k5HszJyQ4D#fn:1
[2]: https://en.wikipedia.org/wiki/Fediverse
[3]: https://en.wikipedia.org/wiki/Prodigy_(online_service)
[4]: https://twobithistory.org/2018/05/27/semantic-web.html
[5]: https://www.ftrain.com/google_takes_all
[6]: tmp.k5HszJyQ4D#fn:2
[7]: tmp.k5HszJyQ4D#fn:3
[8]: tmp.k5HszJyQ4D#fn:4
[9]: tmp.k5HszJyQ4D#fn:5
[10]: http://www.ldodds.com/foaf/foaf-a-matic
[11]: tmp.k5HszJyQ4D#fn:6
[12]: tmp.k5HszJyQ4D#fn:7
[13]: tmp.k5HszJyQ4D#fn:8
[14]: https://en.wikipedia.org/wiki/Mastodon_(software)
[15]: tmp.k5HszJyQ4D#fn:9
[16]: tmp.k5HszJyQ4D#fn:10
[17]: https://twitter.com/TwoBitHistory
[18]: https://twobithistory.org/feed.xml
[19]: https://twitter.com/TwoBitHistory/status/1192196764239093760?ref_src=twsrc%5Etfw
[20]: tmp.k5HszJyQ4D#fnref:1
[21]: tmp.k5HszJyQ4D#fnref:2
[22]: tmp.k5HszJyQ4D#fnref:3
[23]: tmp.k5HszJyQ4D#fnref:4
[24]: tmp.k5HszJyQ4D#fnref:5
[25]: tmp.k5HszJyQ4D#fnref:6
[26]: tmp.k5HszJyQ4D#fnref:7
[27]: tmp.k5HszJyQ4D#fnref:8
[28]: tmp.k5HszJyQ4D#fnref:9
[29]: tmp.k5HszJyQ4D#fnref:10

71
sources/tech/20200105 PaperWM- tiled window management for GNOME.md Normal file
View File

@ -0,0 +1,71 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (PaperWM: tiled window management for GNOME)
[#]: via: (https://jvns.ca/blog/2020/01/05/paperwm/)
[#]: author: (Julia Evans https://jvns.ca/)
PaperWM: tiled window management for GNOME
======
When I started using Linux on my personal computer, one of the first things I got excited about was tiny lightweight window managers, largely because my laptop at the time had 32MB of RAM and anything else was unusable.
Then I got into tiling window managers like [xmonad][1]! I could manage my windows with my keyboard! They were so fast! I could configure xmonad by writing a Haskell program! I could customize everything in all kinds of fun ways (like using [dmenu][2] as a launcher)! I used 3 or 4 different tiling window managers over the years and it was fun.
About 6 years ago I decided configuring my tiling window manager wasn’t fun for me anymore and switched to using the Ubuntu stock desktop environment: Gnome. (which is much faster now that I have 500x more RAM in my laptop :) )
So I’ve been using Gnome for a long time, but I still kind of missed tiling window managers. Then 6 months ago a friend told me about [PaperWM][3], which lets you tile your windows in Gnome! I installed it immediately and I’ve been using it ever since.
### PaperWM: tiling window management for Gnome
The basic idea of [PaperWM][3] is: you want to keep using Gnome (because all kinds of things Just Work in Gnome) but you also kinda wish you were using a tiling window manager.
It’s a Gnome extension (instead of being a standalone window manager) and it’s in Javascript.
### “Paper” means all of your windows are in a line
The main idea in PaperWM is it puts all your windows in a line, which is actually quite different from traditional tiling window managers where you can tile your windows any way you want. Here’s a gif of me moving between / resizing some windows while writing this blog post (there’s a browser and two terminal windows):
![][4]
PaperWM’s Github README links to this video: <http://10gui.com/video/>, which describes a similar system as a “linear window manager”.
I’d never heard of this way of organizing windows before but I like the simplicity of it – if I’m looking for a specific window I just move left/right until I find it.
### everything I do in PaperWM
there are lots of other features but these are the only ones I use:
* move left and right between windows (`Super + ,`, `Super + .`)
* move the window left/right in the ordering (`Super+Shift+,`, `Super+Shift+.`)
* full screen a window (`Super + f`)
* make a window smaller (`Super + r`)
### I like tools that I don’t have to configure
I’ve been using PaperWM for 6 months on a laptop and I really like it! I also really appreciate that even though it’s configurable (by writing a Javascript configuration file), it does the things I want out of the box without me having to research how to configure it.
The [fish shell][5] is another delightful tool like that – I basically don’t configure fish at all (except to set environment variables etc) and I really like the default feature set.
--------------------------------------------------------------------------------
via: https://jvns.ca/blog/2020/01/05/paperwm/
作者：[Julia Evans][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://jvns.ca/
[b]: https://github.com/lujun9972
[1]: https://xmonad.org/
[2]: https://wiki.archlinux.org/index.php/Dmenu
[3]: https://github.com/paperwm/PaperWM
[4]: https://jvns.ca/images/paperwm.gif
[5]: https://jvns.ca/blog/2017/04/23/the-fish-shell-is-awesome/

126
sources/tech/20200106 Create fancy text for your social media posts with this Gawk script.md Normal file
View File

@ -0,0 +1,126 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Create fancy text for your social media posts with this Gawk script)
[#]: via: (https://opensource.com/article/20/1/gawk-scripting-social-media)
[#]: author: (Jim Hall https://opensource.com/users/jim-hall)
Create fancy text for your social media posts with this Gawk script
======
Add a little style to your status updates by posting text in script,
fraktur, or double-strike characters.
![Chat via email][1]
Like almost everyone on the planet, I have a few social media accounts. I mostly stick to Facebook to stay up to date with friends and family and Twitter to follow a few other people.
Have you ever wanted to make a post that includes italics or some other fancy formatting? You can easily change the text to italics or bold when you're writing an email, but most social media platforms don't provide many formatting options.
And sometimes, I just want to put a little _emphasis_ into what I'm writing. If I've had a really good day and I want to share that with my friends, I might want to put that text in italics. For other posts, I might want to use different formatting that will help my text stand out. Sure, you can use emoji, but sometimes a little text formatting can add that extra pizzazz to your posts.
I found a way to do just that. With a short [Gawk][2] script I wrote, I can create fancy formatting that I can copy and paste into my social media posts.
### Special HTML
HTML includes a bunch of special characters for mathematics, symbols, and other languages that most people are not aware of. Within the Mathematical Markup Language ([MathML][3]) math character support, HTML includes alternate versions of the alphabet for script, fraktur, and double-strike (shown respectively in this image) characters.
![script, fraktur, and double-strike text][4]
You can use these alternate versions of the alphabet to create fancy text.
The script alphabet variation is written as the letter followed by **scr**. Characters can be uppercase or lowercase. For example, to print the script letter **a** in an HTML page, type **&amp;ascr;**, and to print the script letter **Z** in HTML, type **&amp;Zscr;**.
The fraktur and double-strike variations are referenced in similar ways. The fraktur mathematical lower-case **a** is **&amp;afr;**, and the capital **Y** is **&amp;Yfr;**. The mathematical double-strike **a** is referenced as **&amp;aopf;**, and the double-strike **X** is **&amp;Xopf;**.
### Gawk functions
Once you know how to reference the alternate versions of each letter, it's easy to define a few Gawk functions to print those HTML entities. Since these alternate characters exist only for letters and not punctuation or numbers, start with a simple wrapper function to determine if a character is an uppercase or lowercase letter.
```
#!/usr/bin/gawk -f
# Echo the input as different "fonts." Redirect this into an html
# page and copy/paste fancy text into twitter or facebook.
BEGIN { alpha="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; }
function is_alpha(c) {
  return(index(alpha, c));
}
```
The **BEGIN** statement defines an alphabet string called **alpha** that contains all letters a–z and A–Z. The **is_alpha(c)** function uses the built-in **index()** function to return the location of the character **c** in the string **alpha**. If the character **c** is not a letter, **index()** returns zero, which the script uses as a False value.
Because the **is_alpha(c)** function just "wraps" a call to the **index()** function without doing anything else; this is called a _wrapper_ function. Think of it as shorthand that makes the Gawk script easier to read.
With that, it's easy to define a few functions that convert single letters into each of the alternate versions of the alphabet. In general, each function calls **is_alpha(c)** to determine if a character is a letter a–z or A–Z. If it is (i.e., if the returned value is non-zero), then the function prints the HTML entity for that letter as script, fraktur, and double-strike. Otherwise, the function prints the letter.
```
function print_script(c) {
  if ( is_alpha(c) ) { printf("&amp;%cscr;", c); } else { printf("%c", c); }
}
function print_fraktur(c) {
  if ( is_alpha(c) ) { printf("&amp;%cfr;", c); }  else { printf("%c", c); }
}
function print_double(c) {
  if ( is_alpha(c) ) { printf("&amp;%copf;", c); } else { printf("%c", c); }
}
```
The **print_script(c)** function prints a single letter in script. Similarly, the **print_fraktur(c)** function prints a letter in fraktur, and the **print_double(c)** function prints a single letter in double-strike.
All that's left is a Gawk loop to convert plain text into each of the alternate alphabet characters. This script loops over each line three times and prints the text in script, fraktur, or double-strike. Each line is wrapped in **&lt;p&gt;** and **&lt;/p&gt;** HTML tags.
```
{ text=$0;
  len=length(text);
  print "&lt;p&gt;";
  for (i=1; i&lt;=len; i++) {
    print_script( substr(text, i, 1) );
  }
  print "&lt;/p&gt;&lt;p&gt;";
  for (i=1; i&lt;=len; i++) {
    print_fraktur( substr(text, i, 1) );
  }
  print "&lt;/p&gt;&lt;p&gt;";
  for (i=1; i&lt;=len; i++) {
    print_double( substr(text, i, 1) );
  }
  print "&lt;/p&gt;";
}
```
### Putting it all together
I saved the above lines in a script file called **htmlecho** and put it in my **~/bin** directory.
```
$ htmlecho &gt; /tmp/hello.html
Hello world
^Z
```
Whenever I want to add fancy text to my Facebook and Twitter posts, I just run the script and save the output to a temporary HTML page. I open the temporary page in a web browser and copy and paste the fancy text I like best into my social media posts.
--------------------------------------------------------------------------------
via: https://opensource.com/article/20/1/gawk-scripting-social-media
作者：[Jim Hall][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/jim-hall
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/email_chat_communication_message.png?itok=LKjiLnQu (Chat via email)
[2]: https://www.gnu.org/software/gawk/
[3]: https://en.wikipedia.org/wiki/MathML
[4]: https://opensource.com/sites/default/files/uploads/hello_world.png (script, fraktur, and double-strike text)

157
sources/tech/20200106 How to write a Python web API with Pyramid and Cornice.md Normal file
View File

@ -0,0 +1,157 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (How to write a Python web API with Pyramid and Cornice)
[#]: via: (https://opensource.com/article/20/1/python-web-api-pyramid-cornice)
[#]: author: (Moshe Zadka https://opensource.com/users/moshez)
How to write a Python web API with Pyramid and Cornice
======
Use Pyramid and Cornice to build and document scalable RESTful web
services.
![Searching for code][1]
[Python][2] is a high-level, object-oriented programming language known for its simple syntax. It is consistently among the top-rated programming languages for building RESTful APIs.
[Pyramid][3] is a Python web framework designed to scale up with an application: it's simple for simple applications but can grow for big, complex applications. Among other things, Pyramid powers PyPI, the Python package index. [Cornice][4] provides helpers to build and document REST-ish web services with Pyramid.
This article will use the example of a web service to get famous quotes to show how to use these tools.
### Set up a Pyramid application
Start by creating a virtual environment for your application and a file to hold the code:
```
$ mkdir tutorial
$ cd tutorial
$ touch main.py
$ python3 -m venv env
$ source env/bin/activate
(env) $ pip3 install cornice twisted
```
### Import the Cornice and Pyramid modules
Import these modules with:
```
from pyramid.config import Configurator
from cornice import Service
```
### Define the service
Define the quotes service as a **Service** object:
```
QUOTES = Service(name='quotes',
                 path='/',
                 description='Get quotes')
```
### Write the quotes logic
So far, this only supports **GET**ing quotes. Decorate the function with **QUOTES.get**; this is how you can tie in the logic to the REST service:
```
@QUOTES.get()
def get_quote(request):
    return {
        'William Shakespeare': {
            'quote': ['Love all, trust a few, do wrong to none',
            'Some are born great, some achieve greatness, and some have greatness thrust upon them.']
    },
    'Linus': {
        'quote': ['Talk is cheap. Show me the code.']
        }
    }
```
Note that unlike in other frameworks, the **get_quote** function is _not_ changed by the decorator. If you import this module, you can still call the function regularly and inspect the result.
This is useful when writing unit tests for Pyramid RESTful services.
### Define the application object
Finally, use **scan** to find all decorated functions and add them to the configuration: 
```
with Configurator() as config:
    config.include("cornice")
    config.scan()
    application = config.make_wsgi_app()
```
The default for scan is to scan the current module. You can also give the name of a package if you want to scan all modules in a package.
### Run the service
I use Twisted's WSGI server to run the application, but you can use any other [WSGI][5] server, like Gunicorn or uWSGI, if you want:
```
`(env)$ python -m twisted web --wsgi=main.application`
```
By default, Twisted's WSGI server runs on port 8080. You can test the service with [HTTPie][6]:
```
(env) $ pip install httpie
...
(env) $ http GET <http://localhost:8080/>
HTTP/1.1 200 OK
Content-Length: 220
Content-Type: application/json
Date: Mon, 02 Dec 2019 16:49:27 GMT
Server: TwistedWeb/19.10.0
X-Content-Type-Options: nosniff
{
    "Linus": {
        "quote": [
            "Talk is cheap. Show me the code."
        ]
    },
    "William Shakespeare": {
        "quote": [
            "Love all,trust a few,do wrong to none",
            "Some are born great, some achieve greatness, and some greatness thrust upon them."
        ]
    }
}
```
### Why use Pyramid?
Pyramid is not the most popular framework, but it is used in some high-profile projects like [PyPI][7]. I like Pyramid because it is one of the frameworks that took unit testing seriously: because the decorators do not modify the function and there are no thread-local variables, functions are callable directly from unit tests. For example, functions that need access to the database will get it from the **request** object passed in via **request.config**. This allows a unit tester to put a mock (or real) database object in the request, instead of carefully setting globals, thread-local variables, or other framework-specific things.
If you're looking for a well-tested library to build your next API, give Pyramid a try. You won't be disappointed.
--------------------------------------------------------------------------------
via: https://opensource.com/article/20/1/python-web-api-pyramid-cornice
作者：[Moshe Zadka][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/moshez
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/search_find_code_python_programming.png?itok=ynSL8XRV (Searching for code)
[2]: https://opensource.com/resources/python
[3]: https://opensource.com/article/18/5/pyramid-framework
[4]: https://cornice.readthedocs.io/en/latest/
[5]: https://en.wikipedia.org/wiki/Web_Server_Gateway_Interface
[6]: https://opensource.com/article/19/8/getting-started-httpie
[7]: https://pypi.org/

107
sources/tech/20200107 App Highlight- Catfish Desktop File Searching Tool.md Normal file
View File

@ -0,0 +1,107 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (App Highlight: Catfish Desktop File Searching Tool)
[#]: via: (https://itsfoss.com/catfish/)
[#]: author: (Abhishek Prakash https://itsfoss.com/author/abhishek/)
App Highlight: Catfish Desktop File Searching Tool
======
_****Brief: Catfish is a nifty file searching GUI tool for Linux desktop. The interface is lightweight and simple and the tool allows to refine your search with** criteria like time, file type etc.**_
The Linux purists use commands like locate, find and grep to search for files in the terminal.
But as a desktop Linux user, you don’t need to leave the comfort of the graphical user interface (GUI) and deep dive into the command line interface (CLI) just for searching files on your desktop.
Most Linux distributions provide a basic desktop search feature either via the file manager or through the desktop environment itself.
On GNOME desktop, you can search for files in the Activities area (use the Windows key to bring it up). Files (previously known as Nautilus) also has a built-in search button.
![Nautilus file manager already has advanced search feature][1]
You can extend this search and add options like time and type of the file. One thing it doesn’t do is to search inside the files. For example, you cannot use it to get all the files that contains “university”.
This is where a desktop file search tool like Catfish could help you.
### Catfish: A nifty GUI tool for searching files on Linux
[Catfish][2] is a GUI tool that enables you to search your desktop for any kind of files. It uses locate and find commands underneath. The autocompletion feature uses [Zeitgeist][3] daemon and [locate command][4]. It’s a lightweight tool and uses GTK+.
Catfish is developed by [Christian Dywan][5], the same person who develops the [lightweight Midori web browser][6].
![Catfish interface on MX Linux][7]
Some of the main features of Catfish are:
* Search for files anywhere on your system, **including the mounted partitions**
* **Search inside the files** for its contents (can be enabled from preferences)
* Search hidden files as well
* Refine your search based on modification time
* Refine your search based on file type (images, videos, documents etc)
* Refine your search based on location (Documents, Downloads, Pictures or other folders)
* Exclude certain directories and paths from your search
* Lightweight and simple interface
* **Support for Wayland** display server (from version 1.4.12)
Catfish is now a Xfce project and it is providing the search feature to Xfce’s Thunar file manager.
### Installing Catfish on Ubuntu and other Linux distributions
Let’s see how to install Catfish on your Linux distributions.
**Ubuntu-based distributions**
Catfish is available in the universe repository for Ubuntu based distributions such as Xubuntu, Linux Mint, Linux Lite etc.
You can install it from the software center by searching for Catfish
![Catfish in Ubuntu Software Center][8]
or, use the terminal to install it:
```
sudo apt install catfish
```
The version provided by Ubuntu may not be the latest. The [official PPA][9] has been abandoned so this means that to get the latest Catfish version, you’ll have to [install it from the source code][10].
**On other distributions**
Catfish is also available in most major Linux distributions. It is certainly available on Fedora and if you check your distribution’s package manager or software center, you should find it there and install it like any other program.
**Conclusion**
In this week’s Linux application highlight, you learned about this handy little utility. However, Catfish is not the only tool of its kind. You may check some other search tools like [ANGRYSearch][11] or [SearchMonkey][12].
Have you ever used a GUI tool for searching files or do you rely on the good old command line? And what do you think of Catfish? Do you look forward to use it?
--------------------------------------------------------------------------------
via: https://itsfoss.com/catfish/
作者：[Abhishek Prakash][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/abhishek/
[b]: https://github.com/lujun9972
[1]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2020/01/search-files-gnome.jpg?ssl=1
[2]: https://launchpad.net/catfish-search/
[3]: https://wiki.archlinux.org/index.php/Zeitgeist
[4]: https://linuxhandbook.com/locate-command/
[5]: http://www.twotoasts.de/index.php/about/
[6]: https://itsfoss.com/midori-browser/
[7]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2020/01/catfish_screenshot.png?ssl=1
[8]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2020/01/catfish_ubuntu_software_center.jpg?ssl=1
[9]: https://itsfoss.com/ppa-guide/
[10]: https://itsfoss.com/install-software-from-source-code/
[11]: https://itsfoss.com/angrysearch/
[12]: https://itsfoss.com/searchmonkey-search-text-files-linux/

67
translated/tech/20200101 5 predictions for Kubernetes in 2020.md
View File

@ -1,67 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: (lxbwolf)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (5 predictions for Kubernetes in 2020)
[#]: via: (https://opensource.com/article/20/1/kubernetes-2020)
[#]: author: (Scott McCarty https://opensource.com/users/fatherlinux)
2020 年对 Kubernetes 的 5 项预测
======
请先回顾下 2019 年网站上最受欢迎的 Kubernetes 的文章。
![Person drinking a hat drink at the computer][1]
你怎么追踪一个广受欢迎的项目（如 Kubernetes）的发展轨迹？你怎么能了解它发展到什么程度了？如果你在为这个项目作贡献或加入了 SIG（Special Interest Group），可能你会在潜移默化中了解到它的发展轨迹，但如果你的全日工作不涉及到为 Kubernetes 作贡献，那么你可能需要一点关于未来的预测来帮助你了解。对于一个诸如 Kubernetes 的快速发展的项目，年末是回顾过去的一年和展望新的一年的最好时机。
今年，Kubernetes 取得了很大的进展。除了去查看源码、文档、会议笔记，你也可以去浏览博客。为了深入了解，我在 Opensource.com 上看了 Kubernetes 的 top 10 文章。通过这些文章，我们能了解开发者们更喜欢读和写哪些话题的文章。我们开始吧！
(2019 年末获取 Kubernetes 文章的 top 10。)
首先，我要指明这些文章中有 5 篇是关于 Kubernetes 工作负载的扩展以及它们可以运行在什么场景。这些工作负载涵盖数据科学、PostgreSQL、InfluxDB、Grafana（不仅仅监控集群本身）和 Edge。从历史角度看，Kubernetes 和容器都是在虚拟机上运行的，尤其是运行在由云提供的基础设施上时。抛开对于 Kubernetes 的兴趣因素，这也表明了终端用户们极度希望在裸机上安装 Kubernetes（参照[OpenShift 环境安装 Kubernetes][2]）。
其次，也有很多开发者希望了解操作相关的知识以及 Kubernetes 的最佳实践。从 [Kubernetes 操作][3] 到 [Kubernetes 控制器][4]，从 [Secrets][5] 到 [ConfigMaps][6]，开发者和运维人员都希望能找到简化部署和管理工作的最佳实践。我们经常纠结在怎么去修改配置文件或别人会怎么配置，而不去回头想想这些配置是怎么让应用部署运转的（不是怎么安装，也不是怎么运行 Kubernetes）。
最后，人们似乎对入门教程真的感兴趣。事实上，构建 Kubernetes 所需了解的信息太多了，以至于让人们望而却步，也使他们走了错误的路。流行度高的文章中有几篇讲述了为什么你需要了解用 Kubernetes 运行应用程序，而不仅仅是安装它。就是最佳实践类的文章一样，人们也通常不会回头分析在入门时他们应该在什么地方花费时间。我一直秉持的理念是，把有限的时间和金钱投入到如何使用某项技术上，而不是如何构建它。
### 2020 年对 Kubernetes 的 5 项预测
回顾下 2019 年的相关主题，这些主题告诉我们 2020 年将如何发展？结合这些文章中的观点，加上我自己的看法，我来分享下我对于 2020 年以及未来发展趋势的想法：
1. 工作负载扩展。我会关注高性能计算，AI/ML 以及使用 Operator 的有状态工作负载。
2. 更多的生产中的最佳实践，尤其是跟一些成熟的标准相关的，像 PCI，HIPAA，NIST 等等.
3. rootless 相关的更好的安全性和 [runtimes classes][7]（如 [gVisor][8]，[Kata Containers][9] 等等）更高的安全性。
4. 在部署和开发者们共享应用时，把 Kubernetes 清单的更好的规范标准作为部署的核心要素。如 [podman generate kube][10], [podman play kube][11], 还有多合一 Kubernetes 环境，如 [CodeReady Containers (CRC)][12]
5. 一个前所未有的网络、存储和专业硬件（如 GPU 等等）供应商的生态系统，为 Kubernetes 提供 BoB（译注：best of breed，单项最佳品牌）解决方案（在免费软件中，我们相信开放的生态系统好过垂直整合的解决方案）。
期待 Kubernetes 在新的一年里再创辉煌！
--------------------------------------------------------------------------------
via: https://opensource.com/article/20/1/kubernetes-2020
作者：[Scott McCarty][a]
选题：[lujun9972][b]
译者：[lxbwolf](https://github.com/lxbwolf)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/fatherlinux
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/coffee_tea_laptop_computer_work_desk.png?itok=D5yMx_Dr (Person drinking a hat drink at the computer)
[2]: https://blog.openshift.com/kubernetes-on-metal-with-openshift/
[3]: https://kubernetes.io/docs/concepts/extend-kubernetes/operator/
[4]: https://kubernetes.io/docs/concepts/architecture/controller/
[5]: https://kubernetes.io/docs/concepts/configuration/secret/
[6]: https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/
[7]: https://kubernetes.io/docs/concepts/containers/runtime-class/
[8]: https://gvisor.dev/
[9]: https://katacontainers.io/
[10]: https://developers.redhat.com/blog/2019/01/29/podman-kubernetes-yaml/
[11]: https://www.redhat.com/en/blog/rhel-81-minor-release-major-new-container-capabilities
[12]: https://developers.redhat.com/products/codeready-containers/overview