Douglas T. Ross's Plex the precursor to structs

Описание: Watch and/or listen to the full episode here: https://open.spotify.com/episode/31U4...

Everyone uses structs.

Almost nobody knows where they came from.

In this clip, we break down Doug T. Ross and the idea of the Plex, a largely forgotten 1950s data structure that quietly became the foundation of modern programming, memory models, and systems languages.

Before structs, before classes, before object-oriented programming, programmers didn’t even have a shared concept for bundling related data together in memory. Early machines worked with arrays, raw addresses, and hardware constraints that made higher-level abstractions hard to even imagine. Doug T. Ross changed that.

By rethinking how memory indexing worked, he introduced a model that predicted structs, pointers, function pointers, discriminated unions, free lists, arenas, and graph-like data structures — decades before those ideas became mainstream.

This isn’t obscure history.
This is the mental model almost all modern software still runs on.

In this clip:
What a Plex actually is and why it mattered
How early computers really handled memory
Why fixed memory layouts were revolutionary
Reverse indexing explained in plain English
Structs and objects before they had names
Discriminated unions decades early
Function pointers in the 1950s
Free lists, arenas, and memory allocation
Plex vs Lisp (and why Lisp paid a performance cost)
How modern languages still reflect these ideas
Why this history is mostly missing from textbooks

Timestamps:
00:00 – What is a Plex?
01:23 – Objects vs fixed memory layout
02:17 – Why no one thought this way in the 1950s
03:33 – Doug T. Ross and MIT
04:41 – Reverse indexing explained
06:50 – The “friend’s house” memory analogy
08:33 – Hardware limits of early computers
09:38 – Plex vs Lisp
11:40 – Discriminated unions & function pointers
13:23 – Free lists, arenas, memory management
15:26 – When everything becomes a Plex
17:04 – Losing a friend to group theory

Why this matters:

Many of today’s programming debates — performance vs flexibility, systems languages vs scripting languages, memory safety vs control — trace back to this exact moment in computing history.

Once you understand Plexes, you understand why C, Rust, Go, and even JavaScript behave the way they do, and why tradeoffs around performance, abstraction, and memory layout are unavoidable.

Modern software didn’t evolve randomly.

Someone had to invent the mental model first.

Doug T. Ross did that — in the 1950s.

If you enjoy:
Programming language history
Low-level systems thinking
Memory, performance, and data layout
Understanding why software works the way it does

Like the video, subscribe, and leave a comment with what topic you want covered next.