Is The Unix Philosophy Still Important?

Today's video topic is "The Unix Philosophy". I often get asked about my thoughts on The Unix Philosophy, or what I think about certain pieces of software that violate the philosophy. Well, I've some mixed feelings on this.

WANT TO SUPPORT THE CHANNEL?

DONATE CRYPTO:
💰 Bitcoin: 1Mp6ebz5bNcjNFW7XWHVht36SkiLoxPKoX
🐶 Dogecoin: D5fpRD1JRoBFPDXSBocRTp8W9uKzfwLFAu
📕 LBC: bMfA2c3zmcLxPCpyPcrykLvMhZ7A5mQuhJ

DT ON THE WEB:

FREE AND OPEN SOURCE SOFTWARE THAT I USE:

Your support is very much appreciated. Thanks, guys!

[UltraZelda]

I always felt that the "UNIX philosophy" fits best on a lower level, especially individual programs at the command line. I don't think it applies quite as well to a GUI or GUI programs. The CLI features a ton of little, yet powerful programs, and they can be used and piped with each other... that, I feel, is the UNIX philosophy at its best.

[FennecTECH]

coreutils are individual programs. They dont violate the Unix philosophy. They are each separate programs that do one thing and do it well. It’s the miscilanous bits and bobs. “Core. Utilitie(s)”. They arent one big monolithic thing. If you have a busybox based coreutils. That does violate the philosiphy. They are just packed in a single package becuase they are really common stuff. It’s like the stuff thats at the bottom of every old lady’s purse. (Nail clippers cuticle scissors. Coins of various sizes and shapes Kleenexes an eyeglasses repair kit. They are each individual items that are useful on their own

[duncanw]

One of the worst violations of the UNIX philosophy in my opinion actually forms the _bedrock_ of modern GNU/Linux systems: GCC.

I recall hearing an anecdote that the FSF actually made the decision to make the divide between the backend IRs (GIMPLE &c, lower-level representations of computations that are language- and architecture-independent) and the frontends in a place where it was _almost impossible_ for anyone to replace the front or backend themselves, to prevent companies from exploiting the linkage exception in the LGPL to make proprietary compilers based on GCC.

While I understand the FSF's reasoning, this means GCC is _antimodular._ When you look at the unparalleled success of LLVM's approach in comparison on both performance and philosophical grounds (seriously, the difference between Clang single-threaded and GCC single-threaded on a recent HPC benchmark I ran was about the same as the overhead of running Clang OpenMP on a _single core_), it makes one wonder how much better free software could be if Stallman et. al. were just a touch closer to the BSD mentality.

[maxpolaris]

I think it's a great philosophy. It's a timeless philosophy. It's a personally empowering philosophy. It embraces KISS. I think we need it more now than ever before.

[mjdxp]

Yes, look at what the Web has become.

[shanent]

Coreutils is the embodiment of Unix philosophy. You can't care if people violate it if you don't even know what it is.

[salman-]

Unix philosophy is about making software easy and desirable from developers’ perspective, not the user. It’s all about the modularity really, and how easy it is to develop, debug, and change.

The minimal vs maximal application thing is another story, which is up to user preference and optimization between tradeoffs.

[FennecTECH]

The Unix philosiphy was what made gnu/linux possible. It allowed the replacing of components one by one so instead of working a whole OS they worked on one piece at a time.

[accountid]

GNOME perfectly adheres to the UNIX philosophy, it accommodates one workflow, and it does that perfectly, hence people complaining about how non customizable it is. Just because a program takes up a lot of RAM does not disqualify it from fitting the UNIX philosophy.

[johntilghman]

I think the whole 1 tool for 1 action was really applied to OS level command line tools for the most part. As for SystemD I have a huge problem with the politics and how the main author sees the community and the OS. Also, remember that this thought pattern came for the OLD UNIX days when there really wasn't a GUI bolted on top. I think Linux as an OS has moved on from that in some ways, but when you start scripting that 1 tool/action mindset makes things a lot easier.

[fisyr]

I think a very important part of Unix philosophy that wasn't mentioned in this video is to have a simple text output and where practical non interactive input.

I think lots of folks complaining about sustemd don't like the binary logs. I don't particularly care about the init system, because I never had to interact with it much, but I do like having a simple text output in programs: it makes scripting things so much easier.

[eliseuvideira]

Also you shouldve pointed out why the unix philosophy is important in the first place, its why unix itself was born, its a keep it straightforward simple OS compared to the feature rich large codebase multics that never really worked

[akashmanjunath]

hello DT :) You should start a podcast. You are good freestyle and also informative along with sharing your opinions.

[chrissaltmarsh]

Back in the day, 'do one thing and do it well' was very, very important. Computers just didn't have the oomph. Try paging a PDP11 which had 64KB of live memory. Now you get a million times as much for ten bucks.
Now, with shedloads of memory you can do it - and perhaps safer with more automated testing.
Except - hang on to one. Be able to pipe data from one to another (and tee it if needed). That's so powerful.
As for emacs, it's a great OS, just lacks a kernel. And a decent editor.
HAHAHAHA.

[DylanMatthewTurner]

Like you mentioned with Emacs, IDEs and Advanced Text Editors like Jetbrains, Eclipse, VS Code, Emacs, Vim, etc don't "do one thing, " but they're not necessarily worse off for it.
It's possible to go too far with features, for sure, and arguably, some of the ones I just listed can go too far, but to go too far the other way is also wrong.
The Unix philosophy mainly fits utilities and dedicated kinds of work, rather than all software.
It is useful for preventing scope tho, so I think you could revise the philosophy to be a little more general like instead of simply do one thing, maybe "fit one workflow." Yes, only put in what's necessary but recognize that it might be more than just ONE thing. Like some DEs for instance

[breadpirateroberts]

dunno. a lot of highly featured programs i would consider great and are basically indispensable for a lot of people. for example blender or krita. i would say practicality > philosophy when applicable (basically, the arch philosophy)

[keylowmike]

I probably echo what others have said, but I feel the Unix Philosophy is more of guidelines to follow and that "free as in freedom" philosophy is more the most important thing to follow.

[KevinBReynolds]

Very thoughtful video today DT. Good to think about. I agree with Jeffrey Bryant that the unix philosophy applies very well to the CLI. The rules have changed for a GUI. Change is good, especially when you know the history.

[DFPercush]

There is definitely a place for complex software like Blender that does a lot of things in the same space, but sometimes all you want is one little piece of it, and having to navigate that complex system to get the one thing out of it you need can be a burden. For example, KDE has a screenshot app called Spectacle. It's a moderately simple application, but it does have some extra features like cropping, annotations, and basic editing. Which is nice in some cases, but guess what, I don't want to stop what I'm doing every time I hit print screen to deal with that dialog, where I have to do about 6 to 8 clicks to actually save it. So I wrote 200 lines of C code to grab that key and the root window from the X server, and call libpng to save it to /tmp. Then I deal with them in bulk later. I think it's great that Spectacle exists, and I don't judge anyone for using it, but it's... more than I need, or want. It has the capability to perform the task I need, but no "quick" way of accessing that one small part.

[matidfk]

I think its a really useful concept to keep in mind when programming - it makes debugging a lot easier, imo makes code a lot more readable. obviously you cant apply this to everything, but using it where appropriate will save time