| One thing i think forgotten here, which actually is in the Worse is Better talk. But people tend to miss it. These ST and Lisps systems failed at another aspect. Reuse. The biggest change of the past 2 decades in software engineering compared to previous generations is the amount of reuse. It is tremendous. It is hard to talk of cause and effects here, but mostly this is due to the Internet. At this point, the vast majority of code running on any proprietary system is... Open source infrastructural packages. This condition a lot of the current ecosystem. You can only reuse code on systems in which said code runs well. As such, the Linux "stability" combined with x86 won, same as C and friends because of the tooling that made the code "portable". Yes i know. It is far from magically portable, but it is far more than full machine living image SmallTalk or Lisp like. As such, these "living code" are fundamentally evolutionary deadend. They are amazing but they cannot easily move to different machines and sharing parts of them is hard to separate from the rest of the living organism. On top of this, a lot of the elements to make this kind of machine works does necessitate deep in depth expertise. As the piece shows, the Newton is a pale copy of the goal because they did not have that knowledge in house nor the time (or money) to create it. Same thing all over the stack. A good efficient logger need deep expertise. Same for a good localization library. Same for a good set of graphic servers. Same for audio servers. Same for a http parser or a network library. A good regexp engine is knowledge knows by less than 10 people in the world probably. Once you realise that, you realise that at scale reuse is the only realistic way forward for software so ubiquitous as it is today. And that is how we got the current FOSS ecosystem, not because the code is better but because it would need too many licences to be manageable without breaking the bank in numbers of lawyers. Same thing for the Worse is Better. It works because it provides extension points and can adapt. Something the Lisp and SmallTalk machines fundamentally failed to provide. And that is something Richard Gabriel focuses on far more than the whole New Jersey schtick in his talk. |
The code of a Symbolics Lisp Machine is written in so-called "systems". A "system" is a collection of files in a directory. Moving the code to another machine is either a) a copy of the directories to another directory or b) dumping an archive to copy to somewhere else or c) most of the time not necessary, since the Lisp Machine edits files on NFS file servers , which makes it possible to share the Lisp code directly with other Lisp systems in the network.
The Symbolics keeps track of versions of files and systems, something other Lisp systems typically don't do themselves.
> As such, the Linux "stability" combined with x86 won, same as C and friends because of the tooling that made the code "portable".
There is little stability. The main theme is ever evolving fragmentation. Linux / BSDs is fragmented in zillions distributions, variants, versions, competing library variants, software archive systems, ... and open source UNIX is fragmented into various BSDs, Linux variants, ... Look at some portable code, it uses a huge configuration checker, which looks for all the variations of code and libraries. Zillions of checks...