The diamond that network databases wired into the physical layer didn’t disappear when relational databases isolated it into a narrow, stable waist. It moved. Three more technologies got sold as solving the same “impedance mismatch” — and all three actually just relocated the diamond somewhere less visible than a schema diagram.

ORM: The Diamond Hidden in Plain Sight

An ORM markets itself as fusing the object layer and the relational layer, rather than isolating the boundary between them the way a query optimiser does. The class hierarchy becomes the schema, or vice versa, and object references that look like free pointer-follows in code are secretly joins — or, when the ORM gets lazy about it, N+1 query storms at runtime.

order.customer.address reads like a field access. It’s SELECT-chasing underneath, network-database navigation reincarnated with friendlier syntax. The coupling didn’t disappear when the ORM promised to hide it. It moved somewhere invisible, which means it fails later and more expensively than a raw join ever would — in production, under load, as a query-count spike nobody budgeted for — because by the time it fails, nobody writing the calling code even knew a query was happening at all.

XML and C++: The Same Shape, Already Covered

Two more technologies make the identical move, and this series has already traced each of them in enough depth that they’re worth naming here rather than re-arguing from scratch.

XML welds semantic content — element names, cardinality, nesting depth — directly into the physical serialisation, the same fusion ORM performs between classes and tables. The fence post already covered why that fusion reads as loud, brittle, and Def-Push — angle brackets shouting louder than the content they’re meant to carry, a schema change breaking every downstream parser because the tree shape is the contract.

C++ performs the same fusion at the level of memory layout — classes with inheritance and vtables couple data representation to behaviour dispatch at compile time, the fragile base class problem, where changing a base class’s fields means every derived binary needs recompiling. The fix for exactly this coupling is the opaque handle — a stable pointer plus accessor functions, never the raw struct layout, the same discipline ODPI-C uses to let Oracle’s internal connection structure evolve without breaking every client linked against an older header.

Damien Katz’s “The Unreasonable Effectiveness of C” makes an adjacent point worth borrowing precisely rather than paraphrased. His case for rewriting Couchbase’s core in C over C++ or Erlang wasn’t primarily about performance — it was that C’s ABI is “supported by every OS, language and platform in existence,” with no runtime overhead, which makes C code “valuable not just to callers from C code, but to every conceivable library, language and environment.” That’s the exact same commodity-interface argument already made for S3 and HTTP, one layer down: a calling convention with no embedded assumptions about vtables, name mangling, or object layout can be spoken by a stranger. C++’s ABI, by contrast, was never standardised across compilers — two C++ compilers can disagree on how a class lays out in memory, which is why C remains the interchange layer every other language builds its foreign-function interface against, and C++ mostly doesn’t.

The Common Thread

All three technologies “solve” impedance mismatch by collapsing two layers into one artifact instead of building a translation waist between them. A real fix looks like the relational optimiser, or protobuf and Avro’s schema evolution rules, or a routeMap/procedureMap split sitting above a dispatcher that has no idea what the data it’s routing actually means. Every one of these got sold as removing a seam. What they actually did was move the seam somewhere less visible — and the diamond always shows up eventually, usually as a migration nobody budgeted for.

This post is part of the Gutenberg/Semantic series. Related: The Diamond Shows Up Eventually on the same fusion in network and object databases, Don’t Erase the White Line on XML’s version of the same mistake, and Use-Specialisation on the opaque handle as C++’s actual fix.

Source: The Unreasonable Effectiveness of C, Damien Katz, January 2013, as reported in “Is C Still A Suitable Language Today?”, Abel Avram, InfoQ, January 18, 2013.