Learning

Service decomposition, gateways, meshes, orchestration, and platform control surfaces.

Systems Design Foundations

Cross-cutting design synthesis, architecture trade-offs, and system-level framing.

Backend and API Architecture

API contracts, backend layering, request flow, and persistence boundary design.

Organization Design and Software Delivery

Socio-technical design for software delivery: team boundaries, ownership, flow, platform interfaces, delivery metrics, governance, and operating cadences.

Workflow Orchestration and Business Process Systems

Long-running workflows, compensation, scheduling, visibility, and the engines used to coordinate business processes across services.

Domain-Driven Design and Service Boundaries

Domain modeling, bounded contexts, service boundaries, and the trade-offs behind carving systems around capabilities rather than endpoints.

Multi-Tenant Platform Architecture

Isolation models, noisy-neighbor control, tenant routing, billing boundaries, and the platform trade-offs behind multi-tenant systems.

Developer Platform Product Management

Internal platform adoption, paved roads, platform economics, and product thinking for developer-facing infrastructure teams.

Backend Development Foundations

Practical backend engineering foundations: internet requests, language/runtime choices, databases, testing, deployment, and operational basics.

Containers, Kubernetes, and Platform Runtime

Container runtime mechanics, image delivery, Kubernetes workload primitives, networking, storage, autoscaling, PDBs, service mesh sidecars, security profiles, and platform operations for backend services.

Startup, SaaS, and Indie Product Building

Problem selection, user discovery, product wedges, MVPs, pricing, distribution, metrics, and small-team execution discipline.

Engineering Craft and Technical Taste

Practical judgment for builders: simplicity, leverage, maintainability, debugging, naming, review, and the craft of choosing what not to build.

Developer Tooling, Automation, and 2AM Prototypes

Hack useful ideas together quickly without losing the engineering thread: CLIs, scripts, APIs, local tools, iteration loops, and prototype discipline.

API Protocols, RPC, and Edge Contracts

Advanced API protocol mechanics for backend systems: HTTP/2, HTTP/3, TLS 1.3, gRPC streams, GraphQL execution, gateway policy, binary encodings, and contract evolution.

Infrastructure as Code and Cloud Automation

Terraform-style infrastructure workflows: desired state, state files, modules, drift, policy gates, CI/CD, GitOps, cost controls, and rebuildable cloud environments.

Complexity and Systems Thinking

Foundational systems-thinking lenses for reasoning about interaction, feedback, emergence, adaptation, boundaries, and bounded prediction before deeper modeling, control, and simulation tracks.

Agent-Based Modeling

Rule-based simulations, emergence from local behavior, and agent-scale experimentation.

Networks, Cellular Automata, and Emergence

Cellular automata, network dynamics, cascading behavior, and emergence in structured systems.

System Dynamics and Causal Modeling

Stocks, flows, calibration, validation, and causal reasoning for system-level decision support.

Nonlinear Dynamics and Chaos

State-space thinking, bifurcations, attractors, oscillation, tipping points, and the dynamics behind sensitive system behavior.

Evolutionary Dynamics and Adaptation

Selection, adaptation, evolutionary game dynamics, genetic search, and the mechanisms that change strategy populations over time.

Information Dynamics and Complexity

Entropy, mutual information, transfer, encoding, and complexity measures for understanding how structure and uncertainty evolve in systems.

Cellular Automata and Pattern Formation

Local rules, emergent structure, spatial computation, and the simple update systems that generate surprisingly rich patterns.

Control Theory and Feedback Systems

Controllers, stability, delay, observability, and feedback design for complex technical and socio-technical systems.

Criticality, Phase Transitions, and Self-Organization

Critical points, scale changes, self-organization, and the regime shifts that explain why systems can transform abruptly.

Network Science and Diffusion

Centrality, diffusion, contagion, percolation, and the structure of networks as systems that transmit influence and failure.

Game Theory and Strategic Systems

Strategic interaction, equilibrium concepts, incentives, and the feedback between competing agents in adaptive systems.

Cybernetics, Autopoiesis, and Second-Order Systems

Control, communication, observers, self-maintaining systems, viable organization, and the strange discipline of studying systems that include the observer.

Artificial Life and Self-Replicating Systems

Synthetic life, digital evolution, self-replication, artificial chemistries, open-ended novelty, and models that ask what life could be.

Fractals, Scaling, and Power-Law Systems

