Notes for Donald E. Knuth and Luis Trabb Pardo “The Early Development of Programming Languages”

Key concepts: .

Related theorists: Charles Babbage, Alonzo Church, David Golumbia, Alan Turing, Konrad Zuse.


Survey of evolution of high level programming languages based on unpublished source materials.

Stepping through this history from hardware to extremely complex software assemblies instantiating machine cognition of the time sets the stage for new methods based on working code now that global free open source environments proliferate in which our software systems can instantiate real virtualities PHI: that is what I mean by critical programming instantiating philosophical production as once wrung out of wood paper print PHI.

(1) This paper surveys the evolution of “high level” programming languages during the first decade of computer programming activity. . . . The principal features of each contribution are illustrated; and for purposes of comparison, a particular fixed algorithm has been encoded (as far as possible) in each of the languages. This research is based primarily on unpublished source materials, and the authors hope that they have been able to compile a fairly complete picture of the early developments in this area.

Covers languages from 1945 to 1957, commissioned for 1977 publication in Encyclopedia of Computer Science and Technology.

(1) This article was commissioned by the Encyclopedia of Computer Science and Technology, ed. By Jack Belzer, Albert G. Holzman, and Allen Kent, and it is scheduled to appear in vol. 6 or vol. 7 of that encyclopedia during 1977.

The Early Development of Programming Languages

Explicit emphasis on how languages were developed, what human elements are expressed in each language, and appreciation of amount of progress now built into the environment and regarded as self evident, all ignored by computer scientists.

(2) It is interesting and instructive to study the history of a subject not only because it helps us to understand how the important ideas were born – and to see how the “human element” entered into each development – but also because it helps us to appreciate the amount of progress that has been made. . . . The real depth of this subject can only be properly perceived when we realize how long it took to develop the important concepts which we now regard as self evident.

Early history of first decade of high level programming languages, now considered dead and primitive like Greek and Latin to humanists, yet due to additive nature of built environment concretized within it.

Pre-Babel days (Raley).

(2) The goal of this paper is to give an adequate account of the early history of “high level” programming languages, covering roughly the first decade of their development. Our story will take us up to1957, when the practical importance of algebraic compilers was first being demonstrated, and when computers were just beginning to be available in large numbers. . . . The best languages we shall encounter are, of course, very primitive by today's standards, but they were good enough to touch off an explosive growth in language development; the ensuing decade of intense activity has been detailed in Jean Sammet's 785-page book [SA 69]. We shall be concerned with the more relaxed atmosphere of the “pre-Babel” days, when people who worked with computers foresaw the need for important aids to programming that did not yet exist.

Use example of fixed algorithm expressed in all languages to grasp their spirit; able to discuss edge of nonsense with language features TPK program example does not reveal.

Footnote to Grimms Law in comparative linguistics evidence the authors coming from deeper background than early programmers themselves, as criticized by Golumbia.

(3) The best way to grasp the spirit of a programming language is to read example programs, so we shall adopt the following strategy: A certain fixed algorithm – which we shall call the “TPK algorithm” for want of a better name – will be expressed as a program in each language we discuss. . . . once we have understood the TPK program, we will be able to discuss the most important language features it does not reveal.
(3) Our treatment will therefore be something like “a recital of Chopsticks as it would have been played by Bach, Beethoven, Brahms, and Brubeck.”

Algol 60 as human machine bridge language expressing TPK algorithm, although a threshold competency is required even to understand it.

Provides example of code citation and working code commentary of what the program means.

(3-4) The exemplary TPK algorithm which we shall be using so frequently can be written as follows in a dialect of Algol 60. . . . (Actually Algol 60 is not one of the languages we shall be discussing, since it was a later development, but the reader ought to know enough about it to understand TPK. If not, here is a brief run-down on what the above program means.

Studying useless algorithm versus more useful working code adequately dismissed as methodological question on basis of length.

(4) Of course this algorithm is quite useless; but for our purposes it will be helpful to imagine ourselves vitally interested in the process. . . . (If a truly useful algorithm were being considered here, it would need to be much longer in order to illustrate as many different programming language features.)

Modifications to TPK algorithm such as for languages unable to define custom functions, the process is turned into a runtime variable declaration.

(4) It turns out that most of the early high-level languages were incapable of handling the TPK algorithm exactly as presented above; so we must make some modifications.

Prior developments

Considers prior history of written algorithms from 1945 back to 2000 BC, noting the most ancient programs always rendered informally in natural language, where loop iterations always expanded.

(5) How were algorithms described prior to 1945?
(5) The earliest known written algorithms come from ancient Mesopotamia, about 2000 B.C. . . . Iterations like “for i := 0 step 1 until 10” were rare, but when present they would consist of a fully-expanded sequence of calculations.
(5) The description of algorithms was always informal, however, rendered in natural language.

Dark age before invention of notation for dynamic processes automated in machinery.

(5) During the ensuing centuries, mathematicians never did invent a good notation for dynamic processes, although of course notations for (static) functional relations became highly developed.

Programs written for Babbage and other early computing devices presented in machine language rather than true programming language to be converted to machine language.

(6) Example programs written for early computing devices, such as those of Babbage's Calculating Engine, were naturally written in “machine language” rather than in a true programming language.

Babbage noticed machines could produce programs as output.

(6) Babbage had noticed already on July 9, 1836 that machines as well as people could produce programs as output: “ This day I had for the first time a general but very indistinct conception of the possibility of making an engine work out algebraic developments. . . . But there hole [sic] might perhaps be small pieces of formulae previously made by the first cards.” [RA 73, p. 349].

Turing macro expansion machine language working code representation of dynamic process, and Church lambda notation as boundaries of highly developed mathematical algorithm description.

(6-7) Turing's machine language was more primitive, not having a built-in arithmetic capability, and he defined a complex program by giving what amounts to macro-expansions of open subroutines. For example, here was his program for making the machine move to the leftmost “a” on its working tape.
(8) Such “skeleton tables,” as presented by Turing, represented the highest-level notations for precise algorithm description that were developed before our story begins – except, perhaps, for Alonzo Church's “
λ-notation” [CH 36] which represents an entirely different approach to calculation.

Zuse's “Plancalculus”

Imagine that the little shed to which Zuse moved the only Z4 machine was near Heideggers hut.

Zuse PK language dead on arrival.

(8) Only his Z4 machine could be rescued, in what Zuse describes as a fantastic way; and he moved the Z4 to a little shed in a small Alpine village called Hinterstein. . . . “Thus the PK [Plankalkül] arose purely as a piece of desk-work, without regard to whether or not machines suitable for PK's programs would be available in the foreseeable future. [ZU 72, p. 6].

Hilbert philosophical logic destined for machines but taught in American universities for decades for human calculation.

Zuse proposed incredibly complex programs of things impossible for humans to compute; compare to Thamus example used by Postman and others.

Interesting chess program development narrative; compare to my pmrek work on Evel Knievel.

(9-10) his chess playing program treated “en passant captures” incorrectly, because he could find no chess boards or people to play chess with [ZU 72, pp. 32, 35]!

Expression of TPK algorithm in Zuse PK.

(10) Zuse's notation may appear somewhat frightening at first, but we will soon see that it is really not difficult to understand.

Knuth, Donald E. and Luis Trabb Pardo. “The Early Development of Programming Languages.” Stanford, CA: Stanford University Computer Science Department, 1976. Print.