Software Effort and Schedule Estimation

Farshad Faghih


Most information for initial cost estimation comes from the feasibility study and requirement analysis. when we estimate costs very early, there is less information upon which to base estimates and, therefore, this information is less detailed and the estimates may be less accurate. Software cost estimation is important for making good management decisions. It is also connected to determining how much effort and time a software project requires. Cost estimation has several uses:

Software cost estimation provides the vital link between the general concepts and techniques of economic analysis and the particular world of software engineering.There is no good way to perform a software cost-benefit analysis, break-even analysis, or make-or-buy analysis without some reasonably accurate method of estimating software costs, and their sensitivity to various product,project, and environmental factors.These methods provide an essential part of the foundation for good software management.Without a reasonably accurate cost-estimation capability, software projects often experience the following problems:

  1. Software project personnel have no firm basis for telling a manager, customer, or salesperson that their proposed budget and schedule are unrealistic. This leads to optimistic overpromising on software development, low-balling on competitive software contract bids, and the inevitable overruns and performance compromises as a consequence.
  2. Software analysts have no firm basis for making realistic hardware-software trade-off analysis during the system design phase. This often leads to a design in which the hardware cost is decreased, at the expense of an even larger increase in the software cost.
  3. Project managers have no firm basis for determining how much time and effort each software phase and activity should take.This leaves managers with no way to tell whether or not the software is proceeding according to plan. That basically means that the software portion of the project is out of control from its beginning.

Estimation Model Development Procedure: 

The interests of the organization are best served when it develops its own estimation model. the models that will be presented provide the organization with an initial starting point, but organization-specific factors must be determined.

To develop an estimation model we have to follow these steps:

  1. Determine a list of potential / most important effort cost drivers.
  2. Determine a scaling model for each effort and cost driver.
  3. Select initial estimation model.
  4. Measure and estimate projects and compare.
  5. Evaluate quality of estimation as part of project post-mortem.
  6. Update and validate model at appropriate intervals.

Cost Drivers:

When determining the cost of a project, there are cost drivers which must be taken into consideration. Cost drivers are those variables which influence the actual dollar amount spent on any given project. The cost drivers can vary from project to project. In addition, cost drivers can be influenced by the model employed to estimate the cost. One of the major Cost Drivers in many estimation models is the size of the software product. The size of the software product:

Size Estimation:

Function Points is one method that has been developed from empirical evidence. Many projects were examined with respect to their different characteristics and the size of the final products examined, and finally a model produced to fit the data.

Function Points method work best with business type information processing applications, since those are the projects that were examined to produce the model. It is also not as widely known, used, or trusted for estimating SIZE as COCOMO is for estimating EFFORT.

5 items determine the ultimate complexity of an application.Take the weighted sum of these counts to get the number of function points ( FP ) in a system.

Characteristic Weight
Number of Inputs 4
Number of Outputs 5
Number of Inquiries 4
Number of Files 10
Number of Interfaces 7

Once the number of function points ( FP ) is calculated ( from requirements ), other data is used to estimate module / system SIZE. For various languages, data was obtained on how many lines of code are usually needed to implement one function point.


Suppose that Ada program needs 70 LOC per FP. A system with, 10 inputs, 10 outputs, 5 Inquiries, 4 Files and and 2 Interfaces would have an FP equal to:

FP= ( 10 * 4 ) + ( 10 * 5 ) + ( 5 * 4 ) + ( 4 * 10 ) + ( 2 * 7 ) = 164

And the estimated Size would be equal to:

Size = FP * 70 = 164 * 70 = 11480 LOC

Software Cost Modeling Accuracy:

Software cost and effort estimation will never be an exact science. Too many parameters such as technical, environmental, personal or political can affect the ultimate cost of software and the effort required to develop it. It is important to recognize that we can't estimate the cost of producing 100,000 source instructions of software as accurately as we can estimate the cost of producing 100,000 transistor radios. There are many reasons for this; some of the main ones are:

Today, a software cost estimation model is doing well if it can estimate software development costs within 20% of the actual costs, 70% of the time, within the class of projects to which it is calibrated.Currently the Intermediate and Detailed COCOMO models do approximately this well ( within 20% of the actual costs, 68 to 70% of the time) over a fairly wide range of applications.


