Software Functional Size Research Articles

Estimating Software Functional Size via Machine Learning

Measuring software functional size via standard Function Points Analysis (FPA) requires the availability of fully specified requirements and specific competencies. Most of the time, the need to measure software functional size occurs well in advance with respect to these ideal conditions, under the lack of complete information or skilled experts. To work around the constraints of the official measurement process, several estimation methods for FPA have been proposed and are commonly used. Among these, the International Function Points User Group (IFPUG) has adopted the “High-level FPA” method (also known as the NESMA method). This method avoids weighting each data and transaction function by using fixed weights instead. Applying High-level FPA, or similar estimation methods, is faster and easier than carrying out the official measurement process but inevitably yields an approximation in the measures. In this article, we contribute to the problem of estimating software functional size measures by using machine learning. To the best of our knowledge, machine learning methods were never applied to the early estimation of software functional size. Our goal is to understand whether machine learning techniques yield estimates of FPA measures that are more accurate than those obtained with High-level FPA or similar methods. An empirical study on a large dataset of functional size predictors was carried out to train and test three of the most popular and robust machine learning methods, namely Random Forests, Support Vector Regression , and Neural Networks. A systematic experimental phase, with cycles of dataset filtering and splitting, parameter tuning, and model training and validation, is presented. The estimation accuracy of the obtained models was then evaluated and compared to that of fixed-weight models (e.g., High-level FPA) and linear regression models, also using a second dataset as the test set. We found that Support Vector Regression yields quite accurate estimation models. However, the obtained level of accuracy does not appear significantly better with respect to High-level FPA or to models built via ordinary least squares regression. Noticeably, fairly good accuracy levels were obtained by models that do not even require discerning among different types of transactions and data.

Generating BPMN diagram from textual requirements

An interesting challenge in software requirements engineering is converting textual requirements to Business Process Model and Notation (BPMN) diagrams. In this study, the BPMN diagram is used as an intermediate representation before measuring the functional software size from Natural Language (NL) input. The methods currently used for converting NL input to BPMN diagrams are not able to generate complete BPMN diagrams, nor can they handle complex and compound-complex sentences in the NL input.This study proposes conversion from textual requirements to a BPMN diagram for improving the weaknesses of existing methods. The proposed method has two stages: 1) analyzing the textual requirements using natural language processing and 2) generating the BPMN diagram. The output of the first stage is fact types as the basis for generating the BPMN diagram in the second phase. The BPMN diagram is generated using a set of informal mapping rules that were created in this study.The proposed method was applied to ten textual requirements of an enterprise application, which involved simple, compound, complex, and compound-complex sentences. The experiments resulted in a suitable BPMN diagram with higher accuracy than obtained by other methods.

Effort estimation of open source Android projects via transaction analysis

AbstractTransactions have been used in many software sizing methods to measure software functional size and provide a basis for effort estimation. To further investigate the effects that transactions have on software functional size and more accurately estimate project effort using the transactional information, in this paper, we propose a method to identify transactions, as well as their complexity attributes that are influential to software functional size, directly from the source code of Android projects using static and dynamic analyses.The identified transactions are classified into different complexity levels and applied with different weights based on their evaluated complexity levels to distinguish their effects on software functional size. A size metric called sum of weighted transactions (SWT) is proposed to measure software functional size. We calibrate an effort estimation model using SWT based on a data set of 34 open source Android projects, and show the effectiveness of using SWT as a software functional size measure to estimate project effort.

Ontology-Oriented Software Effort Estimation System for E-commerce Applications Based on Extreme Programming and Scrum Methodologies

Abstract Presently, software industry is severely suffering from inaccurate effort estimation and inadequate unstructured or semi-structured project history management. In fact, both are difficult to accomplish and hence badly impact the software projects. We proposed improvements in the effort estimation and the project history management of e-commerce projects focusing on Extreme Programing (XP) and Scrum methodologies using ontology models in our software effort estimation system. Proposed system infers suitable estimate in the form of time, resources and lessons learnt as per the project leader’s requirements by using description logic and HermiT reasoner. To validate our approach, we have performed a case study comprising 20 Business-to-Consumer (B2C) web projects and performed comparative analysis on the collected efforts in both XP and Scrum contexts by applying (Mean Magnitude of Relative Error) MMRE and PRED(25) prediction accuracy measures. Likewise, software functional size of understudy e-commerce projects was measured using COSMIC functional size measurement methodology. Regression analysis of relations among actual COSMIC function points, estimated effort, and actual effort spent for the projects show better significance-F and R2 values for our approach. The comparative results show that overall proposed approach provides accurate estimates and significantly improves over planning poker and delphi methods by 10% and 30%, respectively.

