Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Knowledge Graph

Cross-topic relationships for navigation and study planning. Auto-updated by research agents. Last updated: 2026-08-16 (advanced A-T sections, validation re-run)

Core Relationships

Operating Systems ↔ Other Topics

Virtual Memory
  → Paging (OS/Memory)
  → TLB (OS/Memory)
  → Cache Hierarchy (Architecture)
  → Page Replacement (OS/Virtual Memory)
  → Linux mmap() (OS/Memory)
  → NUMA (OS/Memory)
  → Copy-on-Write (OS/Virtual Memory)

Process Scheduling
  → CPU Scheduling Algorithms (OS/Scheduling)
  → Context Switching (OS/Processes)
  → Linux CFS (OS/Scheduling)
  → Real-time Systems (OS/Scheduling)
  → Goroutine Scheduler (Go) → Go Channels, Work-Stealing, GMP
  → JVM Thread Model (Java) → Loom Virtual Threads

File Systems
  → VFS (OS/Filesystems)
  → ext4/XFS/Btrfs (OS/Filesystems)
  → Inode Structure (OS/Filesystems)
  → Journaling (OS/Filesystems)
  → RAID (Storage)
  → Distributed File Systems (Distributed)
  → WAL (Storage/WAL) → ARIES, Checkpointing

Kernel Extensions
  → Kernel Modules (OS/Kernel/Modules) → insmod/modprobe, params, taint, signing
  → eBPF (OS/Kernel/eBPF) → XDP, TC, tracing, uprobes, CO-RE
  → io_uring (OS/Kernel/io_uring) → async I/O, SQ/CQ rings
  → Tracing (OS/Kernel/Tracing) → ftrace, kprobes 0.05us vs 0.5us, tracepoints, perf, bpftrace
  → RCU (Concurrency/RCU) → grace period, publish-subscribe, quiescent states

DBMS ↔ Storage ↔ Other Topics

Transactions
  → ACID Properties (DBMS/Transactions)
  → Isolation Levels (DBMS/Transactions)
  → MVCC (DBMS/Transactions)
  → 2PL (DBMS/Concurrency Control)
  → Distributed Transactions (Distributed) → 2PC/3PC/Saga
  → Saga Pattern (Backend Engineering) → Choreography vs Orchestration
  → WAL (Storage/WAL) → LSN/pageLSN, STEAL/NO-FORCE, group commit

Storage Engines
  → B-Tree (DBMS/Indexing) → B+Tree, Write Amplification low
  → Hash Index (DBMS/Indexing)
  → LSM-Tree (DBMS/Internals/LSM) → MemTable, SSTable, Bloom Filter
  → WAL (Storage/WAL) → durability before MemTable
  → Compaction (Storage/LSM-Compaction) → Leveled (10-30x WA) vs Tiered (2-4x) vs Hybrid (UCS), SAG, RocksDB tuning knobs
  → SSTable Format (Storage) → data blocks, index, bloom, footer, compression
  → Write Amplification (Storage) → affects SSD endurance
  → Read Amplification (Storage) → bloom reduces
  → Space Amplification (Storage) → tombstone reclamation

Query Processing
  → Parser (DBMS/Internals)
  → Optimizer (DBMS/Internals) → cost model, join algorithms
  → Executor (DBMS/Internals)
  → Join Algorithms (DBMS/Query) → nested loop, hash, sort-merge

Networks ↔ Backend ↔ Other Topics

TCP
  → Three-Way Handshake (Networks/TCP)
  → Congestion Control (Networks/TCP) → Slow Start, CUBIC, BBR, Reno
  → Congestion Control Overview (Networks/TCP/Congestion-Control/README) → NEW
  → Flow Control (Networks/TCP)
  → QUIC (Networks/HTTP/QUIC) → 0-RTT, connection migration via Connection ID
  → Socket Programming (Networks/Sockets) → TCP/UDP/Unix Domain, epoll

HTTP
  → TLS/HTTPS (Networks/Security) → TLS 1.3 handshake, mTLS, CT
  → HTTP/1.1, HTTP/2 (Networks/HTTP) → HPACK
  → HTTP/3 (Networks/HTTP) → QUIC, QPACK (RFC 9204), 0-RTT, HOL blocking eliminated
  → QPACK (Networks/HTTP/QPACK) → static 99 vs dynamic table, encoder/decoder streams 0x02/0x03, RIC/Base, blocking
  → QUIC (Networks/HTTP/QUIC)
  → REST API (Backend/API/REST) → versioning, idempotency
  → gRPC (Backend/API/gRPC) → protobuf, HTTP/2, streaming
  → GraphQL (Backend/API/GraphQL) → federation
  → WebSocket (Networks/HTTP/WebSocket)

