algol-60 generality and hierarchy programming languages course computer engineering department...

ALGOL-60 GENERALITY AND

HIERARCHY

Programming Languages CourseComputer Engineering DepartmentSharif University of Technology

Outline2

History and Motivation

Structural Organization

Name Structures

Data Structures

Control Structures

Outline3

Name Structures

Data Structures

Control Structures

The International Algebraic Language

Designed by 8 representatives of ACM and GAMM

Combined experiences of algebraic language design and implementing pseudo-codes.

Essentially completed in 8 days Created a great stir Many dialects: NELIAC, JOVIAL

Objectives of Algol

As close as possible to standard mathematical notation and readable with little further explanation.

possible to be used for the description for computing processes in publications.

Mechanically translatable into machine programs.

Algol-60

Final report was published in May 1960, revised in 1962.

The original algol-60 report is a paradigm of brevity and clarity, remains a standard.

Syntax: BNF notation Semantics: clear, precise, unambiguous

English-language description.

Outline

Name Structures

Data Structures

Control Structures

Hierarchical Structure

begininteger N;read int (N);begin

real array Data[1:N];integer i;sum := 0;for i := 1 step 1 until N do

beginend…

endend

Category of Construct

Declaratives: bind name to the objects Variables Procedures Switches

Imperative: do the work of computation Control-flow Computational (:=)

The Familiar Control Structure

goto If-Then-Else For loop Procedure invocation

Compile-time, Run-time Distinction FORTRAN: static compilation process

Algol: not completely static Dynamic arrays Recursive procedures

The Stack, the Central Run-Time Data Structure

Dynamic allocation and deallocation are achieved by pushing and poping activation records on the stack.

Outline

Name Structures

Data Structures

Control Structures

Blocks and Compound Statements

A compound statement is a group of statements used where one statement is permitted.

Blocks contain declarations, compound statements do not.

An example of regularity in language design.

Example

for i:=0 step 1 until N do

sum:=sum+Data[i]

for i:=0 step 1 until N dobegin

if Data[i]>10 then Data[i]:=10;

sum:=sum+Data[i];

Print Real(sum);

Example

for i:=0 step 1 until N dosum:=sum+Dat

The body of a for loop is one

statement by default.

sum:=sum+Data[i];

Print Real(sum);

Example

for i:=0 step 1 until N dosum:=sum+Dat

sum:=sum+Data[i];

Print Real(sum);

The compound statement is used

where one statement is permitted.

Blocks Define Nested Scopes In FORTRAN scopes are nested in two

levels: global and subprogram-local. Algol-60 allows any number of scopes

nested to any depth. Each block defines a scope that extends

from the begin to the end. Name structures (such as blocks) restrict

the visibility of names to particular parts of the program.

Example

begin real x,y; procedure f(y,z); integer y,z; begin real array A[1:y]; end begin integer array Count [0:99] endend

Sample Contour Diagram

Algol use of nested scopes prevents the programmer from committing errors that were possible in using FORTRAN COMMON blocks.

Making errors impossible to commit is preferable to detecting them after

their commission.

Impossible Error Principle

Static and Dynamic Scoping

Static scoping: a procedure is called in the environment of its definition.

Dynamic scoping: a procedure is called in the environment of its caller.

Algol uses static scoping exclusively.

Example

a: begin integer m; procedure P m:=1; b: begin integer m; P end; P end

a: begin integer m; procedure P m:=1; b: begin integer m; P end P end

Example

With dynamic scoping, the

value of this m is 1 when the

program finishes block b.

Contour Diagram of Dynamic Scoping

m(b)Call P

DLm:=1

a: begin integer m; procedure P m:=1; b: begin integer m; P end; P end

Example

With static scoping, the

value of this m is 1 when the

program finishes block b.

Contour Diagram of Static Scoping

m(b)Call P

DLm:=1

Dynamic Scoping (Advantages)

begin real procedure sum; begin real S,x; S:=0;

x:=0; for x:=x+0.01 while

x<=1 do S:=S+f(x); sum:=S/100; end …end

beginreal procedure f(x); value x; real x; f:=x 2 + 1;sumf:=sum;

To use the sum function it is necessary only to name the function to be summed f.

beginreal procedure f(x); value x; real x; f:=x↑2 + 1;sumf:=sum;

beginreal procedure f(x); value x; real x; f:=x 2 + 1;sumf:=sum;

One advantage of dynamic scoping : A general procedure that makes use of

variables and procedures supplied by the caller’s environment.

