As a systems analyst, you will probably be called on to produce a number of estimates for your project. Indeed, you may be solely responsible for producing these estimates in some cases; in other cases, your project manager may ask you to develop estimates for his or her use.
What kind of things need to be estimated in a systems development project? This will vary from project to project, but typically the major things that need to be estimated are:
- People resources. How many programmers, systems analysts, database designers, telecommunications experts, user representatives, and other categories of people will be required for the project?
- Schedule. How long will the project take? How much time can be expected for each of the typical phases of the project (e.g., systems analysis, design, programming, testing, etc.)?
- Staff scheduling. In addition to knowing how many people the project will require, we need to know when they will be required. If the project requires ten programmers, will all ten be needed at the same time?
- Budget. How much money will it cost to develop the system? The major cost is likely to be the salaries paid to the development staff, and this can usually be computed directly once the staffing and staff scheduling is known. But, of course, there are other costs associated with a project; these are detailed in Appendix C.
Keep in mind that you will generally have to make these estimates more than once. A set of estimates will generally be made in the early stages of a project (e.g., during the feasibility study), but they may need to be made many times, as users and management explore the ramifications of different trade-offs. One obvious example of this is the trade-off between time and functionality (e.g., the project manager might say to the user, “I’m pretty sure we can deliver the system to you by January 1st if you leave out functions X, Y, and Z.”); another example is the trade-off between time and people (e.g., the user might say to the project manager, “If you had three more programmers, would you be able to get the system done in time?”). It may take several iterations before the project team, management, and the user community have reached an acceptable compromise.<ref>Keep in mind also that the estimates will almost certainly have to be revised during the project as circumstances change. External factors (business conditions, new competitors, mergers, etc.) may cause the user to change his or her mind about required functionality, budget expenditures, or required delivery date. And internal factors (staff turnover, unexpected difficulty of implementation, etc.) may also cause budgets and schedules to change, usually dramatically.</ref>
We have a great deal of common experience in the area of estimating; just think of all the situations typified by the question, “How long do you think it will take to drive to your grandmother’s house?” And we are all intuitively familiar with the concept of an optimistic estimate and a pessimistic estimate. But estimating a systems development project is somewhat different, because (1) the scope of work is much larger and more complex, and (2) the consequences of an estimating error are usually much more severe than that of being half an hour late to your grandmother’s house.<ref>Some grandmothers may violently disagree with this assumption!</ref> There are a number of common problems that you should be aware of before you begin calculating estimated budgets, schedules, and resource requirements:
- The difference between estimating and negotiating
- The wide variation in technician skills
- The danger of estimating your own work
- The lack of an estimating database
- Management’s insistence on premature, detailed estimates
- An industry-wide difficulty of measuring the unit of work
- Estimates based on assumptions of unpaid overtime
Depending on your seniority in your project, and your clout with management and users, you may be able to prevent some of these problems from becoming serious. But even if you are a junior systems analyst on the project, you should be aware of the estimating problems, for they can ultimately determine the success or failure of your project.
All of these problems -- which do lead to faulty estimates in many projects -- underscore the need for formally establishing a “triage” approach when the requirements for the project are identified. Even if the initial estimate is reasonably accurate, problems may be encountered in the middle of the project that will make it difficult to implement all of the requirements by the time the deadline arrives. But more commonly, the estimate turns out to have been inaccurate from the very beginning; thus, it’s essential that the end-user and the project team understand which features/requirements are essential (sometimes known as “must-do” requirements), which ones are important (i.e., “should do”), and which ones are optional (i.e., “could do”).
We will discuss each of the problems in more detail next.
The Difference Between Estimating and Negotiating
There is often a great deal of negotiation at the beginning of a project (and often throughout the development phase of the project!). This is normal, because the user community often has little understanding of the amount of work involved in a complex information system and will thus “ask for the moon,” that is, an enormous amount of functionality in an absurdly small amount of time, and for little or no money. Meanwhile, the project manager is faced with limited staff and a limited budget; hence, she or he needs to work with the users to help them see what trade-offs are possible.
But this negotiating process, so necessary and so common in systems development projects, must not be confused with estimating. What you must avoid is the conversation between user and systems analyst (or whoever does the estimating) that goes like this:
- User: “So, how long is it going to take you to build the XYZ system?”
- Analyst: “Well, it looks like we’ll have it finished by April 1st.”
- User: “That’s not good enough. We need it by January 1st.”
without a willingness to discuss other trade-offs in functionality or resources.<ref>There is another trade-off, but hardly anyone ever talks about it explicitly: quality. Many project managers try to accomplish miracles by delivering all the required functionality within the user-imposed schedule and with the less-than-optimal resources provided; but the inevitable result is a system that has more bugs and is less maintainable than would otherwise have been the case.</ref> This is sometimes followed by an appeal by the user to the project team’s sense of devotion, duty, and patriotism, which we will discuss as a separate problem in Section B.1.8.<ref>For an excellent discussion of the “negotiating games” that take place in many development projects, see Rob Thomsett, “Double Dummy Spit, and Other Estimating Games,” American Programmer, June 1996.</ref>
In some cases, this situation simply reflects a lack of understanding on the part of the user; it can usually be corrected by a careful explanation of the activities involved in developing a system. In other cases, though, it reflects the user’s overall approach, his business “paradigm,” for dealing with people and organizations that provide him with products and services. To the typical user, you see, the internal data processing organization is not that much different from an external vendor; negotiating, in an attempt to squeeze the price down or cut the schedule back a few months, is a very natural thing to do. And it is a reasonable thing to do (from his point of view) if the person or organization providing that service has a profit margin that can be cut down through skillful negotiation.
Even in the case of an internal data processing organization, negotiating (without accepting any trade-offs in functionality, resources, budget or schedule) may be reasonable if your estimates include a margin for error (otherwise known as a cushion or a contingency factor) that the user thinks is unreasonably large. But if you have provided careful, realistic estimates, and the user negotiates you down to a smaller staff, smaller budget, and tighter schedule, then your project has entered the realm of heavy-duty politics for which the techniques and tools discussed in this book probably won't help much. The time may have come to update your résumé.
Alternatively, if you decide to participate in the project despite having been negotiated into an unrealistic deadline, budget, or resource allocation, you should realize that you are probably going to experience what is commonly known as a “death-march” project. As the name implies, such projects often involve large amounts of overtime, leading to a certain degree of stress and exhaustion. However, there are a number of things that the project manager and team can do to maximize their chances of success in such projects; for more details, see [Yourdon, 1997].
The Wide Variation in Technician Skills
It is common to make estimates of the work to be done based on average talent (i.e., the typical programmer or systems analyst, who can write 15 lines of code, or draw four DFD bubbles, in an average day). It’s important to keep in mind that numerous studies over the past 20 years have documented an order of magnitude difference between talented professionals and mediocre professionals in the field.<ref>One of the first indications of this was a paper entitled “Exploratory Experimental Studies Concerning Online and Offline Programming Performance,” by H. Sackman, W.J. Erickson, and E. E. Grant in the January 1968 issue of Communications of the ACM. Their study showed a 26:1 variation between the best programmers and the worst programmers, all of whom were given the same programming task. This variation between good programmers and bad programmers has been verified several times during the past 30+ years.</ref> If your project has a group of so-called super programmers, you may drastically overestimate the amount of time and money that will be required to finish the project. Of more concern is the fact that a project team of dullards may cause your project to miss its schedule and exceed its budget by a substantial amount.
One major problem in this area is that the actual performance of experienced practitioners does not correlate strongly with most standard programming aptitude tests. Hence, you must base your estimates on each person’s reputation or previous work experience, or you must simply assume that everyone on the project is average. Since most organizations don’t keep careful, detailed records on the productivity of each person in a systems development environment, it will be very difficult for you to obtain documented evidence that you can trust. All you can do is make your best judgment and then modify the estimates, as appropriate, during the course of the project.
The Danger of Estimating Your Own Work
One of the worst mistakes that you can make is to estimate your own work; it is almost as bad to use the estimate of any one single person, since that person’s judgment may be affected by a number of factors.
If you estimate your own work, you are very likely to fall prey to one or more of the following myths:
- “I’m better than most of the other people around here, and I’m sure I can finish the project much sooner.” It’s very common to overestimate one’s ability. When estimating someone else’s ability, you tend to be conservative; when estimating your own, you tend to be optimistic.
- “I know that the boss needs this project done real fast, and I really want to help her out.” In most cases, this is an altruistic feeling; it’s quite natural to want to help your boss succeed. But it can cloud your judgment about the actual amount of time required to get the project finished. In the worst case, optimistic estimates are made in an effort to impress your boss (keep in mind that he’s doing the same thing to his boss, and his boss is doing the same thing to his boss, etc.) so that you can get that next raise or promotion. If you know what you’re doing and are able to accept the risk, fine<ref>God is looking over my shoulder as I write this, and He says, “No, it’s not fine.” Maybe you’re willing to take the risk of not being able to deliver the project with the optimistic schedule and budget that you’re promising, but a failure is likely to jeopardize much more than just your career. It’s unethical, unprofessional, and intellectually dishonest to make unrealistically optimistic estimates when your boss, your users, and your entire organization might suffer a considerable loss by your inability to deliver what you promise.</ref>; but keep in mind that you’re playing with fire.
- “I’m willing to work hard to get this project done on time.” The willingness to work overtime is commendable, but it is dangerous, as suggested earlier. Also, keep in mind that the commitment to put in long hours is often made in a moment of excitement at the beginning of the project; six months later, it may not seem like such a good idea. For more details on the characteristics of such “death-march” projects, and the strategies for surviving them, see [Yourdon, 1997].
- “I’ve worked on systems like this before; this will be a piece of cake.” Well, maybe, if indeed you have worked on a project exactly like this one or very close indeed. However, there is a tendency at the beginning of a project to see superficial similarities with previous projects and to optimistically assume that you’ll be able to do the new project even more quickly. You’re likely to find that the new project is actually rather different, once you get into the details; and you’re likely to forget all those problems you encountered in the last project.
For these reasons, it’s very important that estimates be carried out by someone other than the person responsible for the work. It’s also highly desirable if one does not have an estimating database (discussed in Section B.1.4) or a computerized estimating package (discussed in Section B.4) to obtain estimates from more than one person. At the very least, get estimates from three people; this will give you a best case and worst case estimate, along with an in-between estimate.
The Lack of an Estimating Database
When faced with a new project, one would like to use statistics from a hundred similar projects in order to produce accurate estimates. Some consulting firms and software houses are able to do this: when asked to estimate the time and cost for, say, an order entry system, they can say, “Well, this is almost exactly the same as the last 137 order entry systems we’ve built, so it should take X person-months, Y dollars, and Z people.”
Even within your own organization, it’s possible that there have been 137 order entry systems developed over the past decade or two. But this doesn’t necessarily mean that it will be easy to estimate the budget or schedule for the 138th order entry system; if careful records have not been kept, all you can go on is hearsay and rumor. For a typical data processing organization, which acts as an internal service organization, without having to worry about profit/loss figures or cash flow considerations, there is no real incentive to keep such careful records.
Some large data processing organizations are beginning to change this attitude and have begun developing large, detailed databases that can be used to generate much more accurate estimates for future projects. And some consulting firms specializing in this area have developed databases of literally thousands of projects; these are usually used to provide parameters in the computerized estimating models discussed in Section B.4.
In the meantime, there is a significant likelihood that you will be faced with a one-of-a-kind estimate. You should certainly look for other, similar projects in your organization; but be aware that you may be in a situation analogous to the architect who was asked how long it would take build an underground house in a swamp.
Management’s Insistence on Premature Detailed Estimates
As a general rule, it is almost impossible to produce detailed estimates of costs, time, and resource requirements for a project until a considerable amount of detailed systems analysis and design have been done. After all, how can you tell the user how much a system will cost if you don’t know what the user wants? Nevertheless, there is often great pressure from both users and management to produce an estimate, which is presumed by both of those parties to be an accurate, detailed estimate, at a very early stage in the project. Why? Simply because they need to make a go/no-go decision to invest the time, money, and people required to build the system.
Indeed, in the worst case the schedule and deadline are determined before a project manager has been assigned, before anyone has done any thinking about budgets or personnel allocations, and before anyone has a clue about the detailed requirements for the system. You might well ask: how could a rational organization allow such a thing to occur? The answer is quite simple: external pressures. If the government suddenly announces new tax laws, or new reporting requirements for safety codes or employee pension plans, there is likely to be a deadline associated with those laws and requirements. If a competitor suddenly introduces a hot new product that threatens the success of the organization’s existing products, senior management may decree a deadline for creating a competitive response even before they worry about the other details. In other words, situations like this might not seem reasonable, but they do happen, and for very “real” reasons.
This demand for an early estimate is quite understandable; the only thing that is not realistic is the assumption that an early estimate can be detailed or accurate. It’s more appropriate to give management a series of estimates throughout the project, with each one being progressively more detailed and more accurate. Thus, if the project team is developing a system for an application they are fairly familiar with, they might provide the following series of estimates:
- At the end of the survey or feasibility study: an estimate that may vary by plus or minus 50%. That is, the project team might tell management that the system will take one year and cost $200,000, plus or minus 50%. Management should thus realize the possibility of the project taking 18 months and costing as much as $300,000.
- At the end of the analysis phase: an estimate that may vary by ± 25%.
- At the end of the design phase: a revised estimate that may vary by ± 10%.
- At the end of the programming phase (when testing remains to be done): a final estimate that should not vary by more than ± 5%.
An Industry-Wide Difficulty of Measuring the Unit of Work
Many industries have standard ways of measuring the amount of work to be done in a project. Someone building a house, for example, might measure the work in terms of the number of bricks to be laid or the number of rooms to be built. But in the field of systems development, there is still no agreed-upon way of measuring the unit of work to be done.
The most common method is to measure the number of program statements to be written, otherwise known as lines of code. Thus, on some projects, you will see references to KLOC, which stands for kilo lines of code. But there are many problems with lines of code as a measure of the unit of work:
- Do comments in a computer program count as a line of code?
- Do we count only the code that is delivered to the user, or do we also count code that is written for testing, utility programs, and other support activities during the project? (And on a larger scale, do we count the code associated with canceled projects in an attempt to measure enterprise productivity?)
- What if the programmer has written more than one program statement on a single line of a program listing? And what about the complex statement that takes more than one line?
- Most important, how do we deal with the fact that some programmers will take more lines of code to accomplish the same function than other programmers? As we saw in Section B.1.2, this can represent an order of magnitude variation!
As Capers Jones points out in Applied Software Measurement ([Jones, 1997]) different ways of measuring the unit of work can distort the reported productivity results by two orders of magnitude; perhaps that’s why some programmers can claim to be 10 times or even 100 times more productive than their colleagues! Because of these problems, some organizations are now beginning to use function points as the unit of work; this corresponds roughly to the bottom-level atomic bubbles in a DFD.<ref>The term function point was introduced by A.J. Albrecht to describe this; see “Measuring Application Development Productivity,” Proceedings of the Joint SHARE/GUIDE Application Development Symposium (Chicago: GUIDE International Corp., 1979). Tom DeMarco uses the term function bang in much the same way; see his book, Controlling Software Projects (New York: YOURDON Press, 1982) for more details. Also, see Capers Jones’ Programming Productivity (New York: McGraw-Hill, 1986) for a thorough discussion of the difficulties of measuring productivity, as well as the many factors that affect productivity.</ref>
Estimates Based on Assumptions of Unpaid Overtime
As mentioned earlier, users and project managers may react to scheduling conflicts by suggesting, implicitly or explicitly, that the project team put in extra hours, work on weekends, skip holidays, and postpone vacations. This is usually accompanied with appeals to the loyalty, professionalism, dedication, devotion, pride, honor, and patriotism of the project participants.
I’ll leave it to you to decide whether a willingness to work extra hours is a necessary attribute of patriotism. In some organizations, this may be the case: every project may be organized in such a way that it will only succeed if the project team regularly puts in an 80-hour week. And some projects (e.g., the NASA Apollo project that put the first men on the moon in the late 1960s) may be so exhilarating that everyone will be more than happy to sign up for the extra work required. And it’s not uncommon to find that a project that appeared to be under control falls behind schedule during the last month, requiring a few weeks of late evenings and weekends.
But you have to remember that working is like running: you can sprint at top speed for a hundred yards, but you can’t sprint at top speed for a 26-mile marathon. Similarly, you can work 14-hour days for a few weeks, but it’s unrealistic, in most cases, to assume that you can work 14-hour days for a 3-year project. People with spouses (spice?), children, or other outside interests will simply refuse to continue working such hours after a few months; if necessary, they’ll quit and find another job. Young, single people may be more willing to devote their entire waking lives (as well as their dreams) to the project, especially if they feel it will help advance their career or their knowledge of the profession.
Even if members of the staff are willing to work 14-hour days, there is no guarantee that they will be effective at their work. This is especially true if the overtime work continues for a period of several months: the long evening hours are often unproductive, and one usually finds that more errors are created as people do their work in an exhausted, frazzled state of mind.
There’s a more subtle version of this problem in many organizations: overtime work on the part of professional staff members throughout the organization (not just IT) is allowed, encouraged, and even expected -- but not measured.<ref>The exception to this situation is a consulting firm that charges its clients for all work, on an hourly basis. The IT professionals who work for the consulting firm may not earn any extra pay, but at least the project manager is likely to have an accurate estimate of the number of hours actually required to build the system, and the end-user is likely to have an accurate picture of the real costs of building the system.</ref> The rationale is simple: since professional “knowledge workers” are not paid for such work (at least not in most North American and Western European countries), there is no need to measure it. Indeed, to do so is an embarrassing reminder to management that either (a) they created such poor estimates of the project that they had no alternative but to ask their staff to work long hours, or (b) they deliberately created a “slave labor” environment to cut labor costs. Whether or not one agrees with the ethics of such management practices, it’s still a bad idea not to measure the overtime — for it creates a false impression of the “true” productivity (e.g., lines of code per person-day), schedule, and budget.
There are four important guidelines to keep in mind when you develop estimates for the amount of work to be done in a systems development project:
- Make the estimating units as small as possible.
- Make the units of work as independent as possible.
- Take into account the communication factor.
- Distinguish between new work and borrowed work.
- Be aware of the impact of time-delays and feedback loops between various activities in the project life cycle.
These are discussed next.
Make the Estimating Units as Small as Possible
This should be an obvious suggestion, but it is not followed as often as you might think; it also has some pitfalls, as we shall see. But, in general, it’s much better to estimate the budget and schedule for a one-week unit of work than it is to estimate a “man-millennium.”<ref>A man-millennium is a thousand man-years of work. I use the term “man” deliberately, because I am convinced that women are far too intelligent to get enticed into estimating in such large, machismo units! The term “man-millennium” was originally suggested by one of my company’s clients, a large public utility company in California.</ref> Large projects have large complexities; if you try to estimate the amount of work involved, you are almost certain to make major errors. It makes much more sense to base your estimates on small amounts of work.
This implies, of course, that the overall project has been broken down into small units of work. This will normally happen quite naturally as a result of structured analysis, structured design, and structured programming; unfortunately, as discussed in Section B.1.5, you may be required to provide a detailed estimate of budget and resource requirements before this detailed work-breakdown has taken place. There is no magic solution to this problem; all you can do is try to impress upon your managers and the users that a detailed, accurate estimate requires some initial effort to identify the units of work to be done.
But how small should the units of work be? Some organizations measure work in units of one month; however, this seems too large -- projects can get seriously out of control in the span of one month. It is perhaps more reasonable to measure work in units of one week; as one veteran project manager said to me, “Nothing useful ever gets done in less than a week.” Perhaps the most common unit of work, though, is a day; this fits nicely with the way we organize our work life. A few organizations actually measure their work in units of an hour; while there are indeed many activities that take an hour or less (e.g., defining a single data element in the data dictionary), it seems too microscopic a unit to work with.
Make the Units of Work as Independent as Possible
A problem that has plagued many attempts at estimating is the interaction, or coupling, between one piece of work and another. If a system is divided into pieces with many, many interactions, then the total amount of work to develop the system will be far more than the linear sum of the work for each piece. If a change is made to piece 13, for example, the change may cause problems in piece 14, and a change to 14 could result in changes being made to 15, and so on. This ripple effect has wreaked havoc in many projects.
The solution is to divide the system into small, independent pieces that are only loosely coupled to other pieces. This requires careful work; we discussed it in Chapter 20 as the major rationale for grouping low-level bubbles in the preliminary behavioral model into higher-level aggregates. The notion of modular independence is also important during the design phase of the project; we discussed this in Chapter 22.
Take into Account the Communication Factor
Even in a project where all the modules are independent of one another, people have to talk to one another. If the project is carried out by one individual, then the only communications required are those that take place with the user (and perhaps some discussions with management). But a typical project has many systems analysts, designers, database specialists, and programmers; even worse, some of these people may work in different companies or even speak different languages.
Thus, your estimates will have to include some time for communication between all the project personnel. This communication will take the form of meetings, memos, telephone conversations, and so forth. Keep in mind also that the amount of communication increases sharply as the size of the project team increases: the number of communication paths between team members increases as the factorial of the number of individuals.
Distinguish Between New Work and Borrowed Work
If the project team is lucky, it will be able to make use of work that was done on previous projects; most often, this takes the form of modules in a common software library.<ref>But it may also be possible to reuse portions of a design portions of a model of user requirements, or even portions of a feasibility study. In the past, this was typically not done because the design model, analysis models, and feasibility studies were not well documented and were never maintained. Now, with the proliferation of analyst workstation products of the kind discussed in Appendix A, this is becoming more practical.</ref> However, you should not assume that the reusable modules are free; it will take some amount of work to (1) find them, (2) investigate them to see if they perform the desired function, and (3) learn enough about them to understand how to use them. It’s more appropriate to estimate that the borrowed modules will require some fraction (perhaps 25%, perhaps as low as 10%) of the work that would have been necessary to develop the modules from the beginning.
Be Aware of Time Delays and Feedback Loops
In Chapter 6, we saw several examples of typical “project life cycles” for systems development; they consist of a network of activities, with the output from one activity becoming input to the next. However, there are two common oversimplifications that project teams make when using these life-cycle models as the basis for their estimates:
They assume that the “transition” from activity N to activity N+1 is instantaneous. But in the “real world,” that may not be true; there are often “hidden” delays that prevent activity N+1 from getting started. For example, activity N might produce a set of data flow diagrams and other documents, which must be sent via “snail-mail” to a different group carrying out the design and implementation. If the post office takes a week to deliver the snail-mail, then activity N+1 has been delayed for a week. Or, equally common: the technical team has finished producing the output for activity N, but is not permitted to send it onward until it has been officially “approved” by the manager of the team that carried out the technical work. Unfortunately, the manager is away on vacation for two weeks, so nothing happens until he or she returns -- and, in particular, activity N+1 doesn’t begin.
They assume that work always flows “forward” from activity N to activity N+1 to activity N+2, etc. But sometimes there are feedback loops -- i.e., work flows “backward” from activity N+1 back to activity N because of problems, misunderstandings, or changes in the business environment. For example, when the systems analysis activity is finished, the output (dataflow diagrams, etc.) is sent to the design activity; but if the designers discover analysis-related defects, then they must send the materials back to the analysis group for re-work. Re-work (and thus a feedback loop) is also common when the testing activity discovers bugs that require re-programming effort.
Models that emphasize time-delays and feedback loops are often referred to as systems dynamics models; thus, the ideal “estimating model” would be more complex and sophisticated than a simple mathematical formula. Indeed, system dynamics models of the software development process have been developed, though they are not widely used; for more details, see [Abdel-Hamid and Madnick, 1991].
FORMULAS FOR ESTIMATING
During the past 20 years, the systems development industry has invested an enormous amount of time and effort developing models, or formulas, to help predict the time, resources, and cost of a system. Some of these models are now in widespread use; perhaps the best known model is the COCOMO model developed by Barry Boehm at TRW.<ref>For a detailed discussion of this model see Barry Boehm’s Software Engineering Economics (Englewood Cliffs, N.J.: Prentice-Hall, 1981).</ref> But as Tom DeMarco points out in Controlling Software Projects,
- "There are no transportable cost models. If you wait for someone elsewhere to develop a set of formulas that you can use for cost forecasting in your own shop, you will probably wait forever. Much of our industry concluded, upon realizing this fact, that cost modeling was therefore irrelevant. I think that was the wrong conclusion. If locally developed cost models can be used to improve the precision of the cost-forecasting process, and if the improvement is worth the cost of developing the models, then the concept is viable."
However, it is interesting to see some of the formulas used in other organizations; if nothing else, they will give you a starting point for developing your own formulas. Some of the formulas involve as many as 40 factors or parameters; but, as we will see, some involve only one parameter.
Formulas for Estimating Work Time
Three common formulas for estimating the effort (described in person-months) are based on lines of code. Walston and Felix developed a model at IBM (see [Walston and Felix, 1977]), based on observations of some sixty projects, which is expressed as
- E = 5.2 * L0.91
where E was measured in person-months, and L was measured in thousands of lines of code.
Similarly, Bailey and Basili developed a formula based on 19 projects; it is expressed as
- E = 3.4 + 0.72 * DL1.17 plus or minus 25%
where effort was measured, once again, in person-months, and DL is thousands of lines of delivered code; see [Bailey and Basili, 1983].
Finally, Barry Boehm’s COCOMO model has an effort formula for three different types of system: organic systems, semidetached systems, and embedded systems:
- E = 2.4 * KDSI1.05 (organic systems)
- E = 3.0 * KDSI1.12 (semidetached systems)
- E = 3.6 * KDSI1.20 (embedded systems)
where KDSI represents Òkilo delivered source instructions; see [Boehm, 1981] for details.
Formulas for Estimating Time
Once you have developed an estimate of the amount of work to be done, you might think that it’s easy to estimate the length of time that the project will take. After all, if you have a project estimated at 10 person-months of work, and 5 people are available, then it should take 2 calendar months to finish the project. But what if only 2 people are available? Does the project then take 5 calendar months?
In general, what we are concerned with here is the trade-off between time and people. Many years of painful experience have taught us that the trade-off is not a simple one: doubling the number of people on a project does not necessarily cut the duration of the project in half. Indeed, Fred Brooks, the architect of the original OS/360 operating system, coined the phrase, “Adding more people to a late software project just makes it later.” There are two reasons for this: (1) adding more people increases the required communication between team members, which reduces productivity, and (2) some work in the project is indivisible; it can only be done by one person and adding more people simply won’t help.
While this is a useful concept, it does not tell us specifically how many people a project will need nor how long it will take. This area has also been the subject of research; Barry Boehm found, for example, that the calendar time for a project could be expressed by the following formula:
- T = 2.5 * E0.33
where E is the effort of the project measured in person-months; see [Boehm, 1981] for details.
Studies have also been made of the optimal “manpower loading” for a project; the three best known formulas are based on the work of Norden, Putnam, and Parr; see [Norden, 1963], [Putnam and Fitzsimmons, 1979] and [Parr, 1980]. Norden was the first to find that project staffing follows a curve similar to the one shown in Figure B.1.
The chart is often known as a Rayleigh distribution, based on the mathematical formula for the curve. Putnam provided a formula describing the number of people required on the project as a function of calendar time:
- People(t) = 2K * a * t * exp(-at2 )
where K is the total effort of the project (expressed in people-months), and a is an acceleration factor that establishes the initial slope of the curve. (Note that K represents the total area under the curve.)
An alternative model was developed by Parr [Parr, 1980]; while the overall shape looks similar to Figure B.1, it estimates a higher amount of staffing in the early phases of the project. The Parr model is described by the following formula:
- People(t) = 1/4 sech2 ((at + c)/2)
COMPUTERIZED ESTIMATING MODELS
The idea of using formulas with exponentials and hyperbolic secants is probably not very appealing; you can be sure that most veteran systems analysts have long since forgotten what a hyperbolic secant is and have no idea how to compute an exponential! But it’s not necessary to remember any of the formulas, nor is it necessary to carry out any of the calculations by hand. There are now many computerized project estimating packages available; most run on PCs, and many of them utilize Boehm’s COCOMO model, as well as the Putnam model described above. Some can also incorporate the PERT charts and GANTT charts discussed in Chapter 16. Among the more popular estimating products are CHECKPOINT, from SPR (www.spr.com); SLIM, from Quantitative Systems Management (www.qsm.com); and OnYourMark, from Omni-Vista (www.omni-vista.com).
If you are working on anything other than a trivial system, you should definitely investigate such packages. Not only will they carry out the calculations for you, but they will allow you to play “what-if” simulations to see the effect of adding people to the project or losing people because of sickness or other calamities. In addition, they can help accomplish a more rational form of “negotiation” with the end-user, in order to examine the results of various tradeoffs between schedule, manpower, resources, defects, and risk.
- Tom DeMarco, Controlling Software Projects. Upper Saddle River, NJ: YOURDON Press/Prentice Hall, 1982.
- Barry Boehm, Software Engineering Economics. Englewood Cliffs, N.J.: Prentice-Hall, 1981.
- Workshop on Quantitative Software Models for Reliability, Complexity, and Cost: An Assessment of the State of the Art. IEEE Catalog No. TH0067-9. New York: #Institute of Electrical and Electronics Engineers, 1979.
- Victor Basili, Tutorial on Model and Metrics for Software Management and Engineering. New York: Institute of Electrical and Electronics Engineers, 1980.
- C.E. Walston and C.P. Felix, “A Method of Programming Measurement and Estimation,” IBM Systems Journal, Volume 16, Number 1 (January 1977), pp.54-73.
- J.W. Bailey and V.R. Basili, “A Meta-Model for Software Development and Resource Expenditures,” Proceedings of the 5th International Conference on Software Engineering. New York: Institute of Electrical and Electronic Engineers, 1983.
- P.V. Norden, “Useful Tools for Project Management,” Operations Research in Research and Development. New York: Wiley, 1963.
- Larry Putnam and A. Fitzsimmons, “Estimating Software Costs,” Datamation, September 1979, pp. 89-98; October 1979, pp,171-178; November 1979, pp. 137-140.
- F.N. Parr, “An Alternative to the Rayleigh Curve Model for Software Development Effort,” IEEE Transactions on Software Engineering, Volume SE-6, Number 3 (May 1980), pp. 291-296.
- T. Capers Jones, Applied Software Measurement, 2nd edition, 1997.
- Edward Yourdon, Death March. Upper Saddle River, NJ: YOURDON Press/Prentice Hall, 1997.
- Tarek Abdel-Hamid and Stuart E. Madnick, Software Project Dynamics: An Integrated Approach. Upper Saddle River, NJ: Prentice Hall, 1991.