Good Software Research Articles

Promoting scientific software quality through transition to continuous integration and continuous delivery

Software quality has been an issue for decades in many areas of scientific modelling for environment applications. Much of the software that has been developed is well-suited to supporting research investigation and application in one-off curated application environments, such as delivering solutions through community-based participatory approaches. However, when releasing the software into constrained production environments, with everyday operational challenges such as missing data, unintended user inputs, variable data quality, and values outside the bounds of those previously tested, lacks in software quality can become apparent. The lacks can result in lost time and effort to get the model running again, loss of trust in the model by users and, potentially, cessation in model use, and early and unexpected end-of-life. There have been many efforts through the years to encourage improved software quality, through approaches such as test-driven development, paired programming, more rigorous documentation, and better and broader user acceptance testing. The basis of many of these approaches is the art and science of software testing, through the whole development chain from unit testing, regression testing, integration testing, functional testing and to user testing. Continuous Integration/ Continuous Development (CI/CD)/ Continuous Deployment uses an automated or semi-automated process pipeline that promotes or progresses software through various stages of 'readiness' in different system realms, from development to testing to production. Faithful application of CI/CD promotes good quality software by requiring the software to pass a series of pre-determined tests before it is accepted into the next realm. Models must meet quality levels and pass automated tests to be able to be promoted. Additionally, governance gateways are used to check non-automated workflow components, such as manual testing. This paper explores the challenges and lessons learned in adoption and application of secure CI/CD in an operational environmental modelling enterprise, and suggests a minimum viable good practice approach for application to scientific environmental modelling.

Analysis of Software Patterns to resolve Design Problems

A reproducible solution to a frequently occurring problem in software design was described as a software pattern, also known as a design pattern. It was a tested method for resolving kinds of software design issues that had been classified and identified by several years of experience and best practices. The key to making safe and accessible software was good software design. There were different types of design problems. Solving those problems was very important to produce good and efficient software. There were some tools, techniques, and patterns to solve these problems. Software design knowledge could be effectively captured and communicated using design patterns. Within a particular context of software design, a software design pattern was a standardized, repeatable solution to a frequently occurring problem. The patterns were effective for software design on several levels. In this paper, we identified the major design problems. Then we have analyzed those problems and present design patterns to develop an effective software design.

Good modelling software practices

Frequently in socio-environmental sciences, models are used as tools to represent, understand, project and predict the behaviour of these complex systems. Along the modelling chain, Good Modelling Practices have been evolving that ensure — amongst others — that models are transparent and their results replicable. Whenever such models are represented in software, Good Modelling meet Good Software Practices, such as a tractable development workflow, good code, collaborative development and governance, continuous integration and deployment; and they meet Good Scientific Practices, such as attribution of copyrights and acknowledgement of intellectual property, publication of a software paper and archiving. Too often in existing socio-environmental model software, these practices have been regarded as an add-on to be considered at a later stage only; modellers have shied away from publishing their model as open source out of fear that having to add good practices is too demanding. We here argue for making a habit of following a list of simple and not so simple practices early on in the implementation of the model life cycle. We contextualise cherry-picked and hands-on practices for supporting Good Modelling Practice, and we demonstrate their application in the example context of the Viable North Sea fisheries socio-ecological systems model.

Good software development practices improve citations of RNA seq tools

Good software development practices improve citations of RNA seq tools

Perancangan Sistem Pelaporan Incident Hack Di Kominfo Lombok Tengah Menggunakan Agile Pendekatan Scrum

The Scrum method is a methodology included in agile software development. Scrum is considered to be able to produce good quality software according to user wishes, can be used in large and small projects, and is easy to adopt changes. The scrum activity stages include product backlog, sprint backlog, daily scrum, sprint review, and sprint retrospective. Roles in Scrum include product owner, scrum master, and development team. Scrum has structured and iterative stages, so that if the product in the first sprint is not sufficient to meet needs, then in the next sprint a system can be developed that is in accordance with user evaluation. The results obtained from Designing a Hack Incident Reporting System at Kominfo Central Lombok Using the Agile Scrum Approach were proven to be able to overcome changes in requirements during the system development phase, producing products that met the wishes of users because they received repeated reviews.

Cohesion measurements between variables and methods using component-based software systems

