This article describes the model-driven development concept and its implementation in the Novulo development platform. Find out how Novulo maximizes the advantages of Model-driven engineering.
The model-driven development concept focuses on the use of conceptualized representations (models or abstractions) in order to increase productivity, simplify the design process, and facilitate changes to a system’s design specifications. MDD is also sometimes referred to as MDE (Model-driven engineering), not to be confused with MDA(1) (model-driven architecture), which proposes an implementation of MDD using UML (Unified modeling language).
The main goal of model-driven software development (when compared to traditional development) is to write applications at a much higher level of abstraction. Among the envisioned advantages are:
Model-driven development refers to a range of approaches that use a software modeling language as a primary form of expression in software development. While a modeling language can be textual or graphical, most tools for modeling that employ code generation provide the user with a textual model. The major drawback of textual models, however, is of course the level of expertise needed to correctly interpret and expand the model. Consequently, a pragmatic visual approach to modeling can offer a whole new set of advantages that a textual model cannot deliver.
The use of models in software development has inherent advantages, but does not necessarily do wonders for the speed of development It is the ability to generate code from a model that most significantly helps speed up the process. Almost all products that can be used to create software models allow code generation, ranging from simple system skeletons to complete, deployable products. A model that can be generated into a working application without writing a line of code is called an executable model. Non-executable models typically create a set of classes and methods that can serve as a foundation for building an interface and logic layer.
Ideally, the product can generate a complete system while allowing a programmer to integrate custom solutions without overwriting custom code upon the next code generation step. This type of generation provides a maximum increase in development speed without losing control over the generated code. Unfortunately, most products that attempt to generate complete systems often fail to allow good integration of custom code or are simply too limited in their modeling options to meet customer demands.
Executable modeling has the potential to transform requirements analysis. It encourages focus on user needs (as opposed to technical design considerations), enables a wider review circle as more people can participate, and makes the review process active (testing) instead of passive (reading documentation). As exploring the prototype becomes the core technique for accepting the model, room for misinterpretation is reduced and the resulting software can conform better to the customer's needs.
The system model itself should be a platform independent representation of the system. The model can potentially be redeployed on different technology (Java, .Net, etc), binding the system model to that specific technology. This way, you can secure the knowledge of intricate business processes without worrying about having to maintain systems in outdated technologies.
The modeling of abstract concepts also defines the (business) domain of the system. In creating a system, questions such as "What is a customer," "What is a purchase order," or "What is a project" are answered by the model, creating a domain-specific language.
A Domain Specific Language (DSL) is a programming language or programming environment designed with a specific purpose in mind, such as the development of commercial business software. A DSL should be more expressive in its particular problem domain than a non-specific language, providing a clearer representation of concepts that can be used to build a solution to a problem. The higher level of abstraction provides an opportunity to get effective business-alignment through a more useful involvement of business analysts and the structured reuse of the modeled domain concepts. Another advantage of domain engineering2 is the removal of the need to build similar systems from scratch, instead allowing variations on models to meet specific customer needs as they arise.
MDD fits perfectly in a code reusability maximizing strategy, allowing the creation of reusable models that provide you with a visual inventory of code assets. Then, you can extend your assets by simple reuse and adaptation, inheritance, or derived models. As a result, the possibility to generate code from the models, reducing the need for "monkey-coding."
While modeling techniques for software development have been around for decades, it is only in the past few years that enthusiasm for model-driven development has soared. This rise can be contributed to the fact that models in software development are evolving from static diagrams that define a system to the primary method of more deeply involving all participants of the application lifecycle. In recent years, MDD has received a lot more attention from large software vendors, who now view modeling as the core focus for their IT strategy.
"I think one of the biggest trends in application development that I talked about... is modeling, and we're making a big investment in that."4 - Bill Gates, Chairman, Microsoft
"Models will take a central role in future development processes -- both of software and larger systems incorporating software and mechanical and electrical elements." - IBM R&D Labs, Model driven engineering technology group
Software vendors all around the world are shifting the focus of their development towards model-driven development.
Novulo incorporates the basic ideas of model-driven development while maximizing many of its potential advantages. So how does MDD play a part in the Novulo development platform?
Since computers are far better at interpreting textual models rather than graphical representations, most modeling tools resemble enhanced text editors. Textual models are easier to use in code generation steps, but are also abstract and often hard to understand if you are not an expert.
The biggest threshold for end-user participation in the development phase has always been the need for intimate technological knowledge. MDD proposes to lower this threshold by introducing the modeling abstraction. While this is indeed an advantage, Novulo can lower the threshold even further by providing a pragmatic visual representation of the system as it is being developed, as well as the possibility of generating a working system at the touch of a button.
There is no need to have theoretical discussions about a model if you can actually see what you are going to get while it is being built.
The Novulo development platform has a unique application design interface, allowing the application to be built from the end-user perspective. Where (almost all) other MDD platforms choose to focus solely on a data-model at the cost of an underdeveloped user interface, Novulo has found an opportunity to combine development of interface, logic, and data layer in one intuitive application design. This is an important step in increasing the advantages gained by traditional MDD.
Business needs will change over time, and software should be able to follow. The Novulo Architect has a dynamic data-model that offers developers the possibility to change the way the system works without losing development speed. Using the Novulo Architect, systems are created by adding components (interface elements, processes, or expressions) to the application model. The data model is in turn derived from that application model. Each change to the design can trigger a change in the data model. This way, changes to the data model are automatically applied and the Architect user can be directly alerted about implicit changes to the application, and their effect on the designed system.
The Novulo Architect keeps track of changes to the model and stores the model information using XML. This way, the application model can always be reverted to an earlier revision and comparisons can be made between revisions. This feature allows you to fine-tune your application with minimal efforts until you are completely satisfied and simply re-deploy the application.
A system design in the Novulo Architect can hold system-specific information, ensuring that the intimate knowledge of your business software is not lost, and can be accessed in an intuitive graphical interface. The code generation step actually formalizes the step from specification to implementation that would traditionally be done by a programmer. Because of this formalization, the important information is stored in the model itself instead of source code and (hard to maintain) documentation.
While MDD is a big step forward in accomplishing a shorter time-to-market and better business alignment, most products incorporating MDD focus solely on data modeling. Novulo combines interface, processes, logic, and data manipulation in one application model, offering additional advantages:
The ability to implement custom code in generated Novulo applications also addresses one of the major drawbacks of using executable models. This solves the shortcoming of most MDD approaches that are incapable of handling requirements that are not in the modeling environment, or cannot be modeled correctly. Novulo supports the development process without posing restrictions.
Global demand for software development and maintenance is expected to rise at a pace that software producers cannot keep up with using traditional development methods. The software industry has embraced model-driven development as a means of improving quality and speed of software engineering in an effort to scale up to higher levels of productivity.
MDD offers a strategy to leave the development processes where every application is built as though it is the first of its kind and instead focus on the customer’s demands: better business value, shorter time to market, and a longer application lifecycle through easier maintenance and adaptability.
The Novulo Architect provides a very practical method of creating and maintaining models for your system while letting you build a library of domain-specific components. It handles direct code generation from the created models, providing a working system within minutes while the ability to integrate custom coding in generated applications ensures enough freedom to meet all customer demands.