Estimation Models:

Estimating models have been generated by measuring certain properties and characteristics ( duration, cost, team size, disk usage, etc...) of past successful projects.Curves are then fit to the data points to get descriptive equations which are the models. We hope these equations can be used for prediction. The fact that they came from measurements of past projects is what gives the hope.

Small Projects:

Measurements of small to moderate projects resulted in a model of the following form:

EFFORT = a * SIZE + b

Here, the magnitude of the effort is a linear function of the size of the project ( Number of Lines of Code, usually ). This model holds up until a certain point, usually for projects that can be reasonably accomplished by small teams of two or three people. By increasing the size of the project, the above model becomes less and less accurate an the need for a new model increases.

Large Projects:

Projects requiring teams of more than three or so people tend to behave in the following way:


Here, the size of the project is scaled exponentially, therefore as a product increases in size, the effort to produce the product grows more than linearly ( for b >= 1 ). It means that if we try to develop a larger product, our productivity ( SIZE / EFFORT ) Decreases. This decrease in productivity on larger projects is called a diseconomy of scale. The main reasons why larger software products incur diseconomies of scale are the following:

  1. Relatively more product design is required to develop the thorough unit-level specifications required to support the parallel activity of a larger number of programmers.

  2. Relatively more effort is required to verify and validate the larger requirements and design specifications.

  3. Even with a thoroughly defined specification, programmers on a large project will spend relatively more time communicating and resolving interface issues.

  4. Relatively more integration activity is required to put the units together.

  5. In general, relatively more extensive testing is required to verify and validate the software product.

  6. Relatively more effort will be required to manage the project.

Like many other cost estimating models, the COCOMO model use the same equation for estimating the software development effort.

The COCOMO Model ( Barry Boehm 1981):

The COnstructive COst MOdel ( COCOMO) is an example of regression models used for estimating software cost and effort. These methods use a basic formula with parameters that are determined via a historical database and current project characteristics.

The COCOMO Model is the most widely used and accepted of the cost / effort estimation models.This model as a size-driven model is highly dependent upon the the manager's ability to estimate the size of the software system at an early stage. This method is generally used in conjunction with one of the size estimation models such as function points.

The COCOMO exists in a hierarchy of increasingly detailed and accurate forms. The top level model, Basic COCOMO is applicable to the large majority of software projects: small to medium products developed in a familiar in-house software development environment.

Basic COCOMO is good for quick, early, rough order of magnitude estimates of software costs, but its accuracy is necessarily limited because of its lack of factors to account for difference in hardware constraints, personnel quality and experience, use of modern tools and techniques, and other project attributes known to have a significant influence on software costs.Intermediate COCOMO include these factors in terms of their aggregate impact on overall project costs.Detailed COCOMO accounts for the influence of these additional factors on individual project phases.

The Basic COCOMO Model:

The Basic Model makes its estimates of required effort ( measured in Staff-Months SM ) based primarily on your estimate of the software project's size ( as measured in thousands of Delivered Source Instructions KDSI ):

SM = a * ( KDSI )b

The Basic model also presents an equation for estimating the development schedule ( Time of Develop TDEV ) of the project in months:

TDEV= c * ( SM )d

Before we can put these equations to much practical use, we need to resolve a number of significant definitional issues, such as:

Definitions and Assumptions:

Below are some additional definitions and assumptions underlying the use of COCOMO.

  1. The primary cost driver is the number of delivered source instructions ( DSI ) developed by the project. DSI is defined such that:

    • Only source lines that are DELIVERED as part of the product are included.Therefore test drivers and other support software are excluded.

    • SOURCE codes, created by project staff and processed into machine code by some combination of pre-processors, compilers, and assemblers. Code created by applications generators is excluded.

    • INSTRUCTIONS are defined as lines of code or card images. Declarations are counted as instructions but Comments are excluded.

  2. The COCOMO cost estimates only cover the period between beginning of the design phase and end of the integration and test phase. Costs and schedules of other phases ( like requirement phase) are estimated separately.

  3. A COCOMO Staff-Month ( SM ) consists of 152 hours of working time. This has to be found to be consistent with practical experience with the average monthly time due to holidays, vacation and sick leaves. COCOMO avoids estimating labour costs in dollars because of the large variations between organizations in what is included in labour costs and because SM is a more stable unit than dollars. After estimating the effort in SM we convert it into dollar estimate by applying different average dollar per Staff-Month figure for each major phase, to account for inflation and the difference in salary level of the people required for each phase.For example, the senior staff (with high salary )are heavily involved in the requirement and early design phases while junior staff ( less salary ) are more involved in later phases ( detailed design, code and test phases) Therefore the average SM is higher for early phases.

  4. COCOMO estimates assume that the project will enjoy good management by both the developer and the customer.

  5. COCOMO assumes that the requirement specification is not substantially changed after the plans and requirement phase.Any significant modification should be covered by a revised cost estimate.

  6. The detailed COCOMO model assumes that the influence of the software cost drivers is phase dependent. Basic COCOMO and Intermediate COCOMO do not, except for distinguishing between development and maintenance.


