hackslash dot org

The Curious Case of Jupiter Ace

Posted: 2025-04-10 12:39:34

The Jupiter Ace, a British home computer from the early 1980s, stood out due to its use of Forth as its primary programming language instead of the more common BASIC. While Forth offered advantages in speed and efficiency, its steeper learning curve likely contributed to the Ace's commercial failure. Despite its innovative use of a then-obscure language and compact, minimalist design, the Jupiter Ace ultimately lost out in the competitive home computer market, becoming a curious footnote in computing history.

The blog post "The Curious Case of Jupiter Ace" delves into the intriguing history of a relatively obscure British home computer released in the early 1980s, the Jupiter Ace. The author paints a picture of a machine born into a fiercely competitive market, already dominated by titans like the Sinclair ZX Spectrum and the Commodore 64. Despite this challenging landscape, the Jupiter Ace dared to be different, distinguishing itself through its utilization of Forth as its primary programming language, a bold choice that set it apart from its BASIC-speaking contemporaries. This decision, while conceptually interesting and potentially powerful for experienced programmers, ultimately contributed to the Ace's downfall. The article meticulously explains the rationale behind choosing Forth, highlighting its efficiency and extensibility, but also acknowledging its steep learning curve and the lack of readily available games, a critical factor for the target audience of home computer users, many of whom were young and primarily interested in entertainment.

The narrative further explores the development and subsequent demise of the Jupiter Cantab, a planned successor to the Ace. This enhanced version aimed to address some of the original machine's shortcomings, boasting improved hardware specifications and the inclusion of BASIC alongside Forth in an attempt to broaden its appeal. However, despite these promising developments, the Cantab ultimately failed to materialize as a commercial product, succumbing to the increasingly cutthroat nature of the home computer market. The post emphasizes the significant role of financial constraints and marketing challenges in the demise of both the Ace and the Cantab. The company behind these machines, Jupiter Cantab Ltd., struggled to secure the necessary funding and market penetration to compete effectively against larger, more established rivals.

Furthermore, the article offers a detailed examination of the technical aspects of the Jupiter Ace, outlining its hardware architecture and the unique capabilities afforded by its Forth-based operating system. The author emphasizes the machine's compactness and affordability, highlighting its minimalist design and relatively low price point. The post also touches upon the cultural context of the early 1980s home computer boom, portraying a period of rapid innovation and fierce competition, where numerous companies vied for the attention and wallets of a burgeoning consumer base. Ultimately, the Jupiter Ace, despite its innovative use of Forth and its dedicated following, became a footnote in the annals of computing history, a testament to the challenging realities of a rapidly evolving technological landscape. The story of the Jupiter Ace, as presented in the post, serves as a cautionary tale of a potentially groundbreaking product hampered by market forces and a failure to fully capture the imagination of the broader consumer base.

Summary of Comments ( 9 )
https://news.ycombinator.com/item?id=43643197

HN commenters discuss the Jupiter Ace's unique use of Forth, some appreciating its educational value and elegance while others find it esoteric and limiting. Several recall fond memories of using the machine, praising its speed and compact design. The limited software library and RAM are mentioned as drawbacks, alongside the challenges of garbage collection in Forth. The unconventional keyboard layout and the machine's overall fragility are also discussed. One commenter notes the irony of its Sinclair connection, being designed by former Sinclair employees yet failing where Sinclair succeeded. A few comments delve into the technicalities of Forth and its implementation on the Ace, while others lament its ultimate commercial failure despite its innovative aspects.

The Hacker News post titled "The Curious Case of Jupiter Ace" has generated several comments discussing the Jupiter Ace computer, its use of Forth, and its place in computing history.

Several commenters reflected on their own experiences with the Jupiter Ace. Some reminisced about owning or wanting one as a child, while others shared anecdotes about its quirks and capabilities. One commenter even recounted struggling with Forth as a child, eventually giving up and returning to BASIC. Another detailed their experience typing in the entire source code for a chess game from a magazine, highlighting the dedication required by early computer hobbyists.

A key theme in the comments is the discussion surrounding Forth as a programming language. Several commenters explored its advantages and disadvantages. Some praised its efficiency and power, contrasting it with BASIC's limitations. Others pointed out Forth's steep learning curve and unconventional syntax, acknowledging why it might not have appealed to a broader audience. One comment highlighted Chuck Moore, the creator of Forth, and his unique perspectives on computing.

