Things that matter for mere mortals

Plain-language guides to the things programmers and makers actually use — written for people who want to understand the idea first, then the how. No jargon without an explanation. No "it's simple, just..." No CS degree required.

Every guide in this series is held to the same nine-point writing standard, and every code example is tested against the real thing before it ships.

The languages

• Python for Mere Mortals — make the computer do things. Ideas first, then code. (repo)
• C for Mere Mortals — understand what the computer is actually doing: pointers, memory, and why C assumes you meant what you wrote. (repo)
• Rust for Mere Mortals — memory safety without giving up control. The compiler catches the bug before your users do. (repo)
• Go for Mere Mortals — fast, simple, and deliberately small. Boring, readable code is the design goal. (repo)
• Node.js for Mere Mortals — JavaScript outside the browser: servers, CLIs, and tools, teaching the modern, sane subset. (repo)
• Bash for Mere Mortals — the shell behind most of the world's servers and automation glue, taught as the safe modern subset. (repo)
• PowerShell for Mere Mortals — Microsoft's automation shell, where commands pass objects, not text — Windows first, now cross-platform. (repo)

• Java for Mere Mortals — the JVM, your first program, types, methods, classes and objects, interfaces, exceptions, and collections. (repo)

• Regular Expressions for Mere Mortals — the tiny pattern language inside every language: matching, extracting, and replacing text. (repo)

• APIs for Mere Mortals — how programs talk to each other: HTTP, REST, JSON, authentication, and building your own. (repo)

• SQL for Mere Mortals — talk to databases: SELECT, JOINs, GROUP BY, and the data model behind nearly every app. (repo)

Version control and operations

• Linux for Mere Mortals — the operating system running most of the world's servers: the terminal, files, permissions, processes, and troubleshooting. (repo)

• Docker for Mere Mortals — containers explained plainly: images, Dockerfiles, volumes, networking, and Compose. (repo)

• Docker Compose for Mere Mortals — run your whole stack from one YAML file: services, networks, volumes, environment, healthchecks, and the everyday commands. (repo)

• Make for Mere Mortals — the 50-year-old build tool that still runs the world: targets, prerequisites, recipes, variables, pattern rules, and Make as a task runner. (repo)

• Networking for Mere Mortals — IP addresses, DNS, ports, WiFi, and home networks explained plainly. (repo)

• Home Networking for Mere Mortals — run your home LAN on purpose: routers, DHCP reservations, local DNS, reverse proxies, VLANs, and Wi-Fi that reaches the back room. (repo)

• Tailscale for Mere Mortals — reach your home machines securely from anywhere: tailnets, exit nodes, sharing, access controls, and the WireGuard underneath. (repo)

• Git for Mere Mortals — the daily git reference: the save-point mental model, the commands you'll actually use, branches, and a cookbook for undoing mistakes. (repo)

• GitHub Actions for Mere Mortals — CI/CD explained plainly: workflows, jobs, triggers, secrets, and deployments. (repo)
• GitOps for Mere Mortals — keep systems the way you want them by storing the description in git. Not just a Kubernetes thing. (repo)
• Backstage for Mere Mortals — the open-source developer portal that answers "who owns this service and where are its docs?" (repo)
• Cybersecurity for Mere Mortals — practical security for a home operator: threat models, passwords, 2FA, phishing, backups, SSH hardening, and what to do if you've been hacked. No fear-mongering. (repo)
• SSH for Mere Mortals — the encrypted pipe behind everything: keys, the config file, jump hosts, tunnels, moving files, and troubleshooting. (repo)
• Proxmox for Mere Mortals — run many machines inside one machine: VMs, containers, storage, snapshots, backups, and the web UI. (repo)

AI at home

• AI for Mere Mortals — understand LLMs and run them on your own computers: Ollama, Open WebUI, choosing models, and RAG. No math degree required. (repo)
• Local AI at Home for Mere Mortals — the hands-on home-operator companion: hardware sizing math, quantization, the Ollama API, multi-machine setups, and troubleshooting. (repo)

Making things

• 3D Printing for Mere Mortals — how 3D printing works, choosing a printer, filament, slicing, and multicolor printing. (repo)

• CAD for Mere Mortals — design your own parts instead of downloading them: sketches, constraints, tolerances, OpenSCAD, and a complete printed bracket. (repo)

• Arduino for Mere Mortals — microcontrollers explained plainly: sketches, pins, sensors, and real circuits. (repo)

• Soldering & Basic Electronics for Mere Mortals — voltage, current, components, and joining metal with heat. (repo)

• Ham Radio for Mere Mortals — get licensed, get on the air: the Technician exam, bands and modes, repeaters, your first radio, antennas, and making your first contact. (repo)

• tmux for Mere Mortals — terminal sessions that survive disconnects: sessions, windows, panes, the prefix key, a sane config, and scripting whole layouts. (repo)

• Raspberry Pi for Mere Mortals — every current model compared, which Pi fits which job, headless setup, and first projects. (repo)

• LLM Evaluation for Mere Mortals — which model is actually better? Benchmarks, pairwise duels, LLM-as-judge, metrics that matter, and running evals yourself. (repo)

• Agile for Mere Mortals — the manifesto, Scrum, Kanban, user stories, estimation, how agile goes wrong, and what to keep on a tiny team. (repo)

• Argo CD for Mere Mortals — GitOps delivery for Kubernetes: your first app, sync and drift, app-of-apps, projects and RBAC. (repo)