--- title: "Computer Systems" description: "45 topics in Computing, in the order they build on each other." canonical: https://lightmysky.com/learn/computing/areas/computer-systems source: https://lightmysky.com/learn/computing/areas/computer-systems.md retrieved: 2026-09-02 --- > **Agent view.** This is the Markdown twin of the page, for tools and assistants. > When to use this site, and the call that answers each job: https://lightmysky.com/agent-instructions.md > API description (OpenAPI 3.1): https://lightmysky.com/openapi.json · Authentication: https://lightmysky.com/auth.md > Pricing: https://lightmysky.com/pricing.md · Catalog: https://lightmysky.com/llms.txt · Full catalog: https://lightmysky.com/llms-full.txt > Every machine-readable file on this domain: https://lightmysky.com/.well-known/ai-catalog.json > Ask for Markdown with `Accept: text/markdown`, a `.md` address, or `?mode=agent`. # Computer Systems 45 topics in Computing, in the order they build on each other. Page: https://lightmysky.com/learn/computing/areas/computer-systems - [Binary Numbers and Place Value](https://lightmysky.com/learn/computing/binary-numbers-and-place-value-mt_t67akIKBmI): Counting with two digits, where each column is worth twice the column to its right. Converting both ways between binary and decimal. - [Adding Binary Numbers and Overflow](https://lightmysky.com/learn/computing/adding-binary-numbers-and-overflow-mt_dBS2OoQscq): Adding binary numbers column by column with a carry, and what happens when the answer needs more bits than the space it has. - [Hexadecimal as Binary Shorthand](https://lightmysky.com/learn/computing/hexadecimal-as-binary-shorthand-mt_OV6PHdnU6N): Writing four bits as one of sixteen digits, so long binary values can be read and typed by people without anything being lost. - [Character Sets: Storing Text as Numbers](https://lightmysky.com/learn/computing/character-sets-storing-text-as-numbers-mt_839VNNZlp2): Every character has an agreed number, and the text on screen is those numbers drawn by a font. A shared standard is what lets two machines read the same file, and one byte per character stopped being enough. - [Bitmap Images: Pixels, Resolution and Colour Depth](https://lightmysky.com/learn/computing/bitmap-images-pixels-resolution-and-colour-depth-mt_-Tr40QK8sN): A picture stored as a grid of pixels, each one a binary colour value. Resolution and colour depth decide both how it looks and how big the file is. - [Sampling Sound into Numbers](https://lightmysky.com/learn/computing/sampling-sound-into-numbers-mt_yTA4W-yFjy): Recording sound by measuring the wave thousands of times a second and storing each measurement as a binary number. Sample rate and bit depth change the quality and the size together. - [Compression: Lossy and Lossless](https://lightmysky.com/learn/computing/compression-lossy-and-lossless-mt_lx2U-B9CFa): Making a file smaller either by storing the same information in fewer bits, or by dropping detail people are unlikely to miss. Which of the two is safe depends on the file. - [Logic Gates and Truth Tables](https://lightmysky.com/learn/computing/logic-gates-and-truth-tables-mt_o2N0-q3A4Q): The and, or and not circuits that everything else is built from, and the table that fixes what each one outputs for every possible input. - [Inside the CPU: Fetch, Decode, Execute](https://lightmysky.com/learn/computing/inside-the-cpu-fetch-decode-execute-mt_YT-FSWnUKR): The cycle a processor repeats: fetch the next instruction from memory, work out what it means, carry it out. Clock speed, cores and cache each change how fast that goes. - [Memory and Storage: RAM, ROM and the Backing Store](https://lightmysky.com/learn/computing/memory-and-storage-ram-rom-and-the-backing-store-mt_AiXGJioO_S): Where a machine keeps things: fast memory that empties at power off for what is running now, permanent storage for what has to survive. Speed, size and cost pull against each other. - [Packets and Protocols on a Network](https://lightmysky.com/learn/computing/packets-and-protocols-on-a-network-mt_IffXVDtfLX): Data crosses a network cut into numbered packets that travel separately and are put back together at the far end. Protocols are the agreed rules that let machines from different makers understand each other. - [How a Web Page Reaches Your Screen](https://lightmysky.com/learn/computing/how-a-web-page-reaches-your-screen-mt_8JveAW2Mg7): The path from typing an address to seeing a page: the name looked up as an address, a request sent to a server, a reply of files the browser assembles. - [Cyber Threats and How Systems Defend](https://lightmysky.com/learn/computing/cyber-threats-and-how-systems-defend-mt_zMJzhIdEWd): The usual ways systems are attacked, from tricking a person into handing over a password to feeding a program input it trusted too far, and the defence that answers each one. - [Boolean Algebra and Simplifying Logic Expressions](https://lightmysky.com/learn/computing/boolean-algebra-and-simplifying-logic-expressions-mt_9MrE1N63D5): Writing a circuit as an algebraic expression and rearranging it with the laws of Boolean algebra, including De Morgan's, to reach a shorter expression with the same truth table. Fewer gates means less silicon and less delay. - [Logic Circuits That Add and Remember](https://lightmysky.com/learn/computing/logic-circuits-that-add-and-remember-mt_zPgkt6zf-i): The half adder and full adder that turn gates into binary arithmetic with a carry, and the flip-flop that holds one bit after its input has gone. Feedback is what turns a circuit into storage. - [Assembly Language and the Instruction Set](https://lightmysky.com/learn/computing/assembly-language-and-the-instruction-set-mt_bzmsfvdzwp): The instructions a processor actually offers: load, store, add, compare, branch, halt, each naming a register or an address. A line of high-level code turns into several of them. - [Registers, Buses and the Fetch-Execute Cycle in Detail](https://lightmysky.com/learn/computing/registers-buses-and-the-fetch-execute-cycle-in-detail-mt_yjy3eSStzH): What each register holds during one cycle, from the program counter and the address and data registers through to the accumulator, and what travels on the address, data and control buses. A branch is just an instruction writing to the program counter. - [Network Layers and the Protocol Stack](https://lightmysky.com/learn/computing/network-layers-and-the-protocol-stack-mt_O3Ew6c2ynD): A network is split into layers, each with one job and each talking only to the layer above and below: application, transport, internet, link. A message gains a header at each layer on the way down and loses it on the way up. - [IP Addressing and How Routers Choose a Path](https://lightmysky.com/learn/computing/ip-addressing-and-how-routers-choose-a-path-mt_l0dRGocXGw): How an address splits into a network part and a host part, and how a router uses its forwarding table to pick the next hop without knowing the whole route. No single machine holds a map of the internet. - [Relational Databases: Tables, Keys and Relationships](https://lightmysky.com/learn/computing/relational-databases-tables-keys-and-relationships-mt_i7pZV6H902): Data held as tables of rows, with a primary key that identifies one row and a foreign key that points at a row in another table. The relationships between tables are the design, not an afterthought. - [Normalisation to Third Normal Form](https://lightmysky.com/learn/computing/normalisation-to-third-normal-form-mt_cbRXVW6KxX): Splitting tables until every field depends on the key, the whole key, and nothing but the key. Each step removes a way the data could contradict itself after an update. - [SQL: Selecting, Filtering and Ordering Rows](https://lightmysky.com/learn/computing/sql-selecting-filtering-and-ordering-rows-mt_lDVVG2AKzs): Asking a database for the rows and columns you want with SELECT, WHERE and ORDER BY. The query says what is wanted, and the database decides how to fetch it. - [SQL: Joining Tables and Summarising Groups](https://lightmysky.com/learn/computing/sql-joining-tables-and-summarising-groups-mt_0QPZDE2KuS): Pulling rows from two tables together on a matching key, and collapsing many rows into one answer with COUNT, SUM and GROUP BY. This is the payoff for having split the tables in the first place. - [Instruction Set Architecture as a Contract](https://lightmysky.com/learn/computing/instruction-set-architecture-as-a-contract-mt_pbwHRePY5M): The instruction set is the promise the hardware makes to every program: these operations exist, these registers are visible, this is how memory is addressed. Everything below it can be rebuilt without breaking a single compiled program, and that separation is why chips can change while software does not. - [The Memory Hierarchy and Why Caching Works](https://lightmysky.com/learn/computing/the-memory-hierarchy-and-why-caching-works-mt_0f5ArFPlxP): Fast memory is small and small memory is fast, so machines stack registers, caches, main memory and disk. The stack pays off only because programs reuse what they touched recently and touch neighbours next, which is what locality means. - [Pipelining and the Cost of a Hazard](https://lightmysky.com/learn/computing/pipelining-and-the-cost-of-a-hazard-mt_GI_fPY9d6s): Splitting instruction handling into stages lets one instruction start before the last has finished, raising throughput without making any single instruction faster. Dependencies between neighbouring instructions and unresolved branches force stalls, which is the price of the arrangement. - [Many Cores and the Limit on Speedup](https://lightmysky.com/learn/computing/many-cores-and-the-limit-on-speedup-mt_dy3-K9dV19): When one core stops getting faster, machines add cores, and the gain then depends on how much of the work can actually run at the same time. The serial fraction sets a ceiling that no number of cores can lift. - [What an Operating System Is: Privilege and System Calls](https://lightmysky.com/learn/computing/what-an-operating-system-is-privilege-and-system-calls-mt_0kMavEKxpX): An operating system exists because programs cannot be trusted with the hardware directly. The processor runs in two modes, ordinary code cannot touch devices, and a system call is the one controlled doorway from a program into the kernel. - [Processes, Context Switches and What They Cost](https://lightmysky.com/learn/computing/processes-context-switches-and-what-they-cost-mt_oiOwHKUoXG): A process is a running program plus everything the kernel remembers about it: registers, memory map, open files. Swapping one for another means saving all of that and loading another set, which is cheap in instructions and expensive in lost cache. - [Scheduling: Deciding Which Process Runs Next](https://lightmysky.com/learn/computing/scheduling-deciding-which-process-runs-next-mt_QZYzfVIcP6): A scheduler chooses from the ready processes, and every rule it could use favours something: throughput, response time, or fairness. Round robin, shortest job first and priority with ageing each make that trade differently. - [Virtual Memory and Address Translation](https://lightmysky.com/learn/computing/virtual-memory-and-address-translation-mt_B-PiAyderj): Every process is given its own address space, and the hardware translates its addresses into real ones through a page table on every access. This is what stops one program reading another's memory and what lets a program use more memory than the machine has. - [Paging, Page Faults and Replacement Policies](https://lightmysky.com/learn/computing/paging-page-faults-and-replacement-policies-mt_nEEuGL89Ze): When a page is not resident the hardware raises a fault and the kernel fetches it, possibly evicting another. Which page leaves is a policy question, and a bad answer produces thrashing, where the machine spends its time moving pages instead of running code. - [File Systems: Names, Blocks and Metadata](https://lightmysky.com/learn/computing/file-systems-names-blocks-and-metadata-mt_jN4u3idvF3): A file system turns a flat array of blocks into names, directories and permissions. An inode or equivalent record holds where the blocks are and who may touch them, while the directory is just a table mapping names to those records. - [Crash Consistency and the Journal](https://lightmysky.com/learn/computing/crash-consistency-and-the-journal-mt_I9DT0TUmiu): A file operation touches several blocks, and a crash between them leaves the file system in a state no correct sequence could produce. A journal writes the intention down first, so recovery can either finish the operation or discard it whole. - [Threads and Shared Memory](https://lightmysky.com/learn/computing/threads-and-shared-memory-mt_N4EGNbN6Xh): Threads inside one process share an address space and everything in it, which makes them cheap to switch between and dangerous to reason about. The gain is a program that keeps working while one part waits; the cost is that any two threads can touch the same variable. - [Race Conditions and Mutual Exclusion](https://lightmysky.com/learn/computing/race-conditions-and-mutual-exclusion-mt_hygT74jJDE): When two threads read, change and write the same value, the result depends on timing that nobody controls. A critical section is the stretch that must not be interleaved, and a lock is the usual way to enforce that, at the cost of everything waiting. - [Deadlock and the Four Conditions](https://lightmysky.com/learn/computing/deadlock-and-the-four-conditions-mt_CsMOA4sBb1): Deadlock needs mutual exclusion, holding while waiting, no preemption, and a cycle of waiting. Removing any one of the four prevents it, which is why a fixed lock ordering is the usual answer in real code. - [Message Passing and Asynchronous Work](https://lightmysky.com/learn/computing/message-passing-and-asynchronous-work-mt_twcpO-945r): Instead of sharing memory and guarding it, threads or processes can own their state and send messages. Queues, channels and event loops trade the race conditions of shared memory for questions about ordering, buffering and back pressure. - [Lexing and Parsing: From Text to a Syntax Tree](https://lightmysky.com/learn/computing/lexing-and-parsing-from-text-to-a-syntax-tree-mt_-ZlCxZ3SOh): A compiler's front end first groups characters into tokens, which a state machine can do, then arranges those tokens into a tree according to a grammar. The tree is where operator precedence stops being a rule to memorise and becomes a shape. - [Semantic Analysis and the Intermediate Representation](https://lightmysky.com/learn/computing/semantic-analysis-and-the-intermediate-representation-mt_f2z_WQxfiw): A tree that parses can still be wrong: an undeclared name, a type mismatch, a call with the wrong arity. After those checks the compiler lowers the tree into a simpler representation, which is what lets one front end serve several targets. - [Code Generation and What an Optimiser May Change](https://lightmysky.com/learn/computing/code-generation-and-what-an-optimiser-may-change-mt__ZSPwP4hfA): The back end turns the intermediate form into instructions, assigns registers, and rearranges work. Every rearrangement is allowed only if the observable behaviour stays the same, which is why an optimiser can reorder arithmetic but not a write to a device. - [Cloud-Native Architecture: Containers, Schedulers and the Control Loop](https://lightmysky.com/learn/computing/cloud-native-architecture-containers-schedulers-and-the-control-loop-mt_nV1LgSRsh_): A deployment is described as a desired state and a controller works continuously to close the gap. Containers make a process portable, a scheduler decides where it runs, and the control loop is what turns a crashed replica into a replaced one with nobody being paged. - [Observability and Tail Latency Across Services](https://lightmysky.com/learn/computing/observability-and-tail-latency-across-services-mt_NT5tmumdfA): Once a request touches a dozen services, an average tells nobody anything. Traces follow one request across process boundaries, percentiles expose the slow tail, and a request that fans out inherits the worst of everything it waited on. - [Type Soundness: Progress and Preservation](https://lightmysky.com/learn/computing/type-soundness-progress-and-preservation-mt_nAAHVPNaVJ): A language is defined by a small-step semantics saying how a program takes one step. Soundness is two lemmas over that definition: a well-typed program is never stuck, and taking a step preserves its type. Together they say the errors the type system rules out cannot occur at run time. - [The Impacts of Computing: Law, Ethics and the Environment](https://lightmysky.com/learn/computing/the-impacts-of-computing-law-ethics-and-the-environment-mt_veX-psjipc): What computing does beyond the machine: the rules on holding people's data, the choices behind who a system serves well, and the energy and materials a device costs.