The practice of leveraging previously created software components to progress new software is identified as component-based software engineering (CBSE). Good software engineering design is the foundation of CBSE principles. The black box approach that underpins CBSE hides the execution of components in nature, and the components communicate with one another using strictly delineated interfaces. Component platforms are shared, which lowers the price of creation. To ascertain a system's complexity, various software metrics are employed. For superiority in software intricacy, coupling would be minimal, and cohesiveness must be high. It is predetermined that coupling should be low and cohesion should be increased for refinement in software complexity. We are identifying the combination of different software systems and improving the methods for doing so with our approach. Proposed: Cohm (cohesion of methods) and Cohv (cohesion of variables) are two cohesion metrics that have been proposed. The cohesiveness metrics in this study have been analytically and empirically evaluated, and a comparison has been made between them. Additionally, an effort was made to give the outcomes of an empirical estimation based on the case study. The T-test is used to determine the consequences of the metrics, and Python is used to validate the metrics. Python or R programming and the Matlab tool are used to determine the relationship between various variables and metrics. Findings: The consequence of the current investigation is very encouraging and might be used to estimate the involvedness of the parts. The proportional analysis of the proposed metrics and various cohesion metrics reveals that the suggested metrics are more cohesive than the present metrics, increasing the likelihood that they can be reused when creating new applications.

The Influence of the National E-Procurement System on Employees’ Performance in Selected Public Institutions in Tanzania

This study evaluates how the Tanzania National E-Procurement System (TANePS) affects worker productivity in a country’s public institutions. The Government Procurement Services Agency (GPSA) and the Public Procurement Regulatory Authority (PPRA) were the two organizations where the study specifically investigated the adoption of TANePS and its impact on employee performance. With 200 employees from the chosen institutions participating in the sttudy’s self-administered questionnaire survey, 66 percent of the respondents responded. According to the study, 84% of the respondents frequently used TANePS for e-tendering and e-payment, but only a small percentage utilized it for user registration and e-contract administration. While internal resistance negatively impacted management policies and system adoption, good software design and IT readiness promoted TANePS deployment. The introduction of TANePS was successful due to supportive policies and IT, increased performance, and enhanced procurement efficiency.

QSOA®: Dynamic integration for hybrid quantum/Classical software systems

This is the “quantum decade” when quantum computers are proving to be more useful for some types of processing than their classical counterparts. The solutions of the future will combine classical IT with quantum algorithms and applications. However, there is very little work that addresses this issue. Each manufacturer provides specific tools for their products, which makes integration between quantum and classical systems a costly and time-consuming process.We believe that we should follow good software engineering principles and best practices to build platforms and tools that insulate software and systems engineers from implementation details and provide them with adequate support. In this paper we propose qSOA® as a mechanism for the dynamic integration of hybrid (quantum/classical) software systems and present in detail an SDK for Python. qSOA® provides a set of well-defined functions with which a classical system can access quantum products as if they were a piece of classical software, accessing the use case and not its complexities. In addition to some examples that illustrates its operation in real cases, we present the evaluation of qSOA® by 200 quantum software developers in a workshop in collaboration with AWS Braket.

An empirical investigation of the relationship between pattern grime and code smells

AbstractDevelopers are encouraged to adopt good design practices to maintain good software quality during the system's evolution. However, some modifications and changes to the system could cause code smells and pattern grime, which might incur more maintenance effort. As the presence of both code smells and pattern grime is considered a bad sign and raises a flag at code segments that need more careful examination, a potential connection between them may exist. Therefore, the main objective of this paper is to (1) empirically investigate the potential relationship between the accumulation of pattern grime and the presence of code smells and (2) evaluate the significance of individual code smells when they appear in a specific pattern grime category. To achieve this goal, we performed an empirical study using six‐grime metrics and 10 code smells on five Java open‐source projects ranging from 217 to 563 classes. Our statistical results indicate that, in general, the growth of grime is more likely to co‐occur with code smells using Spearman's correlation and Odd Ratio test. Specifically, there is a strong positive association between the growth of pattern grime at the class level and the presence of Shotgun Surgery smell according to the result of applying the Apriori algorithm, which gives conviction values equal to 1.66. The findings in this paper are helpful for developers and researchers as the presence of pattern grime could be considered a factor in improving the performance of existing smell detection methods. Furthermore, the link between grime and smells can be exploited as a hint for smell distribution in the system.

An assessment of heterogenous ensemble classifiers for analyzing change‐proneness in open‐source software systems

