Early Phases Of Software Development Research Articles

Context-Based Aspect-Oriented Requirement Engineering Model

Mobile applications are context-oriented systems that involve the use of context information while operating. Mobile applications demand tackling context information in the early phase of software engineering. A context-aware system demands a different approach to handling the influence of the context on a system's requirements. Aspect-oriented Requirement Engineering separates concerns throughout requirements, called crosscutting concerns, in the early phase of software development to improve the modularity of complex applications. Capturing requirements embedded within context is a challenging procedure. This study aimed to identify such contextual characteristics of requirements in the early phase of software engineering, using natural language processing techniques, by proposing Context-Based Aspect-Oriented Requirement Engineering (CB-AORE) to visualize the existence of crosscutting concerns. CB-AORE performs context modeling to analyze the context dependency with base requirements and helps the analyst to visualize the correlation of functional and non-functional requirements with context. A case study analyzed the identification of context and its use to identify crosscutting concerns.

Heterogeneous Cross-Project Defect Prediction via Optimal Transport

Heterogeneous cross-project defect prediction (HCPDP) aims to learn a prediction model from a heterogeneous source project and then apply the model to a target project. Existing HCPDP works mapped the data of the source and target projects in a common space. However, the pre-defined forms of mapping methods often limit prediction performance and it is difficult to measure the distance between two data instances from different feature spaces. This paper introduced optimal transport (OT) theory for the first time to build the relationship between source and target data distributions, and two prediction algorithms were proposed based on OT theory. In particular, an algorithm based on the entropic Gromov-Wasserstein (EGW) discrepancy was developed to perform the HCPDP model. The proposed EGW model measures the distance between two metric spaces by learning an optimal transfer matrix with the minimum data transfer cost and avoids measuring the distance of two instances of different feature spaces. Then, to improve EGW performance, an EGW+ transport algorithm based on EGW was developed by integrating target labels. Experimental results showed the effectiveness of EGW and EGW+ methods, and proved that our methods can support developers to find the defects in the early phase of software development.

HEDF: A Method for Early Forecasting Software Defects Based on Human Error Mechanisms

As the primary cause of software defects, human error is the key to understanding, and perhaps to predicting and avoiding them. Little research has been done to predict defects on the basis of the cognitive errors that cause them. This paper proposes an approach to predicting software defects through knowledge about the cognitive mechanisms of human errors. Our theory is that the main process behind a software defect is that an error-prone scenario triggers human error modes, which psychologists have observed to recur across diverse activities. Software defects can then be predicted by identifying such scenarios, guided by this knowledge of typical error modes. The proposed idea emphasizes predicting the exact location and form of a possible defect. We conducted two case studies to demonstrate and validate this approach, with 55 programmers in a programming competition and 5 analysts serving as the users of the approach. We found it impressive that the approach was able to predict, at the requirement phase, the exact locations and forms of 7 out of the 22 (31.8%) specific types of defects that were found in the code. The defects predicted tended to be common defects: their occurrences constituted 75.7% of the total number of defects in the 55 developed programs; each of them was introduced by at least two persons. The fraction of the defects introduced by a programmer that were predicted was on average (over all programmers) 75%. Furthermore, these predicted defects were highly persistent through the debugging process. If the prediction had been used to successfully prevent these defects, this could have saved 46.2% of the debugging iterations. This excellent capability of forecasting the exact locations and forms of possible defects at the early phases of software development recommends the approach for substantial benefits to defect prevention and early detection.

Design and Programming for Multicore machines: An Empirical study on time and effort required by programmer

