In architecture-based self-adaptation, the managed system is represented as a collection of components that adapt to environmental changes by reconfiguring their composition. When time constraints are involved, process flow diagrams are typically used for verification. However, the ambiguity between flow diagrams and component diagrams often causes confusion, complicating system design. This paper establishes a clear relationship between components and process flows, proposing a framework that facilitates component-oriented system development. Furthermore, it introduces an implementation API for self-adaptive systems with time-constraint verification capabilities and outlines a design procedure for developing such systems. To validate the proposed framework, we implemented and verified the operation of a transportation system, demonstrating its feasibility. Notably, the framework’s system structure ensures that even when a component is involved in multiple functions, the system configuration search can be completed within a fixed amount of time, regardless of the number of functions.

Stakeholders want quality in use requirements to be satisfied as much as possible to make their life or business activities better than ever. However, some of them should be abandoned if they are expensive. In this paper, we propose a method for analyzing the cost ratio of quality in use for a life or business system during early requirements analysis. This method enables stakeholders to sort out initially required quality in use requirements. The cost depends on the number and the complexity of operations in a system, their data and users. In this method, KAOS model is thus used because it contains goals, operations, users and data. KAOS model also enables us to represent the roles of both human and artificial systems embedded in a business system. When a part of a system should achieve some functional and quality goal, the goal should be transformed into some operations and their data respectively. The relative cost of some function or quality is thus quantified on the basis of operations, data and associations among them. Through the case study, the results of analysis seemed to meet our intuition. In addition, we found the relative cost of quality in use is not so small. This finding makes stakeholders to abandon some of quality in use in this case if they do not have enough budget and/or time.

The development of service systems leveraging Machine Learning (ML) has been actively pursued in recent years. In the development of general service systems, knowledge for effectively managing projects has been systematized. Similarly, in ML service system development projects (ML projects), knowledge such as best practices and patterns is being established. Among these, anti-patterns documenting situations that cause issues in ML projects and their corresponding solutions, are also being organized. However, knowledge like patterns and anti-patterns does not clearly define who should recognize their necessity or apply the solutions. As a result, in ML projects, where collaboration among stakeholders is critical, the utilization of such knowledge often depends on the experience and skills of the individuals involved. In this study, we propose a diffusion model for anti-patterns in ML projects and a method for representing the model. Furthermore, by representing actual anti-patterns as a diffusion model using the proposed method, we verify the effectiveness of the represented model.

Robotic Process Automation (RPA) is a technology that uses software robots to mimic and automate human operations performed on computers. By utilizing RPA bots—automation scripts designed for RPA—it is possible to streamline repetitive tasks, reduce work time, and prevent errors. In RPA bot development, the concept of “reusable development” is particularly effective. However, existing RPA platforms face a challenge: when reusing bots, it is often difficult to quickly identify the most suitable bot for a given purpose. This study aims to analyze the requirements for a high-precision search function that facilitates the utilization and reusable development of RPA bots. Through investigation and analysis of RPA bots, we identified that categorizing RPA bots based on their processing functions and leveraging these categories for search purposes is an effective approach. Specifically, we classified bots into categories such as “Application Integration” and “Data Transformation” and conducted a detailed examination of each category. Based on these findings, the study introduces a search method that incorporates category classification according to the processing content of the RPA bots. This method is expected to support the promotion of reusable development of RPA bots.

Streaming Process Discovery has attracted attention as a method to discover a process model in dynamic business processes. In particular, addressing concept drift that occurs within continuously incoming event logs has been emphasized as a critical challenge. Existing methods have mainly focused on the accuracy of detecting concept drift. However, they do not take into account the change type and the amount of change, leading to excessive updates of the process model even for minor changes. In this study, we propose a method that classifies concept drift into distinct types to reduce the number of updates and execution time appropriately. We conducted experiments using four different event logs. The results demonstrate that the proposed method outperforms existing methods, significantly reducing the number of updates and execution time.

