Aspect-Oriented Software Development (AOSD) is a sub-domain of softwareengineering that focuses on the modularization of crosscutting concerns; i.e. concernsthat are impossible to modularize with classical object-oriented or component-baseddecomposition techniques. Paradoxically, AOSD is not immune to a number ofproblems that are often quoted in software engineering literature: limited evolvability(decay), and limited reusability (brittleness) of software.In this dissertation, we address these problems by providing concrete methodologicalsupport to employ existing Aspect-Oriented Programming (AOP) techniques suchas pointcut interfaces to define explicit interfaces between the base and the aspect.Concretely, we present a method to design explicit pointcut interfaces which are(i) robust in light of software evolution and (ii) can be reused by multiple aspects.To achieve this, we base the design of a pointcut interface on the stable abstractionsin the problem domain that are suitable for aspect-oriented composition.The presented method starts in the development phase of domain analysis andrequirements engineering with the discovery of stable abstractions that are anchoredin the domain model of the application. This involves state-of-the-art domainanalysis techniques and systematic restructuring of use case models. Duringarchitecture creation, these stable domain abstractions are mapped onto pointcutinterfaces, and we list a number of potential implementation strategies how to reifydomain abstractions in software and perform composition.To make this method more concrete, we define algorithmic procedures for theactivities that involve use case re-engineering and present guidelines for architecturecreation. Based on this effort, we prove a number of properties of the method(complexity, confluence, etc) and we assess the degree to which it can be automated.Based on this, we have developed a prototype implementation.We conducted the validation of this method across three large-scale realistic casestudies, where we observe that the resulting pointcut interfaces can be reusedfor implementing the composition logic of different aspects without requiringmodifications to their pointcut signatures. These case studies are: (i) an electronicbanking system, (ii) a car crash management system (CCMS), and (iii) a digitalnews platform.The CCMS was provided to us by a third party, and as such serves as an independentvalidation of our work: we provide concrete evidence from the CCMS of how ourmethod can be adopted to realize the above-mentioned goals. Specifically, weillustrate how ripple effects from the base application to the aspects are avoided,and how this contributes to pointcut interface stability. Secondly, we show howduplication is avoided in the specification of the pointcut interfaces, and how thisleads to effective reuse of the pointcut interfaces by multiple aspects.The news publishing system is an industry-grade digital publishing platform. Todevelop this system, we have applied aspect-oriented methods and techniques.Concretely, we show how a component-based software version of the publishingplatform is refactored using AOSD techniques, and how this improves variabilityand evolvability of the publishing infrastructure by enabling invasive features to beintroduced easily and dynamically.The method presented in this dissertation is positioned as a contribution to thematuration of AOSD as a software engineering sub-discipline. Furthermore, weprovide ample argumentation why we believe our findings and results are notexclusively restricted to AOSD and we outline a number of future research tracks.