The Evolution of Programming Languages

The Evolution of PLs 1

The Evolution of Programming Languages

Day 2Lecturer: Xiao [email protected]


In last lecture …

• Anomalies• Theoretical Issues

– Type Theory– REs and Control/Data Structures


The Procedural Paradigm


Early DaysLocation Order100 A 104101 A 2102 T 104103 H 24104 C 50105 T 104

(address 104)


Early Days

A a3A 2T a3H 24

a3) C 50T a3

(symbol a3)


FORTRAN

• 1957• IBM• John Backus


• “The IBM Mathematical Formula Translation System or briefly, FORTRAN, will comprise a large set of programs to enable the IBM 704 to accept a concise formulation of a problem in terms of a mathematical notation and to produce automatically a high-speed 704 program for the solution of the problem.”


Major Achievements

• efficient compilation• separate compilation

(programs as separate subroutines, but the compiler doesn’t check for consistency between components)

• demonstration that high-level programming, with automatic translation to machine code, is feasible


Principal Limitations

• Flat, uniform structure– no concept of nesting

• Limited control structures– no compound statements

• Unsafe memory allocation– do NOT check consistent usage of memory

• No recursion– allocate data statically


Exercise

• The FORTRAN 1966 Standard stated that a FORTRAN implementation may allow recursion but is not required to do so.

• How would you interpret this statement if you were:

• (i) writing a FORTRAN program?• (ii) writing a FORTRAN compiler?


Algol 60

• Goal: universal PL• Algol was a failure

– few compilers, not widely used• Algol was a success

– standard language for describing algorithms


Major Innovations

• Block Structure– block: introduce nested scopes– runtime entity: activation record (AR) on stack

• Dynamic Arrays (discussed later)– dope vector: a pointer and an integer (size)

• Call By Name (discussed later)

• Own Variables– keyword: own– analogy: static in C++ (within a function)


Exercise

• Own Variables:• local scope• global extent

• Discuss the initialization of own variables.


Dynamic Arrays

procedure average (n); integer n; begin real array a[1:n]; … end;


Call By Name

procedure count (n); integer n; begin n := n + 1 end

count(widgets) begin widgets := widgets + 1 end


Call By Name

integer procedure sum (max, i, val); integer max, i, val; begin integer s; s := 0; for i := 1 until n do s := s + val; sum := s end

sum(3, i, a[i])computes

a[1]+a[2]+a[3]


Call By Name

try(x > 0, 1.0 / x)


Call By Name

try(x > 0, 1.0 / x)

real procedure try(b, x); boolean b; real x; begin try := if b then x else 0.0 end


Exercise

integer procedure sum (max, i, val); integer max, i, val; begin integer s; s := 0; for i := 1 until n do s := s + val; sum := s end

sum(3, i, a[i])computes

a[1]+a[2]+a[3]

Why does i appear in the parameter list of sum?


Missed Interesting Opportunities

• An Algol block without statements is, in effect, a record– Yet Algol 60 doesn’t provide records



• An Algol block:– begin

• Declarations• Statements

– end• A natural interpretation of concurrency:

– begin D1 S1 D2 S2 end



• Own variables: separation of scope and extent

• Ultimately lead to objects



• Call By Name: first step towards the idea that functions can be treated as values

• Actual parameters are implemented as Algol calls of parameter-less procedures

• Apply the idea consistently throughout the language high order functions, and functional programming


• The Algol committee knew what they were doing

• “Missed opportunities” would have led to significant implementation problems


COBOL

• COmmon Business-Oriented Language

• structured data• implicit type conversionMOVE X to Y.


Example: Automatic conversion

SALARY PICTURE 99999, USAGE IS COMPUTATIONAL

SALREP PICTURE $$$,$$9.99

MOVE SALARY TO SALREP.


Exercise

• Despite significant advances in the design and implementation of PLs,it remains true that FORTRAN is widely used for “number crunching”, andCOBOL is widely used for data processing

• Explain why.


PL/I

• Design principles:• (i) contain features for all kinds of

programming• (ii) only have to learn a subset of the

language


PL/I is a failure

• A programmer who has learned a “subset” of PL/I is likely to make a mistake


Example: Automatic conversion

(‘57’ || 8) + 171. Convert integer 8 to string ‘8’2. Concatenate strings ‘57’ and ‘8’ ‘578’3. Convert string ‘578’ to integer 5784. Add 17 to 578 5955. Convert integer 595 to string ‘595’


Features

• Storage class: static, automatic, based, controlled

• Programmer-defined types (but could NOT be named)

• Exception handlingON condition BEGIN; … END;

OVERFLOW

PRINTER OUT OF PAPER


Algol 68

• Design principle:

orthogonality• The language is to be defined using a

number of basic concepts that could be combined in arbitrary ways.


Features

• Described in formal notation (contribute to the slow acceptance of the language)

• Operator overloading (even priority can be altered)

• Very uniform notation for declarations and other entities: mode name = expression

• Reference• Large vocabulary of PL terms


Pascal

• Demonstrate that a PL could be simple yet powerful

• Data types form a recursive hierarchy (as blocks do in Algol 60)

• NO implicit type conversions• A kind of “fill in the blanks” language –

stepwise refinement– but prevents independent compilation


Modula-2

• inherits Pascal’s strengths• (to some extent) removes Pascal’s

weaknesses

• Important Features:• (i) Modules (interface, implementation)• (ii) Coroutines HOMEWORK


C

• Very pragmatic PL• Notable for its concise syntax

• Contribution: POPULARITY• the spread of UNIX inevitably led to the

spread of C


Ada

• represents the last major effort in procedural PL design

procedure procname ( parameters ) is body

type recordtype ( parameters ) is body


generic (parameters) package packagename is package description

task type templatename is task description


generic max: integer; type element is private; package Stack is …

package intStack is new Stack(20, integer)


Exercise

• Propose a uniform style for Ada declarations

HOMEWORK

The Evolution of Programming Languages

Documents

Transcript of The Evolution of Programming Languages