Well, the 8-bits, Lisa, Macintosh, and Windows would have still been with us. So, I guess AT&T Sys V and BSD would have not happened which gets rid of Sun and makes one wonder what Dr. Tanenbaum and Mr. Torvalds would have worked on. I guess the second vector would have been what Steve Jobs would have built after leaving Apple (NeXTSTEP, the ultimate user friendly LISP machine?!?). Maybe Dylan would have worked in its infix form.
I would imagine that intelligent people would have worked at getting the same problems solved in a different form.
[edit] Instruction Sets from Intel, IBM, MIPS, Motorola would have been really different. Personally, I wanted the Forth machines to rule :)
Actually they were. The Interface Builder was sold also for the TI Lisp Machine - the TI MicroExplorer running in a Mac. Expertelligence developed the access to the Macintosh Toolbox for TI and also ported the Interface Builder to the MicroExplorer. Thus you could develop Mac-style user interfaces on the TI Microexplorer, including using the Interface Builder, which ran on the Lisp Machine and talked to the Mac for the UI display/interaction.
Here is a video which shows it running on a TI Micro Explorer, a Nubus Board in a Mac II.
I personally think it would have proceeded at a slower pace, and would have been more expensive.
The tradeoffs may or may not have been worth it, but there seemed to be an obsession with doing it Right rather than doing it cheap and quick. Even today it would be financially beneficial to buy a $70k workstation over a $2k workstation for a developer if there was a significant boost to productivity; each developer costs you well over $70k per year, and you can't double your productivity by hiring twice as many developers.
It takes a lot of attention to detail to make software like the lisp machines. Most free software projects stop at "Good Enough" so we end up with e.g. slime.
It is a bit more nuanced than that, ARPANet was a lot of DEC machines, USC and USC-ISI had a number of DEC-10's on the network. Usenet was however primarily a bunch of UNIX (or UNIX like) machines. They traded in their modems for nifty connections to the Internet and carried a lot of the same protocols with them. Much of the Internet protocols were developed in college labs with the ability to 'plug in' different UNIX configurations (the BSD sockets stuff) and since the code was tested well on UNIX was often the operating system on the machine that connected someone to the emerging Internet at the time. Lisp systems were popular for research, but were not used extensively for networking research. I expect it was in part a compatibility issue with BSD's socket stuff (where a lot of research was happening).
A more interesting alternate history for me would be if the folks doing system research had settled on a functional language like Haskell rather than a procedural one like C, what would our APIs look like today. I say that because I suspect that using C as a the language of choice was more influential than the OS of choice.
Lisp Machines were usually networked machines. Their were two branches:
* Interlisp-D from Xerox were smaller machines, networkd with a server + printer. PARC developed networked collaborative software for them, the first remote GUI was written for Interlisp, the first IMAP client was written for Interlisp-D, ...
* the MIT Lisp Machines were developed with CHAOS, an Ethernet-based protocol. TCP/IP was available early. Many of the TCP/IP protocols were implemented for them (often client and server): chat, terminal, mail, RPC, NFS, X11, DNS, HTTP, remote printing, remote booting, ... They also ran DECNET and some IBM network protocol. Actually the networking code from Symbolics was quite sophisticated in some respects...
BBN (the Internet company at that time) also used a lot of Lisp Machines. They had some distributed remote object networking substrate, which also ran on Lisp Machines.
Lucent had developed an ATM network switch, which first versions were based on multiple embedded Lisp Machine boards for the switching code and another Lisp Machine for the control and administration. They ran all kind of fancy networking code on them in a zero downtime fashion with live software upgrades. They were for example thought as large network and telephony switches.
One small correction: the D machines weren't all smaller; there was the Dandelion (later sold as the Star), the Dolphin and the Dorado (which was a full rack, the size of a 32-bit CADR machine, and built of ECL logic). There were at least three different standard microcoded environments you could boot with, Interlisp-D, Smalltalk and Mesa. When I was at PARC if I worked late I could connect to a Dorado, but most of the time I used a Dolphin (plus my group had some Dandelions which ran some custom microcode). They could also run Alto microcode by the way.
I preferred the MIT lispm environment better because I grew up with it. For a while I had a job where I had both a dandelion and a 3600 in my office; later I had two 36xx machines, one with a color display.
They were pretty fast for their time. The late, hyper-dynamic window system was probably too heavyweight for its time, especially when later translated over X, but I generally used the simpler base window system because it was faster.
It was the most productive (in terms of amount of useful code generated per unit time) system I have ever used and I still miss it. The Interlisp D, though quite different to use (and in some ways better), is a close second.
Right, but the large one weren't sold, IIRC. Xerox sold the smaller ones, not the Dorado. That was also why some users upgraded to the Lisp Machines from LMI, Symbolics and TI: they had larger address spaces and could run larger software.
> Lisp systems were popular for research, but were not used extensively for networking research. I expect it was in part a compatibility issue with BSD's socket stuff
They were not used for networking research, AFAIK, but Lisp Machines were definitely very well networked, speaking many protocols which soon came to include IP and TCP (though they started out with MIT's CHAOSnet). I was using Lisp Machines (both Symbolics and TI) networked with Sun 3s in the mid-to-late 1980s, and they definitely interoperated.
But I think that was a few years later than the networking research you're referring to, that created the Internet protocols.
The folks doing systems research weren't about to settle for something like Haskell, precisely because it's way too hard to do systems work in it. C is the way it is for a reason.
And a whole lot was done on PDP-10s, which were in many ways the first Lisp Machines. DEC asked various groups including AI researchers what they needed when designing the PDP-6, which was essentially the PDP-10 prototype, and its 36 bit word size (common back then, because that was enough to encode 10 decimal digits, the pre-computer standard for scientific calculations) was matched with a 18 bit word addressed address space, so one word could be a natural CONS cell, and there were useful instructions for that.
In the fullness of time, long after 1963, 18 bits of 36 bit words totaling 1 MiB of 9 bit bytes was crippling, but that much memory was at the time unimaginable. MIT's proposal some time later to have a full address space of memory built was a big thing, some said it couldn't be done.
Which gets into one big difference between Xerox PARC Altos and their software and UNIX(TM) for the first decade or so: they were seriously constrained by memory. Altos were 16 bit machines, also word addressed, so a total of 128 KiB, although they had a bank switching feature. The bigger PDP-11s had a split Instruction and Data (I&D) feature so that a program could have 64 KiB of code, and due to the MMU, 58 KiB of data and 8 KiB of stack, also for a total of 128 KiB, although you could get fancy with overlays as BSD 2.x did to support TCP/IP.
I believe this resulted in significant differences in software and system design, e.g. part of MIT's going for The Right Thing was using systems with large (for the time) address spaces. Whereas the smaller systems PARC and UNIX systems required more compromises, although occasionally that had good results, e.g. UNIX pipelines and the conventions that developed from them.
Lisp Machines would have become cheap. Similar software divergence would happen. There would be an increased separation from normal people and programmers. Lisp would become a serious thing used by all programmers.
Or maybe another thing like UNIX would've replaced Lisp Machines quickly.
