ALGOL 60 (short for Algorithmic Language 1960) is a member of the ALGOL family of computer programming languages. It followed on from ALGOL 58 which had introduced code blocks and the begin and end pairs for delimiting them. ALGOL 60 was the first language implementing nested function definitions with lexical scope. It gave rise to many other programming languages, including CPL, Simula, BCPL, B, Pascal and C.

Niklaus Wirth based his own ALGOL W on ALGOL 60 before moving to develop Pascal. Algol-W was intended to be the next generation ALGOL but the ALGOL 68 committee decided on a design that was more complex and advanced rather than a cleaned simplified ALGOL 60. The official ALGOL versions are named after the year they were first published. Algol 68 is substantially different from Algol 60 and was criticised partially for being so, so that in general "Algol" refers to dialects of Algol 60.

Paradigmprocedural, imperative, structured
Designed byBackus, Bauer, Green, Katz, McCarthy, Naur, Perlis, Rutishauser, Samelson, van Wijngaarden, Vauquois, Wegstein, Woodger
First appeared1960
Influenced by
Most subsequent imperative languages (so-called ALGOL-like languages), e.g. Simula, CPL, Pascal, Ada, C


ALGOL 60 — with COBOL — were the first languages to seek standardization.

  • ISO 1538:1984 Programming languages — Algol 60 (stabilized)
  • ISO/TR 1672:1977 Hardware representation of ALGOL basic symbols ... (now withdrawn)


ALGOL 60 was used mostly by research computer scientists in the United States and in Europe. Its use in commercial applications was hindered by the absence of standard input/output facilities in its description and the lack of interest in the language by large computer vendors. ALGOL 60 did however become the standard for the publication of algorithms and had a profound effect on future language development.

John Backus developed the Backus normal form method of describing programming languages specifically for ALGOL 58. It was revised and expanded by Peter Naur for ALGOL 60, and at Donald Knuth's suggestion renamed Backus–Naur form.[1]

Peter Naur: "As editor of the ALGOL Bulletin I was drawn into the international discussions of the language and was selected to be member of the European language design group in November 1959. In this capacity I was the editor of the ALGOL 60 report, produced as the result of the ALGOL 60 meeting in Paris in January 1960."[2]

The following people attended the meeting in Paris (from January 11 to 16):

Alan Perlis gave a vivid description of the meeting: "The meetings were exhausting, interminable, and exhilarating. One became aggravated when one's good ideas were discarded along with the bad ones of others. Nevertheless, diligence persisted during the entire period. The chemistry of the 13 was excellent."

The language originally did not include recursion. It was inserted into the specification at the last minute, against the wishes of some of the committee.[3]

ALGOL 60 inspired many languages that followed it. Tony Hoare remarked: "Here is a language so far ahead of its time that it was not only an improvement on its predecessors but also on nearly all its successors."[4] The Scheme programming language, a variant of Lisp that adopted the block structure and lexical scope of ALGOL, also adopted the wording "Revised Report on the Algorithmic Language Scheme" for its standards documents in homage to ALGOL.[5]

ALGOL 60 implementations timeline

To date there have been at least 70 augmentations, extensions, derivations and sublanguages of Algol 60.[6]

