Search

As technology becomes increasingly integrated into our daily lives, the role of software engineering in promoting healthy lifestyles has become increasingly important. Software applications have permeated our routines and well-being. Scrum, unlike traditional methodologies, offers an agile, iterative, and client-centric approach to software engineering. It emphasizes frequent client involvement, adaptability to changing requirements, and early risk mitigation, fostering a dynamic and responsive development environment. This approach is particularly crucial in the realm of mobile application design. Meanwhile, Grounded Theory can enhance the understanding of the alignment between developers and users' needs. This paper presents a comprehensive exploration of the development journey of a mobile application designed for promoting health, utilizing the Scrum framework and Grounded Theory. The iterative process, based on qualitative research, encompasses requirements gathering, database design, interface development, and usability testing. The author introduces concepts and styles to define and simplify sprints for improved clarity and comprehension. The usability testing for the proposed application-based Scrum framework was evaluated by two groups: an expert group familiar with the application's functionality and a participant group with no prior experience. The chi-square analysis revealed no significant differences between the two groups in their performance of the set of tasks, suggesting the application was evaluated similarly. Furthermore, the results of the post-test questionnaire, specifically the System Usability Scale (SUS) measure, indicate that over 83% of the participants scored the application above 82, placing it in the "A" grade range and reflecting an excellent level of user satisfaction. The analysis of the gathered data yields valuable insights with practical implications for organizations aiming to optimize the effectiveness of their Scrum teams. The findings demonstrate the usability of the proposed application design, providing a framework for developing health-focused mobile applications using the Scrum framework. [ABSTRACT FROM AUTHOR]

Enterprise-resource-planning (ERP) systems are highly complex, incorporating critical data and configuration options that can easily cause security threats or risks. While product-line engineering (PLE) provides methods for dealing with configurability, security concerns are not of primary concern in established PLE frameworks. In this paper, we extend the perspectives of established PLE frameworks to incorporate security engineering for ERP systems. We build on a literature review of 15 years (2008-2022) of research on security engineering for ERP systems or product lines. Our framework incorporates three perspectives (i.e., application, security, and domain engineering) with 16 processes and 24 activities. We discuss our framework with respect to the ERP reference architecture and relevant security concerns. Our contributions are intended to help researchers and practitioners obtain a reference on how security engineering can be integrated into PLE for ERP systems. [ABSTRACT FROM AUTHOR]

A critical aspect of software engineering is Software fault prediction which aims to identify and prevent errors in software systems before their release which can cause failures or issues for its users. Various techniques and tools have been developed to detect software faults, including static code analysis, dynamic testing, and machine learning-based approaches. In past few years, the world has seen a growing interest in the use of ML models for predicting software faults, as they can effectively analyse high dimensional datasets and detect complex patterns which are difficult for human experts to detect. However, developing accurate and reliable software fault detection models requires careful selection of data, feature engineering, and model evaluation. This purpose of this paper is to present a comprehensive analysis of potential applications and future research directions in the field of software fault detection. The study emphasizes the importance of identifying and addressing software faults to ensure the reliability and efficiency of software systems. Additionally, the paper outlines various approaches and techniques that can be employed for effective software fault detection. [ABSTRACT FROM AUTHOR]

Machine learning is a popular tool for solving problems, however, incorporating it into a use case with additional business logic poses many challenges. Training, managing and storing many different models is not an easy task, requiring the use of multiple frameworks and languages. To take full advantage of existing frameworks it is necessary to facilitate communication between different programming languages. This paper presents an approach to integrating machine learning in a real-world use case which involves predicting demand for a diverse set of products and combining it with business rules and other components to establish a system that improves and automates the ordering process. Machine learning models are trained on real-world data from a retailer in Austria and the predictions are incorporated into a heuristic that controls and manages stock levels. This work focuses on the challenges that emerge from the integration of machine learning and presents a message bus based architecture to address them. [ABSTRACT FROM AUTHOR]

The ongoing digital transformation of industry is most clearly reflected in the increasing collection and analysis of data from various sources. Among these are sensor equipped machinery, telemetry in logistics or audiovisually monitored production floors. In order to utilize the data, e. g., to predict machinery malfunctions, its technically smooth consolidation is crucial. Therefore, numerous data interchange formats, protocols and middleware emerged over the past years. However, until today there is no gold standard technology stack for industrial data analysis, for multiple reasons, including the applications' heterogeneity. In this work, we present a software library which aims at decoupling messaging protocols and patterns from their implementation to overcome incompatibilities and, thus, facilitate data consolidation for software engineers. Moreover, we show how to use the library for rapidly modeling distributed cyber-physical systems using an integrated schema generation mechanism. Based on one real-world and one synthetic use case, we evaluate the library's applicability, discuss open issues and outline planned features. [ABSTRACT FROM AUTHOR]

Conversational agents (CA) are software programs that can converse with users using natural language. They are now widely used in various domains, such as tourism, healthcare, and others, to perform tasks and provide permanent assistance to users by interacting with them in natural language. The development of such applications is a task that requires expertise in several fields, such as software engineering, machine learning, deep learning, and natural language processing (NLP). However, several platforms and frameworks on the market facilitate the building of CA, such as Dialogflow, Rasa, and others. Recently, several research studies have proposed solutions to reduce the workload of developers and designers by offering their model-driven development approaches using domain-specific languages (DSLs), which facilitate the automation of the development of CA. This work aims to provide an Overview of CA to identify and describe their architecture and the details of its key components. and discuss the tools and technologies for their development. At the same time, discover the research topics that focus on using DSLs for model-driven development to automate and speed up the creation of these agents and discover approaches and technologies employed to implement each of these DSLs. [ABSTRACT FROM AUTHOR]

