Age 18 — discovering the model-driven academic world
At eighteen, I stumbled into the model-driven engineering academic world and it reshaped how I think about software for good. I started learning and prototyping with Eclipse, openArchitectureWare (oAW), AndroMDA, and a constellation of other Eclipse-based modelling frameworks (EMF, GMF, Xtext-era tooling).
That's where I first encountered the OMG meta-modelling stack — M0 (instances) / M1 (models) / M2 (metamodels) / M3 (meta-metamodel) — and understood that you could model the modelling itself. Code generation, transformations between models, DSLs as first-class artefacts, abstract syntax trees as the real source of truth: all of it clicked at once.
In parallel with the Eclipse tooling, I came across John F. Sowa's top-level ontology and his work on Conceptual Graphs. Sowa builds his ontology on a lineage I had not seen named before — Peirce → Whitehead → Aristotle — and derives twelve top-level categories from three binary distinctions (Independent / Relative / Mediating × Physical / Abstract × Continuant / Occurrent). It is, structurally, an M3 metamodel applied to general ontology rather than to software, and the same gesture I had been learning with EMF: a small set of self-describing primitives from which entire vocabularies can be unfolded. Reading Sowa at eighteen gave me a name for what I was doing with attributes and source generators, and a philosophical lineage I could place it in.
What struck me most was Sowa's intellectual honesty about the limits of his own framework. He writes openly that « the other axioms cannot be stated formally until a great deal more has been fully formalized » and acknowledges an infinite-regress problem he does not resolve — Physical axioms depend on Place, Time, and predicates that themselves require formalization. That admission is not a defect; it is exactly what Tarski (1933) and Gödel (1931) had already proven for any system rich enough to describe itself. A meta-metamodel can be syntactically self-describing without being semantically self-grounding, and the honest move is to inherit that limit rather than hide it. Twenty years later, I still consider this one of the most formative things I learned: a framework that admits its own boundary is more trustworthy than one that pretends to have none.
This isn't ancient history on my CV — it's the direct intellectual basis for the M3 → M0 architecture I use today across my entire monorepo. The CMF (Content Management Framework) with its five M2 DSLs built on a shared M3 meta-metamodel, the Injectable source generators, the typed Docker DSL, the feature-tracking DSL — they all descend from what I learned prototyping with oAW and AndroMDA twenty years ago. The tools changed (Roslyn instead of Eclipse EMF, C# instead of Java/Xtend, attribute-based DSLs instead of .xmi files), but the philosophy is the same: model the problem rigorously, then generate the boilerplate.
Most developers discover meta-modelling late, if ever. I had the luck — or stubbornness — to dive into it as a teenager, and it's been the backbone of my architectural thinking ever since.
What I did not see at eighteen is that this Sowa–MOF lineage would later cross paths with the philosophical work I was doing on a completely different track — political theory and the framework I call métacratie. The same gesture (a small set of self-describing primitives, parameterised by an Espace × Temps signature, from which entire domain vocabularies can be unfolded with full traceability) turns out to apply just as cleanly to the reading of political configurations as it does to compiling C# code. I have written two companion essays that make this junction explicit: Appareil et compilateur (in French, in the philosophy section) approaches the bridge from the political side, and MDE and Métacratie approaches it from the engineering side. Both rest on what I learned at eighteen with Sowa, oAW, EMF, and the OMG stack — and on the philosophical honesty I learned at the same time about what such a framework can and cannot do.