master field manual · current focus, technology tracks, and future runway

THE COMPLETE
FIELD MANUAL

Home base for current learning and project work. Start with Current Focus, then use the technology tracks for the questions, projects, and references behind each phase. Milestones and exercises live in the Practice Guide; dated plans live in the Momentum Schedule.

Current Focus · Your next steps

Six starting points for your current engineering and applied Python work. These are learning and project tracks, not automatically tracked progress.

Primary learning · Graphics

C++20 & Forward Rendering

Build the Fedora/OpenGL 4.3+ foundation, then work through matrices, shaders, lighting, and the rendering pipeline. Keep the core renderer implementation as deliberate practice.

Open Renderer Project Structure
Active project · Uptime Tracker

2–3 Week Monitoring Build

30–40 focused hours across endpoint configuration in staff/API/D1, minute-level probing and durable history, then timezone-aware daily summaries published to KV for a public status and history view.

Open Uptime Schedule
Supporting study · Mathematics

Linear Algebra & Numerical Thinking

Prioritize vectors, matrices, transformations, and numerical behavior that connect directly to your renderer and future GPU simulations.

Open Math Guides
Ongoing practice · Engineering

C++ Fundamentals

Strengthen RAII, copy/move semantics, STL fluency, debugging, and resource ownership. Practice transferable C++ decisions and delegate familiar scaffolding.

Open Practice Guide
Applied Python · Data, charts & small pipelines

Data Analysis

Explore Steam and NBA/NFL/NCAA data: clean and combine small CSV/JSON datasets, investigate trends, and tell a clear story with charts. Make your workflow rerunnable without building a heavyweight data platform.

Prepare dataVisualize patternsRepeat the workflow
Explore Data Analysis Exercises
Applied Python · Data pipelines & prediction

Machine Learning

Build reproducible data preparation and feature pipelines, then evaluate simple models for game reception or sports outcomes against strong baselines. Guard against leakage and use time-aware validation.

Explore Machine Learning Exercises
Technology tracks

Ordered by current priority. Each phase lists the questions you should be able to answer, the projects that use it, and its references. Milestones and exercises live in the Practice Guide; dated plans live in the Momentum Schedule.

Graphics + Systems
Primary learning: C++20 and OpenGL first, Lua as the scripting layer, Godot as a shader playground
The C++/OpenGL forward renderer is the primary learning track. C++ supplies ownership, lifetimes, and build discipline; OpenGL 4.3+ and GLSL make the GPU pipeline explicit; Lua adds an embedded scripting layer once the C++ boundaries are stable. Godot is a playground for fast shader and rendering experiments — prototype an idea there, then rebuild it deliberately in GLSL.
Technology Phase

C++

Start here · foundation under the renderer
Depth · Medium
Milestones · 14

The canonical list, each with a paired exercise and follow-ups.

Practice Guide · C++ →
Projects that use it
Audio visualizerTerrain rendererSmall renderer frameworkData-oriented particle benchmark
Questions you should answer · 12
  • What is a stack frame? Draw what the stack looks like when three functions are called in sequence.
  • What is a dangling pointer? Write an example that creates one and explain why it's undefined behavior.
  • Walk through RAII. Write a file-handle wrapper that cannot leak, even if an exception is thrown.
  • When does the compiler-generated copy constructor break, and what is the rule of 3 telling you to do?
  • What does std::move actually do at the memory level? What is left in the moved-from object?
  • What is the vtable, when is it created, and what does a virtual function call actually cost?
  • Explain the difference between unique_ptr and shared_ptr. When is shared_ptr the wrong choice?
  • What is a data race? Write a minimal example and then fix it two different ways.
  • What does CMake actually do? Explain the difference between a translation unit and a header file.
  • What is undefined behavior? Give three concrete examples and explain why the compiler can exploit them.
  • Walk through a draw call: starting from a vertex array in C++, what happens before a pixel is written?
  • What is const-correctness and why does marking a method const matter beyond documentation?
Technology Phase

OpenGL 4.3+ & GLSL

Primary learning · alongside C++
Depth · Deep
Milestones

Sequenced as the eight-week Forward Renderer track; architecture, ownership, and build setup live in Project Structure.