The Development Mode:

There are several modes of software development .These different software development modes have cost-estimating relationships which are similar in form, but which yield significantly different cost estimates for software products of the same size.In the COCOMO Model, one of the most important factors contributing to a project's duration and cost is the Development mode. Every project is considered to be developed in one of three modes:

 To estimate the effort and development time, COCOMO use the same equations but with different coefficients ( a, b, c, d in the effort and schedule equations ) for each development mode. Therefore before using the COCOMO model we must be able to recognise the development mode of our project.

  1. Organic Mode:

    In the organic mode the project is developed in a familiar, stable environment and the product is similar to previously developed products. The product is relatively small, and require little innovation. Most people connected with the project have extensive experience in working with related systems within the organization and therefore can usefully contribute to the project in its early stages, without generating a great deal of project communication overhead. An organic mode project is relatively relaxed about the way the software meets its requirements and interface specifications. If a situation arises where an exact correspondence of the software product to the original requirements would cause an extensive rework, the project team can generally negotiate a modification of the specifications that can be developed more easily.

    The Basic COCOMO Effort and schedule equations for organic mode software projects are:

    SM = 2.4 * ( KDSI )1.05

    TDEV= 2.50 * ( SM )0.38

  2. Semidetached Mode:

    In this mode project's characteristics are intermediate between Organic and Embedded. "Intermediate" may mean either of two things:

    1. An intermediate level of project characteristics.

    2. A mixture of the organic and embedded mode characteristics.

    Therefore in an Semidetached mode project, it is possible that:

    • The team members all have an intermediate level of experience with related systems.

    • The team has a wide mixture of experienced and inexperienced people.

    • The team members have experience related to some aspects of the system under development, but not others.

    The size of a Semidetached mode product generally extends up to 300 KDSI.

    The Basic COCOMO Effort and schedule equations for organic mode software projects are:

    SM = 3.0 * ( KDSI )1.12

    TDEV= 2.50 * ( SM )0.35

      Embedded Mode:

In this development mode Project is characterized by tight , inflexible constraints and interface requirements. The product must operate within a strongly coupled complex of hardware, software, regulations, and operational procedures. The embedded-mode project does not generally have the option of negotiating easier software changes and fixes by modifying the requirements and interface specifications.The project therefore need more effort to accommodate changes and fixes. The embedded mode project is generally charting its way through unknown territory to a greater extent than the organic mode project. This lead the project to use a much smaller team of analyst in the early stages, as a large number of people would get swamped in communication overhead.

Once the embedded mode project has completed its product design, its best strategy is to bring on a very large team of programmers to perform detailed design, coding and unit testing in parallel.Otherwise the project would take much longer to complete. This strategy as we will see leads to the higher peaks in the personnel curves of embedded-mode projects, and to the greater amount of effort consumed compared to an organic mode project working to the same total development schedule.

The Basic COCOMO Effort and schedule equations for organic mode software projects are:

SM = 3.6 * ( KDSI )1.20

TDEV= 2.50 * ( SM )0.32


A large chemical products company, is planning to develop a new computer program to keep track of raw materials. It will be developed by an in-house team of programmers and analysts who have been developing similar programs for several years. An initial study has determined that the size of the program will be roughly 32,000 delivered source instructions.

This project is a good example of an organic-mode software project. Using the Basic COCOMO equations for this development mode we have:

