(Anmerkungen zur) Geschichte der Programmiersprachen

Transcription

1 (Anmerkungen zur) Geschichte der Programmiersprachen Prof. Dr. Hans J. Schneider Department Informatik (Informatik 2) Friedrich-Alexander-Universität Erlangen-Nürnberg Wintersemester 2012/13 I. Die frühe Geschichte der Programmiersprachen 1. Einleitung 2. Einige der ersten Sprachen 3. Strukturierung von Daten und Kontrollfluss 4. Bemühungen um Einheitlichkeit 5. Funktionale Programmierung II. Grundsätzliche Untersuchungen III. Beherrschung großer Systeme IV. Ergänzungen c Hans J. Schneider 2012

2 Lisp Prehistory John McCarthy: My desire for an algebraic list processing language for artificial intelligence work on the IBM 704 computer arose in the summer of 1956 during the Dartmouth Summer Research Project on Artificial Intelligence. 1 At that meeting, Newell, Shaw, and Simon presented IPL-2, a list processing language for the Johnniac computer (Rand Corp.). IPL (Information Processing Language) 2 Ed Feigenbaum reports: 3 In January 1956 Herb [Simon] walked into our seminar... : Over Christmas Allen Newell and I invented a thinking machine. They put together a paper program that got implemented in the language called IPL-I. It was the first list processing language, but it ran in their heads. A.C. Newell ( ) 1 J. McCarthy: History of Lisp, ACM SIGPLAN Not. 13, 8 (1978), pp A. Newell/J.C. Shaw: Programming the logic theory machine, Proc. Western Joint Comp. Conf. 1957, pp L. Shusteck: An interview with Ed Feigenbaum, Comm. Assoc. Comp. Mach. 53, 6 (2010), pp Geschichte der Programmiersprachen 5.1

3 Lisp: Motivation Motivations for developing a language for the IBM 704: 1 IBM was undertaking to develop a program for proving theorems in plane geometry. The computer was available at Dartmouth. It was not then clear whether IBM s Fortran project would lead to a language within which list processing could be conveniently be carried out. McCarthy proceeded along the lines that led to the Advice Taker proposal in 1958: ( ) J. McCarthy representing information about the world by sentences in a suitable formal language, and a reasoning program that would decide what to do by drawing logical consequences. 1 The basic program will draw immediate conclusions from a list of premises. These conclusions will be either declarative or imperative sentences. When an imperative sentence is deduced the program takes a corresponding action. 2 1 J. McCarthy: History of Lisp, ACM SIGPLAN Not. 13, 8 (1978), pp J. McCarthy: Programs with common sense, Symp. Mech. of Thought Processes, Nat. Phys. Lab., Teddington, 1958 Geschichte der Programmiersprachen 5.2

4 Prefix Notation Representing sentences by list structure seemed appropriate and a list processing language also seemed appropriate for programming the operations involved in deduction. This internal representation of symbolic information gives up the infix notation in favor of a notation that simplifies the task of programming the substantive computations, e.g., logical deduction, algebraic simplification, differentiation, integration. Thus most Lisp programs use a prefix notation for algebraic expressions, because they usually must determine the main connective before deciding what to do next. Comit, Formac, and Formula Algol all express the computations as operations on some approximation to the customary printed forms of symbolic expressions. Snobol operates on character strings but is neutral on how character strings are used to represent symbolic information. 1 J. McCarthy: History of Lisp, ACM SIGPLAN Not. 13, 8 (1978), pp Geschichte der Programmiersprachen 5.3

5 Lists on the IBM 704 The first problem was how to do list structure in the IBM This computer had a 36 bit word, and two 15 bit parts, called the address and the decrement, were distinguished by special instructions for moving their contents to and from the 15 bit index registers. The address of the machine was 15 bits, so it was clear that list structure should use 15 bit pointers. Therefore, the compounds car, standing for Contents of the address part of register number, and its analog cdr were defined. The IBM 704 had instructions that made these operations easy to implement. Gelernter and Gerberich implemented the Fortran List Processing Language in connection with IBM s geometry project. 2 cons was made a function, not just a subroutine, permitting new expressions to be constructed out of subexpressions. No recursion, no conditional expressions. 1 J. McCarthy: History of Lisp, ACM SIGPLAN Not. 13, 8 (1978), pp H. Gelernter/J.R. Hansen/C.L. Gerberich: A Fortran compiled list processing language, J. Assoc. Comput. Mach. 7, 2 (1960), pp Geschichte der Programmiersprachen 5.4

