Richard P. Gabriel, in his essay “The Rise of Worse-is-Better,” expounds on this theme (see Appendix A). His thesis is that the Unix design philosophy requires that all design decisions err on the side of implementation simplicity, and not on the side of correctness, consistency, or completeness. He calls this the “Worse Is Better” philosophy and shows how it yields programs that are technically inferior to programs designed where correctness and consistency are paramount, but that are evolutionarily superior because they port more easily. Just like a virus.
The highest achievement of the Unix-aesthetic is to have a command that does precisely one function, and does it well (…) This philosophy, in the hands of amateurs, leads to inexplicably mind-numbing botches like the existence of two programs, “head” and “tail,” which print the first part or the last part of a file, depending. Even though their operations are duals of one another, “head” and “tail” are different programs, written by different authors, and take different options!
That head/tail thing is kind of a goofy argument. For one thing they aren’t duals; tail is naturally more complex because the end of a file often changes and the application can optionally keep showing you the new output. Also, the fact that they’re separate applications in the first place is arguably better than the a one-application approach, which would always require a command line switch to select between outputting the start or end of a file. And finally, while I guess this could vary between implementations of head and tail, mine has identical switches for all the common options.
They could have been two commands that call a single parent command with different options. For example, imagine if cat had an option -N to restrict the number of lines that was printed, and also an option -t to start from the end. head would just proxy to cat -N and tail would proxy to cat -N -t. Combining the three into a single implementation reduces total LoC and opportunity for bugs. Also reduces total maintenance burden.
I believe busybox is like this actually - a ton of Unix commands in a single package. It’s used by Alpine Linux, a tiny and performance linux distro commonly used by docker containers.
The way they do it is fundamentally different. Head just reads until number of newlines is the target number. Tail has to first read the entire file and keep a buffer of the file and/or offsets for each line ending to determine what the last 10 (or so) lines are.
This idiot (Gabriel) probably thinks exclusively in the real world paper line analog.
I also just looked at each program’s command line options and they’re identical. Less things only Tail can do (because they’re fundamentally different operations)
This idiot (Gabriel) probably thinks exclusively in the real world paper line analog.
Typical of Internet discourse to just immediately brand someone you disagree with an idiot… That “idiot” is one of the designers of common lisp, among other things. You’re allowed to disagree with a smart person too you know
From The Unix Hater’s Handbook
(I like Linux, but it’s not all sunshine and rainbows)
That head/tail thing is kind of a goofy argument. For one thing they aren’t duals;
tailis naturally more complex because the end of a file often changes and the application can optionally keep showing you the new output. Also, the fact that they’re separate applications in the first place is arguably better than the a one-application approach, which would always require a command line switch to select between outputting the start or end of a file. And finally, while I guess this could vary between implementations ofheadandtail, mine has identical switches for all the common options.They could have been two commands that call a single parent command with different options. For example, imagine if
cathad an option-Nto restrict the number of lines that was printed, and also an option-tto start from the end.headwould just proxy tocat -Nand tail would proxy tocat -N -t. Combining the three into a single implementation reduces total LoC and opportunity for bugs. Also reduces total maintenance burden.I believe
busyboxis like this actually - a ton of Unix commands in a single package. It’s used by Alpine Linux, a tiny and performance linux distro commonly used by docker containers.Busybox is literally just a bundle. That’s its whole purpose. It doesn’t reimplement anything.
The head and tail programs also do completely different things. What differences in options do they have?
Really completely different? Do they not print first / last lines of text from a file into the terminal?
The way they do it is fundamentally different. Head just reads until number of newlines is the target number. Tail has to first read the entire file and keep a buffer of the file and/or offsets for each line ending to determine what the last 10 (or so) lines are.
This idiot (Gabriel) probably thinks exclusively in the real world paper line analog.
I also just looked at each program’s command line options and they’re identical. Less things only Tail can do (because they’re fundamentally different operations)
Typical of Internet discourse to just immediately brand someone you disagree with an idiot… That “idiot” is one of the designers of common lisp, among other things. You’re allowed to disagree with a smart person too you know
OK. Designers of programming languages can be idiots.
Lisp is a bad language IMO. Way too mathy. Nobody programs like that anymore for a reason.
“This program sucks because it doesn’t come with the world’s most confusing GUI and doesn’t do a trillion things”
If you ask this person what “technically inferior” actually means you’d probably get a different answer every day.
GUI certainly has its place.
Yes and so do simple CLI tools that work. Head and Tail are about the worst examples because they work very well and also do very different things.