The T Project

Jonathan Rees - December 2004 - updated Feburary 2010

It occurred to me recently that The T Project had no coherent presence on the web. There's Olin's history, but I thought something a bit more calm and dignified is in order.

For better links than I could hope to collate on availability of sources, binaries, documentation, and mail archives, and for information on astonishing recent developments, see the T Revival page.

Here are the last versions of T that I worked on:

Version 2.9 - never before released, its only purpose in life was to bootstrap version 3.0.

Version 3.0- - probably a predecessor of a real version 3.0; this was the last version put together at DEC in August 1984.

Cast of Characters

Drew McDermott - taught "Programming Language Expertise" course in which JAR learned Lisp and Scheme

Steele and Sussman - wrote papers that explained why the language was cool and how it could be made to perform well

John L. White, Rick Bryan, and Bob Kerns - taught JAR the craft of Lisp implementation

John O'Donnell - approved and managed the project as a way to wean Yale computer science off of the expensive PDP-10's; bought lots of Apollo workstations

Roger Schank - obtained funding (through the capital budget, I think)

Jonathan Rees - wanted to do something like this

Kent Pitman - major partner in language design, prototype, and propaganda

Norman Adams - recruited to work on compiler back end; continued work for the next several years (MS dissertation at Yale)

Jim Philbin - worked on run-time system, code generators, and concurrency

Jim Meehan - made well-meaning changes to the manual

Stephen Slade - wrote a book describing T

Forest Baskett - invited the whole project to spend summer at DEC SRC

Richard Kelsey - worked on T3/Orbit transformational compiler effort at DEC SRC and Yale

Olin Shivers - interested from the beginning, worked at DEC and CMU on higher-order type reconstruction

David Kranz - worked on trace scheduling code generation at DEC and Yale, continuing T maintenance for several years at MIT

John Lamping - worked on type inference or something (?) at DEC SRC in 1984

Paul Hudak - adopted the project after John O'Donnell left Yale; advisor to Kranz and Kelsey

Taylor Campbell and Brian Mastenbrook - revivers

Timeline

Spring 1981: Ridiculously optimistic proposal written by Rees

Summer 1981: Pitman, Rees, Adams at work

1981-1984: Rees, Adams, Philbin work on fleshing it out and on self-hosting (compiler based on Steele's S-1 Lisp Compiler)

1982: Lisp conference paper

1984: Slade's book The T Programming Language published with no active involvement from project personnel

published with no active involvement from project personnel Spring 1984: Rees writes initial version of Orbit

1984: Revised 2 Scheme report

Scheme report Summer 1984: Project hosted by DEC SRC (Rees, Adams, Kelsey, Kranz, Shivers, Lamping)

Fall 1984: Rees leaves project to go to graduate school

1986: Orbit and object-oriented papers published

1986: Kelsey dissertation on rewrite-based compilation

1986: Revised 3 Scheme report

Scheme report 1987: Slade's book on T published by Prentice-Hall

1988: Kranz dissertation on Orbit back end

1989: Mul-T paper published

1991: Kranz was still doing releases as late as this? (CMU AI repository)

2004: T revival by Campbell and Mastenbrook?

2004: Orbit paper republished in 20 Years of PLDI

Publications

There was the 1982 paper, and some others including some dissertations. Many mentioned above. Look at my publications page or Olin's history or the T revival page for bibliographies.

Influence?

Citations of the manual

I like to think that T influenced CLOS, the Common Lisp Object System, although CLOS generic functions could easily have been an independent reinvention. When CLOS came into being in the mid-1980's, most popular Lisp-based object systems (by which I mean frameworks for controlling the choice of specific methods for ad hoc polymorphic operators) wrote the application of a method named M of an object X on argument Y using a Smalltalk-inspired message-passing syntax (send X 'M Y) or some variant. For T we observed that many functions in Lisp and Scheme were already generic across various data types, and that when you wanted to run an M method specific to object X you simply wrote (M X Y) , and the function (procedure) named M chose and ran it for you. It would therefore be more parsimonious to use ordinary function application syntax instead of message-passing syntax in a Lisp object system. Although this was anathema to some people, the generic function idea eventually won out in Common Lisp and was even extended to permit dispatch over arguments other than the first and even over combinations of arguments - steps never taken by T.

or some variant. For T we observed that many functions in Lisp and Scheme were already generic across various data types, and that when you wanted to run an M method specific to object X you simply wrote and the function (procedure) named M chose and ran it for you. It would therefore be more parsimonious to use ordinary function application syntax instead of message-passing syntax in a Lisp object system. Although this was anathema to some people, the generic function idea eventually won out in Common Lisp and was even extended to permit dispatch over arguments other than the first and even over combinations of arguments - steps never taken by T. Mark S. Miller reports that T's object system, specifically the use of objects instead of strings as method selectors, had an influence on Joule.

T's experience with a thoroughly continuation-passing-based compiler (Orbit) may have influenced Andrew Appel's work.

I told Hal Abelson and Gerry Sussman the currying technique that I had used for writing the T interpreter, and for the second edition of Structure and Interpretation of Computer Programs they decided to rewrite the interpreter chapter in this style.

they decided to rewrite the interpreter chapter in this style. It would be nice to think that T's inherently anonymous classes (1981) had some influence on Java (anonymous inner classes, circa 2000), but that's very unlikely. First, the idea was not really original with T, but came ultimately from Hewitt and the actors languages. Second, it would not have been that difficult to reinvent. Third, Guy Steele may have been responsible for their appearance in both languages.

Users

