Richard Gabriel

This is good advice. Programmers and writers need to fall in love with language, learn to think logically, and come to terms with classical rhetoric. Dick Gabriel is a master of all three. Read his essays at http://www.dreamsongs.com. Read his book Patterns of Software book, inspired by the work of Christopher Alexander.

Lucid tried it with C++/Energize. Sank the company. Nope, it turned out the "business" person/people who arranged the contracts for OEM sales of Lucid's Lisp did them as essentially loans, against the OEM's actual sales as I recall, and when they came due Lucid's investors felt that the success of Energize was sufficiently iffy the extra investment was not worth it. Details can be found on Richard Gabriel's web site: http://dreamsongs.com/ In general my take on what happened is somewhat different. It starts from the observation that when the Lisp Machine was developed, there was a great deal to be said for a custom TTL processor laser focused on Lisp. It was a good way to squeeze a lot of performance out of the available technology, pretty much the only way unless you were crazy enough to try to do it in ECL. And people could see the utility of what became the engineering workstation from the success of Xerox's Alto (which added graphics to NLS). As it became practical to put enough gates on a single chip for a Lisp Machine, it would have taken a great deal of adroitness to make the transition, and that wasn't in the cards. LMI didn't have the capital to do so, in fact, TI bailed them out and invested in them just to keep the company alive so they could do their own gate array Lisp Machine, the TI Explorer. Don't know what happened with TI, but LMI was eventually killed by Canadian politics. Symbolics was very badly managed by then, and continued to make a number…

A Pattern Language is often a required text for at least one studio course in US architectural schools. There are, however, practical issues with Alexander's approach at a professional level. Some are perhaps subtle to a layperson - most architectural projects are typically driven by the client's commercial concerns, e.g. a firehouse apparatus bay is designed for trucks not human habitation and a restaurant is designed to turn over customers not cause them to linger for six hours. On the other hand, some are obvious - planners do not have the ability to limit existing communities to a few thousand people. This isn't to say that Alexander cannot inform a design. In fact, many architects look at his work during the process. But the kind of project which will look like the images in his book is rare simply because many of these patterns are best implemented "at run-time" by the user, rather than at "compile time" by the architect or planner. Finally, I would say that what the programming community got from A Pattern Language is not Christopher Alexander, but Richard P. Gabriel. [http://www.dreamsongs.com/]

Won't argue with that, but it's a classic example of "Worse is better" [1]. It was simple and "good enough". Being ubiquitous is often more important than being efficient. Most of the arguments for using HTTP reverse proxying over FastCGI or SCGI came down to ubiquity. It let you do things (like connect directly to your app servers with a web browser) that you couldn't do with FastCGI. [1] https://dreamsongs.com/RiseOfWorseIsBetter.html

