As the GNU coding standards say:
> Avoid arbitrary limits on the length or number of any data structure, including file names, lines, files, and symbols, by allocating all data structures dynamically. In most Unix utilities, “long lines are silently truncated”. This is not acceptable in a GNU utility.
This never really clicked with me because I didn't live through a time when my primary Unix utilities weren't robust. The closest I got was using old (1990's) HP/UX and Solaris and AIX systems where the sysadmins had installed the GNU tools already. All I knew is that I shouldn't use the system tools, because they were worse.
Personally, I think what helped Unix succeed is that the implementations were bad but the architecture made it (mostly) possible to improve the implementations piecemeal. Accordingly, the parts that have had the most trouble improving (like X11, and C) are those where the design doesn't allow this.
What helped Unix succeed was that originally Bell Labs wasn't allowed to sell it, so they gave it to universities for what was a symbolic price in comparisasion what a standard OS used to cost, alongside its source code.
So naturally many stundents from those universities went out and started businesses based on UNIX, like Sun for example.
One of the reasons behing the BSD lawsuit was that AT&T got the license to charge for UNIX after Bell Labs was broken down into smaller units and they were trying to kill off those free branches.
People have a tendency to gravitate towards free stuff regarless how bad the quality happens to be.
AIX, non-free, was notoriously horrible, too.
And the Wirth systems that you promote here were actually free.
So what exactly is the great stable commercial alternative in the 90s?
In the mainframe world, TOPS-10/20 and VMS were both exemplary. From the user POV, the former was one of the best command-line systems ever created, with none of the insane user-hostility built into UNIX command naming. Dave "VMS -> NT" Cutler absolutely hated Unix, and it shows.
But we're really comparing cinder blocks and potatoes. UNIX was designed as a hobby/student hacker tool, not as a general user OS. Many of the design choices are bizarre and frankly stupid, as the book delights in pointing out. But hackers love UNIX because using it just it feels just like hacking code, and that's considered a good thing.
It wouldn't be impossible to design an OS with powerful command line options but a sensible command naming system, much more intelligent and reliable security, a modern filesystem, and so on - and perhaps add some of the user configurability and extendability of the Lisp/Smalltalk/Hypercard(?) world.
But UNIX is so embedded now it would be a purely academic exercise.
I guess I'm less pessimistic, because I don't think that's true. I think there are quite a few people like me who are fed up with the shit that exists today and really want a good alternative. I think we'd be willing to make quite a few sacrifices for something with a whole lot of potential.
What seems to be true is that there are very few people both capable of making that happen and bold enough to try to make it something people can actually use instead of just a toy academic project.
OS/2 was pretty solid...
Workplace Shell was so cool though.
Of course OS/2 was later severely hampered by its inability to run Win32 apps, but that's another story.
In fact, GCC only got traction after Sun introduced the idea in the UNIX world of selling the developer tools instead of bundling them wiht the OS.
Back in 1994 the Wirth systems were mostly only available at ETHZ.
Had Linux not come up into the scene, with the ongoing BSD lawsuit, and the UNIX landscape would have looked much different nowadays.
[1] - "free" here meaning several factors cheaper than buying a VMS or OS/360 timesharing system for the university campus.
Where does the MS operating system fit in here? Arguably the worst general-computing OS, but by far the most popular. For purpose of discussion, do you consider it free due to being widely pirated?
I'll say that the developer experience on Windows was excellent around the 1995-2005 timeframe. But the user experience was horrible, yet it remained an almost monopoly on the desktop.
Obviously it’s great in a VM!
Regular consumers just handle their computers like appliances, getting a new one with whatever OS it gets bundled with.
The monopoly worked both ways, any OEM was free to ditch Microsoft agreements, they just cared to improve their profits by getting into bed with Microsoft.
But lately I’ve been studying systems that for whatever reason ended up losing out in the marketplace despite having really interesting design decisions and features that would be welcome today. Although I like the classic Mac OS, NeXT, and the modern macOS, I wish Steve Jobs would have “copied” all of Smalltalk and then added Mac-like touches to it. I also wish that Genera were open-sourced instead of the current situation where it’s difficult to obtain legally and inexpensively. I have a dream of writing a modern OS inspired by Genera, Smalltalk, and Apple’s OpenDoc, but writing a new OS is a major undertaking.
Maybe it’s my inner romantic speaking, or maybe I’m just drawn to beautiful things, but I’ve always been attracted to “what could have been” things. Hopefully one day we’ll have a “right thing” OS again, and maybe one day we’ll have an alternative to the Web that isn’t as much of a technology hodgepodge.
But then a rich library at university campus opened my mind to other models of computing and sundenly pure old UNIX wasn't that interesting any longer, only NeXT, which used UNIX compatibility more for winning over Sun's customers than anything else.
And there were mechanisms for an OpenDoc-like system of embedded content (maybe more like OLE). While the rough idea of OpenDoc was and is appealing, I don't think that version of the idea is actually tenable.
Alas, since it was killed, it sort of lives on and occupies that space as an ideal version of the rough idea, rather than as an artefact that can be criticised and improved upon.
25 years ago. Who the hell does that?
I heartily recommend his other writings. In fact, he considers "Worse is Better" some of the worst of his writings, and it is the most successful. ¯\_(ツ)_/¯
Just one that I've gotten a lot of mileage out of is "Habitability and Piecemeal Growth" in Patterns of Software. Lots of other gems in there: Reuse vs. Compression, The Quality Without a Name, etc.
EDIT: Forgot the link
This all happened before my time, but having read a lot about the Lisp Machine I'm as interested in the what-ifs of history if it had won out as the next guy.
I wonder though how much of the legitimate sentiment in this book is simply raging against a machine that's successful and installed in production.
Given widespread commercial use a system where you could modify the running Lisp code of any program down to the kernel would have had its own nightmare stories of sysadmins monkeypatching things in production, and e.g. the perceived shittyness of NFS being replaced by some Lisp-native system where you sent serialized Lisp objects for your program over the wire, with corresponding upgrade hassles if you needed to upgrade a client/server pair.
Plus it's too easy to "reinvent the language" in Lisp. In C-based languages, the block structures (if, while, try, etc.) are pretty much hard-wired into the language so they stay consistent. In Lisp, one can roll their own. It's great if you are the lone reader: you can customize it to fit your head. But, other readers may not agree with your head's ideal model, or learning it adds to the learning curve of a new shop.
There isn't even a token to read in C. You have to infer what it is by parsing the thing in your head. Well, our visual systems have no problems doing this.
The C function definition doesn't have an operator which would help me to identify what it actually is.
float square ( float x )
{
float p ;
p = x * x ;
return ( p ) ;
}
(defun square (x)
(* x x))
Or with types/classes:
(defmethod square ((x float))
(the float (* x x)))
The names and lists may not tell you much, but to a Lisp programmer it signals the operation and the structure of the code, based on typical code patterns.
Once we learned basic Lisp syntax this is the usual pattern for definitions:
<definition operator> <name of the thing to be defined> <parameters>
<body of definition>
<define function> <name of function> <parameter list>
<declarations>
<documentation>
<body of definition>
> block structures (if, while, try, etc.) are pretty much hard-wired into the language so they stay consistent
These are also hardwired in something like Common Lisp. But the general language is differently designed. Common Lisp has relatively few built-in basic syntactic forms (around 30) and the other syntax is implemented as macros.
> It's great if you are the lone reader: you can customize it to fit your head
Over the decades of Lisp usage a bunch of conventions and some language support for common syntactic patterns have emerged. It is considered good style to follow those patterns.
> But, other readers may not agree with your head's ideal model, or learning it adds to the learning curve of a new shop.
That's the same problem everywhere: the new control structure implemented as a Lisp macro is the new control structure in any other language implemented by a bunch of different tools (macros, preprocessor macros, embedded languages, external languages, a web of classes/methods, a C++ template, ...).
If you add a new abstraction, there is always a price to pay. In Lisp the new language abstraction often gets implemented as a new macro and may hide the the implementation behind a more convenient form.
It still stands that "}" indicates larger-scale structures than ")" in C-like languages. Lisp has nothing equivalent, and I find a visual way to identify forests versus trees without first reading text is quite helpful. Your eyes may vary; everyone's head works differently.
But as evidence people agree with me, lisp had roughly 60 years to try to catch on as mainstream. It didn't. Nothing had more opportunities. If you don't win any beauty contests after 60 years, it's time to admit you are probably ugly to the average judge.
prog, let, defun all indicate block structures.
> Your eyes may vary; everyone's head works differently
No, it's just training. You are just unfamiliar with Lisp code. After a few days training, you should have little problem reading Lisp code. It's like bicycle riding: people can't believe that it is possible to balance it, but after a few lessons it's no problem.
That's an old saying:
'Anyone could learn Lisp in one day, except that if they already knew Fortran, it would take three days.' (Marvin Minsky)
Here we are 25 years later and now UNIX is the "good" OS.
The horror.
-Chris
Unfortunately Procyon Common Lisp was taken off the market, when it was bought by Franz, Inc. They used the Windows version of Procyon CL as kind of a starting point for their Windows offering of Allegro CL, IIRC.
From Symbolics (Overview + Technical Summary):
http://bitsavers.informatik.uni-stuttgart.de/pdf/symbolics/h...
http://bitsavers.informatik.uni-stuttgart.de/pdf/symbolics/3...
Texas Instruments, Technical Summary
http://bitsavers.informatik.uni-stuttgart.de/pdf/ti/explorer...
Xerox Interlisp-D Friendly Primer
http://bitsavers.informatik.uni-stuttgart.de/pdf/xerox/inter...
Too complex and takes too long to deliver.In the end, the winner takes it all.
And still miss my Lisp Machine. It's not that Unix is really that bad, it's that it has a certain model of computer use which has crowded out the more ambitious visions which were still alive in the 70s and 80s.
Much as the web (the Unix of hypertext) crowded out the more ambitious visions of what computational media for intellectual work could be (see the work of Doug Engelbart and Ted Nelson). That's a bigger tragedy IMO. Unix, eh, it's good enough, but the shittiness of the web makes humanity stupider than we should be, at a time when we can ill afford it.