Software Development Process Research Articles

Software Requirement Risk Prediction Using Enhanced Fuzzy Induction Models

The development of most modern software systems is accompanied by a significant level of uncertainty, which can be attributed to the unanticipated activities that may occur throughout the software development process. As these modern software systems become more complex and drawn out, escalating software project failure rates have become a critical concern. These unforeseeable uncertainties are known as software risks, and they emerge from many risk factors inherent to the numerous activities comprising the software development lifecycle (SDLC). Consequently, these software risks have resulted in massive revenue losses for software organizations. Hence, it is imperative to address these software risks, to curb future software system failures. The subjective risk assessment (SRM) method is regarded as a viable solution to software risk problems. However, it is inherently reliant on humans and, therefore, in certain situations, imprecise, due to its dependence on an expert’s knowledge and experience. In addition, the SRM does not allow repeatability, as expertise is not easily exchanged across the different units working on a software project. Developing intelligent modelling methods that may offer more unbiased, reproducible, and explainable decision-making assistance in risk management is crucial. Hence, this research proposes enhanced fuzzy induction models for software requirement risk prediction. Specifically, the fuzzy unordered rule induction algorithm (FURIA), and its enhanced variants based on nested subset selection dichotomies, are developed for software requirement risk prediction. The suggested fuzzy induction models are based on the use of effective rule-stretching methods for the prediction process. Additionally, the proposed FURIA method is enhanced through the introduction of nested subset selection dichotomy concepts into its prediction process. The prediction performances of the proposed models are evaluated using a benchmark dataset, and are then compared with existing machine learning (ML)-based and rule-based software risk prediction models. From the experimental results, it was observed that the FURIA performed comparably, in most cases, to the rule-based and ML-based models. However, the FURIA nested dichotomy variants were superior in performance to the conventional FURIA method, and rule-based and ML-based methods, with the least accuracy, area under the curve (AUC), and Mathew’s correlation coefficient (MCC), with values of approximately 98%.

Investigating the Point of View of Project Management Practitioners on Technical Debt - A Study on Stack Exchange

Context: Technical debt (TD) can bring short-term benefits to software projects, but its presence is associated with issues such as decreasing product quality. Recent literature has proposed various approaches for identifying and managing TD, but most of them focus on the software developers’ point of view. Little is known about how project management practitioners perceive and manage TD items. Goal: This work aims to investigate how project management practitioners discuss and experience TD. Method: To achieve this goal, our work mines, curates, and selects a total of 108 TD-related discussions on the Stack Exchange Project Management (SEPM) Q&A site. These discussions amount to 547 posts and 882 text comments on the subject. We analyze this data set quantitatively and qualitatively, using open coding to derive TD types, indicators, and management practices. Results: We identified 74 indicators used for recognizing debt items and 126 TD management practices. The types of debt most discussed at SEPM are process and people debts. This contradicts studies done with developers where code and design debts are most discussed. Conclusion: The perspective considered by project management practitioners to analyze the TD phenomenon is different from the one considered by other roles in the software development process. Our work organizes the identified TD indicators and management practices into a Sankey diagram, which may assist TD management practitioners and serve as guidance for future research on the subject.

Automatic software bug prediction using adaptive golden eagle optimizer with deep learning

In the software maintenance and development process, the software bug detection is an essential problem because it related with the complete software successes. So, the earlier software bug detection is essential to enhance the software efficiency, reliability, software quality and software cost. Moreover, the efficient software bug prediction is a critical as well as challenging operation. Hence, the efficient software bug prediction model is developed in this article. To achieve this objective, optimized long short-term memory is developed. The important stages of the proposed model is preprocessing, feature selection and bug detection. At first the input bug dataset is preprocessed. In preprocessing, the duplicate data instances are removed from the dataset. After the preprocessing, the feature selection is done by Adaptive Golden Eagle Optimizer (AGEO). Here the traditional GEO algorithm is altered by means of opposition-based learning (OBL). Finally, the proposed approach utilizes a long short-term memory (LSTM) based recurrent neural network (RNN) for bug prediction. Long Short-Term Memory (LSTM) network is a type of recurrent neural network. The promise and NASA dataset are considered as the input for bug prediction. the performance of proposed approach is analysed based on various metrics namely, accuracy, F- measure, G-measure and Matthews Correlation Coefficient (MCC).

