The history of programming languages is filled with innovations designed by experts for experts — languages that demanded deep technical knowledge before a single meaningful program could be written. BASIC was the radical exception. Created in 1964 at Dartmouth College by Thomas Kurtz and John Kemeny, BASIC was designed from the very beginning to be accessible to people who were not computer scientists, not engineers, not mathematicians — but students, teachers, and eventually millions of ordinary people who simply wanted to make a computer do something useful. Thomas Eugene Kurtz, the quieter half of this partnership, brought a rare combination of mathematical rigor and practical engineering sensibility to the project. His conviction that computing should be a universal skill, not a specialist’s privilege, helped shape a language that would become the first programming experience for an entire generation.
Early Life and Education
Thomas Eugene Kurtz was born on February 22, 1928, in Oak Park, Illinois — a suburb of Chicago known for its architecture and its educated, middle-class population. Growing up during the Great Depression and World War II, Kurtz belonged to a generation for whom education was both a privilege and a path to opportunity. His aptitude for mathematics became evident early, and it was this talent that would carry him through an academic trajectory leading from the Midwest to one of the most prestigious mathematics programs in the country.
Kurtz pursued his undergraduate studies at Knox College in Galesburg, Illinois, where he earned his bachelor’s degree in mathematics. Knox, a small liberal arts college with a strong tradition in the sciences, provided the kind of broad intellectual foundation that would later inform Kurtz’s belief that computing should be accessible to students across all disciplines — not just those in technical fields. The liberal arts ethos, with its emphasis on making knowledge accessible and interconnected, stayed with Kurtz throughout his career.
For his graduate work, Kurtz went to Princeton University, where he earned his Ph.D. in mathematical statistics. Princeton’s mathematics department in the 1950s was one of the intellectual centers of the world, home to figures whose work spanned pure mathematics, logic, and the nascent field of computing. It was an environment steeped in the tradition of rigorous formal thinking — the same tradition that had produced Alan Turing’s foundational work on computability and John Backus’s later efforts to make scientific computing practical through Fortran. Kurtz’s training in statistics gave him a particular sensitivity to the needs of non-specialist users: statisticians were among the earliest groups who needed computers but lacked the inclination to become programmers in the traditional sense.
Dartmouth College and the Computing Mission
In 1956, Kurtz joined the faculty of Dartmouth College in Hanover, New Hampshire, where he would spend his entire professional career. Dartmouth, an Ivy League institution with a strong commitment to undergraduate education, proved to be the perfect environment for Kurtz’s evolving vision of democratic computing. Shortly after arriving, he encountered John Kemeny, a Hungarian-born mathematician who had worked as a research assistant to Albert Einstein at Princeton and who shared Kurtz’s conviction that computing was too important to be left to specialists.
The partnership between Kurtz and Kemeny was one of those rare intellectual collaborations where the strengths of each party complemented the other almost perfectly. Kemeny was the visionary and the public advocate — charismatic, articulate, and politically adept. Kurtz was the engineer and implementer — methodical, detail-oriented, and deeply practical. Together, they would transform Dartmouth’s relationship with computing and, in doing so, transform computing’s relationship with the world.
Their shared frustration was simple to articulate and difficult to solve. In the early 1960s, using a computer at most universities meant submitting a deck of punched cards to a computing center, waiting hours or even days for the results, and then discovering that a single misplaced comma had caused the entire job to fail. The languages available — Fortran for scientists, COBOL for business — were powerful but demanding. They required an understanding of machine architecture, memory management, and arcane syntax that had nothing to do with the problems students actually wanted to solve. The situation was, as Kurtz and Kemeny saw it, profoundly undemocratic. Computing was a skill that every educated person would eventually need, yet the tools made it accessible only to a self-selecting priesthood of technical initiates.
The Dartmouth Time-Sharing System
Before BASIC could exist, the infrastructure to support it had to be built. In the early 1960s, most computers operated in batch mode: one program at a time, submitted on punched cards, processed sequentially. This model was fundamentally incompatible with the interactive, exploratory style of computing that Kurtz and Kemeny envisioned. If students were to learn programming by writing and running programs — making mistakes, seeing results, and trying again immediately — they needed a system that allowed multiple users to interact with the computer simultaneously.
The solution was the Dartmouth Time-Sharing System (DTSS), which Kurtz and Kemeny developed with a team of undergraduate programmers beginning in 1963. Time-sharing itself was not a new idea — Fernando Corbató at MIT had demonstrated the Compatible Time-Sharing System (CTSS) in 1961, proving that a single computer could serve multiple users through the illusion of simultaneous access. But where CTSS was a research project aimed at advanced computer scientists, DTSS was designed from the start as an educational system. Its users would be freshmen with no prior computing experience, and everything about the system — from its interface to its error messages — was designed with that audience in mind.
DTSS went live on May 1, 1964, running on a General Electric GE-225 computer. At 4 a.m. that morning, two programs ran simultaneously for the first time: one written in BASIC and one in a version of Algol. It was a milestone moment — not because time-sharing was new, but because for the first time, a time-sharing system had been built specifically to put computing power directly in the hands of students. The terminals scattered across Dartmouth’s campus — initially Teletype machines connected to the central computer — represented a new model of computing: personal, immediate, and accessible. This was years before the personal computer would make such access commonplace, and the philosophical foundation that Kurtz and Kemeny laid at Dartmouth anticipated what would become the dominant paradigm of human-computer interaction.
The Creation of BASIC
BASIC — Beginner’s All-purpose Symbolic Instruction Code — was designed to be the language of DTSS, and its design reflected the system’s educational mission in every detail. Kurtz and Kemeny began designing the language in 1963, and the first BASIC program ran on May 1, 1964, the same morning that DTSS went live.
The design principles were radical in their simplicity. BASIC would use English-like keywords that told the user what they did: PRINT, INPUT, IF, THEN, GOTO, LET, FOR, NEXT, END. The syntax would be forgiving — no semicolons to trip over, no braces to balance, no type declarations to puzzle out. Error messages would be written in plain English, not cryptic codes. Every line would be numbered, making it easy to refer to specific parts of a program and to insert new lines between existing ones. The language would be interactive: type a command and see the result immediately, without the punched-card ritual of compile-link-run.
Here is a characteristic example of early Dartmouth BASIC — the kind of program a student might write in their first week:
10 PRINT "TEMPERATURE CONVERSION TABLE"
20 PRINT "=============================="
30 PRINT "FAHRENHEIT", "CELSIUS"
40 PRINT "----------", "-------"
50 FOR F = 0 TO 212 STEP 10
60 LET C = (F - 32) * 5 / 9
70 PRINT F, INT(C * 10 + 0.5) / 10
80 NEXT F
90 PRINT
100 INPUT "ENTER A TEMPERATURE IN F: "; T
110 LET R = (T - 32) * 5 / 9
120 PRINT T; " FAHRENHEIT ="; INT(R * 10 + 0.5) / 10; " CELSIUS"
130 ENDThe clarity of this code was the point. A student encountering this program for the first time could read it almost as English. PRINT displays text. FOR creates a loop. LET assigns a value. INPUT asks the user for data. There was no boilerplate, no ceremony, no invisible machinery. The distance between the idea — “convert temperatures and display a table” — and the code that expressed it was as short as Kurtz and Kemeny could make it. This was a deliberate contrast to the languages that came before, where even a simple program required understanding concepts far removed from the problem at hand.
The language also reflected Kurtz’s statistical background in its approach to numerical computation. BASIC handled floating-point arithmetic transparently, without requiring the user to distinguish between integers and real numbers. Matrix operations were built into the language from the earliest versions — a feature that reflected both Kemeny’s mathematical interests and the kinds of computational problems that social science and natural science students would encounter. The language supported string manipulation, file input and output, and eventually graphics — always with the same philosophy of making the common case simple and the advanced case possible.
BASIC Goes Global: The Home Computer Revolution
Kurtz and Kemeny made a decision that would prove as important as the language’s design itself: they did not patent or restrict BASIC. The language specification was published freely, and anyone was welcome to implement it. This openness was consistent with the academic culture of the time and with Kurtz and Kemeny’s belief that BASIC was a public good — a tool for education that should be available to everyone. It was also the decision that set BASIC on its path to world domination.
In the mid-1970s, when the microcomputer revolution began, BASIC was already the most widely taught programming language in American high schools and colleges. When hobbyists and entrepreneurs began building personal computers — the Altair 8800, the Apple II, the Commodore PET, the TRS-80 — they needed a programming language that was simple enough for individual users, small enough to fit in limited memory, and familiar enough that people would actually use it. BASIC was the obvious choice. Almost every personal computer of the late 1970s and 1980s shipped with a BASIC interpreter built into its ROM, ready to run the moment the machine was turned on.
The most consequential BASIC implementation was arguably the first commercial one. In 1975, a young Harvard dropout named Bill Gates, together with Paul Allen, wrote Altair BASIC for the MITS Altair 8800. It was the first product of their new company, initially called Micro-Soft. Microsoft BASIC became the standard interpreter for most personal computers, and the revenue it generated gave Gates and Allen the foundation on which they built what would become the world’s largest software company. The direct line from Kurtz and Kemeny’s educational language to the birth of the personal computer software industry is one of the most remarkable chains of causation in the history of technology.
The Apple II, launched in 1977 with Applesoft BASIC (written by Microsoft), brought BASIC into schools and homes across America. The Commodore 64, which became the best-selling personal computer of all time, included Commodore BASIC. The BBC Micro in the United Kingdom, the MSX standard in Japan and Europe, the ZX Spectrum — all ran BASIC. For millions of people born between roughly 1965 and 1985, BASIC was not merely the first programming language they learned; it was the first meaningful interaction they had with a computer. Turning on a machine and seeing the READY prompt, then typing 10 PRINT “HELLO” and pressing RUN — that experience, repeated millions of times in bedrooms and classrooms around the world, created the generation of programmers, engineers, and entrepreneurs who built the modern technology industry.
The Fragmentation Problem and True BASIC
The very openness that made BASIC ubiquitous also created a problem that troubled Kurtz deeply: fragmentation. Because the language specification was freely available and anyone could implement it, dozens of incompatible dialects emerged. Microsoft BASIC differed from Applesoft BASIC, which differed from Commodore BASIC, which differed from BBC BASIC. Programs written for one machine often could not run on another without significant modification. Worse, many of these implementations added features — most notably the GOTO-heavy style of programming that Edsger Dijkstra and other computer scientists had rightly criticized — that violated the principles Kurtz and Kemeny had built into the original design.
Dijkstra’s famous criticism that BASIC was harmful to students’ programming education stung, but Kurtz understood that the critique was aimed at the corrupted versions of BASIC that proliferated on home computers, not at the structured Dartmouth original. The line-numbered, GOTO-dependent style of programming that most people associated with BASIC was a consequence of the severe memory constraints of early microcomputers, not a feature of the language as Kurtz and Kemeny had designed it. The original Dartmouth BASIC had always supported structured programming constructs; it was the stripped-down micro implementations that forced programmers into bad habits.
In response to this fragmentation, Kurtz and Kemeny created True BASIC in 1983. True BASIC was a modern, structured version of the language that eliminated line numbers, supported proper subroutines and functions, included structured control flow (IF-THEN-ELSE blocks, DO-WHILE loops, SELECT CASE), and provided graphics capabilities. It was designed to be portable across different operating systems — a program written in True BASIC on a Macintosh would run identically on an IBM PC or a Unix workstation.
! True BASIC: Structured Monte Carlo simulation
! Estimating the value of Pi using random points
PROGRAM MonteCarloPi
RANDOMIZE
LET total_points = 100000
LET inside_circle = 0
FOR i = 1 TO total_points
LET x = RND
LET y = RND
LET distance = SQR(x * x + y * y)
IF distance <= 1 THEN
LET inside_circle = inside_circle + 1
END IF
NEXT i
LET pi_estimate = 4 * inside_circle / total_points
PRINT "Points generated:"; total_points
PRINT "Points inside circle:"; inside_circle
PRINT "Estimated Pi:"; pi_estimate
PRINT "Actual Pi: "; PI
! Graphical demonstration
SET WINDOW -0.1, 1.1, -0.1, 1.1
DRAW circle WITH SCALE(0.5) * SHIFT(0.5, 0.5)
BOX LINES 0, 1, 0, 1
END PROGRAMTrue BASIC represented Kurtz's vision of what BASIC should have become — a clean, structured, portable language that retained the original's accessibility while embracing modern programming practices. Commercially, however, True BASIC struggled. By the mid-1980s, the market had moved on. Microsoft's QuickBASIC and later Visual Basic dominated the BASIC ecosystem, and newer languages were emerging that offered the same accessibility with more modern features. The influence of Niklaus Wirth's Pascal on structured programming education had shifted the academic conversation, and languages like Python would eventually inherit BASIC's mantle as the beginner's first language. But True BASIC stood as a statement of principle: a demonstration that BASIC could be both accessible and rigorous, both simple and structured.
Kurtz and the ANSI BASIC Standard
Kurtz's fight against fragmentation extended beyond True BASIC to the standards process itself. He was actively involved in the development of ANSI BASIC (the American National Standard for BASIC), working through the X3J2 committee to establish a formal specification that would define what BASIC was and was not. The effort was partly successful — the ANSI standard codified structured programming features and eliminated many of the inconsistencies among dialects — but the commercial reality of the personal computer market meant that de facto standards set by Microsoft carried more weight than de jure standards set by committees.
This tension between the original vision and the market's distortions was a recurring theme in Kurtz's career. He had created BASIC as a language for education, grounded in clear design principles and structured programming. The market had taken his creation, stripped it down to fit in 8K of ROM, and produced something that, while wildly successful, bore only a superficial resemblance to the original. Kurtz spent much of the 1980s and 1990s trying to reclaim the language's identity — an effort that was noble, technically sound, and largely futile against the momentum of commercial interests. The experience offered a lesson that resonates in modern software development, where technology strategy consultants regularly advise teams on maintaining architectural integrity as products scale and fragment across platforms.
Director of Dartmouth's Computing Center
Beyond his work on BASIC and DTSS, Kurtz served as the director of Dartmouth College's Kiewit Computation Center, where he oversaw the expansion of computing resources that supported the college's ambitious vision of universal computer access. Under his leadership, Dartmouth became one of the first colleges in the country where every student — regardless of major — was expected to have hands-on experience with computers. This was not a trivial administrative achievement; it required building infrastructure, training faculty across departments, and sustaining institutional commitment over decades.
The Dartmouth model — computing as a liberal art, accessible to all students through time-sharing and simple programming languages — influenced universities across the country. The National Science Foundation supported the dissemination of the Dartmouth approach, and by the late 1960s, time-sharing systems modeled on DTSS were operating at colleges and high schools nationwide. Kurtz's role in this dissemination was both technical and evangelical: he helped institutions set up their own systems and trained their faculty in the pedagogical philosophy that made the Dartmouth experiment work.
The computing center directorship also gave Kurtz a practical understanding of the operational challenges of large-scale computing. Managing a shared system serving hundreds of simultaneous users — keeping it reliable, fast, and fair — required solving problems in resource allocation, scheduling, and system administration that were at the cutting edge of computer science in the 1960s and 1970s. This operational experience informed Kurtz's pragmatic approach to language design: he understood that a language is only as useful as the system that runs it, and that elegance in theory means nothing if the system crashes under real-world load.
Philosophy and Design Principles
Thomas Kurtz's approach to programming language design was grounded in a set of principles that, while simple to state, were revolutionary in their implications for who could participate in computing.
Accessibility above all. The central principle of BASIC was that programming should be accessible to non-specialists. Kurtz believed that the barrier to entry for computing was not intelligence but interface design. If a language required months of study before a student could write a meaningful program, the language was at fault — not the student. This principle led to every design decision in BASIC: English-like keywords, forgiving syntax, immediate feedback through the interactive environment, and clear error messages. The philosophy anticipated by decades the user-experience movement in software design.
Computing as a liberal art. Kurtz and Kemeny did not see programming as a vocational skill for future engineers; they saw it as a fundamental intellectual tool — like writing or mathematics — that every educated person should possess. This vision was radical in the 1960s, when computers were room-sized machines tended by specialists. It has proven prophetic: the debate today is not whether programming should be part of general education but how early it should begin. Modern project management tools reflect this same democratizing impulse, making sophisticated planning and coordination capabilities accessible to teams without specialized technical training.
Interactivity as pedagogy. The decision to build BASIC on a time-sharing system was not merely technical — it was pedagogical. Kurtz understood that learning requires rapid feedback. A student who writes a program and sees the result in seconds will learn faster and more deeply than one who submits a card deck and waits until tomorrow. This insight — that the speed of the feedback loop determines the quality of learning — has become axiomatic in software development, embodied in practices like test-driven development, continuous integration, and the interactive computing environments that Brendan Eich would later help enable through JavaScript in web browsers.
Simplicity as discipline. Making a language simple is harder than making it complex. Kurtz and Kemeny had to decide what to leave out as carefully as they decided what to include. BASIC had no pointers, no memory management, no complex type system, no preprocessor directives — not because these features are not useful, but because they are not useful for beginners. The discipline of simplicity — of resisting the urge to add every feature that an expert might want — is one of the hardest challenges in language design, and Kurtz's success in maintaining it through the original Dartmouth BASIC remains exemplary.
Legacy and Modern Influence
Thomas Kurtz's influence on computing extends far beyond the BASIC language itself, though that alone would secure his place in the history of technology. His legacy operates on multiple levels, from the specific to the philosophical.
At the most direct level, BASIC was the first programming language for an estimated tens of millions of people. The generation of technologists who built the personal computer industry, the internet, and the modern software ecosystem overwhelmingly began their programming careers with BASIC. Steve Wozniak, Bill Gates, Tim Berners-Lee, and countless others wrote their first programs in some version of the language Kurtz and Kemeny created. The cultural impact of putting a programmable machine — and a language simple enough to use it — into the hands of an entire generation is difficult to overstate.
At the architectural level, BASIC's evolution traces the history of programming language design itself. The journey from Dartmouth BASIC through the microcomputer dialects to True BASIC and Visual Basic mirrors the field's broader movement from unstructured to structured programming, from procedural to object-oriented design, from compiled to interpreted execution. Visual Basic, which Microsoft released in 1991, became one of the most widely used programming languages in the world and brought event-driven, graphical programming to millions of developers. Its lineage traces directly back to the language Kurtz and Kemeny designed in a classroom at Dartmouth.
At the philosophical level, Kurtz's most important contribution may be the idea that programming should be accessible to everyone. This idea, which seemed radical in 1964, has become the foundational assumption of movements like code literacy, computational thinking, and programming education for children. Languages like Scratch, designed at MIT to teach programming to children, are the direct intellectual descendants of BASIC. Python's dominance as a first programming language owes much to the same principles — readable syntax, minimal ceremony, immediate feedback — that Kurtz and Kemeny established sixty years ago.
The Dartmouth Time-Sharing System, meanwhile, anticipated the model of personal computing that would not become mainstream for another two decades. By giving individual users their own terminal, their own session, and the illusion of their own computer, DTSS prefigured the personal computer, the time-shared mainframe services of the 1970s, and ultimately the cloud computing model of the 2020s. The conceptual leap from "one computer serves one user at a time" to "one computer serves many users simultaneously" — a leap that Kurtz and his team implemented in practice — was essential to the democratization of computing that defines the modern world.
Thomas Kurtz demonstrated that the most consequential innovations in computing are not always the most technically sophisticated. Creating a language that experts found too simple was, paradoxically, one of the most difficult and impactful achievements in the history of programming. By insisting that computers could be made accessible to everyone — and then proving it with BASIC and DTSS — Kurtz helped set in motion the transformation of computing from a specialized profession into a universal human activity.
Key Facts
- Born Thomas Eugene Kurtz on February 22, 1928, in Oak Park, Illinois
- Earned a B.A. in mathematics from Knox College and a Ph.D. in mathematical statistics from Princeton University
- Joined the Dartmouth College faculty in 1956, where he spent his entire academic career
- Co-created the BASIC programming language with John Kemeny; first BASIC program ran on May 1, 1964
- Co-developed the Dartmouth Time-Sharing System (DTSS), enabling multiple users to share a single computer interactively
- Served as director of Dartmouth's Kiewit Computation Center
- Co-created True BASIC in 1983, a structured, portable version of the language designed to address dialect fragmentation
- Actively participated in the ANSI BASIC standardization effort through the X3J2 committee
- BASIC became the default language on virtually all personal computers of the late 1970s and 1980s, including the Apple II, Commodore 64, TRS-80, and IBM PC
- Bill Gates and Paul Allen's first product, Altair BASIC (1975), launched Microsoft and the commercial software industry
- BASIC's philosophy of accessible programming directly influenced modern beginner-friendly languages like Python and Scratch
- The Dartmouth model of universal computing access anticipated personal computing and cloud computing by decades
Frequently Asked Questions
What is BASIC and why was it created?
BASIC (Beginner's All-purpose Symbolic Instruction Code) is a programming language created in 1964 at Dartmouth College by Thomas Kurtz and John Kemeny. It was designed to solve a specific problem: in the early 1960s, programming languages like Fortran and COBOL were powerful but extremely difficult for non-specialists to learn. Kurtz and Kemeny believed that every college student — whether studying English, history, or physics — should be able to use a computer, and they needed a language simple enough to teach in a few hours. BASIC used English-like commands (PRINT, INPUT, IF-THEN), required minimal syntax, provided immediate interactive feedback through the Dartmouth Time-Sharing System, and gave clear error messages in plain language. The result was a language that lowered the barrier to programming more dramatically than any language before it, ultimately becoming the first programming experience for tens of millions of people during the personal computer era of the 1970s and 1980s.
How did BASIC become the dominant language on personal computers?
Kurtz and Kemeny chose not to patent or restrict BASIC, allowing anyone to create their own implementation. When the personal computer revolution began in the mid-1970s, hardware makers needed a simple, well-known language that fit in limited memory and was familiar to hobbyists and students. BASIC was the natural choice. Bill Gates and Paul Allen wrote the first commercial BASIC interpreter for the Altair 8800 in 1975, founding Microsoft in the process. Microsoft BASIC subsequently became the standard interpreter shipped with nearly every major personal computer, including the Apple II (Applesoft BASIC), Commodore 64, TRS-80, BBC Micro, and IBM PC. For roughly a decade, turning on a personal computer meant being greeted by a BASIC prompt — making the language inseparable from the experience of personal computing itself.
What was the difference between Dartmouth BASIC and the versions on home computers?
The original Dartmouth BASIC was a carefully designed educational language that supported structured programming and ran on a sophisticated time-sharing system. The versions that appeared on home computers in the late 1970s and 1980s were heavily stripped-down implementations constrained by tiny amounts of memory — often just 4 to 16 kilobytes. These micro implementations typically lacked proper subroutines, structured control flow, and many mathematical functions, forcing programmers into a GOTO-heavy style that computer scientists like Edsger Dijkstra rightly criticized. Kurtz found this fragmentation deeply troubling, as the dialects on home computers gave BASIC a reputation for encouraging bad programming habits that the original language had been designed to avoid. His response was True BASIC (1983), a structured version that restored the language's original design principles with proper subroutines, block control structures, and cross-platform portability.
What is the Dartmouth Time-Sharing System and why did it matter?
The Dartmouth Time-Sharing System (DTSS), developed by Kurtz, Kemeny, and a team of undergraduate programmers, went live on May 1, 1964, the same day the first BASIC program ran. DTSS allowed multiple users to interact with a single computer simultaneously through remote terminals, each getting the impression of having the machine to themselves. While MIT's CTSS had demonstrated time-sharing earlier, DTSS was the first system built specifically for education — designed so that freshmen with no computing background could sit at a terminal and start programming immediately. This model of interactive, personal access to computing anticipated the personal computer by nearly two decades and established the philosophical foundation that computing should be an immediate, individual, and accessible experience rather than a remote, batch-oriented, and specialist-only activity.
