The Birth of Dartmouth BASIC

Dartmouth BASIC: The Genesis of Interactive Computing

Dartmouth BASIC, the original version of the BASIC programming language, represents a pivotal milestone in the history of computing. Developed in the early 1960s at Dartmouth College by professors John G. Kemeny and Thomas E. Kurtz, it introduced an innovative approach to programming, emphasizing accessibility and interactivity. The language, designed as part of the Dartmouth Time Sharing System (DTSS), is credited with making computing more approachable to a wider audience. Dartmouth BASIC laid the groundwork for many of the programming paradigms and languages that followed, including Microsoft BASIC, and had a profound impact on the evolution of both personal and educational computing.

Before the advent of Dartmouth BASIC, most programming languages required extensive expertise and were typically confined to large research institutions or corporations. Programming was often performed on batch systems, where users submitted their programs and waited for results. This was a cumbersome process that was inefficient for many potential users, particularly those in education. Kemeny and Kurtz, who were both professors at Dartmouth College, recognized the need for a more accessible and efficient way for individuals to interact with computers. In this context, they embarked on a project to develop a new language that would allow people to program computers interactively in a way that was simple and intuitive.

The result was Dartmouth BASIC, first implemented on May 1, 1964. The language was specifically designed for use with the Dartmouth Time Sharing System, a revolutionary system that allowed multiple users to interact with a computer simultaneously. This was a stark departure from earlier systems that required users to wait for their turn. The idea of time-sharing was groundbreaking, and the development of BASIC as a programming language that could be used interactively was equally transformative.

Dartmouth BASIC was unique in that it was one of the first high-level programming languages designed specifically for interactive use. It allowed users to type commands directly into the computer, execute them, and receive immediate feedback. This was in contrast to previous systems where programming was done on punch cards or via batch processing. The language was easy to learn, with a syntax that was designed to be both simple and flexible, making it an ideal tool for beginners. As Kemeny and Kurtz put it, the goal of Dartmouth BASIC was to “democratize” computing, making it accessible to people who had no prior experience in programming.

The Dartmouth Time Sharing System (DTSS)

Dartmouth BASIC was developed as part of the Dartmouth Time Sharing System (DTSS), which was one of the first time-sharing systems to be widely available. The DTSS allowed multiple users to access a central computer simultaneously, sharing its processing power. Prior to this innovation, computing resources were typically available to only one user at a time, with access being granted in a batch mode. The introduction of time-sharing revolutionized how computers were used, enabling many people to interact with the machine at once and perform tasks that would have otherwise been impossible in a batch-processing environment.

The time-sharing system provided users with immediate access to the computer, which made it possible to run programs interactively and receive immediate feedback. This was a key feature of Dartmouth BASIC. The combination of time-sharing and a user-friendly programming language marked a significant departure from the traditional model of computing and made the technology much more accessible to a broader audience. The first version of Dartmouth BASIC ran on the IBM 704 mainframe, and subsequent versions were adapted to different hardware systems, further expanding the reach of the language.

Key Features of Dartmouth BASIC

Dartmouth BASIC was designed to be simple and straightforward, with a syntax that resembled everyday English. This was a deliberate choice, as Kemeny and Kurtz wanted to make the language as intuitive as possible. The language was developed with the understanding that programming should not be an esoteric skill confined to experts but rather a tool that anyone could learn and use to solve problems. Some of the key features of Dartmouth BASIC included:

