As researchers today, we are witnessing a fundamental change in our technologically-enabled world due to the advent and diffusion of highly disruptive technologies such as generative Artificial Intelligence (AI), Augmented Reality (AR) and Virtual Reality (VR). In particular, software engineering has been profoundly affected by the transformative power of disruptive innovations for decades, with a significant impact of technical advancements on social dynamics due to its socio-technical nature. In this article, we reflect on the importance of formulating and addressing research problems in software engineering through a socio-technical lens, thus ensuring a holistic understanding of the complex phenomena in this field. We propose a research playbook with the aim of providing a guide to formulate compelling and socially relevant research questions and to identify the appropriate research strategies for empirical investigations, with an eye on the long-term implications of technologies or their use. We showcase how to apply the research playbook. Firstly, we show how it can be used retrospectively to reflect on a prior disruptive technology, Stack Overflow, and its impact on software development. Secondly, we show how it can be used to question the impact of two current disruptive technologies: AI and AR/VR. Finally, we introduce a specialized GPT model to support the researcher in framing future investigations. We conclude by discussing the broader implications of adopting the playbook for both researchers and practitioners in software engineering and beyond.

This study reports the results of applying the cross-lingual bug localization approach proposed by Xia et al. to industrial software projects. To realize cross-lingual bug localization, we applied machine translation to non-English descriptions in the source code and bug reports, unifying them into English-based texts, to which an existing English-based bug localization technique was applied. In addition, a prototype tool based on BugLocator was implemented and applied to two Japanese industrial projects, which resulted in a slightly different performance from that of Xia et al.

Although literature has noted the effects of branch handling strategies on change recommendation based on evolutionary coupling, they have been tested in a limited experimental setting. Additionally, the branches characteristics that lead to these effects have not been investigated. In this study, we revisited the investigation conducted by Kovalenko et al. on the effect to change recommendation using two different branch handling strategies: including changesets from commits on a branch and excluding them. In addition to the setting by Kovalenko et al., we introduced another setting to compare: extracting a changeset for a branch from a merge commit at once. We compared the change recommendation results and the similarity of the extracted co-changes to those in the future obtained using two strategies through 30 open-source software systems. The results show that handling commits on a branch separately is often more appropriate in change recommendation, although the comparison in an additional setting resulted in a balanced performance among the branch handling strategies. Additionally, we found that the merge commit size and the branch length positively influence the change recommendation results.

The debugging process is a huge burden on developers, both in terms of time and mentality. Scriptable debugging approaches have been proposed to reduce the burden associated with such debugging work. Scriptable debuggers (SDs) enable to describe developers' debugging process and share the debug scripts to reduce debugging effort. However, SDs require an execution environment for those scripts, and they are unable to manage ancillary information such as execution results and prerequisites for using the script in one place. We extend the existing scriptable debugging and propose an interactive literate debugging environment that enables reproducible bug reporting. The proposed method provides an executable script description that manipulates the debugger, information obtained through the debugger by executing the script, its visualization format, and the ability to save the information in the form of a document that includes explanatory text. By using these documents, it is possible to observe the detailed behavior of a program at runtime and to share the situation in which the focused behavior occurs among developers. In this paper, we describe our proposed interactive literate debugging environment and introduce our prototype tool, JISDLab, which is a web application using Jupyter. The sample debug script used in our demonstration scenario can be accessed via https://github.com/tklabgroup/JISDLab/blob/master/debugspace/case-SANER2022-tooldemo.ipynb

Primitive types are fundamental components available in any programming language, which serve as the building blocks of data manipulation. Understanding the role of these types in source code is essential to write software. Little work has been conducted on how often these variables are documented in code comments and what types of knowledge the comments provide about variables of primitive types. In this paper, we present an approach for detecting primitive variables and their description in comments using lexical matching and advanced matching. We evaluate our approaches by comparing the lexical and advanced matching performance in terms of recall, precision, and F-score, against 600 manually annotated variables from a sample of GitHub projects. The performance of our advanced approach based on F-score was superior compared to lexical matching, 0.986 and 0.942, respectively. We then create a taxonomy of the types of knowledge contained in these comments about variables of primitive types. Our study showed that developers usually documented the variables' identifiers of a numeric data type with their purpose (69.16%) and concept (72.75%) more than the variables' identifiers of type String which were less documented with purpose (61.14%) and concept (55.46%). Our findings characterise the current state of the practice of documenting primitive variables and point at areas that are often not well documented, such as the meaning of boolean variables or the purpose of fields and local variables.