Requirements elicitation is the most crucial yet challenging activity in the requirements analysis phase.Several studies conducted in this field aid in this activity; however, requirements elicitation for innovative systems remains a difficult task due to the lack of experts for such novel systems.To address this challenge, we discuss a requirements elicitation process based on collaborative LLMs.This process involves multiple LLMs, each representing various experts, to gather a diverse range of opinions.We conducted two preliminary case studies aimed at collecting opinions about innovative systems by broadening the pool of experts.The results indicate that this process systematically increases the number of collected opinions.We will discuss our future plans, drawing insights from the results of these preliminary case studies.

In software development, the rapid expansion of code often leads to increased complexity and higher maintenance costs, particularly when unused or redundant code accumulates over time. This study introduces a novel approach to analyzing and visualizing code reachability using probabilistic model checking, enabling efficient identification of components that may no longer be necessary. By leveraging probabilistic reachability analysis, our method evaluates the usage trends of packages, classes and methods throughout the system’s lifecycle. We implemented a prototype tool and conducted case studies on real-world projects to validate its effectiveness. The results demonstrate the tool’s potential to support strategic code management by identifying and visualizing frequently used, rarely used and unused code components, thereby facilitating system optimization and reducing maintenance overhead.

This study addresses software bloat, a prevalent issue in modern software development, causing excessive size and complexity due to feature additions and unnecessary functions. Such bloat leads to decreased efficiency, performance degradation, and increased vulnerability. To combat this issue, the concept of software 3R (reduce, reuse, recycle) is proposed; however, accurately reproducing the internal state of black-box software for 3R requires both source code and execution log data, posing practical challenges. In this paper, we conduct a software execution status estimation using limited execution log. Graph Neural Networks (GNNs) are employed for analysis, offering effective processing of graph data. The task is framed as link prediction and node classification, comparing traditional deep learning methods with GNNs using Apache OFBiz ERP software logs. Preliminary results validate GNN applicability.

In order for a system to provide services in any environment, it is expected to establish a technique for constructing a self-adaptive system that can adapt to its environment by changing its own behavior. Real-world systems often have time constraints. While time constraints are involved in safety and usability concerns, the execution time of a system is uncertain due to uncertainties in the external environment, and this uncertainty should be considered when verifying the system. In this paper, we propose a self-adaptive system implementation framework that can handle time constraints and has a dynamic verification function that considers execution time uncertainty. The framework uses UPPAAL-SMC, a statistical model checking tool that can handle time, to represent execution time uncertainty and perform dynamic verification. We evaluate the usefulness of the proposed framework by implementing a simple self-adaptive system using the framework and verifying the system behavior.

In application marketplace platforms like the Google Play Store, reviews left by users on applications play a vital role for developers. By analyzing user reviews, developers identify potential requirements. The goal model is a commonly used model in requirements analysis. Utilizing reviews to generate goal models can help developers comprehensively understand user requirements. However, manually analyzing a large volume of reviews is a time-consuming and labor-intensive task. To address this problem, an automatic method for clustering user reviews and identifying goal models has been proposed. Nevertheless, the goal model generated by this method has poor accuracy, and the goals generated are difficult for developers to understand. To more comprehensively extract requirements from user reviews, we propose a goal model generation method based on large language models (LLMs). The proposed method consists of two parts: first, a Latent Dirichlet Allocation (LDA) model divides user reviews into different topics; second, we use specific prompts and examples to extract requirements and generate goal models. Experiments show that our LLM-based goal model generation method improves the accuracy of goal model generation and identifies more requirements compared to the existing method.

Processes of some business or life activities are sometimes changed due to some reasons, such as the emergence of new technologies and the change of the human behavior caused by a seasonal event, e.g. Christmas. Such changes are called concept drift. Detecting concept drift is useful for many reasons. For example, we can update existing out-of-date business rules. Many methods of concept drift detection in processes have been already proposed. However, most of them are a little bit complex because sliding widows should be defined on a log of business process during its analysis. We thus propose a light-weight method for its detection by using heuristic miner, which is a famous algorithm for process discovery. In our method, we simple observe the discovered model to identify the infrequent actions and transitions between actions. Our method helps us to identify several types of concept drift although some types cannot be detected. We discuss how to overcome current limitations of our method.

