In software maintenance work, software architects and programmers need to identify modules that require modification or deletion. Whilst user requests and bug reports are utilised for this purpose, evaluating the execution status of modules within the software is also crucial. This paper, therefore, applies spatial statistics to assess internal software execution data. First, we define a software space dataset, viewing the software's internal structure as a space based on module call relationships. Then, using spatial statistics, we conduct the visualization of spatial clusters and the statistical testing using spatial measures. Finally, we consider the usefulness of spatial statistics in the software engineering domain and future challenges. (This paper has been published in the 14th International Conference on Model-Based Software and Systems Engineering (MODELSWARD 2016).

This paper introduces QuanUML, an extension of the Unified Modeling Language (UML) tailored for quantum software systems. QuanUML integrates quantum-specific constructs, such as qubits and quantum gates, into the UML framework, enabling the modeling of both quantum and hybrid quantum-classical systems. We apply QuanUML to Efficient Long-Range Entanglement using Dynamic Circuits and Shor’s Algorithm, demonstrating its utility in designing and visualizing quantum algorithms. Our approach supports model-driven development of quantum software and offers a structured framework for quantum software design. We also highlight its advantages over existing methods and discuss future improvements.

With the growing interest in quantum computing, the emergence of quantum supremacy has marked a pivotal milestone in the field. As a result, numerous quantum programming languages (QPLs) have been introduced to support the development of quantum algorithms. However, the application of Model-Driven Development (MDD) in quantum system engineering remains largely underexplored. This paper presents an MDD-based approach to support the structured design and implementation of quantum systems. Our framework enables the automatic generation of quantum code for multiple QPLs, thereby enhancing development efficiency and consistency across heterogeneous quantum platforms. The effectiveness and practicality of our approach have been demonstrated through multiple case studies.

As software development increasingly relies on external collaboration, organizations face new risks of intellectual property leakage beyond traditional concerns about deployed software. Even when the source code is protected, adversaries may infer sensitive internal program specifications by observing the program behavior during the development and testing phases.This paper addresses the problem of specification leakage through behavioral observation in collaborative software development. We propose a novel software development method that centers on specially crafted test doubles referred to as secure mocks. Secure mocks serve as drop-in replacements for original components during development and testing while preventing the exposure of sensitive internal specifications through observable behavior. We formalize the correctness conditions for secure mocks and define the secure mock construction problem as a constraint satisfaction problem parameterized by the program to protect, the development specification, and a security policy. Our approach enables secure test-driven development (TDD) with external collaborators, bridging the gap between traditional TDD styles. We discuss the implications for secure collaboration with external developers and outline future research directions for automating secure mock generation and integrating this paradigm into real-world development pipelines.

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.

One of the success factors of Business process outsourcing (BPO) is a comprehensive and in-depth understanding of the business processes outsourced. However, such business processes are often undocumented, and discovering them is difficult and time-consuming for BPO service providers. Previously, we introduced an approach for business process discovery that uses swim lanes to recognize that different parts of the process may be performed by different parts of an organization. It generates the business process from an event log and user information extracted from an existing system. Herein, this paper examines whether the approach aids engineers and consultants in the providers who need to investigate business processes of organizations (i.e., their customers on which they do not have sufficient knowledge) discovering the implicit operational knowledge of the target business processes (e.g., undocumented local rules). To do so, we survey an industrial workflow system from which we collected data about 2,000 events and 269 users for a two-year period of the system's operation. We conducted a study on the case by means of document evaluation and expert interviews. The study suggested that the output of the approach is a valuable process visualization for identifying knowledge that is not documented nor recognized by even experts in organizations.

Microtask programming enables software engineers such as freelancers and part-time employees to contribute to software projects even when they can not spend much time on them. It decomposes software design into small, self-contained specifications. The decomposed specifications enable them to complete implementation and review task in a short time. In this paper, we empirically investigate the time required for software engineers to complete microtasks in an industrial setting and explore their perceptions of microtask programming by investigating two industrial projects using it. The projects were carried out in different companies and differed in the employment of the engineers. One contracted 9 freelancers, and the other asked for 8 part-time contributions from employees at work on other projects. We conducted a survey and a focus group with the engineers. Based on the development data of the case studies, we found that almost all microtasks were completed in less than four pomodoro repetitions, namely about two hours in the pomodoro technique. These data shows that engineers who cannot work full-time on a project can undertake microtasks if they can spare one-third of their work day. We also examine how engineers who are employees experience microtask programming similarly and differently from freelancers.

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.

