Background, previous
co-operation related to the project
One of the key questions in software development is software
size estimation. Software size is a primitive measure from
which other important values are calculated (e.g. effort,
productivity and duration). These values are particularly
interesting for project managers at the beginning of a project.
In practice, an intuitive approach is often used, not a methodological
one. The results are often unsatisfactory. The efficiency
of the intuitive estimates can be indirectly measured via
software project success factors, especially time and budget
overruns.
For systematic software size estimation, different methods
are used, all of which have their roots in the Function Point
Analysis (FPA) method. Albrecht introduced this method in
1979. Since then it became the most important method for software
size estimation. The method introduced a specific way of representing
a software system and distinguished between data functions
and transactional functions. The method was intended for all
domains, although in practice, its accuracy is different within
different domains. A more detailed empirical analysis of the
method revealed some weaknesses, which include:
Correlation between elements of the FPA method.
The unsuitability of the Value Adjusment Factor (VAF) and
General System Characteristic (GSC).
The violation of the monotony axiom.
From a practical standpoint, it can be concluded that the
FPA method application is more difficult with object-oriented
projects. The elements and constructs of the FPA method are
not directly applicable to object-oriented concepts. Therefore,
a mapping of object-oriented concepts into the FPA elements
is needed. The mapping is not defined within the FPA method
itself and is consequently not uniform. Different authors
have proposed different mapping functions, mostly in the form
of additional rules. Information is gathered from different
diagrams (e.g. Use Case diagrams, class diagrams, sequence
diagrams) which are considered separately. More detailed research
has shown that the weight factors of the standard FPA method
have to be calibrated for use in object-oriented projects.
Consequently, several FPA-like methods were developed that
map object concepts into metrics similar to function points.
Sneed proposed Object Points and Minkiewicz developed Predictive
Object Points. The results are therefore incomparable to those
calculated within the original FPA method. Additional adjustment
factors are needed that have to be proven statistically.
Project managers need to estimate the effort needed for a
project’s completion and a project’s duration. Most methods
are applicable during the late analysis phase or the beginning
of design, which has little true value for project management
activities.
Most of the current methods for software size estimation
have the same roots (the FPA method), but lack the formal
model needed for method comparison. In the past, a few attempts
were made to establish such a formal model, however none
have become predominant in practice.
We had preparatory discussions with the Slovenian partner
at Microsoft Academic Days for Central and Eastern Europe,
November 16th-19th in Prague.
Reasons of co-operation (with special regard to
the complimentary character of the research groups)
Main objectives are related to the definition and development
of strategies, approaches and tools to support:
Identification of minimum set of metrics needed to establish
valuable metrics program for a given project.
The UML models definition, required in each development
phase to be able to estimate software size in desired accuracy.
Definition of correlation factors between function points
and source-code metrics for .NET environment.
The framework for tool implementation that support data
collection and size estimation for .NET environment using
UML models in Visio.
Existing complementary work of both research groups presents
solid ground for joint efforts in function points and metrics
for .NET environment - see references.
Objectives of the project and planned utilisation
of the results
The focus of this project would be a practical application
of metrics suitable for object, component and aspect -oriented
development in specifics target environment namely Microsoft
.NET. The concrete environment is needed to build a bridge
between two metrics groups - source code metrics on one
side and high level project metrics on the other side. Within
the project a subgroup of source code metrics that has a
greatest impact and higher correlation coefficient with
high level metrics for estimating project size will be defined
collected and tested to formally prove their importance.
In a more general sense the project will define a framework
for software metrics plan that can be used within software
companies and further applied on .NET environment. The framework
itself will focus on specific metrics used within software
projects to estimate project size. However the results and
the framework itself are expected to be applicable to other
metrics families as well. For the practical part of the
project conceptual definition of architecture will be established
that will enable the end user to easily compose a tool for
metrics gathering and analysis in .NET environment. The
analysis will be founded on UML models composed in Visio.
The UML models will then be used to calculate project size
in function points. The correctness of results will be statistically
proven using actual hours; further on the correlation between
function points and selected source-code metrics for .NET
environment will be investigated.
Expected advantages of the co-operation for Hungary,
as well as for the partner country
Common result is the possibility of development practical
tools which are easy-to-use, controllable and customizable
and applicable in software development based on function-point
and source-code metrics. Beside the Hungarian partner widen
its knowledge on function-point mappings and project estimations.
Similar result is expected for the Slovenian partner in the
field of source-code metrics.
Assignments for both the Hungarian and the foreign
institutions
Based on the previous research directions investigations
in function-point metrics and development of theoretical
framework of the whole project will be controlled by the
Slovenian partner,. Development, testing and evaluation
of source-code metrics are planned as the role of the Hungarian
partner.
Time schedule (monitoring points)
The project will have two main
phases:
Phase I.
1. Comparison of existing mappings from UML diagrams into
FPA method elements for .NET environment
Existing mappings from different authors will be compared,
common principles and deviations identified.
2. Definition of the meta-model for describing FSM methods
and selection of the most suitable method for .NET environment
Existing FSM methods are different in many ways. The element
names, calculation function and procedure are different.
Therefore, a comparison of different methods is difficult.
The purpose of this step is defining the meta-model and
the corresponding mathematical model. With a comparison
of procedures, greater accuracy of estimates and quality
of mapping functions will be possible. According to the
results the most suitable FSM method for the target environment
will be selected.
3. Integration and update mapping of object concepts into
FPA method elements using UML 2.0 standard
A detailed comparison of mappings is expected to show their
advantages and disadvantages in practical use. With the
integration of different procedures and the definition of
additional rules, we will develop an original approach for
the software size estimation of object-based systems.
Phase 2.
4. Development of components for counting automation
Since mapping defined during this research will be based
on formal models, it is expected that the automation of
counting steps for .NET environment will be possible. The
component will map software systems expressed with UML diagrams
composed in the Visio tool into size in function points.
The counting procedure will be partial or fully automated
according to the level of system abstraction. It is expected
that automation will lower the subjectivity error and consequently
improve accuracy.
5. Integration with the source code metrics
It is important that the method defines the source-code
metrics data necessary for results comparison and achievement
of desired accuracy level in later projects. The latter
depends on the quality of the input data and selected subset
of metrics. Therefore, the source-code metrics collection
should be fully automated and correlation between function
points and each selected method clarified.
6. Solution evaluation
The proposed solution will be evaluated and statistically
tested on actual .NET projects.