Search

Existing blockchain approaches exhibit a diverse set of dimensions, and on the other hand, IoT-based health care applications manifest a wide variety of requirements. The state-of-the-art analysis of blockchain concerning existing IoT-based approaches for the healthcare domain has been investigated to a limited extend. The purpose of this survey paper is to analyze current state-of-the-art blockchain work in several IoT disciplines, with a focus on the health sector. This study also attempts to demonstrate the prospective use of blockchain in healthcare, as well as the obstacles and future paths of blockchain development. Furthermore, the fundamentals of blockchain have been thoroughly explained to appeal to a diverse audience. On the contrary, we analyzed state-of-the-art studies from several IoT disciplines for eHealth, and also the study deficit but also the obstacles when considering blockchain to IoT, which are highlighted and explored in the paper with suggested alternatives. [ABSTRACT FROM AUTHOR]

This article provides a summary of the current state of the Software & Systems Modeling (SoSyM) journal in 2023. It highlights the publication of new papers and the addition of new editors to the journal. The retirement of two esteemed editors is also mentioned, with gratitude expressed for their contributions. The article includes statistics on the number of papers published, the impact factor of the journal, and the number of submissions and downloads. It announces the recipients of the journal's ten-year most influential paper awards and lists the papers presented at the MODELS conference. The article concludes by expressing appreciation to the reviewers for their contributions. Additionally, a separate document is a message of gratitude and recognition from the software and systems modeling community. The community expresses their appreciation to all the reviewers who have assisted the modeling community and announces the recipients of the Best Reviewers of 2023 award. The document also provides a list of all the reviewers who contributed their expertise to the journal over the past year. The content of the current issue is briefly mentioned, and the community wishes everyone a joyful New Year and encourages readers to explore the journal's archive. [Extracted from the article]

Models are the key tools humans use to manage complexity in description, development, and analysis. This applies to all scientific and engineering disciplines and in particular to the development of software and data-intensive systems. However, different methods and terminologies have become established in the individual disciplines, even in the sub-fields of Informatics, which raises the need for a comprehensive and cross-sectional analysis of the past, present, and future of modeling research. This paper aims to shed some light on how different modeling disciplines emerged and what characterizes them with a discussion of the potential toward a common modeling future. It focuses on the areas of software, data, and process modeling and reports on an analysis of the research approaches, goals, and visions pursued in each, as well as the methods used. This analysis is based on the results of a survey conducted in the communities concerned, on a bibliometric study, and on interviews with a prominent representative of each of these communities. The paper discusses the different viewpoints of the communities, their commonalities and differences, and identifies possible starting points for further collaboration. It further discusses current challenges for the communities in general and modeling as a research topic in particular and highlights visions for the future. [ABSTRACT FROM AUTHOR]

Automated software transformations and the process of automated program repair and improvement are an important aspect of modern software engineering practices. In this paper, we describe a system which uses a graph-based deep learning model that can be trained to automatically transform and improve computer programs. By operating on language-agnostic, universal graph-like structures easily extractable from source code files (abstract syntax trees), the deep learning agent learns which transformations should be effectively applied to various structures recognized in the source code in order to improve it. By defining a metric which we want to improve and introducing an optimization task—a reinforcement learning setting, an agent learns to automatically apply a chain of transformations to the program, drastically improving it. While similar program improvement processes exist, they exclusively use exhaustive search algorithms to try all the possible code transformations which is a long process susceptible to local optimum issues. Our solution aims to model and embed structural knowledge about the programs being transformed which greatly helps the agent to choose best possible code transformations to apply. Elements of the approach we present in this paper are further applicable not just to automatic software improvement tasks, but also to other code-related tasks. [ABSTRACT FROM AUTHOR]

Software quality is becoming a momentous challenge in software engineering processes, and software testing has a pivotal role in its measurements. Nature-inspired metaheuristic methods play an essential role in software testing, in which various studies have been conducted in this field; however, due to a lack of wide-ranging papers reviewing these methods, conducting a comprehensive systematic review to examine an array of crucial mechanisms in this field has become a necessity. This study aims to present a detailed analysis and taxonomically classifies the metaheuristic methods inspired by nature. This paper compromises a systematic literature review of 65 chosen studies published between 2015 and 2022. Genetic algorithm-based, hybrid, ant colony optimization-based, cuckoo search-based, firefly algorithm-based, artificial bee colony-based, and other metaheuristic methods constitute this systematic study's stratification. Evaluation methods, applied tools, merits, and demerits of each reviewed article are investigated. Additionally, future directions and open issues are addressed. This conducted paper not only expounds on software testing strengths, open issues, and future works, but also recognizes the quest for optimizing the insufficient metrics in software testing, such as mutation score, complexity, and scalability, which would be the propulsion of the testing process if consummated. [ABSTRACT FROM AUTHOR]

This document is a guest editorial for the special section on SEFM 2020 and 2021 in the journal Software & Systems Modeling. The International Conference on Software Engineering and Formal Methods (SEFM) aims to bring together practitioners and researchers to advance the state of the art in formal methods and their application in the software industry. This special section includes selected papers from SEFM 2020 and 2021, which were held virtually during the COVID pandemic. Each article in this section has undergone rigorous peer review and has been revised and extended compared to its conference version. The selected papers cover topics such as embedded software portability and verification, nontermination inference, quantitative modeling and analysis of BDI agents, lazy model checking for recursive state machines, P-stable abstractions of hybrid systems, fairness and guarantees for extended bounded response LTL+P synthesis, counterexample classification, analyzing the impact of human errors on interactive service robotic scenarios, and active model learning of stochastic reactive systems. [Extracted from the article]

Interoperability stands as a critical hurdle in developing and overseeing distributed and collaborative systems. Thus, it becomes imperative to gain a deep comprehension of the primary obstacles hindering interoperability and the essential criteria that systems must satisfy to achieve it. In light of this objective, in the initial phase of this research, we conducted a survey questionnaire involving stakeholders and practitioners engaged in distributed and collaborative systems. This effort resulted in the identification of eight essential interoperability requirements, along with their corresponding challenges. Then, the second part of our study encompassed a critical review of the literature to assess the effectiveness of prevailing conceptual approaches and associated technologies in addressing the identified requirements. This analysis led to the identification of a set of components that promise to deliver the desired interoperability by addressing the requirements identified earlier. These elements subsequently form the foundation for the third part of our study, a reference architecture for interoperability-fostering frameworks that is proposed in this paper. The results of our research can significantly impact the software engineering of interoperable systems by introducing their fundamental requirements and the best practices to address them, but also by identifying the key elements of a framework facilitating interoperability in Systems of Systems. [ABSTRACT FROM AUTHOR]

