TinyComputers.io (Posts about vintage computing)

The Z-80 Microcomputer Handbook: A 1978 Reference That Outlived Its Era

A.C. Jokela — Thu, 05 Feb 2026 21:00:00 GMT

In 1978, William Barden, Jr. set out to write a book with a threefold purpose: to acquaint the reader with the hardware of the Z80, to discuss its "almost overwhelming" software instruction set, and to describe the microcomputer systems being built around it. The result was The Z-80 Microcomputer Handbook, published by Howard W. Sams & Co.—one of the most prolific technical publishers of the era. At just over 300 pages, Barden delivered on all three promises, producing a reference that served as both tutorial and encyclopedia for what was arguably the most important microprocessor of the late 1970s.

The copy I have is the eighth printing from 1985. Eight printings. The book was first published in 1978, and Howard W. Sams was still running the presses seven years later. I'll confess I hadn't fully appreciated that the Z80's popularity carried that kind of momentum into the mid-1980s—by which point Intel's 80286 had been on the market for three years and IBM's AT was already sitting on desks in corporate offices across America. Yet here was a book about an 8-bit processor from 1976, still selling briskly enough to justify another print run. That tells you something about the Z80's staying power, and something about the quality of Barden's handbook.

The Author and the Publisher

William Barden, Jr. was a prolific technical author who wrote extensively about microprocessors and microcomputers throughout the late 1970s and 1980s. His writing style sits in a comfortable middle ground between the dry precision of a Zilog datasheet and the conversational approachability of a hobbyist magazine column. He assumes the reader has some technical foundation but doesn't demand an electrical engineering degree. The prose is clear, methodical, and—when the subject matter allows—occasionally wry.

Howard W. Sams & Co., a subsidiary of Macmillan, was headquartered in Indianapolis and had built a reputation as one of the go-to publishers for electronics and computing references. Their catalog included the famous Photofact service manuals and a long list of titles covering everything from transistor theory to amateur radio. A Sams book on your shelf carried a certain implicit endorsement: this was going to be technically sound, well-organized, and useful.

Three Sections, One Processor

Barden organized the book into three distinct sections, each approaching the Z80 from a different angle. Section I covers Z80 hardware—the architecture, interface signals and timing, addressing modes, instruction set, flags and arithmetic operations, interrupt sequences, and interfacing memory and I/O devices. Section II shifts to Z80 software, beginning with the assembly process itself and then working through the major instruction groups: data movement, arithmetic and logical operations, shifting and bit manipulation, list and table operations, subroutine calls, I/O and interrupt operations, and commonly used subroutines. Section III surveys five commercial microcomputer systems built around the Z80.

This three-part structure gives the book a completeness that many competing references lacked. Readers who wanted to understand the Z80 at the silicon level could camp out in Section I. Programmers who needed to write assembly code had a thorough software reference in Section II. And anyone trying to decide which Z80 system to buy—or trying to understand what made these systems different from one another—could turn to Section III for a comparative tour.

The Hardware Foundation

Section I opens with a concise but thorough treatment of the Z80's internal architecture. Barden walks the reader through the processor's register set—fourteen general-purpose 8-bit registers organized in two banks (A through L, and their primed counterparts A' through L'), plus the special-purpose registers: two index registers (IX and IY), the stack pointer, program counter, interrupt vector register, and memory refresh counter.

The dual register bank architecture receives careful attention, and rightly so. The ability to swap between two complete register sets with a single EXX instruction was one of the Z80's most distinctive features. Barden explains not just the mechanics but the motivation: fast interrupt handling without the overhead of pushing and popping registers to the stack. For real-time applications—process control, data acquisition, communications—this was a significant advantage over the Intel 8080A, which required explicit save-and-restore sequences.

The flag register documentation is similarly thorough. Each of the six testable flags—Sign, Zero, Half-carry, Parity/Overflow, Subtract, and Carry—gets individual treatment, with clear diagrams showing bit positions and the conditions under which each flag is set or cleared. Barden's flag register diagram on page 19 is the kind of figure you'd photocopy and tape to the wall above your workbench.

Chapter 3 dives into the Z80's interface signals and timing with a level of detail that borders on the exhaustive. Every control signal is documented: MREQ, IORQ, RD, WR, RFSH, HALT, WAIT, INT, NMI, BUSRQ, BUSAK, and the rest. The timing diagrams for M1 cycles, memory read and write cycles, I/O cycles, interrupt acknowledge sequences, and bus request/acknowledge handshakes are presented with the precision needed for hardware designers wiring up actual systems. This is reference material, not light reading—but it's the kind of reference material you desperately need when your homebrew system isn't behaving and you're staring at an oscilloscope trace trying to figure out why.

