TruePlanning Software Model

The TruePlanning® Software Model from Price Systems Inc. is a proprietary parametric model that estimates the scope, cost, effort and schedule for software projects. Parametric estimating models are mathematical models containing cost estimating relationships (CERs) developed through data collection and regression analysis. The TruePlanning Software model provides activity based parametric models to aid in the estimation of new software development, integrations of Commercial off the Shelf Software (COTS) and life cycle maintenance costs.

Historical Evolution

The TruePlanning software model is the next generation of the Software estimating model (PRICE S). PRICE S was the first software estimating model introduced by RCA in the late 70’s. Its introduction was followed several years later by the introduction of the University of Southern California’s Constructive Cost Model (Cocomo). Other models such as QSM’s Slim and Galorath’s SEER-SEM followed.

The introduction of PRICE S and other parametric cost estimating models occurred at a time when the people most concerned with software costs were the military and their contractors. Because of this fact, the original database for PRICE S contained mostly aerospace and defense data. As software has become so much more prevalent in so many walks of life, it became necessary to extend the breadth and depth of the CERs and capabilities of PRICE S to address both commercial and aerospace and defense software challenges. The TruePlanning Software model is an extension of PRICE S and has been developed using a wide range of data from project domains such as aerospace and defense, banking, financial services, insurance, and many others.

Software Effort Estimation

Effort is estimated using for each of the activities that occur during the typical software development process. The basic effort equation for each activity is:

Effort = Size * Baseline Productivity * Productivity Adjustments

Where:
Size is a quantification of the amount of software that is being built in units such as Source Lines of Code (SLOC), Function Points, Use Case Points, etc.
Baseline Productivity represents the typical productivity that the ‘average’ organization realizes for this activity
Productivity Adjustment is a quantification of how the project being described is different from the ‘average’ organization represented by the baseline productivity.

It is the productivity adjustment factor that contains the rich relationships developed through study of many software projects. Many parameters influence productivity adjustment. A few of the more prominent factors are listed below with graphics that represent the results of research of productivity studies.

Size:
Size is the quantification of functionality that is being development or integrated. There is a linear component to size in a software cost estimate but there is also a non-linear relationship with respect to the impact of overall project productivity as the size increases. Under most circumstances the more software being developed the higher the cost per line of code or function point.

Functional Complexity:
Functional Complexity gives breadth and depth to the size. There are some types of software that are cheaper and easier to develop than other types of software. Software that flies airplanes is more complex and harder to design, develop and test than software that performs routine mathematical calculations. Functional Complexity quantifies this inherent complexity and impacts productivity as shown below.

Technology:
Technology decisions have significant impact of the productivity of a software development project. Research indicates that for a particular implementation tool (programming language, development environment, etc) productivity impacts over time begin slowly as the technology is embraced by a few early adaptors, then increase significantly as it becomes commonly accepted and finally taper off as newer technologies begin to replace it.

Other factors which impact software project productivity in this equation include amount of reuse, amount of code generated with computer aided tools, an organization’s productivity information, development team experience and capability, security and reliability requirements.

Schedule Estimation and Schedule Cost Effect

The amount of time it takes to complete a software project depends on the size of the software project and the factors that influence project productivity. It makes sense that the very same factors that drive effort drive schedule although there is another important consideration. Most software projects have constrained schedules which are rarely the same schedules that statistical analysis of project size and productivity parameters produce. The fact that a software project is attempting to perform outside of the bounds of an optimal schedule tends to influence the cost and effort of the project in predictable and unpredictable ways. Cost and effort increase as additional people are added to make up for schedule compression. These costs are non-linear as additional people create additional effort for others on the team as they require training and management as well as creating additional communication challenges.

The following represents the relationship between effort and duration

Duration = prodFact * SizeFact * Effort^0.35

Where
Effort = Effort calculation discussed above
prodFact = schedule Productivity Adjustment Factor
sizeFact = size scale factor

The TruePlanning Software model contains a submodel that compares this optimal schedule to user schedule constraints and adjusts the effort and cost accordingly. This models the non-linear nature of the relationships between schedule constraint and effort.

Software Sizing

Size is a significant factor in estimating the cost, effort and schedule for any software development project. Estimating software size for a software project is problematic, particularly in the early stages of a project when the requirements are still being ironed out. The size measure measures the amount of functionality that is to be delivered with the software project. Software size can be measured in Source Lines of Code (SLOC - need link here), IFPUG Function Points (link here to FP page), Object Points or Use Case Points. Size measures are included for New functionality, adapted functionality, reused functionality (with no changes), functionality which is automatically generated or translated. The amount of reuse and modification then drive the productivity with which the project is executed.

See Also
http://en. .org/wiki/Software_estimation
http://en. .org/wiki/Software_parametric_models
http://en. .org/wiki/Parametric_models

Related Readings
Six Steps to a Successful COTS Implementation

Main Menu