Computer Science roadmap

At the heart of every computer are billions of tiny electronic switches called transistors. These switches can be either switched on or turned off, which we represent mathematically as ones and zeros. This binary system forms the foundation for all digital information, from the photos on your phone to the text messages you send every day.

Imagine a simple light switch in your hallway. When the switch is up, the light is on, representing a one. When it is down, the light is off, representing a zero. By combining millions of these basic switches into logic gates, computers can make decisions and perform complex calculations in milliseconds.

Understanding binary and logic helps you appreciate how physical hardware translates into the digital apps you use daily. It explains the physical limitations and capabilities of modern computers.

• Computers use transistors as electronic switches.
• Binary represents data using ones and zeros.
• Logic gates combine switches to make decisions.

The central processing unit is often called the brain of the computer. It follows a continuous cycle known as fetch, decode, and execute. It fetches an instruction from memory, figures out what that instruction means, and then executes the required operation using tiny internal storage spaces called registers.

Think of the processor like a chef following a recipe step by step. The chef reads a line in the recipe, prepares the ingredients, and then cooks them before moving to the next instruction. A fast processor reads and executes billions of these tiny recipe steps every single second.

Knowing how architecture works helps you write software that respects hardware limits, ensuring your programs run smoothly without wasting precious processor cycles.

• The CPU fetches, decodes, and executes instructions.
• Registers hold temporary data inside the processor.
• Clock speed determines how many cycles run per second.

Computers rely on two main types of data holding areas. Primary memory, like random access memory, is extremely fast but forgets everything the moment you turn off your device. Secondary storage, such as solid-state drives, is slower but keeps your files safe permanently even without power.

Consider your office desk. Random access memory is like the papers spread out in front of you for easy reaching during the workday. Your filing cabinet in the corner is secondary storage, where you store files away safely for months or years.

Balancing memory and storage is crucial for software performance. Good programs load only what they need into active memory to keep systems running fast.

• RAM is fast and volatile, losing data on power off.
• SSDs and hard drives provide permanent secondary storage.
• Software must balance speed and storage capacity.

Human programmers write code in readable languages using words like print and return. However, processors only understand raw binary machine code. Abstraction layers, such as compilers and interpreters, sit in between, translating our human-friendly instructions into something the computer hardware can actually run.

Think of driving an automatic car. You press the accelerator pedal to move forward, without needing to know how fuel burns in the engine cylinders or how pistons pump. That driving interface is an abstraction layer hiding the messy mechanical details.

Abstraction allows us to build massive, complex software applications without needing to build every single computer chip from scratch.

• Compilers and interpreters translate human code to machine code.
• Abstraction hides complex underlying hardware details.
• Higher-level languages make programming faster and easier.

Variables are named containers used to hold data inside a computer program. Every piece of data has a specific type, such as whole numbers, decimal numbers, or text strings. Telling the computer what type of data it is holding helps it know how much memory to allocate and what operations are valid.

Imagine labelled storage boxes in a garage. A box labelled age holds a whole number, whilst a box labelled username holds text. You would not store a sentence inside a box meant only for numerical measurements.

Mastering variables and data types prevents unexpected program crashes and ensures your data is processed correctly from the start.

• Variables store values in computer memory.
• Data types include integers, floats, and strings.
• Correct types prevent unexpected calculation errors.

Control flow refers to the order in which individual statements and instructions are evaluated in a program. Using conditional statements like if-else and loops like for and while, your code can make decisions and repeat tasks automatically based on changing inputs.

Think of a smart thermostat in your home. If the room temperature drops below twenty degrees, it turns on the heater. Otherwise, it stays idle. If it is cold, it repeats a check every five minutes until the target is reached.

Control flow brings logic and automation to software, allowing simple scripts to handle complex real-world decision-making scenarios.

• Conditionals allow programs to make decisions.
• Loops automate repetitive tasks efficiently.
• Order of execution determines program logic.

Functions are reusable blocks of code designed to perform a single specific task. Instead of rewriting the same lines over and over, you write a function once and call it whenever needed. Scope determines where those variables can be accessed, keeping parts of your program isolated and secure.

Consider a coffee machine. You press a button, and it runs a pre-programmed function to grind beans and pour water. You do not need to rebuild the machine internally every time you want a cup.

Functions make your codebase clean, maintainable, and easy for other developers to read and collaborate on.

• Functions package reusable blocks of logic.
• Scope restricts variable visibility to specific blocks.
• Modularity makes large codebases easier to maintain.

Object-oriented programming is a style of coding that bundles related data and behaviours together into logical models called classes and objects. This mirrors real-world items, making it easier to design large applications with many moving parts and interconnected components.