Effort :

SM = 2.4*(32)1.05 = 91 Staff-Months


32000DSI / 91 SM = 352 DSI / SM

Duration and Staffing:

Once an estimate is obtained for effort ( Staff-Month ), A manager must determine how many persons to put on the job. This will ultimately determine the calendar duration of the project. It is very important to note that more staff does not mean proportionately less calendar time. More staff complicate communications and this complexity translates into a project slowdown. The second equation of the COCOMO model use the estimated effort of the project ( SM ) to suggest the optimum calendar duration of the project. For the example above with estimated effort of 91 SM we have:


TDEM = 2.5 * ( 91 )0.38 = 14 months

After estimating the duration of the project the manager can easily determine how many persons in the average must be put on the project:

Average Staffing:

91 staff-months / 14 months = 6.5 FSP ( Full Time Equivalent Software Personnel )

Phase Distribution of Effort and Schedule for Organic Mode:

After estimating the effort an schedule of a project we need to determine how to distribute them among different phases of the project.This distribution varies as a function of the size of the product.Larger software projects require relatively more time and effort to perform integration and test activities, and are able to compress the programming portion of the program by having larger number of peoples programming components in parallel. Smaller software projects have a more uniform, flat distribution of labour throughout the development cycle, and have relatively more resources devoted to the phases other than integration and test.Table 1 and Table 2 present the percentage distribution of the basic software effort and schedule within the development phases of an organic mode product:


Table 1 - Phase Distribution of Effort: Organic Mode

Phase Small ( 2 KDSI) Intermediate(8 KDSI) Medium( 32 KDSI ) Large( 128 KDSI )
Plans & Requirements 6% 6% 6% 6%
Product Design 16 16 16 16
Detailed Design 26 25 24 23
Code & Unit Test 42 40 38 36
Integration & Test 16 19 22 25
Total: 100 100 100 100


Table 2 - Phase Distribution of Schedule: Oraganic Mode

Phase Small ( 2 KDSI) Intermediate(8 KDSI) Medium( 32 KDSI ) Large( 128 KDSI )
Plans & Requirements 10% 11% 12% 13%
Product Design 19 19 19 19
Detailed Design &

Code & Unit Test

63 59 55 51
Integration & Test 18 22 26 30
Total: 100 100 100 100



Using table 1 and table 2 we can calculate the number of staff needed for programming ( Detailed Design & Code and Unit Test ) phase of the previous example:

Programming Effort :

( 0.62 ) ( 91 SM )= 56 Staff-Months

Programming Schedule:

( 0.55 ) ( 14 )= 7.7 months

Average Staffing:

56 staff-months / 7.7 months = 7.3 FSP ( Full Time Equivalent Software Personnel )


The Basic Labour Distribution:

Using tables 1 and 2, we can calculate the distribution of the effort and schedule among different phases of an organic mode software product. Then by using the same method as the above example we can calculate the number of the personnel required for each phase. Figure 1 shows the basic labour distribution for projects developed in organic mode and with different sizes ( Small, Medium, Large ). The vertical axis shows the ratio of the number of the staff in each phase to the average personnel level for whole project. The horizontal axis shows the percent of the scheduled time which has completed.

Figure 1 - Basic Labour Distribution for Softwares Developed in Organic Mode










The shape of the labour curve for larger products have a somewhat higher peak of parallel effort in the programming phase than do the smaller projects.

The COCOMO average labour level estimates for each software development phase yield the straight line, step function labour distribution shown in Fig. 1. Actually, the level of full-time equivalent software personnel active on a project tends more to follow a continuous curve, particularly on large projects, where the instantaneous full-time commitment of a large number of people is an unlikely event. Examples of such curves are also shown in Fig. 1.

Rayleigh distribution if properly used yields good approximations to the actual labour curves on many types of software projects.In terms of COCOMO variables we can write the Rayleigh distribution in the following form:

FSP= SM ( t / tD2) exp( - t / tD2)

Variable t represents the month for which the FSP ( Full-Time Equivalent Software Personnel ) is being calculated, and the quantity tD represents the month at which the project achieves its peak effort. In modeling the full development cycle ( from t=0 to TDEV ) in the basic COCOMO model, we use the central portion of the Rayleigh Distribution between 0.3tD and 1.7tD . therefore we arrive at the labour estimating equation:

FSP= SM ( ( 0.15 TDEV + 0.7 t ) / 0.25( TDEV )2 ) exp( - ( 0.15 TDEV + 0.7 t )2 / 0.5( TDEV )2 )

This equation can be used as a reasonably effective means for estimating the personnel level at any given point of an organic-mode software development project.

Phase Distribution of Effort and Schedule for Other Modes:

Table 3 and Table 4 present the percentage distribution of the basic software effort and schedule within the development phases of an semidetached mode product:


Table 3 - Phase Distribution of Effort: Semidetached Mode

Phase Small ( 2 KDSI) Intermediate(8 KDSI) Medium( 32 KDSI ) Large( 128 KDSI )
Plans & Requirements 7% 7% 7% 7%
Product Design 17 17 17 17
Detailed Design 27 26 25 24
Code & Unit Test 37 35 33 31
Integration & Test 19 22 25 28
Total: 100 100 100 100


Table 4 - Phase Distribution of Schedule: Semidetached Mode

Phase Small ( 2 KDSI) Intermediate(8 KDSI) Medium( 32 KDSI ) Large( 128 KDSI )
Plans & Requirements 16% 18% 20% 22%
Product Design 24 25 26 27
Detailed Design &

Code & Unit Test

56 52 48 44
Integration & Test 20 23 26 29
Total: 100 100 100 100

Table 5 and Table 6 present the percentage distribution of the basic software effort and schedule within the development phases of an embedded mode product:

Table 3 - Phase Distribution of Effort: Embedded Mode

Phase Small ( 2 KDSI) Intermediate(8 KDSI) Medium( 32 KDSI ) Large( 128 KDSI )
Plans & Requirements 8% 8% 8% 8%
Product Design 18 18 18 18
Detailed Design 28 27 26 25
Code & Unit Test 32 30 28 26
Integration & Test 22 25 28 31
Total: 100 100 100 100


Table 4 - Phase Distribution of Schedule: Embedded Mode

Phase Small ( 2 KDSI) Intermediate(8 KDSI) Medium( 32 KDSI ) Large( 128 KDSI )
Plans & Requirements 24% 28% 32% 36%
Product Design 30 32 34 36
Detailed Design &

Code & Unit Test

48 44 40 36
Integration & Test 22 24 26 28
Total: 100 100 100 100


By comparing tables 1 through 6 we can see some differences between the effort and schedule distribution of the products developed in different modes. The main differences are:

  1. The embedded-mode project consumes considerably more effort in the integration and test phase. This results from the need to follow and verify software requirements and interface specifications more carefully in the embedded and semidetached mode.

  2. The embedded-mode project consumes proportionally less effort in the code and unit test phase. This results from the proportionally higher effort required for the other development phases.

  3. The embedded-mode project consumes considerably more schedule in both the plans and requirement phase and the product design phase. This is because of the project's need for more thorough, validated requirements and design specifications, and the greater need to perform these phases with a relatively small number of people.

  4. The embedded-mode project consumes considerably less schedule in the programming phase. This results from the strategy of employing a great many people programming in parallel, in order to reduce the project's overall schedule.

Manpower Distribution Curves and the Rayleigh Distribution:

The Basic COCOMO estimated personnel distribution curves for the medium-size organic, semidetached and embedded mode projects are shown in Fig. 2 , normalized with respect to the average personnel level for each project. The relatively slower, low level start and higher peak personnel requirement of the embedded mode is clearly evident in this figure. These characteristics are even more pronounced for very large embedded-mode projects.This figure also shows the normalized Rayleigh curve :

FSP= 13,300( t / 60 2) exp(- t 2 / 2(60)2)

Whose peak effort occurs at the 60% point in the development schedule. Again Rayleigh curve is a reasonably good fit for portions of the manpower distribution with the main exception of its zero-level behaviour at the start of the project.

Figure 2 - Basic Labour Distribution for Medium-Size Softwares Developed in Different Modes












Thus for practical use, we would have to tailor a portion of a Rayleigh curve to a particular mode and a particular portion of the development cycle.In general, it is easier and more realistic to develop a project labour plan from the average personnel per phase information given by the COCOMO model, plus as much as information as you can obtain about the future availability of people to support the project and their needs for advance training, combined with your knowledge of the project's strategy for incremental development

