Humanist Discussion Group, Vol. 34, No. 37. Department of Digital Humanities, King's College London Hosted by King's Digital Lab www.dhhumanist.org Submit to: email@example.com  From: Dr. Herbert Wender
Subject: Re: [Humanist] 34.31: punctuation in the assignment statement (22)  From: Tim Smithers Subject: Re: [Humanist] 34.27: punctuation in the assignment statement (228) -------------------------------------------------------------------------- Date: 2020-05-19 19:34:37+00:00 From: Dr. Herbert Wender Subject: Re: [Humanist] 34.31: punctuation in the assignment statement Robert Delius Royar wrote (Humanist 34.31): "I believe the simpler interpretation is that the available character set influenced the choice more than did the designer's sense of the hermeneutic implicature of the ':'." Similarly, Henry Schaffner pointed to the restrictions of the ASCII code table, and surely that is an undeniable precondition for the evolving practice in programming notations, and in compartion with some kinde of smiley one cam see in the ":=" a double-lined arrow directed to the left. Though I would take a look in the history of notations in math and logic. The colon was introduced by Leibniz as division sign, and lexicographers used the colon conventionally between definiendum and definiens. In the latter tradition, it seems to me, can be seen the conventional use of ":=" and "=:" in the domain of set theory, and the colon marks the side of the definiens. I would suspect that the answer to Willards question is to be found in this line of tradition. Regards, Herbert -------------------------------------------------------------------------- Date: 2020-05-19 18:37:37+00:00 From: Tim Smithers Subject: Re: [Humanist] 34.27: punctuation in the assignment statement Dear Willard, I don't think the ':' in the Algol value assignment symbol, ':=', has much to do with the the colon as a punctuation mark. But, my story on this is anecdotal, and thus perhaps mistaken or mythical. Others here may be able to clarify this. In 1975 I spent nine months at a [UK] Ministry of Defense (MoD) Research Establishment doing a second period of Industrial Training as part of my (Sandwich) degree in Aeronautical Engineering, at Kingston Polytechnic (as it then was). At this MoD establishment people worked either on solid fuel rocket motors, or on liquid fuel rocket motors, never both, I was given to understand. The solid fuel people used Fortran. This is where I worked. The liquid fuel people used Algol, and analogue computers! Lunch breaks allowed some conversations with people in the liquid fuel group. Otherwise such fraternisation was frowned upon. But, curious to know about "this Algol language" I asked the person who was treated as the guru on Algol in the liquid fuel group. What I remember from this is that the assignment symbol in Algol, the ':=' symbol, was derived from the Backus notation (after John Backus) used to specify Algol 58. This soon became known as the Backus-Naur Form, and often referred to as BNF [which Peter Naur said stood for Backus-Normal Form, but Donald Knuth said should stand for Backus-Naur Form]. BNF is a metalanguage John Backus designed to specify new programming languages in a precise and unambiguous way, and was used to specify the new Algol language that was then being developed. BNF is a notation for Chomsky-type context-free grammars. (Backus apparently knew about Chomsky's work on these.) The basic idea of BNF is to use it to specify a programming language as a set of metalinguistic formulae (not equations!), using the basic form ::= __expression_ _ where the '::=' symbol here indicates that the left side must be replaced by the right side, whenever it occurs. (Some say the '::=' means "is defined by," but this is, I think, misleading, since context free grammars don't define things, they specify re-write rules, or productions, as they are sometimes called.) Now, in Backus' original version of BNF, the '::=' symbols was composed of ':' followed by a three horizontal line symbol (which I can't produce here) but which is like the mathematical symbol used to denote an equivalence relationship. This original three line symbol was hard to produce on typewriters, so it was changed to the easier to produce form '::=' we are more familiar with today. What I was told, by my Algol guru, was that this BNF symbol for the re-write operation was modified to be ':=' to use as the value assignment symbol in Algol, since assignment is similar to, but not the same as, re-write. It's worth pointing out too, I think, that Algol uses the '=' symbol to denote equality (as it should, I would say). This is used in the condition part of 'If' constructions, for example. So, value assignment could not be the '=' symbol. (Fortran, if I remember well, uses '==' for this instead.) I'm not sure this answers much since it begs the question, why did John Backus use ': and three parallel lines' and then '::=' to denote re-write? To see if I could find an answer I went back to my old copy of Richard L Wexelblat (Ed), 1981. History of Programming Languages, Academic Press which is the proceedings of the ACM SIGPLAN History of Programming Languages (HOPL) conference held in Los Angeles, California, in June, 1978. This contains sections on the origins and early development of Fortran and Algol, but, alas, I didn't find anything that helps here. However, diverting the subject some, what I did (re)find was Grace Murray Hopper's Key Note speech at this conference. This does not address the Algol value assignment symbol question, but it is an immensely interesting and informative, and sometime hilarious, read, for those interested in the human side of early computer coding and programming language developments. I'd forgotten about this, and so am grateful that your question about ':=' led me to re-discover it. Best regards, Tim PS: My preferred way of doing value assignment in programming follows the Cobol and Lisp tradition. I mostly program in Logo these days, an old AI language mostly known for it's Turtle Graphics, but which is also a fully blown list processing language. In Logo we write Make "x 2.71828 for example, or Make "x :someOtherVariable but I'll leave you, and others here, to ponder on what the '"' and ':' symbols mean. Like in Lisp, variables in Logo have property lists and a place to carry a value. > On 18 May 2020, at 12:26, Humanist wrote: > > Humanist Discussion Group, Vol. 34, No. 27. > Department of Digital Humanities, King's College London > Hosted by King's Digital Lab > www.dhhumanist.org > Submit to: firstname.lastname@example.org > > > > > Date: 2020-05-18 10:19:33+00:00 > From: Willard McCarty > Subject: punctuation in the assignment statement > > Here follows a rather lengthy prelude to a question in the history and > psychology of programming. Help, please! > > Anyone who has read David Crystal's Making a Point: The Pernickety Story > of English Punctuation (2015) will know that many have attempted to fix > the semantics of punctuation in English but none succeeded, though > Lindley Murray's English Grammar (1795) established a long-lasting > convention that has survived well beyond the Oxford English Dictionary. > My specific interest in punctuation is in the colon as it is used in > programming when combined with the equals-sign. This occurs in what are > known as assignment statements, e.g. in ALGOL and other languages > influenced by it, thus: > > X := Y + Z > > In FORTRAN, as you may know, the equivalent is written (disturbingly to > some mathematicians) thus: > > X = Y + Z > > This looks like algebra but isn't truly algebraic because it is an > imperative statement ('set the value of X equal to the sum of Y and Z') > rather than a declarative one ('the value of X is equal to the sum of Y > and Z'), as in algebra. Many have objected for very good reasons, mostly > on the grounds that students who come to programming with a background > in maths tend to become confused. > > Now for the historical bit. Within the first decade of digital computing > it became obvious that programmers would fold under the burden of > writing machine instructions. As Grace Hopper remarked, machines were > getting faster but programmers weren't. One of the differences in how to > design a standard high(er)-level programming language that would make > programming easier and quicker centred on the assignment statement, > specifically how to write it. Alan Perlis roughly sums up the story: > >> …Americans, following the FORTRAN approach, had the variable being >> assigned to on the left. The Europeans had it on the right. The >> Americans used an equals sign for the assignment, thus hiding the >> fact that there is a direction to the assignment; the Europeans used >> a directed arrow pointing to the right. When ALGOL 58 came out, >> neither equals nor directed arrow was used, but a colon-equal and it >> pointed to the left. (Wexelblat, History of Programming Languages, 1981: >> 142) > > Hence X := Y + Z! > > My question is this: why the colon? What was this mark of punctuation > meant to suggest, or better, what would it have suggested and what does > it continue to suggest? The OED note on the colon as a mark of > punctuation (rather than as a part of our anatomy) is a succinct > statement of the conventional sense that would have been nigh universal > in English usage in the mid 20th Century: > >> Its best defined use is to separate clauses which are grammatically >> independent and discontinuous, but between which there is an >> apposition or similar relation of sense. Thus it may introduce an >> antithetic statement, an illustration, extract, etc. > > I suppose, then, that in the ALGOL lingo the colon functions as an > appositional qualifier, a cognitive pause and a warning as to how the > equals-sign is to be read. (I am getting here into the psychology of > programming, into how on some level we read and write ALGOL and similar > languages.) So I translate "X is to be MADE equal to the sum of Y and > Z". Or, we might say, "Warning: this is NOT an algebraic statement!" Or, > better, I think: "Here we must stretch our understanding of mathematics > to include something new." > > Is there any supporting historical evidence for my supposition? > > Many thanks for any pointers. > > Yours, > WM > ----- > P.S. Perlis' reference to "the Europeans" should have been more specific > to give credit to Heinz Rutishauser, who in his foundational paper > Automatische Rechenplanfertigung bei programmgesteuerten Rechenmaschinen > (1951, published 1952) introduced what he called the "Ergibtzeichen", > which looks to me like a right-pointing arrow superimposed on an > equal-sign. Clarity! If only... > For the source materials see: > > http://www.softwarepreservation.org/projects/ALGOL/standards/?searchterm=Proceed > ings%20of > > > -- > Willard McCarty (www.mccarty.org.uk/), > Professor emeritus, Department of Digital Humanities, King's College > London; Editor, Interdisciplinary Science Reviews > (www.tandfonline.com/loi/yisr20) and Humanist (www.dhhumanist.org) _______________________________________________ Unsubscribe at: http://dhhumanist.org/Restricted List posts to: email@example.com List info and archives at at: http://dhhumanist.org Listmember interface at: http://dhhumanist.org/Restricted/ Subscribe at: http://dhhumanist.org/membership_form.php
Editor: Willard McCarty (King's College London, U.K.; Western Sydney University, Australia)
Software designer: Malgosia Askanas (Mind-Crafts)
This site is maintained under a service level agreement by King's Digital Lab.