Computer Science

A developer with no computer science background can begin with The Computer Science Book, written by a bootcamp graduate for programmers who do not know what they do not know: each concise chapter is a standalone primer on one area with a list of the classic textbooks for going further, a map rather than a course.[1] For a first piece of real theory, TLDR: Data Structures and Algorithms is free, short and assumes only basic Python; its sample chapters teach binary search through a number-guessing game and recursion through a lazy manager delegating a countdown.[7] Discrete Mathematics for Computer Science states no prerequisites, runs its Python in the browser, and asks the reader to attempt each problem before its solution; it was last revised in 2026.[3]

A student on the degree route, or someone retracing it, has textbooks written for classrooms. Foundations of Computing is for upper-division majors, classroom-tested since 2016, and carries the theory of computation from finite automata to the halting problem with exercises in every chapter.[2] Learning Algorithms Through Programming and Puzzle Solving, the book of a Coursera and edX specialisation with over seven hundred thousand enrolments by 2022, teaches algorithm design by implementing it, with solutions checked by an automated grader in any of eleven languages.[6] Discrete Mathematical Algorithm, and Data Structure pairs discrete mathematics with the data structures built on it, in seven languages, for students who meet the two in separate courses.[4] A Quick Steep Climb Up Linear Algebra, a free and open-source linear algebra text by a university lecturer, supplies the mathematics such students need next.[5]

A working programmer who learns by building has the from-scratch books. Build Your Own Database in Go From Scratch assumes comfortable programming and nothing about databases.[24] Understanding Linux: The Kernel Perspective is for intermediate Linux users with some C.[22] Developing a Computer Operating System from Scratch assumes nothing, teaches the C and assembly it uses, and leaves out Make and linker scripts on purpose.[23] At the far end, The Science of Functional Programming expects mathematics at the level of undergraduate calculus and runs to fourteen hundred pages, and Thinking with Types says plainly that a Haskell beginner who finds type errors inscrutable should not read it yet.[13][12]

The field is younger than its mathematics. Boolean algebra, formal logic and the theory of computable functions came from mathematicians in the nineteenth and early twentieth centuries; Alan Turing's 1936 paper on computable numbers gave the discipline its model of a machine, and the stored-program computers of the late 1940s gave it hardware. University departments of computer science date from the 1960s, and the undergraduate curriculum, discrete mathematics and automata beside algorithms, architecture, operating systems and compilers, has kept its shape since.

Two of the sources carry dates from that period. The Linux kernel book opens with Unix: a first version in 1969, originally called UNICS as a pun on the MULTICS project it grew out of, a programmer's manual in 1971, and five decades of refinement leading to a kernel that runs Android, every one of the world's five hundred fastest supercomputers and the servers of the large internet companies. Before 1992, it notes, kernel source was something only engineers at companies like Sun Microsystems or Silicon Graphics could read.[22] The algorithms book takes its epigraph from Donald Knuth, who did not understand things until he tried to program them, and makes implementation the point, something its authors say the classic textbooks introduce ideas well without teaching.[6]

The more recent history here is of how the subject is taught and where it is applied. The algorithms specialisation launched on Coursera in 2016; its authors stopped lecturing in their own classes in favour of flipped teaching around an automated grader, and the discrete mathematics textbook from the same group grew the same way, with autograded puzzles and feedback from students at St Petersburg State University.[6][3] The reactive programming book traces one idea across the industry: a 2005 memo at Microsoft on the coming era of internet services, Erik Meijer's team dualising the Iterator pattern into a push-based model that became Rx.NET, Jafar Husain carrying it to Netflix in 2011, and RxJava's announcement in February 2013.[26]

Computer science rests on mathematics of a particular kind: not the continuous mathematics of physics but discrete structures, finite and countable, established by proof rather than measurement. The discrete mathematics textbook puts the reason in a sentence: once you have an algorithm, you need to prove it correct, and "the program works for me" does not scale to a library function that runs billions of times.[3] The theory of computation then asks what machines of each kind can compute at all.

An algorithm, in the algorithms textbook's definition, is a sequence of instructions that solves a well-formulated problem, one stated unambiguously in terms of its inputs and outputs; the two questions to ask of it are whether it is correct and how much time it takes.[6] Learning Algorithms Through Programming and Puzzle Solving teaches both through implementation. Its chapters introduce pseudocode, problems against problem instances, correctness, speed and big-O notation, then the design techniques, exhaustive search, branch and bound, greedy, dynamic programming, divide and conquer and randomisation, and work through thirty programming challenges from the Algorithmic Toolbox course, from Fibonacci numbers and money change to binary search with duplicates, closest points, edit distance and longest common subsequences.[6] Each solution is checked against the authors' tests; building those meant cataloguing the ten to fifteen most frequent errors per challenge and writing over twenty thousand test cases.[6]

TLDR: Data Structures and Algorithms starts lower and is free. Its binary search chapter begins with a guessing game between 1 and 1,000: guessing in order is linear search, and by the 374th guess the reader feels the cost; told "too high" or "too low", the reader guesses the middle and the number falls on the third try. The chapter then shows why the middle is the right guess, since halving is the only choice whose worst case is guaranteed, derives the bound of the ceiling of log base two of n guesses, and names three LeetCode patterns, classic search, search for boundaries and search on answers. The recursion chapter does the same with a lazy manager, a countdown function, base cases as dominoes, the call stack and the recursion-tree method.[7]

