Software Maintainability Research Articles

An Exploratory Study on Code Smells during Code Review in OSS Projects: A Case Study on OpenStack and WikiMedia

Objective: Open-source software (OSS) has become an important choice for developing software applications, and its usage has exponentially increased in recent years. Although many OSS systems have shown high reliability in terms of their functionality, they often exhibit several quality issues. Since most developers focus primarily on meeting clients’ functional requirements within the appropriate deadlines, the outcome suffers from poor design and implementation practices. This issue can also manifest as software code smells, resulting in a variety of quality issues such as software maintainability, comprehensibility, and extensibility. Generally speaking, OSS developers use code reviews during their software development to discover flaws or bugs in the updated code before it is merged with the code base. Nevertheless, despite the harmful impacts of code smells on software projects, the extent to which developers do consider them in the code review process is unclear in practice. Methods: To better understand the code review process in OSS projects, we gathered the comments of code reviewers who specified where developers should fix code smells in two OSS projects, OpenStack and WikiMedia, between 2011 and 2015. Results: Our findings indicate that most code reviewers do not pay much attention to code smells. Only a few code reviewers have attempted to motivate developers to improve their source code quality in general. The results also show that there is an increasing tendency to provide advice concerning code smells corrections over time. Conclusion: We believe that this study's findings will encourage developers to use new software engineering practices, such as refactoring, to reduce code smells when developing OSS.

A literature review for measuring maintainability of code clone

Software organizations face constant pressure due to stakeholder requirements and the increasing complexity of software systems. This complexity, combined with defects in code quality and failures, can pose risks to software systems. To ensure code is understood before maintenance, developers must spend over 60% of their time modifying and improving code quality, which is costly. This study examines the impact of code refactoring activities on software maintainability and quality by reviewing relevant research and explaining key terms. The research finds that refactoring activities can enhance specific quality characteristics, including maintainability, understandability, and testability. The study also identifies important factors that should be considered when developing refactoring tools. Refactoring enables code improvement without altering program behavior and can be applied multiple times to source code.

Prototype Development of Risk Mitigation for Software Anti-Ageing System

Constance computer program changes during software maintenance cause program structure and its execution to degrade which in the long run reduce the quality of the program, driving to the rise of software ageing. Change analysis is essential to assess and oversee the effect of changes to handle ageing issue. However, the evaluation of risks is still vague. There are also insufficient tools for change analysis amid software maintenance for ensuring anti-ageing. This motivates the study to propose risk mitigation process as a method to evaluate the risks from software change and construct a prototype as a platform to aid change analysis phase during software maintenance. The prototype aims to foresee and minimize chances of risks from software changes that lead to software ageing. This paper discusses on the development of a prototype named Risk Mitigation for Software Anti-Ageing System that is designed and developed based on software development lifecycle methodology to establish successful development and implementation of the system. The discoveries from this study offer assistance for software maintainers to conduct risk assessment during change analysis in software maintenance via the digital risk mitigation process to ensure software anti-ageing.

Assessing the Impact of Microservices Architecture on Software Maintainability and Scalability

This evaluation delves into the influence of Microservices Architecture (MSA) on crucial factors like software maintainability and scalability, which are vital in today's software development. Exploring MSA's features and benefits reveals how it streamlines bug tracking, improves system comprehension, increases testability, enables independent scaling of services, and optimizes resource utilization. The assessment also identifies potential obstacles, including distribution challenges, communication overhead, network delays, and data consistency. Renowned organizations like Amazon and Netflix have provided real-life scenarios with significant evidence of MSA's practicality and limitations. Though MSA's importance in building durable, scalable systems is underlined, the evaluation also stresses the need for solid design principles, practical management approaches, and constant refinement of procedures.

Refactoring with domain-driven design in an industrial context

