Casey Muratori – The Big OOPs: Anatomy of a Thirty-five-year Mistake – BSC 2025

I'd love a deeper dive on how Objects work in NeXTSTEP. From their brochures, they talk about objects being persistent and distributable, that in a workgroup of people everyone can rely on the objects being up to date. I've always been so curious what the broader technical ecosystem looks like here. Presumably there are still processes running on systems. But these processes have lots of objects in them? And the objects are using Mach message passing to converse with other processes elsewhere? Within an application, are objects communicating across Mach too? There's so much high level rhetoric about. Such as this bit. But I'd love a real technical view at what was happening, what objects really were here. [LINK] [LINK] This is a fun work. It feels like the brief outline for a Speaking for the Dead for OOP. Huge amount of things to lots of different people over time. Seconding @rawgabbit's recommendation for Casey Muratori's The Big OOPs: Anatomy of a Thirty-five-year Mistake, which really is hunting back and back for the cosmogenesis of objects, and covers so much terrain. Objectogenesis? [VIDEO]

Here is an example of a 2006 rant that qualifies: [LINK] OO conflates many different aspects that are often orthogonal but have been conflated together opportunistically rather than by sound rigor. Clearly most languages allow for functions outside classes. It's clearly the case today especially with FP gaining momentum, but it's also clear back then when Java and the JVM were created. I think smalltalk was the only other language that had this limitation. Like others in this thread, I can only recommend the big OOPS video: [VIDEO]

I found this talk to be great. It goes through the history of OOP and how some of the ideas for the more modern ECS were embedded in the culture at the formation of OOP in the 1960s to 1980s but somehow weren't adopted. It was pretty clear, even 20 years ago, that OOP had major problems in terms of what Casey Muratori now calls "hierarchical encapsulation" of problems. One thing that really jumped out at me was his quote [0]: > I think when you're designing new things, you should focus on the hardest stuff. ... we can always then take that and scale it down ... but it's almost impossible to take something that solves simple problems and scale it up into something that solves hard [problems] I understand the context but this, in general, is abysmally bad advice. I'm not sure about language design or system architecture but this is almost universally not true for any mathematical or algorithmic pursuit. [0] [VIDEO]

There's a really good talk about the history of OOP going back to the early 60s that goes over this point. The whole "90s style OOP isn't OOP as it was originally intended" thing is largely a myth. When Kay and other OOP pioneers were describing Smalltalk and OOP to professional developers, they all used 90s Java style "compile-time hierarchy of encapsulation that matches the domain model" OOP to explain it. Smalltalk-80: The Language , a book by some of the original designers of Smalltalk, even uses the same shape class inheritance example you'll see in every introductory Java textbook. Here's a link to the talk, timestamped to when he goes over this. [VIDEO]

Plexes are first mentioned in 1960 [LINK] and the paper even starts with a critique of the efficiency of Lisp's approach for representing data with cons pairs (citing McCarthy's paper from the same year). You might also want to watch Casey's great talk on the history of OOP [VIDEO]

This is the video that's been going around. It's a bit long and could have been compacted into a 20 minute video, but if you have the time, it's a good overview for people without a computer science background. "Casey Muratori – The Big OOPs: Anatomy of a Thirty-five-year Mistake – BSC 2025" [VIDEO] But if your point is there aren't any written articles about stuff like this, I agree. If they're out there, they're a bit outside the mainstream.

Muratori traced the history of OOP to the original documents. Skip to the 1:18 mark if you want to skip to his findings. [VIDEO]

> " Why are we wasting so much time on abstractions like .. objects? " Aside: earlier this year Casey Muratori did a 2.5 hour conference talk on this topic - why we are using objects in the way they are implemented in C++ et al with class hierarchies and inheritance and objects representing individual entities? " The Big OOPs: anatomy of a 35 year mistake "[1]. He traces programming history back to Stroustrup learning from Simula and Kirstan Nygaard, back to C.A.R. Hoare's paper on records, back to the Algol 68 design committee, back to Douglas T. Ross's work in the 1950's. From Ross at MIT in 1960 to Ivan Sutherland working on Sketchpad at MIT in 1963, and both chains influencing Alan Kay and Smalltalk. Where the different ideas in OOP came from, how they came together through which programming languages, who was working on what, and when, and why. It's interesting. [1] [VIDEO]