Chapter 4's treatment of addressing modes deserves special mention. The Z80 supported ten addressing modes—implied, immediate, extended immediate, register, register indirect, extended, modified page zero, relative, indexed, and bit addressing. Barden documents each with examples showing the instruction encoding at the bit level. The indexed addressing mode, using IX or IY plus a displacement byte, was a Z80 innovation that made structured data access far more practical than on the 8080A. Barden's diagrams showing multi-byte instruction formats, with op-codes, displacement values, and immediate data laid out byte by byte, are models of technical illustration.

The instruction set itself, covered in Chapter 5, is presented in tabular form with every detail a programmer needs: mnemonic, symbolic operation, flag effects, op-code encoding in binary, byte count, machine cycle count, and T-state count. These tables span dozens of pages and represent the kind of painstaking documentation that made the book worth keeping within arm's reach during coding sessions. The eleven instruction groups—from 8-bit loads through block transfers, arithmetic operations, rotates and shifts, bit manipulation, jumps, calls, and I/O—are each given systematic treatment.

Chapter 8 rounds out the hardware section with a practical discussion of interfacing memory and I/O devices to the Z80. The treatment of the Z80 PIO (Parallel Input/Output) chip is particularly detailed, covering all four operating modes with programming examples. Barden walks through the initialization sequences for each mode, the interrupt vector configuration, and the handshaking protocols—exactly the kind of information you'd struggle to extract from Zilog's own documentation without considerable effort.

The Software Perspective

Section II opens with what might be the most pedagogically effective chapter in the book: Chapter 9, the Z80 Assembler. Rather than jumping straight into assembly language syntax, Barden starts with raw machine language. He presents a trivial program—adding the numbers one through ten—first as a series of mnemonics, then as hand-assembled machine code with each op-code and operand byte spelled out in hexadecimal. He then shows the same program rewritten with a loop, and walks through the manual assembly process step by step: calculating instruction lengths, assigning memory addresses, resolving label references, filling in the binary encoding of each instruction.

This is brilliant pedagogy. By forcing the reader through the pain of manual assembly—calculating that a JP NZ,LOOP instruction at address 0105H needs to encode the target address 0103H as bytes 03H and 01H in little-endian order—Barden ensures they understand exactly what an assembler does before they start using one. The transition from manual assembly to symbolic assembly language feels earned rather than arbitrary. When Barden introduces labels, pseudo-operations, expression evaluation, and the two-pass assembly process, the reader understands why these features exist, not just how to use them.

Chapters 10 through 15 systematically work through the instruction groups from a programmer's perspective. Each chapter takes a logical group—data movement, arithmetic and logic, shifting and bit manipulation, list and table operations, subroutines, I/O and CPU control—and provides detailed examples showing how the instructions are used in practice. The block transfer instructions (LDI, LDIR, LDD, LDDR) and block search instructions (CPI, CPIR) receive particularly good coverage, as these were among the Z80's most powerful features and had no equivalent in the 8080A instruction set.

Chapter 16, covering commonly used subroutines, is where the book transitions from reference to practical cookbook. Barden provides complete, tested subroutine implementations for comparison, timing loops, multiply, divide, multiple-precision arithmetic, ASCII-to-binary conversion, base conversion, memory fill, string comparison, and table search. Each subroutine is documented with its entry conditions, exit conditions, and register usage—the kind of disciplined documentation that professional assembly programmers live by. The table search routine, using IX as a base pointer with entry size in DE, is a clean example of the Z80's indexed addressing mode earning its keep.

A Snapshot of the Ecosystem

Section III is where the book transforms from a processor reference into a historical document. In two chapters, Barden surveys five companies manufacturing Z80-based microcomputer systems: Zilog itself, Technical Design Labs (TDL), Cromemco, The Digital Group, and Radio Shack.

The Zilog chapter covers the Z80 MCB (Microcomputer Board), a complete single-board computer measuring 7.7 by 7.75 inches. With 4K of dynamic RAM, up to 4K of EPROM or PROM, a PIO for parallel I/O, a USART for serial communication, and a CTC for timing, the MCB was a capable development platform. Barden documents the memory map, I/O port addressing, interrupt configuration, and the 1K monitor program with its eight commands for examining memory, setting breakpoints, and controlling program execution. The minimum MCB system—the board itself, a 5-volt power supply, and a Teletype ASR-33—was a complete development environment, albeit a spartan one.

The Cromemco coverage reveals a more ambitious ecosystem. Their Z-1 and Z-2 systems were built around the S-100 bus, with the Z-2 offering a chassis with 21 card slots, a 30-amp power supply, and room for serious expansion. Cromemco's peripheral lineup included a TV DAZZLER for color graphics, a Digital Interface Board with analog-to-digital and digital-to-analog converters, and their BYTESAVER EPROM programmer board. Their CONTROL BASIC—a specialized BASIC interpreter designed for process control and automated testing—hints at the industrial applications that were already finding the Z80.

