What a computer is, how it works, the history from abacus to microprocessors, data representation in binary, and how every concept connects to modern VLSI chip design.
A computer is an electronic machine that:
A computer can store and manipulate large quantities of data at very high speed — but it cannot think. Every decision a computer makes is based on simple comparisons: is one number larger than another? Is this value zero? Is this bit a 1 or a 0? These comparisons, executed billions of times per second, produce the illusion of intelligence.
The four fundamental components of any computer system. Data flows: Input → Memory → CPU → Output. The CPU and Memory communicate bidirectionally — the CPU fetches instructions and data from memory, processes them, and writes results back.
Regardless of whether it is a mainframe worth millions or a microcontroller costing one dollar, every computer performs exactly four tasks:
| # | Task | Description | Hardware responsible |
|---|---|---|---|
| 1 | Input | Accept information from the outside world | Keyboard, mouse, sensors, ADC |
| 2 | Storage | Hold data and instructions until needed | RAM, ROM, cache, flash, HDD |
| 3 | Processing | Perform arithmetic and logical operations on data | CPU: Control Unit + ALU + registers |
| 4 | Output | Return processed results to the user | Monitor, printer, DAC, network |
The CPU itself is composed of two key sub-units: the Control Unit (CU), which directs the flow of information and sequences operations, and the Arithmetic and Logic Unit (ALU), which performs all calculations and logical comparisons. Together with a set of fast-access registers, these three form the core of every processor from a 1970s 8-bit microcontroller to a modern 64-core data-centre CPU.
The history of computing is really the history of humanity’s search for machines that could handle tedious, large-scale calculation. Progress was driven by two recurring needs: speed (calculations that take humans days should take machines seconds) and decision-making (not just arithmetic, but choosing between alternatives based on data).
The abacus (ancient Babylon, China, medieval Europe) was the first practical counting machine — beads on rods encoding decimal values. Useful, but it required a human to operate every step.
By the 1930s, accurate mechanical adding machines existed. They used gears and levers and could add and subtract reliably. But they were too slow for scientific work, and — crucially — they could not make decisions. A machine that simply adds numbers without being able to branch based on a result is a calculator, not a computer.
In June 1943, work began on the ENIAC (Electronic Numerical Integrator and Computer) at the University of Pennsylvania — a secret military project to calculate artillery shell trajectories. Key facts:
Six major eras in computing history. Each transition was driven by a new switching technology: mechanical → vacuum tube → transistor → IC → VLSI → modern SoC. Each jump increased transistor density by orders of magnitude while reducing power and cost.
Every computer system — from an embedded microcontroller to a supercomputer — contains the same five categories of components. What differs between them is the scale and performance of each component, not the structure.
Complete computer system block diagram. The CPU (Control Unit + ALU + Registers) communicates with Main Memory via the system bus. Input devices feed data to the CPU; Output devices receive processed results. Secondary storage provides non-volatile, persistent data storage and communicates via the bus.
Every piece of data inside a computer — a letter, a number, an instruction, a pixel — is represented as a sequence of bits (Binary digITS). A bit is the smallest unit of information: it can hold exactly one of two values, 0 or 1.
This two-state system maps perfectly to the physical reality of digital circuits: a transistor is either OFF (logic 0) or ON (logic 1). There is no “maybe”.
The reason computers use binary rather than decimal is physical: it is easy to build circuits that reliably distinguish two voltage levels (e.g. 0 V and 3.3 V) and very hard to reliably distinguish ten levels (0 V, 0.33 V, 0.66 V, …). Binary is noise-immune; decimal is not.
Eight bits form one byte. One byte stores one character (using ASCII encoding). Because computers work with vast numbers of bytes, metric prefixes are used:
| Unit | Symbol | Value | Example |
|---|---|---|---|
| Byte | B | 8 bits | One ASCII character |
| Kilobyte | KB | 1,000 bytes | A short text document |
| Megabyte | MB | 1,000,000 bytes | A typical photo (JPEG) |
| Gigabyte | GB | 1,000,000,000 bytes | A standard RAM stick |
| Terabyte | TB | 10¹² bytes | A large HDD |
The letter ‘A’ stored in one byte. ASCII code 65 = binary 0100 0001. The two blue cells represent transistors that are ON (conducting current); the grey cells are OFF. If power is removed, all cells return to OFF — this is why RAM is volatile.
Computers work exclusively in binary internally, but binary numbers become unwieldy for humans to read. Hexadecimal (base-16) provides a compact shorthand — each hex digit represents exactly four binary bits.
Binary uses positional notation with powers of 2. Each bit position has a weight equal to 2 raised to that bit’s position (counting from 0 at the right):
Binary: 10111₂
Position values (right to left): 2⁰=1, 2¹=2, 2²=4, 2³=8, 2⁴=16
Calculation: (1×16) + (0×8) + (1×4) + (1×2) + (1×1) = 16 + 0 + 4 + 2 + 1 = 23
Check: 10111₂ = 23₁₀ ✓
| Character | Decimal | Binary | Hex |
|---|---|---|---|
| A | 65 | 0100 0001 | 41 |
| B | 66 | 0100 0010 | 42 |
| Z | 90 | 0101 1010 | 5A |
| a | 97 | 0110 0001 | 61 |
| 0 | 48 | 0011 0000 | 30 |
| 1 | 49 | 0011 0001 | 31 |
Hex uses base-16 with symbols 0–9 and A–F. Each hex digit represents exactly 4 binary bits. This makes conversion between binary and hex trivial — split binary into groups of 4 bits and convert each group:
Binary: 0110 1011
Split into nibbles: 0110 | 1011
Convert each: 0110₂ = 6 · 1011₂ = B
Result: 0110 1011₂ = 6B₁₆
A parity bit is an extra bit appended to a byte to enable single-bit error detection. The user selects either even parity (total number of 1-bits is even) or odd parity (total is odd). If a single bit flips during storage or transmission, the parity check fails and the error is detected. This is the simplest form of error-detecting code — the foundation of more sophisticated schemes like Hamming codes used in ECC RAM.
Input and output device categories. Input devices convert physical signals (keystrokes, images, sounds, magnetic ink) into binary data the CPU can process. Output devices convert binary results back into human-readable or physically useful form. Storage devices act as both — they receive data as output when writing and provide data as input when reading.
A computer uses several types of memory, each with different trade-offs between speed, capacity, volatility, and cost:
| Type | Full name | Volatile? | Writable by user? | Purpose |
|---|---|---|---|---|
| ROM | Read-Only Memory | No | No | Startup (BIOS/UEFI) instructions, set at manufacture |
| RAM | Random Access Memory | Yes | Yes | Working memory — data and programs while computer is on |
| Cache | SRAM cache | Yes | Auto (CPU) | Fastest memory; holds recently used data to avoid RAM access latency |
| HDD/SSD | Secondary storage | No | Yes | Permanent storage — files, OS, programs persist after power-off |
The operating system (OS) — the first program loaded from ROM into RAM at power-on — acts as interpreter between the user and the hardware. It translates user instructions into binary operations the CPU can execute, and translates binary results back into human-readable output. Without the OS, the CPU has no coherent sequence of instructions to follow.
When you work as a VLSI design or verification engineer, you are building the physical implementation of exactly what this article describes. The CPU block in Figure 3 is what your RTL team designs — register files, ALU, control unit, all in synthesisable SystemVerilog. The Main Memory interface is the LPDDR5 or HBM PHY your physical design team implements. The I/O blocks are the USB, PCIe, SPI, I²C, and UART peripheral IPs. The system bus is AXI4 or CHI interconnect fabric. Every article in this series connects one of these conceptual blocks to its silicon reality.
The bit representation you learned in this article (1=transistor ON, 0=transistor OFF) is the physical foundation of every logic gate, flip-flop, and memory cell. The AND, OR, NOT gates you studied in DE-03/04 each implement a simple binary operation on one or two bits. The ALU inside your CPU chains thousands of these gates to perform addition, subtraction, comparison, and logical operations on 32-bit or 64-bit words — all by manipulating 0s and 1s exactly as described here. Understanding bits is not abstract — it is the exact physical state of two billion transistors switching 4 billion times per second in a modern processor core.
The parity check bit introduced in this article is the simplest member of a family of error-correcting codes. In VLSI memory design, ECC (Error Correcting Code) RAM uses Hamming codes that not only detect but correct single-bit errors — essential in server-class DDR5 modules. Every cache line in a modern L1/L2 cache includes ECC protection bits synthesised directly into the SRAM macro. The concept scales from one parity bit per byte all the way to BCH codes protecting entire flash memory pages. CA-06 (Internal Memory) covers this in detail.