1

Chapter 2 – History of Programming

Languages

Outline
2.1 Appearance of high level language
2.2 Development of HLL
2.3 History of PL
2.4 Some special languages
2.5 Classification of PL
 Issues about PL

• To understand how to implement and design

language
– syntax – What a program looks like
– semantics – What a program means
– Implementation – How a program is executed

• What language is the most appropriate about

special demand?
– Pascal, C – procedural, statement oriented
– C++, Java, C#, Smalltalk – Object oriented
– Prolog – Rule-based
 Language Goals

• During 1950s-1960s
– It is done that compile to execute program efficiently
– relation between language element and hardware : integers,
reals, goto statements
– Programmer was cheap and machine was expensive

• But today
– It is done that compile program to be produced efficiently
– CPU power and memory are very cheap.
– relation between language element and design conception:
encapsulation, inheritance, assertions
2.1 Appearance of high level language

Layer of Programming Language

 High level vs. no high level…
 HLL  Machine Language
(lowest level)
» Near to natural language
» Near to HW
» Consist of word, number,
mathematical symbol » Consist of 0 and 1
» HW can’t understand it » HW can understand it
» “portable” source code » NOT Portable
(independent on HW) (dependent on HW)
» Java, C/C++, COBOL,
FORTRAN, BASIC, Lisp,
Ada, etc.
 Assembly Language (middle level)

• Feature
– readable version of machine language for human
– use 0 and 1 for word, number, symbol
– can be changed from the code human can read to executable
code by machine
– NOT Portable (dependent on HW)
• Problem
– hard to find error because program is not made up by
sentences but by the association of characters.
– This program is influenced by HW.
– If new computer appears, people should make new library.
 From source code to machine code

• “compile of program”
– Translate source code made by HLL to machine code
(object, or executable).
• “Compiler”
– Translation program source code made by HLL to machine
code (object, or executable).
• “Assembly”
– Translate source code made by assembly language to
machine code (object, or executable).
• “Assembler”
– Translation program source code made by assembly
language to machine code (object, or executable).
• Compiler should know special target hardware.
 Compiler vs. Assembler vs. Interpreter

• Compiler and Assembler

– Translation is a special step that user command.
– Translation is performed at “off-line” not execution time.
• Interpreters
– Another method to translate from source code to object code
– interpretation to translate from source code to object code is
not a special step.
– Translation is performed at “on-line”
2.3 Development of HLL
1956
1957 FORTRAN-I
1958 FORTRAN-II ALGOL58
1959 COBOL
1960 APL ALGOL60
1961
1962 FORTRAN-IV

1964 PL/I BASIC SIMULA-I

1966 ALGOL-W
1967 BCPL SIMULA-67
1968 ALGOL-68

1971 PASCAL
1972 C

1977 FORTRAN-77

1979 ADA
1980 SMALLTALK80

1982 C++ MODULA2

1985
1986 Postscript

1989
1990 Perl

1993 Visual Basic, Visual C, Visual C++

1995 Tcl/Tk
Java

±×¸² 1.1 °í±Þ ¾ð¾îÀÇ ¹ß´Þ °úÁ¤

 Development process of HLL

• The first computer: ENIAC

Von Neuman model computer
The set of machine instructions
Von Neuman Model Computer
 Von Neuman Model Computer

• stored a program into a computer

command and data are stored in the memory.
• a single CPU sequentially execute instructions in
memory
• instructions operate on values stored in memory
 Von Neuman Computer Program Execution

• Repeat fetch-decode-execute cycle of CPU

• CPU do translation and execution of instructions
in memory one by one.
 2.3 History of Programming languages

1) Before digital computer

- Euclid : BC300, gcd algorithm
- Charles Babbage (1792-1871): difference engine
- Ada Augusta: the first computer programmer
2) 1950’s : the first programming language
Early 1950’s : Use machine and assembly languages
Middle of 1950’s:
- FORTRAN: the first HLL
End of 1950’s
- COBOL for commercial processing
- ALGOL 60: algorithm technique
- LISP (LISt Processor) for list processing
- APL (A Programming Language) for array processing
 2.3 History of Programming languages