As the demand for high-performance computing continues to surge, harnessing the full potential of multicore architectures has become paramount. This paper explores a pragmatic approach to transition from sequential to parallel programming, capitalizing on the computational prowess of modern hardware systems. Recognizing the challenges of enforcing parallelism in early software development phases, we advocate for a focus on the implementation stage, where architects, designers, and developers can seamlessly introduce parallel constructs while preserving software integrity. To facilitate this paradigm shift, we introduce the “SDLC model with Parallel Constructs,” a modified Software Development Life Cycle (SDLC) framework comprising additional phases: “Parallel Constructs” and “Test Parallel Constructs.” This model empowers development teams to integrate parallel computing efficiently, enhancing performance and maintaining a structured development process. Our observations reveal intriguing dynamics. Initially, the single-threaded program outperforms its parallel counterpart for smaller datasets, but as data sizes grow, the parallel version demonstrates superior performance. We underscore the pivotal role of available CPU cores and task partitioning in determining efficiency. Our analysis also evaluates the programmer’s effort, measured by lines of code, needed for the transition. Leveraging OpenMP constructs streamlines this transition, reducing programming complexity.

SOFTWARE QUALITY PREDICTION USING MACHINE LEARNING TECHNIQUES AND SOURCE CODE METRICS: A REVIEW

Software quality prediction is the Machine Learning (ML) based technique in which ML models are trained using historical data. Output from these quality models can be used by software experts in the early phase of software development for improving the quality of software by controlling the various quality attributes like maintainability, reliability, security issues of software etc. In this study a systematic review of studies from 2005 to 2021 is performed. Studies that use ML techniques and source code metrics for Software Quality Prediction (SQP) are included for review. Study assesses the commonly used machine learning techniques and source code metric for SQP. Commonly used datasets, feature selection techniques and commonly used performance measures in software quality prediction are also assessed. In this paper 53 primary studies are selected for systematic review. Results of this study prove that Bayesian Learning (BL), Regression, Ensemble Learning (EL), Decision Tree (DT) and Support Vector Machine (SVM) are most commonly ML techniques used for quality prediction which comprises 58%, 52%, 41%, 32%, and 32% of the overall studies respectively. It is also assessed that NASA, PROMISE, Apache, Mozilla Firefox and Eclipse are the most commonly used datasets for training and testing the SQP models. LOC, CC, CBO, RFC, WMC, LCOM, DIT and NOC are among the most commonly used source code metrics in SQP. Based on the results from the selected studies it is concluded that ML techniques and source code metrics have the ability to improve the overall quality of the software.

Construction and Validation of Early Software Size Estimation Models Based on ADAF-Adjusted ACD Metrics

Abstract Software size estimation is a vital activity of software project planning and management. Early software size estimation is a challenging task due to the limited information available during the early phases of software development. The goal of this paper is to construct and validate early software size estimation models based on four analysis-to-design adjustment factor (ADAF)-adjusted analysis class diagram metrics (i.e. ADAF-adjusted number of classes, ADAF-adjusted number of attributes, ADAF-adjusted number of methods and ADAF-adjusted number of relationships) using stepwise multiple linear regression and leave-one-out cross-validation. Furthermore, the prediction accuracy of the best-performing proposed model is also compared with the model based on objective class points. The results of this comparison reveal that our proposed method reduces errors significantly (i.e. on average, 16% reduction in mean absolute residual and 24% reduction in mean squared error).

Effective ANN Model based on Neuro-Evolution Mechanism for Realistic Software Estimates in the Early Phase of Software Development

There is no doubt that the software industry is one of the fastest-growing sectors on the planet today. As the cost of the entire development process continues to rise, an effective mechanism is needed to estimate the required development cost to control better the cost overrun problem and make the final software product more competitive. However, in the early stages of planning, the project managers have difficulty estimating the realistic value of the effort and cost required to execute development activities. Software evaluation prior to development can minimize risk and upsurge project success rates. Many techniques have been suggested and employed for cost estimation. However, computations based on several of these techniques show that the estimation of development effort and cost vary, which may cause problems for software industries in allocating overall resources costs. The proposed research study proposes the artificial neural network (ANN) based Neural-Evolution technique to provide more realistic software estimates in the early stages of development. The proposed model uses the advantages of the topology augmentation using an evolutionary algorithm to automate and achieve optimality in ANN construction and training. Based on the results and performance analysis, it is observed that software effort prediction using the proposed approach is more accurate and better than other existing approaches.

Predicting Software Defects for Object-Oriented Software Using Search-based Techniques

