Michael Steil's blog post explores the behavior of illegal or undocumented opcodes on the MOS 6502 processor. Rather than simply halting or throwing an error, these opcodes execute as combinations of shorter, legal instructions. The 6502's instruction decoding mechanism, which combines bits from different parts of the opcode byte, leads to these unintended combinations. Steil demonstrates how these combined instructions can be predicted and even utilized for creative programming tricks, offering a deep dive into the processor's architecture. He provides examples of how these illegal opcodes can manipulate registers and flags in unexpected ways, opening a window into the inner workings of this classic CPU.
The 6502 processor, known for its limitations, inspired clever programming tricks to optimize speed and memory. These "dirty tricks" leverage quirks like the processor's behavior during undocumented opcodes, zero-page addressing, and interactions between instructions and flags. Techniques include self-modifying code to dynamically alter instructions, using the carry flag for efficient branching, and exploiting specific instruction timings for precise delays. By understanding the 6502's nuances, programmers could achieve remarkable results despite the hardware constraints.
Hacker News users generally expressed appreciation for the article on 6502 programming tricks, finding it informative and nostalgic. Several commenters shared additional tricks or variations, including using the undocumented SAX instruction and manipulating the stack for efficient data storage. Some discussed the cleverness borne out of the 6502's limitations, while others reminisced about using these techniques in their youth. A few pointed out the techniques' applicability to other architectures or modern resource-constrained environments. There was some debate about the definition of "dirty" vs. "clever" tricks, but the overall sentiment was positive towards the article's content and the ingenuity it showcased. The discussion also touched on the differences between assembly programming then and now, and the challenges of optimizing for limited resources.
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.
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 author meticulously debugged a mysterious issue where transferring Apple DOS 3.3 system files to a blank diskette sometimes resulted in a bootable disk, and sometimes a non-bootable one, despite seemingly identical procedures. Through painstaking analysis of the DOS 3.3 source code and assembly-level debugging, they discovered the culprit: a timing-sensitive bug within the SYS.COM program related to how it handled track zero formatting. Specifically, SYS.COM occasionally failed to wait for the drive head to settle after seeking to track zero before writing, resulting in corrupted data on the disk. This timing issue was sensitive to drive mechanics and environmental factors, explaining the intermittent nature of the problem. The author's fix involved adding a small delay within SYS.COM to ensure the drive head had stabilized before writing, resolving the frustrating bug and guaranteeing consistent creation of bootable disks.
Several Hacker News commenters praised the author's clear and detailed write-up of the bug hunt, appreciating the methodical approach and the insights into early DOS development. Some shared their own experiences with similar bugs and debugging processes in other systems. One commenter pointed out the historical significance of relying on undocumented behavior, a common practice at the time due to limited documentation. Others discussed the challenges of working with older hardware and software, and the satisfaction of successfully solving such intricate problems. The overall sentiment reflects admiration for the detective work involved and nostalgia for the era of simpler, yet more opaque, computing.
The 6502 assembly language makes a great first foray into low-level programming due to its small, easily grasped instruction set and straightforward addressing modes. Its simplicity encourages understanding of fundamental concepts like registers, memory management, and instruction execution without overwhelming beginners. Coupled with readily available emulators and a rich history in iconic systems, the 6502 offers a practical and engaging learning experience that builds a solid foundation for exploring more complex architectures later on. Its limited register set forces a focus on memory operations, providing valuable insight into how CPUs interact with memory.
Hacker News users generally agreed that the 6502 is a good starting point for learning assembly language due to its small and simple instruction set, limited addressing modes, and readily available emulators and documentation. Several commenters shared personal anecdotes of their early programming experiences with the 6502, reinforcing its suitability for beginners. Some suggested alternative starting points like the Z80 or MIPS, citing their more "regular" instruction sets, but acknowledged the 6502's historical significance and accessibility. A few users also discussed the benefits of learning assembly language in general, emphasizing the foundational understanding it provides of computer architecture and low-level programming concepts. A minor thread debated the educational value of assembly in the modern era, but the prevailing sentiment remained positive towards the 6502 as an introductory assembly language.
The original BBC Micro Elite source code, written in 6502 assembly, has been released and extensively commented by its author, Ian Bell. This release provides a fascinating look into the technical ingenuity behind the classic space trading game, revealing how Bell managed to cram a complex universe simulation, including 3D wireframe graphics and combat, into the limited resources of the 8-bit machine. The heavily commented code offers valuable insights into the optimization techniques employed, such as clever use of lookup tables and bit manipulation, making it a great resource for those interested in retro game development and 6502 programming.
Hacker News users discuss the newly released and heavily commented source code for the 8-bit game Elite. Many express excitement and nostalgia, praising the code's clarity and the detailed comments which provide insights into the game's development process. Several commenters highlight the impressive feats accomplished on such limited hardware, like the use of clever algorithms for 3D graphics and procedural generation. Some discuss the historical significance of Elite and its influence on subsequent games. A few users share personal anecdotes about playing Elite in their youth, while others analyze specific coding techniques used. There's also discussion about the challenges of working with 6502 assembly and the ingenuity required to overcome hardware limitations. The overall sentiment is one of appreciation for the release of this historical artifact and the opportunity it provides to learn from the pioneers of game development.
This GitHub repository contains the fully documented and annotated source code for the classic game Elite, specifically the BBC Micro version adapted for the Commodore 64. The code, originally written in 6502 assembly language, has been meticulously commented and explained to make it easier to understand. The project aims to provide a comprehensive resource for anyone interested in learning about the game's inner workings, from 3D graphics and ship control to trading mechanics and mission generation. This includes explanations of the game's algorithms, data structures, and overall architecture. The repository also offers resources like a cross-reference and memory map, further aiding in comprehension.
Hacker News commenters on the Elite C64 source code release express enthusiasm and nostalgia for the game. Several discuss the ingenuity of the original developers in overcoming the C64's limitations, particularly its memory constraints and slow floating-point math. Commenters highlight the clever use of lookup tables, integer math, and bitwise operations to achieve impressive 3D graphics and gameplay. Some analyze specific code snippets, showcasing the elegant solutions employed. There's also discussion about the game's impact on the industry and its influence on subsequent space trading and combat simulations. A few users share personal anecdotes about playing Elite in their youth, emphasizing its groundbreaking nature at the time.
Summary of Comments ( 2 )
https://news.ycombinator.com/item?id=43743399
HN commenters discuss the cleverness of undocumented opcodes on the 6502, with several sharing their experiences using them in demos and games. Some appreciated the author's clear explanations and visualizations of the normally chaotic behavior, while others reminisced about discovering and exploiting these opcodes in their youth on platforms like the C64 and Apple II. A few highlighted the community effort in meticulously documenting these behaviors, comparing it to similar explorations of the Z80 and other CPUs. Some commenters also pointed out the article's brief mention of the security implications of these undefined instructions in modern contexts.
The Hacker News post "How MOS 6502 Illegal Opcodes Work – Michael Steil" has generated several comments discussing the article's content and related topics.
Several users express appreciation for the article, finding it informative and well-written. They praise the clear explanations of the undocumented opcodes and their sometimes unpredictable behavior. The detailed analysis of how these illegal opcodes function, including their impact on processor flags and registers, is highlighted as particularly valuable.
Some commenters delve into the historical context of the 6502 and its use in various systems, including classic gaming consoles and home computers. They share anecdotes and personal experiences related to programming with the 6502 and encountering these undocumented instructions. These reminiscences touch on the challenges and quirks of working with older hardware.
Technical discussions arise around the specific behaviors of certain illegal opcodes and their potential uses. Commenters analyze the assembly code examples provided in the article and discuss the nuances of the 6502's instruction set. One commenter even mentions the practical application of these undocumented opcodes in demoscene programming, highlighting their use for achieving unique visual effects or optimizing code size.
There's also a discussion about the differences between various 6502 clones and revisions, as not all processors implement these illegal opcodes identically. This points to the intricacies of working with older hardware where subtle variations can exist between seemingly identical chips.
A few commenters express a general interest in retrocomputing and the technical details of older hardware. The article's exploration of the 6502's inner workings is seen as a valuable contribution to preserving and understanding computing history. This appreciation for the technical intricacies of older systems is a recurring theme throughout the comments.