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
In photo, left to right: J. Rees, R. Kelsey, K. Pitman, N. Adams,
J. Philbin, D. Kranz, circa 1986.
Photographer: probably Guy L. Steele, Jr.
- 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
- 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
- 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
- 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
- Spring 1984: Rees writes initial version of Orbit
- 1984: Revised2 Scheme report
- Summer 1984: Project hosted by DEC SRC (Rees, Adams, Kelsey, Kranz,
- 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: Revised3 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
- 2004: T revival by Campbell and Mastenbrook?
- 2004: Orbit paper republished in 20 Years of PLDI
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.
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
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
(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.
Mark S. Miller
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.
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.
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
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
Sometimes people mention T on their resumes.
Mul-T - David Kranz's project at MIT?
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
- 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
By 1981 there was probably also acceptance in the functional
- 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
- 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,
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"
- 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
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.