Scale invariance, fractal geometry, heavy tails, allometry, renormalization intuition, and the warning signs of systems without a typical size.

Complexity Modeling Methods and Labs

A practical modeling track for turning complex-system questions into toy models, simulations, sensitivity analysis, validation, and reproducible reports.

Robustness, Resilience, and Adaptive Capacity

How systems tolerate shocks, degrade gracefully, reorganize after disturbance, and balance efficiency against survival.

Econophysics and Complex Markets

Markets as interacting adaptive systems: heavy tails, volatility clustering, herding, order books, agent-based markets, and systemic risk.

Origins of Life, Autocatalysis, and Chemical Networks

Prebiotic chemistry, autocatalytic sets, hypercycles, compartments, information, metabolism, and the transition from chemistry to evolving organization.

Algorithmic Information and Computational Mechanics

Kolmogorov intuition, compression, randomness, logical depth, causal states, epsilon machines, and formal ways to detect structure in processes.

Product Design, UX, and Interface Foundations

Design usable product interfaces by tracing user pressure, system state, navigation, feedback, hierarchy, product promise, and reusable interaction patterns.

Cinematography, Visual Language, and Mood

Composition, light, movement, editing rhythm, color, atmosphere, and visual storytelling for people who think in systems and scenes.

Poetry, Aesthetics, and Compressed Language

Read and write compressed language: image, rhythm, line, metaphor, voice, translation, ambiguity, and aesthetic judgment.

Industrial Design, Physical Products, and Materials

Physical product thinking: affordances, ergonomics, materials, manufacturing, repair, durability, packaging, and the feel of useful objects.

Visual Systems, Typography, and Editorial Design

Build coherent visual communication systems by using type, grids, hierarchy, rhythm, composition, and diagrams to guide attention without distorting meaning.

Nonfiction Voice, Observation, and Revision

Build nonfiction craft through observation, scene, specificity, voice, anecdote, warmth, and revision as discovery.

Art History and Visual Thinking

Learn to look before labeling and build evidence-grounded visual arguments by connecting composition, medium, patronage, symbolism, abstraction, display, and reproduction.

Worldbuilding and Speculative Systems

Design believable invented worlds through constraints, ecology, institutions, technology, culture, narrative pressure, and symbolic coherence.

Database Engine Internals and Implementation

Implementation-focused deep dive into the single-node database engine substrate: workload shape, page and record layout, buffer pools, B-tree and LSM access paths, WAL, checkpoints, crash recovery, and the transaction boundary that builds on durable storage.

Data Architecture and Platforms

Architecture-level design of data platforms: source-of-truth boundaries, derived-data contracts, regional placement, serving planes, reliability controls, governance handoffs, and platform operating models.

Analytical Query Engines and Warehouses

Columnar storage, execution engines, warehouse architecture, vectorization, and the internals of large-scale analytical query systems.

Data Integration, CDC, and Pipelines

Change capture, ingestion contracts, backfills, schema drift, and the operational trade-offs of moving data through modern pipelines.

Data Systems Foundations

Data models, storage trade-offs, batch versus streaming, analytical versus transactional systems, and the basic mental models for modern data stacks.

Data Lakehouse and Storage Formats

Draft track for columnar formats, table metadata layers, schema evolution, compaction, and lakehouse architecture.

Metadata, Lineage, and Catalog Systems

Schemas, ownership, lineage graphs, discovery surfaces, and the metadata infrastructure that makes data platforms governable.

Streaming Data Infrastructure

Streaming ingestion, stateful processors, watermarks, checkpoints, exactly-once claims, backpressure, replay, and the platform patterns behind low-latency data movement.

In-Memory Data Systems and Redis

In-memory system design through Redis as the concrete case study: event loops, data structures, persistence, replication, clustering, caching, queues, locks, and operations.

NoSQL and Distributed Data Stores

Key-value, document, wide-column, graph, and search-oriented data stores with partitioning, replication, consistency, compaction, indexing, and operations.

Backend Database Operations and Query Performance

Operational database depth for backend engineers: connection pools, isolation, query planning, index health, sharding, replicas, failover, and split-brain prevention.

PostgreSQL Internals and Operations

PostgreSQL-specific depth for production systems: MVCC, WAL, locks, planner evidence, indexes, vacuum, replication, pooling, migrations, security, and operational debugging.

Transaction Manager Implementation