Development without any defect is unsubstantial. Timely detection of software defects favors the proper resource utilization saving time, effort and money. With the increasing size and complexity of software, demand for accurate and efficient prediction models is increasing. Recently, search-based techniques (SBTs) have fascinated many researchers for Software Defect Prediction (SDP). The goal of this study is to conduct an empirical evaluation to assess the applicability of SBTs for predicting software defects in object-oriented (OO) softwares. In this study, 16 SBTs are exploited to build defect prediction models for 13 OO software projects. Stable performance measures — GMean, Balance and Receiver Operating Characteristic-Area Under Curve (ROC-AUC) are employed to probe into the predictive capability of developed models, taking into consideration the imbalanced nature of software datasets. Proper measures are taken to handle the stochastic behavior of SBTs. The significance of results is statistically validated using the Friedman test complied with Wilcoxon post hoc analysis. The results confirm that software defects can be detected in the early phases of software development with help of SBTs. This paper identifies the effective subset of SBTs that will aid software practitioners to timely detect the probable software defects, therefore, saving resources and bringing up good quality softwares. Eight SBTs — sUpervised Classification System (UCS), Bioinformatics-oriented hierarchical evolutionary learning (BIOHEL), CHC, Genetic Algorithm-based Classifier System with Adaptive Discretization Intervals (GA_ADI), Genetic Algorithm-based Classifier System with Intervalar Rule (GA_INT), Memetic Pittsburgh Learning Classifier System (MPLCS), Population-Based Incremental Learning (PBIL) and Steady-State Genetic Algorithm for Instance Selection (SGA) are found to be statistically good defect predictors.

An Automated Approach of Detection of Memory Leaks for Remote Server Controllers

Memory leaks are a major concern to the long running applications like servers which make the working set to grow with the program. This eventually leads to system crashing. This paper discusses a staged approach to detect leaks in firmware of remote server controller. Remote server controller monitors the server remotely with many processes running in the background. Any memory leak in the long running applications pose a threat to the performance of the system. The approach adopted here filters the processes running in the system with leaks based on time threshold in the first stage. These processes with leaks are passed to the next stage where precise memory leak detection is done using the open source dynamic instrumentation tool Valgrind. The system leverages an automated leak detection approach that invokes the leak detection process on encountering any severity in the system and generates a consolidated leak report. The proposed approach has less impact on the performance of the system and is faster compared to many available systems as there is no need to modify or re-compile the program. In addition, the automated approach offers an effective technique for detecting possible leakages in early software development phases.

Security in agile software development: A practitioner survey

Abstract Context: Software security engineering provides the means to define, implement and verify security in software products. Software security engineering is performed by following a software security development life cycle model or a security capability maturity model. However, agile software development methods and processes, dominant in the software industry, are viewed to be in conflict with these security practices and the security requirements. Objective: Empirically verify the use and impact of software security engineering activities in the context of agile software development, as practiced by software developer professionals. Method: A survey ( N = 61 ) was performed among software practitioners in Finland regarding their use of 40 common security engineering practices and their perceived security impact, in conjunction with the use of 16 agile software development items and activities. Results: The use of agile items and activities had a measurable effect on the selection of security engineering practices. Perceived impact of the security practices was lower than the rate of use would imply: This was taken to indicate a selection bias, caused by e.g. developers’ awareness of only certain security engineering practices, or by difficulties in applying the security engineering practices into an iterative software development workflow. Security practices deemed to have most impact were proactive and took place in the early phases of software development. Conclusion: Systematic use of agile practices conformed, and was observed to take place in conjunction with the use of security practices. Security activities were most common in the requirement and implementation phases. In general, the activities taking place early in the life cycle were also considered most impactful. A discrepancy between the level of use and the perceived security impact of many security activities was observed. This prompts research and methodological development for better integration of security engineering activities into software development processes, methods, and tools.

Relative risk proneness in phases of software development: metric based approach with Cox model