3) 1960’s : increasing PL
- PL/1 (Programming Language One)
- ALGOL 68
- Simula 67
- SNOBOL (StriNg Oriented symBolic Language)
- BASIC (Beginners All-purpose Symbol Instruction
Code)
4) 1970’s : simplicity, abstraction
Early 1970’s : pursue simplicity - PASCAL,
C for UNIX
Middle of 1970’s: pursue abstraction
- CLU, Euclid, Mesa
 2.3 History of Programming languages
5) 1980’s : integration and new direction
- Ada
- Modular-2
- Functional L.: Scheme, ML
- Logical L.: Prolog
- Objective L.: Small talk, C++
6) 1990’s : WWW Programming (Java)
- It began from C++
- Object oriented Language
- No support of pointer and multiple inheritance
- Multithread
- Web is an applicative field of Java
7) 2000’s: Software crisis and DB language(SQL, Lotus,
Delphi)
 2.4 Some special languages
• FORTRAN
– The first HLL
– FORmula TRANslation: intend to use normal math expression
– Conditional statement: if (condition) true-label, false-label
– In 1954, John Backus group developed FORTRAN 0.
 FORTARN I, II, III, IV, FORRAN 77, FORTRAN 90
• Efficiency of object code
• simplicity
• Easy to learn
• Popular to many users
– Important feature
• Fixed field: col. 1-5, 6, 7-72, 73-80
• type: A-H, I-N, O-Z
• Arithmetic IF statement: if (arithmetic expression) n1, n2, n3
• DO statement: upward increment index variable
• FORMAT statement: control input/output
• comment: it begins by C
 Example 2.1 FORTRAN 19

C A HYPOTHETICAL PROGRAM IN FORTRAN

FUNF(T) = SQRTF(ABSF(T)) + 5.0*T**3
DIMENSION A(11)
1 FORMAT(6F12.4)
READ 1,A
DO 10 J = 1,11
I = 11-J
Y = FUNF(A(I+1))
IF(400.0-Y)4,8,8
4 PRINT 5,I
5 FORMAT(I10, 10H TOO LARGE)
GO TO 10
8 PRINT 9,I,Y
9 FORMAT(I10,F12.7)
10 CONTINUE
STOP
• ALGOL 60
– one of the language influence to next generation of
language.
– adopt BNF for syntax definition at first
– important contribution
• block structure (begin – end): basic unit of computation
• scope rule about local variables: lexical scope rule
• dynamic variable
• Call-by-value and call-by-name
• Recursive procedure
• dynamic array: size can be set at execution time
• the first language defined using BNF
• iteration statement: for, while, repeat
• selection statement: if-then-else
– successful side: the most influence language, contribute
to computer science
– failed side: can’t be used generally (because of IBM’s no
support), no I/O statement
 21

Example 2.3 ALGOL 60

begin integer i, real y; real array a[0:10]
real procedure f(t); real t; value t;
f := sqrt(abs(t)) + 5 * t ↑ 3;
for i := 0 step 1 until 10 do read(a[i]);
for i := 10 step -1 until 0 do
begin y := f(a[i]);
if y > 400 then write(i, ‘too large’)
else write(i, y)
end
end
• COBOL (COmmon Business Oriented
Language)
– feature
• hierarchical data structure like record
• file and file operation
• variable declaration in the data division
• like nature language (English) : readability increment (?)
• APL
– set of special character: like mathematical symbol
– conversational language
– process total data structure directly
• SNOBOL
– string processing
– string is a basic data type
 23
