ubergeek study guide

title: ubergeek study guide — progress tracker

ubergeek study guide

Master progress tracker and study plan. Single source of truth.

Legend: - [ ] Module Name — not started - [ ] wip Module Name — in progress - [x] Module Name — complete (linked) - skip — skippable for fast-track learners

Study Path

Phases are sequential but topics within a phase can be studied in parallel. Prerequisites are noted — you can jump ahead if you already know the prereqs.

Phase	Focus	Topics	Prereqs
1	Toolkit & Literacy	Command Line, Git, Technical Writing, Programming Fundamentals, C, Python, Bash, Math	None
2	Core Theory	Computer Science, Electronics, Make & Dev Automation	Phase 1
3	Systems & Design	Operating Systems, PCB Design, Web Tech, Project Management	Phase 2
4	Security & Infra	Cyber Security, Ansible, Automation	Phases 2-3
5	Embedded World	Embedded Systems, PCB Prototyping, Digital Fabrication	Phases 2-3
6	Deep Systems	Kernel Development, Embedded OS/RTOS, IoT	Phases 3-5
7	Intelligence & Integration	Computer Vision/Edge AI, Robotics, Rust, C++, Advanced Languages	Phases 5-6
--	Side Quest (anytime)	Global Geek Culture	None

Fast-track: If you have prior knowledge, check the prereqs list in each topic and skip what you know. Modules marked skip are optional/enrichment.

Phase 1 — Toolkit & Literacy

1.1 Linux Command Line Tools

path: linux-command-line/

Prereqs: None

[ ] Shell Basics — navigation, file ops, permissions, pipes, redirection, man pages
[ ] File Management — find, locate, tar, rsync, ln, file, stat, du, df
[ ] Text Processing — grep, sed, awk, cut, sort, uniq, tr, wc, jq, yq
[ ] Process Management — ps, top/htop, kill, nice, nohup, jobs, bg/fg, screen/tmux
[ ] Networking — ssh, curl, wget, netstat/ss, ip, dig, nmap, nc, scp/sftp
[ ] System Administration — systemctl, journalctl, cron, users/groups, disk mgmt, mount
[ ] Advanced Shell — parameter expansion, process substitution, subshells, traps, here-docs
[ ] Power Tools — fzf, ripgrep, fd, bat, eza, delta, zoxide, direnv
[ ] skip Customization — shell config, aliases, functions, prompt, dotfiles management
[ ] Exercises & Projects — system monitor, backup script, log analyzer, file organizer

1.2 Git

path: git/

Prereqs: Command Line basics

[ ] Fundamentals — init, add, commit, status, log, diff, .gitignore
[ ] Branching & Merging — branches, merge, fast-forward, merge conflicts
[ ] Remote Collaboration — remotes, push, pull, fetch, clone, PRs, patches (email workflow)
[ ] Advanced Operations — rebase, cherry-pick, bisect, reflog, stash, worktrees
[ ] Internals — objects (blob/tree/commit/tag), refs, packfiles, how Git works
[ ] Workflows & Strategies — feature branches, Git Flow, trunk-based, monorepo, submodules
[ ] Hooks & Automation — pre-commit, commit-msg, CI integration, custom hooks
[ ] skip Sourcehut-Specific — sr.ht workflows, mailing list patches, builds.sr.ht
[ ] Exercises & Projects — contribute a patch, manage a multi-branch project, write custom hooks

1.3 Technical Writing & Research Methodologies

path: technical-writing/

Prereqs: None

[ ] Writing Fundamentals — clarity, structure, audience analysis, active voice, style guides
[ ] Technical Documentation — API docs, user guides, READMEs, changelogs, man pages
[ ] Research Methodology — literature review, hypothesis, experimental design, data collection
[ ] Data Presentation — tables, charts, statistical visualization, LaTeX/typst basics
[ ] skip Academic Writing — papers, citations, abstracts, peer review process
[ ] Documentation Tools — Markdown, AsciiDoc, Sphinx, Doxygen, mdBook
[ ] Exercises & Projects — write a project README, document an API, create a lab report

1.4 Programming Fundamentals

path: programming/fundamentals/

Prereqs: Command Line basics

