ALGOL
Jonathon Mishic, Sahil Dayal, Jacob Locke
01
The Beginning
A brief history of the creation of ALGOL
Introduction
What this
tells us
Peter Naur
Other Winners
On May 20th, 2006, Peter
Naur received the 2005
ACM Turing Award for
his work on ALGOL 60
Seven others who had
worked on the ALGOL
effort, received the
Turing award for their
contributions to CS
Having such a large
number of award
winning scientists
working on ALGOL
indicates it was a
crucial component in
the development of
Computer Science
The Need for a New Language
-early 1950s
-In Europe, researches started building their own
computing machines, but needed an algorithmic language
to actually make them productive
-In the US, many algorithmic languages had already been
developed but for almost every computing machine, a
different algorithmic language existed.
-Europe had no algorithmic language, and the USA had too
many, and both groups realized they needed a universal
algorithmic language
The
Beginning
In October 1955, an international
symposium on automatic computing was
held in Darmstadt, Germany. Here, several
speakers stressed the need for one
universal, machine-independent
algorithmic language to be used by all
The Two Committees
GAMM
ACM
Association for
Applied
Mathematics
and Mechanics
Association of
Computing
Machinery
1955
1957
Their
Findings
On May 27, 1958, the two groups held a
joint meeting together in Zurich,
Switzerland to finalize their findings. Over
the next 4 days, they came to 4
conclusions about the new language:
The 4 Conclusions
1
It should be as close as
possible to standard
mathematical notation
3
It should be mechanically
translatable into machine
programs
2
It should be possible to
use it for the description
of computing processes
in publications
4
It should be machine
independent
Picking
A Language
After The Preliminary Report: International
Algebraic Language was published (it was
called IAL instead of ALGOL at the time),
the computing community decided they
needed to pick a language to commit to.
The 4 Languages
IT
-used in the first successful compilers
-had a very primitive hardware
representation
-The programmer had to translate their
programs by hand into the hardware
FORTRAN
-in use in many machines
across the world
-machine dependent
-FORTRAN was dominating
the industry due to the
dominance of IBM
MATH-MATIC
-made up of English words and
standard mathematical notation
-intended for use at the UNIVAC I
computer
-small number of UNIVAC
machines in use
IAL (ALGOL)
-the committee to choose IAL, not
because it was better, but because
it “was machine independent and
a compromise between two
computing communities”
Next Steps
-There was an eighteen month span between the meeting
in Zurich and the next major meeting that was held in
Paris. During that time, the first iteration of IAL was
developed, and renamed to ALGOL 58.
-The American committee members were more focused on
expanding the language by adding more types, adding
input and output facilities, and tidying up the syntax.
-The European committee was more focused on the
procedure concept and the scope of variables within the
language. They wanted to improve the fundamental parts of
the language
ALGOL 60
●
Although both groups worked on different aspects of
the language, it actually helped expand ALGOL 58 into
a much more usable and powerful language that
satisfied both group’s criteria
●
The language was published in Peter Naur’s ALGOL 60
report, which not only defined the language, but
became the standard for defining all programming
languages to follow
02
Implementations
The technical side of the language
Syntax
Publication Language
Publication: Mathematical Representation.
Reference: Standard / Generalized Definition.
Hardware: Individualized Machine Code.
Reference Language
The reference language served as the bridge
between published algorithms and specialized
machine implementations.
Hardware Language
The Preliminary Report
Defining the Reference Language
Language Example
procedure Simps (F(), a, b, delta, V);
begin
Simps:
Ibar := V✕(b-a);
n := 1; h := (b-a)/2;
J := h✕(F(a) + F(b));
J1:
S := 0;
for k := 1 (1) n;
S := S + F(a + (2✕k-1)✕h);
I := J + 4✕h✕S
if (delta < abs(I-Ibar));
begin
Ibar := I;
J := (I+J)/4; n := 2✕n; h := h/2;
go to J1
end;
Simps := I/3
return;
integer (k, n)
end Simps
The ALGOL 60 Family
Call by
Value/Name
procedure swap(a, b);
real a, b;
begin
real temp;
temp := a;
a := b;
b := temp
end;
Lexical
Scoping
begin
real A;
A := 3.5;
begin
real B;
B := 2.0;
A := A + B; // A is visible here
end;
// B is not visible here
end;
*Elliot ALGOLI/O
£begin?
£integer? i;
£for? i := 1 £step? 1
£until? 10 £do?
£print? ££L??, i
£end?
03
The Impact
How ALGOL impacted the future of Computer Science
The Lasting Influence of ALGOL
-
Though ALGOL didn’t dominate commercially, its
technical innovations shaped modern programming.
-
Inspired successor languages like Pascal, C, Java,
and Ada.
-
Introduced structured programming, which influenced
modular and object-oriented programming.
Structured Programming and
Block Structure
●
ALGOL 60 introduced block structure, allowing
code to be divided into reusable segments.
●
Provided a systematic approach to
programming, replacing reliance on goto
statements.
●
Enabled easier development of large, complex
programs with well-defined scope.
ALGOL’s block code example
Lexical Scoping and
Recursion
●
Established lexical scoping, limiting variables to
their specific blocks.
●
Enabled recursion, now fundamental in algorithms
like quicksort and tree traversal.
●
Influenced functional languages such as Scheme
and ML, which rely on structured recursion.
ALGOL’s Impact on Compiler
Design
1
Defined syntax using
Backus-Naur Form
(BNF), a standard still
used today
3
Inspired Hoare logic, a
formal system for
verifying program
correctness.
2
Influenced compiler
construction and formal
language definition
Contributions to Algorithmic
Thinking
Standardizing Algorithm Representation
●
ALGOL became the standard language for publishing algorithms in research papers.
●
Donald Knuth’s The Art of Computer Programming used ALGOL notation.
Influence on Divide and Conquer Algorithms
●
Popularized recursive problem-solving, crucial for Merge Sort and Binary Search.
●
Structured approach made algorithms more readable and modular.
Establishing Computer Science
as a Discipline
-
Encouraged international collaboration in
programming language development.
Naur
-
Influenced foundational studies in type theory,
semantics, and compiler optimization.
Backus
Dijkstra
Many contributors, including Backus, Naur, and
Dijkstra, became Turing Award winners.
Conclusion
ALGOL’s Enduring Legacy
●
Promoted the divide and conquer strategy, used in merge sort
and binary search.
●
Standardized how algorithms were described in academic and
research publications.
●
Shaped the development of programming language theory and
computational logic.
References
Aho, A. V., Lam, M. S., Sethi, R., & Ullman, J. D. (2006). Compilers: Principles, techniques, and tools. Addison-Wesley.
Backus, J., et al. (1960). Revised report on the algorithmic language ALGOL 60. Communications of the ACM.
de Beer, H. T. (2006). The history of the ALGOL effort. Technische Universiteit Eindhoven. https://heerdebeer.org/ALGOL/The_History_of_ALGOL.pdf
Knuth, D. E. (1968). The art of computer programming, Volume 1: Fundamental algorithms. Addison-Wesley.
Kernighan, B. W., & Ritchie, D. M. (1988). The C programming language. Prentice Hall.
Naur, P. (1978). The European side of the last phase of the development of ALGOL60. In HOPL-1: The first ACM SIGPLAN conference on History of programming languages (pp. 301-320).
ACM Press.
Perlis, A. J., & Samelson, K. (1958). Preliminary report: International algebraic language. Communications of the ACM, 1(12), 26-32.
Perlis, A. J. (1978). The American side of the development of ALGOL. In HOPL-1: The first ACM SIGPLAN conference on History of programming languages (pp. 271-300). ACM Press.
Poel, W. L. van der. (1986). Some notes on the history of ALGOL. In A quarter century of IFIP (pp. 203-218). Elsevier.
Rosen, S. (1967). Programming systems and languages: A historical survey. In Programming systems and languages (pp. 1-17). London.
Rutishauser, H. (1967). Description of ALGOL 60. In Handbook for automatic computation (Vol. 1, pp. 84-103).
Sammet, J. E. (1969). Programming languages: History and fundamentals. Prentice-Hall.
“Software pioneer Peter Naur wins ACM's Turing award.” (n.d.). Naur.com. https://www.naur.com/ACM.html#:~:text=Dr.,the%20language%27s%20power%20and%20simplicity
Whitaker, W. A. (1996). Ada: The project, the language, the people. ACM SIGAda Ada Letters, 16(4), 7-11.
Wirth, N. (1971). The programming language Pascal. Acta Informatica.