Title: The UNIX philosophy.
Author: Michael Constantine Dimopoulos
Date: 17 March 2020

Introduction.  The upcoming September will mark 50 years since the
initial release of the UNIX operating system, so what better time to
talk about the influence of UNIX in the digital & physical world than
now. UNIX was designed and built by computer legends Ken Thompson,
Dennis Ritchie, Brian Kernighan, Douglas McIlroy among others at Bell
Labs. One of the most interesting concepts to arise along with it was its
philosophy regarding software development, which was especially promoted
by Kernighan and Rob Pike. The Unix philosophy is about minimalism and
simplicity - anyone who's used a Un*x system understands that.

Origins.  When discussing the Unix philosophy, it is important to talk
about its predecessor, Multics. Despite being its main origin, Multics
was different from UNIX. It was written in a high level language and it
was sort of a bloated system for the time. In its effort to be general
purpose, stable and user-friendly, Multics had become too big for the
hardware of the time. Although it was eventually released open source,
and by modern standards it would be considered a very lightweight system,
it caused the reaction which led to Unix: the bare and absolute minimum,
yet complete, system.

It is also important to take into consideration the limitations of
computing systems when UNIX was first developed. The 1960s were a crucial
decade in the development of the fields of electronic engineering,
computer science and STEM as a whole - Many landmarks were marked,
with C and Unix being among the greatest. However, computer memory,
input/output devices, storage space, processing power etc. were extremely
limited and primitive when compared to modern computers. That is the
environment that Unix had to deal with, and not only that: Unix was a
full operating system with permissions, multi user support etc.

The idea.  The "philosophy" itself is based a few core principles They are
the following:
0. Simplicty > complexity
1. Porgrams should be modular. No frameworks and such.
2. Programs should "do one thing and do it well" i.e they should be
specialized without feature-creeping and bloat.
3. Each program can solve a simple problem, but combining them through
pipes can solve different more complex and specialized issues. "Although
that philosophy can't be written down in a single sentence, at its heart
is the idea that the power of a system comes more from the relationships
among programs than from the programs themselves. Many UNIX programs do
quite trivial things in isolation, but, combined with other programs,
become general and useful tools."

Other core features that may or may not be considered part of the Unix
philosophy are:
0. A simple usually textual environment. 
1. Pipes transfer streams of text, from the standard output of one
program to the standard input of another.
2. Everything is a file and acts like a file, including system
information and configurations etc. This allows programs (which primarily
deal with files) to easily interact with every aspect of the system. Files
and standard input/output are not seen as distinct by them. This ultimately
 leads to a very coherent and simple system.
3. Daemons, or servers, allow for higher end programs to interact with
the system without having to reinvent the wheel. For example, a daemon for
audio will provide the audio service to all high end programs that require
it. As a result, those programs don't have to DIY interact with the
audio device on their own individually, since there is already a program
specialized in that. This leads to a better development environment for
programmers, but also to fewer lines of code and less memory/CPU usage.
4. User freedom to tinker and change the system.

Today.  Back in the day when the Unix philosophy was first developed,
it was almost necessary to abide by it, as a result of computing
limitations. This isn't the case anymore. With such computer power
increase, the Unix philosophy is something you need to stick with. It
is hard to not add features. It is hard to not create an over-bloated
feature-creeped monolith of an application. The ignorance and disregard
of the Unix philosophy can be felt all around us. The modern web is a
great example.

Many argue that it is obsolete. Computers are no longer as limited the way
they used to be 50 years ago. It is [CURRENT_YEAR], when will you finally
stop the Unix larping? Let's just be a wholesome egalitarian community
where everyone can program without meritocracy and mean criticism. You
don't understand - I don't have to run minimal programs, I have 16 gigs
of RAM. Just get a newer computer.

Here are some hard pills to swallow: Computer power will not always
keep increasing - it has already started to stagnate. On the other
hand, software keeps getting more and more complicated, more and more
bloated. How long do you think we can keep adding more to the bloat
until we reach the limit of computing ability? For how long will we
have to throw away fine machines to junkyards because they cannot keep
up with with huge badly-written programs? How long until we run out of
resources to create newer hardware? The reason your computer has 16 gigs
of RAM and a great processor is because it has to keep up. It shouldn't
need it! These are resources that could be used in much better ways
than to fill up the consumerist mind. Not just for the hardware, but
for electrical power too. Security is a whole issue different issue by
itself. The number of bugs in a piece of software is directly related to
its SLOC and its complexity. Complex, bloated software is by definition
more vulnerable and a danger to our security and privacy. If we had
abided by the Unix way, the world would be a better place.

Recommended reading: The UNIX programming environment by Brian Kernighan
and Rob Pike