[Milpotel]

I'm pretty sure that this is not true. I talked to Bud Lawson (the inventor of the pointer) and he claimed that they had implemented special behaviour for null pointers earlier. When I talked to Tony later about it, he said he had never heard of Bud Lawson. So probably both invented them independently, but Bud came first.

[elch]

If we start playing the "who was first" game, then for the Soviet machine Kiev (Kyiv), an "address language" with a "prime operation" was created in 1957-59.

The prime operation and address mapping.

The prime operation defines a certain single‑argument function. Its symbol (a prime mark) is written above and to the left of the argument: 'a = b where a is the argument and b is the result of the operation. This is read as: "prime a equals b" (or "b is the contents of a"). The argument a is called an address, and the function value b is called the contents of the address. The prime function ' defines a mapping from the set of addresses A to the set of contents B, which we will call an address mapping.

Page 36, chapter III https://torba.infoua.net/files/kateryna-yushchenko/Vychislit...

[adrian_b]

Pointers and indirect addressing were used in assembly languages and machine languages much earlier than that, perhaps even in some relay-based computers.

In any case, by 1954 already most or all electronic computers used this.

The only priority questions can refer to which are the first high-level programming languages that have used pointers.

In my opinion the first language having pointers with implicit dereferencing was CPL, published in 1963-08, and the first language having pointers with explicit dereferencing was Euler, published completely in 1966-01, but this feature had already been published in 1965-11. The first mainstream programming language, with a large installed base, which had pointers, was the revised IBM PL/I, starting with its version from 1966-07.

Thanks for the link to the book describing the "Kiev" computer. It seems an interesting computer for the year 1957, but it does not have anything to do with the use of pointers in high-level programming languages.

At the page indicated by you there is a description of what appears to be a symbolic assembler. The use of a symbolic assembly language was a great progress at that early date, because many of the first computer programs had been written directly in machine language, or just with a minimal translation, e.g. by using mnemonics instead of numeric opcodes.

However this does not have anything to do with HLL pointers and means to indicate indirect addressing in an assembly language have existed earlier, because they were strictly necessary for any computed that provided indirect addressing in hardware.

In the very first computers, the instructions were also used as pointers, so a program would modify the address field of an instruction, which was equivalent to assigning a new value to a pointer, before re-executing the instruction.

Later, to avoid the re-writing of instructions, both index registers and indirect addressing were introduced. Indirect addressing typically reserved one bit of an address to mark indirection. So when the CPU loaded a word from the memory, if the indirect addressing bit was set, it would interpret the remainder of the word as a new address, from which a new word would be loaded. This would be repeated if the new word also had the indirection bit set.

The assembly languages just had to use some symbol to indicate that the indirection bit must be set, which appears to have been "prime" for "Kiev".

[elch]

Pity you didn't look a little further, where there was more syntax and semantics... The concept of a high-level language is, of course, relative, but if, for example, someone considers Forth to be an HLL, then imho, the language/formalism from the book about the Kiev machine was definitely one, and it was described in more detail by its chief architect, Katherine Yushchenko, in a book from 1963: https://it-history.lib.ru/TEXTS/Adresnoe-programmirovanie_EY...

If you are still interested, you can look at page 35, where there are several examples, including finding the GCD.

[Milpotel]

> the first language having pointers with explicit dereferencing was Euler, published completely in 1966-01

I could only find a manual for PDP-10 Euler with references. Do you have a source for an Euler with pointers?

[adrian_b]

"Reference" was the original term used in the languages derived from ALGOL for what is now called "pointer".

The distinction that exists in C++ between "reference" and "pointer" is something very recent. In the past the 2 terms were synonymous.

The term "pointer" was introduced by IBM PL/I in July 1966, where it replaced "reference".

PL/I has introduced many terms that have replaced previously used terms. For example:

reference => pointer

record => structure

process => task

and a few others that I do not remember right now.

"Pointer" and "structure" have become dominant after they have been taken by the C language from PL/I and then C has become extremely popular. Previously "reference" and "record" were more frequently used.

[Milpotel]

But the "references" in Euler seem to be close to references nowadays. There is no access to the address, no pointer arithmetic etc. such as in PL/I.

[adrian_b]

Euler had both an address-of operator, which was prefix "@" and an indirect addressing a.k.a. pointer dereferencing operator, which was a postfix middle dot.

So it had everything that C has, except pointer arithmetic.

Only a subset of the programming languages that have pointers also allow pointer arithmetic, because many believe that whenever address arithmetic is needed only indices shall be used, not pointers, because with indices it is much easier for the compiler to determine the range of addresses that may be accessed.

[Milpotel]

Nice, and that was implemented and qualifies as high-level language?

[adrian_b]

You should provide a citation for where Bud Lawson has published his invention.

The use of pointers in assembly language does not count as an invention, as it was used since the earliest automatic computers. The use of implicit reference variables, which cannot be manipulated by the programmer, like in FORTRAN IV (1962) does not count as pointers.

The method for forcing another level of evaluation of a variable by using a "$" prefix, which was introduced in SNOBOL in January 1964, and which has been inherited by the UNIX shell and its derivatives does not count as a pointer.

