Function Point Analysis Research Articles

Software cost estimation tool: A App based application, estimate the cost of software project

This paper presents the design and implementation of a software cost estimation tool integrated into a mobile application developed using Flutter. The tool incorporates various techniques for software cost estimation, including expert judgment, function point analysis, 3D point analysis, and the COCOMO model. The purpose of the program is to give software engineers and project managers a practical and effective tool for calculating the time and money needed for software development projects. The paper provides a thorough explanation of each estimation technique’s implementation, along with a discussion of the app’s main features and functionalities. Because of the app’s intuitive and user-friendly design, users can quickly enter project data and get precise cost estimates. The tool’s efficacy is assessed using case studies and contrasts with other software cost estimation methods currently in use. The outcomes show that the app can produce trustworthy and precise cost estimates, which makes it an important resource for software development projects.

Enhancing effort estimation in global software development using a unique combination of Neuro Fuzzy Logic and Deep Learning Neural Networks (NFDLNN)

ABSTRACT Effective project planning and management in the global software development landscape relies on addressing major issues like cost estimation and effort allocation. Timely estimation of software development is a critical focus in software engineering research. With the industry increasingly relying on diverse teams worldwide, accurate estimation becomes vital. Software size serves as a common measure for costs and schedules, but advanced estimation methods consider various variables, such as project purpose, personnel expertise, time and efficiency constraints, and technology requirements. Estimating software costs involve significant financial and strategic commitments, making it crucial to address complexity and versatility related to cost drivers. To achieve enhanced accuracy and convergence, we employ the cuckoo algorithm in our proposed NFDLNN (Neuro Fuzzy Logic and Deep Learning Neural Networks) model. Through extensive validation with industrial project data, using Function Point Analysis as the algorithmic models, our NFA model demonstrates high accuracy in software cost approximation, outperforming existing methods insights of MRE of 3.33, BRE of 0.13, and PI of 74.48. Our research contributes to improved project planning and decision-making processes in global software development endeavours.

Activity-based function point complexity of use case diagrams for software effort estimation

This study proposes a Function Point Analysis (FPA) based software development effort estimation methodology integrated with Use Case Diagrams. These methods include identifying actor activities, classifying those activities into FPA categories, and calculating Unadjusted Function Points (UFP). Followed by the calculation of Technical Complexity Factors (TCF) and Adjusted Function Points (AFP), this study aims to produce more accurate man-hours estimates. Results show a UFP of 162 TCF of 11, AFP of 123.12, and an estimated effort of 1846.8 hours worked, while the actual effort is 1228 hours. Evaluation of estimates using the metrics Mean Magnitude of Relative Error (MMER) 0.34, Mean Magnitude of Relative Error (MMRE) 0.50, Mean Absolute Error (MAE) 618.80, Mean Balanced Relative Error (MBRE) 0.50, Mean Inverse Balanced Relative Error (MIBRE) 0.34, and Root Mean Squared Error (RMSE) 618.80, showed sufficient precision despite the overestimation. The study suggests the need for adjustments in TCF calculations and considering development environment factors in more detail to improve estimation accuracy. These findings are essential in improving the precision of effort estimation methodologies in software development, particularly in projects that use Use Case Diagrams as the primary framework.

Evaluating urban mini plant factories: engineering and software cost perspectives for agriculture sustainability

Precision agriculture serves as a crucial solution to address the challenges of food security and agriculture sustainability. It provides significant benefits and enables effective monitoring of agriculture throughout the entire supply chain using a technology-driven approach that prioritizes internet connectivity and leverages big data. A noteworthy application of precision agriculture is the Mini Plant Factory, where plants are cultivated in closed systems with artificial lighting. The development of the Mini Plant Factory requires an economic feasibility analysis as a determinant of technology viability before widespread implementation, aiming to promote agriculture sustainability. The Software Cost Estimation Model (SCEM) assesses software development’s cost and time requirements. Engineering economics evaluates economic feasibility using metrics like NPV, BCR, IRR, PBP, and BEP methods. Function Point Analysis for UMPF software development estimates a cost of Rp 33,052,414, equivalent to 1,311 man-hours. Investment feasibility analysis considers the utilization of UMPF as viable, with an NPV of IDR 46,938,615, BCR of 1.08, IRR of 28%, and projected profitability within four years. Precision agriculture strategically addresses complex agricultural challenges, fostering sustainability with innovations such as the UMPF. The SCEM and engineering economics confirm the feasibility and rationale for implementing UMPF technology, providing essential insights for sustainable agricultural practices.

