CS Foundations
Build your foundation with Data Structures, Algorithms, OS, and Networks.
- Master Data Structures & Algorithms
- OS, Networks & Architecture
- Software Engineering best practices
Start your 7-day free trial
Get full access to all learning paths across the platform.
All Lessons
Algorithms: Sorting & Searching
Learn how to efficiently find data and organize it using foundational algorithms.
Operating Systems: Processes & Threads
Demystify what happens under the hood when your code actually runs on a CPU.
Computer Networks: The Internet
Explore the protocols that power the web, from IP addresses to HTTP.
Stacks & Queues
Understand LIFO vs FIFO structures and how they power function calls and task scheduling.
Hash Tables & Dictionaries
Learn how Hash Functions enable magical O(1) lookups using key-value pairs.
Trees & BSTs
Understand hierarchical data structures and O(log N) tree traversal.
Heaps & Priority Queues
Master Min-heaps and Max-heaps for priority-based task scheduling.
Graphs & Networks
Learn how Nodes and Edges model real-world networks like social media and GPS.
Tries & Prefix Trees
Store and search strings efficiently with trie data structures for autocomplete, spell check, and prefix matching.
Segment Trees
Perform range queries and updates in O(log N) time using segment trees for competitive programming and databases.
Fenwick Trees (BIT)
Compute prefix sums and range queries efficiently using bitwise operations.
Disjoint Set (Union-Find)
Track connected components dynamically using path compression and union by rank.
Skip Lists
Understand probabilistic data structures that provide O(log N) search as an alternative to balanced trees.
B-Trees & B+ Trees
Learn how B-trees and B+ trees power database indexes and file systems with disk-optimized multi-way branching.
Red-Black Trees
Study red-black tree invariants, rotations, and insertions that guarantee O(log N) balanced operations.
Recursion & Backtracking
Learn how functions that call themselves solve complex problems by breaking them down.
Divide & Conquer
Master algorithms like Merge Sort and Quick Sort that conquer big data by repeatedly halving it.
Dynamic Programming
Optimize heavy algorithms by storing and reusing solutions to overlapping subproblems.
Graph Traversal
Navigate connected node graphs using Breadth-First and Depth-First Search.
Greedy Algorithms
Solve optimization problems by making the locally optimal choice at every step.
Topological Sort
Order vertices in a directed acyclic graph using topological sort for dependency resolution and task scheduling.
Strongly Connected Components
Find strongly connected components in directed graphs with Tarjan's and Kosaraju's algorithms.
Minimum Spanning Trees
Compute minimum spanning trees with Kruskal's and Prim's algorithms for network design and clustering.
Shortest Path Algorithms
Find shortest paths with Dijkstra's, Bellman-Ford, and Floyd-Warshall algorithms for weighted graphs.
Maximum Flow (Ford-Fulkerson)
Solve maximum flow problems using Ford-Fulkerson and Edmonds-Karp for network capacity optimization.
String Matching (KMP)
Search for patterns in text efficiently with the KMP algorithm and its failure function preprocessing.
Computational Geometry Basics
Explore computational geometry: convex hulls, line intersection, point-in-polygon, and sweep line algorithms.
Memory Management & Paging
Learn how the OS tricks programs into thinking they have infinite memory.
File Systems & Storage
Understand block storage, formatting, and how operating systems organize vast oceans of bits.
Deadlocks & Synchronization
Master Mutexes, Semaphores, and preventing gridlock when multiple threads compete for resources.
The Memory Hierarchy
Understand the tradeoff between speed and size: from CPU registers to L1/L2 caches, RAM, and disk storage.
Garbage Collection & Memory Leaks
Explore how high-level languages automatically free memory using Reference Counting and Mark-and-Sweep.
System Calls
Dive into User Space vs. Kernel Space and how applications request hardware resources.
Inter-Process Communication
Learn how completely isolated processes talk to each other safely using Pipes and Sockets.
Shared Memory & Mapped Files
Bypass typical IPC bottlenecks by mapping files directly into RAM with mmap.
Signals & Interrupts
Control the chaotic lifecycle of processes by catching and handling async signals like SIGINT and SIGKILL.
Threading with pthreads
Dive into low-level multiprocessing using the POSIX thread library.
The OSI Model
The 7 structural layers of the internet, isolating abstract apps from raw electrical signals.
Transport Layer: TCP vs UDP
Examine the trade-off between guaranteed delivery and raw speed.
IP Addressing & Subnets
How IPv4 and IPv6 allocate massive address spaces, and how subnets filter traffic.
Network Security & TLS
Securing data in transit with encryption.
Symmetric vs Asymmetric Encryption
The mathematical backbone of modern internet privacy and secure data exchange.
Diffie-Hellman Key Exchange
How two computers can agree on a shared secret over a completely public, compromised channel.
The Full TLS Handshake
The exact millisecond-by-millisecond process of establishing a secure HTTPS web connection.
Digital Signatures & Certificates
How your browser actually knows that bank.com is run by the bank, and not a Russian hacker.
OAuth 2.0 & OpenID Connect
How 'Log in with Google' securely delegates access without handing over your password.
Web Vulnerabilities (XSS, CSRF, SQLi)
Deconstructing the top 3 ways applications get hacked, and how to programmatically fix them.
Zero Trust Architecture
Why the classic 'Castle-and-Moat' corporate firewall and VPN model is completely obsolete.
CPU Architecture & Caching
Identify how hardware processes code and handles immense disparities in read/write latency.
Distributed Systems Basics
Scaling massive applications across hundreds of computers simultaneously.
Databases: Relational vs NoSQL
Deciding the absolute best backend engine to power your web product.
ACID Transactions Deep Dive
Master Database Isolation Levels and understand how to prevent dirty reads and phantom data.
Database Indexing & B-Trees
How databases instantly search billions of rows using algorithmic data structures.
Query Optimization
Investigate how the SQL Engine translates your query into a physical Execution Plan.
Document Stores Deep Dive
Explore MongoDB, Schema-less design, and when to embed vs reference documents.
Key-Value & Graph DBs
Analyze extreme use cases: Redis for memory caching and Neo4j for social networks.
CAP Theorem In Practice
Master Eventual Consistency, Quorums, and exactly how major systems handle node failures.
Database Sharding & Replication
How to split a 50 Terabyte database seamlessly across 50 individual servers.
Logic Gates & Boolean Algebra
How abstract True/False statements map to physical silicon transistors.
Assembly & Machine Code
Explore the bridge between high-level Python and the pure binary a CPU understands.
Compilers vs Interpreters
How modern languages are translated so a CPU can execute them.
Theory of Computation
Turing Machines and the mathematical limits of what a computer can fundamentally solve.
The P vs NP Problem
The million-dollar unproven question that underpins modern encryption.
Virtualization & Containers
Understand Hypervisors, VMs, and the Docker container revolution.
Cryptography Foundations
Hashing, Salting, and the strict difference between Encoding and Encrypting.
Lexical Analysis (Scanner)
How a compiler turns raw text strings into a stream of meaningful Tokens.
Parsing & Abstract Syntax Trees (AST)
How tokens are arranged into a hierarchical tree representing grammatical structure.
Semantic Analysis & Type Checking
Ensure code actually makes logical sense through type safety and scoping.
Intermediate Representation (IR)
Translate the AST into a universal, machine-neutral code format like LLVM IR.
Code Optimization
How compilers rewrite your inefficient code to execute drastically faster.
Code Generation
The final step: translating IR down to physical hardware binary registers and opcodes.
Just-In-Time (JIT) Compilation
How modern VMs compile code dynamically during runtime to hyper-optimize based on actual usage.
Version Control: Git Internals
Demystifying what a commit actually is and how Git saves code history with trees and blobs.
API Design & REST
How to craft scalable interfaces for backends using statelessness and HTTP verbs.
System Design: Caching
Implementing Redis to survive massive traffic spikes using smart eviction policies.
Message Queues & Event-Driven
Decoupling systems using async queues like Kafka and RabbitMQ.
Microservices vs Monoliths
The trade-offs inherent in moving from a single unified codebase to thousands of separated APIs.
Testing: Unit, Integration, E2E
Guarding against regressions using the Test Automation Pyramid.
CI/CD Pipelines
Continuous Integration and Continuous Deployment for rapid, predictable code releases.
Web Security Foundations
Identifying and mitigating common vulnerabilities: XSS, CSRF, and SQLi.
Functional Programming
Embrace immutability and pure functions to write predictable and thread-safe code.
Object-Oriented Design
Master Encapsulation, Inheritance, and Polymorphism to structure large application codebases.
SOLID Principles
Write highly maintainable software using the 5 essential rules of object-oriented design.
Creational Patterns
Control object creation effectively using Singleton, Factory, and Builder patterns.
Structural Patterns
Connect incompatible systems seamlessly using Adapters, Facades, and Decorators.
Behavioral Patterns
Manage complex state and reactive event-driven logic with Observers and State patterns.
Dependency Injection
Decouple services completely, making your application mockable and relentlessly testable.
Clock Synchronization & Timestamps
How thousands of globally scattered computers agree on the exact sequence of events.
Consensus Algorithms (Raft)
How leaderless nodes democratically elect a dictator and guarantee perfectly mirrored data.
MapReduce & Distributed Processing
Processing 5 Petabytes of raw data using thousands of cheap commodity computers.
Streaming Architecture (Kafka)
Moving from slow, overnight batch processing to millions of real-time streaming events.
Microservices vs Monoliths
The massive pros and devastating cons of slicing applications into thousands of tiny servers.
API Gateways & Service Mesh
How to physically route millions of dynamic user requests to 5,000 shifting containers.
Message Queues & Pub/Sub
Decoupling aggressive traffic spikes via asynchronous background workers.
Content Delivery Networks (CDNs)
Bypassing the speed of light by geographically caching massive assets on the edge.
Machine Learning Basics
The mathematical shift from hard-coded rules to algorithmically derived patterns.
Neural Networks & Deep Learning
How mimicking the biological brain scales feature abstraction to solve impossible problems.
Quantum Computing Foundations
Shattering classical binary logic with Superposition and Entanglement.
The Future of Compute
The physical limits of Moore's Law and the profound paradigm shifts on the horizon.