Programming Languages

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 • 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. Automation • Mechanical, tedious, or error-prone activities should be automated • Higher-level languages are an example • Assembly language automates writing binary code • FORTRAN automates writing assembly language or binary code

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. Regularity • 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

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 = 1. 10 is an assignment to DO50I • In general, the earlier an error can be detected, the better

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. BNF • BNF is a simple notation used to describe syntax precisely • Example:<integer> ::= <digit> | <integer> <digit> <digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

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

15. 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”

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

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

18. 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”

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

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

21. 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 hereend

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

23. 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)

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

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

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

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

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

29. 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 17print (r);

30. Algol Supported Recursion • Example: • integer function factorial (n) begin if (n = 0) then return 1 else return n * factorial (n - 1) end

31. The End