Programming Languages The Beginning

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

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

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

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

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!

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

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

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?

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

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

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

BNF BNF is a simple notation used to describe syntax precisely Example: ::= | ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

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

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”

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

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

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”

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

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

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

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

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)

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

Example of Call by Reference procedure A int X X = 5 call B (X) end 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.

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

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

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

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

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

The End