Department of Computer Science
Department of Computer Science
These are very incomplete and ill-informed notes. Some
bits have come from good references (found through Google) when I
needed to look up dates or details, but most of it I have
made up. My memory is failing due to old age but I have
still tried to rely on it (you'd better follow some of the links!).
To make things worse some of the observations, judgments and
opinions expressed are personal and in some cases just pure prejudice.
I do not know where the beginning is. Some say that the nineteenth century collaboration between Byron's daughter and Chales Babbage involved ``programming'', but who cares? More recently, in 1936, Alonzo Church produced the lambda calculus, a model of computation, in an attempt to define the limits of computability. Computations can be expressed in this calculus, however it's not regarded as a programming language. Between 1943 and 1946 in Bavaria, Konrad Zuse produced a computing machine and a language called Plankalkül. The language was an operator language with expressions (a bit like APL). But little was heard of this language for over twenty years when the work was re-discovered, consequently it cannot be considered very influential.
Most computing machines of the forties were not stored program machines and therefore did not need a programming language. But by about 1949 there were some including EDVAC in the US and EDSAC in Cambridge. These machines were first programmed by keying in binary representations of machine instructions. This evolved into hexadecimal and later into assembler languages. Later there were langages called ``autocodes'' that were higher level and needed compilation. One of the first ``compilers'' was produced by Grace Hopper, later a Rear Admiral in the US navy, in 1953 or 1953.
The development of Fortran was a landmark in computing history, it was machine independent, widely used, and quite high level. It contained expressions that no longer had a simple, almost one to one, relationship to the computer instructions. It was developed in the mid fifties by a team include John Backus at IBM. In many ways computer languages haven't changed a lot since, they all have variables, assignment, arrays, expressions, similar control structures, sub-routines and functions (though sub-programs were in a later Fortran). A lot of the later features like, classes, modules and other stuff have not really changed the main programming components and the nature of languages or programming.
The following is a small Fortran program. I think it mainly uses features present in Fortran IV but some might be later. It prints all the prime numbers upto a 1000.
INTEGER isprime(1000)
INTEGER i, multi, n
DO 55 i=2,1000,1
isprime(i) = 1
55 CONTINUE
DO 66 i=2,500,1
IF( isprime(i) .EQ. 1) THEN
DO 77 multi=i+i,1000,i
isprime(multi) = 0
77 CONTINUE
END IF
66 CONTINUE
DO 88 i=2,1000,1
IF(isprime(i) .EQ. 1) THEN
PRINT *, i
END IF
88 CONTINUE
STOP
END
Notice:
After Fortran the next most influential language. It was produced by a committee, not a company or individual. Here is an example, the Sieve of Erastosthenes, like the Fortran:
BEGIN
BOOLEAN ARRAY isprime(2:1000);
INTEGER i,multi,n;
FOR i:=2 STEP 1 UNTIL 1000 DO isprime(i) := TRUE;
FOR i:=2 STEP 1 UNTIL 1000/2 DO
IF isprime(i) THEN
FOR multi:=i+i STEP i UNTIL 1000 DO
isprime(multi) := FALSE;
n:=0;
FOR i:=2 STEP 1 UNTIL 1000 DO
IF isprime(i) THEN
BEGIN
IF n=10 THEN BEGIN outimage; n:=1 END
ELSE n:=n+1;
outint(i,5); outtext(", ");
END
END
Actually this program has been executed by a Simula67 compiler, not
an Algol one.
But since Simula67 has Algol as a subset it is not too big
a fraud. Everything is the same except that outimage,
outint, and outtext are Simula I/O statements.
Notes:
One of the important aspects of the development of Algol was
that it produced a report formally defining the structure
of the language using a new grammar notation devised for
the purpose, called BNF, Backus Naur Form. This
was the first use of formal grammar definition before implementation,
something all later languages have done (with the exception of C).
The semantics
were defined informally, and still are in most languages.
Here is an example of a fragment of the Algol60 report:
![\includegraphics[width=0.75\hsize]{algol60-rep-fragment.eps}](hist-img1.png)
This language was designed in 1960 by the CODASYL committee based on work done by Grace Hopper on commercial languages such as Flowmatic. It was intended to be used for commercial data processing: record and file oriented applications. It was also intended to be readable by non-programmers such as managers. For the next 20 years it was the most heavily used programming language.
I found the following program somewhere, I can't compile it, I don't know if it's correct but at least it gives some idea of the what it looks like. The original is quite long so I've cut some of it out.
identification division.
program-id. example.
author. Jacques Levin.
environment division.
input-output section.
file-control.
select employee-file-in assign to input "calcpay.in".
select employee-file-out assign to output "calcpay.out".
data division.
file section.
fd employee-file-in
label records standard
block contains 5 records
record contains 31 characters
data record is employee-record-in.
01 employee-record-in.
02 employee-name-in pic x(20).
02 employee-rate-in pic 9(3)v99.
02 employee-hours-in pic 9(3)v99.
02 line-feed-in pic x(1).
fd employee-file-out
label records omitted
...
procedure division.
a000-control-logic.
perform b100-initialize-processing.
perform b200-process-data
until end-of-file equal to 'y'.
perform b300-terminate-processing.
stop run.
b200-process-data.
perform x100-read-data.
perform c100-calc-regular-pay.
if employee-hours-in is greater than 40
perform c200-calc-overtime-pay.
perform x200-write-data.
x100-read-data.
read employee-file-in
at end move 'y' to end-of-file.
...
Notes:
In 1958 Marvin Minsky and John McCarthy at M.I.T. designed a language for symbolic computation called Lisp (for ``list processing''). This meant that it would need dynamic, flexible data structures that could be easily created and discarded. In 1960 this language evolved into Lisp 1.5 which has been in use continuously ever since, especially for artificial intelligence programming. Here is a very small example, on function to work out the greatest common divisor of two numbers and a call on it:
(defun gcd (a b)
(cond ((eq a b) a)
((> a b) (gcd (- a b) b))
(t (gcd a (- b a)))
)
)
(gcd 30 42)
Notes:
Simula67 was produced in Norway for discrete event simulation. It was built on top of Algol60, the main extension was a CLASS structure to provide a record and coroutine facility for implementing active ``process'' components for simulation. In addition these classes could ``inherit'' from another class by using ``prefixing''. The class and inheritance are very close to those in most object oriented programming language. The only difference is that there was no data hiding or encapsulation with Simula classes, all data fields are freely accessible to all code outside the class. Also ``object orientedness'' wouldn't be invented for about 13 years. The mechanisms existed but the idea of programming in that way did not arrive until 1971.
BEGIN
CLASS Stack(size); INTEGER size;
BEGIN
INTEGER ARRAY mem(0:size-1);
INTEGER topp;
BOOLEAN PROCEDURE empty;
BEGIN empty := topp < 0; END;
INTEGER PROCEDURE top;
BEGIN
IF NOT empty THEN top := mem(topp)
ELSE BEGIN OutText("panic"); OutImage END
END;
PROCEDURE pop;
BEGIN
IF NOT empty THEN topp := topp-1
ELSE BEGIN OutText("panic"); OutImage END
END;
PROCEDURE push(e); INTEGER e;
BEGIN
IF topp<size-1 THEN
BEGIN
topp := topp+1; mem(topp) := e;
END
END;
topp := -1;
END;
INTEGER n;
REF(Stack) filo;
filo :- NEW Stack(100);
FOR n:=10 STEP 10 UNTIL 90 DO filo.push(n);
OutText("contents of stack: ");
WHILE NOT filo.empty DO
BEGIN
OutInt( filo.top, 3); filo.pop
END;
OutImage;
END;
Notes:
Pascal was designed in 1970 by Prof. Niklaus Wirth at ETH Zürich. He had been a member of the Algol committee and has earlier designed Algol-W which was Algol with records. Pascal was a beautiful simple, clear, consistent language. It introduced simple type definitions, pointers and record structures. Its biggest weakness was that it had no rules about separate compilation or multi-file programs. It has had a major influence on later programming language design.
program list;
type
link = ^cell;
cell = record
val : integer;
nxt : link;
end;
var
cursor, root : link;
i : integer;
function atfront(v : integer; ptr: link): link;
var
tmp : link;
begin
new(tmp);
tmp^.val := v;
tmp^.nxt := ptr;
atfront := tmp;
end; { atfront }
begin
root:=nil;
for i:=1 to 10 do root := atfront(i*10, root);
cursor := root;
while cursor <> nil do
begin
write( cursor^.val); write(' ');
cursor := cursor^.nxt;
end;
writeln;
end.
It is very difficult to choose which languages to mention and which to omit. The ones listed already are the most important or influential but there are many others.
This gets a mention because it was so unusual, not because it is widely used or because it is influential (it is neither of these).
Prolog evolved out of research at the University of Aix-Marseille in the late 60's and early 70's. Alain Colmerauer and Phillipe Roussel collaborated with Robert Kowalski of the University of Edinburgh to create the underlying design of Prolog. Kowalski contributed the theoretical framework on which Prolog is founded while Colmerauer's research at that time provided means to formalize the Prolog language. By 1972 the basic design of Prolog was complete. The first Prolog compiler widely used was written by David Warren at the University of Edinburgh.
The language has no sequential statement execution, no stored variables, no evaluable expressions, it works by attempting to prove ``logic'' theorems.
The name stands for ``If you See What I Mean''. ISWIM was described by Peter Landin in a paper he published in 1966 called the The next 700 programming languages [#!Landin66!#]. It was a simple elegant functional language. It was never implemented but it influenced later languages like Miranda and Haskell.
Created in 1964 by Thomas Kurtz and John Kemeny at Dartmouth College. Soon it was the main language of a successful early multi-access timesharing system the Dartmouth Time Sharing System. It was intended to be for beginners. It was line oriented, with no structure and parameter-less subroutines. However it proved very popular.
In 1977 the Seventh Edition of Unix was released and it contained a new command shell written by Steve Bourne. The new shell was really designed as a programming language rather than operating system commands with some control flow features. It had variables, assignment, loops, conditionals etc.
I have chosen this one command shell as important because, as a result of its success, I believe it helped influence the development of other scripting languages. Command languages existed before, other languages might have been embryo scripting languages, but Bourne's sh was a strong influence.
Example. Here is a silly little script that will delete all the files in a directory except those named on the command line, before deleting it prompts for a ``y'' or ``n'' answer.
#!/bin/sh
for f in *; do
for s in $*; do
if [ "$f" = "$s" ]; then continue 2; fi
done
echo -n "deleting $f, confirm(y/n): "
read ANS
if [ "$ANS" = "y" ]; then rm -f $f; fi
done
Notes:
$* in the nested loop matches all the
command line arguments,
© University of Hertfordshire Higher Education Corporation