Overview

Computer Science Fundamentals are the core concepts that underpin everything in software engineering. Whether you are preparing for technical interviews, building production systems, or deepening your understanding of how computers work, mastering these topics will make you a significantly better engineer.

What You Will Learn

This guide covers five major areas of computer science:

• Data Structures & Algorithms (DSA) - The tools and techniques for storing, organising, and processing data efficiently
• Operating Systems (OS) - How your computer manages hardware, processes, memory, and files
• Database Management Systems (DBMS) - How data is stored, queried, and managed at scale
• Networking - How computers communicate with each other across the internet and local networks
• System & Architecture Design - How to design large-scale, reliable, and scalable software systems

Data Structures & Algorithms

DSA is the foundation of efficient programming. Every interview, every optimisation problem, every fast system traces back to choosing the right data structure and algorithm.

• Arrays and Strings - The most fundamental building blocks; indexing, slicing, and manipulation
• Linked Lists - Singly and doubly linked lists; insertion, deletion, and traversal
• Stacks and Queues - LIFO and FIFO structures; use cases like undo history and job scheduling
• Hashing - Hash maps and hash sets; collision resolution strategies
• Trees - Binary trees, BSTs, AVL trees, segment trees, and tries
• Heaps - Min-heaps and max-heaps; priority queues
• Graphs - Representations (adjacency list, matrix), BFS, DFS, shortest paths, and spanning trees
• Sorting Algorithms - Bubble, merge, quick, heap, and counting sort; time and space complexities
• Searching Algorithms - Linear search, binary search, and their applications
• Dynamic Programming - Memoization and tabulation; breaking problems into overlapping subproblems
• Greedy Algorithms - Making locally optimal choices to reach a global optimum
• Recursion and Backtracking - Solving problems by exploring all possibilities systematically
• Bit Manipulation - Working directly with binary representations for speed and efficiency
• Complexity Analysis - Big O notation; understanding time and space trade-offs

Operating Systems

Operating systems sit between your hardware and your software. Understanding how they work helps you write faster, safer, and more reliable programs.

• Process Management - What a process is, how the OS creates and schedules them, and how they communicate
• Threads and Concurrency - Threads vs processes; race conditions, locks, and synchronisation primitives
• CPU Scheduling - Algorithms like FCFS, SJF, Round Robin, and Priority Scheduling
• Memory Management - How the OS allocates, tracks, and reclaims memory; paging and segmentation
• Virtual Memory - Page tables, TLBs, and how programs use more memory than physically available
• File Systems - How data is stored and retrieved on disk; inodes, directories, and journaling
• I/O Management - How the OS handles input and output devices; buffering and drivers
• Deadlocks - Conditions that cause deadlocks and strategies to prevent, avoid, or recover from them
• Inter-Process Communication (IPC) - Pipes, message queues, shared memory, and semaphores
• System Calls - The interface between user programs and the OS kernel
• Kernel vs User Space - The privilege boundary and why it matters for security and stability

Database Management Systems

DBMS is what powers every application that needs to store and retrieve data. From simple apps to large-scale systems, understanding databases is essential.

• Relational Databases - Tables, rows, columns, and how relational data is structured
• SQL - Querying, inserting, updating, and deleting data; joins, aggregations, and subqueries
• Normalisation - Organising data to reduce redundancy (1NF, 2NF, 3NF, BCNF)
• Transactions - Grouping operations so they either all succeed or all fail
• ACID Properties - Atomicity, Consistency, Isolation, Durability - the guarantees a reliable database provides
• Indexing - How indexes speed up queries and the trade-offs involved
• Query Optimisation - How database engines decide the fastest way to run a query
• NoSQL Databases - Document stores, key-value stores, column families, and graph databases
• CAP Theorem - The trade-off between Consistency, Availability, and Partition Tolerance in distributed databases
• Concurrency Control - Locking, MVCC, and how databases handle simultaneous reads and writes
• Database Replication - Copying data across servers for availability and fault tolerance
• Sharding - Splitting a database across multiple machines to handle large scale

Networking

Networking is how every internet-connected application works. Understanding the layers of a network helps you debug problems, design better systems, and reason about security.

• OSI and TCP/IP Models - The layered models that describe how data travels across a network
• IP Addressing - IPv4, IPv6, subnets, and CIDR notation
• DNS - How domain names are translated to IP addresses
• TCP vs UDP - Reliable, ordered delivery vs fast, connectionless delivery
• HTTP and HTTPS - The protocol that powers the web; requests, responses, status codes, and TLS
• HTTP/2 and HTTP/3 - Performance improvements over classic HTTP/1.1
• WebSockets - Full-duplex communication between client and server
• REST and APIs - Designing clean HTTP APIs
• Routing and Switching - How packets move through a network
• Firewalls and NAT - Controlling traffic and translating addresses
• CDNs - Serving content from servers close to the user for speed
• Load Balancers - Distributing traffic across multiple servers
• Network Security - TLS/SSL, certificates, common attacks (DDoS, MITM), and defences

System & Architecture Design

System design is the process of planning how large, complex software systems are built. It combines knowledge from all the other areas into a unified approach to building scalable and reliable products.

• Scalability - Vertical vs horizontal scaling; how to grow a system as load increases
• Availability and Reliability - Designing systems that stay up even when parts fail; SLAs and SLOs
• Load Balancing - Distributing work across servers; algorithms and types of load balancers
• Caching - Speeding up reads with in-memory caches like Redis; cache invalidation strategies
• Databases at Scale - When to use SQL vs NoSQL; replication, sharding, and read replicas
• Message Queues - Decoupling services with systems like Kafka, RabbitMQ, or SQS
• Microservices vs Monoliths - Trade-offs between different architectural styles
• API Design - REST, GraphQL, and gRPC; versioning and backward compatibility
• Event-Driven Architecture - Designing systems that react to events rather than direct calls
• Rate Limiting and Throttling - Protecting services from abuse and overload
• Storage Systems - Object storage, block storage, and file storage; when to use each
• Search Systems - Full-text search with tools like Elasticsearch
• Real-Time Systems - Designing for live data, notifications, and streaming

graph TD CS["CS Fundamentals"] CS --> DSA["Data Structures & Algorithms"] CS --> OS["Operating Systems"] CS --> DBMS["Database Management Systems"] CS --> NET["Networking"] CS --> SYS["System & Architecture Design"] DSA --> A1["Arrays, Trees, Graphs, DP"] OS --> B1["Processes, Memory, File Systems"] DBMS --> C1["SQL, ACID, Indexing, NoSQL"] NET --> D1["TCP/IP, HTTP, DNS, Security"] SYS --> E1["Scalability, Caching, Queues, Microservices"]

These five pillars of computer science are interconnected. A system design decision depends on your understanding of networking and databases. Writing fast code depends on your knowledge of algorithms and OS internals. Work through each section in order or jump to the area most relevant to your goals. Happy learning!