How Model-Driven Software Engineering Can Benefit from the Third Dimension

Introduction

Over the last years, the processing power of computer systems increased steadily. Gordon Moore predicted in Moore’s Law that the number of transistors in integrated circuits doubles every year. This trend is related to the increasing complexity of software systems and architectures.[1] This emphasizes the importance of abstract representations with the intent to support the system architects/designers and programmers by comprehending structures of the system.

Tools for software visualization and modeling are important for raising the comprehension, and hence help to make the design and evaluation process through all software development phases more productive.

What is Model-Driven Software Engineering?

Model-Driven Software Engineering (MDSE) has the main purpose to increase the comprehension of a software system by providing a higher abstraction level through models. Models usually hide irrelevant aspects and show the relevant information in a more simple and easier to perceive manner. Therefore, different models can provide different views on a system. Usually, visual models are used to provide an even better comprehension. In this article, modeling languages refer to visual modeling languages.

Model-Driven Software Engineering has another aim – It is supposed to automate certain parts of the software development process, and hence close the gap between the specification, made with the model, and the implementation. It is desirable that the abstract model is transformed into software artifacts like source code.  This may often happen with an intermediate step of a specialized model.

When it comes to Model-Driven Software Engineering, one can basically distinguish two types of modeling languages. There are the general-purpose languages like the OMG’s Unified Modeling Language (UML) and the domain-specific languages (DSL). The standardized UML is widely used and supported by many tools. But the use of a domain-specific modeling language can pay off in the long run because it might be more powerful and more adjusted to the target domain’s problems and requirements. This leads to an increased efficiency. But is should also be kept in mind that it is time consuming to develop a DSL.

Related Work from the Field of 3D Software Visualization

There has already been done some research on the field of 3D software visualization. To get an overview, I recommend the journal article “An Overview of 3D Software Visualization”[2] which deals with the previous research and findings concerning three-dimensional computation and software visualization. They especially highlighted the importance of integrating the findings and developed techniques into the software development process and team. They also stated that user requirements and human factors should be considered, and the problem of navigating in visualizations with 2D input and output devices should be addressed. But it is also pointed out that 3d software visualizations will gain influence in the future.

Previous research on the field of software visualization has found that three-dimensional visualizations have benefits though, like:

  • Increased information density,
  • Better and faster perception through the user,
  • Decreased error-proneness when it comes to identifying structures[3]

This can be put down to the assumption that 3D software visualizations are closer to reality, and hence are better perceived. The third dimension can also be used to show additional information.

But I clearly want to distinguish the software visualization from the software modeling. Software visualizations comprise graphical representations of system aspects (e.g. code metrics, system components) or a system overview with the aim to increase and enhance the comprehension, for documentation or to highlight potential sources of errors. Software visualizations are often made via reverse engineering from an existing system.

Vergleich Softwarevisualiserung und Softwaremodellierung

Comparison Software Visualization and Software Modeling

Software modeling in terms of model-driven development has the aim to make the software development process more efficient by means of abstract, formal models. These models are used to create software artifacts via automated transformations. The models can be either of textual or visual nature. An example for a textual language is the Object Constraint Language (OCL) of the OMG. The visually model-driven software development process is based on visualizations of the system, and therefore the findings of the common research area on software visualizations can be applied. This includes findings about the perceptual eligibility of visualizations to support the grasp for the visualized system, as well as findings about the user-optimized interaction with the visualization. When it comes to model-driven software development, special attention has to be paid to interactions because the models are the primary artifacts.

Conclusion

The approach to use three dimensional visualizations to illustrate software structures is not a new one.  Previous findings support the assumption that these visualizations are advantageous compared to 2D visualizations. But previous research mainly focused on the visualization of existing systems. The question, we try to answer in this research project is, how model-driven software development can benefit from visual 3D software models.

In this research project, a framework for efficient, model-driven and domain-specific software development with 3D models shall be developed. This framework should enable one to create modeling languages and define 3D representations for them. Combined with code generation rules this can be used to create a language for the model-driven development.

Komponenten einer 3D-Modellierungssprache für modellgetriebene Softwareentwicklung

Components of a 3D modeling language for model-driven software development

This framework will be the basis for an exemplary modeling language, which will be used for further studies. Interaction techniques will be evaluated, as well as the suitability of the 3D visual language compared to 2D languages.


References

1.    Bob Schaller: The Origin, Nature, and Implications of “MOORE’S LAW”. The Benchmark of Progress in Semiconductor Electronics (1996)

2.    Teyseyre, A., Campo, M.: An Overview of 3D Software Visualization. Visualization and Computer Graphics, IEEE Transactions on 15, 87–105 (2009)

3.     Irani, P., Ware, C.: Diagrams based on structural object perception. In: Proceedings of the working conference on Advanced visual interfaces, pp. 61–67. ACM, New York, NY, USA (2000)

This entry was posted in 3D Software Engineering. Bookmark the permalink.

Kommentar sind geschlossen.