Single-node transaction-manager implementation: transaction state, isolation anomalies, lock managers, MVCC, optimistic validation, serializable snapshot isolation, undo, WAL integration, recovery, index consistency, testing, and observability.

Distributed Systems Foundations

Core mental models for coordination, failure, time, load, contracts, and operational trade-offs in distributed systems.

Event-Driven Architecture and Streaming Foundations

Application-level event-driven design: event boundaries, broker models, delivery semantics, contracts, idempotency, replay, backpressure, and operational review. This track is the bridge into deeper messaging internals, stream processing, CDC, and distributed workflow tracks.

Networking and Failure Models

Network layers, protocol boundaries, retries, and the failure models they create.

Gossip, Membership, and Epidemic Systems

Probabilistic dissemination, failure evidence, membership lifecycles, resilient overlays, epidemic repair, and production design for large changing clusters.

Consensus and Coordination

Consensus safety and liveness, Paxos, Raft, ZAB, quorum and commit evidence, replicated state machines, safe reads, reconfiguration, coordination APIs, operations, and failure verification.

Consistency and Replication

Replication models, quorums, isolation, ordering, and large-scale coordination trade-offs.

Distributed Transactions and Sagas

Atomicity boundaries, sagas, idempotency, outbox patterns, and the trade-offs between coordination and compensation in distributed workflows.

Distributed Schedulers and Control Planes

Reconcilers, leases, scheduling, placement, autoscaling, and control-plane design patterns.

CRDTs and Coordination Avoidance

Mergeable data types, invariant design, monotonicity, and the techniques that reduce coordination in replicated systems.

Geo-Distributed Systems and Disaster Tolerance

Regional topology, failover control, latency trade-offs, disaster tolerance, and the architecture of systems stretched across failure domains.

Distributed Messaging and Queue Internals

Log brokers, consumer coordination, delivery semantics, retention, and the internals of queue and streaming substrates.

Distributed Testing, Simulation, and Deterministic Replay

Fault injection, schedule control, simulation harnesses, trace replay, and the testing strategies used to make distributed bugs reproducible.

Network Protocols and Transport Systems

Internet protocol mechanics from link layer and IP through TCP congestion algorithms, routing, middleboxes, measurement, secure channels, SDN, and datacenter fabrics.

HTTP Protocol and Content Delivery

HTTP semantics, representation contracts, browser credential boundaries, caching, HTTPS delivery, proxies, DNS, CDNs, long-lived connections, and observability for backend-facing web delivery.

Distributed Systems Protocols and Labs

Implementation-centered distributed systems practice: RPC, MapReduce, clocks, snapshots, DHTs, replication, Raft, Spanner-style transactions, and key-value services.

Game Engine Runtime Patterns

Engine loop patterns, runtime composition, resource ownership, and gameplay control structures.

Engine Systems, Tooling, and Performance

Engine core systems, editor/runtime tooling boundaries, profiling discipline, job systems, replay, validation, and performance workflow for real-time interactive engines.

Rendering and Graphics Systems

Frame production, GPU pipeline architecture, shader and material systems, lighting, visibility, temporal techniques, and rendering evidence for real-time engines.

Networked Game Systems and LiveOps

Networking, authority, transport, live operations, and shipping readiness for multiplayer games.

Animation, Character, and Behavior Systems

Animation graphs, character controllers, state machines, and the runtime systems that make interactive characters feel alive.

Game AI, Navigation, and Decision Systems

Navigation meshes, planners, behavior trees, and the decision systems that drive responsive interactive agents.

Graphics Math and Rendering Foundations

Transforms, projection, shading intuition, and the mathematical foundations that make graphics systems intelligible.

Physics and Real-Time Simulation

Collision, integration, constraints, and the numerical trade-offs behind stable simulation in interactive systems.

Procedural Generation and World Systems

Noise, rule-based generation, world simulation, and the systemic design patterns used to produce rich worlds from compact rules.

Game Audio and Interactive Sound Systems

Audio engines, mixing graphs, spatial sound, adaptive music, voice, asset pipelines, performance budgets, and accessibility for interactive worlds.

Polymath Learning and Idea Synthesis

A compact entry point for turning scattered technical, scientific, artistic, and philosophical interests into disciplined questions, bounded analogies, and small synthesis artifacts.

Philosophy, Existentialism, and Stoic Practice