Analyzing the performance of two COSMIC approximation sizing techniques at the functional process level

For accurate results, standards for the measurement of the functional size of software require that the functionality to be measured be fully known. However, when estimating in the early phases of software development where there is a lack of detail, approximate sizing techniques must be used. This paper investigates ‘equal size bands’ approximation and fuzzy-logic based approximation techniques using two distinct upper size boundaries and compares performance using a set of 180 functional processes identified from 63 use cases.

Automated COSMIC Function Point measurement using a requirements engineering ontology

ContextThere are two interrelated difficulties in requirements engineering processes. First, free-format modelling practices in requirements engineering activities may lead to low quality artefacts and productivity problems. Second, the COSMIC Function Point Method is not yet widespread in the software industry because applying measurement rules to imprecise and ambiguous textual requirements is difficult and requires additional human measurement effort. This challenge is common to all functional size measurement methods. ObjectiveIn this study, alternative solutions have been investigated to address these two difficulties. Information created during the requirements engineering process is formalized as an ontology that also becomes a convenient model for transforming requirements into COSMIC Function Point Method concepts. MethodA method is proposed to automatically measure the functional size of software by using the designed ontology. The proposed method has been implemented as a software application and verified with real projects conducted within the ICT department of a leading telecommunications provider in Turkey. ResultsWe demonstrated a novel method to measure the functional size of software in COSMIC FP automatically. It is based on a newly developed requirements engineering ontology. Our proposed method has several advantages over other methods explored in previous research. ConclusionManual and automated measurement results are in agreement, and the tool is promising for the company under study and for the industry at large.

Improvements to the Function Point Analysis Method: A Systematic Literature Review

Function point analysis (FPA) is a standardized method to systematically measure the functional size of software. This method is proposed by an international organization and it is currently recommended by governments and organizations as a standard method to be adopted for this type of measurement. This paper presents a compilation of improvements, focused on increasing the accuracy of the FPA method, which have been proposed over the past 13 years. The methodology used was a systematic literature review (SLR), which was conducted with four research questions aligned with the objectives of this study. As a result of the SLR, of the 1600 results returned by the search engines, 454 primary studies were preselected according to the criteria established for the SLR. Among these studies, only 18 specifically referred to accuracy improvements for FPA, which was the goal of this study. The low number of studies that propose FPA improvements might demonstrate the maturity of the method in the current scenario of software metrics. Specifically in terms of found issues, it was found that the step for calculating the functional size exhibited the highest number of problems, indicating the need to revise FPA in order to encompass the possible improvements suggested by the researchers.

A measurement method for sizing the structure of UML sequence diagrams

ContextThe COSMIC functional size measurement method on UML diagrams has been investigated as a means to estimate the software effort early in the software development life cycle. Like other functional size measurement methods, the COSMIC method takes into account the data movements in the UML sequence diagrams for example, but does not consider the data manipulations in the control structure. This paper explores software sizing at a finer level of granularity by taking into account the structural aspect of a sequence diagram in order to quantify its structural size. These functional and structural sizes can then be used as distinct independent variables to improve effort estimation models. ObjectiveThe objective is to design an improved measurement of the size of the UML sequence diagrams by taking into account the data manipulations represented by the structure of the sequence diagram, which will be referred to as their structural size. MethodWhile the design of COSMIC defines the functional size of a functional process at a high level of granularity (i.e. the data movements), the structural size of a sequence diagram is defined at a finer level of granularity: the size of the flow graph of their control structure described through the alt, opt and loop constructs. This new measurement method was designed by following the process recommended in Software Metrics and Software Metrology (Abran, 2010). ResultsThe size of sequence diagrams can now be measured from two perspectives, both functional and structural, and at different levels of granularity with distinct measurement units. ConclusionIt is now feasible to measure the size of functional requirements at two levels of granularity: at an abstract level, the software functional size can be measured in terms of COSMIC Function Point (CFP) units; and at a detailed level, the software structural size can be measured in terms of Control Structure Manipulation (CSM) units. These measures represent complementary aspects of software size and can be used as distinct independent variables to improve effort estimation models.

Functional Size Estimation Technologies for Software Maintenance

