Agile Management for Software Engineering: Applying the Theory of Constraints for Business Results

by David J. Anderson

Book Overview

This text explains how agile software development methods produce better business results. It aims to help managers combat the biggest business complaints about software (for example, late, doesn't... This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0131424602
• ISBN13: 9780131424609
• Release Date: September 2003
• Publisher: Prentice Hall
• Length: 352 Pages
• Weight: 1.60 lbs.
• Dimensions: 0.8" x 6.9" x 9.4"

Customer Reviews

Metrics for agile software development

The text gives a good explantion of agile practices and theory. It looks closely at three agile development methods : Scrum, Extreme Programming (XP), and Feature Driven Development (FDD), with an emphasis on FDD. One of Anderson's key points is although agile software development is an empirical process (eg. dependent upon experimentation and observation), it is not necessarily chaotic. Therefore, it can be planned and predicted. The text also emphasizes in order for agile software development to be adopted in a large corporation, software managers need to provide development metrics that focus on what matters to the CIO -- namely financial and production metrics. The bulk of the text covers how to derive these production and financial metrics for the various agile software development methods. Anderson's proposed metrics are based on throughput accounting and Goldratt's Theory of Constraints. Specifically, he covers how to compute net profit, throughput, and production rates. Thought provoking and highly recommended.

Changing the Point of View

I found this book highly informative and relevant.As an agile advocate, this additional perspective is what I have been looking for. The explanations of the Theory of Constraints has proven valuable to me in my interactions with customers already.

A Management Book that Developers Should Read Too

This book is essential reading for IT managers, but senior developers should read it too. While some things in this book will make engineers say "I know that, but just didn't know how to say it", other things are real eye openers. Engineers will find some of the management theory to be dry reading, but it is relevant.If you ask engineers who have used both traditional (i.e. waterfall) methods and agile methods they will tell you that agile methods are superior, but if you ask them why and how agile methods deliver better results almost none of them will be able to tell you. They know it from experience and intuition, but they do not understand the why and how.Of course, since engineers don't know how and why agile methods work they are at a disadvantage when it comes to convincing management to try them. That's where David Anderson's book comes in. It explains how and why agile methods work in terms that engineers can identify with and that managers understand: increased profit, meaningful accounting, and the ability to repeat successes.Being able to convince your manager to try agile methods is only one benefit. As a team lead or architect if you don't understand what makes agile methods work you may very well end up doing things that defeat their advantages.This book explains why certain things help software development and why others impede it. Why and how should software development teams should identify and exploit constraints? What is Throughput Accounting and why should it be used for software development instead of Cost Acounting? How is software development different from other kinds of engineering and manufacturing businesses? How can the self organizing behavior intrinsic to successful software development efforts be improved?Anderson's book is invaluable to the manager and valuable to the software engineer.

Superlative and profound

Anderson takes agile development, which is a loose-leaf collection of unintegrated practices, and transforms it into a serious discipline with a firm foundation. He accomplishes this by borrowing concepts from manufacturing (like theory of constraints) and applying them to software development. Such a book could only be written by someone thoroughly familiar with both software development and manufacturing; fortunately the author seems quite knowledgeable about both. In all, this book is serious, contentful, and even profound at times. It is by far the best book I've read on the topic in quite a long while.

hard work, but worth it.

This is the hardest - and possibly best - Agile software book I have read so far. It's hard because it digs deeper into the cause and effect at play within agile environments and because it deals with the "bigger" financial aspects of lean. It's a well written, comprensive text.