Assembly

Human-readable mnemonics for the processor's own instructions: registers, flags, and system calls.

31 steps across 1 tours, from the basics to complete programs.

The tours

First released: 1949
Created by: Kathleen Booth wrote the first assembly notation; NASM by Simon Tatham and Julian Hall
Typing: One instruction per line; the mnemonic column sets the rhythm
Snippets target: NASM 3 (x86-64)
File extensions: .asm, .s

What it is for

Assembly is the last human-readable layer before the processor: mnemonics that map one-to-one onto machine instructions, registers instead of variables, condition flags instead of booleans, and the operating system reached by number through syscalls. Nobody builds applications in it anymore; everybody who debugs crashes, reads compiler output, writes performance-critical inner loops, studies malware, or plays CTFs ends up reading it — and reading fluently means having written some.

This corpus speaks NASM for x86-64 Linux, the dialect of most modern tutorials: Intel operand order, square-bracket memory operands, and the System V calling convention underneath. The working set is small — mov, the arithmetic quartet, cmp with the jump family, push/pop, call/ret, lea, and a handful of syscalls — but composes into everything: the compiler's jump tables, the runtime's stack frames, libc's string loops all reappear here at their original size.

Its professional homes are compilers and JITs (reading their output is the daily bread of performance work), operating systems and firmware, reverse engineering and security research, and the embedded niches where cycles and bytes still get counted by hand. Godbolt's Compiler Explorer made casual assembly literacy mainstream; this is the vocabulary it displays.

Where it came from

Assembly notation is as old as stored-program machines: Kathleen Booth wrote assembly for the ARC2 at Birkbeck in 1947-49, and David Wheeler's EDSAC 'initial orders' assembled symbolic programs in 1949. For two decades it *was* programming, until Fortran and its successors made compilers respectable — and even then systems programmers kept the fluency.

The x86 lineage begins with Intel's 8086 in 1978; each generation stacked compatibly on the last, through the 386's 32 bits to AMD's 2003 x86-64, the dialect this corpus targets. On the tooling side, MASM and Borland's TASM ruled the DOS era until NASM (1996, Simon Tatham and Julian Hall) gave free platforms a portable Intel-syntax assembler; GNU as carried the AT&T syntax that gcc emits.

Optimizing compilers ended assembly as an application language decades ago, but the reading population keeps growing: every debugger session bottoms out in disassembly, security work lives there, and Compiler Explorer turned 'what does this compile to?' into a reflex. The syscall ABI this corpus uses — numbers in rax, arguments in rdi/rsi/rdx — is the stable floor of Linux itself.

What it is like to type

Assembly types in columns: a short mnemonic, a tab's worth of space, then operands with commas — mov, add, cmp landing over and over until they are pure reflex. Registers are the vocabulary (rax, rdi, rcx in endless rotation), brackets mark memory, and the semicolon comment column is half the typing. Lines are short but dense with punctuation, and the token count per line is the lowest in this corpus, so the pace stat runs low — each line is small, but every character of it is load-bearing.

Practice Assembly