Dynamic Scoping (Problems)33

begin real procedure discr(a,b,c) values a,b,c; real a,b,c; discr:=b↑2-4хaхc; procedure roots(a,b,c,r1,r2); value a,b,c; real a,b,c,r1,r2; begin …d:=discr(a,b,c); … end . . roots(c1,c2,c3,root1,root2); . .end

begin real procedure discr(a,b,c); values a,b,c; real a,b,c; discr:=b↑2-4хaхc; procedure roots(a,b,c,r1,r2); value a,b,c; real a,b,c,r1,r2; begin …d:=discr(a,b,c); … end . . roots(c1,c2,c3,root1,root2); . .end

begin real procedure discr(x,y,z); value x,y,z; real x,y,z; discr:=sqrt(x ↑2); . . . roots(acoe,bcoe,ccoe,rt1,rt2); . . . end

The roots procedure will use the wrong discr function to compute its result.

Dynamic Scoping (Problems)

This is called vulnerability.The root procedure is vulnerable to being called

from an environment in which its auxiliary procedure is not accessible.

Static and Dynamic Scoping

In dynamic scoping, the meanings of statements are determined at run-time.

In static scoping, the meanings of statements are fixed.

Static scoping aids reliable programming.

Dynamic scoping is against the Structure Principle.

Blocks and Efficient Storage Management

The value of a variable is retained In the scope of that variable. In a block or structure that returns to the

scope of the variable. Variables of disjoint blocks can never

coexist. Much more secure than FORTRAN

EQUIVALENCE. Implemented by a stack.

Do not ask users what they want, find out what they need.

Responsible Design Principle

Outline

Name Structures

Data Structures

Control Structures

Primitives

The primitive data types are mathematical scalars: integer, real, Boolean.

Only one level of precision: real.

No double-precision types, they violate Portability: Doubles need word size and floating point

representation of the computer to be implemented.

Primitives (cont.)

Complex numbers were omitted because: They are not primitive. The convenience and efficiency of adding them to

the language is not worth the complexity of it.

string data type: a second hand citizen of Algol-60. Can only be passed to procedures as arguments. Does not cause a loophole in the type system, as

it does in FORTRAN. Algol was the last major language without strings.

Algol follows the Zero-One-Infinity principle.

Arrays are generalized in Algol: More than 3 dimensions. Lower bounds can be numbers other than 1.

The only reasonable numbers in a programming language design are

zero, one, and infinity.

Zero-One-Infinity Principle

Dynamic Arrays

Arrays are dynamic in a limited fashion: The array’s dimension can be recomputed

each time its block is entered. Once the array is allocated, its dimension

remains fixed.

Stack allocation permits dynamic arrays. The array is part of the activation record. The array’s size is known at block entry

Strong Typing

Strong typing is where a language does not allow the programmer to treat blocks of memory defined as one type as another (casting).

Example: Adding numbers to strings, doing a floating point multiply on Boolean values.

This is different from legitimate conversions between types, i.e. converting reals to integers, which are machine independent operations.

Outline47

Name Structures

Data Structures

Control Structures

Primitive Computational Statement

The primitives from which control structures are build are those computational statements that do not affect the flow of control → ‘:=’

In Algol, function of control structures is to direct and manage the flow of control from one assignment statement to another

Control Structures, Generalization of FORTRAN’s

FORTRAN:

Algol:

if expression then statemtent1 else statement2

IF (logical expression) simple statement

Algol for-loop Includes the functions of a simple Do-loop

Has a variant similar to while-loop

for NewGuess := improve(oldGuess)while abs( NewGuess - oldGuess)>0.1

do oldGuess := NewGuess

for 1:=1 step 2 until M*N doinner[i] := outer [N*M-i];

for i:=i+1while i < 100

do A [i] := i;

Algol for-loop Includes the functions of a simple Do-loop

Has a variant similar to while-loop

for NewGuess := improve(oldGuess)while abs( NewGuess - oldGuess)>0.1

do oldGuess := NewGuess

for 1:=1 step 2 until M*N doinner[i] := outer [N*M-i];

while i < 100 dobegin

A [i] := i;i=i+1;

Algol-60 control structures are more: Regular Symmetric Powerful General

FORTRAN has many restrictions, because of:

Efficiency ( the array restriction) Compiler simplicity (the IF restriction)

the Algol designers’ attitude:

“Anything that you thing you ought to be able to do, you will be able to do.”

Restrictions are inexplicable for programmer.

Irregularity in a language, makes it hard to learn and remember.

