Understanding Memory, Variables, and Pointers in a Minimal 8‑Byte Environment

Assume you have an extremely small memory of only 8 bytes, no high‑level language, and no operating system; you operate on individual bytes. Memory consists of tiny boxes indexed from 0 to N, each holding a single byte.

To write the number 1 into box 6 you use a store 1 6 instruction, where the first operand is the value and the second is the address. To read the content you use load r1 6 . Because the same numeric token can denote a value or an address, an immediate‑value prefix (e.g., $ ) is introduced: store $1 6 stores the literal 1, while load r1 6 loads the byte at address 6.

Giving address 6 a human‑readable name creates a variable: a = 1 means variable a refers to address 6 that holds the value 1. The variable thus carries two pieces of information: the value (1) and the location (address 6).

When another variable b is defined as b = a , a new box (e.g., address 2) is allocated for b . Copying the whole content of a would waste memory, especially when a occupies multiple bytes. Instead, b stores the address of a , acting as a reference.

This reference‑holding variable is a pointer: a variable whose content is interpreted as an address rather than a raw value. Pointers are a higher‑level abstraction of memory addresses, allowing indirect addressing such as load r1 @1 , which first fetches the value at address 1 (e.g., 3) and then treats that value as another address to retrieve the final data.

In assembly language you must manage these indirections explicitly, while high‑level languages hide them: the variable b directly points to data a without the programmer thinking about the intermediate address chain.

Using pointers enables complex data structures; the article illustrates a linked list built from nodes that store addresses of the next node, demonstrating how seemingly loose memory can be organized through pointers.

Historically, pointers first appeared in the PL/I language to support linked lists, influencing the design of Multics and later Unix and C, where pointers remain a core concept.