Richard Gabriel wrote a famous essay Worse Is Better (https://www.dreamsongs.com/WorseIsBetter.html). The MIT approach vs the New Jersey approach does not necessarily apply to the discussion of the merits of coding agent, but the essay's philosophy seems relevant. AI coding sometimes sacrifices correctness or cleanness for simplicity, but it will win and win big as long as the produced code works per its users' standards. Also, the essay notes that once a "worse" system is established, it can be incrementally improved. Following that argument, we can say that as long as the AI code runs, it creates a footprint. Once the software has users and VC funding, developers can go back and incrementally improve or refactor the AI's mess, to a satisfying degree.

If you're trying to connect Alexander to software patterns like GOF, it's important to include Gabriel's "Patterns of Software" [1] as the first genuine attempt to apply Alexandrian patterns to software. It also introduces the first and probably the best takedown of OO inheritance as not reuse but instead a form of _compression_ that is in many ways worse than just copy-and-paste. 1 - https://www.dreamsongs.com/Files/PatternsOfSoftware.pdf

I love Richard Gabriel's writing. "The Structure of a Programming Language Revolution" (https://www.dreamsongs.com/Files/Incommensurability.pdf) is both insightful and beautiful.

The issue is, whats the alternative? People are generally bad at predicting what work will get broad adoption. Carefully elegantly constructing a project that goes nowhere also seems to be a common failure mode; there is a sort of evolutionary pressure towards sloppy projects succeeding because they are cheaper to produce. This reminds me of classics like "worse is better," for today's age (https://www.dreamsongs.com/RiseOfWorseIsBetter.html)

OS/2 was better, but so was NeXTSTEP, AmigaOS 2.0, and BeOS, BSD386, IRIX, and so on. Windows could have competed with merit only with GEOS and might have lost. Windows 3.0 ... 3.11 was objectively the worst UI and or OS at the time. Then Windows 95 made minimum improvement, still behind everyone worth mentioning. https://www.dreamsongs.com/WorseIsBetter.html

I love The Rise of Worse is better, and this sounds just like that: https://www.dreamsongs.com/RiseOfWorseIsBetter.html It doesn't explain _why_ simple implementation is more important than having a simple interface, but it just makes an observation that simple implementation usually wins. In my experiments simple implementation won for velocity, because quite often I need to change small parts in all the implementation no matter how modular / reusable code I'm trying to write. As my velocity increases testing becomes more important as well (especially integration testing), as there are more features interacting in a small amount of code.

May as well complete the set: Is Worse Really Better? https://dreamsongs.com/Files/IsWorseReallyBetter.pdf Also: Nickieben Bourbaki might be an anagram of something, but it is definitely not an anagram of Richard Gabriel, with or without the P. There's no G, there's no h, there's an N and a k, it isn't even particularly close. That claim is my best interpretation of this sentence: > Same author (name is an anagram). Although perhaps it was not your intention to connect the clauses in that way.

That website's homepage really takes me back to the Old Web: https://www.dreamsongs.com

The phrase was made famous in an influential essay[0] by Richard P. Gabriel, where he laments Lisp's relative failure to compete with Unix. In Gabriel's opinion, Unix proved to follow the more adaptive design strategy in certain ways (in spite of his involvement with and admiration for Lisp), and the phrase "Worse is better" is meant to capture the essence of that advantageous strategy (as outlined in the essay). The essay is worth reading and is a bit more elaborate than just saying "less is more", or "keep it simple, stupid". [0] https://dreamsongs.com/WorseIsBetter.html

Open Nexus looks great! The UI design is super clean, and the open-ness of your nodes give it true Bret-Victor-ish vibes! I started closer to this at first (but still lower-level) and slowly got "down to earth", taking a https://www.dreamsongs.com/WorseIsBetter.html approach.

I recommend Richard Gabriel's essay "The End of History and the Last Programming Language", which you can find at https://www.dreamsongs.com/Files/PatternsOfSoftware.pdf . The point that stuck with me is "Languages are accepted and evolve by a social process, not a technical or technological one." But I should add that when he wrote the essay the last programming language was C.

This is still the best explanation IMO: https://www.dreamsongs.com/RiseOfWorseIsBetter.html

I think the "Worse is Better" essay captures it well https://www.dreamsongs.com/RiseOfWorseIsBetter.html Platonic ideals are great for thinking clearly. Doing things in the messy reality often requires compromising. It's impossible to solve all corner cases a priori...

You're right, but that's kind of the point of suckless. To them, we should all be using software that is small, self-contained, and simple in implementation; both GCC and Clang are too complex in that case. C++ itself sucks to them, so g++ and clang++ don't need alternatives anyway. Sometimes, it would mean separating what one piece of software does into many in order to replicate what that one complex thing does. I don't subscribe to their philosophy, by the way. "Good" software which is elegant and easy to use is often very complex in implementation. That philosophy is basically the "worse is better" philosophy: https://www.dreamsongs.com/RiseOfWorseIsBetter.html

Right. If you want something that has perhaps a more profound and interesting description of the open source model (as Zawinski would put it, the "CADT model"), it's worth going back to Richard Gabriel: https://www.dreamsongs.com/WorseIsBetter.html Gabriel's essay is cited in Raymond's article. It's interesting to compare them; Raymond claims that Gabriel anticipated much of what his article was going to say, but I think they have markedly different takes about it.

The Elm/React tradeoff recounted here feels a lot like a rerun of the classic Lisp/C "Worse is better" story. https://www.dreamsongs.com/RiseOfWorseIsBetter.html

This is excellent advice. The "worse is better" manifesto says similarly: > The lesson to be learned from this is that it is often undesirable to go for the right thing first. It is better to get half of the right thing available so that it spreads. https://www.dreamsongs.com/RiseOfWorseIsBetter.html

Tying this insight back to a popular and insightful HN trope: https://dreamsongs.com/WorseIsBetter.html

I appreciate the irony, but the kind of AI that Lisp was designed for (i.e. automated reasoning, expert systems, etc) is really not the same as the kind of AI that we have today. The AI we have today is very much a "worse-is-better" [1] AI. There's no elegance. No craftmanship. Just scale and raw power. And just like worse-is-better programming languages conquered Lisp, worse-is-better AI approaches conquered the classical approaches that were pioneered along with Lisp. It might be ironic, but I don't see any particular contradiction in saying that worse-is-better AI magnifies the advantages of worse-is-better programming languages. [1]: https://www.dreamsongs.com/WIB.html

Counterpoint regarding C and C++ is the famous “Worse is Better” essay by famed Lisp hacker Richard Gabriel: https://www.dreamsongs.com/RiseOfWorseIsBetter.html C was the implementation language of AT&T Unix. The operating system spread across universities in the 1970s due to AT&T’s inexpensive licensing to them, including source code. Unix, though its variants and clones, became the dominant operating system with most competitors either dying out or adopting Unix. Both C and C++ also had the benefits of being the “blessed” languages of Windows (for example, Win32 is a C API, and MFC is a C++ API). Even in the days of the classic Mac, while Pascal was originally the language of choice, eventually in the 1990s C would be “blessed” by Apple.

Tempered tuning is a great example of "worse is better"(1) (including the part where "worse" winds up being "better" for various cases). When making an instrument, every interval between adjacent notes has the ratio of (12th root of 2). And it allows the musician to play any mode almost perfectly. (1) https://dreamsongs.com/RiseOfWorseIsBetter.html

This article, and all the ones like it, remind me of Worse is Better. Specifically, the key point from that essay is: "The lesson to be learned from this is that it is often undesirable to go for the right thing first. It is better to get half of the right thing available so that it spreads like a virus. Once people are hooked on it, take the time to improve it to 90% of the right thing." This post concedes that point in the first couple of paragraphs. Much like C and Unix-like systems, this is why React isn't going anywhere. Indeed not based on the competition it has now. The best its competitors can do is convince React to steal their ideas and keep pushing toward doing 90% of the right thing. [1] https://www.dreamsongs.com/RiseOfWorseIsBetter.html

https://dreamsongs.com/Files/PatternsOfSoftware.pdf is a great read that cites Alexander's work and talks about how that influenced OO design. Very accessible too

> He is a building architect that greatly influenced how people think about Object Oriented Programming (http://www.patternlanguage.com/archive/ieee.html) The funny part about this speech is that he's just telling everyone they did it wrong, and Richard Gabriel agrees: https://dreamsongs.com/Files/DoingItWrong.pdf The point of his pattern language is to enable people to create their own architecture for their own needs. The point of OOP design patterns is to lock you in a prison of enterprise Java programming in the Kingdom of Nouns. Of course, I think everyone realized this like a decade ago.

This essay contains the famous "Worse is Better" section, made popular by Jamie Zawinski https://cs.stanford.edu/people/eroberts/courses/cs181/projects/2010-11… Summarized as: "When tradeoffs are required in a software system, priority should go to implementation simplicity at the expense of completeness or correctness." See also the wikipedia article: https://en.wikipedia.org/wiki/Worse_is_better An interesting aspect of all this is that Gabriel argues with himself in a series of papers under a false name: https://dreamsongs.com/Files/worse-is-worse.pdf A great example of someone looking at both sides of an argument.

This smells a lot of the classic "Worse is Better" discussion [0]. Back then, it was Scheme people insisting on correctness and C people insisting on pragmatism. It's no surprise to me that Rust, a language with a heavy focus on correctness, attracts the correctness-over-pragmatism crowd. The author is a "worse is better" programmer who finds themselves surrounded by "the right thing" people. I think the addendum the author adds a year later in the top comment is the right insight: fork away. This keeps the "the right thing" people happily obsessed with getting everything right, without the author being blocked on moving faster. [0] https://dreamsongs.com/RiseOfWorseIsBetter.html (1991)