The term "pointer" was introduced in a revision of the IBM PL/I language, which was published in July 1966. In all earlier publications that I have ever seen the term used was "reference", not "pointer".

There are 2 high-level programming languages that were the first to introduce explicit references (i.e. pointers). One language was Euler, published in January 1966 by Niklaus Wirth and Helmut Weber. However Hoare knew about this language before the publication, so he mentioned it in his paper from November 1965, where he discussed the use of references (i.e. pointers).

The other language was the language CPL, which had references already in August 1963. The difference between how CPL used references and how Euler used references is that in Euler pointer dereferencing was explicit, like later in Pascal or in C. On the other hand, in CPL (the ancestor of BCPL), dereferencing a pointer was implicit, so you had to use a special kind of assignment to assign a new value to a pointer, instead of assigning to the variable pointed by the pointer.

Looking now in Wikipedia, I see a claim that Bud Lawson has invented pointers in 1964, but there is no information about where he has published this and about which is the high-level programming language where the pointers of Bud Lawson had been used.

If the pointers of Bud Lawson were of the kind with explicit dereferencing, they would precede by a year the Euler language.

On the other hand, if his pointers were with implicit dereferencing, then they came a year after the British programming language CPL.

Therefore, in the best case for Bud Lawson, he could have invented an explicit dereferencing operator, like the "*" of C, though this would not have been a great invention, because dereferencing operators were already used in assembly languages, they were missing only in high-level languages.

However, the use of references a.k.a. pointers in a high-level programming language has already been published in August 1963, in the article "The main features of CPL", by Barron, Buxton, Hartley, Nixon and Strachey.

Until I see any evidence for this, I consider that any claim about Bud Lawson inventing pointers is wrong. He might have invented pointers in his head, but if he did not publish this and it was not used in a real high-level programming language, whatever he invented is irrelevant.

I see on the Internet a claim that he might have been connected with the pointers of IBM PL/I.

This claim appears to be contradicted by the evidence. If Bud Lawson had invented pointers in 1964, then the preliminary version of PL/I would have had them.

In reality, the December 1964 version of PL/I did not have pointers. Moreover, the first PL/I version used in production, from the middle of 1965 also did not have pointers.

The first PL/I version that has added pointers was introduced only in July 1966, long enough after the widely-known publications of Hoare and of Wirth about pointers. That PL/I version also added other features proposed by Hoare, so there is no doubt that the changes in the language were prompted by the prior publications.

So I think that the claim that Bud Lawson has invented pointers is certainly wrong. He might have invented something related to pointers, but not in 1964.

PL/I had one original element, the fact that pointer dereferencing was indicated by replacing "." with "->". This has later been incorporated in the language C, to compensate its mistake of making "*" a prefix operator.

The "->" operator is the only invention of PL/I related to pointers, so that is a thing that has been invented by an IBM employee, but I am not aware of any information about who that may be. In any case, this was not invented in 1964, but in 1966.

[elch]

He (Lawson) can only point to his paper from 1967 and the fact that in 1964 he was asked to join PL/I team due to his earlier published works on linked lists.

https://dl.acm.org/doi/epdf/10.1145/363332.363344

PS He didn't mention it in his recollections [1], but 1978 paper The Early History and Characteristics of PL/I [2] claims that a paper was produced in October 1965.

[1] https://archive.computerhistory.org/resources/access/text/20... [2] https://dl.acm.org/doi/pdf/10.1145/960118.808389

[adrian_b]

Thanks for the link to his paper.

Like I have said, PL/I did not have pointers in the beginning, i.e. since 1964 until July 1966.

So I think that this claim about Lawson having invented pointers comes from a misunderstanding. It is likely that Lawson has been the lead developer for adding pointers to PL/I.

Someone has heard this and because the first version of PL/I was developed during 1964, a false conclusion was inferred, i.e. that Lawson had invented pointers in 1964, before Euler.

That conclusion was wrong, because pointers have been added to PL/I much later, not during the initial development.

The paper written by Lawson about using pointers was sent for publication in August 1966, i.e. one month after the official introduction of a new PL/I version with pointers.

Due to the timing of the implementation of a PL/I extension with pointers, a short time after a public debate about how programming languages such as ALGOL must be improved, with most proposals integrated and analyzed in the papers published by Hoare, Wirth and a few others, I believe that it is rather certain that the impulse to add pointers to PL/I was not internal to IBM, but it was caused directly or indirectly by watching this debate.

The paper written by Radin, linked by you, confirms that IBM has added pointers to PL/I after an important customer, General Motors, has requested this, presumably in Q4 1965.

Because Lawson was the one who reported the end result of this work of extending PL/I with pointers, I assume that he was the lead developer of this project, which must have happened mostly during the first half of 1966.

As I have said, the only original element of the PL/I pointers was the "->" indirect addressing operator. Unlike in C, no other operator was needed, because PL/I followed the recommendation of Hoare, which was to use pointers only as structure members, where they are useful for implementing linked data structures, and not also as independent variables.

Therefore it seems likely that Harald Lawson was the one who invented the "->" operator.

However, he clearly had not invented pointers, as those (under the alternative name of "references") had been used earlier in the languages CPL and Euler and the implementation of pointers in PL/I done by Lawson followed closely the recommendations made by Hoare in his "Record Handling" paper.