AbstractSoftware managers constantly look out for methods that ensure cost effective development of good quality software products. An important means of accomplishing this is by allocating more resources to weak classes of a software product, which are prone to changes. Therefore, correct prediction of these change‐prone classes is critical. Though various researchers have investigated the performance of several algorithms for identifying them, the search for an optimum classifier still persists. To this end, this study critically investigates the use of six Heterogenous Ensemble Classifiers (HEC) for Software Change Prediction (SCP) by empirically validating datasets obtained from 12 open‐source software systems. The results of the study are statistically assessed using three robust performance indicators (AUC, F‐measure and Mathew Correlation Coefficient) in two different validation scenarios (within project and cross‐project). They indicate the superiority of Average Probability Voting Ensemble, a heterogenous classifier for determining change‐proneness in the investigated systems. The average AUC values of software change prediction models developed using this ensemble classifier exhibited an improvement of 3%‐9% and 3%‐11% respectively when compared with its base learners and homogeneous counter parts. Similar observations were inferred using other investigated performance measures. Furthermore, the evidence obtained from the results suggests that the change in number of base learners or type of meta‐learner does not exhibit significant change in the performance of corresponding heterogenous ensemble classifiers.

Identification of Risk Factors in the Software Design Stage Using the C4.5 Algorithm

A strong design phase is necessary for good software. However, design errors in software can cause serious issues with its creation and use. Therefore, the goal of this study is to find risk variables that could have an early impact on software development. In this study, a machine learning technique called technique C4.5 is employed to create decision tree models. 100 respondents with software design experience participated in the online surveys and questionnaires that collected the data for this study in 2022. The C4.5 Algorithm was used in this study to analyze the data and determine the risk variables that affect the success of software design. The study's findings show that the C4.5 Algorithm-based model has a high level of accuracy (93.33%), which means that the data can offer crucial insights into understanding potential risks that may arise during the software design stage, enabling software developers to take the necessary precautions to lessen or eliminate these risks. In order to enhance the caliber and effectiveness of software design, this research is anticipated to provide a significant contribution to practitioners and academics in the field of software development.

Introducing Open Science in Teaching Health Economic Modelling.

Open Science is gaining ground in all research fields, including health economics and outcomes research (HEOR). However, teaching Open Science is still in its infancy. This paper describes the design, implementation and evaluation of a teaching activity focusing on introducing Open Science during a Master's course during which participants have to develop a discrete event simulation. The teaching activity was organised as a series of lectures introducing different aspects of the Open Science philosophy and practices, such as good software coding practices, version control systems and reproducible research. The participants' increase in Open Science knowledge was elicited through a survey before and after the teaching innovation. After the teaching innovation, participants' knowledge of Open Science increased and they reported an improvement in Open Science-related skills, such as using a script-based statistical software, identifying and re-using open data, and collaborative script development. During the evaluation at the end of the course, the course participants mentioned that the Open Science-related content was interesting but would fit better within a course in which broader research-related content is taught. Based on this feedback, we will most likely narrow the scope of the Open-Science-related content in this course to Open Source Modelling which may better fit the scope of the course. This paper contains links to the teaching activities we developed and other resources which may be used to design teaching activities on Open Science. Herewith, we hope to inspire other teachers in including Open Science into their teaching.

Development and usability testing of a patient digital twin for critical care education: a mixed methods study.

Digital twins are computerized patient replicas that allow clinical interventions testing in silico to minimize preventable patient harm. Our group has developed a novel application software utilizing a digital twin patient model based on electronic health record (EHR) variables to simulate clinical trajectories during the initial 6 h of critical illness. This study aimed to assess the usability, workload, and acceptance of the digital twin application as an educational tool in critical care. A mixed methods study was conducted during seven user testing sessions of the digital twin application with thirty-five first-year internal medicine residents. Qualitative data were collected using a think-aloud and semi-structured interview format, while quantitative measurements included the System Usability Scale (SUS), NASA Task Load Index (NASA-TLX), and a short survey. Median SUS scores and NASA-TLX were 70 (IQR 62.5-82.5) and 29.2 (IQR 22.5-34.2), consistent with good software usability and low to moderate workload, respectively. Residents expressed interest in using the digital twin application for ICU rotations and identified five themes for software improvement: clinical fidelity, interface organization, learning experience, serious gaming, and implementation strategies. A digital twin application based on EHR clinical variables showed good usability and high acceptance for critical care education.

Model View Controller Method For Animal Care (Petcare) Information System At Niz Petcare Lawang

