Evolution, Binary Compatibility, and Safe Migration Strategies

Inheritance tightly couples subclasses to base class internals, making evolution risky at scale. Adding an abstract method to a base breaks all implementers unless they are recompiled. Even adding a non abstract method can alter method resolution, change vtable layout, and impact performance. In multi team, multi repo environments serving billions of requests daily, this coupling is operationally expensive: a single base change requires coordinating deploys across hundreds of services. Google Protocol Buffers explicitly avoid inheritance for this reason, favoring composition (messages contain messages) to guarantee forward and backward compatibility across thousands of services without coordinated rollouts. Composition enables safer evolution: new capabilities are added as components, existing implementations remain unaffected. You can introduce a new retry strategy or timeout policy without touching core logic or requiring downstream consumers to rebuild. This is critical when services are deployed independently and schema changes must be non breaking. At Meta and Google, layering cross cutting concerns as composable policies means you can canary a new circuit breaker implementation on 1 percent of traffic, compare error rates and latencies, and roll back without impacting the core request path or other layers. Migrating from inheritance to composition requires careful validation. Create adapters that wrap the old base class with composed components and run both in production behind feature flags. Compare p50, p95, p99 latencies, error rates, resource usage (CPU, memory, garbage collection), and request success rates. Shadow deployments and differential testing catch subtle contract drift: serialization behavior, error propagation semantics, or ordering changes that alter observable behavior. Production teams report discovering 2 to 5 percent error rate differences or 10 to 30 millisecond latency shifts during shadow runs that were invisible in unit tests. Android development illustrates another dimension: the 65,536 method reference limit per DEX file is a hard constraint. Deep inheritance hierarchies increase method count and virtual call sites. Teams report that moving cross cutting behaviors (logging, metrics, lifecycle hooks) from base activities and fragments into composable delegates reduces method counts by 10 to 20 percent, avoiding multi DEX penalties that add tens to hundreds of milliseconds to cold start on low end devices, directly affecting p90 and p95 app startup Service Level Agreements (SLAs).

Google Protocol Buffers allow adding optional fields to messages without breaking older consumers; inheritance based schemas would require recompiling all services, infeasible at scale of billions of messages per day

Meta canaries a new timeout strategy as a composed component on 1 percent of newsfeed traffic, compares p99 latency (305 milliseconds vs 295 milliseconds baseline), and rolls back when error rate increases by 0.5 percent

An Android app reduced base activity method count from 8,200 to 6,500 by extracting lifecycle hooks into delegates, avoiding multi DEX and cutting cold start time from 1,200 milliseconds to 950 milliseconds on low end devices