1. Programming Languages
The Beginning

2. In the beginning...
Computers were very expensive; programmers were cheap
Programming was by plugboards or binary numbers (on-off switches)
Memories were maybe 4K and up
Cycle times were in milliseconds
No compromises for programmer's ease

3. Early compromises Assembly language FORTRAN reduced human error
programs were just as efficient
FORTRAN
the compiler generated very efficient code
easier to read, understand, debug
need to compile was still extra overhead
the idea was: compile once, run many times

4. The Automation Principle
Automate mechanical, tedious, or error-prone activities.
Higher-level languages are an example
Assembly language automates writing binary code
FORTRAN automates writing assembly language or binary code
Textbook, p. 10

5. FORTRAN Efficiency was everything
Card oriented, with information in fixed columns
First language to catch on in a big way
Because it was first, FORTRAN has many, many "mistakes"
Algol 60 was a great leap forward

6. Expressions In FORTRAN, an expression...
In a WRITE statement, could be c (constant), v (variable), or v+c, or v-c
As a parameter, could be c or v
As an array subscript, could be c, v, c*v, v+c, v-c, c*v+c, or c*v-c
On the RHS of an assignment, could be anything
In Algol 60, an expression is an expression is an expression!

7. The Regularity Principle
Regular rules, without exceptions, are easier to learn, use, describe, and implement.
Arithmetic expressions in FORTRAN vs. Algol are an example
BNF is a great aid to imposing regularity
Textbook, p. 11

8. Lexical Conventions
Reserved words, used in most modern languages (C, Pascal, Java)
Easier for experts, somewhat harder for novices
Keywords, unambiguously marked
Hard to type and often hard to read
Keywords in context (FORTRAN, PL/1)
If it makes sense as a keyword, it's a keyword, otherwise it's something else

9. The Reserved Word Controversy
FORTRAN had no reserved words
IF (I) = 1 was an array assignment
Advantages of reserved words
Easier for the compiler writer
Helps avoid ambiguities in the language
Disadvantages of reserved words
Programmer has to know them all
Few reserved words imply less language power?

10. Other FORTRAN "Mistakes"
The FORTRAN compiler ignored blanks
DO 50 I=1,10 became DO50I=1,10
Did not require variable declarations
Misspellings were automatically new variables
Earliest versions did not have subprograms
But they did have callable library routines
DO , IF, and GO TO were the only control structures

11. The Impossible Error Principle
Making errors impossible to commit is preferable to detecting them after their commission.
In FORTRAN, variables were declared simply by appearing in a program
DO 50 I = is an assignment to DO50I
In general, the earlier an error can be detected, the better
Textbook, p. 12

12. Algol 60 Introduced the idea of a virtual machine
Used BNF to define syntax formally
Introduced nested scopes
Introduced free-format programs
Introduced recursion
Required declarations of all variables
Introduced if-then-else and flexible loops

13. Algol 60 was three+ languages
The language definition was given in the reference language
Algorithms were published using the publication language, in which keywords were boldface
Programs were in a hardware representation
Often looked like: 'IF' X < Y 'THEN' X := X + 1
Difficult to type, difficult to read

14. Algol 60 Shortcomings Algol 60 had no input/output!
I/O was considered to be too hardware-specific
Most implementations “borrowed” FORTRAN's I/O
Used “call by name” semantics
powerful, but hard to implement
sometimes hard to understand
Few but very flexible control structures were considered to be “baroque”

15. Metalanguages
A metalanguage is a language used to talk about a language (usually a different one)
We can use English as its own metalanguage (e.g. describing English grammar in English)
It is essential to distinguish between the metalanguage terms and the object language terms

16. BNF BNF stands for either Backus Naur Form or Backus Normal Form
BNF is a metalanguage used to describe the grammar of a programming language
BNF is formal and precise
BNF is essential in compiler construction
There are many dialects of BNF in use, but…
…the differences are almost always minor

