In 1978, William Barden, Jr. set out to write a book with a threefold purpose: to acquaint the reader with the hardware of the Z-80, 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 Z-80'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 Z-80'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 Z-80 from a different angle. Section I covers Z-80 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 Z-80 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 Z-80.
This three-part structure gives the book a completeness that many competing references lacked. Readers who wanted to understand the Z-80 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 Z-80 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 Z-80'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 Z-80'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 Z-80'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 Z-80 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 Z-80 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 Z-80. The treatment of the Z-80 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 Z-80 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 Z-80'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 Z-80'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 Z-80-based microcomputer systems: Zilog itself, Technical Design Labs (TDL), Cromemco, The Digital Group, and Radio Shack.
The Zilog chapter covers the Z-80 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 Z-80.
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 Z-80—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 Z-80.
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 Z-80 machines, was fading in the face of MS-DOS. The TRS-80 line was winding down. Cromemco had pivoted to 68000-based systems. The Z-80's reign as the king of personal computing was effectively over.
And yet the eighth printing rolled off the presses.
The Z-80 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 Z-80 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 Z-80 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 Z-80 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-Z-80 instruction cross-reference, a complete instruction summary, binary and hexadecimal tables, and ASCII codes—round out the reference material.
The 8080/Z-80 comparison in Appendix B is particularly useful for readers coming from the Intel side. Since the Z-80 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 Z-80 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 Z-80 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 Z-80 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 Z-80'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 Z-80 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.