Key Takeaways
Follow a computer from voltage to app, one layer at a time.
The whole machine. A computer is more than a laptop or phone: it is an electronic device that can be programmed to carry out logical instructions. The book’s central project is to connect the layers that make this possible, from electrical circuits and digital logic through processors, software, operating systems, networks, and apps.
Build a mental model. Each layer uses capabilities provided by the layer below it, while hiding many of those details from the layer above. That is why a web app can work without its creator designing a transistor. The book moves upward through this stack and uses exercises and 41 optional projects, from breadboard circuits to a Raspberry Pi web server, to make the connections tangible.
The layered view is a powerful way to make a sprawling subject navigable. It also explains why specialists can build reliable systems without understanding every component: each layer offers a manageable interface to the next. The trade-off is that abstraction can make failures feel mysterious when a hidden layer behaves unexpectedly. A useful habit is to ask both, “What does this layer promise?” and, when the promise fails, “Which lower layer might be responsible?”
Read bits only after identifying the format that gives them meaning.
Symbols need rules. Digital computers represent information as sequences of two states, conventionally written as 0 and 1. Eight bits form a byte, which can represent 256 different combinations. A byte might encode a text character, a color value, or part of a number. For example, ASCII assigns a code to each character, while RGB uses three 8-bit values to describe red, green, and blue light.
Context does the decoding. The same sequence of bits can mean different things to different programs. A text editor may read a sequence as letters, while an image program interprets it as color data. Hexadecimal gives people a shorter way to inspect binary: each hex digit corresponds to four bits. The book also warns that data-size labels can mislead: network speeds commonly use bits per second, while file sizes are often counted in bytes.
This is a useful corrective to the idea that data carries its meaning intrinsically. A sequence becomes a picture, word, or number only when a format and a program interpret it that way. That principle reaches beyond computing: measurement systems and languages also depend on shared conventions. The book’s examples make the convention visible, though digital representation should not be confused with perfect preservation. A compressed image, for instance, can be a useful representation without being identical to the original scene.
Build arithmetic from gates, and watch fixed-width numbers overflow.
Logic becomes hardware. Boolean logic describes true-or-false conditions with operators such as AND, OR, and NOT. A truth table lists every input combination and its output. Transistors act as electrically controlled switches, allowing circuits to implement those operations as logic gates. Gates can then be combined: a half adder adds two bits, and a full adder also accounts for a carry from the previous position. Linking adders produces multi-bit addition, though a ripple carry adder must wait for carries to pass along the circuit.
Bits have limits. Two’s complement lets the same addition hardware handle negative numbers. But a fixed number of bits can represent only a fixed range. In Pac-Man, an 8-bit level counter overflowed after level 255, producing corrupted graphics at level 256. The bits had not stopped working; the game’s interpretation of their limited range had failed.
The striking lesson is that complex behavior can emerge from simple, repeatable rules. A gate does not understand addition, but an arrangement of gates can produce the right sum and carry. This compositional approach is central to both hardware design and many kinds of engineering. The Pac-Man example also shows why a correct operation can still produce a wrong result: the arithmetic may be valid within the available bits, while the program’s assumptions about the range are not.
Give circuits memory and clocks so they can respond to history.
State changes the answer. A combinational circuit’s output depends on its current inputs. A sequential circuit also depends on what happened before. An SR latch stores one bit: a set input makes its output 1, a reset input makes it 0, and the saved value remains after the input returns low. That memory lets a vending-machine circuit remember that a coin was inserted before the vend button was pressed.
Clocks coordinate change. A flip-flop is a clocked one-bit memory device. T flip-flops can toggle their stored values when clock pulses arrive, and three of them can form a counter that counts from 0 to 7. Real pushbuttons can bounce between on and off as their contacts settle, creating unwanted pulses. The book’s hands-on circuits show how a latch can clean up that signal and how a capacitor can delay a vending machine’s reset.
Memory turns a circuit from a calculator of present conditions into a system with state. That distinction is easy to miss because the physical parts are still just electrical components, yet it changes what the system can do. The vending example makes the idea concrete: the machine must remember payment across time. It also introduces a practical design principle: timing and human visibility matter. A circuit can perform the intended action so quickly that its user never sees it happen.
Treat the CPU, RAM, storage, and I/O as one working system.
Different jobs, different parts. Main memory, usually RAM, holds the program and its data while the computer is powered. Secondary storage, such as an SSD or hard drive, keeps information when power is off. The CPU fetches instructions from memory, decodes them, and executes them using registers, an arithmetic logic unit, and a control unit. Buses carry addresses, data, and control signals between components. Input and output devices connect the computer to people, storage, and other machines.
Speed depends on arrangement. The CPU can access its small registers faster than main memory, and caches keep frequently used data close to the processor. Multiple cores can execute separate instruction streams, while pipelining overlaps stages of instructions within a core. Neither higher clock speed nor more cores guarantees a proportional improvement: software and the rest of the system determine how much of that capacity can be used.
This hardware picture replaces the vague notion of a computer as a single fast object with a system of specialized components. The distinction between RAM and storage is especially clarifying: one is working space, the other is durable capacity. Performance, in turn, is a property of the whole path a task takes, not simply the processor’s advertised speed. The model is deliberately simplified, but that is useful as long as it is treated as a map of responsibilities rather than a complete description of every modern chip.
Use higher-level code for leverage, while remembering it becomes machine instructions.
Layers of expression. A processor executes machine code specific to its instruction set. Assembly language gives those instructions readable names, but remains tied to a processor family. Higher-level languages such as C and Python let programmers describe operations in a more portable form. A compiler translates C into machine code; Python code is run by an interpreter, though the book notes that the common CPython implementation uses bytecode internally. Libraries and functions let programs reuse work instead of repeating it.
Abstraction has a cost. Variables, loops, and functions conceal details of memory and execution. In C, a local variable may live on the stack, while larger or longer-lived allocations can use the heap. The book follows the same factorial calculation from assembly into C to show how a clearer program can still become processor-specific instructions before it runs.
Each programming layer exchanges direct control for convenience. Assembly makes the processor’s operations visible but demands attention to hardware details; a high-level language makes common tasks easier while relying on translation and runtime support. That is not a contest over which level is best. It is a question of what the task requires. When debugging or performance matters, looking beneath the source code can reveal what the abstraction has hidden.
Let the operating system mediate hardware, memory, and competing programs.
A protected workspace. An operating system manages hardware and provides an environment for programs. The kernel runs with privileged access; ordinary applications run in user mode, where they cannot directly control hardware or access other programs’ memory. When an application needs a protected operation, such as reading a file, it requests help through a system call. The operating system’s API and libraries give programmers a practical interface to those services.
Many programs, one machine. The OS creates processes to run programs and can schedule multiple threads to share processor time. Virtual memory gives each process its own address space, which the system maps to physical memory. Device drivers handle the details of particular hardware. Together, these mechanisms make a computer easier to program and help contain mistakes or unauthorized access, though kernel-level software and drivers must be trusted because they have broad privileges.
The operating system is both a convenience layer and a boundary-setting institution. It lets applications use files, networks, and devices without each program reinventing hardware control, while also deciding which requests are allowed. This makes the API more than a technical menu: it defines what software can ask the system to do. The boundary is not absolute protection. A flaw in privileged code can affect the entire machine, which is why the distinction between user and kernel mode matters.
Follow a packet from Wi-Fi to IP address to listening process.
Networking has layers. The internet connects networks using a shared protocol suite. Data travels from an application protocol, such as HTTP, through a transport protocol, an internet protocol, and a local link protocol such as Wi-Fi or Ethernet. The link layer reaches a nearby device; IP addresses and routers move packets between networks; transport ports direct arriving data to the right process. TCP provides reliable, ordered delivery, while UDP offers best-effort delivery.
Names and addresses do different work. DHCP can assign a device an IP address and network settings. At home, Network Address Translation lets several devices share a public address while using private addresses locally. DNS translates human-readable names into IP addresses. Together, these mechanisms explain why a browser can request a named service without a user needing to know the route, packet format, or server port.
The layered model makes a complicated journey legible by assigning each part a narrower responsibility. A router can forward traffic based on network addresses without needing to understand the web page inside the packet. This resembles modular design elsewhere in computing: components cooperate through agreed formats rather than sharing every internal detail. The simplification has limits, since real traffic can cross many devices and configurations, but the model gives readers a disciplined starting point for diagnosing where communication breaks.
Do not mistake the web for the internet beneath it.
The web is one internet service. The internet is the network of networks; the World Wide Web is a collection of resources accessed over it, usually through HTTP or HTTPS. A URL identifies a resource and how to reach it. HTTP requests ask a server for an action, often to retrieve a page, and responses include status codes such as 200 for success or 404 when a resource is not found. HTTPS adds TLS encryption to protect traffic in transit.
Pages combine three roles. HTML structures a page, CSS styles it, and JavaScript adds behavior. A browser fetches the page and its referenced resources, then renders them. A static server returns files already prepared; a dynamic server generates content in response to requests. A local Python server project lets readers see this process directly, including the separate request for an image referenced by the page.
Separating the web from the internet clears up a common conceptual blur. The distinction also shows how a website depends on several contracts at once: naming, transport, HTTP behavior, and browser interpretation. A page that fails to load may have a problem at any of these levels. HTTPS protects communication, but it does not by itself guarantee that a site is accurate, trustworthy, or harmless. Security of the connection and trust in the content are different questions.
Choose where computation runs, because every boundary creates a trade-off.
Machines can be re-created in software. Virtualization presents software with virtual hardware, allowing one physical computer to host multiple operating systems. Emulation goes further by reproducing a different kind of machine, so software for an older game console can run on a modern computer. Containers isolate applications while sharing the host operating system’s kernel.
Cloud services shift responsibility. In Infrastructure as a Service, customers manage much of the software on a virtual computer. Platform as a Service manages more of the environment; Function as a Service runs code in response to events; Software as a Service delivers a complete application. Native apps target a particular operating system, while web apps use browser technologies. Bitcoin’s public transaction ledger and VR or AR interfaces are other examples of computing being organized in different ways.
These models are best understood as choices about control, portability, and responsibility, not as a ladder where newer is automatically better. A virtual machine offers a familiar computer environment; an emulator offers compatibility with unlike hardware; a managed cloud service reduces operational work but gives the provider more responsibility and influence. The same question applies to native and web apps: platform access and performance are weighed against reach and reuse. The suitable boundary depends on what must remain under the user’s control.
Prototype an internet-connected device, then ask who controls its data.
One vending machine, two designs. The book’s final project begins with a circuit that remembers inserted coins and permits a vend. A Raspberry Pi replaces much of that fixed hardware logic with Python code, using GPIO pins to read buttons and control an LED. The program tracks credits and can serve a web page showing coin and vend counts. This links physical input, software, networking, and a browser in one small Internet of Things project.
Connectivity adds dependencies. Connected devices often rely on online services, collect information, and may be poorly secured. Their usefulness can depend on the manufacturer continuing to operate the service. A device that seems like a simple convenience can therefore create security, privacy, and longevity concerns. The project demonstrates how software makes hardware behavior easier to change, while also making network access part of the system’s design.
The vending machine is a compact demonstration of the book’s larger argument: software can coordinate hardware, user interaction, and network services without rebuilding the physical circuit for every new feature. It also makes the costs of connectivity harder to ignore. Remote status is useful, but it raises questions about who can access the device, what information leaves it, and what happens if its service disappears. Those are design requirements, not afterthoughts.
Analysis
The book’s distinctive achievement is not exhaustive coverage of computer science, but a continuous chain of explanation. It begins with voltage and binary states, then shows how transistors implement logic, how logic can preserve state and perform arithmetic, and how those circuits become processors and memory. The chain continues through machine code, programming languages, operating systems, networks, and web applications. Each transition answers a practical question: what must the next layer provide so that the layer above can work?
That structure is pedagogically important. A reader who knows how to write code may have learned to treat a computer as an obedient surface. A reader who has only seen circuit diagrams may regard software as an unrelated subject. Justice connects these views by showing how each abstraction rests on real mechanisms while making the next abstraction possible. His repeated use of a vending machine is especially effective: first it illustrates memory in a circuit, then it becomes a software-controlled device, and finally it can report status over a network. The same recognizable task gains new capabilities as its implementation moves through the stack.
The book also teaches a useful form of technical skepticism. Binary data has no fixed meaning without an encoding; a machine instruction is architecture-specific; an IP address does not identify a process; a web page depends on more than HTML. These distinctions help readers resist attractive but imprecise claims about technology. At the same time, the explanations simplify real systems by design. Modern processors, operating systems, and networks have many complications that cannot fit into an introductory tour. The text is strongest when its models are treated as entry points, not complete accounts.
The projects reinforce that distinction between knowing a description and understanding a mechanism. Measuring a resistor, tracing a system call, or inspecting a running process makes invisible layers observable. The book’s lasting value is a mental map that lets a learner ask better next questions, not the illusion that a single volume has made every layer simple.
Review Summary
How Computers Really Work is highly praised for its clear explanations of computer fundamentals, from basic electronics to programming. Readers appreciate the hands-on activities and practical exercises, making it accessible for beginners and young audiences. The book's comprehensive coverage, from transistors to high-level programming, is commended. Some reviewers note that certain sections, particularly on modern computing, feel less substantial. Overall, it's considered an excellent resource for understanding computer operations, with a few critiques on writing style and depth in specific areas.
People Also Read
Glossary
Boolean logic
Logic with two valuesA system for reasoning about values that can be true or false, commonly represented in digital circuits as 1 and 0. Operators such as AND, OR, and NOT combine or invert these values. Truth tables list possible inputs and the output for each combination, providing a precise way to design and describe logic gates.
two’s complement
Binary signed-number representationA widely used way to represent positive and negative integers with a fixed number of bits. To form the negative of a value, invert its bits and add one. This representation allows the same basic binary addition hardware to handle signed values, although the number of available bits limits the range and can produce overflow.
SR latch
One-bit memory circuitA circuit with set and reset inputs that stores one binary value. Setting S makes output Q equal to 1; setting R makes Q equal to 0. When both inputs return to their inactive state, the output retains its previous value. Setting both inputs at once is an invalid condition in the design described in the book.
instruction set architecture
Processor instruction specificationThe defined instructions and operating model that software uses when communicating with a processor. Processors that implement the same instruction set architecture can run compatible machine code, even if their internal designs differ. The book identifies x86 and ARM as major examples and explains why software compiled for one architecture may not run on another.
virtual memory
Private process address spaceAn operating-system abstraction that gives each process its own address space rather than direct access to physical memory. The operating system and hardware translate virtual addresses to physical locations, helping isolate programs from one another. Some virtual memory can be moved to secondary storage through paging, which expands available space but is slower than RAM.
system call
Request for kernel serviceA mechanism that lets code running with limited user-mode privileges ask the operating-system kernel to perform a protected operation. Reading a file or communicating with hardware may require such a request. Libraries and operating-system APIs commonly provide convenient ways to make system calls without requiring application developers to write processor-specific instructions.
internet protocol suite
Layered network protocolsThe set of protocols that enables communication across the internet, commonly described using four layers: link, internet, transport, and application. Each layer has a narrower role and passes data to adjacent layers. For example, a web request can be carried by TCP, addressed and routed with IP, then transmitted over Wi-Fi or Ethernet.
Network Address Translation
Private-to-public address mappingA technique used by a router to let devices with private IP addresses communicate with the public internet through a shared public IP address. The router modifies address information in outgoing packets and uses that mapping to direct responses back to the appropriate device. It is common in home networks, where an internet provider may supply only one public address.
Domain Name System
Names mapped to addressesA distributed naming system that lets computers look up information associated with domain names, including the IP address for a host. Its hierarchy divides responsibility among servers for different levels of names. DNS records can also point one name to another or identify mail services, and cached results can speed up repeated lookups.
virtual machine
Software-created computer environmentA software representation of a computer that can run an operating system and its applications as though it had its own hardware. A hypervisor manages the virtual machines and their access to a physical host. Unlike emulation, ordinary virtualization generally presents hardware compatible with the underlying processor architecture.
Internet of Things
Network-connected physical devicesThe use of internet-connected devices beyond traditional computers and phones, including appliances, sensors, and home controls. These devices often exchange data with web services and may be controlled remotely. Their convenience can bring security and privacy risks, and some lose functionality if the manufacturer’s supporting service is discontinued.
Download PDF
Download EPUB
.epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.