Robotic process automation (RPA) is a technique for automating desktop tasks by developing bots. While RPA enables automatic repetition of tasks, various defects can occur during actual operations. Some defects manifesting as smells in bot codes during the development phase are considered to possess distinct characteristics compared to conventional programs. This study aims to classify these smells in RPA and facilitate their detection. We first categorize RPA smells using code reviews that highlight smells in actual bot development. Based on the categorization, we also develop a preliminary smell detection tool. The categorization result reveals that the most prominent category is substitutable process, highlighting the importance of replacing a sequence of commands with single RPA commands. Experimental results show that the detection tool can find smells with a high degree of accuracy. This high accuracy seems to be attributable to the stronger constraints present in RPA code compared to conventional programming code.

Software system developments generally involve writing codes.As code reduction is not considered, with accelerated software development, the number of code increases, which in turn increases the system management load.In this study, we pursue an analysis process to determine the necessity of each code present in the software.To handle a large amount of code, we utilize a probabilistic model checking technique.The analysis process identifies the trends in code usage by estimating probabilistic reachability.We implemented a prototype tool for the analysis.Results of two case studies in the real world demonstrate that the tool set has a possibility of extracting components that can be eliminated in the projects.

Many different activities are performed simultaneously in the real world, and one of them contains actions, that can be utilized in another activity. If such actions are actually utilized, the activity utilizing them become more efficiently than ever. We call the activity providing such actions a contributable activity, and the one utilizing the actions a contributed activity. Our research goal is to find such contribution relationships between activities. To achieve the goal, we used a conformance checking technique in the field of process mining research. In the process mining research, logs of actions and control flow models are used, and the logs and the models are usually represented by the verb attribute in an action such as “submit”, “decide” and so on. However, we could not find some contribution relationships by using the logs and models of the verb attribute. We thus examine the usage of non-verb attributes such as a place or a tool in an action for our goal. Through a case study about elderly people care, we find non-verb attributes have some potential to achieve our goal more comprehensively than ever.

In this study, we consider projects for developing service systems using machine learning (ML) techniques. As ML techniques have been introduced in various domains, there is reusable knowledge on ML projects that can be employed for conducting such projects without facing major failures. The usage of such knowledge during a project has not yet been clearly described in the form of reusable knowledge such as best practices or patterns. Thus, in this study, we propose a method for collecting the ominous signs in ML projects as “bad smells” and incorporating them as a part of such reusable knowledge. We confirmed the effectiveness of the proposed method through an evaluation.

Self-adaptive systems can adapt to environmental changes by modifying their behavior and require runtime verification after adaptation.More efficient verification mechanisms are required because verification mechanisms such as model checking are computationally and memory intensive.A possible method is to generate expressions for model checking at design time and execute such expressions at runtime.Our previous work proposed a caching mechanism and parameterization to improve the expression generation method.In this study, we improve our previous work by generating expressions using Laplace expansion.This method expands the probabilistic model at the points where it is different from the design model and brings the model closer to a model in a cache for generating expressions.We also propose a method to generate candidate metrices to increase the number of cached matrices and improve the cache hit ratio.We conducted experiments with three types of changes, that is, adding, changing, and deleting states.We observed that our approach is effective when the model's states are added or changed.

We propose a method to comprehensively find a pair of business or life activities, which can mutually contribute to each other. We assume that the activities with synchronized processes can mutually contribute to each other. A process model of an activity is thus compared to a log of another activity for measuring whether the activities can synchronize their processes to a certain extent using a conformance checking technique. The threshold of the extent is defined on the basis of a randomly generated log containing the same events as those in the compared log. We tentatively evaluated the method through a case study, and confirmed that the method seemed to be valid.