Momentum Schedule · Renderer →Renderer Project Structure →
Projects that use it
Forward renderer referenceLighting and material labCompute particle simulationWeather Simulator renderer
Questions you should answer · 08
  • What does the GLFW context own, and why must GLAD load function pointers only after that context is current?
  • Walk a vertex from a VBO through the vertex shader, clipping, perspective division, rasterization, and the fragment shader to the framebuffer.
  • What state does a VAO record, and what does it not record?
  • Why are normals transformed by the inverse-transpose of the model matrix, and when can you skip it?
  • How do uniforms, uniform buffer objects, and shader storage buffers differ in size limits, access, and intended use?
  • What must be configured for depth testing to work, and what does the frame look like when one piece is missing?
  • Your window is black. Walk through how you localize the fault: context, shader logs, KHR_debug output, and a RenderDoc capture.
  • When is a compute shader the right tool in OpenGL 4.3, and why is glMemoryBarrier needed before reading its results?
Technology Phase

Lua Embedding

Add after C++ boundaries are stable
Depth · Basic–Medium
Milestones · 09

The canonical list, each with a paired exercise and follow-ups.

Practice Guide · Lua →
Projects that use it
Scriptable particle presetsLua-driven scene runtimeModdable simulation sandboxEvent-driven game prototype
Questions you should answer · 08
  • How does a single table represent both an array and a dictionary? What does that imply about iteration?
  • What is a closure in Lua and what does it capture? Write one that maintains state across calls.
  • Explain how __index and metatables give you inheritance. What happens when a key isn't found in a table?
  • What is a coroutine and how does it differ from a thread? When would you use one in a game context?
  • Walk through the Lua C API stack. How do you call a C function from Lua and pass two integers to it?
  • How do you call a Lua function from C++? Walk through the steps from loading the file to reading the return value.
  • Why is Lua a better fit for embedded scripting than Python or JavaScript in a C++ host?
  • What does luaL_newstate do and what happens if you don't open the standard libraries?
Technology Phase

Godot + GDShader

Playground · fast shader and rendering experiments
Depth · Playground
Milestones · 12

The canonical list, each with a paired exercise and follow-ups.

Practice Guide · Godot →
Projects that use it
Shader galleryGPU particle toy/toolPost-processing stackProcedural planet renderer
Questions you should answer · 10
  • What runs per-vertex vs per-fragment, and why does that distinction matter for performance?
  • Walk through what UV coordinates represent and why they go from 0 to 1.
  • Explain the MVP matrix — what does each transform actually do to a vertex?
  • How does a uniform get from a GDScript into a running shader?
  • Walk through implementing Lambertian diffuse from scratch. What inputs do you need?
  • What is a compute shader's workgroup and how does it map to GPU threads?
  • How does a SubViewport let you build a multi-pass rendering pipeline?
  • What is a storage buffer in a compute shader and how is it different from a uniform?
  • Name three things Godot handles for you that you would have to manage manually in Vulkan.
  • If your post-processing pass looks wrong, what's your debugging process?
References
LearnCpp Language reference

Use when ownership, const correctness, object lifetime, templates, undefined behavior, or a standard-library detail needs a deeper explanation.

CMake Documentation Build-system reference

Targets, include paths, linking, visibility, presets, toolchain files, subdirectories, and the commands used to structure C++ builds.

vcpkg Documentation Package-manager reference

Manifest mode, dependency restoration, triplets, toolchain integration, package features, and reproducible project setup.

LearnOpenGL Tutorial reference

Context setup, buffers and VAOs, shaders, transforms, cameras, lighting, and debugging, written against the modern core profile.

Per-function behavior, parameters, and errors. Check each page’s version table: this project targets 4.3, so avoid 4.5-only entry points such as DSA.

GLSL 4.60 Specification Language specification

The authoritative source for qualifiers, interface blocks, built-ins, layout rules, and compute-shader semantics when a tutorial is ambiguous.

RenderDoc GPU debugger

Frame capture and inspection of draw calls, pipeline state, buffers, and textures — the first tool to reach for on a black or wrong frame.

Lua 5.4 Reference Manual Language manual

Tables, functions, metatables, coroutines, modules, the C API stack, protected calls, and embedding behavior.

Official Godot Docs Engine reference

Nodes, resources, 3D rendering, ShaderMaterial, SubViewport, RenderingDevice, storage buffers, and compute workflows.

The Book of Shaders Interactive guide

A structured path through color math, coordinates, patterns, noise, animation, and learning to think in shader space.

Inigo Quilez Articles Technique library

Procedural graphics, signed-distance fields, raymarching, noise, lighting, and compact mathematical techniques to revisit as needed.

Uptime Checker Platform
The active product: edge runtime, probe history, daily summaries, and KV-published status
The uptime checker combines TypeScript with a constrained runtime and two different storage models. Its real curriculum is platform judgment: scheduled execution, bounded fan-out, durable history, current snapshots, timezone-aware daily summaries, and tests that run in the production-like runtime. Incident management and notifications are optional follow-up work, not part of the three core objectives (see the Momentum Schedule).
Technology Phase