ChatGPT has shown great potential in the field of software engineering with its ability to generate code. Yet, ChatGPT's ability to interpret code has been deemed unreliable and faulty, which causes concern for the platform's ability to properly refactor code. To confront this concern, we carried out a study to assess ChatGPT's abilities and limitations in refactoring code. We divided the study into three parts: if ChatGPT can refactor the code, if the refactored code preserves the behavior of the original code segments, and if ChatGPT is capable of providing documentation for the refactored code to provide insights into intent, instructions, and impact. We focused our research specifically on eight quality attributes to use when prompting ChatGPT to refactor our dataset of 40 Java code segments. After collecting the refactored code segments from ChatGPT, as well as data on whether the behavior was preserved, we ran the refactored code through PMD, a source code analyzer, to find programming flaws. We also tested ChatGPT's accuracy in generating documentation for the refactored code and analyzed the difference between the results of each quality attribute. We conclude that ChatGPT can provide many useful refactoring changes that can improve the code quality which is crucial. ChatGPT offered improved versions of the provided code segments 39 out of 40 times even if it is as simple as suggesting clearer names for variables or better formatting. ChatGPT was able to recommend numerous options ranging from minor changes such as renaming methods and variables to major changes such as modifying the data structure. ChatGPT's strengths and accuracy were in suggesting minor changes because it had difficulty addressing and understanding complex errors and operations. Although most of the changes were minor, they made significant improvements because converting loops, simplifying calculations, and removing redundant statements have a crucial effect on runtime, memory, and readability. However, our results also indicate how ChatGPT can be unpredictable in its responses which threatens the reliability of ChatGPT. Asking ChatGPT the same prompt often yields different results, so some outputs were more accurate than others. This makes it difficult to fully access ChatGPT's capabilities due to its variation and inconsistency. Due to ChatGPT's limitations of its reliance on its data set, it lacks understanding of the broader context so it may occasionally make errors and suggest alternations that are neither applicable nor necessary. Overall, ChatGPT has proved to be a beneficial tool for programming as it is capable of providing advantageous suggestions, even if it is on a small scale. However, human programmers are still needed to oversee these changes and determine their significance. ChatGPT should be used as an aid to programmers since we cannot completely depend on it yet. [ABSTRACT FROM AUTHOR]

Correctly adhering to the processes within the software development life cycle (SDLC), from analysis and design to coding and testing, is vital for ensuring the successful and efficient creation of high-quality software applications. These structured phases provide a systematic approach to software development, facilitating clear communication, reducing errors, and improving collaboration among development teams. For the proper and correct use of SDLC processes, it is essential for both software engineers and software decision makers to perform the correct and needed actions while performing each software process, and one method of facilitating that is multicriteria decision making (MCDM). This study aims to provide a systematic review of the use of MCDM within the field of software engineering (SE), encompassing methodologies such as fuzzy MCDM, AHP, TOPSIS, DEMATEL, and other methods, with a deliberate focus on software engineering development processes. To ensure the high quality of this review, a methodical and structured literature search process was performed with strict selection criteria, resulting in the identification of 32 contributions on the applications of MCDM in SE from various databases, including Scopus, ScienceDirect, IEEE Xplore digital library (IEEE), and Web of Science (WOS). The selected papers were taxonomized into seven main categories, with some divided into subcategories. This paper presents a systematic and comprehensive analysis of the aforementioned studies, investigating the challenges, motivations, and recommendations found within each, thereby paving the way for potential future research. Bibliometric analysis is also provided to show concise quantitative analysis of related bibliographic information, which draws several key insights into publication trends. Finally, a critical analysis of the current literature and existing research is presented, while also addressing relevant research gaps. • Investigates the taxonomy of MCDM applicability in software engineering. • Provides four bibliometric analyses and insights into the research landscape. • Explores data quality issues, high computation time, and sampling bias. • Illustrates perspectives on motivations, challenges, and recommendations. • Identifies a critical analysis and research gaps in MCDM-software engineering. [ABSTRACT FROM AUTHOR]

The study was conducted on 125 US based high-tech firms from software engineering, hardware production, biotechnology, and telecommunications. Senior-level executives, including CEOs, board members, and CTOs, provided insights through structured questionnaires. Key findings indicate that AI adoption significantly enhances organizational capabilities in terms of employees' innovation, creativity, and experimentation. Moreover, AI adaptation positively impacts decision making thus yielding more accurate and timely valuable decisions. These findings contribute to both theoretical understanding and managerial practice by guiding strategic investments in AI technologies, fostering innovation, and advocating for ethical AI deployment practices. Future study should examine longitudinal impacts across industries and regions to optimize benefits and minimize risks in digital transformation efforts. It should also integrate qualitative methods for deeper insights and appropriate AI governance systems. [ABSTRACT FROM AUTHOR]

