Boolean algebra and digital logic, explained — with live examples you can build yourself.
An introduction to Boolean algebra: variables, the three core operations, and the laws that let you simplify any logical expression.
What a truth table is, how to build one by hand, and how it connects directly to logic gates and circuit verification.
How De Morgan's laws let you convert any AND/OR expression into an equivalent built entirely from NAND or NOR gates.
A visual technique for minimizing Boolean expressions by grouping adjacent 1s in a grid — fewer gates, faster and cheaper circuits.
The key difference between level-sensitive latches and edge-triggered flip-flops, and why it matters for reliable digital memory.
How two NOR gates wired back into each other remember a bit, why S = R = 1 is forbidden, and what Boolflow shows when the loop cannot settle.
How binary addition is built from XOR and AND gates, and how chaining full adders produces a complete N-bit adder.
How select lines let a multiplexer route one of several inputs to a single output, and why demultiplexers do the exact opposite.
How positional number systems work, and how to convert between binary, decimal, and hexadecimal — the foundation for reading any digital schematic.
How a chain of flip-flops counts in binary, the difference between ripple and synchronous counters, and where counters show up in real circuits.
How chained flip-flops shift bits left or right each clock cycle, and why shift registers are the standard tool for serial-to-parallel conversion.
How a decoder activates exactly one output line from a binary address, and how an encoder does the reverse — the backbone of memory addressing.
How an Arithmetic-Logic Unit combines adders, logic gates, and a multiplexer to perform multiple operations selected by an opcode.
How RAM stores data in an array of latches addressed by a decoder, why ROM is wired permanently, and where each type is used in a real system.
Why Gray code changes only one bit between consecutive values, and how a parity bit gives circuits a cheap way to detect single-bit errors.
How a comparator circuit determines whether one binary number is greater than, equal to, or less than another, one bit — or one nibble — at a time.
Why every flip-flop in a circuit should share one clock, and what happens — metastability — when an input changes too close to the clock edge.
How an FPGA implements arbitrary logic using configurable look-up tables instead of fixed gates, and how Boolflow's PLM blocks model the same idea.
Why any Boolean function whatsoever can be built from NAND gates alone, or from NOR gates alone, and why real chips are built that way.
How negative numbers are represented in binary, and how a subtractor computes A − B by reusing ordinary addition hardware.
How a BCD-to-seven-segment decoder turns a 4-bit digit into the right combination of glowing segments, and how to drive one from a counter.
How a tri-state buffer's third, high-impedance state lets multiple drivers safely share one wire — and what happens when it's wired wrong.
How to turn a signal that stays high for many clock cycles into a single one-cycle pulse, and why that distinction matters.
How to design a sequential circuit as an explicit set of states and transitions, and the practical difference between Mealy and Moore machines.
How the JK flip-flop's four modes generalize the D flip-flop, and why the T flip-flop is the natural building block for a binary counter.
How a majority gate outputs whatever most of its inputs agree on, and how three of them let a circuit survive one failed component.
How a bank of flip-flops with a shared load enable becomes an N-bit register, and how address decoding turns several registers into a register file.
Why adding or subtracting 1 doesn't need a full adder, and how that shortcut becomes a CPU's program counter.
Why a gate that leaves the logic value unchanged is still useful — restoring signal strength and driving more inputs than a single gate safely can.
Why a single 4-input gate isn't just a bigger version of a 2-input gate — the trade-off between wide gates and cascades of smaller ones.
How Zero, Carry, and Overflow flags let an ALU's result answer questions like 'was that equal to zero?' or 'did that overflow?' — the basis of every conditional branch.
How feeding a shift register's own bits back through XOR gates produces a long pseudo-random sequence — the same trick behind PRNGs and CRC checksums.
How Boolflow's multi-layer canvas, VIA cross-layer links, and Frame containers keep a big circuit readable instead of an unmanageable tangle of wires.
How to turn a circuit into a reusable block with named pins, why each placed copy keeps its own state, and what a block means for the truth table, the waveform and the exported code.
How the XNOR gate outputs 1 exactly when its inputs agree, and why that makes it the natural building block for comparators and error checks.
The difference between an AND-based enable gate that forces its output to 0 and a tri-state buffer that disconnects entirely — and why the choice matters.
How to make a 4-bit counter roll over at 9 instead of 15 by decoding the very next value into an asynchronous reset — and the classic trick behind why.
How adding a few extra parity bits, each covering a different overlapping subset of the data, lets a receiver identify and fix exactly which bit flipped.
Why a real switch's contacts bounce between 0 and 1 dozens of times before settling, and how a shift register plus a little logic filters that noise into one clean transition.
How a parallel word gets framed with start and stop bits, shifted out one wire at a time, and reassembled at the other end — the idea behind every UART.
A complete, concrete finite state machine — three states, one register, one block of combinational logic — built the same way any real Moore machine is.
What INPUT, OUTPUT, LED, CONST0/CONST1, and PROBE actually do — the small elements every circuit uses to get signals in, read them back out, and debug what's happening in between.
How Boolflow's CLOCK element generates the periodic signal every flip-flop, counter, and register in a synchronous design depends on, and what its frequency actually controls.
What Boolflow's HDL export actually generates — a single flat combinational module, ports named after your labels, and an honest list of what it can't translate yet.
How Boolflow turns a combinational circuit into one topologically-sorted C++ function you can drop into another program — and why it doesn't model clocks or memory.
How Boolflow's built-in test-case table checks a circuit's outputs against the table you expect — for combinational logic row by row, and for flip-flops, registers and counters with a clock-pulse symbol.
Chaining two BCD decade counters so the second one advances exactly once per rollover of the first — the same carry idea behind any multi-digit counter.
Combining a free-running LFSR with a debounced button and a seven-segment display to build a circuit that shows a fresh, unpredictable-looking number 1–6 on every press.
A Mealy machine that watches a single input bit over time and raises its output the instant a specific pattern — like a combination-lock code — appears.