Knowledge Management in Multimedia Communication Using Software Agents

This paper presents the problem of knowledge management related to software agents and agent systems (i.e. systems composed of communicating and cooperating software agents). The author presents basic theoretical issues, but the main focus is on the areas of application of software agents in multimedia communication - both existing and prospective applications. Particular attention has been paid to the applications of software agents for: supporting customer service processes through the Contact Centre system; supporting the distance learning system; creating virtual assistants in the form of conversation bots; searching for information in the Semantic Web, and assisting in setting up a video conference call. Software agents are often referred to as 'intelligent' - due to their intelligent behaviour. At their core, they involve: perception, reasoning, learning, communication and operation in complex environments, using all multimedia techniques and procedures. Software agents and agent systems, as presented in this article, represent a new approach to the analysis, design and implementation of complex (usually decentralised and distributed) computer systems, offering a whole range of concepts, techniques and tools to significantly improve the software development process. The ability of software agents to make autonomous decisions have been a subject of considerations. Among other things, they are based on the example of cognitive sciences, which deal with modelling real processes of information processing in humans and building programmes that imitate these processes. Research on the common understanding of shared knowledge and knowledge management in agent-based systems focuses on ontologies, understood as a description of the relationship between the way knowledge is represented and the concept represented by that knowledge. In contrast, research on knowledge sharing has focused on communication languages and their associated - interaction protocol and message transport protocol.

Software Engineering: New Methodologies, Tools, and Best Practices in Software Development

Software engineering is a dynamic field that is always evolving to meet the demands of difficult software development projects. This journal article investigates contemporary software engineering methodologies, tools, and best practices in order to enhance the efficiency, quality, and dependability of software development processes. We discuss the most recent advancements in quality assurance, DevOps, agile software development, and automated testing. We also look at the role that cooperation, communication, and project management have in efficient software engineering methods. By highlighting these advances, this article aims to promote the delivery of high-quality software products and improve software development processes.

Enhanced Approach for Bug Severity Prediction: Experimentation and Scope for Improvements

Software development is an iterative process, where developers create, test, and refine their code until it is ready for release. Along the way, bugs and issues are inevitable. A bug can be any error identified in requirement specification, design or implementation of any project. These bugs need to be categorized and assigned to developers to be resolved. the number of bugs generated in any large scale project are vast in number. These bugs can have significant or no impact on the project depending on the type of bug. The aim of this study is to develop a deep learning-based bug severity prediction model that can accurately predict the severity levels of software bugs. This study aims to address the limitations of the current manual bug severity assessment process and provide an automated solution using various classifiers e.g. Naïve Bayes, Logistic regression, KNN and Support vector machine along with Mutual information as feature selection method, that can assist software development teams in giving severity code to bugs effectively. It seeks to improve the overall software development process by reducing the time and effort required for bug resolution and enhancing the quality and reliability of software.

On the validity of retrospective predictive performance evaluation procedures in just-in-time software defect prediction

Just-In-Time Software Defect Prediction (JIT-SDP) is concerned with predicting whether software changes are defect-inducing or clean. It operates in scenarios where labels of software changes arrive over time with delay, which in part corresponds to the time we wait to label software changes as clean (waiting time). However, clean labels decided based on waiting time may be different from the true labels of software changes, i.e., there may be label noise. This typically overlooked issue has recently been shown to affect the validity of continuous performance evaluation procedures used to monitor the predictive performance of JIT-SDP models during the software development process. It is still unknown whether this issue could potentially also affect evaluation procedures that rely on retrospective collection of software changes such as those adopted in JIT-SDP research studies, affecting the validity of the conclusions of a large body of existing work. We conduct the first investigation of the extent with which the choice of waiting time and its corresponding label noise would affect the validity of retrospective performance evaluation procedures. Based on 13 GitHub projects, we found that the choice of waiting time did not have a significant impact on the validity and that even small waiting times resulted in high validity. Therefore, (1) the estimated predictive performances in JIT-SDP studies are likely reliable in view of different waiting times, and (2) future studies can make use of not only larger (5k+ software changes), but also smaller (1k software changes) projects for evaluating performance of JIT-SDP models.