Code smell detection is one of the essential tasks in the field of software engineering. Identifying whether a code snippet has a code smell is subjective and varies by programming language, developer, and development method. Moreover, developers tend to focus on code smells that have a real impact on development and ignore insignificant ones. However, existing static code analysis tools and code smell detection approaches exhibit a high false positive rate in detecting code smells, which makes insignificant smells drown out those smells that developers value. Therefore, accurately reporting those actionable code smells that developers tend to spend energy on refactoring can prevent developers from getting lost in the sea of smells and improve refactoring efficiency. In this paper, we aim to detect actionable code smells that developers tend to refactor. Specifically, we first collect actionable and non-actionable code smells from projects with numerous historical versions to construct our datasets. Then, we propose a dual-stream model for fusion learning of code metrics and code semantics to detect actionable code smells. On the one hand, code metrics quantify the code's structure and even some rules or patterns, providing fundamental information for detecting code smells. On the other hand, code semantics encompass information about developers' refactoring tendencies, which prove valuable in detecting actionable code smells. Extensive experiments show that our approach can detect actionable code smells more accurately compared to existing approaches. • We provide a method to collect actionable code smells automatically. • We propose a dual-stream model for detecting and identifying actionable code smells. • We comprehensively evaluate our approach on the publicly available and collected datasets. • We provide several valuable suggestions for practitioners and a benchmark for identifying actionable code smells. [ABSTRACT FROM AUTHOR]

Natural Language-based Source Code Generation (NLSCG) holds the promise to revolutionize the way how software is developed by means of facilitating a collection of intelligent technical enablers, based on sustained improvements on the natural language to source code pipelines and continuous adoption of new coding paradigms. In recent years, a large variety of NLSCG technical solutions have been proposed, and quite exciting experimental results have been reported. Meanwhile, current researches and initiative application projects in this area reflect a large diversity of NLSCG contexts and of major technical enablers. Such heterogeneity, fragmentation, and vagueness of the NLSCG technical landscape are currently frustrating the full realization of the NLSCG research and application vision. Players in this field could not find systematic guidelines on how to effectively address the "known unknowns" and how to simply spot the "unknown unknowns", which eventually hinder the turning of NLSCG solutions into further research enhancements or production applications. Understanding the context, boundaries, capabilities, and integrations of NLSCG enablers is considered as one of the key drivers for the more practical application of NLSCG models. In this paper, we analyze in detail the natural language to source code pipelines and the evolvement of source code generation tasks, by considering both the problem context and technological aspects. A foresight reference framework for NLSCG is proposed to help handle the source code generation tasks with proper intelligent models. We review the present-day NLSCG technical landscape, as well as the core technical enablers along the source code generation pipelines. Relevant experiments are conducted to validate the role of representative models across different technical enablers on typical datasets, and we finally highlight the contribution of different enablers to code generation capabilities. [ABSTRACT FROM AUTHOR]

The quality of software projects is measured by different attributes such as efficiency, security, robustness, or understandability, among others. In this paper, we focus on maintainability by studying the optimization of software modularity, which is one of the most important aspects in this regard. Specifically, we study two well-known and closely related multi-objective optimization problems: the Equal-size Cluster Approach Problem (ECA) and the Maximizing Cluster Approach Problem (MCA). Each of these two problems looks for the optimization of several conflicting and desirable objectives in terms of modularity. To this end, we propose a method based on the Multi-Objective Variable Neighborhood Search (MO-VNS) methodology in combination with a constructive procedure based on Path-Relinking. As far as we know, this is the first time that a method based on MO-VNS is proposed for the MCA and ECA problems. To enhance the performance of the proposed algorithm, we present three advanced strategies: an incremental evaluation of the objective functions, an efficient exploration of promising areas in the search space, and an analysis of the objectives that better serve as guiding functions during the search phase. Our proposal has been validated by experimentally comparing the performance of our algorithm with the best previous state-of-the-art method for the problem and three reference methods for multi-objective optimization. The experiments have been performed on a set of 124 real software instances previously reported in the literature. [ABSTRACT FROM AUTHOR]

Understanding the way, developers perform different software development and management tasks with objective measures can support improving potency and performance. Exploring the cognitive skills of programmers in software engineering has been the focus of immense and ongoing research for beyond 30 years. This work aims to combine and analyze different cognitive aspects such as psychology, understanding of program comprehension, and emotions of developers in the software engineering field, by conducting a Systematic Literature Review (SLR). We collected more than 300 articles from 7 major digital libraries and narrowed them down by selecting the 80 most relevant articles. Moreover, we framed six research questions and justified each question with the help of tables and graphs. Furthermore, we generated a classification scheme for each article, based on the justification of 10 quality assessment queries. Our analysis based on research questions shows that most of the research articles (12/80) published in the field of cognitive aspects are after the year 2017. In our SLR 39/80 articles are published in reputed journals. To measure developers' cognitive abilities, 48/80 studies used particular bio measures. Most of the articles (19/80) employed student datasets in their experiments. In the case of the research methodology used, 23/80 of the articles are validation studies and 22/80 are experimental lab studies. In exploring the sensors, 37 % of the studies in which sensors were used to analyze cognitive features have applied multimodal sensors, while the rest of the studies used individual sensors according to their requirement such as Eye trackers, fMRI, fNIRS, etc. Exploring the range of the participants engaged in the experiments in various studies, 18 % of the total studies involved participants in the range of 11–20 and 27 % of studies did not mention the number of participants. The research implications of this review work will be the assessment of the understanding level of a programmer while developing or comprehending a program. This combined analysis will be helpful for the professionals or field experts to perform a better analysis of different cognitive features of developers in the software engineering field and for that analysis, they will be able to select more optimal bio measures, sensors, and methodologies over different conditions. [ABSTRACT FROM AUTHOR]

