Ignorance, Surface, and Deep Architecture

Why Modern C++ Keeps Getting Misunderstood
A blog post about modern C++ architecture, the role of ranges, concepts, RAII, coroutines, and compile time structures, and about why many developers are dismissed by superficial criticism despite deep expertise. A continuation of the post [“Innovation or Amnesia”] and a plea to protect those who truly understand modern C++.

Introduction: The Return of an Old Pattern

When I wrote [“Innovation or Amnesia“], my goal was to describe a kind of technical blindness that has haunted our industry for years. It was a spontaneous response to a remark in my Twitch live stream, in this special case about CORBA and efficient applications. Yet it captured a broader trend: judging modern ideas by their surface and confusing deep architecture with buzzwords. Some readers felt the piece was theoretical, almost abstract. Recent events in Embarcadero live streams have shown me how alive this amnesia still is and how quickly a misleading impression can dominate an entire technical discussion.

Over the past weeks I demonstrated modern C++ in practice with C++Builder 13. I started simply to evaluate the tool, then walked through real software examples grounded in ranges, concepts, Resource Acquisition Is Initialization, coroutines, variadic templates, std::expected, std::optional, std::generator, and std::println. I learned a few new things myself, which I described in the post “Rethinking C++.”

The point was to treat C++ not as a tool but as a way of thinking, with structure, responsibility, and precision as the core of an architecture.

The criticism of that live stream continued the same line I had outlined in the first post. The Embarcadero live stream touched the same theme. I explicitly said at the outset that I was not demonstrating tool handling, but the concepts of modern C++, and that C++Builder 13 now makes this possible.

Even though those structures were front and center, the discussion was overrun by surface level perception. One viewer called the architecture a supposedly outdated “mummy” that should have “stayed in the sarcophagus,” and judged what was shown as “miserable to program.” The comparison to MVVM, data binding, and reflection was symptomatic of a mindset that does not recognize modern C++ concepts unless they look like web frameworks. That is the technical distortion that prompted this new post.

Looking Through the Wrong Lens: When Modern Architecture Gets Labeled as Old

The critique claimed there were “onClick” handlers, a non existent mainForm1, and manually moved buttons. It insisted that modern user interfaces must use MVVM and data binding and held reflection up as the modern gold standard. The punch line was the “dusty mummy in a sarcophagus”.

These claims are not only incorrect, they typify the mindset I analyzed in “Innovation or Amnesia”. The surface of a demo becomes the yardstick for modernity while the underlying architecture is ignored. C++ in general, and C++Builder here in particular, gets reflexively labeled as old without even a glance at the structures that define modern code today.

The critical mistake is judging modern C++ through the lens of dynamic frameworks. It equates MVVM, binding, and reflection with progress, even though these mechanisms impose heavy runtime costs and erode type safety. At the same time, compile time models that deliver efficiency, safety, and precision are dismissed as “old,” even though they underpin the modern software stack.

What Modern C++ Actually Delivers: Structure, Precision, and Compile Time Architecture

In the streams I showed how modern C++ concepts compose into a clear, structured architecture. A text box (TMemo) became a true std::ranges sequence that could be piped without copies and without abstraction penalties. A table view (TListView) became a structured std::range object that can act as an output sink and also be used as a random-access range, all of it in C++Builder 13. It is not merely a classic container. The database pipeline was modeled with std::generator, producing data in a controlled and well-defined way without the burden of asynchronous machinery that adds needless complexity.

The IOCntrl object served as an RAII wrapper and showed how modern C++ models responsibility at the level of the type system. A resource exists only within the scope where it is needed and never escapes that scope uncontrolled. Errors are represented via std::expected rather than global state. Output is type safe, efficient, and precisely formatted through std::println, prepared optimally at compile time.

That is modern C++.

It is not old and not in a sarcophagus. It is a form of software architecture that takes resources seriously and does not invent structure at runtime but describes it explicitly before execution.

Why MVVM, Binding, and Reflection Are Not an Answer to Modern C++

