Search

We propose a rich foundational theory of typed data streams and stream transformers, motivated by two high-level goals. First, the type of a stream should be able to express complex sequential patterns of events over time. And second, it should describe the internal parallel structure of the stream, to support deterministic stream processing on parallel and distributed systems. To these ends, we introduce stream types, with operators capturing sequential composition, parallel composition, and iteration, plus a core calculus λST of transformers over typed streams that naturally supports a number of common streaming idioms, including punctuation, windowing, and parallel partitioning, as first-class constructions. λST exploits a Curry-Howard-like correspondence with an ordered variant of the Logic of Bunched Implication to program with streams compositionally and uses Brzozowski-style derivatives to enable an incremental, prefix-based operational semantics. To illustrate the programming style supported by the rich types of λST, we present a number of examples written in Delta, a prototype high-level language design based on λST.

I/O performance monitoring tools such as Darshan and Recorder collect I/O-related metrics on production systems and help understand the applications' behavior. However, some gaps prevent end-users from seeing the whole picture when it comes to detecting and drilling down to the root causes of I/O performance slowdowns and where those problems originate. These gaps arise from limitations in the available metrics, their collection strategy, and the lack of translation to actionable items that could advise on optimizations. This paper highlights such gaps and proposes solutions to drill down to the source code level to pinpoint the root causes of I/O bottlenecks scientific applications face by relying on cross-layer analysis combining multiple performance metrics related to I/O software layers. We demonstrate with two real applications how metrics collected in high-level libraries (which are closer to the data models used by an application), enhanced by source-code insights and natural language translations, can help streamline the understanding of I/O behavior and provide guidance to end-users, developers, and supercomputing facilities on how to improve I/O performance. Using this cross-layer analysis and the heuristic recommendations, we attained up to 6.9× speedup from run-as-is executions.

Over the academic year 2022-23, we discussed the teaching of software performance engineering with more than a dozen faculty across North America and beyond. Our outreach was centered on research-focused faculty with an existing interest in this course material. These discussions revealed an enthusiasm for making software performance engineering a more prominent part of a curriculum for computer scientists and engineers. Here, we discuss how MIT's longstanding efforts in this area may serve as a launching point for community development of a software performance engineering curriculum, challenges in and solutions for providing the necessary infrastructure to universities, and future directions.

Abstract: This Roadmap article provides a succinct, comprehensive overview of the state of electronic structure methods and software for molecular and materials simulations. Seventeen distinct sections collect insights by 51 leading scientists in the field. Each contribution addresses the status of a particular area, as well as current challenges and anticipated future advances, with a particular eye towards software related aspects and providing key references for further reading. Foundational sections cover density functional theory and its implementation in real-world simulation frameworks, Green's function based many-body perturbation theory, wave-function based and stochastic electronic structure approaches, relativistic effects and semiempirical electronic structure theory approaches. Subsequent sections cover nuclear quantum effects, real-time propagation of the electronic structure, challenges for computational spectroscopy simulations, and exploration of complex potential energy surfaces. The final sections summarize practical aspects, including computational workflows for complex simulation tasks, the impact of current and future high-performance computing architectures, software engineering practices, education and training to maintain and broaden the community, as well as the status of and needs for electronic structure based modeling from the vantage point of industry environments. Overall, the field of electronic structure software and method development continues to unlock immense opportunities for future scientific discovery, based on the growing ability of computations to reveal complex phenomena, processes and properties that are determined by the make-up of matter at the atomic scale, with high precision.

The high-performance computing I/O stack has been complex due to multiple software layers, the inter-dependencies among these layers, and the different performance tuning options for each layer. In this complex stack, the definition of an "I/O access pattern"has been reappropriated to describe what an application is doing to write or read data from the perspective of different layers of the stack, often comprising a different set of features. It has become common to have to redefine what is meant when discussing a pattern in every new study, as no assumption can be made. This survey aims to propose a baseline taxonomy, harnessing the I/O community's knowledge over the past 20 years. This definition can serve as a common ground for high-performance computing I/O researchers and developers to apply known I/O tuning strategies and design new strategies for improving I/O performance. We seek to summarize and bring a consensus to the multiple ways to describe a pattern based on common features already used by the community over the years.

The Exascale Computing Project software deployment effort developed and advanced DevOps capabilities. One goal was to enable robust continuous integration (CI) workflows that span the protected high-performance computing environments found within many of the U.S. Department of Energy's (DOE's) national laboratories. This article highlights several challenges encountered with enabling automation, such as charging models for CI jobs and meeting individualized security requirements that revolve around strongly associating running code with a human identity. It also describes how the Jacamar CI tool evolved to meet later requirements and became a key aspect of the solutions currently offered. Derived from this experience, we offer a conceptual framework for understanding current and future CI challenges at DOE facilities and offer suggestions for long-term solutions.