Nested Statements

FORTRAN IF: if the consequent is more than 1 statement there are some problems:

Problem of maintainability Irregular syntax, source of error

FORTRAN DO-loop: begin and end of the loop is marked.

DO 20 I=1, Nstatement 1statement 2…statement m

20 CONTINUE

Nested Statements

the Algol designers’ realized:

All control structures should be allowed to govern an arbitrary number of

statements.

Nested Statements

Compound statement:

beginstatement 1 statement 2...statement n

Nested Statements

Begin-end brackets do double duty:1. Group statements into compound

statements.2. Delimit blocks, which define nested

scopes.

Nested Statements

Begin-end brackets do double duty:1. Group statements into compound

statements.2. Delimit blocks, which define nested

scopes.

Lack of orthogonality!

Hierarchical Structure of Compound Statements

Hierarchical structure is one of most important principles of language and program design.

Complex structures are built up by hierarchically combining single statements into larger compound statements.

Nested Led to Structured Programming

Many fewer GOTO-statements were needed in Algol-60.

Programs were much easier to read.

Edsger Dijkstra:

“Go To Statement Considered Harmful.”

Nested Led to Structured Programming

the static structure of the program should correspond in a simply way to

the dynamic structure of the corresponding computations.

The Structure Principle

Recursive Procedures

Example:

integer procedure fac (n);

value n; integer n;

fac := if n =0 then 1 else n * fac(n-1);

Recursive Procedures

There must be a memory location to hold the formal parameter!

Only one location for n? Each invocation of fac has its own instance of

the formal parameter n.

Creating new activation record for fac each time it is called, is instantiation.

Parameter Passing by Value

Example:

procedure switch(n);

value n, integer n;

Example:

Procedure switch(n);

Value n, integer n;

n:=3;Useful only for

input parameters!

Pass by value is very inefficient for arrays:

Real procedure avg (A , n);

value A, n;

real array A; integer n;

Parameter Passing by Name

Example:

Pass by name is based on substitution!

Procedure Inc (n);

integer n;

n := n+1;

Implementation is not based on substitution!

The procedure can be replaced by its body with the actuals

substituted for the formals.

Copy Rule

Example:

Pass by name is based on substitution!

Procedure Inc (n);

integer n;

n := n+1;Satisfies Algol’s need for output parameters!

Pass by Name Is Powerful!Example:

real procedure Sum (k, l, u , ak);

value l, u;

integer k, l , u; real ak;

begin real S; S := 0;

for k:=1 step 1 until u do

S := S + ak;

Sum:=S;

Pass by Name Is Powerful!Example: X := Sum (i, 1, n, v [i])

real procedure Sum (k, l, u , ak);

value l, u;

integer k, l , u; real ak;

begin real S; S := 0;

for I := 1 step 1 until n do

S := S + v [i];

x := S;

How is it implemented? Following the Copy Rule? Passing the address of the code sequence!

A thunk is an invisible, parameterless, address-returning,

function used by a compiler to implement name parameters and similar constructs.

Pass by Name is Dangerous and Expensive!Example: Swap (A[i], i) and Swap (i, A[i])

procedure swap (x, y);

integer x, y;

begin integer t;

t := x;

x := y;

y := t ;

Parameter Passing Summarized

1. Pass by value: At call time, the formal is bound to the value of the actual.

2. Pass by reference: At call time, the formal is bound to a reference to the actual.

3. Pass by name: At call time, the formal is bound to a thunk for the actual.

Good Conceptual Models

3 kind of conceptual models:1. Designer’s model2. System image3. User’s model;

Donald Norman (psychologist):

“A good conceptual model allows us to predict the effects of our

actions”

Expensive Out of Block GOTOs

An identifier declaration is visible if we are nested within the block in

which it occurs .

Algol Scope Rule

Example:a : begin array X [1:100];

b : begin array Y [1:100];

goto exit;

exit :

Another example:

procedure P (n);

value n; integer n;

if n=0 then goto out

else P(n-1);

P(25);

Another example:

procedure P (n);

value n; integer n;

if n=0 then goto out

else P(n-1);

P(25);

The goto-statement must be implemented as a call of a run-time routine that find the appropriate activation record

and deletes all the ones above it!

Future Interaction, a Difficult Design Problem

Algol visibility rules versus GOTO statement

Problem of Interaction!

Future Interaction, a Difficult Design Problem

Designer must develop a “nose” for spotting possible problem

areas!

Generality of the for-Loop

for var:=exp step exp' until exp" do stat

