How a computer is actually built, and why it works.

ICT (Information and Communication Technology) is the integration of computers and telecommunications for the purpose of communication and data processing. A few core terms sit underneath it: data is raw, unprocessed facts (numbers, letters, symbols); information is data that has been processed into something meaningful; a program is a set of instructions that tells a computer what to do and how to do it; and data processing is the set of activities that turns data into information.

Computers show up almost everywhere because the same core task — accept input, process it, produce output — maps onto very different problems:

These two terms are used almost interchangeably in casual speech, but on an exam they are distinct layers of the same system.

Computer architecture is the functional, programmer‑visible design of a system — the instruction set, addressing modes, registers, and data paths. It answers what the computer does, and it's decided first, before organisation.

Computer organisation is the physical implementation of that architecture — how the CPU, memory, and I/O devices are actually wired together and made to cooperate. It answers how the computer does it, and is decided after the architecture.

• Fast — completes in seconds what would take a person hours.
• Accurate — high precision regardless of task complexity.
• Versatile — the same machine handles typing, calculation, and media.
• Reliable — identical inputs reliably produce identical outputs.
• Has memory — stores and retrieves far more than human recall.
• Diligent — repetitive tasks don't cause fatigue or lapses in concentration.
• Largely automatic — runs with minimal ongoing human intervention.

A computer is built from a system unit (housing the CPU, motherboard, main memory, and drives) and peripheral devices (monitor, keyboard, mouse) connected through data cables and ports.

The motherboard is the circuit board every other component connects to — it carries the CPU socket, memory slots, expansion slots, and the chipset that coordinates data flow between them.

Fifteen things every motherboard manages:

• CPU socket — the electrical and mechanical mount for the processor.
• BIOS/UEFI firmware — initialises hardware at boot and hands off to the OS.
• CMOS battery — keeps BIOS settings and the system clock alive when the power is off.
• Northbridge / Southbridge (now mostly folded into a single chipset) — route high‑speed traffic to RAM/graphics, and lower‑speed traffic to USB/audio.
• Heat sinks & cooling — dissipate heat from the CPU and other hot components.
• Memory slots — hold RAM modules.
• Expansion slots — accept graphics, sound, and network cards.
• Chipset — manages data transfer between CPU, memory, and storage.
• Power connectors, USB, SATA, PCIe, audio, and networking headers — the physical connection points for everything else in the case.

The most common form factor — the physical shape and layout standard — is ATX, introduced in 1995; Micro‑ATX and Mini‑ITX serve smaller or budget builds. The power supply unit (PSU) converts wall or battery power into the regulated voltages every component needs.

By physical size and power — from most to least powerful:

By purpose: general‑purpose computers run whatever program is loaded onto them; special‑purpose computers (robots, calculators) are built to do one job well. Embedded computers are hidden inside another machine (a microwave, a car's engine controller); dedicated computers are general‑purpose machines permanently assigned to one task, such as payroll processing.

By the type of data processed: digital computers process discrete (0/1) data — this is essentially every modern computer; analog computers process continuous physical quantities like temperature or pressure; hybrid computers combine both.

Booting is the process of loading the operating system from disk into main memory so the computer becomes usable.

1. Power reaches the system unit; the cooling fan spins up.
2. POST (Power‑On Self‑Test) runs, directed by the BIOS/UEFI firmware stored in ROM on the motherboard — it checks that storage, input/output devices, and core components are working. A fault here halts booting and shows an error.
3. The system reads the current date and time from CMOS, a small battery‑backed memory chip.
4. The operating system is read from disk and loaded into RAM — this final step is booting proper — and the desktop appears.

Shutting down correctly matters: save all open work, close running programs, then use the operating system's shutdown command rather than cutting power directly — an abrupt power loss can corrupt files or damage components.

Input devices convert human‑readable input into a form the computer can process. They fall into five broad families:

Choosing an input device comes down to cost, speed, the volume of data expected, required accuracy, reliability, and the nature of the task.

Mouse

Pointing device

Photo: Sandstein / Wikimedia Commons (CC BY‑SA)

Keyboard

Keying device

Photo: MichaelMaggs / Wikimedia Commons (CC BY‑SA)

Scanner

OCR / OMR capture

Monitor

Primary output device

Photo: Konstantin Lanzet / Wikimedia Commons (CC BY‑SA)

Every processor, regardless of size, is built from three functional elements:

The Control Unit (CU) coordinates every processing activity using the system clock. It interprets each instruction fetched from memory, tells the ALU how to execute it, decides where results are stored, and tracks where the next instruction lives.

The Arithmetic and Logic Unit (ALU) performs the actual arithmetic (addition, multiplication, division) and logical operations (comparisons — greater than, equal to, less than) that make up every computation.

Main memory holds data and instructions immediately before and after processing.

A bus is an electrical pathway that carries signals between components. Three buses connect the ALU, CU, and memory:

This is how every single instruction gets carried out, over and over, for as long as the computer is running.

1. Fetch — the Program Counter (PC) holds the address of the next instruction; that address travels along the address bus, and the instruction itself travels back along the data bus into the Instruction Register (IR).
2. Decode — the CU interprets the instruction against the CPU's built‑in instruction set and prepares the relevant circuitry.
3. Execute — the operation is actually carried out (e.g. the ALU adds two values), and the result is stored in a register.

The processor then returns to the program counter for the next instruction, and repeats.

An instruction set architecture (ISA) is the vocabulary of commands a CPU understands — things like ADD, COMPARE, LOAD, STORE, and JUMP. Different processors (Intel and AMD, for example) can implement nearly the same ISA — the widely used x86 family — while having very different internal designs.

Pipelining improves throughput by overlapping instruction stages, much like an assembly line: while one instruction is executing, the next is being decoded, and the one after that is being fetched. A single instruction still passes through the same stages — fetch, decode, fetch operands, execute, memory access, write‑back — but multiple instructions are in flight simultaneously, so a new instruction can complete almost every clock cycle once the pipeline is full.

Pipelining isn't free: a pipeline stall happens when one instruction needs a result that hasn't been produced yet; a branch misprediction can force the pipeline to be flushed and refilled; and exceptions can interrupt the flow mid‑stream. Modern CPUs mitigate these with branch prediction and multi‑level caching.

These are two philosophies for how much work a single instruction should do.

A multicore processor packs two or more independent processing cores onto a single chip, letting the CPU genuinely run multiple instruction streams in parallel rather than just switching between them quickly.

Clock speed is measured in Hertz (Hz) — one cycle per second — and indicates how many instruction cycles the CPU can process in that time. Kilohertz, megahertz, and gigahertz describe thousands, millions, and billions of cycles per second respectively.

Von Neumann architecture, named after John von Neumann, popularised the stored‑program concept: both data and instructions live in the same memory and travel over the same bus. This made computers general‑purpose and easy to reprogram, but it also creates the well‑known Von Neumann bottleneck — the CPU can't fetch an instruction and read/write data at the same time, because they share one pathway.

Harvard architecture solves this by giving instructions and data separate memory spaces and buses, so both can be accessed simultaneously. This costs more and reduces flexibility (you can't easily treat instructions as data), but it removes the bottleneck — which is why it's the standard choice for embedded systems and digital signal processors, where speed and predictability matter more than general‑purpose flexibility.

Four factors define how a CPU will perform in practice:

1. Cores — each core is a complete processing unit with its own ALU, control unit, and registers; more cores means more programs can genuinely run at once.
2. Clock speed — how many cycles per second the CPU can execute, in MHz or GHz.
3. Cache size — a small pool of very fast memory sitting closer to the CPU than RAM, holding data likely to be reused.
4. Processor type — whether the design philosophy is CISC or RISC.

On Windows, the quickest way to check these is Task Manager → Performance tab → CPU, which shows core count, base speed, and current utilisation (covered in full in Chapter 6).

Read Only Memory (ROM) is non‑volatile: its contents survive power loss and, under normal operation, can be read but not rewritten. It stores firmware such as the POST routine, the BIOS/UEFI, and the bootstrap loader that finds and starts the operating system.

Photo: Wikimedia Commons (CC BY‑SA)

Random Access Memory (RAM) is volatile working storage: it holds whatever programs and data the CPU is actively using, can be read from and written to at any point, and loses everything when power is cut.

These "special‑purpose" memories sit inside or near the CPU to close the speed gap between a fast processor and slower memory or I/O devices.

Registers are the fastest memory in the system — tiny, high‑speed storage locations inside the CPU itself, each holding a single piece of data.

Buffers are temporary holding areas — often inside an I/O device such as a printer — that free the CPU from having to wait for slow peripherals; they can hold more than one item at a time.

Cache memory is very fast SRAM sitting between the CPU and main memory, holding data and instructions the processor is likely to reuse, which speeds up the fetch cycle.

• L1 cache — smallest and fastest, built directly into each core.
• L2 cache — larger, slightly slower, often per‑core or shared between a small group of cores.
• L3 cache — largest and slowest of the three, typically shared across all cores on the chip.

No single memory technology is simultaneously fast, large, and cheap — so systems layer several kinds together. The memory hierarchy exploits locality of reference (the tendency of a program to reuse the same or nearby data) by keeping frequently‑used data in the fastest, smallest, most expensive memory, and everything else further away.

Virtual memory lets the operating system use part of secondary storage (disk) to simulate additional RAM when physical memory is limited or heavily loaded. It maps the virtual addresses a program uses onto real physical addresses, and it means the machine keeps running — just more slowly — instead of running out of memory outright.

Benefits: larger effective memory for running big or many applications; memory isolation between processes (better security and stability); and simplified programming, since the OS manages allocation automatically.

Limitations: disk access is far slower than RAM, so heavy swapping causes thrashing — the system spends more time moving data than doing useful work; and it depends on having enough free disk space.

HDD

Spinning magnetic platters

Photo: Inklein / Wikimedia Commons (CC BY‑SA)

SSD

No moving parts

USB flash drive

Portable solid-state

Photo: Cjp24 / Wikimedia Commons (CC BY‑SA)

Optical disc

CD / DVD / Blu‑ray

Magnetic storage reads and writes data using magnetised material.

Optical storage reads and writes with a laser beam.

Solid‑state storage has no moving parts — it stores data purely electronically, like RAM but non‑volatile.

RAID (Redundant Array of Independent Disks) combines multiple physical drives into one logical unit for better performance, redundancy, or both.

RAID improves reliability and speed, but it is not a substitute for backups — it protects against drive failure, not against accidental deletion, corruption, or ransomware.

A byte is the basic addressable unit of memory — 8 bits, enough to represent one character.

Input–output (I/O) is the exchange of data between the computer system and the outside world — input devices bring data in, output devices present results, and backing storage devices hold data more permanently than RAM. Choosing peripherals well means matching their specifications (speed, accuracy, resolution, capacity) to what the user actually needs, rather than buying by feature count alone.

An I/O processor is a separate processor dedicated to handling input/output work, so the main CPU doesn't have to babysit slow peripherals — it hands off a task and gets the result later.

The Bus Interface Unit (BIU) manages all data and address transfers on the buses on behalf of the execution unit, including fetching instructions and reading/writing data and ports — the execution unit has no direct line to the system buses, so everything routes through the BIU.

An interface is the hardware circuitry that sits between the computer and an I/O device, handling the actual transfer of input/output.

There are three ways the CPU can move data to and from an I/O device, trading off simplicity against efficiency.

An I/O module can receive four kinds of command from the processor: Control (tell a peripheral what to do, e.g. rewind a tape), Test (check status — is it ready? did an error occur?), Read (pull data from the peripheral into a buffer), and Write (push data from the bus out to the peripheral).

A few units of measure first: a bit is a single binary digit (0 or 1); a nibble is 4 bits; a byte is 8 bits, the standard unit for one character; and a word is two or more bytes — commonly 16, 32, or 64 bits, describing how much data a CPU handles in one chunk.

Computers work with four number systems, each defined by its base (radix) — how many unique digits it uses before repeating with a new place value.

Every positional number system works the same way: each digit's contribution is digit × base^position, counting positions from 0 at the rightmost digit. For example, binary 1011₂ equals (1×2³) + (0×2²) + (1×2¹) + (1×2⁰) = 8 + 0 + 2 + 1 = 11 in decimal.

To convert a decimal number to binary by hand, repeatedly divide by 2 and record the remainders — reading them from bottom to top gives the binary result. For example, 30 ÷ 2 repeatedly gives remainders 0,1,1,1,1 (bottom to top), so 30₁₀ = 11110₂.

Octal‑to‑binary and hexadecimal‑to‑binary conversions are especially quick because each octal digit maps to exactly 3 binary digits, and each hex digit maps to exactly 4 — you can convert digit‑by‑digit without doing any arithmetic on the whole number at all.

Type a value into any one field — the other three update instantly. Use it to check your manual working, or to build intuition for how the same value looks across bases.

Coding schemes define how bit patterns map onto characters and numbers, so text and symbols can be stored and exchanged consistently.

Computers need a way to represent negative numbers using only 0s and 1s. There are three approaches:

1. Sign‑and‑magnitude — prefix an extra bit: 0 for positive, 1 for negative. Simple, but zero has two representations (+0 and −0).
2. One's complement — flip every bit (a "bitwise NOT") to get the negative of a number. Also has two representations of zero.
3. Two's complement — flip every bit, then add 1. This is what real computers use, because zero has exactly one representation, and addition/subtraction work correctly without any special‑case circuitry for the sign.

Addition follows four simple rules, the same way decimal addition follows the "carry the 1" rule:

The ALU doesn't have separate subtraction circuitry — it performs subtraction by addition, using two's complement: to compute A − B, it takes the two's complement of B and adds it to A. Multiplication and division are handled by repeated shifting and adding, rather than dedicated multiply/divide logic in the simplest designs.

An integer is a whole number with no fractional part. A floating‑point number represents real numbers — ones with a fractional component, like 5.5 or −2345.6789 — using a fixed number of bits split into three fields, standardised by IEEE 754 so every compliant system computes the same result:

• Sign bit (S) — 0 for positive, 1 for negative.
• Exponent (E) — the scale of the number, stored with a bias.
• Mantissa / fraction (F) — the significant digits.

This is why floating‑point arithmetic can introduce small rounding errors: a fixed number of bits can't exactly represent every possible real number, the same way ⅓ can't be written exactly as a finite decimal.

Every digital circuit — including the entire CPU — is built from combinations of a handful of logic gates, each implementing one Boolean operation.

NAND and NOR are called universal gates — either one, on its own, can be wired together to reproduce every other logic gate, which is why real chips are often built almost entirely from just one of them.

A Karnaugh map (K‑map), developed by Maurice Karnaugh in 1953, is a grid‑based way to simplify a Boolean expression without grinding through algebraic manipulation. Each cell represents one possible combination of input values, arranged so that only a single bit changes between any two adjacent cells (Gray code order) — that arrangement makes groups of neighbouring 1s easy to spot visually, and each group you circle corresponds to a simplified term in the final expression. It's essentially a specially laid‑out truth table designed to make simplification visual rather than algebraic.

Open it with Ctrl + Shift + Esc, or right‑click the taskbar and choose Task Manager, or run taskmgr from the Run dialog (Win + R).

Open it by typing perfmon into the Run dialog (Win + R). It goes beyond Task Manager's live view by letting you track specific counters (like % Processor Time or Available MBytes) over time, and save that history as a Data Collector Set you can revisit later — useful for diagnosing intermittent performance problems rather than just glancing at a snapshot.

Disk partitioning divides one physical drive into separate logical sections, each behaving like an independent disk — useful for keeping the operating system, data, and multiple OS installs separate. On Windows this is done through Disk Management (search for it in the Start menu).

Virtual memory (page file) settings are found under System Properties → Advanced → Performance → Settings → Advanced → Virtual Memory, where you can let Windows manage the paging file automatically or set a custom size per drive.