Chapter 2

Evolution of the Major Programming Languages

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

ShortCodeA 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 X0 03 20 06 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.

Compiling systems

Relocatable code

Assembly languages

Fortran 0, I, II

AI – FLPL; IPL-I, LISP

Business – Flowmatic & COBOL

ALGOL

1950s

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

A First Compiling System

1950-1953 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

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.

Speedcode SystemSupport 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

First Real Compiler?

1952 Alick E. Glennie

– 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

FortranA 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

Artificial IntelligenceAn 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.

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

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

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

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, 2002...

The Business Domain

Fortran progresses

1958 Fortran II compiler

– Bug fixes– Independent compilation of subprograms

Made lengthier programs possible

ALGOLAlgorithmic 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]

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 54-55. Decendents are:

– Scheme– COMMON LISP

Related Language - ML

IPL-VALGOL-60

APLSNOBOLFortran IV

BASICPL/I

SIMULAALGOL-68

1960s

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

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

APL and SNOBOL

1960 APL

– 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

Fortran IV

1962 Fortran IV

– 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

BASICLet’s make it easy…

1963 John Kemeny and Thomas Kurtz

– Designed BASIC Beginner’s All-purpose Symbolic Instruction Code

– Goals1. Must be easy for non-science students to learn and use2. Must be pleasant and friendly3. Must provide fast turnaround for homework4. Must allow free and private access5. 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.

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

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

ALGOL 68Dramatically 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

1970s

Pascal

C

Prolog

Scheme

Fortran 77

Ada

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

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

Logic Languages

1975 Phillippe Roussel

– Described Prolog– Example code on page 86

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

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

1980s

Smalltalk

ADA

ML

Common LISP

Miranda

C++

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

MetaLanguageFunctional Language Interest Continues

1980s Robin Milner

– ML (MetaLanguage) Functional but supports imperative Syntax similar to imperative

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

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

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

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– 2002 - .NET

Fortran 90

Fortran 95

ADA 95

Java

1990s

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

Fortran 95

1995 Fortran 95

– Forall added for parallelizing..– See code example on page 50-51.

ADA 95

Features– 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++

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.

Scripting Languages

Perl – Larry Wall – Combination of sh and awk– Statically typed variables - $ scalar; @ 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.

2000s

Fortran 2003

C#

…

Fortran 2003

2003 Fortran 2003

– Parameterized derived types– OOP support– Procedure pointers– C interoperability