Consider a Special C Language

⧫ No dynamic variables
⚫ All variables are global and static; no malloc(), free()
int i,j,k;
float temperature[100]; If, in addition, no
void init_temp() { type-define, then
for (i=0; i<100; i++) { you pretty much
have the first high-
temperature[i] = 0.0; level programming
} language: FORTRAN
}
⚫ How to program? How about hash table? binary tree?
Problems: developing large programs, making errors,
being inflexible, managing storage by programmers, …
0
Outline
⧫ Evolution of Programming Languages (Ch. 2)
⚫ Influences on Language Design (Sec. 1.4)
⚫ Language Categories (Sec. 1.5)
⚫ Programming Domains (Sec. 1.2)

1
The Dawn of Modern Computers
⧫ Early computers (40’s and early 50’s) are
programmed using machine code directly:
⚫ Limited hardware; no FP, indexing, system software
⚫ Computers more expensive than programmers/users
⚫ Poor readability,
modifiability,
expressiveness
⚫ Describe computation
flows
⚫ Mimic von Neumann
architecture

2
Early Programming
⧫ Programmers have to enter machine code to
program the computer
⚫ Floating point: coders had to keep track of the
exponent manually
⚫ Relative addressing: codes had to be adjusted by
hand for the absolute addresses
⚫ Array subscripting needed
⚫ Something easier to remember than octal opcodes
⧫ Early aids:
⚫ Assembly languages and assemblers: English-like
phrases 1-to-1 representation of machine instructions
⧫ Saving programmer time became important …
3
Fortran
⧫ First popular high-level programming language
⚫ Computers were small and unreliable
→ machine efficiency was most important
⚫ Applications were scientific
→ need good array handling and counting loops
⧫ "The IBM Mathematical FORmula TRANslating
System: FORTRAN", 1954: (John Backus at IBM)
⚫ To generate code comparable with hand-written code
using simple, primitive compilers
⚫ Closely tied to the IBM 704 architecture, which had
index registers and floating point hardware

4
Fortran
⧫ Fortran I (1957)
⚫ Names could have up to six characters, formatted
I/O, user-defined subprograms, no data typing
⚫ No separate compilation (compiling “large” programs
– a few hundred lines – approached 704 MTTF)
⚫ Highly optimize code with static types and storage
⧫ Later versions evolved with more features and
platform independence
⚫ Almost all designers learned from Fortran and Fortran
team pioneered things such as scanning, parsing,
register allocation, code generation, optimization

5
FORTRAN and von Neumann Arch.
⧫ FORTRAN, and all other imperative languages,
which dominate programming, mimic von
Neumann architecture
⚫ Variables → memory cells
⚫ Assignment statements → data piping between
memory and CPU
⚫ Operations and expressions → CPU executions
⚫ Explicit control of execution flows
⚫ Efficient mapping between language and HW
→ efficient execution performance, but limited by von
Neumann bottleneck

6
FORTRAN Programming Style
⧫ Global view, top down
i=0; f=0;
⧫ Program starts from first
executable statement and N
follow a sequential flow i<N
with go-to Y
⚫ Conceptually, a large f = f + c[i]*x[i]; f = 0;
main() including
everything but without
main() declaration, i = i+1;
though FORTRAN has functions
⚫ Match a flow chart with traces
Problems: developing large programs, making errors,
being inflexible, managing storage by programmers, … 7
Functional Programming: LISP
⧫ AI research needed a language to
⚫ Process data in lists (rather than arrays)
⚫ Symbolic computation (rather than numeric)
⧫ John McCarthy of MIT developed LISP (LISt
Processing language) in 1958
⧫ A LISP program is a list:
(+ a (* b c))
⚫ List form both for input and for function
⚫ Only two data types: atoms and lists

8
LISP
⧫ Example: a factorial function in LISP
(defun fact (x)
(if (<= x 0)
1
(* x (fact (- x 1)))
)
)
⧫ Second-oldest general-purpose programming
language still in use
⚫ Ideas, e.g. conditional expression, recursion, garbage
collection, were adopted by other imperative lang.

9
LISP
⧫ Pioneered functional programming
⚫ Computations by applying functions to parameters
⚫ No concept of variables (storage) or assignment
◼ Single-valued variables: no assignment, not storage
⚫ Control via recursion and conditional expressions
◼ Branches → conditional expressions
◼ Iterations → recursion
⚫ Dynamically allocated linked lists

10
First Step Towards Sophistication
⧫ Environment (1957-1958):
⚫ FORTRAN had (barely) arrived for IBM 70x
⚫ Many other languages, but all for specific machines
→ no universal lang. for communicating algorithms
⚫ Programmer productivity became important
⧫ ALGOL: universal, international, machine-
independent (imperative) language for
expressing scientific algorithms
⚫ Eventually, 3 major designs: ALGOL 58, 60, and 68
⚫ Developed by increasingly large international
committees
11
Issues to Address (I)
⧫ Early languages used label-oriented control:
GO TO 27
30 IF (A-B) 5,6,7
⧫ ALGOL supports sufficient phrase-level control,
such as if, while, switch, for, until
→structured programming
⧫ Programming style:
⚫ Programs consist of blocks of code: blocks →
functions → files → directories
⚫ Bottom-up development possible
⚫ Easy to develop, read, maintain; make fewer errors