The conversation also touched upon the broader context of the home computer market in the early 1980s. Commenters discussed the fierce competition and the various factors that contributed to the success or failure of different machines. The Jupiter Ace's relatively low price was mentioned as a potential advantage, while its reliance on Forth was seen as a possible reason for its limited commercial success.

Beyond personal experiences and technical details, some comments offered broader reflections on the history of computing and the legacy of machines like the Jupiter Ace. One commenter lamented the disappearance of smaller, more experimental computers, contrasting the vibrant landscape of the early 80s with the more consolidated market of today.

Finally, several commenters provided additional resources and links related to the Jupiter Ace, including emulators, documentation, and historical information, further enriching the discussion and allowing others to explore this piece of computing history.

Collapse OS

permalink

Posted: 2025-03-26 14:34:32

Collapse OS is a minimal, highly adaptable operating system designed for a post-apocalyptic scenario where global supply chains have broken down. It aims to be runnable on minimal and easily scavenged hardware, using widely available Z80 processors. Its functionality focuses on essential tasks like bootstrapping other, more complex systems, creating and running simple programs, and interfacing with rudimentary hardware like text terminals and floppy drives. The project anticipates a future where readily available modern hardware and software are no longer accessible, and seeks to provide a digital life raft by relying on robust, easily reproduced technologies.

The "Collapse OS" project, as detailed on its website, posits a scenario of widespread societal collapse due to a hypothetical long-term grid failure, resulting in the unavailability of modern computing infrastructure. It anticipates a world where readily available resources would revert to simpler, more robust technologies akin to those of the late 1970s and early 1980s, a period the project characterizes as the "final stage" of easily repairable and understandable electronic systems. In this post-collapse world, the project envisions a need for a specialized operating system capable of running on minimal and adaptable hardware, facilitating bootstrapping back to a more technologically advanced state.

Collapse OS aims to fill this perceived need by providing a highly adaptable and resilient operating system designed to operate on a variety of readily available, low-resource hardware platforms, primarily Z80-based systems. Its core functions are geared towards enabling the creation and maintenance of essential tools and systems in a resource-constrained environment. These functionalities include running a text editor, assembling programs for Z80 processors and other supported architectures like the 6502 and RISC-V, and facilitating rudimentary networking capabilities. The system is designed to be self-hosting, meaning it can be built and modified using its own tools, ensuring its continued evolution and maintenance even without access to modern development environments.

The project emphasizes simplicity and resilience in its design philosophy. The choice of the Z80 architecture is rooted in its prevalence, relative simplicity, and the continued availability of compatible hardware even in less developed regions. Furthermore, the operating system is designed to be bootable from a variety of storage media, including floppy disks, hard drives, and ROM chips, enhancing its adaptability to diverse hardware configurations. The website outlines the project's goals, technical details of its implementation, and instructions on building and using the system. It also includes documentation on porting the OS to new hardware platforms and contributing to the project’s development. The overarching objective is to provide a robust and adaptable computing platform that can serve as a foundation for rebuilding technological capabilities in a post-collapse scenario.

Summary of Comments ( 59 )
https://news.ycombinator.com/item?id=43482705

Hacker News users discussing Collapse OS express skepticism about its practicality and usefulness. Many question the likelihood of a societal collapse severe enough to render existing technology useless, while others point out the difficulty of bootstrapping complex technology from salvaged parts in a post-apocalyptic scenario. Some find the project interesting as a thought experiment or a hobby, but doubt its real-world applicability. A few commenters express concerns about the project's potential to attract a "doomer" mentality. The overall sentiment is one of cautious curiosity mixed with significant doubt about the project's premise and viability.

The Hacker News post titled "Collapse OS" with the ID 43482705 sparked a discussion with a variety of viewpoints on the project and its premise.

Several commenters expressed skepticism about the likelihood of a complete societal collapse severe enough to warrant such a specialized operating system. They questioned the practicality and usefulness of Collapse OS in such a scenario, suggesting that focusing on more immediate and probable challenges might be a better use of resources. The idea of maintaining complex technology like a Z80-based system in a true collapse scenario was also met with skepticism. Concerns were raised about the availability of compatible hardware and the ability to manufacture or repair it without existing industrial infrastructure.

