Free through lesson 3

IT Fundamentals for Beginners

From bits and information through base conversion, two's complement, logic operations, adders, CPUs, databases, networking, virtualisation and the cloud. Twenty lessons that replace "I memorised the term" with "I ran it and now it makes sense". Every piece of code and output shown was produced by actually running Python 3.14.2 (standard library only).

Start from lesson 1 Unlock every course

Curriculum

The 20 lessons are grouped into five chapters, and working through them in order is the best way. What you build in one lesson comes back in a later one (the XOR from lesson 6 becomes the adder in lesson 7, the adder in lesson 7 becomes the CPU in lesson 8, and that same XOR becomes RAID parity in lesson 19), so going straight through gets you there faster than dipping in. Note: the code runs inside the browser as it is (no third-party libraries).

Chapter 1 — Underlying theory (lessons 1–7)

Starting from 0 and 1, you assemble a circuit that performs addition. Information, base conversion, two's complement, shifts, floating point, logic operations and adders. This is the heart of the course.

1

Digital data and information (why 1TB shows as 931GB)

One bit is two possibilities; n bits are 2 to the n. The unit mismatch, sampling, quantisation and encoding, and character encodings, all confirmed in code.

Free
2

Base conversion (moving between binary, decimal and hex)

Multiply by the weights and add. Divide, then read the remainders bottom-up. Binary to hex is just grouping in fours. Including why 0.1 cannot be written out.

Free
3

Negative numbers and complements (a CPU has no subtraction circuit)

Flip the bits and add one and you get the number that sums to zero. Two's complement turns subtraction into addition, and how to spot an overflow.

Free
4

Shift operations (are they really faster? let us measure)

Shift and you double. Logical and arithmetic shifts differ only when you shift a negative number right. And we measure whether x << 3 really beats x * 8.

🔒 Basic
5

Numbers with a fractional part (why 0.1 + 0.2 is not 0.3)

Fixed point and floating point. Opening up the actual IEEE754 bits, then causing rounding, truncation, absorption and cancellation, and learning to avoid all four.

🔒 Basic
6

Logic operations and logic diagrams (you can build everything from NAND)

AND, OR, NOT, XOR, NAND and NOR. Confirming that NAND alone builds every circuit, and connecting De Morgan's laws to flags and masks.

🔒 Basic
7

Half adders and full adders (verified over 65,536 cases)

Building one-bit addition from XOR and AND alone, then lining them up into an 8-bit adder. Exhaustive verification, and doing subtraction with the same circuit.

🔒 Basic

Chapter 2 — Hardware and software (lessons 8–9)

How the circuit you assembled becomes a computer. The five functional units and how a CPU works, the memory hierarchy, the three categories of software and the role of an OS — all measured as you go.

8

The five units of a computer (building a 12-bit CPU)

Input, output, memory, arithmetic and control. Assembling and running a small CPU with 12-bit instructions, and on to what a for loop really is and the memory hierarchy.

🔒 Basic
9

The three categories of software and the OS (18.6x slower without a buffer)

The layers of system, middleware and application software. The five things an OS manages, the trade-off in scheduling, and how the number of system calls decides the speed.

🔒 Basic

Chapter 3 — Databases (lessons 10–14)

From tables and constraints to normalisation, SQL and indexes, transactions and failure management. You cause a lost update, and a condition that defeats an index, and see both for yourself.

10

Databases and tables (why a CSV will not do)

What tables, rows and columns are called, and six kinds of constraint. Comparing the same query over a full CSV scan, an unindexed database and an indexed one — a 752x difference.

🔒 Basic
11

Normalisation and database design (causing all three anomalies for real)

Causing update, insertion and deletion anomalies in an unnormalised table, then splitting it step by step into first, second and third normal form. Many-to-many is solved with a join table.

🔒 Basic
12

Working with a database (adding an index made it slower)

Writing relational algebra yourself to see what SQL really is. The difference between the order you write it and the order it runs. When an index helps, when it does not, and what it costs.

🔒 Basic
13

Transactions (85 items become 95)

ACID and the lost update. Causing the accident for real over two connections, and preventing it with a lock and with a single statement. Including isolation levels and deadlocks.

🔒 Basic
14

Failure management (what if you SIGKILL halfway through a transfer)

Write-ahead logging, journals and the WAL, rollback and roll-forward. Three backup strategies, and RPO and RTO.

🔒 Basic

Chapter 4 — Networking (lessons 15–18)

Transmission and packet switching, the OSI reference model, IP addresses and routing, DNS, DHCP and HTTP. You assemble packets from raw bytes yourself.

15

Networks and switching methods (bandwidth and latency are different things)

The factor of eight between bps and bytes. Three steps for computing transmission time. Circuit versus packet switching, the cost of headers, and the 36.8% ceiling on a shared line.

🔒 Basic
16

The OSI reference model (assembling it from bytes, then taking it apart)

The seven layers and the four of TCP/IP. Actually attaching TCP, IP and Ethernet headers to some HTTP, then peeling them off one at a time as the receiver.

🔒 Basic
17

IP addresses and routing (subnetting is just an AND)

Splitting 32 bits into a network part and a host part. Choosing the mask from how many hosts you need, and on to longest match and NAPT.

🔒 Basic
18

Network services (DNS goes from 363ms to 1.3ms)

The DNS hierarchy and caching, DHCP's DORA exchange, HTTP headers and statuses, and SMTP, POP, IMAP and MIME for mail.

🔒 Basic

Chapter 5 — Systems (lessons 19–20)

System architecture and reliability (availability and RAID), processing models, virtualisation and the cloud. Finally all 20 lessons come together on a single page.

19

System architecture and reliability (two machines turn 88 hours a year into 53 minutes)

Availability, MTBF and MTTR. In series you multiply; in parallel you subtract the product of the failure rates from one. RAID parity is XOR, and RAID is not a backup.

🔒 Basic
20

Processing models, virtualisation and the cloud (past 80% utilisation it climbs suddenly)

Verifying the queueing formula with a 200,000-run simulation. Virtualisation and containers, IaaS, PaaS and SaaS, and a round-up of all 20 lessons.

🔒 Basic

Once you have finished all 20 lessons, go deeper into the language itself in Python for Beginners, get hands-on with databases in Django for Beginners, or continue with containers and virtualisation in Docker for Beginners and Linux for Beginners. Membership unlocks every course.