Computational and data-enabled science and engineering are revolutionizing advances throughout science and society, at all scales of computing. For example, teams in the U.S. Department of Energy's Exascale Computing Project have been tackling new frontiers in modeling, simulation, and analysis by exploiting unprecedented exascale computing capabilities-building an advanced software ecosystem that supports next-generation applications and addresses disruptive changes in computer architectures. However, concerns are growing about the productivity of the developers of scientific software. Members of the Interoperable Design of Extreme-scale Application Software project serve as catalysts to address these challenges through fostering software communities, incubating and curating methodologies and resources, and disseminating knowledge to advance developer productivity and software sustainability. This article discusses how these synergistic activities are advancing scientific discovery-mitigating technical risks by building a firmer foundation for reproducible, sustainable science at all scales of computing, from laptops to clusters to exascale and beyond.

Over the last decade merge trees have been proven to support a plethora of visualization and analysis tasks since they effectively abstract complex datasets. This paper describes the ExTreeM-Algorithm: A scalable algorithm for the computation of merge trees via extremum graphs. The core idea of ExTreeM is to first derive the extremum graph G of an input scalar field f defined on a cell complex K, and subsequently compute the unaugmented merge tree of f on G instead of K; which are equivalent. Any merge tree algorithm can be carried out significantly faster on G, since K in general contains substantially more cells than G. To further speed up computation, ExTreeM includes a tailored procedure to derive merge trees of extremum graphs. The computation of the fully augmented merge tree, i.e., a merge tree domain segmentation of K, can then be performed in an optional post-processing step. All steps of ExTreeM consist of procedures with high parallel efficiency, and we provide a formal proof of its correctness. Our experiments, performed on publicly available datasets, report a speedup of up to one order of magnitude over the state-of-the-art algorithms included in the TTK and VTK-m software libraries, while also requiring significantly less memory and exhibiting excellent scaling behavior.

The US Exascale Computing Project (ECP) has succeeded in preparing applications to run efficiently on the first reported Exascale supercomputers in the world. To achieve this, it modernized the whole leadership software stack, from libraries to simulation codes. In this article, we contrast selected leadership software before and after ECP. We discuss how sustainable research software development for leadership computing can embrace the conversation with the hardware vendors, the leadership computing facilities, the software community, and the domain scientists who are the application developers and integrators of software products. We elaborate on how software needs to take portability as a central design principle and to benefit from interdependent teams; we also demonstrate how moving to programming languages with high momentum, like modern C++, can help improve the sustainability, interoperability, and performance of research software. Finally, we showcase how cross-institutional efforts can enable algorithm advances that are beyond incremental performance optimization.

Neuroscience research has evolved to generate increasingly large and complex experimental data sets, and advanced data science tools are taking on central roles in neuroscience research. Neurodata Without Borders (NWB), a standard language for neurophysiology data, has recently emerged as a powerful solution for data management, analysis, and sharing. We here discuss our labs’ efforts to implement NWB data science pipelines. We describe general principles and specific use cases that illustrate successes, challenges, and non-trivial decisions in software engineering. We hope that our experience can provide guidance for the neuroscience community and help bridge the gap between experimental neuroscience and data science. Key takeaways from this article are that (1) standardization with NWB requires non-trivial design choices; (2) the general practice of standardization in the lab promotes data awareness and literacy, and improves transparency, rigor, and reproducibility in our science; (3) we offer several feature suggestions to ease the extensibility, publishing/sharing, and usability for NWB standard and users of NWB data [ABSTRACT FROM AUTHOR]

Refactoring is a well-established topic in contemporary software engineering, focusing on enhancing software's structural design without altering its external behavior. Commit messages play a vital role in tracking changes to the codebase. However, determining the exact refactoring required in the code can be challenging due to various refactoring types. Prior studies have attempted to classify refactoring documentation by type, achieving acceptable results in accuracy, precision, recall, F1-Score, and other performance metrics. Nevertheless, there is room for improvement. To address this, we propose a novel approach using four ensemble Machine Learning algorithms to detect refactoring types. Our experimentation utilized a dataset containing 573 commits, with text cleaning and preprocessing applied to address data imbalances. Various techniques, including hyperparameter optimization, feature engineering with TF-IDF and bag-of-words, and binary transformation using one-vs-one and one-vs-rest classifiers, were employed to enhance accuracy. Results indicate that the experiment involving feature engineering using the TF-IDF technique outperformed other methods. Notably, the XGBoost algorithm with the same technique achieved superior performance across all metrics, attaining 100% accuracy. Moreover, our results surpass the current state-of-the-art performance using the same dataset. Our proposed approach bears significant implications for software engineering, particularly in enhancing the internal quality of software. [ABSTRACT FROM AUTHOR]