Service Mesh
  → xDS Protocol (Backend/Containers/xDS-Protocol) → LDS/RDS/CDS/EDS/SDS, ADS, protobuf not YAML, SotW vs Delta, Pilot, go-control-plane
  → Service Mesh (Backend/Containers/Service-Mesh) → sidecar pattern (Envoy), mTLS via Citadel SPIFFE, VirtualService/DestinationRule/Gateway
  → Envoy Proxy → listeners, filter chains, clusters, outlier detection

Wireless
  → WiFi (Networks/Wireless/WiFi)
  → Bluetooth (Networks/Wireless/Bluetooth) → NEW: PAN, A2DP/HID/GATT, Classic vs BLE
  → 5G (Networks/Wireless/5G)

Architecture ↔ Other Topics

Cache Hierarchy
  → L1/L2/L3 Cache (Architecture)
  → Cache Coherence (Architecture/MESI) → MSI/MESI/MOESI/MESIF, directory-based, false sharing
  → False Sharing (Concurrency)
  → TLB (OS/Memory)
  → NUMA (OS/Memory)
  → Storage Hierarchy (Storage/Overview) → Registers → L1 → RAM → NVMe ~25us → HDD 5-10ms → S3 50-200ms

CPU Pipeline
  → Branch Prediction (Architecture)
  → Out-of-Order Execution (Architecture)
  → Speculative Execution (Architecture)
  → SIMD/AVX (Architecture)
  → GPU Architecture (Parallelism/GPU) → CUDA (Parallelism/CUDA) → Thread Hierarchy, Memory Model, Kernels
  → Modern Processors (Arch/Modern) → x86-64 Xeon/EPYC, ARM Neoverse Graviton, RISC-V, Apple Silicon M3/M4

Storage Performance
  → IOPS vs Throughput vs Latency (Storage)
  → RAID (Storage) → 0/1/5/6/10
  → Erasure Coding (Storage/Erasure-Coding) → Reed-Solomon, 10+4
  → Ceph (Storage/Ceph) → RADOS, CRUSH, PGs

Machine Learning ↔ Systems ↔ Other Topics

Neural Networks
  → Backpropagation (ML/NN)
  → Gradient Descent (ML/Optimization) → SGD, Adam
  → CNN (ML/CNN) → ResNet, ViT
  → RNN (ML/RNN) → LSTM, GRU
  → Transformer (ML/Transformer) → Self-Attention O(n²), Positional Encoding
  → Attention Mechanism (ML/Deep-Learning/Attention)

LLMs
  → Transformer Architecture (ML/Transformer)
  → Tokenization (LLM-Serving/Tokenization) → BPE, SentencePiece
  → Embeddings (LLM-Serving/Embeddings)
  → Fine-tuning (LLM-Serving/SFT) → LoRA, QLoRA
  → RLHF/DPO (LLM-Serving/RLHF) → PPO, GRPO
  → Inference Optimization → KV Cache (LLM-Serving/KV-Cache), Quantization (Quant), Speculative Decoding, Batching, vLLM/TensorRT/ TGI/Ollama
  → RAG (LLM-Serving/RAG) → Vector DBs (Vector-Databases) → HNSW, IVF, PQ
  → Probabilistic Data Structures (Interview/System-Design/Probabilistic) → Bloom for cache penetration, HLL for distinct count, CMS for heavy hitters

GPU Computing
  → CUDA (Parallelism/CUDA) → Thread Hierarchy (Thread/Block/Grid), Memory Model (global/shared/registers), Kernels
  → Thread Hierarchy (ML/GPU)
  → Memory Model (ML/GPU)
  → Tensor Cores (ML/GPU) → Mixed Precision Training (ML/Distributed) → FP16/BF16, DDP/FSDP/ZeRO

Programming Languages ↔ Frameworks ↔ Backend

