Aspect-oriented software evolution

All software systems are subject to evolution. This poses great challenges to software engineers. We claim that aspect-oriented software development (AOSD), in addition to separating the different concerns during software development, can be seen as a way to overcome many of the problems related to software evolution. At the same time, AOSD may benefit from tools and techniques that automate software evolution. Our research explores the cross-fertilisation between these two active research domains. Introduction Real-world Software needs to evolve continually in order to cope with ever-changing software requirements. This characteristic has been identified by Manny Lehman in his so-called first law of software evolution, addressing continuing change: A program that is used must be continually adapted else it becomes progressively less satisfactory. This need for software to evolve continuously poses important challenges on software engineers. Advanced automated software engineering techniques and tools are needed to improve software evolution support. An ERCIM Working group on Software Evolution was launched in May 2004 to address this need. Two important techniques that will be investigated actively are software restructuring and aspect-oriented software development. Software Restructuring Software restructuring should be an essential activity in software engineering, according to Lehman’s second law of software evolution, addressing increasing complexity: As a program is evolved its complexity increases unless work is done to maintain or reduce it. In program transformation research, two different restructuring approaches can be distinguished. The term rephrasing is used to refer to techniques that improve the structure of the software without changing the implementation language. A typical example is software refactoring, which aims at improving the internal structure of a program without changing its external behaviour. The term translation refers to techniques that restructure the software across programming languages. A typical example is migration of legacy code to an object-oriented equivalent (e.g., COBOL to Java). Aspect-Oriented Software Development An essential problem with software development is the tyranny of the dominant decomposition. No matter how well a software system is decomposed into modular units, there will always be concerns (typically non-functional ones) that cut across the chosen decomposition. The code of these crosscutting concerns will necessarily be spread over different modules, which has a negative impact on the software quality in terms of comprehensibility, adaptability and evolvability.