With the growing complexity of modern software, the expense of improving software reliability becomes significant. To reduce costs, Software Defect Prediction (SDP) was proposed to detect hidden bugs a few decades ago. Recent studies demon-strate the superiority of the deep learning-based approach in SDP, such as Convolutional Neural Network (CNN). However, the noise in defect data can still deteriorate their performance. To enhance the performance of the state-of-the-art CNN-based method, we propose an improved SDP framework named Defect Prediction via Multi-Channel Convolutional Neural Network (DP-MC-CNN). The novelty is that DP-MC-CNN extracts sub-trees from the Abstract Syntax Tree, generates multiple paths, and feeds them to a multi-channel CNN, which weakens the noise effect. In evaluation, we assess DP-MC-CNN on seven projects by average F1 score, and it outperforms the state-of-the-art CNN-based method by 3.93%. Furthermore, we validate the effectiveness of the multi-channel approach and reveal the influences of each sub-tree component.

To understand program's behavior, using reverse-engineered sequence diagram is a valuable technique. In practice, researchers usually record execution traces and generate a sequence diagram according to them. However, the diagram can be too large to read while treating real-world software due to the massiveness of execution traces.

Dynamic feature location techniques (DFLTs), which use execution profiles of scenarios that trigger a feature, are a promising approach to locating features in the source code. A sufficient set of scenarios is key to obtaining highly accurate results, however, its preparation is laborious and difficult in practice. In most cases, a scenario exercises not only the desired feature but also other features. We focus on the relationship between a module and multiple features that can be calculated with no extra scenarios, to improve the accuracy of locating the desired feature in the source code. In this paper, we propose a DFLT using the odds ratios of the multiple relationships between modules and features. We use the similarity coefficient, which is used in fault localization techniques, as a relationship. Our DFLT better orders shared modules compared with an existing DFLT. To reduce developer costs in our DFLT, we also propose a filtering technique that uses formal concept analysis. We evaluate our DFLT on the features of an open source software project with respect to developer costs and show that our DFLT outperforms the existing approach, the average cost of our DFLT is almost half that of the state-of-the-art DFLT.

Behaviors of an object-oriented system can be visualized as reverse-engineered sequence diagrams from execution traces. This approach is a valuable tool for program comprehension tasks. However, owing to the massiveness of information contained in an execution trace, a reverse-engineered sequence diagram is often afflicted by a scalability issue. To address this issue, we present in this paper a method for identifying core objects for trace summarization by reference relations and access analysis. We detect and eliminate temporary objects that are trivial for a system, and then estimate the importance of non-trivial objects. By grouping objects with a focus on highly important ones (i.e., core objects), we visualize the system's behavior in terms of intergroup interactions. Consequently, we obtain a readable size of a reverse-engineered sequence diagram containing the system's key behavior. We implemented our technique in our tool and evaluated it by using traces from open-source software systems. The results showed that our reverse-engineered sequence diagrams contained only less than 30 lifelines, whereas the original diagrams (no abstraction methods were applied) contained approximately 1,000 to 3,000 lifelines. Our proposed method achieved significant reduction of the horizontal size of the diagram and is expected to be a valuable tool for program comprehension.

One of the most common causes of bugs is overlooking changes. To prevent bugs and improve the quality of the products, numerous studies have been undertaken on change guides based on logical couplings extracted from developers' past process histories, such as change history. While valuable change rules based on logical couplings can be gleaned found from the change history, these rules often fail to find appropriate candidates because the change histories in repositories only preserve a summary of changes between commits. We recently analyzed the interaction data produced by a developer in an integrated development environment. Such interaction data contains not only a detailed change history but also reference activities between commits. In this paper, we investigate whether logical couplings extracted from interaction data could improve change recommendation performance. We used the interaction data from actual open source development, not from the project only for this study. Experimental results obtained using the interaction data from actual open source development showed a significant improvement in the efficiency of the change recommendation process. The results also indicated improvement in the number of detected artifacts that the developer had forgot to change.