Software engineers play a centric role throughout the software development lifecycle. Their activities directly impact the quality, performance, and successful delivery of software products, in particular for enterprises with an emphasis on high levels of quality assurance and timely delivery. Proper incentives that motivate software engineers are vital to secure and continuously improve development productivity and software quality. However, most existing research ignores the positive incentives for software engineers, especially industry‐oriented research. In addition, existing research largely relies on peer assessment and lacks objectivity and transparency. To this end, this study investigates the process of contribution measurement for software engineers in a global Information and Communications Technology (ICT) enterprise, to explore the practical experiences and significance of contribution measurement. We investigated the practices of contribution measurement through multiple methods, including archival analysis, interviews, and survey. A total of 22 software engineers were interviewed to understand the practical implementation process of measuring contributions and its impact on software processes as well as engineers. In addition, 74 responses to our questionnaire were collected and used for a comprehensive impact analysis on software engineers. The analysis results reveal five benefits for software development processes and four benefits for practitioners of contribution measurement in the studied enterprise. In addition, this study reports on the best practices of contribution measurement, such as team‐specific measurements, and provides a practical reference for researchers and organizations interested in studying or performing contribution measurement. [ABSTRACT FROM AUTHOR]

Quantum software engineering is advancing in the domain of quantum computing research and application, yet the documentation is scattered. The slow transition from Von-Neumann based computation systems to quantum systems, and conserving the fundamental computing principles in software development and software engineering helps in enrichment of quantum software development. The evolution of quantum computing over the past years shows a shift in the domain of classical computation to quantum computation in the years to come. Future applications such as, quantum AI and quantum machine learning will benefit from quantum software engineering. This survey collects and explores the various documentations in the domain of quantum systems and quantum software engineering. The survey provides an in-depth exploration of quantum programming languages, which is combined with explanations of quantum computing's fundamentals. The review also goes in-depth about quantum software engineering and quantum software life cycle development, outlining the quantum software reuse methodology that is introduced in the quantum software lifecycle development domain. [ABSTRACT FROM AUTHOR]

Crowdsourced software development (CSSD) is a fast-growing field among software practitioners and researchers from the last two decades. Despite being a favorable environment, no intelligent mechanism exists to assign price to CSSD tasks. Software development effort estimation (SDEE) on the other hand is already an established field in traditional software engineering. SDEE is largely facilitated by machine learning (ML), particularly, ML-based ensemble effort estimation (EEE) which targets accurate estimate by avoiding biases of single ML model. This accuracy of EEE can be exploited for CSSD platforms to establish intelligent cost assignment mechanism. This study aims to integrate EEE with CSSD platform to provide justified costing solution for crowdsourced tasks. Effort-based cost estimation model is proposed, implementing EEE to predict task's effort along with natural language processing (NLP) analysis on task's textual description to assign effort-based cost. TopCoder is selected as targeted CSSD platform, and the proposed scheme is implemented on TopCoder QA category comprising software testing tasks. Ensemble prediction is incorporated via random forest, support vector machine and neural network as base learners. LDA topic modeling is utilized for NLP analysis on the textual aspects of CSSD task, with a specific emphasis on the testing and technology factors. Effort estimation results confirm that EEE models, particularly stacking and weighted ensemble, surpass their base learners with 50% overall increased accuracy. Moreover, R2, log-likelihood and topic quality measures confirm considerable LDA model significance. Findings confirmed that cost adjustment achieved from EEE and NLP defines acceptable price range, covering major testing aspects. [ABSTRACT FROM AUTHOR]

Despite the increase in the efficiency of energy consumption in information and communication technology, software execution and its constraints are responsible for how energy is consumed in hardware hosts. Consequently, researchers have promoted the development of sustainable software with new development methods and tools to lessen its hardware demands. However, the approaches developed so far lack cohesiveness along the stages of the software development life cycle (SDLC) and exist outside of a holistic method for green software development (GSD). In addition, there is a severe lack of approaches that target the analysis and design stages of the SDLC, leaving software architects and designers unsupported. In this article, we introduce our behavior-based consumption profile (BBCP) external Domain-Specific Language (DSL), aimed at assisting software architects and designers in modeling the behavior of software. The models generated with our external DSL contain multiple sets of properties that characterize features of the software's behavior. In contrast to other modeling languages, our BBCP emphasizes how time and probability are involved in software execution and its evolution over time, helping its users to gather an expectation of software usage and hardware consumption from the initial stages of software development. To illustrate the feasibility and benefits of our proposal, we conclude with an analysis of the model of a software service created using the BBCP, which is simulated using Insight Maker to obtain an estimation of hardware consumption and later translated to energy consumption. [ABSTRACT FROM AUTHOR]

In this article we report some practical experiences of integrating education for sustainable development into established university teaching modules. The 2021 guidance on Education for Sustainable Development from the UK's standards bodies QAA and Advance HE is an important and urgent motivation for introducing sustainability into university courses. We take as our context a first-year introductory module in Chemical Products and Process in the School of Chemistry and Chemical Engineering and a second-year module in Software Engineering and Systems Development in the School of Electronics, Electrical Engineering and Computer Science, both at Queen's University Belfast. We outline some of the challenges of adding new themes to existing courses. We comment on ways of presenting themes of sustainable development alongside existing module content, and we indicate the type of work students produced. We identify approaches that resulted in good outcomes, and outline changes we have made with a view to improved future outcomes. [ABSTRACT FROM AUTHOR]