Self-adaptive systems can decide autonomously to adapt their settings depending on the current situation of their operating environment. To increase their dependability in a dynamic environment, different techniques like evolutionary al-gorithms, artificial intelligence techniques, etc., have been widely used. Recently, machine learning has been leveraged to solve issues like discovering new knowledge at runtime or helping to cope with uncertainty. The adaptation space reduction problem and the interactions with human-in-the-loop problem are among the issues facing self-adaptive systems. In our work we propose a mechanism that can solve the former while contributing to a solution for the latter. The mechanism uses a deep learning approach that leverages explainable AI (XAI) in the process of the learning and predictions. Our approach uses a convolutional neural network (CNN) to implement the deep learning approach and the integrated gradients technique for the explainable AI (XAI). XAI helps to build trust in the system by explaining the predictions and the behavior of the deep learning model. We evaluated our approach on the MAPE-K framework of two simulated Internet of Things systems.

We study the applicability of graph queries to the coverage analysis of test cases for requirements specifications.First we show that when the similarity degrees between requirements specifications and test cases are available, they can be represented in the form of a graph.Then we identify several queries that are useful for extracting coverage information and show that all these queries can be written in the Cypher query language, a common graph query language.In a case study we apply these queries to data obtained from a real-world project in industry.The results of the case study show that coverage information can be retrieved in reasonable time.We also compare the graph queries with SQL queries with respect to conciseness and processing time.

Combinatorial interaction testing is an efficient software testing strategy. If all interactions among test parameters or factors needed to be covered, the size of a required test suite would be prohibitively large. In contrast, this strategy only requires covering t-wise interactions where t is ty pically very small. As a result, it becomes possible to significantly reduce test suite size. Locating arrays aim to enhance the ability of combinatorial interaction testing. In particular, (1¯,t) -locating arrays can not only execute all t-way interactions but also identify, if any, which of the interactions causes a failure. In spite of this useful property, there is only limited research either on how to generate locating arrays or on their minimum sizes. In this paper, we propose an approach to generating minimum locating arrays. In the approach, the problem of finding a locating array consisting of N tests is represented as a Constraint Satisfaction Problem (CSP) instance, which is in turn solved by a modern CSP solver. The results of using the proposed approach reveal many (1¯,t) -locating arrays that are smallest known so far. In addition, some of these arrays are proved to be minimum.

Combinatorial interaction testing is known to be an efficient testing strategy for computing and information systems. Locating arrays are mathematical objects that are useful for this testing strategy, as they can be used as a test suite that permits fault localization as well as fault detection. In this application, each row of an array is used as an individual test. This paper proposes an algorithm for constructing locating arrays with a small number of rows. Testing cost increases as the number of tests increases; thus the problem of finding locating arrays of small sizes is of practical importance. The proposed algorithm uses simulated annealing, a meta-heuristic algorithm, to find locating array of a given size. The whole algorithm repeatedly executes the simulated annealing algorithm with the input array size being dynamically varied. Experimental results show (1) that the proposed algorithm is able to construct locating arrays for problem instances of large sizes and (2) that, for problem instances for which nontrivial locating arrays are known, the algorithm is often able to generate locating arrays that are smaller than or at least equal to the known arrays. Based on the results, we conclude that the proposed algorithm can produce small locating arrays and scale to practical problems.

Self-adaptive software systems change their behaviors to adapt to their environmental changes at runtime. Runtime verification, which checks the correctness of behaviors after adaptation, sometimes uses probabilistic model checking, because the verification has to deal with uncertainty. However, since probabilistic model checking is usually computation intensive and time consuming, a more efficient verification mechanism is desired. A possible approach is to pre-generate some expressions for model checking at design time and execute model checking simply by evaluating the expressions at runtime. A problem with this approach is that when environmental changes require changes of the system model, these expressions need to be re-generated at runtime. In order to cope with such significant changes, we develop a caching mechanism that reduces computational time at runtime. We also introduce a parameterization technique in order to improve the efficiency of caching. The experimental results show that our new implementation of the caching mechanism greatly improves the computational time of runtime verification.

CPS (Cyber Physical System) includes a complicated architecture that spans cyber space and physical space. There are several relationships related to the transmission of data and energy and the control and monitoring of CPS components. Many control loops exist, and these control loops represent the cyclic relations of components based on the relationships mentioned above. Design faults in the control loops can cause accidents, and so we propose a method of verifying the stability of control loops to ensure safety in CPS. In the proposed method, control loops are identified in an architecture model proposed by us. An identified control loop is converted into a temporal logic formula, and the stability of a control loop is verified using a model checking tool. The effectiveness of the proposed method was confirmed by applying a farm monitoring system, which can be considered a type of actual CPS.