for var:=exp while exp ' do stat

for days:= 31, 28, 31, 30, do…

for days:=31,if mod (year , 4) =0 then 29else 28, 31, 30, do…

The Baroque for-Loop

Example:

3 7 11 12 13 14 15 16 8 4 2 1 2 4 8 16 32

for i :=3, 7,

11 step 1 until 16,

i/2 while i>=1,

2 step i until 32

Do print (i)

The Baroque for-Loop

Users should pay only for what they use; avoid distributed costs.

The Localized Cost Principle

Handling Cases with the switch Example:

beginswitch marital status = single, married, divorced;…goto marital status [i];

single: … handle single casegoto done:

married: … handle married casegoto done:

divorced: … handled divorced casedone:end;

The Baroque switch

Example:

beginswitch S=L, if i>0 then M else N, Q;goto S [j];

The Baroque switch

Example:

goto if i>0 then M else N;

Handling Cases with the switch Example:

beginswitch marital status = single, married, divorced;…goto marital status [i];

single: … handle single casegoto done:

married: … handle married casegoto done:

divorced: … handled divorced casedone:end;

The Baroque switch

Example:

The Baroque switch

Example:

goto if i>0 then M else N;

SYNTAX AND ELEGANCE:

ALGOL-60

Programming Languages CourseComputer Engineering DepartmentSharif University of Technology

Outline92

Syntactic Structures

Descriptive tools: BNF

Elegance

Evaluation and Epilog

Outline93

Elegance

Software Portability

Avoid features or facilities that are dependent on a particular computer

or small class of computers.

Portability Principle

Free Format

FORTRAN: fixed format

Algol: free format

Free Format

FORTRAN: fixed format

Algol: free format

Programmers had to think about:

“How a program should be formatted?”

Free Format

Example: FORTRAN style

for i:=1 step 1 until N dobegin real val;Read Real (val);Data [i] := val;end;for i:=1 step 1 until N dosum:= sum + Data [i];avg := sum/N;

Free Format

Example: English style

for i:=1 step 1 until N do begin real val;Read Real (val); Data [i] := val; end; fori:=1 step 1 until N do sum:= sum + Data [i];avg := sum/N;

Free Format

Example: English style

for i:=1 step 1 until N do begin real val;Read Real (val); Data [i] := val; end; fori:=1 step 1 until N do sum:= sum + Data [i];avg := sum/N;

Remember the Structure Principle!

Free Format

Example:

for i:=1 step 1 until N dobegin

real val;Read Real (val);Data [i] := val;

end;for i:=1 step 1 until N do

sum:= sum + Data [i];avg := sum/N;

Levels of Representation

No universal character set!

How to design the lexical structure? Using those symbols available in all char

sets. Design independent of particular char sets.

Levels of Representation

Three levels of the language:1. Reference Language

2. Publication language

3. Hardware representations

a [i+1] := (a [i] + pi ˣ r↑2 ) / 6.021023

a (/i+1/) := (a (/i/) + pi * r**2 ) / 6,02e23

ai+1 ← { ai + π ˣ r2 } / 6.02 ˣ1023

Problems of FORTRAN Lexics Example:

IF IF THEN THEN = 0;

ELSE; ELSE ELSE = 0;

Problems of FORTRAN Lexics Example:

IF IF THEN THEN = 0;

ELSE; ELSE ELSE = 0;

Confusion!

Problems of FORTRAN Lexics How does Algol solve the problem?

if procedure then until := until +1 else do := false;

Lexical Conventions

Reserved words: reserved words cant be used by the

programmer

Keywords: used word by the language are marked in

some unambiguous way

Keywords in Context: used words by the language are keywords

in those context they are expected.

Arbitrary Restrictions, Eliminated!

Number of chars in an identifier Subscript expression

Remember theZero-One-Infinity Principle!

Dangling else

What does the above code mean?

if B then if C then S else T;

if B then begin if C then S else T end;

if B then begin if C then S end else T;

Dangling else

What does the above code mean?

if B then if C then S else T;

Algol solved the problem:

“Consequent of an if-statement must be an unconditional statement”

Algol’s lexical and syntactic structures became so popular that virtually all languages designed since have been

“Algol-like”.

Outline111

Elegance

Various Descriptive tools

Example: numeric denotations 1. Giving Examples:

Gives a clear idea, But not so precise.

Integers such as: ‘-273’Fractions such as: ‘3.76564’Scientific notations: ‘6.021023’

Example: numeric denotations 2. English Description:

Precise, But not so clear!

1. A digit is either 0,1,2,…,9.2. An unsigned integer is a sequence of one or more digits.3. An integer is either a positive sign followed by an unsigned integer or … .4. A decimal fraction is a decimal point immediately followed by an unsigned integer.5. An exponent part is a subten symbol immediately followed by an integer6. A decimal number has one of three forms: … .7. A unsigned number has one of three forms: … .8. Finally, a number … .

3. Backus-Naur Form (BNF)

Backus Formal Syntactic Notation

How to combine perceptual clarity and precision?

Example: FORTRAN subscript expressions

cvv + c or v - cc * vc * v + c′ or c * v - c′

Backus Formal Syntactic Notation

How to combine perceptual clarity and precision?

Example: FORTRAN subscript expressions

cvv + c or v - cc * vc * v + c′ or c * v - c′The formulas make use of

syntactic categories!

Naur’s Adaptation of the Backus Notation

BNF represents: Particular symbols by themselves, And classes of strings (syntactic

categories) by phrases in angle brackets.

Describing Alternates in BNF

Example: alternative forms

Describing Repetition in BNF

Example: recursive definition

Extended BNF

How to directly express the idea “sequence of …”?

Kleene cross Kleene star

<unsigned integer> ::== <digit>+

<identifier> ::== <letter>{<letter>|<digit>}*

Extended BNF

How to directly express the idea “sequence of …”?

Kleene cross Kleene star

Why preferable? Remember the

Structure principle!

Mathematical Theory of PLs

Chomsky type 0, or recursively enumerable languages

Chomsky type 1, or context-sensitive languages

Chomsky type 2, or context-free languages

Chomsky type 3, or regular languages

Mathematical Theory of PLs

Languages described by BNF are context-free.

→Mathematical analysis of the syntax and grammar of PLs.

Outline124

Elegance

Design Has Three DimensionsEfficiency

Scientific

Economy

Social

Elegance

Symbolic

Efficiency

Efficiency seeks to minimize resources used.

Resources : Memory usage Processing time Compile time Programmer typing time

Economy

Economy seeks to maximize social benefit compared to its cost.

The public: The programming community. Trade offs are hard to make since values

change unpredictably. Social factors are often more important

than scientific ones. (E.g. major manufacturers, prestigious universities, influential organizations)

Elegance

The feature interaction problem. It is impossible to analyze all the possible feature

interactions. All we need to do is to restrict our attention to

designs in which feature interactions look good.

Designs that look good will also be good. Good designers choose to work in a region of

the design in which good designs look good. A sense of elegance is acquired through

design experience. Design, criticize, revise, discard!

Outline129

Elegance

Evaluation

Algol-60 never achieved widespread use.

Algol had no input-output Little uniformity among input-output

conventions. It was decided that input-output would be

accomplished by using library procedures. Eventually several sets of input-output

procedures were designed for Algol: It was too late!

Algol directly competed with FORTRAN

Same application area.

FORTRAN had gained considerable ground.

More focus on reductive aspects of Algol.

IBM decided against supporting Algol.

Algol became an almost exclusively academic

language.

A Major Milestone

Introduced programming language terminology.

Influenced most succeeding languages.

An over general language: Quest for simplicity

that resulted in Pascal.

The basis of several extension, like Simula.

Computer architects began to support Algol

implementation.

Second Generation Programming Languages

Algol-60: The first second generation

programming language.

Data structures are close to first-generation

structures.

Hierarchically nested name structures.

Structured control structures (e.g. recursive

procedures, parameter passing modes).

Shifted from free formats.

The End!

algol-60 generality and hierarchy programming languages course computer engineering department...

sum dataibegin

sum dataithe body

n dosum

original algol

standard mathematical

runtime distinctionfortran

bnf notation backusnaur

precise method

Documents

programming language (algol,fortran,basic)

algol-60 generality and hierarchy

expressing generality pm751.tif

algol prosp sem 2012 13

generality about dyeing process

modul praktikum algol jauharifirmansyah 20101

algol 60rettungszeichenleuchten | exit sign luminaires |...

algol ailesi programlama dilleri

algol validation algolvl

algol group

the algol mystery

generality of languages

ab38.3.1 a commentary on the algol 60 revised...

generality of metrology

algol trab

algol x and algol y - cwi amsterdam lambert meertens.pdf ·...

algol programmeits reference...

spectroscopically resolving the algol triple system ·...

the algol family and ml

algebraic generality vs arithmetic generality in the ... ·...