ContextSoftware developers need to constantly work on evolving the structure and the stability of the code due to changing business needs of the product. There are various refactoring approaches in industry which promise improvements over source code composition and maintainability.ObjectiveIn our research, we want to improve the maintainability of an existing system through refactoring using Domain-Driven Design (DDD) as a software design approach. We also aim for providing empirical evidence on its effect on maintainability and the challenges as perceived by developers.MethodIn this study, we applied the action research methodology, which facilitates close academia-industry collaboration and regular presence in the studied product. We utilized focus groups to discover problems of the existing system with a qualitative approach. We reviewed the subject codebase to construct our own expert opinion as well and identified problems in the codebase and matched them with the ones raised by engineers in the team. We refactored the existing software system according to DDD principles. To measure the effects of our actions, we utilized Technology Acceptance Model (mTAM) questionnaire, and also semi-structured interviews with the development team for data collection, and card sorting methodology for qualitative analysis. For minimizing bias that might affect our results with the existing software engineers in the team, we extended our measurement with three new joiner software engineers in the team through the think aloud protocol.ResultsWe have identified that engineers mostly gave positive answers to our interview questions, which are mapped to software maintainability metrics defined by ISO/IEC 25010. Our DDD refactoring scored 85 in PU and 83 in PEU, leading to an overall mTAM score of 84. This means acceptable on the acceptability scale, B on the grade scale, and good on the adjective rating scale.ConclusionOur research led us to conclude that a powerful design approach, like DDD, is an effective tool for restructuring and resolving software issues in this situation. It offers standardization to the software and the refactoring efforts. We realized that DDD entails a certain degree of complexity and cognitive load, which is a barrier for software engineers, but they are aware of its benefits.

A METRICS -BASED MODEL FOR ESTIMATING THE MAINTENANCE EFFORT OF PYTHON SOFTWARE

Software project management includes a substantial area for estimating software maintenance effort. Estimation of software maintenance effort improves the overall performance and efficiency of software. The Constructive Cost Model (COCOMO) and other effort estimation models are mentioned in literature but are inappropriate for Python programming language. This research aimed to modify the Constructive Cost Model (COCOMO II) by considering a range of Python maintenance effort influencing factors to get estimations and incorporated size and complexity metrics to estimate maintenance effort. A within-subjects experimental design was adopted and an experiment questionnaire was administered to forty subjects aiming to rate the maintainability of twenty Python programs. Data collected from the experiment questionnaire was analyzed using descriptive statistics. Metric values were collected using a developed metric tool. The subject ratings on software maintainability were correlated with the developed model’s maintenance effort, a strong correlation of 0.610 was reported meaning that the model is valid.

ON APPLICATION OF FRAME-BASED APPROACH FOR INFORMATION SYSTEMS DEVELOPMENT

The work is devoted to specific of frame-based approach application for information systems development. Three-layered generator provided to make the process of multi-layered infor-mation systems development more effective and robust. The results of its application in the context of building more flexible and robust, testable and maintainable software are also discussed.

Analysis of Hybridized Techniques with Class Imbalance Learning for Predicting Software Maintainability

Software maintainability is a vital concern of organizations that develop and maintain large software products. The models that assess the maintainability of software systems at initial development stages play a significant role. In the Software Maintainability Prediction (SMP), a prevalent issue that needs to be taken care of is imbalanced data problem. For SMP, imbalanced data problem arises when the software classes that require high maintenance effort are less in number than classes that require low maintenance effort. In this paper, we dealt with the imbalanced data problem by the data resampling. With the imbalanced data, efficient machine learning algorithms are unable to predict the data points of both classes competently. Therefore, we examine the effectiveness of hybridized (HYB) techniques. The HYB techniques aid in finding an optimal solution for a problem by judging the goodness of multiple solutions. As per the results of the study, Adaptive synthetic minority oversampling technique (Adasyn) and Safe level synthetic minority oversampling technique (SafeSMOTE) are the best techniques of imbalanced data. Also, among the investigated HYB techniques, Fuzzy LogitBoost (GFS-LB) and Particle Swarm Optimization with Linear Discriminant Analysis (PSOLDA) emerged as the best techniques to predict maintainability.

Adding Chatbots to Web Applications: Using ASP.NET Core and Angular

The integration of chatbots into web applications has become a prominent trend in enhancing user experience, streamlining processes, and providing immediate customer support. This paper explores the development of chatbots within web applications using ASP.NET Core and Angular, two powerful frameworks for building scalable and maintainable software solutions. By leveraging the strengths of ASP.NET Core for backend services and Angular for the frontend, developers can create sophisticated chatbots that seamlessly interact with users in real time. This paper outlines the architectural design, implementation strategies, and key considerations for adding chatbots to web applications, including natural language processing (NLP) capabilities, user interface design, and deployment best practices. The discussion extends to integrating third-party APIs, handling conversational flows, and ensuring scalability and security in production environments. Through practical examples and case studies, this paper demonstrates how to build a chatbot that not only meets functional requirements but also provides a seamless user experience. The paper concludes with insights into future trends in chatbot development, including AI-driven enhancements and the growing importance of voice-based interactions in web applications.

Predicting Software Cohesion Metrics with Machine Learning Techniques