6 The Language Concept McCarthy introduced conditional expressions in connection with a set of chess legal move routines ( ) and proposed their use in Algol. 1 The program was written in Fortran for the IBM 704 at MIT. The IF statement provided in Fortran I and Fortran II was very awkward to use. This led to the invention of the true conditional expression. Differentiating algebraic expressions was chosen as a sample problem and led to the decisive innovations: 2 Writing recursive function definitions using conditional expressions. The maplist function. To use functions as argument, one needs a notation for functions: It seemed natural to use Church s λ-notation. ( I didn t understand the rest of his book, so I wasn t tempted to try to implement his more general mechanism. ) 1 J. McCarthy: Letter to the editor, Communicat. Associat. Comput. Mach. 2, 8 (1959) 2 J. McCarthy: History of Lisp, ACM SIGPLAN Not. 13, 8 (1978), pp Geschichte der Programmiersprachen 5.5

7 LISP 1 The implementation of Lisp began in fall The original idea was to produce a compiler. In order to get good conventions for subroutine linking, stack handling, and erasure, the group started by hand-compiling various functions into assembly language. The programs were written in an informal notation called M- expressions intended to resemble Fortran as much as possible. The notation allowed conditional expressions, recursive functions, and the basic functions of Lisp. The M-notation was never fully defined, because representing Lisp functions by Lisp lists became the dominant feature when the interpreter later became available. I can t now remember whether the decision to use parenthesized list notation as the external form of Lisp data was made then or whether it had already been used in discussing the paper differentiation program. 1 J. McCarthy: History of Lisp, ACM SIGPLAN Not. 13, 8 (1978), pp Geschichte der Programmiersprachen 5.6

8 LISP and Recursive Function Theory A milestone (1960): McCarthy s paper describing Lisp both as a programming language and as a formalism for doing recursive function theory. 1 Lisp s way of describing computable functions is much neater than the Turing machines or the general recursive definitions used in recursive function theory. 2 But recursive function theorists almost never have any reason to write particular recursive definitions. They are usually interested in the existence of functions with specific properties. One mathematical consideration was to express programs as applicative expressions built up from variables and constants using functions ( Pure Lisp ) allowing proofs of properties of programs using ordinary mathematical methods. 3 1 J. McCarthy: Recursive functions of symbolic expressions and their computation by machine, Part I, Communicat. Associat. Comput. Mach. 3, 4 (1960), pp Zur Entwicklung des Berechenbarkeitsbegriffs vergleiche man: U. Schöning/W. Thomas: Turings Arbeiten über Berechenbarkeit eine Einführung und Lesehilfe, Informatik Spektrum, 35, 4 (2012), pp Fans of other languages are challenged to write a program to concatenate lists and prove that the operation is associative. Geschichte der Programmiersprachen 5.7

9 Eval Another way to show that Lisp was neater than Turing machines was to write a universal Lisp function and show that it is briefer and more comprehensible than the description of a universal Turing machine: eval. Writing eval required inventing a notation representing Lisp functions as Lisp data, and such a notation was devised for the purposes of the paper with no thought that it would be used to express Lisp programs in practice. S.R. Russel noticed that eval could serve as an interpreter for Lisp, promptly hand coded it, and we now had a programming language with an interpreter. The unexpected appearance of an interpreter tended to freeze the form of the language, and some of the decisions made rather for the paper later proved unfortunate, e.g., cond leading to an unnecessary depth of parentheses. 1 J. McCarthy: History of Lisp, ACM SIGPLAN Not. 13, 8 (1978), pp Geschichte der Programmiersprachen 5.8

10 From LISP 1 to LISP 1.5 Property lists The idea of providing each atom with a list of properties was one of the theoretical ideas of the Advice Taker. Insertion of elements in lists and their deletion Lisp contains them in the form of rplaca and rplacd pseudo-functions. Unfortunately, this facility coexists uneasily with shared list structure. Programs that use them cannot be conveniently represented in logic. Numbers treated by themselves to do efficient numerical computations. FUNARG The construct originated from an example where in modern terminology lexical scoping was wanted, and dynamic scoping was obtained. The FUNARG device that took the lexical environment along with the functional argument. Geschichte der Programmiersprachen 5.9

