Stories with Tag Forth

• The Curious Case of Jupiter Ace

  permalink

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

  Verbose tl;dr

  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.

  • Jupiter Ace
  • Retrocomputing
  • Home Computer
  • Vintage Computer
  • British microcomputer
  • Z80
  • Forth
  • Jupiter Cantab
  • 8-bit computer
  • 1980s Computers
  • computer history
  • technology history
  • personal computer
  • Computing

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

  Verbose tl;dr

  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.

• MilliForth-6502: The smallest Forth real programming language for 6502

  permalink

  Posted: 2025-03-28 11:04:40

  Verbose tl;dr

  MilliForth-6502 is a minimalist Forth implementation for the 6502 processor, designed to be incredibly small while remaining a practical programming language. It features a 1 KB dictionary, a 256-byte parameter stack, and implements core Forth words including arithmetic, logic, stack manipulation, and I/O. Despite its size, MilliForth allows for defining new words and includes a simple interactive interpreter. Its compactness makes it suitable for resource-constrained 6502 systems, and the project provides source code and documentation for building and using it.

  MilliForth-6502 is presented as an incredibly compact implementation of the Forth programming language, specifically designed for the 6502 microprocessor, a popular 8-bit processor used in systems like the Apple II, Commodore 64, and Atari 8-bit computers. The project's primary goal is to create a functional Forth system within an extremely limited memory footprint, aiming for a size under 1 kilobyte. This makes it suitable for resource-constrained environments or as a foundational layer for building more complex software on 6502-based platforms.

  The core features of a traditional Forth system are retained, including a dictionary (a symbol table that maps words to their corresponding code), an interpreter for executing Forth words, and a compiler for defining new words. MilliForth-6502 utilizes a threaded interpretation model, where each word's definition consists of a sequence of pointers to other words, creating an efficient execution flow.

  The system provides a minimal set of primitive words, allowing for basic arithmetic, logical operations, stack manipulation, memory access, and input/output functions. These primitives serve as the building blocks for creating more complex words and programs through Forth's unique approach to programming, which relies heavily on combining smaller, defined words into larger, more specialized words.

  A key aspect of MilliForth-6502's design is its simplicity. The code is meticulously crafted to minimize its size while maintaining functionality. This minimalistic approach is not just about conserving memory but also about providing a clear and understandable implementation of Forth, making it a valuable resource for learning or exploring the inner workings of both Forth and the 6502 architecture. The source code is provided for users to examine, modify, and adapt to their specific needs.

  While complete, MilliForth-6502 acknowledges its own limited nature. It is a foundational system designed for expansion. Users are expected to build upon the core functionalities and extend the vocabulary with custom words tailored to their particular applications. It provides a compact and robust basis for further Forth development on the 6502 platform.

  • Forth
  • 6502
  • programming language
  • Retrocomputing
  • Low-Level Programming
  • Embedded Systems
  • MilliForth
  • Assembly Language
  • virtual machine
  • interpreter
  • compiler
  • Open Source
  • GitHub

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

  Verbose tl;dr

  Hacker News users discussed the practicality and minimalism of MilliForth, a Forth implementation for the 6502 processor. Some questioned its usefulness beyond educational purposes, citing limited memory and awkward programming style compared to assembly language. Others appreciated its cleverness and the challenge of creating such a compact system, viewing it as a testament to Forth's flexibility. Several comments highlighted the historical context of Forth on resource-constrained systems and drew parallels to other small language implementations. The maintainability of generated code and the debugging experience were also mentioned as potential drawbacks. A few commenters expressed interest in exploring MilliForth further and potentially using it for small embedded projects.

  The Hacker News post for MilliForth-6502 has a modest number of comments, focusing primarily on its size, speed, and potential applications.

  Several commenters express fascination with the extreme minimalism of MilliForth, marveling at how a functional Forth system can be implemented in such a small footprint. They discuss the challenges and ingenuity involved in fitting a complete language within such tight constraints. Some commenters delve into the technical details of its implementation, analyzing how certain features are achieved with limited resources.

  A recurring theme is comparing MilliForth to other small language implementations, particularly FORTHs and BASICs on similar hardware. Commenters share anecdotes and experiences with historical systems, highlighting the tradeoffs between size, speed, and functionality. Some discuss how MilliForth's size compares favorably to other FORTHs on the 6502, while acknowledging that its minimalist nature may impact usability for larger projects.

  The speed of MilliForth is also a point of discussion. Some commenters question its performance relative to other FORTHs and even assembly language, wondering if the extreme size optimization comes at the cost of execution speed. Others express interest in benchmarking MilliForth against similar systems to quantify its performance characteristics.

  Regarding applications, some commenters speculate on potential uses for such a small FORTH, suggesting embedded systems, retrocomputing projects, and educational purposes as possible areas where MilliForth could be valuable. The idea of fitting a complete language within the limited memory of older hardware is particularly appealing to retrocomputing enthusiasts. One commenter mentions using a similar small FORTH on an Apple II, demonstrating the practicality of such systems.

  Finally, a few comments focus on the readability and maintainability of the code. Due to its highly optimized nature, some commenters acknowledge that MilliForth might be challenging to understand and modify. However, the overall sentiment leans towards appreciation for the technical achievement, even if the code itself is not intended for extensive modification.