In a world where Artificial Intelligence (AI) is pervasive, humans may feel threatened or at risk by giving up control to machines. In this context, ethicality becomes a major concern to prevent AI systems from being biased, making mistakes, or going rogue. Requirements Engineering (RE) is the research area that can exert a great impact in the development of ethical systems by design. However, proposing concepts, tools and techniques that support the incorporation of ethicality into the software development processes as explicit requirements remains a great challenge in the RE field. In this paper, we rely on Ontology-based Requirements Engineering (ObRE) as a method to elicit and analyze ethicality requirements ('Ethicality requirements' is adopted as a name for the class of requirements studied in this paper by analogy to other quality requirements studied in software engineering, such as usability, reliability, and portability, etc. The use of this term (as opposed to 'ethical requirements') highlights that they represent requirements for ethical systems, analogous to how 'trustworthiness requirements' represent requirements for trustworthy systems. To put simply: the predicates 'ethical' or 'trustworthy' are not meant to be predicated over the requirements themselves). ObRE applies ontological analysis to ontologically unpack terms and notions that are referred to in requirements elicitation. Moreover, this method instantiates the adopted ontology and uses it to guide the requirements analysis activity. In a previous paper, we presented a solution concerning two ethical principles, namely Beneficence and Non-maleficence. The present paper extends the previous work by targeting two other important ethicality principles, those of Explicability and Autonomy. For each of these new principles, we do ontological unpacking of the relevant concepts, and we present requirements elicitation and analysis guidelines, as well as examples in the context of a driverless car case. Furthermore, we validate our approach by analysing the requirements elicitation made for the driverless car case in contrast with a similar case, and by assessing our method's coverage w.r.t European Union guidelines for Trustworthy AI. [ABSTRACT FROM AUTHOR]

Business process modeling is a crucial aspect of domains such as Business Process Management and Software Engineering. The availability of various BPM languages in the market makes it challenging for process modelers to select the best-fit BPM language for a specific process modeling task. A decision model is necessary to systematically capture and make scattered knowledge on BPM languages available for reuse by process modelers and academics. This paper presents a decision model for the BPM language selection problem in research projects. The model contains mappings of 72 BPM features to 23 BPM languages. We validated and refined the decision model through 10 expert interviews with domain experts from various organizations. We evaluated the efficiency, validity, and generality of the decision model by conducting four case studies of academic research projects with their original researchers. The results confirmed that the decision model supports process modelers in the selection process by providing more insights into the decision process. Based on the empirical evidence from the case studies and domain expert feedback, we conclude that having the knowledge readily available in the decision model supports academics in making more informed decisions that align with their preferences and prioritized requirements. Furthermore, the captured knowledge provides a comprehensive overview of BPM languages, features, and quality characteristics that other researchers can employ to tackle future research challenges. Our observations indicate that BPMN is a commonly used modeling language for process modeling. Therefore, it is more sensible for academics to explain why they did not select BPMN than to discuss why they chose it for their research project(s). [ABSTRACT FROM AUTHOR]

Despite potential benefits in Software Engineering, adoption of software modelling in industry is low. Technical issues such as tool support have gained significant research before, but individual guidance and training have received little attention. As a first step towards providing the necessary guidance in modelling, we conduct a systematic literature review to explore the current state of the art. We searched academic literature for guidance on model creation and selected 35 papers for full-text screening through three rounds of selection. We find research on model creation guidance to be fragmented, with inconsistent usage of terminology, and a lack of empirical validation or supporting evidence. We outline the different dimensions commonly used to provide guidance on software and system model creation. Additionally, we provide definitions of the three terms modelling method, style, and guideline as current literature lacks a well-defined distinction between them. These definitions can help distinguishing between important concepts and provide precise modelling guidance. [ABSTRACT FROM AUTHOR]

With the recent rise in internet usage, the volume of crucial, private, and confidential data traveling online has increased. Attackers have made attempts to break into the network due to weaknesses in the security mechanisms, gaining access to sensitive data that could disrupt the operation of the systems and jeopardize the confidentiality of the data. Intrusion detection systems, a key component of cybersecurity, were used to defend against these potential threats. Numerous review papers have examined various intrusion detection system (IDS) approaches for networks, many of which focused primarily on the anomaly-based IDS while paying less attention to the signature and hybrid-based approaches. Additionally, a lot of these studies took a non-systematic approach, comparing existing techniques, without taking into account the in-depth analytical synthesis of methodologies and results of the approaches to provide a thorough grasp of state-of-the-art. In order to provide a thorough assessment of the current status of Network IDS, this work provides an in-depth insight into what is attainable in the research of Anomaly, Signature, and Hybrid-Based methods by adhering to the principles of Preferred Reporting Items for Systematic Reviews and Meta-Analyses and guidelines for Software Engineering Domain. We discovered unexplored study topics and unsolved research issues based on the study's findings. We end by highlighting potential, high impact future research areas in order to improve the IDS model. [ABSTRACT FROM AUTHOR]

Quantum computing is based on the principles of quantum mechanics, such as superposition, entanglement, measurement, and decoherence. The basic units of computation are qubits, which are abstract objects with a mathematical expression to implement the quantum mechanics principles. Alongside quantum hardware, software is a principal element for conducting quantum computing. The software consists of logic gates and quantum circuits that implement algorithms for the execution of quantum programs. Due to those characteristics, quantum computing is a paradigm that non-physics experts cannot understand. Under this new scheme for developing software, it is important to integrate a conceptual framework of the fundamentals on which quantum computing is based. In this paper, we present a kind of taxonomical view of the fundamental concepts of quantum computing and the derived concepts that integrate the emerging discipline of quantum software engineering. We performed a quasi-systematic mapping for conducting the systematic review because the objective of the review only intends to detect the fundamental concepts of quantum computing and quantum software. The results can help computer science students and professors as a starting point to address the study of this discipline. [ABSTRACT FROM AUTHOR]