Hono + Hono JSX

Application surface
Depth · Basic–Medium
Milestones · 07

The canonical list, each with a paired exercise and follow-ups.

Practice Guide · Hono →
Skills to build
  • Route JSON, HTML, and form requests cleanly
  • Use context, typed bindings, middleware, and centralized errors
  • Understand server-rendered JSX and opt into client behavior deliberately
  • Keep handlers thin by extracting checks, repositories, and policies
  • Render useful empty, stale, degraded, and failure states
Projects that use it
Service management UIPublic status pageDaily history viewOperator dashboard
Questions you should answer
  • What does Hono add, and what remains plain Web Platform behavior?
  • When does a page need client-side JavaScript?
  • Where should validation happen?
  • What information belongs in an operator error versus a public error?
Technology Phase

Cloudflare Workers

Runtime and scheduling
Depth · Medium–Deep
Skills to build
  • Understand request isolation and the lack of reliable process-local state
  • Use scheduled handlers and waitUntil correctly
  • Design bounded-concurrency polling within subrequest limits
  • Separate CPU work from time spent awaiting network requests
  • Use Wrangler environments, bindings, secrets, and local cron testing
  • Plan for partial failure and repeatable invocations
Sequenced in the Uptime schedule →
Projects that use it
Scheduled polling engineBatch/fan-out coordinatorMaintenance workerFailure-summary pipeline
Questions you should answer
  • Why is a module-level cache unreliable as durable state?
  • What work belongs in waitUntil?
  • How do limits shape the number of services polled per invocation?
  • What makes a scheduled poll cycle safe to retry?
Technology Phase

D1 + Workers KV

History and current state
Depth · Medium
Skills to build
  • Model instance health configuration, minute-level probe history, and daily summaries as separate relational concepts
  • Use migrations, prepared statements, indexes, and retention cleanup
  • Store current public status as a versioned KV snapshot
  • Document stale and missing-snapshot behavior
  • Keep summary aggregation (timezone and idempotency rules) separate from persistence mechanics
  • Rebuild the current snapshot from durable data when necessary
Sequenced in the Uptime schedule →
Projects that use it
Daily summary aggregatorSnapshot publisherHistory explorerRetention and recovery job
Questions you should answer
  • Why is D1 appropriate for history while KV fits current snapshots?
  • What query finds the latest result per service efficiently?
  • How do eventual-consistency assumptions appear in the UI?
  • What data is sufficient to rebuild public state?
Technology Phase

Vitest in the Workers Runtime

Verification and hardening
Depth · Medium
Skills to build
  • Run tests with the Workers-specific Vitest pool
  • Mock outbound fetch without hiding important behavior
  • Seed D1 and KV bindings per test
  • Test scheduled handlers independently from HTTP routes
  • Cover timeouts, partial failure, stale snapshots, and local-day boundaries (including DST)
  • Use deterministic clocks and IDs where behavior depends on time
Sequenced in the Uptime schedule →
Projects that use it
Poll-cycle integration suiteDaily-summary boundary testsSnapshot contract testsDeployment smoke checks
Questions you should answer
  • Which tests require the actual Workers runtime?
  • What should be mocked at the network boundary?
  • How do you prove one failed service does not cancel a poll cycle?
  • What makes a test deterministic?
References
Hono Official Docs Framework reference

Routing, context, middleware, typed bindings, validation, JSX, and error handling. Small enough to read narrowly as the application grows.

Cloudflare Workers Docs Runtime reference

Execution model, scheduled handlers, waitUntil, bindings, environments, secrets, platform limits, and deployment behavior.

Cloudflare D1 Docs Database reference

Migrations, prepared statements, indexes, query behavior, local development, backups, and relational storage limits.

Workers KV Docs Storage reference

Eventually consistent reads, namespace bindings, expiration, metadata, limits, and the tradeoffs behind current-status snapshots.

Runtime-faithful tests for bindings, scheduled handlers, D1, KV, service bindings, and request behavior inside Workers.

Web Application Pair
Typed interfaces, APIs, data products, and visualization surfaces
TypeScript and Vue provide the user-facing layer and fast visual feedback. Go provides a separate backend track for conventional services, APIs, ingestion, and concurrency. They pair naturally, but each remains useful independently.
Technology Phase

TypeScript + Vue

Frontend and visualization layer
Depth · Medium
Milestones · 12

The canonical list, each with a paired exercise and follow-ups.