Others discussed the more technical aspects of the project. The choice of the Z80 processor was a frequent topic, with some commenters questioning its suitability compared to other potentially more accessible and powerful platforms like the 6502. Discussions around the feasibility of bootstrapping a technological society from scratch using salvaged parts and limited resources also emerged. Some suggested that focusing on simpler, more robust technologies might be more appropriate for a post-collapse environment.

Some commenters, while not necessarily endorsing the premise of total collapse, expressed interest in the project from a hobbyist or educational perspective. They viewed Collapse OS as an intriguing experiment in minimalist computing and a potential platform for learning about low-level programming and hardware interaction.

A few commenters engaged with the philosophical implications of preparing for societal collapse, touching on themes of resilience, self-sufficiency, and the potential dangers of focusing on worst-case scenarios.

While acknowledging the potentially niche nature of the project, some commenters appreciated the creator's effort and vision, viewing Collapse OS as a thought-provoking exploration of alternative technological pathways.

A recurring theme throughout the comments was the importance of community and collaboration in any post-collapse scenario, with several commenters emphasizing the limitations of purely technological solutions and the need for social structures and human connection.

Converting C to ASM to specs and then to a working Z/80 Speccy tape

permalink

Posted: 2025-03-17 11:17:09

The author details the process of creating a ZX Spectrum game from scratch, starting with C code for core game logic. This C code was then manually translated into Z80 assembly, a challenging process requiring careful consideration of memory management and hardware limitations. After the assembly code was complete, they created a loading screen and integrated everything into a working .tap file, the standard format for Spectrum games. This involved understanding the intricacies of the Spectrum's tape loading system and manipulating audio frequencies to encode the game data for reliable loading on original hardware. The result was a playable game demonstrating a complete pipeline from high-level language to a functional retro game program.

This blog post chronicles the author's intricate journey of transforming a simple C program into a functional program on a ZX Spectrum, a classic 8-bit home computer from the 1980s. The process involved multiple stages of translation and conversion, each requiring careful consideration of the target platform's limitations and quirks.

Initially, the author began with a rudimentary C program designed to display a sequence of color changes on the screen. This C code served as the high-level blueprint for the subsequent transformations. The first step involved compiling the C code into Z80 assembly language, the native language understood by the ZX Spectrum's Z80 processor. This translation process necessitated adapting the C code's logic and data structures to the more primitive constructs available in assembly language.

Next, the generated assembly code was further refined into a format suitable for the ZX Spectrum's specific hardware and operating system. This involved incorporating system calls and memory management techniques particular to the ZX Spectrum. The author meticulously addressed details such as screen memory mapping and color palette manipulation to ensure compatibility with the target platform.

The final stage involved converting the tailored assembly code into a format that could be loaded and executed on the ZX Spectrum. This involved packaging the code into a .TAP file, a standard format used for distributing programs on audio cassette tapes, the primary storage medium for the ZX Spectrum. This .TAP file contained not just the program code itself, but also the necessary loading instructions and metadata for the ZX Spectrum's tape loading system. The author accomplished this using a dedicated tool designed specifically for generating .TAP files from assembly code. This tool handled the intricacies of encoding the data into an audio format suitable for playback on a cassette player and subsequent loading into the ZX Spectrum.

The successful outcome of this process was a functional .TAP file that, when played back on a cassette player connected to a ZX Spectrum, correctly reproduced the color sequence originally defined in the C program. The author's journey demonstrates the intricate process of developing software for retro hardware platforms, showcasing the multiple layers of abstraction and conversion required to bridge the gap between modern programming languages and the limitations of vintage computing systems.

Summary of Comments ( 56 )
https://news.ycombinator.com/item?id=43387259

Hacker News users discuss the impressive feat of converting C code to Z80 assembly and then to a working ZX Spectrum tape. Several commenters praise the author's clear explanation of the process and the clever tricks used to optimize for the Z80's limited resources. Some share nostalgic memories of working with the ZX Spectrum and Z80 assembly, while others delve into technical details like memory management and the challenges of cross-development. A few highlight the educational value of the project, showing the direct connection between high-level languages and the underlying hardware. One compelling comment thread discusses the efficiency of the generated Z80 code compared to hand-written assembly, with differing opinions on whether the compiler's output could be further improved. Another interesting exchange revolves around the practical applications of such a technique today, ranging from embedded systems to retro game development.