11 From LISP 1 to LISP 1.5 (II) PROG feature Lisp allows sequential programs written with assignments and gotos. The idea antedates that of having recursive function definition. The notation was definitively an afterthought and is far from optimal. FEXPRS / FSUBRS eval made possible functions that are not given their actual arguments but are given the expressions that evaluate to the arguments. Application: Functions that don t always evaluate all of their arguments. This facility resembles Algol s call-by-name, but is more flexible, because eval is explicitly available. Functions with variable number of arguments List of arguments instead of separate arguments. None of these features has been given mathematical semantics. 1 McCarthy, loc.cit. Geschichte der Programmiersprachen 5.10

12 Basic Program Structure 419 A Lisp main program has the relatively trivial form of a sequence of function subprogram definitions. Lisp functions are defined entirely as expressions. Each operator is a function which returns a value. There is no block structure or other complex syntactic organization. Lisp referencing is primarily based on the most recent association rule for nonlocal referencing, implemented using a simple linked list of current associations, the A-list, which is searched for the current association each time an identifier is referenced. Run-time program translation and execution are provided as primitives, and programs may be created and executed dynamically. 1 T.W. Pratt: Programming Languages - Design and Implementation, Prentice-Hall, Englewodd Cliffs, N.J., 1975, pp Geschichte der Programmiersprachen 5.11

13 Basic Program Structure (II) Data in Lisp are rather restricted. Atoms (symbols) and numbers are the basic elementary types. Linked lists and property lists (represented as a special case of linked lists) form the basic data structures. Example: Expanding a list of lists: 1 (DEFINE 2 ((LISTATOMS 3 (LAMBDA (X) 4 (COND ((NULL X) NIL) 5 ((ATOM (CAR X)) 6 (CONS (CAR X) (LISTATOMS (CDR X)))) 7 (T (APPEND (LISTATOMS (CAR X)) 8 (LISTATOMS (CDR X)))) 9 ))) ) ) 1 T.W. Pratt, loc.cit. Geschichte der Programmiersprachen 5.12

14 Property Lists Property lists are of the form: (p1 v1 p2 v2 p3 v3... pn vn) where the p s are atoms denoting properties, and the v s are values associated with those properties. Example: (AUTHOR TUCKER ISBN 007Y TITLE PROG_LANGUAGES) The quotation mark, the letter q in setq, and the function quote are used to distinguish explicitly between evaluated and unevaluated expressions. (quote is the opposite of eval.) Operations defined on property lists: (GET listname property) (PUT listname property value) (REMPROP listname property) 1 A.B. Tucker: Programming Languages, McGraw-Hill, New York, 1985 Geschichte der Programmiersprachen 5.13

15 Control Structure Lisp control structures are relatively simple. 1 The expressions used to construct programs are written in prefix form and may include conditional branching. The prog feature provides a simple structure for writing expressions in a sequence with provision for labels and gotos. Generator primitives are also provided for generating elements of lists in sequence. A macro allows a function to be automatically reinstantiated (or generated) in-line within the text of a program wherever it is needed. 2 (DEFUN name MACRO (parameter) e1 e2... en) The macro facility can be used to define control structures. (See: Definition of while in the examples.) 1 T.W. Pratt, loc.cit. 2 A.B. Tucker, loc.cit. Geschichte der Programmiersprachen 5.14

16 Beyond LISP 1.5 Limitations of Lisp most evident in the early 1960s: ultra-slow numerical computation inability to represent objects by blocks of registers lack of a good system for input-output of symbolic expressions These limitations were to be fixed in Lisp 2: Initially planned for the Q32 computer, built by IBM for military purposes, but never equipped with more than 48K words of memory. Alternatives: Development for IBM 360/67 and PDP-6 But: more expensive than expected, and so Lisp 2 was dropped. From a 1970s point of view, this was regrettable, because much more money has since been spent to develop Lisps with fewer features. Existence of an interpreter makes it particularly natural to use Lisp 1.5 in a time-sharing environment: A demonstration was made in 1960 (or 1961) on the IBM 704. Deutsch implemented the first interactive Lisp on the PDP-1 in J. McCarthy: History of Lisp, ACM SIGPLAN Not. 13, 8 (1978), pp Geschichte der Programmiersprachen 5.15