Calling modern C++ outdated because it does not lean on MVVM, binding, or reflection is a technical misread. Those mechanisms come from a world where structure is created at runtime. They can be convenient, but convenience is not a quality attribute. MVVM adds layers, binding consumes memory and creates hidden coupling, reflection cracks the type system at the root. Modern C++ addresses these problems before they exist. The next standard, C++26, will go a step further by bringing reflection to C++, but at compile time rather than bloated at runtime.

Compile time architecture is not an alternative style. It is the only sustainable path if efficiency, safety, and precision matter. It demands understanding rather than habit. It rewards thinking, not rote pattern application.

In Defense of Developers Who Master Modern Architecture or Want to Learn It

This post is not aimed at individuals but at a mode of discourse that devalues the effort and results of many developers, often to justify a narrow view and burnish one’s own standing. It is a familiar pattern in a generation of full stack developers who announce new frameworks on a regular basis.

Those who work with modern C++ do valuable work. They master structures that are demanding and require responsibility. They build software that enables the many layers other languages and frameworks stand on. They carry a form of architecture that has become the foundation of modern technology.

It is disrespectful and wrong to call that work outdated. It is also technically indefensible to deride compile time architecture as a mummy while celebrating “runtime magic” as progress. That kind of judgment evaluates the veneer, not the technology, and misses the essence of software development.

Why “Outdated” Applies to Mindsets, Not Technologies

“Outdated” is often used to dismiss anything that does not fit familiar patterns. C++ is not outdated. It is the language that takes efficiency, resources, and architecture seriously and forces explicit choices. Outdated is the perspective that sees only the surface. Outdated is the notion that modernity is a visual impression. Outdated is the amnesia that forgets the depth of architecture.

Modern software emerges from clear structure, not decorative patterns. It emerges from precision in the type system, not from runtime magic. And it emerges from languages like C++ that refuse to outsource responsibility to frameworks.

Closing Thought for Embarcadero Readers

This post continues “Innovation or Amnesia,” and it is also an invitation to look at modern software development with fresh eyes. If you only see the surface, you miss the architecture. If you pass surface judgments, you undermine those who master modern technologies. And if you call C++ outdated, you do not understand how much modern software depends on the structure, responsibility, and compile time precision that operate beneath the surface.

Modern C++ deserves respect and recognition. It is not outdated. It is the foundation on which modern systems rest. If we understand that, we understand software architecture.

In my opinion, Embarcadero, with the current C++Builder release, has closed the gap to the modern standard and enables developers to use these concepts inside this tool again. It is certainly no dusty mummy and does not belong in any sarcophagus.

Why not download a free trial of C++Builder today and see why we think it’s the fastest, easiest, and most efficient way to create modern apps?

About the Author

Volker Hillmann is a mathematician and software architect from northern Germany with an interdisciplinary background that bridges formal science and applied computer science. His mathematics studies blend classical rigor with logical and cybernetic thinking, complemented by many years working with chaos theory, systems theory, and artificial intelligence. His work in computer science centers on databases, data security, and software architecture, with a consistently modern focus on C++.

He has programmed in Turbo C since 1988 and in Turbo C++ since 1991, and knows the evolution of the language and its tools firsthand. He has given numerous talks on C++ and software architecture and has been self employed since 2001. Since the mid 2000s he has also been an Embarcadero MVP, with a special commitment to advancing and applying C++Builder in practice.

His passion is modern C++. In his free live streams he focuses exclusively on current C++, independent of compiler, whether MSVC, GCC, or with the new release once again C++Builder. The topic is never a specific tool, it is always the language itself: C++ as an expression of architecture, precision, and thought.

He sees C++ not only as a tool but as a language of thought, a platform for structured, efficient, and safe design. In his current streams and articles, he evaluates and analyzes C++Builder 13 to show where modern C++ stands in practice, what is already possible, and which boundaries still need to be crossed. His topics range from RAII and move semantics to coroutines, ranges, and concepts, on to compile time metaprogramming and type safety. As a mathematician he thinks in systems and relations, in ranges, tuples, and mappings, and he applies that perspective consistently to software architecture. He argues for an understanding of C++ that unites responsibility, precision, and evolution, and shows that the language is neither outdated nor unsafe but the most precise and honest form of software design.