BASIC Interactivity and Fortran labels/line numbers

[cjs]

Edit after Moderator Moves

If you’re finding this thread confusing, it will help to know that:

• This head post is the fourth reply in to a discussion that started here with the comment, “[T]he key thing with BASIC was that it was designed to be interactive from day 1.This IMO is what set it apart from just about everything else at the time.”
• The second third posts are part of that thread’s discussion of line numbers (which is not directly related to the discussion this head post), and there are additional responses to messages here in that thread.

TLDR

Interactive program development was conceived and demonstrated by LISP developers years before BASIC, and the BASIC authors got the idea directly from LISP developers. Further, BASIC, for its first two years, was less interactive than LISP, both requiring compilation and not having any facility for the program to read data from the user.

“The first interactive LISP”

@jecel

L Peter Deutsch’s PDP-1 LISP was a significant event in computing history, but it came out in 1963 so “doing it for years” is a slight exaggeration.

I hadn’t noticed that in McCarthy’s History of Lisp he claims that Deutsch’s version was “the first interactive LISP,” which is what I guess you are referring to. But on closer examination this doesn’t seem consistent with the full paragraph:

The existence of an interpreter and the absence of declarations makes it particularly natural to use LISP in a time-sharing environment. It is convenient to define functions, test them, and re-edit them without ever leaving the LISP interpreter. A demonstration of LISP in a prototype timesharing environment on the IBM 704 was made in 1960 (or 1961). (See Appendix 2). L. Peter Deutsch implemented the first interactive LISP on the PDP-1 computer in 1963, but the PDP-1 had too small a memory for serious symbolic computation.

The appendix makes it clear that this demonstration was indeed interactive use on a terminal:

A Flexowriter had been connected to the IBM 704 and the operating system modified so that it collected characters from the Flexowriter in a buffer when their presence was signalled by an interrupt. Whenever a carriage return occurred, the line was given to LISP for processing.

(The technical description also makes it plausible that this could have been in 1960, which was pre-CTSS, since it notes an OS modification that surely would have been an integral part of CTSS.)

Deutch’s interpreter was not significantly different (except perhaps in scale, since he had to fit it on a smaller computer) from the original LISP interpreter, where one would punch a series of cards, start the interpreter, and have it read the cards. I don’t see any technical reason preventing you from punching a card, starting the interpreter, having it read the card, examining the output on the printer, and then punching your next card based on what you saw. Perhaps this was even done. But of course until time-sharing systems came along this would tie up an expensive machine that was in high demand for much longer than it would take to do the same processing as a batch.

(I’ve been unable to find a reference for when LISP was first made available on CTSS, but it certainly was made available on it at some point.)

Thus, while interactive use was perhaps not an explicit design goal of LISP in 1959 and it just happened to work out that the design supported that well, within a year or so the ability to work interactivity was noticed and seen as something useful that should be preserved.

Where the Idea Really Came From

But here the story gets even better. (And it’s also here where we can all thank you for prompting further research and a fix to the Wikipedia page.)

Thomas Kurtz, one of the developers of BASIC, had early on identified the problem of lack of immediate feedback. But as it turns out, the solution (which also prompted the development of DTSS) was given to him by John McCarthy (full quote from the preview of the book on Amazon):

Kurtz had learned of time-sharing from his former Dartmouth colleague John McCarthy. McCarthy, a pioneer in the field of artificial intelligence, had worked at Dartmouth during the 1950s and moved to MIT during the 1960s. [Actually autumn 1956; he moved to Stanford in 1962. --cjs] At MIT, McCarthy collaborated with Fernando Corbató’s research group, working on implementing time-sharing…

McCarthy suggested to Kurtz, “Why don’t you guys do time sharing,” then Kurtz shared the idea with Kemeny. Kurtz researched the other institutions in the United States that were implementing time-sharing, and he communicated with Corbató [the author of MIT’s time-sharing system, CTSS] about the MIT project.

Interactivity

Even here, the environment was still not quite as interactive as it might seem. First, the original BASIC was apparently not an interactive interpreter like later BASICS:

Unlike many BASICs to come, Dartmouth BASIC was a compiler, which meant that it converted your entire program in one fell swoop into machine code that the computer could understand, rather than line by line every time you ran the program. It performed that task rapidly, especially by the leisurely standards of 1960s computing: “If you were writing a very simple program, you’d get your answer in a second or so,” McGeachie says.

LISP, on the other hand, from almost the beginning offered both a compiler and an interpreter, directly executed its input, and even let you mix compiled and interpreted code. So there even with programs that were not “very simple” you could interactively make modifications to a small part of a program and quickly see the results.

Perhaps more of a problem as that you could not write interactive programs in the original BASIC because it had no way of reading from the terminal. It was not until the Third Edition, released in 1966, that this was possible:

The major change in this version was the new INPUT statement, which allowed the user to type in numeric values, making the language truly interactive during execution for the first time; previously the only control one had during execution was to type STOP in the monitor.

LISP programs of course had to have the ability to read input from the very start, since the first LISP program was the LISP interpreter itself.

[cjs]

@jecel

JOSS was developed slightly before BASIC and also numbered every line, though with two part numbers.

As it turns out, JOSS appears not to have been the first; it looks to be predated by DOPE:

DOPE might be the first programming language to require every statement to have a line number, predating JOSS and BASIC.

And the author of DOPE, John Kemény, just happens to be one of the authors of BASIC! (While DOPE was otherwise not very similar to FORTRAN or BASIC, apparently many of the lessons of DOPE were applied to BASIC; you can see the Wikipedia article and its references for more details.)

@jecel

This was a natural thing to do when a language was edited in a paper terminal while for languages edited in individual cards you needed some other scheme to implement labels.

Well, you don’t really need an entirely different scheme; FORTRAN was exclusively card-based at the start and use line numbers as labels; you just didn’t need to number lines that did not need labels.

I’m not convinced that it’s “natural” to combine line numbers for editing and labels. TECO, an interactive editor first released in 1962 for the PDP-1, certainly proved that it was not necessary. (The PDP-1 had only paper tape storage at the time, so all editing would have been of “files” in a stream-of-characters format, and PDP-1 assembly language did not use line numbers.)

[jecel]

@cjs

@jecel

This was a natural thing to do when a language was edited in a paper terminal while for languages edited in individual cards you needed some other scheme to implement labels.

Well, you don’t really need an entirely different scheme; FORTRAN was exclusively card-based at the start and use line numbers as labels; you just didn’t need to number lines that did not need labels.

What I meant was that you could rearrange a FORTRAN program so that the card with label 9 actually comes before the card with label 7. So they are numbers, but not line numbers.

Some places actually numbered the cards in the columns after 72 since they had machines that could sort a deck into increasing order. Since FORTRAN simply ignored columns after 72 my university made the users put their student numbers there (the same number in every single card) to prevent cheating by borrowing cards from other students.

For places without sorting machines the most popular solution to deal with dropping the cards was to draw a diagonal line across one of their sides. As a program was edited, however, the line quickly started to look like it had been through an earthquake.

[rlauzon]

I’m not convinced that it’s “natural” to combine line numbers for editing and labels.

When I was a Freshman in college, I often saw new computer science students getting confused about editor line numbers and FORTRAN labels. i.e. setting up a GOTO pointing to an editor line number.