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.

Paradigms | procedural |
---|---|

Designed by | John G. Kemeny |

Developer | Sidney Marshall |

First appeared | 1962; 58 years ago |

Implementation language | Assembly |

Platform | LGP-30 |

Influenced by | |

DARSIMCO, DART, Dartmouth ALGOL 30, Fortran | |

Influenced | |

Dartmouth BASIC |

**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.^{[1]}

## 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.

Operation | Function | Number of operands |
---|---|---|

A | Ask (prompt for input) | 2 |

C | Arithmetic IF | 4 |

E | End loop | (Unknown) |

J | Input into variable | 1 |

N | Print a newline | (Unknown) |

P | Print a variable | 1 |

T | Jump | 1 |

Z | For loop | (Unknown) |

+ | Addition | 3 |

– | Subtraction | 3 |

* | Multiplication | 3 |

/ | Division | 3 |

EXP | E to the power | 2 |

LOG | Logarithm | 2 |

SIN | Sine | 2 |

SQR | Square root | 2 |

*DOPE operators*

The language was used for only one freshman computing class.^{[2]} Kemeny collaborated with high school student Sidney Marshall (taking freshman calculus) to develop the language.^{[3]}^{[4]}

## 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:

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

*Unlike either Fortran or Algol 60.

## See also

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

## References

- Kurtz, Thomas (1981). “BASIC”.
*History of programming languages*.*History of programming languages I*. ACM. pp. 517-518 517–518. doi:10.1145/800025.1198404. ISBN 0-12-745040-8. - Williams, Michael (November 1, 1985).
*A History of Computing Technology*(1st ed.). Prentice-Hall. p. 432. ISBN 0133899179. *Application to the National Science Foundation*, Kurtz, Rieser, and Meck, cited in Rankin, pages 20-21- 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" 10 READ D 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 – Flickr: lgp30-at-manhattan-college-aug65.)*