Assist Software Developers Research Articles

Practical Sustainable Software Development in Architectural Flexibility for Energy Efficiency Using the Extended Agile Framework

Many regular business operations are transforming into digital services, increasing advanced multi-platforms, rapid operational alignment, flexibility, and environmental impact through energy consumption, hardware waste, and technology investments. Flexible and sustainable system development models emphasizing energy efficiency can help innovate software development as digital servicing applications shift. This research is motivated by the need to improve energy consumption in early software design and development due to rising technological efficiency and sustainability demands. Although effective in iterative development and stakeholder engagement, traditional Agile methodologies often struggle with long-term sustainability and energy efficiency. Extended Agile, combining Agile, layered architecture, and aspect-oriented frameworks (ALAI), promises to improve system modularity, flexibility, maintainability, and sustainability. This study’s findings are not just theoretical, but also practically relevant, as they explore the energy efficiency of ALAI software development methodologies, using graduate admission information system services (GAISS) as an example. GAISS is a complex system that handles the entire process of graduate admissions, from application submission to final decision. The study quantifies the energy usage of a student-list webpage by analyzing Microsoft IIS server logs from February 2022 to May 2024. Directly applicable findings show that the GAISS based on the ALAI framework reduces energy consumption by 10.7914% compared to traditional Agile software developments. ALAI used 892.80 kWh versus Agile’s 1000.80 kWh during operations, saving energy. These findings demonstrate the benefits of integrating aspect-oriented frameworks and layering approaches into Agile methodologies, contributing to sustainable software development discourse. The study emphasizes the importance of energy-efficient frameworks such as ALAI to reduce software systems’ environmental impact and promote software development sustainability. The findings of this study, with their practical relevance, assist software developers and organizations in choosing software design and development methods that maximize operational efficiency and environmental sustainability.

The effect of augmented reality applied to learning process with different learning styles in structural engineering education

PurposeThe purpose of this study is to scrutinize the influence of individual learning styles on the effectiveness of augmented reality (AR)-based learning in structural engineering. There has been a lack of research examining the correlation between learning efficiency and learning style, particularly in the context of quantitatively assessing the efficacy of AR in structural engineering education.Design/methodology/approachUsing Kolb’s experiential learning theory (ELT), a model that emphasizes learning through experience, students from the construction management department are assigned four learning styles (converging, assimilating, diverging and accommodating). Performance data were gathered, appraised, and compared through the three dimensions from the Knowledge, Attitude and Practices (KAP) survey model across four categories of Kolb’s learning styles in both text-graph (TG)-based and AR-based learning settings.FindingsThe findings indicate that AR-based materials positively impact structural engineering education by enhancing overall learning performance more than TG-based materials. It is also found that the learning style has a profound influence on learning effectiveness, with AR technology markedly improving the information retrieval processes, particularly for converging and assimilating learners, then diverging learners, with a less significant impact on accommodating learners.Originality/valueThese results corroborate prior research analyzing learners' outcomes with hypermedia and informational learning systems. It was found that learners with an “abstract” approach (convergers and assimilators) outperform those with a “concrete” approach (divergers and accommodators). This research emphasizes the importance of considering learning styles before integrating technologies into civil engineering education, thereby assisting software developers and educational institutions in creating more effective teaching materials tailored to specific learning styles.

Software component selection methods and techniques: a systematic review

<p>Software component selection is critical in software engineering due to its vital role in reducing software development cost and time. This study analyzes software component selection research studies on methodologies, criteria, and multi-criteria decision-making (MCDM) techniques. The key study findings are: first, comprehensive standardized criteria for software component selection are lacking, with ambiguous terminology used in research. Second, current ad hoc selection processes need streamlining to reduce time, cost, and effort. Thus, an integrated approach is required to aid decision-makers. The review suggests developing automated tools or decision support systems combining multiple criteria decision methods to improve selection accuracy and efficiency. Standardized criteria catalogs can also assist software developers in the evaluation. The findings highlight that despite extensive academic research, component selection in practice remains sub-optimal. By informing future research and tool development, this review can benefit practitioners to systematically select the most appropriate software components meeting software requirements.</p>