Practice Guide · TypeScript + Vue →
Projects that use it
Steam Library UnwrappedSocial graph explorerAnalytics dashboardTyped visualization component library
Questions you should answer · 12
  • What does TypeScript actually give you that JavaScript doesn't? Be specific — name three things the compiler catches.
  • What is the difference between type and interface in TypeScript? When does the distinction matter?
  • Explain union types. Write a function that takes a string | number and handles both branches.
  • What is type narrowing? How does TypeScript know which branch of a union you're in?
  • Walk through async/await in terms of the event loop. What does await actually do to execution?
  • You get a JSON response from a Go API. Walk through how you type it and consume it safely in a Vue component.
  • What is a generic? Write a generic identity function and explain what the type parameter is doing.
  • What is the difference between undefined and null in TypeScript and how do you handle both?
  • Explain Vue's reactivity system. How does Vue know when to re-render a component?
  • What is the difference between watch and watchEffect in Vue? When do you reach for each?
  • Walk through the three states every data-fetching component needs and how you model them in state.
  • What does Vite actually do? What problem does a bundler solve?
Technology Phase

Go

Backend and data-processing layer
Depth · Medium
Milestones · 10

The canonical list, each with a paired exercise and follow-ups.

Practice Guide · Go →
Projects that use it
Steam data aggregatorREST API with databaseData pipeline and dashboard backendCLI analysis tool
Questions you should answer · 13
  • How do Go interfaces work? How does a type satisfy an interface without declaring it explicitly?
  • What is a goroutine and how is it different from a thread? What does it cost to spawn one?
  • Explain Go's error handling model. Why explicit returns instead of exceptions? What are the tradeoffs?
  • What is a channel? Walk through a producer-consumer pattern using one goroutine and one channel.
  • Walk through writing an HTTP handler in Go from scratch — no framework, just net/http.
  • How do struct tags work for JSON marshaling? What happens to a field with no tag?
  • What is sql.DB and what does it manage for you? What is a prepared statement and why use one?
  • What is middleware in the context of an HTTP server? Write a logging middleware by hand.
  • How does Go handle optional or nullable JSON fields — a field that may or may not be present?
  • Walk through how your Vue frontend connects to your Go backend — CORS, JSON, the full path.
  • Your Go API serves both a Vue web app and a mobile client. A new required field is added to a response struct. Walk through the consequences for each consumer and how Go's type system helps or doesn't.
  • A Vue component is making 200 requests per second to a Go endpoint during a load test. Walk through three things you would do on the Go side to handle this without the server falling over.
  • Explain how Go fits into a web app stack where Vue handles the UI, Go handles the API, and a database sits behind Go. What is Go's specific job in that chain and why is it a better fit than Node.js for your use case?
References
TypeScript Handbook Language reference

Everyday types, narrowing, generics, and module resolution — the sources cited throughout the TypeScript milestones.

Vue Guide Framework reference

Single-file components, reactivity, watchers, composables, props/emits, and provide/inject.

Go Documentation Language reference

A Tour of Go, Effective Go, and the standard-library packages (net/http, encoding/json, database/sql) used by the Go milestones.

Future runway
Future Project Previews
web app · sports data

NBA Stats Explorer

A typed dashboard with player search, season stats, recent games, compact charts, and live-data states.

TypeScript · Vue · API clients · charts · polling
full stack · visualization

Steam Library Visualizer

A Go and Vue application that turns library and achievement data into treemaps, bubble charts, rarity views, and overlap comparisons.

Go · Vue · SQLite · SVG geometry · caching
graphics · procedural terrain

Terrain Generator

A landscape sandbox with layered noise, height-based materials, lighting controls, and room for erosion, rivers, biomes, and LOD.

noise · mesh generation · shaders · LOD
★ Flagship Star Project

Interactive Weather Simulator

A terrain-based weather laboratory where the user can adjust temperature, humidity, pressure, wind, cloud cover, precipitation, sunlight, and terrain parameters to generate different atmospheric conditions in real time. An alternate real-world mode accepts a ZIP code, retrieves the location’s current weather, and recreates those conditions across the simulated terrain. The project joins meteorology and atmospheric physics with numerical simulation, procedural terrain, shaders, particles, volumetric effects, data visualization, and graphics-engine architecture.

Simulation SandboxShape atmospheric conditions manually and observe how weather evolves across a configurable terrain.
Live Location ModeEnter a ZIP code and translate real weather data into a rendered, explorable local scene.
meteorology · thermodynamics · fluid motion · terrain · shaders · volumetrics · weather APIs · simulation architecture