The Digital Group section reveals a company taking a different approach: offering CPU boards for multiple processor families—Motorola 6800, MOS Technology 6502, Intel 8080A, and Z80—all interchangeable at the board level. Their Phi-Deck cassette storage system, with 800 bytes per second transfer rates and CRC error checking, was a notably sophisticated approach to the cassette storage problem.

And then there's Radio Shack. Barden's description of the TRS-80 stands out because of what it represented: a completely integrated, turnkey system that a consumer could purchase, take home, plug in, and immediately begin programming in BASIC. While the other systems in this chapter required varying degrees of assembly, configuration, and technical knowledge, the TRS-80 was designed for people who wanted to use a computer, not build one. With its 53-key keyboard, 12-inch monitor, cassette storage, and 4K of ROM containing a BASIC interpreter, it was a vision of the microcomputer's commercial future—even if its 64-character-by-16-line display and 4K of RAM seem quaint today.

Reading these system descriptions in sequence, you can see the microcomputer market stratifying in real time. At one end, boards like Zilog's MCB served engineers and serious hobbyists who wanted maximum flexibility. In the middle, S-100 systems from Cromemco and others offered expandability with some degree of standardization. And at the consumer end, Radio Shack was proving that microcomputers could be mass-market products. All of them ran on the Z80.

The Intel Shadow

What makes the 1985 printing date so remarkable is the context in which someone would have been buying this book. By 1985, the microcomputer landscape had shifted dramatically from the world Barden documented in 1978.

Intel had introduced the 8086 in 1978—the same year this book was published—and its cost-reduced sibling, the 8088, in 1979. When IBM chose the 8088 for its Personal Computer in 1981, the x86 architecture gained a gravitational pull that would reshape the entire industry. The Intel 80286, launched in 1982, brought protected mode, a 16-megabyte address space, and hardware memory management. When IBM built the 80286 into the PC/AT in August 1984, it created what would become the standard business computer platform for years to come. The AT was fast, expandable, and—critically—backward compatible with the enormous library of software already written for the original PC.

By 1985, the trajectory was clear. The x86 architecture was the future of personal computing. CP/M, which had been the dominant operating system for Z80 machines, was fading in the face of MS-DOS. The TRS-80 line was winding down. Cromemco had pivoted to 68000-based systems. The Z80's reign as the king of personal computing was effectively over.

And yet the eighth printing rolled off the presses.

The Z80 endured because personal computing was never the whole story. The processor had found its way into embedded systems, industrial controllers, point-of-sale terminals, scientific instruments, and countless other applications where its simplicity, low cost, and well-understood behavior were more valuable than raw performance. The Z80 didn't need a 16-megabyte address space to control a factory floor. It didn't need protected mode to run a cash register. It needed to be cheap, reliable, and thoroughly documented—and books like Barden's were part of that documentation ecosystem.

There's also the educational angle. In 1985, the Z80 was still one of the best processors for learning computer architecture. Its instruction set was complex enough to illustrate real-world design tradeoffs—accumulator-based operations, register pairs for 16-bit addressing, multiple addressing modes, condition flags—without being so complex as to overwhelm a student. Many universities and technical colleges were still teaching microprocessor courses using the Z80 well into the late 1980s. For those students and their instructors, Barden's handbook was still entirely relevant.

The Book as Reference

Evaluating The Z-80 Microcomputer Handbook as a technical reference, it holds up remarkably well within its domain. The instruction set tables in Chapter 5 are comprehensive and clearly formatted, with every detail needed for hand-coding or verifying assembler output. The appendices—covering electrical specifications, an 8080-to-Z80 instruction cross-reference, a complete instruction summary, binary and hexadecimal tables, and ASCII codes—round out the reference material.

The 8080/Z80 comparison in Appendix B is particularly useful for readers coming from the Intel side. Since the Z80 included the entire 8080A instruction set as a subset (using Zilog's own mnemonics rather than Intel's), this cross-reference served as a Rosetta Stone for programmers transitioning between the two architectures. Many Z80 systems needed to run software originally written for the 8080A, and understanding the mapping between Intel and Zilog mnemonics was a practical necessity.

Where the book shows its age most clearly is in Section III. The specific microcomputer systems described—the Zilog MCB, the TDL ZPUTM and Xitan, the Cromemco Z-1 and Z-2, the Digital Group systems, and the TRS-80—are all long discontinued. But this is precisely what makes Section III valuable today: it's a primary source document of a hardware ecosystem that existed for a brief, vibrant moment and then vanished. You won't find this level of detail about the Digital Group's Phi-Deck cassette system or TDL's System Monitor Board in Wikipedia.

A Companion Piece

Readers of this site may notice a natural pairing with Steve Ciarcia's Build Your Own Z80 Computer (Amazon), which we reviewed previously. Where Ciarcia's book is a construction manual—guiding the reader through building a complete Z80 system from power supply to CRT terminal—Barden's handbook is a reference and survey. Ciarcia teaches you to build; Barden teaches you to understand. The two books complement each other almost perfectly, and it's easy to imagine a 1978-era hobbyist keeping both within reach: Barden's for looking up instruction encodings and timing specifications, Ciarcia's for wiring up the hardware to run them on.