The cohesion value is one of the important factors used to evaluate software maintainability. However, measuring the cohesion value is a relatively difficult issue when tracing the source code manually. Although there are many static code analysis tools, not every tool measures every metric. The user should apply different tools for different metrics. In this study, besides the use of these tools, we predicted the cohesion values (LCOM2, TCC, LCC, and LSCC) with machine learning techniques (KNN, REPTree, multi-layer perceptron, linear regression (LR), support vector machine, and random forest (RF)) to solve them alternatively. We created two datasets utilizing two different open-source software projects. According to the obtained results, for the LCOM2 and TCC metrics, the KNN algorithm provided the best results, and for LCC and LSCC metrics, the REPTree algorithm was the best. However, out of all the metrics, RF, REPTree, and KNN had close performances with each other, and therefore any of the RF, REPTree, and KNN techniques can be used for software cohesion metric prediction.

A Hyper-parameter Tuning based Novel Model for Prediction of Software Maintainability

Software maintainability is regarded as one of the most important characteristics of any software system. In today's digital world, the expanding significance of software maintenance is motivating the development of efficient software maintainability prediction (SMP) models using statistical and machine learning methods. This study proposes a hyper-parameter optimizable Software Maintainability Prediction (HPOSMP) model using the hybridized approach of data balancing and hyper-parameter optimization of Machine Learning (ML) approach using software maintainability datasets. The training dataset has been created with object-oriented software namely UIMS and QUES. To balance the dataset, Synthetic Minority Oversampling Technique (SMOTE) technology has been adopted. Further, Decision Tree, Gaussian Naïve Bayes, K-Nearest neighbour, Logistic Regression, and Support Vector Machine are adopted as Machine Learning and Statistical Regression Techniques for training of software maintainability dataset. Results demonstrate that the proposed HPOSMP model gives better performance as compared to the base SMP models.

Surface Realization Architecture for Low-resourced African Languages

There has been growing interest in building surface realization systems to support the automatic generation of text in African languages. Such tools focus on converting abstract representations of meaning to a text. Since African languages are low-resourced, economical use of resources and general maintainability are key considerations. However, there is no existing surface realizer architecture that possesses most of the maintainability characteristics (e.g., modularity, reusability, and analyzability) that will lead to maintainable software that can be used for the languages. Moreover, there is no consensus surface realization architecture created for other languages that can be adapted for the languages in question. In this work, we solve this by creating a novel surface realizer architecture suitable for low-resourced African languages that abides by the features of maintainable software. Its design comes after a granular analysis, classification, and comparison of the architectures used by 77 existing NLG systems. We compare our architecture to existing architectures and show that it supports the most features of a maintainable software product.

Naming Practices in Object-oriented Programming: An Empirical Study

Currently, research indicates that comprehending code takes up far more developer time than writing code. Given that most modern programming languages place little to no limitations on identifier names, and so developers are allowed to choose identifier names at their own discretion, one key aspect of code comprehension is the naming of identifiers. Research in naming identifiers shows that informative names are crucial to improving the readability and maintainability of programs: essentially, intention-revealing names make code easier to understand and act as a basic form of documentation. Poorly named identifiers tend to hurt the comprehensibility and maintainability of software systems. However, most computer science curricula emphasize programming concepts and language syntax over naming guidelines and conventions. Consequently, programmers lack knowledge about naming practices. This article is an extension of our previous study on naming practices. Previously, we set out to explore naming practices of Java programmers. To this end, we analyzed 1,421,607 identifier names (i.e., attributes, parameters, and variables names) from 40 open-source Java projects and categorized these names into eight naming practices. As a follow-up study to further investigate naming practices, we examined 40 open-source C++ projects and categorized 1,181,774 identifier names according to the previously mentioned eight naming practices. We examined the occurrence and prevalence of these categories across C++ and Java projects and our results also highlight in which contexts identifiers following each naming practice tend to appear more regularly. Finally, we also conducted an online survey questionnaire with 52 software developers to gain insight from the industry. All in all, we believe the results based on the analysis of 2,603,381 identifier names can be helpful to enhance programmers’ awareness and contribute to improving educational materials and code review methods.

Exploring Maintainability Index Variants for Software Maintainability Measurement in Object-Oriented Systems

During maintenance, software systems undergo continuous correction and enhancement activities due to emerging faults, changing environments, and evolving requirements, making this phase expensive and time-consuming, often exceeding the initial development costs. To understand and manage software under development and maintenance better, several maintainability measures have been proposed. The Maintainability Index is commonly used as a quantitative measure of the relative ease of software maintenance. There are several Index variants that differ in the factors affecting maintainability (e.g., code complexity, software size, documentation) and their given importance. To explore the variants and understand how they compare when evaluating software maintainability, an experiment was conducted with 45 Java-based object-oriented software systems. The results showed that the choice of the variant could influence the perception of maintainability. Although different variants presented different values when subjected to the same software, their values were strongly positively correlated and generally indicated similarly how maintainability evolved between releases and over the long term. Though, when focusing on fine-grained results posed by the Index, the variant selection had a larger impact. Based on their characteristics, behavior, and interrelationships, the variants were divided into two distinct clusters, i.e., variants that do not consider code comments in their calculation and those that do.

