Fundamentals of Computer Systems

Go deeper · A1

A closer look inside three kinds of computer

Every computer has the same basic jobs (input, processing, storage, output), but designers package the parts very differently depending on the job. Compare the three diagrams below and look for what changes: how easy parts are to replace, how much power they use, and how much is duplicated.

A desktop PC is built from separate parts joined by the motherboard. Because the RAM, storage and graphics card sit in standard slots, a technician can upgrade or replace one part without replacing the whole computer. Laptops use similar parts, but many are soldered to the board to save space, so they are harder to upgrade.

A phone must be thin, light and last all day on a battery. Instead of many separate chips, it uses a System on a Chip (SoC) that combines the CPU cores, graphics, an AI engine and the mobile modem. Storage is NAND flash, which is non-volatile and has no moving parts. Sensors such as the accelerometer, gyroscope, GPS receiver and proximity sensor are inputs that most desktop PCs do not have.

A server provides a service to many client computers at once, so a failure affects everyone. That is why servers have lots of RAM, many CPU cores, and redundant parts: two power supplies, two network connections and drives in a RAID array, often all in a rack with an uninterruptible power supply (UPS).

Why speed depends on the slowest part

The CPU can only work on data that has been copied close to it. If data has to come from a slow hard disc or across a busy network, the fastest CPU still waits. This is called a bottleneck. When you recommend hardware, find the part that is holding the system back for that user, rather than simply choosing the biggest numbers.

Keeping data available: RAID and NAS

A NAS (network attached storage) is a small computer whose only job is to share its drives over a network. It usually contains two or more drives in a RAID array, so that one drive failing does not lose the files. Remember the difference: RAID keeps a system running when a disc fails; a backup lets you recover from deletion, ransomware, theft or fire.

Go deeper · A2

What the operating system is really doing

The kernel is the part of the operating system that is always running. It decides which program uses the CPU next (scheduling), gives each program its own area of memory, reads and writes files through the file system, and talks to hardware through device drivers. Programs run in a restricted user mode; only the kernel runs in the privileged kernel mode, so a crashing app cannot take the whole computer down.

An interrupt is a signal that asks the CPU for attention: a key press, a network packet arriving, or a disc finishing a read. Instead of checking every device constantly, the CPU gets on with its work until an interrupt arrives. The kernel then runs the matching interrupt handler and returns to what it was doing.

Utility and application software

Utility software looks after the computer itself: antivirus and firewalls protect it, backup tools copy data, disc tools clean up and (for hard discs) defragment, compression tools make files smaller and encryption tools protect data. Application software helps a person do a task, such as writing, calculating, editing video or booking appointments.

Go deeper · A3

From raw data to useful information

Data is collected by hardware such as sensors, barcode scanners, RFID readers, card readers, cameras and keyboards, and by software such as online forms, apps that log activity, and systems that import data from other systems. Automatic collection (a sensor or scanner) is fast and avoids typing errors; manual collection (a person typing) is flexible but slower and error-prone.

Validation stops impossible data, but it cannot tell whether data is true. Verification checks that data was copied correctly, for example by typing a password twice or by a person comparing the screen with the paper form.

Data stored across more than one system

Go deeper · B1

Two ways to connect the CPU to memory

In the stored program model, the program is held in memory just like data, so a computer can switch jobs simply by loading a different program. Early computers were rewired or re-switched for each new task. In a von Neumann machine, instructions and data share one memory and one bus, which is simple and flexible. In a Harvard machine they are separate, so the next instruction can be fetched while data is being read. Small controllers such as those in microwaves, washing machines and Arduino-style boards often use Harvard designs; modern PC processors mix both, with separate instruction and data caches in front of one main memory.

Many processors working together

A cluster links many computers, called nodes, with a fast network. Big jobs such as weather forecasting, film rendering or searching huge datasets are split into parts that run at the same time. Clusters can grow by adding nodes, and they keep working if one node fails. The cost is the network: sending data between nodes is far slower than inside one computer, so the job must split into parts that do not need to talk to each other often.

Emulation

Go deeper · B2

The instruction cycle in more detail

Every program, from a game to a spreadsheet, is turned into millions of simple machine instructions such as load a number, add, compare and jump. The list of instructions a processor understands is its instruction set. A 3 GHz clock ticks three billion times a second, so one tick lasts about 0.33 nanoseconds.

Pipelining

Cores, threads and cache

A multi-core processor has several complete processing units on one chip; multi-processing means using more than one of them at the same time. A program can be written as several threads, flows of work that the OS can run on different cores. Some cores can also run two threads at once, switching to the second thread whenever the first is waiting for memory. Cache keeps copies of recently used instructions and data close to the core: a cache hit is fast; a cache miss means a much slower trip to RAM.