17 The Evolution of LISP: From Lisp 1.5 to PDP-6 Lisp During this period, Lisp spread rapidly to a variety of computers, either by bootstrapping from an existing Lisp or by a new implementation. Almost all of these implementations had a small hand-coded (assembly) core and a compiler; the rest of Lisp was written in Lisp and compiled. The PDP-6 and PDP-10 computers were, by design, especially suited for Lisp, with 36-bit words and 18-bit addresses. This allowed a cons cell - a pair of pointers or addresses - to be stored efficiently in a single word. There were half-word instructions that made manipulating the car and cdr of cons cells very fast. In 1965, virtually all of the Lisps in existence were identical or differed only in trivial ways. 1 G.L. Steele Jr./R.P. Gabriel: The evolution of Lisp, ACM SIGPLAN Not. 28, 3 (1993), pp Geschichte der Programmiersprachen 5.16

18 MacLisp MacLisp was the primary Lisp dialect at the MIT AI Lab from the late 1960 s until the early 1980 s. MacLisp introduced the LEXPR, which is a type of function that takes any number of arguments and puts them on the stack; the single parameter of the function is bound to the number of arguments passed. The next phase of MacLisp development began when the developers of MacLisp started to see a large and influential user group emerge - Project MAC and the Mathlab/Macsyma group. The emphasis turned to satisfying the needs of their user community rather than doing language design and implementation as such. Fast compiler techniques were incorporated, and the resulting compiler became a standard against which all other Lisp compilers were measured in terms of the speed of running code. Arbitrary precision arithmetic was added to meet the needs of Macsyma users. 1 G.L. Steele/R.P. Gabriel, loc.cit. Geschichte der Programmiersprachen 5.17

19 Interlisp Interlisp introduced many radical ideas into Lisp programming style and methodology. The most visible of these ideas are embodied in programming tools: 2 The spelling corrector was invoked when a symbol had no value. DWIM ( Do What I Mean ) was invoked whenever an error of any sort was detected, e.g., parenthesis errors. The source code was presented by a structure editor. CLISP (Conversational Lisp) was a mixed Algol-like and English-like syntax embedded within normal Interlisp syntax. Masterscope was a facility for finding out information about the functions in a large system. 1 G.L. Steele/R.P. Gabriel, loc.cit. 2 W. Teitelman, PILOT - A step toward man-computer symbiosis, Ph.D. Thesis, MIT, 1966 Geschichte der Programmiersprachen 5.18

20 Interlisp: Parameter Passing Like MacLisp, Interlisp extended the function calling mechanisms in Lisp 1.5 with respect to how arguments can be passed to a function. Interlisp function definitions specified arguments as the cross product of two attributes: LAMBDA versus NLAMBDA, and spread versus nospread. LAMBDA functions evaluate each of their arguments; NLAMBDA functions evaluate none of their arguments. Spread functions require a fixed number of arguments; nospread functions accept a variable number. These two attributes were not quite orthogonal, because the parameter of a nospread NLAMBDA was bound to a list of the unevaluated argument forms, whereas the parameter of a nospread LAMBDA was bound to the number of arguments passed and the ARG function was used to retrieve actual argument values. 1 G.L. Steele/R.P. Gabriel, loc.cit. Geschichte der Programmiersprachen 5.19

21 LISP Machines Though ideas for a Lisp machine had been informally discussed before, L. Peter Deutsch (*1946) seems to have published the first concrete proposal. 1,2 Single-user minicomputer-class machine that would be microcoded to run Lisp and support a Lisp development environment. Duality of load and store access: There should be two internal functions associated with every accessor function, and that the store version should be called when the function is mentioned in a particular set of special forms, e.g., (DEFINE RPLACA (LAMBDA (X Y) (SETFQ (CAR X) Y))) 1 G.L. Steele/R.P. Gabriel, loc.cit. 2 P.L. Deutsch: A Lisp machine with very compact programs, Proc. Third Int. Joint Conf. Artificial Intelligence, Stanford, CA, 1973, pp Geschichte der Programmiersprachen 5.20