A decision tree approach based on BOCR for minimizing criteria in requirements prioritization

<span>The requirements selection in the development of a software mostly requires a set of criteria. Determining the criteria used is often confusing because of the many criteria that must match with the characteristics of the project. This study introduces how to classify criteria based on benefits, opportunities, costs, risks (BOCR) to make the requirements prioritization process scalable. Project context characteristics and stakeholder perspectives are essential points discussed in this study because they are crucial in the requirements prioritization process. The criteria obtained from the literature review were followed by a survey to determine the importance of the criteria and their grouping in the BOCR using the decision tree method. There are 38 criteria and are grouped into four categories. There are two very significant criteria with a high level of importance, namely business value and stakeholder satisfaction. A decision tree based on BOCR can be used to classify the criteria for requirements prioritization. This research contributes to assisting software developers in finding and determining the criteria operated during the prioritization of requirements. Additionally, it is important to consider the project context and the collaboration the client and developer when prioritizing requirements.</span>

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.

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.

Maturity model for secure software testing

AbstractSecurity is an essential attribute of high‐quality software. However, effectively incorporating security practices into different phases of the software development life cycle (SDLC) remains challenging. Owing to less mature secure testing processes, organizations are prone to ineffective testing practices for defect detection, including severe security‐related failures. Thus, in this study, we present a maturity model for secure software testing (MMSST) to assist software development organizations in improving the secure testing of software applications. We conducted a multivocal literature review and identified 68 primary studies from the formal and gray literature. Then, based on the available evidence, 27 process areas were identified to develop the proposed MMSST. The MMSST includes five main categories: governance, contrive and design, execution, deployment and configuration, and mature. The MMSST was subsequently evaluated using case studies related to practical environments. Results demonstrate that the proposed MMSST is useful for estimating the maturity level of an organization with respect to the secure testing phase of the SDLC. The participants of the case studies also agreed that the proposed MMSST is useful in terms of structure, user satisfaction, and ease of use. We believe that the proposed MMSST can help organizations evaluate and improve software security testing practices. In addition, the proposed MMSST is expected to provide researchers and industry practitioners with an effective foundation for developing new secure testing approaches and tools.

Improving the Safety and Security of Software Systems by Mediating SAP Verification

Security and performance (SAP) are two critical NFRs that affect the successful completion of software projects. Organizations need to follow the practices that are vital to SAP verification. These practices must be incorporated into the software development process to identify SAP-related defects and avoid failures after deployment. This can only be achieved if organizations are fully aware of SAP verification activities and appropriately include them in the software development process. However, there is a lack of awareness of the factors that influence SAP verification, which makes it difficult for businesses to improve their verification efforts and ensure that the released software meets these requirements. To fill this gap, this research study aimed to identify the mediating factors (MFs) influencing SAP verification and the actions to promote them. Ten MFs and their corresponding actions were identified after thoroughly reviewing the existing literature. The mapping of MFs and their corresponding actions were initially evaluated with the help of a pilot study. Mathematical modeling was utilized to model these MFs and examine each MF’s unique effect on software SAP verification. In addition, two case studies with a small- and a medium-sized organization were used to better understand the function these MFs play in the process of SAP verification. The research findings suggested that MFs assist software development organizations in their efforts to integrate SAP verification procedures into their standard software systems. Further investigation is required to support the understanding of these MFs when building modern software systems.

On the evaluation of usability design guidelines for improving network monitoring tools interfaces

Network monitoring tools are vital to network administrators, helping them make decisions and accomplish their tasks. In general, those tools are developed with a focus on technical aspects not taking into account important usability principles. On the other hand, the Human–Computer Interaction community presents great potential for the improvement of interfaces in network management tools suggesting that usability guidelines can guide software developers during user interface design. The goal of this work is to evaluate how different usability design guidelines can assist software developers in elaborating network monitoring tools interfaces with improved usability, creating a better experience for network administrators. To do that, we engage in an experimental study, where 52 software developers prototyped user interfaces based on different scenarios and applied 12 guidelines for usability design in network monitoring tools. Through the quantitative and qualitative analysis as well as Fisher’s Exact Test, we demonstrate that the level of complexity of the scenarios for the creation of the prototypes had no significant effect on the acceptance of the guidelines. We conclude that the guidelines were used by most participants and are relevant to assist the software developers to create interfaces with a focus on usability in network monitoring tools.