Memory Management
  → C malloc/free (C) → Undefined Behavior, POSIX
  → C++ RAII/Smart Pointers (C++) → move semantics, STL, templates, concurrency
  → Rust Ownership (Rust) → borrow checker, lifetimes, traits, unsafe, async Tokio
  → Java GC (Java/GC) → Serial/Parallel/G1/ZGC 0.5ms/Shenandoah, generational ZGC JDK21
  → Python Reference Counting (Python) → GIL, asyncio, typing, 3.13 free-threaded
  → Go GC (Go) → GMP scheduler, channels, memory model, Web Frameworks (Gin/Echo/Fiber) → net/http compat vs fasthttp 89k rps vs 76k vs 72k
  → Virtual Memory (OS)

Concurrency
  → C pthreads (C)
  → C++ std::thread (C++) → std::jthread, memory model
  → Rust Send/Sync (Rust) → Tokio work-stealing
  → Java synchronized/ReentrantLock (Java) → Loom virtual threads
  → Python asyncio/GIL (Python) → free-threaded 3.13t
  → Go goroutines/channels (Go) → work-stealing scheduler, channels
  → JavaScript Event Loop (JS) → V8, Node.js, libuv

Web Frameworks
  → Go: Gin (minimal, 1000+ middleware, net/http), Echo (batteries included, radix), Fiber (Express-inspired, fasthttp, 0-1 alloc, 89k rps) → Decision: need compat → Gin, need built-ins → Echo, need max perf → Fiber
  → Rust: Tokio (async runtime), Axum/Actix (web)
  → Python: FastAPI (async, Pydantic), Django (batteries), Flask, Pydantic
  → Java: Spring Boot, Quarkus, Micronaut, Hibernate
  → JS/TS: React, Next.js, Vue & Angular (combined), Express.js

Backend Patterns
  → API Design (Backend/API) → REST (versioning, idempotency), gRPC (protobuf, streaming), GraphQL (federation), Webhooks, Connection Pools
  → Messaging (Backend/Messaging) → Kafka (log), RabbitMQ (queue), Redis (pub/sub + streams + Bloom/HLL), NATS (subject-based)
  → Auth (Backend/Auth) → JWT RS256, OAuth2 PKCE, mTLS (Service Mesh mTLS via Citadel SPIFFE), Session Management
  → Containers (Backend/Containers) → Docker, Kubernetes (Pods, Services, Deployments, Ingress, Operators CRD/reconciliation), Service Mesh (sidecar Envoy), xDS (ADS, LDS/RDS/CDS/EDS/SDS)
  → Observability (Backend/Observability) → Logs, Metrics Prometheus, Tracing Jaeger/Zipkin, Kiali
  → Patterns (Backend/Patterns) → Circuit Breaker (Closed/Open/HalfOpen), Retry + Exponential Backoff + Jitter, Idempotency Keys, Saga (Choreography vs Orchestration), CQRS (read/write separation), Event Sourcing, Distributed Transactions, Bulkhead
  → Probabalistic (Interview/Probabilistic) → Bloom for negative cache, HLL for cardinality, CMS for frequency

System Design ↔ All

Scalability
  → Vertical vs Horizontal, Stateless vs Stateful, Consistent Hashing (Distributed/Partitioning), Load Balancing L4 vs L7 (Networks/Load-Balancing), Caching Strategy (Cache-Aside, Write-Through, LRU/LFU/TTL), CDN (Networks/CDN/How-It-Works + Edge)

Data Structures for System Design
  → Bloom Filter (Interview/Probabilistic) → membership, 10 bits/elem @1% FP, Cassandra SSTable skip 90% IO, cache penetration prevention, safe-browsing
  → HyperLogLog (Interview/Probabilistic) → distinct counting 12KB fixed ~2% err, mergeable via max, Redis PFADD/PFCOUNT, BigQuery APPROX_COUNT_DISTINCT
  → Count-Min Sketch (Interview/Probabilistic) → frequency, overestimates, heavy hitters, ε/δ sizing

Storage & Retrieval
  → WAL (Storage/WAL) → LSN/pageLSN, group commit, fuzzy checkpoint
  → LSM Compaction (Storage/LSM-Compaction) → leveled vs tiered vs hybrid, RocksDB tuning, write stall
  → SSTable → bloom, index, data blocks

