One video per sub-topic, in syllabus order. Start the playlist and it keeps playing in a corner of the screen while you read the written notes — it does not stop when you move to another page.
Cambridge IGCSE Computer Science 0478 — the complete course. Every topic, every sub-topic, one video each: 64 lessons across all 10 topics, matched to the 2026–2028 syllabus. Where something has to be seen to be understood, it is shown working rather than described.
Why computers count in twos and programmers count in sixteens
Converting both ways, and the maximum a byte can hold
Base 16, why programmers use it, and converting both ways
Adding bits, carrying, and what happens when a byte runs out of room
ASCII and Unicode — how a computer that only holds numbers stores letters
Turning characters into bits, and calculating what the file will cost
Pixels, colour depth, and calculating what an image costs to store
Sampling a wave, and the two settings that decide quality and size
Why a 1 TB drive shows as 931 GB — the two standards, and converting between units
Lossy and lossless — and the run-length encoding you can do by hand
Direction, serial and parallel, and why distance changes the answer
Memory hooks for serial, parallel, duplex and USB — and where each one breaks
Wired and wireless, and how to justify a choice in an exam
Splitting data, routing each piece independently, and putting it back together
Parity, checksums, echo checks, ARQ and check digits — and which one actually repairs the data
Why a stolen message can be useless, and why only one of the two methods survives an interceptor
The stored program idea, what sits inside the processor and what does not, and the instruction set
What each register holds, which bus carries what, and why the program counter is incremented
What each bus carries, why only one is one-way, and what bus width decides
The three things that make a CPU faster — and why each one stops helping
How each device turns something physical into binary — and why the order of the steps is the answer
Screens, projectors, the three printers and the speaker — each one as a sequence you can write down
Fourteen sensors, the ADC, and the control loop that has to repeat
RAM and ROM, the two types of each, and why cache is made of different stuff from main memory
Magnetic, optical and solid state — how each one physically holds a bit, and which to choose
Using the hard disk as extra RAM — what it buys, and the point at which it stops helping
Someone else's data centre — the three deployment types, and what you give up for what you gain
Every device on the diagram, and the one question that tells them apart
Two addresses on every device — what each identifies, and why one of them changes
System, application and firmware — and the seven jobs the OS is actually doing
Why the CPU stops, how it resumes, and why a printer needs both mechanisms at once
The programs that maintain the system rather than serve the user
High-level and low-level, and why the choice is about who the code is written for
Compiler, interpreter, assembler — and the tools that sit around them
The network and what runs on it — plus how a typed address becomes a page on your screen
Small text files a website stores on your device — what they can and cannot do
Money with no bank behind it — and the ledger that replaces the bank
What each attack targets — the machine, the password, or the person
Matching the defence to the threat — and why one measure can never be enough
Sensors, microprocessor, actuators — the loop that runs without anyone watching
The one difference that decides which kind of system you are describing
What makes a machine a robot, where they are used, and what they cost as well as save
What AI is, the three types, and how an expert system actually reaches a conclusion
Learning the rules from data instead of being given them
Abstraction, decomposition, and the development cycle they sit inside
Six shapes, and the rules that decide which one you need
Decomposing a system into sub-systems — and describing each by what goes in and out
Following an algorithm line by line — the skill that finds logic errors
Six patterns that appear in almost every algorithm question
Two different jobs — is the data sensible, and is it what was meant?
Four kinds of test data, and how to choose values that actually prove something
The five faults that appear most often — and a method for finding any of them
The five data types, variables against constants, and why declaring things matters
Sequence, selection and iteration — and which loop to reach for
The operators you compute with, and the routines you are given for free
Subroutines, what they return, what they can see, and what they can change
Two full programs, assembled from patterns you already know
One name for many values — and the nested loop that walks a table
Making data survive the program closing — in the pseudocode the paper uses
Fields, records, the primary key, and choosing the right data type
Asking a database a question — and seeing exactly which rows come back
What each gate does, and the truth table that defines it
Turning a written scenario into an expression and a truth table
Moving between expression, truth table and circuit — in every direction the syllabus asks for