María Cecilia Bastarrica

An MDE approach to software process tailoring

Defining organizational processes is essential for enhancing maturity. However the best process depends on the particularities of each project. Typically a process engineer defines a specific process for each project in an ad-hoc fashion, which is expensive, unrepeatable and error prone. Trying to deal with this challenge we propose a model-based approach to software process tailoring that generates project specific processes based on the organizational process and the project context. The approach is systematic, repeatable and it does not depend on the people using it. The proposal has been applied for tailoring the Requirements Engineering process of a medium size company. The obtained results were validated by process engineers of the company. Processes obtained using the proposed approach matched the ones used in the company for planned contexts and also they were reasonable for non-expected situations.

Integrated notation for software architecture specifications

Currently, there are many notations to specify software architectures, which address a wide range of formality and completeness. Completely formal notations produce accurate and analyzable software architecture specifications, but the most formal and complete notations are also the most difficult to use and understand. Conversely, informal notations are easier to use and understand, but several design aspects may remain underspecified. This paper presents an integrated notation for specifying software architecture that reduces the complexity to use completely formal notations without resigning the formality required by software architecture specifications. The integrated notation proposes an architectural specification in three levels of abstraction: a graphical box-and-line diagram to specify the structure, a behavioral specification using input/output automata, and a basis of Larch traits describing the domain specific abstract data types. The proposed integrated notation has been used to specify the architecture of a complex mesh management tool and part of the specification is presented. Although more experimentation is required, the obtained results are encouraging.

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.

Building software process lines with CASPER

Software product quality and project productivity require defining suitable software process models. The best process depends on the circumstances where it is applied. Typically, a process engineer tailors a specific process for each project or each project type from an organizational software process model. Frequently, tailoring is performed in an informal and reactive fashion, which is expensive, unrepeatable and error prone. Trying to deal with this challenge, we have built CASPER, a meta-process for defining adaptable software process models. This paper presents CASPER illustrating it using the ISPW-6 process. CASPER meta-process allows producing project specific processes in a planned way using four software process principles and a set of process practices that enable a feasible production strategy. According to its application to a canonical case, this paper concludes that CASPER enables a practical technique for tailoring a software process model.

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.

Typing in Model Management

Model management is essential for coping with the complexity introduced by the increasing number and varied nature of artifacts involved in MDE-based projects. Global Model Management (GMM) addresses this issue enabling the representation of artifacts, particularly transformation composition and execution, by a model called a megamodel. Typing information about artifacts can be used for preventing type errors during execution. In this work, we present a type system for GMM that improves its current typing approach and enables formal reasoning about the type of artifacts within a megamodel. This type system is able to capture non-trivial situations such as the use of higher order transformations.

Estimating the development effort of Web projects in Chile

We present a method to fast estimate the development effort of Web-based information systems in Chile. The method, called Chilean Web application development effort estimation (CWADEE), addresses a necessity to get effort estimations in a short period of 24 to 72 hours using limited information. In contrast with other existing methods, CWADEE uses raw historical information about development capability and high granularity information about the system to be developed, in order to carry out such estimations. This method is simple and specially suited for small or medium-size Web-based information systems. CWADEE has been applied to twenty-two projects with very accurate results.

Typing artifacts in megamodeling

Model management is essential for coping with the complexity introduced by the increasing number and varied nature of artifacts involved in model-driven engineering-based projects. Global model management (GMM) addresses this issue by enabling the representation of artifacts, particularly transformation composition and execution, within a model called a megamodel. Type information about artifacts can be used for preventing type errors during execution. Built on our previous work, in this paper we present the core elements of a type system for GMM that improves its original typing approach and enables both typechecking and type inference on artifacts within a megamodel. This type system is able to deal with non-trivial situations such as the use of higher order transformations. We also present a prototypical implementation of such a type system.

Designing a product family of meshing tools

Applying software engineering concepts can improve the quality of any software development, and this is even more dramatic for complex, large and sophisticated software, such as meshing tools. Software product families are series of related products that make intensive reuse of already developed components. Object-oriented design promotes reusability, so it is specially suited for designing the structure of product families. In this paper we present an object-oriented design of a product family of meshing tools, where all family members share the software structure. By instantiating the structure with particular algorithms and parameters, we can easily produce different tools of the family. A good family design allows us not only to combine existing algorithms but also to easily incorporate new ones, improving software family evolution. We show how the family design is used for the generation of finite element and finite volume meshing tools, as well as a new tool for image processing.

MDE software process lines in small companies

Software organizations specify their software processes so that process knowledge can be systematically reused across projects. However, different projects may require different processes. Defining a separate process for each potential project context is expensive and error-prone, since these processes must simultaneously evolve in a consistent manner. Moreover, an organization cannot envision all possible project contexts in advance because several variables may be involved, and these may also be combined in different ways. This problem is even worse in small companies since they usually cannot afford to define more than one process. Software process lines are a specific type of software product lines, in the software process domain. A benefit of software process lines is that they allow software process customization with respect to a context. In this article we propose a model-driven approach for software process lines specification and configuration. The article also presents two industrial case studies carried out at two small Chilean software development companies. Both companies have benefited from applying our approach to their processes: new projects are now developed using custom processes, process knowledge is systematically reused, and the total time required to customize a process is much shorter than before.