This post was sparked by a conversation at OpenStack Atlanta between OpenStack Foundation board members Todd Moore (IBM) and Rob Hirschfeld (Dell/Community). We share a background in industrial and software process and felt that sharing lean manufacturing translates directly to helping face OpenStack challenges.
While OpenStack has done an amazing job of growing contributors, scale has caused our code flow processes to be bottlenecked at the review stage. This blocks flow throughout the entire system and presents a significant risk to both stability and feature addition. Flow failures can ultimately lead to vendor forking.
Fundamentally, Todd and I felt that OpenStack needs to address system flows to build an integrated product. The post expands on the “hidden influencers” issue and adds an additional challenge because improving flow requires that the community influences better understands the need to optimize work inter-project in a more systematic way.
Let’s start by visualizing the “OpenStack Factory”
Imagine all of OpenStack’s 1000s of developers working together in a single giant start-up warehouse. Each project in its own floor area with appropriate fooz tables, break areas and coffee bars. It’s easy to visualize clusters of intent developers talking around tables or coding in dark corners while PTLs and TC members dash between groups coordinating work.
Expand the visualization so that we can actually see the code flowing between teams as little colored boxes. Giving project has a unique color allows us to quickly see dependencies between teams. Some features are piled up waiting for review inside teams while others are waiting on pallets between projects waiting on needed cross features have not completed. At release time, we’d be able to see PTLs sorting through stacks of completed boxes to pick which ones were ready to ship.
Watching a factory floor from above is a humbling experience and a key feature of systems thinking enlightenment in both The Phoenix Project and The Goal. It’s very easy to be caught up in a single project (local optimization) and miss the broader system implications of local choices.
There is a large body of work about Lean Process for Manufacturing
You’ve already visualized OpenStack code creation as a manufacturing floor: it’s a small step to accept that we can use the same proven processes for software and physical manufacturing.
As features move between teams (work centers), it becomes obvious that we’ve created a very highly interlocked sequence of component steps needed to deliver product; unfortunately, we have minimal coordination between the owners of the work centers. If a feature is needs a critical resource (think programmer) to progress then we rely on the resource to allocate time to the work. Since that person’s manager may not agree to the priority, we have a conflict between system flow and individual optimization.
That conflict destroys flow in the system.
The number #1 lesson from lean manufacturing is that putting individual optimization over system optimization reduces throughput. Since our product and people managers are often competitors, we need to work doubly hard to address system concerns. Worse yet our inventory of work in process and the interdependencies between projects is harder to discern. Unlike the manufacturing floor, our developers and project leads cannot look down upon it and see the physical work as it progresses from station to station in one single holistic view. The bottlenecks that throttle the OpenStack workflow are harder to see but we can find them, as can be demonstrated later in this post.
Until we can engage the resource owners in balancing system flow, OpenStack’s throughput will decline as we add resources. This same principle is at play in the famous aphorism: adding developers makes a late project later.
Is there a solution?
There are lessons from Lean Manufacturing that can be applied
- Make quality a priority (expand tests from function to integration)
- Ensure integration from station to station (prioritize working together over features)
- Make sure that owners of work are coordinating (expose hidden influencers)
- Find and mange from the bottleneck (classic Lean says find the bottleneck and improve that)
- Create and monitor a system view
- Have everyone value finished product, not workstation output
Added Subscript: I highly recommend reading Daniel Berrange’s email about this.