In most current cases of enterprise system development, the requirement specifications should follow those of an existing legacy system. However, it is difficult to identify high-level specifications, such as business process steps, from legacy and undocumented systems. In this paper, we propose a method to recover an abstract business process by using system logs and the organizational information of the operators using an existing legacy system. Our method provides a hierarchical view based on a clustering technique to find abstract activities that consist of a series of operations. We also propose a method to extract the main operation in a cluster. We evaluated the effectiveness of our method through experiments on a real system.

Feature location (FL) is an important activity for finding correspondence between software features and modules in source code. Although dynamic FL techniques are effective, the quality of their results depends on analysts to prepare sufficient scenarios for exercising the features. In this paper, we propose a technique for guiding identification of missing scenarios using the prior FL result. After applying FL, unexplored call dependencies are extracted by comparing the results of static and dynamic analyses, and analysts are advised to investigate them for finding missing scenarios. We propose several metrics that measure the potential impact of unexplored dependencies to help analysts sort out them. Through a preliminary evaluation using an example web application, we showed our technique was effective for recommending the clues to find missing scenarios.

To comprehend an object-oriented software, visualizing object interactions performed as a UML sequence diagram is a promising technique for helping developers. However such UML sequence diagrams are typically too huge to comprehend behavior. In this paper, we propose a novel technique to generate abstracted sequence diagrams based on the information of applied GoF design patterns in a source code. We discuss effectiveness of our approach through a case study applying our implemented tool to an open source software.

We propose an XML C source code representation to support developing CASE tools. Since source code is a main artifact of software development, most CASE tools have some features related to source code editor, static analyzer, profiler, etc. To develop such tools, detailed information related to source code is needed. However, it is quite difficult to reuse program analysis features because they do not have common interfaces even for parsing and data/control-flow analysis that are most common features for such CASE tools. To address this issue, we focus on XML as an intermediate representation for source code information. Existing XML representations only represent structure of syntax trees and lack some important information required for CASE tools. We propose two models for representing source code, one is for intra-file information, which consists of syntax structure, flow, and type information, the other is for inter-file relation, which is cross-reference information. We also introduce CASE tools with our representation and demonstrate the efficacy in CASE tool development. To evaluate the efficacy, we show that a coding rule checker and a cross-referencer can be easily implemented using common XML processing libraries such as XSLT and XPath.

Software metrics is one of promise technique to capture the size and quality of products, development process in order to assess a software development. Many software metrics based on various aspects of a product and/or a process have been proposed. There is some research which discuss the relation between software metrics and faults to use these metrics as the indicator of quality. Most of these software metrics are based on structural features of products or process information related to explicit fault. In this paper, we focus on latent faults detected by static analysis techniques. The coding checker is widely used to find coding standards violations which are strongly relating to latent faults. In this paper, we propose new software metrics based on coding standards violations to capture latent faults in a development. We analyze two open source projects by using proposed metrics and discuss the effectiveness.

Software visualization with sequence diagrams is one of the promising techniques aimed at helping developers comprehend the behavior of object-oriented systems effectively. However, it is still difficult to understand this behavior, because the size of automatically generated sequence diagrams tends to be beyond the developer's capacity. In this paper, we propose a sequence diagram slicing method, which is an extension of our previous method based on a dynamic slicing technique using static information. Our proposed method is capable of accurate slice calculation based on high-precision data dependency and can support various programs, including exceptions and multithreading. In addition, our proposed new tool performs slice calculations on the Eclipse platform and we demonstrate the applicability of this method by applying the tool to two Java programs as case studies. The results confirm the effectiveness of our proposed method for understanding the behavior of object-oriented systems.

In software development with frameworks, it is essential to use the framework with which given software requirements are implementable. This paper focuses on use cases as the requirements specifications and proposes a technique to check whether the given use cases are implementable with the framework. To check the implementability, consistency of branch conditions of the frameworks and the requirements specification has to be checked as well as equivalence of action sequences between the frameworks and the requirements specification. To this end, a novel approach based on a satisfiability problem for deriving the consistent truth assignments of the branch conditions is introduced. The approach can be incorporated in bi-simulation checking for assuring the equivalence of the action sequences, and therefore, the implementability can be checked. Furthermore, this paper shows a feasibility of the proposed technique by using Compositional Reachability Analysis as a mean of bi-simulation checking.

