The theoretical review establishes the foundational theories underpinning the research, focusing on existing, tested, and viable frameworks. It connects past proven theories with the current study, providing a robust lens for addressing research gaps.

Huang and Strigini (2018) introduced the Cognitive Error Model, which explains software defects as a consequence of human errors influenced by task complexity and individual cognitive limitations [6] . This model identifies three key elements:

1) Error Mode: The underlying pattern of erroneous human behavior, such as applying incorrect but familiar rules.

2) Error Scenario: The specific conditions under which an error occurs, integrating task content, representation, and individual cognitive conditions.

3) Error Mechanism: The combined factors explaining how a defect is introduced.

This theory aligns with the present research by highlighting parameters like lines of code, design complexity, and cyclomatic complexity, which are directly correlated with human error. By leveraging this model, the research incorporates predictive elements for identifying scenarios prone to defects. Huang and Liu (2016) proposed Defect Prevention Based on Human Error Theories (DPeHE), a human-centered approach emphasizing learning from past errors to prevent future defects [7] . DPeHE integrates meta-cognition the awareness and regulation of one’s cognitive processes to improve developers’ problem-solving abilities. The framework has three stages; knowledge training, regulation training, encouraging self-awareness and monitoring using defect prevention checklists and skill development. The DPeHE model informs this research by emphasizing the importance of analyzing specific aspects of software systems (e.g., operators, operands, comments) to ensure comprehensive defect detection and prevention.

Saini and Ahmad (2012) explored the Chaos Theory of Software Systems, which describes software as a nonlinear system with interdependent variables sensitive to initial conditions [8] . This sensitivity leads to unpredictability in defect occurrence. Key features of chaos include sensitive dependence and nonlinearity. The chaos theory relates to this research by addressing the limitations of static, linear models in capturing the dynamic, complex nature of software defects and cost estimation. The study applies Support Vector Machines (SVM) to identify hidden patterns in software metrics, accommodating the nonlinear dynamics highlighted by chaos theory.

The conceptual review delves into the fundamental concepts of software defects and cost estimation, defining variables and mapping their interrelations. Software defects represent deviations between actual and expected outcomes, encompassing errors in functionality, performance, usability, compatibility, and security [9] [10] . Types of defects include:

Arithmetic Defects: Errors in calculations or expressions.

Logical Defects: Flaws in program logic or corner-case handling.

Syntax Defects: Mistakes in code structure, such as missing semicolons.

Performance Defects: Issues affecting system response times or resource usage.

Interface Defects: Problems in user interactions or platform integration.

Defects can also be classified by severity (e.g., critical, high, medium, low) and priority (e.g., urgent, high, medium, low) [11] . Effective defect management involves early detection, categorization, and resolution, which are central to improving software quality and reducing maintenance costs. Cost estimation involves predicting the resources required for software development, focusing on effort, duration, and manpower [12] .

Estimation techniques are categorized as:

Algorithmic Methods: Utilize mathematical equations based on historical data, e.g., COCOMO, Putnam Model, and Function Point Analysis.

Non-Algorithmic Methods: Include expert judgment, analogy-based estimation, neural networks, genetic programming, and fuzzy logic [13] .

Each method has strengths and weaknesses. For instance, algorithmic methods provide structured, repeatable results but require extensive data, while non-algorithmic methods are flexible but dependent on expert availability and historical data accuracy.

Software metrics quantitatively measure aspects of software systems, aiding in defect prediction and cost estimation [14] . Key metrics include:

Lines of Code (LOC): Measures software size; higher LOC often correlates with increased defect probability.

Cyclomatic Complexity: Quantifies code complexity and potential error-prone paths.

Halstead Metrics: Evaluate program complexity based on operators and operands.

Object-Oriented Metrics: Assess features like cohesion, coupling, and inheritance.

Metrics are classified into:

Product Metrics: Assess the software product’s quality attributes (e.g., complexity, performance).

Process Metrics: Measure the efficiency of development processes (e.g. defect detection rates).

Project Metrics: Evaluate project-level attributes (e.g., cost, schedule adherence).

