---
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 |