Summary
Why does software seem to drift toward complexity no matter how carefully we build it? What unseen forces shape our systems over time?
In this intensive one-day workshop, Michael Feathers explores the fundamental forces that determine how software changes over time and why systems take the forms they do. You’ll walk away with actionable insights and practical strategies for steering long-lived systems toward sustainable growth rather than inevitable decay.
Who should attend?
Ideal for senior developers, architects, and technical leaders who are responsible for long-lived systems, this workshop goes beyond simple patterns and practices to explore the deeper dynamics that govern software development at scale.
Learning Objectives
Participants will leave with a new mental model for understanding why software behaves the way it does and how to navigate its natural tendencies.
Agenda
Through hands-on exercises, case studies, and collaborative analysis, you’ll learn to recognize these forces in your own systems and develop strategies to work with them rather than against them. The workshop provides practical techniques for harnessing these forces to guide systems toward sustainable evolution rather than decay.
This workshop dives into the forces—often invisible, yet always present—that influence the structure, behavior, and longevity of software systems. You’ll learn to recognize the principles that drive software evolution and work with these dynamics in your own codebase, including:
- Entropic Forces: Why systems naturally move toward disorder and complexity without active intervention
- Conway's Law: How organizational communication structures inevitably become reflected in code architecture
- Hyrum's Law: The inevitable dependence on implementation details despite API contracts
- Complexity Attractors: Identifying the patterns that draw complexity into specific areas of systems
- Resistance and Flow: Understanding how information and change propagate through codebases
- Cohesive Forces: The elements that bind code together and resist decomposition
- Evolutionary Pressure: How external business demands shape internal technical structures
Working Effectively with Legacy Code
By Michael Feathers - Published by Robert C Martin Series
This book provides programmers with the ability to cost-effectively handle common legacy code problems without having to go through the hugely expensive task of rewriting all existing code. It describes a series of practical strategies that developers can employ to bring their existing software applications under control. The author provides useful guidance about how to use these strategies when refactoring or making functional changes to codebases.
One of the book's key points is that it teaches developers to write tests that can be used to ensure they are not unintentionally changing the application as they optimize it. Examples are provided in Java, C++, and C#, and the book assumes that the reader has some knowledge of UML notation. Strategies using UML and code in C++ and Java are emphasized, while language-independent advice is delivered in sidebars and appendices for language-specific users.
