Information Processing Language (IPL) is a family of early programming languages developed in the mid‑1950s by Allen Newell, Cliff Shaw, and Herbert A. Simon at the RAND Corporation. Designed primarily for symbolic list processing and heuristic problem solving, IPL is considered one of the first languages to support linked‑list data structures and to be used in artificial intelligence research, most notably for the Logic Theorist and the General Problem Solver. IPL introduced novel concepts such as dynamic memory allocation, recursion, and primitive operations for manipulating symbolic expressions, which influenced later languages like Lisp and Scheme.
1 Historical Context
1.1 Origins at the RAND Corporation
The development of IPL began in 1954 as part of a research project at the RAND Corporation in Santa Monica, California. Newell, Shaw, and Simon were investigating how computers could be programmed to simulate human problem‑solving behavior. At that time, most programming was done in machine language or assembly language, which lacked facilities for handling complex symbolic data. The team recognized that a new kind of language was needed—one that could manipulate symbols and their relationships rather than merely performing numeric calculations. IPL emerged as the vehicle for their experiments.
1.2 Relationship to the Logic Theorist
The immediate motivation for IPL was the need to implement the Logic Theorist, a program that could prove theorems in propositional logic. Written in IPL in 1955–1956, the Logic Theorist is often credited as the first artificial intelligence program. It used heuristic search to find proofs, a method that IPL’s list‑processing capabilities made possible. The language’s design was thus tightly coupled with the demands of symbolic reasoning: lists represented logical formulas, and primitive operations allowed the program to decompose and combine them.
1.3 Evolution from IPL‑I to IPL‑V
The language evolved through several versions. IPL‑I was a purely theoretical specification used for early algorithm design. IPL‑II introduced a primitive interpreter on the RAND Johnniac computer. IPL‑III added features like property lists and rudimentary recursion. IPL‑IV, completed in 1957, was the first fully implemented version with a compiler for the IBM 704. The final and most widely used version, IPL‑V, appeared in 1958. It included a refined set of primitive operations, support for co‑routines, and a more flexible memory allocation scheme. IPL‑V remained the standard for AI research until the emergence of Lisp in the early 1960s.
2 Language Design
2.1 Data Structures
2.1.1 Lists and Linked Memory
IPL’s fundamental data structure was the list, implemented as a linked list of memory cells. Each cell contained two fields: a symbol (representing data or a pointer to a sublist) and a link (pointing to the next cell). This structure allowed dynamic growth and sharing of sublists, a radical break from the fixed arrays of contemporary languages. Memory was managed via a free‑list system; cells could be allocated and deallocated at runtime, though garbage collection was manual in early versions.
2.1.2 Symbols and Associated Values
Symbols in IPL were atomic identifiers, stored in a table with associated values. A symbol could be a simple name (e.g., A, PLUS) or a number. Each symbol could hold a value, which could be a list, another symbol, or a numeric constant. This provided a rudimentary form of a symbol table, enabling the representation of variables and their bindings.
2.2 Control Flow
2.2.1 Recursive Processes
IPL supported recursion by allowing a routine to call itself, using a push‑down list (stack) to save return addresses and intermediate data. The language’s designers noted that recursion was natural for processing list structures, such as traversing a tree of symbols. However, IPL did not enforce strict stack discipline; programmers had to manage the recursion depth manually in some cases.
2.2.2 Co‑routines and Generators
A distinctive feature of IPL‑V was the inclusion of co‑routines. A co‑routine could suspend its execution and transfer control to another co‑routine, later resuming from the point of suspension. This mechanism was used to implement generators—routines that produce a sequence of values one at a time. Generators were employed in heuristic search, where a generator would produce candidate moves or subgoals for a problem solver.
2.3 Primitive Operations
2.3.1 List Manipulation (e.g., CAR, CDR analogues)
IPL provided a set of primitive operations for list manipulation, which directly inspired the car and cdr functions of Lisp. The main operations were:
- HEAD – returns the first element of a list (analogous to
car). - TAIL – returns the rest of a list (analogous to
cdr). - CONS – constructs a new list cell by combining a head and a tail.
- ASSIGN – replaces the head or tail of an existing cell.
These operations, along with equality tests and copying functions, formed the core of list processing.
2.3.2 Property Lists
IPL introduced property lists as a means of attaching metadata to symbols. A symbol could have an associated property list—a set of attribute‑value pairs. For example, a symbol representing a logical operator might have properties such as ARITY (the number of arguments) or COMMUTATIVITY (a flag indicating whether the operator is commutative). Property lists were accessed via the GET and PUT primitives, which foreshadowed similar features in Lisp and Prolog.
3 Programming Paradigms
3.1 Heuristic Problem‑Solving
IPL was designed from the ground up to support heuristic problem‑solving. Programs could define a set of rules or operators, and use heuristic search (e.g., means‑ends analysis) to explore the problem space. The language’s list structures naturally represented problem states, and co‑routines allowed the search to alternate between different strategies. The General Problem Solver, written in IPL‑V, demonstrated this paradigm by solving puzzles such as the Tower of Hanoi and proving simple theorems.
3.2 Symbolic Computation
Beyond numeric computation, IPL emphasized symbolic manipulation. Programs could process algebraic expressions, logical formulas, and natural‑language fragments. The ability to treat symbols as first‑class objects made IPL suitable for tasks like symbolic differentiation and theorem proving. This focus on symbols rather than numbers set IPL apart from contemporary languages such as FORTRAN.
3.3 Use of Association Lists
Association lists (alists) were a common idiom in IPL programs. An alist is a list of pairs, where each pair maps a key to a value. For example, a symbol table could be implemented as an alist: ((X . 42) (Y . 3) (Z . 7)). Primitive functions such as ASSOC (find a pair by key) and ACONS (add a new pair) were provided. Association lists remained a standard data structure in Lisp and later languages.
4 Implementations
4.1 IPL‑V on the IBM 704
The most influential implementation of IPL was IPL‑V for the IBM 704. The IBM 704 was a vacuum‑tube mainframe with 32K words of memory and a floating‑point unit. The IPL‑V system comprised a compiler that translated IPL source code into a pseudo‑machine code, an interpreter that executed that code, and a runtime library that managed list memory. The compiler operated in two passes: the first pass parsed the language into an intermediate representation; the second pass generated the pseudo‑code. The interpreter was roughly 2,000 lines of assembly code.
4.2 Later Ports and Influence
Although IPL‑V was tied to the IBM 704, some attempts were made to port it to other machines, such as the IBM 7090 and the Philco TRANSAC S‑2000. These ports were limited in scope because the AI community quickly moved to Lisp, which offered a more elegant syntax and automatic memory management. Nevertheless, IPL’s concepts—linked lists, recursion, and property lists—were absorbed into Lisp’s design. IPL‑V source code and documentation are preserved in historical archives, serving as a record of early programming language evolution.
5 Applications
5.1 Artificial Intelligence Pioneers
IPL was the language of choice for several landmark AI programs of the late 1950s and early 1960s:
- Logic Theorist (1956) – the first AI program, which proved theorems from Whitehead and Russell’s *Principia Mathematica*.
- General Problem Solver (1959) – a domain‑independent problem‑solver that used means‑ends analysis.
- NSS (Newell, Shaw, Simon) – a system for simulating human cognition in tasks like cryptarithmetic.
- EPAM (Elementary Perceiver and Memorizer) – a model of human verbal learning, implemented in IPL‑V by Edward Feigenbaum.
5.2 Educational and Research Tools
In the early 1960s, IPL was also used as a teaching tool at Carnegie Institute of Technology (now Carnegie Mellon University) and the University of California, Berkeley. Students learned list‑processing concepts by writing IPL programs for puzzles or simple natural‑language processing. The language’s manual, *Information Processing Language‑V Manual* (1961), was widely circulated and influenced the curriculum of emerging AI courses.
6 Legacy
6.1 Influence on Lisp and Modern AI Languages
IPL’s most significant legacy is its influence on Lisp. John McCarthy, who visited the RAND Corporation in the late 1950s, acknowledged that his design of Lisp was inspired by IPL’s list‑processing primitives and property lists. McCarthy’s 1960 paper “Recursive Functions of Symbolic Expressions” explicitly cites IPL as a precursor. Lisp replaced IPL in the early 1960s because of its cleaner syntax (S‑expressions), automatic garbage collection, and a more flexible evaluation model. However, IPL’s concepts—especially linked lists, recursion, and symbolic computation—remained central to Lisp and its descendants (Scheme, Common Lisp).
6.2 Place in History of Programming Languages
IPL occupies an important niche in the history of programming languages as one of the earliest high‑level languages and the first to focus on symbolic rather than numeric computation. It introduced dynamic memory allocation, list‑based data structures, and heuristic programming paradigms. While IPL itself faded into obscurity, its ideas were woven into the fabric of AI programming languages. Today, IPL is remembered primarily as a pioneering effort that helped launch the field of artificial intelligence and demonstrated that computers could manipulate symbols, not just numbers.