Akihiko Matsuo

Feature-gathering dependency-based software clustering using Dedication and Modularity

Software clustering is one of the important techniques to comprehend software systems. However, presented techniques to date require human interactions to refine clustering results. In this paper, we proposed a novel dependency-based software clustering algorithm, SArF. SArF has two characteristics. First, SArF eliminates the need of the omnipresent-module-removing step which requires human interactions. Second, the objective of SArF is to gather relevant software features or functionalities into a cluster. To achieve them, we defined the Dedication score to infer the importance of dependencies and utilized Modularity Maximization to cluster weighted directed graphs. Two case studies and extensive comparative evaluations using open source and industrial systems show that SArF could successfully decompose the systems fitting to the authoritative decompositions from a feature viewpoint without any tailored setups and that SArF was superior to existing dependency-based software clustering studies. Besides, the case studies show that there exist measurable authoritativeness limits and that SArF nearly reached the limits.

SArF map: Visualizing software architecture from feature and layer viewpoints

To facilitate understanding the architecture of a software system, we developed SArF Map technique that visualizes software architecture from feature and layer viewpoints using a city metaphor. SArF Map visualizes implicit software features using our previous study, SArF dependency-based software clustering algorithm. Since features are high-level abstraction units of software, a generated map can be directly used for high-level decision making such as reuse and also for communications between developers and non-developer stakeholders. In SArF Map, each feature is visualized as a city block, and classes in the feature are laid out as buildings reflecting their software layer. Relevance between features is represented as streets. Dependency links are visualized lucidly. Through open source and industrial case studies, we show that the architecture of the target systems can be easily overviewed and that the quality of their packaging designs can be quickly assessed.

ImpactScale: Quantifying change impact to predict faults in large software systems

In software maintenance, both product metrics and process metrics are required to predict faults effectively. However, process metrics cannot be always collected in practical situations. To enable accurate fault prediction without process metrics, we define a new metric, ImpactScale. ImpactScale is the quantified value of change impact, and the change propagation model for ImpactScale is characterized by probabilistic propagation and relation-sensitive propagation. To evaluate ImpactScale, we predicted faults in two large enterprise systems using the effort-aware models and Poisson regression. The results showed that adding ImpactScale to existing product metrics increased the number of detected faults at 10% effort (LOC) by over 50%. ImpactScale also improved the predicting model using existing product metrics and dependency network measures.

Flow Editor: Semantic Web Service Composition Tool

Semantic web service is proposed to support the automation of service discovery, composition and invocation. However, it is still difficult for common users to compose semantic web services or generate them from web services. In order to alleviate such pains, in this paper we present Flow Editor: a visual semantic web service composition tool based on OWL-S specification. It has several advantages, including visual service composition by drag-and-drop, semi-automatic semantic web service generation, visual control construct supports and so on. In practice, the tool is already applied to help users solve realistic problems by creating and exporting new on-demand services.

A maintenance support system based on high-level control-flow and data dependency

We propose a new method to support the maintenance of large scale business application systems, and discuss its implementation. Large scale business applications handle huge numbers of data items. To improve the maintenance of business application systems, our method proposes integrating the following features: (1) a high level control flow diagram which displays an unstructured program in a structured form; (2) a data dependency diagram which is essential in understanding business rules; and (3) ripple effect analysis functions to find the side effects of program modification. This paper also describes an execution path model and a repository which enable us to efficiently implement the above features. The system has been developed to reflect the discussions with software maintainers.

SaaS Application Framework Using Information Gateway Enabling Cloud Service with Data Confidentiality

Along with the rapid evolution of cloud computing, outsourcing service has also changed significantly. One of the main concerns for cloud computing is security. In particular, it becomes more important to handle client data securely in such a consulting service. In this paper, we present the design and implementation of Software as a Service (SaaS) application framework using Information Gateway that enables cloud service while maintaining data confidentiality. By setting up Information Gateway in the client environment, the executing location is dynamically controlled according to whether the data contains confidential information or not, and only secured data is routed to the SaaS application in the cloud. Therefore, if the data policy is registered by the client administrator beforehand, the user is able to use the cloud service appropriately without being aware of it. Moreover, we also describe that existing applications can be easily ported into the SaaS application because our framework allows application developers to define complicated routing logic briefly.