Use Case Point Methods For Analysis of Software Development Cost In Information Communication Technology Units of Khairun University

The Information and Communication Technology Unit (ICTU) is a technical implementation unit in the field of information and communication technology development and management. Currently, Khairun University's ICTU is undertaking a software development project, one of which involves creating an application called "Permata". In the process of developing this application, one of the common challenges faced is estimating the project costs for software development, as the developers do not yet have a standard method to determine the costs of software development. The objective of this research is to produce a Use Case Point application for estimating the costs of software development at ICTU, Khairun University. The Use Case Point (UCP) method is derived from the Function Point Analysis (FPA) method and aims to provide a simple estimation method oriented toward software project objects. The software objects involved in this method are Actor Types (UAW), Use Case Weight (UUCW), Technical System Development Complexity (TF), and Development Environment Complexity (EF). The estimated time value for developing the Permata application is 1,389.844855 man-hours, equivalent to approximately 1.904 months. The estimated cost for the Permata application is Rp129,099,127.

RPER Software - A Social Management Tool for Rapid Participatory Emancipatory Research: Planning, Design and Implementation

Theoretical framework: This study is grounded in Social Management, a paradigm that focuses on society's deliberative process for public decisions. It also employs the Rapid Participatory and Emancipatory Research (RPER) method, an adaptation of rapid and participatory appraisals, to apply social management in rural contexts. Research objectives: Identify the requirements, plan, design, assess the complexity, and implement a system to support the RPER application. Methodology: The waterfall model for software development lifecycle was used to carry out the system's planning. The discipline of Business Process Management (BPM) was necessary for the requirements mapping and the Function Point Analysis (FPA) technique to measure the software complexity from a user perspective. Results: The RPER application process was fully mapped, and several features that could be implemented for the software were uncovered. These functionalities address practically all the steps involved in the method’s application. In addition, the software measurement was completed, and 542 function points were found. After this, the design for the graphical user interface was then created. Finally, the software was developed using technologies such as Express for building the back-end RESTful API with Node.js, React library to create the front-end’s componentized user interface, TypeScript as the main programming language and PostgreSQL as the relational database. Originality: It is notable that some software has already been used to try and promote social participation in public matters. However, studies specific to the use of information and communication technology (ICT) to resolve social issues, and, at the same time, dealing specifically with participatory techniques are non-existent. There is an overflow of software tools designed to support quantitative research in the agriculture field, yet there remains a notable deficiency in software tailored to assist qualitative research and practices. Theoretical and practical contributions: The use of a web system on participatory approaches can bring advantages. In the theoretical side, this research might provide insights into these methods’ evolution. It will also provide a foundational framework for understanding the intersection of ICT and participatory techniques, paving the way for future research in this area. Some other more practical benefits include the wider distribution and dissemination of results, data transparency, the unification or centralization of the research made using the methods, the organization of data, the possibility of automation on report generation, better communication and collaboration between team members, and data safety with periodic backups. Nonetheless, the software could serve as a platform for preparing new researchers with help and tips section for each of the methods’ techniques.

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.

Pengukuran Perangkat Lunak Menggunakan Function Point Analysis – Studi Kasus Software Akuntansi “Beecloud”

Accounting software is a must have for small and large companies. In carrying out its business the company uses special accounting software. To find out how complex the software used , it is necessary to have software measurements . Measurements use the Function Point Analysis method where measurements are measured based on their functionality. There are 3 factors used as measurement tools, namely Crude Function Point (CFP), Relative Complexity Adjustment Factor (RCAF), and Function Point (FP). Based on the results of calculations using 3 methods, the Crude Function Point (CFP) is 11548, the Relative Complexity Adjustment Factor (RCAF) is 64, the Function Point (FP) is 15330.4. From the results obtained from calculations using the Function Point Analysis method, it can be seen that the Beecloud web-based accounting software is very complex.