22 LISP Machines (II) MIT Lisp machines ( ) 1 The CONS machine was designed to have good performance while supporting a version of Lisp upwards-compatible with MacLisp. 2 An improved version, the CADR machine, became the computational mainstay within the MIT AI Lab. Language extensions included a more convenient macro facility, multiple values to be passed as the result from a function invocation, record structures, closures over special variables, flavors (an objectoriented programming system). Xerox Lisp machines ( ) 1 The Alto was a microcodable machine (1973) using Interlisp. 3 The Dorado (prototype in 1978) was specifically designed to interpret byte codes produced by compilers. Further development: Dolphin, Dandelion. All the Xerox Lisp machines used a reference-count garbage collector. 1 G.L. Steele/R.P. Gabriel, loc.cit. 2 R. Greenblatt: The LISP Machine, Working Paper 79, MIT Artificial Intelligence Lab., Cambridge, Mass., Nov See also: L. Hoffmann: From single core to multicore An interview with Charles P. Thacker, Communicat. Associat. Comput. Mach. 53, 7 (2010), pp Geschichte der Programmiersprachen 5.21

23 Scheme The dialect of Lisp known as Scheme was originally an attempt by Sussman and Steele (MIT) during Autumn 1975 to explicate for themselves some aspects of Hewitt s theory of actors as a model of computation. 1 Sussman and Steele had some trouble understanding some of the consequences of the model, so they decided to construct a toy implementation of an actor language in order to experiment with it. In the tradition of Planner and Conniver, they named the implementation Schemer, but the operating system had a 6-character limitation. 3 G.J. Sussman (*1947) G.L. Steele (*1954) 1 G.L. Steele/R.P. Gabriel, loc.cit. 2 C. Hewitt: Viewing control structures as patterns of passing messages, Journ. of Artif. Intell. 8 (1977), pp G.J. Sussman/G.L. Steele Jr.: SCHEME - An interpreter for extended lambda calculus, AI Memo 349, Cambridge, Mass.: MIT Artificial Intelligence Laboratory, Dec Geschichte der Programmiersprachen 5.22

24 Some Characteristics of Scheme Hewitt s model was object-oriented (and influenced by Smalltalk). Using MacLisp as a working environment, they wrote a tiny Lisp interpreter and then added the necessary mechanisms for creating actors and sending messages. Because Sussman had just studied Algol, he suggested starting with a lexically scoped dialect of Lisp. Evaluating a form beginning with lambda creates a closure (and returns a value). Evaluating a form beginning with alpha creates an actor (and invokes a continuation, i.e., will never return). The difference between an actor and a function would be detected in the part of the interpreter known as apply. Geschichte der Programmiersprachen 5.23

25 Common Lisp In Spring 1981, ARPA was no longer interested in funding a variety of needlessly competing and gratuitously different Lisp projects and called a meeting, in which the implementation groups got together to discuss the future of Lisp. 1 It was agreed that it was worth defining a family of languages in such a way that any program written in the language defined would run in any language in the family. Virtually all technical decisions were completed by early 1983, but it was almost a year before the book Common Lisp - The Language was available. 2 Role of Common Lisp: While the differences among the several implementations will continue to force some incompatibilities, Common Lisp should serve as a common dialect for these implementations. 1 G.L. Steele/R.P. Gabriel, loc.cit. 2 G.L. Steele: Common Lisp: The Language, Digital Press, Burlington, Ma., 1984 Geschichte der Programmiersprachen 5.24

26 Goals of Common Lisp Portability: Common Lisp should exclude features that cannot be easily implemented on a broad class of computers, e.g., features requiring microcode. Consistency: The interpreter and compiler should exhibit the same semantics. Compatibility: Common Lisp should strive to be compatible with Zetalisp, MacLisp, and Interlisp, in that order. Efficiency: It should be possible to write an optimizing compiler for Common Lisp. Power: Common Lisp should be a good system-building language, suitable for writing Interlisp-like user-level packages, but it will not provide these packages. Stability: Common Lisp should evolve slowly and with deliberation. 1 G.L. Steele/R.P. Gabriel, loc.cit. Geschichte der Programmiersprachen 5.25