I think a cheat sheet is the best way to learn a complex device. Not the manual, which explains everything in
the order the manufacturer thought of it, and not a tutorial, which explains one thing — a dense, single page
that puts every command, key and quirk in front of you at once, so you can see the shape of the whole machine and
then filter down to the line you need. Every device deserves one, and most never got one. These are mine: for
modern and classic devices — calculators, pocket computers, bench instruments, single-board computers — and
for operating systems, languages and AI tooling. Beside the sheets sit a few lessons, longer pieces
meant to be read through where the point is a method rather than a table. Each page is self-contained: no tracking,
no fonts to fetch, no JavaScript beyond a filter box. Save the page and it still works offline.
01 · Cheat Sheets 48 sheetsDense single-file references. Press / inside any sheet to filter every line on the page.
The DB48X dialect of RPL and where it departs from HP48/50, plus native C/C++ programs against the
DMCP SDK. Then every command, operator, flag, setting and menu, indexed straight from ids.tbl.
TI’s document-based graphing handheld — problems and pages, entry templates and modes, CAS
behaviour, TI-Basic, and the MicroPython that has no f-strings. The Calculator menu tree and the machine’s
own specs were read off a real CX II CAS over USB; every screen is a capture from it. Then 415 entries —
commands, symbols, templates and the CX II-only draw commands.
The HP Prime Programming Language end to end — structure, scope, operators, graphics, apps and
views, user keys, CAS access, base integers, idioms — then every command, function and system variable.
The User RPL language — objects, locals, tests, branching, loops, lists, flags, errors, I/O, menus,
debugging — then every command in the AUR reference for the 48gII, 49g+ and 50g, indexed by category.
The unchecked internal language the ROM itself is written in — 3–10× faster than User RPL, and
no seatbelts. The toolchain on the calculator, bints, argument dispatch, temporary environments, then 3,260 supported
entries with their 49/50 ROM addresses and stack diagrams. Ends with the book's parameterized-outer-loop program
taken apart line by line.
HP's menu-driven business calculator: six blank keys take their meaning from the labels above
them, and every label stores or solves. The guide walks the menu tree — TVM, amortisation, cash-flow
lists, bonds, depreciation, statistics, the clock — then the Equation Solver that stands in for programming,
with IF, summation, multi-equation menus and guesses. Every menu label and Solver function indexed with its
manual page; a drawn keyboard; an odd-period loan worked as one equation.
The machine guide — modes, TEXT editor, ML monitor, memory map, ports — then 128 BASIC keywords
with their shortest abbreviations, the Z80 and CASL/COMET instruction sets, and the C runtime library.
Every command in the HP 48SX Command Dictionary, arranged by category and subgroup. Commands
belonging to several topics are listed under each. Hover any entry for its description, type and manual page.
The HP-41 rethought around a two-line display: Y visible above X, named variables of any
type, complex numbers and matrices as objects, and a Solver that turns any program with MVARs into a form. The
keyboard drawn to the machine's proportions, the machine explained from the stack outward, then every function
grouped by the menu it lives in, from the Owner's Manual Operation Index.
The clamshell that started RPL: fold it open and there is an alphabet on the left, a calculator on the
right, and a language in which numbers, formulas, programs and matrices are all objects on one stack. Both
keyboards drawn, the ideas the 28C introduced explained, then every command by menu with its type and manual
page, and a Fibonacci loop taken apart.
The HP-71 as a machine and as a language: CALC mode, line syntax, IEEE math exceptions,
subprograms, flags, files, the clock. Then every keyword from the Owner's Manual index.
The calculator that could talk: a fourteen-character alphanumeric display, an Alpha register
that holds text, named files in extended memory, and a clock that runs with the machine off and can wake it to run
a program. The keyboard drawn with all three of its legends, the machine explained from the stack outward, then
every function grouped as the Owner's Manual groups them — with the names read out of the ROM, because the
scans print them in a symbol font.
The most capable calculator HP put in a shirt pocket: RPN on a four-level stack, complex
arithmetic on a parallel imaginary stack, five matrices addressed by descriptor, and a root finder and
numerical integrator in firmware — all in 448 bytes. A working guide to the machine, then every
function with its handbook page, and a twelve-line polynomial engine explained line by line.
The longest-produced calculator ever made, and still what finance actually uses. A guide to the
machine and to the money: what time value of money is really solving, why internal rate of return can lie
to you, when to accelerate a depreciation schedule, and what the cash-flow sign convention is for. Then every
function, and a nine-line amortisation schedule explained line by line.
The first programmable pocket calculator: three prefix keys, five keys you define yourself, a
hundred-step memory with labels, tests, flags and a loop counter, the two-step skip, program codes and which ones
merge, editing, and the magnetic card reader. The keyboard drawn with every key's code in its cap, every key under
each prefix with its handbook page, and a thirteen-step loop shown exactly as the display shows it.
The HP-45: the HP-35's machine with a gold shift key, and everything that bought: nine storage registers with arithmetic
in them, LAST x, FIX and SCI, three angular modes, degrees-minutes-seconds, polar and rectangular conversion, mean and
standard deviation, percent, factorials and unit constants. The keyboard drawn from the handbook's figure, every key
with its page, and the handbook's vector sum traced through the stack and the summation registers.
The first scientific pocket calculator: thirty-five keys and no shift, a four-level RPN stack
with the automatic lift, one memory register, the power-first x^y, degrees-only trigonometry and the errata sheet.
The keyboard drawn from the manual's cover, the machine explained from the stack outward, every key and behaviour
with its Operating Manual page, and the manual's mortgage example traced through the stack one key at a time.
Claude Code, the model family and the Messages API on one page — every command, flag, key, setting,
hook event and permission mode, then the model IDs, context windows and prices. Model and API facts checked
against the current reference, not recalled: adaptive thinking, effort tiers, and what returns a 400 on which model.
Not what each feature is, but how to work: verification as the primary quality lever, context
as the real budget, and the parallelism ladder from worktrees to hundred-agent workflows.
For a Windows developer: agent mode in Visual Studio and VS Code, the CLI under PowerShell,
the cloud agent and the app. Every command, file and frontmatter field, the %USERPROFILE% paths that
differ between the two IDEs, and what each model costs.
xAI's terminal coding agent, built to be bounded rather than trusted: deny rules that
survive always-approve, five kernel-enforced sandbox profiles, and a genuinely read-only plan mode. Every command,
slash command, config key and TOML field — plus the 200k-token pricing cliff.
Moonshot AI's single-binary terminal agent: three permission modes, a plan mode that writes only the plan,
goals that persist until the evidence holds, swarms of item-based subagents, and a web UI and ACP server on the
same engine. Every command, slash command, config key, hook event and tool — plus what the K-series costs and a straight
answer on where the code goes.
The language on its own: what the standard says, what it leaves to the implementation, and what it
leaves undefined. The statements come first — the whole grammar is six kinds of statement and the rest
is expressions — then precedence, the type system, integer promotion, declarations, the object model,
aliasing, sequencing, _Generic, undefined behaviour and what C23 changed. Every statement and
keyword carries a code example on hover.
gcc is not a compiler — it is a driver that runs cc1,
as and ld, and knowing which of the three produced a message is most of knowing what to do
about it. The four phases, the gnu23 default GCC 15 changed under you, warnings as a real taxonomy,
what each -O level turns on, LTO and PGO, -fanalyzer, linking, binutils, make and
cross-compiling.
Clang is a front end and LLVM is everything behind it — which is why this toolchain has an
opt and an llc you can run by hand, why clang-tidy and clangd
exist, and why cross-compiling is a flag rather than a second toolchain. The diagnostic engine, ThinLTO, the full
sanitizer set, lldb, the LLVM tools, reading the IR, and what is genuinely different on a Mac.
For someone who knows C and knows what a vtable is. The through-line is where the machine code
comes from: what a value category costs, what the compiler synthesises and when it stops, what a
shared_ptr allocates, what an exception really compiles to. Then three cards on embedded C++
— the freestanding subset, zero-cost register abstraction, and what each toolchain really gives you.
A programmer's guide to Forth as Gforth implements it — the text interpreter, stacks, defining
words, control structures, locals, memory, exceptions, compile-time semantics, word lists, floating point,
objects — then every word in the Gforth Manual, indexed by category.
The language for someone who already knows how languages work: what the compiler
guarantees, what erasure takes away, what the memory model actually promises, how virtual threads
change the shape of a server, and what the JVM does at run time. Then a searchable index of the core
API whose every signature was read out of a real JDK with javap rather than written
from memory — Java 8 through 25, each entry dotted with the release it arrived in.
C with a Smalltalk message layer bolted on, and forty years of framework on top. Written for
someone who already knows what a vtable is: dispatch through objc_msgSend, the four hooks a failed
message falls through, the ownership contract ARC infers from method names, the class clusters and
isa-swizzling that make KVO and Foundation stranger than they look, toll-free bridging, and what still bites in
a mixed Swift codebase. Then every directive, runtime call and Foundation/AppKit/UIKit class worth knowing.
One binary, unchanged in shape since 2001, and still the only supported way to drive a Mac
application from a shell. Apple events, terminology dictionaries, both shipped languages, the TCC permission
gate, error codes and the traps — verified against a live machine.
The language for someone who does not need the tutorial: what the object model actually
guarantees, why @property cannot be shadowed but a method can, what NotImplemented
is for, and what the specialising adaptive interpreter does to your loop. Four cards on CPython itself —
object layout, the two-mechanism collector, bytecode, C3 — then 1,206 built-ins, dunders and library names,
every one checked against a running 3.14 by the build script.
Three shells on one sheet, because they are one language with three dialects and the question is
always whether a line survives the move to the other machine. Word splitting, startup-file order, 1- versus
0-indexed arrays, the pipeline subshell, glob qualifiers — and what #!/bin/sh really runs on
each system. Every builtin, expansion, test operator and glob, dotted with the shells it works in.
Written for someone who already knows what a proxy and an isolation level are. What
auto-configuration actually evaluates, the fifteen-deep property precedence, the defaults that are wrong in
production, what the proxy silently declines to do — and the Boot 4 module split that renamed half the
starters. Then 262 annotations indexed by what they do, colour-coded by where they come from.
The language as the compiler implements it, for someone who already knows a systems language.
Where ARC puts its retains; which of the four dispatch mechanisms a call gets, and why a method in a
protocol extension quietly picks the wrong one; what an existential box really is — any P is
40 bytes, and the sheet says which five words. Then structured concurrency and actor isolation. Every layout
number was measured by compiling it.
Vim as a small language for describing edits — twelve operators and forty motions give
you several hundred edits nobody taught you. Why undo is a tree and g- reaches branches
u cannot; why "0p pastes the yank after a delete clobbered it; what :g
and :normal compose into; why \v makes Vim regex ordinary. Installs on macOS, Windows
and Omarchy. Then 2,537 entries read straight out of the 9.1 runtime docs — 599 ex commands, 436
options, 591 functions, 119 autocommand events.
There is no plugin API: a plugin is a directory on 'runtimepath', and every
manager ever written puts directories there and runs git. What plugin/,
autoload/ and after/ mean for load order, what Vim 8 packages already do for
free, which manager and why, and the four commands that find the one misbehaving. Then 182 plugins, each
resolved against the GitHub API — canonical names after renames, stars in the tooltip, and a dot on the
five that are archived.
A native editor in Rust that draws its interface on the GPU, keeps every buffer as a CRDT
so collaboration is not bolted on, and sandboxes extensions as WebAssembly. The settings precedence ladder and
the two lsp blocks people confuse, how keymap context predicates resolve, multibuffers, tasks
and runnables, DAP scenarios, and the agent panel. Then 841 default key bindings read out of Zed’s own
keymaps and 282 settings from its reference.
An extension is a git repo with an extension.toml, plus optional Rust compiled to
WebAssembly: it cannot draw UI and cannot hang the editor. The manifest, a language end to end through all
nine tree-sitter query files, the zed_extension_api trait, themes as plain JSON, the capability list
the user controls, and the submodule PR that publishes it. Then the whole registry, fetched live
and ordered by installs.
Fusion for scale models that print in colour: the interface and every hotkey read out of the installed
build, sketching, solid modelling, components and parameters, the scale arithmetic from 1:16 to 1:600 and what a
0.4 mm nozzle can reproduce, the one-body-per-colour workflow for a Prusa CORE One with the eight-tool INDX,
export into PrusaSlicer, the Python API — and a 312-command index in toolbar order.
The hardware half of the pair with the Fusion sheet: the machine, not the CAD. A Bondtech
INDX moves one smart head and parks eight passive nozzles — induction-heated, no wires,
~12 s and 13 mg per change, so no purge tower. Siting, the setup order, every calibration, and the
build volume the docks cost you (248 × 205, not 250 × 220). Then the
whole LCD menu tree — which Prusa publishes without explanations — annotated, and all 138
error codes.
Apple bolts roughly a thousand of its own programs onto a BSD userland — keychain plumbing,
code-signing, kext management, Spotlight, launchd, firmware updaters for chips you didn't know were in the
machine. Almost none of it is documented. Every executable directory, in plain English.
Half textbook, half man page. Layers, addresses, routing, TCP, DNS, firewalls and TLS keyed to two free
university texts and to the command that shows each idea on a live Mac — then every networking tool Apple
ships, its flags and its traps, checked against the man pages of macOS 26. Why ifconfig forgets,
why dig lies, and where the SSID went.
DHH's omakase Linux: Arch and the Hyprland tiling compositor served as one finished, keyboard-driven
desktop. What it is and why, the hotkeys, the 284-command omarchy-* toolbelt, all 19 themes — and a verified
build of the whole thing running headless on a $4/month AWS server, every frame rendered by CPU.
The four-channel bench scope end to end: the dual-ADC acquisition chain, the probing technique
that decides whether any measurement is true, sampling theory, the full SCPI surface, the undocumented
on-disk binary format, and the traps. Opens with a labelled front-panel diagram.
Every pin, every bus, and the commands that drive them — pin multiplexing read out of pinctrl's own RP1
function table, the rest from the official documentation source. Written for a 2 GB board running Pi OS: blank
SD card to a headless machine you never plug a monitor into.
Everything on the board, on the pins and in the language. Pin multiplexing taken from the Renesas
core's own variant.cpp and pinmux.inc, net names read out of the ABX00087 schematic — so the tables
say what the silicon actually does.
Twelve boards, five models, three silicon families — ESP32, C3 and S3 — on one sheet. The
toolchain, Wi-Fi, OTA, NVS, filesystem, sleep and FreeRTOS layers are common to all of them and written once;
everything that is not portable is collected into a single matrix, so a sketch can be checked before it
is moved between boards.
The 2G/8G board end to end: the Allwinner H6 and the four chips around it, the 26-pin header with
both sets of GPIO numbers the tooling uses, every bus, and the driver traps — the Wi-Fi module is a
Unisoc part with no mainline driver, and the Ethernet PHY needs kernel 6.3.
02 · Lessons 6 lessonsRead start to finish. Each ships the files it describes.
A numbered, no-fluff guide to the skill that decides whether an agent is useful: maintaining its state —
a plain-markdown wiki it can read, plus what it remembers globally and per folder. Nine steps to build it on Windows 11 and wire it to Copilot, the seven-minute daily habit, then
global memory, a laptop kitted out with pandoc, rg and friends, live data over PowerShell
CLIs and MCP servers, and cloning twelve repos to map a whole ecosystem. Ends with the payoff — troubleshooting,
finding that old technical email, and an annual review written from evidence.
The same state-keeping method, wired to xAI's Grok Build: grok inspect to prove it found your
AGENTS.md, a read-only plan mode for surveying without touching, /mcps and /context
for live data and its cost, MEMORY.md you can open and edit, and the quiet fact that the kernel sandbox
does not exist on native Windows. Kit the laptop out, map a twelve-repo ecosystem, then troubleshooting, recall and
the annual review — all in numbered steps.
How the people who built the tool actually use it, and why most tutorials are a year behind. Verification
is worth 2–3× on output quality and almost nobody sets it up; context is the real budget; a correction fixes one
turn but a rule fixes every future run. Ends with the harness ladder — worktrees, subagents, workflows, agent teams —
and a section on using it for electronics, CAD and 3D printing, where the trick is finding the command that
returns pass or fail.
Not the autocomplete product. Copilot is now five surfaces reading one configuration layer — editor,
CLI, cloud agent, desktop app, SDK — so a line in AGENTS.md improves all of them at once, including the
reviewer on your colleagues' PRs. Verification in four rungs, from the brief to a read-only reviewer agent;
context as the budget; then the ladder from worktrees through /fleet and /delegate to the
app and mission control. Windows and PowerShell throughout.
xAI's agent is built to be bounded rather than trusted, and the method follows: sandbox first, then
loosen approvals; a reviewer role at read-only capability instead of a polite request; a plan mode that
genuinely cannot write. Then verification, context and the 200k pricing cliff, and the ladder from subagents
on worktrees to workflows that run hundreds of agents. Windows and PowerShell throughout — including the quiet fact
that the kernel sandbox needs WSL.
A fourth agent, from a Chinese lab, at a fifth of the price — and two things it does differently: goals
that say what must become true and are checked after every turn, and swarms for work that comes in items.
Hooks fail open here, so the hard guarantees go in deny rules and read-only tool lists; a cheap model pool takes the
reading stages. Opens with the question everyone asks first — where does the code go — and the answer that the
weights are separable from the company.
Built for paper as well as screen. Every sheet reflows to a multi-column landscape layout with a light
palette when printed — ⌘P gives you a bench reference rather than a wall of dark ink. On screen,
press / to jump to the filter box, which narrows every card, table row and definition on the page
as you type; Esc clears it.