|A3 = (||S1 · 4||)|
expresses that S1 · 4 is subjected to the restriction B3.6
Zuse calls object Angaben which pretty closely corresponds
Figure 1 shows an illustrative section [Z59].
Finally, programs and subroutines have their own identifiers like
|(0 i < l)|
|(0 j < m)|
|(0 k < n)|
Furthermore, variable component subscripts can be used [Z70, p. 123], for example by the help of an intermediate value in the form
[? Der Operator jux hat grosse Vortelle bet
der systematischen Untersuchung einer
sich evrl. In threm Umfang kiufend ünderzden
Liste auf Glieder einer bestimmien
Eigenschaft und Verarbdung derseiben. ?]
7. Further Operational Features
Apart from the possibility of selecting record and
array components by (component) subscripts, certain
operations from the predicate calculus are used to test
components with respect to a specified property, with
the result of selecting them or of obtaining a Boolean
value. In this respect the Plankalkül surpasses
the potentialities in today's programming languages,
including ALGOL 68.
Zuse uses both the "existence" and the "all" operator, and in particular the operator µ:
means "The next component of V0, for which the
property R holds."
V ^ R(x))
The property R, in the notation R(x), is expressed by means of a computational rule which gives a Boolean values (Ja-Nein-Wert), or of a result parameter of a suitable subroutine (see Section 8).
It is clear, that procedures can be defined in, say, ALGOL 68, which have the above effect. But it may be worthwhile to see whether Zuse's constructions could be introduced as original concepts in high level languages. See also [BG72].
8. Statements and Subroutine Calls
Statements are what Zuse calls Planteile.
In particular, assignments are statements. Other statements,
which we shall discuss, are conditional statements and
repetitive statements. There is also a compound statement,
formed with the help of parenthesis. In order to
seperate statements, as well as the line marks (see Section
5), a vertical bar is used.
Conditional statements are formed with the help of the Bedingt-Zeichen (or ) in the following form
-- K. Zuse (1970)
The program (Figure 3) checks these conditions:
(2) serves for the special case of condition 1.
(3) and (4) are initializations for the repetitive statement which checks
condition 2 and the count 5. Condition 3 for the
final case is then checked in (11) and the count 4 in (12).
The program, by the way, contains mistakes: for example,
a count corresponding to (7) is missing for the first symbol.
More seriously, the condition x V0 in (5) should be
read as x = V0[i] ^ i 0.
For a direct transliteration of Zuse's (corrected) procedure,
we assume first that suitable Boolean
procedures Va(x), Op(x), etc., are declared. Using these predicates,
we obtain in ALGOL 68 (the encircled numbers refer to Figure 3):
[ ? Troszdern glaube ichm dass der... Plankalkül noch einmel praktische Bedeutung bekommen wird. ? ]
K. Zuse (1970)
a. Syntax Checking for Boolean Expressions
A typical application of the Plankalkül [Z49, p. 446] contains
a procedure for the syntax check of Boolean expressions. Zuse
starts from the observation:
Such expressions contain the following symbols: variable symbols,
negation symbol, operation symbols, parentheses symbols, and
space symbol that is needed for the separation of expressions.
The symbols in question are coded in bit sequences.
Sa(x): <<x is a 'meaningful expression', i.e. a (syntactically
correct) Boolean expression>>.
This predicate is introduced recursively by:
(i) A variable symbol is a meaningful expression.
To transform this definition into an algorithm, Zuse defines, now for symbols
x, the auxilliary predicates:
(ii) A meaningful expression, prefixed by a negation symbol, yields a meaningful expression.
(iii) Two meaningful expressions, connected by an operation symbol, yield a meaningful expression.
(iv) A meaningful expression, put in parentheses, yields a meaningful expression.
Va(x): <<x is a variable symbol>>
and furthermore the predicates:
Op(x): <<x is operation symbol>>
Neg(x): <<x is negation symbol>>
Kla(x): <<x is opening patenthesis>>
Klz(x): <<x is closing parenthesis>>
Az(x): Va(x) V Neg(x) V Kla(x)
He then postulates:
Sz(x): Va(x) V Klz(x)
Sq(x,y): (Sz(x) ^ ¬ Az(y)) V (¬Sz(x) ^ Az(y))
1. The first symbol x has to fulfill Az(x)
Moreover, he uses the two parentheses counts:
2. Two symbols x, y following each other have to fulfill Sq(x, y)
3. The last symbol x has to fulfill Sz(x).
4. The number of opening parenthesis has to be equal to the number of
5. For any segment of the symbol sequences, the number of opening parentheses must not be smaller than the number of closing parentheses.
(1) proc Sa = ([0 : either] bits V0) bool : begin
(Of course, in ALGOL 68 there exist possibilities for a more
(2) bits Z0 := V0;
(3) bool R := Az(Z0);
(4) int eps := 0; if Kla(Z0) then eps := 1 fi;
(5) for i to upb V0 while R do begin
bits Z1 := V0[i];
(6) R := R ^ Sq(Z0, Z1);
(7) if Kla(Z1) then eps +:= 1 fi; (8) if Klz(Z1) then eps -:= 1 fi; (9) R := R ^ eps >= 0;
(10) Z0 := Z1 end;
(11), (12) R ^ Sz(Z0) ^ eps = 0 end
b. Checking a Move of the White King
mode A1 = int
co coordinates 1, ..., 8
instead of 0, ..., 7 corresponding to [0:2] bool
co, \ A2 = [1:2] A1 co point co, A3 = int co occupation by 1, ..., 6 (9, ..., 14)
for white (black) Q, K, R, B, S, P; instead of 0 for unoccupied co, A4 = struct (A2 point, A3 occ) co occupation of the point co, A5 = [1:64] A4 co occupation of the board co; proc R17 co adjacent co = (A2 V0, V1) bool :
abs (V0 - V1) <= 1 ^ abs (V0 - V1) <= 1; proc R128 co move permissible co = (A5 V0, A2 V1, V2) bool :
<<corresponding to the occupation occ of V0[i] that belongs to V1, where point of V0[i] = V1, the move from
V1 to V2 is geometrically permissible>> ^ <<intermediate fields, if any, are free>>; 1) proc R148 co move 2 (wK) permissible co = (A5 V0, ref A2 px) bool :
co additional result parameter px for reference to target co
begin bool c co if already checked, px refers to permissible target co := false;
int i := 1; while occ of V0[i] 2 do i +:= 1; A4 Z0 = V0[i];
for j to 64 while ¬c do
begin A4 x = V0[i]; px := point of x;
c := R17 (point of Z0, px) ^ occ of x >= 8;
for k to 64 while c do
begin A4 y = V0[k];
if occ of y > 8 then c := ¬R128 (V0, point of y, px) fi
Altogether the Plankalkül turns out to be a highly
developed programming languag with structured objects that are
built from a single primitive mode of objects - the two Boolean
values (Ja-Nein-Werte) 0, L.
Conceptually, this is certainly advantageous, but the existing
plurality of modes in some predominant programming languages
indicates the practical weakness of this approach. Apart from
this, the Plankalkül show many of the features of the
programming languages of the sixties, sometimes obscured by an
unorthodox notation, which disregarded some requirements of
mechanical processing as well as some of the common notational
habits. Some features - for example the structuring of objects -
have only recently come into existing programming languages;
others have yet to come. In particular, consideration of the
features mentioned in Section 7 could be rewarding.
To assess the Plankalkül historically, one has to compare it with the flow diagram symbolism that originated at about the same time in the United States. Zuse's pioneering achievement of the forties should not be diminished by certain limitations, e.g. that the specification of modes is meant only to be an informal help for the correct use (in particular with respect to the parameters) of a procedure and not an intrinsic part of the program, or that the explicit formation of all modes from a single basic mode as well as the corresponding notation, are clumsy, or that questions of implementation have not been tackled13.
It is also interesting to indicate the features that are generally accepted today but which were not contained in the Plankalkül. Here we should first mention the reference concept - it is not even obvious whether => means an identity declaration or an assignment. Names or references as objects are also missing in ALGOL 60; in this respect the relation between Plankalkül and Rutishauser's influence14 on ALGOL 60 is obvious. The essential restriction to numerical objects in ALGOL 60 was, as one knows today, not critical; the intention was to make the address calculation not accessible to the programmer, and this was motivated by the desire for error-free programming as well as by awareness of the frequent malfunction of machines in those years.15 Thus, at that time, there was not enough justification to open, in ALGOL 60, the Pandora's box of manipulable names - i.e. addresses.16 It was therefore left to Wirth to introduce this later into higher programming languages, and it can now be found in ALGOL 68 as well as in some "lower level languages."
Zuse, K. Ansätze einer allgemeinen Theorie des Rechnens. 1943, unpublished.
Zuse, K. "Plankalkül", Theorie der angewandten Logistik. 1945, unpublished.
Zuse, K. Über den allgemeinen Plankalkül als Mittel zur Formulierung schematisch-kombinativer Aufgaben. Archiv Math. I (1948/49), 441-449. (Received Dec 6, 1948.)
Zuse, K. Die mathematischen Voraussetzungen für die Entwicklung logistisch-kombinativer Rechenmaschinen. ZAMM 29 (1949), 36-37. (Lecture, GAMM Conference Göttingen, Sept. 1948.)
Rutishauser, H. Automatische Rechenplanfertigung bel programmgestewerten Rechenmuschinen. Mitteilungen aus dem Institut für angewandte Mathematik der ETH Zürich, No. 3. Birkhäuser, Basel, 1952.
Zuse, K. Über den Plankalkül, Elektron. Rechenanl. I (1959), 68-71.
Zuse, K. Gesichtspunkte zur sprachlichen Formulierung in Vielfachzugriffssystemen unter Berücksichtigung des Rechensysteme. Oldenbourg, Munich 1968.
Zuse, K. Der computer mein Lebenswerk. Verlag Moderne Industrie, Munich, 1970.
Knuth, D. E. Von Neumann's first computer program. Computing Surveys 2 (1970), 247-260.
Bauer, F. L., and Goos, G. Informatik: Eine einführende Ubersicht. Springer, Berlin, 1971.
Bauer, F. L., and Gnatz, R.
1 "Anzätze einer Theorie des allgemeinen Rechnens," a planned Ph.D. dissertation. See [Z70, p. 112].
2 See [Z49].
3 In terminology and notation, we follow ALGOL 68. Whatever position one may have with respect to ALGOL 68, the difference from other reputable terminologies and notations, such as the one Hoare, Wirth and Dijkstra prefer, is not so great that it would hinder communication.
4 In [Z49] a small o is used.
5 [Z49, p. 447]; see also Section 9.
6 For a chess example such a restriction is defined in [Z59, p. 72] by: "A3 is restricted to 13 possibilities: 12 kinds of chessmen and o for unoccupied."
7 [Z59, p. 70]. From a remark in [Z70, p. 157], one can infer that Zuse already during his Berlin period, that is before 1944, used L and 0, which he called Sekundalziffern (see also [Z70, p. 68] in his diary entry of June 20, 1937).
8 It should be noted that Zuse already used floating point computation.
9 Originally, Zuse [Z59] introduced the >==, shaped equality sign. The arrow-like sign => is used in [Z59], after Rutishauser had helped to propagate it. In [R52], Rutishauser used in typescript the sign =>=. At the Zürich ALGOL Conference 1958, the sign := was introduced under strong pressure from the American participants. The European group wished to use Zuse's sign.
10 It cannot be excluded that Zuse considered the input parameters to be genuine variables whose values can be changed during the subroutine. This is indicated by an isolated occurance of (V/5, V/6) => (V/7) in [Z59].
11 [Z49, p. 447]: "The Ergibt-Zeichen >== joins an expression which is to be calculated (left) with a result (right)." According to Zuse such expressions mean computational rules (Rechenvorschritten.)
12 The example in [Z59, p. 71] ends, however, with an expression E instead of E ==> Ro FIN, where Ro is the only result parameter.
13 K. Zuse in [Z70, p. 128]: "Der Plankalkül hätte noch 'compiler-gerecht' zugeschnitten werden müssen."
14 F.L. Bauer. Heinz Rutishauser, Nachruf. Computing 7 (1971), 129-130.
15 "By this token one can calculate addresses. Symbolically, one can bring about this feature by a single wire. I had misgivings to do this step." [Z70, p. 99.]
16 The question was, by the way, violently discussed at the Paris ALGOL Conference in January 1960. Proponent of "generated names" was Julian Green, who wanted ALGOL to have the possibility of describing it's own translator.
Copyright (c)1972, Association for Computing Machinery, Inc.
General permission to republish, but not for profit, all or part of this material is granted, provided that reference is made to this publication, to it's date of issue, and to the fact that reprinting privileges were granted by permission of the Association for Computing Machinery.
Author's address: Mathematisches Institut der Technischen Universität München, 8000 München 2, Postfach 202420, Germany.
Republished from Communications of the ACM, July 1972, Volume 15, Number 7. Reprinting privileges were granted by permission of the Association of Computing Machinery.
Last updated Oct 1998, Cat's-Eye Technologies. Any inaccuracies from the original document are our fault and we would appreciate being notified of any errors.
The program (Figure 3) checks these conditions: (2) serves for the special case of condition 1. (3) and (4) are initializations for the repetitive statement which checks condition 2 and the count 5. Condition 3 for the final case is then checked in (11) and the count 4 in (12). The program, by the way, contains mistakes: for example, a count corresponding to (7) is missing for the first symbol. More seriously, the condition x V0 in (5) should be read as x = V0[i] ^ i 0.
For a direct transliteration of Zuse's (corrected) procedure, we assume first that suitable Boolean procedures Va(x), Op(x), etc., are declared. Using these predicates, we obtain in ALGOL 68 (the encircled numbers refer to Figure 3):
[ ? Troszdern glaube ichm dass der... Plankalkül noch einmel praktische Bedeutung bekommen wird. ? ]
K. Zuse (1970)