diff options
Diffstat (limited to 'PROGRESS.md')
| -rw-r--r-- | PROGRESS.md | 542 |
1 files changed, 542 insertions, 0 deletions
diff --git a/PROGRESS.md b/PROGRESS.md new file mode 100644 index 0000000..abb0cfb --- /dev/null +++ b/PROGRESS.md @@ -0,0 +1,542 @@ +--- +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 | |