Building Trust in AI -A Simplified Guide to Ensure Software Quality

In recent years, Artificial Intelligence (AI) has emerged as an innovative technology in a variety of areas, including software development. The demand for high-quality software has grown in tandem with the increasing complexity of applications and user expectations.AI-driven approaches are revolutionizing traditional software development methodologies by automating and augmenting various stages of the development life cycle, leading to improved efficiency, reduced costs, and enhanced software quality. This research explores the crucial role of AI in developing high-quality software and its impact on the software development process. Firstly, it discusses how AI technologies like machine learning, natural language processing, and deep learning can facilitate requirements gathering, analysis, and validation, leading to better understanding and refinement of user needs. Next, it delves into the significance of AI in automating the coding process, such as generating code snippets, fixing bugs, and optimizing performance, thus accelerating development and reducing human errors. Moreover, the paper highlights the pivotal role of AI in software testing and quality assurance. AI-powered testing tools can execute comprehensive tests more efficiently, detect defects, and predict potential software vulnerabilities, thereby enhancing the overall reliability and robustness of the software product. Additionally, AI techniques can enable real-time monitoring and analytics, allowing developers to identify and address issues promptly during the software's operational phase. Furthermore, the paper addresses the ethical considerations and challenges associated with AI in software development, including bias in training data, interpretability of AI-driven decisions, and potential job displacement for software developers.

An Innovative Approach for Predicting Software Defects by Handling Class Imbalance Problem

From last decade unbalanced data has gained attention as a major challenge for enhancing software quality and reliability. Due to evolution in advanced software development tools and processes, today’s developed software product is much larger and complicated in nature. The software business faces a major issue in maintaining software performance and efficiency as well as cost of handling software issues after deployment of software product. The effectiveness of defect prediction model has been hampered by unbalanced data in terms of data analysis, biased result, model accuracy and decision making. Predicting defects before they affect your software product is one way to cut costs required to maintain software quality. In this study we are proposing model using two level approach for class imbalance problem which will enhance accuracy of prediction model. In the first level, model will balance predictive class at data level by applying sampling method. Second level we will use Random Forest machine learning approach which will create strong classifier for software defect. Hence, we can enhance software defect prediction model accuracy by handling class imbalance issue at data and algorithm level.

Predicting software defects with swarm-intelligence-based machine learning algorithm for improved process quality

The quality and effectiveness of software systems may be significantly impacted by Software Defects (SD). Therefore, enhancing process quality is essential for controlling and minimizing the incidence of faults. Implementing reliable Software Development (SDe) processes and best practices is one way to do this information. SD, commonly referred to as software bugs or software mistakes, are defects or errors that occur in computer programs and cause them to act up or create unintended outcomes. These vulnerabilities may appear for several causes, including programming mistakes, poor design choices, or issues with the SDe cycle. The prediction of software problems based on Machine Learning (ML) using an Enhanced Artificial Neural Network (E-ANN) is implemented in this study to increase software quality and testing effectiveness. Particle swarm optimization and grey wolf optimization, these two algorithms named grey wolf swarm optimization algorithm (GWSA), are combined to recognize the corresponding compensation of the methods following the respective benefits and drawbacks. The hybrid algorithm-based model to the conventional hyperparameter optimization strategy and a single swarm intelligence algorithm's investigation of investigational consequences from six data sets shows that the hybrid algorithm-based model has high and enhanced indicators. Processed by the autoencoder, the model's performance has also improved.

A survey on secure metadata of agile software development process using blockchain technology