The theories and concepts reviewed provide a robust framework for the proposed hybrid model. Cognitive and chaos theories guide defect prediction by emphasizing the nonlinear and human-centric nature of software systems. Metrics and estimation techniques offer structured methodologies for cost evaluation. Together, these foundations support the development of an accurate, efficient model using SVM for both defect detection and cost estimation.

Empirical research focuses on deriving outcomes through qualitative or quantitative methods of observation, based on verifiable evidence, experiments, or observations. This section synthesizes significant studies in software defect prediction and cost estimation.

Hammouri et al. (2018) developed a software bug prediction model using machine learning (ML) algorithms such as Naïve Bayes (NB), Decision Tree (DT), and Artificial Neural Networks (ANNs) [15] . Their findings showed high accuracy rates; however, the model lacked optimization and unbiased evaluation techniques like K-Fold cross-validation, limiting its generalizability. This study aims to address these limitations by integrating grid search for hyperparameter tuning. Alsaeedi and Khan (2019) explored various ML techniques for defect prediction across NASA datasets, highlighting the effectiveness of Random Forest (RF) [10] . Despite promising results, the study employed only four ML models and lacked model optimization. This research will incorporate five ML models and use grid search for fine-tuning to enhance predictive accuracy.

Dam et al. (2018) employed deep learning techniques, specifically tree-structured long/short-term memory networks, for defect prediction [16] . While effective, the study faced limitations in dataset size and optimization. The current research will utilize larger datasets and implement grid search for optimization. Huda et al. (2017) proposed hybrid models combining wrapper and filter techniques for defect prediction [17] . Their method achieved high accuracy with reduced metrics but lacked optimization. This research addresses these gaps by incorporating grid search for parameter tuning and expanding the scope to include software cost evaluation.

Jinsheng et al. (2014) tackled class imbalance issues using asymmetric kernel classifiers [18] . Despite improvements, the study was constrained by small datasets and lacked optimization. This research aims to integrate a hybridized model addressing both software defects and costs with robust cross-validation. Aleem et al. (2015) analyzed supervised and unsupervised learning techniques for defect prediction [19] . Although extensive evaluation measures like accuracy and F-measure were used, the absence of optimization limited model performance. This study incorporates grid search and addresses both defect prediction and cost estimation. Sun et al. (2012) proposed converting imbalanced binary-class data into balanced multiclass data for defect prediction [20] . Despite the robustness of their approach, the study overlooked hyperparameter tuning and cost-related aspects. This research bridges these gaps by incorporating software cost estimation and model optimization.

Petric et al. (2016) demonstrated the benefits of diversity techniques in defect prediction using stacking ensembles [21] . While effective, the study focused solely on defects, neglecting cost aspects. This research extends the methodology to address both software defects and costs. Pan et al. (2019) improved CNN-based defect prediction models, emphasizing hyperparameter instability [22] . Although effective for defect prediction, the study did not address software cost. This research proposes a unified model for defects and cost estimation. Laradji et al. (2015) combined feature selection and ensemble learning, achieving high accuracy in defect classification [23] . However, the study focused only on defects. The proposed model in this research will address both defects and costs.

Pelayo and Dick (2014) evaluated SMOTE for addressing class imbalance in defect prediction [24] . While successful, the study did not explore software cost. This research integrates cost-related metrics in a hybrid model. Balogun et al. (2019) analyzed feature selection methods for defect prediction [25] . Although effective, the research ignored cost estimation. This study adopts Principal Component Analysis (PCA) for preprocessing and expands the model’s scope to include cost evaluation. Wu et al. (2018) proposed a cost-sensitive dictionary learning approach for defect prediction [26] . While addressing defects effectively, the study excluded cost metrics. This research bridges this gap with a hybridized model.

Fan et al. (2019) introduced an attention-based recurrent neural network for defect prediction [27] . While the model achieved high accuracy, it neglected cost-related predictions. The proposed model addresses both dimensions. Wang et al. (2011) compared ensemble methods for defect prediction, finding Random Forest and Voting to be most effective [28] . The study lacked model optimization and cost considerations, which this research integrates into its methodology. Song et al. (2010) proposed a comprehensive defect prediction framework but excluded hyperparameter tuning and cost considerations [29] . These gaps are addressed in this research with grid search optimization.

