EAUNIT

Why we model? ¶

In MBSE, we model to understand, communicate, and manage complexity. As systems grow larger and more interconnected, it becomes harder to keep everything in our heads or describe it with documents alone.

A model gives us a structured, visual way to represent the system - so we can:

• Clarify complex ideas: Modeling helps engineers think clearly about how different parts of the system work together.
• Ensure consistency: It makes sure that requirements, design, and implementation are all aligned.
• Detect errors early: By simulating and analyzing the model, we can catch mistakes before they reach the real system.
• Communicate effectively: A model speaks a common language among team members, stakeholders, and tools.
• Make better decisions: With a reliable model, we can explore design options, evaluate trade-offs, and make confident choices.

If the implementation deviates… ¶

But even if the model is perfect, if the implementation deviates from the design, the system can:

• Behave unexpectedly, because what’s built no longer matches what was intended.
• Break integration points, especially in large systems, where even small changes can ripple out and cause failures elsewhere.
• Invalidate verification, since tests and simulations based on the model no longer apply.

That’s why traceability and verification are essential parts of MBSE. It’s not just about creating the model - it’s about ensuring the real system reflects it, and feeding back results from the implementation - like test outcomes - into the model. When we do that, the model evolves from just a blueprint into something more powerful: a single source of truth.

Traditional Issues ¶

Although there are various factors that cause discrepancies between design, implementation, and verification, the following issues are generally identified.

• Difficulty in checking the quality of design and implementation in large scale development.
• The relationship between the model on the tool and the software that actually works is weak.
• The design model is ideal, but there is no way to verify consistency with the implementation.
• Design information is not updated even though the design and implementation are completely different.
• Unable to ascertain the comprehensiveness of verification for the entire system.
• The end is not in sight due to the repetition of ad-hoc verification.
• There are systems that work, but the design details are unknown.

These are caused by the gradual loss of access to design information during the process of design, implementation, and verification. In particular, if there is no feedback from verification to design in the implementation and verification process, where complex issues tend to arise, a gap between design and implementation is likely to occur.

Solution ¶

Ensuring consistency between design, implementation, and verification is one of the most important aspects of continuous software delivery. With traditional methods, there is little direct relationship between design and implementation, and as a result, it is often unnoticed when deviations occur.

In recent years, test-driven development has become widespread in the software development field, and consistency between implementation and verification is now ensured. EAUNIT provides a means to reflect the verification results in the design, thus constituting a feedback loop that can ensure consistency between design, implementation, and verification.

EAUNIT operates as a plug-in for Enterprise Architect, a model-based design tool that can organize the logic of design objects in a variety of representations. The verification results output from the verification process are fed back to the design tool, and the integrated information is used to observe the system, enabling multifaceted decisions.

Improve your workflow with EAUNIT ¶

Let’s imagine a shift.

What if your model didn’t stop at design - what if it showed actual test results? What if it could reveal failures you didn’t even expect, and help you verify real system behavior - right inside the model?

Think about traceability that doesn’t just link requirements to design, but all the way to validation. In that world, your model becomes more than documentation - it becomes a source of truth that keeps everyone aligned: engineers, testers, managers.

That’s the promise of a truly integrated, model-based approach.

In development projects involving multiple stakeholders, maintaining a complete view of requirements, design, implementation, verification, and delivery is crucial. Ensuring consistency and quality across all processes is essential for successful outcomes when dealing with defining and structing of the software from the developers perspective EAUNIT, an add-in for Enterprise Architect, bridges the gap between design and implementation by logically linking test items and results.

Developed by Liberal Logic Inc., this solution enables multidimensional analysis of design objects from all aspects-requirements, design, implementation, verification, and delivery-creating a cohesive and efficient development environment. In the vertical integration of requirements definition, design, implementation, and validation, workflow awareness is essential for development teams to collaborate effectively in creating high value-added systems. With EAUNIT, the workflow remains simple and clear.

Vertical integration of requirements definition, design, implementation, and validation, workflow awareness is essential for development teams to work together to create high value-added systems. Workflow with EAUNIT is simple and clear. It can be deployed in all sizes of development, from small development organizations to large cross-organizational development organizations.