The difference in approach also reflects the different publishers. BYTE Books, which published Ciarcia, was rooted in the hobbyist magazine world and emphasized hands-on projects. Howard W. Sams had a longer tradition of comprehensive technical references. Each publisher played to its strengths.

Final Thoughts

The Z-80 Microcomputer Handbook is not a book that will teach you to build a computer, nor is it one that will dazzle you with narrative flair. It is, instead, something arguably more valuable: a thorough, well-organized, clearly written reference to a processor and its ecosystem, produced at the moment when that ecosystem was at its peak. Barden's systematic approach—hardware first, then software, then systems—gives the reader a complete understanding of the Z80 world from silicon to finished product.

That the book was still being printed in 1985, with the IBM AT already on the market and the 80386 just a year away, is a testament to both the Z80's remarkable longevity and the quality of Barden's work. Eight printings don't happen by accident. They happen because engineers, students, hobbyists, and embedded systems designers kept walking into bookstores and electronics shops and deciding that yes, they still needed this book.

Nearly five decades after its original publication, The Z-80 Microcomputer Handbook remains a worthwhile read for anyone interested in the foundations of microcomputing. Paired with Rodnay Zaks' Programming the Z80 for software depth and J.S. Walker's Design a Z80 Computer for a modern practical build guide, it forms part of an essential Z80 library. The architecture it documents influenced a generation of processor designs. The assembly language techniques it teaches remain relevant for anyone working close to the metal. And the ecosystem it surveys—that brief, fertile period when a handful of small companies were inventing the personal computer industry in real time—deserves to be remembered in the detail that Barden provided.

Build Your Own Z80 Computer: A Classic Guide to DIY Microcomputing

A.C. Jokela — Mon, 19 Jan 2026 14:00:00 GMT

In 1981, Steve Ciarcia published what would become one of the most influential books in the homebrew computing movement: Build Your Own Z80 Computer: Design Guidelines and Application Notes. Published by BYTE Books, this comprehensive guide took readers on a journey from understanding basic power supply design all the way through constructing a fully functional microcomputer called ZAP (Z80 Applications Processor). More than four decades later, the book remains a fascinating window into an era when building your own computer wasn't just possible—it was expected.

The Author and His Mission

Steve Ciarcia was already well-known to readers of BYTE magazine through his popular "Ciarcia's Circuit Cellar" column, where he regularly presented do-it-yourself hardware projects. His columns had generated substantial reader interest, revealing that despite the growing availability of assembled personal computers, there remained a dedicated community of technically-minded individuals who wanted to understand what was inside their machines—and build them themselves.

Ciarcia wrote in the introduction: "Build Your Own Z80 Computer is a book written for technically minded individuals who are interested in knowing what is inside a microcomputer. It is for persons who, already possessing a basic understanding of electronics, want to build rather than purchase a computer."

This wasn't a book for beginners who had never held a soldering iron, nor was it an engineering textbook filled with impenetrable mathematics. Ciarcia positioned it squarely in the middle—practical enough for the determined hobbyist, technical enough to provide genuine understanding.

The book also reflected Ciarcia's pragmatic philosophy about engineering design. He shared an anecdote about having lunch with the designer of a major personal computer system, expecting to hear about months of careful optimization and instruction set analysis. Instead, he learned the designer had simply been given two months to produce something manufacturable, and had built the system around the microprocessor he happened to already own. "So much for textbook engineering design," Ciarcia noted wryly, while acknowledging that hobbyists doing hand-wiring needed to be more deliberate in their choices.

Why the Z80?

The choice of the Z80 microprocessor as the heart of the ZAP computer wasn't arbitrary. Ciarcia explained that when building a microcomputer from scratch, several criteria must be carefully considered: circuit complexity, cost, and software compatibility.

The Z80 (also available in 5-packs), introduced by Zilog in 1976, offered a compelling combination of features. It executed the complete instruction set of the Intel 8080A while adding significant enhancements of its own. Where the 8080A required multiple support chips (the 8224 clock driver and 8228 bus controller) to function, the Z80 integrated much of this functionality on-chip. This meant fewer components, simpler wiring, and reduced opportunities for errors—critical considerations for hand-wired projects.

The Z80's architecture included 158 instructions (compared to the 8080A's 78), dual register sets for rapid context switching, index registers for sophisticated addressing modes, and a built-in memory refresh counter for dynamic RAM. The processor came in a standard 40-pin dual inline package, with clearly defined buses: a 16-bit address bus capable of addressing 64K bytes of memory, an 8-bit bidirectional data bus, and a comprehensive control bus.