Name Year Author State Description Target CPU
X1 ALGOL 60 August 1960[7] Edsger W. Dijkstra and Jaap A. Zonneveld Netherlands First implementation of ALGOL 60[8] Electrologica X1
Algol 1960[9] Edgar T. Irons USA Algol 60 CDC 1604
Burroughs Algol
(Several variants)
1961 Burroughs Corporation (with participation by Hoare, Dijkstra, and others) USA Basis of the Burroughs (and now Unisys MCP based) computers Burroughs large systems
and their midrange as well.
Case ALGOL 1961 USA Simula was originally contracted as a simulation extension of the Case ALGOL UNIVAC 1107
GOGOL 1961 William M. McKeeman USA For ODIN time-sharing system PDP-1
DASK ALGOL 1961 Peter Naur, Jørn Jensen Denmark Algol 60 DASK at Regnecentralen
SMIL ALGOL 1962 Torgil Ekman, Carl-Erik Fröberg Sweden Algol 60 SMIL at Lund University
GIER ALGOL 1962 Peter Naur, Jørn Jensen Denmark Algol 60 GIER at Regnecentralen
Dartmouth ALGOL 30 1962 Thomas Eugene Kurtz et al. USA LGP-30
USS 90 Algol 1962 L. Petrone Italy
Elliott ALGOL 1962 C. A. R. Hoare UK Discussed in his 1980 Turing Award lecture Elliott 803 & the Elliott 503
Algol Translator 1962 G. van der Mey and W.L. van der Poel Netherlands Staatsbedrijf der Posterijen, Telegrafie en Telefonie ZEBRA
Kidsgrove Algol 1963 F. G. Duncan UK English Electric Company KDF9
VALGOL 1963 Val Schorre USA A test of the META II compiler compiler
FP6000 Algol 1963 Roger Moore Canada written for Saskatchewan Power Corp FP6000
Whetstone 1964 Brian Randell and Lawford John Russell UK Atomic Power Division of English Electric Company. Precursor to Ferranti Pegasus, National Physical Laboratories ACE and English Electric DEUCE implementations. English Electric Company KDF9
ALGEK 1965 USSR Minsk-22 АЛГЭК, based on ALGOL-60 and COBOL support, for economical tasks
MALGOL 1966 publ. A. Viil, M Kotli & M. Rakhendi, Estonian SSR Minsk-22
ALGAMS 1967 GAMS group (ГАМС, группа автоматизации программирования для машин среднего класса), cooperation of Comecon Academies of Science Comecon Minsk-22, later ES EVM, BESM
ALGOL/ZAM 1967 Poland Polish ZAM computer
Chinese Algol 1972 China Chinese characters, expressed via the Symbol system
DG/L 1972 USA DG Eclipse family of Computers
NASE 1990 Erik Schoenfelder Germany Interpreter Linux and MS Windows
MARST 2000 Andrew Makhorin Russia Algol-60 to C translator All CPUs supported by the GNU Compiler Collection; MARST is part of the GNU project

The Burroughs dialects included special system programming dialects such as ESPOL and NEWP.


ALGOL 60 as officially defined had no I/O facilities; implementations defined their own in ways that were rarely compatible with each other. In contrast, ALGOL 68 offered an extensive library of transput (ALGOL 68 parlance for Input/Output) facilities.

ALGOL 60 allowed for two evaluation strategies for parameter passing: the common call-by-value, and call-by-name. Call-by-name has certain effects in contrast to call-by-reference. For example, without specifying the parameters as value or reference, it is impossible to develop a procedure that will swap the values of two parameters if the actual parameters that are passed in are an integer variable and an array that is indexed by that same integer variable.[10] Think of passing a pointer to swap(i, A[i]) in to a function. Now that every time swap is referenced, it's reevaluated. Say i := 1 and A[i] := 2, so every time swap is referenced it'll return the other combination of the values ([1,2], [2,1], [1,2] and so on). A similar situation occurs with a random function passed as actual argument.

Call-by-name is known by many compiler designers for the interesting "thunks" that are used to implement it. Donald Knuth devised the "man or boy test" to separate compilers that correctly implemented "recursion and non-local references." This test contains an example of call-by-name.

ALGOL 60 Reserved words and restricted identifiers

There are 35 such reserved words in the standard Burroughs large systems sub-language:

  • DO
  • ELSE
  • END
  • FILE
  • FOR
  • GO
  • IF
  • LIST
  • LONG
  • OWN
  • REAL
  • STEP
  • TASK
  • THEN
  • TRUE
  • ZIP

There are 71 such restricted identifiers in the standard Burroughs large systems sub-language:

  • AND
  • BY
  • CALL
  • CASE
  • DIV
  • DUMP
  • EQL
  • EQV
  • FILL
  • GEQ
  • GTR
  • IMP
  • IN
  • IS
  • LB
  • LEQ
  • LINE
  • LOCK
  • LSS
  • MOD
  • MUX
  • NEQ
  • NO
  • NOT
  • ON
  • OPEN
  • OR
  • OUT
  • RB
  • READ
  • RUN
  • SCAN
  • SEEK
  • SET
  • SKIP
  • SORT
  • SWAP
  • THRU
  • TO
  • WAIT
  • WHEN
  • WITH