Huang et al. (2015) assessed preprocessing techniques for software cost estimation [30] . Although impactful, the study lacked a direct evaluation of machine learning methods. This research ensures robust evaluation of ML models for defects and costs. Nassif et al. (2012) compared log-linear regression and neural networks for cost estimation, finding complementary strengths based on project size [31] . This research expands their approach to encompass defect prediction. This comprehensive empirical review identifies key gaps in existing research and highlights the novelty of a hybridized model integrating defect prediction and cost estimation using advanced ML techniques and optimization strategies.

The study expanded the related literature to provide a thorough comparison of hybrid or multi-task learning approaches in software engineering. Zhang et al. (2018) employed a neural network sharing hidden layers for defect density and maintenance effort, achieving improved classification metrics due to learned cross-task representations [32] . Sun and Xia (2019) introduced a CNN-based multi-task model for bug detection and code-smell identification, underscoring that shared layers reduce false positives compared to task-specific networks [33] . Panichella et al. (2020) applied partially shared ensemble techniques for code-quality classification and basic effort estimation; however, the tasks still used separate modules for training [34] . Kim & Williams (2021) proposed a Bayesian multi-task framework for defect detection and release-time predictions [35] . While effective, it did not incorporate an integrated dimensionality-reduction step such as PCA. Compared to these prior works, our model contributes a fully integrated SVM solution for both classification (defect prediction) and regression (cost estimation) using a single kernel-based system, joint feature preprocessing (PCA), and an overarching multi-objective optimization procedure. This deeper integration enables the discovery of cross-task correlations and demonstrates strong empirical performance on public datasets (NASA PROMISE, Kaggle).

The study adopts the Object-Oriented Analysis and Design (OOAD) methodology. This approach is well-suited as it represents the system as a collection of objects encapsulating functionalities (behaviour) and data (state). OOAD ensures modularity and enhances the system’s scalability and maintainability. In line with the study’s objectives, the following techniques and procedures were employed; data preprocessing, model development, data partitioning, model training and testing, and performance evaluation.

This study builds upon the systems developed by Hammouri et al. (2018) for software defect prediction and Premalatha and Srikrishna (2019) for software cost estimation [15] [36] . Hammouri et al. (2018) utilized Naïve Bayes (NB), decision tree (DT), and artificial neural networks (ANNs) for software defect prediction, preprocessed datasets with clustering techniques and evaluated models using metrics like accuracy, precision, recall, and RMSE [15] . The work used small training datasets and absence of model optimization techniques. Premalatha and Srikrishna (2019) developed a Cost-sensitive deep belief network (ECS-DBN) for software cost estimation, evaluated using metrics such as RAE, MAE, and RMSE [36] . The study focused solely on cost estimation without addressing software defect prediction or dataset scalability. Figure 1 to Figure 2 highlight the systems of Hammouri et al. (2018) and (Premalatha & Srikrishna, 2019) respectively [15] [36] .

The hybrid system integrates software defect prediction and cost estimation into a unified model using Support Vector Machine (SVM). Key steps in the system development.

Dataset Acquisition: Software defect datasets were sourced from the NASA PROMISE repository. Software cost estimation datasets were obtained from Kaggle.

Data Preprocessing: PCA was used to reduce dimensionality, ensuring computational efficiency and enhancing model performance.

Model Training and Testing: The hybridized model was trained on 70% of the dataset and tested on 30%. K-fold cross-validation was implemented to ensure unbiased performance evaluation.

Performance Metrics: Defect prediction: Accuracy, Precision, Recall, F1-score. Cost estimation: Coefficient of Determination (R²).