Ciarcia also noted the practical reality of the personal computer market: "The fact that so many personal computers are in use has established de facto standardization of central processor choice." The Z80 was already powering popular systems like the TRS-80, Sinclair ZX80, and numerous CP/M machines, which meant abundant software and documentation were available.

The Z80 compared favorably to its contemporaries. While the Motorola 6800 and MOS Technology 6502 were capable processors, Ciarcia's analysis considered three key factors: circuit complexity (keeping components to a minimum to reduce wiring errors), cost (finding the sweet spot between cheap discrete logic and expensive LSI), and software compatibility (ensuring the user could benefit from existing programs and development tools). The Z80 struck an optimal balance across all three dimensions for the hand-wired builder.

Starting With the Power Supply

In a decision that reveals much about Ciarcia's pedagogical approach, the book begins not with the glamorous central processor but with the humble power supply. His reasoning was both practical and psychological: "This is a good way to test ability and provide immediate positive reinforcement from successful construction."

The ZAP computer required three DC voltage rails: +5V at 5 amps for the digital logic, and ±12V at 1 amp each for peripheral interfaces and analog circuits. Ciarcia devoted an entire chapter to power supply design, explaining transformer selection, full-wave bridge rectification, filter capacitor sizing, and three-terminal voltage regulators.

The technical depth here is remarkable. Readers learned about ripple voltage calculations, the relationship between peak voltage and steady-state voltage, and why a 25% ripple factor was recommended for the filter capacitor. The explanation of three-terminal regulators like the μA78H05 covered not just their use but their internal operation—bandgap references, error amplifiers, and thermal protection circuits.

Perhaps most valuably, Ciarcia addressed overvoltage protection. Recognizing that a regulator failure could send dangerous voltage spikes to sensitive logic circuits, he included detailed designs for SCR-based "crowbar" circuits that would short the output to ground and blow a fuse before damage could occur. This wasn't theoretical paranoia—it was the kind of practical wisdom that came from experience with real-world failures.

The chapter also tackled thermal management—a subject often glossed over in hobbyist literature. Ciarcia explained heat sink calculations, thermal resistance from junction to ambient, and the importance of forced air cooling for high-current regulators. His advice was characteristically practical: "I hate red-hot power supplies." Rather than agonize over precise thermal calculations, he recommended adequate heat sinking combined with a fan. The additional cost of robust cooling was, he noted, far less than the cost of replacing fried computer components.

Layout considerations received equal attention. Ciarcia explained how improper placement of filter capacitors could induce ripple on the output voltage, and how resistance in power distribution wiring could create different voltage levels at different points in the circuit. His solution—heavy gauge wire, single-point grounding, and dedicated bus strips—reflected the kind of hard-won practical knowledge that separates reliable designs from troublesome ones.

Understanding the Z80's Internal Architecture

Chapter 3 provides what amounts to a complete Z80 programmer's reference. Ciarcia walked through every aspect of the processor's architecture: the accumulator and flag registers, general-purpose register pairs (BC, DE, HL), special-purpose registers (program counter, stack pointer, index registers IX and IY), and the interrupt and refresh registers.

The dual register set architecture received particular attention. The Z80 contained two complete sets of general-purpose registers—main and alternate—that could be swapped with single exchange instructions. This feature enabled rapid interrupt handling and context switching, capabilities that made the Z80 attractive for real-time applications.

The instruction set documentation is exhaustive—rivaling dedicated references like Rodnay Zaks' Programming the Z80 (PDF) and Ramesh Gaonkar's The Z80 Microprocessor: Architecture, Interfacing, Programming and Design. Every instruction is described with its mnemonic, operation, affected flags, byte encoding, cycle count, and timing states. Load and exchange instructions, arithmetic and logical operations, block transfer and search commands, rotate and shift operations, bit manipulation, jumps, calls, returns, and I/O instructions—all are covered with the detail needed for hand assembly of machine code.

Ciarcia also explained the hardware interface: the meaning of every pin on the Z80's 40-pin package. Control signals like MREQ (memory request), IORQ (I/O request), RD (read), WR (write), and RFSH (refresh) are described in terms of their logical function and timing relationships. The interrupt system, with its three modes and maskable/non-maskable hierarchy, receives thorough treatment.

Building the Basic Computer

Chapter 4, "Build Your Own Computer—Start With the Basics," transitions from theory to practice. The approach is methodical: construct the minimum viable system first, verify its operation, then expand.

The basic ZAP configuration included the Z80 processor, 1K of EPROM containing the monitor program, 2K of static RAM for user programs and stack, address decoding logic, and a hexadecimal display with keyboard for interaction. Ciarcia deliberately avoided elaborate peripherals in the initial build, focusing instead on achieving a working foundation.

Memory architecture was a central concern. Ciarcia explained memory mapping—the allocation of the Z80's 64K address space among ROM, RAM, and I/O devices. For ZAP, the memory map placed the 1K monitor EPROM at addresses 0000-03FF (where the Z80 begins execution after reset), with RAM starting at address 2000 hex.

