13 May
2024
13 May
'24
12:18 p.m.
On Sun, May 12, 2024 at 11:23 PM markus schnalke <meillo(a)marmaro.de> wrote:
It depends on what the Unix philosophy is seen to be. If it is
solving problems by reading text from standard in and printing to
standard out, then that might not be suitable anymore for many of
today's problems. But if it is prefering plain text to binary,
perfering simple solutions to complex ones, increasing the number
of operations one can perform by combining small generic parts,
... all because of good reasons ... Focussing on simplicity,
clarity, generality ... Omitting needless words! ... All this still
holds true, no matter if applied as shell scripts or within the
design of a new programming language or a programming interface.
It's not so much about the tools we use -- these should be suited
for the times you live in and the problems you have to solve --
but it's more about how you look at them and how you look at the
problems and what ideas for solutions you can imagine in your
mind. Here, Unix provides a continuing inspiration.
Only, like with every old book: when we read it today, we have to
read it within the background of the times back then and transfer
its message to today's times. The older the book, the more transfer
work has to be done, the more knowledgable the then younger and
more distant readers have to be, to really understand it.
Thus, in my oppinion, the Unix philosophy remains a good and very
relevant fit today, although not all of its applications from back
then still are.
I agree, but it seems that most Unix developers haven't really cared
since the side branches and clones effectively took over from Research
Unix in the early 80s. They've added system calls and ad-hoc socket
RPC interfaces with abandon instead of using generic filesystem-based
extensibility APIs, added options to various commands that should just
have been separate programs, and written desktop
environments/applications that have poor composability, extensibility
and modularity (I guess KDE's KParts kind of counts as a mechanism for
composing applications, but it's limited by being based on plugins
rather than an open IPC-based API). The only Unix desktop I can think
of that really tries to follow the Unix philosophy somewhat is the
now-abandoned Étoilé <http://etoileos.com/etoile/>. There's also the
desktops of the rather obscure BTRON family
<http://tronweb.super-nova.co.jp/btronproducts.html>, although those
OSes are only vaguely Unix-like. Both have an object-centric rather
than application-centric model with support for embedding applications
within each other and controlling them with RPC APIs.
IMO, the best practical realization of the Unix philosophy for the
modern era would be a QNX/Plan 9-like OS with an Étoilé/BTRON-like
desktop, hence why I'm working on one. Some of the specifics of the
original Unix philosophy may not be relevant to large parts of modern
computing, but I'd say the general ideas still are.