Compare existentialist freedom, absurdist revolt, Nietzschean value critique, Stoic judgment, and finitude, then turn their differences into bounded reflection practices and a revisable personal philosophy.

Literature, Storytelling, and Symbolic Worlds

A practical foundation for moving from plot summary and personal reaction to evidence-grounded interpretations of character pressure, narration, structure, genre, symbols, and narrative worlds.

Clear Technical Writing, Rhetoric, and Explanation

Turn technical knowledge into reader-centered explanations and durable documentation by choosing the right document shape, revealing mechanisms through concrete examples, writing for decisions and operations, and revising a maintained service docs pack.

Rhetoric, Debate, and Deep Conversations

Turn disagreement into joint inquiry by asking generative questions, listening for the real claim, reconstructing arguments fairly, mapping reasons, noticing identity pressure, and designing conversations that produce clearer beliefs or next steps.

Great Books: Russian, Modern, and Absurdist Literature

Compare how Tolstoy, Dostoevsky, Kafka, Camus, Nabokov, Orwell, and Borges use narrative form to pressure agency, guilt, meaning, language, and moral judgment.

Technical English: Verb Tenses and Engineering Status

Use English verb tenses to describe current state, ongoing work, past incidents, evidence, plans, rollouts, and technical timelines.

Technical English: Modals and Engineering Judgment

Use modal and auxiliary verbs to express ability, uncertainty, obligation, recommendation, permission, risk, inference, and retrospective judgment in technical work.

Technical English: Gerunds and Infinitives in Engineering Work

Use gerunds and infinitives to talk about goals, plans, avoidance, preference, purpose, repeated work, and technical trade-offs.

Technical English: Nouns, Articles, and Countability

Use nouns, articles, plurals, uncountable technical words, quantifiers, and ownership language to make engineering sentences precise.

Technical English: Pronouns and Determiners for Clear References

Use pronouns, possessives, demonstratives, substitutes, and distributive determiners to keep technical references clear across sentences, groups, and alternatives.

Technical English: Clauses, Modifiers, and Comparison

Add identifying detail, qualification, and comparison to technical sentences without hiding the component, evidence, constraint, or trade-off being described.

Technical English: Prepositions for Systems and Data Flow

Choose prepositions that make system location, request paths, timelines, methods, dependencies, and operational boundaries precise.

Technical English: Connectors and Phrasal Verbs

Connect evidence, constraints, actions, and consequences in short engineering communication, then use common operational phrasal verbs with clear agency and natural object placement.

Epistemology and Knowledge Systems

Audit claims by separating belief from knowledge, testing evidence and defeaters, evaluating testimony and disagreement, and tracing how institutions create or distort trust.

History of Ideas and Technology

Historical tracing practice for explaining how media, instruments, institutions, infrastructure, conflict, and imagined futures reshape ideas and technologies over time.

LLM Foundations

Transformer-era language modeling concepts, architectures, and capability framing.

LLM Training, Alignment, and Serving

Training data, distributed pretraining, post-training, alignment loops, inference optimization, and production serving for large language models.

RAG, Agents, and LLM Production

Evidence-grounded LLM product architecture: RAG pipelines, agent-facing context, evaluation slices, observability, cost, safety boundaries, and production release judgment.

Reasoning and Frontier Post-Training

Synthetic data, verifiers, process supervision, reasoning traces, and frontier post-training loops.

Agent Runtime and Tool-Use Systems

Tool schemas, planners, sandboxes, browser agents, orchestration loops, and runtime failure handling.

Agent Memory, Planning, and Context Engineering

Design memory, context assembly, and planning state for long-lived LLM agents that must preserve evidence, recover work, and act under operational constraints.

Agent Safety, Guardrails, and Policy Systems

Guardrails, policy enforcement, action filtering, runtime controls, and the trust boundaries needed around agentic systems.

LLM Evaluation and Benchmarking

Offline evals, task suites, judge systems, reliability trade-offs, and the measurement discipline required to compare LLM behavior honestly.

Multi-Agent Systems and Coordination

Coordination protocols, role assignment, negotiation, and the design patterns for systems composed of multiple autonomous agents.

Tool Learning and Environment Interaction

Tool selection, environment feedback, learned interaction policies, and the mechanisms that let agents improve through action.

Human-AI Collaboration and Agentic Workflows

Design reliable work with AI assistants and agents: delegation, context, review, tool boundaries, memory, failure recovery, and human judgment.