The PCA process includes computation, principal component selection, and integration into the hybrid model. The process starts by standardizing each feature (e.g., code metrics, developer experience). Then, we compute the covariance matrix of these standardized values. Eigen decomposition of the covariance matrix yields eigenvalues {λ_i} and corresponding eigenvectors {v_i}. The total variance is ∑λ_i. We order eigenvalues λ_i in descending order. Let the sum of the top k eigenvalues be ${\displaystyle {\sum }_i^n={\lambda }_i}$. We choose the smallest k satisfying ${\displaystyle {\sum }_i^n=k{\lambda }_i}\ge 0.95$ ensuring at least 95% of the original data variance is preserved.

Principal Component Selection

• The total variance is ${\displaystyle \sum {\lambda }_i}$. We order eigenvalues λ_i in descending order. Let the sum of the top k eigenvalues be ${\displaystyle {\sum }_{i=1}^k{\lambda }_i}$.

• We choose the smallest k satisfying

$\frac{{\displaystyle {\sum }_{i=1}^k{\lambda }_i}}{{\displaystyle {\sum }_{j=1}^d{\lambda }_j}}\ge 0.95$

95% is commonly used in data mining as a balance between dimensionality reduction and information retention. Empirically, we found this threshold to maintain prediction accuracy while reducing computational overhead in SVM training. After determining k, we project the data onto the top k eigenvectors. Both the defect-prediction and cost-estimation submodules receive these same PCA-transformed features, ensuring uniform input spaces across tasks.

The proposed system leverages the strengths of machine learning for multi-tasking:

1) Hybrid Approach: Tackles classification (defects) and regression (cost) problems simultaneously, uncovering potential correlations.

2) Efficiency: SVM’s duality in handling classification and regression tasks ensures optimal model performance.

3) Scalability: Incorporates larger datasets and preprocessing techniques to overcome existing system constraints.

The system design is based on OOAD and employs Unified Modeling Language (UML) for structural representation. Components include:

Inputs: Software defect parameters (e.g., McCabe’s metrics, Halstead’s measures). Software cost parameters (e.g., project size, team experience, transaction counts).

Outputs: Predicted software defects and estimated costs.

Core Components:

Data Acquisition: Data sourced from PROMISE and Kaggle repositories.

Data Preprocessing: PCA for dimensionality reduction.

Model Training: SVM for learning from datasets.

Performance Evaluation: Accuracy metrics for defects; R² for cost.

The UML use case diagram for this system serves as the primary representation of the system/software requirements. It specifies the expected behavior (the “what”) of the system rather than detailing the method of implementation (the “how”). The use case diagram is a visual representation designed to capture system functionality and interactions from the perspective of the end user. This modeling approach aids in designing the system with a user-centered focus, ensuring clarity and alignment with user needs.

The use case diagram is an effective tool for communicating system behavior in terms familiar to the user by illustrating all externally visible actions the system can perform. It helps bridge the gap between technical implementation and user expectations. The use case diagram for the proposed hybridized software defect and cost evaluation model is illustrated in Figure 3 .

The activity diagram for the proposed hybridized software defect and cost evaluation model illustrates the interactions, workflows, and decisions involved in the system’s operations. This detailed and structured representation facilitates better understanding and effective system design. The system activity diagram is presented in Figure 4 .

The flat file schema is selected for its simplicity and suitability for storing machine learning datasets. This schema organizes data into a single, two-dimensional structure, typically a CSV file, making it easy to integrate with Python libraries such as pandas and scikit-learn. The flat file schema is selected for its simplicity and suitability for storing machine learning datasets. This schema organizes data into a single, two-dimensional structure, typically a CSV file, making it easy to integrate with Python libraries such as pandas and scikit-learn. The proposed architecture integrates: Data Acquisition, Seamless extraction from repositories; Preprocessing -PCA for noise reduction; Training and Testing, implementation using PyCharm and Python libraries; and Evaluation: Metrics for comprehensive performance analysis. Figure 6 shows the integrated architecture of hybrid.

The parameters of software defect dataset are described in Table 1 while parameters of software defect dataset are described in Table 1 .

The parameters of software cost dataset are described in Table 2 .

The state equation for each of the independent variables in the dataset are:

Line of Code,