Panduan Pengukuran Perangkat Lunak Metode Function Point Serta Implementasinya pada Website Pemesanan Tiket Bus

Measuring software quality is an important thing for software engineering. The purpose of applying measurements to software processes is to find out how complex and useful the software is. The measurement method used is Allan Albrecht's method, namely the Function Point Analysis method, which was developed by the International Function Point User Group (IFPUG). In this study, the authors measured the quality of a bus ticket booking website. Prior to the measurement stage, the authors compiled a module that contains the limitations of each point so that it can be used as a guide for scoring at each measurement stage, namely the stage of calculating the Crude Function Point (CFP) and Relative Complexity Adjustment Factor (RCAF). A calculator application is also made that can automatically calculate the total of function points so that it can make measurements easier. After the total Function Point value of the website is found, the total value can be used to predict the price or cost of making the software.

Arriving at the Results by Comparing with Traditional Approach to My Approach in Deriving Function Points for ETL Operations

It can be hard to guess how much data will need to be put into the data warehouse when the whole history of the transaction system is moved there. This is especially true when the transfer process could take weeks or even months. The ETL system's parts must be broken down into its three independent stages, nevertheless, when estimating a big starting load. Data extraction from source systems, Creating the dimensional model from data, Loading the data warehouse and timing estimates for the extraction process. Surprisingly, data extraction from the source system may take up the majority of the ETL procedure. Online transaction processing (OLTP) systems are simply not built to return those massive data sets from the data warehouse's historic load, which extracts a tremendous quantity of data in a single query. However, the daily incremental loads and the breath-of-life historic database loads are very different. In any case, fact-table filling requires data to be pulled in a different way than what transaction systems are able to do. ETL extraction procedures frequently call for time-consuming techniques like views, cursors, stored procedures, and correlated subqueries. It is essential to anticipate how long an extract will take to begin before it does. Calculating the extract time estimate is challenging. Due to the hardware mismatch between the test and production servers, estimates based on the execution of the ETL operations in the test environment may be greatly distorted. Sometimes working on certain projects where an extract task would run continuously and until it eventually failed, at which point it would be restarted and run once more until it failed. Without producing anything, days or even weeks passed. One must divide the extract process into two simpler steps in order to overcome the challenges of working with large amounts of data. Response time for queries. the interval between when the query is conducted and when the data starts to be returned. It is pertinent that effort arrival for ETL Operations for Data Marts and DWH projects in terms of Function Points which is a scientific way is essential. In the last paper, I have talked about general System Characteristics to arrive at Value Adjustment Factor. In this paper, I came up with results. I compared my findings with the conventional FPA on industrial projects in order to evaluate the Function Point Analysis’s suitability for Data Mart projects. I outline the strategy, implementation, and outcomes analysis of this validation in this section.

Retraction Note: Enrichment of accurate software effort estimation using fuzzy-based function point analysis in business data analytics

Retraction Note: Enrichment of accurate software effort estimation using fuzzy-based function point analysis in business data analytics

Research on Structured Extraction Method for Function Points Based on Event Extraction

Software size is a significant input for software cost estimation, and the implementation of software size estimation dramatically affects the results and efficiency of cost estimation. Traditionally, the software size estimation is implemented by strictly trained experts and is more labor-intensive for large software projects, which is relatively expensive and inefficient. Function Point Analysis is a widely used method for software size estimation, supported by several international standards. We propose a structured and automated function point extraction method based on event extraction in natural language processing to address the problem of complex and inefficient manual recognition for function point recognition. This approach has been validated in 10 industrial cases. Experimental results show that our method can identify more than 70% of the function points, which significantly improves the efficiency of Function Point Analysis implementation. This paper could be a guide on the application of artificial intelligence techniques to software cost estimation.

ESTIMASI PENGUKURAN PERANGKAT LUNAK MENGGUNAKAN METODE MATRIK FUNCTION POINT ANALYSIS – STUDI KASUS APLIKASI AKADEMIK SISWA BERBASIS WEBSITE

