ALGOL-60 GENERALITY AND HIERARCHY Programming Languages Course Computer Engineering Department Sharif University of Technology.

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

4

The International Algebraic Language

5

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

6

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.

7

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.

8

Outline



Name Structures

Data Structures

Control Structures

9

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

10

Category of Construct

Declaratives: bind name to the objects Variables Procedures Switches

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

11

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

12

The Stack, the Central Run-Time Data Structure

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

13

14

Outline



Name Structures

Data Structures

Control Structures

15

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

16

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);

end

Example


17

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

a[i]

The body of a for loop is one

statement by default.

begin


sum:=sum+Data[i];

Print Real(sum);

end

Example


18

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

a[i]

begin


sum:=sum+Data[i];

Print Real(sum);

end

The compound statement is used

where one statement is permitted.

19

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.

20

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

21

Sample Contour Diagram

xyf

y

zA

count

22

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

23

Static and Dynamic Scoping

24


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.

25

Example

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

26

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.

27

Contour Diagram of Dynamic Scoping

mP

(a)

m(b)Call P

DLm:=1

(P)

28

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.

29

Contour Diagram of Static Scoping

mP

(a)

m(b)Call P

DLm:=1

(P)

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;

end

30

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;

end

31





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

end

32

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)



36

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

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

37


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.

38

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.

39

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

Responsible Design Principle

40

Outline



Name Structures

Data Structures

Control Structures

41

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.

42

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.

43

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

44

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

time.

45

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;

end


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

end

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;

n:=3;


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;

begin

.

.

end;

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;

end;


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;

end;


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 ;

end

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;

…

end;

exit :

…

end


Another example:

begin

procedure P (n);

value n; integer n;

if n=0 then goto out

else P(n-1);

P(25);

out:

end


Another example:

begin

procedure P (n);

value n; integer n;

if n=0 then goto out

else P(n-1);

P(25);

out:

end

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

end

The Baroque switch

Example:


end

goto if i>0 then M else N;

88

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;

89

The Baroque switch

Example:


end

90

The Baroque switch

Example:


end

goto if i>0 then M else N;

91

SYNTAX AND ELEGANCE:

ALGOL-60

Programming Languages CourseComputer Engineering DepartmentSharif University of Technology

92

Outline92

Syntactic Structures

Descriptive tools: BNF

Elegance

Evaluation and Epilog

93

Outline93



Elegance


94

Software Portability

Avoid features or facilities that are dependent on a particular computer

or small class of computers.

Portability Principle

95

Free Format

FORTRAN: fixed format

Algol: free format

96

Free Format

FORTRAN: fixed format

Algol: free format

Programmers had to think about:

“How a program should be formatted?”

97

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;

98

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;

99

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!

100

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;

101

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.

102

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

103

Problems of FORTRAN Lexics Example:

IF IF THEN THEN = 0;

ELSE; ELSE ELSE = 0;

104

Problems of FORTRAN Lexics Example:

IF IF THEN THEN = 0;

ELSE; ELSE ELSE = 0;

Confusion!

105

Problems of FORTRAN Lexics How does Algol solve the problem?

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

106

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.

107

Arbitrary Restrictions, Eliminated!

Number of chars in an identifier Subscript expression

Remember theZero-One-Infinity Principle!

108

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;

109

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”

110

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

“Algol-like”.

111

Outline111



Elegance


112

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’

113


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

114


3. Backus-Naur Form (BNF)

115

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′

116

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!

117

Naur’s Adaptation of the Backus Notation

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

categories) by phrases in angle brackets.

<decimal fraction> ::== .<unsigned integer>

118

Describing Alternates in BNF

Example: alternative forms

<integer> ::== +<unsigned integer>| -<unsigned integer>| <unsigned integer>

119

Describing Repetition in BNF

Example: recursive definition

<unsigned integer> ::== <digit> | <unsigned integer><digit>

120

Extended BNF

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

Kleene cross Kleene star

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

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

<integer> ::== [+/-]<unsigned integer>

121

Extended BNF

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

Kleene cross Kleene star

Why preferable? Remember the

Structure principle!

122

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

123

Mathematical Theory of PLs

Languages described by BNF are context-free.

→Mathematical analysis of the syntax and grammar of PLs.

124

Outline124



Elegance


125

Design Has Three DimensionsEfficiency

Scientific

Economy

Social

Elegance

Symbolic

126

Efficiency

Efficiency seeks to minimize resources used.

Resources : Memory usage Processing time Compile time Programmer typing time

127

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)

128

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!

129

Outline129



Elegance


130

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!

131

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.

132

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.

133

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.

134

The End!

ALGOL-60 GENERALITY AND HIERARCHY Programming Languages Course Computer Engineering Department Sharif University of Technology.

Documents

sum dataibegin

sum dataithe body

n dosum

original algol

standard mathematical

runtime distinctionfortran

bnf notation backusnaur

precise method