AutodiDAQt: Simple Scientific Data Acquisition Software with Analysis-in-the-Loop

Scientific data acquisition is a problem domain that has been underserved by its computational tools despite the need to efficiently use hardware, to guarantee validity of the recorded data, and to rapidly test ideas by configuring experiments quickly and inexpensively. High-dimensional physical spectroscopies, such as angle-resolved photoemission spectroscopy, make these issues especially apparent because, while they use expensive instruments to record large data volumes, they require very little acquisition planning. The burden of writing data acquisition software falls to scientists, who are not typically trained to write maintainable software. In this paper, we introduce AutodiDAQt to address these shortfalls in the scientific ecosystem. To ground the discussion, we demonstrate its merits for angle-resolved photoemission spectroscopy and high bandwidth spectroscopies. AutodiDAQt addresses the essential needs for scientific data acquisition by providing simple concurrency, reproducibility, retrospection of the acquisition sequence, and automated user interface generation. Finally, we discuss how AutodiDAQt enables a future of highly efficient machine-learning-in-the-loop experiments and analysis-driven experiments without requiring data acquisition domain expertise by using analysis code for external data acquisition planning.

A review on soft computing approaches for predicting maintainability of software: State‐of‐the‐art, technical challenges, and future directions

AbstractThe software is changing rapidly with the invention of advanced technologies and methodologies. The ability to rapidly and successfully upgrade software in response to changing business requirements is more vital than ever. For the long‐term management of software products, measuring software maintainability is crucial. The use of soft computing techniques for software maintainability prediction has shown immense promise in software maintenance process by providing accurate prediction of software maintainability. To better understand the role of soft computing techniques for software maintainability prediction, we aim to provide a systematic literature review of soft computing techniques for predicting software maintainability. Firstly, we provide a detailed overview of software maintainability. Following this, we explore the fundamentals of software maintainability and the reasons for adopting soft computing methodologies for predicting software maintainability. Later, we examine the soft computing approaches employed in the process of software maintainability prediction. Furthermore, we discuss the difficulties and potential solutions associated with the use of soft computing techniques in predicting maintainability of software. Finally, we conclude the review with some promising future directions to drive further research innovations and developments in this promising area. This systematic literature review provides a comprehensive overview of the soft computing strategies utilized for software maintainability for future researchers.

CLCD-I: Cross-Language Clone Detection by Using Deep Learning with InferCode

Source code clones are common in software development as part of reuse practice. However, they are also often a source of errors compromising software maintainability. The existing work on code clone detection mainly focuses on clones in a single programming language. However, nowadays software is increasingly developed on a multilanguage platform on which code is reused across different programming languages. Detecting code clones in such a platform is challenging and has not been studied much. In this paper, we present CLCD-I, a deep neural network-based approach for detecting cross-language code clones by using InferCode which is an embedding technique for source code. The design of our model is twofold: (a) taking as input InferCode embeddings of source code in two different programming languages and (b) forwarding them to a Siamese architecture for comparative processing. We compare the performance of CLCD-I with LSTM autoencoders and the existing approaches on cross-language code clone detection. The evaluation shows the CLCD-I outperforms LSTM autoencoders by 30% on average and the existing approaches by 15% on average.

Assessing the impact of software quality models in healthcare software systems

ABSTRACT Health and medical care are safety-critical environments. The development of a safe and reliable healthcare software system is one of the most important processes which may affect the accuracy of clinical decision making and have an impact on determining diagnoses of and treatment for diseases. The aim of this study is to assess if software quality models, such as McCall, can have an impact on healthcare software quality for the purpose of reducing software failures. We have identified the main criticalities of healthcare software systems based on existing literature, software quality models and programming language standards; we have related these criticalities to software characteristics; we have analysed the relationship between the main criticalities of healthcare software systems and their software characteristics. The following criticalities - the risk of changing hard-coded software and the importance of developing maintainable software – must be addressed at the start of the software development process.

The Impact of Design-level Class Decomposition on the Software Maintainability

The Impact of Design-level Class Decomposition on the Software Maintainability

Improvement in Software Maintainability Prediction Using Data Balancing and Machine Learning

Improvement in Software Maintainability Prediction Using Data Balancing and Machine Learning