Master Computer Science Through Real Courses

Algorithms & Complexity

Most people learn algorithms by memorizing solutions. This course does the opposite it teaches you to *think* algorithmically, so you can solve problems you've never seen before. You'll start from first principles: what an algorithm actually is, what makes one better than another, and how to measure that difference rigorously using Big-O notation. From there you'll work through the essential algorithm families searching, sorting, recursion and the data structures that make them possible. By the end, you won't just know how bubble sort or binary search work. You'll understand *why* they work, *when* to use them, and *what to reach for* when neither fits. **What you'll cover:** - What algorithms are and how to design them - Time and space complexity analysis with Big-O notation - Linear search and binary search (including edge cases) - Bubble, selection, insertion, and merge sort and how to choose between them - Recursion, the call stack, and recursion vs. iteration - Arrays, stacks, queues, and linked lists **Who this is for:** Anyone who wants to move beyond writing code that "works" and start writing code that's *correct and efficient* whether you're preparing for technical interviews, university coursework, or just want to think sharper. **Prerequisites:** Basic programming in any language. You don't need to be an expert you just need to know what a variable, loop, and function are.

Computer Architecture

Every line of code you write eventually becomes electricity. This course explains exactly how that happens. Computer Architecture bridges the gap between software and hardware the layer most developers never see but always depend on. You'll start at the lowest level (transistors and logic gates), build up through number systems and circuits, and arrive at a full picture of how a CPU fetches, decodes, and executes your code. Along the way you'll understand why cache matters, what a pipeline hazard is, and why some programs are faster than others on the exact same machine. This isn't a theory course. Every concept connects directly to something a programmer or engineer encounters in the real world. **What you'll cover:** - Digital signals, transistors, clock cycles, and voltage logic - Binary, hexadecimal, two's complement, and floating-point numbers - Logic gates, Boolean algebra, adder circuits - CPU internals: registers, ALU, fetch-decode-execute cycle, pipelining - Memory hierarchy: SRAM, DRAM, cache, virtual memory - I/O systems, buses, interrupts, and DMA - Performance metrics: CPI, Amdahl's Law, bottleneck analysis - Instruction Set Architecture (ISA) and reading assembly **Who this is for:** Computer science students, self-taught developers curious about what's "under the hood," and anyone preparing for systems-level roles or low-level programming. **Prerequisites:** Basic comfort with binary numbers helps but isn't required. No programming experience is assumed though if you write code, this course will change how you think about it.

Computer Architecture & Operating Systems Essentials

Computer Networks

Every time you open a browser, stream a video, or send a message, dozens of invisible systems work together in milliseconds to make it happen. This course shows you exactly how. Starting from the physical layer signals and cables you'll work your way up through the full network stack to the application protocols you use every day. Along the way you'll build genuine intuition for how data actually moves across the internet: how it gets addressed, routed, verified, and reassembled at the other end. Each unit closes with a Boss Challenge a real-world scenario where you apply what you've learned to debug, design, or trace a complete network interaction. **What you'll cover:** - How the internet works: packets, switching, OSI and TCP/IP models - Physical and link layer: signals, encoding, error detection, Ethernet, switches - Network layer: IPv4, subnetting, CIDR, routing, ARP, NAT - Transport layer: ports, sockets, UDP, TCP, the 3-way handshake, flow control - Application layer: DNS, HTTP/HTTPS, TLS, and real-world protocols **Who this is for:** Developers who want to understand what happens beneath their API calls, students preparing for networking certifications or CS exams, and anyone who's ever wondered what actually happens when you type a URL. **Prerequisites:** No networking experience required. Basic familiarity with how computers work is helpful but not mandatory.

Computer Networks & Web Mechanics

Database Systems

Almost every application in existence stores data. This course teaches you to design, query, and understand the systems that do it well. You'll begin by understanding why databases exist at all what problems they solve that plain files can't then move into SQL, the universal language of relational databases. From there, you'll learn how to design a proper schema from scratch, write queries that span multiple tables, and understand the internals that determine why some databases fly and others crawl. This course is practical from the first lesson. You'll be writing real SQL by the end of Unit 1. **What you'll cover:** - Why databases exist and how they differ from file storage - The relational model: tables, rows, columns, and data types - SQL fundamentals: SELECT, WHERE, INSERT, UPDATE, DELETE, ORDER BY, NULL - Database design: entities, relationships, cardinality, ER diagrams - Normalisation from 1NF to 3NF and why it matters - Joins: INNER, LEFT, RIGHT, FULL - Aggregate functions, HAVING, and subqueries - Transactions, ACID properties, indexes, views, and constraints **Who this is for:** Developers building applications that store data, students studying CS or data-related fields, and anyone who wants to go from "I can write a SELECT statement" to genuinely understanding relational databases. **Prerequisites:** No prior database experience needed. Basic programming literacy is helpful for the SQL sections.

linux command line essentials

Operating Systems

Your operating system is running right now managing memory, switching between processes, reading from disk and most developers never think about it. This course changes that. Operating Systems is one of the hardest and most important subjects in computer science. This course makes it approachable without dumbing it down. You'll learn how an OS manages processes, schedules CPU time, handles memory, and controls I/O all with hands-on simulator labs that let you see these systems in action rather than just reading about them. By the end, you'll have a mental model of what happens on your machine between the moment you run a program and the moment you see output. **What you'll cover:** - What an OS actually does: kernel, shell, system calls, and the boot process - Processes and threads: lifecycle, scheduling, context switching - CPU scheduling algorithms: FCFS, SJF, Round Robin, multilevel queues - Process synchronisation: critical sections, mutex locks, semaphores, deadlock - Memory management: logical vs. physical addressing, paging, contiguous allocation - Virtual memory: page replacement algorithms, page faults, thrashing - File systems and I/O: allocation methods, disk scheduling, hardware and software layers **Who this is for:** CS students taking their first OS course, developers who want to understand performance at the system level, and anyone preparing for interviews where OS internals come up. **Prerequisites:** A solid understanding of basic programming. Familiarity with processes and memory at a high level is helpful but not required the course builds up from first principles.

Problem Solving & Python Fundamentals

Relational Databases & SQL Fundamentals

Software Engineering / Design Patterns

Writing code that works is the easy part. Writing code that holds together six months later, when requirements change and your team doubles in size that's what this course is about. Software Engineering & Design Patterns covers the principles and patterns that professional developers use to build systems that are maintainable, extensible, and actually understandable by other humans. You'll move from the fundamentals of the software development lifecycle through OOP principles and SOLID, then into the classic Gang of Four design patterns creational, structural, and behavioral and finally to the architectural patterns that structure entire applications. Every pattern is taught in context: not just "here's how it works" but "here's the problem it solves and what goes wrong without it." **What you'll cover:** - Software engineering fundamentals: SDLC phases, Agile vs. Waterfall - OOP recap and the SOLID principles - Design heuristics: DRY, KISS, YAGNI, coupling and cohesion - Creational patterns: Singleton, Factory Method, Abstract Factory, Builder - Structural patterns: Adapter, Decorator, Facade, Proxy - Behavioral patterns: Observer, Strategy, Command, Template Method - Architectural patterns: MVC, Repository, Dependency Injection - Anti-patterns: what to recognize and how to refactor out of them **Who this is for:** Intermediate developers who can write working code but want to level up their design skills, CS students studying software engineering, and anyone who's inherited a codebase and thought "why is this so hard to change?" **Prerequisites:** Comfortable with OOP in at least one language (Python, Java, C#, or similar). You should know what a class and interface are before starting.

Software Lifecycle, Testing & Design Awareness