Large software systems, which often consist of many interacting components, are hard to develop. For example, a compiler may contain tens of components modeling abstract syntax tree (AST) nodes, and various components for compiler passes, and the implementation of each component is entangled with that of many other components, as suggested in Wadler’s expression problem [87]. This dissertation describes language-based mechanisms to improve the reliability and extensibility of large software. Accessing uninitialized data is a significant source of software unreliability, causing unpredictable or exceptional behavior. Existing object-oriented languages do not guarantee that objects are correctly initialized before use. This dissertation presents masked types to ensure the soundness of object initialization, even with class inheritance and cyclic data structures. The type system tracks initialization in a fine-grained, modular way, and embeds a graph theoretic algorithm for reasoning about the construction of complex data structures. Class inheritance is an important way to reuse code in object-oriented languages, but it has two limitations when applied to large software systems. First, a family of interacting classes cannot be extended together while preserving their relationships, and second, new functionality cannot be added to existing objects in a modular way. The dissertation presents two solutions: class sharing and family sharing, both addressing the two limitations at once. Class sharing is heterogeneous, which allows two families of classes to share some of their members, but at the price of complex language mechanisms. Family sharing is homogeneous: two shared families always share all of their member classes. Shadow classes are introduced to ensure type safety, and provide the additional expressiveness of open families. Finally, the dissertation presents implementation techniques that make the sharing mechanisms practical.