Web API Creation for Enterprise Mashup

It is desirable for web applications to be reusable, for example in case a vendor wants to deliver new valuable services by using and combining existing applications quickly. One of the well-known ways of reusing web applications, Mashup, has become popular in the web development community and applied to many open web sites, as we can just combine the data retrieved from Web pages or APIs of the web applications. But in the case of the Mashup of enterprise web applications, or Enterprise Mashup, it is quite difficult since these applications are often not intended to be reusable and have no Web APIs. That means we have to create the Web APIs for the applications, which takes much work. In this paper, we describe a light-weight Web API creation methodology in order to create Web APIs for enterprise web applications much more easily than we can by extending the source code. The created Web API can connect to the web application just as a client who has an account does. So we can create a Web API for Enterprise Mashup without modifying the application at all and we can call the Web API securely using the user account information of the application. We developed the implementation of our methodology and applied it to actual applications to evaluate its effectiveness.

Labeling Feature-Oriented Software Clusters for Software Visualization Application

Software clustering techniques have been used to analyze the reality of software structure. The visualization of the detected clusters has also been studied. However, the features implemented by the detected clusters are not obvious and understanding them is a crucial part of the industrial use of software clustering. In this study, we examined the existing information retrieval method and found three major issues it has. We developed technical solutions for each of them: using hierarchical labeling, weighing the words likely representing the feature by considering an architectural convention, and modifying the idf score by the scale of the cluster. The effectiveness of our approach is validated through case studies using actual software products including a COBOL business application. Also, we faced two additional practical problems: effectiveness of the method words and plural and conjugated forms of the words. We found the method name words were less useful than the class name words, and lemmatization was successfully used to normalize the form of the words even in the case of program identifiers.

An Ontology-Based Method for Rendering Execution Results of Dynamically Invoked Web Services

Web services technology is mainly designed for the interoperability among machines, whose inputs and outputs are defined in the form of XML schema without presentation information, hence it is unable to present the execution results of Web services to human beings directly and friendly. To address this problem, an ontology-based method and a rendering engine are proposed in this paper. In the method, domain ontology is utilized to annotate the types of inputs and outputs of a Web service. Templates are generated and stored according to each type described in the ontology. When rendering, the rendering engine first finds out the type of the execution results, and then retrieves corresponding templates with the URL of the type, finally recursively renders the execution results with the templates. In addition, a management interface is proposed for managing the templates.

Removing code clones from industrial systems using compiler directives

Refactoring of code clones is an effective method for improving software maintainability. Existing studies have proposed automated techniques and tools for refactoring. However, it is difficult to apply refactoring to our industrial systems in practice because of three main reasons. First, we have many industrial systems written in COBOL which requires a particular refactoring method compared with current techniques because Type-2 clones in COBOL are generated by renaming parts of identifiers. Second, nested clones must be refactored, in which an instance of a clone set is contained within an instance of another clone set. They also make it difficult to estimate the reduction size by refactoring. Third, refactoring requires testing which is time-consuming and laborious. To overcome these problems, we developed an approach for refactoring of Type-2 clones in COBOL programs. Our approach identifies actual refactorable clone sets and includes a string comparison technique to parameterize partial differences in identifier names. The clone sets are extracted as shared code fragments and transformed into the refactored code using compiler directives. It is easy to confirm that refactoring using compiler directives preserves program behavior, because they do not change program structure. We also provide a method that makes it possible to refactor nested clones by ordering their refactoring. This method enables to estimate how many lines can be reduced by refactoring. We applied the approach to four industrial systems to assess how many lines can be reduced. The results show that the lines could be reduced by 10 to 15% and one system was reduced by 27%. We also discuss the parameter number required for our refactoring approach.