Development of machine learning (ML) systems differs from traditional approaches. The probabilistic nature of ML leads to a more experimentative development approach, which often results in a disparity between the quality of ML models with other aspects such as business, safety, and the overall system architecture. Herein the Multi-view Modeling Framework for ML Systems (M3S) is proposed as a solution to this problem. M3S provides an analysis framework that integrates different views. It is supported by an integrated metamodel to ensure the connection and consistency between different models. To facilitate the experimentative nature of ML training, M3S provides an integrated platform between the modeling environment and the ML training pipeline. M3S is validated through a case study and a controlled experiment. M3S shows promise, but future research needs to confirm its generality. [ABSTRACT FROM AUTHOR]

Auxiliary functions in software systems, often overlooked due to their perceived simplicity, play a crucial role in overall system reliability. This study focuses on the effectiveness of agile practices, specifically the pair programming and the test-first programming practices. Despite the importance of these functions, there exists a dearth of empirical evidence on the impact of agile practices on their development, raising questions about their potential to enhance correctness without affecting time-to-market. This paper aims to bridge this gap by comparing the application of agile practices with traditional approaches in the context of auxiliary function development. We conducted six experiments involving 122 participants (85 novices and 37 professionals) who used both traditional and agile methods to develop six auxiliary functions across three different domains. Our analysis of 244 implementations suggests the potential benefits of agile practices in auxiliary function development. Pair programming showed a tendency towards improved correctness, while test-first programming did not significantly extend the total development time, particularly among professionals. However, these findings should be interpreted cautiously as they do not conclusively establish that agile practices outperform traditional approaches universally. As indicated by our results, the potential benefits of agile practices may vary depending on factors such as the programmer's experience level and the nature of the functions being developed. Further research is needed to fully understand the contexts in which these practices can be most effectively applied and to address the potential limitations of our study. [ABSTRACT FROM AUTHOR]

Global software development (GSD) refers to developing software with a distributed team spanning multiple locations and time zones. Based on relationships, there are four types of outsourcing: dyadic (one client–one vendor), multi‐vendor (one client–many vendors), co‐sourcing (many clients–one vendor), and complex outsourcing (many clients–many vendors). Compared to the other types of outsourcing contracts, complex outsourcing contracts are the hardest to work on and have the highest risk of project failure. This paper presents a model, the complex outsourcing relationships management model (CORMM), to assist the complex outsourcing stakeholders (both the clients and vendors) in managing their relationships in the context of GSD. This paper aims to develop a CORMM to assist the complex outsourcing relationships management stakeholders in GSD. Also, we are interested in identifying the applicability and effectiveness of the CORMM in the real‐world industry. The research approach follows a structured methodology comprising multiple phases. Initially, it leverages a systematic literature review (SLR) as its primary research method. The second phase involves the validation of the SLR findings via an empirical study. Subsequently, in the third phase, a model is developed. Finally, the proposed research approach is validated by incorporating two industrial case studies to assess the organization's relationship management utilizing the Motorola tool. The case study results show that CORMM can successfully point out relationship management issues in a complex outsourcing context. The feedback received from the participants of both companies indicates several positive and valuable insights about the CORMM and its application in the context of complex outsourcing relationships. The results highlight that CORMM serves as an assessment tool for evaluating an organization's relationship management capability and a means for organizations to enhance their position. Through CORMM, complex outsourcing organizations (many clients–many vendors) can identify strengths and weaknesses in their relationship management practices, enabling targeted improvement efforts. [ABSTRACT FROM AUTHOR]

Sustainability in systems refers to applying sustainable principles and practices to create more resilient, efficient, and equitable systems that promote the well-being of people and the planet. Sustainability is an essential topic in contemporary software engineering, and its relationship with the characteristics and properties of a system or product called quality attributes is still an open question since each researcher has established their definition of sustainability in software. This has created diverse terms and concepts for distinct application environments and scopes, creating ambiguity and misconceptions. This work defines a domain ontology of Sustainability in Software named SinSO to address these issues. SinSO was implemented in OWL, using competency-based questions to validate. The findings show that this proposal satisfies several quality and content requirements. Also, using Protégé and the Hermit reasoner, we verified that SinSO is consistent since the ontology statements are coherent and do not lead to conflicting or contradictory conclusions. In addition, competency questions allowed us to demonstrate that SinSO does fulfill its purpose. FOCA methodology allowed us to evaluate SinSO quality. Also, SinSO was used in two case studies, one about software for senior-citizen smart-home, and the other, a simulator to develop and test smart-city applications, achieving positive outcomes. To verify its accuracy, completeness, and maintainability, further evaluations of SinSO are needed in real case studies. We conclude that SinSO can significantly contribute to reducing ambiguity and enhancing comprehension in this area. Furthermore, SinSO can be an effective tool for engineers to recognize the concepts and relationships in the sustainable domain to consider in the systems development life cycle to build sustainable systems. [ABSTRACT FROM AUTHOR]