Yale computer science research and education. (It was JAR's idea to name Apollo workstations after ungulates, hence the name 'zoo' for the educational facility as it scaled up.)

Nat Mishkin used it in his dissertation work.

There was a group using T at JPL. I have a nice testimonial from Erann Gat printed on a piece of paper somewhere. Until I find it, read this page, or try googling 'gat yale scheme mars'.

Paul Graham liked it.

There was a group of users at MITRE Corp. I found this URL.

Dorab Patel writes: "T was used for the AI classes at UCLA at least from the mid 80's (if not a bit earlier) until the late 80's, through Prof Michael Dyer and Margot Flowers (both of Yale, and I believe Roger Schank's students). ... The SARA - System's ARchitect's Apprentice - project used T heavily on the Sun workstations."

Sometimes people mention T on their resumes.

Successors

Mul-T - David Kranz's project at MIT?

Scheme 48 by Kelsey, Rees et al. 1986 - present

Errata in Olin's history

When I started working for Yale in June 1981, I had just graduated. Olin must have been class of 82 or 83.

There was at least one other person at Yale who knew the Steele and Sussman papers, namely Drew McDermott, who had been a student of Sussman's; and it was only through McDermott that I knew Lisp and Scheme. (My earlier attempt to understand it by reading Bruce Wilcox's MTS Lisp manual failed.)

Steele's CHEAPY, not RABBIT, was the first Scheme compiler. This must have been in about 1977. I think it's discussed either in Declarative or in the Rabbit TR.

I had forgotten about Perlis's programming languages seminar - lots of fun. That would have been spring of 1981, and it was key to my being able to graduate.

Regarding acceptance of GC outside of the AI community, to be fair you must mention APL (which probably just used reference counts), SNOBOL4 (with true GC; internally very Lisp-like), Algol 68, and Smalltalk. By 1981 there was probably also acceptance in the functional programming community - ML, Hope, Miranda, POP2, and friends.

It's a bit unfair to leave UCI Lisp and the Utah Lisps out of a discussion of PDP-10 Lisps.

George Carrette didn't join NIL until long after I left. The 'soul' of NIL in my mind was John L White, Rick Bryan, and Bob Kerns. George and Glenn Burke (not sure of the timing) picked up the pieces after the original crew drifted away.

(NIL was always an ugly duckling at MIT, since it competed for talent with the Lisp Machine project. The Lisp Machine was much sexier and managed to attract a larger, more effective, and more determined staff.)

(NIL was always an ugly duckling at MIT, since it competed for talent with the Lisp Machine project. The Lisp Machine was much sexier and managed to attract a larger, more effective, and more determined staff.) Don't be so sure that Sussman/Steele's Scheme (NSCHSY) was the only one in existence in spring of 1981. You would need to check up on how far the Indiana folks had gotten; it's quite possible they already had something by then.

Regarding Schank and O'Donnell, the sequence of events was that John and I were friends; I convinced him that a Scheme would be a good thing to do (I don't think he needed much convincing since he was desparate to reduce costs by migrating to cheaper hardware); and John convinced Schank. Incidentally, in my entire life I have never exchanged words with Roger. [Update 5/05: no longer true.]

As for 'blasting' out a prototype in Maclisp - I don't remember the details, but the person who did most or all of the Maclisp work in 1981 was Kent Pitman, so don't credit me. But this prototype wasn't used for bootstrap; for that I just did the usual thing of writing sufficient Maclisp macros to make Maclisp code look sort of like T code, and carefully arranged for the compiler to not use any features not supportable by Maclisp - not a difficult task given that the compiler (Steele's S-1 Lisp compiler) was written in Maclisp in the first place. The first code we compiled was a little throw-away interpreter that Kent wrote.

A side note on the relation of MIT Scheme and T/NIL: around 1980 I had a conversation with an undergraduate named Chris Hanson, who was looking for something to do. Sussman and Steele had been busy working on a VLSI Scheme interpreter, and I was fresh off of a for-fun-only project of compiling the chip's microcode to PDP-10 machine code. I suggested that Chris translate the Scheme Chip microcode into VAX assembly code, obtaining with relatively little work a Scheme interpreter running on a 32-bit architecture. Fortunately he ignored the details of my advice and instead wrote an interpreter for the 68000 (whether assembly code or C I don't know). The virtual machine level continued to be called the "microcode" for much of the lifetime of the MIT Scheme project, which is what Chris's project became. [I spoke to Chris about this at one point and he remembers it differently; so consider that I may have manufactured this memory.]

Re "There was more to T than..." - note again that Pitman was T 1, not T 2. The work on morphemes was to his credit, not mine. ... Also observe again that Kent and Norman started at the same time, June 1981.

Forest Baskett invited the team out not because he knew me - he had no idea who I was - but because of an existing relationship with John O'Donnell, I believe.

Regarding "everyone else completed" at DEC, this needs to be qualified. I think Forest and Smokey Wallace would have been much happier, and might have invited us back, if we had actually done what we said we'd do, which was to write a Scheme compiler for their new machine, the Titan - or at least created a simulacrum of one.

Lamping's dissertation was "about allowing first class objects to retain some free parameters without operations on the objects having to be aware of that fact" (see bio).

The chronology of my graduate career is as follows. I worked on my masters degree from 1984 to 1989. I first studied entomology in 1989. The biology courses continued at Harvard through 1990 and through my Scheme-48-on-robot work at Cornell in 1991-93. I finished the PhD at MIT in January 1995, and went to England to study insect behavior in 95-96.

To report that Pre-Scheme "sort of died" would be an exaggeration. It is still used to build Scheme48, and Michael Sperber is using it to control a hairy multiprocessor financial simulation system. I believe there are other users as well, as evidenced by the bug reports we keep getting.



The T Project by Jonathan A. Rees is licensed under a Creative Commons Attribution 3.0 United States License.

Based on a work at mumble.net.