An adaptive system is able to adapt at runtime to dynamically changing environments and to new requirements. Adaptive systems can be single adaptive entities or collective ones that consist of several collaborating entities. Rigorous engineering requires appropriate methods and tools that help guaranteeing that an adaptive system lives up to its intended purpose. This paper introduces the special section on "Rigorous Engineering of Collective Adaptive Systems." It presents the 11 contributions of the section categorizing them into five distinct research lines: correctness by design and synthesis, computing with bio-inspired communication, new system models, machine learning, and programming and analyzing ensembles. [ABSTRACT FROM AUTHOR]

Refactoring tools have advanced greatly and are being used in many large projects. As a result, a great deal of information is now available about past refactoring and its effects on the source code. However, when multiple refactoring is performed at once, it becomes more difficult to analyze their impact. Refactoring visualization can help developers create more maintainable code that is easier to understand and modify over time. Although there is an increasing interest in visualizing code changes in software engineering research, there has been relatively little research on visualizing the process of refactoring. In this paper, we propose a Radar Chart Refactoring Visualization (RcRV) approach to visualize software refactoring of source code across multiple software releases. Radar charts are a form of 2D visualization that can show multiple variables on a single chart. The RcRv receives input from developers or through refactoring identification tools, such as Ref-Finder, to generate charts. The generated charts can show the changes made during the refactoring process, highlighting areas of the trend of refactoring over evolution for multiple refactoring, multiple methods, and multiple classes. The evaluation study conducted to assess the usefulness of the RcRV tool has shown that the proposed tool is useful to developers, appealing, and easy to use. The proposed method of visualization can be beneficial for developers and maintainers to detect design violations and potential bugs in the code, thus saving time and effort during the development and maintenance process. Therefore, this research presents a significant contribution to the software engineering field by providing developers with an efficient tool to enhance code quality and maintainability. [ABSTRACT FROM AUTHOR]

Industrial control applications are usually designed by domain experts instead of software engineers. These experts frequently use visual programming languages based on standards such as IEC 61131-3 and IEC 61499. The standards apply model-based engineering concepts to abstract from hardware and low-level communication. Developing industrial control software is challenging due to the fact that control systems are usually unique and need to be maintained for many years. The arising challenges, together with the growing complexity of control software, require very usable model-based development environments for visual programming languages. However, so far only little empirical research exists on the practical usefulness of such environments, i.e., their usability and utility. In this paper, we discuss common control software maintenance tasks and tool capabilities based on existing research and show the realization of these capabilities in the 4diac IDE. We performed a walkthrough of the demonstrated capabilities using the cognitive dimensions of notations framework from the field of human–computer interaction. We then improved the tool and conducted a user study involving ten industrial automation engineers, who used the 4diac IDE in a realistic control software maintenance scenario. Based on lessons learnt from this study, we adapted the 4diac IDE to better handle large graphical models. We evaluated these changes in a reassessment study with automation engineers from seven industrial enterprises. We derive general implications with respect to large-scale applications for developers of IDEs that we deem applicable in the context of (visual) model-based engineering tools. [ABSTRACT FROM AUTHOR]

Modeling is a key activity in conceptual design and system design. Through collaborative modeling, end-users, stakeholders, experts, and entrepreneurs are able to create a shared understanding of a system representation. While the Unified Modeling Language (UML) is one of the major conceptual modeling languages in object-oriented software engineering, more and more concerns arise from the modeling quality of UML and its tool-support. Among them, the limitation of the two-dimensional presentation of its notations and lack of natural collaborative modeling tools are reported to be significant. In this paper, we explore the potential of using virtual reality (VR) technology for collaborative UML software design by comparing it with classical collaborative software design using conventional devices (desktop PC/laptop). For this purpose, we have developed a VR modeling environment that offers a natural collaborative modeling experience for UML Class Diagrams. Based on a user study with 24 participants, we have compared collaborative VR modeling with conventional modeling with regard to efficiency, effectiveness, and user satisfaction. Results show that the use of VR has some disadvantages concerning efficiency and effectiveness, but the user's fun, the feeling of being in the same room with a remote collaborator, and the naturalness of collaboration were increased. [ABSTRACT FROM AUTHOR]

Earlier software development processes (SDPs), such as waterfall processes, were mainly focused on process steps and did not address people- and product-related issues. Emergence of Software development methodologies (SDM) has created a new paradigm for developing software systems. A SDM is a special kind of technically engineered framework for organizing SDPs; this framework is expected to specify three main interwoven elements, namely people, products, and process. It has since become evident that it is impossible to provide a general-purpose SDM for developing all the various kinds of software systems, and it has thus become essential to construct the most appropriate methodology for the system development situation in hand, a practice commonly called Situational Method Engineering (SME). The problem with existing SME methods is lack of adequate attention to the role of people who might seek or possess valuable knowledge about the project situation. This knowledge can be tacit information that is hidden in the developer's mind, or it might be explicitly available. This paper proposes a knowledge management (KM)-driven and DevOps-based SME method as a new integrated multi-view methodological paradigm that satisfies the need for sharing human experience in engineering SDMs. The method has been proposed by reusing general SME practices and complementing them by embedding appropriate KM and DevOps practices to alleviate the weaknesses of previous SME methods. Furthermore, the proposed method has been evaluated through four case studies and also by conducting a criteria-based comparison with eight prominent SME methods. [ABSTRACT FROM AUTHOR]

Requirements prioritization is essential for development of quality software products. Requirements prioritization helps focus on the most important requirements between the available software requirements. This process is also called preserving core vision according to customer viewpoint or managing the quality requirements. Many requirements prioritization techniques have been proposed in the Software Engineering field. However, one requirement prioritization technique can only be generalized for some software projects. This research effort aims to develop a sustainable hybrid model for requirements prioritization, utilizing critical software project factors. The prioritization technique is shortlisted from a pool of software prioritization techniques, based on these project factors and their quantized scores. The proposed model is equipped with state-of-the-art literature to provide a customized prioritization technique improving the requirements prioritization process for a specific software project. The paper also presents popular software prioritization techniques used in the software industry and an extensive comparison using a thorough empirical analysis. Finally, the quantization of the software project factors for each technique has been assessed for better understanding, and a sustainable hybrid model has been constructed. With the proposed hybrid model, requirements prioritization in software development has been controlled effectively, reducing the failure risks and increasing the overall benefit and success rate. The success of the proposed hybrid approach is verified with two software case studies attaining satisfactory results and improving the organization's productivity by incorporating pivotal software requirements on which all the stakeholders agree. Furthermore, an automated approach will be developed by implementing the proposed approach to benefit from human–machine collaboration, improving user satisfaction by incorporating end-user opinions effectively and timely. [ABSTRACT FROM AUTHOR]