Summary Continuous integration and continuous delivery (CI/CD) automate software integration and reduce repetitive engineering work. While the use of CI/CD presents efficiency gains, in database application development, this potential has not been fully exploited. We explore the state of the art in this area, with a focus on current practices, common software tools, challenges, and preconditions that apply to database applications. The work is grounded in a synoptic literature review and contributes a novel generic CI/CD pipeline for database system application development. Our generic pipeline was tailored to three industrial development use cases in which we measured the benefits of integration and deployment automation. The measurements demonstrate clearly that introducing CI/CD had significant benefits. It reduced the number of failed deployments, improved their stability, and increased the number of deployments. Interviews with the developers before and after the implementation of the CI/CD show that the pipeline brings clear benefits to the development team (i.e., a reduced cognitive load). These findings put current database release practices driven by business expectations, such as fixed release windows, in question. [ABSTRACT FROM AUTHOR]

Many powerful metamodeling platforms enabling model-driven software engineering (MDSE) exist, each with its strengths, weaknesses, functionalities, programming language(s), and developer community. Platform interoperability would enable users to exploit their mutual benefits. Such interoperability would allow the transformation of metamodels and models created in one platform into equivalent metamodels and models in other platforms. Language engineers could then freely choose the metamodeling platform without risking a lock-in effect. Two well-documented and publicly available metamodeling platforms are the eclipse modeling framework (EMF) and the modeling SDK for visual studio (MSDKVS). In this paper, we propose an M3-level-bridge (M3B) that establishes interoperability between EMF and MSDKVS on the abstract syntax level and on the graphical concrete syntax level. To establish such interoperability we (i) compare the two platforms, (ii) present a conceptual mapping between them, and (iii) implement a bidirectional transformation bridge including both the metamodel and model layer. We evaluate our approach by transforming a collection of publicly available metamodels and automatically generated or manually created models thereof. The transformation outcomes are then used to quantitatively and qualitatively evaluate the transformation's validity, executability, and expressiveness. [ABSTRACT FROM AUTHOR]

We investigated the relationship between various design approaches of AgentSpeak code for Jason Beliefs-Desires-Intentions (BDI) agents and their performance in a simulated automotive collision avoidance scenario. Also explored was how the approaches affected software maintainability, assessed through coupling, cohesion, and cyclomatic complexity. We then compared each agent's performance, specifically their reasoning cycle duration and their responsiveness. Our findings revealed that agents with looser coupling and higher cohesion are more responsive to stimuli, implying that more maintainable AgentSpeak code can result in better performing agents. Performance was inversely related to cyclomatic complexity. [ABSTRACT FROM AUTHOR]

The adoption and popularity of mobile devices by end-users is partially driven by the increasing development and availability of mobile applications that can aid solving different problems and provide access to services in a wide range of domains or categories, namely healthcare, education, e-commerce or entertainment. While these applications use and benefit from the combination of a wide panoply of technologies from the Internet of Things, fog and cloud computing, data security and privacy are typically not fully taken into account before the creation of many mobile applications or during the software development phases. This paper presents an in-depth approach to modeling attacks on the specific cloud and mobile ecosystem, given its importance in the process of secure application development. Moreover, aiming at bridging the knowledge gap between developers and security experts, this paper presents an alpha version of the security by design for cloud and mobile ecosystem (secD4CloudMobile) framework. secD4CloudMobile is a set of tools that covers cloud and mobile security requirement elicitation (CMSRE), cloud and mobile security best practices guidelines (CMSBPG), cloud mobile attack modeling elicitation (CMAME), and cloud mobile security test specification and tools (CM2ST). The purpose of the framework is to provide cloud and mobile application developers useful readily applicable information and guidelines, striving to bring security engineering and software engineering closer, in a more accessible and automated manner, aiming at the incorporation of security by construction. Finally, the paper presents some preliminary results and discussion. [ABSTRACT FROM AUTHOR]

Summary: In software development, developer turnover is among the primary reasons for project failures, leading to a great void of knowledge and strain for newcomers. Unfortunately, no established methods exist to measure how the problem domain knowledge is distributed among developers. Awareness of how this knowledge evolves and is owned by key developers in a project helps stakeholders reduce risks caused by turnover. To this end, this paper introduces a novel, realistic representation of problem domain knowledge distribution: the ConceptRealm. To construct the ConceptRealm, we employ a latent Dirichlet allocation model to represent textual features obtained from 300 K issues and 1.3 M comments from 518 open‐source projects. We analyze whether the newly emerged issues and developers share similar concepts or how aligned the individual developers' concepts are with the team over time. We also investigate the impact of leaving developers on the frequency of concepts. Finally, we also evaluate the soundness of our approach on a closed‐source software project, thus allowing the validation of the results from a practical standpoint. We find out that the ConceptRealm can represent the problem domain knowledge within a project and can be utilized to predict the alignment of developers with issues. We also observe that projects exhibit many keepers independent of project maturity and that abruptly leaving keepers correlates with a decline of their core concepts as the remaining developers cannot quickly familiarize themselves with those concepts. [ABSTRACT FROM AUTHOR]

