Chapter 2 - Evolution of Major Programming Languages

Konrad Zuse (Tsoo-zuh)

• 1936-1945

• Built a series of complex computers from electromechanical relays

• Developed a language called Plankalkul for expressing computations

John Mauchly

Developed a language named ShortCode for the BINAC

ShortCode

• It consisted of coded versions of mathematical expressions.

• Example statement: 00 X0 03 20 06 Y0

• 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.

Grace Hopper and her team at UNIVAC

• 1950-1953

• 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

David J. Wheeler

• 1950

• Developed a method of using blocks of relocatable addresses

Maurice Wilkes

• 1951

• Extended David J. Wheeler’s idea to design an assembly program that could combine chosen subroutines and allocate storage

John Backus

• Early 1950s

• 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.

Alick E. Glennie

• 1952

• Developed Autocode compiler for the Manchester Mark I computer

Laning and Zierler

• 1953

• Developed an algebraic translation system

Fortran

• 1954

• The first important high level language

• Created by John Backus and group at IBM

• Designed specifically for numerical and scientific computation

Mid 50s

When did interest in AI emerge?

FLPL - Fortran List Processing Language

• Extension to the Fortran compiler

• Used to construct a theorem prover for plane geometry

Allen Newell, J.C. Shaw, Herbert Simon

• 1956

• Published a description of one of the first AI languages

• IPL-I (Information processing Language)

Flow-Matic

• 1957

• 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

COBOL 60 - Common Business Oriented Language

• 1959

• Design goals: (1) Use English as much as possible (2) Easy to use, even at the expense of being less powerful, (3) Not to be overly restricted by the problems of its implementation

• Characteristics: (1) Define verb for macros (2) Records (3) 30 character names with hyphens (4) Data division and procedure division (5) Mandated by the DOD

• Standardized versions in 1968; 1974 (subprograms w/ parameters)

Fortan II compiler

• 1958

• Bug fixes

• Independent compilation of subprograms

• Made lengthier programs possible

ALGOL - Algorithmic Language

• 1958

• GAMM (Society for Applied Mathematics and Mechanics) and ACM (Assoc. for Computing Machinery)

• Developed jointly by a committee of European and American computer scientists in a meeting in 1958 at ETH Zurich. 

• Inspired many languages that followed it

LISP - List Processing

• 1959

• John McCarthy and Marvin Minsky

• A functional language

• Dominated for a decade

• Originally interpreted

• Descendants are: Scheme, Common LISP

• Related language - ML (Meta Language)

IPL-V

• 1960

• Newell and Tonge

• Demonstrated that list processing was feasible and useful

• Actually an assembly language implemented in an interpreter with list processing instructions for the Johnniac machine

ALGOL 60

• 1960

• Formally described using Backus-Naur Form

• 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

• Descendants: PL/I, SIMULA 67, C, Pascal, Ada, C++, Java

APL

• 1960

• Kenneth Iverson at IBM

• Designed for describing computer architecture

• Odd character set required for operators

• Expressivity vs readability

• Implemented in mid 60s

SNOBOL

• 1960

• 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 of APL and SNOBOL

• Not based on a previous language nor a basis for any languages

• Dynamic typing and hence storage allocation

Fortran IV

• 1962

• 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

BASIC - Beginner’s All-purpose Symbolic Instruction Code

• 1963

• John Kemeny and Thomas Kurtz

• Goals: (1) Must be easy for non-science students to learn and use (2) Must be pleasant and friendly (3) Must provide fast turnaround for homework (4) Must allow free and private access (5) Must consider user time more important than computer time!

• Characteristics: (1) Small, non interactive (2) Used through terminals (3) Single data type – fp – numbers (4) Resurgence with Visual BASIC in 90s.

PL/I

• 1964

• IBM

• Goals: (1) 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! (2) Replace Fortran, LISP, COBOL and assembly languages.

• Contributions: (1) ALGOL 60’s recursion and block structure (2) Fortran IV’s separate compilation with communication via global data (3) COBOL 50’s data structures, I/O and report generating facilities (4) A collection of new constructs

• 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

Simula 67

• 1967

• Kristen Nygaard and Ole-Johan Dahl

• Designed for system simulation, implemented in mid-60s

• Features: (1) Extension of ALGOL 60 taking block structure and control statements (2) Support for coroutines via the class construct thus beginning the concept of data abstraction

ALGOL 68

• 1968

• 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

Pascal

• 1971

• Niklaus Wirth

• 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

C

• 1972

• Dennis Ritchie

• Heritage was: (1) CPL - Cambridge early 60s (2) BCPL - Martin Richards 1967 (3) B - Ken Thompson 1970 First HLL under Unix (4) ALGOL 68

Prolog

• 1975

• Described by Philippe Roussel

Scheme

• 1975

• MIT

• 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

Fortran 77

• 1978

• Character string handling

• Logical loop control statements

• If else

Smalltalk

• 1980

• Alan Kay who predicted computer “desktop” windowing environment

• First language that fully supported OOP as a part of the Xerox Palo Alto Research Center (PARC) group

MetaLanguage

• 1980s

• Robin Milner

• Functional but supports imperative

• Syntax similar to imperative 

ADA

• 1983

• DoD - US Department of Defense

• Climate: (1) More than 450 different languages were in use and none were standardized (2) Reuse and tools not feasible (3) High-Order Language Working Group was formed

• Features: (1) Packages (2) Exception handling (3) Generics (4) Concurrency support

Common LISP

• 1984

• Designed to combine features of a number of different dialects of LISP that were developed during the 70s and 80s.

• Large and complex

• Allows both dynamic and static scoping

• Basis is pure lisp

Miranda

• 1984

• Based on ML, SASL, and KRC

• Functional, no variables, no assignment statement

• Haskell is based on this but has the unique feature of lazy evaluation - No expression is evaluated until its value is required

C++

• Bjarne Stroustrup at Bell Labs

• Goals: (1) Provide a language with classes and inheritance (2) No performance penalty – reason array index range checking was not considered (3) It could be used for every application ofr which C was used – so left unsafe features of C

Fortran 90

• 1990

• Dynamic arrays

• Records

• Pointers

• Multiple selection statement

• Modules

• Recursion

• Obsolescent-features list

• Dropped fixed format of code requirement

• Convention – keywords & identifiers in uppercase 

Fortran 95

• 1995

• Forall added for parallelizing

ADA 95

• Features: (1) Adding new components to those inherited from a base class (2) Dynamic binding of subprogram classes to subprogram definitions (polymorphism) (3) Protected objects

• Success hindered by C++

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

• Combination of sh and awk

• Designed as a UNIX tool for processing text files. Common Gateway Interface language as well.

• Statically typed variables - $ scalar; @ arrays; % hash names

• Arrays can be dynamic and sparse

• Some dangers: (1) If a string is used in a numeric context and the string cannot be converted to a number, zero is used without warning (2) 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.

Fortran 2003

• 2003

• Parameterized derived types

• OOP support

• Procedure pointers

• C interoperability