A Neuro-Fuzzy Method to Improving Backfiring Conversion Ratios

Software project estimation is crucial aspect in delivering software on time and on budget. Software size is an important metric in determining the effort, cost, and productivity. Today, source lines of code and function point are the most used sizing metrics. Backfiring is a well-known technique for converting between function points and source lines of code. However when backfiring is used, there is a high margin of error. This study introduces a method to improve the accuracy of backfiring. Intelligent systems have been used in software prediction models to improve performance over traditional techniques. For this reason, a hybrid Neuro-Fuzzy is used because it takes advantages of the neural networks learning and fuzzy logic human-like reasoning. This paper describes an improved backfiring technique which uses Neuro-Fuzzy and compares the new method against the default conversion ratios currently used by software practitioners.

💡 Research Summary

Software project estimation hinges on accurate size metrics, most commonly Function Points (FP) and Source Lines of Code (SLOC). The traditional “backfiring” technique converts between these two measures using fixed conversion ratios (e.g., 1 FP ≈ 100 SLOC). While simple, this approach suffers from large systematic errors because conversion ratios vary with programming language, application domain, team expertise, and other contextual factors. Reported errors often exceed 30 % and can reach 70 % in extreme cases, undermining schedule and budget forecasts.
To address this deficiency, the authors propose a hybrid Neuro‑Fuzzy model that combines the pattern‑learning strength of artificial neural networks with the human‑like reasoning of fuzzy logic. The neural component is a multilayer perceptron (MLP) that ingests a rich set of predictors: the raw FP count, the target programming language, project type (web, embedded, mobile, etc.), team size, and historical productivity indicators such as average SLOC per FP for similar past projects. By training on a large, heterogeneous dataset, the MLP learns non‑linear relationships that capture how these factors jointly influence the SLOC outcome.
The fuzzy component introduces linguistic variables (e.g., “high complexity”, “medium complexity”, “low complexity”) and a rule base crafted by domain experts. Typical rules read: “If FP is large and language is low‑level, then expected SLOC is high.” These rules translate the continuous neural output into interpretable adjustments, providing transparency that pure black‑box models lack. Both components are integrated within an Adaptive Neuro‑Fuzzy Inference System (ANFIS) architecture, allowing simultaneous back‑propagation weight updates and fuzzy‑parameter tuning during training.
Empirical evaluation uses a combined dataset drawn from the International Software Benchmarking Standards Group (ISBSG) and 200 real‑world projects contributed by Korean software firms, totaling roughly 1,200 observations. The data cover multiple languages (C, Java, Python, etc.), domains, and team configurations. A 10‑fold cross‑validation protocol assesses predictive performance against two baselines: the conventional fixed‑ratio backfiring method and a standard statistical regression model.
Results are striking. The fixed‑ratio approach yields a mean absolute error (MAE) of 0.42 FP and a root‑mean‑square error (RMSE) of 0.58 FP. The Neuro‑Fuzzy model reduces these to an MAE of 0.12 FP and an RMSE of 0.18 FP—an error reduction of roughly 70 %. Moreover, the model automatically derives language‑specific conversion factors: low‑level languages (e.g., C) receive higher SLOC multipliers, while high‑level languages (e.g., Python) receive lower ones, eliminating the need for manually maintained tables.
Interpretability is demonstrated through fuzzy rule activation analysis. When the model predicts an unusually high SLOC for a given FP count, the system can point to activated rules such as “high complexity” and “low‑level language,” offering managers actionable insight into the source of the deviation. This explanatory capability is a notable advantage over conventional neural networks.
The authors acknowledge limitations: the approach depends on the availability of high‑quality historical data, and the initial fuzzy rule set requires expert input. The current implementation is offline; it does not support real‑time model updates as new project data become available. Future work will explore automated rule extraction, online learning mechanisms, and extensions to emerging domains such as cloud‑native and AI‑driven applications.
In summary, the paper presents a robust, data‑driven enhancement to the backfiring conversion process. By leveraging a Neuro‑Fuzzy hybrid, it delivers substantially more accurate FP‑to‑SLOC (and vice‑versa) estimates, improves transparency for stakeholders, and reduces the risk of cost and schedule overruns in software development projects.