Why Did Symbolics Fail?
In a comment on a previous blog entry, I was asked why Symbolics failed. The following is oversimplified but should be good enough. My old friends are very welcome to post comments with corrections or additions, and of course everyone is invited to post comments.
First, remember that at the time Symbolics started around 1980, serious computer users used timesharing systems. The very idea of a whole computer for one person was audacious, almost heretical. Every computer company (think Prime, Data General, DEC) did their own hardware and their own software suite. There were no PCs’, no Mac’s, no workstations. At the MIT Artificial Intelligence Lab, fifteen researchers shared a computer with a .001 GHz CPU and .002 GB of main memory.
Symbolics sold to two kinds of customers, which I’ll call primary and secondary. The primary customers used Lisp machines as software development environments. The original target market was the MIT AI Lab itself, followed by similar institutions: universities, corporate research labs, and so on. The secondary customers used Lisp machines to run applications that had been written by some other party.
We had great success amongst primary customers. I think we could have found a lot more of them if our marketing had been better. For example, did you know that Symbolics had a world-class software development environment for Fortran, C, Ada, and other popular languages, with amazing semantics-understanding in the editor, a powerful debugger, the ability for the languages to call each other, and so on? We put a lot of work into those, but they were never publicized or advertised.
But we knew that the only way to really succeed was to develop the secondary market. ICAD made an advanced constraint-based computer-aided design system that ran only on Symbolics machines. Sadly, they were the only company that ever did. Why?
The world changed out from under us very quickly. The new “workstation” category of computer appeared: the Suns and Apollos and so on. New technology for implementing Lisp was invented that allowed good Lisp implementations to run on conventional hardware; not quite as good as ours, but good enough for most purposes. So the real value-added of our special Lisp architecture was suddenly diminished. A large body of useful Unix software came to exist and was portable amongst the Unix workstations: no longer did each vendor have to develop a whole software suite. And the workstation vendors got to piggyback on the ever-faster, ever-cheaper CPU’s being made by Intel and Motorola and IBM, with whom it was hard for Symbolics to keep up. We at Symbolics were slow to acknowledge this. We believed our own “dogma” even as it became less true. It was embedded in our corporate culture. If you disputed it, your co-workers felt that you “just didn’t get it” and weren’t a member of the clan, so to speak. This stifled objective analysis. (This is a very easy problem to fall into — don’t let it happen to you!)
The secondary market often had reasons that they needed to use workstation (and, later, PC) hardware. Often they needed to interact with other software that didn’t run under Symbolics. Or they wanted to share the cost of the hardware with other applications that didn’t run on Symbolics. Symbolics machines came to be seen as “special-purpose hardware” as compared to “general-purpose” Unix workstations (and later Windows PCs). They cost a lot, but could not be used for the wider and wider range of available Unix software. Very few vendors wanted to make a product that could only run on “special-purpose hardware”. (Thanks, ICAD; we love you!)
Also, a lot of Symbolics sales were based on the promise of rule-based expert systems, of which the early examples were written in Lisp. Rule-based expert systems are a fine thing, and are widely used today (but often not in Lisp). But they were tremendously over-hyped by certain academics and by their industry, resulting in a huge backlash around 1988. “Artificial Intelligence” fell out of favor; the “AI Winter” had arrived.
(Symbolics did launch its own effort to produce a Lisp for the PC, called CLOE, and also partnered with other Lisp companies, particularly Gold Hill, so that customers could develop on a Symbolics and deploy on a conventional machine. We were not totally stupid. The bottom line is that interest in Lisp just declined too much.)
Meanwhile, back at Symbolics, there were huge internal management conflicts, leading to the resignation of much of top management, who were replaced by the board of directors with new CEO’s who did not do a good job, and did not have the vision to see what was happening. Symbolics signed long-term leases on big new offices and a new factory, anticipating growth that did not come, and were unable to sublease the properties due to office-space gluts, which drained a great deal of money. There were rounds of layoffs. More and more of us realized what was going on, and that Symbolics was not reacting. Having created an object-oriented database system for Lisp called Statice, I left in 1988 with several co-workers to form Object Design, Inc., to make an object-oriented database system for the brand-new mainstream object-oriented language, C++. (The company was very successful and currently exists as the ObjectStore division of Progress Software (www.objectstore.com). I’m looking forward to the 20th-year reunion party next summer.)
Symbolics did try to deal with the situation, first by making Lisp machines that were plug-in boards that could be connected to conventional computers. One problem is that they kept betting on the wrong horses. The MacIvory was a Symbolics Ivory chip (yes, we made our own CPU chips) that plugged into the NuBus (oops, long-since gone) on a Macintosh (oops, not the leading platform). Later, they finally gave up on competing with the big chip makers, and made a plug-in board using a fast chip from a major manufacturer: the DEC Alpha architecture (oops, killed by HP/Compaq, should have used the Intel). By this time it was all too little, too late.
The person who commented on the previous blog entry referred by to an MIT Masters thesis by one Eve Philips (see http://www.sts.tu-harburg.de/~r.f.moeller/symbolics-info/ai-business.pdf) called “If It Works, It’s Not AI: A Commercial Look at Artificial Intelligence Startups”. This is the first I’ve heard of it, but evidently she got help from Tom Knight, who is one of the other Symbolics co-founders and knows as much or more about Symbolics history than I. Let’s see what she says.
Hey, this looks great. Well worth reading! She definitely knows what she’s talking about, and it’s fun to read. It brings back a lot of old memories for me. If you ever want to start a company, you can learn a lot from reading “war stories” like the ones herein.
Here are some comments, as I read along. Much of the paper is about the AI software vendors, but their fate had a strong effect on Symbolics.
Oh, of course, the fact that DARPA cut funding in the late 80′s is very important. Many of the Symbolics primary-market customers had been ultimately funded by DARPA research grants.
Yes, there were some exciting successes with rule-based expert systems. Inference’s “Authorizer’s Assistant” for American Express, to help the people who talk to you on the phone to make sure you’re not using an AmEx card fraudulently, ran on Symbolics machines. I learn here that it was credited with a 45-67% internal rate of return on investment, which is very impressive.
The paper has an anachronism: “Few large software firms providing languages (namely Microsoft) provide any kind of Lisp support.” Microsoft’s dominance was years away when these events happened. For example, remember that the first viable Windows O/S, release 3.1, came out in in 1990. But her overall point is valid.
She says “There was a large amount of hubris, not completely unwarranted, by the AI community that Lisp would change the way computer systems everywhere ran.” That is absolutely true. It’s not as wrong as it sounds: many ideas from Lisp have become mainstream, particularly managed (garbage-collected) storage, and Lisp gets some of the credit for the acceptance of object-oriented programming. I have no question that Lisp was a huge influence on Java, and thence on C#. Note that the Microsoft Common Language Runtime technology is currently under the direction of the awesome Patrick Dussud, who was the major Lisp wizard from the third MIT-Lisp-machine company, Texas Instruments.
But back then we really believed in Lisp. We felt only scorn for anyone trying to write an expert system in C; that was part of our corporate culture. We really did think Lisp would “change the world” analogously to the way “sixties-era” people thought the world could be changed by “peace, love, and joy”. Sorry, it’s not that easy.
Which reminds me, I cannot recommend highly enough the book “Patterns of Software: Tales from the Software Community” by Richard Gabriel (http://www.dreamsongs.com/Files/PatternsOfSoftware.pdf) regarding the process by which technology moves from the lab to the market. Gabriel is one of the five main Common Lisp designers (along with Guy Steele, Scott Fahlman, David Moon, and myself), but the key points here go way beyond Lisp. This is the culmination of the series of papers by Gabriel starting with his original “Worse is Better”. Here the ideas are far more developed. His insights are unique and extremely persuasive.
OK, back to Eve Philips: at chapter 5 she describes “The AI Hardware Industry”, starting with the MIT Lisp machine. Does she get it right? Well, she says “14 AI lab hackers joined them”; see my previous post about this figure, but in context this is a very minor issue. The rest of the story is right on. (She even mentions the real-estate problems I pointed out above!) She amply demonstrates the weaknesses of Symbolics management and marketing, too. This is an excellent piece of work.
Symbolics was tremendously fun. We had a lot of success for a while, and went public. My colleagues were some of the skilled and likable technical people you could ever hope to work with. I learned a lot from them. I wouldn’t have missed it for the world.
After I left, I thought I’d never see Lisp again. But now I find myself at ITA Software, where we’re writing a huge, complex transaction-processing system (a new airline reservation system, initially for Air Canada), whose core is in Common Lisp. We almost certainly have the largest team of Common Lisp programmers in the world. Our development environment is OK, but I really wish I had a Lisp machine again.
November 16th, 2007 at 1:38 pm
[...] got up from my desk to walk the dogs, and Dan Weinreb wrote another great post, this on on the history of Symbolics and why it [...]
November 16th, 2007 at 2:02 pm
Nice description of SMBX Dan. I still yearn for the days of developing Statice on my 3640 (my machine’s name was ‘Dove’ since we named all our development machines after birds). And I still believe that today’s IDEs are less than the Lisp Machine development environment. Re: Lisp language features: another great feature of that language is the ability to treat code as data (i.e. macros and backquote).
November 16th, 2007 at 3:43 pm
This is depressing because it reminds me how old I am. We had a Symbolics system at Combustion Engineering in Hartford back in the late 1980′s. It was next-level-sh*t at the time. We used it along with a much larger Calma setup.
November 16th, 2007 at 3:44 pm
These articles are fascinating; thanks for taking the time to write them for us.
On a completely pedantic front, you have a minor typo – The ‘of out’ in “So the real value-added of out special Lisp architecture was suddenly diminished.” probably was meant to be ‘of our’.
November 16th, 2007 at 4:04 pm
I have a Statice version on my Lispm rewritten in portable Common Lisp (and CLOS) (not by me). Maybe its time will come again.
November 16th, 2007 at 5:10 pm
Dan, interesting notes on the technology industry. Believing one’s own story is a hard pattern to break.
I have a quibble about your sense of history, though. You imply that Microsoft was not a factor before 1990, as Windows 3.1 came out then.
One of my college jobs in 1986 was supporting campus computing clusters. In 1986 we supported three user categories – Macintosh, PC, and Mainframe (VM 360). My parents had a PC for two years at that point, simply for word processing. I had a job that summer writing a graphical sound editor for the PC environment, and although windowing did not yet exist, I had a choice of several free or very cheap graphics packages for lines, arcs, text and mouse input. LISP wasn’t on the plate as an alternative – I was certain then that LISP was “expensive” and “fancy”, not something that would run on a cheap old PC, not something we could license for our computer labs. If I wanted to write software for the masses, C and Pascal were my choices, not LISP – and that choice was made on marketplace economics and marketing messages, and the availability of solutions, not the technical qualities of the language.
Today I write mostly in C, Java, and Perl. I still enjoy the “blunt hammer” of C, but continue to be flexible in my technology adoption.
If Sybolics had created a crash project for the PC and Mac in 1985, and distributed LISP development kits for very cheap during that time, would the market have turned out differently? I would argue yes. Most companies aren’t wiling to do the give-aways that create market share, simply out of stinginess. Often they spend their treasure fighting internal wars that become lost in the sands of time.
From your vantage point in the LISP community, it was likely you didn’t see the groundswell of the single-board based platforms, but by 1990, I already had 5 years experience writing software for PC environments, and had “shipped” three projects on PCs (all internal projects in academia). My one friend at Gold Hill was doing fun stuff, but it clearly had no traction, no relevance, and I wasn’t going to join them.
November 16th, 2007 at 5:41 pm
Data is not Code.
Microsoft has proven this beyond doubt.
November 16th, 2007 at 5:53 pm
Dan,
Thanks for your post. One thing… you make it sound as though workstations were a big surprise in 1980:
> …at the time Symbolics started around 1980, … The very idea of a whole computer for one person was audacious, almost heretical. … There were no PCs’, no Mac’s, no workstations….
> The world changed out from under us very quickly. The new “workstation” category of computer appeared…
But in fact Symbolics was part of the same trend as that workstation category. Not only had there been research work in this area for some years (Xerox Alto, 1973), but commercial products were showing up by 1980. Excluding the Imlac PDS-1 (1970), which was mostly used as a smart graphics terminal, not a standalone computer, Symbolics’ first commercial offering, the LM-2 (1981, MIT technology), was pretty much contemporaneous with three other companies’ commercial workstation offerings: Three Rivers (Perq, 1979, CMU), Apollo (Domain, 1981, Prime and MIT Multics alumni), and Xerox (Star, 1981, Xerox PARC). And of course some PDP-8s, PDP-11s, and DG minis were being used as single-user systems before that. I agree, though, that single-user home machines like the Apple II (1977) and Commodore PET (1977) were just hobbyist toys, not “serious”.
November 16th, 2007 at 9:10 pm
Footnote to last comment: http://www.blinkenlights.com/pc.shtml has an interesting survey of pre-1980 computers which could arguably be called “personal”.
November 16th, 2007 at 9:45 pm
I worked at General Dynamics in San Diego 87-89 on a Symbolics machine in an AI group. I still pine for those days. I was schooled in prolog and lisp but ended up doing neural networks. Even though I wouldn’t say it was a canonical language/system for that , it was still such a fabulous development environment. I still have yet to meet it’s match in general. I remember leaving GD in 89 and I had to program on a SUN and PC in C. I remember wishing I was dead. No longer could I debug on the command line and write code that interrogated it’s objects for their field names on the fly.
Many people at GD disparaged Symbolics but they didn’t know WTF they were talking about. The stuff they did in weeks I could do in a day. I would try and explain how and why the Symbolics was more productive but that was like trying to explain the city to a bunch of farmers (and farmers who were sure that the city had nothing to offer). That being said, I was in a machine learning R&D group which required lots of ideas to be tried quickly (RAD) as opposed to others who needed to deliver real-time (or close) code.
Furthermore, they hated the functional language style. It was totally alien to them and sometimes could be painful (and I damn well was not above using setq).
These days I use Matlab. The environment is, in some ways, like the Symbolics but it’s a math centric non-functional language. I have to say I’m not sure what I would, as a machine learning/vision engineer, do on a Symbolics that I wouldn’t do in Matlab.
So, I would say that in the end functional languages are not most people’s cup of tea, nor is buying a hugely expensive computer, and as most people still have to care about performance being delivered on cheap hardware (vs R&D) mean that the Symbolics concept was doomed.
But god damnit it was great.
November 17th, 2007 at 12:51 am
Interesting story re: SMBX. Thanks for sharing with us.
November 17th, 2007 at 4:05 am
Nice piece of blogging about a fascinating topic… I am only now, after a year of bit-by-bit getting around to it, writing Lisp functions & macros that are ‘my own creations’ (versus modifying others’ examples/code).
I can see how that hubris about Lisp came about & do find myself wondering why it’s not the first language we’re all taught… cultures work mysterious ways.
November 17th, 2007 at 4:17 am
[...] Why Did Symbolics Fail? « Dan Weinreb’s Weblog (tags: history lisp) [...]
November 17th, 2007 at 4:34 am
Another factor in Symbolics demise was a focus on the mainstream at the expense of the high end, high performance market. They wanted to be Sun.
In the beginning each new Symbolics machine was better and faster than the last generation. Then at their xenith, Symbolics devoted its resources to cheaper to build systems without any performance benefit. Several years of standing still made life very easy for Sun and Apollo.
It’s possible that going after the smaller but more profitable high performance market could have kept Symbolics at the forefront of an elite marketplace.
Shame. There are things in Genera (the Symbolics OS/Development Environment) which are only now becoming mainstream.
November 17th, 2007 at 12:16 pm
Mr Bulkowski: What I meant was the fact that Windows 3.1 didn’t come out until 1990 should remind everyone that Microsoft was not a factor affecting Symbolics then. Actually, re-reading Ms Philips, her sentence is in the present tense, and she’s surely right that Microsoft does not offer a Lisp product.
Hi Stavros! Yes, more accurately I should have said that a single-user computer powerful enough to do AI research (as opposed to the PDP-8′s and PDP-11′s) was novel. The Perq was novel at the same time as the Symbolics LM-2. Both made a spash at the IJCAI-81 in Vancouver (so did one other such machine, perhaps LMI’s but I can’t remember). We knew all about the Xerox PARC Alto (and owe a great debt to its ideas), but it was unknown to the general public, and not that powerful.
It was so funny at the IJCAI-81 when so many of the attendees mainly wanted to see the novel (to them) overlapping windows, whereas Howard Cannon and I were trying to demonstrate the real abilities of the system! The two machines (named Bulldog and Boxer, if I remember correctly) that we shipped to Vancouver were subsequently shipped to Fairchild’s AI lab, our very first customer shipment.
Eric: That’s possible. However, it was felt at the time that there just wasn’t that much more of the high end, high performance market available that would be interested in Lisp machines, in the context of those years. We knew that we’d never be Sun, but we wanted to have a product that would be attractive to VAR’s, in order to develop what I call the secondary market. (By “we” I mean “they”, as I was just leaving at this time; maybe other, later Symbolics people could comment.)
November 17th, 2007 at 2:29 pm
I just came across a wonderful quote from Joel Spolsky:
(http://www.joelonsoftware.com/items/2006/06/16.html)
—–
Watching non-programmers trying to run software companies is like watching someone who doesn’t know how to surf trying to surf.
“It’s ok! I have great advisors standing on the shore telling me what to do!” they say, and then fall off the board, again and again.
—–
Russell Noftsker was not exactly a hardware or software engineer, but he knew enough to understand what was going on, and when things got too technical he was very good about delegating, and trusting us. The subsequent CEO’s, unfortunately, neither understood what was going on nor trusted the technical people. Too many business school graduates really do believe that they can run anything, without domain-specific expertise; I’ve heard them say so. Perhaps that’s true outside of the high-tech world; I have no experience there. But for leading-edge technology companies, they’ll be in over their heads. And, being the type of people they are, they’ll never admit what trouble they’re in, to themselves or anyone else. The Board of Directors’ disastrous choice of new CEO’s badly hurt the chance that Symbolics would find a good corporate strategy, and was quite bad for morale, too.
November 17th, 2007 at 10:44 pm
This was fascinating to read.
You write, “Our development environment is OK, but I really wish I had a Lisp machine again.” I’d love to know what you’re using (the Allegro IDE? something in-house?).
November 18th, 2007 at 7:17 pm
I just came across another posting about why Symbolics failed, a somewhat different impression than mine, from Chris Stacey, who was at Symbolics after I left: http://bc.tech.coop/blog/040610.html. I think performance really was more of an issue than Chris does. The whole original justification for Lisp machines was that you could get much higher performance. In part, what happened is that the conventional-platform Lisps got better performance (especially on benchmarks) by turning off run-time checks, or by requiring a lot of type declarations. Nevertheless, the overall evaluation of the market was that it was not really mandatory to have a Lisp machine in order to run Lisp. We certainly feel that way at ITA Software, where I work now, though many of us miss our Lisp machines.
Eli, we currently use SBCL with SLIME under Gnu Emacs on Linux boxes. Some people are starting to take a look at “cusp”, the Eclipse plugin for Lisp, which uses some of SLIME’s technology (the “Swank” part).
November 18th, 2007 at 9:09 pm
Its interesting to hear you’re not using Mac OS X: Most hackers who aren’t into GNU/Linux for software freedom seem to have switched there. I wonder why you haven’t
November 18th, 2007 at 10:28 pm
I can’t help but wonder if the defeat of Symbolics and the demise of the Lisp Machine world was analogous to a (thankfully averted) Edison victory in the War of the Currents. (For those who have forgotten, read up on what New York looked like when DC was king.)
November 18th, 2007 at 10:39 pm
One of the most amazing thing about the Lisp Machines was the ability to view the source code of the entire operating system, UI, and applications and make changes to it … on the fly … with immediate results!
Linux and Eclipse have only one tiny facet of this magic. They both suffer from a great separation between the source code and the running program.
It also helped that there was an amazing amount of code sharing across the environment. If you altered the way editing worked, that change would be in your source code editor, command line shell, and most any place where input was requested. And much of the design of the code was oriented around open hooks for customization (which made it really easy to make certain classes of changes).
One can only hope that such a world will spring up again.
November 19th, 2007 at 3:05 am
In response to Eric Raymond’s most recent comment:
For better or for worse, I don’t think that here in the future, most people want the combination of flexibility and deep integration that you describe.
Theory: the Lisp Machines were built in the spirit of, and at the end of, a period of experimentation in computer systems. Sometime in the late 80′s, early 90′s, enough experiments had been run that a lot of things no longer needed to be flexible. Users — and there were more and more non-OS-hacking users — just wanted their filesystems, email, and applications to work. At that point, separation between code and running program became a virtue, not a liability. The fraction of users — even developers — that want the operating system to be mutable on-the-fly is vanishingly small.
This theory is based on speculation and second-hand information. In the late 80′s, I was in high school in Colorado. But as an MIT grad student in the mid 90′s, someone commented to me that because of the nature of code sharing on the Lisp machines, “you’d fix a regexp routine to make your app work, and NFS would mysteriously break.” (The commentator might or might not have been Patrick Sobalvarro. I wont pretend to have clear memories of offhand comments that long ago.)
All that said, there are clearly a good number of old-school alpha developers who miss the Lisp Machine development environment. Many of them clearly read Dan’s blog. To all of you — why do you think the environment isn’t missed by the world at large? Nobody ever says “Franz (or LispWorks) have finally surpassed the Lisp Machine environment” — what are they doing wrong? And — the loaded question — if you miss the development environment so badly, why haven’t you rebuilt it yourself, on top of the operating system of your choice?
November 19th, 2007 at 12:23 pm
Jeremy,
The most useful aspect of what Eric is mentioning is the ability to look around, even if you don’t make changes. I don’t just mean the source code. I mean that you could understand the state of the system. With my Windows PC these days, if it gets slow, I have no idea how to tell what’s going on. On a Symbolics machine it was always easy to examine the state of the system — it was very transparent. Admittedly a non-programmer wouldn’t be helped too much by this. But the Lisp machine was always primarily targeted at sophisticated software developers.
Sure, if you make a change to a shared, dynamically-linked library (like a Lisp function), you can break other things that depend on the library. That’s true in any dynamically-linked system. This problem has been well-understood since Multics. At MIT, I was taught about various theoretical schemes to cope with this — management of the mapping of library names to library instances to make sure everybody got the right version (avoidance of what is now sometimes called “DLL hell”) — although I’m not sure those schemes were ever implemented anywhere. Doing that for Lisp, or some future post-Lisp language, would be a good idea.
Why isn’t the environment missed by the world at large? Because it’s primarily targeted at sophisticated developers, which is only a small fraction of the world at large. And of those, many never heard of the Lisp machine, or could not afford one, or didn’t care for Lisp.
I haven’t used Allegro or LispWorks. They are said to have good tools, but since I don’t know the specifics, I can’t compare. The SBCL/SLIME environment that I use (and you used until recently) is a good step in the right direction, but I still don’t get nearly enough information in backtraces for some reason, and there are other inconveniences. I may soon have the opportunity to try Clozure Common Lisp (OpenMCL), which I’ve been told has some advantages at development time.
Why hasn’t anyone rebuilt it? Well, rebuilding the whole thing would be a vast job, and it’s not clear how you’d pay for the work. The open source community is doing a great job but there aren’t that many of them, and most of them are doing it “on the side” and have paying day jobs. Again, I can’t comment on Allegro and LispWorks. But having the whole system be transparent all the way down, so I can always see why my machine is slow, would require a new Lisp machine (even without special hardware).
Also, if we rebuilt it today, there would be much more to do. The most important architectural change I’d make would be to pay a lot of attention to security, along capability-architecture lines. See the security-related work of Mark S. Miller, as in the paper he recently delivered at the Dynamic Languages Symposium at OOPSLA-2007, for example; Howie Shrobe at MIT CSAIL also has a proposal along these lines although I can’t find it right now.
But would we really undertake again to build a software system with every single component brand new? An Emacs, a mail reader, a mail transfer agent, a DNS server, device drivers, window system, and now a web browser, a bittorrent client, a DVD player, and so on, not being able to take advantage of anyone else’s software components?
November 19th, 2007 at 3:20 pm
There is an interesting project out there which could be used to rebuild a lisp machine:
http://common-lisp.net/project/movitz/
I don’t think you would have to build all the different tools without being able to take advantage of existing code. There are Common Lisp implementations out there of some tools, but they don’t get any publicity to speak of.
November 19th, 2007 at 5:13 pm
It has been twenty years since I worked on a Symbolics and I’m still waiting for the current crop of technical development tools to reach the level we enjoyed in the Genera environment. I can understand why Lisp had problems gaining technical market acceptance (functional style – unique syntax). But there is no excuse for Java wining out over Smalltalk (which took the best of what was learned in Lisp / Flavors and used a straightforward syntax).
I was fortunate to be part of the excellent group at General Dynamics in San Diego (along with Andy Diamond) – well said Andy.
November 19th, 2007 at 6:02 pm
Well,some experimentation has ended. Unfortunately. Maybe we can say experimentation is difficult now? Maybe we can say that experimentation is done at the wrong level? Something in me says that the software I’m using is not done like I want it. It ‘feels’ wrong. What is it?
First let me say that I think people want to be involved in moving software forward. That’s very important for Linux (and related) and free software.
The most successful (IMHO) software is the one that is the one that enables a community to contribute to its design and its development. These communities need some direction and some structure, so they are not moving into random directions. It also needs a few experts at the core. People who preferably work full-time and really understand the software.
Software development on the application level is harder than it should be. Part of the problem is that the application might not be designed to be extensible, might be written in a way that is only accessible to experts or, even, the implementation is done in a more capable language than what you get for extensibility. Still the step from a user to a co-designer is very difficult to do.
Given that Windows and applications running under Windows are still on the majority of desktop systems, then right there is a huge barrier.
There is still a lot of programming done in what I would call dynamic languages. An estimate would be that this is about 40%-45% of all programming. Still most dynamic languages and environments are not used or are not usable on the system level.
I’d say Emacs is kind of an application platform for editor-based applications and tools (just see the large amount of extensions for Emacs – web browsers, maths, personal information managers. development environments, …). It survives because it has a community that can share and extend (see above) and it will be morphed into something that depends on its users and their needs. It also is sufficiently portable, so that it can be ported to new platforms without breaking the user-level software.
Now imagine for a moment that we would have a Lisp environment similar to Emacs, but with a little different focus. It would not focus on the idea of buffers with mode-based keybindings, but it would focus on a more GUI-like approach. It would have threads, a gui library, a simple data store and a good networking story. Now you could write GUI-based applications with it: a drawing tool, a newsreader, a database designer, a note pad, an outliner, an alarm clock, a to do manager, an electronic book reader, a mail client and so on. Wouldn’t it be cool to develop these things in a language that is: somehow ‘high-level’, interactive, descriptive, debuggable, usable for implementation AND extension? Wouldn’t it be cool if you as a user could contribute to such a thing and that you would not be using some compiled application that keeps you away from enhancing it? People can and do contribute to Emacs. Why shouldn’t they be able to contribute to something that has a slightly different focus, but is based on similar ideas?
Are ‘we’ satisfied with the status quo? Open source allows us to contribute. But do we like how its currently done? Checking in C code in repositories? Building static pyramids by pushing stones around?
When I was first reading the Byte issue on Smalltalk, I think in 1984, I was frustrated. I wanted to work in the area of software development. After looking at the article about Smalltalk 80, I thought, that’s it, the end to software. I give up! It has everything. No need for more. Objects, Interactivity, Networking, Editors, Development environment and all beautifully done. Who would need me now?
It took me some time to get over it. Lots of software has been written since then. Lots of things have been reinvented over and over. Some better, some worse. What should hinder me to reinvent things?
November 19th, 2007 at 7:38 pm
[...] Why did Symbolics fail? The MacIvory was a Symbolics Ivory chip (yes, we made our own CPU chips) that plugged into the NuBus (oops, long-since gone) on a Macintosh (oops, not the leading platform). Later, they finally gave up on competing with the big chip makers, and made a plug-in board using a fast chip from a major manufacturer: the DEC Alpha architecture (oops, killed by HP/Compaq, should have used the Intel). By this time it was all too little, too late. [...]
November 20th, 2007 at 11:35 am
Above I mentioned capability architectures. See my upcoming blog post, “XO: The Next Lisp Machine?” for a bit more about this topic. I hope to consolidate more info on capabilities and write a whole blog article about it, in the future.
November 20th, 2007 at 5:36 pm
BTW, I don’t remember exactly when the AXP mess started, but was it such a bad idea to use DEC Alpha, really? I think Compaq/HP have impressed us all with their mismanagement and stupidity. Who would have thought it would be that bad?
November 21st, 2007 at 3:40 am
Mr Davour: Sorry, I need to clarify what I meant here, since I said it in a way intended to be humorous/snarky. At the time, the choice of the Alpha made a great deal of sense. It was a very good architecture, it was fast, and it was a particularly nice target for various specific technical reasons. But in retrospect (in hindsight), it turned out to be a bad choice because of its fate in the marketplace, which could not have been anticipated by Symbolics at the time. My friends who were at Symbolics at the time this decision was made are invited to contribute at this point. I was gone then so I only know about this second-hand, mainly from my then and current co-worker, Scott McKay.
November 21st, 2007 at 2:05 pm
The main cause of Symbolics’ failure, as I remember it, was the announcement of a desktop version of the Lisp box that was a direct replacement of the existing 3640 product. The announcement was made while the new product was still in development, at least 6 months prior to it being available. The new product was announced as being far superior to the 3640 product and did not require a cooled computer room as did the 3640. Customers decided to wait for the new product resulting in very little revenue for more than 6 months.
Product design at Symbolics was driven by engineers with the focus of simply making the next best Lisp box. While Sun and Apollo, at the time, were creating product lines targeted at specific users, Symbolics only had one and it’s main competitor became itself.
November 21st, 2007 at 4:19 pm
No problem. As usual humour can work in mysterious ways in this medium.
I really wish the Alpha could have gotten more support from Compaq/HP.
November 26th, 2007 at 11:48 am
Software emulation of a lispm requires a 64bit computer, as Alphas are. Only now that Intel architecture is getting 64bit one can run Genera on a laptop (speed factor *0) so you don’t have to miss it …well, provided you have the corresponding licence (Let us know if Symbolics demands you).
SBCL on Slime is a good choice. Try also simple inferior-lisp-mode with a hack I wrote:
http://www.eurogaran.com/downloads/lisp/emacs/lispmstyle.el
and I bet you will feel at home.
December 6th, 2007 at 2:18 pm
Going back to the dispute with Richard Stallman, the number of people
claiming that Symbolics’ software was many years in advance of the
rest of the industry proves that Stallman was right: should the
Symbolics code have been free software, the world would have been able
to use it and improve it even after the crash of the company.
But it was closed and private code, and so disappeared, leaving
mankind with C and Pascal…
December 6th, 2007 at 10:33 pm
There has been talk of liberating the Genera sources from its current copyright holders by (or at least with the help of) former Symbolics employees. Does anyone know if this process is still ongoing?
December 7th, 2007 at 3:09 am
Yes, apparently the process of trying to liberate the Genera sources is ongoing. Unfortunately, the wheels of the law appear to grind exceedingly slowly. There’s nothing any of us can do now but wait while the people who are driving this continue to work on it.
December 12th, 2007 at 10:12 am
Phillips mentions twice that “object-oriented techniques” survived as a legacy of Lisp in environments where Lisp itself died out. I don’t see any evidence that Lisp had any role in the acceptance of OO. Simula was the first OO language, in 1968. It used GC, but was statically typed. Smalltalk appeared around 1972, also GC, but dynamically typed, maturing around 1980. C++ began around 1982, became the victim of extreme market hype around 1990, and matured in markedly different form 1998. Java sprang up in 1995, essentially C++ as it was in 1990 with GC pasted on. Of these, only Smalltalk owes anything noticeable to Lisp, but Lisp got what OO it has from Smalltalk.
OO itself turns out, in any case, to be much less interesting than was once commonly thought. In statically typed languages it offers a way to add some dynamism short of writing an interpreter, and in dynamically typed languages it helps organize a type system otherwise tending to chaos. Languages like C++ (in its mature form) and Haskell get much more mileage from compile-time type calculus. In Java, of course, it’s the only tool available, so everything is a nail.
December 31st, 2007 at 4:22 am
A few small points. One of the “secondary” markets where Symbolics
had some success was in the computer animation industry. In the peak
year (1985 I think) about half of the Siggraph film show was created on
Symbolics machines, and Symbolics Graphics Division was selling enduser
products to post production houses and TV stations.
I think you should differentiate to a greater extent between why
Symbolics failed and why Lisp failed. They are interrelated of course,
but IMO Symbolics as a company was doomed primarily by being on
the wrong end of Moore’s law, as were Perc, Apollo and any number of
other companies based on what turned out to be the wrong hardware.
Lisp would have fared much better if the language had ever developed a credible way to deliver bulletproof modular applications.
January 3rd, 2008 at 4:19 am
[...] love Paul Graham’s comment on Dan Weinreb’s Why Did Symbolics Fail? [...]
January 14th, 2008 at 8:58 pm
[...] long story short, the game changed and Lisp fell from prominence. A number of factors torpedoed the Lisp machine companies, the DoD pulled funding for AI research, better competing languages were [...]
January 18th, 2008 at 6:41 am
Posting in thread with ESR!
What do folks think of Scheme and its role in the LISP family of things. I’m kind of fond of Scheme, in that its nice and elegant, powerful, but perhaps a little easier on the initial learning curve. It sure seems a nicer way to learn programming than the current academic fad of torturing kids with Haskell (Not saying Haskells a bad thing, but oh my god does it make my brain break).
April 14th, 2008 at 7:05 pm
In 1984, the BBDO Business to Business Group in NY City won the Symbolics ‘advertising’ account and the agency team assigned suddenly became immersed in the alien culture (to the BBDO guys) that seemed to prevail at the spiffy new Corporate HQ in Cambridge, near Kendall Square. Our chief marketing liaison there (at first) had newly come from Wall Street, but our daily and weekly contacts were with a series of middle-level marketing managers who seemed to be different people every time we met in the Conference Rooms at Cambridge…even though they were appointed from the same set of players there…some with no marketing background at all, and one who seemed to have been a retired mercenary soldier who was a really scary guy. Internal intriguing and back-biting among them seemed to be a constant and it was very difficult for the BBDOers to come up with creative concepts for advertising because of the lack of consistent direction they were being given. An opulent national sales meeting at Port Saint Lucie, FL was totally chaotic, and the execution of Symbolics’ attendance at an important trade show at UCLA later in that year was even more so. Coincident with the latter, the marketing leaderperson was summarily canned because of some financial problem evidently unrelated to his Symbolics relationship. Those were not happy days for either Symbolics or for BBDO.
April 27th, 2008 at 6:52 pm
[...] ever created for developing in Lisp, but sadly died out quite a while ago (Dan Weinreb has described some of the reasons for [...]
April 28th, 2008 at 11:46 am
[...] above paper reference came from Dan Weinreb’s post Why Did Symbolics Fail? If you ever want to start a company, you can learn a lot from reading “war stories” like the [...]
April 28th, 2008 at 2:27 pm
Wait, wait, wait a second. I seem to remember a slightly different reason for Symbolics’ demise: they–along with a few other companies–were stomped in the marketplace by Sun. The mid-80′s were a time of fierce competition in the workstation market, and Sun was really good at bringing out hardware that was reasonably capable and remarkably cheap compared to their rivals.
Someone with a better memory please correct me, but I seem to remember that you could put together a nicely loaded Sun-2 (and later Sun-3) workstation for around $50K; that was pretty close to the starting price for a stripped-down 36XX series. You’d be looking at well over $100K for a Symbolics comparable to the Sun in terms of CPU speed, RAM, and disk space. (The Symbolics system did however include essentially the same hardware as a Sun-2 as a front-end for the Lisp engine.)
But the real trick wasn’t just comparing one box against another: for the same price as the Symbolics, you could buy one really loaded Sun (that could be used as a workstation-cum-server) plus a couple more stripped-down Sun workstations. And then you could network the Suns and have a complete environment for a small software development team–for the same price as one single-user Symbolics workstation. And if you added another coder to the team? You bought another $25K stripped-down Sun and hooked it up to the network. No such option with the Symbolics.
That’s the way I remember it. The company I worked for at the time did indeed buy a few Symbolics for a specific project, along with a few Apollos, etc., but mostly we–like many, many other companies–bought lots of Suns.
April 29th, 2008 at 10:32 am
JK: Yes, that’s what I’m trying to say above in the paragraph starting “The world changed out from under us…” and so on. Of course we knew all about Sun when they were emerging, but at the time we thought we nevertheless had a huge edge when it came to running Lisp, and that there would be a big demand for said premium.
June 27th, 2008 at 8:29 pm
All I know is that I still enjoy writing my Genera programs on my XL1201s at work. I can develop just about any application I try faster and better than anyone else there.
August 27th, 2009 at 12:40 pm
[...] the company started its slow descent towards bankruptcy and oblivion, neatly chronicled in this blog post by a former employee: The world changed out from under us very quickly. The new “workstation” [...]
August 27th, 2009 at 1:11 pm
[...] the company started its slow descent towards bankruptcy and oblivion, neatly chronicled in this blog post by former Symbolics employee Dan Weinreb: The world changed out from under us very quickly. The new [...]
August 27th, 2009 at 1:34 pm
[...] the company started its slow descent towards bankruptcy and oblivion, neatly chronicled in this blog post by former Symbolics employee Dan Weinreb: The world changed out from under us very quickly. The new [...]
October 13th, 2009 at 4:55 pm
I was very green 3D animator in the late 80′s early 90′s who got started with a Symbolics unified workstation, so I come at this from that perspective. It was WAY ahead of it’s time in many ways, but the UNIX boxes (SGI in particular) were kicking it’s butt on performance if not functionality. As an end user, I did not care if LISP was elegant, I wanted faster renders, and begged the developers for more speed.The industry was moving away from the “Black box” turn key systems and going toward platform independence…. Symbolics became a hardware vendor in a software world. I clung on as long as I could, and to this day STILL use some of the software that migrated to the PC… I remember very fondly the engineers from those days… some of the most brilliant people I’ve ever been associated with.
February 13th, 2010 at 1:02 pm
Whichever way you look at the facts, it makes for a nice reminiscence on one of the most innovative and exciting computing platforms of all time. It’s very interesting that talk of the DEC Alpha gets brought into it too.
Sometimes I think the reason we lose these platforms along with their plus points is that the market isn’t always smart enough to know what’s good for it.
The situation with are in today in I.T. is definitely not the culmination of the best of everything that came before it.
Some things are explained by the throw of chance.