$Loc={\displaystyle {\sum }_{i=i}^{n}Lo{c}_i}$ (1)

Cyclomatic complexity,

$v\left(g\right)=E-N+2\times P$ (2)

where E = Number of Edges in the flow graph.

N = Number of Nodes in the flow graph.

P = Number of Nodes that have exit point.

Essential complexity

$ev\left(g\right)=EP+TP+ND$ (3)

where EP = Entry Points.

TP = Termination points.

ND = Non Deducible nodes.

Design complexity,

$iv\left(g\right)={\displaystyle {\sum }_{i=i}^{n}iv\left(gi\right)}$ (4)

Program length (Total Operators + Operands),

$N=N_1+N_2$ (5)

Program difficulty,

$D=\frac{n_1}{2}\times \frac{n_2}{n_2}$ (6)

where n₁ = Unique Operators.

n₂ = Unique Operands.

N₂ = Count of Operands.

Program volume V is the product of program length and the logarithm of vocabulary size (n).

i.e.

$V=N\times \log 2\left(n\right)$ (7)

Program Intelligence,

1 = $\frac{V}{D}$ (8)

where V is the program volume.

And D in program difficulty.

Program Effort, E is the product of program volume and program difficulty,

$E=V\times D$ (9)

Halstead Delivered Bug,

$B=\frac{E^{2/3}}{3000}$ (10)

Halstead Time Estimation,

$T=\frac{E}{F\times S}$ (11)

where E is program effort, f is the seconds to minutes factor and S in stoud number.

Line of comment,

$Locomment={\displaystyle {\sum }_{i=i}^{n}Locommen{t}_i}$ (12)

Halstead’s count of blank lines,

$LOBlank={\displaystyle {\sum }_{i=i}^{n}LOBlan{k}_i}$ (13)

$Uniqueoperators={\displaystyle {\sum }_{i=i}^{n}Uniqo{p}_i}$ (14)

$Uniqueoperands={\displaystyle {\sum }_{i=i}^{n}Uniqopn{d}_i}$ (15)

$Totaloperators={\displaystyle {\sum }_{i=i}^{n}o{P}_i}$ (16)

$Totaloperand={\displaystyle {\sum }_{i=i}^{n}opn{d}_i}$ (17)

$Branchcount={\displaystyle {\sum }_{i=i}^{n}b{c}_i}$ (18)

The relationship between the dependent variable and the independent variables was derived as follows;

$\begin{array}{c}S{D}_i=\alpha +{\beta }_{1}Lo{c}_1+{\beta }_2{V}_2\left(g\right)+{\beta }_{3}e{v}_3\left(g\right)+{\beta }_{4}i{v}_4\left(g\right)+{\beta }_5{n}_5\\ +{\beta }_6{V}_6+{\beta }_7{l}_7+\cdots +{\beta }_{i}branchcoun{t}_i+ℰ\end{array}$ (19)

where

$S{D}_i$ is the dependent variable (software defect), $\alpha$ is the intercept, $\beta$ is the coefficient (effect of the independent variable on the dependent variables), Loc, V(g), ev(g), iv(g), n, V, I … are the independent variables as presented in the software dataset used in the research, $ℰ$ is the residual (error term), Let X represent all the independent variables.

Therefore

$S{D}_i=\alpha +{\displaystyle {\sum }_{i=i}^n{\beta }_i{X}_i}+ℰ$ (20)

We state the equation for each of the independent variables in the dataset as follows;

$Project={\displaystyle {\sum }_{i=i}^n{p}_i}$ (21)

$TeamExp={\displaystyle {\sum }_{i=i}^{n}TeamEx{P}_i}$ (22)

$ManagerExp={\displaystyle {\sum }_{i=i}^{n}ManagerEx{P}_i}$ (23)

$Length={\displaystyle {\sum }_{i=i}^n{L}_i}$ (24)

$Transaction={\displaystyle {\sum }_{i=i}^{n}fpcount{T}_i}$ (25)

$Entities={\displaystyle {\sum }_{i=i}^n{E}_i}$ (26)