Intermediate COCOMO Model: 

 The Intermediate COCOMO is an extension of the basic COCOMO model. Here we use the same basic equation for the model. But coefficients are slightly different for the effort equation.Also in addition to the size as the basic cost driver we use 15 more predictor variables. these added cost drivers help to estimate effort and cost with more accuracy. An estimator looks closely at many factors of a project such as amount of external storage required, execution speed constraints, experience of the programmers on the team, experience with the implementation language, use of software tools, etc., for each characteristic, the estimator decide where on the scale of "very low" , " low", " Nominal", "High", "Very High" and "High" the project falls. Each characteristic gives an adjustment factor( from the table 7 ) and all factors are multiplied together to to give an Effort Adjustment Factor ( EAF).If a project is judged normal in some characteristic the adjustment factor will be 1 for that characteristic ( Nominal column in Table 7 ), which means that that factor has no effect on overall EAF. The effort equation for the intermediate model has the form of:

SM = EAF * a * ( KDSI )b

If we assume that the project is "Nominal" in every aspect then all adjustment factors would be 1, which results in EAF=1, and the effort equation would have the same form as the Basic mode.

in addition to the EAF the model parameter "a" is slightly different in Intermediate COCOMO, but the "b" parameter is the same.The effort equation for different modes of Intermediate COCOMO is given in the following table:

Development Mode Intermediate Effort Equation
Organic: SM = EAF * 3.2 * ( KDSI )1.05
SemiDetached SM = EAF * 3.0* ( KDSI )1.12
Embedded SM = EAF * 2.8* ( KDSI )1.20


Bohem in Software Engineering Economics defines each of the cost drivers, and defines the Effort Multiplier associated with each rating ( Table 7 ).

Table 7 - Project Characteristic Table

Cost Driver Very Low Low Nominal High Very High Extra High
ACAP Analyst Capability 1.46 1.19 1.00 0.86 0.71 --
AEXP Application Experience 1.29 1.13 1.00 0.91 0.82 --
CPLX Product Complexity 0.70 0.85 1.00 1.15 1.30 1.65
DATA Database Size -- 0.94 1.00 1.08 1.16 --
LEXP Language Experience 1.14 1.07 1.00 0.95 -- --
MODP Modem Programming Practices 1.24 1.10 1.00 0.91 0.82 --
PCAP Programmer Capability 1.42 1.17 1.00 0.86 0.70 --
RELY Required Software Reliability 0.75 0.88 1.00 1.15 1.40 --
SCED Required Development Schedule 1.23 1.08 1.00 1.04 1.10 --
STOR Main Storage Constraint -- -- 1.00 1.06 1.21 1.56
TIME Execution Time Constraint -- -- 1.00 1.11 1.30 1.66
TOOL Use of Software Tools 1.24 1.10 1.00 0.91 0.83 --
TURN Computer Turnaround Time -- 0.87 1.00 1.07 1.15 --
VEXP Virtual Machine Experience 1.21 1.10 1.00 0.90 -- --
VIRT Virtual Machine Volatility -- 0.87 1.00 1.15 1.30 --


If your project is rated Very High for Complexity (Effort Multiplier of 1.30), and Low for Tools Use (Effort Multiplier of 1.10), and all of the other cost drivers are rated to be Nominal, these Effort Multipliers are used to calculate the Effort Adjustment Factor, which is used in the effort equation:

EAF = 1.30 * 1.10 = 1.43

Effort = EAF * 3.2 * 31.05 = 14.5 SM

TDEV = 2.5 * 14.50.38 = 6.9 Months

Average staffing:

14.5 / 6.9 = 2.1 people

There are two reasons why Intermediate model produces better results than the Basic Model. First, It considers the effect of more cost drivers. Second, in the Intermediate mode the system can be divided into "components". DSI value and Cost Drivers can be chosen for individual components, instead of for the system as a whole.COCOMO can estimate the staffing, cost, and duration of each of the components--allowing you to experiment with different development strategies, to find the plan that best suits your needs and resources.

The Detailed COCOMO Model: 