Go deeper · B3

Where the registers sit

Registers are the fastest storage in the whole computer because they are part of the CPU itself, but there are only a few of them. General-purpose registers hold values a program is working on, such as a loop counter. Special registers have one fixed job in the instruction cycle. A 64-bit processor has 64-bit registers, so it can move or add 8 bytes in one step.

Interrupts

Go deeper · C1

Units, and why 1,000 is not always 1,000

Hexadecimal: a short way to write binary

Programmers and technicians use hexadecimal (base 16) because it is much easier to read than long binary strings but converts to binary instantly. You will see it in colour codes such as #FF8000, network MAC addresses such as 3C:22:FB:19:A0:7E, and memory addresses in error messages.

Binary arithmetic

Negative numbers and fractions

Binary coded decimal (BCD) stores each denary digit in its own nibble. It is less efficient than pure binary but converts easily to the digits on a display, which is why calculators, digital clocks and some financial systems use it. When a BCD digit adds up to more than 9, add 0110 (6) to correct it and carry into the next digit.

Go deeper · C2

Inside the ASCII code

ASCII uses 7 bits, giving 128 codes: control codes (such as new line), the space, digits, punctuation and the English upper and lower case letters. Many systems use an 8-bit extended ASCII with 256 codes, but different countries filled the extra 128 codes differently, so a file could show the wrong symbols on another computer.

Unicode solves this by giving one agreed number, a code point, to more than 150,000 characters from almost every writing system, plus symbols and emoji. UTF-8 is the most common way to store those code points as bytes. The first 128 Unicode code points are the same as ASCII, which made the change-over much easier.

Go deeper · C3

From pixels to bits

Compression

Screens make colours by adding red, green and blue light (RGB). Printers work the other way, mixing cyan, magenta, yellow and black ink (CMYK) that absorbs light. Images for print are therefore often converted, and a colour that looks bright on screen may print duller.

Go deeper · D1

Seeing the structures

Stacks and queues are defined by where items can be added and removed, not by how they are stored. Both can be built inside an array, using a variable (a pointer) to remember where the top, front or rear is. In a circular queue the rear wraps round to the start of the array when it reaches the end, so the free spaces at the front can be reused.

Data types

Choosing the right type matters: storing a phone number as an integer would lose the leading zero and allow nonsense such as adding two phone numbers together, so it should be a string. Storing money as a float can create rounding errors, so money is often held as a whole number of pence.

Go deeper · D2

Arrays of any size

A program can calculate where any item is stored without searching. For a grid with R rows and C columns stored in row-major order, item [row][col] is at offset row × C + col. In column-major order it is at col × R + row. Multiplying the offset by the size of each item gives the byte position. Reading memory in the order it is stored is faster, because nearby items arrive in cache together.

Calculating with matrices

Go deeper · E1

Channels and connections

Packets, frames and protocols

A protocol is a set of rules both sides agree to follow: the speed, the packet size and format, how the connection starts (a handshake), how errors are detected and corrected, and whether data is compressed or encrypted. Without shared protocols, devices from different makers could not understand each other.

Keeping data private: encryption

Go deeper · E2

Why errors happen

Errors are more likely over long cables, weak wireless signals, near electrical machinery, or when many wires run side by side. Error detection adds a little extra data calculated from the message. The receiver repeats the calculation: if its answer is different, something changed on the way.

Go deeper · E3

Asking again: ARQ

Automatic repeat request needs error detection (such as a CRC), acknowledgements (ACKs) and a timer. It sends as little extra data as possible, but each error costs a round trip. That is fine on a fast local network, but painful on a satellite link where each round trip takes over half a second.

Fixing it at the receiver: FEC

Real systems use cleverer forward error correction codes than simple repetition. A Hamming code mixes a few parity bits into the data so that the pattern of failed parity checks points to the exact bit that flipped, which can then be flipped back. The same idea lets RAID rebuild a lost disc, lets a scratched CD still play, and lets a QR code be read even when part of it is covered.

Go deeper · F1

Every gate at a glance

Written Boolean expressions use a dot for AND (A.B), a plus for OR (A + B), a bar over a letter for NOT (Ā) and ⊕ for XOR. You may also see ∧ for AND, ∨ for OR and ¬ for NOT. Just like in maths, brackets are worked out first, then NOT, then AND, then OR.

How a computer adds

Simplifying with a Karnaugh map

Go deeper · F2

The symbols

A complete flowchart

Seeing the whole system

A flowchart shows the steps of one process in order. A system diagram shows the big picture: the people and other systems involved, the processes, the stored data and the data flowing between them. Label every arrow with the data it carries. If a process has data going in but nothing coming out, something is missing.