The software suffers from confounding effect due to defects that occurs during its entire development process. Software failure occurs due to various reasons. One of the reasons can be removal of defects at a much later stage, even though it has been detected in early phases of software development. Defect prediction has emerged as an interesting area for researchers within stipulated time period. Prediction depends mainly on the modeling of these defects and while modeling the simplest parameter used by researchers is the software size. In this paper, we showed deployment of Cox model and investigated the significance on defect prediction during various phases of development. The parameter used here is the defect count in various phases. Next, we proposed and compared two strategies for effective overall risk prediction of the projects using another proposed metric “Relative Risk Proneness Probability”. This metric is used in phases as evaluation criteria for judging the cost effectiveness of the project.

A fuzzy rule-based generation algorithm in interval type-2 fuzzy logic system for fault prediction in the early phase of software development

ABSTRACTReliability, a measure of software, deals in total number of faults count up to a certain period of time. The present study aims at estimating the total number of software faults during the early phase of software life cycle. Such estimation helps in producing more reliable software as there may be a scope to take necessary corrective actions for improving the reliability within optimum time and cost by the software developers. The proposed interval type-2 fuzzy logic-based model considers reliability-relevant software metric and earlier project data as model inputs. Type-2 fuzzy sets have been used to reduce uncertainties in the vague linguistic values of the software metrics. A rule formation algorithm has been developed to overcome inconsistency in the consequent parts of large number of rules. Twenty-six software project data help to validate the model, and a comparison has been provided to analyse the proposed model’s performance.

Automatic test cases generation from business process models

Traditional test case generation approaches focus on design and implementation models while a large percentage of software errors are caused by the lack of understanding in the early phases. One of the most important models in the early phases of software development is business process model which closely resembles the real world and captures the requirements precisely. The aim of this paper is to present a model-based approach to automatically generate test cases from business process models. We first model business processes and convert them to state graphs. Then, the graphs are traversed and transformed to the input format of the “Spec explorer” tool that generates the test cases. Furthermore, we conduct a study to evaluate the impact of process characterizations on the performance of the proposed method.

Analyzing Machine Learning Techniques for Fault Prediction Using Web Applications

Web applications are indispensable in the software industry and continuously evolve either meeting a newer criteria and/or including new functionalities. However, despite assuring quality via testing, what hinders a straightforward development is the presence of defects. Several factors contribute to defects and are often minimized at high expense in terms of man-hours. Thus, detection of fault proneness in early phases of software development is important. Therefore, a fault prediction model for identifying fault-prone classes in a web application is highly desired. In this work, we compare 14 machine learning techniques to analyse the relationship between object oriented metrics and fault prediction in web applications. The study is carried out using various releases of Apache Click and Apache Rave datasets. En-route to the predictive analysis, the input basis set for each release is first optimized using filter based correlation feature selection (CFS) method. It is found that the LCOM3, WMC, NPM and DAM metrics are the most significant predictors. The statistical analysis of these metrics also finds good conformity with the CFS evaluation and affirms the role of these metrics in the defect prediction of web applications. The overall predictive ability of different fault prediction models is first ranked using Friedman technique and then statistically compared using Nemenyi post-hoc analysis. The results not only upholds the predictive capability of machine learning models for faulty classes using web applications, but also finds that ensemble algorithms are most appropriate for defect prediction in Apache datasets. Further, we also derive a consensus between the metrics selected by the CFS technique and the statistical analysis of the datasets.

Determining Interdependencies among NFRs in Agile Environment to Reduce Conflicts

NFRs play a very key role in the development of high quality software. As NFRs are quality attributes of the software system, so it must be dealt properly and with care in the early phases of software development otherwise it will lead the system to failure or dismissal of quality requirement at later phases. NFRs have a very unique ability to conflict and contradict among themselves. And the main reason behind this ability of NFRs is interdependency, which should be found and dealt properly in order to avoid requirement dismissal. Agile methodologies only focus on functional requirements but neglects non-functional requirements. In this work, we identified and highlighted all the possible dependencies between different NFRs in agile environment. In addition we also proposed a specific framework to cope up with the identified dependencies between NFRs.