[ ] Core Concepts — variables, types, expressions, control flow (all languages compared)
[ ] Functions & Modularity — functions, scope, recursion, modules/packages
[ ] Data Structures (language-level) — arrays, strings, hash maps, structs/classes
[ ] I/O & File Handling — stdin/stdout, file read/write, serialization (JSON, TOML, CSV)
[ ] Error Handling — exceptions, return codes, Result/Option types (cross-language comparison)
[ ] Memory Models — stack vs heap, value vs reference, ownership overview
[ ] Build & Run — compilers, interpreters, REPLs, build systems, package managers
[ ] Testing Basics — unit tests, assertions, test frameworks per language
[ ] Exercises & Projects — CLI calculator, file processor, multi-language Rosetta Stone set

1.5 C

path: programming/c/

Prereqs: Programming Fundamentals

[ ] C Basics — syntax, types, printf/scanf, compilation with gcc/clang
[ ] Pointers & Memory — pointer arithmetic, malloc/free, arrays vs pointers, void pointers
[ ] Strings & Arrays — C strings, buffer safety, multi-dimensional arrays
[ ] Structs & Unions — struct layout, padding/alignment, bit fields, tagged unions
[ ] Preprocessor — macros, conditional compilation, include guards, X-macros
[ ] Standard Library — stdio, stdlib, string.h, math.h, time.h, errno
[ ] File I/O & System Calls — fopen/fread, open/read/write, mmap, ioctl
[ ] Build Systems — Makefiles for C, static/shared libraries, linking, pkg-config
[ ] Debugging & Profiling — gdb, valgrind, sanitizers (ASan/UBSan), perf
[ ] Advanced C — function pointers, callbacks, opaque types, C11/C17/C23 features
[ ] Exercises & Projects — memory allocator, linked list library, simple shell, file parser

1.6 Python

path: programming/python/

Prereqs: Programming Fundamentals

