September 8th, 2024

How to Tame Evil Dependencies

Dependencies among software development teams can hinder project success, increasing time-to-market and failures. Effective management involves reframing dependencies as risks and employing strategies like minimization, mitigation, and knowledge sharing.

Read original articleLink Icon
How to Tame Evil Dependencies

Dependencies among software development teams in large organizations can significantly hinder project success, leading to increased time-to-market and potential project failures. These dependencies often arise from interrelated requirements, sequential engineering processes, and interconnected software components. To effectively manage these "evil dependencies," it is crucial to adopt a holistic approach that reframes them as tangible risks. This involves three key strategies: risk avoidance, risk mitigation, and risk acceptance. Minimizing dependencies is the most effective strategy, achieved by realigning teams, refactoring software systems, and focusing on customer-oriented backlog items. Mitigating the impact of dependencies can be accomplished through establishing common standards, fostering a whole product focus, and enabling self-service capabilities. Continuous knowledge sharing and coordination practices are essential for managing residual dependencies. By implementing these strategies, organizations can enhance team performance, reduce lead times, and ultimately improve software delivery.

- Dependencies can lead to increased time-to-market and project failures.

- Effective management of dependencies involves reframing them as risks and employing risk management strategies.

- Minimizing dependencies is crucial and can be achieved through team realignment and refactoring.

- Mitigating the impact of dependencies requires common standards and a focus on whole product development.

- Continuous knowledge sharing and coordination are vital for managing remaining dependencies.

Link Icon 4 comments
By @PaulHoule - 7 months
I’ve felt like Cassandra whenever I’ve pointed out how product structure, team structure, or process structure was causing development to bog down.

I’ve seen cases where we were building models that took a certain amount of calendar time and if we only managing punchclock time we wouldn’t start building early enough.

Similarly I think it’s a problem if you have 12 maven projects and what management thinks is a ‘simple’ change involves touching 7 of them, I think an objective measure of a good design is that changes can frequently be confined to a small number of files and directories.

Most of all the popular ‘heavy JS frontend’ architecture is frequently disastrous not for technical reasons but for the wetware problems of coordinating a front end and a back end team which would turn 2 sprints into 3 sprints without any bungling but add just a little bungling multiplied by the team structure and 2 sprints become 7 or 8 sprints. (The worst thing about it is that because people feel disempowered to do anything about it there is this ‘groupthink’ that causes people to neither perceive the bungling or the amplification of bungling by sprints that transform 2 day delays into 2 week delays)

By @simonw - 7 months
One of my favorite stories of a failed dependency concerns video support for Flickr.

My recollection is that the Flickr team had been told they should to hold off on building this and wait for technology developed by Yahoo! Video.

After six months or so of waiting, a Flickr engineer knocked something together using ffmpeg over a weekend.