History of Programming Languages

Home , Ada Lovelace, ALGOL 58, ALGOL 60, ALGOL W, COBOL, Pseudocode

UMBC CMSC 331

History

• Early History : The first programmers • The 1940s: Von Neumann and Zuse History of • The 1950s: The First Programming Language • The 1960s: An Explosion in Programming languages Programming • The 1970s: Simplicity, Abstraction, Study • The 1980s: Consolidation and New Directions Languages • The 1990s: Internet and web • The 2000s: ? scripting, parallel, Web 2.0, …?

Early History: First Programmers Konrad Zuse and Plankalkul • Jacquard loom of early 1800s Konrad Zuse began work on Plankalkul (plan calculus), the first – Translated card patterns into cloth designs algorithmic programming language, with an aim of creating the • Charles Babbage’s analytical engine theoretical preconditions for the (1830s & 40s) formulation of problems of a general nature. Programs were cards with data and operations. Steam powered! Seven years earlier, Zuse had developed and built the world's first • Ada Lovelace – first programmer binary digital computer, the Z1. He completed the first fully functional “The engine can arrange and combine its program-controlled electromechan- numerical quantities exactly as if they ical digital computer, the Z3, in were letters or any other general 1941. symbols; And in fact might bring out its Only the Z4 – the most sophisticated results in algebraic notation, were of his creations -- survived World provision made.” War II. CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 3 CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 4

The 1940s: Von Neumann and Zuse Plankalkul notation • Konrad Zuse (Plankalkul) – in Germany - in isolation because of the war – defined Plankalkul (program calculus) circa 1945 but A(7) := 5 * B(6) never implemented it. – Wrote algorithms in the language, including a program to play chess. | 5 * B => A – His work finally published in 1972. V | 6 7 (subscripts) – Included some advanced data type features such as S | 1.n 1.n (data types) » Floating point, used twos complement and hidden bits » Arrays » records (that could be nested)

The 1940s: Von Neumann and Zuse Machine Codes (40’s) Von Neumann led a team that • Initial computers were programmed in raw built computers machine codes. with stored • These were entirely numeric. programs and a • What was wrong with using machine code? central pro- Everything! cessor • Poor readability ENIAC was • Poor modifiability programmed • Expression coding was tedious with patch • Inherit deficiencies of hardware, e.g., no cords indexing or floating point numbers Von Neuman with ENIAC

