Mark Needham

Thoughts on Software Development

The Mythical Man Month: Book Review

with 4 comments

The Book

The Mythical Man Month by Fred Brooks Junior

The Review

Pretty much since I started working at ThoughtWorks 2 1/2 years ago I’ve been told that this is a book I have to read and I’ve finally got around to doing so.

Maybe it’s not that surprising but my overriding thought about the book is that just about every mistake that we make in software development today is covered in this book!

What did I learn?

  • The title of the book and the second chapter of the book refers to the situation that surely everyone who has ever worked on a software development project is aware of – if a project is late then adding new people onto it will make it even later. This is due to the fact that a big part of software development is communication and adding people makes that communication more complicated than it previously was, therefore meaning it takes longer to get things done. My colleague Francisco has a nice post describing the ways that adding people can slow down a development team. The idea that a baby can’t be produced any quicker by having 9 women rather than just one is a particularly common metaphor used to explain this.
  • Incompleteness and inconsistencies of ideas only becomes clear during implementation – pretty much putting a dagger into the idea that we can define everything up front and then code it just like that. This is certainly the area that the agile and lean approaches look to change and certainly the earlier we can try out different ideas by using approaches such as set based concurrent engineering the more quickly we can end up with a useful solution.
  • An interesting idea about creating a surgical team ,with a few very experienced people doing the majority of the coding and being assisted by other members of the team, is suggested as being a successful route to delivering software. It sounds quite different to the teams that I have worked on where everyone on the team is involved although the objectives behind it seem valid – reducing the communication points and ensuring the conceptual integrity of the solution. Uncle Bob recently wrote about this describing these teams as master craftsman teams but it sounds as if this would require quite a radical shift in the recruiting strategies of organisations. Dave Hoover also has an interesting post on this subject but he takes the angle of building apprentices on teams like this.
  • This seems closely linked to another idea about team composition described later on in the book which speaks of the need for a team to have a technical director and a producer – the technical director sounds to be quite similar to Toyota’s idea of the Chief Engineer and they would be technically in charge while the producer (Iteration Manager?) is in charge of everything else. The underlying idea here is that we don’t just have one person in charge of a team, there are two distinct and important roles.
  • Brooks says the most important aspect of the design of a system is to ensure its conceptual integrity i.e. a consistent set of design ideas. In order to achieve this Brooks suggests the need for a system architect – while I agree with this idea I think it is more a role and maybe one that can be done by the Tech Lead on a project. The Poppendieck’s also talk of the need for conceptual integrity in Lean Software Development. The point here is to create a system which is easy to use both in terms of function to conceptual complexity. I am reminded of a Dan North quote at this stage: “We’re done not when there’s nothing more to add, but when there’s nothing more to take away”
  • The productivity increases gained by using high level languages are mentioned – the underlying idea being that using these allow us to avoid an entire level of exposure to error. I think this makes sense and as an example I think the introduction of functional collection parameters into C# 3.0 will lead to a reduction in the amount of time spent debugging loop constructs since we no longer have to use these so frequently.
  • When talking about object oriented programming Brooks speaks of the need to design objects which describe the concepts of the client.

    If we design large grained classes that address concepts our clients are already working with, they can understand and question the design as it grows, and they can cooperation in the design of test cases.

    In other words…Domain Driven Design! Reading this part of the book very much reminded me of Phil Will’s QCon presentation where he spoke of the way that the business and software development teams at the Guardian were able to collaborate to drive the design of the domain model for their new website.

  • The idea of only performing system debugging when each individual component actually works is something which should be obvious but is often not followed. If we know a component doesn’t work on its own then we can guarantee it is not going to work when we try to integrate it with other components so the exercise seems slightly pointless to me. Common sense advice I think!
  • Speaking of code reuse Brooks points out that the key here is the perceived cost of finding a component to reuse that is important – this ties in nicely with an idea from Dan Bergh Johnsson’s QCon presentation

    Your API has 10-30 seconds to direct a programmer to the right spot before they implement it [the functionality] themselves

  • Brooks talks of the need to have documentation for our projects – he uses a project workbook to do this and I think the modern day equivalent would be the project wiki. The idea of creating self documenting programs to help minimise the documentation that needs to be written is also covered. The importance of how we name concepts in our code is especially important in this area.
  • The need to progressively refine the system by growing it rather than building it is suggested later on in the book – the limitations of the waterfall model are described and the approaches of agile/lean are pretty much described – building frequently, getting it working end to end, rapid prototyping and so on.

In Summary

I really enjoyed reading this book and seeing how a lot of the ideas in more modern methodologies were already known about in the 1980s and aren’t in essence new ideas.

I’d certainly recommend this book.

Written by Mark Needham

April 11th, 2009 at 12:33 pm

Posted in Books

Tagged with ,

  • Pingback: Arjan`s World » LINKBLOG for April 11, 2009

  • Pingback: approach ramp Blog » Brooks’s law

  • Pingback: Zen Mind, Beginners Mind: Book Review at Mark Needham

  • http://twitter.com/21tigermike Michael A. Robson

    I actually reviewed this on 21tiger because, though I’m not an engineering, I think there’s alot of brilliance we can borrow from the world of software. They’ve worked out a ton of stuff on creating something, distributing it amongst teams, and working out the bugs, etc.

    Perhaps more interestingly, the software industry has grown and progressed over time (say, going back 30 years) while almost every other creative endeavour has had to change, kicking and screaming.

    Good artists copy, great artists steal. ;)