I started another new Wikipedia article, this one on DOPE. The example programs below aren’t in the Wikipedia article, as they are just speculation.

DOPE, short for Dartmouth Oversimplified Programming Experiment, was a simple programming language designed by John Kemény in 1962 to offer students a transition from flow-charting to programming the LGP-30. Lessons learned from implementing DOPE were subsequently applied to the invention and development of BASIC.

## Description

Each statement was designed to correspond to a flowchart operation and consisted of a numeric line number, an operation, and the required operands:

``` 7 + A B C
10 SIN X Z```

The final variable specified the destination for the computation. The above program corresponds in functionality to the later BASIC program:

``` 7 LET C=A+B
10 LET Z=SIN(X)```

The language was case insensitive.

Variable names were a single letter A to Z, or a letter followed by a digit (A0 to Z9). As with Fortran, different letters had different representations. Variables starting with letters A to D were floating point, as were variables from I to Z; variables E, F, G, and H each were defined as vectors with components from 1 to 16.

The language was used for only one freshman computing class. Kemeny collaborated with high school student Sidney Marshall (taking freshman calculus) to develop the language.

## Legacy

According to Thomas Kurtz, a co-inventor of BASIC, “Though not a success in itself, DOPE presaged BASIC. DOPE provided default vectors, default printing formats, and general input formats. Line numbers doubled as jump targets.”

The language had a number of other features and innovations that were carried over into BASIC:

1. Variable names were either a letter or a letter followed by a digit
2. Arrays (vectors) did not have to be declared and had a default size (16 instead of 10)
3. Every line required a numeric label*
4. Lines were sorted in numeric order*
5. Every line begin with a keyword*
6. Function names were three letters long*
7. The only loop construct was a for-loop

*Unlike either Fortran or Algol 60.

• DARSIMCO, ‘Dartmouth Simplified Code’, a 1956 assembler macro language
• Dartmouth ALGOL 30, a compiler developed by Dartmouth for the LGP-30

## References

1. Kurtz, Thomas (1981). “BASIC”History of programming languagesHistory of programming languages I. ACM. pp. 517-518 517–518doi:10.1145/800025.1198404ISBN 0-12-745040-8.
2. Williams, Michael (November 1, 1985). A History of Computing Technology (1st ed.). Prentice-Hall. p. 432. ISBN 0133899179.
3. Application to the National Science Foundation, Kurtz, Rieser, and Meck, cited in Rankin, pages 20-21
4. Kemeny, John G.; Kurtz, Thomas E. (1985). Back To BASIC: The History, Corruption, and Future of the Language. Addison-Wesley Publishing Company, Inc. 141 pp. ISBN 0-201-13433-0

## Example Programs

The following sample programs are conjectures based on what little has been published about the language. For reference programs, I turned to the 1964 manual for BASIC.

BASIC program (page 13):

```10 FOR X = 2 TO 100 STEP 2
20 PRINT X, SQR(X)
30 NEXT X
40 END```

Equivalent DOPE program:

```10 Z X 2
15 SQR X S
20 P X
21 P S
25 N
30 E X 2 100```

BASIC program (page 42):

```10 REM COMPUTE A TABLE OF VALUES OF SINE FUNCTION IN DEGREES
20 LET P = 3.14159265/180
30 FOR X = 0 TO 90
40 PRINT X, SIN(X*P)
50 NEXT X
60 END```

Equivalent DOPE program:

```20 / 3.14159265 180 P
30 Z X 0
35 * X P S
36 SIN S S
40 P X S
45 N
50 E X 1 90```

Adapted from the BASIC program on page 25 (which used READ and DATA instead of INPUT, which wasn’t even in the language yet; fun fact, a READ with no DATA simply ended the program):

```  5 PRINT "X VALUE", "SINE", "RESOLUTION"
20 LET M = -1
30 FOR X = 0 TO 3 STEP D
40 IF SIN(X) <= M THEN 80
50 LET X0 = X
60 LET M = SIN(X)
80 NEXT X
85 PRINT X0, M, D
90 GOTO 10
100 DATA .1, .01, .001
110 END```

For DOPE, you would need to enter each value one at a time… .1, .01, .001:

``` 5 P 'X VALUE
6 P 'SINE
7 P 'RESOLUTION
10 J D
20 – 0 1 M
30 Z X 0
35 SIN X S
36 – M S S
40 C M 80 80 50
50 + 0 X X0
60 SIN X M
80 E X D 3
85 P X0
86 P M
87 P D
88 N
90 T 10```

Assumptions:

• The notation for the print command P is taken from the convention the ACT-III programming language used of delimiting tokens with an apostrophe. I assumed it took one operand (variable or delimited quote).
• The for-loop format is assumed to be Z loopvariable startingvalue and E loopvariable increment lastvalue. Since BASIC’s NEXT includes the loop variable, I assume this command does as well; I put the increment and last value in the E command because that would be easier for a programmer to implement than doing the test on the Z command. In this scenario, though, the loop will always execute once, which it didn’t do in 1964 BASIC.
• The arithmetic IF format copies FORTRAN in format: C expression negative zero positive, specifying the three line numbers to jump to depending upon the condition. Dissatisfaction with this notation led to the IF-THEN statement in BASIC, according to Kurtz.
• No command was specified by Kurtz for assigning a constant to a variable. That was probably an oversight in his terse summary of the language, but in the example above I used + 0 to accomplish this.

(Photo credit: Bob Fleischer – Flickrlgp30-at-manhattan-college-aug65.)