Utility of CK Metrics in Predicting Size of Board-Based Software Games

Software size is one of the most important inputs of many software cost and effort estimation models. Early estimation of software plays an important role at the time of project inception. An accurate estimate of software size is, therefore, crucial for planning, managing, and controlling software development projects dealing with the development of software games. However, software size is unavailable during early phase of software development. This research determines the utility of CK (Chidamber and Kemerer) metrics, a well-known suite of object-oriented metrics, in estimating the size of software applications using the information from its UML (Unified Modeling Language) class diagram. This work focuses on a small subset dealing with board-based software games. Almost sixty games written using an object-oriented programming language are downloaded from open source repositories, analyzed and used to calibrate a regression-based size estimation model. Forward stepwise MLR (Multiple Linear Regression) is used for model fitting. The model thus obtained is assessed using a variety of accuracy measures such as MMRE (Mean Magnitude of Relative Error), Prediction of x(PRED(x)), MdMRE (Median of Relative Error) and validated using K-fold cross validation. The accuracy of this model is also compared with an existing model tailored for size estimation of board games. Based on a small subset of desktop games developed in various object-oriented languages, we obtained a model using CK metrics and forward stepwise multiple linear regression with reasonable estimation accuracy as indicated by the value of the coefficient of determination (R 2 = 0.756).Comparison results indicate that the existing size estimation model outperforms the model derived using CK metrics in terms of accuracy of prediction.

Incorporation of ISO 25010 with machine learning to develop a novel quality in use prediction system (QiUPS)

Guided by the eagerness to fulfill business objectives, quality assurance has become one of the highlighted topics in software engineering. With the rise of globalization and free markets, software users are becoming increasingly powerful with their ability to buy or reject computer software. While there is agreement over achieving quality, there is debate over the definition of quality. To illustrate, literature shows inconsistencies between a software development team definition to quality and a user definition to quality. Recently, there is a tendency amongst researchers to appreciate the need for studying quality from a user prospective. Following a systematic approach, this research attempts to develop a QiUPS, an expert system for predicting quality in use in early software development phases. With the scariness of research data in this field, the research generates a dataset from the documentation of Information, Communication, and E-learning Technology Centre software projects. The research methodology followed a comparative approach as it statistically compared four different classification algorithms (CAs) in terms of accuracy in classifying the research dataset. After that, the research results led the researchers to compare the performance of artificial neural networks with convolutional neural networks in three empirical experiments, which is rarely researched. Finally, the research incorporated the best CA with ISO 25010 in order to develop the novel QiUPS. The research results are consistent and contributive to this rarely researched area.

Software Size Estimation Using Activity Point

Software size is widely recognized as an important parameter for effort and cost estimation. Currently there are many methods for measuring software size including Source Line of Code (SLOC), Function Points (FP), Netherlands Software Metrics Users Association (NESMA), Common Software Measurement International Consortium (COSMIC), and Use Case Points (UCP). SLOC is physically counted after the software is developed. Other methods compute size from functional, technical, and/or environment aspects at early phase of software development. In this research, activity point approach is proposed to be another software size estimation method. Activity point is computed using activity diagram and adjusted with technical complexity factors (TCF), environment complexity factors (ECF), and people risk factors (PRF). An evaluation of the approach is present.

Early Test Effort Prediction using UML Diagrams

<p>Software Testing is essential for delivering quality software products. Accurate test effort estimation is an important part of project planning. Prediction of test effort at early phases of Software Developmen Life Cycle enables managers to plan ahead for the testing phase. This increases the chances of the project meeting its timeline while achieving required quality. Unified Modeling Language is a widely-used standard for representing Object Oriented Systems. Use Case and Class Diagrams are two of the most important models of the system created during early phases of software development. This work proposed that the initial test effort is predicted early using Use Case Diagram during the requirement stage and is refined during design stage when Class Diagrams are available. The predicted test efforts in both stages are functions of parameters derived from Use Case and Class Diagrams. Estimations can be revised when rest of the UML diagrams are created.</p>

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.