Try This


We offer this 21-step program for implementing lean software development. Each step contains just a brief sketch of what might be done. You will find the details scattered throughout the earlier parts of this book. Consider these as suggestionstry them and see if they produce the results that you are looking for in your organization.

Optimize the Whole

  1. Implement lean across an entire value stream and the complete product: Appoint a value stream leader or leadership team that accepts responsibility for the entire value stream starting and ending with customers. Focus on the whole product, not just the software. Draw a value stream map and look for interruptions in flow, loop-backs or churn, and areas in the flow that are either not available when needed or not capable of delivering the needed results. Fix broken processes, and provide missing system capabilities.

  2. Restructure the measurements: Chances are very high that there are local measurements within the value stream, and chances equally high that these measurements lead to suboptimizationor worsedysfunction. Stop using the local measurements, and use value stream measurements instead.

  3. Reduce the cost of crossing boundaries: If there are big delays in a value stream, they probably occur at department or company boundaries. Look at these boundaries carefully and evaluate how much they are actually costing. Anything you can do to speed the flow of value across these boundaries will almost certainly reduce the cost of crossing the boundary.

Respect People

  1. Train team leaders/supervisors: Instead of focusing on process leaders, give natural team leaders the training, the guidance, the charter, and the time to implement lean in their areas.

  2. Move responsibility and decision making to the lowest possible level: Your lean initiative should be implemented by the work teams that create value under the guidance of their existing leaders. Have work teams design their own lean processes, with guidance from properly trained team leads and supervisors. Expect the work teams to ask for what they need to make the new processes work.

  3. Foster pride in workmanship: Many things impede pride in workmanship: individual over team rewards, sloppy workspaces and work practices, impossible deadlines, no time for proper testing or refactoring, imposed processes, routine or robot-like jobs, etc. Root out and eliminate these practices: never create conflicting incentives among team members, automate routine tasks, let workers decide the best approach to their job, never ask for sloppy work in the interest of meeting deadlines. Encourage passionate commitment and expect top-quality results. This will have a more sustained positive impact by far than individual incentives and bonuses.

Deliver Fast

  1. Work in small batches: Reduce project size. Shorten release cycles. Stabilize. Repeat. Clean out every list and queue, and aggressively limit their size going forward.

  2. Limit work to capacity: Have teams work at a repeatable cadence to establish capacity. Expect teams to pull from queues based on their proven velocity and to completely finish the work before they start on more work. Limit queue sizes, and accept no work unless there is an empty slot in a queue.

  3. Focus on cycle time, not utilization: Stop worrying about resource utilization and start measuring time-to-market and/or customer response time.

Defer Commitment

  1. Abolish the notion that it is a good practice to start development with a complete specification: Concurrent development means allowing the specification to emerge from the development process. Concurrent development saves money, it saves time, it produces the best results, it allows you to make decisions based on the most current data. There is nothing not to like about concurrent development, so why cling to the idea that there ought to be a complete specification before getting started with development? If the answer is driven by up-front funding, then move to incremental funding. If it is driven by fixed-price contracting practices, move to another contracting model.

  2. Break dependencies: Instead of worrying about dependencies, do everything possible to break them so that any feature can be added in any order. A divisible systems architecture is fundamental. Ruthlessly question dependencies, and tolerate them only very sparingly.

  3. Maintain options: Develop multiple options for all irreversible decisions and never close off an option until the last responsible moment. Critical design decisions are tradeoffs. Invest enough in understanding the impact of each option to have the data and the confidence to make the best choice. For all other decisions, create change-tolerant code, keep it clean and simple, and do not hesitate to change it.

Create Knowledge

  1. Create design-build teams: Assure that the systems architecture allows products to be broken into logical modules that can be addressed by cross-functional teams representing the interests of all steps in the value stream. Provide each team with the appropriate leadership and incentives to maintain engagement, transparency, and intensive feedback. These teams must be encouraged to share early and often, fail fast, and learn constantly.

  2. Maintain a culture of constant improvement: Create the time and the expectation that every team and every function will continually examine and improve its processes and test its assumptions. Hold cross-team and cross-functional events to identify accommodations and constraints in the flow of value and replace these with practices and policies that will improve overall results.

  3. Teach problem-solving methods: Teach the PDCA cycle or the scientific method or some variation of these problem-solving methods. Expect teams to establish hypotheses, conduct many rapid experiments, create concise documentation, and implement warranted changes.

Build Quality In

  1. Synchronize: Aggressively reduce partially done work. Write tests first. Test code as soon as possible. Don't put defects on a liststop and fix them the moment they are detected. Integrate code as continuously and as extensively as possible. Use nested synchronization to integrate with ever larger and more complex systems.

  2. Automate: Accept that people make mistakes, and mistake-proof through automation. Automate every process you can as soon as early as possible. Automate testing, builds, installations, anything that is routine, but be sure to automate in a way that supports people and keeps them thinking about how to do things better.

  3. Refactor: Keep the code base clean and simple, and the minute duplication shows up, refactor the code, the tests, and the documentation to minimize complexity.

Eliminate Waste

  1. Provide market and technical leadership: Assure that there is clear responsibility for developing a deep understanding of what customers value and a closely associated deep understanding of what the technology can deliver. Be sure the team builds the right thing.

  2. Create nothing but value: Assure that all steps in all processes are focused on value-creating activities or improved capability to deliver value in so far as this is possible. Measure process cycle efficiency and keep on improving it.

  3. Write less code: Aggressively limit the features in a system to only those that are absolutely necessary to add value. Develop an organizational intolerance for complexity.




Implementing Lean Software Development. From Concept to Cash
Implementing Lean Software Development: From Concept to Cash
ISBN: 0321437381
EAN: 2147483647
Year: 2006
Pages: 89

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net