Richard Gabriel

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/]

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.

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

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.

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)