A groundbreaking initiative led by prominent software developer and "Coding Horror" blogger Jeff Atwood aims to meticulously update the seminal "101 BASIC Computer Games" for the modern programming landscape. This ambitious project, hosted on GitHub, seeks to transform the rudimentary code of these 1970s games into contemporary, memory-safe versions across ten popular scripting languages, inviting global collaboration to preserve a cornerstone of early computing history. The endeavor not only revives historical artifacts but also serves as a pedagogical bridge, illustrating the evolution of programming practices for a new generation of developers.
The Genesis of a Digital Legacy: "101 BASIC Computer Games"
For many pioneers of the digital age, the journey into programming began not with sleek graphical user interfaces or intuitive drag-and-drop environments, but with the stark, blinking cursor of a command line. Early personal computers of the 1970s and early 1980s booted directly into this text-based interface, often presenting a prompt that demanded direct interaction. Unlike today’s app-rich ecosystems, these machines offered little out-of-the-box functionality. Users who desired their computers to perform tasks, or, more often, to entertain, frequently had to manually input programs. This arduous process often involved painstakingly typing lines of code from printed manuals or, most famously, from books like David H. Ahl’s "101 BASIC Computer Games."
Published by Digital Equipment Corporation (DEC) in 1973, "101 BASIC Computer Games" quickly transcended its humble origins to become a cultural phenomenon in the nascent world of personal computing. The book was a compendium of games originally featured in Ahl’s influential "Creative Computing Magazine," offering a diverse array of text-based adventures, puzzles, and simulations. Its impact was immediate and profound, as evidenced by its unprecedented sales figures. At one point, the book sold more copies than there were personal computers available, a testament to its widespread appeal and its role as a primary gateway to computer interaction for countless individuals. It was, notably, the first computer book ever to sell a million copies, a benchmark that underscored its immense influence on an entire generation of aspiring programmers, including Jeff Atwood himself, who credits the book as foundational to his professional career.
David H. Ahl and the Birth of Creative Computing
The story of "101 BASIC Computer Games" is inextricably linked to its visionary author, David H. Ahl, a figure often hailed as one of the most significant evangelists of personal computing. Before authoring the landmark book, Ahl was instrumental in popularizing computing through his work at DEC, where he recognized the immense potential of making computers accessible to the general public. His passion led him to establish "Creative Computing Magazine," a publication that would become a beacon for early computer enthusiasts.
Ahl’s entrepreneurial spirit and dedication were legendary. In 1974, after leaving DEC, he poured his "sweat equity" into launching "Creative Computing." With minimal capital, he single-handedly managed every aspect of the magazine’s production: editing articles, writing his own content, specifying type, taking photographs, creating illustrations, and meticulously laying out boards. He even handled the marketing and distribution, famously printing 8,000 copies of the inaugural issue despite having only 600 subscribers. The remaining 7,400 copies were personally labeled and mailed by Ahl to libraries and school systems across the country, a strategic move that significantly broadened the magazine’s reach and fostered a grassroots interest in computing long before microcomputers became a household item. This pioneering approach laid the groundwork for the future success of his books, which tapped into a growing appetite for hands-on computer experience.
The Era of Manual Input and BASIC’s Dominance
The 1970s and early 1980s represented a unique period in computing history. The personal computer revolution was still in its infancy, and machines like the Apple II, Commodore 64, and TRS-80 were just beginning to democratize access to computing power. Crucially, these early machines predominantly ran on BASIC (Beginner’s All-purpose Symbolic Instruction Code). Designed at Dartmouth College in 1964 by John G. Kemeny and Thomas E. Kurtz, BASIC was conceived as a simple, easy-to-learn programming language that could be used by students and non-specialists. Its straightforward syntax and interpretive nature made it ideal for direct interaction with computers, contrasting sharply with more complex languages like Fortran or COBOL.
However, the simplicity of early BASIC came with its own set of challenges, particularly for users typing programs from books. The reliance on line numbers and ubiquitous GOTO statements often led to "spaghetti code" – programs that were difficult to follow, debug, and maintain. A single typographical error could render an entire program non-functional, leading to hours of frustrating manual debugging. The process of copying code by hand was a ritual for many, a blend of meticulous transcription and hopeful expectation, often culminating in the triumphant (or frustrating) execution of a rudimentary game. This era, while challenging, forged a deep connection between user and machine, where understanding the underlying code was a prerequisite for interaction. The trickle-down of inexpensive personal computers to the mainstream by approximately 1984 made these books, and the hands-on coding experience they offered, truly accessible to a broad public, sparking a generation’s interest in software development.
The Imperative for True Modernization
While the historical significance of these BASIC programs is undeniable, their direct relevance to contemporary programming practices is limited. An earlier attempt in 2010 to modernize these programs using SmallBasic, an educational programming language from Microsoft, largely fell short of truly updating them. This initiative primarily focused on removing line numbers, a superficial change that failed to address the deeper structural and conceptual differences between 1970s BASIC and modern coding principles. As Atwood points out, crucial concepts like subroutines – widely regarded as one of the greatest inventions in computer science for promoting modularity and code reuse – were conspicuously absent in these "modernized" versions.
The comparison between the original 1973 BASIC "Civil War" game and its 2010 SmallBasic port starkly illustrates this point. While the SmallBasic version shed the explicit line numbers, its underlying logic and structure remained largely monolithic, devoid of the modularity, function abstraction, and structured control flow that define modern programming. This approach missed an opportunity to not only preserve the essence of these historical games but also to showcase how modern languages handle similar computational problems with greater elegance, efficiency, and maintainability. Modern software development emphasizes principles like encapsulation, abstraction, and memory safety, which were not inherent in the unstructured nature of early BASIC.
Jeff Atwood’s Vision for a Collaborative Update
Recognizing this gap, Jeff Atwood embarked on a mission to undertake a comprehensive and authentic modernization. With considerable enthusiasm, he contacted David H. Ahl, seeking permission to create a website and collaborative project that would genuinely update these ancient BASIC programs. Ahl, understanding the enduring legacy of his work, graciously granted permission, paving the way for a project that respects history while embracing the future.
Atwood’s vision extends beyond mere translation. The project aims to rewrite these games in modern, memory-safe languages, integrating contemporary programming practices such as subroutines, functions, and object-oriented principles where appropriate. The emphasis on "memory-safe, general-purpose scripting languages" is crucial. This selection ensures that the updated code is not only more robust and secure but also accessible to a wide audience of developers familiar with current mainstream languages. The initial selection of languages included Python, Ruby, JavaScript, and others, with an iterative refinement process that saw the inclusion of Kotlin (as an alternative to Java, offering modern features and conciseness, especially in mobile and enterprise development), Rust (renowned for its strong memory safety guarantees without a garbage collector, replacing Pascal which could not guarantee the same level of safety), and Lua (a lightweight, embeddable scripting language that recently entered the top 20 in the TIOBE index and is popular in game development and embedded systems). This curated list reflects a commitment to both practical utility and adherence to modern security and design principles.
A Global, Open-Source Endeavor
The project is hosted on GitHub, leveraging the power of open-source collaboration to achieve its ambitious goals. This choice is symbolic: it transforms the solitary act of typing code from a book in 1984 into a global, collective effort. Instead of individual programmers isolated in their rooms, battling typos and debugging alone, the GitHub platform allows for simultaneous contributions, peer review, and collective problem-solving. This collaborative model not only accelerates the modernization process but also embodies the spirit of community that has become a hallmark of modern software development.
Contributors are tasked with translating each of the original 101 games into the specified modern languages, adhering to guidelines that prioritize readability, maintainability, and the incorporation of structured programming concepts. While the games themselves are acknowledged as primitive artifacts of the 1970s – not intended to win awards for gameplay or programming sophistication – their value lies in their historical context and their potential as educational tools. The project also aims to preserve the charming original artwork by George Beker, ensuring that the aesthetic heritage of the book is carried forward, offering a complete historical package. The collaborative framework encourages participants to see themselves as part of a larger historical preservation effort, replicating the collective learning experience that defined early computing in a globally connected, modern context.
Incentives and Broader Impact
To foster engagement and encourage contributions, Jeff Atwood has pledged a significant incentive: for every functioning program submitted in each of the ten designated languages by the end of 2022, he will donate $5 to Girls Who Code. This initiative highlights the project’s commitment to social impact, particularly in promoting diversity and inclusion within the technology sector. Girls Who Code is a non-profit organization dedicated to closing the gender gap in technology, providing educational opportunities and resources to young women. By linking contributions to this cause, the project not only modernizes code but also contributes to shaping the future of programming talent, underscoring the idea that historical preservation can align with contemporary social responsibility.
The project also seeks co-owners, individuals passionate enough to help organize and steer this considerable effort, transforming it from a personal initiative into a truly community-driven endeavor. This call for leadership underscores the collaborative ethos, aiming to build a sustainable framework for ongoing maintenance and future expansion. Atwood emphasizes the importance of teamwork, a fundamental aspect of modern software development, directly contrasting it with the isolated learning experiences of the past. Discussions and queries are channeled through a dedicated Discourse topic, fostering a community of practice around the project.
The broader implications of this project are manifold. Firstly, it represents a crucial act of digital preservation, ensuring that these early examples of interactive computing remain accessible and understandable for future generations. As technology evolves rapidly, artifacts from earlier eras can quickly become obscure or incompatible with modern systems. By translating these games into current languages, the project safeguards a vital piece of computing heritage, preventing digital rot and ensuring historical continuity.
Secondly, it serves as an invaluable educational resource. Students and aspiring programmers can explore the fundamental logic of these games, then examine how those same concepts are expressed using modern language constructs, modular design, and memory-safe practices. This comparative approach offers a unique window into the evolution of programming paradigms, highlighting the advancements in code structure, readability, and robustness over five decades. It allows a tangible understanding of concepts like subroutines, functions, and structured programming, demonstrating their practical benefits in a historical context and making abstract concepts concrete.
Finally, the project reinforces the idea that programming, at its core, is a creative and often enjoyable pursuit. The original book was about making computers fun and accessible, and this modernization effort aims to rekindle that spirit. It reminds us that even the most complex modern systems have roots in simple, interactive programs designed for exploration and play. As a New Year’s resolution for developers worldwide, contributing to this project offers a unique opportunity to engage with computing history, contribute to a meaningful open-source initiative, and support the next generation of technologists. The collaborative spirit, the focus on memory safety, and the commitment to education ensure that this update of "101 BASIC Computer Games" will stand as a testament to the enduring power of innovation and community in the world of software development.
The initiative, therefore, is more than just a code translation; it is a profound nod to the past, a practical engagement with the present, and an optimistic investment in the future of programming. It celebrates the legacy of David H. Ahl and the enduring appeal of the very first computer games, demonstrating that even the simplest programs can hold immense historical and educational value when viewed through a modern lens, encouraging current programmers to find the same joy and curiosity that fueled their predecessors.
About the Author
