In software engineering, techniques of continuous integration allow short test cycles and thus fast feedback cycles. However, if there is a need to change the deployment or update the functionality, it becomes dificult to assess the impact of such changes on performance. In this context, we present in this paper an extensible approach for reverse engineering of component-based systems for quality prediction. We build on the principles and techniques of model-driven engineering to analyze a system at the model level and to enable subsequent optimization.
Component-based software development is characterized by the concept of developing systems by integrating reusable components that interact with each other and form a clearly defined software architecture. However, the resulting advantages, such as improved maintainability and scalability, also face new challenges. The increased number of software components brings to the fore the importance of compliance with standards for rapid development and sustainable maintenance. To perform this task, a new developer must first understand the architecture of the component-based systems. One way to improve this understanding is to automatically restore and create an architecture model with the system properties relevant for developers. Model-driven reverse engineering techniques can be used for this purpose. It is the process of understanding software and creating a model suitable for documentation, maintenance or reengineering.
Garcia et al. conclude in [
The goal of our proposed approach is to support the creation and maintenance of software architecture models for quality prediction. For this purpose, we want to capitalize on reusable descriptions of concepts for the reverse engineering of models for quality prediction. To achieve such a goal, the following research questions are formulated: RQ1 How do the technologies used induce the software architecture? RQ2 How can knowledge about technologies be implemented as rules for reverse engineering? RQ3 How can these rules be composable for diferent technologies for a software system?
The application of model-driven software development techniques to solve reverse engineering
problems is called Model-Driven Reverse Engineering (MDRE). [
The motivation of Model-Driven Quality Prediction (MDQP) is to enable the early design time prediction of software systems to determine quality characteristics such as performance, reliability or data protection. MDQP attempts to automate the process of analyzing the information available in the model and provide software developers and architects with these analysis values as early as possible as a basis for design decisions.
An example of a MDQP approach would be the so-called Palladio approach [
The idea of the approach we propose is to model the knowledge of the domain of the technologies used in component-based software development in order to reverse engineer the architecture from artifacts. This knowledge could describe how a component is implemented using a certain framework. Our approach is module-based and comes with a predefined set of modules for model discovery, understanding and generation. This allows our approach to be easily extended by project-specific rules or implementations. Our approach is to integrate the following steps into the continuous integration of a software system: 1. Discovery: Parsing the existing artifacts, accumulating structure and behavior information about these artifacts in EMF-based models. 2. Understanding: Analyzing these models using rules represented by model-to-model transformations. Detected concepts are stored in the decorated model. 3. Generation: Generate behavioral models based on the source code model and the decorated model.
The first step of our reverse engineering approach is to obtain a model from existing artifacts that allows a uniform view of the software system. Thereby artifacts that are written during the development of a software system, e. g. source code or other configuration files like deployment descriptors, are taken into account. In order for these models to provide a uniform view, they must conform to a given metamodel that expresses the selected artifacts. This metamodel could be programming language specific or map other configuration files. Moreover, these metamodels are created as Ecore metamodels in order to enable uniform modeling. The actual structure of these models is realized in model-driven reverse engineering by so-called discoverers, which depend on the associated metamodel. In our approach, discoverers are provided by additional modules and can support diferent types of artifacts.
The second step is the main step of our reverse engineering approach. In this step, the previously generated models are used to efectively achieve the desired reverse engineering scenario. During this step, these models are analyzed by using so-called rules. The underlying idea of the rules is to capture domain knowledge about technologies with them. We use this knowledge to reverse engineer the architecture of a system in which this technology is used. For this purpose, rules capture how a certain concept is implemented in a technology and, which efects this concept has on the architecture of the system. These rules are expressed as model-to-model transformations.
In the third step the behavior of the methods of the interfaces of the recognized components is transformed into a PCM instance. In this step, parts of the Palladio-Bench are used to transform the behavior given in the Java model into an abstract behavior on component level. For this purpose, not only the Java model but also the references to the previously recognized concepts are entered into the Palladio-Bench. Links to the original source classes are stored here for each architecture model entity. By this mechanism, any later analysis result on architecture level can be traced back to low-level classes and methods.
The expected main contribution is the design and development of the model-driven reverse engineering approach described in the previous section. Where the focus will be on the rules for a diverse set of technologies. We plan to evaluate both the framework and these rules. Evaluation methods will include industrial case studies as well as reference applications for reverse engineering. In this evaluation, we will define goals, questions whose answers will indicate whether the goal has been achieved, and metrics that represent measurable answers to the questions. On this basis, we will compare the quality predictions of our own reverse engineering results with related approaches.
Tzerpos and Holt present ACCD [
Garzón et al. propose an approach to reverse engineer object-oriented code into a unified
language for both object-oriented programming and modeling [
Raibulet et al. compare in depth fifteen diferent model-driven reverse engineering approaches
in their literature review and find that both these approaches and their areas of application
are versatile [
In this paper, we created an overview of our model-driven approach to improve the reverse engineering of component architectures. The main idea is the reverse engineering of components with their interfaces and their distribution from existing software development artifacts such as source code or configuration files under consideration of the used technologies. We expect improved reverse engineering results, since heuristics such as cohesion or coupling no longer need to be used to determine components from the source code. As we want to use knowledge about the technologies used to detect components, we expect our proposed approach to generate models more in line with real architecture. Also we expect technology-specific rules to provide a better understanding of the relationships between a technology and its underlying concept and software architecture. These technology-specific rules allow reuse in projects that use a specific technology.