Description
Modifying existing code is just the worst. It's a tangled mess of dependencies, you don't know the original author's intent, and simple changes feel like they break the world. But it can be better. Wouldn't it be nice to be in a codebase where you primarily added new code and didn't touch the old stuff? We can achieve this by viewing your code through the lens of extensibility.
In this talk, you'll learn what extensibility means, and some common patterns for making your code more extensible. We'll take a hard look at the Open-Closed Principle and how to deal with a mess of dependencies. We'll then walk through how to make your code composable so that it's easier to build up abstractions. We'll finish off by looking through two architectural styles that promote extensilbility: event-driven architectures and pluggable architectures.
Software is going to change (that's why we call it "soft"ware). That's inevitable. How your codebase withstands that change is up to you. Don't write a tangled, fragile mess that is incomprehensible. Make it easy to extend, and you'll greatly extend the lifetime of your products.