Estimating functional software size is the key input for building software models. Unlike direct effort estimates, software size estimation gives a measure of the software product itself and can be used to build objective estimation models for predicting project effort and duration, estimating defects for quality and service cost predictions, and obtaining software development productivity ratios. Although maintenance dominates software projects, the underlying technologies for estimation have been rather poorly described to date. Here, the authors examine estimation technologies based on the COSMIC (Common Software Measurement International Consortium) method as it's applied to maintenance projects.

An experimental study on the conversion between IFPUG and UCP functional size measurement units

The use of functional size measurement (FSM) methods in software development organizations is growing during the years. Also, object oriented (OO) techniques have become quite a standard to design the software and, in particular, Use Cases is one of the most used techniques to specify functional requirements. Main FSM methods do not include specific rules to measure the software functionality from its Use Cases analysis. To deal with this issue some other methods like Kramer’s functional measurement method have been developed. Therefore, one of the main issues for those organizations willing to use OO functional measurement method in order to facilitate the use cases count procedure is how to convert their portfolio functional size from the previously adopted FSM method towards the new method. The objective of this research is to find a statistical relationship for converting the software functional size units measured by the International Function Point Users Group (IFPUG) function point analysis (FPA) method into Kramer-Smith’s use cases points (UCP) method and vice versa. Methodologies for a correct data gathering are proposed and results obtained are analyzed to draw the linear and non-linear equations for this correlation. Finally, a conversion factor and corresponding conversion intervals are given to establish the statistical relationship.

Experimental evaluation of an industrial technique for the approximation of software functional size

The Early & Quick sizing techniques, built based on ISO standards, have been proposed to derive an early approximation of software functional size when only high-level and incomplete requirements specifications are available. In the literature, there is a lack of research to evaluate the performance of such approximation sizing methods. This paper presents an experimental study to evaluate their reproducibility and accuracy. The experimental results show both poor reproducibility and large inaccurate approximations. In particular, the analysis of the findings indicates that the practitioners could not classify the functional requirements specifications in accordance to their levels of granularity using the rules and the concepts of the Early & Quick COSMIC technique.

Using the ISO 19761 COSMIC Measurement Standard to Reduce “Information Asymmetry” in Software Development Contracts and Enable Greater Competitiveness

In most economic transactions involving software development projects, differences in the amount and quality of information possessed by economic agents (i.e. producers and customers) can lead to significant market inefficiencies. This paper describes the way the information derived from the functional size of software measured using the ISO 19761 COSMIC measurement standard that can help reduce information asymmetry in software development transactions, and lead to increased competitiveness in the software industry.

Generalized model for software functional size measurement

Functional Size Measurement (FSM) methods obtain the functional size of software systems by quantifying the Functional User Requirements (FUR). Since different FSM methods use distinct abstractions to depict a software system,a generalized model was proposed. According to the generalized abstraction of the software system,data groups and transactions involved in the measurement process were generalized at first. And then an example of IFPUG FPA was given in order to interpret the transformation and mapping of Function Point Analysis to the generalized model. Finally,the algorithm description of the measurement process was presented.

An experimental study on the conversion between IFPUG and COSMIC functional size measurement units

The adoption of functional size measurement (FSM) methods in software organizations is growing. In particular, special attention is being paid to the COSMIC method, because of its novelties against 1st generation FSM methods such as IFPUG FPA. One of the main problems facing organizations wanting to use COSMIC is how to properly convert the software functional size of the projects in their portfolio measured by the previously adopted FSM method to the size measured by the new method. The objective of this paper is to find a sound mathematical basis for converting an IFPUG measurement to a COSMIC measurement. In the light of previously published researches, parallel measurements were performed to establish three new datasets (respectively composed by 21, 14 and 35 data points) and verified by an expert measurer, certified on both techniques. In order to obtain a more precise solution, the search for a mathematical relationship has been run using new nonlinear equation types. Results from the analysis confirmed an approximated conversion factor of 1:1, within a range between 0.9 and 1.1, but moving from a larger number of data points analyzed then in past studies. These results can be very useful for those companies starting to use their benchmarking databases populated in IFPUG FP units to projects measured in COSMIC FP.

Horizontal dispersion of software functional size with IFPUG and COSMIC units