Real-World Designs
  → URL Shortener, Chat, News Feed, Rate Limiter (token bucket/leaky/sliding), KV Store, Search Engine, Video Streaming, Notifications, Distributed FS, Web Crawler, Pastebin, Social Graph, Typeahead, Metrics, Payment (idempotency keys), Ad Click Aggregation, Stock Exchange, Google Maps
  → Netflix (CDN + microservices), Twitter (fanout), Uber (geo), WhatsApp (presence), YouTube (transcoding), Instagram (feed), Dropbox (sync), Distributed Lock (Redlock/etcd/fencing tokens), Streaming Pipeline (Kafka + Flink/Spark + stateful processing), Probabilistic (Bloom/HLL/CMS for scale)

Cross-Language Relationships (Updated)

Memory Management
  → C malloc/free (C) → ecosystem & tooling (CMake, Conan, GDB)
  → C++ RAII/Smart Pointers (C++) → move semantics, STL, templates, ecosystem (Boost, CMake, Catch2)
  → Rust Ownership (Rust) → borrow checker, lifetimes, traits, error handling, async Tokio, unsafe, ecosystem (Serde, Rayon, Axum)
  → Java GC (Java) → G1 default 200ms, ZGC <1ms colored pointers load barriers, Shenandoah Brooks pointers, generational ZGC JDK21
  → Python (Python) → CPython internals, GIL 3.13 free-threaded, asyncio, typing, data model, packaging
  → Go (Go) → scheduler GMP work-stealing, channels, memory model, web frameworks Gin 76k rps vs Echo vs Fiber 89k rps
  → Virtual Memory (OS/Virtual Memory) → paging, TLB, NUMA

Concurrency
  → C pthreads (C) → POSIX
  → C++ std::thread (C++) → memory model acquire/release
  → Rust Send/Sync (Rust) → ownership ensures thread safety
  → Java (Java) → synchronized/ReentrantLock, Loom virtual threads
  → Python (Python) → asyncio, GIL
  → Go (Go) → goroutines/channels, work-stealing
  → JavaScript (JS) → Event Loop, V8, Node.js libuv
  → Kernel (OS/Kernel) → RCU grace period, publish-subscribe, tracing ftrace/kprobes

Linux and DSA Integration Edges — 2026-08-12

Linux track

  • Linux Tools → shell quoting, NUL-delimited pipelines, find/xargs, text processing, process inspection, sockets, HTTP, storage, tracing, and incident response.
  • Shell → system programming → system calls, file descriptors, IPC, epoll, io_uring, ELF, and dynamic linking.
  • Processes and threads → kernel scheduling and synchronization → per-CPU data, atomics, RCU, lock ordering, and lock contention.
  • ip/ss/tcpdump → Linux networking → TCP/IP, DNS, routing, TLS, WireGuard, and kernel eBPF hooks.
  • /proc, perf, ftrace, eBPF → performance → USE method, flame graphs, cache behavior, NUMA, and production diagnosis.
  • Namespaces + cgroups + seccomp → containers → OCI runtimes, rootless isolation, Kubernetes, and security boundaries.
  • Block I/O and filesystems → Linux storage → LVM, RAID, NVMe-oF, Ceph, multipath, and filesystem internals.

DSA track

  • DSA overview → foundations → arrays, sorting, searching, hashing, recursion, and complexity analysis.
  • Arrays and hashing → problem-solving patterns → two pointers, sliding windows, prefix sums, monotonic structures, and divide and conquer.
  • Trees → heaps, tries, DSU, segment trees, Fenwick trees, sparse tables, and binary lifting; these feed range-query and graph problem strategies.
  • Graph fundamentals → DFS/BFS → topological sort, shortest paths, MST, SCC, network flow, and tree decompositions.
  • DP fundamentals → DP patterns → digit/profile/optimization DP; correctness proofs and complexity analysis provide the explanation expected in interviews.
  • String algorithms → rolling hash, KMP, Z, tries, suffix arrays/automata, Aho–Corasick, BWT/FM-index, and palindromic structures.
  • DSA engineering chapters → architecture, C++ memory and STL, cache hierarchy, profiling, branch prediction, SIMD, and undefined behavior.

Research loop batch 4 edges — 2026-08-12

  • GraphQL Federation → subgraphs, entities, @key, @requires, @provides, @shareable, composition, query planning, schema checks, and OpenTelemetry.
  • GraphQL Federation → GraphQL, API gateways, service mesh, authorization, and distributed failure handling.
  • Distributed Locks → leases, Redis/Redlock, ZooKeeper ephemeral-sequential nodes, etcd revisions, fencing tokens, idempotency, and transactional alternatives.
  • Distributed locks ↔ Consensus and CDC/outbox: coordinate only when a resource-side invariant cannot be enforced with a conditional write.
  • Tiered Storage → NVMe-oF, SSTables, LSM compaction, BlobDB, object lifecycle, cache admission, and recovery SLOs.
  • Tiered Storage ↔ Capacity Planning → cost, tail latency, retrieval, egress, and data temperature policies.