and also the names of all the intrinsic functions.

Standard Operators

Priority Operator
first ↑ (power)
second ×, / (real), ÷ (integer)
third +, -
second <, ≤, =, ≥, >, ≠
third ¬ (not)
fourth ∧ (and)
fifth ∨ (or)
sixth ⊃ (implication)
seventh ≡ (equivalence)

Examples and portability issues

Code sample comparisons


procedure Absmax(a) Size:(n, m) Result:(y) Subscripts:(i, k);
    value n, m; array a; integer n, m, i, k; real y;
comment The absolute greatest element of the matrix a, of size n by m,
    is transferred to y, and the subscripts of this element to i and k;
    integer p, q;
    y := 0; i := k := 1;
    for p := 1 step 1 until n do
        for q := 1 step 1 until m do
            if abs(a[p, q]) > y then
                begin y := abs(a[p, q]);
                    i := p; k := q
end Absmax

Implementations differ in how the text in bold must be written. The word 'INTEGER', including the quotation marks, must be used in some implementations in place of integer, above, thereby designating it as a special keyword.

Following is an example of how to produce a table using Elliott 803 ALGOL:[11]



 FOR A:= 0.0 STEP D UNTIL 6.3 DO
   PRINT PUNCH(3),££L??'
   B := SIN(A)'
   C := COS(A)'

ALGOL 60 family

Since ALGOL 60 had no I/O facilities, there is no portable hello world program in ALGOL. The following program could (and still will) compile and run on an ALGOL implementation for a Unisys A-Series mainframe, and is a straightforward simplification of code taken from The Language Guide at the University of Michigan-Dearborn Computer and Information Science Department Hello world! ALGOL Example Program page.

  WRITE(F, *, E);

A simpler program using an inline format:


An even simpler program using the Display statement:


An alternative example, using Elliott Algol I/O is as follows. Elliott Algol used different characters for "open-string-quote" and "close-string-quote", represented here by and .

 program HiFolks;
    print Hello world

Here's a version for the Elliott 803 Algol (A104) The standard Elliott 803 used 5 hole paper tape and thus only had upper case. The code lacked any quote characters so £ (UK Pound Sign) was used for open quote and ? (Question Mark) for close quote. Special sequences were placed in double quotes (e.g. ££L?? produced a new line on the teleprinter).


The ICT 1900 series Algol I/O version allowed input from paper tape or punched card. Paper tape 'full' mode allowed lower case. Output was to a line printer. Note use of '(',')' and %.[12]


See also


  1. ^ Knuth, Donald E. (December 1964). "Backus normal Form vs Backus Naur Form". Comm. ACM. 7 (12): 735–6. doi:10.1145/355588.365140.
  2. ^ ACM Award Citation / Peter Naur, 2005
  3. ^ van Emden, Maarten (2014). "How recursion got into programming: a tale of intrigue, betrayal, and advanced programming-language semantics". A Programmer's Place.
  4. ^ Hoare, C.A.R. (December 1973). "Hints on Programming Language Design" (PDF). p. 27. (This statement is sometimes erroneously attributed to Edsger W. Dijkstra, also involved in implementing the first ALGOL 60 compiler.)
  5. ^ Abelson, Hal; Dybvig, R. K.; et al. Rees, Jonathan; Clinger, William, eds. "Revised(3) Report on the Algorithmic Language Scheme, (Dedicated to the Memory of ALGOL 60)". Retrieved 2009-10-20.
  6. ^ The Encyclopedia of Computer Languages Archived September 27, 2011, at the Wayback Machine
  7. ^ Daylight, E. G. (2011). "Dijkstra's Rallying Cry for Generalization: the Advent of the Recursive Procedure, late 1950s — early 1960s". The Computer Journal. 54 (11): 1756–1772. doi:10.1093/comjnl/bxr002.
  8. ^ Kruseman Aretz, F.E.J. (30 June 2003). "The Dijkstra-Zonneveld ALGOL 60 compiler for the Electrologica X1" (PDF). Software Engineering. History of Computer Science. Kruislaan 413, 1098 SJ Amsterdam: Centrum Wiskunde & Informatica.
  9. ^ Irons, Edgar T., A syntax directed compiler for ALGOL 60, Communications of the ACM, Vol. 4, p. 51. (Jan. 1961)
  10. ^ Aho, Alfred V.; Ravi Sethi; Jeffrey D. Ullman (1986). Compilers: Principles, Techniques, and Tools (1st ed.). Addison-Wesley. ISBN 978-0-201-10194-2., Section 7.5, and references therein
  11. ^ "803 ALGOL", the manual for Elliott 803 ALGOL
  12. ^ "ICL 1900 series: Algol Language". ICL Technical Publication 3340. 1965.