Epidemiological modeling is a key lever for infectious disease control and prevention on farms. It makes it possible to understand the spread of pathogens, but also to compare intervention scenarios even in counterfactual situations. However, the actual capability of decision makers to use mechanistic models to support timely interventions is limited. This study demonstrates how artificial intelligence (AI) techniques can make mechanistic epidemiological models more accessible to farmers and veterinarians, and how to transform such models into user-friendly decision-support tools (DST). By leveraging knowledge representation methods, such as the textual formalization of model components through a domain-specific language (DSL), the co-design of mechanistic models and DST becomes more efficient and collaborative. This facilitates the integration of explicit expert knowledge and practical insights into the modeling process. Furthermore, the utilization of AI and software engineering enables the automation of web application generation based on existing mechanistic models. This automation simplifies the development of DST, as tool designers can focus on identifying users' needs and specifying expected features and meaningful presentations of outcomes, instead of wasting time in writing code to wrap models into web apps. To illustrate the practical application of this approach, we consider the example of Bovine Respiratory Disease (BRD), a tough challenge in fattening farms where young beef bulls often develop BRD shortly after being allocated into pens. BRD is a multi-factorial, multi-pathogen disease that is difficult to anticipate and control, often resulting in the massive use of antimicrobials to mitigate its impact on animal health, welfare, and economic losses. The DST developed from an existing mechanistic BRD model empowers users, including farmers and veterinarians, to customize scenarios based on their specific farm conditions. It enables them to anticipate the effects of various pathogens, compare the epidemiological and economic outcomes associated with different farming practices, and decide how to balance the reduction of disease impact and the reduction of antimicrobial usage (AMU). The generic method presented in this article illustrates the potential of artificial intelligence (AI) and software engineering methods to enhance the co-creation of DST based on mechanistic models in veterinary epidemiology. The corresponding pipeline is distributed as an open-source software. By leveraging these advancements, this research aims to bridge the gap between theoretical models and the practical usage of their outcomes on the field. • AI makes mechanistic epidemiological models usable to support decisions on farms. • Structured text for knowledge representation enhances collaborative tool design. • AI and software engineering automate web application generation for disease control. • The resulting code for creating decision-support tools from models is open-source. [ABSTRACT FROM AUTHOR]

The Virtual Special Issue "Agents for Theory" discusses theory development using agent-based models (ABMs). The six contributions focus on how the word "theory" is used in the ABM literature, how reviews of ABMs should be conducted to gain general insights, how even the conceptualisation of ABMs can help to transform heuristic theories into scientific ones, how the context-dependent choice of decision models can be better justified, how reusable building blocks (RBBs) of ABMs could support theory development, and how a modular framework of RBBs can be used to identify general solutions. Overall, theories of decision making that go into ABMs and theories of system dynamics that come out of ABMs are interrelated, so the micro-macro perspective and the attempt to identify and reproduce patterns at both levels simultaneously is a way forward. Theory development requires clearer communication using a common language, reference to patterns, and more detailed model analysis and testing. • We provide a detailed summary of the Special Issue on theory development with agent-based modelling. • The Special Issue condenses discussions between experts from a wide range of disciplines. • Clearer communication of context and a stronger focus on reproducing multiple patterns are suggested as a way forward. • We outline a vision of how the virtual laboratory provided by ABMs may be leveraged to foster theory development. [ABSTRACT FROM AUTHOR]

Quantum computers (QCs) aim to disrupt the status-quo of computing – replacing traditional systems and platforms that are driven by digital circuits and modular software – with hardware and software that operate on the principle of quantum mechanics. QCs that rely on quantum mechanics can exploit quantum circuits (i.e., quantum bits for manipulating quantum gates) to achieve 'quantum computational supremacy' over traditional, i.e., digital computing systems. Currently, the issues that impede mass-scale adoption of quantum systems are rooted in the fact that building, maintaining, and/or programming QCs is a complex and radically distinct engineering paradigm when compared to the challenges of classical computing and software engineering. Quantum service orientation is seen as a solution that synergises the research on service computing and quantum software engineering (QSE) to allow developers and users to build and utilise quantum software services based on pay-per-shot utility computing model. The pay-per-shot model represents a single execution of instruction on quantum processing unit and it allows vendors (e.g., Amazon Braket) to offer their QC platforms, simulators, and software services to end-users. This research contributes by (i) developing a reference architecture for enabling Quantum Computing as a Service (QCaaS), (ii) implementing microservices with the quantum-classic split pattern as an architectural use-case, and (iii) evaluating the architecture based on practitioners' feedback. The proposed reference architecture follows a layered software pattern to support the three phases of service lifecycle namely development , deployment , and split of quantum software services. In the QSE context, the research focuses on unifying architectural methods and service-orientation patterns to promote reuse knowledge and best practices to tackle emerging and futuristic challenges of architecting QCaaS. [ABSTRACT FROM AUTHOR]