COVID-19 has transformed face-to-face software development into distributed development (e. g., remote work). While the company authors belong to studies microtask programming, an open source software (OSS) -like development, as a solution to employ distributed development, a prior study reports a challenge: online communication in microtask programming takes longer; such lengthy communication discourages developers and affects their completion of assigned tasks. OSS, however, is successfully developed using online communication, such as issues. Hence, we have a question: how does OSS address the online communication challenge? In this experience report, we answer this question based on an empirical study on OSS communication. We found that (1) OSS prefers burst communication similar to face-to-face development, and (2) attracting developers’ attention may be a possible solution. Based on the findings, we discuss the direction of future studies to achieve better online communication in microtask programming in the company. The main contributions of this report are (1) to empirically reveal the actual communication times in OSS and (2) to show how an empirical approach helps industrial collaborators.

It is a higher priority for organizations to keep their source code secured. When a certain specific code includes a secret such as intellectual property, they need to pay special attention to prevent the secret code from leaking outside. On the other hand, sometimes code leaks comes from acts by inside programmers. This industrial paper proposes a MORDEn (Micro Organized Remote Development Environment) toward preventing code leaks. MORDEn enables programmers capable of coding and debugging by physically separating secret code from their client. We also introduce a showcase that demonstrates the feasibility of MORDEn from a case study project using it.

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.

The expansion of the development of software systems has been continuing in companies for years. That causes higher maintenance effort for the companies. To address the situation, exploring how reducing, reusing, and recycling software, which we call software 3R, is assumed to be the right direction. This paper proposes a new software visualization technique, Digital Software City (DigiSoC) by combining two approaches: process mining and program comprehension. By analyzing digital data (log and source code), it creates a 3D visualization of both software structure and behavior. For promoting software 3R, DigiSoC can help software architects to comprehend the actual, comprehensive status of the usage of the software in operation.

As companies run their business (e.g., sales, pro-curement), they conduct a set of business processes that include activities and flows connecting them. There exist an enormous number of patterns of business processes, or process-patterns. This industrial paper proposes a new technique, RP2A (Rare Process-Pattern Analysis), to examine process-patterns for finding operational problems such as compliance violations. The technique analyzes system execution data (= event log and user information) stored in the system related to the processes. By a combination of process-pattern search and activity search, RP2A discovers potential problem process-patterns in terms of execution frequency. We also report an industrial case study carried out using the technique. By analyzing the system execution data corrected from the 6-month system operation, we identified all 373 process-patterns, and 32 potential problem process-patterns out of them. Then, 4 domain experts in the industry verified the 32 process-patterns and found that 18 process-patterns, namely more than half of them (56% (=18/32)) contain actual problems. Almost problems are violations of internal policies which even the domain experts did not recognize. The technique succeeded in finding a kind of unknown problems in the business processes.

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.

Microtask programming [4] is a solution to promote distributed development in industry. The key idea of microtask programming is to reduce face-to-face communication across developers by splitting the development task of software into independent microtasks. Such microtasks can be completed by crowd workers who work remotely and at their preferable time such as early morning. Dedicated developers who have the responsibility for the progress of development split the task into microtasks, and distribute them to crowd workers. Hence, microtask programming has these two actors. Our research team reported that microtask programming has potential benefits such as the fluidity of project assignments in industrial companies [4]. However, we suppose it still has challenges. In addition, it is still unclear what are future research direction to support both actors in microtask programming, though our research team has conducted three studies for microtask programming so far [2--4].

Industrial software maintenance devotes much time and effort to find duplicate bug reports. In this paper, we propose an automated duplicate bug report detection system to improve software maintenance efficiency. Our system detects duplicate reports by vectorizing the contents of each report item by deep-learning-based sentence embedding and calculating the similarity of the whole report from those of the item vectors. The Sentence-BERT fine-tuned with report texts is used for sentence embedding. Finally, we verify that the combination of processing separately by item and Sentence-BERT fine-tuned with reports effectively detects duplicate bug reports in industrial experiments that compare the performance of existing methods.