Function Point (FP) is a measurement method as well as a unit of measure from a software. FP can measure software by quantifying (number of units in numbers) functionality in software that is already provided to users based on logic. The FP matrix is calculated from 5 components which include the number of user inputs (external input-EI), the number of outputs to the user (external inquiry - EQ), the number of user inquiries (external inquiry - EQ), the number of internal files used (internal logical file - EQ). ILF), and the number of external interfaces (external files – EIF). This case study aims to study carefully how to calculate FP which produces the final result in the form of cost estimation in software. The existing software is the Website-Based Student Academic Application (AASBW). The technical files available from this software are source code and running application. This FP measurement will be carried out from a software point of view, namely measuring the finished application. From the observation, it is found that the FP for AASBW = 152.90 and the estimated cost to market this application is Rp. 7,645.00, the estimated production time is 29 days, and the estimated cost of managing this application is Rp. 3,850,000, so the results of the three estimation factors are used by the authors as analysis material for Website-Based Student Academic Applications using the Function Point Analysis method.

Evolution of Software Development Effort and Cost Estimation Techniques: Five Decades Study Using Automated Text Mining Approach

Software development effort and cost estimation (SDECE) is one of the most important tasks in the field of software engineering. A large number of research papers have been published on this topic in the last five decades. Investigating research trends using a systematic literature review when such a large number of research papers are published is a very tedious and time-consuming task. Therefore, in this research paper, we propose a generic automated text mining framework to investigate research trends by analyzing the title, author’s keywords, and abstract of the research papers. The proposed framework is used to investigate research trends by analyzing the title, keywords, and abstract of select 1015 research papers published on SDECE in the last five decades. We have identified the most popular SDECE techniques in each decade to understand how SDECE has evolved in the past five decades. It is found that artificial neural network, fuzzy logic, regression, analogy-based approach, and COCOMO methods are the most used techniques for SDECE followed by optimization, use case point, machine learning, and function point analysis. The NASA and ISBSG are the most used dataset for SDECE. The MMRE, MRE, and PRED are the most used accuracy measures for SDECE. Results of the proposed framework are validated by comparing it with the outcome of the previously published review work and we found that the results are consistent. We have also carried out a detailed bibliometric analysis and metareview of the review and survey papers published on SDECE. This research study is significant for the development of new models for cost and effort estimations.

Automated data function extraction from textual requirements by leveraging semi-supervised CRF and language model

Function Point Analysis (FPA) provides an objective, comparative measure for size estimation in the early stage of software development. When practicing FPA, analysts typically abide by the following steps: data function (DF) extraction, transactional function extraction, function type classification and adjustment factor determination. However, due to lack of approach and tool support, these steps are usually conduct by human efforts in practice. Related approaches can hardly be applied in the FPA due to the following three challenges, i.e., FPA rule-driven extraction, domain-specific parsing, and expensive labeled resources.

A New Approach to Calibrating Functional Complexity Weight in Software Development Effort Estimation

Function point analysis is a widely used metric in the software industry for development effort estimation. It was proposed in the 1970s, and then standardized by the International Function Point Users Group, as accepted by many organizations worldwide. While the software industry has grown rapidly, the weight values specified for the standard function point counting have remained the same since its inception. Another problem is that software development in different industry sectors is peculiar, but basic rules apply to all. These raise important questions about the validity of weight values in practical applications. In this study, we propose an algorithm for calibrating the standardized functional complexity weights, aiming to estimate a more accurate software size that fits specific software applications, reflects software industry trends, and improves the effort estimation of software projects. The results show that the proposed algorithms improve effort estimation accuracy against the baseline method.

Toward Improving the Efficiency of Software Development Effort Estimation via Clustering Analysis

