Dartmouth Oversimplified Programming Experiment

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]

DOPE (Dartmouth Oversimplified Programming Experiment)

Paradigms	procedural
Designed by	John G. Kemeny
Developer	Sidney Marshall
First appeared	1962; 63 years ago (1962)
Implementation language	Assembly
Platform	LGP-30
Influenced by
DARSIMCO, DART, Dartmouth ALGOL 30, Fortran
Influenced
Dartmouth 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)

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

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 represented different variable types. 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.

Caption text

Operation	Function	Number of operands
A	Ask (prompt for input)	2
C	Arithmetic IF	4
E	End loop	Un­known
J	Input into variable	1
N	Print a newline	Un­known
P	Print a variable	1
T	Jump	1
Z	For loop	Un­known
+	Addition	3
-	Subtraction	3
*	Multiplication	3
/	Division	3
EXP	E to the power	2
LOG	Logarithm	2
SIN	Sine	2
SQR	Square root	2

The language was used by 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:

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

See also

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