Embedded systems that realize specific functions are usually hardware constrained systems running dedicated software. These embedded systems rarely take into account the possibility to change functions after their release. As a result, it would be difficult to change some function from outside an embedded system in its operational environment. In order to keep up with the need of quickly reacting to changes affecting requirements and environments, it is paramount to find a way to update the functions of these systems. We constructed a programming framework for updating functions based on the MAPE loop mechanism, which is generally used to develop self-adaptive systems. We regard MAPE loop as a set of independent components that make it easy to separate the updating functions from other functions. We apply our framework to a web application and an embedded system. The proposed framework is independent of the target embedded system and makes it possible to easily inject new functions into it.

Application users can submit reviews for downloaded applications.Recently, developers have received more and more user reviews.However, it is still difficult to extract beneficial comments from a large amount of reviews.Latent Dirichlet Allocation (LDA) is a promising way of topic modeling, which classifies documents according to implicit multiple topics.However, there is a gap between the documents that the developer wants to extract and the document extracted by LDA.In this paper, we propose a method to extract documents of each category, such as requirements descriptions or bug reports, more accurately.Our method first decomposes the topics.Then, the method uses the keyword list which is a set of semantically similar words collected by word2vec, to integrate the decomposed topics.We apply our method to the applications user reviews in Apple Store and demonstrate the validity of it.Our approach can help application developers to extract beneficial information.

Efficient software testing requires precise test space definition.To determine the test space, constraint elicitation is one of the important processes in a test design; however, the process usually requires manual capturing and precise definition of constraints.We have developed a constraint elicitation process that helps to define constraints from documents relevant to the test model.In this paper, we propose a refined metric that finds parameter combinations to be extracted more precisely.This metric determines the parameter correlation on the basis of word co-occurrences in the specification document.We conduct experiments on some test models and demonstrate that our metric allows us to find parameter combinations that form constraints with a high recall rate.

Feedback comments, such as mailing lists and reviews, contain beneficial suggestion for software developers.Recently, developers have received more and more feedback comments; but it is still difficult to extract beneficial comments from a large amount of e-mail message or reviews.Latent Dirichlet Allocation (LDA) is a promising way of topic modeling, which classifies documents according to implicit multiple topics.In this paper, we tried to apply a requirements elicitation based on LDA to two different sources, i.e., Apache Commons User List and App Store reviews, and discuss the feasibility of this approach.An interesting finding was that some usual stop words indicated requirements description.This suggests that these words should be removed from the stop word list before applying LDA.

Many surprising recipes which have different the ingredients or the cooking processes from the normal recipes exist in the user-generated recipe sites. The easiest way to find surprising recipes is to use the search function of the recipe sites. However, the title of surprising recipes do not always include the keyword “surprise”. Therefore, we cannot find surprising recipes in an easy way. In this paper, we propose a method to extract surprising recipes from the user-generated recipe sites. We propose RF-IIF (Recipe Frequency-Inverse Ingredient Frequency) based on TF-IDF (Term Frequency-Inverse Ingredient Frequency). First, we calculate the surprising value of the ingredients by using RF-IIF. Then, we calculate the surprising value of each recipe by summing the surprising value of the ingredients appearing in a recipe. Finally, we extract recipes which have high surprising value of the recipe as surprising recipes of the dish category. In the evaluation experiment, the subjects were requested an evaluation about each surprising recipe. As a results, we showed that the extracted recipes were valid recipe and had the element of surprise. And, we showed the usefulness of the our proposed method.