Imagine a blueprint for a house. The blueprint is the class, defining what every house should have. The actual physical houses built from that blueprint are the individual objects, each with its own wall colour and furniture.

This paradigm helps developers organise massive projects by keeping related code neatly packaged together in logical, reusable units.

• Classes act as blueprints for creating objects.
• Objects bundle data properties and behaviours together.
• Promotes code reuse and clean project organisation.

Arrays store items sequentially in continuous memory blocks, making it very fast to access any item if you know its numerical index. Linked lists store items anywhere in memory, using pointers to connect each item to the next one in line.

Think of an array as a row of numbered parking bays, where you can instantly find car number four. A linked list is like a treasure hunt, where each clue points you directly to the location of the next clue.

Choosing between arrays and linked lists depends on whether your program needs fast item lookups or frequent insertions and deletions.

• Arrays store items in contiguous memory blocks.
• Linked lists connect scattered items using pointers.
• Access speed versus insertion speed guides your choice.

Stacks and queues are specialised linear collections with strict rules about how items are added and removed. A stack follows last-in-first-out rules, meaning the last item added is the first one removed. A queue follows first-in-first-out, serving items in the exact order they arrived.

Imagine a stack of plates on a kitchen counter; you always take the top plate off first. A queue is like a checkout line at a supermarket, where the person who arrived first gets served first.

These structures are vital for managing tasks in operating systems, web browsers, and print spoolers.

• Stacks use last-in-first-out ordering principles.
• Queues use first-in-first-out ordering principles.
• Essential for managing tasks and function calls.

Hash tables store information in key-value pairs, using a mathematical formula called a hash function to compute exactly where each value is kept. This clever technique allows programs to find, update, or delete data almost instantly, regardless of how large the overall collection grows.

Think of a contact list in your phone. You type in a person's name as the key, and the phone instantly looks up their phone number value without scanning every single contact.

Hash tables are among the most useful structures in computer science, powering everything from database indexes to web caching systems.

• Store data using key-value pairs for quick access.
• Hash functions calculate exact storage locations.
• Provide near-instantaneous data lookups on average.

Trees and graphs are non-linear data structures used to model hierarchies and complex networks. A tree starts at a single root node and branches downwards into child nodes without loops. A graph is an interconnected network of nodes linked by edges, allowing relationships to point in any direction.

Think of a family tree showing parents and children branching downwards. A social network like LinkedIn is a graph, where people are nodes and connections are edges linking them together.

These structures are essential for representing maps, file directories, and social connections in modern software.

• Trees represent hierarchical parent-child relationships.
• Graphs model complex networks of interconnected nodes.
• Crucial for routing, navigation, and social features.

Big O notation is a mathematical way to describe how the running time or memory usage of an algorithm grows as the input data gets larger. It helps developers compare different solutions objectively, ensuring programs remain responsive when handling thousands or millions of users.

Imagine searching for a word in a pocket dictionary versus searching through a massive digital database. Big O gives us a label, like linear time or constant time, to describe how long that search takes as the dictionary grows thicker.

Understanding Big O stops you from choosing inefficient algorithms that crash production servers when traffic spikes unexpectedly.

• Measures how algorithm execution scales with input size.
• Focuses on worst-case performance scenarios.
• Helps compare efficiency of different code solutions.

Sorting arranges items in a specific order, whilst searching locates specific values within collections. Efficient algorithms like binary search cut search times dramatically by repeatedly halving sorted lists, whilst merge sort organises chaotic data sets quickly using divide-and-conquer strategies.

Think of looking for a name in a physical phone book. Instead of reading every page from the start, you open it near the middle, see if the name is before or after, and discard half the book instantly.

Mastering sorting and searching is a fundamental requirement for solving complex data problems efficiently in any programming language.

• Binary search requires sorted data to find items fast.
• Merge sort uses divide-and-conquer to order items.
• Efficient searching saves valuable processor time.

Recursion is a problem-solving technique where a function calls itself to break a large, complicated problem down into smaller, identical sub-problems. Every recursive function must include a base case to stop the repeating loop and prevent infinite crashes.

Imagine standing between two parallel mirrors, seeing an endless reflection of yourself getting smaller and smaller until you reach the furthest visible point.

Recursion provides elegant solutions for navigating complex tree structures and sorting algorithms, making your code shorter and more expressive.

• Functions call themselves to solve sub-problems.
• Must include a base case to stop execution.
• Great for traversing hierarchical tree structures.

Dynamic programming is an optimisation technique used to speed up complex algorithms by storing the results of expensive sub-problems. If the algorithm needs the same result again later, it retrieves the cached answer instead of recalculating it from scratch.

