---
Video Title: Project Estimation Techniques
Description: Project Estimation Techniques
Watch more Videos at https://www.tutorialspoint.com/videotutorials/index.htm
Lecture By: Mr. Arnab Chakraborty, Tutorials Point India Private Limited
---

Project estimation techniques.

So, in this session, we shall discuss how
the project cost estimation can be done.

So, we discuss various parameters
involving project estimation such as size,

effort, time and the cost.

Please watch the previous
video because this

concept is
the continuation of the previous video.

So, project manager can estimate the
listed factors using two broadly

recognized techniques.

So, the first one is the decomposition
technique.

And here, we
are having this technique assume the

software as a product
of various compositions.

And there are two main models we are
having.

One is that line of code.

That is, here the estimation is done on
behalf of the number of lines of code in

the software product, which we usually
measure it in the terms of KLOC.

That is, kilo lines of code.

That means, how many thousand lines of
codes are getting written.

And next one is the functional point.

And here, the estimation
is done on behalf of

number of
functional points in the software product.

That means, how many number of functional
recommends have got implemented.

So, that can give us the set.

So, that can give us also one estimate.

So, that can give us also one estimation
for this project cost.

So, decomposition technique is one of the
techniques.

And the next technique is the empirical
estimation technique.

So, we are having two different broad
categories.

So, the first one was decomposition
technique, which you have discussed,

which is actually having the KLOC of lines
of code.

That will be the estimation measures.

And the one is the number of functional or
function points.

So, that is, how
many number of functions are So, all the

functional features have got implemented
in the soft track.

And the next one is our empirical
estimation technique.

This technique uses empirically derived
formula to make our estimation.

This formula are based on LOC or FPS that
is the functional points.

So, functional points and lines of code.

So, Putnam model.

So, this model is made by Lawrence H.

Putnam, which is based
on Norden's frequency

distribution can
also be known as the Rayleigh's curve.

And Putnam model maps time and effort
required with the softer side.

That is here, we are having this time
estimate.

And here, we are having this effort.

This graph indicates that at the very
initial stage, the

effort will
be very maximum at this particular level.

The effort will be maximum, but along
with the progress with

the time, the effort required meant will
be little bit lesser.

So, this is known as the Rayleigh's curve.

And this curve was actually proposed by
this Putnam.

So, another one is our Kokomo model.

So, constructive cost model.

So, actually, it will be known as Kokomo.

That is a constructive cost model.

Stands for constructive cost model
developed by Barry H.

Wim and it divides the software product
into three broad categories.

So, they are nothing but organic,
semi-detached and embedded.

So, you might be asking me what are they?

Organic, this organic category of software
means those software which will be where

the experienced, experienced developers
will be working, experienced manpower and

personnel will be working on that.

And the software size is not too big and
this particular software will be having a

very limited size, experienced people will
be working for the shorter duration of

time and that is known as the organic
software.

In case of semi-detached software,
in case of semi-detached software,

here the mixer of experienced and
non-experienced personnel will be working.

So, some persons may not be having a
proper experience and domain knowledge.

They are also participating in the
software The software development process.

And here,
this particular site, software site might

be a little bit larger compared to this
organic one.

And as an example, if you consider
development one, compiler, linker,

in those cases, the software can be
considered as semi-detached.

In case of embedded software, in this
case, what will happen?

The software will be very much dependent
on the hardware of the system.

So, that is known as the embedded
software.

So, real-time software, the respective OS
can be treated as this embedded software.

So, we have got the three broad
categories.

One is the organic.

Next one is the semi-detached.

And the last one is the embedded one.

Thanks for watching this video.