1. Evolution of the Major Programming Languages
Chapter 2
Evolution of the Major Programming Languages

3. Amid the strife of war... 1936-1945 Konrad Zuse (Tsoo-zuh)
Built a series of complex computers from electromechanical relays
Developed a language called Plankalkul for expressing computations
Unpublished until 1972

4. ShortCode A Step Toward Readability/Writability
1949
John Mauchly
Developed a language named ShortCode for the BINAC
It consisted of coded versions of mathematical expressions
Example statement: 00 X Y0
Meaning X0 = SQRT(ABS(Y0))
X0 and Y0 were variable names; 03 the assignment opearator, 20 sqrt, and 06 absolute value
Machine implementation was pure interpretation, which was termed automatic programming.
More readable and writable than keying in the machine code equivalent, but at a cost of running 50 times slower.

5. Business – Flowmatic & COBOL
Compiling systems
Relocatable code
Assembly languages
Fortran 0, I, II
AI – FLPL; IPL-I, LISP
Business – Flowmatic & COBOL
ALGOL

6. Keep in Mind the Initial Context
At the beginning of the 50s
Primary use of computers were for numerical calculations
Computer memories were small
Hardware did not directly support floating point operations or indexing
Hardware was unreliable
Hardware was more costly than programmers

7. A First Compiling System
Grace Hopper and her team at UNIVAC
Developed a “compiling system” named A-0, A-1, and A-2
Programs were written in a type of code called pseudocode which was expanded into machine code subprograms

8. Progress in Generality
1950
David J. Wheeler
Developed a method of using blocks of relocatable addresses.
1951
Maurice Wilkes
Extended this idea to design an assembly program that could combine chosen subroutines and allocate storage.

9. Speedcode System Support for Floating Point Operations
Early 1950s
John Backus
Developed a Speedcode system for the IBM 701 which extended machine code to include floating-point operations.
Instruction set included the four arithmetic operations for floating points, sqrt, sine, arc tangent, exponent and logarithm; conditional and unconditional branching; I/O conversions.
Novel facility of auto incrementing address registers.
Pure interpretation (slow -“add” took 4.2 milliseconds)
Faster coding - Matrix multiplication could be coded in 12 instructions

10. First Real Compiler? 1952 Alick E. Glennie OR 1953 Laning and Zierler
Developed Autocode compiler for the Manchester Mark I computer
Lowlevel and machine oriented OR
1953
Laning and Zierler
Developed an algebraic translation system
Used function calls and included arrays and branching instructions
Implemented on the MIT Whirlwind computer
Generated a subroutine call to each formula, expression
Easy to read
Used within MIT

11. Fortran A Significant Step Up – First Important High Level Language
1954
IBM 704
Provided hardware for indexing and floating point instructions
John Backus and group at IBM
Published a description of Fortran 0
Major goal: Provide efficiency of hand-coded programs
Note: The first version of the compiler had little syntax error checking based on claims of eliminating coding errors and thus debugging
Implementation began in 1955
Released in 1957 as Fortran I.
Types and storage for all variables fixed before run time – efficiency vs. flexibility
Included I/O formatting
Variables of up to six characters
User-defined subprograms
If and Do statements
Implicit data types – I-N for integers
18 worker-years of effort
Huge success

12. Artificial Intelligence An Influence on Programming Languages
Mid 50s
Interest in AI emerged
Natural language processing
Modeling human information storage and retrieval and other brain processes
Mechanizing certain intelligent processes such as theorem proving
These interests held a common need for processing symbolic data in lists that could be easily manipulated
linked lists vs. arrays.

13. AI and Fortran Mid 50s IBM FLPL (Fortran List Processing Language)
Extension to the Fortran compiler
Used to construct a theorem prover for plane geometry

14. First AI Programming Language IPL - Information Processing Language
1956
Allen Newell, J.C. Shaw, Herbert Simon
Published a description of one of the first AI languages
IPL-I
Information Processing Language

