Cristóbal Costa-Soria

Plastic Partial Components: A solution to support variability in architectural components

Software Product Line Engineering is becoming widely used due to the improvement it means when developing software products of the same family. The commonalities and variabilities of Software Product Lines (SPL) are identified during the Domain Engineering process and then, they are realized in the software architecture. Therefore, mechanisms to explicitly specify the commonalities and variabilities of SPLs at the architectural level are required. Most of the current mechanisms specify variations on the architecture by adding or removing architectural elements. However, it is also necessary to specify variations inside components. In this paper, we propose the notion of Plastic Partial Components to support internal variations. The specification of these components is performed using Invasive Software Composition techniques and without tangling the core and product architectures of the SPL. This contribution is illustrated through a SPL for developing domain-specific validation environments.

A Reflective Approach for Supporting the Dynamic Evolution of Component Types

The increasing complexity of software systems requires a continuous revisions process in order to correct errors or to add new functionalities. However, the nature of some systems makes unfeasible their stopping to integrate changes. Dynamic evolution of types is a feature that provides support for changing completely at runtime the types that a system is composed of. Thus, a system is able to integrate new types, or to modify/remove existing ones, while it is running. In software architecture, these types are component specifications, and its instantiations, component instances. This paper presents a reflective approach for providing dynamic evolution of component types and instances in a decentralized way. Each type can be evolved separately from others, and each one of its instances evolves asynchronously, only after finishing their running transactions. The approach is reflective since it dynamically provides editable specifications of the type to evolve, and reflects changes on both types and instances while they are running.

Teaching software architectures and aspect-oriented software development using open-source projects

The complexity and the big size of current software systems are challenges to be faced in software development. In the last few years, these challenges have increased the effort required to develop such large software systems. As a result, students must be able to develop these systems using approaches that reduce their development costs. Two of these approaches are Software Architectures and the Aspect-Oriented Software Development. However, in order to acquire skills in these approaches, students must put them into practice in realistic software projects. For this reason, we propose a reverse engineering method to learn these approaches by using open-source projects.

Managing Dynamic Evolution of Architectural Types

Software systems evolvability is more and more required in current software developments, in order to provide systems with enough flexibility to adapt to future requirements. The evolvability in the field of Software Architecture can be classified into two kinds: dynamic reconfiguration or dynamic architectural type evolution. The former enables an architecture to change its configuration at run-time, by creating or destroying architectural element instances and their links dynamically. The latter enables an architecture to change entirely its specification at run-time, by introducing new architectural element types and connections or by modifying the type and the running instances of its architectural elements. This paper presents an approach to address how to dynamically evolve the architectural types of a system from a platform-independent view. This approach identifies the different concerns involved in the adaptation process by encapsulating them into aspects, and makes use of reflection mechanisms to perform the type updating process.

Modelling the asynchronous dynamic evolution of architectural types

Self-adaptability is a feature that has been proposed to deal with the increasing management and maintenance efforts required by large software systems. However this feature is not enough to deal with the longevity usually these systems exhibit. Although self-adaptive systems allow the adaptation or reorganization of the system structure, they generally do not allow introducing unforeseen changes at runtime. This issue is tackled by dynamic evolution. However, its support in distributed contexts, like self-organizing systems, is challenging: these systems have a degree of autonomy which requires asynchronous management. This paper proposes the use of asynchronous dynamic evolution, where both types and instances evolve dynamically at different rates, while preserving: (i) type-conformance of instances, and (ii) the order of type evolutions. This paper describes the semantics for supporting the asynchronous evolution of architectural types (ie. types that define a software architecture). The semantics is illustrated with PRISMA architecture specifications and is formalized by using typed graph transformations.

Handling the Dynamic Reconfiguration of Software Architectures Using Aspects

Currently, most software systems have a dynamic nature and need to evolve at run-time. For this reason, the dynamic reconfiguration of software architectures is a challenge that must be dealt with to enable the creation and destruction of component instances and their links at run-time. This challenge is even greater when there are autonomous composite components which also need reconfiguration capabilities to evolve their internal compositions. This paper presents a novel approach to dynamically reconfigure software architectures taking advantage of aspect-oriented techniques. The approach presented is a platform-independent alternative whose aim is to increase the reuse and to decrease the maintenance effort. It deals with the challenge of reconfiguring composite components that: (1) are easy to maintain, since the dynamic reconfiguration concern is separated from the other concerns; (2) can autonomously reconfigure themselves, since each composite component is provided with dynamic reconfiguration services to change its internal architecture.

An approach for teaching software engineering through reverse engineering

As the number of existing software systems increases, it also does the number of software engineers involved in the maintenance of large existing systems. Maintenance projects are becoming more usual than new software developments. For this reason, Computer Science education should also consider the development of abilities to deal with large existing software systems. This paper describes an approach to teach software engineering by using existing real-life software systems, through reverse software engineering techniques. The approach introduces the student into a medium-sized team which has to perform a set of modifications over an unknown large software system. The learning process is directed towards the improvement of abstraction skills, a key skill for software engineers.