resources

remzi & andrea arpaci-dusseau. the best free intro to virtualization, concurrency and persistence.

ritchie & thompson. the paper that started it all.

mit pdos. labs on xv6, a small unix for risc-v.

john lions. line-by-line walk through sixth edition unix.

pike et al.. what unix's authors did next: everything is a file, for real.

klein et al.

baumann et al.. treat a multicore machine as a distributed system.

boyd-wickizer et al.

lozi et al.

philipp oppermann. a bootable kernel, one post at a time.

helin & renberg

0xax. how the linux kernel boots and works, from the source.

the reference for writing your own kernel.

build a complete linux system from source.

bryant & o'hallaron. how computers work from the bottom up.

nisan & schocken. logic gates to a working computer to tetris.

charles petzold

patterson & hennessy

hennessy & patterson

ulrich drepper. caches, numa and why memory access patterns matter.

patterson & ditzel

ben eater. a cpu on breadboards, wire by wire.

onur mutlu

agner fog. instruction tables and microarchitecture guides for x86.

intel

kernighan & ritchie. still the best way to learn c.

michael kerrisk. the linux and unix system call interface, exhaustively.

stevens & rago

john levine

ian lance taylor. from the author of the gold linker.

chris lattner

sam rose. an interactive explanation of malloc and free.

klabnik & nichols

the dark arts of unsafe rust.

aria beingessner

brian hall

robert nystrom. two complete interpreters, a tree-walker and a bytecode vm.

aho, lam, sethi & ullman. the dragon book.

cooper & torczon

abdulaziz ghuloum. a working compiler at every step, down to x86.

jeremy siek

jack crenshaw

thorsten ball

alex kladov

llvm project. the kaleidoscope tutorial.

simon peyton jones

matt godbolt. see what your code compiles to.

abelson & sussman. how to think about computation.

benjamin pierce. the definitive textbook, from lambda calculus to system f.

robert harper. rigorous pl theory. a good companion to tapl.

pierce et al.. logic and pl theory, proved in coq.

shriram krishnamurthi

friedman & christiansen. dependent types in the little schemer style.

john mccarthy. the paper that invented lisp.

peter landin

john backus

robin milner. introduced hindley-milner type inference.

damas & milner. algorithm w.

per martin-löf

cardelli & wegner

luca cardelli

philip wadler. the curry-howard correspondence.

philip wadler

philip wadler

john hughes

mark p. jones

hudak, hughes, peyton jones & wadler

dunfield & krishnaswami

bartosz milewski

guy steele. a talk about language design that builds its own vocabulary as it goes.

martin kleppmann. the bible for modern backend systems.

robert morris. lectures on the classic papers, and a raft lab.

leslie lamport

lamport, shostak & pease

fischer, lynch & paterson. the flp result.

leslie lamport

ongaro & ousterhout. raft.

liskov & cowling

waldo et al.. why remote calls can't pretend to be local.

ghemawat, gobioff & leung

dean & ghemawat

chang et al.

mike burrows

decandia et al.. eventual consistency at amazon.

lakshman & malik

hunt et al.

corbett et al.. global transactions with atomic clocks.

verma et al.

shapiro et al.

eric brewer

jay kreps. what every engineer should know about real-time data's unifying abstraction.

jeff hodges

mikito takada

kyle kingsbury. real databases, tested against their consistency claims.

alex petrov. storage engines and distributed databases, in depth.

e. f. codd

hellerstein, stonebraker & hamilton

bailis, hellerstein & stonebraker. the red book.

andy pavlo

o'neil et al.

rosenblum & ousterhout

mohan et al.. write-ahead logging and recovery.

sheehy & smith. a log-structured hash table in six pages.

connor stack. a sqlite clone in c.

hironobu suzuki

markus winand. sql indexing for developers.

cerf & kahn. the design of tcp/ip.

saltzer, reed & clark

van jacobson

david clark

langley et al.

peterson & davie

kurose & ross

w. richard stevens

ilya grigorik

brian hall. sockets in c.

julia evans

c. a. r. hoare. the foundation of go's concurrency model.

c. a. r. hoare

herlihy & shavit

paul mckenney

mara bos. memory ordering explained properly.

herb sutter

rob pike

mcsherry, isard & murray. a laptop beats the cluster more often than you'd think.

brendan gregg. and his site: flame graphs, perf, ebpf.

colin scott

casey muratori

martin thompson

cormen, leiserson, rivest & stein. clrs.

donald knuth

steven skiena

jeff erickson

chris okasaki

william pugh

sergey slotin. algorithms tuned for real cpus and caches.

antti laaksonen

data structures and algorithms, animated.

alan turing

stephen cook. np-completeness.

michael sipser

arora & barak

lehman, leighton & meyer

scott aaronson

douglas hofstadter

ken thompson. you can't trust code you didn't compile yourself. or the compiler.

diffie & hellman

aleph one

lipp et al.

kocher et al.

ross anderson

boneh & shoup

jean-philippe aumasson

laurens van houtven

break real crypto by implementing the attacks.

hands-on exploitation, from the basics up.

peter shirley

pharr, jakob & humphreys

akenine-möller et al.

fabian giesen. what a gpu actually does with your draw call.

dmitry sokolov. write a software rasterizer in 500 lines.

joey de vries

gonzalez vivo & lowe

robert nystrom

jason gregory

casey muratori. a complete game, from scratch, on stream.

fabien sanglard. code reviews of doom, quake and the hardware they ran on.

martin korth. how the ps1 hardware actually worked, register by register.

andrej karpathy. backprop to gpt, written from scratch.

goodfellow, bengio & courville

zhang et al.

3blue1brown

fast.ai

krizhevsky, sutskever & hinton

he et al.

vaswani et al.. the transformer.

jay alammar

lewis et al.

dao et al.. attention made fast by respecting the memory hierarchy.

kwon et al.. vllm: virtual memory ideas applied to the kv cache.

sculley et al.

rich sutton

david parnas. information hiding, before it had a name.

edsger dijkstra

edsger dijkstra

butler lampson

peter naur

fred brooks

fred brooks

richard gabriel. why simple, imperfect solutions often win.

joel spolsky. don't rewrite from scratch.

moseley & marks. complexity is the enemy.

rich hickey

casey muratori

john ousterhout. deep modules, and fighting complexity.

hunt & thomas

tutorials for building git, docker, databases and more from scratch.

daniel holden. learn c by writing a lisp.

joel martin. the same lisp, in any language, in eleven steps.

stephen diehl

panchekha & harrelson

jeremy ruten. kilo, about 1000 lines of c.

james smith

mit. shells, editors, git, debugging.

myers & shah. a self-study curriculum, one book per subject.