DOPE (Dartmouth Oversimplified Programming Experiment)

From Wikipedia, the free encyclopedia
DOPE (Dartmouth Oversimplified Programming Experiment)
Paradigmsprocedural
Designed byJohn G. Kemeny
DeveloperSidney Marshall
First appeared1962; 60 years ago (1962)
Implementation languageAssembly
PlatformLGP-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)

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 (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

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

See also[]

  • 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 languages. History of programming languages I. ACM. pp. 517-518 517–518. doi:10.1145/800025.1198404. ISBN 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


Stub icon

This programming-language-related article is a stub. You can help Wikipedia by .

  • v
  • t
Retrieved from ""