The Hacker News post discussing the blog post "Converting C to ASM to specs and then to a working Z/80 Speccy tape" has generated a moderate number of comments, mostly focusing on the intricacies of Z80 programming, the Spectrum's limitations, and the author's approach.

Several commenters expressed admiration for the author's dedication and the ingenuity required to work within the constraints of the ZX Spectrum. One user highlighted the complexity of managing memory and timing on such a limited system, particularly noting the challenge of fitting code within the Spectrum's tight memory constraints. Another commenter reminisced about the challenges and rewards of programming for the Spectrum during its heyday, emphasizing the creativity fostered by its limitations. The clever use of the undocumented HALT instruction to achieve precise timing was specifically pointed out and praised by multiple commenters.

There's a discussion around the tools and techniques used in the Z80 development ecosystem back then. One user mentioned the use of disassemblers and how they helped understand the inner workings of games and other programs, sometimes even leading to modifications and improvements. Another recalled the prevalence of manually crafted assembly routines and the importance of understanding hardware nuances.

The conversation also touched upon the differences between the Z80 and other processors like the 6502, with comparisons being made regarding their architectures, instruction sets, and the resulting programming paradigms. One comment delved into the specifics of how the Z80 handles interrupts, contrasting it with the 6502's approach.

Some users expressed a desire for more technical details in the blog post itself, particularly regarding the author's choices in assembly optimization and memory management. A specific request was made for more information on how the author interfaced the C code with the Z80 assembly.

Finally, there's a thread discussing the broader context of retrocomputing and the enduring fascination with older hardware and software. The challenges and satisfaction of working with these systems were highlighted, emphasizing the different mindset required compared to modern development practices. One user pointed out the significant cognitive overhead involved in managing limited resources and the deeper understanding of hardware it necessitated.

How to build your own ZX80/ZX81 (2019)

permalink

Posted: 2025-01-23 21:02:57

This blog post details a modern approach to building a functional replica of a Sinclair ZX80 or ZX81 home computer. The author advocates using readily available components like an Arduino Nano, a PS/2 keyboard, and a composite video output for a simplified build process, bypassing the complexities of sourcing obsolete parts. The project utilizes a pre-written ROM image and emulates the Z80 CPU via the Arduino, allowing for a relatively straightforward construction and operation of a classic machine. The author provides complete instructions, including schematics, Arduino code, and links to necessary resources, enabling enthusiasts to recreate this iconic piece of computing history.

This comprehensive guide, titled "How to build your own ZX80/ZX81 (2019)," meticulously details the process of constructing a replica of the iconic Sinclair ZX80 or ZX81 home computer. The author begins by emphasizing the project's suitability for both novice and experienced electronics enthusiasts, offering a pathway to understanding fundamental computer architecture while indulging in a bit of nostalgic computing.

The guide outlines two distinct approaches to building these retro machines: The first involves utilizing readily available, modern PCB (Printed Circuit Board) designs and readily sourced components. This approach simplifies the build process, reducing the complexity of sourcing obsolete parts. The second method embraces a more traditional approach, mimicking the original construction techniques by using stripboard or veroboard, offering a more authentic, albeit slightly more challenging, building experience. The guide meticulously details both methods, providing clear instructions and visual aids for each step.

The author provides a thorough explanation of the necessary components, including the Z80 microprocessor, the heart of both machines, and the different memory chips required. The function of each component is carefully explained, helping the builder understand the role it plays in the overall system. Furthermore, the guide provides insights into sourcing these components, directing readers towards reputable suppliers or suggesting suitable replacements where original parts might be difficult to obtain.

The construction process is broken down into manageable steps, each accompanied by clear photographs and diagrams. These visuals illustrate the correct placement of components on the PCB or veroboard, ensuring that even those new to electronics assembly can follow along with confidence. Specific instructions are given for soldering the components, emphasizing proper techniques for creating reliable connections.