Further reading

External links


For the cryonics organization, see Alcor Life Extension Foundation.

ALCOR is a radar tracking station in Roi-Namur island in the north part of the Kwajalein atoll in the Marshall Islands.ALCOR is an early computer language definition created by the ALCOR Group, a consortium of universities, research institutions and manufacturers in Europe and the United States which was founded in 1959 and which had 60 members in 1966. The group had the aim of a common compiler specification for a subset of ALGOL 60 after the ALGOL meeting in Copenhagen in 1958. ALCOR is an acronym, from ALGOL Converter.

In addition, the naming of Alcor is an astronomical reference. Algol is named, in addition to its programming application, for the star Algol; In this way, Alcor is also named in astronomical reference for the star Alcor.

The fact that this star is the fainter companion of the 2nd magnitude star Zeta Ursae Majoris was sometimes ironized as being a bad omen for the future of the language.

In Europe, a high level machine architecture for ALGOL 60 was devised which was emulated on various real computers, among them the Siemens 2002 and the IBM 7090. An ALGOL manual was published which provided a detailed introduction of all features of the language with many program snippets, and four appendixes:Revised Report on the Algorithmic Language ALGOL 60

Report on Subset ALGOL 60 (IFIP)

Report on Input-Output Procedures for ALGOL 60

an early "standard" character set for representing ALGOL 60 code on paper and paper tape.This character set included the unusual "᛭" (iron/runic cross) character for multiplication and the "⏨" (Decimal Exponent Symbol) for floating point notation.


ALGOL (; short for "Algorithmic Language") is a family of imperative computer programming languages, originally developed in the mid-1950s, which greatly influenced many other languages and was the standard method for algorithm description used by the ACM in textbooks and academic sources for more than thirty years.In the sense that the syntax of most modern languages is "Algol-like", it was arguably the most influential of the four high-level programming languages among which it was roughly contemporary: FORTRAN, Lisp, and COBOL. It was designed to avoid some of the perceived problems with FORTRAN and eventually gave rise to many other programming languages, including PL/I, Simula, BCPL, B, Pascal, and C.

ALGOL introduced code blocks and the begin…end pairs for delimiting them. It was also the first language implementing nested function definitions with lexical scope. Moreover, it was the first programming language which gave detailed attention to formal language definition and through the Algol 60 Report introduced Backus–Naur form, a principal formal grammar notation for language design.

There were three major specifications, named after the year they were first published:

ALGOL 58 – originally proposed to be called IAL, for International Algebraic Language.

ALGOL 60 – first implemented as X1 ALGOL 60 in mid-1960. Revised 1963.

ALGOL 68 – introduced new elements including flexible arrays, slices, parallelism, operator identification. Revised 1973.ALGOL 68 is substantially different from ALGOL 60 and was not well received, so that in general "Algol" means ALGOL 60 and dialects thereof.


ALGOL 58, originally known as IAL, is one of the family of ALGOL computer programming languages. It was an early compromise design soon superseded by ALGOL 60. According to John Backus

"The Zurich ACM-GAMM Conference had two principal motives in proposing the IAL: (a) To provide a means of communicating numerical methods and other procedures between people, and (b) To provide a means of realizing a stated process on a variety of machines..."

ALGOL 58 introduced the fundamental notion of the compound statement, but it was restricted to control flow only, and it was not tied to identifier scope in the way that Algol 60's blocks were.

ALGOL Bulletin

The ALGOL Bulletin (ISSN 0084-6198) was a periodical regarding the ALGOL 60 and ALGOL 68 programming languages. It was produced under the auspices of IFIP Working Group 2.1 and published from March 1959 till August 1988.