AbstractScrum is an important and essential technique for developing software. Scrum framework is a project management technique that can emphasize software development teamwork. If you are starting, consider scrum as a method for accomplishing tasks as a team in manageable chunks simultaneously, with ongoing experimentation and feedback loops to learn and improve as you go. Scrum enables individuals and groups to collaboratively and gradually generate value. Being an agile framework, scrum gives people and teams the perfect structure to fit into their workflows while still including the best practices to cater to their requirements. There are some important considerations for security in the agile software development process such as threat modeling, secure coding practices, continuous security testing, authentication, and authorization. In this work, we reviewed various scrum developing techniques to find out the research gaps. This article consider the scrum technique with blockchain technologies for review because it is preferred by most of the software industries.

Activities and Practices of Requirements Engineering in Agile Software Environments

Requirements are one of the important factors for software success. However, Requirements Engineering (RE) activities, in the Waterfall process model, are done sequentially in the analysis phase, which makes it difficult when RE practitioners think and reason about them in Agile Software Development (ASD) process model. RE practitioners need to find the established RE activities conventions in the ASD process model, especially with an increase of software companies, which transform to the ASD process model, in order to foster their transition to the new model. The objective of this study is to provide RE activities in ASD to allow RE practitioners to utilize the appropriate activity for specific ASD methodology. RE activities in ASD are handled repetitively and on a small scale, which makes them embedded in the development life cycle. This paper focuses on highlighting them in different ASD methodologies and discusses the practices that resolve the traditional Waterfall model issues. Although the ASD model has resolved some traditional RE issues, it introduced other issues, such as a consequence of trying to achieve an adequate balance between agility and stability. In addition, there is a lack of practices that target non-functional requirements.

An Exploratory Study Gathering Security Requirements for the Software Development Process

Software development stands out as one of the most rapidly expanding markets due to its pivotal role in crafting applications across diverse sectors like healthcare, transportation, and finance. Nevertheless, the sphere of cybersecurity has also undergone substantial growth, underscoring the escalating significance of software security. Despite the existence of different secure development frameworks, the persistence of vulnerabilities or software errors remains, providing potential exploitation opportunities for malicious actors. One pivotal contributor to subpar security quality within software lies in the neglect of cybersecurity requirements during the initial phases of software development. In this context, the focal aim of this study is to analyze the importance of integrating security modeling by software developers into the elicitation processes facilitated through the utilization of abuse stories. To this end, the study endeavors to introduce a comprehensive and generic model for a secure software development process. This model inherently encompasses critical elements such as new technologies, human factors, and the management of security for the formulation of abuse stories and their integration within Agile methodological processes.

Artificial Intelligence-Based Tools in Software Development Processes: Application of ChatGPT

Software development processes are continuously evolving and rapidly transforming alongside the rapid changes in technology. Recently, innovations in the field of Artificial Intelligence (AI) have led to significant changes in software development practices. AI tools can greatly enhance traditional software development processes by offering developers the ability to create projects more intelligently, swiftly, and effectively. These tools can be employed in various tasks, such as code generation, test automation, error analysis, and performance improvements. Particularly, ChatGPT, an AI-based language model that has had a profound impact on almost every domain, can assist software developers in writing code faster and in a more natural language manner. In this research article, essential information about the usage of ChatGPT in the software development process is presented. To evaluate some capabilities of ChatGPT in the software development context, applications were performed on a software project. For this purpose, a software development process was constructed based on the responses provided by ChatGPT. Various questions related to software development processes were formulated, and the responses generated by GPT were evaluated. The obtained results indicated that ChatGPT exhibited excellent performance in the software development process. Based on these findings, it was observed that AI-based models like ChatGPT could be effectively utilized as assisting tools in software development processes, accelerating traditional workflows. Furthermore, AI-based tools can automate testing processes, enhancing software quality while saving time and effort.

Automatic Software Bug Prediction Using Adaptive Artificial Jelly Optimization With Long Short-Term Memory

