Wednesday, March 23, 2011

Mythical Man Month Ch 7-9

Mythical Man-Month, The: Essays on Software Engineering, Anniversary Edition
By: Frederick P. Brooks Jr.
Publisher: Addison-Wesley Professional
Pub. Date: August 02, 1995

Chapter 7 : Why Did the Tower of Babel Fail?



Lack of communication. Even though the people who were building the Tower
of Babel had all the time and resources they needed, they failed because of
a lack of communication that led to a lack of organization. Without communication
a large system can't be put together.

Communication can occur:
informally,
in meetings,
or formally through a documentation structure called a "Project Workbook"

Brooks describes the project workbook as a kind of physical data structure
that includes:
Objectives
External Specifications
Interface Specifications
Technical Standards
Internal Specifications
Administrative Memos

Brooks claims that by applying a structure at the beginning of the project, much of the structure and organization in the design of the documentation will carry through to all later documentation since, "Technical prose is almost immortal."
The project workbook also controls how information is conveyed to the whole team.

Brooks recommends numbering an ordering all memos and setting up a hierarchical tree structure for all the documentation.
He then recommends that the documentation should be updated very frequently and to highlight all changes with a dedicated edit margin at the side of all documents. He then recommends the distribution of change logs. By doing these things Brooks claims that the documentation should scale up effectively.

Brooks admits that this can cost a lot of time, energy, and material so he mentions something called a "microfiche," but doesn't really explain what it is.

Brooks then addresses how to set up the project workbook electronically and recommends a similar highlighting of revision updates an storing files in a LIFO structure.

Brooks then talks about organizing for large projects and brings up the problem of how communication takes place in those structures. He proposes that division of labor and specialization of functions in a tree like authority structure are good tools for tackling this problem.

An organizational subtree should have:
1) A mission
2) A producer
3) A Technical Director or Architect
4) A Schedule
5) A Division of Labor
6) Interface Definitions Among the Parts

He then dives into the structures that can be found in the technical director (that conceives design, identifies subparts, and provides conceptual integrity) and the producer (that assembles the team, divides the work, and establishes the schedule).

Combinations are:
Producer = tech director
Brooks claims this is rare in occurrence and rarely workable.

Producer > tech director
It's hard to establish the director's authority to make technical decisions in ways that don't detract from his time.

Tech Director > Producer
Brooks provides a section of Robert Heinlein's Book: "The Man Who Sold the Moon"
Brooks thinks this is best for small teams.

Chapter 8 : Calling the Shot

In this chapter, Brooks talks about estimations of productivity and discuses why they always fall short.
He first observes that linear extrapolation of estimates are inaccurate and that the number of man-hours needed for increased number of instructions increases exponentially at a 1:1.5 rate.

The reason for the mis-estimations in Portman's data is that they didn't account for things outside of strictly programming and design like machine downtime, meetings, and paperwork.


Aron's Data from IBM support Portman's data.

Harr's Data from AT&T Bell labs indicate that difficulty of the implementation factors into time either in the form of the number of modules, complexity of the implementation of the number of men assigned to it.

The OS/360 data confirms Harr's data showing that compilers are generally more difficult than batch applications, and that OS's are even harder than those.

Corbato's data shows that high level programming languages can increase the productivity on a project by up to 5 times and that the number of errors are constant to the number of statements.

Chapter 9 : Ten Pounds in a Five-Pound Sack

Brooks enters into this chapter to discuss how to get the most value out of program for the space that it occupies in memory.

Brooks says that size itself is not bad, but unnecessary space usage should be avoided.

Brooks recommends that total size targets as well as resident-space budgets and that the designer should specify what a module must do when considering size for all parts of the system. Speed considerations have to be taken along with the amount of space available for certain resources. Having a fast memory access disk does not imply that all the sections of the program can abuse the space. (Similar to the tragedy of the Commons)

When considering space, granularity of tools and functions that can be added should also be considered so that many individual tools are not added unnecessarily and that each part should come together to a meaningful whole.

Space-time tradeoff should also be considered and Brooks observes that with more space, generally, more speed is gained.

To be aware of the kind of tradeoff considerations that exist, programmers should be trained for the particular technology they're working with and that good programming techniques are observed.

Finally, Brooks proposes that the Essence of Programming is representation and that most gains in technology and advances in the field are done be reconsidering the representation of the data rather than getting bogged down in the specifics of the code.

Discussion :

While this set of chapter was slightly drier than his previous ones, his basic observation on organization and communication are well founded. Again, his writing shows signs of its age when he talks about things like feet deep stacks of paper based documentation but one also has to consider the unending stacks of documentation that can be generated electronically and how we can best organize, communicate, and update large teams despite huge amounts of data. His ideas on highlighting changes and having the documents constantly available are quite sounds.

I can't say I got too much from his discussion of the technical director and the producer and it's probably because I haven't been exposed to the business organization side of software development but the idea of leading the technical man lead rings true to me.

His comparison of data on productivity is nothing new, we all know that time to implement drastically increases with number of people and complexity of implementation. I'm definitely glad we're not programming in Machine Code very much anymore.

His discussion on space time considerations are almost completely outdated. Memory is both cheap and widely available so working so hard to put value into small amounts of space isn't all that important. His last observation on chapter nine about programming being about representation was noteworthy. Often times, I feel like programmers are in too much of a hurry getting something of work to really think about design and representation that will best achieve the goal implementation to the point that we tend to implement bad solutions that could be so much more.

No comments:

Post a Comment