The adoption and popularization of mobile devices, such as smartphones and tablets, accentuated after the second decade of this century, has been motivated by the growing number of mobile applications, which can solve problems in different areas of contemporary societies. Conversely, the software development industry is motivated by the increasing number and quality of resources that mobile devices possess nowadays (e.g., memory, sensors, processing power or battery). While powerful mobile devices do exist, one of the main driving factors behind the increase of resources is the usage of Cloud technology, which strongly complement mobile computing. As expected, the adoption of measures to mitigate security issues has not accompanied the growth and speed of development for Cloud and Mobile software, to ensure that these are resilient to attacks by design. Aiming to contribute to decrease the gap between software and security engineering, this paper presents a deep approach to attack taxonomy, security mechanisms, and security test specification for the Cloud and Mobile ecosystem of applications. This is also the first time an encompassing and conjoined approach is provided for attack taxonomy and specification of security tests automation tools for this ecosystem. [ABSTRACT FROM AUTHOR]

Big data analytics technologies are rapidly expanding across all industry sectors as organisations try to make analytics an integral part of their everyday decision-making. Although there are many software tools and libraries to assist analysts and software engineers in developing solutions, organisations are looking for flexible analytics platforms that can address their specific objectives and requirements. To minimise costs, such platforms also need to co-exist with existing IT infrastructures and reuse knowledge and resources already accumulated within the organisation. To address such needs, this paper proposes the Data Analytics Solution Engineering (DASE) framework—a knowledge-driven approach supported by semantic web technologies for requirements engineering, design and development of new data analytics platforms. It includes a meta-model that captures data analytics platform requirements via a Knowledge Base, a set of guidelines that organisations can follow in engineering data analytics platforms and a reference architecture that demonstrates how to use these guidelines. We evaluate the DASE framework through two case studies and demonstrate how it can facilitate knowledge-based and requirements-driven data analytics platform engineering. The resulting data analytics platforms are observed to be user friendly, easy to maintain and flexible in handling changes to requirements. This work contributes to the body of knowledge in knowledge-driven requirements engineering, and data analytics platform engineering by providing a meta-model and a reference architecture that can be tailored to different analytics application domains. [ABSTRACT FROM AUTHOR]

As software engineering (SE) practitioners, we can help society by using our communities of experts to address a software need of a socially conscious organization. Doing so can benefit society in the locale of a SE conference and provide access to international experts for local organizations. Furthermore, established SE researchers as well as practitioners and students have the opportunity for a unique learning experience. While the SE community has already realized the importance of addressing human values and promoting social good objectives in software development, we are unaware of previous attempts to leverage SE conferences for this activity. Conferences present an opportunity to enjoy the assembly of SE practitioners, researchers, and students for the purpose of a philanthropic endeavor. Over the past four years of running a "Requirements Engineering for Social Good" event called RE Cares, co-located with the International Conference on Requirements Engineering, we worked with the stakeholders local to the conference venue. We selected stakeholders who would not necessarily have ready access to requirements engineering, software design, and development expertise otherwise, to build software targeting "good causes." In the last two years, this event was altered to adapt to the constraints induced by COVID-19, moving to a hybrid mode and changing many of its practices accordingly. This paper summarizes and generalizes our experiences, discussing our lessons learned in the context of the pandemic and beyond and providing a framework for conducting similar social contribution in any SE conferences in general. [ABSTRACT FROM AUTHOR]

Model-driven software engineering and specifically domain-specific languages have contributed to improve the quality of software and the efficiency in the development of software. However, the design and implementation of domain-specific languages requires still an enormous investment. Language workbenches are the most important tools in the field of software language engineering. The introduction of language workbenches has alleviated partly the development effort, but there are still a few major challenges that need to be tackled. This paper presents a personal perspective on the development of tools for language engineering and language workbenches in particular and future challenges to be tackled. [ABSTRACT FROM AUTHOR]

Self-adaptive software can assess and modify its behavior when the assessment indicates that the program is not performing as intended or when improved functionality or performance is available. Since the mid-1960s, system adaptivity has been extensively researched, and during the last decade, many application areas and technologies involving self-adaptation have gained prominence. All of these efforts have in common the introduction of self-adaptability through software. Thus, it is essential to investigate systematic software engineering methods to create self-adaptive systems that may be used across different domains. The primary objective of this research is to summarize current advances in awareness requirements for adaptive strategies and their performance management based on an examination of state-of-the-art methods described in the literature. This paper reviews self-adaptive systems in the context of requirement awareness and summarizes the most common methodologies applied. At first glance, it examines the previous surveys and works about self-adaptive systems. Afterward, it classifies the current self-adaptive systems based on six criteria. Then, it presents performance management in the current adaptive systems and then evaluates the most common self-adaptive approaches. Lastly, the self-adaptive models are evaluated based on four concepts (requirements description, monitoring, relationship, dependency/impact, and tools). [ABSTRACT FROM AUTHOR]

Welcome to this special issue that includes papers on the latest advances in Requirements Engineering (RE). As new software systems are developed, they can impact our society, economy and environment, and software requirement engineers should consider the implications on sustainability when designing software requirements. [Extracted from the article]

Quality requirements deal with how well a product should perform the intended functionality, such as start-up time and learnability. Researchers argue they are important and at the same time studies indicate there are deficiencies in practice. Our goal is to review the state of evidence for quality requirements. We want to understand the empirical research on quality requirements topics as well as evaluations of quality requirements solutions. We used a hybrid method for our systematic literature review. We defined a start set based on two literature reviews combined with a keyword-based search from selected publication venues. We snowballed based on the start set. We screened 530 papers and included 84 papers in our review. Case study method is the most common (43), followed by surveys (15) and tests (13). We found no replication studies. The two most commonly studied themes are (1) differentiating characteristics of quality requirements compared to other types of requirements, (2) the importance and prevalence of quality requirements. Quality models, QUPER, and the NFR method are evaluated in several studies, with positive indications. Goal modeling is the only modeling approach evaluated. However, all studies are small scale and long-term costs and impact are not studied. We conclude that more research is needed as empirical research on quality requirements is not increasing at the same rate as software engineering research in general. We see a gap between research and practice. The solutions proposed are usually evaluated in an academic context and surveys on quality requirements in industry indicate unsystematic handling of quality requirements. [ABSTRACT FROM AUTHOR]

