Information Processing Language
The Information Processing Language, or IPL, was a family of programming languages developed by Allen Newell, Cliff Shaw, and Herbert Simon at the RAND Corporation beginning in 1956, created so that their Logic Theorist and later AI programs could manipulate symbols held in flexible list structures. It was the first language designed for list processing, and it introduced, in rugged and low-level form, several ideas that Lisp would present in a polished one.
IPL grew out of a practical need: the Logic Theorist had to build, search, and rearrange logical expressions whose sizes could not be predicted, and no existing language or assembler supported that. Newell and Simon, working with Shaw, a RAND systems programmer, had the program's design worked out in late 1955 and early 1956, and the first versions of the language were used to specify and run it on RAND's JOHNNIAC computer. The program was described in the 1956 paper The Logic Theory Machine in the IRE Transactions on Information Theory, and the group presented their work at the Dartmouth summer project the same year. The language was therefore a by-product, built because the research could not proceed otherwise, rather than a designed product of language theory.
The core of IPL was the list structure: memory organized as cells linked by pointers, with a list of cells possibly containing other lists as elements. Each symbol in a list could be a datum or the name of another list, allowing hierarchies of arbitrary depth, and IPL also supported description lists, in which an object carried attribute and value pairs, a forerunner of property lists. A pool of free cells supplied new cells on demand and took back those the programmer released, so structures could grow and shrink while the program ran. This is the memory model that lets a program work on a proof, a plan, or a chess position as an object it can restructure, and it is the same list processing that became standard in symbolic work.
Push-down stacks and recursion were the other structural innovations, and they were deeply tied to the problems the programs addressed. A push-down stack stores values so that the most recent is retrieved first, and IPL used these to save and restore working information, allowing a routine to be interrupted by a call to a subroutine and then resumed. This made it natural for routines to call themselves, a requirement for programs whose subgoals are smaller copies of the original problem, as in proof search. The idea of recursive subroutines was not unique to IPL, but IPL used it as a routine working tool in a period when mainstream languages like early Fortran had no support for it.
The language's ancestry in assembly code showed in its form, and that is the reason Lisp displaced it. An IPL program was written as numbered instructions with symbolic names for routines and storage, in the manner of a machine-level assembler, with primitive operations that manipulated list cells and communication cells. Writing in it was laborious and tied to a particular style of thinking about the machine. John McCarthy encountered IPL at Dartmouth in 1956, judged its list structures valuable but its notation unwieldy, and in designing Lisp combined its list-and-recursion approach with expression-oriented algebraic notation, borrowing also from Gelernter's Fortran-based list system. IPL-V, documented in a 1961 manual edited by Newell, continued to serve cognitive modeling and the General Problem Solver work, while Lisp took over the field's general programming.
Misunderstandings about IPL usually concern credit. It is sometimes said that Lisp was simply a cleaned-up IPL, but McCarthy's central contributions, the conditional expression, lambda notation drawn from Church, and above all programs represented as the same lists they process, were not in IPL, and garbage collection replaced IPL's explicit release of cells. The opposite error is dismissing IPL as a curiosity: it was the first running system to show list structures, hierarchical symbolic memory, and stack-based recursion working together on a real intelligent-behavior problem, and it established that research programs in AI would need languages of their own.
Read IPL as the first workbench for symbolic AI: a rough assembly-style language, built for one theorem-proving program at RAND in 1956, which proved that lists, stacks, and recursion could carry reasoning, and thereby gave Lisp the foundations it made elegant.