Software development companies today are widely using software functional size measurement (FSM) as the main variable to assess the effort and time needed to perform a new software project. In the recent years, this has led to a grown interest in improving the way the measures are taken. In such sense, one of the main aspects that could have impact on measurements and that has not been enough studied is the error introduced by the measurer of the software application, through the subjectivity that can be introduced in the interpretation of the unit application rules. Such error could be evident in a measurement dispersion, defined in this paper in two possible ways: (a) Horizontal Dispersion, where the error could be introduced by the fact that two or more different people counted the same application at the same moment in the project development; and (b) Vertical Dispersion, where the error could be introduced by same measurer that count the same application at different times during the development. Since its definition by Albrecht in 1979 and its subsequent change of name in 1986, IFPUG function points have been the functional software measurement unit mostly applied, despite the definition and standardization of other variants such as NESMA, Mk-II, or more recently FiSMA. However in recent years a new method has been introduced called COSMIC that has been defined as a 2nd-generation FSM method, attracting the interest of the international software measurement community. The aim of this research is to draw some preliminary conclusions from statistical analysis of the software functional size data in which the horizontal dispersion degree could have been introduced in measurements taken into account IFPUG and COSMIC methods.

On the Cognitive Complexity of Software and its Quantification and Formal Measurement

The quantification and measurement of functional complexity of software are a persistent problem in software engineering. Measurement models of software complexities have been studied in two facets in computing and software engineering, where the former is machine-oriented in the small; while the latter is humanoriented in the large. The cognitive complexity of software presented in this paper is a new measurement for cross-platform analysis of complexities, functional sizes, and cognition efforts of software code and specifications in the phases of design, implementation, and maintenance in software engineering. This paper reveals that the cognitive complexity of software is a product of its architectural and operational complexities on the basis of deductive semantics. A set of ten Basic Control Structures (BCS’s) are elicited from software architectural and behavioral modeling and specifications. The cognitive weights of the BCS’s are derived and calibrated via a series of psychological experiments. Based on this work, the cognitive complexity of software systems can be rigorously and accurately measured and analyzed. Comparative case studies demonstrate that the cognitive complexity is highly distinguishable for software functional complexity and size measurement in software engineering.

Improvement of full function point for Web-based applications

Full Function Point (FFP) is a widely and expediently used method of software Functional Size Measurement (FSM), but it can only measure the static aspects of systems and can not take the interactions and behaviors of objects into consideration. On the foundation of measurement elements of COSMIC-FFP and the structure of Web applications, an improved COSMIC-FFP software model was proposed and measurement rules were also supplied especially for Web applications. An example was also given to explain these rules.

On the conversion between IFPUG and COSMIC software functional size units: A theoretical and empirical study

Since 1984 the International Function Point Users Group (IFPUG) has produced and maintained a set of standards and technical documents about a functional size measurement methods, known as IFPUG, based on Albrecht function points. On the other hand, in 1998, the Common Software Measurement International Consortium (COSMIC) proposed an improved measurement method known as full function points (FFP). Both the IFPUG and the COSMIC methods both measure functional size of software, but produce different results. In this paper, we propose a model to convert functional size measures obtained with the IFPUG method to the corresponding COSMIC measures. We also present the validation of the model using 33 software projects measured with both methods. This approach may be beneficial to companies using both methods or migrating to COSMIC such that past data in IFPUG can be considered for future estimates using COSMIC and as a validation procedure.

On the Estimation of the Functional Size of Software from Requirements Specifications

This paper introduces a measurement procedure, called RmFFP, which describes a set of operations for modelling and estimating the size of object-oriented software systems from high-level specifications using the OO-Method Requirement Model. OO-Method is an automatic software production method. The contribution of this work is to systematically define a set of rules that allows estimating the functional size at an early stage of the software production process, in accordance with COSMIC-FFP. To do this, we describe the design, the application, and the analysis of the proposed measurement procedure following the steps of a process model for software measurement. We also report initial results on the evaluation of RmFFP in terms of its reproducibility.

Software quality assurance through COSMIC FFP

Success in software development depends on the satisfaction of the quality requirements stated by the stakeholders. Software architecture ensures development of quality software. Quality measurement at the software architecture level leads to risk mitigation, cost reduction and quality assurance. Existing software architectural measurement techniques are qualitative in nature. However, quantification of quality measures facilitates the process of effective quality assurance. In this paper, we propose a new quantitative measurement technique based on COSMIC Full Function Points (CFFP) and ISO 9126 quality standards. Though CFFP methodology was basically designed to measure the functional size of software at the requirements level, attempt has been made to apply COSMIC FFP principles at the architectural level to measure quality attributes based on ISO 9126 quality standards.