Customer Reviews

Software by Numbers: Low-Risk, High-Return Development

5 star:		(7)
4 star:		(5)
3 star:		(2)
2 star:		(1)
1 star:		(0)

 

 

"Software by Numbers" is yet another book I would like any manager involved in my working life to read and re-read.

The authors describe an Incremental Funding Method (IFM) for scheduling incremental development of software which optimizes the Return on Investment (ROI) by having the requirements engineered into Minimum Marketable Features (MMF) with concrete, monetary value.

The book is very light (less than 200 pages) but packed with interesting material. I read most of the book during a flight from Finland to Germany and finished the book on my way home. Despite the minimal page count, the authors manage to explain why their method is desperately needed and how it fits to existing software processes such as RUP and XP. They also describe the business case for incremental architecture and different strategies for sequencing MMFs and Architectural Elements (AE) for maximum ROI over the project's lifetime.

The only downside I found for this book is that I would've needed some more baby-steps support for the actual calculations (sequence-adjusted net present values etc.). I'm sure others will be hoping to see some more real world examples of feature deconstruction and sequencing as well. On the other hand, I really appreciate the fact that the authors made the effort of putting up a spreadsheet online for supporting their method.

Overall, an excellent book. Highly recommended.

This book hopefully is the atomic bomb that will destroy the remaining methodologies that insist on treating software development like a manufacturing process.

Software development is not manufacturing, nor is it construction, nor is it "just" engineering. It is precisely "development", as in product development. It is a mix of economics, science, art, engineering, and craft. It is "knowledge work", and therefore cannot be optimized by critical path analysis, scientific management techniques, or formal method compliance.

The above, however, is no excuse for a lack financial discipline and rigor in the business case. Most modern approaches have no concept of finances and costs, nor do they apply cost/benefits analysis to the ordering of features. This was to be the responsibility of the "customer", but sadly, they're as human as the developers, and are only familiar with the old tried-and-true WBS time/cost projections. Negotiated-scope contracts are only a partial solution to this problem. Many executives want to get an understanding of their discounted cash flow projections vs. "total spend" over an arbitrary period. They need to ensure they are achieving an appropriate return for the capital commitment.

This book's incremental funding method enables you to budget, sequence, risk-adjust, and NPV-optimize every marketable user story or bundle of use cases over a set period. It will enable you to ROI-justify your software architecture and evolve it instead of sinking costs into it up-front. It will show to non-technical executives the true benefits of agile development: faster time-to-revenue, projects that rapidly self-fund, quicker break-even points, and smaller up-front investments.

In short, this book is an indispensible means to sell the breakthrough productivity of agile methods.

I picked up this book based on the recommendation of a collegue,and found the information invaluable. I work in a product-based IT organization, and these concepts are very helpful for mature product release planning and budgeting, which was a missing element at my company. I am not sure about the comments from the previous reviewer saying the book is based on a flawed premise that "you know the costs and time frame for development to a high degree of accuracy for every available option." It is explicitly stated in the book several times that estimation, not perfection, is the key and perfect-world scenarios don't exist. The authors even say that due to potential and probable changes in cost and time estimation, market conditions, etc. that one should revisit MMF sequencing at the start of each period anyway. Also, the website of the book, http://www.softwarebynumbers.org, explains about accurate projections in the FAQ section. Overall, a very useful tool!

For the past five years I have been a consultant, helping companies analyze the link between the products they buy and the financial impact those products make on their businesses. During that time I've poured over numerous books on the subject of ROI and tried to make sense of them in the context of real world environments. Most books fail to make a contribution to real world problems because they are typically too academic, unrealistic or they are too vague.

However, I'm very impressed with this book.

This book clearly outlines an excellent, flexible methodology for real world technology resource management that MAXIMIZES BUSINESS IMPACT. It's different from other approaches I've seen in the past. I can tell from the authors' examples and analysis that there is a real synthesis between disciplined academic approach and real life project management. Even after five years of study, there were a lot of new ideas that I hadn't seen elsewhere.

I think this book applies to a wide audience within IT development. CIOs can gain a lot of ground from reading this book and instilling this approach across their organization. Technology managers who have come up the ranks from being smart technicians MUST read this book to take the leap from coder to business manager. Business analysts ought to read this book to optimize their tradeoff of features and functions versus resources.

I think that if my clients embraced the approach in this book, they'd see a lot of cash crunch problems disappear. I recommend it to all of them.

The core theory of the book is that feature/stories need to be prioritized based on business value. To anyone doing Agile (Scrum, XP, FDD) this is pretty much standard stuff.

What is new in the book is that they provide a framework for tying individual features to future cash flow/benefit for that feature to drive an analysis of net present value.

My viewpoint is that this book is very academic in orientation rather than grounded in the real world examples. As an example, there is no detailed example/sample/case study of how future cash flows were determined for a given set of features. The derivation of these values is critical to the applicability of the approach.

Do I buy it? No. I think XP User stories prioritized by the customer(s) will be a much more robust mechanism for selecting what to work on next. It will also come at a lower cost.

