Okay, quick… how many people besides Alan Kay can you name that worked at Xerox PARC? Not very many, eh? Yeah, that’s your loss. It wasn’t all about the guys like Kay that get all the glory, you know….
Warren Teitelman was by far my favorite speaker. Unfortunately my notes got worse as the day drug on, so I simply cannot do justice to him. Yeah, Guy Steele is…you know… Guy Steele. (OMG! The guy who wrote the lambda papers is sitting right behind me! Uh… can I have your autograph?) Fritz Kunze seemed like he’d have been a great guy to go out drinking with. And we’d heard from John McCarthy himself, for crying out loud…. But Teitelman came off as being at once knowledgeable and approachable. He didn’t exude any of the “dysfunctional Lisp-programmer” type attitudes at all. (Not that anyone else did….) And his work at PARC and InterLisp seemed to address things that the Lisp community as a whole seems to have overlooked somewhat in the years since. He’d been right in the middle of some pretty significant moments of computer history, but he still seemed like a pretty humble guy in spite of it.
Teitelman’s early work had to do with debugging Lisp programs while they were still running. When he presented it at a conference in 1968, he was completely flamed by Dijkstra! “We shouldn’t make it easier for programmers to recover from bugs,” Dijkstra said angrily. (He’d been visibly shaking his head through out the talk even before this outburst.) “How many bugs are we going to tolerate?” he demanded. “Seven,” Teitelman shot back. The audience laughed, of course, but Dijkstra never forgave him. From that day forward, Dijkstra referred to him as the Internationally Renowned Computer Entomologist!
In 1970 he worked on the DWIM features of InterLisp. He’d been discussing the feature for weeks, but somehow the implications of it were just not evident to the people he worked with. The idea was that the computer should be able to automatically correct doubled and transposed characters and such like. He rolled out the code for it into production and soon one of his colleages burst into the room and explained breathlessly: “I was talking on the phone and typed the wrong thing… and… and the computer corrected it!” Until you have something out there, the user can’t be sure what it can do, Teitelman said.
So yes… we were all sitting there listening to the guy that pretty much impelented the first spell checker, the first undo system (for a Lisp environment), and the first online help system. There were some court cases between Microsoft and Apple back in the eighties over who had these features first, but Teitelman of course has printouts from long before either one were on the scene! I think he was one of the first people to get a personal computer. (It cost $150,000…. It was something called a “Dorado”.) And when windowing systems were first developed at PARC, he rewired the Lisp programming tools to work with it. He was the first person to use the term “programming enviornment” in print. Incredible.
He concluded by quoting Alan Kay as saying that there aren’t enough languages these days that are late binding self-reflexive. Teitelman said that we’ve got to strive to separate the business process from the code. Your average developer, though, just thinks, “hey… I can easily build this rule in Java!” Don’t!!! This is a concept that people don’t get. If the program is rapidly changing or needs to look at itself, then you really need those late binding self-reflexive features, he said.
After hearing about many of the wonderful developments in the various branches of Lisp, Kent Pitman told us about extremely Machiavellian process of consolidating them under Common Lisp. (Earlier in the day, Fritz Kunze had remarked that this was a “deeply flawed” process and that the mailing archive revealed it to be an “unfolding disaster.”) Pitman had a strikingly cynical slide detailing the strategies of the process organizers: “due process is an illusion,” it said. Other bullet points sounded like something out the Art of War: “turn opponents against each other and let them wear each other down.” “Soliciting volunteers gives critics something to do,” another said, “which dilutes their passion, pacifies them, and makes them feel involved.” In order to isolate the Interlisp guys, dark rumors were spread about various computing nightmares caused by Teitelman’s DWIM features!
While at MIT, Pitman recounted how he’d written the MacLisp manual and naively signed the copyright over to them. “Oh, it’s just a formality,” they said. Not really understanding what copyright was about, he didn’t really think anything of it. He also didn’t see a dime of the money that MIT brought in with the book sales. Pitman wrote up the standard for the Common Lisp project and was very careful to avoid a similar deal for that. The committee would vote on the truth of the various propositions, but he would do all of the writing. No matter what, he was not going to give up the copyright for any reason!
When ANSI Common Lisp was finally finished, Pitman described how people simply could not come to grips with the fact that it was portable. “What platform is this implementation for?” people would ask. After failing to get people to try it out, these same people would end up calling two years later and say, “hey, you know… we tried it and it works. Can we use this?” Talk abut not getting the point!
He had another slide detailing an eerie phone conversation between him and someone from ANSI. Each side engaged in subtle forms of intimidation to try to get their way. After being pushed to turn it over, Pitman said flatly: “Our commitee just voted on the truth of things, not the text. Copyright covers the form of the text, not the truth.” He held his ground and somehow ANSI figured something out. The tragedy is that you can’t get a decent copy of the language standard anymore! And due to all of these maneuverings, it was years before Pitman could get his work published on the web… (Steele’s CLtL books actually beat him, much to his chagrin….) Stallman was not happy with the way Pitman handled copyrights: “I don’t care about useful,” he said, “it has to be free!”
Pitman seemed to have a knack for being a day late and a dollar short. He decided to write a Lisp based web server back in the nineties and after six months of working on it Franz (I think) came out with a free one. As a result of this experience, he has reservations about not only giving up his copyrights, but also with the open source development model in general….
(I apologize for the poor quality of this post. There so much that could be done to get this right, but I have limited time, etc. Hopefully this will suffice to give people a sense of the sessions until something better is released.)
Learning Lisp 
October 24, 2008 at 9:19 pm |
From 1986 – 88, I worked at Xerox AI Systems. We were the people down the hill from PARC who sold Interlisp-D and products related to it. I was there during the effort to add Common Lisp to the Lyric release of Interlisp-D.
I can tell you that the “dark rumors about computing nightmares caused by DWIM” had grounding in fact. We tried, VERY hard, to keep DWIM in Lyric and make it work in the combined IL/CL environment, but were defeated ultimately by Teitelman’s impenetrable DWIM code.
Larry Masinter (PARC Interlisp wizard, creator of Masterscope) couldn’t do it, and ultimately settled for reducing DWIM’s scope to simple spelling correction and package guessing.
October 24, 2008 at 11:59 pm |
Re: How many other people can you name who worked at PARC
Three: Dan Ingalls, Larry Tesler, Adele Goldberg. That’s just the Learning Research Group. That’s where my main focus was when I learned about their work. I forget, but did Peter Deutsch work there?
The part about Dijkstra (that’s how his name was spelled) was hilarious! 🙂 I have a good idea about what was going on. I read a few of Dijkstra’s speeches. He believed that all programs should be proved correct mathematically before they were implemented on a computer, thereby removing all bugs before implementation. He even said that in his freshman classes they would devise their own simple programming language that they would use on the chalkboard and on paper. The programs they wrote in it would just be exercises for mathematic proof. And he made sure the language didn’t exist on any of the computers at the school so that students “would not be tempted to test their programs”. He was totally against testing programs. He saw CS as purely a mathematical discipline (I think), and he wanted the discipline to only focus on programming that could be proved mathematically, to even get away from artifacts like operating systems, because they could not be proved correct, and disciplines like software engineering which he thought was a sham (actually I think his opinion about the latter has had validity). So the idea of writing a program before it was proven, thereby permitting bugs, was terrible practice to him.
Apparently Alan Kay and Dijkstra had a long feud. In one of his speeches from 1997 I talk about in one of my posts Kay just rips Dijkstra up one side and down the other. Kay, and it sounds like Teitleman, and Dijkstra just came from two completely opposite schools of thought as far as what should be studied in CS, and to a lesser extent what programming was.
I vaguely remember reading about the Durado in Kay’s “The Early History of Smalltalk”. It was a model that Xerox made in the 70s.
Teitelman said that we’ve got to strive to separate the business process from the code.
Huh. It would be interesting to hear more of what he really meant by this. Perhaps he was talking more about the philosophy of human-computer symbiosis, that computers should be tools for helping people understand complexity and work together more effectively, not automate what people already do.
October 25, 2008 at 8:13 pm |
Gregor Kiczales, the infamous “AspectJ Guy”, was also at PARC. In fact Common LOOPS, a predecessor to CLOS, was developed at PARC.
October 25, 2008 at 10:08 pm |
@Mark
>> Teitelman said that we’ve got to strive to separate the business process from the code.
This is what I think he meant:
That’s sort of the dynamic corollary to not hard coding your data base connection string and stuff like that. Make everything data driven that you can. Have every setting you can think of be set from a configuration file. What’s left after that? There’s the pain of having to recompile and redeploy your binaries for every little change. It’s the same sort of problem those guys at the DSM workshop were trying to deal with when they were emphasizing their “declarative and interpretative approaches” to coding. It’s the same problem that Lisp solved long ago, as demonstrated when they debugged running code on a satellite zillions of miles away.
“Late binding self-reflexive” systems are more maleable at run-time… and let you get away with “hard coding” even less than you would otherwise….
October 26, 2008 at 2:19 pm |
About the Dijkstra-Kay feud. Kay once said: “Arrogance in Computer Science is measured in nano-Dijkstras”.
Dijkstra, however, was right in what he said: programs should be bug-free, and to get there you should prove it mathematically. But he came from a theoretical background (he graduated a ‘theoretical physicist’), and the industry didn’t see (and still doesn’t) the problem with tolerable bugs and incremental software releases. You can see that by the reaction people got when Teitelman said “Seven” bugs were tolerable. Seven bugs in a big program are tolerable by everyone’s standard.
Poor Pitman, bad luck every time.
October 26, 2008 at 7:41 pm |
@Diogo:
Okay, but if we’re going to just stick to what can be proven, then should there be no such things as operating systems?
I understand what you’re saying, but context matters. If you watch Kay’s 1997 speech “The Computer Revolution Hasn’t Happened Yet”, you can see the incident I’m talking about. He gives some of the context for his theory of computing. He talked about an essay Dijkstra wrote called “On the fact that the Atlantic has two sides”. He talked about how in his classes CS is based on classical mathematics, and that his program is recognized by royalty. Kay wrote a response paper called, “On the fact that most of the software is written on one side of the Atlantic”. He said, “Computers form a new kind of math. They don’t really fit well into classical math,” implying that Dijkstra was missing the point, and lacking in vision. To back up his point he said that Euler wrote many volumes filled with proofs, and speculations about what might be true, many of which turned out to be true. On later inspection, however, most of his proofs were found to be flawed, and he said that many Ph.D’s have been granted on the basis of students finding flaws in Eulers proofs, but thinking that his speculations were true, and finding proofs that actually work to prove Euler correct. He said, “So debugging actually goes on in mathematics as well.”
Kay has long advocated for late-binding, self-reflective systems, because this enables debugging, and even changing the design while the program is “alive”. You can repair the flaw and continue execution where a thread halted, or change the design while the program is running without halting anything. The point is the program and/or the system doesn’t have to stop. This is how Erlang works. A bug doesn’t bring the system down. So bugs become “tolerable” because they’re less disruptive.
A key difference I think between Dijkstra and Kay is Dijkstra saw CS as purely a form of math (based on classical math, that is), whereas Kay sees CS as a fusion of math and science. In science we come up with hypotheses and test them. Science is a philosophy of discovery. So we don’t know what’s true ahead of time, and most hypotheses don’t pan out. I think Kay sees programming as a process of experimentation. Just as in science, you work with real things, see how they respond to experiments, and then you learn something about them. You can then build on this knowledge.
I’m not sure if Dijkstra would agree on this, but a key thing Kay has said for years is, “We haven’t figured out what computing is yet.” Dijkstra liked to stick to what could be proven. Kay, like Euler I guess, likes to speculate on “what might be true” and hopes that a good proof will come along later.
October 26, 2008 at 7:46 pm |
@Diogo:
Oh, and I think Teitelman was joking when he said “seven”, like he was just throwing a number out there to get under Dijkstra’s skin. 🙂
November 24, 2008 at 7:54 am |
I spent about two hours writing a long reply here expressing my dismay/distress with the summary that is offered of my talk, which contains either errors of fact or confusions in a number of places and gives what I regard are a number of material misconceptions about what I said. But after pressing “submit” it just gave me a page saying the word “discarded”. I had a backup of only about half of what I wrote and am not up to writing again this evening and it may be some time before I get a chance to try again. But I wanted to at least note that I tried to respond.
December 20, 2008 at 11:00 pm |
I loved Warren Teitelman’s talk. I realize now, more than ever, that he practically invented the whole idea of an interactive development environment, including inventing dynamic spelling correctors.
About Kent Pitman, keep in mind that he is not talking about the process that led from many Lisp dialects to the original “Common Lisp: The Lanaguage”. Rather, he’s talking about what happened later, when CLTL was being turned into an official ANSI specification. The two processes were vastly different. The former was informal, orchestrated by Guy Steele, and very pleasant. The latter was run according to official ANSI and X3 rules, and was very painful and unpleasant, at least as far as I was concerned.
It’s too bad people don’t know about all the fine researchers and developers who were at Xerox PARC in its heyday. Mark Miller, above, mentioned Dan Ingalls, Larry Tesler, and Adele Goldberg. Yes, L. Peter Deutsch did work there. He was one of the most brilliant people in the software world. He had a lot to do with the invention of time-sharing, Lisp, JIT compilers, and so much more. Gregor did indeed work at PARC. And then there’s Danny Bobrow, Johan DeKleer, Larry Masinter, Alice Harley, Bob Taylor, Butler Lampson, Chuck Thacker, Bob Metcalfe, Brian Williams, Lucy Suchman, Rick Cattell, John Warnock, Charles Geschke… So much of the computing environment/infrastructure/ecosystem that we all take for granted today emerged from the work of these people!