AbstractIn the software maintenance and development process, software bug detection is an essential problem because it is related to complete software success. It is recommended to begin anticipating defects at the early stages of creation rather than during the assessment process due to the high expense of fixing the found bugs. The early stage software bug detection is used to enhance software efficiency, reliability, and software quality. Nevertheless, creating a reliable bug-forecasting system is a difficult challenge. Therefore, in this paper, an efficient, software bug forecast is developed. The presented technique consists of three stages namely, pre-processing, feature selection, and bug prediction. At first, the input datasets are pre-processed to eliminate the identical data from the dataset. After the pre-processing, the important features are selected using an adaptive artificial jelly optimization algorithm (A2JO) to eliminate the possibility of overfitting and reduce the complexity. Finally, the selected features are given to the long short-term memory (LSTM) classifier to predict whether the given data is defective or non-defective. In this paper, investigations are shown on visibly obtainable bug prediction datasets namely, promise and NASA which is a repository for most open-source software. The efficiency of the presented approach is discussed based on various metrics namely, accuracy, F- measure, G-measure, and Matthews Correlation Coefficient (MCC). The experimental result shows our proposed method achieved the extreme accuracy of 93.41% for the Promise dataset and 92.8% for the NASA dataset.

ACCELERATION OF LEARNING MANAGEMENT SYSTEM APPLICATION DEVELOPMENT IN THE EDUCATION SECTOR USING THE LOW CODE CONCEPT ON MICROGEN

The background of this research is to speed up application development which tends to take a long time. To respond this, researchers apply the concept of "Low-Code" referring to a software development approach by speeding up the manufacturing process by reducing the amount of code that needs to be written manually to be automated using the microgen platform. This research was tested on a case study of the development of a Learning Management System, making it faster and more efficient. System development used in this study is System Development Life Cycle (SDLC) method, which is a software development process model that is carried out in stages according to the existing mechanism. The backend created for this Learning Management System, uses the Microgen generator backend platform to automate the creation of the GraphQL API, and the database which is then consumed by the frontend which is the interface for the Learning Management System. This research resulted in a better understanding of how using automation tools like Microgen able to speed up the learning management system web development process. The research model with development (R&D) applied in this study uses a systematic model that requires each process to be fulfilled sequentially starting from the first stage to the final stage to produce a product and determine feasibility through product validation being developed. By adopting this automation approach, the previously time-consuming time required to generate the backend can be significantly reduced. Thus, the result is greater efficiency in Web Learning Management System development, savings in human resources, and better opportunities to respond to changing market or user needs.

Operationalising AI ethics through the agile software development lifecycle: a case study of AI-enabled mobile health applications

AbstractAlthough numerous ethical principles and guidelines have been proposed to guide the development of artificial intelligence (AI) systems, it has proven difficult to translate these principles into actionable practices beyond mere adherence to ethical ideas. This is particularly challenging in the context of AI systems for healthcare, which requires balancing the potential benefits of the solution against the risks to patients and the wider community, including minorities and underserved populations. To address this challenge, we propose a shift from one-size-fits-all ethical principles to contextualized case-based ethical frameworks. This study uses an AI-enabled mHealth application as a case study. Our framework is built on existing ethical guidelines and principles, including the AI4People framework, the EU High-Level Expert Group on trustworthy AI, and wider human rights considerations. Additionally, we incorporate relational perspectives to address human value concerns and moral tensions between individual rights and public health. Our approach is based on ”ethics by design,” where ethical principles are integrated throughout the entire AI development pipeline, ensuring that ethical considerations are not an afterthought but implemented from the beginning. For our case study, we identified 7 ethical principles: fairness, agility, precision, safeguarding humanity, respect for others, trust and accountability, and robustness and reproducibility. We believe that the best way to mitigate and address ethical consequences is by implementing ethical principles in the software development processes that developers commonly use. Finally, we provide examples of how our case-based framework can be applied in practice, using examples of AI-driven mobile applications in healthcare.

Machine Learning Operations (MLOps): Challenges and Strategies