Computer Algebra Systems (CAS) currently lack an effective auditory representation, with most existing solutions relying on screen readers that provide limited functionality. This limitation prevents blind users from fully understanding and interpreting mathematical expressions, leading to confusion and self-doubt. This paper addresses the challenges blind individuals face when comprehending mathematical expressions within a CAS environment. We propose "Math for Everybody" (Math4e, version 1.0), a software module to reduce barriers for blind users in education. Math4e is a Sonification Module for CAS that generates a series of auditory tones, prosodic cues, and variations in audio parameters such as volume and speed. These resources are designed to eliminate ambiguity and facilitate the interpretation and understanding of mathematical expressions for blind users. To assess the effectiveness of Math4e, we conducted standardized tests employing the methodologies outlined in the Software Engineering Body of Knowledge (SWEBOK), International Software Testing Qualifications Board (ISTBQ), and ISO/IEC/IEEE 29119. The evaluation encompassed two scenarios: one involving simulated blind users and another with real blind users associated with the "Asociación de Invidentes Milton Vedado" foundation in Ecuador. Through the SAM methodology and verbal surveys (given the condition of the evaluated user), results are obtained, such as 90.56% for pleasure, 90.78% for arousal, and 91.56% for dominance, which demonstrates significant acceptance of the systems by the users. The outcomes underscored the users' commendable ability to identify mathematical expressions accurately. [ABSTRACT FROM AUTHOR]

Software systems are often maintained by a group of experienced software developers in order to ensure that faults that may bring the system down are less likely. Large turnover in organizations such as CERN makes it important to think of ways of onboarding newcomers on a technical project rapidly. This paper focuses on optimizing the way that people get up-to-speed on the business logic and technologies used on the project by using a knowledge-imbued large language model that is enhanced using domain-specific knowledge from the group or team's internal documentation. The novelty of this approach is the gathering of all of these different open-source methods for developing a chatbot and using it in an industrial use-case. [ABSTRACT FROM AUTHOR]

Gamification, the integration of game design elements into non-game contexts, has gained prominence in the software engineering education and training realm. By incorporating elements such as points, badges, quests, and challenges, gamification aims to motivate and engage learners, potentially transforming traditional educational methods. This paper addresses the gap in systematic evaluations of gamification's effectiveness in software engineering education and training by conducting a comprehensive literature review of 68 primary studies. This review explores the advantages of gamification, including active learning, individualized pacing, and enhanced collaboration, as well as the psychological drawbacks such as increased stress and responsibility for students. Despite the promising results, this study highlights that gamification should be considered a supplementary tool rather than a replacement for traditional teaching methods. Our findings reveal significant interest in integrating gamification in educational settings, driven by the growing need for digital content to improve learning. [ABSTRACT FROM AUTHOR]

Early advances in quantum computing have provided new opportunities to tackle intricate problems in diverse areas such as cryptography, optimization, and simulation. However, current methodologies employed in quantum computing often require, among other things, a broad understanding of quantum hardware and low‐level programming languages, posing challenges to software developers in effectively creating and implementing quantum services. This study advocates the adoption of software engineering principles in quantum computing, thereby establishing a higher level of hardware abstraction that allows developers to focus on application development. With this proposal, developers can design and deploy quantum services with less effort, which is similar to the facilitation provided by service‐oriented computing for the development of conventional software services. This study introduces a continuous deployment strategy adapted to the development of quantum services that covers the creation and deployment of such services. For this purpose, an extension of the OpenAPI specification is proposed, which allows the generation of services that implement quantum algorithms. The proposal was validated through the creation of an application programming interface with diverse quantum algorithm implementations and evaluated through a survey of various developers and students who were introduced to the tool with positive results. [ABSTRACT FROM AUTHOR]

Summary: To ensure the quality of software systems, software engineers can make use of a variety of quality assurance approaches, for example, software testing, modern code review, automated static analysis, and build automation. Each of these quality assurance practices have been studied in depth in isolation, but there is a clear knowledge gap when it comes to our understanding of how these approaches are being used in conjunction, or not. In our study, we broadly investigate whether and how these quality assurance approaches are being used in conjunction in the development of 1454 popular open source software projects on GitHub. Our study indicates that typically projects do not follow all quality assurance practices together with high intensity. In fact, we only observe weak correlation among some quality assurance practices. In general, our study provides a deeper understanding of how existing quality assurance approaches are currently being used in Java‐based open source software development. Besides, we specifically zoom in on the more mature projects in our dataset, and generally we observe that more mature projects are more intense in their application of the quality assurance practices, with more focus on their ASAT usage, and code reviewing, but no strong change in their CI usage. [ABSTRACT FROM AUTHOR]

The use of search‐based software engineering to address model‐driven engineering activities (SBMDE) is becoming more popular. Many maintenance tasks can be reformulated as a search problem, and, when those tasks are applied to software models, the search strategy has to retrieve a model fragment. There are no studies on the influence of the search parameters when applied to software models. This article evaluates the impact of different search parameter values on the performance of an evolutionary algorithm whose population is in the form of software models. Our study takes into account the nature of the model fragment location problems (MFLPs) in which the evolutionary algorithm is applied. The evaluation searches 1895 MFLPs (characterized through five measures that define MFLPs) from two industrial case studies and uses 625 different combinations of search parameter values. The results show that the impact on the performance when varying the population size, the replacement percentage, or the crossover rate produces changes of around 30% in performance. With regard to the nature of the problems, the size of the search space has the largest impact. Search parameter values and the nature of the MFLPs influence the performance when applying an evolutionary algorithm to perform fragment location on models. Search parameter values have a greater effect on precision values, and the nature of the MFLPs has a greater effect on recall values. Our results should raise awareness of the relevance of the search parameters and the nature of the problems for the SBMDE community. [ABSTRACT FROM AUTHOR]

