Software is amenable to frequent evolution, in order to accommodate various changes (such as those in response to clients’ demands). As a software system undergoes changes for which it was not initially designed, it becomes harder and harder to evolve. Moreover, due to time-to-market pressures, the various software artefacts (requirements, architecture, programs, tests) are often not properly updated in a consistent way. Together with the turnover of project development staff, this leads to so called ‘legacy systems’, where the only trustworthy information source about the system is the implementation itself, and knowledge about its architecture and rationale has been lost. This makes further change even more difficult and error-prone, as modifications might break implicit requirements or architectural constraints. Model-driven architecture promises to alleviate these problems in some well-understood application domains: by generating part of the implementation from the architecture, which is the most abstract model of a software system, the consistency between code and design is kept. However, the realisation of this vision will take some time.
The overall aim in this topic is to develop concepts, methodologies, and tools that facilitate evolution of software systems at the architectural level. The following is a non-exhaustive list of possible projects:
- Using existing tools or developing new ones, extract the architecture from multiple releases of the source code of long-lived systems, and develop model comparison and visualisation techniques that enable developers to quickly see and understand how the architecture has been changing over time and its implications.
- Develop algorithms and tools (possibly by adapting those existing for source code) to verify whether intended changes to an architecture will break any constraints and lead to problems.
- Investigate how to capture the rationale of a software architecture, map it to the implementation, and allow the consistent transformation of architecture and implementation.
- Investigate how to represent different views of the same architecture and how to automatically propagate changes in one view to the others, while checking for inter-view consistency.
Whatever the project, ideally the tools to be developed should be based on meta-models of architectural description languages and programming languages, in order to make the developed approach more systematic and widely applicable. Moreover, the techniques to be developed should be light-weight or amnable to automation in order to be useful for professional architects and developers.
Skills and Background required
You should have good programming skills in order to develop new tools or adapt existing ones. Depending on the project (e.g. verification of architectural constraints, or visualization of architectural changes), some knowledge of formal methods or computer graphics might be needed.
References
See also the generic software evolution references and tools in the source code evolution topic.
- Mens et al. Co-evolving code and design with intensional views: A case study. Computer Languages, Systems & Structures, 32(2-3):140-156, 2006
- Oliveira and Wermelinger. A Model-Driven Approach to Extract Views from an Architecture Description Language. Proc. WICSA, 2007.
- Sangal et al. Using Dependency Models to Manage Complex Software Architecture. Proc. OOPSLA 2005.
- van der Hoek et al. Taming Architectural Evolution. Proc. of FSE, 2001.
- Wermelinger et al. Design Principles in Architectural Evolution: a Case Study. Proc. ICSM 2008.