Learning Paths
Structured curriculums that guide you through articles, traces, practice problems, and interviews — ordered for progressive mastery.
Algorithms Advanced
Go deep on searching, sorting, graphs, and dynamic programming — the advanced patterns that solve the hardest coding problems.
Algorithms Foundations
Start from zero: what algorithms are, how arrays work in memory, and how simple algorithms like linear search actually execute.
Algorithms Intermediate
Arrays, hash tables, trees, and recursion — the core data structures and patterns you need to solve coding problems efficiently.
C++ Advanced
Move semantics, concurrency with threads and atomics, STL containers, and RAII — the advanced features that make C++ fast and safe.
C++ From the Ground Up
Start from zero: what C++ pointers are, stack vs heap memory, how function calls use the stack, and common memory errors to avoid.
C++ Intermediate
Automatic memory management with RAII, smart pointers, the STL containers and algorithms, and how function calls use the stack.
High-Frequency Trading Advanced
Colocation, hardware acceleration, adversarial trading, and market surveillance — the systems that power modern trading infrastructure.
High-Frequency Trading From the Ground Up
Start from zero: what markets are, what order books look like, how market orders execute, and why latency matters.
High-Frequency Trading Intermediate
Matching engines, market data feeds, and order book dynamics — building the systems that power modern trading venues.
Advanced Networking and Performance
HTTP/2 multiplexing, CDNs, anycast, and TLS security — the advanced patterns that make production networks fast and resilient.
Networking From the Ground Up
Start from zero: what networks are, how the client-server model works, how packets travel through layers, and the difference between TCP and UDP.
Networking Protocols Deep Dive
Dive into IP addressing, DNS resolution, TCP transport, and TLS security — the protocols that move data reliably and securely.
Operating Systems Advanced
CPU scheduling algorithms, deadlock prevention and detection, and the advanced concurrency patterns that keep systems reliable.
Operating Systems From the Ground Up
Start from zero: what an OS is, what a process is, how processes move through states, and how processes differ from threads.
Operating Systems Intermediate
System calls, concurrency, processes, and virtual memory — the intermediate concepts that keep operating systems correct and performant.
System Design Advanced
Consensus, sharding, circuit breakers, and cross-region resilience — the advanced patterns that keep distributed systems alive under failure.
System Design Foundations
Start with the basics — what a system is, how requests travel, and the metrics that drive every design choice — before moving to databases, caches, and distributed consensus.
System Design Intermediate
Build on the foundations — load balancing, databases, replication, queues, and rate limiting — with execution traces that show where the work actually happens.
Web Development Advanced
Real-time communication (WebSockets/SSE), SPA vs MPA architecture, security, and performance optimization at scale.
Web Development From the Ground Up
Start from zero: how the web works, HTML/CSS/JS layers, browser rendering, HTTP, and the difference between GET and POST.
Web Development Intermediate
REST API design, state management, idempotent POST requests, and reliable API patterns — building on the foundations.
Algorithmic Problem Solving
Build a repeatable method for analyzing, selecting, and proving algorithms across arrays, windows, and graphs.
Application Security: Model Trust and Protect Data
Identify trust boundaries and apply controls suited to password storage, browser output, and authorization decisions.
Backend APIs, Identity, and Safe Retries
Design request contracts that remain understandable under authentication, retries, timeouts, and duplicate delivery.
Build and Operate Reliable Systems
Connect architecture choices to deployment control loops, security boundaries, performance evidence, and safe software delivery.
Cloud Platforms: Containers and Reconciliation
Understand container isolation, Kubernetes desired state, rollout health, and reproducible infrastructure changes.
Code to Machine: Execution Foundations
Connect algorithm choices to data representation, compilation, CPU memory behavior, operating-system services, and runtime scheduling.
Computer Architecture: Pipelines and Memory
Connect instruction dependencies, branch behavior, and cache locality to the performance of real algorithms.
Computer Systems: Source to Process
Follow source representation through compilation, linking, loading, virtual addresses, and process execution.
Data Storage and Consistency
Move from in-memory structures to database plans, transaction visibility, replication, cache freshness, and consensus.
Data Structures in Practice
Compare arrays, lists, hash maps, trees, and heaps by the operations and access patterns they make efficient.
Database Internals: Indexes, Transactions, and Plans
Learn how indexes narrow work, MVCC shapes visibility, and query plans execute relational operations.
Distributed Systems: Failure, Replication, and Consensus
Reason about uncertainty across network calls, replica freshness, leader election, and quorum-based commits.
Language and Runtime Internals
Move from tokenization and bytecode to JIT specialization, heap management, and event-loop scheduling.
Networked Services: From Browser to Backend
Follow a web request through DNS, transport, TLS, HTTP, backend reliability, query execution, and distributed dependencies.
Networking Foundations: Follow an API Request
Build a layered mental model of an HTTPS request, inspect its route, trace its execution, and practice explaining network paths.
Networking Protocol Foundations
Trace name resolution, transport, and secure-channel setup, then distinguish protocol guarantees from deployment choices.
Operating Systems: Processes, Memory, and Synchronization
Build an operating-system mental model around scheduling, address translation, and safe shared-state transitions.
Performance Engineering: Measure Before Optimizing
Use workload shape, queueing, profiling, and query evidence to locate the dominant cost before changing code.
Software Architecture: Boundaries and Patterns
Choose module boundaries from change patterns and use architecture styles or patterns only when they solve a concrete pressure.
Software Delivery: Version, Test, Release, Observe
Connect version control, test boundaries, deployment feedback, and rollback into a repeatable delivery system.
Software Systems: From Code to Production
A guided tour across all 17 TRT domains, from algorithms and machine execution to distributed services, security, and delivery.
System Design From Workload to Failure Mode
Translate workload assumptions into request paths, capacity needs, cache behavior, and explicit degraded modes.