The responsibility for creating accessible software within the development of digital services is important for multiple reasons, mainly equity and inclusion. However, adopting and sustaining the development of accessible digital solutions has always been challenging, more so in countries that are relatively new to the concept of universal design, and physical and digital accessibility, and where legal sanctions are not yet established. This work investigates the technology scene in the State of Kuwait and analyses the responses of computing professionals with regard to their skills, best practices and procurement of accessible tech and to their level of awareness toward people with disabilities. The findings reveal a low level of awareness among tech professionals with regard to disabilities and digital accessibility-related standards. The findings also highlight a lack of available guidance for developing inclusive design and accessibility. Additionally, time constraints, lack of training, legal enforcement and fundamentals concepts during undergraduate and higher education contributed to observed weaknesses. Participants were keen to learn more and benefited from flyers and free professional development courses offered as incentives for survey completion. [ABSTRACT FROM AUTHOR]

The software maintenance process is costly, accounting for up to 70% of the total cost in the software development life cycle (SDLC). The difficulty of maintaining software increases with its size and complexity, requiring significant time and effort. One way to alleviate these costs is to automate parts of the maintenance process. This research focuses on the automation of the classification phase using decision trees (DT) to sort, rank, and accept/reject maintenance requests (MRs) for mobile applications. Our dataset consisted of 1,656 MRs. We found that DTs could automate sorting and accepting/rejecting MRs with accuracies of 71.08% and 64.15%, respectively, though ranking accuracy was lower at 50%. While DTs can reduce costs, effort, and time, human verification is still necessary. [ABSTRACT FROM AUTHOR]

Context: Quantum software development is a complex and intricate process that diverges significantly from traditional software development. Quantum computing and quantum software are deeply entangled with quantum mechanics, which introduces a different level of abstraction and a deep dependence on quantum physical properties. The classical requirements engineering methods must be adapted to encompass the essential quantum features in this new paradigm. Aim: This study aims to systematically identify and analyze challenges, opportunities, developments, and new lines of research in requirements engineering for quantum computing. Method: We conducted a systematic literature review, including three research questions. This study included 105 papers published from 2017 to 2024. Results: The main results include the identification of problems associated with defining specific requirements for quantum software and hybrid system requirements. In addition, we identified challenges related to the absence of standards for quantum requirements engineering. Finally, we can see the advances in developing programming languages and simulation tools for developing software in hybrid systems. Conclusions: This study presents the challenges and opportunities in quantum computing requirements engineering, emphasizing the need for new methodologies and tools. It proposes a roadmap for future research to develop a standardized framework, contributing to theoretical foundations and practical applications. [ABSTRACT FROM AUTHOR]

Effective project planning and management in the global software development landscape relies on addressing major issues like cost estimation and effort allocation. Timely estimation of software development is a critical focus in software engineering research. With the industry increasingly relying on diverse teams worldwide, accurate estimation becomes vital. Software size serves as a common measure for costs and schedules, but advanced estimation methods consider various variables, such as project purpose, personnel expertise, time and efficiency constraints, and technology requirements. Estimating software costs involve significant financial and strategic commitments, making it crucial to address complexity and versatility related to cost drivers. To achieve enhanced accuracy and convergence, we employ the cuckoo algorithm in our proposed NFDLNN (Neuro Fuzzy Logic and Deep Learning Neural Networks) model. Through extensive validation with industrial project data, using Function Point Analysis as the algorithmic models, our NFA model demonstrates high accuracy in software cost approximation, outperforming existing methods insights of MRE of 3.33, BRE of 0.13, and PI of 74.48. Our research contributes to improved project planning and decision-making processes in global software development endeavours. [ABSTRACT FROM AUTHOR]