Code smells in software indicate poor design and implementation choices. Detecting and removing them is critical for sustainable software development. Machine learning (ML) can automate code smell detection. Most ML solutions train models from scratch on code smell datasets, using handcrafted source code metrics as features. Pretrained language models, like BERT, fueled a paradigm shift in natural language processing: from handcrafted features to automatically inferred features and from training models from scratch to using pretrained models. Code embeddings offer the potential to bring a similar paradigm shift to code analysis. Nevertheless, the potential of using pretrained neural code embeddings for code smell detection has yet to be fully explored. To this end, we evaluated ML models trained using different code representations: code metrics and state-of-the-art neural code embeddings (CodeT5 and CuBERT). We experimented with CodeT5 variants (base and small) and explored multiple ways of embedding code snippets (by combining line-level embeddings or passing the entire code snippet as input). We tested our approaches on the tasks of detecting Data Class and Feature Envy on the MLCQ dataset. Considering the results of this study and our previous research, performance-wise, there is no clear winner between using code metrics or code embeddings for different code smell types and programming languages. However, given that, in contrast to code metrics, code embeddings can automatically adapt to new programming constructs and are expected to scale better with dataset size, these models are likely to become the future state-of-the-art feature generation technique for code smell detection. • We detect Feature Envy and Data Class code smells using pre-trained code embeddings. • We compare handcrafted code metrics with automatically inferred code embeddings. • We test the performance of smell detectors on the large manually labeled dataset. • Embedding capture crucial semantics and do not suffer metric extraction limitations. • Code embedding and code metrics have comparable smell detection performance. [ABSTRACT FROM AUTHOR]

Software Product Lines (SPLs) constitute a popular method for encouraging the methodical reuse of software artefacts. Just like any other piece of software, SPLs require management throughout their evolution, namely to preserve the consistency between requirements and the code. Over time, for a given SPL, many change requests are made and all of them need to be integrated in a consistent and coordinated way. The evolution of an SPL is facilitated if there exist links between its artefacts, namely between each feature and its respective pieces of implementation code. This paper proposes FMap, a systematic feature mapping approach to be used within SPLs. FMap traces a Feature Model (FM) to other artefacts of an SPL, the reference architecture, and the code, and it establishes connections between each feature of the FM and its locations in the code-base. Additionally, we have created a tool called friendlyMapper to provide some automatic support for the approach. Using two case studies from two different companies, FMap and friendlyMapper are evaluated. The evaluation of the case studies indicates that the FMap approach outperforms the baseline approach (i.e., the branching approach). This work contributes with FMap, a novel tool-based approach that supports feature-architecture-code mappings based on reference architecture. FMap assists software engineers in adapting the evolution of the SPLs to accommodate new features and change requests as the SPLs evolve. The case studies for both companies demonstrate that the approach is applicable to real-world products and is able to support feature traceability and maintain consistency among features, architecture, and code. [ABSTRACT FROM AUTHOR]

Academic genealogy (AG) provides valuable insights into the transmission of knowledge from mentors to mentees, revealing the evolution of knowledge within the academic community. This study explores the intricate dynamics of knowledge evolution within academic genealogies, utilizing on a dataset comprising 16,852 computer science researchers, 613,277 papers, and 11,988 mentorship relationships. By focusing on small-scale knowledge units, our analysis aims to uncover patterns of knowledge inheritance and mutation across different subfields of computer science and highlights several aspects of knowledge evolution in computer science. Firstly, computer science is characterized by strong mentorship ties, indicating the significance of knowledge transmission within the field. Additionally, there is a mix of foundational and developing areas, suggesting a field that is growing and diversifying rather than declining, as indicated by linear regression outcomes. Secondly, our research reveals a surge in collaborative knowledge exchange in computer science since 2000, with fields such as Computer-Communication Networks and Software Engineering leading in terms of output and impact. Furthermore, areas like Computer Graphics and Artificial Intelligence stand out for their depth and novelty. Thirdly, we categorize researchers into three types: roots, branches, and leaves, reflecting their role in knowledge transmission. Branch researchers tend to innovate, while leaf researchers show a combination of traditional knowledge uptake and new contributions, illustrating the dynamic flow of ideas within the field. Future research endeavors are encouraged to embrace larger datasets and further fortify our understanding of the topic. [ABSTRACT FROM AUTHOR]

Despite the increasing use of standards for documenting and testing agent-based models (ABMs) and sharing of open access code, most ABMs are still developed from scratch. This is not only inefficient, but also leads to ad hoc and often inconsistent implementations of the same theories in computational code and delays progress in the exploration of the functioning of complex social-ecological systems (SES). We argue that reusable building blocks (RBBs) known from professional software development can mitigate these issues. An RBB is a submodel that represents a particular mechanism or process that is relevant across many ABMs in an application domain, such as plant competition in vegetation models, or reinforcement learning in a behavioural model. RBBs need to be distinguished from modules, which represent entire subsystems and include more than one mechanism and process. While linking modules faces the same challenges as integrating different models in general, RBBs are "atomic" enough to be more easily re-used in different contexts. We describe and provide examples from different domains for how and why building blocks are used in software development, and the benefits of doing so for the ABM community and to individual modellers. We propose a template to guide the development and publication of RBBs and provide example RBBs that use this template. Most importantly, we propose and initiate a strategy for community-based development, sharing and use of RBBs. Individual modellers can have a much greater impact in their field with an RBB than with a single paper, while the community will benefit from increased coherence, facilitating the development of theory for both the behaviour of agents and the systems they form. We invite peers to upload and share their RBBs via our website - preferably referenced by a DOI (digital object identifier obtained e.g. via Zenodo). After a critical mass of candidate RBBs has accumulated, feedback and discussion can take place and both the template and the scope of the envisioned platform can be improved. • Reusable Building Blocks (RBBs) are effective in software development but are underrepresented in agent-based modelling. • RBBs describe individual mechanisms or processes, distinguishing them from modules that represent entire subsystems. • We present a first website that demonstrates how a RBB template and repository can be organized. • Examples of RBBs are provided to illustrate the concept, fostering discussion and encouraging further refinement. [ABSTRACT FROM AUTHOR]

