You are a software engineering manager and your team proposes that model-driven
ID: 3766172 • Letter: Y
Question
You are a software engineering manager and your team proposes that model-driven engineering (using design models such as UML or structured) should be used to develop a new system. What factors should you take into account when deciding whether or not to introduce this approach to software development? You are a software engineering manager and your team proposes that model-driven engineering (using design models such as UML or structured) should be used to develop a new system. What factors should you take into account when deciding whether or not to introduce this approach to software development? You are a software engineering manager and your team proposes that model-driven engineering (using design models such as UML or structured) should be used to develop a new system. What factors should you take into account when deciding whether or not to introduce this approach to software development?Explanation / Answer
I have written a lot about model driven software development approaches from different perspectives. For example from a domain specific language design perspective, an integrated modeling approach for SOA perspective, etc. I also have tried to give you a balanced view on MDD by talking about the things to know before starting with MDD and by discussing some potential dangers of MDD. You would say that if someone asked me for the advantages of Model-Driven Development I would just send him a link… Unfortunately this is not the case. I can of course answer this question,
So, why MDD? What are the advantages of MDD, MDE, MDA or other model-driven related acronyms?
MDD is faster
In Model-Driven Development the model of a software application is specified on a higher abstraction level than traditional programming languages. This model is automatically transformed into a working software application by generating code or interpreting / executing the model. While the used model is on a higher abstraction level it is much smaller compared to the same model expressed in code. In other words: each element in the model represents multiple lines of code. Hence, you can build more functionality in the same time. See for example this comparison between Mendix and Java development. MetaEdit+, another MDD tool is told to be five times faster than traditional programming.
MDD is more cost-effective
MDD can be more cost effective. The first reason is that you have a shorter time-to-market because MDD is faster. The second reason is that it is possible to do it at lower cost (i.e. with less people, non-specialists, increased quality, etc. – see the points that follow). This of course depends on the costs of learning the MDD approach and the costs to develop or buy the tool. It also depends on your business model. If you are used to selling programming hours your business will be affected by using MDD. Changing and maintaining applications build using an MDD approach is also more cost-effective. It is easier to understand the behavior of an application by reading high-level models. Additionally it is faster to add functionality or change existing functionality using a high-level language.
MDD leads to increased quality
Because a software application is specified in a high-level model which is executed by an engine or transformed into code; the (technical) quality of the application depends on the generator or engine. Hence, the quality can increase a lot because we can let our best people work on the generator. Furthermore, all best practices we learn in projects can be included in the generator and will automatically be applied to projects build using the MDD tool. In case of buying an MDD tool the tool can contain even more best practices because it builds on the knowledge of all projects build by the MDD tool in the past.
MDD is less error-prone
Everyone having experience with delivering a new software application knows that testing costs a lot of time and expertise. MDD ensures that you can focus on testing the functionality of the application, i.e. acceptance testing. Technical problems are covered by testing the MDD tool. Think for example about infrastructure related problems or security leaks in the technology.
MDD leads to meaningful validation
Even the functionality itself is less-error prone when using an MDD approach, because meaningful validations can be executed on the high-level models. When using traditional programming languages you will have some syntax checking in your IDE and maybe even some static code analyzers. However, due to the generality of the programming language this does not really help you to avoid functional errors. When using an MDD approach domain-specific validations can be executed at design-time. The resulting error message can be domain-specific too. See for example this article on the static verification of a textual DSL. In the Mendix modeling environment we use real-time consistency checking to ensure that the model is consistent and can be executed by the runtime environment.
MDD results in software being less sensitive to changes in personnel
When using an MDD approach the resulting software will be less sensitive for changes in personnel. As you do not need a technical specialist anymore to build software you can draw from a larger pool of people. Furthermore, if someone joins a project it is far easier to understand the high-level model of the software application compared to trying to understand the behavior of the application by reading source code.
MDD results in software being less sensitive to changes in business requirements
One of the problems of software development is that business requirements often change faster than the supporting software systems. In a previous article I stated: it is questionable whether enterprises can actually maintain a focused strategy long enough to align their core business processes with IT. The current dynamic business environments do not give enterprises that time. However, MDD can provide a solution because it makes software development faster, it also leads to easier to change applications.If there is an explicit link between business requirements and the model of the software application it is even possible to propagate part of the changes automatically.
MDD results in software being less sensitive to changes in technology
Technology changes follow each other faster and faster. Think about things like Java EE, SOA / SOBA, webservices, REST, SCA, OSGi, and more recently restrictions in technology when moving applications to the cloud (e.g. other database structures). MDD makes sure you do not have to change your application model when you want to migrate your application to other technologies. The only thing which needs to change is the code generator (or interpreter). After changing the code generator (or adding additional code generating options) all application models can directly be transformed into code for the new technology.
If you recognize one of these points from your practical experiences or if you think you have a solution for (almost) all points, please let me know it in the comments! Although model-driven approaches can differ a lot
MDD actually introduces a lot of rigidity
If you’re used to programming everything by hand, MDD can be quite rigid. The goal of MDD is to ‘program’ on a higher level of abstraction. This means that you have to specify less and generate more. However, this also means that you can’t change every little detail you want. It is, for example, often the case that generated graphical user interface are inflexible and they all look like each other.
Models are only flexible where flexibility has been designed
The problem with using models to directly drive the engineering of software is that they are far from flexible. First, you are limited by the kind of Model Driven Engineering tool you use. Second, you’re only flexible in the parts of the solution covered by the used Domain-Specific Languages. The higher level the DSL the more commonalities are ‘hard-coded’ in the framework or engine you use. Third, sometimes models are made flexible at predefined points by lower level expressions or languages. That’s nice, but hopefully it is exactly done at the points you’ll need it.
The roles of project members are quite different
You need to be aware of the fact that the roles in Model-Driven Engineering are different from the roles in traditional development. The real technical or programming part is mostly moved to the ‘meta-team’ building the model-driven software factory. Building the solution is done by so-called business engineers instead of programmers. These people need to understand the business (like e.g. traditional functional designers) but they also need to express the knowledge they gather in a formal model. People able to do both these things are quite rare.
The modeling environment doesn’t always support version control
If you have experience with building (enterprise) software applications I guess you’re using a version control system. If not you should go and read this nice explanation. Existing version control systems work very well for textual programming languages. However, versioning of graphical models is a far less researched field. Most existing modeling and model-driven tools don’t include a full featured versioning system. That’s a pain when working with large teams.
The requirements team needs to understand what is allowed and what not
I pointed at the rigidity and inflexibility of MDD. This is mostly dangerous from a technical perspective. However, it is even more dangerous when the requirements team, i.e. the people talking with the customer, don’t understand the limitations of the used tool/approach. In the ideal situation, the people talking with the customer directly translate their knowledge in executable models. However, in big projects you often see a separation in two roles. As in traditional development this can lead to a gap. This gap can become a nasty problem if the requirements team doesn’t understand the limitations of the tool/approach. For example, the requirements team reaches a consensus with the customer on a certain part of the graphical user interface (let’s say a form), while it isn’t possible to build that form with the model-driven tool without a lot of custom handiwork.
Innovation distracts
Last but not least, MDD is dangerous because innovation distracts. People tend to focus on the new tool they are using with all its cool features. Even more, people will start bragging about the great advantages they have with the new technology, in the end forgetting the projects objectives. Experiments have been done actually showing this behavior of project teams starting to use new innovative tools. The important lesson: don’t forget your project management, your process, and all other things you need beside the tool or technical approach you use!
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.