IITRAN

IITRAN (pronounced “it-tran”) is a programming language designed at the Illinois Institute of Technology in Chicago in the mid-1960s as a first language for students. The name comes from the institute. IIT’s archives describe it as “a student-oriented algebraic language with corresponding computer complier” (sic). It ran first on an IBM 7040, was reworked for IBM System/360 in about 1966, and was later carried to a Univac 1108. Its syntax resembled PL/I. Its designers focused on what mattered to a beginner: readable statements, few arbitrary restrictions, error messages a novice could understand, and fast handling of large numbers of small student jobs.

IITRAN never spread far beyond IIT and the schools connected to it, but it is a good example of the 1960s student languages and compilers, alongside Waterloo’s WATFOR and ahead of Cornell’s PL/C and, later, Toronto’s SP/k. Some of its users went on to notable careers, among them Ward Cunningham, who created the first wiki.

History & Origins

Computing education at IIT

In the early 1960s IIT taught programming through its mathematics department and its Information Science Center, also called the Computation Center. IIT’s history of its computer science department says that “computers were first making their way into schools, and computer education required pioneers”. IIT ran several outreach efforts: a Saturday high school program for students and teachers, a Secondary School Computer Science Education program, and remote access to an IIT computer for local high schools.

FORTRAN was a poor fit for this audience. Chuck Guzis, an IIT student at the time, later recalled that the FORTRAN available on IIT’s System/360 Model 40 had “extremely limited syntax and even more cryptic diagnostics”. IITRAN was the Computation Center’s answer.

The 7040 version (c. 1964)

According to Wikipedia, the first IITRAN implementation ran on an IBM 7040, and a compiler was made available to students in 1964. The IIT Archives support that date. Its IITRAN collection is dated 1964 to 1967 and includes Vol. 1, No. 1 of the ITRAN Bulletin, edited by Don Lund and dated October 1964. According to the finding aid, that first Bulletin includes “a brief history of the IIT Secondary School Computing Support Program”, and the collection also holds a blank IITRAN punch card sold by the IIT Book Store. No technical description of the 7040 version was found, so how it differed from the later 360 language is not known in detail.

IITRAN/360 (c. 1966)

When IIT moved to an IBM System/360, the language was carried over and, according to Wikipedia, partly redesigned by a committee led by Dr. Peter G. Lykos, a chemist whom IIT’s history calls the center’s Director. IIT’s history records that he hired “fellow Ph.D. chemist” Robert B. K. Dewar, who “began thinking about the problem of introducing programming to beginners” and, “with others”, created IITRAN. Dewar finished his doctorate at the University of Chicago in 1968 and joined IIT’s faculty that year. He later created the SPITBOL compiler for SNOBOL4 with Ken Belcher (1971) and co-founded AdaCore in 1994.

Wikipedia names William S. Worley Jr. as the language’s primary designer and says he also contributed to the design of PL/I; the article gives no source for either statement, and neither was confirmed elsewhere. Worley co-wrote both IITRAN/360 manuals in the IIT Archives:

• IITRAN/360: Self-Instruction Manual and Text, by Charles R. Bauer, Anthony P. Peluso and William S. Worley Jr., 212 pages, © 1966 Four Pi Inc., Oak Park, Illinois. Addison-Wesley published it in 1967, and Henry Mullish reviewed it in Mathematics of Computation in January 1968.
• IITRAN/360, by Thea Drell Hodge (IIT Computation Center) and William S. Worley Jr. (listed with Cornell University), 59 pages, April 1967. The archive’s finding aid spells the second author “Morley”, which looks like a transcription error.

The definitive account is “The IITRAN Programming Language” by Dewar, Ronald R. Hochsprung and Worley, published in Communications of the ACM in October 1969. The paper’s abstract describes IITRAN as “a procedure-oriented language with a one-level block structure and a variety of data types”, says that “several novel and powerful features are included”, and promises “a discussion of design principles to be followed in a student language”.

The Univac era

IIT later replaced its 360 with a Univac 1108, and Wikipedia says an IITRAN compiler was developed for the 1108 in the early 1970s. Harry Chesley, who used IITRAN at Oak Park-River Forest High School from about 1969 to 1971, recalls that “at the beginning, IIT had an IBM 360; by the end, they’d switch to a Univac 1108”.

Design Philosophy

Wikipedia lists seven design goals, taken from the preface of the Bauer manual. They have not been checked against the book itself. In paraphrase, the language was meant to be:

1. clear, concise and easy to learn, even for people with no background in computers or mathematics;
2. as close to English as possible;
3. free of awkward restrictions and limitations;
4. consistent with mathematical and logical foundations;
5. able to process a large number of individual programs in a very short time;
6. a practical computational tool for science and engineering students;
7. able to produce a clear, easily understood set of diagnostic messages.

Goals 5 and 7 reflect how student computing worked in the 1960s. A university machine might receive hundreds of short, mostly wrong programs a day. Every job paid a fixed overhead before it ran, and every error message had to tell a beginner what had gone wrong. A language that loaded once and stayed resident, handling each student job without reloading, could in principle turn such jobs around faster than a general-purpose compiler that paid its full start-up cost every time. Guzis’s recollection that IITRAN occupied a permanent DOS/360 foreground partition fits that model. No published throughput figures for IITRAN were found, so none are given here.

Key Features

The 1969 paper could not be consulted for this article, so this section only reports features stated in the sources that were reviewed:

• PL/I-like syntax. IIT’s history says IITRAN was “based on a subset of PL/I”, and Wikipedia notes the similarity in syntax.
• One-level block structure and “a variety of data types” (1969 CACM abstract).
• Complex numbers as a built-in type (IIT history), which was unusual in a beginners’ language and useful for science and engineering students.
• Boolean values. Ward Cunningham recalls that once the advanced manual became available he “could branch based on a boolean variable”. He credits IITRAN with teaching him the difference between a boolean expression and the conditional logic that depends on it.
• A “novel set of control structures” (IIT history). The paper’s specific constructs are not reproduced here because they could not be verified.
• Comprehensive diagnostics (IIT history). Diagnostics were one of the language’s main design goals.
• Labels and GO TO. Cunningham remembers a classmate whose programs used labels such as TOWN and BED, so that they read GO TO TOWN and GO TO BED.
• Execution time limits that the programmer could raise. Cunningham recalls raising his own time limit to run a longer pi calculation.

Compiler or interpreter?

The sources differ. The IIT Archives, Wikipedia and IIT’s history all describe a compiler. Guzis remembered IITRAN/360 as “interpreted, not compiled”. Many student systems of the period compiled into memory and ran the result at once, without producing an object deck, and such a system could easily look like an interpreter to its users. Without the 1969 paper, the question is left open here.

A Spanish-language variant

Wikipedia says that IIT also had a Spanish-language version of IITRAN, with Spanish keywords instead of English ones (for example LEER for READ). No primary source for this was found.

Using IITRAN Remotely

Two former high school students described the same teletype procedure on Ward Cunningham’s federated wiki. Programs were punched onto paper tape on a Teletype Model 33, and the tape was then read into a teletype connected to IIT. The IIT computer controlled the flow of input with X-OFF characters. The teletype could not stop immediately, so each line had to end with extra RUBOUT characters as padding. Cunningham gives the prescribed sequence as “CR, LF, X-OFF, RUBOUT, RUBOUT”. Chesley remembered it as “CR/LF/X-off/rubout/rubout/rubout”. Cunningham notes that when the echo delay ran long, characters were lost “and another day lost debugging a program”, so students learned to hold the repeat key and punch a second or so of RUBOUTs.

Results came back as printouts, and a lost character could cost a day. At Oak Park-River Forest, teachers Norm Thompson and Phil Rendone also taught a weekend programming course at IIT. For some classes they handed out pre-punched but shuffled cards: students put them in order, removed the extra cards, and handed in a working program.

Current Relevance

IITRAN is extinct. No implementation, source code or emulator is known to be publicly available, and no Docker image exists. What survives is on paper: the 1969 CACM paper, the Bauer, Peluso and Worley self-instruction text, and the items in the IIT Archives. In 1977 the paper on the University of Toronto’s SP/k teaching system still cited the IITRAN paper, in a passage on printing to narrow paper.

Why It Matters

IITRAN belongs to a short-lived but important class of 1960s student languages and student compilers, built on the idea that a beginner’s language should be designed for the beginner and not simply be a smaller version of a production language. Fast handling of large numbers of student jobs, diagnostics written for novices and forgiving syntax were the same concerns behind WATFOR, PL/C and SP/k.

Through IIT’s outreach, IITRAN was also an early example of high school students programming a university computer remotely, over teletypes and paper tape. Ward Cunningham writes that IIT “shared its computer with my high school where I learned to program in the mid ’60s”, and that when IIT later gave him an honorary doctorate he told the deans how its system “had lit a lightbulb” for him. Robert Dewar’s later work on SPITBOL and on the GNAT Ada compiler arguably shows the same interest in fast compilers and helpful error messages.