$\begin{array}{c}PointNonadjust=fpcount\left(ILFs\right)+fpcount\left(EI{F}_s\right)+fpcount\left(E{I}_s\right)\\ +fpcount\left(E{O}_s\right)+fpcount\left(E{Q}_s\right)\end{array}$ (27)

where

ILF is Internal Logical File.

EIF is External Interface File.

EI is External Input.

EO is External Output.

EQ is External Inquiries.

$Pointadjust=Non\text{-}adjustedFPC\times VAF$ (28)

where

VAF is the Value Adjustment Factor.

The relationship between the dependent variable and the independent variable is derived as follows

$\begin{array}{c}Cos{t}_K=\theta +{\delta }_{1}projec{t}_1+{\delta }_{2}teamEx{p}_2+{\delta }_{3}managerEx{p}_3+{\delta }_{4}yearEn{d}_4\\ +{\delta }_{5}lengt{h}_5+{\delta }_{6}transactio{n}_6+{\delta }_{7}entitie{s}_7+\cdots +{\delta }_{k}languag{e}_k+ℰ\end{array}$ (29)

where

$\theta$ is the intercept.

$\delta$ is the coefficient.

Project₁, teamExp₂, ManagerExp₃, yearEnd₄, length₅, transactions₆, entities₇, PointNonAdjusts₈, PointAdjust₉, Language₁₀ are the independent variables.

Let P represent all the independent variables,

Therefore,

$Cos{t}_k=\theta +{\displaystyle {\sum }_{k=i}^n{\delta }_k{P}_k}+ℰ$ (30)

To hybridize Equations (3.20) and (3.30), we need them merge them into a single equation that incorporates elements from both equations. Since both equations represent different aspects of software development (defect and cost), we create a unified model that accounts for both factors. One way to achieve this is by incorporating both defects and cost components into a single equation as shown in Equation (31).

$S{D}_i{C}_i={\beta }_i{X}_i+{\delta }_k{P}_k+{ℰ}_i$ (31)

where

$S{D}_i{C}_i$ represents the dependent variable for software defect and cost, ${\beta }_i$ is the coefficient representing the effect of the independent variables related to defect, $X_i$ represents the independent variables related to defect, ${\delta }_k$ is the coefficient representing the effect of the independent variables related to cost, $P_k$ represents the independent variables related to cost, ${ℰ}_i$ is the residual error term.

The hybridized equation combines aspects of both the software defect model and the software cost model into a single equation allowing for the simultaneous considerations of both the defect and cost factors in the evaluation.

Equation (31) formalizes a joint objective combining classification and regression losses within the same SVM framework:

$\underset{w_d,w_c}{\min }\left(\alpha L_{\text{defect}}\left(w_d\right)+\left(1-\alpha \right)L_{\text{cost}}\left(w_c\right)\right)+\Omega \left(w_d,w_c\right),$

where

• $w_d$ are weights for defect prediction (classification),

• $w_c$ are weights for cost estimation (regression),

• $L_{\text{defect}}$ typically denotes a hinge loss or other classification loss,

• $L_{\text{cost}}$ denotes an ε-insensitive or squared error regression loss,

• $\alpha \in \left[0,1\right]$ balances the two tasks,

• Ω is a regularization term (e.g., L₂ norm) preventing overfitting.

The PCA-transformed features feed into both defect (SVM classifier) and cost (SVM regressor), enabling them to learn from a consistent representation. We apply a unified kernel (e.g., RBF or polynomial) for both tasks, ensuring the same non-linear feature mapping in the SVM. The classifier and regressor maintain separate decision functions within this shared space. This unified approach allows cost predictions to be influenced by knowledge from defect patterns and vice versa, uncovering relationships like “higher complexity → higher defect risk → potentially higher cost,” within one integrated learning procedure.

The outputs of this system include the predicted software defects and estimated software development costs, where the cost is quantified as the actual effort measured in person-hours. These outputs are displayed in both numeric and graphical formats for better interpretability and decision-making. The outputs are visualized through the computer’s display unit, ensuring user-friendly presentation and comprehensive insights. The high-level output model of this system is depicted in Figure 7 .

