Mia-Software provides solutions based on the engineering model (Model-Driven Engineering) to industrialize the development of software applications.
A code generator intervenes primarily during the design phase of an application. It offers a number of benefits, of which the principal ones are given below:
Reduced development time
Frequently, repetitive code has to be written for a great number of entities (e.g. accessors for all the classes). Each time, the code is almost identical with only some minor changes to a few characters (e.g. the entity name). When this type of code has to be reproduced a large number of times, the ability to generate it makes it possible to save a considerable amount of time.
Quality
When code is generated, the number of errors is considerably reduced. In fact, all typing errors, copy and paste mistakes (very common technique when a generator is not used), omissions, etc. are avoided. These types of errors are not necessarily glaringly obvious, so the risk to leave some in the final code is significant.
However, when using a code generator, if a mistake is done when the script is written, the error is generally reflected on all entities: thus, the detection is fast. A script correction and a complete regeneration make it possible to correct the error. And finally, if the code is generated, it is possible to ensure a single presentation format, which allows the code to be more readable, and thus easier to maintain.
Adaptability
When you start a design, you do not necessarily have everything clear in your mind. This leaves two possibilities open to the developer :
- You begin the design quickly, with the risk of making bad choices, and then have to rewrite part of the code.
- Or you postpone the beginning of the design until all the concepts have been completely validated, with the risk of delaying the other phases of the project.
When a code generator is available, this dilemma is not of such importance since a late design idea can be easily integrated, no matter what the number of impacted entities. In this way, the design can be started without all of the concepts being completely frozen, even if it means having to reconsider certain parts of the code later on. Therefore, it is possible to quickly deliver a first version, in which it will be easier to detect possible problems.
Continuity between analysis and design
In any project of significant size, analysis constitutes a prominent part of the workload. The purpose of this analysis is, among others, to obtain a design model that will guide the developers in carrying out their implementation task. Everything would be perfect if, once the analysis is complete, you are sure to have forgotten nothing and to have modeled everything as it should be. However, it is uncommon that once the design phase has started, you do not have to reconsider the analysis phase anymore. In fact, in addition to possible omissions, you are never completely exempt from an evolution of specifications and future users' expectations.
When the design is started, any modification implies a change of both the model and the existing code. This double intervention has a very significant cost because it is a tiresome operation consuming time and energy. When the lead-time is short, the risk exists that modifications are carried out only on the code and that they are not reflected in the model. In this event (which happens frequently) the model is gradually forsaken, then completely abandoned, as the differences become too significant.
With a code generation tool, the model remains the reference throughout the project's lifecycle. In effect, the modifications can be performed on the model (and not directly into the code), where you can always re-generate the necessary code. In this way, the model is not only a representation of what should be implemented, but also becomes a representation of what is implemented (and therefore what has been implemented, which is very useful during the maintenance phase).
Reactivity
Generally speaking, the use of a code generator ensures better reactivity during the implementation phase.
Mia-Software designed and developed Mia-Generation to respond to such challenges: the templates apply on a model to automatically produce code.
Mia-Documentation is based on the power and ease of use of Mia-Generation to propose a solution for generating flexible and effective documentary.
The use of Mia-Generation helps define the content and presentation of documentation to produce and can fully exploit the UML model to be documented. Finally, the documentation produced responds to the need for the user.
During the development process, the application can be described through several models depending on the different steps that lead from analysis to design.
Some of these models can be deduced from another model produced in the previous step. When the shift from one model to another is done according to rules formalized, it is possible to automate this transformation.
Mia-Software designed and developed Mia-Transformation to respond to such challenges: the rules apply automatically processing on one or more models to obtain one or more other models.
