I still remember watching one of the very first online courses published on Coursera – that one about Modeling (something-something modeling to make one a better citizen of the world - they are just like that in the humanties departments).

Back then I felt, without a clear understanding of why, that something is fishy here, and that that clown on the screen was way too smug, and virtue-signaled (with all his might) every other minute that he [only] knows something absolutely profound which I (and all of [the lesser] you) don’t – they are just like that in liberal arts “education”.

Now I’ve got what it was (a bit slow, am I?).

There are two fundamental ways of looking at the world (yes, yes, I know) – as a set of relations and properties of entities (or as a set of entities with relations and properties) – the way mathematicians (and some physicists) would, and as a [naive] rigid hierarchy of classes of objects, as a delusional Platonist or an over-confident humanties major would.

The rigid hierarchical view is fundamentally flawed, because the world is not inherently strictly hierarchical (while a layered hierarchy (a hierarchy of layers) is an evolved (again and again) architecture of complexity). Traits and/or capabilities of entities are better representations for properties and relations than a rigid hierarchy of classes, and compositions of traits or capabilities, as a set union (instead of direct inheritance - a set-subset relation) is, plain and simple - the right way.

But this is not the main point. The main point is how mathematicians “see” and model the world and how humanties majors do it. Stoustrup was a math major, but something went wrong (I will show you exactly what).

A mathematician would model the world by defining sets, their properties, and relations between them – declaring what is out there – describing an inherent, properly captured and abstracted out structure of the world .

A humanties major (or the OOP modeler) models the world by doing simulations (daydreaming inside their head) of entities, their classes, and interactions among “objects” – constructing something that mimics what is out there – building an artificial world that resembles the real world .

Simulation is, in principle, the flawed way of modeling. Period. It is not even modeling per se, it is sort of daydreaming, indeed. The preoccupation with imaginary abstract entities outside of the realm of mathematics is obviously related to an uncontrolled daydreaming.

Not only missing a single “factor” (or adding a non-existent imaginary one) in a simulation may lead to completely wrong results (i.e. bullshit), but the very approach of “building” something that “resembles” the real world is flawed in principle.

Simulation, (and naive Platonism) however, is implicitly at the “very core” of the OOP (Object-Oriented Programming) paradigm.

The objects as “holders” of a mutable state, (just as “humans” would see other humans), is not how the world is structured. The world is not made of objects with hidden mutable states – that would be only appearances, but of entities with properties and relations to other entities.

Again, that dramatic episode when Sussman cuts his nail with a pocket knife on a live TV!

This is exactly what is wrong (and exactly why) with OOP in principle – it tried to model the world as a simulation of objects with mutable states, rather than as a set of entities with properties and relations.

Learning from simulations is just like learning about life from cartoons and movies – you may get some insights, but in principle you are missing the point – nothing in them is real.

Now think of some languages which were explicitly “designed” to “imperatively program simulations with objects as instances of classes” in terms of machine-level representation details of everything, with every implementation detail to be taken into account. Maybe you will begin to see the why everything is so fucked out there.

This, by the way, is not an opinion, you know, this is a flawless analysis, which traces flawed notions back their socially construction and the “true” (properly captured) notions back to What Is (which is what I do for a living).

Now, after so many lost decades (not an over-statement), the major “paradigm shift” (yes, yes, I know) is underway to program declaratively, like math itself, even in the imperative OO crap like C++, trying to move from run-time checks, runtime polymorphism (and multiple dispath) to a compiler-time checks and even guarantees.

Again, a simulation is NOT the way to describe [aspects of] What Is, and therefore is not the right way to program, especially with objects with a hidden mutable state (instead of mere “pure” immutable values).

With every simulation one creates one’s own (naive and incomplete or over-complicated – always a mismatch, in principle) version of “reality”, with whatever naive and flawed assumptions one holds at the moment, and then observes it. This never generalizes well (except very few specific “closed” systems, such as atoms – as stable interfaces which Life Itself uses – not of “what is inside” them).

Takeaway: When one programs in the imperative OO “paradigm” one “unconsciously” (without being fully aware) builds a naive simulation out of classes and stateful objects. This is flawed in principle. When one program such simulations in terms of machine-level representation and implementation details (instead of proper non-leaking “mathematical” abstractions) one is fucked twice as hard. While this can be made to “work”, adding “concurrency” and shared mutable state to already stateful objects – each containing its own hidden mutable stated, which can be changed without the change being “observed” makes the problem intractable, in principle.

There is no solution, this is just an evolutionary dead end.

There are reasons why mathematics (after thousands of years) is what it is, and why just after some 50 years or so an imperative OO machine-level programming is the way it is.

It is not a random coincidence that Algol and Simula-68 are the common ancestor of all the crappy [low-level imperative OO] languages in the world – this is Platonism implemented at the wrong level of “abstraction”, with leaking abstractions and implementations details – everything leaks everything else (coined by myself).

Now have a nice day.

I feel obliged to clarify – people indeed are distinct biological “objects” with a hidden mutable state within their brains (being constantly mutated with each new “experience”). We know in principle that there are actual biological structures made out of living cells – “neural networks” – which are being “trained” by a feedback of repetitive actions. We even know, again, only in principle, that whatever you call “I” or " my personality" is “just” myelination of “connections” and, literally, the “state” of synaptic gaps “so far”. The problem is that there are a “bunch” of such networks, specialized by evolution for particular functions. No one knows the “algorithm”, no one knows “synchronization”, etc.

But this is NOT how to model or program.