Research loop batch 3 edges — 2026-08-12

  • eBPF networking → XDP, TC/TCX, cgroup and socket hooks, BPF maps, AF_XDP, CO-RE/BTF, and Cilium datapaths.
  • eBPF networking → Linux networking tools, TCP/IP, Cilium/Kubernetes, and kernel tracing.
  • Rust async runtimes → futures, executors, reactors, Tokio work stealing, smol/futures traits, io_uring, blocking pools, cancellation, and OpenTelemetry context propagation.
  • OpenTelemetry → traces, metrics, logs, baggage, semantic conventions, Collector pipelines, sampling, cardinality, service mesh, CDC, and async context propagation.
  • OpenTelemetry ↔ system design observability → SLOs, tail latency, retries, queues, and production diagnosis.

Research loop batch 2 edges — 2026-08-12

  • NVMe-oF → NVMe command queues, TCP/RDMA transports, discovery, multipathing, Linux nvme-cli, storage latency, and network congestion.
  • NVMe-oF → Block Storage, Linux networking, RDMA, and distributed-storage design.
  • CRDTs → convergence, SEC, vector clocks, gossip, replication, local-first software, Yjs/Automerge, and rich text collaboration.
  • CRDTs ↔ Consensus: CRDTs avoid some coordination for mergeable state; consensus is required for linearizable decisions and global invariants.
  • CDC and Transactional Outbox → WAL, logical decoding, Debezium, Kafka, idempotency, event-driven architecture, CQRS, and distributed transaction boundaries.
  • CDC/outbox ↔ CRDTs: event publication transports changes; CRDTs define a mergeable replicated state. Neither alone guarantees business invariants or exactly-once external side effects.

ABA and safe-reclamation edges — 2026-08-12

  • ABA Problem → CAS/compare-exchange, tagged pointers, memory ordering, lock-free stacks and queues.
  • ABA → Hazard Pointers → per-pointer reader reservations, retire lists, scans, and delayed reclamation.
  • ABA → Epoch Reclamation → pinning, participant advancement, stalled-reader memory growth, and Crossbeam Epoch.
  • ABA → RCU → grace periods, unlink-before-free, Linux kernel quiescent states, and read-mostly data structures.
  • ABA → C++ safe reclamation → current C++ working draft hazard_pointer and rcu_obj_base, with implementation availability still compiler-dependent.
  • Safe reclamation → Memory Model → acquire/release publication, CAS success/failure orderings, and lifetime safety as a separate proof obligation.

Cross-track placement edges

  • Linux perf/cache hierarchy ↔ DSA complexity and cache-aware engineering.
  • Linux kernel trees, hash tables, allocators, and schedulers ↔ DSA trees, hashing, heaps, graphs, and amortized analysis.
  • epoll/io_uring readiness queues ↔ DSA queues and event-driven systems.
  • Consistent hashing ↔ Linux/network service discovery and DSA’s advanced hashing chapter; this is also relevant to distributed-system interviews.

Provenance and integrity

  • Source learning tracks: lb2 and dsa_book_2.
  • Parent navigation: src/SUMMARY.md.
  • Validation edges: Markdown links → Summary reachability → Mermaid v11 parser → mdBook build.

New Edges Added 2026-08-09

  • Go Web Frameworks → net/http compatibility ↔ observability (prometheus, pprof, otelhttp) vs fasthttp incompatibility
  • Probabilistic Data Structures → Caching Strategy (negative cache), Redis (BF.ADD, PFADD), LSM (SSTable bloom), Kafka (heavy hitters), BigQuery
  • Kernel Tracing → eBPF (bpftrace kprobe:do_sys_open, hist(retval)), ftrace (function_graph), perf (record), cgroups filtering
  • WAL → ARIES (Analysis/REDO/UNDO), Checkpointing (sharp vs fuzzy), LSM Trees (MemTable replay), RocksDB/Kafka/etcd Raft
  • LSM Compaction → WAL, SSTable, Bloom Filter, RocksDB tuning, Write Amplification, Space Amplification Goal, Time-Window Compaction for time-series
  • RCU → Lock-free (ABA, hazard pointers), Memory Barriers (acquire/release, smp_mb), Kernel Modules (rcu_barrier for unload), cgroups traversal
  • Storage → Distributed (Ceph CRUSH, RADOS), Erasure Coding (Reed-Solomon)
  • Links fixed: introduction.md revision/README → revision/os.md, os/README → os/overview.md, etc., congestion-control README and bluetooth added

