One of the most important features for the construction of programs is the assignment. It was first introduced by Zuse, as the double arrow, ⟹, which he called the *Ergibt-zeichen* (results or yields sign). The ⟹ symbol represents “*implies*” in math symbology, meaning that A⟹B, means “*if A is true, then B is true*“. The systematic use of an assignment constituted a distinct break between computer-science thinking and mathematical thinking [6]. When Zuse introduced the new symbol, he remarked that Z_{3} + 1 ⟹ Z_{3} was analogous to the more traditional Z_{3.i} + 1 ⟹ Z_{3.i+1} [7]. The interesting thing about this symbol is the fact that it directs the flow of information. For example in Plankalkül:

`Z + 1 ⟹ Z`

This obviously implied that the result of 1 added to the value of **Z** would be stored in **Z**. In the original manuscript [8], the symbol is shown as , however Zuse never actually used the symbol. At the time it was considered one of the more important features in the construction of programs. Rutishauser used the symbol, in *Superplan*. In the preliminary work on the language which was to become Algol 58 this evolved into => with the requirement that formula were written in an “appropriate way” [4]. The concept here was to write to the left of the “*ergibt*” symbol “=>” (ergibt roughly translates to results or yields) the arithmetic expression to be evaluated and to the right the designation of the new quantity defined by the calculation [5]. This ergibt symbol was considered a better choice fore the dynamic flow of the program than the equality symbol.

```
((a×b)+c) => s
s + 2 => s
```

For example above, “old” **s** plus 2 yields “new” **s**. Interestingly, in the earliest form of the new language, the symbol** :=** was used in the **for** loop [5]. For example:

`for i := 1...n`

By the time the design of Algol 58 was finalized, **:=** was chosen, and it has been suggested that this only occurred because the American group pressured the Europeans, who would have preferred to use Zuse’s symbol. Why := was chosen is uncertain. It is possible that it was to represent a left facing arrow, although why <− was not chosen is uncertain. Even the use of <= would have been more meaningful (at the time ≤ was used to represent less-than, as opposed to <=).

By the time of the discussions on the design of ALGOL 60 at the Zurich ACM-GAMM Conference (1958), there is no doubt that there were preconceived notions on the part of the American contingent due to their “experience with FORTRAN” [1]. This is amply shown in the discussion on the operation of assignment. The natural flow of computation is a notation of the form b+7⟶z. However the American’s preferred the reverse [1]. Algol 60 also used the **:=** operator. Algol 60 lended its assignment operator to Algol 68, which was also adopted by Pascal (and its descendants), and Ada.

The use of = as the assignment operator harkens back to Fortran [2]. Here it was touted that a Fortran arithmetic formula closely resembles a conventional arithmetic formula, “it consists of the variable to be computed, followed by an = sign, followed by an arithmetic expression” [2]. The problem is that an expression such as “x=x+1” would be mathematically interpreted as “0=1”. Fortran used the = operator for both initialization, and reassignment.

```
initialization: x = 1
reassignment: x = x + 1
```

This was really a poor notational decision, as the = operator is more classically associated with *equality*. Fortran initially avoided this confusion somewhat because the* logical if* statement did not appear until Fortran IV in 1965, and even then it used **.EQ.** as the equality operator. PL/I would use the = for both assignment and equality. But neither Fortran nor PL/I were the direct source of the use of = as a contemporary assignment operator in languages such as C.

In 1963 work began by Christopher Strachey, at the University of Cambridge, on a language which would innovate from Algol 60 – **CPL** (originally short for Cambridge Programming Language, but later Combined Programming Language). This was a case of a theoretical language never fully implement, but a language doesn’t have to be implemented to have influence. CPL introduced the concept of *initialized definition* [3], which existed in three forms. The most interesting one is “initialization by value”, implying that when a variable is defined, it may be assigned an initial value obtained by evaluating an expression. For example:

`integer x = 37`

CPL also included initialization “by reference” (≃), and by substitution (≡). Add to this the use of **:=** for reassignment. The problem now was that = was used for both initialization *and* equality. At the time CPL was never really implemented, partially because of its size and complexity. The complexity was removed, eventually resulting in **BCPL** (Basic CPL), designed by Martin Richards in 1967. Among its simplifications, the “three forms of initialization” had to go. The initializations were reduced to a simple **=**, with **:=** for reassignment, and **=** for equality. Ken Thompson wanted to convert BCPL to run on the PDP-7. The problem here was that although the BCPL compiler was small, it was still larger than the minimum working memory available on the PDP-7. The solution? Create an even more minimalistic language, **B**. This resulted in the merging of initialization and reassignment into one operator, =. This made assignment and equality somewhat ambiguous, so Thompson added a new equality operator, **==** . Thompson was suppose to have noted that “*Since assignment is about twice as frequent as equality testing in typical programs, it’s appropriate that the operator be half as long.*“. B of course evolved into **C**. B also introduced a cornucopia of assignment statements some of which would find their way into C. This included 16 assignment operators: =, =|, =&, ===, =!=, =<, =<=, =>, =>=, =<<, =>>, =+, =−, =%, =*, and =/ .

Along other assignment operator roads not taken are symbols derived from languages such as APL. Ken Iverson introduced APL ion 1966, and used `←`

for all assignments. As keyboards changed and lesser known symbols disappeared, even Iverson changed it to =: in his language J. APL influenced S, which in turn influenced R, which uses <− as the assignment operator.

Language | Assignment | Equality |
---|---|---|

Fortran | = | .eq. (FortranIV) == (Fortran 90) |

Algol 60, Algol68 | := | = |

APL | ← | = |

Pascal (+ descendants), Ada | := | = |

C (+ descendants) | = | == |

- Naur, P., “The European side of the last phase of development of Algol 60”,
*History of Programming Languages*, pp.92–139 (1978) - Backus, J.W., et al.
*The Fortran Automatic Coding System for the IBM 704 EDPM*, IBM (1956) - Barron, D.W., et al. “The main features of CPL”,
*The Computer Journal*, 6(2), pp.134-143 (1963) - Rutishauser, H., “Automatische Rechenplanfertigung bei programmgesteuerten Rechenmaschinen” (1952)
- Bauer, F.L., Bottenbruch, H., Rutishauser, H., Samelson, K., “Proposal for a Universal Language for the description of computing processes In: J. W. Carr (ed.),
*Computer Programming and Artificial Intelligence*, University of Michigan Summer School 1958, pp.355-373 (1958) - Knuth, D.E., Pardo, L.T., “The early development of programming languages.” Technical Report, Stanford University (1976)
- Zuse, K., “Der Plankalkül”, Manuscript prepared in 1945, published in “Berichte der Gesellschaft für Mathematik und Datenverarbeitung , No. 63 (Bonn, 1972), part 3, 285 pp. English translation in No. 106 (Bonn, 1976), pp.42-244.
- Zuse, K., “Über den allgemeinen Plankalkül als Mittel zur Formulierung schematisch kombinativer Aufgaben”, Archiv der Math. 1 (1948/49), pp.441-449.