<i>Introduction</i>: The precise estimation of software effort is a significant difficulty that project managers encounter during software development. Inaccurate forecasting leads to either overestimating or underestimating software effort, which can be detrimental for stakeholders. The International Function Point Users Group&#x2019;s Function Point Analysis (FPA) method is one of the most critical methods for software effort estimation. However, the practice of using the FPA method in the same fashion across all software areas needs to be reexamined. <i>Aim</i>: We propose a model for evaluating the influence of data clustering on software development effort estimation and then finding the best clustering method. We call this model the effort estimation using machine learning applied to the clusters (EEAC) model. <i>Method</i>: We cluster the dataset according to the clustering method and then apply the FPA and EEAC methods to these clusters for effort estimation. The clustering methods we use in this study include five categorical variable criteria (Development Platform, Industrial Sector, Language Type, Organization Type, and Relative Size) and the k-means clustering algorithm. <i>Results</i>: The experimental results show that the estimation accuracy obtaining with clustering consistently outperforms the accuracy without clustering for both the FPA and EEAC methods. Significantly, using the FPA method, the average improvement rate from using clustering as opposed to non-clustered was highest at 58.06%, according to the RMSE. With the EEAC method, this number reached 65.53%. The Industry Sector categorical variable achieves the best accuracy estimation compared to the other clustering criteria and k-means clustering. The improvement in accuracy in terms of the RMSE when applying this criterion is 63.68% for the FPA method and 72.02% for the EEAC method. <i>Conclusion</i>: Better results are obtained through dataset clustering compared to no clustering for both the FPA and EEAC methods. The Industry Sector is the most suitable clustering method among the tested clustering methods.

Comparing Multiple Linear Regression, Deep Learning and Multiple Perceptron for Functional Points Estimation

This study compares the performance of Pytorch-based Deep Learning, Multiple Perceptron Neural Networks with Multiple Linear Regression in terms of software effort estimations based on function point analysis. This study investigates Adjusted Function Points, Function Point Categories, Industry Sector, and Relative Size. The ISBSG dataset (version 2020/R1) is used as the historical dataset. The effort estimation performance is compared among multiple models by evaluating a prediction level of 0.30 and standardized accuracy. According to the findings, the Multiple Perceptron Neural Network based on Adjusted Function Points combined with Industry Sector predictors yielded 53% and 61% in terms of standardized accuracy and a prediction level of 0.30, respectively. The findings of Pytorch-based Deep Learning are similar to Multiple Perceptron Neural Networks, with even better results than that, with standardized accuracy and a prediction level of 0.30, 72% and 72%, respectively. The results reveal that both the Pytorch-based Deep Learning and Multiple Perceptron model outperformed Multiple Linear Regression and baseline models using the experimental dataset. Furthermore, in the studied dataset, Adjusted Function Points may not contribute to higher accuracy than Function Point Categories.

Spectral Clustering Effect in Software Development Effort Estimation

Software development effort estimation is essential for software project planning and management. In this study, we present a spectral clustering algorithm based on symmetric matrixes as an option for data processing. It is expected that constructing an estimation model on more similar data can increase the estimation accuracy. The research methods employ symmetrical data processing and experimentation. Four experimental models based on function point analysis, stepwise regression, spectral clustering, and categorical variables have been conducted. The results indicate that the most advantageous variant is a combination of stepwise regression and spectral clustering. The proposed method provides the most accurate estimates compared to the baseline method and other tested variants.

Investigating the Use of an Adaptive Neuro-Fuzzy Inference System in Software Development Effort Estimation

Modeling software development effort estimation models has been a hot research topic over the last three decades. Numerous models were proposed in these decades to predict the effort. The key challenges for future software development is providing accurate software estimation. Failure to acknowledge the accuracy of effort estimation can cause inaccurate estimation, customer disappointment, and poor software development or project failure. This research presents a novel computational technique, named adaptive neuro-fuzzy inference system (ANFIS), for the modeling of software effort estimation. It was developed utilizing the Constructive Cost Model (COCOMO) dataset. The data were randomly divided into two sets: 83% for training and 17% for testing. The mean magnitude relative-error (MMRE) and the coefficient of correlation (R) were used as assessment indices. Results showed that the accuracy of the proposed model is quite satisfactory in comparison with actual values. Moreover, a comparison study was conducted with another approach. The results showed that ANFIS produced better results in comparison with Function Point Analysis, Software Lifecycle Management, and COCOMO methods. ANFIS was found to be a potential predictive model for software development effort estimation.