This paper reflects on a decade-long journey into the industrial practices developed for requirements inspection in the Japanese software industry; it proposes an ELFIEP (Evolutionary Lifecycle Framework for Industrial Engineering Practice). We published two papers in RE’13 and RE’14. The first paper introduced the industrial practice of SRS (Software Requirements Specifications) inspection system of a software company. The system is a set of inspection items: inspection processes, techniques, and supporting tools. In the second paper, to encourage wider industrial adoption of requirements inspection systems, we proposed a methodology for designing requirements inspection systems. Called RISDM (Requirements Inspection System Design Methodology), it has been recognized by professional communities in Japan. A number of software companies have adopted the methodology, and are now operating their individual inspection systems. This paper provides a retrospect of the journey to RISDM. Learning from the journey, we propose ELFIEP as a generic framework for the evolution of engineering practice, and discuss insights gained from the journey and the framework.

Agile practices are widely introduced to projects these days. However, merely using processes/tools in the practices does not necessarily result in “achieving agility”, especially for those who have been using a waterfall model. They tend to think that the waterfall model is the only way. This mindset is the main obstacle to make the introduction of agile practices successful. To derive a true value in using them, understanding the underlying mindset in the agile practices is essential. This report introduces a novel workshop-based learning course to understand the agile mindset. The course participants create pipe cleaner arts for experiencing pseudo software development in two different models: waterfall and agile. A questionnaire result from total 201 participants shows that they perceived a clear difference between the two models. About 87% of them answered that the experience is useful for their future development works.

Sourcing the right IT engineers is critical for project success. In recent years, two sourcing strategies have been grabbing attention: crowdsourcing and inner-sourcing. Each has their own good points and bad points. Crowdsourcing allows organizations to recruit IT engineers from outside on demand. However, organizations working on closed-source code with confidential information might be worried about security concerns (e.g., information leak). The other strategy, inner-sourcing, can make any IT engineer in an organization become a member of all projects by adopting open source software development practices. This improves the mobility of IT engineers between projects inside the organization. However, there is a limit to the types of IT engineers that one organization can have. In this report, we propose a hybrid sourcing approach. It integrates the two sourcing strategies to develop software - crowdsourcing and inner-sourcing. This approach distributes the development tasks to either software crowdsourcing or inner-sourcing according to task type. As a case study, we adopt hybrid sourcing approach for an industrial project. The project developed a web application system for a bus company. We evaluate the effectiveness and future issues of hybrid sourcing.

A critical issue in software development projects in IT service companies is finding the right people at the right time. By enabling assignments of tasks to people to be more fluid, the use of crowdsourcing approaches within a company offers a potential solution to this challenge. Inside a company, as multiple system development projects are ongoing separately, developers with slack time on one project might use this time to contribute to other projects. In this paper, we report on a case study of the application of crowdsourcing within an industrial web application system development project in a large telecommunications company. Developers worked with system specifications which were organized into a set of microtasks, offering a set of short and self-contained descriptions. When crowd workers in other projects had slack time, they fetched and completed microtasks. Our results offer initial evidence for the potential value of microtask programming in increasing the fluidity of team assignments within a company. Crowd contributors to the project were able to onboard and contribute to a new project in less than 2 hours. After onboarding, the crowd workers were together able to successfully implement a small program which contained only a small number of defects. Interview and survey data gathered from project participants revealed that crowd workers reported that they perceived onboarding costs to be reduced and did not experience issues with the reduced face to face communication, but experienced challenges with motivation.