12
Issues to Address (II)
⧫ ALGOL designs avoided special cases:
⚫ Free-format lexical structure
⚫ No arbitrary limits:
◼ Any number of characters in a name
◼ Any number of dimensions for an array
⚫ Orthogonality: every meaningful combination of
primitive concepts is legal—no special forbidden
combinations to remember
◼ Each combination not permitted is a special case that
must be remembered by the programmer

13
Example of Orthogonality

Integers Arrays Procedures

⧫ By ALGOL 68, all combinations above are legal

14
Influences
⧫ Virtually all languages after 1958 used ideas
pioneered by the ALGOL designs:
⚫ Free-format lexical structure
⚫ No limit to length of names and array dimension
⚫ BNF definition of syntax
⚫ Concept of type
⚫ Block structure (local scope)
⚫ Compound stmt (begin end), nested if-then-else
⚫ Stack-dynamic arrays
⚫ Call by value (and call by name)
⚫ Recursive subroutines and conditional expressions
15
Beginning of Timesharing: BASIC
⧫ BASIC (Beginner’s All-purpose Symbolic
Instruction Code)
⚫ Kemeny & Kurtz at Dartmouth, 1963
⧫ Design goals:
⚫ Easy to learn and use for non-science students
⚫ Must be “pleasant and friendly”
⚫ Fast turnaround for homework
⚫ Free and private access
⚫ User time is more important than computer time
⧫ First widely used language with time sharing
⚫ Simultaneous individual access through terminals
16
Everything for Everybody: PL/I
⧫ IBM at 1963-1964:
⚫ Scientific computing: IBM 1620 and 7090, FORTRAN
⚫ Business computing: IBM 1401 and 7080, COBOL
⚫ Scientific users began to need elaborate I/O, like in
COBOL; business users began to need FP and arrays
⧫ The obvious solution
⚫ New computer to do both → IBM System/360
⚫ Design a new language to do both → PL/I
⧫ Results:
⚫ Unit-level concurrency, exception handling, pointer
⚫ But, too many and too complex
17
Beginning of Data Abstraction
⧫ SIMULA
⚫ Designed primarily for system simulation in University
of Oslo, Norway, by Nygaard and Dahl
⧫ Starting 1961: SIMULA I, SIMULA 67
⧫ Primary contributions
⚫ Co-routines: a kind of subprogram
⚫ Implemented in a structure called a class, which
include both local data and functionality and are the
basis for data abstraction

18
Object-Oriented Programming
⧫ Smalltalk: Alan Kay, Xerox PARC, 1972
⧫ First full implementation of an object-oriented
language
⚫ Everything is an object: variables, constants,
activation records, classes, etc.
⚫ All computation is performed by objects sending and
receiving messages
⚫ Data abstraction, inheritance, dynamic type binding
⧫ Also pioneered graphical user
interface design

Dynabook (1972) 19
Programming Based on Logic: Prolog
⧫ Developed by Comerauer and Roussel
(University of Aix-Marseille) in 1972, with help
from Kowalski (University of Edinburgh)
⧫ Based on formal logic
⧫ Non-procedural
⚫ Only supply relevant facts (predicate calculus) and
inference rules (resolutions)
⚫ System then infer the truth of given queries/goals
⧫ Highly inefficient, small application areas
(database, AI)

20
Logic Languages
⧫ Example: relationship among people
fact: mother(joanne,jake).
father(vern,joanne).
rule: grandparent(X,Z) :- parent(X,Y),
parent(Y,Z).
goal: grandparent(vern,jake).

⧫ Features of logic languages (Prolog):

21
Genealogy
of
Common
Languages

(Fig. 2.1)

22
Summary: Application Domain
⧫ Application domains have distinctive (and
conflicting) needs and affect prog. lang.
⚫ Scientific applications: high performance with a large
number of floating point computations, e.g., Fortran
⚫ Business applications: report generation that use
decimal numbers and characters, e.g., COBOL
⚫ Artificial intelligence: symbols rather than numbers
manipulated, e.g., LISP
⚫ Systems programming: low-level access and
efficiency for SW interface to devices, e.g., C
⚫ Web software: diff. kinds of lang. markup (XHTML),
scripting (PHP), general-purpose (Java)
23
Summary: Programming
Methodology in Perspective
⧫ 1950s and early 1960s: simple applications;
worry about machine efficiency (FORTRAN)
⧫ Late 1960s: people efficiency important;
readability, better control structures (ALGOL)
⚫ Structured programming
⚫ Top-down design and step-wise refinement
⧫ Late 1970s: process-oriented to data-oriented
⚫ Data abstraction
⧫ Middle 1980s: object-oriented programming
⚫ Data abstraction + inheritance + dynamic binding

24
Theory of PL: Turing Equivalence
⧫ Languages have different strengths, but
fundamentally they all have the same power
{problems solvable in Java}
= {problems solvable in Fortran}
=…
⧫ And all have the same power as various
mathematical models of computation
= {problems solvable by Turing machine}
= {problems solvable by lambda calculus}
=…
⧫ Church-Turing thesis: this is what “computability” means

25