For practice at scale, C++ Algorithmic Mastery: 1000 Challenges from Beginner to Legendary arranges a thousand C++ problems in eight volumes, each with a statement, hint, compiled solution, complexity and explanation, climbing from output and variables through sorting, graphs and dynamic programming to suffix structures, flow and matching and polynomial transforms; its sample is the first seventeen problems of the beginner volume, and its description discloses AI assistance under human planning and review.[8] Coffee Break Python is fifty short Python puzzles with an Elo-style rating of the reader's skill, a minority of them on binary search, sorting, recursion and graph traversal.[9] And Build Your Own Redis with C/C++ makes the case that data structures are best learnt from production software: it builds a key-value server from a TCP socket and a request-response protocol through an event loop, hashtables, serialisation, a balanced binary tree, sorted sets, timers, expiry and a thread pool, on the principle it quotes from Richard Feynman, that what one cannot create one does not understand.[10]

The survey's chapter on programming languages covers how a language is defined, its concepts and paradigms, and type systems; its chapter on compilers covers compilation against interpretation, the program life-cycle, building a compiler, linking, just-in-time compilation and the mechanics of garbage collection, and ends with a section on who to trust.[1] The books that go deeper come from two directions: the algebra of types, and the parsing and resolution of programs.

The survey's architecture chapter is the one most self-taught developers never had: representing information, circuits and computation, the processor, memory and performance optimisations.[1] The sources that go further are practical. Practical Foundations of Windows Debugging, Disassembling, Reversing, Second Edition, Dmitry Vostokov's training course on Windows debugging, disassembling and reversing, is in parallel x86 and x64 halves that each start from memory, registers and simple arithmetic and proceed through number representations, pointers, stacks, frame pointers and function parameters to a summary of disassembly patterns; the sample is the front matter and contents of the April 2022 revision.[16] Welcome to C exists because, its description says, introductory courses taught in Java obscure how computer systems are oriented and how memory is accessed; it teaches C to students with a semester or two of Java by the differences between the languages, in twenty-five pages.[17]

The microcontroller books teach architecture where software meets the chip. Mastering STM32 - Second Edition, a nine-hundred-page guide to the STM32 family and ST's official toolchain, introduces the ARM Cortex-M architecture in its first chapter and then works through what a processor's peripherals are: the NVIC that manages exceptions and interrupts, the DMA controller, the clock tree, timers, ADCs, the I²C and SPI buses, and the low-power modes behind the WFI and WFE instructions. Later chapters design a linker script from scratch to lay out memory, describe the boot sequence and build an encrypting bootloader, and explain the fault exceptions a Cortex-M raises. The author calls it a guide to the HAL rather than a Cortex-M architecture text and sends the reader to Joseph Yiu's books for that, and notes that an STM32 value-line part costs about what an eight-bit microcontroller does.[18] Raspberry Pi Pico Tips and Tricks opens with a chapter on what separates a microcontroller from a computer before its tour of the Pico's RP2040, GPIO, I²C and SPI.[19] Instant Raspberry Pi explains the single-board computer and the system on a chip, and is otherwise a setup and administration guide for the Pi models of 2016.[20]

At the other end of the scale, Build an LLM Inference Engine in C++ is architecture for the machine-learning era: strided tensors with zero-copy views and arena allocation, matrix multiplication with SIMD, int8 and int4 quantisation, model loading with mmap, and a CUDA capstone for the heaviest kernels, built in C++20 one challenge at a time until a Llama-family model runs on the CPU; its description discloses AI assistance under human planning and review.[21]

An operating system, in the survey's chapter, is the boot process, interrupts as hardware support for software, the kernel, and the management of the processor, memory and persistence, with isolation and virtualisation at the end.[1] Understanding Linux: The Kernel Perspective takes the kernel's perspective on a running system. Its first chapter traces one shell pipeline: it was the kernel that turned the bash executable into a process, checked that bash was allowed to run ps, and created a process from it; memory a process allocates is a virtual structure the kernel presents. A one-line fork bomb, run as an ordinary user, is the motivating puzzle, and the method is to treat the running kernel as a black box and probe it with modules and commands, since the source is too large to read cold, something Linus Torvalds conceded in 2018. The sample then separates kernel space from user space, where even root runs, and explains the system call as the only door between them, about three hundred and thirty of them in a modern kernel, before an exercise downloads the 6.1 source and maps its tree.[22] The later chapters, on the description, cover ELF binaries, system calls traced with eBPF, virtual memory, inodes and procfs, Netfilter, and containers built from namespaces and cgroups.[22]

Developing a Computer Operating System from Scratch goes the other way and writes one. It exists, its description says, because OS development is labelled as only for geeks and the existing material leans on Make, linker scripts and heavy C and assembly, all of which it refuses. After primers in C and NASM assembly, its chapters write programs for the boot sector, define a GDT and switch to protected mode, call a C kernel, add a keyboard driver from scan codes and the PIC chip, assemble a prototype called OS0, write a disk driver and a file system with a file allocation table, and add a graphics-mode interface and sound, with closing sections pointing onward to paging, the IDT, timers, GRUB and UEFI.[23]

Past the single process, the subject becomes how data is kept safely, how concurrent work is coordinated, and what changes when the computer is several computers.

Two of the books sit at the field's edges. Fundamentals of Computer Vision is a reference compiled from Georgia Tech's graduate courses in computational perception, with every explanation in the compiler's own words and many hand-drawn diagrams, that omits deep learning on purpose to cover the classical algorithms still used for everything in vision that is not classification: images as functions, filtering and convolution, gradient operators and Canny edges, the Hough transform, Fourier analysis and aliasing, pyramids and blending, cameras, calibration, stereo, motion and tracking.[28] The survey's last three chapters, on machine learning, deep learning, and large language models and AI, are the field's newest territory, and the LLM inference engine above is where that territory meets the computer architecture this article began with.[1][21]