CodeLabeller: A Web-Based Code Annotation Tool for Java Design Patterns and Summaries

With the rise of AI in SE, researchers have shown how AI can be applied to assist software developers in a wide variety of activities. However, it has not been accompanied by a complementary increase in labelled datasets, which is required in many supervised learning methods. Several studies have been using crowdsourcing platforms to collect labelled training data in recent years. However, research has shown that the quality of labelled data is unstable due to participant bias, knowledge variance, and task difficulty. Thus, we present CodeLabeller, a web-based tool that aims to provide a more efficient approach in handling the process of labelling Java source files at scale by improving the data collection process throughout, and improving the degree of reliability of responses by requiring each labeller to attach a confidence rating to each of their responses. We test CodeLabeller by constructing a corpus of over a thousand source files obtained from a large collection of opensource Java projects, and labelling each Java source file with their respective design patterns and summaries. Apart from assisting researchers to crowdsource a labelled dataset, the tool has practical applicability in software engineering education and assists in building expert ratings for software artefacts. This paper discusses the motivation behind the creation of CodeLabeller, the intended users, a tool demonstration and its UI, its implementation, benefits, and lastly, the evaluation through a user study and in-practice usage.

Systematic Literature Review on Security Risks and its Practices in Secure Software Development

Security is one of the most critical aspects of software quality. Software security refers to the process of creating and developing software that assures the integrity, confidentiality, and availability of its code, data, and services. Software development organizations treat security as an afterthought issue, and as a result, they continue to face security threats. Incorporating security at any level of the Software Development Life Cycle (SDLC) has become an urgent requirement. Several methodologies, strategies, and models have been proposed and developed to address software security, but only a few of them give reliable evidence for creating secure software applications. Software security issues, on the other hand, have not been adequately addressed, and integrating security procedures into the SDLC remains a challenge. The major purpose of this paper is to learn about software security risks and practices so that secure software development methods can be better designed. A systematic literature review (SLR) was performed to classify important studies to achieve this goal. Based on the inclusion, exclusion, and quality assessment criteria, a total of 121 studies were chosen. This study identified 145 security risks and 424 best practices that help software development organizations to manage the security in each phase of the SDLC. To pursue secure SDLC, this study prescribed different security activities, which should be followed in each phase of the SDLC. Successful integration of these activities minimizing effort, time, and budget while delivering secure software applications. The findings of this study assist software development organizations in improving the security level of their software products and also enhancing their security efficiency. This will raise the developer’s awareness of secure development practices as well.

A face recognition software framework based on principal component analysis.

Face recognition, as one of the major biometrics identification methods, has been applied in different fields involving economics, military, e-commerce, and security. Its touchless identification process and non-compulsory rule to users are irreplaceable by other approaches, such as iris recognition or fingerprint recognition. Among all face recognition techniques, principal component analysis (PCA), proposed in the earliest stage, still attracts researchers because of its property of reducing data dimensionality without losing important information. Nevertheless, establishing a PCA-based face recognition system is still time-consuming, since there are different problems that need to be considered in practical applications, such as illumination, facial expression, or shooting angle. Furthermore, it still costs a lot of effort for software developers to integrate toolkit implementations in applications. This paper provides a software framework for PCA-based face recognition aimed at assisting software developers to customize their applications efficiently. The framework describes the complete process of PCA-based face recognition, and in each step, multiple variations are offered for different requirements. Some of the variations in the same step can work collaboratively and some steps can be omitted in specific situations; thus, the total number of variations exceeds 150. The implementation of all approaches presented in the framework is provided.

Facilitating program comprehension with call graph multilevel hierarchical abstractions