Beyond the hardware assembly, the guide delves into the software aspect of these retro machines. It describes the process of loading programs into the limited memory, either through manual entry or using more modern methods like cassette interfaces or even ROM chips. The author explains the basic principles of the ZX80/ZX81's operation, providing a fundamental understanding of how the system functions.

The guide further explores options for enhancing the basic build, such as expanding the memory or adding a more robust power supply. These enhancements provide opportunities for customization and improvement beyond the initial construction. Troubleshooting tips are also included, offering solutions to common problems encountered during the build process. The author concludes by showcasing a finished, functioning ZX80/ZX81, demonstrating the successful culmination of the project and inspiring readers to embark on their own retro computing journey. This comprehensive resource makes the seemingly daunting task of building a vintage computer accessible to a wide audience, fostering an appreciation for the ingenuity of early computer design.

Summary of Comments ( 10 )
https://news.ycombinator.com/item?id=42808038

Commenters on Hacker News largely express nostalgia for the ZX80/81 and similar early home computers, recalling fond memories of learning to program on them and the ingenuity required to overcome their limitations. Several commenters discuss their experiences building replicas or emulating these machines, sharing tips on sourcing components and alternative approaches like using Raspberry Pis. Some debate the historical accuracy of classifying the ZX81 as a "full computer," with others pointing out its significance in democratizing access to computing. A few commenters express interest in the simplicity and elegance of the design compared to modern computers, while others share links to similar retro-computing projects and resources. The overall sentiment is one of appreciation for the ingenuity and historical importance of these early machines.

The Hacker News post linked, titled "How to build your own ZX80/ZX81 (2019)", has several comments discussing various aspects of the original ZX80/ZX81 computers, building modern replicas, and the nostalgic appeal of these early machines.

Several commenters reminisce about their experiences with the ZX80/81, sharing personal anecdotes about learning to program on them, the limitations of the hardware (especially the membrane keyboard and the tendency for the picture to vanish when typing), and the excitement of getting one as a child. One user describes how they wrote a simple program to print their name, showcasing the impact these machines had on introducing people to programming.

The discussion also delves into technical details, comparing the ZX80 to the ZX81, and noting the improvements made in the later model. One commenter explains the differences between the two models and notes that the American version of the ZX81 was called the TS1000/TS1500. Others discuss the limitations of the original ROM and the availability of third-party ROMs that provided enhanced functionality. A recurring theme in these technical discussions is the simplicity and elegance of the hardware design, making it a great learning platform.

Several comments explore the practicality of building a replica today, considering the availability of modern alternatives like the Raspberry Pi. Some users argue that building a replica offers a unique learning experience and a deeper appreciation for the original hardware, while others suggest that emulating the ZX80/81 on modern hardware is a more practical approach. One commenter mentions a project called the "ZX Spectrum Next" which aims to be a "ZX Spectrum for the 21st Century," bridging the gap between the classic machine and modern hardware capabilities. Another points to a modern recreation of the ZX81 with a real membrane keyboard being sold on Etsy.

A few comments also touch on the broader historical context of the ZX80/81, its role in the home computer revolution, and its influence on subsequent generations of computers and programmers. The affordability and accessibility of these machines are highlighted as key factors in their popularity and impact.

Overall, the comments paint a picture of fond remembrance and technical appreciation for the ZX80/81, showcasing its importance in the history of personal computing and its enduring appeal for enthusiasts and hobbyists. The discussion also reflects the ongoing interest in retrocomputing and the desire to revisit and learn from these early machines.

Stories with Tag Z80

The Curious Case of Jupiter Ace

Summary of Comments ( 9 ) https://news.ycombinator.com/item?id=43643197

Collapse OS

Summary of Comments ( 59 ) https://news.ycombinator.com/item?id=43482705

Converting C to ASM to specs and then to a working Z/80 Speccy tape

Summary of Comments ( 56 ) https://news.ycombinator.com/item?id=43387259

How to build your own ZX80/ZX81 (2019)

Summary of Comments ( 10 ) https://news.ycombinator.com/item?id=42808038

Summary of Comments ( 9 )
https://news.ycombinator.com/item?id=43643197

Summary of Comments ( 59 )
https://news.ycombinator.com/item?id=43482705

Summary of Comments ( 56 )
https://news.ycombinator.com/item?id=43387259

Summary of Comments ( 10 )
https://news.ycombinator.com/item?id=42808038