The detailed model differs from the Intermediate model in only one major aspect: the Detailed model uses different Effort Multipliers for each phase of a project. These phase dependent Effort Multipliers yield better estimates than the Intermediate model. the six phases COCOMO defines are:


Abbreviation Phase
RQ Requirements
PD Product Design
DD Detailed Design
CT Code & Unit Test
IT Integrate & Test
MN Maintenance

The phases from Product Design through Integrate & Test are called the Development phases. Estimates for the Requirements phase and for the Maintenance phase are performed in a different way than estimates for the four Development phases.

The Programmer Capability cost driver is a good example of a phase dependent cost driver. The Very High rating for the Programmer Capability Cost Driver corresponds to an Effort Multiplier of 1.00 (no influence) for the Product Design phase of a project, but an Effort Multiplier of 0.65 is used for the Detailed Design phase. These ratings indicate that good programmers can save time and money on the later phases of the project, but they don't have an impact on the Product Design phase because they aren't involved.

Using COCOMO with PSP:

COCOMO is a tool for helping the manager to estimate the effort and schedule of a team project. As we saw in this review historical data shows that the relation between size and effort in a large team project with more than two or three person is not a simple linear relation:

EFFORT = a * SIZE + b

Actually these type of projects have a diseconomy of scale which means that the larger the size of the program, the lower is the productivity of the team. The model obtained from historical data has the form of:


In which b is greater than 1. Therefore the method we used in PSP to estimate the effort ( regression method ) can not extend to team projects and we need more complicated models. As we saw the main reason is the overhead required to break the work between staff, need to communication and interface between the group and the effort needed to test and reintegrate the parts again together, In addition a team project needs much more management efforts. In a personal process after estimating the effort, all we need to do is to look at the task and schedule table and estimate the time when the work will finish. Our estimation of the schedule of the project and its finishing time is directly related to how much time we can allocate to that project.If we need to finish it earlier we can change our schedule table by assigning more time to this project. But in a team project the situation is not that simple. If you for example estimated the effort to be 100 Staff-Month it doesn't mean that by putting 100 person on this project you can finish it in 1 month. It is very important to note that more staff does not mean proportionately less calendar time. More staff complicate communications and this complexity translates into a project slowdown. By putting extra staff , the effort will increase for example from 100 SM to 200 SM and the work will finish in 2 months instead of 1 month. Therefore we have to optimize the number of staff. Actually COCOMO model itself gives the schedule and finishing time for the project ( Schedule Equation in COCOMO Model ). As we saw in this review by using COCOMO model we can estimate the distribution of effort and scheduled time among different phases and by dividing effort by scheduled time for each phase we can estimate the optimum number of staff required.

Therefore we can not extend our Personal Software Process ( At least Up to the process 1.1 ) directly to a team project to estimate the effort and schedule required in a team project. But we can look at the problem from another point of view. As we saw during the course, the PSP can improve the quality of the work of each team member individually. As we saw during this review, the communication and need to interface among team members need a lot of extra effort and time. As a simple example if a team member could not finish his work at the estimated time probably other team members have to wait for him. In a software team each individual's contribution is uniquely important. The performance of a software system can be damaged by almost any defective part.By using PSP every individual can improve his own work Each team member can produce a higher quality product with less defects which can reduce the effort required to reintegrate and test the whole product. In addition the PSP can improve the planning accuracy of each team member. By making more accurate and realistic plans the performance of each team member become more predictable.The PSP gives each individual the required basis to check the status of his work This can be done by defining milestones and checking the actual time with planned time for each step. Therefore each team member can realize in earlier stages if he is behind the schedule. Therefore by putting more effort or asking help he can finish his work at the time required by other team members. The PSP can make the interface between team members much easier.As we saw COCOMO use three different development modes for projects (Organic, Semidetached, Embedded ) and one of the factors that determines to which group a project belong is the quality of work of each individual and his capability in interface to others.PSP can improve this factors and therefore reduce the effort required to finish a job. Managing a team, when the work of each individual is predictable is much easier and the estimations for the whole work effort and schedule can be much more accurate. Therefore using the PSP by the team members can increase the productivity of the team and make the results obtained from COCOMO more accurate.


Main Reference: Software Engineering Economics, Barry Boehm, Prentice Hall, 1981