Machine Learning Foundations

A decision-centered introduction to supervised learning: frame prediction problems, trace how models learn, compare model biases, evaluate generalization honestly, and diagnose what to improve next.

Deep Learning and Neural Networks

How neural networks build representations, receive credit through gradients, train reliably, encode architectural bias, transfer knowledge, and cross the boundary into inference systems.

Multimodal Foundations and Vision-Language Models

Multimodal encoders, contrastive learning, grounding, and vision-language model design.

World Models and Model-Based Agents

Latent dynamics, predictive state, imagination-based planning, and model-based agent architectures.

Diffusion, Audio, Video, and Generative Media

Diffusion models, latent media generation, controllability, and evaluation across image, audio, and video systems.

Causal ML and Decision Making

Interventions, counterfactual thinking, uplift, and the use of causal structure to support better decisions than prediction alone.

Optimization, Generalization, and Learning Theory

Bias-variance trade-offs, sample complexity, optimization behavior, and the theory that explains why learning succeeds or fails.

GPU Systems and Accelerators

Draft track for GPU execution models, accelerator runtime behavior, and heterogeneous systems design.

ML Systems and Training Infrastructure

Draft track for feature platforms, training pipelines, experiment systems, model deployment, and inference operations.

Probabilistic Modeling and Bayesian Inference

Latent-variable models, priors, posterior reasoning, and the probabilistic view of learning under uncertainty.

Reinforcement Learning and Sequential Decision Making

Value functions, policy learning, exploration, planning, and the algorithms for acting under delayed feedback.

Representation Learning and Self-Supervision

Embeddings, contrastive objectives, pretext tasks, and the training recipes that build reusable latent structure from raw data.

MLOps, DataOps, and Model Operations

Operational discipline for machine learning: datasets, training pipelines, evaluation, deployment, monitoring, drift, lineage, and rollback.

AI Research Literacy and Paper Reading

Read AI research with discipline: claims, baselines, ablations, datasets, benchmarks, limitations, replication, and implementation judgment.

Algorithms, Complexity, and Approximation

Algorithm design, hardness, approximation, and the computational trade-offs that bound what systems can do efficiently.

Formal Methods and Verification

Draft track for specification, model checking, proof techniques, and systems verification workflows.

Information Theory, Coding, and Compression

Entropy, channel capacity, coding, compression, and the formal limits of representation and communication.

Linear Algebra, Geometry, and Spectral Methods

Vector spaces, matrix decompositions, geometry, and spectral reasoning used across graphics, learning, and systems analysis.

Logic, Automata, and Formal Languages

Formal languages, automata, decidability, and the logical machinery that underpins compilers, verification, and computation theory.

Optimization, Convexity, and Numerical Methods

Objective landscapes, convexity, constrained optimization, and the numerical methods that make large-scale learning and control practical.

Probability, Random Processes, and Statistical Thinking

Build a practical probability model of uncertain events, samples, measurements, and processes, then test what its summaries can and cannot justify.

Abstract Algebra and Structural Thinking

Groups, rings, fields, homomorphisms, invariants, and algebraic structure as reusable ways to see symmetry and constraint.

Computer Science Great Ideas

A beginner orientation to computer science that traces how exact procedures, representations, algorithms, abstractions, languages, networks, and system layers turn intent into working software.

Mathematical Proof and Problem Solving

Develop mathematical maturity through definitions, examples, proof strategies, counterexamples, invariants, induction, contradiction, and problem taste.

Category Theory and Compositional Thinking

A gentle bridge into objects, morphisms, functors, natural transformations, adjunctions, diagrams, and compositional design intuition.

Psychology, Neuroscience, and Cognitive Science

Perception, attention, emotion, memory, habit, bias, and social cognition for technical learners who want a better model of minds.

Knowledge Work, Notebooks, and Zettelkasten Systems

Design a tool-neutral knowledge loop that turns sources and experience into durable claims, purposeful links, retrieval cues, project decisions, and synthesis without letting capture or maintenance become the work.

Neuroscience of Learning, Creativity, and Consciousness

Brains as adaptive systems: plasticity, attention, sleep, creativity, predictive processing, consciousness debates, and careful limits on explanation.

World Modeling Foundations

Build usable models of reality: assumptions, boundaries, variables, feedback, uncertainty, evidence, and model failure.

Decision Making, Uncertainty, and Judgment