Many organizations now outsource the operation of specific business processes to external service providers, which is referred to as BPO (Business Process Outsourcing). At a transition phase in BPO, the providers need a comprehensive and in-depth understanding of the target (outsourced) business domain. There are many types of the business processes. Most of them are often undocumented. A common way to discover business processes is shadowing (i.e., observing system operators' work). If providers observe all types of business processes, it is costly and time-consuming. An important part of the transition phase is to identify and understand the key business processes being outsourced. This can be costly and time-consuming, especially if shadowing is used. This report introduces an industrial case study of transition phase in BPO. In the case, we analyzed 1,960 records stored in the system related to the business processes for one year period system operation. Each record corresponds to one activity execution by a system operator of the business processes. We transformed the records into 152 distinct types of business processes and found 19 activities in all types of the processes. By evaluating the execution frequency of each type, we selected top four types as key business processes which include 10 activities which cover 96.8 % (1,898/1,960) of all activity executions. The key business processes were very helpful in comprehending the main characteristic of the target business domain in the transition phase.

In agile software development projects, software engineers prioritize implementation over documentation to eliminate needless documentation. Is the cost of missing documentation greater than the cost of producing unnecessary or unused documentation? Even without these documents, software engineers maintain other software artifacts, such as tickets in an issue tracking system (ITS) or source code committed to a version control system (VCS). Do these artifacts contain the necessary knowledge? In this paper, we examine undocumented knowledge in an agile software development project at NTT. For our study, we collected 159 commit logs in a VCS and 102 tickets in the ITS from the three-month period of the project. We propose a ticket-commit network chart (TCC) that visually represents time-series commit activities along with filed issue tickets. We also implement a tool to generate the TCC using both commit log and ticket data. Our study revealed that in 16% of all commits, software engineers committed source code to the VCS without a corresponding issue ticket in the ITS. Had these commits been based on individual issue tickets, these "unissued" tickets would have accounted for 20% of all tickets. Software users and requirements engineers also evaluated the contents of these commits and found that 42% of the "unissued" tickets were required for software operation and 23% of those were required for requirements modification.

In this paper, we propose a Requirements Engineering Ontology (REO). We reviewed three well-known Bodies of Knowledge (BoKs) on requirements engineering: BABOK, SWEBOK, and REBOK. Based on the review, we compiled the REO as an organized set of knowledge of the requirements engineering. With the REO, we propose "knowledge spectrum analysis", a technique to analyze and visualize the distribution of knowledge in technical documents. As a practical application of the REO, we conduct two case studies on the knowledge spectrum analysis. First, we evaluate three BoKs (i.e., BABOK, SWEBOK, and BABOK) using the REO. Second, we utilize the REO to survey a set of technical documents for corporate-wide methodology for business modeling at NTT DATA. Based on the results of the case studies, we demonstrate the effectiveness of the REO.

The quality of the SRS (Software Requirements Specification) is the key to the success of software development. The inspection for the verification and validation of SRS are widely practiced, however, the techniques of inspection are rather ad hoc, and largely depend on the knowledge and skill of the people. This article proposes RISDM (Requirements Inspection Systems Design Methodology) to design the RIS (Requirements Inspection System) to be conducted by a thirdparty inspection team. The RISDM includes a meta-model and design process of RIS, PQM (Pragmatic Quality Model) of SRS, and a technique to generate inspection question set based on the PQM and PBR (Perspective-Based Reading). We have been applying the RIS designed by the proposed RISDM to more than 140 projects of a wide variety of software systems in NTT DATA for five years. By analyzing the statistics from the experience, we discovered some key quality characteristics of SRS reveal strong correlation to the project cost and level of quality to be used for evaluating the maturity of the SRS and predicting the risk.

We introduce a whole view of current status of requirements engineering based on REBOK (Requirements Engineering Body Of Knowledge) and its practical use with case studies.

We have been involved in a number of large-scale software development projects, which might lead to loss of millions of dollars if failed. The quality of SRS (Software Requirements Specification) is the key to success of the software development. Review and inspection are common practices for the verification and validation of SRS. However, verification techniques used in projects might be characterized as ad hoc. In this article, we propose requirements clinic, a third party inspection methodology for improving the quality of the SRS. In order to systematically inspect a SRS, we developed a perspective-based inspection methodology based on PQM (Pragmatic Quality Model) of SRS. PQM is derived from IEEE Std. 830 from the perspective of pragmatic quality. To inspect a SRS according to PQM, we identified 198 inspection points, which lead to a quality score between 0 and 100. The requirements clinic advises to the requirements engineering team by a comprehensive quality inspection report including quality score, benchmark and SRS patterns for improvement. Since 2010, we have been practicing the methodology to a variety of development projects, and revealed an average of 10.6 ROI in 12 projects. We also discuss the feasibility of the methodology and lessons learned from the practices.

The aim of our research is to empirically analyze the impact of requirements trace ability quality to the productivity of the enterprise applications development. We analyze trace ability links of Requirements Specification Documents (RSDs) collected from the enterprise applications development. These RSDs are classified into two groups in terms of project performance. One group includes RSDs of significant cost overrun projects, another group includes RSDs of normal range cost projects. Our analysis revealed that high quality of trace ability in RSDs significantly reduces the cost overrun in the enterprise applications development.

Requirements engineering has been extensively developed as a discipline. Many statistics on the software development indicate requirements process is the most influential to both success and failure of software development. However, practitioners are still difficult to learn and apply requirements engineering. As a guideline for practitioners to learn and apply requirements engineering, we developed REBOK (Requirements Engineering Body Of Knowledge). In the development, we found there is no common model of BOKs in software engineering. This article proposes the model and architecture of the body of knowledge of REBOK and its proof of the concept.

We initiate the discussions on the REBOK (Requirements Engineering Body of Knowledge) in requirements engineering community.