Recommender systems are information filtering systems used in many online applications like music and video broadcasting and e-commerce platforms. They are also increasingly being applied to facilitate software engineering activities. Following this trend, we are witnessing a growing research interest on recommendation approaches that assist with modelling tasks and model-based development processes. In this paper, we report on a systematic mapping review (based on the analysis of 66 papers) that classifies the existing research work on recommender systems for model-driven engineering (MDE). This study aims to serve as a guide for tool builders and researchers in understanding the MDE tasks that might be subject to recommendations, the applicable recommendation techniques and evaluation methods, and the open challenges and opportunities in this field of research. [ABSTRACT FROM AUTHOR]

Access control is a fundamental security aspect and has been adopted in diverse systems. Particularly, fine-grained access control models present good flexibility and scalability to adapt to complicated systems. However, building a trustworthy fine-grained access control mechanism in untrustworthy distributed environments such as Internet of Things (IoT) environments is challenging. Conventional access control mechanisms encounter security and privacy issues caused by centralized entities, such as single point of failure and data tampering. To address these issues, we have proposed Bloccess, a fine-grained access control framework based on the consortium blockchain, in our previous work. By leveraging blockchain technology, we formulate a set of protocols to enforce a tamper-proof access control mechanism in untrustworthy distributed environments. In this paper, we refine our previous work and present the extended version of Bloccess. We optimize our protocols and extend them to support a hybrid blockchain structure. We also formulate complete identification protocols for the administration mechanism in Bloccess. Besides, we show Bloccess in practice with a Bloccess-enabled IoT system. Furthermore, we conduct a semi-formal analysis to prove the security properties of Bloccess and evaluate its security through a security model and a threat model. [ABSTRACT FROM AUTHOR]

Blended modeling aims to improve the user experience of modeling activities by prioritizing the seamless interaction with models through multiple notations over the consistency of the models. Inconsistency tolerance, thus, becomes an important aspect in such settings. To understand the potential of current commercial and open-source modeling tools to support blended modeling, we have designed and carried out a systematic study. We identify challenges and opportunities in the tooling aspect of blended modeling. Specifically, we investigate the user-facing and implementation-related characteristics of existing modeling tools that already support multiple types of notations and map their support for other blended aspects, such as inconsistency tolerance, and elevated user experience. For the sake of completeness, we have conducted a multivocal study, encompassing an academic review, and grey literature review. We have reviewed nearly 5000 academic papers and nearly 1500 entries of grey literature. We have identified 133 candidate tools, and eventually selected 26 of them to represent the current spectrum of modeling tools. [ABSTRACT FROM AUTHOR]

This special issue of Software Tools for Technology Transfer comprises extended versions of selected papers from the 26th edition of the International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS 2020). The focus of this conference series is tools and algorithms for the rigorous analysis of software and hardware systems, and the papers in this special cover the spectrum of current work in this field. [ABSTRACT FROM AUTHOR]

Software systems play an ever more important role in our lives and software engineers and their companies find themselves in a position where they are held responsible for ethical issues that may arise. In this paper, we try to disentangle ethical considerations that can be performed at the level of the software engineer from those that belong in the wider domain of business ethics. The handling of ethical problems that fall into the responsibility of the engineer has traditionally been addressed by the publication of Codes of Ethics and Conduct. We argue that these Codes are barely able to provide normative orientation in software development. The main contribution of this paper is, thus, to analyze the normative features of Codes of Ethics in software engineering and to explicate how their value-based approach might prevent their usefulness from a normative perspective. Codes of Conduct cannot replace ethical deliberation because they do not and cannot offer guidance because of their underdetermined nature. This lack of orientation, we argue, triggers reactive behavior such as "cherry-picking," "risk of indifference," "ex-post orientation," and the "desire to rely on gut feeling." In the light of this, we propose to implement ethical deliberation within software development teams as a way out. [ABSTRACT FROM AUTHOR]

The coronavirus COVID-19 swept the world in early 2020, working from home was a necessity. In the software industry, thousands of software developers began working from home, many did so on short notice, under difficult and stressful conditions. The emotions of developers can be affected by this situation. On the other hand, some well-known soft skills have been emphasized as required for working remotely. Software engineering research lacks theory and methodologies for addressing human aspects in software development. In this paper we present an exploratory study with a survey applied to practitioners in the west border area of Mexico-USA. It is focused on the developers' wellbeing during pandemic, expressed as emotions, and the perceptions of the level in which soft skills are practiced/required in the working from home mode. The results show that high percent expressed to experience positive emotions, however, a portion of respondents expressed to feel negative emotions. In general terms, 91.0% of respondents expressed to be satisfied working from home, but some conditions should be improved. In the case of soft skills, some of them are revealed as practiced in high level in working from home, but still there is not consensus. [ABSTRACT FROM AUTHOR]

Software analysis is the process carried out to obtain requirements that reflects the needs of a client's stakeholders and that allows the construction of a software product that meets their expectations. However, it is also known as a process where many defects are injected. In this context, although process improvement has contributed to the software industry, in the case of software requirements it needs to be studied to determine the improvements obtained and established models. In the literature reviewed, a similar mapping study with 4 research question was identified and used as a reference. The objective of this work is to structure the available literature on process improvement in the software requirements engineering (SRE) domain to identify the improvement phases, paradigms, principles, and established models. For this purpose, a systematic mapping study (SMS) was carried out in the most recognized digital databases. The mapping carried out recovered a total of 1,495 studies, and after the process, 86 primary studies were obtained. In this SMS had established and answered 13 research questions. The different models that are applied throughout the software requirements engineering process were identified, and accepted studies were classified and findings on SRE process improvement were collected. The most used models are CMMI, Requirements Engineering Good Practice Guide (REGPG), and ISO/IEC 15504. Also, 62% of accepted studies are of the proposal and evaluation type; that is, they propose a framework and study the implementation of a proposal in one or more case studies respectively. On the other hand, it was found that most of the studies focused on the process improvement analysis phase. Likewise, in contrast with a previous study, proposal and validation type of studies increased in 9 papers each one from 2014 to date. This shows the interest of the scientific community in this domain. [ABSTRACT FROM AUTHOR]

