Dartmouth BASIC

Content sourced from Wikipedia, licensed under CC BY-SA 3.0.

Dartmouth BASIC is the original version of the BASIC programming language. It was created at Dartmouth College by John G. Kemeny and Thomas E. Kurtz and ran on the Dartmouth Time-Sharing System (DTSS). It gave undergraduates and other members of the college community an interactive way to write and run programs. The first version appeared in 1964, with the last major release in 1979. In 1975 Dartmouth introduced Structured BASIC (SBASIC), which added structured programming ideas and later influenced early standardization efforts.

What made Dartmouth BASIC special
- It aimed to make programming easy for non-specialists and to put a computer in the hands of many users.
- It ran in a time-sharing environment, so many people could use the same computer at once.
- It was designed for interactivity: you could type commands and see results right away.
- Its early design was influenced by FORTRAN and ALGOL, but it was built to be simpler and more approachable.

A quick look at the major editions and features
- Second Edition (1964): could start arrays at 0, added a semicolon option to PRINT, and introduced a version called CARDBASIC for card-based work. It kept the BASIC concept simple and interactive.
- Third Edition (1966): added the MAT commands to work with matrices and encouraged a clearer, more indented style of code.
- Fourth Edition (1968): brought multi-line functions with DEF and a powerful string-manipulation tool called CHANGE. MAT stayed centered on arrays, and arrays commonly used 1-based indexing again for MAT.
- Fifth Edition (1970): added file handling. You could open files, read data from them, and write results to them using new FILES and related commands. This edition also refined some input and output features.
- Sixth Edition (1971): a major refinement. It replaced the old CHAIN feature with CALL (functions called by name, not by line number). It introduced SUB...SUBEND for functions, and it added more robust file handling with file numbers (handles). PRINT USING and LINPUT supported formatted and “raw” input. String handling improved, and new string operations (like LEN, SEG$, and others) began to appear. MAT matrices stayed, and the language could handle more complex data tasks, including two-dimensional strings.
- Seventh Edition (1980): known as SBASIC, a version of BASIC with a stand-alone compiler. It introduced structured programming more fully, added modules (data hiding for a group of routines), overlays to break programs into parts, and richer matrix math inside LET statements. Activation records made recursion possible, and the edition improved the way external programs and libraries could be used.
- Eighth Edition (1982): incorporated an early version of a standard BASIC draft into DTSS, while the language and environment continued to evolve in the marketplace.

DTSS and the broader BASIC ecosystem
- DTSS provided an early, integrated development environment on the mainframes, with commands for saving, listing, and editing programs. Many DTSS users learned basic programming as part of their coursework.
- The popularity of BASIC on both mainframes and, later, microcomputers helped spread programming to millions. A lot of early BASIC games and simple programs appeared on DTSS and in early microcomputer software.
- Other vendors adapted BASIC for their machines. HP’s Time-Shared BASIC and DEC’s BASIC-Plus were common, each with its own twists. Microsoft’s BASIC (MS BASIC) became the de facto standard on home computers, shaping the BASIC landscape for years.

Standards and the later era
- In the 1970s and 1980s there were efforts to standardize BASIC. ANSI and ECMA worked on Minimal BASIC and Standard BASIC, but these standards faced mixed reception as many popular variants (and MS BASIC in particular) diverged.
- Despite the standards effort, by the mid-1980s the market moved toward shrink-wrapped software and more commercial languages, and the prominence of BASIC declined. Dartmouth’s draft of Standard BASIC influenced the history of the language, but the broader scene moved in other directions.

Legacy
- Dartmouth BASIC played a crucial role in making programming accessible and in teaching thousands of students the fundamentals of programming.
- It influenced many later dialects and laid the groundwork for the idea that computing could be integrated into everyday education.
- The language’s emphasis on interactivity, readability, and practical tools helped spark a generation of programmers and a lasting interest in computer science education.

In short, Dartmouth BASIC started as a small, interactive project at Dartmouth and grew into a major influence on how people learned and used programming for decades.