Digital Logic Notebook
Digital logic did not arrive fully formed. It was built up in layers — mechanical switches and relays giving way to vacuum tubes, tubes to discrete transistors, transistors to small-scale integrated gates, and gates to the dense programmable fabrics and processors that define modern hardware. Each layer solved the limits of the one before it, and each carried forward ideas that only make sense once the earlier layer is understood.
This notebook traces that evolution — but its central argument is not historical. It is this:
Digital design has evolved by moving functionality to higher levels of integration — not by making the lower levels disappear.
That distinction matters. An engineer who understands a 74HC14, a 74HC245, or a 74HC595 is not learning obsolete technology; they are learning the vocabulary that still underpins digital hardware. The package got smaller, the supply voltage dropped, and sometimes the function moved inside a microcontroller or FPGA — but the idea stayed the same. This is not a nostalgia project. It is an account of the building blocks practicing hardware engineers still reach for, and why.
In that sense the notebook aims to be the missing bridge between two familiar reference points: NAND to Tetris, which teaches how digital logic can be built from first principles, and embedded systems work, which teaches how to write firmware. The question in the middle — what are the primitives real hardware still reaches for, and why do they persist? — is what this notebook answers.
What lives here:
- The through-line — How each generation of logic technology grew out of the constraints of the last, and which concepts carried forward unchanged.
- Why, not just what — Beyond how a device works, why it exists: the problem it solved, the cost it paid, and what it made possible.
- Problems, not just parts — A glue-logic toolbox organized by the problem in front of you (“I need more outputs”) rather than by chip number.
- Honest obsolescence — Which classic parts are genuinely dead, which are quietly immortal, and what replaced the rest.
How It’s Organized#
The notebook starts with the building blocks — the gates, memory, and functions that are the same in every technology and independent of how they are implemented. From there it follows the evolution of the hardware that realized them: the switches before the integrated circuit, the logic families that industrialized them, and the programmable and integrated forms that define current practice.
Functional Building Blocks#
The heart of the notebook: gates, Boolean foundations, arithmetic, storage, counting, state machines, selection, moving data, and analog helpers — the technology-independent primitives everything is built from.
Before the IC#
Relays, tubes, and transistors — how those primitives were first physically built, and the pressures that drove functionality onto silicon.
Evolution of Implementation#
The logic-family lineage — RTL, DTL, TTL, CMOS, HC/HCT, LVC/AHC, and tiny logic — and why the function survived every change of transistor.
Timing & the Real World#
Where the ideal abstraction leaks: propagation delay, setup/hold, clocks, metastability, and clock-domain crossing — the source of most puzzling hardware failures.
The Glue Logic Toolbox#
Organized by problem, not by chip: the part to reach for when you need one inverter, a debounce, more I/O, an analog switch, level shifting, or a reset delay.
What Became Obsolete?#
An honest reference: which classic parts are dead, which are quietly immortal, and what replaced the rest.
The Modern World#
Microcontrollers, FPGAs, ASICs, and SoCs — how they absorbed logic rather than replacing it, and why discrete parts persist anyway.