Software process has been studied from various perspectives, among them, the human factor is one of the most important due to the intrinsic social aspect of the discipline. This study aims to explore the benefits of using Belbin's role theory in tasks – team and individual – related to the software development process, particularly in Database Design (DB) Design. In this paper two controlled experiments with students are presented. In the first experiment integrated teams with compatible roles identified in the students and teams integrated through a traditional strategy were compared, during the task of DB conceptual design. In the second experiment, individual students were the experimental subjects, the performance of the Belbin roles identified in them were compared, in the task of the DB logical design. The dependent variables in both experiments were the effort in the task, and the quality of the generated design. Results in the first experiment did not show significant differences in both variables, a possible limitation was the complexity of the task. The second experiment also did not show significant differences in the effort variable; however, in the variable related to the quality of the logical design, the monitor-evaluator role presented significant differences when compared with the other six identified roles; these results are consistent with previous studies identified in the literature. We plan to continue experimenting with other tasks in order to get a deeper understanding of applying the Belbin's theory in software process to accumulate experiences. [ABSTRACT FROM AUTHOR]

The development process of on-board software applications can benefit from model-driven engineering techniques. Model validation and model transformations can be applied to drive the activities of specification, requirements definition, and system-level validation and verification according to the space software engineering standards ECSS-E-ST-40 and ECSS-Q-ST-80. This paper presents a model-driven approach to completing these activities by avoiding inconsistencies between the documents that support them and providing the ability to automatically generate the system-level validation tests that are run on the Ground Support Equipment and the matrices required to complete the software verification. A demonstrator of the approach has been built using as a proof of concept a subset of the functionality of the software of the control unit of the Energetic Particle Detector instrument on-board Solar Orbiter. [ABSTRACT FROM AUTHOR]

The software engineers retain the test cases they create for specific software for future usage. This form of test case reuse is called regression testing and this step mainly improves the software testing efficiency. The test case minimization and prioritization for regression testing raise different issues such as higher time consumption and heavier resource utilization. To overcome this problem, this paper presents a Side-blotched lizard optimized AdaBoost Convolutional Neural Network (SBLA-AdaBoost CNN) model. The proposed technique mainly aims to discover the faults initially and minimize the test case execution cost. The proposed model is evaluated using the Defects4J dataset. Our proposed method tends to be cost-effective since it integrates test case selection, prioritization, and minimization. The proposed methodology can be also utilized to arrange the test cases during their initial stages of software testing. The results demonstrate that the proposed methodology is efficient in identifying the changes in different parts of the source code, minimizing resource utilization, and time consumption. The precision and recall score obtained by the proposed methodology is 98.5% and 99% which is relatively higher than the state-of-art techniques. The time taken by the proposed methodology to evaluate a total of 50 test cases is 19.14 s. [ABSTRACT FROM AUTHOR]

Classical computing, which gave us the current digital age, is about to be overriden by a more exciting, powerful, and radically distinct form of computing technology termed as quantum computing. Quantum-based computing may eventually be many times faster than the computing capability that we all use today in our smart phones, laptop computers, and other devices. By leveraging the fundamentals of quantum mechanics, quantum potential is initially focused in this research paper. A baseline has been defined to get through the fundamentals of quantum computing. To get insights, currently available quantum computing platforms or environments are described. Software quality models are investigated to enlist detailed software quality attributes and their relevance for different software application types. We have presented characteristics of quantum computers or quantum processors that may be pertinent to understanding or reasoning about software quality attributes. How these quantum computing characteristics (QCCs) may impact quality of quantum software, is analyzed in the end. [ABSTRACT FROM AUTHOR]

Goal-oriented models are gaining significant attention from researchers and practitioners in various domains, especially in software requirements engineering. Similar to other software engineering models, goal models are subject to bad practices (i.e., bad smells). Detecting and rectifying these bad smells would improve the quality of these models. In this paper, we formally define the circular dependency bad smell and then develop an approach based on the simulated annealing (SA) search-based algorithm to detect its instances. Furthermore, we propose two mechanisms (namely, pruning and pairing) to improve the effectiveness of the proposed approach. We empirically evaluate three algorithm combinations, i.e., (1) the base SA search algorithm, (2) the base SA search algorithm augmented with pruning mechanism, and (3) the base SA search algorithm augmented with pruning and pairing mechanisms, using several case studies. Results show that simulated annealing augmented with pruning and pairing is the most effective approach, while the simulated annealing augmented with pruning mechanism is more effective than the base SA search algorithm. We also found that the proposed pruning and pairing mechanisms provide a significant improvement in the detection of circular dependency bad smell, in terms of computation time and accuracy. [ABSTRACT FROM AUTHOR]

With the increasing computing and networking capabilities, IoT devices and edge gateways have become part of a larger IoT–edge–cloud computing continuum, where processing and storage tasks are distributed across the whole network hierarchy, not concentrated only in the cloud. At the same time, this also introduced continuous delivery practices to the development of software components for network-connected gateways and sensing/actuating nodes. These devices are placed on end users' premises and are characterized by continuously changing cyber-physical contexts, forcing software developers to maintain multiple application versions and frequently redeploy them on a distributed fleet of devices with respect to their current contexts. Doing this correctly and efficiently goes beyond manual capabilities and requires an intelligent and reliable automated solution. This paper describes a model-based approach to automatically assigning multiple software deployment plans to hundreds of edge gateways and connected IoT devices implemented in collaboration with a smart healthcare application provider. From a platform-specific model of an existing edge computing platform, we extract a platform-independent model that describes a list of target devices and a pool of available deployment plans. Next, we use constraint solving to automatically assign deployment plans to devices at once with respect to their specific contexts. The result is transformed back into the platform-specific model and includes a suitable deployment plan for each device, which is then consumed by our engine to deploy software components not only on edge gateways but also on their downstream IoT devices with constrained resources and connectivity. We validate the approach with a fleet deployment prototype integrated into a DevOps toolchain used by the partner application provider. Initial experiments demonstrate the viability of the approach and its usefulness in supporting DevOps for edge and IoT software development. [ABSTRACT FROM AUTHOR]

In model-driven software engineering, models are used in all phases of the development process. These models must hold a high quality since the implementation of the systems they represent relies on them. Several existing tools reduce the burden of manually dealing with issues that affect models' quality, such as syntax errors, model smells, and inadequate structures. However, these tools are often inflexible for customization and hard to extend. This paper presents a customizable and extensible model repair framework, PARMOREL, that enables users to deal with different issues in different types of models. The framework uses reinforcement learning to automatically find the best sequence of actions for repairing a broken model according to user preferences. As proof of concept, we repair syntactic errors in class diagrams taking into account a model distance metric and quality characteristics. In addition, we restore inter-model consistency between UML class and sequence diagrams while improving the coupling qualities of the sequence diagrams. Furthermore, we evaluate the approach on a large publicly available dataset and a set of real-world inspired models to show that PARMOREL can decide and pick the best solution to solve the issues present in the models to satisfy user preferences. [ABSTRACT FROM AUTHOR]

