On the reputation and usefulness of models: Model-Based Techniques Require Model Quality Assurance
The successful application of Model-Based techniques (such as Model-Based Testing or Model-Driven Development) relies on the quality of the models in which the resultant artifacts are based on. In other words, a Model-Based technique assumes that the input model is valid since the quality of the result depends on the quality of the model. If this equation is not considered, Model-Based techniques may lead to unexpected results and loss of reputation, despite their widely accepted benefits and opportunities. Therefore, several questions arise:
- How can we pursue the quality of a functional model in a Model-Based context?
- Do Model-Based techniques require Quality Assurance to be applied on the model?
- What are the risks of non up-to-date models as the project goes on?
The successful application of Model-Based techniques relies on model quality. Pursing the quality of software is a marathon that finds the continuous alignment between relative truths (stakeholders’ expectations, perceptions, the current version of explicit specifications, the system behavior, etc.). In this context, requirements validation throughout a project is a common challenge since validation references are multiple and diverse and an agreement in a common view is a key aspect. Even the system implementation cannot be considered an absolute truth because it usually becomes unaligned with other validation references over time (changing requirements, new expectations, unrevealed necessities, etc.). This is why maintenance efforts need to be continuously invested in on software systems. Therefore, models also require continuous validation and maintenance to take into account observed changes. The quality of a functional model may be pursued and analyzed in practice by managing its alignment with other artifacts (tests, requirements specifications, implementation, etc.) that may potentially trigger/discover changes that may affect the current common view.
Validation requires alignment points and up-to-date evolution of the model. The usefulness and acceptance of models rely on its credibility and reputation. Model-Based techniques need to guarantee enough quality of the model during project evolution. Performing Model-Based projects without designing validation alignment points between the model and other software artifacts may lead to important risks. If, for example, a change is detected during testing and the model is not evolved accordingly, then the model becomes inconsistent and its reputation falls down because the Model-Based process cannot be applied for evolution. As in scientific progress, absence of contradictory observations is the base for acceptance and progress. We need to guarantee consistent models as time passes. Therefore, we need to detect contradictory views and solve them as soon as possible. Detecting un-alignments between the model and other artifacts and resolving them is a practical technique for models to represent with lower risks and the most up-to-date common view of the system.
In conclusion, Model-Based techniques require support by quality assurance techniques that focus on the validation and the consistent evolution of models. Existing innovation projects support the automated alignment between models and other artifacts (like tests), considering its evolution over time. If no quality evolving techniques are applied to Model-Based projects, then models become one-use artifacts, the reputation of input models decreases quickly, and software maintenance does not benefit from their potential. So… let’s pursue the alignment for successful Model-Based approaches!
About Albert Tort
Albert Tort is CTO of Sogeti Spain. He is a software engineering and testing & quality assurance specialist.
More on Albert Tort.
It is possible (maube even recommended) to use model to model transformation to ensure quality of the code.
For example, we can transform our model to the Petri net model, that is easily provable and verifiable with languages such as CTL (computational tree logic) and LTL (linear temporal logic).
After that using OCL, we can ensure that the generated code is valid. Because we have already checked that our model (or rather our model tranformation) is valid and respect all the possible cases.
For your information, during my studies, I’ve specialized in Model Driven Engineering (Model to model tranformation, Model to text transformaiton, Model checking, Code generation, …)