Pet Care is a company that offers animal care services that are equipped with a variety of pet shop products such as food, vitamins and care. In addition to Daily Pet Care selling pet supplies and also offering animal medical and treatment services. on one computer. Pet sitting services are one of the best solutions for the majority of Indonesian people who have pets but have to travel far and cannot bring their pets with them. The owners of Niz Petcare see this as a great business opportunity. However, currently they still use manual recording in their business processes, sometimes resulting in loss of material and customer confidence. The purpose of this research is to solve this problem by designing a flow and design of a petcare application prototype that is integrated and more organized using information technology that is developing rapidly and makes it easier for customers to access online. Given these needs, the authors apply the prototyping method to accommodate these needs. The implementation of making software uses the model view controller (MVC) method which adopts the CodeIgniter framework. In this study, an evaluation was carried out using UAT and Usability Testing with ISO/IEC 9126. The evaluation results show that the application of the MVC method can produce good software products that work according to their functionality. Based on the ISO/IEC 9126 percentage, the criteria with the greatest value for understanding on P05, P07, and P09 is 89%, usability on P05 is 89%, and learning on P07 is 89% and 88% power handling at P10. From the results of the summary of the evaluation, it can be concluded that there are if the users of the system are owners, customers, administrators, fully aware of the ease of understanding, learning, use and attractiveness of the NIZ pet care information system created

Test Case Prioritization via Embedded Autoencoder Model for Software Quality Assurance

Software quality can be ensured by passing the process of software testing before the software is released. However, the software testing process involves many phases which leads to more resources and time consumption. Test Case Prioritization (TCP) has gained widespread acceptance because it prioritizes the tasks and reduces the number of phases and also produces results in good quality software free from defects. The coverage-based prioritization can be useful to distinguish each test case and result in a better prioritization process by using some algorithm. In this work, we propose a coverage-based prioritized test case generation using an Embedded Auto Encoder (EAE) algorithm which will produce an ordered sequence of the prioritized test cases. Initially, the code coverage for each benchmark has been extracted from the source code repository and is further processed to eliminate the noise in the data. The processed data will be given to the embedded autoencoder which consists of an autoencoder and a sparse autoencoder. Once the modeling is done, the model has been trained with the data generated by the Keras Data Generator class. The efficiency of the proposed EAE technique has been evaluated by using the APFD metric and the observations clearly show that the EAE framework proves to provide an APFD metric of 0.72 on average which is a good value in comparison to the previously deployed methodologies.

Design and Evaluation using Technology Acceptance Model of an Architecture Conceptualization Framework System based on the ISO/IEC/IEEE 42020

Among the difficulties in developing software-intensive systems are the necessity of managing and controlling data that must be held for decades, as well as describing the needs and concerns of a variety of stakeholders. Therefore, one cannot neglect a good Software Engineering practice which is to develop software-intensive systems based on solid software architecture. However, the processes related to the software architecture of software-intensive systems are often considered only from a low level of abstraction. A recent architectural Standard, the ISO/IEC/IEEE 42020, defines 6 clauses for the architecture process, among them the Architecture Conceptual-ization process is the subject of this study. Considering that the ISO/IEC/IEEE 42020 has only recently been published, given the importance of establishing a well-defined software architecture, and considering the difficulties of understanding an architectural Standard, this work proposes a framework, and then the design and further evaluation of a web-based application to support soft-ware architects in using the activities and tasks of the Architecture Conceptualization clause based on the framework described. The ArchConcept was designed to address the high-level abstraction of the Standard ISO/IEC/IEEE 42020 and can be useful for software architects who want to follow ISO/IEC/IEEE 42020’s recommendation and achieve high-quality results in their work of software architecture conceptualization. A qualitative evaluation employing a questionnaire was carried out to obtain information about the perceptions of professionals regarding the ArchConcept, according to the Technology Acceptance Model (TAM). As ArchConcept is focused on activities of Archi-tecture Conceptualization, which is one of the early stages of a software project, the results found could be evidence of the short time dedicated to the initial phases of projects and their consequences.regarding the ArchConcept, according to the Technology Acceptance Model (TAM). As ArchConcept is focused on the early stages of the project (Architecture Conceptualization), the results found in this work could be evidence of the short time dedicated to the initial phase of projects and their consequences.

On specifics of adaptive logging method implementation

