Daniel Perovich

Model-Driven approach to Software Architecture design

Software Architecture (SA) allows for early assessment of and design for quality attributes of a software system, and it plays a critical role in current software development. However, there is no consensus on fundamental issues such as design methods and representation organization and languages, and current proposals lack specificity and preciseness. Thus, it is extremely difficult to build a complete and appropriate software architecture, even though it is recognized as a fundamental artifact. In this paper we define an architecture design method that enables the systematic and assisted construction of the SA of Enterprise Applications, taking into account major quality attributes involved in this family of systems. We apply Model-Driven Engineering techniques to achieve this goal. The architecture is treated as a mega-model (a model composed of related models) and the application of design decisions is encoded in terms of model transformations. The architectural rationale is explicitly registered as the set of transformations that yields the complete SA from scratch. We illustrate the application of the approach by designing the SA of a case study from the literature.

Feature model to product architectures: Applying MDE to Software Product Lines

A Software Product Line (SPL) is a portfolio of products that targets a particular domain. Feature Models are generally used for modeling domain knowledge including variability within SPLs. The Product Line Architecture (PLA) defines the structure that all potential products in the SPL share. Designing a good PLA is challenging since different products may require different characteristics, and it is difficult to achieve an acceptable trade-off. In this paper we apply Model-Driven Engineering techniques for systematizing the Domain Engineering stage to enable the automation of the Application Engineering stage. We use features to modularize architectural decisions and we encode them as model transformations that render the fragment of the product architecture that addresses the features. Then, we make the rationale explicit, and we enhance evolvability and incrementality diminishing design complexity. Product implementation is derived by means of generators analogously. We show our approach by developing a Meshing Tool SPL.

A megamodel for Software Process Line modeling and evolution

Companies formalize software processes as a way of organizing development projects. Since there are differences in project contexts, a one-size-fits-all approach does not work well in practice. Some companies use a family of a predefined processes, but this approach has a high process maintenance cost. Instead, we define Software Process Lines (SPrL), where a general process with variability is tailored to project contexts. Model- Driven Engineering (MDE) provides a formal framework for defining the models and transformations required for automated SPrL tailoring. However, this approach requires the definition and co-evolution of various types of models and tool support beyond the skills of process engineers, making the industrial adoption challenging. This paper shares our experience using a megamodeling approach to the development of the back-end of our toolset. The megamodel provides a uniform mechanism for process definition, variability, tailoring and evolution, and we hide the MDE complexity through a user-friendly front-end. We report the application of our approach at Mobius, a small Chilean software enterprise.

Reuse of Architectural Knowledge in SPL Development

Software Product Lines (SPL) promote reuse within an application domain in an organized fashion. Preimplemented software components are arranged according to a product line architecture (PLA). Balancing possibly conflicting quality attributes of all potential products makes PLA design a challenging task. Moreover, if quality attributes are part of the variabilities of the SPL, then a unique PLA may result highly inconvenient for particular configurations. We consider the PLA as a set of architectural decisions organized by the features in the Feature Model. A particular product architecture (PA) is defined as the subset of decisions associated to the chosen features for the product. Architectural knowledge is then reused among products and when new features are required in the SPL. Variability at the quality attribute level will impact the style of the resulting architecture, thus choosing different quality features will produce PAs following different styles, even within the same SPL. We use MDE techniques to operationalize this procedure and we illustrate the technique using the case of a Meshing Tool SPL.

ATAM-HW: Extending ATAM for Explicitly Incorporating Hardware-Related Trade-Off Decisions

ATAM is a widely known software architecture analysis method based on trade-offs of design decisions for coping with quality attribute requirements. Practically, all reported cases of applying ATAM refer mainly to software-intensive systems. However, there is a series of software systems for which fulfilling their requirements strongly depends on hardware-related decisions. As ATAM provides no special treatment for these cases, several problems arise when applying the method. In this paper we present ATAMHW, an extension to ATAM, that explicitly deals with hardware-related decisions. It adds some steps to ATAM to links quality attributes requirements of a system with hardware related decisions made by the architect. We illustrate its application for analyzing a virtual electrical generator that has been developed in the last years.

Architecture of Component-based Information Systems over the J2EE Platform

Component-based development can be addressed from two dierent fronts, or more precisely, from two dierent levels. One of them regards the technology used for system implementation, and the other is a previous and more abstract level, where the focus is set to the logical structure of the solution and where technological issues are not considered. Model Driven Architecture promotes such separation by distinguishing platform independent models from platform specic models. In alignment with this approach, this article proposes a mapping from the tiered and platform independent architecture for information systems resulting from the application of a widely known methodological approach, to the available constructs in the J2EE platform. This mapping allows the denition of transformations between platform independent models, resulting from the referred methodology where it is possible to abstractly reason about the solution, and platform specic models which are aligned with technological constructs and are directly implemented.

Process-based project management and SPI

Software process definition and improvement are frequent strategies followed by software companies in order to enhance software quality and boost development productivity. Software processes are used for guiding development teams while executing projects, and also as a basis for project planning and monitoring. There are some tools available for software process definition and a plethora of tools for project management with support for project planning and monitoring. These tools are usually not integrated so project plans are made manually possibly introducing inconsistencies with respect to the process they are based on. Moreover, when project management is not performed using an integrated tool, plan and trace also differ. Measuring process execution is a common path for SPI. To this end, matching tasks in the process, plan and trace is needed to understand where the process fails and how it might be improved. Inconsistencies among these artifacts hinders SPI since manually matching tasks demands a large effort. In this paper we define an approach for process-based project management that reduces these inconsistencies. We present CASPLE, a tool that supports this approach, and we illustrate its application in PowerData, a small Chilean company. A case study of applying the approach and CASPLE in four of our industrial partners is also presented.

Brief author index

Software Architecture (SA) allows for early assessment of and design for quality attributes of a software system, and it plays a critical role in current software development. However, there is no consensus on fundamental issues such as design methods and representation organization and languages, and current proposals lack specificity and preciseness. Thus, it is extremely difficult to build a complete and appropriate software architecture, even though it is recognized as a fundamental artifact. In this paper we define an architecture design method that enables the systematic and assisted construction of the SA of Enterprise Applications, taking into account major quality attributes involved in this family of systems. We apply Model-Driven Engineering techniques to achieve this goal. The architecture is treated as a mega-model (a model composed of related models) and the application of design decisions is encoded in terms of model transformations. The architectural rationale is explicitly registered as the set of transformations that yields the complete SA from scratch. We illustrate the application of the approach by designing the SA of a case study from the literature.

Extracting Object Interactions Out of Software Contracts Using Model Transformations

One popular approach to object design proposes to identify responsibilities from software contracts, apply a number of principles to assign them to objects, and finally construct an object interaction that realizes the contract. This three-step activity is currently a manual process that is time-consuming and error-prone, and is among the most challenging activities in object-oriented development. In this paper, we present a model transformation that partially automates this activity. Such a transformation is modularized in three stages. The first stage automatically transforms a software contract to a trace of state modification actions. In the second stage the designer manually extends the trace with design decisions. Finally, the extended trace is automatically transformed to an object interaction in the third stage. A prototype of the whole transformation was developed and successfully applied to a case study from the literature. Our technique allows the extraction of valuable information from software contracts, provides a bridge between analysis and design artifacts, and significantly reduces the effort of interaction design.