Nowadays, anybody can easily express their opinion publicly through Consumer Generated Media. Because of this, a phenomenon of flooding criticism on the Internet, called flaming, frequently occurs. Although there are strong demands for flaming management, namely, a service to reduce damage caused by a flaming after one occurs, it is very difficult to properly do so in practice. We are trying to keep the flaming from happening. Concretely, we propose methods to identify a potential tweet which will be a likely candidate of a flaming on Twitter, considering public opinion among twitter users. We divide flamings into three categories: criminal episodes, struggles between conflicting values and secret exposures. The first two represent the vast majority of flaming cases. As for the CEs, a Naive Bayes-based method has been promising to identify the cases. As for the SBCVs, we propose a dynamic P/N analysis based on daily polarity, which represents the strength of the polarity of public opinion on a given topic. An experiment using a past flaming case has shown that the method has successfully explained the case as one caused by a gap between the polarity of the tweet and that of public opinion.

This article discusses the location of faulty interactions in software testing. We propose an algorithm to generate a test suite that can be used to identify a faulty pair-wise interaction. This approach works as follows. First, a test suite is generated using an existing method for pair-wise testing. Pair-wise testing requires testing all pair-wise interactions but does not guarantee that the faulty interaction can be located. Second, pair-wise interactions that cannot be located by the test suite are enumerated. Finally, test cases are repeatedly added to the test suite until all pair-wise interactions can be located. The results of applying the algorithm to several problem instances show that the test suites obtained using the algorithm are nearly twice as large as those for ordinary pair-wise testing which does not ensure fault locating ability.

There is a need for the development of systems that are compliant with laws in public administration, because their administrative activities are based on laws. When new laws are made or existing laws are amended, however, civil servants need to develop or modify the systems in the short time before the laws are issued. Related work in requirements elicitation from the legal texts includes approaches using ontology but there are difficulties in building an ontology for practical use. In this paper we propose pre-defined templates with the expression of functional requirements to identify legal texts, including their functional requirements, and a support tool consisting of two functions, one for automatic summary creation from complicated legal texts and one for the suggestion of the legal texts, including their functional requirements. We have also applied this approach to Japanese laws and have evaluated its accuracy. Our research revealed that using this approach can identify functional requirements with high accuracy.

Software evolution is an essential activity that adapts existing software to changes in requirements. Localizing the impact of changes is one of the most efficient strategies for successful evolution. We exploit requirements descriptions in order to extract loosely coupled components and localize changes for evolution. We define a process of elaboration for the goal model that extracts a set of control loops from the requirements descriptions as components that constitute extensible systems. We regard control loops to be independent components that prevent the impact of a change from spreading outside them. To support the elaboration, we introduce two patterns: one to extract control loops from the goal model and another to detect possible conflicts between control loops. We experimentally evaluated our approach in two types of software development and the results demonstrate that our elaboration technique helps us to analyze the impact of changes in the source code and prevent the complexity of the code from increasing.

Recently, the video hosting is one of the most popular services on the Web. The service user can search movies by title, tag, date, and so on. However, the user can hardly obtain information on a particular scene of a movie. Thus, it is very difficult to determine whether a movie contains interesting scenes or not. This research aims to provide information in order to help a user to choose a movie. Concretely, this paper proposes a method for labeling scenes in a movie using a video hosting service called "Nico Nico Douga". The proposed method extracts important scenes in a movie from "Nico Nico Douga" based on the statistics of social annotations attached to them. Also, using the characteristics of folksonomy the authors extract feature words for labeling. Moreover, in order to take advantage of the feature words, the authors estimate their semantic categories. We use the attached comments themselves to label the important scenes. In order to select the comments, the authors take into account the importance of the feature words with semantic categories in a scene. Finally, the authors carry out experiments to evaluate the proposed method and to discuss future works.

Formal methods and requirements analysis are techniques for developing complex systems. However, there is little research on reconciling the requirements phase with the formal specification phase. To bridge this gap, we propose a formal specification generator based on model transformation techniques. This tool transforms KAOS models (requirements specifications) into VDM++ formal specifications. Our generator enables consistent and effective software development activities.

The purpose of this study is to reduce the gap between the requirement analysis and analysis phases of developing multi-agent systems. We utilize KAOS, one of the goal-oriented analysis methodologies, as a requirement analysis method, and propose a model translation into an analysis model for simple and effective development of multi-agent systems.