Before BASIC there was DOPE

Standing for Dartmouth Oversimplified Programming Experiment.

I’ve just read a reference to it on facebook where they give this link:

but I’ve also found a wikipedia article on it:

It’s somewhat terse but from the same stable as BASIC…



Interesting read!

What might be interesting, is what would have been the alternative at the time. In 1959 the ACT I language for the LGP-30 was released. ACT I (“Algebraic Compiler and Translator”) was intended to “facilitate the coding of problems through the use of common mathematical terminology, bearing in mind some basic rules of elementary algebra” (source) and was greeted with enthusiasm.

Here’s what an ACT I program looks like:

LGP-30 ACT I Program for dice frequencies
dim freq 20
index i d
read n
1 : i
s1 0 : freq i
iter i 1 n s1 s2
read d
when d equal 0 trn s3
freq d + 1 : freq d
use s2
s3 1 : i
s4 0 print i 0 print freq i cr
iter i 1 n s4

From Keith Smillie, “Programming Then and Now: From the LGP-30 to the Laptop” (Appendix. Programming examples),

(The appendix of this document is notable on its own rights, as it provides the same program by the same author in several languages: LGP-30 machine language, ACT I, Fortran II, WATFIV Fortran, two dialects of BASIC, Algol W, Pascal, C, Java, Perl, Matlab, and J.)

Apparently, Kemeny and Kurtz weren’t satisfied with ACT I, provided that ACT I had been readily available in 1962 and covers about the same scope of problem space. So, what might be wrong with ACT I?

As may be observed, an ACT I program is quite self-explanatory, it may be even easy to read (esp. when compared to machine language). On the other hand, it’s not easy to write, as there’s a variable number of “slots” to each instruction. “How many argument does this one take?”. Also, the commands are already quite remote from the underlying machine logic, thus it may not be an ideal tool to introduce someone to the basic concepts and workings of a computer by providing an easily graspable and accessible package at the same time.
DOPE seems to be much closer to the LGP-30 machine language, which consists of single-letter, mnemonic op-codes (much like the UNIVAC I) and an argument consisting of a track and sector number on the drum (as a memory address, as the LGP-30 is a drum computer).

With its single-letter instruction codes and fixed number of slots for arguments (which may be of significance or not as an instruction may use all of them or just a few) it really resembles much more the ML format. But it does away with all its hassles: universal floating point (no conversion for integer and fixed-point operations, no tracking of arithmetic context), no need for indirect addressing, variables and line numbers instead of drum addresses, etc. But it still resembles machine language (or assembler code), down to incremental indexing as the only form of a loop.

With a grain of salt, I’d say, it’s an easy going assembler, much like BASIC could be seen as an easy going FORTRAN.