We have previously proposed a unified presentation contents search mechanism named UPRISE (unified presentation slide retrieval by impression search engine), and have also proposed a method to use laser pointer information in lecture scene retrieval. In this paper, we discuss the treatment of the laser pointer and speech information, and propose two methods to filter the laser pointer information using keyword occurrence in slides and speech. We also propose weighting schemata with filtered laser pointer information using slide text and speech information. We evaluate our approach by using actual lecture videos and presentation slides

In a workflow management system, appropriate allocation of its activities greatly contributes to the improvement of its efficiency. We have proposed OXTHAS, a loadbalancing method of scheduling the activities in workflow management systems using Web-services. The OXTHAS makes the activities to be assigned to appropriate executors based on the estimation of their processing capacity using execution histories in workflow engines. In this paper, we propose a failure-aware re-scheduling method for the OXTHAS using process time-outs under network and system failures. To allocate activities appropriately, the estimated processing capacity and time-out duration are re-calculated with consideration of the penalty for a failure when a process time-out occurs. We then evaluate the effectiveness of the proposed methods through simulations.

More and more within the last couple of years, there is a recognition that the Web services composition concept constitute a major breakthrough and revolutionize the way we deal with integrating disparate and distributed computing environments. Yet, to rise to such a position, a chief concern is to guarantee a high-dependability level of the Web services compositions, which is significantly critical, specially in view of the particularities of the Web services environment unpredictability, heterogeneity, autonomy), if confronted with other computing environments. Our present work falls within this context since we tackle the problem of QoS (quality of service) in the Web services context by verifying to what extent fault-tolerant and dynamically-executed Web services compositions are efficiently serving their purposes. And in pursuing this goal, we introduce a novel model that characterizes, estimates and analyzes several QoS properties of dynamically-executed fault-tolerant Web services compositions - namely the reliability and the execution time. Our model allows acquiring more accurate estimations since it confers a paramount importance to the repercussions of failures. In addition, contrary to other QoS estimations models in the Web services context, which use QoS estimations published in UDDIs by the Web services owners/providers, our model computes QoS estimations on the base of the compositions execution observations, where the observation results are collected in a history. Finally, since Web services are stateless, tracking the failures and determining their locations is almost impossible. To overcome this limitation, we propose to attach to each of the composition's component a state. In doing so, obtained estimations can contribute in acquiring more accurate information about the failures locations and can be used later to improve the composition QoS in the future.

This paper proposes a plant-shaped robot object as an awareness driven display device of human daily life information. While a conventional monitor display (operation driven display) device transmits information to a person when it is operated intentionally (actively) by the person, the awareness driven display device transmits the information to the person when the device is made aware by chance (passively) by the person with a change of its appearance. The constructed display device is designed taking account of a houseplant. It consists of 12 leaf modules and a flower module. It displays the information by means of leaf poses and extent of flower opening. The leaves can also sense a touch action. A display experiment was conducted to evaluate the device. The activity of a remote target person is calculated from actual sensed daily life data and displayed to the subject person. Experimental results show the effectiveness of the display system. It reveals that a larger change of pose and flower opening evokes more effective awareness of the activity of the person. This display device in the future will be able to be utilized as a communication tool to generate a virtual feeling of cohabitation even though the remote target person lives apart from the subject person.

This paper discusses a technique to model software patterns for supporting pattern based software development. Software development can be considered as the evolution of the artifacts to be produced. Software patterns are general structures that frequently appear in the artifacts and the patterns are also being evolved as the artifacts are being done. By specifying how to evolve software patterns as software processes progress, we can get a support for developing an artifact from the artifacts that were produced in the previous steps. In our approach, we consider that a software pattern consists of a pattern structure (a class diagram and/or an object diagram) and manipulation operations on the pattern structure. These operations are for pattern instantiation (applying a pattern to an actual problem) and for pattern evolution (evolving the artifacts of the previous steps into a new one). We model them with the object-oriented technique encapsulating these operations into patterns.