• Proposing an iterative and incremental knowledge management model for problem solving. • Developing a new search intent predicting method. • Designing a knowledge learning strategy addressing knowledge visualization techniques. • Achieving an interactive healthcare knowledge management system. Healthcare is a knowledge intensive process, which requires large amount of information from various healthcare knowledge providers. However, this growing information makes challengeable for users in finding useful healthcare information to support their healthcare decision making. Knowledge management and knowledge management systems are drawing increasing attention in healthcare community. This paper proposes an online healthcare knowledge management framework and system prototype, featured with integrating knowledge learning and exploratory search for solving problems efficiently. Inspired by the knowledge to action framework in healthcare and the iterative process in software engineering, an iterative and incremental knowledge management model is designed to organize the activities during the knowledge learning and searching procedure. Supported by the knowledge-enhanced infrastructure of online healthcare information designed, domain knowledge learning and task knowledge learning environment can work collaboratively and interactively to improve the result of learning and exploratory search. Knowledge base also provides helpful information in an interactive way for solving problems. Given exploiting probabilistic information retrieval model and concept semantics described in Description Logics, a search intent discovery method and search intent guided learning and searching mechanism are designed within this environment for achieving the learning and search goal. The results of the experiments have proved the efficacy of the methods and process model used in the leaning-focused healthcare knowledge management system. [ABSTRACT FROM AUTHOR]

• Comprehensiveness of the proposed model. Introducing a model that supports most features that a developer needs to extract from source code. • Extensibility of the proposed model. All models are designed independently of programming languages ​​to support all object-oriented languages. • Ease of use of the proposed model. Any features with any kind of complexity can be extracted just by writing a SQL command or its extensions. • New data model. Proposing a new data model to store all artifacts of source code and their relations aiming to extract the required features. Providing models that enable developers, architects, and executives to make intelligent decisions about software projects is imperative. Static analyzer tools can extract the information required by developers from the source code to achieve various goals. There are generally two types of tools for analyzing source codes in the software engineering community: commercial tools and open-source tools. Commercial tools provide a limited set of features, pre-built by the tool developers, for extracting information from source code. Open-source tools, while also having limited features, often have fewer features than commercial tools. Extending open-source tools to support new and unembedded features requires a complete knowledge of the programming language used in the tools as well as the architecture used in the modules of tools. Additionally, tool extension requires a complete knowledge of the Abstract Syntax Tree (AST) structure used in those tools. To overcome existing problems, this paper proposes a new model named Sahand, which utilizes a Relational Database Repository (RDP) to store the source code. To this end, utilizing RDP, we propose a new data model to store the source code of the object-oriented projects aiming to extract the required information from it. This new data model provides an infrastructure for developers to extract information from the source code using only the SQL language or its extensions. This model facilitates the extraction of previously inaccessible information, such as the maximum depth of the inheritance tree in the entire project or the maximum method call sequence in the project. The proposed model has been further investigated using two large-scale projects namely JavaParser and Tomcat, consisting of 1802 and 3566 classes, respectively. All source codes and database model used for Sahand are open-source and can be accessed at https://github.com/gClassAcademy/Sahand. [ABSTRACT FROM AUTHOR]

• ClimMob is a software package that facilitates experimental citizen science in agriculture. • ClimMob was designed to support tricot, a citizen science approach which allows farmers to make simple comparisons between crop varieties. • ClimMob facilitates implementation of experimental citizen science at scale. Experimental citizen science offers new ways to organize on-farm testing of crop varieties and other agronomic options. Its implementation at scale requires software that streamlines the process of experimental design, data collection and analysis, so that different organizations can support trials. This article considers ClimMob software developed to facilitate implementing experimental citizen science in agriculture. We describe the software design process, including our initial design choices, the architecture and functionality of ClimMob, and the methodology used for incorporating user feedback. Initial design choices were guided by the need to shape a workflow that is feasible for farmers and relevant for farmers, breeders and other decision-makers. Workflow and software concepts were developed concurrently. The resulting approach supported by ClimMob is triadic comparisons of technology options (tricot), which allows farmers to make simple comparisons between crop varieties or other agricultural technologies tested on farms. The software was built using Component-Based Software Engineering (CBSE), to allow for a flexible, modular design of software that is easy to maintain. Source is open-source and built on existing components that generally have a broad user community, to ensure their continuity in the future. Key components include Open Data Kit, ODK Tools, PyUtilib Component Architecture. The design of experiments and data analysis is done through R packages, which are all available on CRAN. Constant user feedback and short communication lines between the development teams and users was crucial in the development process. Development will continue to further improve user experience, expand data collection methods and media channels, ensure integration with other systems, and to further improve the support for data-driven decision-making. [ABSTRACT FROM AUTHOR]