ALGOL W is a programming language. It is based on a proposal for ALGOL X by Niklaus Wirth and Tony Hoare as a successor to ALGOL 60 in IFIP Working Group 2.1. When the committee decided that the proposal was not a sufficient advance over ALGOL 60, the proposal was published as A contribution to the development of ALGOL. After making small modifications to the language Wirth supervised a high quality implementation for the IBM/360 at Stanford University that was widely distributed.It represented a relatively conservative modification of ALGOL 60, adding string, bitstring, complex number and reference to record datatypes and call-by-result passing of parameters, introducing the while statement, replacing switch with the case statement, and generally tightening up the language.

The implementation was written in PL/360, an ALGOL-like assembly language designed by Wirth. The implementation includes influential debugging and profiling abilities.


ALGOL X was the code name given to the programming language which the Working Group 2.1 on ALGOL of the International Federation for Information Processing was to develop as a successor to ALGOL 60. It attempted to find a "short-term solution to existing difficulties".

According to de Morgan "... the Algol 60 devotees had not been idle... they set out to eliminate the dreaded Remaining Trouble Spots. They called their Algol 60 'Modified'."

One ALGOL X compiler is known to have existed, it was written with the AED-0 system ("Automated Engineering Design", also referred to as"ALGOL Extended for Design") by Douglas T. Ross of MIT.Example class definition: (An extract from AB26.2.2)

class expression is constant (real value) ora variable (string printname)

ora class pair is (sum ora difference ora product

ora quotient)((expression) left operand, right operand, derivative);

Example class usage:

(expression) X; (constant) Y; (pair) Z; (product) Q;

X := Y:= constant(10.5);

Z := Q := product(variable("ALPHA"), constant(2.), constant(2.))

"Initially the proposal for an update to Algol was Algol X, with Algol Y being the name reserved for

the corresponding metalanguage. Van Wijngaarden produced a paper for the 1963 IFIP programming language

committee, entitled “Generalized Algol,” which contained the basic concepts which were eventually

incorporated into Algol 68."[1]

Backus–Naur form

In computer science, Backus–Naur form or Backus normal form (BNF) is a notation technique for context-free grammars, often used to describe the syntax of languages used in computing, such as computer programming languages, document formats, instruction sets and communication protocols. They are applied wherever exact descriptions of languages are needed: for instance, in official language specifications, in manuals, and in textbooks on programming language theory.

Many extensions and variants of the original Backus–Naur notation are used; some are exactly defined, including extended Backus–Naur form (EBNF) and augmented Backus–Naur form (ABNF).

Elliott ALGOL

Elliott ALGOL was an ALGOL 60 compiler for the Elliott 803 computer. It was implemented by Tony Hoare and others. It differed slightly from the reference version of Algol, particularly in the supported character set. First released in February 1962, it is believed to be the first implementation of an ALGOL 60 compiler in a commercial context and was an unexpectedly popular product for the company.

Euler (programming language)

Euler is a programming language created by Niklaus Wirth and Helmut Weber, conceived as an extension and generalization of ALGOL 60. The designers' goal was to create a language:

which was simpler, and yet more flexible, than ALGOL 60

that was a useful programming language processed with reasonable efficiency

that can be defined with rigorous formalityAvailable sources indicate that Euler was operational by 1965.

Executive Systems Problem Oriented Language

This article is about the programming language. For the university, see Escuela Superior Politecnica del Litoral.ESPOL (short for Executive Systems Problem Oriented Language) was a superset of ALGOL 60 that provided capabilities of what would later be known as Mohols, machine oriented high order languages, such as interrupting a processor on a multiprocessor system (the Burroughs large systems were multiprocessor processor systems). ESPOL was used to write the MCP (Master Control Program) on Burroughs computer systems from the B5000 to the B6700. The single-pass compiler for ESPOL could compile over 250 lines per second.

ESPOL was superseded by NEWP.

IFIP Working Group 2.1

IFIP Working Group 2.1 on Algorithmic Languages and Calculi is a working group of the International Federation for Information Processing (IFIP).

IFIP WG 2.1 was formed as the body responsible for the continued support and maintenance of the ALGOL 60 programming language.

