A computer follows very simple instructions, extremely fast. This guide builds the picture from tiny switches and logic gates to binary, the CPU's three-step loop, memory and software, with diagrams and worked examples you can do by hand.
A computer does not think or understand. It follows a huge number of very simple instructions, extremely fast and without ever getting tired or bored. Underneath every app, game and website sits the same short list of ideas: tiny electronic switches that are either on or off, simple logic built from those switches, numbers written with just two digits, a processor that repeats one three-step cycle billions of times a second, and memory that holds what it is working on. This guide builds the whole picture from the ground up, with worked examples you can do by hand, so that a computer stops feeling like magic.
A computer is a machine that takes in information (input), follows instructions to process it, stores information, and produces a result (output). Under that broad definition, a calculator, a washing machine's control panel and a supercomputer all count. What makes a modern computer special is that it is programmable and general-purpose: the same physical machine can run a spreadsheet, play a video or control a robot, just by loading different instructions. That idea goes back to Charles Babbage's designs and Alan Turing's theory (see The History of Computing).
The basic building block of a modern computer is the transistor, a tiny electronic switch with no moving parts. It lets current flow or blocks it, depending on a control signal. A switch has two reliable states, on and off, which we write as 1 and 0. A modern processor contains billions of transistors.
Combining a few transistors makes a logic gate, a circuit that takes one or more 1/0 inputs and gives a single 1/0 output according to a rule:
| Gate | Rule | Output is 1 when... |
|---|---|---|
| NOT | Flips the input | the input is 0 |
| AND | Both inputs must be 1 | A is 1 and B is 1 |
| OR | At least one input is 1 | A is 1 or B is 1 (or both) |
| XOR | Exactly one input is 1 | A and B are different |
It may seem impossible that such simple rules could add numbers, show video or run a game. But gates can be wired together, and wired-together gates can do arithmetic, compare values and remember information. Everything a computer does is built in layers on top of these simple rules.
A half adder adds two single bits, A and B. It has two outputs: Sum = A XOR B, and Carry = A AND B.
| A | B | Sum (XOR) | Carry (AND) | Result |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 00 = 0 |
| 0 | 1 | 1 | 0 | 01 = 1 |
| 1 | 0 | 1 | 0 | 01 = 1 |
| 1 | 1 | 0 | 1 | 10 = 2 |
Check the last row: 1 + 1 = 2. In binary, two is written 10 (one two, no ones). The sum bit is 0 and the carry bit is 1, exactly as in decimal when 5 + 5 gives 0 and carries 1.
Going further: to add longer numbers, a full adder also accepts a carry from the previous column. A row of full adders adds numbers of any size. So arithmetic, the heart of a computer, is nothing more than gates arranged cleverly.
Because the hardware has two states, computers store everything with binary (base 2). Each 0 or 1 is a bit (binary digit). Eight bits make a byte. Place values double as you move left, in the same way decimal place values multiply by ten: 1, 2, 4, 8, 16, 32, 64, 128 and so on. An n-bit number can take 2n different values, so 8 bits give 28 = 256 values (0 to 255).
Decimal 45 to binary. Write the 8 place values: 128, 64, 32, 16, 8, 4, 2, 1.
Reading the digits from left to right: 00101101. Check: 32 + 8 + 4 + 1 = 45. ✓
Binary 01100100 to decimal. Add the place values wherever there is a 1: 64 + 32 + 4 = 100.
A limit to know: the biggest 8-bit number is 11111111 = 255. Adding 1 needs a ninth bit. If only 8 bits are kept, the result wraps round to 00000000. This is called overflow, and it is the reason programs choose number sizes carefully.
Bits have no meaning on their own. Meaning comes from an agreed way of reading them:
Colours: with 3 bytes (24 bits) per pixel, the number of possible colours is 224 = 16,777,216.
A photo: a full-HD image is 1,920 × 1,080 pixels = 2,073,600 pixels. At 3 bytes each: 2,073,600 × 3 = 6,220,800 bytes, which is about 6.2 MB if stored with no compression.
A song: CD-quality sound takes 44,100 samples per second, each of 2 bytes (16 bits), on 2 channels (stereo). Bytes per second: 44,100 × 2 × 2 = 176,400. For a 3-minute song (180 seconds): 176,400 × 180 = 31,752,000 bytes, about 31.8 MB.
Why files are usually smaller: compression, as used by JPEG images and MP3 or AAC audio, removes repeated or less noticeable detail, so real files are often many times smaller than these raw figures.
A note on units: in storage, 1 kilobyte is usually 1,000 bytes and 1 megabyte is 1,000,000 bytes. Some software instead counts in units of 1,024, which is why the same drive can show slightly different sizes.
The physical parts are called hardware. Four do most of the work, and the rest connect them:
| Memory type | Speed | Size (typical) | Keeps data when off? |
|---|---|---|---|
| CPU registers and cache | Fastest | Tiny (bytes to megabytes) | No |
| RAM | Very fast | Gigabytes | No |
| SSD | Fast | Hundreds of gigabytes to terabytes | Yes |
| Hard disk | Slower | Terabytes | Yes |
This pattern is called a memory hierarchy: the faster the memory, the smaller and more expensive it is. Computers keep what they need most right now in the fast, small levels and the rest in the slow, large levels.
Whatever a program does, the CPU repeats the same loop, called the fetch-decode-execute cycle:
Imagine a very simple processor with one working register called A, and this four-instruction program stored in memory:
LOAD 5 puts the number 5 into A.ADD 3 adds 3 to A.STORE 7 copies A into memory location 7.HALT stops.| After instruction | Register A | Memory location 7 |
|---|---|---|
| (start) | 0 | 0 |
| LOAD 5 | 5 | 0 |
| ADD 3 | 8 | 0 |
| STORE 7 | 8 | 8 |
Result: location 7 now holds 8, which is 5 + 3.
How long would it take? Three instructions with 3 steps each (fetch, decode, execute) is 9 steps. If each step took one tick of a 3 GHz clock (3,000,000,000 ticks per second), each tick lasts 1 ÷ 3,000,000,000 ≈ 0.33 nanoseconds, so 9 ticks ≈ 3 nanoseconds. That is an idealised figure, since real instructions often take more ticks, but it shows how enormous the speed is.
A neat consequence: light travels about 30 cm in a nanosecond, so in one tick of a 3 GHz clock it moves only about 10 cm. Signals cannot cross a large chip instantly, which is one reason processors are built small.
Software is the set of instructions that tells hardware what to do. There are layers of it:
The processor can only run its own machine code, which is a list of binary instructions specific to that type of CPU. People rarely write that directly. They write in a programming language such as Python or JavaScript, which is much closer to human language. A compiler translates the whole program into machine code in advance, while an interpreter translates and runs it step by step. See What Is Coding? for more.
Watch what happens when you press the letter "A" while typing a message:
All of that takes a few thousandths of a second, so it feels instant. At no point does anything in the machine "know" what the letter means. Each step simply moves numbers and applies rules.
Most computers do not look like computers. Chips called microcontrollers sit inside washing machines, cars, thermostats and toys, running one fixed program. Phones and laptops are general-purpose computers. Servers in data centres answer requests from many users (see Cloud Computing), and supercomputers link enormous numbers of processors to tackle scientific problems such as weather forecasting. They differ in size, power and purpose, but the same ideas run through them all: bits, gates, a processor looping through instructions, and memory.
Try each question first, then tap it to reveal the answer. A scored multiple-choice quiz follows below.
A bit is a single 0 or 1. A byte is a group of 8 bits.
0, because AND gives 1 only when both inputs are 1.
16 + 4 = 20, so the bits are 00010100.
1,000 × 1,000 = 1,000,000 pixels. 1,000,000 × 3 = 3,000,000 bytes, about 3 MB.
RAM needs a constant electrical supply to hold its contents (it is volatile). An SSD uses flash memory that keeps its stored state without power.
Fetch the instruction, decode it, execute it. Then the cycle repeats.
Human logic gates: let two students hold up cards showing 0 or 1 as inputs, and a third student acts as an AND, OR or XOR gate, announcing the output. Chain two gates to make a half adder, as in Worked Example 1.
Binary bracelet: students write their initials in ASCII binary (A = 01000001) and make a bracelet using two bead colours for 0 and 1.
Pixel art: on squared paper, students draw a small picture, write each row as a binary number, and swap the numbers with a partner to rebuild each other's picture, as in Figure 3.
Be the CPU: give a student a card-based program like Worked Example 4 and a "register" whiteboard, and let them carry out fetch, decode and execute out loud.
Safety note: take care when opening computers. Unplug and ask an adult before opening one, and do not touch the power supply. Old devices should be recycled responsibly.
This article is original EDUSAMBAM writing. It follows the standard layered view of computer systems taught in university courses, and the numbers in the worked examples are plain arithmetic. All diagrams are original EDUSAMBAM schematics, and the tiny processor in Worked Example 4 is an invented teaching model, not a real instruction set.
Hardware changes quickly, so check current specifications for any device you are considering. This article does not recommend any particular brand or product.
10 questions. Select an answer for each, then submit to see your score instantly.