This paper presents ThreadAbs , an extension of the layer-based software formal verification toolkit CCAL (Gu et al., 2018). ThreadAbs is specifically designed to provide better expressiveness and proof management for thread abstraction in multithreaded libraries. Thread abstraction isolates the behavior of each thread from others when providing a top-level formal specification for software. Compared to the original CCAL , ThreadAbs offers significant improvements in this regard. CCAL is a verification framework that enables a layered approach to building certified software, as demonstrated by multiple examples (Gu et al. 2016; Li et al. 2021; Shin et al. 2019). Obviously, its main targets usually include multithread libraries, which support significant improvement in the utilization and isolation of system resources. However, it poses new challenges for formal verification. Firstly, it requires a sudden change in the granularity of concurrency during the implementation and verification of the target software. Typically, systems are associated with software schedulers that are built on top of several underlying components in the system (e.g. , thread spawn, yield, sleep, and wake-up). Due to the software scheduler, these systems can be divided into low-level components consisting of modules that the software scheduler depends on (e.g. , allocators for shared resources and scheduling queues) and high-level components that use software schedulers (e.g. , condition variables, semaphores, and IPCs). Therefore, software formal verification on those systems has to provide proper method to deal with those distinct features, which is usually abstracting other threads' behavior as much as possible to provide an independent thread model and its formal specification. Secondly, it requires handling side effects from other threads, such as dynamic resource allocation from parents with proper isolation of all threads from each other. CCAL has limited support for two crucial aspects of formal verification in multithreaded systems. Firstly, its previous thread abstraction method does not handle the side effects caused by a parent thread during dynamic initial state allocation properly. Secondly, the proofs produced by CCAL are tied to CertiKOS , which makes it challenging to use them for similar proofs that use CCAL as their verification toolkit. To address these issues, we introduce ThreadAbs , a new mechanized methodology that provides proper thread abstraction to reason about multithreaded programs in conjunction with CCAL. We also extend the previous CertiKOS proof with ThreadAbs to demonstrate its usability and expressiveness. [ABSTRACT FROM AUTHOR]

Retrieving relevant source code from large repositories is a significant and ongoing challenge in the field of software engineering, primarily due to the vast and ever-expanding amount of available code. Existing deep learning methods, although effective to some extent, exhibit limitations in capturing the intricate and complex structural information embedded within source code, which hinders their ability to provide highly accurate retrieval results. This study endeavors to tackle this prominent issue by introducing a novel and innovative approach known as the Joint Bi-directional LSTM and Graph Neural Networks (JBLG) model for source code retrieval. The central aim is to harness the combined strengths and capabilities of Bi-directional Long Short-Term Memory (LSTM) networks and Graph Neural Networks (GNNs) to significantly enhance the model's capacity to capture and interpret the complex structural characteristics intrinsic to source code. The proposed JBLG model employs a unique fusion of Bi-directional LSTM, which excels in capturing sequential and temporal dependencies within code, and GNN, which is adept at modeling the intricate graph structure of the code. By leveraging this hybrid architecture, the model aims to provide a comprehensive and highly effective solution for source code retrieval tasks. To assess the efficacy of the JBLG model, extensive experiments are conducted, and the model's performance is evaluated against well-established benchmarks, including LSTM, GNN, and ChatGPT, using two diverse datasets: CodeSearchNet and CosBench datasets. These evaluations span multiple programming languages, ensuring a comprehensive and robust assessment of the model's capabilities. The experimental results indicate that the JBLG model consistently outperforms its counterparts, including Bi-LSTM, GNN, ChatGPT, and DGMS, across various evaluation metrics. the JBLG model showcases an exceptional ability to handle and extract the intricate structural information inherent in source code, resulting in significantly enhanced retrieval accuracy. The JBLG model emerges as a highly promising solution for real-world source code retrieval applications, with the potential to revolutionize the field. The success of this model underscores the importance of combining deep learning techniques like Bi-directional LSTM and GNNs for tackling complex software engineering challenges. Furthermore, future research directions could involve exploring advanced techniques such as attention mechanisms and extending the model's applicability to other software engineering tasks like code summarization and code completion. The findings of this study are expected to have a lasting impact on the advancement of source code retrieval methodologies. [ABSTRACT FROM AUTHOR]

Quantum physics has changed the way we understand our environment, and one of its branches, quantum mechanics, has demonstrated accurate and consistent theoretical results. Quantum computing is the process of performing calculations using quantum mechanics. This field studies the quantum behavior of certain subatomic particles (photons, electrons, etc.) for subsequent use in performing calculations, as well as for large-scale information processing. These advantages are achieved through the use of quantum features, such as entanglement or superposition. These capabilities can give quantum computers an advantage in terms of computational time and cost over classical computers. Nowadays, scientific challenges are impossible to perform by classical computation due to computational complexity (more bytes than atoms in the observable universe) or the time it would take (thousands of years), and quantum computation is the only known answer. However, current quantum devices do not have yet the necessary qubits and are not fault-tolerant enough to achieve these goals. Nonetheless, there are other fields like machine learning, finance, or chemistry where quantum computation could be useful with current quantum devices. This manuscript aims to present a review of the literature published between 2017 and 2023 to identify, analyze, and classify the different types of algorithms used in quantum machine learning and their applications. The methodology follows the guidelines related to Systematic Literature Review methods, such as the one proposed by Kitchenham and other authors in the software engineering field. Consequently, this study identified 94 articles that used quantum machine learning techniques and algorithms and shows their implementation using computational quantum circuits or ansatzs. The main types of found algorithms are quantum implementations of classical machine learning algorithms, such as support vector machines or the k-nearest neighbor model, and classical deep learning algorithms, like quantum neural networks. One of the most relevant applications in the machine learning field is image classification. Many articles, especially within the classification, try to solve problems currently answered by classical machine learning but using quantum devices and algorithms. Even though results are promising, quantum machine learning is far from achieving its full potential. An improvement in quantum hardware is required for this potential to be achieved since the existing quantum computers lack enough quality, speed, and scale to allow quantum computing to achieve its full potential. [ABSTRACT FROM AUTHOR]

