The demand for incremental software development has driven a search for advanced programming techniques, such as aspect-oriented programming and feature-oriented programming. These techniques share the goal of supporting localized implementation of software changes in order to promote program stability. To achieve this goal, they offer a wide range of sophisticated composition mechanisms, which provide means to flexibly define the composition of two or more modules in a program. However, given the complexity of the resulting composition code, the initial definition and further changes to a single composition specification might affect the structure and behaviour of multiple modules, thereby harming the program stability. A complicating factor is that those changes often require some reasoning about certain composition properties, which are not explicit in the implementation or design artefacts. Unfortunately, there is no understanding in the state of the art about the composition properties that affect positively or negatively the program stability. This understanding is not yet possible as: (i) there is no conceptual characterization and quantification means for composition code properties, and (ii) there is no empirical investigation on the influence of these properties on program stability. A side effect of these gaps is that developers have resorted to conventional metrics, such as coupling, to determine or predict the stability of a program implemented with advanced programming techniques. In this context, this thesis presents three contributions to overcome the aforementioned problems. First, we have developed an empirical study revealing that widely-used metrics, such as coupling, are not effective indicators of stability when advanced programming techniques are used. Second, we propose a measurement framework encompassing a suite of composition metrics intended to quantify properties of the composition code. This framework is based on a meta-model and terminology for characterizing the elements and properties of the composition code. This framework is extensible and agnostic to particular programming techniques. Third, we also investigate how to alleviate the maintenance effort in performing changes related to the composition code. We evaluate if the availability of design models enriched with specification of composition properties help developers to improve program stability in their maintenance tasks.