17. BNF
< > indicate a nonterminal that needs to be further expanded, e.g. <variable>
Symbols not enclosed in < > are terminals; they represent themselves, e.g. if, while, (
The symbol ::= means is defined as
The symbol | means or; it separates alternatives, e.g. <addop> ::= + | -

18. BNF uses recursion
<integer> ::= <digit> | <integer> <digit> or <integer> ::= <digit> | <digit> <integer>
Many people find recursion confusing
"Extended BNF" allows repetition as well as recursion
Repetition is often more efficient when using BNF to construct a compiler

19. BNF Examples I <digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<if statement> ::= if ( <condition> ) <statement> | if ( <condition> ) <statement> else <statement>

20. BNF Examples II
<unsigned integer> ::= <digit> | <unsigned integer> <digit>
<integer> ::= <unsigned integer> | + <unsigned integer> | - <unsigned integer>

21. BNF Examples III
<identifier> ::= <letter> | <identifier> <letter> | <identifier> <digit>
<block> ::= { <statement list> }
<statement list> ::= <statement> | <statement list> <statement>

22. BNF Examples IV
<statement> ::= <block> | <assignment statement> | <break statement> | <continue statement> | <do statement> | <for loop> | <goto statement> | <if statement> |

23. Extended BNF The following are pretty standard:
[ ] enclose an optional part of the rule
{ } mean the enclosed can be repeated any number of times (including zero)
The textbook uses a different notation:
x* means repeat x zero or more times
x+ means repeat x one or more times
{ } enclose alternatives, usually listed vertically

24. Limitations of BNF
No easy way to impose length limitations, such as maximum length of variable names
No way to impose distributed requirements, such as, a variable must be declared before it is used
Describes only syntax, not semantics
Nothing clearly better has been devised

25. Functions and Procedures
In mathematics, a function:
returns a value
has no side effects (except maybe I/O)
does not alter its parameters
A procedure (a.k.a. subroutine):
does not return a value
is called precisely for its side effects
may (probably does) alter its parameters

26. C Has No Procedures Functions may return void (no value)
Functions really can’t alter their parameters
This is inadequate for real programs
There are workarounds, such as passing pointers to values
Hence, “functions” in C are seriously distorted

27. Predicates A predicate is a binary (two-valued) function
In some languages, a predicate returns “true” or “false”
In other languages (Snobol IV, Prolog, Icon), a predicate “succeeds” or “fails”

28. Methods A procedure or function is called directly
In an O-O language, an object has methods
A message is sent to an object
The object decides what to do about the message
Typically, the object chooses a method to execute

29. Scope Rules
The scope of a variable is the part of a program in which it is defined and accessible
FORTRAN: scope is the enclosing subprogram
Prolog: scope is the (one) enclosing clause
Java: scope is from point of definition to }
Algol, Pascal: scopes are nested

30. Nested Scopes
begin int x, y; int x and int y are defined here begin float x, z; int y, float x, float z are defined here this is a “hole” in the scope of int x end int x, int y are defined here end

31. Actual and Formal Parameters
Parameters are passed to subprograms in a variety of ways
Actual parameters are the values used in a call to the subprogram
Formal parameters are the names used for those values in the subprogram

32. Parameter Transmission
Call by reference (FORTRAN, Pascal, Java)
Call by value (C, Pascal, Java)
Call by name (Algol 60)
Call by value-result (Ada)
Call by unification (Prolog)

33. Call by Reference
Every value (data item) is stored at some particular machine address
The subprogram is given that address
The subprogram directly manipulates the original data item
This is the most efficient way to pass parameters
In FORTRAN, could alter “constants” this way

34. Example of Call by Reference
procedure A int X X = 5
call B (X) end
procedure B (Y) Y = Y + 1
end
X is stored in only one place (that place is in A), and B is made to refer to that place.

35. Call by Value Subprograms are given a copy of the formal parameter
Subprograms are free to change their copy
The changed value is not copied back
Safe, but not efficient or flexible
C uses call-by-value exclusively
workaround: pass a pointer to the data item

36. Example of Call by Value
procedure A int X X = 5
call B (X) end
procedure B (Y) Y = Y + 1
end
Value is copied down when B is called, and never copied back up

37. Call by Name Used in Algol 60, hardly anywhere else
Uses the copy rule: the subprogram acts as if it had a textual copy of the formal parameter
Mathematically, this is very neat
Doesn’t play well with scope rules
Violates information hiding (names matter)
Difficult to implement and usually inefficient

38. Example of Call by Name int a, r;
function fiddle (int x) { int a = 3, b = 5; return a * x + b; // means a * (a+1) + b }
a = 9; r = fiddle (a+1); // should return 17 print (r);

39. Algol Supported Recursion
Four rules for recursion:
Always check for base cases first
Recur only with a simpler case
Avoid global variables
Don’t look down

40. The End