Turn incomplete evidence into inspectable choices using options, calibrated probabilities, values, trade-offs, reversibility, failure tests, and feedback.

Caching, Workers, and Performance

Application performance under repeated work and bursts: cache authority and freshness, worker scheduling and failure control, load distribution, scaling, and evidence-driven diagnosis across the request path.

Capacity Planning and Performance Engineering

Load envelopes, queuing trade-offs, forecasting, and the methods used to plan system growth before painful saturation.

Incident Management and Operational Learning

Incident response as an operational learning system: paging signals, roles, triage, communication, runbooks, mitigation, postmortems, corrective actions, on-call training, and durable organizational memory.

Release Safety and Progressive Delivery

Canaries, feature gates, rollback design, change safety, and the release controls that reduce production risk.

Reliability Engineering Foundations

SLIs, SLOs, failure budgets, operational trade-offs, and the core mental models behind production reliability work.

Chaos Engineering and Resilience Labs

Failure injection, resilience drills, blast-radius control, and experiment design for hardening systems before real incidents.

Observability, Telemetry, and Production Debugging

Production observability depth for backend systems: OpenTelemetry propagation, Prometheus cardinality, logs, sampling, traces, profiling, service maps, and incident evidence.

Robotics, Automation, and Embodied AI

Sensors, actuators, frames, control loops, perception, planning, safety, and simulation-to-reality gaps in embodied systems.

Physics, Astronomy, and Quantum Intuition

Physical reasoning across scales: forces, energy, fields, entropy, astronomy, quantum states, and careful bridges to computation.

Futurism, Transhumanism, and Biohacking

Forecasting, human enhancement, longevity, quantified self, brain-computer interfaces, AI futures, and responsible speculation.

Economics, Geopolitics, and Strategy

Incentives, markets, game theory, institutions, supply chains, energy, geopolitical risk, and strategic decision-making.

Quantum Computing, Information, and Algorithms

Qubits, gates, measurement, entanglement, quantum circuits, algorithms, error correction, and realistic claims about quantum advantage.

Astronomy, Cosmology, and Space Systems

A bridge from night-sky wonder to physical inference: telescopes, stars, galaxies, cosmology, spacecraft, orbits, and space engineering constraints.

Behavioral Economics and Decision Markets

Bounded rationality, incentives, nudges, prediction markets, risk, uncertainty, narratives, and the gap between ideal agents and real people.

Geopolitics of Technology, Chips, Energy, and Cloud

How compute, semiconductors, energy, standards, platforms, data centers, cables, export controls, and cloud infrastructure shape power.

Scientific Reasoning and Philosophy of Science

Evaluate scientific claims by tracing hypotheses, experiments, measurement, causality, replication, theory pressure, and the limits of what the evidence can justify.

Sociotechnical Systems, Ethics, and Technology

Review technological systems by tracing coupled behavior, stakeholders, power, encoded values, incentives, feedback, governance, and repair.

Search Indexing and Retrieval

Index construction, lexical retrieval models, postings mechanics, ranking baselines, and the retrieval-system boundary before serving, vector search, and evaluation tracks.

Ranking, Evaluation, and Search Quality

Learning to rank, experimentation, evaluation pipelines, and search quality governance.

Web Crawling and Corpus Acquisition

Crawler frontiers, politeness, canonicalization, parsing, duplicate control, freshness, corpus governance, and the handoff from web acquisition into search indexing.

Knowledge Graphs and Entity Resolution

Entity linking, graph modeling, canonicalization, and the data structures used to connect knowledge across noisy sources.

Large-Scale Data Mining

Approximation, sketching, distributed analytics, graph mining, clustering, and operational judgment for massive datasets without mixing in personalization product loops.

Ads, Auctions, and Marketplace Ranking

Auction design, bidding signals, marketplace objectives, and the ranking trade-offs unique to monetized retrieval systems.

Query Understanding and Semantic Retrieval

Intent parsing, reformulation, semantic matching, and the retrieval improvements that start from better representations of user needs.

Experimentation and Online Learning for Ranking

Interleaving, A/B testing, bandits, feedback loops, and the online methods used to improve ranking systems safely.

Recommendation and Personalization Systems

Candidate generation, multi-stage ranking, feedback loops, experimentation, fairness, and serving architecture for personalization systems.

Retrieval and Ranking Foundations

Indexing basics, ranking intuition, query-document matching, and the introductory mental models behind search and recommendation quality.

