IPL, short for Information Processing Language, was created in 1956 by Allen Newell, Cliff Shaw and Herbert A. Simon to write programs that manipulated symbols rather than numbers. If you want to know what was the IPL programming language used for, the short answer is artificial intelligence research: it was built to run the Logic Theorist, one of the first AI programs, and it introduced list processing, an idea that went on to shape Lisp and much of computer science.

Origins at RAND and Carnegie Tech

Newell and Shaw worked at the RAND Corporation in Santa Monica, while Simon was a professor at the Carnegie Institute of Technology in Pittsburgh, where Newell later moved. The three were interested in how people solve problems and wanted to simulate that process on a computer. Fortran was not yet available, and in any case numeric languages were a poor fit. Their programs needed to build, search and rearrange structures of symbols whose size was unknown in advance.

Their answer was a language organised around linked lists. IPL-I was a design that was never implemented. IPL-II was implemented in 1956 on the JOHNNIAC, RAND's own computer, and was used for the Logic Theorist. IPL-III and IPL-IV followed as experiments, and IPL-V, the best-known version, was documented in a manual first published in 1961 and ran on a range of machines, including IBM's 650 and 704 series.

Design and key features

IPL looked more like an assembly language than a modern high-level language, but its ideas were well ahead of its syntax:

  • Lists as the core data structure. Memory was organised into cells linked together, so structures could grow and shrink while the program ran.
  • A free-storage list. Unused cells were kept on an available-space list, and programs took cells from it and returned them, an early form of dynamic memory management.
  • Push-down stacks. Symbols could be saved and restored in last-in, first-out order, which made recursive procedures practical.
  • Description lists, which attached attribute-value pairs to a symbol, close to what later languages called property lists.
  • Generators, routines that produced a sequence of elements one at a time for another routine to process.
  • A library of primitive processes, named J-routines in IPL-V, for tests, list operations and input and output.

Illustrative example

IPL-V programs were written in fixed columns: a name field, a two-part prefix (P and Q) saying how to treat the symbol, the symbol itself and a link to the next instruction. The fragment below is illustrative of the layout, not a tested listing. It sketches a loop that steps through a list until it reaches the end:

NAME   PQ  SYMB   LINK    COMMENT
R1         J60            locate next cell of list in H0
       70  9-1            branch to 9-1 if end of list (H5 negative)
           R2     R1      process the symbol, then loop back
9-1        J8             finish and return

Reading IPL required knowing the meaning of each P and Q code and the role of special cells such as H0, the communication cell, and H5, which held the result of tests. That density is one reason later researchers wanted something cleaner.

What was the IPL programming language used for?

IPL was the working language of early symbolic AI. Its best-known programs were:

  • Logic Theorist (1956), which proved theorems from chapter 2 of Whitehead and Russell's Principia Mathematica, 38 of the first 52, and was presented around the time of the 1956 Dartmouth workshop that named the field of artificial intelligence.
  • General Problem Solver, developed from 1957 onward, which used means-ends analysis to work on puzzles and formal problems.
  • The NSS chess program, named for Newell, Shaw and Simon, an early attempt to model human chess thinking.

Beyond these flagship projects, IPL-V was used by researchers in psychology and AI through the early 1960s to build models of human cognition and problem solving.

Influence and legacy

IPL's most important contribution was showing that list processing was a practical way to program a computer. John McCarthy knew the IPL work when he designed Lisp in 1958. He kept the idea of programs built around lists and recursion but wanted a notation grounded in mathematical functions rather than assembly-style instructions. Lisp quickly replaced IPL in most AI work.

Several ideas first worked out in IPL became standard: linked data structures, dynamic memory allocation from a free list, stacks for recursion and attaching properties to symbols. Newell and Simon received the Turing Award in 1975, in part for their work on list processing.

Is IPL still used today?

No. IPL was largely superseded by Lisp during the 1960s, and its implementations died with the machines they targeted. Its interest today is historical.

So what was the IPL programming language used for? It gave the first generation of AI researchers a way to represent symbols, goals and proofs inside a computer, and the list processing ideas it pioneered outlived the language itself by a wide margin.

Frequently asked questions

Who invented the IPL programming language?

Allen Newell, Cliff Shaw and Herbert A. Simon created IPL in 1956, working between the RAND Corporation and the Carnegie Institute of Technology. Shaw is often credited with much of the implementation work on RAND's JOHNNIAC computer.

Was IPL the first list processing language?

Yes, IPL is generally regarded as the first language built around list processing. It introduced linked lists, a free-storage list and push-down stacks as programming tools several years before Lisp appeared.

Lisp borrowed IPL's central idea of programming with lists and recursion. John McCarthy designed Lisp in 1958 with a more mathematical, function-based notation, and it soon replaced IPL as the main language of AI research.