Program comprehension is a fundamental prerequisite for software maintenance and evolution. In order to understand a software structure, developers often read its codebase or documentation—if available and not outdated. Both approaches are tedious, time-consuming, and inefficient. Recent methods and tools have emerged to facilitate program comprehension, such as static call graphs, which depict the structure of the software system as a directed graph. However, the usage of call graphs still faces two main challenges: (1) large call graphs can be difficult to understand, and (2) they are limited to a single level of granularity, such as function calls. In this paper, we introduce a coarsening technique to create multi-level, hierarchical representations of the call graph. Specifically, we propose a hierarchical clustering approach of the execution paths to visualize the call graph at different granularity levels and for different software units, including packages, classes, and functions. Our overarching goal is to assist software developers in understanding the software system from a high-level of abstraction to the low-level of implementation with the ability to focus on particular parts of the system individually. To validate our approach and tool support, we conducted a user study of 18 software engineers from more than 11 industries who carried out several tasks using our system and then answered a survey. The results demonstrate that our approach is feasible to automatically construct multi-level abstractions of the call graph and hierarchically cluster them into meaningful abstractions. A video demo of the tool is available at https://rakanalanazi.github.io/CodEx/.

RAPID: a knowledge-based assistant for designing web APIs

With the rise in initiatives such as software ecosystems and Internet of Things (IoT), developing web Application Programming Interfaces (web APIs) has become an increasingly common practice. One main concern in developing web APIs is that they expose back-end systems and data toward clients. This exposure threatens critical non-functional requirements, such as the security of back-end systems, the performance of provided services, and the privacy of communications with clients. Although dealing with non-functional requirements during software design has been long studied, there is still no framework to specifically assist software developers in addressing these requirements in web APIs. In this paper, we introduce Rational API Designer (RAPID), an open-source assistant that advises on designing non-functional requirements in the architecture of web APIs. We have equipped RAPID with a broad range of expert knowledge about API design, systematically collected and extracted from the literature. The API design knowledge has been encoded as a set of 156 rules using the Non-Functional Requirements (NFR) multi-valued logic, a formal framework commonly used to describe non-functional and functional requirements of software systems. RAPID uses the encoded knowledge in a stepwise inference procedure to arrive from a given requirement, to a set of design alternatives to a final recommendation for a given API design specification. Seven well-experienced software engineers have blindly evaluated the accuracy of RAPID’s consultations over seven different cases of web API design and on providing design guidelines for thirty design questions. The results of the evaluation show that RAPID’s recommendations meet acceptable standards of the majority of the evaluators 73.3% of the time. Moreover, analysis of the evaluators’ comments suggests that more than one-third of the unacceptable ratings (33.8%) given to RAPID’s answers are due to valid but incomplete design guidelines. We thus expect that the accuracy of the consultations will increase as RAPID’s knowledge of API design is extended and refined.

A maturity model for secure requirements engineering

Security is considered to be a critical software quality attribute. Tackling security at the requirements phase helps to avoid the need to rework secure software development issues. The aim of this paper is to develop a Requirements Engineering (RE) Security Maturity Model (RESMM) to assist software development organizations to better specify the requirements for secure software development. To achieve this objective, first, we conducted a systematic literature review (SLR) to identify the requirement practices for secure software development. Then we modified Sommerville's requirements engineering practices. We also conducted a questionnaire survey based on the identified security requirements practices. Next, the RESMM was built based on the results of the SLR, the modified Sommerville practices and feedback from the security practitioners. Finally, two case studies were conducted to assess RESMM. RESMM has 79 practices classified into 7 RE categories. The case study results show that RESMM has a clear structure and is easy to comprehend and use. In addition, the case study participants recommended that software organizations adopt RESMM. RESMM has the ability to identify the RE security maturity levels in software organizations. RESMM can also help software development organizations deliver secure software.

A Catalogue Supporting Software Sustainability Design

