Large software systems are often constructed by reusing existing code. This dissertation describes several approaches that address the limitations of existing code reuse mechanisms such as class inheritance. The Polyglot design pattern enables software systems to be extended in a scalable way: the code required to extend the system is proportional to the amount of new functionality provided. This design pattern has been used to implement an extensible compiler framework. Nested inheritance is an object-oriented programming language mechanism that supports scalable extensibility in a safer, more natural way than the design pattern approach. Nested inheritance permits modular, type-safe extension of a package (including nested packages and classes), while preserving existing type relationships. Nested intersection extends nested intersection to enable composition and extension of two or more packages, combining their types and behavior while resolving conflicts with a relatively small amount of code. Nested intersection is implemented in the language J&. The utility of J& is demonstrated by using it to construct two composable, extensible frameworks: a compiler framework for Java, and a peer-to-peer networking system. Both frameworks support composition of extensions. For example, two compilers adding different, domain-specific features to Java can be composed to obtain a compiler for a language that supports both sets of features.