{
"path": "/3me265xkom226",
"site": "at://did:plc:p7sxjpo2opcfkn7cgi5jqyqi/site.standard.publication/3m6opukdd3s2m",
"tags": [],
"$type": "site.standard.document",
"title": "Why Simula — Not Smalltalk — Changed the World: The Power of Simulation and Coroutines",
"content": {
"$type": "pub.leaflet.content",
"pages": [
{
"id": "019c2934-e26e-7775-b90b-bdbf9397597b",
"$type": "pub.leaflet.pages.linearDocument",
"blocks": [
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.image",
"image": {
"$type": "blob",
"ref": {
"$link": "bafkreihilrpf52hzqf4jgrjzl7ikihlne4dzcnm6n3nahwryej6jakxvia"
},
"mimeType": "image/png",
"size": 3768970
},
"aspectRatio": {
"width": 1536,
"height": 1024
}
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 181,
"byteStart": 175
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "When we trace the genealogy of modern programming, we often celebrate Smalltalk as the progenitor of object-oriented programming. Yet this narrative obscures a deeper truth: Simula, created by Ole-Johan Dahl and Kristen Nygaard in 1962–1967, fundamentally transformed how we model complex systems, and its influence extends far beyond the syntax of classes and objects that Smalltalk popularized."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 233,
"byteStart": 148
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
},
{
"index": {
"byteEnd": 336,
"byteStart": 315
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Smalltalk gave us elegant syntax, live programming environments, and a pure vision of message passing. But Simula gave us something more profound: the ability to directly encode the structure of reality itself into executable models. Where Smalltalk was a language for building systems, Simula was a language for understanding systems."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "The Conceptual Revolution"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Simula emerged not from computer science departments, but from the Operations Research section of the Norwegian Computing Center, where Dahl and Nygaard were wrestling with simulation problems for industrial processes. They needed to model ships moving through fjords, production lines with queues, and telecommunications networks with competing demands."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 308,
"byteStart": 164
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "The breakthrough wasn’t just “bundling data with procedures” — that’s the reductionist view that misses the point. The breakthrough was recognizing that complex systems consist of semi-autonomous entities that maintain their own state, interact through well-defined protocols, and evolve over time. This insight predates and transcends the later “everything is an object” philosophy of Smalltalk."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Consider the fundamental difference in motivation:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 9,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Smalltalk: How can we build a computational environment where everything is uniform, reflexive, and malleable?"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 6,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Simula: How can we express the inherent structure of real-world systems — manufacturing plants, traffic networks, biological processes — in a way that lets us reason about their behavior?"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "One is inward-looking (computational aesthetics), the other outward-looking (epistemic fidelity to reality)."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Coroutines: Encoding Time Itself"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 126,
"byteStart": 86
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Simula’s most profound innovation wasn’t inheritance or encapsulation — it was coroutines with quasi-parallel execution. This feature, largely absent from Smalltalk, gave programmers the ability to directly encode temporal relationships and causal chains."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "The Coroutine Model"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "In Simula, every object could be a coroutine — an independent locus of execution with its own instruction pointer and local state. Three primitives enabled this:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 6,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
},
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
},
{
"index": {
"byteEnd": 71,
"byteStart": 65
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
},
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
},
{
"index": {
"byteEnd": 144,
"byteStart": 140
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
},
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "detach - Suspend execution and return control to the activator resume - Transfer control to another object, continuing where it left off\ncall - Like resume, but create a return point for when the called object detaches"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Here’s a canonical example — a producer-consumer system:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "! Simula Producer-Consumer with Coroutines"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "begin \nclass Buffer; \nbegin \ninteger array items(1:10); \ninteger count, writePos, readPos; \nprocedure put(item); integer item; \n begin \n items(writePos) := item; \n writePos := if writePos = 10 then 1 else writePos + 1; \n count := count + 1; \n end; \n integer procedure get; \n begin \n integer item; \n item := items(readPos); \n readPos := if readPos = 10 then 1 else readPos + 1; \n count := count - 1; \nget := item; \nend; \ncount := 0; \nwritePos := 1; \nreadPos := 1; \nend Buffer; \n\nref(Buffer) shared; \n class Producer(id, total); integer id, total; \n begin integer i; for i := 1 step 1\n until total do \n begin \nwhile shared.count = 10 do \ndetach; ! Buffer full, yield control \n shared.put(id * 100 + i); \nouttext(\"Producer \"); outint(id, 2); \nouttext(\" produced: \"); outint(id * 100 + i, 5); \n outimage; \ndetach; ! Voluntarily yield after each item \n end; \nend Producer; \nclass Consumer(id, total); integer id, total; \nbegin integer i, item; \nfor i := 1 step 1 until total do \n begin while shared.count = 0 do \n detach; ! Buffer empty, yield control \n item := shared.get; \nouttext(\"Consumer \"); outint(id, 2); \nouttext(\" consumed: \"); outint(item, 5); \n outimage; \ndetach; ! Voluntarily yield after each item \n end; end Consumer; \nref(Producer) prod1, prod2; \nref(Consumer) cons1; \nshared :- new Buffer; \nprod1 :- new Producer(1, 5); \n prod2 :- new Producer(2, 5); \ncons1 :- new Consumer(1, 10); \n! Coroutine scheduling - explicit, deterministic \nwhile prod1.count < 5 or\n prod2.count < 5 or cons1.count < 10 do \n begin prod1.resume; ! Run until detach \n prod2.resume; ! Run until detach \ncons1.resume; ! Run until detach \nend;\nend"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": ""
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 80,
"byteStart": 33
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
},
{
"index": {
"byteEnd": 100,
"byteStart": 88
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
}
]
},
{
"index": {
"byteEnd": 235,
"byteStart": 229
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
}
]
}
],
"plaintext": "Notice what’s happening here: Each object maintains its own execution context. When prod1.resume is called, execution continues exactly where that producer left off—mid-loop, with all local variables intact. When it hits detach, control returns to the scheduler."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 116,
"byteStart": 68
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "This isn’t threads with locks. This isn’t async/await. This is direct encoding of cooperative temporal behavior — objects that naturally interleave their actions in a deterministic, reproducible way."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Why This Matters: Discrete Event Simulation"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 74,
"byteStart": 64
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
}
]
},
{
"index": {
"byteEnd": 122,
"byteStart": 97
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Simula’s creators embedded these coroutine primitives into a Simulation class that provided discrete event simulation capabilities:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "! Bank Teller Simulation in Simula"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "Simulation begin class Customer; begin real arrivalTime, serviceStart, serviceEnd; arrivalTime := time; ! Current simulation time ! Request service from teller if teller.idle then begin serviceStart := time; hold(normal(5.0, 1.0, randomStream)); ! Service time serviceEnd := time; outtext(\"Customer served: \"); outfix(serviceEnd - arrivalTime, 2, 6); outtext(\" total time\"); outimage; end else begin ! Join queue into(tellerQueue); passivate; ! Suspend until reactivated serviceStart := time; hold(normal(5.0, 1.0, randomStream)); serviceEnd := time; outtext(\"Customer waited: \"); outfix(serviceStart - arrivalTime, 2, 6); outtext(\", served in: \"); outfix(serviceEnd - serviceStart, 2, 6); outimage; end; end Customer; class Teller; begin boolean idle; idle := true; while true do begin if not tellerQueue.empty then begin ref(Customer) next; idle := false; next :- tellerQueue.first; out(next); activate next; ! Resume waiting customer end else idle := true; hold(0.1); ! Check queue periodically end; end Teller; class CustomerGenerator; begin integer i; for i := 1 step 1 until 20 do begin activate new Customer; hold(exponential(3.0, randomStream)); ! Inter-arrival time end; end CustomerGenerator; ref(Teller) teller; ref(Head) tellerQueue; ref(RandomStream) randomStream; randomStream :- new RandomStream(12345); tellerQueue :- new Head; teller :- new Teller; activate new CustomerGenerator; hold(100.0); ! Run simulation for 100 time units end Simulation;"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Look at what Simula provides here:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 4,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
},
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
},
{
"index": {
"byteEnd": 46,
"byteStart": 32
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
},
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
},
{
"index": {
"byteEnd": 121,
"byteStart": 113
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
},
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
},
{
"index": {
"byteEnd": 165,
"byteStart": 156
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
},
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
},
{
"index": {
"byteEnd": 230,
"byteStart": 219
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "time - Global simulation clock\nhold(duration) - Suspend this object and schedule its resumption after duration\nactivate - Schedule another object to run\npassivate - Suspend indefinitely until explicitly reactivated\nEvent queue - Automatically managed, sorted by scheduled time"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 25,
"byteStart": 16
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
}
]
},
{
"index": {
"byteEnd": 102,
"byteStart": 70
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "When you write hold(5.0), you're not just sleeping a thread. You're expressing a causal relationship: \"This customer's service takes 5 time units, and nothing about this customer matters until that duration elapses.\""
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 100,
"byteStart": 83
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "The simulation framework maintains an event queue, advances the global clock, and deterministically processes events in temporal order. Every run with the same random seed produces identical results — critical for analyzing complex systems."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Why Simula Changed the World (and Smalltalk Didn’t, Quite)"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "1. Simula Enabled Domain Modeling, Not Just Software Architecture"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 118,
"byteStart": 98
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Smalltalk gave us MVC, design patterns, and agile development. These are valuable, but they’re software engineering concerns."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Simula gave us the ability to model:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.unorderedList",
"children": [
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Manufacturing systems (the original motivation)"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Telecommunications networks (Ericsson used it extensively)"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Biological ecosystems"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Economic systems"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Social dynamics"
},
"children": []
}
]
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 187,
"byteStart": 131
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
},
{
"index": {
"byteEnd": 245,
"byteStart": 230
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#italic"
}
]
}
],
"plaintext": "When Bjarne Stroustrup created C++, he wasn’t inspired by Smalltalk’s message passing or live environment. He was inspired by Simula’s ability to directly represent domain concepts as classes. When the Gang of Four wrote Design Patterns, many patterns (State, Strategy, Command) are essentially formalizations of techniques Simula programmers had used for decades to model real-world systems."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "2. Coroutines Anticipated Modern Concurrency Models"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Simula’s coroutines directly influenced:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.unorderedList",
"children": [
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 17,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "CLU’s iterators (Barbara Liskov, 1970s)"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 21,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Modula’s coroutines (Niklaus Wirth)"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 21,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Python’s generators (PEP 255, inspired by CLU)"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 26,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "JavaScript’s async/await (cooperative, single-threaded)"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 17,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Go’s goroutines (though these can be parallel)"
},
"children": []
}
]
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 33,
"byteStart": 28
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
}
]
},
{
"index": {
"byteEnd": 106,
"byteStart": 100
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
}
]
},
{
"index": {
"byteEnd": 119,
"byteStart": 113
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
}
]
}
],
"plaintext": "Every modern language with yield, generators, or cooperative multitasking owes a debt to Simula's detach and resume."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 34,
"byteStart": 27
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
}
]
},
{
"index": {
"byteEnd": 185,
"byteStart": 180
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
}
]
}
],
"plaintext": "Smalltalk, meanwhile, had Process objects and semaphores—useful for concurrency within the environment, but not conceptually exportable in the same way. When you use Python's yield today, you're using Simula's ideas, not Smalltalk's."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "3. Simula’s Influence Is Structural, Not Stylistic"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 182,
"byteStart": 102
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Languages influenced by Smalltalk: Objective-C, Ruby, arguably Scala\nLanguages influenced by Simula: C++, Java, C#, Eiffel, Python, Beta — essentially every mainstream OO language"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Why? Because Simula’s model — static typing, classes as types, inheritance hierarchies, virtual methods — maps more naturally to how hardware works and how large teams coordinate."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Smalltalk’s model — dynamic typing, metaclasses, message passing, live environments — is more powerful in many ways, but requires a paradigm shift that industry largely rejected in favor of Simula’s more conservative approach."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "The Irony of History"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 65,
"byteStart": 21
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Here’s the irony: Simula solved harder problems than Smalltalk, but Smalltalk got more academic attention because it was philosophically purer and more radical."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Simula said: “Let’s extend Algol with classes, coroutines, and simulation facilities — tools for modeling complex systems.”"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Smalltalk said: “Let’s build a minimal, reflexive computational universe where everything is an object and everything is a message.”"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 235,
"byteStart": 218
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Academia loves the second story. It’s clean, revolutionary, inspiring. But industry needed the first story. They needed to model air traffic control systems, telecommunications networks, factory floors. They needed engineering tools, not computational philosophy."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "When you look at modern software — distributed systems with microservices (objects), event-driven architectures (coroutines/async), domain-driven design (Simula’s class modeling), agent-based simulations (quasi-parallel entities) — you’re seeing Simula’s vision fully realized."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 134,
"byteStart": 113
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Smalltalk gave us important ideas about programming environments and reflective systems. But Simula gave us the conceptual vocabulary for how we think about complex systems themselves."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Conclusion"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 143,
"byteStart": 91
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Simula changed the world not because it had cleaner syntax than Smalltalk, but because it encoded deeper truths about how complex systems work. It recognized that the world consists of semi-autonomous entities with internal state, engaged in quasi-parallel interactions, unfolding over time."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 128,
"byteStart": 96
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Smalltalk showed us that computation could be uniform and reflexive. But Simula showed us that computation could mirror reality — and in doing so, help us understand and predict it."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "When Dahl and Nygaard received the Turing Award in 2001, the citation read: “for ideas fundamental to the emergence of object-oriented programming.” But perhaps it should have read: “for showing us how to encode time, causality, and structured complexity into executable models.”"
}
}
]
}
]
},
"coverImage": {
"$type": "blob",
"ref": {
"$link": "bafkreihilrpf52hzqf4jgrjzl7ikihlne4dzcnm6n3nahwryej6jakxvia"
},
"mimeType": "image/png",
"size": 3768970
},
"bskyPostRef": {
"cid": "bafyreiglrml3jmlbqtneqctzm3ni4sstddeoysghjmrpbvvm32bhtwwyci",
"uri": "at://did:plc:p7sxjpo2opcfkn7cgi5jqyqi/app.bsky.feed.post/3me2663uax226",
"commit": {
"cid": "bafyreigbpkrqsihabsxt6ira4bt5f6phncfsalr2lfeiap6rzzrlwemlsy",
"rev": "3me2663x7fg2t"
},
"validationStatus": "valid"
},
"publishedAt": "2026-02-04T15:15:42.102Z"
}