The 1950s: The First Pseudocodes (1949) Programming Language • Short Code or SHORTCODE - John Mauchly, 1949. • Pseudocodes: interpreters for assembly language • Pseudocode interpreter for math problems, on Eckert • Fortran: the first higher level programming and Mauchly’s BINAC and later on UNIVAC I and II. language • Possibly the first attempt at a higher level language. • COBOL: he first business oriented language • Expressions were coded, left to right, e.g.: X0 = sqrt(abs(Y0)) • Algol: one of the most influential programming 00 X0 03 20 06 Y0 languages ever designed • Some operations: • LISP: the first language outside the von Neumann 01 – 06 abs 1n (n+2)nd power 02 ) 07 + 2n (n+2)nd root model 03 = 08 pause 4n if <= n • APL: A Programming Language 04 / 09 ( 58 print & tab

More Pseudocodes Fortran (1954-57)

Speedcoding; 1953-4 • FORmula TRANslator • A pseudocode interpreter for math on IBM701, IBM650. • Developed by John Backus • Developed at IBM under the guidance of John Backus • Pseudo ops for arithmetic and math functions primarily for scientific, • Conditional and unconditional branching computational programming • Autoincrement registers for array access • Slow but still dominated by slowness of s/w math • Dramatically changed forever the • Interpreter left only 700 words left for user program way computers used Laning and Zierler System - 1953 • Has continued to evolve, adding new features & concepts. • Implemented on the MIT Whirlwind computer – FORTRAN II, FORTRAN IV, FORTRAN66, FORTRAN77, FORTRAN90 • First "algebraic" compiler system • Subscripted variables, function calls, expression translation • Always among the most efficient compilers, producing fast • Never ported to any other machine code

Fortran 77 Examples Fortran 0 and 1 FORTRAN 0 – 1954 (not implemented) C Hello World in Fortran 77 C (lines must be 6 characters indented) FORTRAN I - 1957 PROGRAM HELLOW Designed for the new IBM 704, which had index registers and WRITE(UNIT=*, FMT=*) 'Hello World' floating point hardware END Environment of development: Computers were small and unreliable Applications were scientific PROGRAM SQUARE No programming methodology or tools DO 15,I = 1,10 Machine efficiency was most important WRITE(*, *) I*I Impact of environment on design 15 CONTINUE • No need for dynamic storage • Need good array handling and counting loops END • No string handling, decimal arithmetic, or powerful input/ output (commercial stuff)

Fortran I Features Fortran II, IV and 77 • Names could have up to six characters • Post-test counting loop (DO I=1, 100) FORTRAN II - 1958 • Formatted I/O • Independent compilation • User-defined subprograms • Fix the bugs • Three-way selection statement (arithmetic IF with GOTO) IF (ICOUNT-1) 100 200 300 FORTRAN IV - 1960-62 • Implicit data typing statements • Explicit type declarations variables beginning with i, j, k, l, m or n were integers, • Logical selection statement all else floating point • Subprogram names could be parameters • No separate compilation • ANSI standard in 1966 • Programs larger than 400 lines rarely compiled correctly, mainly due to poor reliability of the 704 FORTRAN 77 - 1978 • Code was very fast • Character string handling • Logical loop control statement • Quickly became widely used • IF-THEN-ELSE statement CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 15 CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 16

Fortran 90 (1990) COBOL Added many features of more modern programming languages, including • COmmon Business Oriented Language • Principal mentor: (Rear Admiral Dr.) • Pointers Grace Murray Hopper (1906-1992) • Recursion • Based on FLOW-MATIC which had such features as: • CASE statement • Names up to 12 characters, with • Parameter type checking embedded hyphens • A collection of array operations, DOTPRODUCT, • English names for arithmetic operators MATMUL, TRANSPOSE, etc • Data and code were completely separate • dynamic allocations and deallocation of arrays • Verbs were first word in every statement • CODASYL committee (Conference on Data Systems • a form of records (called derived types) Languages) developed a programming language by the • Module facility (similar Ada’s package) name of COBOL

COBOL COBOL First CODASYL Design Meeting - May 1959 Design goals: • Must look like simple English • Must be easy to use, even if that means it will be less powerful • Must broaden the base of computer users • Must not be biased by current compiler problems Design committee were all from computer manufacturers and DoD branches Design Problems: arithmetic expressions? subscripts? Fights among manufacturers

IDENTIFICATION DIVISION. COBOL PROGRAM-ID. HelloWorld. AUTHOR. Fabritius. Cobol Example Contributions: - First macro facility in a high-level language ENVIRONMENT DIVISION. - Hierarchical data structures (records) CONFIGURATION SECTION. - Nested selection statements INPUT-OUTPUT SECTION. - Long names (up to 30 characters), with hyphens - Data Division DATA DIVISION. Comments: FILE SECTION. • First language required by DoD; would have WORKING-STORAGE SECTION. failed without DoD LINKAGE SECTION. • Still the most widely used business applications language PROCEDURE DIVISION. DISPLAY "Hello World". STOP RUN. CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 21 CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 22

BASIC (1964) BASIC Examples • Beginner's All purpose Symbolic Instruction Code • Designed by Kemeny & Kurtz at Dartmouth for the GE 225 with the goals: PRINT "Hello World" • Easy to learn and use for non-science students and as a path to Fortran and Algol • Must be “pleasant and friendly” • Fast turnaround for homework • Free and private access FOR I=1 TO 10 • User time is more important than computer time PRINT I*I; • Well suited for implementation on first PCs (e.g., Gates NEXT I and Allen’s 4K Basic interpreter for the MITS Altair personal computer (circa 1975) • Current popular dialects: Visual BASIC CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 23 CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 24

LISP (1959) LISP Examples • LISt Processing language (Designed at MIT by McCarthy) (print "Hello World") • AI research needed a language that: • Process data in lists (rather than arrays) (defun fact (n) • Symbolic computation (rather than numeric) (if (zerop n) • One universal, recursive data type: the s-expression 1 • An s-expression is either an atom or a list of zero or more (* n (fact (1- n))))) s-expressions • Syntax is based on the lambda calculus (format t “factorial of 6 is: ~A~%" (fact 6)) • Pioneered functional programming • No need for variables or assignment (defun print-squares (upto) • Control via recursion and conditional expressions (loop for i from 1 to upto do (format t "~A^2 = ~A~%" i (* i i)))) • Status • Still the dominant language for AI • COMMON LISP and Scheme are contemporary dialects • ML, Miranda, and Haskell are related languages CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 25 CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 26

Algol Algol 60 Examples Environment of development:

1. FORTRAN had (barely) arrived for IBM 70x 'begin' --Hello World in Algol 60 2. Many other languages were being developed, all for outstring(2, 'Hello World'); specific machines 'end' 3. No portable language; all were machine dependent 4. No universal language for communicating 'begin' 'comment' Squares from 1 to 10 algorithms 'integer' I; ACM and GAMM met for four days for design 'for' i := 1 'step' 1 'until' 10 'do' - Goals of the language: 'begin' 1. Close to mathematical notation outinteger(2,i*i); 2. Good for describing algorithms 'end' --for 3. Must be translatable to machine code 'end' --program

Algol 58 Features Algol 60 • Concept of type was formalized Modified ALGOL 58 at 6-day meeting in Paris adding such • Names could have any length new features as: • Arrays could have any number of subscripts • Block structure (local scope) • Parameters were separated by mode (in & out) • Two parameter passing methods • Subscripts were placed in brackets • Subprogram recursion • Compound statements (begin ... end) • Stack-dynamic arrays • Semicolon as a statement separator • Still no i/o and no string handling • Assignment operator was := Successes: • if had an else-if clause • It was the standard way to publish algorithms for over Comments: 20 years • Not meant to be implemented, but variations of it were • All subsequent imperative languages are based on it (MAD, JOVIAL) • First machine-independent language • Although IBM was initially enthusiastic, all support was • First language whose syntax was formally defined dropped by mid-1959 (BNF)

Algol 60 (1960) APL

Failure: Never widely used, especially in U.S., • designed by K.Iverson at Harvard in late mostly because 1950’s 1. No i/o and the character set made • A Programming Language programs nonportable • A language for programming mathematical 2. Too flexible--hard to implement computations – especially those using matrices 3. Entrenchment of FORTRAN • Functional style and many whole array 4. Formal syntax description operations 5. Lack of support of IBM • Drawback is requirement of special keyboard

The 1960s: An Explosion in APL Examples Programming Languages • APL required a special character set, usually • The development of hundreds of programming provided by an IBM Selectric type ball languages • Here is an example that prints the squares of • PL/1 designed in 1963-4 the first 10 integers – supposed to be all purpose • The iota operator takes a number and returns a – combined features of FORTRAN, COBOL and Algol60 and more! – translators were slow, huge and unreliable vector from 1 to than number – some say it was ahead of its time...... • Algol68 • SNOBOL • Simula • BASIC CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 33 CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 34

PL/I PL/I • Computing situation in 1964 (IBM's point of view) PL/I contributions: Scientific computing 1. First unit-level concurrency • IBM 1620 and 7090 computers 2. First exception handling • FORTRAN 3. Switch-selectable recursion • SHARE user group 4. First pointer data type Business computing 5. First array cross sections • IBM 1401, 7080 computers • COBOL Comments: • GUIDE user group • Many new features were poorly designed • IBM’s goal: develop a single computer (IBM 360) and a • Too large and too complex single programming language (PL/I) that would be good • Was (and still is) actually used for both scientific for scientific and business applications. and business applications • Eventually grew to include virtually every idea in current • Subsets (e.g. PL/C) developed which were more practical programming languages. manageable

Simula (1962-67) Algol 68 From the continued development of ALGOL 60, but it is not • Designed and built by Ole-Johan Dahl and Kristen a superset of that language Nygaard at the Norwegian Computing Centre (NCC) in Oslo between 1962 and 1967 • Design is based on the concept of orthogonality • Originally designed and implemented as a language for • Contributions: discrete event simulation • Based on ALGOL 60 • User-defined data structures Primary Contributions: • Reference types • Coroutines - a kind of subprogram • Classes (data plus methods) and objects • Dynamic arrays (called flex arrays) • Inheritance • Dynamic binding • Comments: => Introduced the basic ideas that developed into object- • Had even less usage than ALGOL 60 oriented programming. • Had strong influence on subsequent languages, especially Pascal, C, and Ada

The 1970s: Simplicity, Pascal (1971) Abstraction, Study • Designed by Wirth, who quit the ALGOL 68 • Algol-W - Nicklaus Wirth and C.A.R.Hoare committee (didn't like the direction of that – reaction against 1960s work) – simplicity • Designed for teaching structured programming • Pascal • Small, simple – small, simple, efficient structures • Introduces some modest improvements, such as – for teaching program the case statement • C - 1972 - Dennis Ritchie • Was widely used for teaching programming ~ – aims for simplicity by reducing restrictions of the type system 1980-1995. – allows access to underlying system – interface with O/S - UNIX

C (1972-) Other descendants of ALGOL

• Modula-2 (mid-1970s by Niklaus Wirth at ETH) • Designed for systems programming at Bell • Pascal plus modules and some low-level Labs by Dennis Richie and colleagues. features designed for systems programming • Evolved primarily from B, but also • Modula-3 (late 1980s at Digital & Olivetti) ALGOL 68 • Modula-2 plus classes, exception handling, • Powerful set of operators, but poor type garbage collection, and concurrency checking • Oberon (late 1980s by Wirth at ETH) • Adds support for OOP to Modula-2 • Initially spread through UNIX and the • Many Modula-2 features were deleted (e.g., for availability of high quality, free compilers. statement, enumeration types, with statement, noninteger array indices)

The 1980s: Consolidation Ada and New Paradigms • In study done in 73-74 it was determined that the US DoD was spending $3B annually on software, over • Ada half on embedded computer systems. – US Department of Defence • The Higher Order Language Working Group was – European team lead by Jean Ichbiah formed and initial language requirements compiled and refined in 75-76 and existing languages • Functional programming evaluated. – Scheme, ML, Haskell • In 1997, it was concluded that none were suitable, • Logic programming though Pascal, ALGOL 68 or PL/I would be a good starting point. – Prolog • Language DoD-1 was developed thru a series of • Object-oriented programming competitive contracts. – Smalltalk, C++, Eiffel

Ada Ada Contributions: • Renamed Ada in May 1979. 1. Packages - support for data abstraction 2. Exception handling - elaborate • Reference manual, Mil. Std. 1815 approved 10 3. Generic program units December 1980. (Ada Bryon was born 4. Concurrency - through the tasking model 10/12/1815) Comments: • “mandated” for use in DoD work during late 80’s • Competitive design and early 90’s. • Included all that was then known about software • Ada95, a joint ISO and ANSI standard, accepted in engineering and language design February 1995 and included many new features. • First compilers were very difficult; the first really • The Ada Joint Program Office (AJPO) closed 1 usable compiler came nearly five years after the October 1998 (Same day as ISO/IEC 14882:1998 language design was completed (C++) published!) • Very difficult to mandate programming technology CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 45 CMSC 331. Some material © 1998 by Addison Wesley Longman, Inc. 46

Logic Programming: Prolog Functional Programming

• Developed at the University of Aix • Common Lisp: consolidation of LISP dialects Marseille, by Comerauer and Roussel, with spured practical use, as did the development of some help from Kowalski at the University Lisp Machines. of Edinburgh • Scheme: a simple and pure LISP like language used for teaching programming. • Based on formal logic • Logo: Used for teaching young children how to • Non-procedural program. • ML: (MetaLanguage) a strongly-typed functional • Can be summarized as being an intelligent language first developed by Robin Milner in the database system that uses an inferencing 70’s process to infer the truth of given queries • Haskell: polymorphicly typed, lazy, purely functional language.

Smalltalk (1972-80) C++ (1985) • Developed at Xerox PARC by Alan Kay and • Developed at Bell Labs by Stroustrup colleagues (esp. Adele Goldberg) inspired by • Evolved from C and SIMULA 67 Simula 67 • First compilation in 1972 was written on a bet to • Facilities for object-oriented programming, taken come up with "the most powerful language in the partially from SIMULA 67, added to C world" in "a single page of code". • Also has exception handling • In 1980, Smalltalk 80, a uniformly object-oriented programming environment became available as the • A large and complex language, in part because it first commercial release of the Smalltalk language supports both procedural and OO programming • Pioneered the graphical user interface everyone • Rapidly grew in popularity, along with OOP now uses • Saw some industrial use in late 80’s and early 90’s • ANSI standard approved in November, 1997

1990’s: the Internet and web Eiffel

• Eiffel - a related language that supports OOP During the 90’s, Object-oriented languages (mostly C++) became widely used in - (Designed by Bertrand Meyer - 1992) practical applications - Not directly derived from any other The Internet and Web drove several language phenomena: - Smaller and simpler than C++, but still has – Adding concurrency and threads to existing most of the power languages – Increased use of scripting languages such as Perl and Tcl/Tk – Java as a new programming language

Java C# (C Sharp)

• Developed at Sun in the early 1990s • Microsoft and Sun were bitter rivals in the with original goal of a language for 90s embedded computers • C# is Microsoft’s answer to Java • Principals: Bill Joy, James Gosling, Mike Sheradin, Patrick Naughton • C# is very similar to Java with (maybe) • Original name, Oak, changed for copyright reasons some minor improvements • Based on C++ but significantly simplified • If you know Java, learning C# should be • Supports only OOP easy • Has references, but not pointers • However: both languages have extensive • Includes support for applets and a form of libraries, and mastering them is a big part of concurrency mastering the language.

Scripting Languages The future • Scripting languages like Perl, Ruby, • The 60’s dream was a single all purpose language (e.g., Javascript and PHP have become important PL/I, Algol) • They shine at connecting diverse pre- • The 70s and 80s dream expressed by Winograd (1979) existing components to accomplish new “Just as high-level languages allow the programmer to tasks escape the intricacies of the machine, higher level programming systems can provide for manipulating • Cf. shell languages in Unix complex systems. We need to shift away from algorithms • Typical properties include: and towards the description of the properties of the packages that we build. Programming systems will be – privileging rapid development over execution efficiency declarative not imperative” – implemented with interpreters rather than compilers • Will that dream be realised? – strong at communication with program components in other languages • Programming is not yet obsolete