Stories with Tag Forth

• I learned Snobol and then wrote a toy Forth

  permalink

  Posted: 2025-05-11 06:38:27

  Verbose tl;dr

  Fascinated by Snobol's unique string-centric nature and pattern matching capabilities, the author decided to learn the language. They found its table-driven implementation particularly intriguing, inspiring them to explore implementing a similar structure for a different language. This led to the creation of a small, experimental Forth interpreter written in Snobol, showcasing how Snobol's pattern matching could effectively parse and execute Forth code. The project served as a practical exercise to solidify their understanding of Snobol while exploring the underlying mechanics of language implementation.

  The author of the blog post "I learned Snobol and then wrote a toy Forth" embarks on a personal journey of programming language exploration, beginning with Snobol4. Intrigued by its unique pattern-matching capabilities and string manipulation prowess, the author delves into the intricacies of Snobol4, highlighting its distinctive features such as its reliance on success or failure of pattern matching for control flow, its dynamic typing system, and its built-in backtracking mechanisms. The author expresses a degree of fascination with the language's power and elegance, even while acknowledging its age and relative obscurity in the modern programming landscape.

  After gaining familiarity with Snobol4, the author decides to undertake the project of creating a simplified implementation of Forth. This endeavor is motivated by a desire to further explore language design and implementation, and the author leverages the knowledge gained from working with Snobol4 to inform the design choices made in the Forth implementation. The post details some of the key steps involved in building the Forth interpreter, including the process of tokenization, parsing, and execution of Forth code. The author emphasizes that this is a "toy" implementation, meaning it is not a fully-featured or optimized version of Forth, but rather a learning exercise focused on the fundamental concepts. The experience of implementing Forth allows the author to appreciate the stark differences between the two languages, highlighting the simplicity and stack-based architecture of Forth in contrast to the more complex pattern-matching paradigm of Snobol4. The post concludes with a sense of accomplishment and an invitation for readers to explore the fascinating world of programming language design and implementation.

  • Snobol
  • Forth
  • Programming Languages
  • compiler design
  • interpreters
  • Language Implementation
  • Retrocomputing
  • esoteric languages
  • Toy Programming Languages

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

  Verbose tl;dr

  Hacker News users discuss the original poster's experience learning SNOBOL and subsequently creating a toy Forth implementation. Several commenters express nostalgia for SNOBOL, praising its unique string manipulation capabilities and lamenting its relative obscurity today. Some discuss its influence on later languages like Icon and Perl. Others debate SNOBOL's performance characteristics and its suitability for various tasks. A few users share personal anecdotes about using SNOBOL in the past, including applications in bioinformatics and text processing. The discussion also touches on the differences between SNOBOL and Forth, with some commenters expressing interest in the poster's Forth implementation.

  The Hacker News post titled "I learned Snobol and then wrote a toy Forth" generated several comments discussing various aspects of Snobol, Forth, and programming languages in general.

  Several commenters reminisced about their experiences with Snobol, often highlighting its unique pattern-matching capabilities. One user fondly recalled using Snobol on a mainframe in the 1970s, emphasizing its power for text processing tasks that would be cumbersome in other languages. Another commenter pointed out the educational value of Snobol, particularly in understanding different programming paradigms. Its distinct approach, they argued, broadens one's perspective beyond more conventional languages.

  The discussion also touched on the influence of Snobol on other languages, with one commenter mentioning its impact on Icon and SL5, highlighting the legacy of its pattern-matching features. The concise and expressive nature of Snobol's syntax was also praised, with one user contrasting it favorably to the perceived verbosity of Perl.

  The connection between Snobol and Forth, as mentioned in the title of the post, also drew comments. One user questioned the perceived relationship, prompting the original poster to clarify that learning Snobol inspired them to explore other unique languages, leading them to Forth. This sparked further discussion about the contrasting philosophies of the two languages.

  Some commenters expressed curiosity about the specific implementation of Snobol used by the original poster, including Catspaw Snobol and the Vanilla Snobol4 implementation. This led to a brief exchange about the availability and portability of different Snobol versions.

  Beyond the specific languages, the conversation broadened to encompass the value of learning "weird" or less mainstream languages. Several commenters argued that exploring such languages can significantly expand a programmer's understanding of different programming concepts and approaches. This sentiment was echoed in a comment suggesting that languages like Snobol and Forth encourage a deeper appreciation for the underlying mechanics of computation. The thread also briefly touched on the practical applications of Snobol, with one commenter mentioning its use in bioinformatics.

• 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.