Simplicity: The syntax of Dartmouth BASIC was intentionally simple, with commands that were easy to understand and use. This simplicity made the language accessible to a wide range of users, including students, educators, and non-technical individuals.
Interactive Environment: Unlike earlier programming languages, which required users to submit programs and wait for output, Dartmouth BASIC allowed users to enter commands directly into the system and receive immediate results. This interactive approach made it much easier to test ideas and iterate on programs.
Focus on Education: The development of Dartmouth BASIC was driven by a desire to promote learning. The language was designed to be used in educational settings, where it could help students learn programming and computational thinking. Over time, it became widely used in schools and universities, where it played a key role in teaching computer science.
Support for Mathematical Computations: Dartmouth BASIC was designed with support for mathematical functions, making it particularly useful for scientific and engineering applications. The language included commands for matrix math and other advanced computations, which were relatively uncommon in early programming languages.
Easy Debugging: The interactive nature of Dartmouth BASIC also made it easier for users to identify and correct errors. The immediate feedback provided by the system helped users learn from their mistakes and improve their programming skills more quickly.
Program Compilation: Dartmouth BASIC used a “compile-and-go” approach, which meant that programs could be written and executed in a single step. This approach simplified the process of running programs and eliminated the need for complex compilation procedures.

Dartmouth BASIC’s Legacy and Influence

The influence of Dartmouth BASIC extended far beyond the Dartmouth campus. Over the years, it became the foundation for a number of other BASIC dialects, most notably Microsoft BASIC (MS BASIC), which became the de facto standard for personal computers in the 1980s. MS BASIC was based on Dartmouth BASIC’s fifth edition and introduced many of the features that were present in the original language, including its simple syntax and interactive nature. While MS BASIC lacked some of the more advanced features of Dartmouth BASIC, such as matrix math, it was well-suited for early microcomputers with limited resources.

The widespread adoption of MS BASIC helped establish the BASIC language as one of the most popular programming languages of the 1970s and 1980s. It was included in many early home computers, including the Altair 8800, the Commodore PET, and the Apple II. As personal computers became more widespread, BASIC became one of the first languages that many individuals learned to program with.

Dartmouth BASIC also had a significant impact on the development of structured programming. In 1975, Dartmouth College introduced a revised version of BASIC known as Structured BASIC (SBASIC). SBASIC incorporated many of the principles of structured programming, a paradigm that emphasized the use of clear, logical structures in programs. This version of BASIC formed the basis for many of the ANSI-standard efforts in the 1980s, and it influenced the development of later programming languages like C and Pascal.

The Rise of True BASIC

In the late 1970s and early 1980s, Kemeny and Kurtz began to explore the development of a more advanced version of BASIC known as True BASIC. This new version was designed to address some of the shortcomings of earlier BASIC dialects, particularly with regard to structured programming. True BASIC introduced a more formalized syntax, with improved support for control structures and modular programming. It also removed some of the more limiting features of traditional BASIC, such as the use of line numbers for program flow.

True BASIC gained some popularity in educational settings, particularly in the 1980s and 1990s, as it offered a more structured and powerful programming environment compared to traditional BASIC implementations. Despite this, True BASIC was ultimately overshadowed by the rise of object-oriented languages like C++ and Java, which became more widely used in both academia and industry.

The Decline of Dartmouth BASIC and the Rise of Personal Computing

As personal computers became more widespread in the 1980s, the need for a language like Dartmouth BASIC declined. The rise of microcomputers and the proliferation of graphical user interfaces led to the development of new programming paradigms that were more suited to the capabilities of these new machines. Languages like C, Pascal, and later object-oriented languages like Java and Python, became more popular as personal computing evolved.

Despite its decline in popularity, Dartmouth BASIC remains a significant part of the history of computing. It was one of the first languages to make programming accessible to a broad audience, and its emphasis on interactivity and simplicity paved the way for the development of modern programming languages.

Conclusion

Dartmouth BASIC is much more than just a historical artifact. It represents a key turning point in the history of computing, from a world where programming was an esoteric skill limited to a few experts to an era in which anyone could learn to program and interact with computers. The language’s simple syntax, focus on interactive use, and educational emphasis made it an important tool in the development of the computing field. Although its direct influence may have waned with the rise of personal computing, its legacy continues to be felt today. Many of the principles behind Dartmouth BASIC — simplicity, accessibility, and interactivity — remain foundational to the way we think about programming and computing in general.

Dartmouth BASIC will always be remembered as the birthplace of a revolution in computer science that helped make computers and programming accessible to a global audience. It was a language that, in its time, democratized computing in a way that few could have predicted, and its impact is still evident in the programming languages and tools we use today.