We report on our success stories in developing and using Model-Driven Engineering (MDE) tools for information systems on real-world projects within different application domains. It is necessary that we ensure the extensibility and adaptability of code generators if we want to reuse them for different domains. Up to now, research on reusing software has been mainly conducted in the software product line community but rarely discussed in the context of code generators. This paper introduces the generation framework MontiGem and shows how it has been used and evolved within five different research and industry projects in the domains of financial management, IoT, energy management, privacy policy, and wind turbine engineering. We have developed the code generator within the first project and further refined it with each of the following projects. This paper describes the projects, shows how MDE helped us in the software engineering process, and discusses the lessons we learned. These examples show how MDE techniques can be successfully applied to the development of information systems in practice, although further requirements have been met over time. [ABSTRACT FROM AUTHOR]

The description of complex river environments requires interdisciplinary approaches to collect and manage manifold data types and sources. Deriving comprehensive knowledge from complex data sources is challenging and necessitates not only knowledge of environmental science but also statistics and Software engineering. This study introduces a relational database framed in an application called River Analyst for creating and managing river data with open-source standards (Python3 and Django). We conceptualize data models of river environments, which describe sediment characteristics and hydraulics related to hyporheic exchange. River Analyst enabled us to derive novel insights for restoring rivers affected by so-called riverbed clogging, notably, fine sediment infiltration in the hyporheic zone. The database analysis reveals that clogging is not a dominant control process when the fraction of fine sediment exceeds 50%–55%. In conclusion, the new Software holds promise for data-informed advancements in augmenting knowledge to restore ecologically functional hydro-environments. • A database app in Django enables scalable, centralized management of fluvial data. • Database scheme enhances data analysis through linked parametrical data. • Open-source framework can leverage data-driven decisions for river restoration. [ABSTRACT FROM AUTHOR]

Accessible design focuses on enabling as many people as possible to access software products and services, which has drawn extensive attention from software engineering researchers and developers. Currently, developers are improving the accessibility of software in a simple way, and researchers are putting much effort into investigating the characteristics of accessibility issues. No studies have explored the interaction of accessibility with other factors that affect software performance, although some researchers have found that these accessibility problems interact with other quality attributes (e.g., functionality , efficiency , and security) when they categorize accessibility issues. To fill this gap, we conducted the first comprehensive study to characterize symptoms, the violated standard, causes, and solutions for the accessibility issues along with quality attributes of software with 4,572 accessibility issues collected from GitHub. Specifically, we first investigated the symptoms of the interaction between the accessibility issues and software quality attributes. Second, we manually assessed accessibility issues where the interaction occurs to determine the violated standards. We then analyzed the causes of these interaction problems. Finally, we explored the commits that fix these accessibility issues along with quality attributes to find solutions. Our results indicate that: i) usability and functionality are the quality attributes that most frequently interact with accessibility, appearing more than 66% of the time; ii) 87% of the interaction issues violated Perceivable and Operable in the Web Content Accessibility Guidelines; iii) the main reason for these interaction problems is that UI Component Related (UCR) and Contrast Related (CR) issues show up more than 52% of the time. • Study the relationship between accessibility and attributes. • Summary how developers address accessibility problems. • Create a reliable dataset. [ABSTRACT FROM AUTHOR]

Semantic processing of conceptual models is a focus of research for several years, bridging the disciplines of knowledge-based systems, conceptual modeling, and model-driven software engineering. With Knowledge Graphs, this research area gained momentum. In this paper, we introduce CM2KGcloud, a generic and extensible Web-based platform for transforming conceptual models into Knowledge Graphs. The platform can work on models created by state-of-the-art metamodeling platforms (e.g., EMF, Papyrus, ADOxx) and transforms models created with them into standardized Knowledge Graph representations like GraphML, RDF, and OWL. CM2KGcloud can be used as a service and can be integrated into software systems by its exposed API. • We introduce CM2KGcloud, a cloud platform for transforming conceptual models into Knowledge Graphs. • CM2KGcloud can process models created with ADOxx, EMF, and Papyrus-based modeling tools. • CM2KGcloud comes with pre-defined queries that are able to detect models smells. • Query results are graphically superimposed to the transformed Knowledge Graph. • The software is available at http://me.big.tuwien.ac.at/cm2kg. [ABSTRACT FROM AUTHOR]

• Distributed and global software development has increased since COVID-19 pandemic. • DevOps is being adopted in distributed and global settings. • DevOps practices in global and distributed settings brings benefits and challenges. • Related DevOps practices, benefits and challenges in distributed and global settings. The software industry is adopting the DevOps paradigm to an increasingly frequent extent. In addition, the trend of developing software in a distributed manner greatly increased as a result of the COVID-19 pandemic, which forced team members from software companies to work remotely. We present the results of a Systematic Mapping Study (SMS) of how DevOps has been applied in distributed and global settings that adopts Global Software Development (GSD). The results were obtained from analysing 27 papers. The main conclusions obtained after carrying our SMS show that adopting DevOps in such settings by implementing certain practices brings several advantages to software companies, even though there are difficulties to be confronted when adopting DevOps in global and distributed contexts. Moreover, we (1) proposed definition of DevOps in distributed and global settings, (2) mapped the challenges detected with a list of well-known GSD risks and (3) mapped the benefits that can be obtained from applying certain practices identified and the challenges that should be overcame to obtain such benefits. [ABSTRACT FROM AUTHOR]