15. The Business Domain 1957 FLOW-MATIC
Business oriented language for the UNIVAC
“mathematical programs should be written in mathematical notation, data processing programs should be written in English statements” – Grace Hopper 1953

16. The Business Domain 1959 COBOL 60 Common Business Oriented Language
Design Goals
Use English as much as possible
Easy to use, even at the expense of being less powerful..
Not be overly restricted by the problems of its implementation
Characteristics
DEFINE verb for macros
Records
30 character names with hyphens
Data division and procedure division
Mandated by the DOD
Example on pages 65-67
Standardized versions in
1968; 1974 (subprograms with parameters), 1985,

18. Fortran progresses 1958 Fortran II compiler Bug fixes
Independent compilation of subprograms
Made lengthier programs possible

19. ALGOL Algorithmic Language
1958
GAMM (Society for Applied Mathematics and Mechanics) and ACM (Assoc. for Computing Machinery)
ALGOL 58 – A Universal Standard Language
Developed jointly by a committee of European and American computer scientists in a meeting in 1958 at ETH Zurich.
IAL (International Algorithmic Language vs. ALGOrithmic Language
The following people attended the meeting in Paris (from January 1 to 16):
Friedrich L. Bauer, Peter Naur, Heinz Rutishauser, Klaus Samelson, Bernard Vauquois, Adriaan van Wijngaarden, and Michael Woodger (from Europe), John W. Backus, Julien Green, Charles Katz, John McCarthy, Alan J. Perlis, and Joseph Henry Wegstein (from the USA).
Alan Perlis gave a vivid description of the meeting: "The meetings were exhausting, interminable, and exhilarating. One became aggravated when one's good ideas were discarded along with the bad ones of others. Nevertheless, diligence persisted during the entire period. The chemistry of the 13 was excellent."
Design Goals
The syntax should be as close as possible to standard mathematical notation, and programs written in ti should be readable with little further explanation
It should be possible to use the language for the description of algorithms in publications.
Programs in the new language must be mechanically translatable into machine language.
Characteristics
Machine independent
Flexible & powerful
Simple and elegant
Generalized many of Fortran’s features
Identifiers of any length; any number of array dimensions, lower bound of arrays set by programmer; nested selection statements.
Formalized the data type concept
Compound statements
:= assignment operator
Both John Backus and Peter Naur served on the committee which created ALGOL 60 as did Wally Feurzeig, who later created Logo.
ALGOL 60 inspired many languages that followed it.
Tony Hoare remarked: "Here is a language so far ahead of its time that it was not only an improvement on its predecessors but also on nearly all its successors."[7]

20. LISP 1959 John McCarthy and Marvin Minsky
Produced a system for list processing
LISP
A functional language
Dominated for a decade
Originally interpreted
Example diagrams and program on pages
Decendents are:
Scheme
COMMON LISP
Related Language - ML

22. IPL-V ALGOL-60 APL SNOBOL Fortran IV BASIC PL/I SIMULA ALGOL-68

23. Progress in AI 1960 Newell and Tonge IPL-V
Demonstrated that list processing was feasible and useful.
Actually an assembly language implemented in an interpreter with list processing instructions for the Johnniac machine

24. ALGOL 60 1960 ALGOL 60 Formally described using Backus-Naur Form
Example on pages 61-62
New additions
Block structure concept
Pass by value and pass by name
Recursive procedures
Stack-dynamic arrays
Note that formatted I/O was omitted due to goal of machine independence
Parent
Fortran
Descendents
PL/I, SIMULA 67, C, Pascal, Ada, C++ and Java

26. APL and SNOBOL 1960 APL SNOBOL Common features Kenneth Iverson at IBM
Designed for describing computer architecture
Odd character set required for operators
Expressivity vs. readability
Implemented in mid 60s
SNOBOL
D. J. Farber, R. E. Griswold, and I.P. Polonsky at Bell Labs
Designed for text processing.
Collection of powerful operations for string pattern matching
Common features
Not based on a previous language nor a basis for any languages
Dynamic typing and hence storage allocation

27. Fortran IV 1962 Fortran IV 1966 One of the most widely used PLs
Explicit type declarations for variables
Logical If construct
Capability of passing subprograms as parameters
1966
Fortran 66 – its Standardized version

28. BASIC Let’s make it easy…
1963
John Kemeny and Thomas Kurtz
Designed BASIC
Beginner’s All-purpose Symbolic Instruction Code
Goals
Must be easy for non-science students to learn and use
Must be pleasant and friendly
Must provide fast turnaround for homework
Must allow free and private access
Must consider user time more important than computer time!’
Characteristics
Small, nonteractive
Used through terminals
Single data type – fp – numbers
Resurgence with Visual BASIC in 90s.
Example on page 69.

30. PL/I A Single Universal Language
1964
IBM
Developed PL/I
Goal
Capable of both floating point and decimal arithmetic to support both scientific and business apps, as well as, support for list processing and systems programming!
Replace Fortran, LISP, COBOL and assembly languages.
Contributions
ALGOL 60’s recursion and block structure
Fortran IV’s separate compilation with communication via global data
COBOL 50’s data structures, I/O and report generating facilities
A collection of new constructs
Concurrently executing subprograms
Exception handling for 23 different types of exceptions
Allowed the disabling of recursion for more efficient linkage
Pointers as data types
References to cross sections of Arrays
Failings
“I absolutely fail to see how we can keep our growing programs firmly within our intellectual grip when by its sheer baroqueness the programming language – our basic tool, mind you! – already escapes our intellectual control.” – Edsger Dijkstra 1972
Example on pages 74-75

32. Simula 67 1967 Kristen Nygaard and Ole-Johan Dahl
First developed SIMULA I in the early 60s
Designed for system simulation, implemented in mid-60s
Generalized into Simula 67
Features
Extension of ALGOL 60 taking block structure and control statements
Support for coroutines via the class construct thus beginning the concept of data abstraction
Encapsulation of data and processes that manipulate the data
Class definition as a template
Constructors

34. ALGOL 68 Dramatically Different
1968
ALGOL 68
Design Criteria – Orthogonality
Never achieved widespread use, but contributed several important ideas.
User defined data types
Flex arrays – Implicit heap-dynamic arrays
Orthogonality – a few primitive concepts and unrestricted use of a few combining mechanisms
Descendents – ALGOL-W
Value-result method of passing parameters as an alternative to pass-by-name
Case statement for multiple selection

36. 1970s
Pascal C
Prolog
Scheme
Fortran 77
Ada

37. Pascal 1971 Niklaus Wirth Developed Pascal based on ALGOL 60
Primarily used as a teaching language
Simple but expressive
Lacked essential features for many apps which led to non-standard dialects such as Turbo Pascal
Example on pages 80-81

39. C 1972 Dennis Ritchie Developed the C language Heritage was
CPL - Cambridge early 60s
BCPL – Martin Richards 1967
B – Ken Thompson 1970 First HLL under Unix C
and ALGOL 68
Example on pages 82-83

41. Logic Languages 1975 Phillippe Roussel Described Prolog
Example code on page 86

42. Scheme A Functional Programming Language
1975
MIT
Scheme
Small size
Exclusive use of static scoping
Functions are first-class entities – can be values of expressions and elements of lists; assigned to variables; passed as parameters and returned as values of function applications.
Simple syntax and semantics

43. Fortran 77 Continues to Dominate
1978
Fortran 77
Character string handling
Logical loop control statements
If else
“Fortran is the “lingua franca” of the computing world..” Alan Perlis

44. 1980s
Smalltalk
ADA ML
Common LISP
Miranda
C++

45. Smalltalk
1980
Alan Kay who predicted computer “desktop” windowing environment
Developed the first language that fully supported OOP as a part of the Xerox Palo Alto Research Center (PARC) group
Charged with task of designing a lanuage to support Kay’s vision.
Objects and message passing
Example on pages 93-94

47. MetaLanguage Functional Language Interest Continues
Robin Milner
ML (MetaLanguage)
Functional but supports imperative
Syntax similar to imperative

48. ADA 1983 DOD Most extensive and expensive language design effort
Climate
More than 450 different languages were in use and none were standardized
Reuse and tools not feasible
High-Order Language Working Group was formed
Id the requirements for a new DoD HLL
Evaluate existing languages to determine candidate languages
Recommend adoption or implementation of a minimal set of languages
April 1975 – produced Strawman requirements docs
August 1975 – Woodenman
Jan 1976 – Tinman
Jan 1977 – Ironman
June 1978 – Steelman
July 1979 – Cii Honeywell/Bull language design was selected.
Spring of 1979 – name was adopted
1983 – “final” official ANSI version
Features
Packages
Exception handling
Generics
Concurrency support

50. LISP
1984
COMMON LISP
Designed to combine features of a number of differenct dialects of LISP that were developed during the 70s and 80s.
Large and complex
Allows both dynamic and static scoping
Basis is pure lisp

51. Miranda 1984 David Turner Miranda Based on ML, SASL, and KRC
Functional, no variables, no assignment statement
Haskell is based on Miranda
But has the unique feature of lazy evaluation - No expression is evaluated until its value is required

53. C++ Bjarne Stroustrup at Bell Labs
Made the first step from C to C++ with C with Classes language int 1983
Goals
provide a language with classes and inheritance
No performance penalty – reason array index range checking was not considered
It could be used for every application ofr which C was used – so left unsafe features of C
Progression
1980
Addition of function parameter tyep checking and conversion
Classes like those of SIMULA 67 and Smalltalk
Derived classes, public/private access, constructors/destructors, friends.
1981
Inline functions, default parameters, overloading
1984
Named C++ - virtual methods, dynamic binding of method calls to method definitions, reference types
1985
First available implementation named Cfront which translates C++ programs into C programs
Continued to evolve
multiple inheritance, abstract classes
Templates which provide parameterized types and exception handling
NET

55. 1990s
Fortran 90
Fortran 95
ADA 95
Java

56. Fortran 90 1990 Fortran 90 Dynamic arrays Records Pointers
Multiple selection statement
Modules
Recursion
Obsolescent-features list
Dropped fixed format of code requirement
Fortran vs. FORTRAN
Convention – keywords & identifiers in uppercase

57. Fortran 95 1995 Fortran 95 Forall added for parallelizing..
See code example on page

58. ADA 95 Features Success hindered by C++
Adding new components to those inherited from a base class.
Dynamic binding of subprogram classes to subprogram definitions (polymorphism)
Protected objects
Success hindered by C++

60. Scripting Languages
Sh (shell) – a small collection of commands interpreted as calls to system subprograms to perform utility functions with added varaibels, control flow statements, functions andetc
Ksh – David Korn ’95
Awk – Al Aho, Brian Kernighan, Peter Weinberger (’88) began as a report generation language
Tcl – John Ousterhout ’94
Perl – Larry Wall – designed as a UNIX tool for processing text files. Common Gateway Interface language as well.

61. Scripting Languages Perl – Larry Wall Combination of sh and awk
Statically typed variables - $ arrays; % hash names
Arrays can be dynamic and sparse
Some dangers
If a string is used in a numeric context and teh string cannot be converted to a number, zero is used without warning
Array indexing cannot be checked since there is no set subscript range. References to non-existent elements return undef, which is interpreted as 0 in numeric context.

62. 2000s
Fortran 2003 C# …

63. Fortran 2003 2003 Fortran 2003 Parameterized derived types OOP support
Procedure pointers
C interoperability