We introduce PyVRP, a Python package that implements hybrid genetic search in a state-of-the-art vehicle routing problem (VRP) solver. The package is designed for the VRP with time windows (VRPTW) but can be easily extended to support other VRP variants. PyVRP combines the flexibility of Python with the performance of C++ by implementing (only) performance-critical parts of the algorithm in C++ while being fully customizable at the Python level. PyVRP is a polished implementation of the algorithm that ranked first in the 2021 DIMACS VRPTW challenge and, after improvements, ranked first on the static variant of the EURO meets NeurIPS 2022 vehicle routing competition. The code follows good software engineering practices and is well documented and unit tested. PyVRP is freely available under the liberal MIT license. Through numerical experiments, we show that PyVRP achieves state-of-the-art results on the VRPTW and capacitated VRP. We hope that PyVRP enables researchers and practitioners to easily and quickly build on a state-of-the-art VRP solver. History: Accepted by Ted Ralphs, Area Editor for Software Tools. This paper has been accepted for the INFORMS Journal on Computing Special Issue on Software Tools for Vehicle Routing. Funding: Funding was provided by TKI Dinalog, Topsector Logistics, and the Dutch Ministry of Economic Affairs and Climate Policy. Supplemental Material: The software that supports the findings of this study is available within the paper and its Supplemental Information (https://pubsonline.informs.org/doi/suppl/10.1287/ijoc.2023.0055) as well as from the IJOC GitHub software repository (https://github.com/INFORMSJoC/2023.0055). The complete IJOC Software and Data Repository is available at https://informsjoc.github.io/. There is a video associated with this paper. Click here to view the Video Overview. To save the file, right click and choose "Save Link As" from the menu. [ABSTRACT FROM AUTHOR]

Computational biological models have proven to be an invaluable tool for understanding and predicting the behaviour of many biological systems. While it may not be too challenging for experienced researchers to construct such models from scratch, it is not a straightforward task for early stage researchers. Design patterns are well-known techniques widely applied in software engineering as they provide a set of typical solutions to common problems in software design. In this paper, we collect and discuss common patterns that are usually used during the construction and execution of computational biological models. We adopt Petri nets as a modelling language to provide a visual illustration of each pattern; however, the ideas presented in this paper can also be implemented using other modelling formalisms. We provide two case studies for illustration purposes and show how these models can be built up from the presented smaller modules. We hope that the ideas discussed in this paper will help many researchers in building their own future models. [ABSTRACT FROM AUTHOR]

The lack of a common executable modeling framework that integrates systems engineering, software design, and other engineering domains is a major impediment to seamless product development processes. Our research aims to overcome this system‐software modeling gap by integrating computational, software‐related, and model execution capabilities into OPM‐based conceptual modeling, resulting in a holistic unified executable quantitative‐qualitative modeling framework. The gap is overcome via a Methodical Approach to Executable Integrative Modeling—MAXIM, an extension of OPM ISO 19450:2015, a standardization approvement given on 2015. We present the principles of MAXIM and demonstrate its operation within OPCloud—a web‐based collaborative conceptual OPM modeling framework. As a proof‐of‐concept, a model of an Airbus civil aircraft landing gear braking system is constructed and executed. Using MAXIM, engineers from five domains can collaborate at the very early phase of the system development and jointly construct a unified model that fuses qualitative and quantitative aspects of the various disciplines. This case study illustrates an important first step towards satisfying the critical and growing need to integrate systems engineering with software computations into a unified framework that enables a smooth transition from high‐level architecting to detailed, discipline‐oriented design. Such a framework is a key to agile yet robust future development of software‐intensive systems. [ABSTRACT FROM AUTHOR]

Blockchain technology has attracted significant attention in both academia and industry. Recently, the application of blockchain has been advocated in software engineering. The global software engineering paradigm exacerbates trust issues, as distributed and cross‐organizational teams need to share software artifacts. In such a context, there is a need for a decentralized yet reliable traceability knowledge base to keep track of what/how/when/by whom software artifacts were created or changed. This study presents a blockchain‐enabled framework for trustworthy and collaborative traceability management and identifies benefits, challenges, and potential improvements based on the feedback of software engineering experts. A qualitative approach was followed in this study through semistructured interviews with software engineering (SE) experts. Transcripts were analyzed by applying the content analysis technique. The results indicated the emergence of five categories, further grouped into three main categories: experts' perceptions, blockchain‐based software process improvement, and experts' recommendations. In addition, the findings suggested four archetypes of organizations that may be interested in blockchain technology: distributed organizations, organizations with contract‐based projects, organizations in regulated domains, and regulators who may push the use of this technology. Further efforts should be devoted to the integration of the proposal with tools used throughout the software development lifecycle and leveraging the potential of smart contracts in validating the implementation of requirements automatically. [ABSTRACT FROM AUTHOR]

Software development projects depend on collaborative teams. In the past 50 years of research, various studies have explored the effect of software engineer's personality traits and cultural values on team performance. These studies have led to better understand these relationships; however, how the personality traits and cultural values influence the team effectiveness is still far away in the literature. This research aims to investigate the relationships between social and psychological complexities (including personality traits and cultural values), team coordination, team motivation, and team success (which comprises team effectiveness and team climate) to explore the impact of social and psychological issues on software team success. An online survey targeting software development professionals and unstructured interviews were followed for data collection. We received 112 responses from software developers working in different countries. Findings indicate that personality traits and cultural values, that is, consciousness, openness, harmony, and autonomy, have positive relationship with team coordination effectiveness, while other factors such as neuroticism, embeddedness, hierarchy, and mastery were found to be related negatively with it. These negative relationships can be mitigated by motivating team members appropriately. Based on our research findings, we conclude that the negative impact caused by different personality and cultural traits could be reduced by improving team coordination effectiveness using effective motivation. [ABSTRACT FROM AUTHOR]