In Software by Numbers: Low-Risk, High-Return Development, authors Mark Denne and Jane Cleland-Huang define an Incremental Funding Methodology (IFM). Building on the major post-waterfall methodologies - Agile and RUP - which call for development based on iterations, Denne and Cleland-Huang urge looking at those iterations as Minimum Marketable Features (MMFs) - which a colleague refers to as "the memes of software development". Based on the notion that software is never complete, IFM offers unique opportunity for product managers and developers to collaborate to find the earliest sequence of MMFs for returns that match the project's optimal goals. The authors walk through how to calculate ROI, NPV (net present value) and sequence-adjusted NPV (what's its NPV if you don't start the feature until February) of individual MMFs; and show how to prioritize and order a project based on return so it can become self-funding earliest. I've been managing software development for 15 years, and for much of it looking for ways to better engage the development and business sides with each other to raise the level of teamwork. IFM offers new opportunity to do so. Putting dollar values on individual features gives product managers the means to add value to feature ordering -- to provide real world input into a process often done by developers alone, optimizing the sequencing of features they develop based solely on gut feel. If they score - if they get the optimum sequencing right - they've enabled earliest delivery of both a marketable product and each of the follow-on versions. I might consider, to introduce IFM to a project team, a set of weekly brownbags for product managers and developers alike to work through an understanding, chapter by chapter, of how to optimize their project. Five stars for bringing new (and very useful!) thinking to the methodology discussion.
-- Ron Lichty

This book was a surprise but only because I didn't read the title properly.
"Software by Numbers : Low-Risk High-Return Development".
Fundamentally, it is about project planning and prioritisation and not about estimation.

This book starts with three assumptions:-
1. You are using a feature-driven development iterative release approach to a project.
2. You can attach numeric business value to each of the features.
3. You can estimate the cost of developing the required software modules to implement the above features.

With these assumptions in place, the authors then use a number of net present value accounting algorithms to help you schedule the software module development to provide "Low-Risk High-Return development".
The algorithms are designed to maximise business return and minimise the risk as per the book's title.

It is only 190-pages, well-laid out with clear examples pitched at the right level for me so I swallowed in a week-end with only faint and distant grumbling from my wife.

I will be trying it out on my next green-field project and interested to see how assumptions 2 and 3 stand up to the test.

Highly Recommended.

This book draws from a number of existing, proven practices and combines them into a synergistic approach in which the whole exceeds the sum of the parts. The focus of this book is iterative development, so if you are in an environment that employs the waterfall development life cycle the some of the material will not be as useful. As a side note - the waterfall SDLC is anything but dead, unfortunately. First, the parts - there are two main ideas set forth in the book:

(1) Viewing software as a collection of minimum marketable features (MMFs), which requires a radical shift in thinking. This is especially true because most of us have been trained to approach software from a function points or source lines of code (or from the viewpoint of the constructive cost model). The MMF view is ideal for determining the value of software to an organization as a business proposition, whereas FPs, SLOCs and other methods are for estimating development effort. Adding MMF means you have a new dimension to consider when making the go/no-go decision to proceed with a development project, making it an ideal factor during discovery and inception, and for governance purposes.

(2) Incrementally funding development--called "Incremental Funding Method" or "IFM" for short--which is similar to the progress payments concept in earned value project management. In essence IFM ties funding to delivery, which is ideally suited to iterative development. There are safeguards incorporated into this approach, such as a requirement for accurate cost forecasts, which have obvious dependencies on schedule and resources. However, since IFM is tied to net present value, this is where true value to be achieved from the software viewed as MMFs is determined. Since iterative development a fluid approach and accurate forecasts cannot be made beyond a single iteration the authors have devised an innovative solution to the problem by using sequence-adjusted net present value, which ties NPV to MMF and adjusts them through each iteration.

The whole - this book treats software development as value creation, and provides a workable solution to establishing and managing the value of software to business throughout the development life cycle. If the book ended here it would only be theory. What the authors did to make this book essential reading and to add credibility to their approach is provide two case studies--one for the RUP development approach and one for those in the agile camp--as well as a wealth of other information in the later chapters that show how to effectively deal with intangibles and decision making. What is remarkable is this is done in less than 200 pages. This book is an important work and should be read by IT executive management, project managers and software engineering managers.

Software by Numbers focuses on the financial aspects of software development. It introduces a method called "Incremental Funding Method" which demonstrates how software development with incremental delivery can fund itself, therefore lowering investment costs and thus lowering the risks for starting the development. The key-idea in the method is probably to break up the feature sets of a software product in MMFs (minimum marketable features) and calculate the investment and ROI of these separately and then deciding in what order they could be developed to maximize the total ROI.

The ideas of software by numbers are important to understand when selecting a development method that enables incremental delivery (like most agile development methods). Its especially good in convincing people who do not know software development that incremental delivery is a very good idea and financially sound idea.

To me this book was definitively worth reading. However, at some points the book seemed to lose my attention. At points I felt the authors were just repeating the same points over and over again. Eventhough the book is not very thick, I felt it could have been even thinner and conveying the same message.

Still, it's a recommended read.

I read this book because Tom and Mary Poppendieck recommended it to me at XP Day 3 (Their book on Lean Software Development is a must read.). It is an important book because it places Return on Investment (ROI) at the heart of IT prioritisation and decision making. If your company is not doing this, then it will have lots of trouble with its IT projects. The book explains ROI and Net Present Value (NPV) and then presents a heuristic for delivering the optimal deliver of ROI. The heuristic depends on having groups of functionality with associated revenues (These groups are called Minimum Marketable Functions or MMFs). The book then presents a methodology for delivering optimal ROI that works with RUP or Agile. I'm tempted to try out the heuristic although I suspect that most decent project managers could work out the optimal delivery without the use of the heuristic (one of the approaches they suggest.).

The big question that the book leaves me with is "Where do the revenue figures come from?" The book gives an unsatisfactory single sentence answer along the lines that they are produced by marketing and the business.

Overall I liked the book, it is well written and easy to read. My one contention is that the RUP chapters comes before the one on Agile. ;-)