Vector Search and Embedding Systems

Draft track for embeddings, ANN indexes, hybrid retrieval, vector databases, and retrieval serving trade-offs.

Search Engine Serving and Operations

Production search serving: schemas, analyzers, shards, query execution, aggregations, relevance tuning, hybrid search, indexing pipelines, cluster operations, and incidents.

Security and Platform Trust

Platform-level security foundations for zero-trust service platforms: workload identity, artifact provenance, secure defaults, runtime guardrails, tenancy, audit evidence, and trust-degradation response.

Application Security and Secure Design

Input validation, auth flaws, data exposure, secure defaults, and the design patterns that reduce common application risks.

Cloud, Container, and Supply Chain Security

Image provenance, runtime isolation, dependency trust, and the controls used to secure modern cloud software supply chains.

Cryptography, Secrets, and Key Management

Cryptographic primitives, secret rotation, key hierarchy, and the operational discipline needed to use cryptography safely.

Identity, Authorization, and Policy Systems

Identity boundaries, token flows, authorization models, policy engines, and the auditability of trust decisions in software systems.

Privacy, Governance, and Data Compliance Engineering

Draft track for lineage, retention, deletion workflows, policy enforcement, auditability, and privacy-aware data operations.

Security Foundations and Threat Modeling

A practical foundation for turning system diagrams, assets, trust boundaries, adversary assumptions, and abuse paths into prioritized security requirements, verifiable controls, and living threat models.

Detection, Response, and Forensics

Security telemetry, investigation workflows, triage, containment, and the evidence-handling needed after active compromise.

Reverse Engineering and Program Understanding

Understand software from the outside inward: binaries, protocols, traces, decompilers, symbols, patching, and ethical analysis.

Adversarial Security and Hacker Mindset

A compact, defense-oriented practice for challenging assumptions, tracing realistic attack chains across technical and human workflows, mapping attacker behavior to controls and signals, and reporting findings responsibly.

Operating Systems Internals

A compact foundation for tracing how operating systems isolate work, cross kernel boundaries, schedule execution, manage memory pressure, coordinate concurrency, and expose evidence for host-level diagnosis.

Storage and Filesystems

A compact bridge from operating-system foundations to storage design: choose a storage contract, separate metadata from data paths, trace caching and durability boundaries, follow an I/O request, and read operational pressure before entering implementation deep dives.

Operating Systems Implementation

A project-oriented bridge that turns operating-system mental models into traceable implementation decisions for a small kernel, from boot and privilege transitions through memory, scheduling, syscalls, I/O, isolation, and debugging.

Computer Architecture and Performance Models

Caches, pipelines, memory hierarchies, branch behavior, and the hardware performance models that shape software design decisions.

Concurrency, Memory Models, and Lock-Free Systems

Memory ordering, atomicity, lock-free design, wait-freedom, and the concurrency models behind scalable shared-memory systems.

I/O Stacks, Device Drivers, and Storage Paths

Interrupts, DMA, drivers, block and network I/O paths, and the kernel-to-device mechanics that shape latency and throughput.

Kernel Networking and eBPF

Draft track for kernel datapaths, packet processing, observability, and programmable networking hooks.

Compiler Construction, Runtimes, and Virtual Machines

Compiler and runtime systems from lexing, parsing, IR, dataflow, optimization, register allocation, and code generation through bytecode VMs, JIT tiering, deoptimization, GC interfaces, and runtime observability.

Memory Systems and Allocators

Memory behavior from virtual memory, page faults, cache locality, and NUMA through arena, stack, pool, free-list, buddy, slab, and general-purpose allocator design.

Filesystem and Storage Implementation

Journaling, copy-on-write trees, allocators, recovery, metadata engines, and the implementation trade-offs inside storage stacks.

Virtualization and Hypervisor Systems

Virtual machines, hypervisors, device emulation, paravirtualization, and the isolation mechanisms underneath cloud compute.

Linux Workstations: Ownership, Reproducibility, and Repair

Build a Linux workstation you can inspect, repair, and reproduce by tracing shell, filesystem, package, and service behavior before comparing Arch-style ownership with NixOS-style declaration.

Programming Languages: Rust, C++, Python, and API Craft

A comparative path through language trade-offs, memory, types, performance, ergonomics, bindings, and API design across Rust, C++, and Python.

Backend Runtime, I/O, and Performance