The Modified Report on the Algorithmic Language ALGOL 60 and the ALGOL 68 programming language were produced by WG 2.1.

Its current scope is:

The study of calculation of programs from specifications

The design of notations for such calculation.

The formulation of algorithm theories, using such notations.

The investigation of software support for program derivation.

Continuing responsibility for Algol 60 and Algol 68.

Jensen's Device

Jensen's Device is a computer programming technique that exploits call by name. It was devised by Danish computer scientist Jørn Jensen, who worked with Peter Naur at Regnecentralen. They worked on the GIER Algol compiler, one of the earliest correct implementations of ALGOL 60. ALGOL 60 used call by name.

Man or boy test

The man or boy test was proposed by computer scientist Donald Knuth as a means of evaluating implementations of the ALGOL 60 programming language. The aim of the test was to distinguish compilers that correctly implemented "recursion and non-local references" from those that did not.

There are quite a few ALGOL60 translators in existence which have been designed to handle recursion and non-local references properly, and I thought perhaps a little test-program may be of value. Hence I have written the following simple routine, which may separate the man-compilers from the boy-compilers.


NEWP (or the New Executive Programming Language) is a high-level programming language used on the Unisys MCP systems. The language is used to write the operating system and other system utilities, although it can also be used to write user software as well. Several constructs separate it from extended ALGOL on which it is based. Language operators such as MEMORY which allows direct memory access are strictly used by programs running as the MCP.

Peter Naur

Peter Naur (25 October 1928 – 3 January 2016) was a Danish computer science pioneer and Turing award winner. His last name is the "N" in the BNF notation (Backus–Naur form), used in the description of the syntax for most programming languages. He contributed to the creation of the ALGOL 60 programming language.

He began his career as an astronomer for which he received his PhD degree in 1957, but his encounter with computers led to a change of profession. From 1959 to 1969, he was employed at Regnecentralen, the Danish computing company, while at the same time giving lectures at the Niels Bohr Institute and the Technical University of Denmark. From 1969 to 1998 Naur was a professor of computer science at University of Copenhagen.

His main areas of inquiry were design, structure and performance of computer programs and algorithms. Areas such as software engineering and software architecture have also been pioneered by Naur. In his book Computing: A Human Activity (1992), which is a collection of his contributions to computer science, he rejected the formalist school of programming that views programming as a branch of mathematics. He did not like being associated with the Backus–Naur form (attributed to him by Donald Knuth) and said that he would prefer it to be called the Backus normal form.

Naur was married to computer scientist Christiane Floyd.

Naur disliked the very term "computer science" and suggested it be called "datalogy" or "data science". The former term has been adopted in Denmark and in Sweden as datalogi, while the latter term is now used for data analysis (including statistics and databases).

Since the middle of the 1960s, computer science has been practiced in Denmark under Peter Naur's term datalogy, the science of data processes. Starting at Regnecentralen and the University of Copenhagen, the Copenhagen Tradition of Computer Science has developed its own special characteristics by means of a close connection with applications and other fields of knowledge. The tradition is not least visible in the area of education. Comprehensive project activity is an integral part of the curriculum, thus presenting theory as an aspect of realistic solutions known primarily through actual experience. Peter Naur early recognized the particular educational challenges presented by computer science. His innovations have shown their quality and vitality also at other universities. There is a close connection between computer science training as it has been formed at Copenhagen University, and the view of computer science which has characterized Peter Naur's research .

In later years he was quite outspoken of the pursuit of science as a whole: Naur can possibly be identified with the empiricist school, that tells that one shall not seek deeper connections between things that manifest themselves in the world, but keep to the observable facts. He has attacked both certain strands of philosophy and psychology from this viewpoint. He was also developing a theory of human thinking which he called "Synapse-State Theory of Mental Life".Naur won the 2005 ACM A.M. Turing Award for his work on defining the ALGOL 60 programming language. In particular, his role as editor of the influential Report on the Algorithmic Language ALGOL 60 with its pioneering use of BNF was recognized. Naur is the only Dane to have won the Turing Award.

Naur died on 3 January 2016 after a short illness.