This paper presents a case study that theorizes how project team culture in software engineering organizations affects Capability Maturity Model Integration (CMMI) implementation from an organizational culture perspective. It contends that the success of CMMI implementation is positively related to project team culture along the six aspects of organizational culture: position on reform, centralization and coordination, position on collaboration, rationality and truth, motivation, and position on task. This paper uses a qualitative approach to conduct semi-structured interviews and performs a content analysis of the transcribed interview-related data from case protocol to analyze the gathered information. The results indicate the scope for the impact team culture has on CMMI implementation and suggests the potential for CMMI implementations to bring about changes in organizational culture, which can support the integration of software into an organization. In addition, this study develops a cultural construction that shows the aspects of culture that best facilitate a strong project team culture in CMMI implementation. It extends the theory regarding the impact of culture on CMMI implementation and provides a theoretically grounded basis for future research. [ABSTRACT FROM AUTHOR]

Agile is often associated with a lack of architectural thinking causing technical debt but has the advantage of user centricity and a strong focus on value. Model-driven software engineering (MDSE) strongly performs for building a quality architecture and code, but lacks focus on user requirements and tends to consider development as a monolithic whole. The combination of Agile and MDSE has been explored, but a convincing integrated method has not been proposed yet. This paper addresses this gap by exploring the specific combination of MERODE—as an example of a proven MDSE method—with Scrum, a reference agile method offering a concrete (sprint-based) life cycle management on the basis of user stories. The method resulting of this integration is called Agile MERODE; it is driven by user stories, themselves associated with behavior-driven development scenarios. It allows for domain-driven design and permits fast development from domain models by means of code generation. An illustrative example further clarifies the practical application of Agile MERODE, while a case study shows the planning game application in the case's context. While the approach, in its entirety, allows reducing technical debt by building the architecture in a logical, consistent and complete manner, introducing MDSE involves a trade-off with pure value-driven development. Agile MERODE contributes to the state of the art by showing how to increase user centricity in MDSE, how to align model-driven engineering with the Scrum cycle, and how to reduce the technical debt of agile developments yet remaining value-focused. [ABSTRACT FROM AUTHOR]

The engineering of mechatronic production systems is complex and requires various disciplines (e.g., systems, mechanical, electrical and software engineers). Model-driven engineering (MDE) supports systems development and the exchange of information based on models and transformations. However, the integration and adoption of different modeling approaches are becoming challenges when it comes to cross-disciplinary work. VIATRA is a long-living enduring and mature modeling framework that offers rich model transformation features to develop MDE applications. This study investigates the extent to which VIATRA can be applied in the engineering of mechatronic production systems. For this purpose, two model transformation case studies are presented: "SysML – AutomationML" and "SysML4Mechatronics – AutomationML." Both case studies are representative of structural modeling and interdisciplinary data exchange during the development of mechatronic production systems. These case studies are derived from other researchers in the community. A VIATRA software prototype implements these case studies as a batch-oriented transformation and serves as one basis for evaluating VIATRA. To report on our observations and findings, we built on an evaluation framework from the MDE community. This framework considers 14 different characteristics (e.g., maturity, size, execution time, modularity, learnability), according to the Goal-Question-Metric paradigm. To be able to evaluate our findings, we compared VIATRA to ATL. We applied all cases to a lab-size mechatronic production system. We found that, with VIATRA, the same functions for model transformation applications can be achieved as with ATL, which is popular for model transformations in both the MDE and the mechatronic production systems community. VIATRA combines the relational, imperative, and graph-based paradigms and enables the development and execution of model-to-model (M2M) and model-to-text (M2T) transformations. Furthermore, the VIATRA internal DSL is based on Xtend and Java, making VIATRA attractive and intuitive for users with less experience in modeling than in object-oriented programming. Thus, VIATRA leads to an interesting alternative for the model-driven engineering of mechatronic production systems. It has the potential to reduce the complexity during the development of model transformations. To conclude, this paper evaluates the applicability of VIATRA, its strengths and limitations. It provides lessons learned and insights that can stimulate further research in the MDE for mechatronic production systems. [ABSTRACT FROM AUTHOR]

Software architecture models are considered first-class artifacts in current software engineering best practices. Thus, usable and well-understood modeling methods are required for software architects. For this aim, several specific software architecture modeling methods as well as generic design methods included in software development methodologies are available. However, we believe, there is the lack of more specific guidance in current software architecture methods. One of the principal causes of such a lack of specific guidance is the general-purpose nature of these methods. Therefore, further efforts are required to define domain-specific software architecture methods. In this paper, we present SOCAM, a software architecture modeling method for Web Service-Oriented Systems. We illustrate the use of SOCAM with a customization of the well-known SOA test application case: the Sun Adventure Builder system. A comparative analysis of SOCAM with other methods reveals a number of benefits of our method over the other approaches. Also, a survey research method evaluation confirms some of these benefits such as the fact that SOCAM is perceived as more useful than certain general-purpose methods. [ABSTRACT FROM AUTHOR]

The effectiveness of software test data relates to the number of found faults by the test data. Software mutation test is used to evaluate the effectiveness of the software test methods and is one of the challenging fields of software engineering. In order to evaluate the capability of test data in finding the program faults, some syntactical changes are made in the program source code to cause faulty program; then, the generated mutants (faulty programs) and original program are executing with the corresponding test data. One of the main drawbacks of mutation testing is its computational cost. Indeed, high execution time of mutation testing is a challenging research problem. Reducing the time and cost of mutation test is the main objective of this paper. In the traditional mutation methods and tools the mutants are injected randomly in each instructions of a program. Meanwhile, in the real-world program, the probability of fault occurrences in the simple locations (instructions and data) of a program is negligible. With respect to the 80–20 rule, 80% of the faults are found in 20% of the fault-prone code of a program. In the first stage of the proposed method, Artificial Bee Colony optimization algorithm is used to identifying the most fault prone paths of a program; in the next stage, the mutation operators (faults) are injected only on the identified fault-prone instructions and data. Regarding the results of conducted experiments on the standard benchmark programs, Compared to existing methods, the proposed method reduces 28.10% of the generated mutants. Reducing the number of generated mutants will reduce the cost of mutation testing. The traditional mutation testing tools (Mujava, Muclipse, Jester, Jumble) can perform the mutation testing with a lower cost using the method presented in this study. [ABSTRACT FROM AUTHOR]

