Luis Filipe Andrade

Tool support for coordination-based software evolution

In todays global and highly competitive business environments, organisations are replying to the question of whether technology is forming business or vice versa by integrating their business and IT strategies, thus using technology to do business. As a consequence, there is an increasing pressure to build software systems that are able to cope with the new requirements imposed by both technological advances and different business rules. At the same time, it is now widely accepted that, although object-oriented techniques have provided useful tools for software construction, their support cannot be extended directly to evolution. Even worse, it is becoming evident that there is a lack of theoretical principles and accompanying practical tools that can effectively support software evolution. In this paper, we describe in detail a development tool that is based on sound mathematical principles and supports an architecture-based approach to evolution centred on the notion of a coordination contract - a modelling primitive that treats components as black boxes and is compositional with respect to change.

Coordination: the evolutionary dimension

Whereas object-oriented techniques like inheritance and clientship have provided useful tools for taming the complexity of system construction, it is now clear that the same kind of support cannot be extended to evolution. However, the volatility of business requirements (as a result of e-economics) is putting an increasing pressure on the ability to accommodate changes and extensions at run-time, even performed directly by customers, and with minimal impact on the rest of the system. In this paper, we argue for the adoption of an additional structuring principle - coordination - which treats components as black boxes and is compositional with respect to change. This principle is supported by techniques borrowed from parallel program design (superposition) and configurable distributed systems (architectural connectors). We provide a formal semantics based on category theory that admits an implementation via design patterns. Finally, we discuss its impact on software development methodology.

Coordination Technologies for Managing Information System Evolution

Information System Engineering has become under increasing pressure to come up with software solutions that endow systems with the agility that is required to evolve in a continually changing business and technological environment. In this paper, we suggest that Software Engineering has a contribution to make in terms of concepts and techniques that have been recently developed for Parallel Program Design and Software Architectures, which we have named Coordination Technologies. We show how such mechanisms can be encapsulated in a new modelling primitive - coordination contract - that can be used for extending Component Based Development approaches in order to manage such levels of change.

Architecture Based Evolution of Software Systems

Although architectural concepts and techniques have been considered mainly as a means of controlling the complexity of developing software, we argue, and demonstrate, that they can play a vital role in supporting current needs for systems that can evolve and adapt, in run-time, to changes that occur in the application or business domain in which they operate.

Patterns for Coordination

The separation between computation and coordination, as proposed by recent languages and models [7], has opened important new perspectives for supporting extendibility of systems, i.e. the possibility of adapting software systems to changes in requirements in an easy way. The evolutionary model that we have been developing is based on the representation of the more volatile aspects of the application domain like business rules as connectors whose purpose is to coordinate the interaction among core, more stable, components. The idea is that, in this way, evolution can be made to be compositional over the changes that occur in the application domain through the addition, deletion or substitution of connectors, without interfering with the services provided by the core objects of the system.

Architectural Transformations: From Legacy to Three-Tier and Services

With frequent advances in technology, the need to evolve software arises. Given that in most cases it is not desirable to develop everything from scratch, existing software systems end up being reengineered. New software architectures and paradigms are responsible for major changes in the way software is built. The importance of Service Oriented Architectures (SOAs) has been widely growing over the last years. These present difficult challenges to the reengineering of legacy applications. In this chapter, we present a new methodology to address these challenges. Additionally, we discuss issues of the implementation of the approach based on existing program and model transformation tools and report on an example, the migration of an application from two-tier to three-tier architecture.

Interconnecting objects via contracts

The evolution of todays markets and the high volatility of business requirements put an increasing emphasis on the flexibility of systems, i.e. on the ability for systems to accommodate the changes required by new or different organisational needs with a minimum impact on the implemented services. In this paper, we put forward an extension of UML with a semantic primitive-contract-for representing explicitly the rules that determine the way object interaction needs to be coordinated to satisfy business requirements, as well as the mechanisms that make it possible to reflect changes of the business requirements without having to modify the basic objects that compose the system. Contracts are proposed as extended forms of association classes whose semantics rely on principles that have been used in Software Architectures and Distributed System Design for supporting dynamic reconfiguration.

AGILE: Software Architecture for Mobility.

Architecture-based approaches have been promoted as a means of controlling the complexity of system construction and evolution, in particular for providing systems with the agility required to operate in turbulent environments and to adapt very quickly to changes in the enterprise world. Recent technological advances in communication and distribution have made mobility an additional factor of complexity, one for which current architectural concepts and techniques can be hardly used. The AGILE project is developing an architectural approach in which mobility aspects can be modelled explicitly and mapped on the distribution and communication topology made available at physical levels. The whole approach is developed over a uniform mathematical framework based on graph-oriented techniques that support sound methodological principles, formal analysis, and refinement. This paper describes the AGILE project and some of the results gained during the first project year.

An architectural approach to auto-adaptive systems

We propose a layered architecture based on the separation of two concerns - computation and coordination - as a means of achieving higher levels of auto-adaptability. This separation makes it possible for adaptation to be enforced through the reconfiguration of the system in terms of the mechanisms that coordinate interactions, superposing connectors among components of the system without intruding on the way the computations that they perform locally are implemented.

Agility through coordination

Information System Engineering has become under increasing pressure to come up with software solutions that endow systems with the agility that is required to evolve in a continually changing business and technological environment. In this paper, we suggest that Software Engineering has a contribution to make in terms of concepts and techniques that have been recently developed for Parallel Program Design and Software Architectures. We show how such mechanisms can be encapsulated in a new modelling primitive--coordination contract--that can be used for extending Component-Based Development approaches in order to manage such levels of change.