New Edges Added 2026-08-13 — Massive Expansion

Git ↔ Other Topics

Git Internals
  → Objects (blob, tree, commit) ↔ Data Structures (hash tables, trees)
  → SHA-1/SHA-256 ↔ Cryptography (hashing)
  → Packfiles ↔ Storage (delta compression)
  → Refs ↔ File Systems (pointer files)

Git Workflows
  → CI/CD (GitHub Actions) ↔ DevOps
  → Code Review ↔ Software Engineering (team dynamics)
  → Branching Strategy ↔ Release Management
  → Merge vs Rebase ↔ Distributed Systems (conflict resolution)

Git Hooks
  → Pre-commit ↔ Testing (linting, unit tests)
  → Commit-msg ↔ Code Quality (Conventional Commits)
  → Pre-push ↔ CI/CD (validation)

Software Engineering ↔ Other Topics

SDLC Models
  → Agile/Scrum ↔ Project Management
  → Waterfall ↔ Documentation (requirements specs)
  → Spiral ↔ Risk Management

SOLID Principles
  → Single Responsibility ↔ Design Patterns (SRP in every pattern)
  → Open/Closed ↔ Strategy Pattern, Decorator Pattern
  → Liskov Substitution ↔ OOP (inheritance contracts)
  → Interface Segregation ↔ API Design (focused interfaces)
  → Dependency Inversion ↔ Backend (DI containers, Spring)

Code Quality
  → Technical Debt ↔ Refactoring
  → Code Smells ↔ Design Patterns (antidotes)
  → Clean Code ↔ Interview Preparation

Security ↔ Other Topics

Authentication
  → OAuth 2.0 ↔ Backend (JWT, API auth)
  → OIDC ↔ Identity Providers
  → Sessions ↔ Backend (session management)
  → JWT ↔ Distributed Systems (stateless auth)

Web Security
  → XSS ↔ Frontend (CSP, sanitization)
  → SQL Injection ↔ DBMS (parameterized queries)
  → CSRF ↔ Backend (tokens, SameSite cookies)
  → SSRF ↔ Cloud (metadata endpoints)

Cryptography
  → AES ↔ Storage (encryption at rest)
  → TLS ↔ Networks (HTTPS, certificate pinning)
  → RSA/ECC ↔ PKI (certificate chains)
  → Password Hashing ↔ Backend (bcrypt, Argon2)

Data Engineering ↔ Other Topics

Spark
  → RDDs ↔ Programming Fundamentals (functional programming)
  → DataFrames ↔ SQL (query optimization)
  → DAG Execution ↔ Distributed Systems (task scheduling)

Kafka
  → Partitions ↔ Distributed Systems (partitioning)
  → Consumer Groups ↔ Message Queues
  → Exactly-Once ↔ Distributed Transactions
  → WAL ↔ Storage (append-only log)

Airflow
  → DAGs ↔ Graph Algorithms
  → Operators ↔ DevOps (CI/CD pipelines)
  → Scheduling ↔ OS (cron, systemd timers)

Machine Coding ↔ Other Topics

Design Patterns
  → Strategy ↔ OOP (polymorphism)
  → Observer ↔ Backend (event-driven)
  → Factory ↔ Creational Patterns
  → Builder ↔ Complex Object Construction

Parking Lot
  → OOP (inheritance, polymorphism)
  → Design Patterns (Strategy for pricing)
  → Database (slot allocation)

LRU Cache
  → Data Structures (HashMap + Doubly Linked List)
  → Caching Theory ↔ OS (page replacement LRU)
  → Concurrency (thread-safe cache)

Rate Limiter
  → Token Bucket ↔ Backend (API rate limiting)
  → Sliding Window ↔ Networks (traffic shaping)
  → Distributed Rate Limiting ↔ Distributed Systems

Aptitude & Placement ↔ Other Topics

Probability
  → Randomized Algorithms ↔ DSA
  → Expected Value ↔ Algorithm Analysis
  → Hashing ↔ Data Structures

