path: root/PROGRESS.md

---
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](path/to/module/) — 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 |