Series: WHY MODELING MATTERS - 1/3
This series explores why domain modeling is once again becoming a central element in modern software engineering.
In this first article, we address the gap between the tools we still use for modeling and the actual complexity of today’s systems, and we explain the origin of Structura.
The Gap in Modern Engineering
Software development has reached an extraordinary level of technological maturity, yet the engineering that sustains it still relies on tools from the 20th century.
We design distributed, collaborative, and regulated systems, and yet most teams continue to manage the organization of their software, the classes, entities, and relationships that underpin it, with static diagrams or fragmented documentation.
At Metadev, we have seen this repeatedly: teams that start with energy, well-chosen frameworks, and solid conceptual models, only to reach a first major iteration where the codebase grows, dependencies become entangled, and the models become unrecognizable. What was once a clear architecture becomes a collection of implicit, ad hoc decisions that are not always consistent, depending instead on the judgment or preferences of whoever happens to be executing the work.
We are still modeling 21st century systems with 20th century tools.
That gap is not merely an aesthetic concern. It is an operational breach between design and the actual state of the software, and it generates technical debt.
The Problem: Software Domain and Architecture Are Neither Visible Nor Shared
Every system has an internal structure, a way of organizing its components and relationships, but in most projects that architecture and domain remain hidden inside the code.
Diagrams, when they exist at all, become outdated.
Architectural decisions are left in conversations or in the minds of a few engineers.
Documentation becomes, far too often, something that “gets done at the end, if there is time.”
The result:
- Small changes produce side effects that degrade overall system quality.
- Teams lose time trying to understand their own code.
- Maintenance of existing systems becomes more expensive and slower than building from scratch.
- In regulated environments, traceability and assurance are lost.
What Is Needed: A New Generation of Tools That Provide Visibility and Coherence
Modern engineering does not need more bureaucratic processes. It needs living, executable models. Models that accurately reflect the domain and architecture of the software and evolve alongside it.
A modern modeling tool must:
- Support both visual and textual modeling, enabling clear design and precise automation.
- Be collaborative, integrated with real repositories and actual workflows.
- Generate reliable and auditable code artifacts, not mockups. It must be capable of generating code by applying best practices, following the organization’s coding conventions, and ensuring compliance with regulatory policies.
- Connect design, validation, and execution without any loss of semantics.
In other words, the model must not be a drawing or a piece of documentation, but the source from which all other software artifacts are derived.
The Answer: Structura
Out of that need, Structura was born: a web environment for editing class models both graphically and textually, combining technical rigor with accessibility.
Structura is built on:
- Daga, our visual editing library.
- Essential, a formal metamodel that defines how software structures must be represented.
The result is an editor that makes it possible to:
- Represent classes, associations, and inheritance relationships using UML-style visual notation.
- Review and version models as code, compatible with version control systems such as Git.
- Generate code on demand, customizable according to the technology stack or domain.
- It will also incorporate artificial intelligence assistants to support the creation and explanation of models, though not in the code generation phase, where we intentionally prioritize deterministic generation in order to guarantee the quality of the generated code at all times and make it certifiable.
The Story Behind It: Metadev’s Vision
Structura is not a starting point. It is a consequence.
We work in model-driven engineering, code generation, and regulated environments, from industrial systems to defense and aerospace applications. Throughout that journey, we learned something: tools matter when they allow us to think more clearly, addressing what is essential and discarding irrelevant detail, ultimately choosing the level of abstraction at which we need to work.
First came Apricot, our editor for SysML v2, with which we opened a new chapter in systems modeling. Now, with Structura, we take the next step: bringing that same precision to software modeling.
Both tools share a single principle: engineering must be grounded in models based on formal languages, models that are validatable, versionable, and executable.
Building on What We Design
Modeling is not drawing. Modeling is giving shape to technical thinking, making it shareable, communicable with precise semantics, maintainable, and automatable.
We are committed to a future of software that will be increasingly domain-oriented.
And to get there, we need tools that allow us to shape the domain the way a potter shapes clay, forming the foundation of a system’s knowledge.
Structura: Technical Overview
| Category | Technical Description |
|---|---|
| Tool Type | Graphical and textual editor for software class modeling (UML). |
| Core Technologies | Daga (graphical engine), Essential (metamodel library). |
| Visual Modeling | Notation inspired by classical UML: classes, enumerations, associations, inheritance, and decorators (stereotypes). |
| Textual Modeling | Concise syntax, readable by both humans and tools. Compatible with version control workflows such as Git and designed to facilitate automation. |
| Collaboration | Concurrent real-time editing (multi-user mode). |
| Versioning | Compatible with version control tools such as Git through textual representation of models. |
| Code Generation | Support for on-demand code generation, customizable according to the technology stack or domain. Deterministic, capable of guaranteeing and certifying the quality of generated code by construction. |
| Deployment | Available as a web application (SaaS) or as an on-premise installation in secure environments. |
| Use Cases | Software engineering, class and relationship modeling, and support for traceability and validation. |
| Metadev Integration | Structura shares technological foundations with other Metadev tools, such as Apricot, within the model-driven engineering ecosystem. |
Next in the Series
The Domain as a Common Language
We will explore why the domain acts as a shared language for understanding, communicating, and evolving complex systems.