Example 2.2 COBOL
Non-structured program
1 IDENTIFICATION DIVISION.
2 PROGRAM-ID. SALARY.
3 INSTALLATION. CRUSADERS.
4 DATE-WRITTEN. 1984. 8. 15.
5 DATE-COMPILED. 84.08.11.
6 SECURITY. YOU HAD BETTER NOT KNOW.
7 ENVIROMENT DIVISION.
8 CONFIGURATION SECTION.
9 SOURCE-COMPUTER. COMPUTER-X.
10 OBJECT-COMPUTER. COMPUTER-X.
11 INPUT-OUTPUT SECTION.
12 FILE-CONTROL
13 SELECT EMPL-FILE ASSIGN TO CARD-READER.
14 SELECT PRINT-FILE ASSIGN TO LINE-PRINTER.
15 DATA DIVISION.
16 FILE SECTION.
17 FD EMPL-FILE
18 LABEL RECORDS ARE OMITTED
19 DATA RECORD IS EMPL-RECORD.
20 01 EMPL-RECORD.
 24

Example 2.5 APL

Example 2.6 SNOBOL
 /* increment Program */
 
 ▽ INCREMENT
/* Change ‘X’ to ‘A’, ‘Y’ to ‘B’ in INPUT file */
[1] Z ← 1
LOOP TEXT = INPUT :F(END)
[2] Z ← Z+R
ONE TEXT ‘X’ = ‘A’ :S(ONE)
[3] Z
TWO TEXT ‘Y’ = ‘B’ :S(TWO)
[4] → 2
OUTPUT = TEXT
[5] ▽
END
Execute
R←2
INCREMENT
3
5
7
.
.
• BASIC(Beginner’s All-purpose Symbolic Instruction
Code)
– for student not having science technology and background of
math
– having simple grammar and vocabulary
• Simula
– simulation language to devise the conception of class
– influence to OOL (Object Oriented Language)
• PL/I
– FORTRAN + COBOL + ALGOL 60 + exception handling,
multitasking, …
– block structure, recursive procedure, record, pointer, …
• Pascal
– for educational language, common conception is integrated
– focus on simplicity and user defined data type
• Modula-2
– module conception for support of abstract data type
– split compile
• C
– Language of programmer for programmer, and by
programmer
– Lack of readability and ambiguous error message
• LISP
– list structure and recursive of function: S-expression and
functional language
– Garbage collection
– main language of Artificial Intelligence in times past
• Smalltalk
– Alan Kay: computer is an educational tool for comprehence
and creativity
– icon, window, mouse control system
– successful OOL
 27

Example 2.4 LISP

Example 2.7 PROLOG
 
 
/* 세번째 인자 가운데 두번째
인자가 있는 곳에 첫번째 인자를 /* Reasoning function by rule and question */
삽입하는 프로그램 ( recursion likes(joe, fish).
사용 ) */
likes(mary, book).
 
likes(john, money).
(DEFUN SUBST ( X Y Z)
Question:
(COND
? - likes(mary, book). : yes
[(EQUAL Y Z) X]
likes(john, X) : - likes(X,wine), likes(X, food).
[(ATOM Z) Z]
: John likes X if X likes wine and likes food.
[(CONS(SUBST X Y(CAR Z))
(SUBST X Y (CDR Z)))]))  
(SUBST `a`b`(c b a))  
→(c a a)
• C++
– C’s superset (add class and exception handling)
• ADA
– computer program for embedded computer system
– DoD tried to standardize
– based on Pascal and add exception handling, data
abstraction, concurrence, etc
• Prolog
– Declaration (nonprocedural) logical language
– Used in AI usually
• Java
– for no bug and simple S/W to use electric home appliances.
– simple, OOP, distribution, strong, high security,
independence on H/W, high effectiveness, multithread
dynamic
 2.5 Classification of PL
• By computation model
– imperative language
• perform computation process using variable and assignment
statement
– functional language
• functional application
• applicative language
– logic language
• use logical symbol and sets for computation
• construct database using sets of logical relation and query
– object-oriented language
• data and operation are included in the object
• By use
– general purpose language
• language used in lots of parts usually
– special purpose language
• parallel language: multitasking
• database query language: SQL
• typesetting language: Tex, LaTex
• page description language: Postscript, HTML, JavaScript
• command language: process definition language, UNIX shell
• spread sheet language: Lotus 1-2-3, Excel macro