Logical Reasoning
  → Problem Solving ↔ Interview Preparation
  → Pattern Recognition ↔ Algorithm Design

Placement Preparation
  → Technical Interview ↔ All CS Topics
  → System Design ↔ Distributed Systems, Backend
  → Coding Round ↔ DSA, Competitive Programming
  → Behavioral ↔ Communication, Resume

Advanced Sections A-T Edges — 2026-08-15

A: Advanced OS ↔ Other Topics

NUMA & Memory Domains
  → NUMA (OS/Memory) → Linux NUMA policies, autonuma, CFS bandwidth
  → CPU Topology (Architecture) → CCX, chiplets, mesh interconnect
  → Memory Model (Concurrency) → acquire/release, seq_cst on weak ARM

Container Isolation & Seccomp
  → Linux namespaces (OS) → user, mount, network, PID
  → cgroups v2 (OS) → resource limits, eBPF
  → Kubernetes security (Cloud) → pod security standards, seccomp profiles

Capability-Based Security
  → POSIX capabilities (Linux) → ambient, inheritable, permitted sets
  → seccomp-bpf (OS/Kernel) → syscall filtering
  → Security Research (L) → sandboxing, least privilege

B: Linux Kernel ↔ Other Topics

eBPF & Tracing
  → XDP/TC (Networks) → packet processing at L2/L3
  → BPF Maps → kernel-userspace data sharing
  → Perf → hardware performance counters
  → Tracing (OS/Kernel) → ftrace, kprobes, tracepoints

io_uring & Async I/O
  → Async/Await (PL) → futures, completion-based I/O
  → Rust Tokio (Languages) → io_uring driver
  → Storage I/O path → NVMe, block layer, page cache

C: Distributed Systems ↔ D/E/O/N

Consensus Protocols
  → Raft (Distributed) → Multi-Raft, etcd
  → Paxos (Distributed) → Multi-Paxos, Google Chubby
  → Byzantine Fault Tolerance (Blockchain M) → PBFT, HotStuff

Consistency Models
  → Linearizability (Formal Methods K) → TLA+ specification
  → Serializability (DBMS E) → 2PL, S2PL, OCC
  → Eventual Consistency → CRDTs, Dynamo-style

Distributed Transactions
  → 2PC/3PC (DBMS) → atomic commit
  → Saga (Backend) → choreography vs orchestration
  → CDC/Outbox (Backend) → event-driven consistency

F: Advanced Algorithms ↔ DSA/ML

Approximation Algorithms
  → NP-Hard Problems (DSA) → vertex cover, TSP, set cover
  → Load Balancing (Distributed) → consistent hashing, power of 2 choices

Randomized Algorithms
  → Probabilistic Structures → Bloom, HLL, CMS
  → Monte Carlo Methods (ML) → MCMC, importance sampling
  → Quicksort/Hashing (DSA) → average-case analysis

G: PL/Compilers ↔ Architecture/Languages

Type Systems
  → Rust Ownership (Languages) → borrow checker, lifetimes
  → Haskell Type Classes → higher-kinded types
  → C++ Templates → compile-time polymorphism, concepts

SSA & IR Optimization
  → LLVM IR → instruction selection, register allocation
  → JIT Compilation (V8/PyPy/Java) → tiered compilation
  → Dataflow Analysis → liveness, reaching definitions

N: AI Systems ↔ Architecture/Distributed

LLM Inference
  → GPU Architecture (H) → tensor cores, memory bandwidth
  → KV Cache (LLM) → PagedAttention, vLLM
  → Quantization → INT8/INT4, GPTQ, AWQ
  → Distributed Serving → tensor/pipeline/data parallelism

RAG & Vector Search
  → Vector DBs (DBMS E) → HNSW, IVF-PQ
  → Embedding Models (ML) → sentence-transformers, ColBERT
  → Chunking Strategies → fixed, semantic, recursive

P: Cloud/Serverless ↔ Backend/Distributed

Serverless Architecture
  → FaaS (Cloud) → AWS Lambda, Cold/Warm Start
  → Event-Driven (Backend) → SQS, EventBridge
  → Edge Computing (Q) → CDN compute, Cloudflare Workers

Service Mesh & Observability
  → xDS Protocol (Backend) → Envoy configuration
  → OpenTelemetry (Backend) → traces, metrics, logs
  → eBPF (Kernel B) → Cilium, network observability