Think of doing a difficult maths puzzle where you write down the answer to each intermediate sum on a sticky note. When that same sum appears later in the puzzle, you just read the sticky note.

This technique turns impractically slow algorithms into lightning-fast solutions for problems involving optimisation and pathfinding.

• Caches results of sub-problems to avoid redundant work.
• Trades extra memory usage for faster execution speed.
• Ideal for overlapping recursive calculation problems.

The operating system is the master software layer that manages all physical hardware resources, organises system files, and coordinates running programs. It acts as an intermediary between your applications and the underlying computer processor, memory, and storage drives.

Think of the operating system like an airport air traffic controller. It directs flights, assigns runways, and manages arrivals and departures safely so all planes share the airspace without crashing.

Knowing how operating systems work helps you configure servers, manage file paths correctly, and troubleshoot performance bottlenecks in your applications.

• Manages hardware resources and peripheral devices.
• Provides file system organisation and security permissions.
• Acts as an intermediary for running user applications.

A process is an independent program instance running in memory with its own dedicated resources. A thread is a smaller unit of execution inside a process, allowing programs to perform multiple tasks concurrently by sharing the same memory space.

Imagine a large restaurant kitchen. The process is the entire restaurant operation, whilst threads are individual chefs working on different dishes at the same time to speed up service.

Proper thread management allows modern applications to stay responsive while downloading files or rendering graphics in the background.

• Processes run as independent execution units.
• Threads share memory inside a single process.
• Enables multitasking and responsive user interfaces.

Computer networking is the physical and logical infrastructure that allows different machines to communicate and share data. Devices connect via routers, switches, and cables or wireless signals, breaking information into small packets to transmit across local and global networks.

Think of the postal service. You write a letter, put it in an envelope with an address, and drop it in a mailbox. The postal network sorts and delivers it to the correct doorstep.

Understanding networking basics is essential for building web applications, connecting to APIs, and ensuring secure data transmission.

• Connects computers via local and global infrastructures.
• Breaks data into packets for transmission.
• Relies on routers and switches to direct traffic.

Network protocols are agreed communication standards that govern how data is formatted, transmitted, and received across networks. Protocols like TCP ensure reliable delivery, UDP prioritises speed, and HTTP powers the transfer of web pages across the internet.

Think of human languages and postal conventions. Both sender and receiver must agree on the language and address format, otherwise the message cannot be understood.

Knowing these protocols helps you design robust web services and debug network connection issues efficiently.

• TCP ensures reliable, ordered packet delivery.
• UDP prioritises speed for streaming and gaming.
• HTTP governs web browser and server communication.

Relational databases store information in structured tables made up of rows and columns. Tables are linked together using defined relationships and foreign keys, ensuring data remains organised, consistent, and easy to query across multiple connected entities.

Imagine a spreadsheet for an online shop. One table holds customer details, another holds product information, and a third records orders, linking customers to products using reference numbers.

Relational databases are the gold standard for applications requiring strict data integrity, such as banking systems and e-commerce checkouts.

• Stores data in structured tables with rows and columns.
• Links tables using primary and foreign keys.
• Ensures high data consistency and integrity.

Structured Query Language is the standard programming language used to interact with relational databases. With simple commands, you can retrieve specific records, insert new data entries, update existing information, and manage database security settings.

Think of Structured Query Language as asking a librarian a precise question, such as finding all science fiction books published after the year two thousand.

Mastering these query basics lets you extract valuable insights from stored data and build dynamic, data-driven applications.

• Standard language for querying relational databases.
• Uses commands like select, insert, update, and delete.
• Allows filtering and sorting of large datasets.

ACID properties are a set of database guarantees that ensure transactions are processed reliably. They stand for atomicity, consistency, isolation, and durability, protecting your data even if the server loses power mid-transaction.

Imagine transferring money from your savings to your checking account. If the power fails after money leaves savings but before it reaches checking, ACID rules roll back the change so no funds disappear.

These guarantees are critical for financial applications and any system where data corruption would cause serious business problems.

• Atomicity ensures transactions complete fully or not at all.
• Consistency maintains valid database state rules.
• Isolation and durability protect concurrent and permanent data.

Non-relational databases offer flexible schemas designed to store unstructured or semi-structured data. Instead of rigid tables, they use document stores, key-value pairs, or graphs, making them easy to scale horizontally across multiple servers.

Think of a filing cabinet where each folder contains a different type of form, rather than a strict spreadsheet grid where every cell must match.

NoSQL databases are ideal for real-time analytics, user session management, and apps with rapidly changing data requirements.

• Provides flexible schemas for unstructured data.
• Uses document, key-value, or graph storage models.
• Scales easily across distributed server clusters.