The discussion of memory devices compared available options. The 2716 EPROM (2K × 8) and 2114 static RAM (1K × 4) were recommended for their balance of capacity, availability, and ease of use. Ciarcia explained why static RAM was preferred over dynamic RAM for this application—dynamic RAM required refresh logic that, while supported by the Z80, added complexity inappropriate for a learning project.

Address decoding used simple 74LS138 three-to-eight decoders, with higher address lines selecting among memory banks and lower lines addressing within each device. This straightforward approach traded some address space efficiency for wiring simplicity.

The Peripheral Ecosystem

With the basic computer operational, Chapter 5 expanded the system with practical peripherals. The hexadecimal display and keyboard provided the most basic human interface, allowing users to examine and modify memory contents, run programs, and debug code.

The RS-232C serial interface opened connections to terminals and other equipment. Ciarcia used the COM2017 UART (Universal Asynchronous Receiver/Transmitter) to handle serial data formatting, baud rate generation, and handshaking. The interface supported standard rates from 110 to 9600 baud, making ZAP compatible with widely available terminals.

For mass storage, the book included a cassette interface design. In 1981, audio cassettes were the affordable mass storage medium for personal computers. Ciarcia's design used the Kansas City Standard (300 baud), encoding data as audio tones that could be recorded on any audio cassette recorder. While primitive by modern standards, this approach made program storage accessible without expensive disk drives.

The ZAP Monitor Software

Chapter 6 revealed the software that breathed life into the hardware. The ZAP monitor was a 1K program stored in EPROM that coordinated system operations and provided a command interface for the user.

The monitor's capabilities included: - Memory examination and modification - Program execution from specified addresses - Register display and modification - Block memory operations (move, fill, compare) - Cassette load and save operations - Breakpoint debugging support

Ciarcia presented the complete source code with detailed annotations. The listings served dual purposes: they documented the specific monitor implementation, and they provided extensive examples of Z80 assembly language programming. Readers learned about interrupt handling, I/O programming, data structure manipulation, and subroutine organization—not from abstract examples but from working, useful code.

The flow diagrams accompanying the source code illustrated program logic visually, a documentation technique that helped readers understand the relationships between code sections before diving into instruction-level details.

Programming an EPROM

Chapter 7 addressed a critical practical concern: how to get the monitor program into the EPROM in the first place. This chicken-and-egg problem—needing a programmed EPROM to have a working computer, but needing a working computer to program an EPROM—was solved through a dedicated EPROM programmer built as part of the ZAP system.

Ciarcia's EPROM programmer design could program 2708, 2716, and similar devices. The programming process required specific voltage sequences and timing, all explained in sufficient detail for readers to understand the underlying physics of EPROM operation. For those who preferred to avoid this bootstrap problem, Ciarcia noted that programmed EPROMs were available by mail order.

Connecting ZAP to the Real World

Chapter 8, "Connecting ZAP to the Real World," transformed the computer from an abstract digital machine into a practical tool for measurement and control. This chapter covered analog-to-digital and digital-to-analog conversion, enabling ZAP to interact with continuous physical quantities.

The A/D converter design used the ADC0804, an 8-bit successive approximation converter that could digitize analog signals for processing. Applications ranged from simple voltage measurement to data logging systems that could record environmental parameters over time.

On the output side, D/A conversion allowed ZAP to generate analog signals for control applications. Ciarcia included a particularly interesting application: digital speech synthesis using the SC-01 speech synthesizer chip. By sending phoneme codes from the Z80 to the speech chip, ZAP could produce intelligible spoken output—a capability that seemed almost magical in 1981.

Building a CRT Terminal

The final major project, Chapter 9, was arguably the most ambitious: a complete CRT terminal. Rather than connecting ZAP to an expensive commercial terminal, readers could build their own using the CRT5027 video timer/controller and CRT8002 video attributes controller.

The terminal design supported an 80-column by 24-row display—the standard format that would dominate computing for decades. Character generation used a ROM-based approach, with dot-matrix patterns for the full ASCII character set. The design included cursor control, scrolling, and basic display attributes.

This project integrated many skills developed earlier in the book: power supply design, digital logic, memory interfacing, and RS-232 communication. The completed terminal could serve not only ZAP but any computer with a serial port, making it a genuinely useful piece of equipment.

The terminal design included detailed worksheets for calculating timing parameters—horizontal and vertical sync widths, blanking intervals, and character clock rates. These calculations showed readers how video timing worked at a fundamental level, demystifying what seemed like magic to many hobbyists. The result was not just a working terminal but genuine understanding of raster-scan display technology.

The Appendices: Reference Material

The appendices transformed the book from a tutorial into a reference. Appendix A covered construction techniques—wire-wrapping, soldering, and printed circuit board fabrication. Appendix B provided ASCII code tables. Appendix C collected manufacturers' specification sheets for key components, eliminating the need to track down separate datasheets.