Machine Learning Operations (MLOps) is a critical discipline that aims to streamline and enhance the end-to-end machine learning (ML) lifecycle, encompassing development, deployment, monitoring, and maintenance. As organizations increasingly adopt machine learning models to derive actionable insights and automate decision-making, MLOps becomes indispensable for ensuring efficiency, scalability, and reliability in ML workflows. This abstract explores the challenges encountered in implementing MLOps and presents strategies to overcome these hurdles.The challenges in MLOps can be categorized into technical, organizational, and cultural aspects. Technical challenges include model versioning, reproducibility, and ensuring consistent performance across diverse environments. Organizational challenges involve collaboration between cross-functional teams, managing diverse tools and frameworks, and integrating ML workflows with existing software development processes. Cultural challenges encompass resistance to change, skill gaps, and the need for a shared understanding of ML concepts among stakeholders.To address these challenges, a multifaceted strategy is proposed. Implementing robust version control systems and containerization techniques can enhance model reproducibility and deployment consistency. Cross-functional collaboration can be fostered through the establishment of dedicated MLOps teams, emphasizing communication and knowledge sharing. The integration of MLOps into existing DevOps practices can streamline workflows and mitigate organizational silos.Furthermore, the adoption of automated testing, continuous integration, and continuous deployment practices specific to ML can bolster the reliability of ML systems. Education and upskilling programs can bridge skill gaps, while promoting a culture of continuous learning and adaptability. Open-source MLOps tools and frameworks contribute to standardization and interoperability, facilitating smoother integration into diverse ecosystems.
 
 In conclusion, the successful implementation of MLOps is crucial for organizations seeking to harness the full potential of machine learning. By addressing technical, organizational, and cultural challenges through a comprehensive strategy, businesses can establish resilient and efficient MLOps pipelines, paving the way for sustainable and scalable deployment of machine learning models.

Requirement Elicitation Modeling Using Knowledge Acquisition in Automated Specification Method

Errors often occur during the requirements elicitation stage, causing failure of the software development process as a whole, so that the built system cannot be used optimally; these data are obtained from survey data from several large companies involved in technology development. To overcome this problem, this study tries to apply the elicitation requirements using the KAOS method in the case study of the SMM reseller ordering system to obtain system requirements that are in accordance with the goals and objectives of each existing stakeholder. Based on the elicitation of system requirements, functional requirements are generated that include automatic orders, automatic payments, manage product sales, manage orders, manage payment methods, manage problem orders, manage customer data, manage company information, automatic email notifications, and sales statistics information. The results of this study are a table of functional requirements that have been declared valid and in accordance with the goals and requirements of each stakeholder after evaluating and validating the results for each stakeholder involved.

Python API Misuse Mining and Classification Based on Hybrid Analysis and Attention Mechanism

APIs play a crucial role in contemporary software development, streamlining implementation and maintenance processes. However, improper API usage can result in significant issues such as unexpected outcomes, security vulnerabilities and system crashes. To detect API misuses, current methods primarily rely on comparing established API usage patterns with target points for automated detection, mainly based on pre-validated datasets. Nonetheless, there is a scarcity of publicly available datasets on API misuses and their corresponding fixes, which hinders data-driven research. Moreover, most existing techniques concentrate on statically typed languages, such as Java and C, with only a few addressing dynamic languages like Python effectively, due to difficulties in handling dynamic features. Therefore, it is essential to identify Python API misuses and their fixes automatically and promptly. In this paper, we introduce HatPAM, a Hybrid Analysis and Attention-based Python API-Misuse Miner, which (a) provides a method for automatically mining true-positive commits related to Python API-misuse fixes from GitHub and (b) presents the subsequent processing for classifying Python API misuses in true-positive cases. Particularly, HatPAM applies hybrid static analysis and introduces a structure-based attention mechanism to examine syntax, semantics and structural features in Python code context, and considers the consistency between code and developers’ natural intent to significantly reduce false-positive cases. Evaluation on six popular Python projects reveals that HatPAM outperforms various state-of-the-art baselines, achieving up to 92.2% Precision, 86.7% Recall and 89.3% F1-score, indicating its capability to identify and classify Python API-misuse commits.