Model-Based Software Engineering provides various modelling formalisms for capturing the structural, behavioral, configuration, and intentional aspects of software systems. One of the most widely used kinds of models—domain models—are used during requirements analysis or the early stages of design to capture the domain concepts and relationships in the form of class diagrams. Modellers perform domain modelling to transform the problem descriptions that express informal requirements in natural language to domain models, which are more concise and analyzable. However, this manual practice of domain modelling is laborious and time-consuming. Existing approaches, which aim to assist modellers by automating or semi-automating the construction of domain models from problem descriptions, fail to address three non-trivial aspects of automated domain modelling. First, automatically extracted domain models from existing approaches are not accurate enough to be used directly or with minor modifications for software development or teaching purposes. Second, existing approaches do not support modeller-system interactions beyond providing recommendations. Finally, existing approaches do not facilitate the modellers to learn the rationale behind the modelling decisions taken by an extractor system. Therefore, in this paper, we extend our previous work to facilitate bot-modeller interactions. We propose an algorithm to discover alternative configurations during bot-modeller interactions. Our bot uses this algorithm to find alternative configurations and then present these configurations in the form of suggestions to modellers. Our bot then updates the domain model in response to the acceptance of these suggestions by a modeller. Furthermore, we evaluate the bot for its effectiveness and performance for the test problem descriptions. Our bot achieves median F1 scores of 86%, 91%, and 90% in the Found Configurations, Offered Suggestions, and Updated Domain Models categories, respectively. We also show that the median time taken by our bot to find alternative configurations is 55.5ms for the problem descriptions which are similar to the test problem descriptions in terms of model size and complexity. Finally, we conduct a pilot user study to assess the benefits and limitations of our bot and present the lessons learned from our study in preparation for a large-scale user study. [ABSTRACT FROM AUTHOR]

The Discrete Event System Specification (DEVS) is a modular and hierarchical Modeling and Simulation (M&S) formalism based on systems theory that provides a general methodology for the construction of reusable models. Well-defined M&S structures have a positive impact when building simulation models because they can be applied systematically. However, even when DEVS can be used to model routing situations, the structures that emerge from this kind of problem are significant due to the handling of the flow of events. Often, the modeler ends with a lot of simulation models that refer to variants of the same component. The goal of this paper is to analyze the routing process domain from a conceptual modeling perspective through the use of a new DEVS extension called Routed DEVS (RDEVS). The RDEVS formalism is conceptually defined as a subclass of DEVS that manages a set of identified events inside a model network where each node combines a behavioral description with a routing policy. In particular, we study the modeling effort required to solve the M&S of routing problems scenarios employing a comparison between RDEVS modeling solutions and DEVS modeling strategies. Such a comparison is based on measures that promote the capture of the behavioral complexity of the final models. The results obtained highlight the modeling benefits of the RDEVS formalism as a constructor of routing processes. The proposed solution reduces the modeling effort involved in DEVS by specifying the event routing process directly in the RDEVS models using design patterns. The novel contribution is an advance in the understanding of how DEVS as a system modeling formalism supports best practices of software engineering in general and conceptual modeling in particular. The reusability and flexibility of the final simulation models, along with designs with low coupling and high cohesion, are the main benefits of the proposal that improve the M&S task applying a conceptual modeling perspective. [ABSTRACT FROM AUTHOR]

An optimal software release strategy is a well-investigated issue in software reliability literature. Comprehensive testing is expected before releasing the software into the market to enhance the reliability and security of the software device. In recent years, few analysts have recommended the scheme for software projects that support releasing the software early in the market and continue the testing process for an added period in the field environment even after the software is distributed. These studies are based on one common assumption that the efficiency of the software engineers in detecting the faults occurs at a consistent rate throughout the testing phase. However, bug-identification rate may experience discontinuity at the software release time. In software engineering, the time-point at which fault detection rate changes is termed as change-point. Consequently, an alternative software release policy is proposed in the present paper, which offers a generalized framework for fault detection phenomenon using the unified approach. An extensive analysis of software time-to-market and testing duration based on cost-efficiency and reliability measures is discussed by considering the change in tester's fault detection rate. A multi-criteria decision making technique known as multi-attribute utility theory is applied to optimize the software release policy under field-testing (FT) and no field-testing (NFT) frameworks. The relevance of the optimization problem is illustrated using a numerical example, comprising both the exponential and S-shaped bug-detection process. [ABSTRACT FROM AUTHOR]

This paper investigates how the core technical processes of the INCOSE model of systems engineering differ from other models of designing used in the domains of mechanical engineering, software engineering and service design. The study is based on fine-grained datasets produced using mappings of the different models onto the function-behaviour-structure (FBS) ontology. By representing every model uniformly, the same statistical analyses can be carried out independently of the domain of the model. Results of correspondence analysis, cumulative occurrence analysis and Markov model analysis show that the INCOSE model differs from the other models in its increased emphasis on requirements and on behaviours derived from structure, in the uniqueness of its verification and validation phases, and in some patterns related to the temporal development and frequency distributions of FBS design issues. [ABSTRACT FROM AUTHOR]

There are many tangled normative and technical questions involved in evaluating the quality of software used in epidemiological simulations. In this paper we answer some of these questions and offer practical guidance to practitioners, funders, scientific journals, and consumers of epidemiological research. The heart of our paper is a case study of the Imperial College London (ICL) covid-19 simulator, set in the context of recent work in epistemology of simulation and philosophy of epidemiology. [ABSTRACT FROM AUTHOR]

This document is a guest editorial for a special issue of the journal "Programming & Computer Software" titled "Recent Trends on Advanced Computing: The Converging Technologies." The issue features research and practical implementation results from researchers and industry experts in computer science, engineering, and technology. The papers cover a range of topics including microservices, software quality, user engagement on social media, non-functional requirements, medical software architecture, fallacies in political speeches, intelligent learning environments, and more. The guest editors for this special issue are Prof. Dr. Andrei Tchernykh, Prof. Reyes Juárez Ramírez, Dr. Esteban Mocskos, and Prof. Sergio Nesmachnow. [Extracted from the article]