Appendix D contained the complete ZAP operating system listing, while Appendix E provided Z80 CPU technical specifications including electrical characteristics, timing diagrams, and the complete instruction set summary. The glossary and index made the book's wealth of information accessible for quick reference.

The Historical Context

To fully appreciate Build Your Own Z80 Computer, one must understand the computing landscape of 1981. The MITS Altair 8800 had kicked off the personal computer revolution just six years earlier. The Apple II was four years old. The Commodore PET and TRS-80 were both recent arrivals. Computing was still new enough that the question "Should I build or buy?" was legitimate.

Commercial computers were expensive—often thousands of dollars—while components were relatively cheap. A skilled hobbyist with time could build substantial systems for a fraction of the commercial cost. More importantly, building your own computer meant you understood it completely. When something broke, you could fix it. When you wanted to expand it, you knew how. This self-reliance was both necessity and philosophy in the early hobbyist community.

The book also appeared during the golden age of electronics magazines. BYTE, Radio Electronics, Popular Electronics, and others featured monthly construction articles. Readers expected detailed schematics, parts lists, and construction notes. Ciarcia's book was, in many ways, an extended version of the magazine articles that had made him famous—but comprehensive enough to guide a reader through an entire computer system rather than a single peripheral.

The Book's Lasting Significance

Build Your Own Z80 Computer appeared at a transitional moment in computing history. The homebrew era of the mid-1970s, when building your own computer was often the only affordable option, was giving way to an era of mass-produced personal computers. The IBM PC would debut later in 1981, accelerating the shift toward standardized, commercially manufactured systems.

Yet Ciarcia's book served a purpose beyond mere necessity. It educated a generation of engineers and enthusiasts in the fundamentals of digital design. Readers who worked through ZAP gained deep understanding of computer architecture—not just how to use a computer, but how computers actually work at the hardware level. Many professional engineers who came of age in the 1980s cite this book—or Ciarcia's magazine columns—as formative influences on their careers.

The book also demonstrated that complex systems could be understood through systematic decomposition. By building each subsystem separately, testing it in isolation, and then integrating the pieces, even ambitious projects became manageable. This approach to complexity management remains relevant today, whether one is building embedded systems, designing software architectures, or troubleshooting network infrastructure.

The pedagogical approach Ciarcia employed—theory interspersed with practice, abstract concepts grounded in concrete examples—anticipated modern project-based learning. Readers weren't just told how a regulator worked; they built one and measured its performance. They weren't just taught about memory addressing; they wired decode logic and watched the computer access specific memory locations. This hands-on approach created understanding that mere reading could never provide.

For the retrocomputing enthusiast, Build Your Own Z80 Computer offers both historical insight and practical guidance. The Z80 remains available, its instruction set unchanged from 1976. Modern implementations on FPGAs and emulators keep the architecture accessible. Projects like the RC2014 and other Z80-based single-board computers carry forward the tradition of building your own system. For those inspired to design their own Z80 system from scratch, J.S. Walker's Design a Z80 Computer provides a modern practical guide to discrete-logic computer design. And Ciarcia's thorough documentation makes it possible to understand—and even construct—systems that defined the early personal computer era.

Steve Ciarcia went on to found Circuit Cellar magazine and continued contributing to the hobbyist electronics community for decades. But Build Your Own Z80 Computer remains perhaps his most complete and influential work—a comprehensive guide that took readers from bare components to working computer, explaining every step along the way.

The book stands as a testament to an era when understanding technology meant building it yourself, one wire at a time. In an age of sealed devices and cloud computing, there's something deeply satisfying about returning to first principles—about understanding that a computer is ultimately just silicon responding to voltages, executing instructions one cycle at a time, exactly as Steve Ciarcia explained over four decades ago.

The History, Use and Technical Details of QEMU

A.C. Jokela — Sun, 23 Jul 2023 03:43:01 GMT

Introduction

In today's interconnected world, the need for virtualization technologies is more pronounced than ever. These tools help developers simulate different computing environments, facilitating easy testing and debugging across platforms. QEMU, an abbreviation for Quick Emulator, is one such powerful technology. It's a free and open-source hypervisor that performs hardware virtualization. Since its inception, it has become a cornerstone in the world of emulation, offering support for various hardware platforms and operating systems. This article will delve into the history of QEMU, its uses, and technical aspects.

To be honest, I had shyed away from experimenting with QEMU; I had used VMWare and VirtualBox for some time. I first utlitized VMWare in 2007 when a, at the time, friend and I started a software development and consultancy. Amazon Web Services had been launched just one year prior and it was not an established name is computing. Cloud Computing was not called that; I recall a reading about Sun Microsystems developing "Utility Computing"; pay as you go. The idea seemed crazy to me at the time. When you needed compute power, you bought physical hardware, in our case, a Dell PowerEdge 1950. We did an initial installation of Debian Linux and installed VMWare and then shipped the server to a colocation facility in Miami, FL. There, we would create, manage, and ultimately destroy countless virtual machines over the lifetime of the server as well as the halcyon days of the consultancy.