[ ] Python Basics — syntax, types, REPL, scripts, pip, virtual environments (venv, uv)
[ ] Data Structures — lists, tuples, dicts, sets, comprehensions, slicing, unpacking
[ ] Functions & Modules — def, args/*kwargs, lambda, imports, packages, __name__
[ ] OOP — classes, inheritance, dunder methods, properties, dataclasses, protocols
[ ] Error Handling — exceptions, try/except/finally, custom exceptions, context managers
[ ] File I/O & Data — file ops, pathlib, JSON, CSV, TOML, regex, struct/binary
[ ] Standard Library — os, sys, subprocess, collections, itertools, functools, logging, argparse
[ ] Testing — pytest, unittest, mocking, fixtures, parametrize, coverage
[ ] Scientific Stack Intro — NumPy basics, Matplotlib, pandas intro, Jupyter notebooks
[ ] Exercises & Projects — CLI tool, web scraper, data pipeline, test suite for a library

1.7 Bash Scripting

path: programming/bash/

Prereqs: Command Line Tools

[ ] Script Basics — shebang, variables, quoting, exit codes, set options (-euo pipefail)
[ ] Control Flow — if/elif/else, case, for, while, until, select
[ ] Functions — definition, local variables, return values, passing arguments
[ ] Text Processing in Scripts — grep/sed/awk integration, regex, here-docs/here-strings
[ ] Process & Job Control — subshells, command substitution, pipe chains, xargs, parallel
[ ] Advanced Patterns — signal handling (trap), getopts, associative arrays, nameref
[ ] Script Packaging — argument parsing, help messages, config files, logging, color output
[ ] Exercises & Projects — deployment script, system health checker, interactive menu tool

1.8 Mathematics Foundations

path: mathematics/

Prereqs: None (high school math assumed)

[ ] Logic & Proofs — propositional logic, predicate logic, proof techniques, set theory
[ ] Number Systems — integers, rationals, reals, complex numbers, modular arithmetic
[ ] Linear Algebra — vectors, matrices, systems of equations, determinants, eigenvalues
[ ] Calculus I — limits, derivatives, integrals, fundamental theorem
[ ] Calculus II — techniques of integration, sequences, series, Taylor/Maclaurin
[ ] Multivariable Calculus — partial derivatives, gradients, multiple integrals, vector fields
[ ] Differential Equations — first/second order ODEs, Laplace transforms, systems of ODEs
[ ] Probability & Statistics — combinatorics, probability theory, distributions, inference, Bayes
[ ] Discrete Mathematics — graph theory, combinatorics, recurrences, number theory basics
[ ] skip Numerical Methods — root finding, interpolation, numerical integration, optimization
[ ] skip Transform Methods — Fourier series/transform, Z-transform, DFT/FFT
[ ] Exercises & Projects — problem sets per module, computational exercises (Python/Julia)

Phase 2 — Core Theory

2.1 Computer Science

path: computer-science/

Prereqs: Programming Fundamentals, Math (discrete math, logic)

[ ] Data Structures — arrays, linked lists, stacks, queues, trees, heaps, graphs, hash tables
[ ] Algorithms — sorting, searching, graph algorithms (BFS/DFS/Dijkstra), recursion
[ ] Algorithm Design — divide & conquer, dynamic programming, greedy, backtracking
[ ] Complexity Theory — Big-O/Omega/Theta, amortized analysis, P vs NP, reductions
[ ] Computer Architecture — CPU design, instruction sets, pipelining, caches, memory hierarchy
[ ] Networking — OSI model, TCP/IP, DNS, HTTP/HTTPS, sockets, routing
[ ] Databases — relational model, SQL, normalization, indexing, transactions, NoSQL overview
[ ] skip Compilers — lexing, parsing, ASTs, semantic analysis, code generation
[ ] skip Distributed Systems — CAP theorem, consensus, replication, consistency models
[ ] Exercises & Projects — implement core data structures (C + Python + Rust), solve algorithm sets

2.2 Electronics

path: electronics/

Prereqs: Math (calculus, linear algebra, complex numbers)

[ ] Circuit Fundamentals — voltage, current, resistance, power, Ohm's/Kirchhoff's laws
[ ] DC Circuit Analysis — node/mesh analysis, Thevenin/Norton, superposition
[ ] AC Circuits — phasors, impedance, resonance, frequency response, Bode plots
[ ] Passive Components — resistors, capacitors, inductors, transformers, practical specs
[ ] Diodes & Rectifiers — PN junction, diode types, rectifier circuits, voltage regulators
[ ] Transistors (BJT) — operation, biasing, small-signal models, amplifier configurations
[ ] Transistors (MOSFET) — operation, biasing, CMOS logic, switching applications
[ ] Op-Amps — ideal model, inverting/non-inverting, integrator/differentiator, active filters
[ ] Digital Electronics — logic gates, Boolean algebra, combinational circuits, sequential (flip-flops, counters)
[ ] Sensors & Measurement — common sensors (temp, light, force, IMU), signal conditioning, ADC/DAC
[ ] Power Electronics — linear regulators, switching converters (buck/boost), battery charging
[ ] skip RF Basics — transmission lines, impedance matching, modulation, antenna fundamentals
[ ] Exercises & Projects — voltage divider lab, amplifier design, logic circuit build, sensor interface

2.3 Make & Dev Automation

path: make-and-automation/

Prereqs: Command Line, Git, Programming (C or any compiled language)

[ ] Make Basics — targets, prerequisites, recipes, variables, automatic variables, phony targets
[ ] Advanced Make — pattern rules, functions, conditional directives, auto-dependencies, recursive vs non-recursive
[ ] CMake — CMakeLists.txt, targets, find_package, generator expressions, modern CMake idioms
[ ] skip Meson — build definitions, dependencies, cross-compilation, wraps
[ ] Task Runners — Justfile, Taskfile, npm scripts, Python invoke, cargo-make
[ ] Dev Containers — Dockerfiles for dev, devcontainer spec, reproducible environments
[ ] skip Documentation Generation — Doxygen, Sphinx autodoc, mdBook, man page generation
[ ] Exercises & Projects — multi-target C Makefile, CMake project with libraries, polyglot build system

Phase 3 — Systems & Design

3.1 Operating Systems

path: operating-systems/

Prereqs: CS (architecture, data structures), C, Math (basic)

[ ] Introduction — OS role, history, types, system calls, kernel vs userspace
[ ] Process Management — processes, threads, context switching, scheduling algorithms
[ ] Synchronization — race conditions, mutexes, semaphores, deadlocks, condition variables
[ ] Memory Management — virtual memory, paging, segmentation, page replacement, TLB
[ ] File Systems — VFS, inodes, ext4, FAT, journaling, directory structures
[ ] I/O & Devices — device drivers model, block vs character, DMA, interrupt handling
[ ] IPC — pipes, shared memory, message queues, signals, sockets
[ ] Networking in OS — socket API, TCP/IP stack, network drivers, netfilter
[ ] Security & Protection — access control, capabilities, namespaces, cgroups, sandboxing
[ ] skip Virtualization — hypervisors (type 1/2), containers, paravirtualization, KVM
[ ] Exercises & Projects — system call tracer, simple scheduler simulation, xv6 labs

3.2 PCB Design

path: pcb-design/

Prereqs: Electronics (all fundamentals)

[ ] Fundamentals — schematic capture workflow, EDA tools overview (KiCad focus), libraries
[ ] Component Selection — reading datasheets, footprints, sourcing, lifecycle management
[ ] Schematic Design — hierarchical sheets, power symbols, net labels, design review checklist
[ ] PCB Layout Basics — board outline, stackup, component placement strategy, routing basics
[ ] Routing — trace width, via types, differential pairs, length matching, copper pours
[ ] Power Distribution — PDN design, decoupling strategy, thermal management, power planes
[ ] Signal Integrity — impedance control, crosstalk, EMI/EMC basics, ground planes
[ ] skip High-Speed Design — controlled impedance, return paths, high-speed routing rules
[ ] Design for Manufacturing — DFM/DFA rules, panelization, assembly drawings, BOM management
[ ] Exercises & Projects — LED breakout board, sensor board (2-layer), power supply board (4-layer)

3.3 Web Technologies

path: web-technologies/

Prereqs: CS (networking, databases), Programming (Python or JS)

[ ] HTML & CSS — semantic HTML5, CSS layout (flexbox, grid), responsive design, accessibility
[ ] JavaScript — ES6+, DOM manipulation, events, async/await, modules, fetch API
[ ] Backend Fundamentals — HTTP protocol, REST API design, authentication/authorization
[ ] Server-Side Development — Python (Flask/FastAPI), Node.js (Express), API development
[ ] Databases for Web — SQL (PostgreSQL), ORM concepts, migrations, Redis caching
[ ] skip Frontend Frameworks — component architecture, state management, SPA vs MPA concepts
[ ] DevOps for Web — Docker, reverse proxies (nginx), TLS, CI/CD, deployment strategies
[ ] Security — XSS, CSRF, CSP, SQL injection prevention, CORS, HTTPS
[ ] Exercises & Projects — static site, REST API with database, full-stack CRUD app

3.4 Project Management

path: project-management/

Prereqs: Technical Writing

[ ] Fundamentals — project lifecycle, scope, stakeholders, constraints triangle
[ ] Methodologies — Agile, Scrum, Kanban, Waterfall, hybrid approaches
[ ] Planning — work breakdown structure, estimation, scheduling, Gantt charts, risk management
[ ] Execution & Monitoring — KPIs, burndown charts, stand-ups, retrospectives
[ ] Tools & Systems — issue trackers, Kanban boards, time tracking, documentation wikis
[ ] skip Team Dynamics — communication, conflict resolution, remote collaboration
[ ] Engineering-Specific — hardware project management, firmware release cycles, versioning
[ ] Exercises & Projects — plan a personal project end-to-end, set up a Kanban workflow

Phase 4 — Security & Infrastructure

4.1 Cyber Security

path: cyber-security/

Prereqs: CS (networking, OS concepts), Command Line, Programming

[ ] Fundamentals — CIA triad, threat modeling, attack surfaces, defense in depth
[ ] Network Security — firewalls, IDS/IPS, VPN, packet analysis, network scanning
[ ] System Hardening — access control, SELinux/AppArmor, audit logging, patching, CIS benchmarks
[ ] Cryptography — symmetric/asymmetric encryption, hashing, TLS/SSL, PKI, key management
[ ] Application Security — OWASP top 10, input validation, secure coding practices, code auditing
[ ] Embedded Security — secure boot, firmware encryption, hardware attacks, side-channel basics
[ ] skip Penetration Testing — methodology, recon, exploitation, post-exploitation, reporting
[ ] skip Incident Response — detection, containment, forensics, recovery, lessons learned
[ ] Exercises & Projects — harden a Linux server, set up TLS, CTF challenges, vulnerability assessment

4.2 Ansible

path: ansible/

Prereqs: Command Line (advanced), SSH, Linux administration

[ ] Introduction — IaC concepts, Ansible architecture, installation, configuration
[ ] Core Concepts — inventory, modules, ad-hoc commands, YAML syntax
[ ] Playbooks — plays, tasks, handlers, variables, facts, conditionals, loops
[ ] Roles & Organization — role structure, Galaxy, collections, reuse patterns, project layout
[ ] Advanced — Jinja2 templates, filters, lookups, custom modules, vault (secrets)
[ ] skip Cloud & Containers — cloud provisioning, Docker management, Kubernetes basics
[ ] Testing — Molecule, ansible-lint, CI integration, idempotency testing
[ ] Exercises & Projects — server setup playbook, multi-tier deployment, homelab automation

4.3 Automation

path: automation/

Prereqs: Command Line, Bash, Git, Make basics

[ ] Principles — DRY, idempotency, reproducibility, when to automate (ROI)
[ ] Shell Automation — cron, systemd timers, inotify/file watching, at
[ ] CI/CD — concepts, GitHub Actions, sourcehut builds, pipeline design, artifacts
[ ] Testing Automation — unit/integration/e2e strategies, fuzzing, property-based testing
[ ] Infrastructure Automation — Terraform concepts, Ansible integration, GitOps basics
[ ] skip Monitoring & Alerting — Prometheus, Grafana, alerting rules, log aggregation
[ ] Workflow Automation — pre-commit hooks, linters, formatters, changelog generation
[ ] Exercises & Projects — CI pipeline for a project, pre-commit setup, automated backup system

Phase 5 — Embedded World

5.1 Embedded Systems

path: embedded-systems/

Prereqs: Electronics, C, OS concepts

[ ] Introduction — embedded vs general-purpose, architectures (ARM Cortex-M, RISC-V, AVR), dev boards
[ ] Microcontroller Fundamentals — CPU architecture, memory map, registers, clock system, startup code
[ ] GPIO & Basic I/O — digital I/O, pull-ups/downs, debouncing, LED/button interfacing
[ ] Interrupts — interrupt vectors, ISRs, priority, NVIC (ARM), critical sections
[ ] Timers & PWM — timer modes, input capture, output compare, PWM generation, frequency measurement
[ ] Serial Communication — UART (theory + implementation), SPI, I2C, protocol debugging
[ ] ADC & DAC — conversion principles, sampling, resolution, DMA-driven ADC, signal conditioning
[ ] DMA — DMA controller, channels, circular mode, memory-to-peripheral, performance gains
[ ] Memory — flash programming, linker scripts, bootloader concepts, EEPROM, external memory
[ ] Low Power Design — sleep modes, wakeup sources, power budgets, current measurement
[ ] Communication Protocols — CAN bus, Modbus, 1-Wire, wireless overview (BLE, WiFi, LoRa)
[ ] HAL vs Bare-Metal — vendor HALs (STM32 HAL/LL), CMSIS, register-level programming
[ ] Debugging & Tools — JTAG/SWD, OpenOCD, GDB for embedded, logic analyzer, oscilloscope
[ ] Exercises & Projects — blinky to bare-metal, UART logger, SPI sensor driver, motor controller

5.2 PCB Prototyping

path: pcb-prototyping/

Prereqs: PCB Design, Electronics

[ ] Breadboarding & Perfboard — prototyping techniques, Manhattan style, wire wrapping
[ ] PCB Milling — desktop CNC (3018, Bantam), FlatCAM, isolation routing, drill files
[ ] Chemical Etching — toner transfer, UV photoresist, etchant chemistry, safety
[ ] Professional Fabrication — Gerber/drill generation, fab house selection (JLCPCB, PCBWay), ordering
[ ] Assembly — hand soldering (through-hole + SMD), reflow (hot plate, oven), stencils
[ ] Testing & Debugging — continuity testing, power-on sequence, functional testing, rework
[ ] skip Rapid Iteration — version control for hardware, ECOs, change management
[ ] Exercises & Projects — etch a simple board, order and assemble a PCB, full prototype cycle

5.3 Digital Fabrication

path: digital-fabrication/

Prereqs: Electronics basics, CAD basics

[ ] Overview — fab labs, maker culture, digital fabrication workflow
[ ] 3D Printing — FDM, SLA/DLP, materials, slicing (Cura/PrusaSlicer), design for 3D printing
[ ] Laser Cutting — materials, kerf compensation, design for laser, power/speed settings, safety
[ ] skip CNC Machining — milling basics, G-code, CAM (FreeCAD Path), materials, work-holding
[ ] CAD for Fabrication — FreeCAD, OpenSCAD, parametric design, export formats (STL, DXF, STEP)
[ ] Enclosure Design — designing for electronics, standoffs, cable routing, thermal considerations
[ ] skip Mold Making & Casting — silicone molds, resin casting, urethane, finishing
[ ] Exercises & Projects — 3D print an enclosure, laser-cut a panel, design a complete housing

Phase 6 — Deep Systems

6.1 Kernel Development

path: kernel-development/

Prereqs: OS, C (advanced), Computer Architecture

[ ] Introduction — kernel role, monolithic vs micro, Linux source tree navigation
[ ] Build & Boot — kernel configuration, cross-compiling, QEMU/VM testing, boot process
[ ] Kernel Modules — module structure, Makefiles, loading/unloading, module parameters, licensing
[ ] Character Devices — file_operations, major/minor numbers, ioctl, sysfs, procfs
[ ] Kernel Memory — kmalloc/kfree, vmalloc, slab allocator, page allocator, GFP flags
[ ] Concurrency — spinlocks, mutexes, RCU, atomic operations, per-CPU data, completion
[ ] Interrupts & Timers — top/bottom halves, tasklets, workqueues, hrtimers, softirqs
[ ] Device Model — platform devices, device tree, driver model, buses, probe/remove
[ ] skip Networking — net_device, socket buffers (skb), netfilter hooks, packet flow
[ ] skip File Systems — VFS interface, implementing a simple filesystem, block layer
[ ] Debugging — printk/dynamic debug, ftrace, kprobes, KGDB, crash dump analysis, KASAN
[ ] Exercises & Projects — hello-world module, char device driver, device tree overlay, simple driver

6.2 Embedded OS & RTOS

path: embedded-os/

Prereqs: Embedded Systems, OS, C

[ ] RTOS Concepts — real-time constraints, hard/soft RT, scheduling (rate monotonic, EDF), WCET
[ ] FreeRTOS — tasks, queues, semaphores/mutexes, timers, memory management, portability
[ ] Zephyr — architecture, devicetree, Kconfig, kernel primitives, networking stack, west tool
[ ] Embedded Linux — Buildroot, Yocto/OpenEmbedded, cross-toolchains, root filesystem, device tree
[ ] Bootloaders — U-Boot, MCUboot, boot stages, secure boot chain
[ ] Bare-Metal vs RTOS vs Linux — decision framework, resource constraints, trade-offs
[ ] Inter-Task Communication — message queues, event groups, mailboxes, shared memory, priority inversion
[ ] skip OTA Updates — firmware update strategies, A/B partitions, rollback, delta updates
[ ] Exercises & Projects — FreeRTOS multitask app, Zephyr sensor driver, Buildroot custom image

6.3 Internet of Things

path: iot/

Prereqs: Embedded Systems, Web Tech (backend), Networking

[ ] IoT Architecture — edge/fog/cloud, reference architectures, design patterns
[ ] Connectivity — WiFi, BLE, LoRa/LoRaWAN, Zigbee, Thread, protocol comparison
[ ] Messaging Protocols — MQTT (deep dive), CoAP, HTTP for IoT, WebSockets
[ ] IoT Platforms — Home Assistant, Node-RED, Thingsboard, AWS IoT Core overview
[ ] Data Pipeline — collection, time-series databases (InfluxDB), processing, dashboards (Grafana)
[ ] Edge Computing — local processing, gateway design, edge inference, offline operation
[ ] Security & Privacy — device identity, secure communication, firmware signing, threat landscape
[ ] skip Standards — Matter, Thread, OPC-UA, industrial IoT
[ ] Exercises & Projects — MQTT sensor network, LoRa node + gateway, home automation system

Phase 7 — Intelligence & Integration

7.1 Computer Vision & Edge AI

path: computer-vision/

Prereqs: Math (linear algebra, calculus, probability), Python, Embedded basics

[ ] Image Fundamentals — digital images, color spaces, histograms, geometric transforms
[ ] Image Processing — convolution, filtering, morphology, edge detection, thresholding
[ ] Feature Detection — corners (Harris, Shi-Tomasi), descriptors (SIFT/ORB), feature matching
[ ] Classical CV — template matching, object detection (Haar/HOG), tracking, optical flow
[ ] Deep Learning Foundations — neural networks, backprop, CNNs, training loop, PyTorch/TensorFlow
[ ] Object Detection & Segmentation — YOLO, SSD, U-Net, Mask R-CNN, transfer learning
[ ] Model Optimization — quantization, pruning, knowledge distillation, ONNX, TFLite
[ ] Edge Deployment — Coral TPU, Jetson, OpenMV, RPi, NPU/VPU, inference frameworks
[ ] skip Advanced Topics — 3D vision, depth estimation, visual SLAM, generative models
[ ] Exercises & Projects — OpenCV pipeline, train a classifier, deploy on edge device, visual inspection

7.2 Robotics

path: robotics/

Prereqs: Math (linear algebra, calculus, diff eq), Electronics, Embedded, Programming (C++/Python)

[ ] Foundations — robot types, coordinate frames, homogeneous transforms, DH convention
[ ] Kinematics — forward/inverse kinematics, Jacobian, velocity kinematics, workspace analysis
[ ] Dynamics — Newton-Euler, Lagrangian mechanics, torque computation, gravity compensation
[ ] Actuators & Sensors — DC/stepper/servo motors, encoders, IMUs, LIDAR, depth cameras
[ ] Control Systems — PID control, state-space, trajectory generation, motion profiles
[ ] Motion Planning — path planning (A*, RRT, PRM), obstacle avoidance, configuration space
[ ] skip SLAM & Localization — EKF/particle filter, lidar SLAM, visual SLAM, sensor fusion
[ ] ROS 2 — architecture, nodes, topics, services, actions, launch files, URDF, Gazebo
[ ] skip Mobile Robots — wheeled (differential, omnidirectional), legged basics, drone basics
[ ] Exercises & Projects — PID line follower, robotic arm control, ROS 2 navigation stack

7.3 Rust

path: programming/rust/

Prereqs: Programming Fundamentals, C (recommended)

[ ] Getting Started — cargo, crate structure, hello world, rustup, editions
[ ] Ownership & Borrowing — ownership rules, references, lifetimes, borrow checker
[ ] Type System — structs, enums, pattern matching, generics, traits, trait objects
[ ] Error Handling — Result, Option, ? operator, custom errors, anyhow/thiserror
[ ] Collections & Iterators — Vec, HashMap, iterator adaptors, closures, functional patterns
[ ] Concurrency — threads, channels, Arc/Mutex, Send/Sync, async/await, tokio basics
[ ] Unsafe & FFI — unsafe blocks, raw pointers, extern "C", bindgen, calling C from Rust
[ ] Ecosystem — serde, clap, reqwest, embedded Rust (no_std), testing, benchmarking
[ ] Exercises & Projects — CLI tool, concurrent web scraper, embedded Rust blinky, C FFI wrapper

7.4 C++

path: programming/cpp/

Prereqs: C, Programming Fundamentals

[ ] C++ Basics — classes, constructors/destructors, namespaces, references, streams
[ ] OOP — inheritance, polymorphism, virtual functions, abstract classes, RTTI
[ ] Templates — function/class templates, template specialization, variadic templates, SFINAE basics
[ ] STL — containers, iterators, algorithms, string, functional
[ ] Modern C++ (17/20/23) — auto, structured bindings, ranges, concepts, modules, coroutines overview
[ ] Memory Management — RAII, smart pointers (unique/shared/weak), move semantics, rule of 5
[ ] Concurrency — std::thread, mutex, condition_variable, atomic, futures, async
[ ] skip Advanced — type erasure, CRTP, policy-based design, compile-time computation
[ ] Exercises & Projects — matrix library, concurrent data structure, embedded C++ on MCU

7.5 Advanced Languages

path: programming/advanced-languages/

Prereqs: Programming Fundamentals, specific domain knowledge per language

[ ] Python Advanced — decorators, generators, metaclasses, asyncio, C extensions, type hints
[ ] Lua — tables, metatables, coroutines, embedding in C, LuaJIT FFI, game scripting
[ ] Julia — multiple dispatch, type system, macros, performance, scientific computing, GPU
[ ] R — data frames, tidyverse, ggplot2, statistical modeling, R Markdown
[ ] Cross-Language — FFI patterns, polyglot projects, language interop, choosing the right tool
[ ] Exercises & Projects — Python C extension, Lua-embedded app, Julia scientific notebook, R analysis

Side Quest — Anytime

S.1 Global Geek Culture

path: geek-culture/

Prereqs: None — read alongside any phase

[ ] Hacker Culture Origins — MIT AI Lab, Tech Model Railroad Club, PDP-1, hacker ethic, "Hackers" (Levy)
[ ] Phone Phreaking & Early Hacking — Captain Crunch, blue boxes, 2600 magazine, WarGames, Legion of Doom
[ ] The Jargon File & Hacker Lore — Jargon File, INTERCAL, RFC humor, koans, AI koans, quines, IOCCC
[ ] Text File Underground — textfiles.com, e-zines (Phrack, LoD/H Technical Journal), BBS culture, ANSI art
[ ] The Geek Code & .sig Culture — Geek Code blocks, ASCII art sigs, fortune files, Plan files, finger protocol
[ ] Usenet & Early Internet Culture — flame wars, FAQs, killfiles, alt.* hierarchy, trolling as art, Eternal September
[ ] Cryptography Wars & Cypherpunks — cypherpunk mailing list, PGP, Clipper chip, Zimmermann, remailers
[ ] Demoscene — demo groups, size coding (4k/64k intros), Amiga/Atari scene, Revision/Assembly parties, pouet.net
[ ] Open Source Movement — GNU Manifesto, FSF, Cathedral vs Bazaar, Linux, copyleft vs permissive, forking culture
[ ] Warez & Underground Scenes — warez groups, NFOs, cracktros, courier culture, The Scene
[ ] Internet Mysteries & Challenges — Cicada 3301, Webdriver Torso, Markovian Parallax Denigrate, crypto puzzles, ARGs
[ ] MUDs, MOOs & Virtual Worlds — text adventures, LambdaMOO, online community origins, digital identity
[ ] Hacker Conferences & Community — DEF CON, CCC, 2600 meetings, hackerspaces, CTF culture
[ ] Maker & Hardware Hacking — hackerspaces, CCC hardware, Arduino/RPi, OSHW, right to repair, modding
[ ] skip Cyberpunk & Sci-Fi Canon — Gibson, Stephenson, Dick, Doctorow, technology predictions
[ ] skip Global Perspectives — CCC vs DEF CON culture, Shenzhen, Global South tech, internet freedom

Summary

#	Topic	Modules	Status
1.1	Linux Command Line	10	Not started
1.2	Git	9	Not started
1.3	Technical Writing	7	Not started
1.4	Programming Fundamentals	9	Not started
1.5	C	11	Not started
1.6	Python	10	Not started
1.7	Bash Scripting	8	Not started
1.8	Mathematics	12	Not started
2.1	Computer Science	10	Not started
2.2	Electronics	13	Not started
2.3	Make & Dev Automation	8	Not started
3.1	Operating Systems	11	Not started
3.2	PCB Design	10	Not started
3.3	Web Technologies	9	Not started
3.4	Project Management	8	Not started
4.1	Cyber Security	9	Not started
4.2	Ansible	8	Not started
4.3	Automation	8	Not started
5.1	Embedded Systems	14	Not started
5.2	PCB Prototyping	8	Not started
5.3	Digital Fabrication	8	Not started
6.1	Kernel Development	12	Not started
6.2	Embedded OS & RTOS	9	Not started
6.3	IoT	9	Not started
7.1	Computer Vision & Edge AI	10	Not started
7.2	Robotics	10	Not started
7.3	Rust	9	Not started
7.4	C++	9	Not started
7.5	Advanced Languages	6	Not started
S.1	Geek Culture	16	Not started