Simula is the name of two simulation programming languages, Simula I and Simula 67, developed in the 1960s at the Norwegian Computing Center in Oslo, by Ole-Johan Dahl and Kristen Nygaard. Syntactically, it is a fairly faithful superset of ALGOL 60, also influenced by the design of Simscript.Simula 67 introduced objects, classes, inheritance and subclasses, virtual procedures, coroutines, and discrete event simulation, and features garbage collection. Also other forms of subtyping (besides inheriting subclasses) were introduced in Simula derivatives.Simula is considered the first object-oriented programming language. As its name suggests, Simula was designed for doing simulations, and the needs of that domain provided the framework for many of the features of object-oriented languages today.

Simula has been used in a wide range of applications such as simulating VLSI designs, process modeling, protocols, algorithms, and other applications such as typesetting, computer graphics, and education. The influence of Simula is often understated, and Simula-type objects are reimplemented in C++, Object Pascal, Java, C# and several other languages. Computer scientists such as Bjarne Stroustrup, creator of C++, and James Gosling, creator of Java, have acknowledged Simula as a major influence.

Timeline of programming languages

This is a record of historically important programming languages, by decade.

Trabb Pardo–Knuth algorithm

Knuth algorithm is a program introduced by Donald Knuth and Luis Trabb Pardo to illustrate the evolution of computer programming languages.

In their 1977 work "The Early Development of Programming Languages", Trabb Pardo and Knuth introduced a small program that involved arrays, indexing, mathematical functions, subroutines, I/O, conditionals and iteration. They then wrote implementations of the algorithm in several early programming languages to show how such concepts were expressed.

The trivial Hello world program has been used for much the same purpose.

Whetstone (benchmark)

The Whetstone benchmark is a synthetic benchmark for evaluating the performance of computers. It was first written in Algol 60 in 1972 at TSU (The Technical Support Unit of the Department of Trade and Industry - later part of the Central Computer and Telecommunications Agency or CCTA in the United Kingdom). It was derived from statistics on program behaviour gathered on the KDF9 computer at NPL National Physical Laboratory in the United Kingdom, using a modified version of its Whetstone ALGOL 60 compiler. The workload on the machine was represented as a set of frequencies of execution of the 124 instructions of the Whetstone Code. The Whetstone Compiler was built at the Atomic Power Division of the English Electric Company in Whetstone, Leicestershire, England, hence its name. Dr. B.A. Wichman at NPL produced a set of 42 simple ALGOL 60 statements, which in a suitable combination matched the execution statistics.

To make a more practical benchmark Harold Curnow of TSU wrote a program incorporating the 42 statements. This program worked in its ALGOL 60 version, but when translated into FORTRAN it was not executed correctly by the IBM optimizing compiler. Calculations whose results were not output were omitted. He then produced a set of program fragments which were more like real code and which collectively matched the original 124 Whetstone instructions. Timing this program gave a measure of the machine’s speed in thousands of Whetstone instructions per second (kWips) The Fortran version became the first general purpose benchmark that set industry standards of computer system performance. Further development was carried out by Roy Longbottom, also of TSU/CCTA, who became the official design authority. The ALGOL 60 program ran under the Whetstone compiler in July 2010, for the first time since the last KDF9 was shut down in 1980, but now executed by a KDF9 emulator.

Following increased computer speeds, performance measurement was changed to Millions of Whetstone Instructions Per Second (MWIPS). The original results on numerous minicomputers, mainframes and supercomputers are available in Whetstone Benchmark History and Results. This also shows original system costs and year of manufacture. For comparison purposes, a summary of results on PCs is also provided, including a table showing the relative efficiency of various programming languages. Detailed results on PCs are also available, showing speeds of the different test functions.

Source code and pre-compiled versions for PCs in C/C++, Basic, Visual Basic, Fortran and Java were available from Roy Longbottom's PC Benchmark Collection (Free) and have been archived at British Library, with Whetstone Data being of particular significance. Compiled codes include those to run via DOS, OS/2 plus 32 bit and 64 bit Windows.

The Whetstone benchmark primarily measures the floating-point arithmetic performance. A similar benchmark for integer and string operations is the Dhrystone.

ISO standards by standard number

This page is based on a Wikipedia article written by authors (here).
Text is available under the CC BY-SA 3.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.