In an odd chain-reaction of thoughts, I wanted to experiment with getting MacOS 9 running on modern hardware. As it turns out, QEMU comes in quite handy.

History of QEMU

QEMU was initially released in 2003, a creation of French programmer Fabrice Bellard, who is also known for creating other groundbreaking tools like FFmpeg and LZEXE. Bellard's idea was to develop a fast, portable dynamic translator that could make software developed for one machine run on another.

While the initial version of QEMU only supported emulation for x86, ARM, and SPARC architectures, it gradually expanded to cater to various others like PowerPC, MIPS, and more. Throughout its history, QEMU has continually evolved and improved, integrating with other projects like KVM (Kernel-based Virtual Machine) and libvirt, and extending its support to system and user-mode emulation.

Use of QEMU

QEMU has a wide array of applications, ranging from cross-platform development, virtualization, sandboxing, to hardware design and testing.

Cross-Platform Development and Testing: As QEMU can emulate different architectures, it has become an invaluable tool for developers, allowing them to compile and test their code across various platforms without needing physical access to them. This functionality significantly accelerates the software development process, enabling more efficient multi-platform software creation.

Virtualization: In conjunction with KVM, QEMU can run multiple operating systems concurrently on a single hardware host. This feature has driven the rapid growth of cloud computing, where multiple virtual machines are hosted on powerful servers, offering flexibility and scalability to businesses.

Sandboxing: QEMU's ability to emulate an entire system makes it ideal for creating secure sandboxes. This is particularly useful for testing potentially harmful code or software without risking the host system's integrity.

Hardware Design and Testing: In hardware design and testing, QEMU is used to emulate the behavior of different hardware components. It enables hardware designers to simulate and validate their designs before manufacturing the physical components.

Technical Details of QEMU

QEMU can function in two primary modes: system emulation mode and user-mode emulation.

System Emulation Mode: In this mode, QEMU can emulate a full computer system, including a processor and various peripherals. It can boot and run different operating systems and applications compiled for a different CPU, providing complete system isolation. The system mode is beneficial for debugging system code and running unmodified guest operating systems.

User-mode Emulation: In user mode, QEMU can launch individual Linux processes compiled for one CPU on another CPU. This approach is highly beneficial for running binary files from different architectures and is often used to build and test software in a cross-compilation environment.

The technical prowess of QEMU lies in its dynamic binary translation. It translates the binary code of a guest system into the binary code of a host one instruction at a time, creating a cache of translated code to optimize performance. QEMU supports numerous architectures, including x86, ARM, MIPS, SPARC, and PowerPC, among others, either as the host or the guest architecture.

When paired with KVM, QEMU's capabilities expand even further. KVM, a feature of the Linux kernel, facilitates hardware-assisted virtualization. When QEMU is combined with KVM, it uses the CPU's virtualization extensions, offering near-native performance for the emulated guest system.

To manage QEMU and KVM virtual machines, libvirt, a toolkit, is often used. It provides a common, consistent API, simplifying the management of different virtualization technologies.

Quick HOWTO

Installation: sudo apt-get install qemu-system-ppc
- You may or may not need to install other packages. Google will be your friend.
Download Required Files:
- Head over to here to grab an ISO of macOS 9.2.2
Prepare a QEMU Disk Image:
- Create a blank disk image that will serve as the virtual hard drive for macOS 9.2. You can do this using the qemu-img command: qemu-img create -f qcow2 macos9.qcow2 10G
Install macOS 9.2 on QEMU:
- Launch the QEMU virtual machine with the following command: qemu-system-ppc -M mac99 -m 512 -boot d -cdrom path/to/macos9.iso -hda macos9.qcow2 -netdev user,id=net0 -device sungem,netdev=net0 Note: Replace path/to/macos9.iso with the path to your macOS 9.2 installation ISO or CD image.
Restore:
- You cannot simply install macOS, you will need to restore. Locate Apple Software Restore on the CD drive. Run the program and follow the instructions.
Launching macOS 9.2:
Once the restore is complete, you can start macOS 9.2 using a similar command as before: qemu-system-ppc -M mac99 -m 512 -hda macos9.qcow2 -netdev user,id=net0 -device sungem,netdev=net0 -g 1024x768x32

Keep in mind that macOS 9.2 may not work perfectly on QEMU due to limited hardware emulation and driver support. If you encounter any issues, there might not be straightforward solutions. Use Google

Final Thoughts

Here are instructions on running MacOS 9 on a couple different flavors of Mac architecture. I personally got MacOS 9 running under Linux and specifically Armbian running on a Pine64 ROCKPro64; this meant that audio and a couple other things did not work.