Relevancy of this work is based on the fact that having an understanding of why given code behaves the way it does, both during normal execution and when encountering erroneous states, is an invaluable part of a good software design. As software systems become more complex, the demand for solutions, that can give deeper insight into code execution, remains high. The goal of this work is to formalize a software tool able to provide better observability of a program. Main methods used are: analysis of common approaches such as monitoring and logging, formalization of main components and modeling of an example implementation based on the Singleton software pattern. As a result, “severity only” based logging was analysed and core parts of “adaptive logging method” were described in a similar manner. There are two distinct features of this method: log tagging and subsequent introduction of a configuration schema that is capable of adapting to changing requirements during software program execution. Systems utilizing such approach gain the ability to extract more precise information about execution flow and also can focus on particular components that might behave incorrectly. As this switch is designed to happen without restarting the observed program, it should be possible to debug and investigate some issues without the need to try and reproduce from scratch the state of an environment where those have occurred. An example of formal description based on the Singleton software pattern is also presented, describing necessary methods and their signatures required to set up a basic variant of an adaptive logging method. This approach could be utilized by a variety of different applications and programming languages as it is developed in general terms and all required abstractions should be present in multiple environments

Towards Automation of the FORM/BCS Method

The software industry is facing more complex computer systems, with short development and sustainability issues. To deliver good software with these constraints, software reuse has become a central concept for minimizing design and realization costs. This study improves upon Feature-Oriented Reuse Method with Business Component Semantics (FORM/BCS), a software development method that produces adaptable architectures from reusable domain components. This is a promising method for reusable software assets and model creation. The objective of the FORM/BCS is to bring the industrial production chain to the software. This study proposes a model to automatically transform the FORM/BCS business subsystem component into a process business component. Two metamodels for business subsystems and process business components were developed. In addition, this study establishes correspondences between the source metamodel and target metamodel classes, transformation rules, and the instance of the source metamodel and generates the target metamodel instance. Detailed findings can help practitioners reduce software design costs and development time, and contribute to the advancement of knowledge in software engineering.

Architecting ML-enabled systems: Challenges, best practices, and design decisions

Context:Machine learning is increasingly used in a wide set of applications ranging from recommendation engines to autonomous systems through business intelligence and smart assistants. Designing and developing machine learning systems is a complex process that can be eased by leveraging effective design decisions tackling the most important challenges and by having a good system and software architecture. Goal:The research goal of this work is to identify common challenges, best design practices, and main software architecture design decisions of machine learning enabled systems from the point of view of researchers and practitioners. Method:We performed a mixed method including a systematic literature review and expert interviews. We started with a systematic literature review. From an initial set of 3038 studies, we selected 41 primary studies, which we analysed according to a data extraction, analysis, and synthesis process. In addition, we conducted 12 expert interviews that involved researchers and professionals with machine learning expertise from 9 different countries. Findings:We identify 35 design challenges, 42 best practices and 27 design decisions when architecting machine learning systems. By eliciting main design challenges, we contribute to best practices and design decisions. In addition, we identify correlations among design challenges, decisions and best practices. Conclusions:We believe that practitioners and researchers can benefit from this first and comprehensive analysis of current software architecture design challenges, best practices, and design decisions.

Cognitive Driven Development helps software teams to keep code units under the limit!

Software design techniques are key elements in the process of designing good software. Over the years, a large number of design techniques have been proposed by both researchers and practitioners. Unfortunately, despite their uniqueness, it is not uncommon to find software products that make subpar design decisions, leading to design degradation challenges. One potential reason for this behavior is that developers do not have a clear vision of how much a code unit could grow; without this vision, a code unit can grow endlessly, even when developers are equipped with an arsenal of design practices. Different than other design techniques, Cognitive Driven Development (CDD for short) focuses on (1) defining and (2) limiting the number of coding elements that developers could use at a given code unit.In this paper, we report on the experiences of a software development team using CDD for building from scratch a learning management tool at Zup Innovation, a Brazilian tech company. By curating commit traces left in the repositories, combined with the developers’ perception, we organized a set of findings and lessons that could be useful for those interested in adopting CDD. For instance, we noticed that by using CDD, despite the evolution of the product, developers were able to keep the code units under a small amount of size (in terms of lines of code). Furthermore, although limiting the complexity is at the heart of CDD, we also discovered that developers tend to relax this notion of limit so that they can cope with the different complexities of the software. Still, we noticed that CDD could also influence testing practices; limiting the code units’ size makes testing easier to perform.