Like other communities, sustainability in and for software design is a grand research and development challenge. Current research focuses on eliciting the meanings of sustainability and on building approaches for its engineering and integration into the mainstream software development lifecycle. However, few concrete guidelines that software designers can apply effectively are available. A guideline aims to streamline the design processes according to a set of well-known research routines or sound industry practices. Such guidelines can help software developers in the elicitation of sustainability requirements and testing software against these requirements. This paper introduces a sustainability design catalogue (SSDC) comprising a series of guidelines. It aims to assist software developers and managers in eliciting sustainability requirements, and then in measuring and testing software sustainability. The catalogue is based on reviews of the current and past research on sustainability in software engineering, which are the grounds for the development of the catalogue. Four different case studies were analyzed using the Karlskrona manifesto principles on sustainability design. A pilot framework is also proposed that includes a set of sustainability goals, concepts and methods. It exemplifies how to apply and quantify sustainability.

Evaluating the Quality of UCP-Based Framework using CK Metrics

Software effort estimation is one of the most important concerns in the software industry. It has received much attention since the last 40 years to improve the accuracy of effort estimate at early stages of software development. Due to this reason, many software estimation models have been proposed such as COCOMO, ObjectMetrix, Use Case Points (UCP) and many more. However, some of the estimation methods were not designed for object-oriented technology that actively encourages reuse strategies. Therefore, due to the popularity of UCP model and the evolution of the object-oriented paradigm, a UCP-based framework and supporting program were developed to assist software developers in building good qualities of software effort estimation programs. This paper evaluates the quality of the UCP-based framework using CK Metrics. The results showed that by implementing the UCP-based framework, the quality of the UCP-based program has improved regarding the understandability, testability, maintainability, and reusability.

An Early Phase Software Project Risk Assessment Support Method for Emergent Software Organizations

Risk identification and assessment are amongst critical activities in software project management. However, identifying and assessing risks and uncertainties is a challenging process especially for emergent software organizations that lack resources. The research aims to introduce a method and a prototype tool to assist software development practitioners and teams with risk assessment processes. We have identified and put forward software project related risks from the literature. Then by conducting a survey to software practitioners of small organizations, we collected probability and impact of each risk factor opinions of 86 practitioners based on past projects. We developed a risk assessment method and a prototype tool initially based on data that accumulates further data as the tool. Along with a risk prioritisation and risk matrix, the method utilises fuzzy logic to provide the practitioners with predicted scores for potential failure types and aggregated risk score for the project. In order to validate the usability of the method and the tool, we have conducted a case study for the project risk assessment in a small software organization. The introduced method is partially successful at prediction of risks and estimating the probability of predefined failure modes.

Exploring software security approaches in software development lifecycle: A systematic mapping study

There is an increase use of security driven approaches to support software development activities, such as requirements, design and implementation. The objective of this paper is to identify the existing software security approaches used in the software development lifecycle (SDLC). In order to meet our goal, we conducted a systematic mapping study to identify the primary studies on the use of software security techniques in SDLC. In total, we selected and categorized 118 primary studies. After analyzing the selected studies, we identified 52 security approaches and we categorized them in to five main categories, namely, ‘secure requirements modeling’, ‘vulnerability identification, adaption and mitigation’, ‘software security focused process’, ‘extended UML-based secure modeling profiles’, ‘non UML-based secure modeling notations’. The results show that the most frequently used approaches are static analysis and dynamic analysis that provide security checks in the coding phase. In addition, our results show that many studies in this review considered security checks around the coding stage of software development. This work will assist software development organizations in better understanding the existing software security approaches used in the software development lifecycle. It can also provide researchers with a firm basis on which to develop new software security approaches.

Soft error resilience in Big Data kernels through modular analysis

The shrinking processor feature and operating voltages of processor circuits are making them increasingly vulnerable to soft faults, which calls for fault resilience techniques at both the software and hardware levels under the big data context. To assist software developers in writing fault-resilient big data applications, we propose the tool ErrorSight, which helps them to focus their efforts on code regions and data structures that are most vulnerable to soft errors, understand how numerical errors propagate through the program, and apply fault resilience techniques effectively. ErrorSight achieves this through efficient generation of error profiles leveraging the predictive power of the Boosted Regression Tree model. We use four big data kernels to illustrate the modular analysis mechanism of ErrorSight and show its usefulness in the development of numerical fault-resilience in Big Data.