{"id":2900,"date":"2018-11-08T05:20:06","date_gmt":"2018-11-08T05:20:06","guid":{"rendered":"https:\/\/www.appservgrid.com\/paw92\/?p=2900"},"modified":"2018-11-12T00:24:50","modified_gmt":"2018-11-12T00:24:50","slug":"revisiting-the-unix-philosophy-in-2018","status":"publish","type":"post","link":"https:\/\/www.appservgrid.com\/paw92\/index.php\/2018\/11\/08\/revisiting-the-unix-philosophy-in-2018\/","title":{"rendered":"Revisiting the Unix philosophy in 2018"},"content":{"rendered":"

In 1984, Rob Pike and Brian W. Kernighan published an article called “Program Design in the Unix Environment<\/a>” in the AT&T Bell Laboratories Technical Journal, in which they argued the Unix philosophy, using the example of BSD’s cat -v implementation. In a nutshell that philosophy is: Build small, focused programs\u2014in whatever language\u2014that do only one thing but do this thing well, communicate via stdin\/stdout, and are connected through pipes.<\/p>\n

Sound familiar?<\/p>\n

Yeah, I thought so. That’s pretty much the definition of microservices<\/a> offered by James Lewis and Martin Fowler:<\/p>\n

In short, the microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API.<\/p><\/blockquote>\n

While one *nix program or one microservice may be very limited or not even very interesting on its own, it’s the combination of such independently working units that reveals their true benefit and, therefore, their power.<\/p>\n

*nix vs. microservices<\/h2>\n

The following table compares programs (such as cat or lsof) in a *nix environment against programs in a microservices environment.<\/p>\n\n\n\n\n\n\n\n\n
<\/th>\n*nix<\/th>\nMicroservices<\/th>\n<\/tr>\n<\/thead>\n
Unit of execution<\/td>\nprogram using stdin\/stdout<\/td>\nservice with HTTP or gRPC API<\/td>\n<\/tr>\n
Data flow<\/td>\nPipes<\/td>\n?<\/td>\n<\/tr>\n
Configuration & parameterization<\/td>\nCommand-line arguments,
\nenvironment variables, config files<\/td>\n		JSON\/YAML docs<\/td>\n<\/tr>\n
Discovery<\/td>\nPackage manager, man, make<\/td>\nDNS, environment variables, OpenAPI<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Let’s explore each line in slightly greater detail.<\/p>\n

Unit of execution<\/h3>\n

The unit of execution in *nix (such as Linux) is an executable file (binary or interpreted script) that, ideally, reads input from<\/p>\n

stdin<\/p>\n

and writes output to<\/p>\n

stdout<\/p>\n

. A microservices setup deals with a service that exposes one or more communication interfaces, such as HTTP or gRPC APIs. In both cases, you’ll find stateless examples (essentially a purely functional behavior) and stateful examples, where, in addition to the input, some internal (persisted) state decides what happens.<\/p>\n

Data flow<\/h3>\n

Traditionally, *nix programs could communicate via pipes. In other words, thanks to Doug McIlroy<\/a>, you don’t need to create temporary files to pass around and each can process virtually endless streams of data between processes. To my knowledge, there is nothing comparable to a pipe standardized in microservices, besides my little Apache Kafka-based experiment from 2017<\/a>.<\/p>\n

Configuration and parameterization<\/h3>\n

How do you configure a program or service\u2014either on a permanent or a by-call basis? Well, with *nix programs you essentially have three options: command-line arguments, environment variables, or full-blown config files. In microservices, you typically deal with YAML (or even worse, JSON) documents, defining the layout and configuration of a single microservice as well as dependencies and communication, storage, and runtime settings. Examples include Kubernetes resource definitions<\/a>, Nomad job specifications<\/a>, or Docker Compose<\/a> files. These may or may not be parameterized; that is, either you have some templating language, such as Helm<\/a> in Kubernetes, or you find yourself doing an awful lot of sed -i commands.<\/p>\n

Discovery<\/h3>\n

How do you know what programs or services are available and how they are supposed to be used? Well, in *nix, you typically have a package manager as well as good old man; between them, they should be able to answer all the questions you might have. In a microservices setup, there’s a bit more automation in finding a service. In addition to bespoke approaches like Airbnb’s SmartStack<\/a> or Netflix’s Eureka<\/a>, there usually are environment variable-based or DNS-based approaches<\/a> that allow you to discover services dynamically. Equally important, OpenAPI<\/a> provides a de-facto standard for HTTP API documentation and design, and gRPC<\/a> does the same for more tightly coupled high-performance cases. Last but not least, take developer experience (DX) into account, starting with writing good Makefiles<\/a> and ending with writing your docs with (or in?) style<\/a>.<\/p>\n

Pros and cons<\/h2>\n

Both *nix and microservices offer a number of challenges and opportunities<\/p>\n

Composability<\/h3>\n

It’s hard to design something that has a clear, sharp focus and can also play well with others. It’s even harder to get it right across different versions and to introduce respective error case handling capabilities. In microservices, this could mean retry logic and timeouts\u2014maybe it’s a better option to outsource these features into a service mesh? It’s hard, but if you get it right, its reusability can be enormous.<\/p>\n

Observability<\/h3>\n

In a monolith (in 2018) or a big program that tries to do it all (in 1984), it’s rather straightforward to find the culprit when things go south. But, in a<\/p>\n

yes | tr \\n x | head -c 450m | grep n<\/p>\n

or a request path in a microservices setup that involves, say, 20 services, how do you even start<\/em> to figure out which one is behaving badly? Luckily we have standards, notably OpenCensus<\/a> and OpenTracing<\/a>. Observability still might be the biggest single blocker if you are looking to move to microservices.<\/p>\n

Global state<\/h3>\n

While it may not be such a big issue for *nix programs, in microservices, global state remains something of a discussion. Namely, how to make sure the local (persistent) state is managed effectively and how to make the global state consistent with as little effort as possible.<\/p>\n

Wrapping up<\/h2>\n

In the end, the question remains: Are you using the right tool for a given task? That is, in the same way a specialized *nix program implementing a range of functions might be the better choice for certain use cases or phases, it might be that a monolith is the best option<\/a> for your organization or workload. Regardless, I hope this article helps you see the many, strong parallels between the Unix philosophy and microservices\u2014maybe we can learn something from the former to benefit the latter.<\/p>\n

Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

In 1984, Rob Pike and Brian W. Kernighan published an article called “Program Design in the Unix Environment” in the AT&T Bell Laboratories Technical Journal, in which they argued the Unix philosophy, using the example of BSD’s cat -v implementation. In a nutshell that philosophy is: Build small, focused programs\u2014in whatever language\u2014that do only one … <\/p>\n

Continue reading “Revisiting the Unix philosophy in 2018”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-2900","post","type-post","status-publish","format-standard","hentry","category-linux"],"_links":{"self":[{"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/posts\/2900","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/comments?post=2900"}],"version-history":[{"count":1,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/posts\/2900\/revisions"}],"predecessor-version":[{"id":3111,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/posts\/2900\/revisions\/3111"}],"wp:attachment":[{"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/media?parent=2900"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/categories?post=2900"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.appservgrid.com\/paw92\/index.php\/wp-json\/wp\/v2\/tags?post=2900"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}