The performance results of the defect prediction feature of the hybrid model are outlined in Table 3 .

The Coefficient of Determination (R²) of the cost estimation prediction is 0.87, the Mean Absolute Error (MAE) is 5.2 persons per hour, and the Root Mean Squared Error (RMSE) is 6.8 persons per hour. Figure 8 shows the performance graph of the Defect Prediction Results.

The model performance is highlighted in three measurements, namely;

1) Hybrid Model Synergy: By combining defect prediction and cost evaluation, the hybrid model exhibited improved efficiency compared to separate models. The integrated approach allowed for insights into correlations between defects and cost.

2) Principal Component Analysis (PCA): PCA effectively reduced dimensionality, retaining 95% of the dataset’s variance, which enhanced computational efficiency without compromising prediction accuracy.

3) K-Fold Cross-Validation: The model maintained consistent performance across all folds, confirming its generalizability.

The accuracy (94.5%) of the hybrid model demonstrates high reliability in identifying defect-prone components in software systems. A high precision (93.7%) indicates that the model minimizes false positives, which is critical for ensuring trust in defect predictions. The recall (92.3%) reveals that the model effectively identifies most actual defects, reducing the risk of undetected bugs. The F1-Score (93.0%) suggests a balanced performance between precision and recall, ensuring robustness in real-world applications.

Similarly, Coefficient of Determination (R²): The model achieved an R² value of 0.87, demonstrating its strong ability to explain variance in software development costs. Mean Absolute Error (MAE): The MAE was 5.2 person-hours, indicating minimal deviation between predicted and actual cost values. Root Mean Squared Error (RMSE): The RMSE was 6.8 person-hours, further validating the accuracy of the cost estimation.

The study validated the dual capability of SVM in classification (defect prediction) and regression (cost estimation). Its ability to handle high-dimensional datasets and separate classes with a maximum-margin hyperplane contributed to the model’s effectiveness.

The hybrid model outperforms traditional models (e.g., Naïve Bayes, Decision Tree) used by Hammouri et al. (2018) for defect prediction and Premalatha and Srikrishna (2019) for cost estimation [15] [36] . Unlike existing models, the hybridized approach integrates defect prediction and cost estimation, providing a unified solution. The application of Principal Component Analysis (PCA) for dimensionality reduction enhanced computational efficiency and reduced overfitting. K-fold cross-validation ensured unbiased performance evaluation, strengthening the reliability of the results.

Combining classification (defects) and regression (costs) tasks uncovers potential correlations between software quality attributes and cost factors. The hybrid model leverages larger datasets and advanced preprocessing techniques, making it adaptable to real-world scenarios. SVM’s duality in handling diverse tasks (classification and regression) ensures optimized performance across both domains. The contribution to Software Engineering therefore includes; Defect Prediction, Cost Estimation, and Correlation Insights.

In contrast to training two separate, optimized models, the proposed hybrid model integrates defect prediction (classification) and cost estimation (regression) into a unified framework. Empirical evidence (Caruana, 1997) indicates that multi-task learning can exploit overlapping data patterns. For instance, complexity metrics, team experience, and code churn often influence both defect proneness and cost. A single model capitalizes on these shared features rather than duplicating efforts in two disjoint models. Multi-task learning commonly acts as a natural regularizer, preventing the model from overfitting to just one objective. By simultaneously learning defects and cost, the model is forced to find parameter configurations that explain both tasks, often leading to better generalization. A single hybrid model simplifies deployment pipelines (e.g., continuous integration setups) by producing both defect predictions and cost estimates from one codebase. This streamlines updates, monitoring, and resource allocation compared to maintaining two separate ML models. The hybrid approach yields competitive or even superior performance metrics (F1, MAE) compared to specialized single-task models. Notably, it also reveals potential correlations such as how modules with higher defect risk often correlate with elevated cost/effort. Hence, by combining both tasks, our study advances the state of software analytics, offering holistic insights that can enhance project management strategies more effectively than disjoint, specialized models.