Vulnerability and attack information must be collected to assess the severity of vulnerabilities and prioritize countermeasures against cyberattacks quickly and accurately. Common Vulnerabilities and Exposures is a dictionary that lists vulnerabilities and incidents, while Common Attack Pattern Enumeration and Classification is a dictionary of attack patterns. Direct identification of common attack pattern enumeration and classification from common vulnerabilities and exposures is difficult, as they are not always directly linked. Here, an approach to directly find common links between these dictionaries is proposed. Then, several patterns, which are combinations of similarity measures and popular algorithms such as term frequency–inverse document frequency, universal sentence encoder, and sentence BERT, are evaluated experimentally using the proposed approach. Specifically, two metrics, recall and mean reciprocal rank, are used to assess the traceability of the common attack pattern enumeration and classification identifiers associated with 61 identifiers for common vulnerabilities and exposures. The experiment confirms that the term frequency–inverse document frequency algorithm provides the best overall performance.

To guide practitioners and researchers to design and research Machine Learning (ML) system development processes, we conduct a preliminary literature review on ML system development practices. We identified seven papers and two other papers determined in an ad-hoc review. Our findings include emphasized phases in ML system developments, frequently described ML-specific practices, and tailored traditional practices.

There are many lectures for students or working adults. Educational institutions have created a table that associates educational courses with learning standards in order to understand the content of these courses. Learning standards such as SFIA (Skills Framework for an Information Age) indicate the skills that learners should learn. The mapped table can make contents clear for students or other educational institutions.

Participants’ feelings and impressions utilizing electroencephalography (EEG) and the effectiveness of code are compared for different types of programming sessions. EEG information is obtained as an alternate viewpoint during three programming sessions (solo, pair, and mob programming). MindWave Mobile 2 (brainwave detector) is equipped to collect the attention levels, meditation levels, and EEG brainwaves. These data are utilized to distinguish efficiencies, weaknesses, and points of interest by programming session. The results provide preliminary information to distinguish between the three sessions, but further studies are necessary to make firm conclusions. Additionally, alternative methods or systems are required to analyze the collected data.

Extreme programming (XP) approaches such as pair and mob programming (PP and MP, respectively) have been introduced to the educational sector. However, higher education curricula have started implementing online courses as a method for teaching programming, which poses challenges when conducting XP. Because social factors are vital to learning, we examine a project-based learning method using online MP that introduces a high level of communication. It also maintains the advantages of PP through the "driver" and "navigator" approach. However, there are multiple complications, including discomfort, slow code generation, and interpersonal issues, when using conventional MP. Accordingly, we introduce a mentoring approach to the MP setup and examine the differences compared to conventional MP sessions. We create and analyze co-occurrence networks of codes found via open coding. In this paper, we explain our method and show its advantages based on the results of our analysis.

The recent boom in social networking services has prompted the research of recommendation systems. The basic assumption behind these works was that "users’ preference is similar to or influenced by their friends". Although many studies have attempted to use social relations to enhance recommendation system, they neglected that the heterogeneous nature of online social networks and the variations in users' trust of friends according to different items. As a natural symmetry between the latent preference vector of the user and her friends, we propose a new social recommendation method called ScAN (short for “co-Attention Neural Network for Social Recommendation”). ScAN is based on a co-attention neural network, which learns the influence value between the user and her friends from the historical data of the interaction between the user/her friends and an item. When the user interacts with different items, different attention weights are assigned to the user and her friends respectively, and the user’s new latent preference feature is obtained through an aggregation strategy. To enhance the recommendation performance, a network embedding technique is utilized as a pre-training strategy to extract the users’ embedding and to incorporate the extracted factors into the neural network model. By conducting extensive experiments on three different real-world datasets, we demonstrate that our proposed method ScAN achieves a superior performance for all datasets compare with state-of-the-art baseline methods in social recommendation task.

In the IoT, gateways are used as relay points so that resources deployed in an environment can communicate with each other. As the number communication paths connected to one gateway increases, the number of paths interrupted by a gateway failure increases. In an environment where real-time communication is required, the loss of data due to a gateway failure is unacceptable. Therefore, a method to determine the routing topology with fewer paths that are interrupted by a gateway failure is needed. In this paper, we propose a method to generate a fault-tolerant routing topology by a genetic algorithm. Our experimental results show that the proposed method can generate a topology where communication routes are not concentrated on one gateway in a realistic time.

Testing database applications correctly and effectively remains an issue. This study improves Selected Pairwise Coverage Testing (SPCT), which is a pairwise coverage-based test method for database applications that can discover bugs not detected by conventional methods. Because SPCT considers only selected columns in the SQL query and the conditions in the simple WHERE clause, achieving full pairwise coverage has some redundancies. In this work, we propose a new pairwise coverage-based test method, Join-based Pairwise Coverage Testing (JPCT) by considering the condition in the JOIN clause to further reduce the redundant parameter combinations. The experimental results are evaluated to con?rm the effectiveness of the proposed method, JPCT compared to SPCT.

Many researchers have proposed program visualization tools for memory management because this is a challenging concept for novice programmers. For example, SeeC and PythonTutor (PT) are state-of-the-art tools for C languages. However, three problems hinder the use of these and other tools: capability (P1), installability (P2), and usability (P3). (P1) Tools do not fully support dynamic memory allocation or File Input / Output (I/O) and Standard Input. (P2) Novice programmers often have difficulty installing SeeC due to its dependence on Clang and setting up an offline environment that uses PT. (P3) Revisualization of the modified source code in SeeC requires several steps. To alleviate these issues, we propose a new visualization tool called PlayVisualizerC (PVC). PVC, which is designed for novice C language programmers to provide solutions (S1-3) for P1-3. S1 offers complete support for dynamic memory allocation, standard I/O, and file I/O. S2 involves installation in a user web browser and its server program is initiated by executing a jar file. S3 reduces the steps required for revisualization. To evaluate PVC, we conducted an experiment and questionnaire involving 30 students. Students using PVC solved a set of four programming tasks on average 1.7 times faster and with 19% more correct answers than those using a current state-of-the-art visualization tool.

Children can learn programming using different tools. Understanding how the characteristics and features of each tool impact the learning effect will enhance learning. However, the impact of specific tools on the learning effect is unclear. In this study, we conducted a workshop to evaluate the characteristics and features of six tools on the learning effect. Our study reveals that the learning effect clearly differs between the six tools.

Numerous studies and surveys have examined the utilization of Information and Communication Technologies (ICTs) in Higher Education (HE). However, the absence of studies that specifically investigate the utilization of ICTs in Quality Assurance and Accreditation (QAA) of HE led us to perform a Systematic Literature Review (SLR). This review mainly benefits QAA agencies and researchers interested in utilizing ICTs for QAA of HE. Several facts regarding ICTs contribute to QAA of HE are identified. 1) Compared to QAA agencies, Higher Education Institutions (HEIs) are more likely to implement ICTs. 2) Most of the ICTs in HEIs are for Quality Assurance (QA) and not Accreditation. 3) Most previous studies were conducted in Europe. These studies demonstrate that efforts have been made to align the QAA agencies and HEI QAA units with European Standards, resulting in ICTs utilization into European HEIs.

Software developments involving multiple organizations such as Open Source Software (OSS)-based projects tend to have numerous defects when one organization develops and another organization edits the program source code files. Developments with complex file creation, modification history (origin), and software architecture (functional layer) are increasing in OSS-based development. As an example, we focus on an Android smart phone and a VirtualBox development project, and propose new visualization techniques for product metrics based on file origin and functional layers. One is the Metrics Area Figure, which can express duplication of edits by multiple organizations intuitively using overlapping figures. The other is Origin City, which was inspired by Code City. It can represent the scale and other measurements, while simultaneously stacking functional layers as 3D buildings. The contributions of our paper are to propose new techniques, implement them as web applications, and share the results of our questionnaire. Our proposed techniques are useful not only to visualize the measured metrics, but also to improve the product quality.

In software and IT systems engineering, personal characteristics are expected to impact performance and attitude. To clarify the optimal composition in a team of students in academic education, we researched the relationship between student personality characteristics and learning effectiveness of teams using the Five Factor and Stress theory (FFS). The results taken from a Project-based Learning (PBL) course at Waseda University showed that educational effectiveness is highest when a team consists of management and anchor types without leadership types. In addition to FFS, we are currently adopting the Five Factor Model (FFM), which is a well-accepted personal characteristic model, to dig deeper the relationship in different courses on IT systems and software development conducted at various universities. Preliminary results show that although individual characteristics are not strongly correlated to learning effectiveness, there are a few strong team correlations. As our future work, we plan to acquire more data and investigate relationship between FFS measurements and FFM ones in terms of learning effectiveness.

Previous studies have researched how developer experience affects code quality, but they ignore work difficulty, although experienced developers are more likely to work on the more complex parts of a project. To examine work difficulty, we focus on revised files. Using product metrics, we evaluate file complexity in each type of file origin. Specifically, we analyze three large commercial projects (each project has about 250,000 LOC) executed by the same organization to analyze the relationship between previous project experience and developer's work. Although experienced developers do not always work on more complicated files, they introduce fewer defects, especially if the difference in work difficulty is not significant.

Although working in teams is an effective method for students to learn skills necessary for information systems, the optimal combination of team members to maximize the learning effectiveness has yet to be clarified. This study investigates the relationship between the combination of students' personality characteristics and learning effectiveness in three information system lecture courses. Two Five Factor Model (FFM) questionnaires were used to determine each student's personality characteristic. For each course, which has different styles, several different relationships are found. This study should assist educators in maximizing students' learning effectiveness in information systems courses involving teamwork.

Today's development environment has changed drastically; the development periods are shorter than ever and the number of team members has increased. Consequently, controlling the activities and predicting when a development will end are difficult tasks. To adapt to changes, we propose a generalized software reliability model (GSRM) based on a stochastic process to simulate developments, which include uncertainties and dynamics such as unpredictable changes in the requirements and the number of team members. We assess two actual datasets using our formulated equations, which are related to three types of development uncertainties by employing simple approximations in GSRM. The results show that developments can be evaluated quantitatively. Additionally, a comparison of GSRM with existing software reliability models confirms that the approximation by GSRM is more precise than those by existing models.

Self-adaptive systems alter their behavior in response to environmental changes to continually satisfy their requirements. Self-adaptive systems employ an environment model, which should be updated during runtime to maintain consistency with the real environment. Although some techniques have been proposed to learn environment model based on execution traces at the design time, these techniques are time consuming and consequently inappropriate for runtime learning. Herein, a technique using a stochastic gradient descent and the difference in the data acquired during the run-time is proposed as an efficient learning environment model. The computational time and accuracy of our technique are verified through a case study.

Although different programming environments have been developed to teach programming to beginners, the programming environment most suitable for introductory education is unknown in terms of the programming method such as text or visual. This study applies programming learning using a digital game, Minecraft, to compare the learning effect of textbased and visual-based programming in the LUA programming environment provided by a Minecraft extension. Both methods have certain learning effects, but visual-based programming has more significance than text-based programming on the attitude toward programming, indicating that visual-based programming is superior to text-based programming in introductory education.

Software stakeholders, including developers, managers, and end users, require high quality software products. Several works have aimed to identify software quality, but the quality of software products is often not comprehensively, specifically, or effectively defined because previous approaches have focused on certain quality aspects. Moreover, the evaluation results of quality metrics often depend on software stakeholders so that it is often hard to compare quality evaluation results across software products. ISO/IEC has tried to define evaluation methods for the quality of software products and provide common standards, called the SQuaRE (Systems and software Quality Requirements and Evaluation) series including ISO/IEC 25022:2016 and ISO/IEC 25023:2016. However, the SQuaRE series include ambiguous metrics so that it is not always easy to apply the series to products and compare results. In this paper, we propose a SQuaRE-based software quality evaluation framework, which successfully concretized many product metrics and quality in use metrics originally defined in the SQuaRE series1. Through a case study targeting a commercial software product, we confirmed that our framework is concretely applicable to the software package/service product.

<p>現在、小学生のプログラミング知識や能力を評価する指標として様々なものが存在するが、いずれも特定の対象に特化しており汎用性に乏しく、継続的に用いることが難しい。そこで我々は、 包括的かつ実効性を伴うルーブリック形式の評価基準を提案する。本基準の項目作成にあたって は我々が主催するワークショップにおけるアンケート結果および複数の既存の評価基準を取り 入れ、達成目標の設定はブルームの教育目標分類を参考にした。本基準は様々なプログラミング 教育機会において網羅的かつ一律的に生徒の学習効果を評価し学習計画を策定することに役立 つといえる。</p>

To improve practical IT education, many Japanese universities are implementing project-based learning (PBL). Although a previous study examined the relationship between educational effectiveness and the scatter of personal characteristics, the relationship between educational effectiveness and the combination of personal characteristics in a team, which is important to optimize the team composition for PBL, has yet to be examined. Herein, we use the five factor and stress theory to measure personal characteristics and classify students enrolled in a PBL class at Waseda University into four types-leadership, management, tugboat, and anchor. Then, knowledge and skills questionnaires are used to measure educational effectiveness. The results show that educational effectiveness is highest when a team consists of management and anchor types without leadership types. The results are preliminary, because the practical usefulness of our results is limited as the experiment of the paper targeted only one PBL course of one university. For that reason, we need to collect data from other PBL course at the same or other university.

Static-type systems are a major topic in programming language research and the software industry because they should reduce the development time and increase the code quality. Additionally, they are predicted to decrease the number of defects in a code due to early error detection. However, only a few empirical experiments exist on the potential benefits of static-type systems in programming activities. This paper describes an experiment that tests whether static-type systems help developers create solutions for certain programming tasks. The results indicate that although the existence of a static-type system has no positive impact when subjects code a program from scratch, it does allow more errors in program debugging to be fixed.

Test Driven Development as well as the documentation of tests and their architecture are today an important pillar of software quality assurance. The change of requirements during the implementation phase entails a need to change tests as well as the test documentation of the software. Since unit tests are specified in the implementation language, an interdisciplinary readable documentation must be maintained, which is structurally easier to comprehend and also make the test transparent for persons who are not involved into code writing. This leads to additional effort, costs and possibly inconsistencies between the test and its documentation. This gap in the workflow could be closed by Tanni - a domain specific language, which allows the specification of test cases in the form of interdisciplinary readable tables without requiring programming skills. Based on them executable test code for the respective unit test framework is generated. This merges specification and documentation of unit test cases to one step of work. By this the mentioned additional effort, costs and imminent inconsistencies can be reduced. The Language Workbench Meta Programming System from JetBrains serves as a technological base and is enabler for further positive effects which possibly could be gained by using the described language.

In software development, defects are inevitable. To improve reliability, software reliability growth models are useful to analyze projects. Selecting an expedient model can also help with defect predictions, but the model must be well fitted to all the original data. A particular software reliability growth model may not fit all the data well. To overcome this issue, herein we use multistage modeling to fit defect data. In the multistage model, an evaluation is used to divide the data into several parts. Each part is fitted with its own growth model, and the separate models are recombined. As a case study, projects provided by a Japanese enterprise are analyzed by both traditional software reliability growth models and the multistage model. The multistage model has a better performance for data with a poor fit using a traditional software reliability growth model.

Personas are fictional characters used to understand users' requirements. Many researchers have proposed persona development methods from quantitative data (data-driven personas development). However, it is not assumed that personas in these works are used continuously and these personas cannot reflect on unpredictable changes in users. It is difficult to plan reliable strategies in a web service because users' preference dynamically changes. To develop more suitable personas for decision-making in a web service, this paper proposes Iterative Data-Driven Development of Personas (ID3P). In particular, to detect an unpredictable change in users' characteristics, our proposal includes an iterative process where the personas are quantitatively evaluated and revised in each iteration. Moreover, it provides a quantitative evaluation of business strategies based on GQM+Strategies and personas. To verify our proposal, we applied it to Yahoo!JAPAN's web service called Netallica.

Monitoring the results of software reliability growth models (SRGMs) helps evaluate project's situations. SRGMs are used to measure the reliability of software by analyzing the relations between the number of detected bugs and the detected time to predict the number of remaining bugs within the software. For example, development managers apply a SRGM to the number of detected bugs and the detected time to predict the number of remaining bugs. Sometimes the SRGM results cause managers to make incorrect decisions because the results are temporary snapshots that change as a development progresses. We propose a method to help evaluate a project's qualities by monitoring the results of SRGM applications. We collected the number of detected bugs and the detected time in the test phases for cloud services provided by e-Seikatsu Co., Ltd. to real estate businesses. The datasets contain about 34 cloud service features. The evaluation found that our method provides correct answers for 29 features and incorrect answers for 5 features.

To achieve overall business goals, GQM+Strategies is one approach that aligns business goals at each level of an organization to strategies and assesses the achievement of goals. Strategies are based on rationales ( contexts and assumptions). Because extracting all rationales is an important process in the GQM+Strategies approach, we propose the Context-Assumption-Matrix ( CAM), which refines the GQM+Strategies model by extracting rationales based on analyzing the relationships between stakeholders, and the process of using GQM+Strategies with CAM effectively. To demonstrate the effectiveness of the CAM and the defined process, we conducted three experiments involving students majoring in information sciences at two different Japanese universities. Moreover, we applied the GQM+Strategies approach with CAM to the Recruit Sumai Company in Japan. The results reveal that compared to GQM+Strategies alone, GQM+Strategies with CAM can extract rationales of the same quality more efficiently and exhaustively.

Although both visual and text environments have been used to teach programming, the most appropriate method for beginners is unknown. Herein we research the most suitable programming environment to introduce programming to beginners using Minecraft to provide different programming learning environments (Visual or Text) via ComputerCraftEdu as an extended function. The learning effects between these two environments are compared using a lecture course. The results show that a visual environment is more suitable to introduce programming to beginners.

Security patterns are intended to support software developers as the patterns encapsulate security expert knowledge. However, these patterns may be inappropriately applied because most developers are not security experts, leading to threats and vulnerabilities. Here we propose a support method for security design patterns in the implementation phase of software development. Our method creates a test template from a security design pattern, consisting of an "aspect test template" to observe the internal processing and a "test case template". Providing design information creates a test from the test template with a tool. Because our test template is reusable, it can easily perform a test to validate a security design pattern. In an experiment involving four students majoring in information sciences, we confirm that our method can realize an effective test, verify pattern applications, and support pattern implementation.

To achieve the business objectives of an organization, the business goals and strategies must align. GQM+Strategies® is a method that aligns goals and strategies. By repeatedly defining lower-level goals and strategies, GQM+Strategies creates grids, which are specified from the initial set of goals and strategies, to link goals and strategies across different level units. Although the above approach can maintain consistency within a vertical refinement tree, horizontal relations at different branches may be missed. Herein we propose the Horizontal Relation Identification Method (HoRIM) to identify horizontal relations. HoRIM is an approach that detects the difference between the initial GQM+Strategies grid and a model obtained by applying Interpretive Structural Modeling (ISM) to the grid. ISM provides a hierarchical structure from the relation matrix that presents the relations between elements. An experiment confirms that HoRIM identifies about 1.5 times more horizontal relations than an ad hoc review. Additionally, an industrial application demonstrates the practical value of HoRIM.

Agile development is aimed at minimising overall risk and encouraging rapid and flexible response to specification changes by using an iterative process. Despite its iterative feature, studies on the effects of iteration length have been lacking. Currently, there is no established method to quantitatively determine the appropriate iteration length, and abortion of projects with an inappropriate iteration length has been reported. We therefore create a model of agile development that focuses on iteration length, and propose a method of simulating a particular project to estimate the appropriate iteration length. Furthermore, we simulate diverse situations using various parameters to understand the relationship between the iteration length and project constraints. Our results show that the appropriate iteration length depends on the condition of the project constraints
the larger the amount of uncertainty, the shorter the appropriate iteration length, while the higher the complexity of the project, the longer the iteration length should be.

To improve practical IT education, many universities are implementing project-based learning (PBL). Although researchers have examined the relationship between projects and personality, they have not investigated the type of projects and team construction based on personality. We consider not to construct optimal team for the view of educational effectiveness if we do not understand the difference of each course characteristic. Herein the Five Factor & Stress theory is used to measure personal characteristics and classify students enrolled in two different PBL courses at a university into four types - leadership, management, tugboat, and anchor. Then knowledge and skills questionnaires are used to measure educational effectiveness. The results show that educational effectiveness is highest when a team consists of management and anchor types but not leadership types in the PBL course which teaches system development, and a team without management types is consisted in the PBL course which teaches IT management strategy.

When developers operate a service, both the business objectives and users' requirements must be satisfied. However, the interest between a business strategy and an action for the users is often unclear. Moreover, users' requirements that are inferred from user data analysis may not correspond with users' real requirements. In this paper, we propose the GO-MUC method (Goal-oriented Measurement for Usability and Conflict) and apply it to Yahoo! Crowdsourcing. The GO-MUC method can develop a strategy considering requirements of both the user and the business. Our results validate this method; this method can find an interest between the business side and users side and plan more effective and user-friendly strategies to resolve a conflicting interest.

Students working in teams to complete software tasks is an effective method to learn necessary skills. Previously we examined the educational effectiveness as a function of personal characteristics, but the findings were inconclusive. Because we hypothesize that team discussions impact learning and are related to educational effectiveness, this study investigates the influence of team discussions on learning effectiveness in various types of software engineering education courses. Students' responses to questionnaires about how much students contribute to discussions indicate that learning effectiveness and the number of remarks during a discussion are related. Additionally, upon comparing two learning courses (a system development course and a IT management course), two antithetical results are elucidated. We expect that this research will help improve the effectiveness of educators leading student team discussions.

Because program behaviors of database applications depend on the data used, code coverages do not effectively test database applications. Additionally, test coverages for database applications that focus on predicates in Structured Query Language (SQL) queries are not useful if the necessary predicates are omitted. In this paper, we present two new database applications using Plain Pairwise Coverage (PPC) and Selected Pairwise Coverage (SPC) for SQL queries called Plain Pairwise Coverage Testing (PPCT) and Selected Pairwise Coverage Testing (SPCT), respectively. These coverages are based on pairwise testing coverage, which employs selected elements in the SQL SELECT query as parameters. We also implement a coverage calculation tool and conduct case studies on two open source software systems. PPCT and SPCT can detect many faults, which are not detected by existing test methods based on predicates in the query. Furthermore, the case study suggests that SPCT can detect faults more efficiently than PPCT and the costs of SPCT can be further reduced by ignoring records filtered out by the conditions of the query.

We propose a metamodel for handling security and privacy in cloud service development and operation. The metamodel is expected to be utilized for building a knowledge base to accumulate, classify and reuse existing cloud security and privacy patterns and practices in a consistent and uniform way. Moreover the metamodel and knowledge base are expected to be utilized for designing and maintaining architectures for cloud service systems incorporating security and privacy.

Quality measured and evaluated based on organization-specific quality models cannot be compared to the quality of other software products. To alleviate this problem, ISO/IEC defined international standards called the SQuaRE (Systems and software Quality Requirements and Evaluation) series for comprehensive quality measurement and evaluation; however, these standards include ambiguous measurements, making them difficult to apply. Herein an initial comprehensive quality measurement framework, which includes a clear measurement plan based on ISO/IEC 25022 and 25023, is proposed. A case study confirms the usefulness of the framework. As future work, we will introduce the framework to various domains. And then, we revise and refine measurements and evaluation plans to improve feasibility and usefulness.

We propose a method to compare software products developed by the same company in the same domain. Our method, which measures the time series of the number of detected faults, employs software reliability growth models (SRGMs). SRGMs describe the relations between faults and the time necessary to detect them. Herein we propose a method to compare SRGMs across products. To provide managers and developers insight on advances of its products, our method is applied to the datasets for nine projects developed by Sumitomo Electric Industries, Ltd.

We propose a method to compare software products developed by the same company in the same domain. Our method, which measures the time series of the number of detected faults, employs software reliability growth models (SRGMs). SRGMs describe the relations between faults and the time necessary to detect them. Although several researchers have studied cross project defect predictions to determine defect locations using the features of previous software product's code such as lines of codes and complexities, past works on SRGMs did not compare products or develop comparison methods. Herein we propose a method to compare SRGMs across products. To provide managers and developers insight on advances of its products, our method is applied to the datasets for nine projects developed by Sumitomo Electric Industries, Ltd. SRGMs based on person hours are between 13% and 97% more precise than those based on calendar time.

Software developments involving multiple organizations such as OSS (Open Source Software)-based projects tend to have numerous defects when one organization develops and another organization edits the program source code files. Developments with complex file creation, modification history (origin), and software architecture (functional layer) are increasing in OSS-based development. As an example, here we focus on an Android smart phone development project and propose new visualization techniques for product metrics based on the file origin and functional layers. One is the Metrics Area Figure, which can express duplication of edits by multiple organizations intuitively using overlapping figures. The other is Origin City, which was inspired by Code City. It can represent the scale and other measurements, while simultaneously stacking functional layers as 3D buildings.

We propose a method to compare software products developed by the same company in the same domain. Our method, which measures the time series of the number of detected faults, employs software reliability growth models (SRGMs). SRGMs describe the relations between faults and the time necessary to detect them. Herein our method is extended to classify past projects for comparison to current projects to help managers and developers decide when to end the test phases or release a project. Past projects are classified by three parameters: lines of code, number of test cases, and test density. Then SRGM is applied. Our extended method is applied to the datasets for nine projects developed by Sumitomo Electric Industries, Ltd. Classification by test density produces the best results.

Manual code inspections are intense and time-consuming activities to improve the maintainability and reusability of source code. Although automatic detection of high-risk source code file by metrics thresholds can help inspectors, determining the optimal thresholds is difficult Thus, we propose an iterative process to defin and improve GQM models with metrics thresholds to detect high-risk files Our process clarifie experts' viewpoints in the inspection and the measurement metrics using the GQM method, define how to interpret the metrics values, searches concrete thresholds for a specifi project by supervised learning using some of the file in the project as training data, and analyzes how to improve models and thresholds. We implemented our tool in R language and evaluated our process using a industrial project. Small-sized embedded C++ systems require only a few training data.

The studies of Repository Mining have been actively conducted. However, it is difficult to search projects with specified languages, development scale, purposes and so on. In this paper, we propose RepositoryProbe, a dataset creation support tool fot the study of repository mining. It makes easier to search and collect the projects in project hosting service on the web, and supports the creation of datasets. In addition, it can collect the social metrics, the amount of development activities.

Existing techniques for crawling Javascript-heavy Rich Internet Applications tend to ignore user interactions beyond mouse clicking, and therefore often fail to consider potential mouse, keyboard and touch interactions. We propose a new technique for automatically finding and exercising such interactions by analyzing and exercising event handlers registered in the DOM. A basic form of gesture emulation is employed to find states accessible via swiping and tapping. Testing the tool against 6 well-known gesture libraries and 5 actual RIAs, we find that the technique discovers many states and transitions resulting from such interactions, and could be useful for cases such as automatic test generation and error discovery, especially for mobile web applications.

Traceability links between requirements and source code are helpful in software reuse and maintenance tasks. However, manually recovering links in a large group of products requires significant costs and some links may be overlooked. Here, we propose a semi-automatic method to recover traceability links between requirements and source code in the same series of large software products. In order to support differences in representation between requirements and source code, we recover links by using the configuration management log as an intermediary. We refine the links by classifying requirements and code elements in terms of whether they are common to multiple products or specific to one. As a result of applying our method to real products that have 60KLOC, we have recovered valid traceability links within a reasonable amount of time. Automatic parts have taken 13 minutes 36 seconds, and non-automatic parts have taken about 3 hours, with a recall of 76.2% and a precision of 94.1%. Moreover, we recovered some links that were unknown to engineers. By recovering traceability links, software reusability and maintainability will be improved.

To meet future demands for wireless sensor network (WSN) software, both experts and average software developers should be involved in WSN software development. However, WSN software development is difficult for the average software developer because data processing-related design and network-related design are tangled in the software. Here, we propose a software development process for WSN software by stepwise refinement. Our process enables stepwise refinement to separately address data processing-related and network-related concerns, reuse of well-defined designs, and implementations for network-related concerns prepared by the experts, and perform model-driven development to obtain source codes from models by model transformations. Additionally, we used case studies using actual WSN software development and user studies to evaluate how our proposed process can support actual WSN software development.

学生奨励賞

Webアプリケーションは大規模化にともないテストコードの作成コストが増大しているうえ，保守コストが膨大であるという問題がある．特に，Webアプリケーションは他のアプリケーションよりも仕様変更の頻度が高く，また，アサーションの記述に関して構造化する手法が存在していないため，可読性および変更容易性の低下により，保守コストが増大しがちである．本稿では，Webアプリケーションの頻繁な仕様変更に対応可能なページオブジェクトデザインパターンを利用した保守性の高い内部DSLおよび，内部DSLに基づくテストコードを自動生成するテスティングフレームワークDePoTを提案する．DePoTはテストコードの自動生成によりテストコードの作成コストを削減して，また，ページオブジェクトデザインパターンと内部DSLにより保守コストを削減する．我々は被験者実験によって人手でテストコードを記述する従来手法との比較を通して，DePoTの有用性を確認した．The sizes of web applications are increasing, thus, development costs to write test code for web applications are also increasing. Moreover, specification changes of web applications are frequently occured and there are no method to modularize assertions of test code. Such situation poses high maintenance costs by decreasing understandability and changeability. We propose a novel testing framework for web applications, named DePoT, which provides an internal DSL on the basis of the Page Object design pattern. DePoT reduces the development costs of test code by generating a skeleton test code using the internal DSL and reduces the maintenance costs of test code by using the Page Object design pattern and the internal DSL. We evaluate DePoT by comparing traditional testing methods.

Computational Thinking skills are basic and important to manipulate computers. Currently, several systems exist to provide an effective way to learn programming that use computers, smartphones, tablets, or programmable robots. Although studies have reported improved programming skills and motivation to learn programming using an on-screen application or a programmable robot, the benefits of these tools have not been directly compared. To resolve this issue, especially with regard to motivation to learn programming and impression of programming, we conducted a large scale comparative experiment involving 236 middle and high school students to evaluate the effects of a game based educational application and programmable robots on learning programming. We then compared the effects of a game based educational application with and without programmable robots on learning programming. We found that employing programmable robots on learning programming did not always give an improvement to all students.

Although security patterns contain security expert knowledge to support software developers, these patterns may be inappropriately applied because most developers are not security specialists, leading to threats and vulnerabilities. Here we propose a validation method for security design patterns in the implementation phase of software development. Our method creates a test template from a security design pattern, which consists of the "aspect test template" to observe the internal processing and the "test case template". Providing design information creates a test from the test template. Because a test template is recyclable, it can create easily a test, which can validate the security design patterns. As a case study, we applied our method to a web system. The result shows that our method can test repetition in the early stage of implementation, verify pattern applications, and assess whether vulnerabilities are resolved.

ソフトウェアの成果物，および開発プロセスの情報などを対象に分析を行うリポジトリマイニングの研究が盛んに行われている．しかし，数多くの公開されているプロジェクトから，分析の対象とする規模，言語，用途などを満たすプロジェクトを探すことは困難な作業である．そこで我々は，リポジトリマイニングのためのデータセット作成支援ツール，RepositoryProbeを提案する．本ツールではGitHub上で特定の条件を指定して検索を行うことで，目的のプロジェクト群を容易に見つけ出すことを可能にする．また，GitHub上での開発者の活動量のデータや，外部ツールで取得したソフトウェアメトリクスなどのデータを組み合わせて出力することで，データセットの構築を支援する．

In the requirements definition phase, conceptual models are used to understand the developing software. Although scenarios are often described on the basis of conceptual models, there are cases that necessary requirements are omitted in the scenarios when the scenarios are created manually. Herein we propose an approach to support scenario creation from conceptual models where event lists of scenarios, which include checkpoints to define requirements, are generated from conceptual models automatically. The conceptual models represent the core resources of the software, the owner of the core resources, and use cases as class diagrams. Then software engineers and their clients arrange the event lists and define requirements as scenarios on the basis of the checkpoints. Our approach can support describing scenarios with all the necessary requirements from conceptual models. To confirm the effectiveness of our approach, we compared our approach to the all-manual approach.

Test case prioritization is a technique to improve software testing. Although a lot of work has investigated test case prioritization, they focus on white box testing or regression testing. However, software testing is often outsourced to a software testing company, in which testers are rarely able to access to source code due to a contract. Herein a framework is proposed to prioritize test cases for black box testing on a new product using the test execution history collected from a similar prior product and the Ant Colony Optimization. A simulation using two actual products shows the effectiveness and practicality of our proposed framework.

Because software developers are not necessarily security experts, identifying potential threats and vulnerabilities in the early stage of the development process (e.g., the requirement-or design-phase) is insufficient. Even if these issues are addressed at an early stage, it does not guarantee that the final software product actually satisfies security requirements. To realize secure designs, we propose extended security patterns, which include requirement-and design-level patterns as well as a new model testing process. Our approach is implemented in a tool called TESEM (Test Driven Secure Modeling Tool), which supports pattern applications by creating a script to execute model testing automatically. During an early development stage, the developer specifies threats and vulnerabilities in the target system, and then TESEM verifies whether the security patterns are properly applied and assesses whether these vulnerabilities are resolved.

Traceability links between requirements and source code can assist in software maintenance tasks. There are some automatic traceability recovery methods. Most of them are similarity-based methods recovering links by comparing representation similarity between requirements and code. They cannot work well if there are some links independent of the representation similarity. Herein to cover weakness of them and improve the accuracy of recovery, we propose a method that extends the similarity-based method using two techniques: a log-based traceability recovery method using the configuration management log and a link recommendation from user feedback. These techniques are independent of the representation similarity between requirements and code. As a result of applying our method to a large enterprise system, we successfully improved both recall and precision by more than a 20 percent point in comparison with singly applying the similarity-based method (recall: 60.2% to 80.4%, precision: 41.1% to 64.8%).

Because developers significantly impact software development projects, many researchers have studied developers as a means to improve the quality of software. However, most works have examined developers in a single project, and research involving multiple projects has yet to be published. Herein we propose an analysis method which investigates whether an evaluation of developers based on individual experience is feasible when targeting more than one project by the same organization transversely. Our method deals with the logs of the version control system and the bug tracking system. To support this method, we also propose two models to evaluate developer, the defect removal overhead rate (DROR) and developer's experience point (EXP). The results reveal the following. 1) DROR cannot be used to compare different projects in the same organization. 2) There is certainly a difference in DROR's between experienced and inexperienced developers. 3) EXP should be a useful model to evaluate developers as the number of projects increases. The data obtained from our method should propose the personnel distribution measures within the development framework for future developments, which might lead to improve the quality of software.

There is a significant challenge that how to predict the possible release date of the target software having enough reliability in agile development where incremental development and small software releases are key characteristics. Existing approaches targeting agile development usually use release backlogs for predicting and setting delivery windows; however these do not consider the reliability of software for release date prediction so that there is a possibility that software at the predicted release date have poor reliability. Previously we proposed a generalized software reliability model (GSRM) based on a stochastic process and compared it with other models to evaluate recent software developments. However, we, did not directly evaluate the accuracy of the predicted release time by model. In this paper, towards prediction of release dates in agile development, we focus on the release dates of open source software (OSS) developments and the number of detected issues (faults) since OSS developments comply well with the definition of the agile development in terms of incremental process and frequent releases We define the accuracy of the predicted release time using the given development terms and the number of issues. Additionally, we propose a method to evaluate the accuracy of the predicted release time. In the best case, GSRM shows only 0.572% Error Rate, which corresponds to a predicted release date of two days prior to the actual release date. We believe that our method should be applicable to agile developments too.

Due to the prevalence of tablets, the usability of the User Interfaces (UIs) must be improved, but the number of support methods for usability evaluations for tablets is small. Herein we propose a method to automatically evaluate usability based on operation histories, including action frequency and operation times, and statistical analysis. Because our approach easily detects UI design problems, the burdens on developers and costs can be reduced. Using a small-scale case study and test with about 20 participants, we show that our approach can detect detailed problems with usability via a mostly automated process.

Although many methods have been suggested to automatically recover traceability links in software development, they do not cover all link combinations (e.g., links between the source code and test cases) because specific documents or artifact features (e.g., log documents and structures of source code) are used. In this paper, we propose a method called the Connecting Links Method (CLM) to recover transitive traceability links between two artifacts using a third artifact. Because CLM uses a different artifact as a document, it can be applied to kinds of various data. Basically, CLM recovers traceability links using the Vector Space Model (VSM) in Information Retrieval (IR) methods. For example, by connecting links between A and B and between B and C, CLM retrieves the link between A and C transitively. In this way, CLM can recover transitive traceability links when a suggested method cannot. Here we demonstrate that CLM can effectively recover links that VSM is hard using Open Source Software.

In software development, software reliability growth models (SRGMs) often provide values that do not meet expectations; sometimes the results of the SRGM and the actual data disagree and other times the SRGM overestimates the expected values. The former often occurs in model curves and the predicted number of faults. For example, the software reliability growth curve cannot describe the situation where developers stop testing multiple times because the equations in SRGMs cannot treat such information. The latter can arise when the total number of expected faults is 100, but the SRGM indicates 1000. If developers encounter such situations, they often doubt the SRGM results and hesitate using SRGMs for predictions. In this study, we apply two different cases of SRGM. Two projects of Fujitsu Labs Ltd. are analyzed using SRGM either for the entire dataset or each test phase. Based on the results and interviews with the developers, we found that the model using separate test phases provides a better fit because faults counted in each test phase have different viewpoints and the deviation between SRGM and expectations indicates a problem with development.

Learning to programming language is difficult. One solution is to use a digital game, which increases motivation of first-time learners. In this paper, we were executing programming learning with MincraftEdu of sandbox game and ComputerCraftEdu of expansion function. In addition, learning method to programming has illustration-based programming and text-based programming in ComputerCraftEdu. We compare the programming way of illustration programming and text programming. In this result, there was a significant difference towards the illustration-based programming throughout the comparison. In this paper, we present the results.

Software extension is a fundamental challenge in software engineering which involves extending the functionalities of a software module without modifying it. Many modern software developers choose to adapt third-party extension platform to further improve customizability. As the project evolves, the requirements may change to include third-party extension support. However to design and to implement such platform is no trivial task, and should happen at the beginning of the project. In this paper, we have shown the four types of extensions that are often made to object-oriented software, namely Member Access Extension, Subclass Extension, Event-based Extension and Data Extension. And proposed a language-independent platform design that can be applied to an existing software project to support such third-party extensions. The platform exercises design patterns to implement its features. We also developed an Eclipse plugin that helps developers introduce the platform to existing Java software via semi-automatic code manipulation. We further conducted a comparative experiment to test our tool with volunteers from Waseda University and noticed a significant decrease of required effort.

再利用性の高い資産を蓄積するためには，保守性・再利用性の低いソースコードファイル （Unacceptable Files:FS） とそうでないファイル （Acceptable Files:Fs） を見分け，早い段階で UFs を発見し修正する必要がある．人手レビューには時間がかかるため，自動で UFs を検出するための研究がこれまでされてきた．しかし，言語や開発形態の違いなどからソフトウェアプロジェクト毎にメトリクス傾向は異なることが多い．そのため，GQM 法などを用いてあるプロジェクトに対して自動評価式を作成しても，他のプロジェクトに対しては適切でない評価をしてしまう場合がある．そこで，我々は GQM モデルを共通のドメインで再利用しつつ，メトリクスの値を解釈する評価式のパラメタ （閾値） 変更によってプロジェクトに合わせた自動評価をする仕組みを考えた．そして，可変部分である閾値を経験的に決めるのでなく，実際の人手レビュー結果に基づいて決めるための枠組みを考案した．本稿では建機メーカーの実プロダクト （C++） を用いて，提案する枠組みの有効性を実験的に確認した．その結果，評価する項目によってはファイルの自動評価を人手レビューに十分近似させることが可能とわかった （カッパ係数 0.7 以上の一致度）．

To realize usability in software, GUI (Graphical User Interface) layouts must be consistent because consistency allows end users to operate software based on previous experiences. Often consistency can be achieved by user interface guidelines, which realize consistency in a software package as well as between various software packages within a platform. Because end users have different experiences and perceptions, GUIs based on guidelines are not always usable for end users. Thus, it is necessary to realize consistency without guidelines. Herein we propose a method to realize consistent GUIs where existing software packages are surveyed and common patterns for window layouts, which we call layout rules, are specified. Our method uses these layout rules to arrange the windows of GUIs. Concretely, source programs of developed GUIs are analyzed to identify the layout rules, and then these rules are used to extract parameters to generate source programs of undeveloped GUIs. To evaluate our method, we applied it to existing GUIs in software packages to extract the layout rules from several windows and to generate other windows. The evaluation confirms that our method easily realizes layout consistency.

プログラムの欠陥を検出する静的解析ツールは,ソフトウェアに作りこまれた欠陥の早期発見に役立つことが知られている.一方,欠陥の誤検出や些細な欠陥の報告が多すぎるといった問題点があり,その有用性にもかかわらず静的解析ツールの普及は進んでいない.上述の問題点を解決するため,より正確な静的解析を実現するための研究が広く進められている.しかし,これらの研究は,検出数の多さから欠陥が無視されがちになる問題を直接的に解決するための研究ではない.本論文では,静的解析ツールを利用する開発者の欠陥修正に対するモチベーションを向上させ,報告された欠陥がより多く修正されるような仕組みを提案する.静的解析によって報告される欠陥をより多く修正させるように動機づけることで,開発者が報告される欠陥を無視しがちになる問題を緩和し,ソフトウェアの品質向上を図る.提案する仕組みの有用性を確認するため,提案する仕組みを導入したツールを開発し,被験者実験を行った結果,ツールを利用することによっておよそ1.5倍ほど多くの欠陥が修正されることを確認した.

無線センサネットワークアプリケーションの機能要求を達成するための主な手段は実世界のデータ取得であるため,開発においてデータに関する品質を改善することが重要となる.開発時には,低コストでプロトタイプを開発し早期に品質改善のための課題を発見すること,細やかな品質改善により要求を満たすことが求められる.しかし,既存の開発方法では単一の抽象度の言語を一貫して用いるため,記述能力と記述の容易さとの間にトレードオフによってこれらの要件を同時に満たせない.本論文では,抽象度の異なる複数のモデリング言語を併用することでデータ品質改善を支援する開発プロセスを提案する.本開発プロセスでは,設計対象ごとに適した抽象度を用いるようモデリング言語を定義し,これらの使い分けをプロセスとして提案する.また,上位モデルの設計を下位モデルへ反映させつつ実装へと近づける際の設計の伝播は,自動モデル変換規則を定義することで実現した.本開発プロセスが前述の要件を満たしつつ開発可能であることを,運用実績のあるWSNアプリケーションでのケーススタディを用い示した.

特定の品質要求を満足するためのプログラムコードはしばしば、プログラムの基本的なモジュール構成に対して横断的に散らばることが知られている。そのような横断的関心事のモジュール化を通じて保守性を維持あるいは高めることに有効な技術として、アスペクト指向プログラミング(Aspect-Oriented Programming:AOP)がある。本稿では、AOPの実行性能や品質向上に関する応用として、マルチコア環境における単体テスト実行時間の短縮を目的とした単体テストフレームワークJUnitのAspectJ(Java言語用のAOP処理系)によるマルチスレッド化と、ロボット制御プログラムの低消費電力化を目的としたハードウェア制御方式やアルゴリズムのAspectC(C言語用のAOP処理系)による追加および変更の事例をそれぞれ報告する。

In the requirements elicitation phase, operation flows of software are often defined by scenarios. It is necessary to define appropriate operation flows as scenarios in terms of easily comprehended operation flows, efficiency, etc. Then scenarios are implemented as software Graphical User Interfaces (GUIs). If the operation flows are defined inappropriately, the implemented GUIs may require modifications in the late software development phase. Although defining appropriate operation flows is difficult in the requirements elicitation phase, operation flows of GUIs cannot be always modified in the late software development phase. Thus, it is necessary for end users to evaluate the appropriateness of operation flows in scenarios. Herein we propose a method to generate GUI prototypes from scenarios. By parsing the events in the target scenarios, which are written in a natural language, GUI prototypes are automatically generated. Using the generated GUI prototypes, the appropriateness of operation flows can be evaluated by end users. If problems arise, the GUI prototypes can be modified in the early requirements elicitation phase.

Design models are often developed using UML class diagrams. Based on past questionnaire surveys reported by Lange and Nugroho, we assumed that the existence of highly responsible classes indicate that a class diagram was created through the proper consideration of the structure of the system. Thus, we analyzed the structure of UML design class diagrams. Specifically, we measured our novel metrics (the amount of highly responsible classes in class diagrams), and investigate the correlations between our metrics and the structural validity of design. In this study, we propose two viewpoints to distinguish large values which indicate high responsibility. Additionally, we conducted the evaluation experiment using 65 design class diagrams, which were originally submitted to a Robot Contest on the domain of embedded systems and evaluated by software development experts based on structural validity. Then the correlations between our novel metrics and the experts' qualitative assessment were analyzed.

In order to improve the training of IT professionals, practical courses in the form of project-based learning (PBL), which teach practical skills for systems acquisition and provisioning and for project management, are being implemented in various universities. For example, a course has been offered at Waseda University since 2011 in cooperation with the Japanese governmental bodies and IT companies. This course consists of three lectures per day for five days (each lecture has 90 minutes) and the number of students attending this course is 26 in 2011, 17 in 2012 and 39 in 2013. In this course, students mainly learn the management of software intensive systems development projects from the viewpoint of the provider such as requirements analysis and architectural design.
There is a study investigating the relationships between the variation in the personality profile of paired students and their academic performance in Pair Programming [1]. However, in practical courses on software intensive business systems, we do not yet have an established method for determining what kind of personal characteristics and team compositions are most beneficial to obtaining the maximal educational effectiveness.
In this study, we use the Five Factors and Stress (FFS) theory [2] to quantify the personal characteristics and we ask students to answer same questionnaire before and after the course to measure how improved their knowledge and skills. This questionnaire consists of about 40 questions and each student answers them in six degrees. As example of the questions, there is "Can you analyze requirements?". In many cases, the business of acquiring and providing software intensive systems is carried out as a team-based activity. Therefore, to teach actual business concepts, we randomly compose teams regardless of personal characteristics. The number of teams formed was 6, 4 and 8 for 2011, 2012 and 2013, respectively. This is an additional study of our paper [3] and as significant differences, we add the data of the course of 2013 in Waseda University and we analyze the data through 3 years (2011 - 2013).
We investigate the relationships between personal characteristics and educational effectiveness to reveal the common tendency. Through t-test and boxplot, we clearly see that variations in the team members' personal characteristics have an effect on educational effectiveness. Large variation team acquires approximately 1.5 times higher educational effectiveness than small one. From this result, it is better for a team to have members with different characteristics in FFS theory for acquiring more knowledge and skills through course. We expect that in similar practical courses, we can also obtain the desirable educational effectiveness if we can compose a team with the suitable characteristics as based on our findings.

In practical courses on software-intensive business systems, students work in teams to acquire practical skills in systems acquisition and provisioning. However, we do not yet have an established method to determine the optimal team composition to achieve maximum educational effectiveness. In this study, we quantitatively and qualitatively investigate how personal characteristics and the learning process of team members affect educational effectiveness by examining a university course in which students work in teams on a realistic project in a classroom setting. We use the Five Factors and Stress (FFS) theory and the modified grounded theory approach (M-GTA) to measure the personal characteristics and to identify the learning process of each team member. Additionally, we compare the learning process of a team with a high educational effectiveness to one with a low educational effectiveness based on number of topics about the learning process and the kind of topics. As a result, we find that it is better for a team to have members with different personal characteristic as defined by FFS theory in order for the students to acquire more knowledge and skills through the course. Additionally, teams that focus on fewer learning process topics acquire more knowledge and skills. We expect that our findings will help increase the educational effectiveness in similar practical courses.

GQM+Strategies is an approach that aligns business goals at each level of an organization to strategies to realize overall business goals and assesses the achievement of such goals. Strategies are extracted from business goals based on rationales (contexts and assumptions). Using the proposed approach, which refines the GQM+Strategies model by extracting rationales based on the analysis of the relationships between stakeholders, it is possible to extract rationales exhaustively and to reconsider the GQM+Strategies model even if the business environment changes. © Springer-Verlag Berlin Heidelberg 2014.

Organizational patterns are known as the basis for Agile software development movement. Patterns usually form a network having relationships among them to support users understand and utilize patterns efficiently and effectively. However little is known about the nature of pattern networks, such as how are organizational patterns different from other patterns from the viewpoint of centrality. To clarify such characteristics, we mine a network consisting 285 patterns including 15 organizational patterns from an existing online pattern repository called Portland Pattern Repository. By applying network analysis techniques to the mined network, we revealed several interesting characteristics of the pattern network and organizational patterns such as that the degree centrality seems to somewhat reflect the commonness and generality of the corresponding pattern.

Development environments have changed drastically, development periods are shorter than ever and the number of team members has increased. Especially in open source software (OSS), a large number of developers contribute to OSS. OSS has difficulties in predicting or deciding when it will be released. In order to assess recent software developments, we proposed a generalized software reliability model (GSRM) based on a stochastic process, and compared GSRM with other models. In this paper, we focus on the release dates of OSS and the growth of faults (issues).

To realize layout consistency and operability of Graphical User Interfaces (GUIs), user interface guidelines (UI guidelines) are common. Currently, UI guidelines vary by platform (e. g., operating systems and desktop systems) and even by company. Although UI guidelines must be applied to GUIs, applying them is burdensome for software developers because UI guidelines contain many detailed guideline elements. To reduce this burden, we previously proposed a method to apply user interface guidelines to GUIs. However, this method targets specific UI guidelines. Hence to apply diverse UI guidelines, unified descriptions of guideline elements and mechanisms to automatically apply guideline elements to GUIs must be developed. In this paper, we propose templates to describe guideline elements of various UI guidelines and a method to automatically apply guideline elements to GUIs. The proposed method can support the development of new guideline elements.

Although design is an extremely important activity in software development, it is subjective because it depends on the designers' knowledge and skills. Every designer has her or his own strategies to solve design problems. Herein we model the design process as an ordered sequence of logical actions of "Create", "Delete", and "Modify" applied to the elements of a UML class diagram, and propose an automatic approach to collect information about the design process to elucidate design strategies. The strategies considered are top-down, bottom-up, breadthfirst, depth-first, and opportunistic. By mining the ordered sequences of actions for frequent patterns and analyzing the position and distribution of the actions in the sequence, we obtained two types of relationships in the design process: micro-patterns and macro-patterns. Then we evaluated our approach with two case studies. The first one, which occurred over a short time frame with seven subjects, identified the strategies used, while the second, which involved three subjects over a long period, revealed that there is not a universal strategy, but a combination of strategies.

Home cleaning robots have become popular. Most of the home cleaning robots are based on ground vehicles. While the cleaning robots based on ground vehicles can vacuum or wash floors robustly and efficiently, but they only clean on floors, not on stairs or furnitures. In this demo, we show a new concept of cleaning robot, called HoppingDuster. HoppingDuster is based on an aerial vehicle, which can y to stairs or furnitures to be cleaned, and hop or hover to wipe or blow down dust on them toward the floor so that the ground cleaning robot can vacuum the dust. HoppingDuster adapts its behavior to finish it cleaning within designated time and battery capacity.

Static analysis tools such as bug pattern tools are useful to detect bugs early in software development. However, existing tools sometimes yield so many warnings that developers tend to ignore such warnings.
To deal with this problem, we propose a gamified tool for motivating developers to remove such warnings. Our tool employs the gamification technique that calculates points by counting removed warnings with respect to each developer and each team. The points give developers feedback and urge them to compete with each other. We confirmed that developers removed about 150% warnings with our tool in comparison with the case where they did not use our tool through an experiment.

Wireless sensor networks (WSNs) play important roles in systems that interact with the real world (e.g., cyber-physical systems and internet of things). To mitigate the complex nature of WSNs, many platforms at different abstraction levels (e.g., abstraction of hardware, communications, and individual nodes) have been proposed in the last decade. WSNs in different environments might employ different platforms to satisfy nonfunctional requirements (NFRs) because the diversity of platforms results in trade-offs of NFRs and the quality of WSN heavily depends on the environment it runs. Although WSN software should be highly portable, existing approaches only support porting between operating systems and not more abstract middleware. Herein we propose a methodology with a framework to capture various platforms in the WSN domain with platform-independent multi-level models. A case study demonstrates that our framework can port WSN software to platforms at different abstraction levels and adapt the software to the new platform to improve performance.

To achieve overall business goals, GQM+Strategies (R) is an approach that aligns the business goals at each level of an organization to strategies and assesses the achievement of goals. Strategies derived from business goals are based on rationales (contexts and assumptions). Because extracting all rationales is an important process in the GQM+Strategies approach, we propose Context-Assumption-Matrix (CAM), which refines the GQM+Strategies model by extracting rationales based on the analysis of the relationships between stakeholders, and the Context Assumption (C/A) definition template to unify the expressive style of contexts and assumptions. To demonstrate the effectiveness of CAM, we conducted an experiment involving 43 students majoring in information sciences at Shimane University in Japan. GQM+Strategies with CAM can extract rationales more efficiently and exhaustively than GQM+Strategies alone. Moreover, when the management policy or the business environment changes, GQM+Strategies with CAM can analyze the rationales and the GQM+Strategies model easily.

Do open source software projects provide and maintain tests? What metrics are correlated with the test success? This paper answers these questions by executing tests of 452 open source software projects in GitHub and measuring 13 metrics from 77 projects. Only 117 projects passed all test cases. Additionally, the results are correlated with the comment density, public documented API density, and test coverage.

Development environments have changed drastically, development periods are shorter than ever and the number of team members has increased. These changes have led to difficulties in controlling the development activities and predicting when the development will end. Especially, quality managers try to control software reliability and project managers try to estimate the end of development for planing developing term and distribute the manpower to other developments. In order to assess recent software developments, we propose a generalized software reliability model (GSRM) based on a stochastic process, and simulate developments that include uncertainties and dynamics. We also compare our simulation results to those of other software reliability models. Using the values of uncertainties and dynamics obtained from GSRM, we can evaluate the developments in a quantitative manner. Additionally, we use equations to define the uncertainty regarding the time required to complete a development, and predict whether or not a development will be completed on time. We compare GSRM with an existing model using two old actual datasets and one new actual dataset which we collected, and show that the approximation curve generated by GSRM is about 12% more precise than that generated by the existing model. Furthermore, GSRM can narrow down the predicted time range in which a development will end to less than 40% of that obtained by the existing model.

Many program tasks require continuous modification of similar program elements, which is burdensome on programmers because continuous modifications are time consuming and some modifications are easily overlooked. To resolve this issue, we developed a tool, named SimilarHighlight, which extracted all possible matching elements via similarity patterns from recently modified elements using a sub syntax tree comparison. SimilarHighlight suggests similar program elements that may be modified during the next modification. Potential elements are highlighted and their text can be immediately selected by shortcut keys. Evaluations indicate that SimilarHighlight can improve programming productivity. Currently, SimilarHighlight supports C, C#, JAVA, JavaScript, and PHP, but in the future we will expand it to other languages.

It is important for project stakeholders to identify the states of projects and quality of products. Although metrics are useful for identifying them, it is difficult for project stakeholders to select appropriate metrics and determine the purpose of measuring metrics. We propose an approach that defines the measured metrics by GQM method to identify tendency in projects and products based on Trend Pattern. Additionally, we implement a tool as a Jenkins Plugin to visualize an evaluation results based on GQM method. We perform an industrial case study, which objects are two software development projects. In our industrial case study, we can identify the problem that product contains. As our future work, we will adopt our approach and GQM Plugin to software development project continuously to assess their effectiveness in the long term.

It is important for project stakeholders to identify the states of projects and quality of products. Although metrics are useful for identifying them, it is difficult for project stakeholders to select appropriate metrics and determine the purpose of measuring metrics. We propose an approach that defines the measured metrics by GQM method, and supports identifying tendency in projects and products based on Trend Pattern. Additionally, we implement a tool as a Jenkins Plugin which to visualizes an evaluation results based on GQM method. We perform an experiment with OSS and industrial case study with two software development projects. In our experiment, we can identify the problem and project tendency. In our industrial case study, we can also identify the problem that project contains. As our future work, we will adopt our approach and GQM Plugin to software development project continuously to assess their effectiveness in the long term.1.

リファクタリングはコード体質改善の手法として広く知られているが，手動での実行はコストが高く欠陥を埋め込みやすいため，リファクタリングツールが多数提案されている．しかし，これらのツールは単体の単純なリファクタリングの実行を支援するものであり，リファクタリングによるデザインパターンの導入など，複雑なリファクタリングを行うのは難しい．すなわち，単体のリファクタリングを複数種類組み合わせて逐次実行したり，複数箇所に対してあるいは複数回数繰り返してリファクタリングを実行したりすることは困難である．そこで我々は，Javaソースコードを表現可能なモデルを用いて，リファクタリング内容やその適用箇所の指定を記述できるスクリプトおよびその処理系を提案する．複雑なリファクタリングを簡潔に記述でき，少ないコストで複雑なリファクタリングを実行できること，またプロジェクト横断的に再利用できることを評価実験で確認し，本手法の有用性を示した．Refactoring has been recognized widely as the way to improve the internal qualities of source codes. Because manual refactorings is time-consuming and error prone, many tools supporting automated refactoring have been suggested. However, because these tools are only for supporting a unit and simple refactoring, it is difficult to preform complicated refactorings such as a introduction of a design pattern. That is, it is difficult to apply a set of combined refactorings or to apply refactorings multiple times to multiple positions. In this research, we propose the script language and its interpreter that can describe how and where to refactor by using a model expressing source codes. From the results of evaluations, we concluded that our language and interpreter allow users to describe the steps of refactorings as scripts, replay and reuse them simply for multiple projects.

数多くのパターンからパターンランゲージを構築することで,言語として体系化されたパターン名を利用した円滑なコミュニケーションが可能となり,思考や情報の共有が容易となる.しかしながら,パターンを抽出するための従来手法では,関連を伴う多くのパターンを抽出することは困難である.そこで我々は,既知のパターンのモデル化とそれに基づく構造変形を利用して,関連するパターンの候補群を導出する手法を提案する.本手法を用いることで,既知のパターンと関連するパターンを現実的な時間で導出することができる.

障害を持つユーザがWebサイトを利用するためにWebサイトを支援技術に対応させるためのガイドラインが存在する。しかしガイドラインは膨大であり、Webコンテンツに適用させるために必要なコストや労力が大きい。本研究では、動的なリッチインターネットアプリケーション(RIA)を実現する技術の中でもJavaScriptによるコンテンツに着目し、ガイドラインに対応しているかを評価する手法について提案する。本手法により、ガイドラン対応のためのコストや労力を軽減することができる。

ソフトウェアパターンの収集サイトPortland Pattern Repository(以下PPR)にネットワーク分析の手法を適用し,パターンの参照関係の位置をしめす指標である中心性を算出し,パターン間の参照関係の構造的特徴を明らかにした.また,PPRに記載されている各パターンの履歴情報についてデータ分析を行った.分析の結果,使用頻度の高いと思われるパターンは次数中心性が高い傾向がみられた.このことは適用するパターンの検討や新たなパターンの抽出に有用であると考えられる.

欠陥の発見におけるソフトウェア信頼性モデルについて,確率過程を用いた一般化されたモデルを提案する.開発での様々な不確定要素と開発の時間変化をモデルに組み込み、定量的に開発工程を扱えるようにする.これにより,開発の時間変化や不確定要素を考慮した開発の予測が行える.特に多くの既存モデルでは扱っていない,時間変化に関して複数のタイプを例として扱い,実際の開発との比較を行う.本発表では既存のソフトウェア信頼性モデルと提案するモデルを比較し,提案するモデルでのシミュレーション結果を示し,時間変化と不確定要素について考察を行う.

卒業論文認定

バグローカリゼーションとは,ソフトウェアテスティングで得られる情報からコード内のバグの位置を推定する手法で,近年その有用性が注目を浴びている.しかし,既存のバグローカリゼーションツールでは,単一のプログラミング言語および単一のSuspiciousness算出式にしか対応していない.そこで,我々は複数のプログラミング言語に対応し, Suspiciousness算出式が容易に変更可能なバグローカリゼーションフレームワークを提案する.複数のプログラミング言語に対してそれぞれのSuspiciousness算出式を適用し,比較を行うことで本手法の有用性を確認する.

Information technology (IT) services have been applied to mission critical businesses such as financial firms or telecommunication firms. And more applications are expected for IT supporting social and economic infrastructures, particularly those for healthcare in the future. However, defects in IT services will have greater negative impacts on social and economic activities in the future, since the risks of such defects are increasing due to their wider applications and the growth of IT systems’ complexity and scale. In this chapter, upon surveying the current state of affairs and seeing that little progress has been made towards understanding and reducing defects in IT services that influence social and economic activities, despite a number of efforts including upgrading software and hardware quality, we propose a new approach to understanding and managing the dependability of IT services by discussing a dependability model. The model consists of not only functions for legacy system dependability but also two types of functions (additional safety and safety operation). Next we evaluate the efficacy of these two types of functions relative to IT dependability, both qualitatively and quantitatively, by using 42 actual cases of IT accidents obtained by the Informationtechnology Promotion Agency, Japan. Moreover, based on the verification, we examine the ways in which improvement of IT dependability associated with social and economic infrastructure, previously dependent on the skill of individual engineers, is eventually achieved as a result of organizational activities.

In practical lectures on software intensive business systems, we do not yet have an established method for determining what kind of personal characteristics and team compositions are most beneficial to obtaining the maximal educational effectiveness. Here, we propose a framework for analyzing the effects of personal characteristics of team members on educational effectiveness. We also apply the framework to an actual practical lecture. As a result, we find that it is better for a team to have members with a similar degree of tendency of conservative for acquiring more knowledge and skills and the team members have similar characteristics of progressive or conservative. It is expected that in similar practical lectures, we can also obtain the desired educational effectiveness if we can compose a team with the suitable characteristics as based on our findings.

トレーサビリティはソフトウェアの保守性を左右する1つの要素であり，これまで様々な管理手法が報告されてきた．しかし，現状ではトレーサビリティの達成度合を示す指標が提供されていないため，その認識は主観的なものになりがちである．我々は，UML記述の設計モデルとオブジェクト指向言語記述のソースコード間におけるトレーサビリティの定量的測定手法を提案する．具体的には，独自の半自動アルゴリズムにより設計と実装を対応付け，GQM法(Goal-Question-Metric approach)で定めた枠組みを利用し測定を実施する．提案手法を実際の設計モデルとソースコードの組に適用した結果，第三者でも少ない労力でトレーサビリティを把握できることを確認した．

Web pages are used for a variety of purposes. End users must understand dynamically changing content and sequentially follow page links to find desired material, requiring significant time and effort. However, for visually impaired users using screen readers, it can be difficult to find links to web pages when link text and alternative text descriptions are inappropriate. Our method supports the discovery of content by analyzing 8 categories of link types, and allows visually impaired users to be aware of the content represented by links in advance. This facilitates end users access to necessary information on web pages. Our method of classifying web page links is therefore effective as a means of evaluating accessibility.

Simulinkモデルは組み込みソフトウェア開発に適している。一方、大規模で煩雑なモデルになりやすく検討・修正が困難である。サブシステムによるモデルを抽象化は属人性が強いためにモデルの理解性が低い。そこで、我々はSimulinkモデルの保守性の向上を目指して、クラスタリング手法を適用し、属人性の無い適切な抽象化を行う。さらに、SimullnkモデルとUMLモデルの双方向変換を提案する。UMLモデルの静的・動的なモデルに変換する事で、責務等を明らかにして理解性を向上させる。及び、双方向変換でモデル間の対応関係を維持する。

Web applications are complex; they consist of many subsystems and run on various browsers and platforms. This makes it difficult to conduct adequate integration testing to detect faults in the connections between subsystems or in the specific environments. Therefore, establishing an efficient integration testing method with the proper test adequacy criteria and tools is an important issue.
In this paper, we propose a new test coverage called template variable coverage. We also propose a novel technique for generating skeleton test code that includes accessor methods and improves the template variable coverage criterion, using a tool that we developed called POGen. Our experiments show that template variable coverage correlates highly with the capability to detect faults, and that POGen can reduce testing costs.

Although many programming languages and test coverage criteria currently exist, most coverage measurement tools only support select programming languages and coverage criteria. Consequently, multiple measurement tools must be combined to measure coverage for software which uses multiple programming languages such as web applications. However, such combination leads to inconsistent and inaccurate measurement results.In this paper, we describe a consistent and flexible framework for measuring coverage supporting multiple programming languages, called Open Code Coverage Framework (OCCF). OCCF allows users to add new extensions for supporting programming languages and coverage criteria with low development costs. To evaluate the effectiveness of OCCF, sample implementation to support statement coverage and decision coverage for eight programming languages (C, C++, C#, Java, JavaScript, Python, Ruby and Lua) are demonstrated. Additionally, applications of OCCF for localizing faults and minimizing tests are shown. © 2013 IEEE.

In practical lectures on software intensive business systems, we do not yet have an established method for determining what kind of personal characteristics and team compositions are most beneficial to obtaining the maximal educational effectiveness. Here, we propose a framework for analyzing the effects of personal characteristics of team members on educational effectiveness. We also apply the framework to an actual practical lecture. As a result, we find that it is better for a team to have members with a similar degree of tendency of conservative for acquiring more knowledge and skills and the team members have similar characteristics of progressive or conservative. It is expected that in similar practical lectures, we can also obtain the desired educational effectiveness if we can compose a team with the suitable characteristics as based on our findings.

An artificial intelligence programming contest with game software is one of the most effective way of learning programming. Contestants can spontaneously learn programming to win in such contests. Although our previous work helps to hold artificial intelligence programming contests, its effectiveness is limited owing to an insufficient requirement analysis and uses of an unrefined design pattern.
In this paper, we report on ACM JavaChallenge 2012, that is an artificial intelligence programming contest. we elicit requirements on a contest with a goal-oriented requirements analysis and extend the state design pattern using Scala to hold JavaChallenge 2012. We evaluate JavaChallenge 2012 very highly by questionnaire investigation.

In systems that require several services to collaborate, specifying coordination protocols is vital, but costly. Additionally, several properties, which are derived from laws, regulations, requirements, etc., must be satisfied. Coordination protocol composition approaches construct specific protocols in a cost effective manner in accordance with the composition intentions. However, existing composition approaches are insufficient in terms of satisfying properties. Existing approaches use concrete specifications to identify composition intentions and do not consider interference between compositions. Herein we propose a new composition approach in which a developer directly expresses his or her intentions as constraints via metadata, and then the system searches for optimal composition methods based on the constraints. © 2013 IEEE.

Development environments have changed drastically in recent years. The development periods are shorter than ever and the number of team has increased. These changes have led to difficulties in controlling the development activities and predicting the end of developments. In order to assess recent software developments, we propose a generalized software reliability model based on a stochastic process, and simulate developments that include uncertainties and dynamics, such as unpredictable requirements changes, shortening of the development period, and decrease in the number of members. We also compare our simulation results to those of other software reliability models. Using the values of uncertainties and dynamics obtained from our model, we can evaluate the developments in a quantitative manner.

If traceability links between requirements and source code are not clarified when conducting maintenance and enhancements for the same series of software products, engineers cannot immediately find the correction location in the source code for requirement changes. However, manually recovering links in a large group of products requires significant costs and some links may be overlooked. Here, we propose a semi-automatic method to recover traceability links between requirements and source code in the same series of large software products. In order to support differences in representation between requirements and source code, we recover links by using the configuration management log as an intermediary. We refine the links by classifying requirements and code elements in terms of whether they are common or specific to the products. As a result of applying our method to real products that have 60KLOC, we have recovered valid traceability links within a reasonable amount of time. Automatic parts have taken 13 minutes 36 seconds, and non-automatic parts have taken about 3 hours, with a recall of 76.2% and a precision of 94.1%. Moreover, we recovered some links that were unknown to engineers. By recovering traceability links, software reusability will be improved, and software product line introduction will be facilitated. © 2013 ACM.

Workshops are sometimes known as effective ways to learn the human and social factors of software engineering. However, their effectiveness in learning agile development principles in particular has not yet been determined, despite the fact that numerous agile development workshops have been held over the years. In this paper, we analyze the effectiveness of agile development workshops through an experiment, and show that one of representative workshops is indeed effective at learning agile principles. Self-study is another commonly used method to learn something new. Therefore, we compare the effectiveness of workshops with that of self-study to better illustrate the effectiveness of agile development workshops. In our experiment, we examine 7 workshop subjects and 8 self-study subjects, and compare their scores on the agile mind check, which is a method used to measure their degree of mastery of agile principles. As a result, we demonstrate the effectiveness of agile development workshops, especially those that simulate actual experiences. We also show that one of workshops is more effective than self-study regarding the agile mind check score.

Software developers are not necessarily security specialists, security patterns provide developers with the knowledge of security specialists. Although security patterns are reusable and include security knowledge, it is possible to inappropriately apply a security pattern or that a properly applied pattern does not mitigate threats and vulnerabilities. Herein we propose a method to validate security pattern applications. Our method provides extended security patterns, which include requirement- and design-level patterns as well as a new model testing process using these patterns. Developers specify the threats and vulnerabilities in the target system during an early stage of development, and then our method validates whether the security patterns are properly applied and assesses whether these vulnerabilities are resolved. © 2013 IEEE.

The development organization often changes during software development. Derivative developments, forks, and change of developers due to acquisition or open-sourcing are some conceivable situations. However, the impact of this change on software quality has yet to be elucidated. Herein we introduce the concept of origins to study the effects of organizational changes on software quality. A file's origin is defined as its creation and modification history. Using the concept of origins, we analyze two open source projects, OpenOffice and VirtualBox, which were each developed by a total of three organizations. We conduct statistical analysis to investigate the relationship between the origins, product metrics, the number of modifications, and defects. Results show that files that are created or modified by multiple organizations or by later organizations tend to be faultier due to the increase in complexity and modification frequency.

Webサービスの動的な連携技術が盛んに研究され,連携を記述し実行可能な言語が活用されている.サービス連携は今後複数クラウトを跨って実行されると考えられる.WS-BPEL標準を用いた場合中央エンジンを介して連携が行われ,データが巨大な場合にネットワーク遅延問題が生じる.本研究では適切なクラウトにサービスコンポーネントを動的配置する技術を適用し,遅延を軽減することを可能とするサービス連携のためのクラウト制御の枠組みを提案する.クラウト制御とコンポーネント配備に関する振る舞いを連携フローから分離し,連携ロジックに付加するルールとして表現する.この分離により,連携ロジックを変更せず振る舞いを容易に追加,変更できる.

派生開発されてきたプロダクト群に対して,保守や拡張を行う際には,要求と実装の間でトレーサビリティが明確化されていることが望ましい.しかし,大規模なプロダクト群に対して,これらの作業を人手のみで行うことは困難である.我々は,構成管理ログを用いて,要求資産とソースコード,それぞれの共通性・可変性分析結果間の対応関係を分析し,その結果を利用することで,要求・実装間のトレーサビリティリンクを自動的に抽出する手法を提案する.提案手法を,一定規模の派生プロダクト群に適用した結果,実用的な時間内で,妥当なトレーサビリティリンクを抽出できた.

我々は Ajax アプリケーションの保守容易性を測るソフトウェアメトリクスを定義するための研究を行っている.通常の Web アプリケーションを対象とする保守容易性ソフトウェアメトリクスは既に存在するが. Ajax の特徴を考慮したものはまだない.我々は実際に Ajax アプリケーションを作成し.保守を繰り返すことで保守容易性が変化する経過を観察し具体的データを得た.このデータをもとに回帰分析により保守容易性を測るための指標を求めた.

派生開発されてきたプロダクト群に対して,保守や拡張を行う際には,要求と実装の間でトレーサピリティが明確化されていることが望ましい.しかし,大規模なプロダクト群に対して,これらの作業を人手のみで行うことは困難である.我々は,構成管理ログを用いて,要求資産とソースコード,それぞれの共通性・可変性分析結果間の対応関係を分析し,その結果を利用することで,要求・実装問のトレーサビリティリンクを自動的に抽出する手法を提案する.提案手法を,一定規模の派生プロダクト群に適用した結果,実用的な時間内で,妥当なトレーサビリティリンクを抽出できた.

Simulinkモデルは,ブロック線図としてプログラムを表現したモデルであり,制御系を中心として組込みソフトウェア開発において使われつつある.大規模なモデルや,同一ドメインで複数のモデルを扱う場合,クローンと呼ばれる重複箇所の存在がモデルの保守性を低下させる可能性がある.この問題解決に向けて,完全に一致するクローンを検出する手法が提案されているが,コピー&ペースト後に部分的に変更されたような非完全一致ながら類似性の高いクローン(ギャップを含むクローン)を十分に検出できなかった.そこで我々は,完全一致のクローンを検出する既存の手法と,多頻度グラフ検出アルゴリズムを組み合わせることで,非完全一致のモデルクローンをSimulinkモデル群から効率よく検出する手法を提案する.提案手法を検出ツールとして実装し,複数の具体的な制御モデルに適用した結果,非完全一致のクローンを検出可能なことを確認した.提案手法により検出した結果を記録し管理することで,効率的な保守を実現することが期待できる.

実務経験を持たない大学生を対象とした演習中心の情報システムの受発注に関する実践的講座において,教育効果を高めるための適切なチーム構成の方法は知られていない.そこで我々は,チーム構成が教育効果にもたらす影響を分析するための枠組みを設計し,その枠組みを実際の2つの実践的講座に適用した.適用結果の分析により,チームにおける個人特性上のメンバのばらつきが教育効果に影響を与えることを明らかにした.

Fault-Localizationはテスト結果からテスト失敗の原因となるコードの箇所を推定する手法で,デバッグ作業の支援に有効である。しかし、テストケースが十分でない場合,バグを十分に局所化できないため、Fault-Localization結果が信頼できない.本稿では,実際の開発形態に沿ったインクリメンタルな運用のもとでプログラム構造を用いてFault-Localization結果を改善する手法を提案する.Fault-Localization結果のトップランキングの高精度化とバグの修正を繰り返していく手法により,効率的なデバッギングの実現可能性を示す.

近年,プロブラミングコンテスト,特にゲームソフトウェア上で自律的に動作するプレイヤーのプログラムを作成して競い合う形式のコンテストが,教育向けの枠組みとして注目を浴びている.一方,コンテストで利用されるゲームプラットホームは,一般的なゲームソフトウェアやエンタープライズシステムと異なり,開発手法や技術的な知見が体系化されていない.本論文では,過去の開発経験からゲームプラットホームの要求を分析した結果をもとに,開発における知見を設計原則としてまとめる.更に,ゲームプラットホームの品質を保証して,開発コストを低減させるため,設計原則を踏まえたアーキテクチャと汎用的な共通処理を提供するフレームワークを提案する.その上で,提案フレームワークを利用するゲームプラットホームとコンテストの事例報告をもとに,提案フレームワークを利用するゲームプラットホームが分析した要求を満たすかどうかという定性的評価と,ソフトウェアメトリックスや参加者のアンケートによる定量的評価の両方から提案フレームワークの有用性を示す.

For software development, methods must be able to effectively perform evaluations with respect to financial and time considerations. Usability evaluations are commonly performed to ensure software is usable. Most evaluations are individually performed, leading to some significant disadvantages. Although individual evaluations identify many usability problems, efficient modifications in terms of cost and development time are difficult. Additionally, usability problems in only specific perspectives are identified in individual usability evaluations. It is important to identify comprehensively usability problems in various perspectives. To improve these situations, the authors have proposed a method to automatically integrate various types of usability evaluations. Their method adds functions to record the operation histories of the target software. This information is then used to perform individual usability evaluations with an emphasis on usability categories, such as efficiency, errors, and learnability. Then the method integrates these individual evaluations to identify usability problems and subsequently prioritize these problems according to usability categories determined by the software developers and end users. Specifically, the authors' research focuses on employing automatic usability evaluations to identify problems. For example, they analyze the operation histories, but do not focus on manually performed evaluations such as heuristic ones. They assume their research can aid software developers and usability engineers because their work allows them to recognize the more serious problems. Consequently, the software can be modified to resolve the usability problems and better meet the end users' requirements. In the future, the authors strive to integrate more diverse usability evaluations, including heuristic evaluations, to refine integration capabilities, to identify problems in more detail, and to improve the effectiveness of the usability evaluations. © 2013, IGI Global.

パターン・ランゲージは，プロセスのグラスボックス化を目的としている．しかし、従来のパターンのマイニング手法は，プロセスが明確であることを前提としているので，マイニングされたパターン・ランゲージが正当であるといえる．したがって，開発者自身も開発プロセスの全容を把握していないプロセスが不明瞭な開発においては，目的となるプロセス自体がそもそも不明瞭なので，抽出されたパターン・ランゲージが正当であるか判断できない．我々はこれらの問題を解決するために，開発プロセスとパターン・ランゲージを同時に抽出する新たなパターンマイニングの手法を提案する．我々は実際に新たなマイニング手法を用いて，開発プロセスが不明瞭になりがちな，本業の合間に取り組むコンテスト形式の「ETロボットコンテスト」のパターン・ランゲージの抽出を行った．Pattern Language aimed at to clear the process. However, it can be said that it is correct since the mining technique of the conventional pattern is premised on a process being clear. Therefore, we cannot judge whether the extracted pattern language is correct when the development process which development is ambiguity and not understood by developer because the process itself is not clear. We propose the technique of new pattern mining which extracts a development process and a pattern language simultaneously, in order to solve these problems. We extracted the pattern language of "ET robot contest" which tends to become ambiguous because that development of the contest is in the intervals of vocational.

The technology for web services has facilitated composition of a new service by combining existing services. The resulting composite service is required to guarantee Quality of Service (QoS), such as price, in addition to the demanded function. Each composite service faces computationally-expensive service selection by exploring enormous service combinations for optimization of a utility function and satisfaction of global constraints. In addition, each concrete service has difficulties in determining QoS that is profitable while attractive for customers, or composite services. Specifically, information on rival services is generally secret and changeable, which is required for the optimal decision. In response to these problems, this paper proposes an algorithm for service selection using Vickrey auction. In the first phase of the proposed algorithm, the composite service selects some best concrete services through the reverse Vickrey auction, only considering the utility function. In the second phase, the global constraints are satisfied through adjustments based on the Vickrey auction. The proposed algorithm avoids full exploration of services combinations for efficient computation, while encouraging providers to declare their best QoS without caring about extra profit. © 2012 IEEE.

The activities of software analysis and design are important because they are the first steps in the software development. The objective of this paper is to identify the patterns that emerge during these activities. Identifying these patterns is important because we can imitate the patterns that increase our productivity and avoid the patterns that decrease our productivity. The patterns are made from sequences the logical actions "Create", "Delete" and "Rename" applied on the elements of the design diagrams. These actions are collected when creating UML class diagrams with the open source modeling tool ArgoUML. The patterns found are of two types: micro-pattens and macro-patterns. These patterns were related to different design strategies such as top down, breadth first.

Web pages are used for various purposes. End users must sequentially follow page links to find necessary content, requiring significant time and effort. Our method supports the location of content by analyzing link types. This facilitates end users' access to necessary information on web pages.

Agile development refers to the group of software development methodologies based on an iterative and incremental process model. It divides the development period into short time frames called iterations and uses a body of knowledge obtained from past experience called practice to ensure agile software development Although the iteration length is an important factor in agile development however it has so far been decided by the qualitatively and it has been reported that projects with an inappropriate iteration length tends to be failed. We thus propose a new methodology for estimating an appropriate iteration length through the conduct on of a simulation based on project constraints. In this paper we first, propose a method of calculating an appropriate iteration length for a particular project to promote the easy use of agile development. Second, the relationship between the iteration length and project constraints was investigated by varying the parameters to create diverse situations. © 2012 IEEE.

To realize usability of software, consistency of GUI (Graphical User Interface) layouts is required. Consistency is realized by user interface guidelines, in many cases. However, there are many items in the guidelines, and it is difficult to apply all items to GUIs in terms of costs and schedule. In our method, we have proposed a method to realize consistency of GUIs. Concretely, source programs of developed GUIs are analyzed, and layout rules are extracted. Then, source programs of undeveloped GUIs are generated based on the extracted layout rules.

The commonality and variability analysis of legacy software assets requires high costs in terms of personnel and time in extractive core asset development. We propose a technique for supporting the commonality and variability analysis, targeting the requirements and structural models of legacy software assets for the development of a feature diagram and a product line architecture (PLA). We analyze the commonality and variability of the sentences as requirements and classes as structural models by calculating similarities based on a vector space model. By using our technique, the costs in terms of personnel and time required for the analysis of legacy software assets can be reduced. Copyright 2012 ACM.

Test coverage is an important indicator of whether software has been sufficiently tested. However, there are several problems with the existing measurement tools for test coverage, such as their cost of development and maintenance, inconsistency, and inflexibility in measurement. We propose a consistent and flexible measurement framework for test coverage that we call the Open Code Coverage Framework (OCCF). It supports multiple programming languages by extracting the commonalities from multiple programming languages using an abstract syntax tree to help in the development of the measurement tools for the test coverage of new programming languages. OCCF allows users to add programming language support independently of the test-coverage-criteria and also to add test-coverage-criteria support independently of programming languages in order to take consistent measurements in each programming language. Moreover, OCCF provides two methods for changin the measurement range and elements using XPath and adding user code in order to make more flexible measurements. We implemented a sample tool for C, Java, and Python using OCCF. OCCF can measure four test-coverage-criteria. We also confirmed that OCCF can support C#, Ruby, Java Script, and Lua. Moreover, we reduced the lines of code (LOCs) required to implement measurement tools for test coverage by approximately 90% and the time to implement a new test-coverage-criterion by over 80% in an experiment that compared OCCF with the conventional non-framework-based tools.

モデル検査法がアプリケーションソフトウェアの形式検証のために適用されつつある.ソフトウェア開発の上流工程ではモデルを開発成果物とすることが多く,その成果物としてUMLが普及している.UMLのモデルを形式検証に活用するために,モデルから検証可能なオートマトンへと変換する手法が提案されている.我々は,WebアプリケーションのUMLモデルを,検証可能なオートマトンへ変換する手法を提案する.従来手法では,オートマトン生成のための情報をモデルに付加していたが,本手法ではWebアプリケーションモデリング以外の情報をモデルの前提としない.モデリング対象は携帯電話向けのWebアプリケーションとし,検証条件はセッションに関するセキュリティ脆弱性の不存在とした.

Design patterns are known for their usefulness to solve recurrent problems. Design patterns are a way of transmitting knowledge and experience by using proven, high quality solutions. A problem that emerges when using design patterns is that it is not clear how to measure the impact that has its application on the source code. The relationships between metrics and design patterns is not clear. We propose an experiment for measuring the usefulness of metrics and their success in predicting correct usage of design patterns. With this experiment we will explore which metrics capture best the relationship of design patterns quality of the source code. By using those metrics we will make predictions about the correct usage of the design patterns. In this experiment the selected metrics were not a good predictor, however it is a starting point to explore more metrics and their relationships with design patterns.

無線センサネットワーク上で動作する移動体追跡アプリケーションには,期待する分解能を満たしつつ,データ送信回数を抑制することが求められる.この問題に対し,ソフトウェアによってセンサの計測値をフィルタし,分解能を抑えることでデータ送信回数を抑制するセンサモデルが提案されている.しかし,既存のセンサモデルでは分解能の調整が行えず,分解能とデータ送信回数の細かなトレードオフ調整が困難であった.そこで本論文では.(1)分解能とデータ送信回数のトレードオフを調整可能にするN-aryセンサモデルと,(2)ノードの配置状況に応じて地域ごとに得られる分解能を均一化するN-aryセンサモデル設定手法を提案する.更に,シミュレーション結果により,本手法を用いることで,システムに期待する分解能要求に合わせてシステムの分解能を調整し,過分な通信を抑えることが可能となることを示した.

FOSE貢献賞

The amount of test code has increased as the test technology has developed and the amount of duplicated test code that is redundant has also increased. Duplicated test code that does not change defects which are found when testing software even if it is removed. This increases the size of test code and decreases the efficiency of execution and maintenance of software testing. We therefore propose techniques of detecting duplicated test code based on test coverage supporting multiple programming languages. We define the inclusion relation of test code based on test coverage and present techniques of detection and the implementation of a detection tool supporting three programming languages: Java, C and Python. We explain an experiment for detecting duplicated test code in open source software with the detection tool and discuss the benefits of the proposed techniques. Moreover, we show that the duplicated test code that is detected with the detection tool does not influence the results obtained from measuring the test coverage and demonstrate that the change in using test coverage can change the measurement criteria.

IT分野において,社会・経済活動に大きな影響を及ぼす大問題プロジェクトの原因としては,プロジェクト・マネージャーだけでなく,顧客,上司,営業担当(以下,この三者のステークホルダーを企画責任者と呼ぶ)も係わりうる.しかし,従来,企画責任者と大問題プロジェクトとの因果関係について,客観的な手法で,明らかにされていなかった.本稿では,結果が恣意的に導かれないような手続きを用いることで,(独)情報処理推進機構にて収集・開示された失敗プロジェクト事例の中から,大問題プロジェクト事例を抽出・分析し,両者の因果関係について調べる.また,大問題プロジェクトの回避のための,企画責任者も含めた標準化の必要性について述べる.

ソフトウェアの使いやすさを意味するユーザビリティにとって重要な要素のひとつとして,一貫性が挙げられる.GUIに一貫性を持たせることで,ユーザの操作方法の学習や効率化を助けることができる.しかし,ソフトウェアのGUIに一貫性を持たせることはソフトウェア開発者にとって大きな負担となっている.そこで本手法では,ソフトウェアの既存ウインドウ情報を解析することによりレイアウトのルールを発見し,GUIウィジェットをルールに沿って自動レイアウトする.これにより,開発者がGUIを作成するプロセスを短縮することや,一貫性のあるレイアウトを容易に生成することを可能にする.

In order to develop Wireless Sensor Network (WSN) applications, it is necessary to develop prototypes in a low-cost way and to optimize application performance. Existing development approaches enable to develop a low-cost prototype by concealing the detail of WSN from the developers. However, there is a trade-off between the development cost of prototype and the description capability needed to optimize the application performance. We propose a Model-Driven Development (MDD) process to enable a low-cost prototyping and detailed optimization. To enable such a development process, we define modeling languages, which describe an application at three abstraction levels, and transformation rules, which transform models described by our modeling language to concrete one. Using our process, in prototyping, the developer describes a model by using the modeling language at the highest abstraction level and automatically obtains an executable model by using transformation rules. In addition, in optimizing, the developer can automatically obtain the models at more concrete abstraction level than the prototype by using transformation rules and modifies them in greater detail by using each modeling language. © 2011 ACM.

Semantic web techniques have been leveraged in planning methods for automated service composition. Typically, inputs and outputs of services are described in abstract concepts for efficient and meaningful matching between output of one service and input of another. However, existing methods have not examined concrete data structures, which are essential for successful service interaction in common implementation architectures. To address the problem, this paper proposes a matching method that can be incorporated into existing planning methods to ensure consistency in concrete data structures. The proposed method applies a two-phase matching process to efficiently filter out services that do not match at the abstract level. It also applies a data structure to organize similar services according to their relationships for efficient matching during the planning process. © 2011 IEEE.

Currently numerous websites contain dynamic content, but it is difficult to create accessible websites with dynamic content compared to those with static content. Because many platforms can realize Rich Internet Applications (RIAs), it is important that this type of dynamic content become accessible. We propose a method to improve accessibility of RIAs. Our method consists of two phases. In the first phase, we develop libraries to realize accessibility of RIAs. In the second phase, the libraries are automatically applied to RIAs. As an example of platforms that realize RIAs, our research focuses on JavaFX Script. © 2011 Springer-Verlag Berlin.

本研究ではJavaFX Scriptにより作成されたRIA(Rich Internet Applications)のアクセシビリティを向上させる手法について提案する。具体的には、JavaFX ScriptのGUIに対し、アクセシビリティを向上させるためのライブラリを自動的に適用するための方法を提案する。これにより、設計者がアクセシビリティを確保する労力の削減を目指す。

Computers and software have become necessities in human society. and most people ale replied to be able to use them However software is not always accessible for users with special needs, and it is difficult to develop software accessible to such users Theme are many guidelines and support tools for developing accessible websites For software, however such guidelines and support tools are few In our research, to develop accessible software easily we propose a method of evaluating the accessibility of Graphical User Interface (GUI) software This method involves analyzing GUI software source programs. assessing accessibility on the basis of accessibility guidelines, and presenting a list of unsatisfactory accessibility code and indicating how to modify it.

Serious problem projects (SPPs) often occur, particularly in a system integration environment, and it is difficult to prevent them, since the relationships among phenomena that occur throughout the project life cycle are extremely complicated. Our goal is to make it easier to identify major risks by distinguishing phenomena that are sources of future SPPs from phenomena observed in actual field projects. By choosing several events whose causal relation is known to be cyclic, we constructed a causal model and clarified that it can contribute to the easier recognition of SPPs empirically, by analyzing actual SPP cases.

設計の理解支援のためオブジェクト指向プログラムからのデザインパターン検出手法が提案されている．しかしながら，デザインパターン適用後のソースコードに対する静的解析を用いた従来手法では検出精度が低い．本稿では，デザインパターン適用前のソースコードの静的解析を併用して検出精度を高めた検出手法を提案する．提案手法により，構造が類似するデザインパターン群を高精度に判別し，保守目的の参照者の設計理解を支援することができる．

本研究ではソフトウェアのGUIに関して,自動的にユーザビリティを評価する手法について提案する.具体的には,ユーザに対象となるソフトウェアに関してあるタスクを実行してもらい,その操作履歴を取得し,その内容を分析することで,GUIのウィジェットやウィンドウ間の操作時間や操作順序などからユーザビリティ上の問題点を特定する.また,これら一連の評価作業を自動で行えるようにすることで,ユーザビリティ評価にかかる労力の削減を目指す.

Test coverage is an important indicator of whether software has been tested sufficiently. However, existing measurement tools for test coverage are associated with several problems such as their cost of development and maintenance, inconsistency and inflexibility in measurement. We propose a framework for consistent and flexible measurement of test coverage, called the Open Code Coverage Framework (OCCF), that supports multiple programming languages. OCCF extracts commonalities from multiple programming languages focusing on only small syntax differences in programming languages using an abstract syntax tree. OCCF provides guidelines to support several test coverage criteria. Moreover, OCCF let users expand features to add user-defined test coverage and new programming language. As a result, we reduced the lines of code required to implement measurement tools for test coverage by about 90%and the time to implement a special coverage criterion by80% or more in an experiment that compared OCCF with conventional tools developed individually without using the framework. © 2010 IEEE.

Defects in information technology (IT) services will have greater negative impacts on social and economic activities in the future, since the risks of such defects are increasing due to their wider applications and the growth of IT systems' complexity and scale. In this paper, upon surveying the current state of affairs and seeing that little progress has been made towards understanding and reducing defects in IT services that influence social and economic activities, despite a number of efforts including upgrading software and hardware quality, we propose a new approach to understanding and managing the dependability of IT services by discussing a dependability model. The model consists of not only functions for legacy system dependability but also two types of functions (additional safety and safety operation). Next we evaluate the efficacy of these two types of functions relative to IT dependability, both qualitatively and quantitatively, by using 42 actual cases of IT accidents obtained by the Information-technology Promotion Agency, Japan. Moreover, based on the verification, we examine the ways in which improvement of IT dependability associated with social and economic infrastructure, previously dependent on the skill of individual engineers, is eventually achieved as a result of organizational activities.

Among several diagrams defined in UML, the class diagram is particularly useful through entire software development process, from early domain analysis stages to later maintenance stages. However conventional UML environments are often inappropriate for collaborative modeling in physically remote locations, such as exchanging models on a public mailing list via email. To overcome this issue, we propose a new diagram notation, called "TCD" (Text-based uml Class Diagram), for describing UML class diagrams using ASCII text. Since text files can be easily created, modified and exchanged in anywhere by any computing platforms, TCD facilitates the collaborative modeling with a number of unspecified people. Moreover, we implemented model converters for converting in both directions between UML class diagrams described in the XMI form and those in the TCD form. By using the converters, the reusability of models can be significantly improved because many of UML modeling tools support the XMI for importing and exporting modeling data.

マルチエージェントシステムではエージェント間の協調動作を定義する協調プロトコルが重要である.しかし,多数のエージェントが参加する協調プロトコルを定義することは非常に複雑でコストの高いタスクである.複雑な協調プロトコルを容易に作成する手法として協調プロトコル合成があるが,既存の協調プロトコル合成では一つの協調プロトコルを複数の箇所に合成する場合には,合成のコストを十分に低減することができなかった.本論文では協調プロトコル合成の新しい手法として,メタデータを用いた協調プロトコル合成手法を提案する.本手法を用いることで,一つの協調プロトコルを複数箇所に合成する場合の合成のコストを低減することができる.

FIT船井ベストペーパー賞, FITヤングリサーチャー賞

グラフ彩色法はレジスタ割付けの代表的な手法であるが，冗長なスピルが発生しやすいという欠点があった．そこで，冗長なスピルの発生を抑えるために，生存区間分割という手法が提案されている．しかし，生存区間分割には副作用が存在し，それがレジスタ割付けに悪影響を及ぼしてしまう場合があった．その副作用とは，生存区間分割によって発生する逐次コピー処理が原因となり，分割前には存在しなかった干渉が新たに発生してしまうというものである．この新たに発生する干渉を偽干渉と呼ぶ．本論文では，偽干渉の発生を回避することで生存区間分割の効果をより高める手法を提案する．偽干渉の発生を回避するためには，複数のコピー命令が並列に実行されることを表現する必要がある．そこで，我々は並列コピー中間コードを新たに定義し，逐次コピー処理の代わりにそれを利用することにした．ただし，実際に並列コピーを行うことはできないので，レジスタ割付け完了後に，並列コピーをした場合と同じ結果が得られるようなマシンコードに変換しなければならない．この変換の際には，特にコピー命令間の依存関係に注意する必要がある．以上のような手法を用いることで，生存区間分割の効果をより高めることができる．SPEC ベンチマークにおいて，本手法を実装したコンパイラが生成したコードは，本手法未実装のコンパイラが生成したコードよりも平均で約 0.9% 高速であった．Graph coloring, a typical technique of register allocation, is prone to generate redundant spill code. Some techniques of live-range splitting have been proposed to solve this problem. However, these techniques have the side-effect which interferes with register allocation, because the interference among variables can be increased by the sequence of copy instructions which are generated by live-range splitting. The increased interference is called pseudo-interference. In this paper, we propose a new technique that can improve the performance of live-range splitting by eliminating pseudo-interference. The representation which means some copy instructions are concurrently executed is required for eliminating pseudo-interference. Therefore, we defined concurrent-copy instruction in intermediate representation and use it instead of the sequence of copy instructions. However, we must convert it into the sequence of machine codes that can obtain the same result as it after register allocation, because it can not be executed. The dependences which exist among the copy instructions must be paid attention at this conversion. In this way, the performance of liverange splitting can be improved. The codes generated by a compiler with our technique run an average of about 0.9% faster than the codes generated by a compiler without our technique in the SPEC benchmark.

Detecting design patterns from object-oriented program source-code can help maintainers understand the design of the program. However the detection precision of conventional approaches based on the structural aspects of patterns is low due to the fact that there are several patterns with the same structure. To solve this problem, we propose an approach of design pattern detection using source-code of before the application of the design pattern. Our approach is able to distinguish different design patterns with similar structures, and help maintainers understand the design of the program more accurately. Moreover our technique reveals when and where the target pattern has been applied in an ordered series of revisions of the target program. Our technique is useful to assess what kinds of patterns increase what kinds of quality characteristics such as the maintainability.

Java Script is a popular scripting language that is particularly useful for client-side programming together with HTML/XML on the Web. As Java Script programs become more complex and large, separation of concerns at the implementation level is a significant challenge. Aspect orientation has been a well known concept to realize improved separation; however, existing mechanisms require modifications in the target modules for aspect weaving in Java Script (i.e., not "complete" separation). In this paper, we propose an Aspect-Oriented Java Script framework, named "AOJS", which realizes the complete separation of aspects and other core modules in Java Script. AOJS can specify function executions, variable assignments and file initializations in Java Script programs as the joinpoints of aspects. Moreover, AOJS guarantees the complete separation of aspects and core program modules by adopting a proxy-based architecture for aspect weaving. By utilizing these features, we confirmed that AOJS offers improved modifiability and extendability for Java Script programming.

携帯端末で構成されるMANET では，通信データ量を低減させることで限られた無線帯域やバッテリの消費を抑えることが重要となる．通信データ量を低減させる手法として，通常MANET 外で行われるデータ処理をMANET 内部のノード上で実行するようなネットワーク内処理が有効であることが知られている．データ収集による通信データ量を低減させるためには，ネットワーク内処理を配備するノードを適切に選択する必要がある．複数のデータ源からMANET を介してデータを収集する場合，各データ源の配置や提供データ量の差異によって各ノードの通信データ量に偏りが生じる．しかし，従来のノード選択指標では，ノードの位置やネットワークトポロジのみに基づいているため，通信データ量の偏りを考慮に入れておらず，十分にデータ量を低減させることができるノードを選択できなかった．そこで，本論文では，データ源の情報に基づいたネットワーク内処理配備ノード選択指標COLOR を提案する．COLOR は，あるノードにネットワーク内処理を配備してデータ収集を行った場合に生じる総通信データ量の推定値を表し，COLOR が最小となるノードをネットワーク内処理の配備ノードとして選択する．COLOR は，データ通信量の各データ源の位置と提供データ量に基づいて算出される．これらのデータ源に関する情報は，ネットワーク内処理による通常のデータ収集時に同時に収集されるため，少量のオーバヘッドで算出することが可能となる．シミュレーション結果より，正方地域の4 隅にデータ源があり，1 つのデータ源が他のデータ源の4 倍のデータ量を有する場合，従来の指標を用いた場合と比べて，平均で7 割程度の通信データ量でデータを収集することを確認した．In-network processing is a powerful technique to reduce communication traffic in an ad-hoc network where energy efficiency is a critical issue. In the case that an in-network process retrieves data from multiple data sources, the node which hosts the in-network process should be carefully chosen to reduce the amount of necessary traffic. Conventional metrics to select a host node are insufficient in this case, because they do not consider differences in the amount of data provided by each data source. In this paper, we propose the COLOR metric to solve this problem. COLOR uses estimated locations of data sources and the amount of data which they provide so that a data source which provides more data than others has a stronger effect than the others. Moreover, overhead associated with COLOR is small, because meta-data of data sources used in COLOR can be retrieved during a data retrieval phase which in-network processing ordinarily does. Simulation results showed that data retrieval with COLOR consume less resources than that with conventional metrics in an environment where placements of data sources and the amount of data are nonuniform.

To develop usable software, it is necessary to develop Graphical User Interfaces (GUIs) in iterative steps, such as evaluating the usability of GUIs and improving GUIs. In improving GUIs, developers are often required to modify both the GUI and the logic code of the software. In our research, to facilitate GUI improvement, we propose a method of automatically searching for code to be modified and suggesting how to modify them. To search for appropriate code to be modified, we define the roles of widgets according to their purpose and the patterns for how to change GUIs. In our method, how to change GUIs is specified, and then the parts of source programs that are required to be modified are searched for. Also, we classify methods for each widget according to their functions. Using this classification, a method of modifying the code that is searched for is suggested.

プロダクトライン型ソフトウェア開発において，コアアセットの開発範囲を決定するスコープ定義は，プロダクトラインへの投資効果に影響を与える重要なタスクである．複数のプロダクトラインを有する企業は，スコープ定義の結果に基づき，投資先のプロダクトラインを適切に判断する必要がある．本稿では，コアアセットの範囲を計測するメトリクスである，カバー率と対応度を定義し，これらのメトリクスによりコアアセットのスコープを可視化する手法を提案する．本手法によりコアアセットのスコープと企業内の位置付けを明確にできる．Core asset scoping is an essential activity that provides economic impact on product line driven software development. In the enterprise that has several product lines, it is necessary to judge in which product line to invest appropriately by using the result of the scope definition. In this paper, we propose a core asset scoping method on the basis of two metrics:the levels of coverage and consistency of core assets. The method makes the scope of the core assets and the positioning of individual product lines in the enterprise visible.

Many complicated software packages make the operation difficult for end users. To acquire the skills for software operation, supporting end users to learn operating methods by themselves is effective. When in learning operating methods, it is important for end users to check the overview of the operating methods and their current step in the sequence of operations. On the basis of the overview and their current step, end users can consider how to operate the software to achieve their goal. For this purpose, we consider that "operation maps" are effective. Operation maps show the sequences of window switching in the software. Also, in operation maps, the window on currently focused is emphasized. This window can be considered as the current step of an end user. To realize operation maps easily, we propose a method of generating operation maps from the source programs of the software. In this paper, we describe how operation maps can be generated by extracting window information, such as the titles and widget types of windows, from source programs.

In a sensor network, the technique that limits the number of sensors used for observation is effective to reduce the energy consumption of each sensor. To limit the number of sensors without sacrificing observation accuracy, an appropriate sensor combination must be selected by evaluating the observation effectiveness of various combinations. However, the computational workload for evaluating all the sensor combinations is quite large. We can define a parameter related to the optimal size of a region around an observation target by making a trade-off between accuracy and the computational workload. In region-based sensor selection, a combination of sensors is selected from that is near the observation target. Accuracy is better in a larger region with a lot of sensors, but the computational workload is heavier. In contrast, a smaller region with fewer sensors has poorer accuracy, but a lighter workload. The size of the region controls the trade-off between accuracy and the computational workload. We define a parameter related to the optimal size of a region, and use it to dynamically adjust the region's size. Our simulations confirmed that region-based sensor selection reduces the computational workload and improves accuracy in comparison to existing techniques. © 2008 IEEE.

グラフ彩色法は，レジスタの多いアーキテクチャにおいては効果的である．なぜなら，スピルコードが出なかった場合，そのレジスタ割付けの結果は最適解だからである．しかし，このアルゴリズムには，レジスタの少ないアーキテクチャにおいて，特に長い処理時間がかかるという問題がある．なぜなら，このアルゴリズムは，干渉グラフが彩色可能になるまで，変数の生存区間分割による干渉グラフの再構築という全過程を繰り返すからである．そこで，我々は，エッジを重み付き双方向エッジにした干渉グラフを用いて，レジスタの少ないアーキテクチャにおける静的コンパイラ向けの，新しい高速なレジスタ割付け手法を提案する．我々の手法は，物理レジスタ数をK とすれば，仮想レジスタをK 色以上の色で塗り分ける．そして，グラフ変形のみでスピルコードを挿入することによりK 色まで色数を減らしている．このようにして，我々の手法は，高速なレジスタ割付けと，生成されたコード内のスピルコード削減を可能にしている．我々の手法を組み込んだコンパイラは，GNU Cコンパイラバージョン3.4.4（gcc-3.4.4）よりも約8%高速であった．また，スタンフォードベンチマークにおいて，我々のコンパイラが生成したコードは，gcc-3.4.4の生成したコードより，約5%高速であった．Graph coloring is effective for architectures with a large number of registers, because the results of register allocation are optimal if there is no spill code. However, this algorithm has a problem that it particularly takes long time in register allocation for architectures with a small number of registers, because the algorithm iterates the entire process that an interference graph must be rebuilt by spilling live range of a variable until the graph becomes colorable. Thus, we propose a new faster register allocation algorithm in a static compiler for architectures with a small number of registers by using an interference graph with weighted bidirectional edges. Our method applies colors of more than K-colors to virtual registers if K is the numbers of physical registers. Then the number of colors is reduced to K-colors by insertion of spill codes with only transformation of the graph. Thus, our method enables to allocate registers fast and to reduce spill codes in generated codes. A compiler that our method is applied to runs about 8% faster than GNU C Compiler version 3.4.4 (gcc-3.4.4).Also, the codes generated by our compiler run about 5% faster than the codes generated by gcc-3.4.4 in the Stanford Benchmark.

Computers and software are now widely used in human society. With their dissemination, it becomes necessary for disabled and elderly people to use software. However, it is difficult to develop accessible software for them. Also, there are many guidelines and support tools for developing accessible web sites. However, for software, such guidelines and support tools are few. In our research, to develop accessible software easily, we propose a method of evaluating the accessibility of Graphical User Interface (GUI) software. In our method, source programs of GUI software are analyzed, the accessibility of the GUI software is evaluated along with the accessibility guidelines, and the list of unsatisfactory codes for accessibility and indications on how to modify them are shown.

In component-based software development, it is necessary to measure the quality of components before they are built into the system in order to ensure the high quality of the entire system. However, in application development with component reuse, it is difficult to use conventional metrics because the source codes of components cannot be obtained, and these metrics require analysis of source codes. Moreover, conventional techniques do not cover the whole of quality characteristics. In this paper, we propose a suite of metrics for measuring quality of JavaBeans components based on limited information that can be obtained from the outside of components without any source codes. Our suite consists of 21 metrics, which are associated with quality characteristics based on the ISO9126 quality model. Our suite utilizes the qualitative evaluation data available on WWW to empirically identify effective metrics, and to derive a reference value (threshold) for each metric. As a result of evaluation experiments, it is found our suite can be used to effectively identify black-box components with high quality. Moreover we confirmed that our suite can form a systematic framework for component quality metrics that includes conventional metrics and newly defined metrics.

Multi-agent systems need protocols to coordinate among agents implemented by different owners. However specifying coordination protocols for many participating agents is a complex task. A protocol composition approach, which can reduce the complexity of specifying such a coordination protocol, must specify how to compose coordination protocols in a composition configuration. Current protocol compositions cannot sufficiently reduce the complexity because composing a protocol several times requires the specification of too many configurations. We propose a protocol composition approach that can specify composition configurations in an abstract way. We assign metadata to the messages in a coordination protocol and use the metadata to specify the configuration. An abstract configuration using metadata can be applied to various protocol compositions and can reduce the number of specifications required for configuration composition.

Patterns combine experience and good practices to develop basic models that can be used for new designs. Security patterns join the extensive knowledge accumulated about security with the structure provided by patterns to provide guidelines for secure system design and evaluation. In addition to their value for new system design, security patterns are useful to evaluate existing systems. They are also useful to compare security standards and to verify that products comply with some standard. A variety of security patterns has been developed for the construction of secure systems and catalogs of them are appearing. However, catalogs of patterns are not enough because the designer does not know when and where to apply them, especially in a large complex system. We discuss here several ways to classify patterns. We show a way to use these classifications through pattern diagrams where a designer can navigate to perform her pattern selection.

In e-Business, agents need to coordinate with each other Coordination protocols that specify the defining orders of message passing are very important. The scale of e-Business grows with the advancement of technology, and the number of agents involved continues to increase. Specifying the coordination protocols for so many participating agents is a complex task. A coordination protocol composition approach reduces the complexity of specifying such a coordination protocol. It treats coordination protocols as individual parts and composes them to construct the intended protocols. However existing approaches do not sufficiently reduce the complexity when a coordination protocol is composed several times, because too many configurations are required to specify a composition. A new approach is proposed that uses metadata to specify the compositions by specifying only one configuration. It can reduce the number of configurations when a coordination protocol is composed several times.

グラフ彩色法はレジスタ割付けの代表的な手法であるが，冗長なスピルが発生しやすいという欠点があった．この冗長なスピルの発生を抑えるために，生存区間分割という手法が提案されている．しかし，従来の手法では生存区間分割を行った際に余計な干渉が発生し，最適なレジスタ割付けを妨害してしまう場合があった．本論文では，同時コピー中間コードを定義して利用することで余計な干渉の発生を回避し，最適なレジスタ割付けを可能にする生存区間分割手法を提案する．実験の結果，本手法を実装したコンパイラは，本手法未実装のコンパイラに対して最大６％程度実行速度が速いコードを出力可能なことが確認できた．Graph coloring is a typical technique of register allocation. But it has a problem to generate redundant spill codes easily. To solve this problem, some techniques of live-range splitting have been proposed. However, previous techniques generate pseudo-interference that disturb optimal register allocation. We propose a new technique of live-range splitting that can avoid to generate pseudo-interference by defining and using concurrent-copy intermediate code in this paper. Our experimental results have shown that our technique improves the performance of a compiler by maximum of about 6%.

Wireless sensor networks (WSNs) have attracted attention in recent years. Many sensors will be equipped in buildings and provide data about the context of buildings in the future. We can provide many kinds of services that use various context information acquired from wireless sensor networks. However, sensing programs may not be able to be executed concurrently on the same sensor node because of sensors' resource restrictions. So, sensing programs sometimes have to relocate to other sensors if necessary. In this paper, we suggest a middleware for the relocation of a sensing program. Considering severe resource restrictions in a wireless sensor network, we can make a sensing program with a small code footprint. © 2006 IEEE.

Prolonging a network lifetime is one of crucial issues of message routing protocol in mobile ad-hoc networks (MANETs), because MANETs consist of mobile devices powered by batteries. Previous routing protocols focus on route selection by a message sender to balance message forwarding load. However, in this approach, message routes determined by different senders cannot be coordinated, because each sender selects its message route independently. In this paper, we propose an auction-based route allocation scheme where message routes are determined by auctions between message senders and forwarders, and apply the route allocation scheme to the Dynamic Source Routing protocol. Simulation results show the DSR protocol with our allocation scheme can prolong the network lifetime comparing with the routing protocol proposed in the previous works. © 2006 IEEE.

ソフトウェアの多機能化に伴って,その操作方法は複雑化している.そのため,ユーザに対してソフトウェアの操作方法を簡単,効果的に学習させるための支援が必要となってきている.チュートリアルシステムは,実際のソフトウェア上で操作を実演することにより,ユーザに操作方法を学習させるシステムであり,高い有用性を持つ.しかしながら,チュートリアルシステムを新たに作成するためには大きな労力が必要となり,時間的制約や金銭的制約などの点から困難であることが多い.本手法では,ユースケース図,シーケンス図,テストデータを基にして,チュートリアルシステムを生成し,ソフトウェアに付加することを目的とする.具体的には,ユースケース図から抽出した機能名,シーケンス図から抽出した操作情報,テストデータから抽出した入力文字列および選択内容,の各情報を利用する.本論文では,本手法によりチュートリアルシステムを作成するために必要となる労力と,チュートリアルシステムの操作の再現性を評価した.Recent complicated software functions have made it difficult for end users to operate them. Thus, it becomes important to learn how to operate them easily and effectively. Employing a tutorial system is the most suitable approach for learning how to operate software functions. A tutorial system demonstrates how to operate using the actual software. However, development of tutorial systems requires much time and costs. Therefore, we propose a method of generating tutorial systems based on use case diagrams, sequence diagrams and test cases. In our method, a generated tutorial system shows fumction names extracted from use case diagrams, how to operate along with sequence diagrams, and text string input and item selection using data from test cases. We evaluate the burden placed on developers by the requirement of generating tutorial systems and whether the tutorial system generated by our method performs software operation correctly.

To develop usable software, it is necessary to develop GUIs in iterative steps, such as evaluating usability of GUIs and improving GUIs. In improving GUIs, developers are often required to modify not only GUI codes but also logic codes of the software. In our research, to make GUI improvement easy, we propose a method for automatically searching for modification codes which developers are required to modify and suggesting how to modify them. To search for more appropriate modification codes, we define roles of widgets according to purposes of usages and patterns for how to change GUIs.

Continuing optimal product line development needs to evolve core assets in response to market, technology or organization changes. In this paper, we propose a product line evolution method based on the kaizen approach. Kaizen is a continuous improvement method that is adopted in Japanese industry. The important points of the kaizen are to prepare a work standard and continue to improve processes by correcting the differences between the standard and actual results. Our core asset kaizen method provides a standard that includes core asset types based on simple metrics, kaizen patterns representing expertise, and kaizen processes for continuous improvement.

Middleware for wireless sensor network (WSN) abstracts a network as an entity and hides programming difficulties from programmers. Many middlewares have been proposed, but they use different programming languages to manipulate functions in WSNs. This inhibits usability when manipulating multiple WSNs managed by different middlewares, because the primitives of each language have different descriptive capabilities. In this paper, we propose and apply design patterns in WSN programming to complement the capabilities of language primitives, and discuss the effectiveness of these design patterns. First, we discuss major middleware languages and compare the capabilities of their primitives. Second, we extract design patterns from the representative middlewares to cover the missing capabilities identified in the comparison. Finally, we discuss the effectiveness of design patterns for WSN programming. The discussion indicates that design patterns improve the usability of manipulating multiple WSNs.

The abstraction level of the problem treated by a design pattern has wide variety, from architecture to near implementation. There is no objective metric indicating the abstraction level of the problems addressed by patterns. Thus, it is difficult to understand the abstraction level of each pattern and to position a new pattern. In this paper, a metric is proposed. It indicates the relative abstraction level of a pattern's problem. We propose a metric obtained from inter-pattern relationships. We also propose a visualization method for the metric. Using such metrics, we aim to help developers easily understand the abstraction level of each pattern and, therefore, to better decide about its usefulness for the problem at hand. © 2007 Copyright is held by the authors.

モバイルアドホックネットワーク上において,省電力性を考慮した位置依存情報収集手法を提案する.遠距離の情報収集地域に関する位置依存情報を収集する場合,従来のように情報収集者端末から,情報収集地域内の端未群と通信しデータを収集するアプローチでは,使用するネットワーク経路が長くなるため,通信による総消費電力量は大きくなる.データ解析プログラムを情報収集地域内の端末に配備し,近距離でデータ収集させ,必要な解析結果だけを取得することで,帯域使用量を節約し,総消費電力量が低減できることが期待できる.しかし,すべての端末は独立的に移動しているため,データ解析プログラムを配備した端末が情報収集地域から離れると,データ収集コストが増大する.データ解析プログラムを処理状態とともに情報収集地域内の他の端末に配備し,データ解析を引き継がせることにより,データ収集コストの増大を防ぐことができるが,一方で,データ解析プログラムの再配備による総消費電力量が増大してしまう.本論文では,データ収集コストと再配備コストのトレードオフを考慮した,データ解析プログラムの再配備手法を提案する.本手法を用いることにより,遠距離地域の位置依存情報を少ない消費電力で収集することが可能となる.

ソフトウェアパターンとは、ソフトウェア開発において頻出する問題と問題が発生する状況、解法の選択にかかる制約条件、および、具体的な解法の組である。パターンを用いることで熟練技術者の持つ知識やノウハウの共有や再利用を促進することができる。パターンの有機的な利用にはパターン間関連の分析が重要であるが、人手による網羅的なパターン間関連の分析は困難である。本稿では、自然言語処理技術を用いて、ソフトウェアパターン間の関連を自動的に抽出する手法を提案する。本手法を用いることで、人手による分析よりも多数のパターンについて、網羅的な関連分析が可能になる。By using software patterns, developers can reuse knowledge obtained from experts' empirical rule. Analysis of Inter-pattern relationships is important, but analysis by human costs a lot. In this paper, we propose an automated inter-pattern relationship analysis method. Our method includes a pattern model and two inter-pattern relationship models, and uses several natural language processing techniques such as TF-IDF weighting.

多種のシステムを低コストで短期間に開発しなければならない組込みソフトウェアなどの分野でもモデル検査手法のような設計検証技術が容易に使えるようになることに期待が高まっている.時間制約のあるシステムでは,動的な挙動をシーケンスチャートで定義し,ステートチャートでプロセスの静的な挙動を定義することが多い.性能モデル検査はプロセス毎のステートチャートと同等の時間オートマトンで定義された挙動を検証するものであるが検証したい性質を時相論理式で与える点が,設計者にとって利用の敷居を高くしている理由の1つである.本稿では,モデル検査ツールUPPAALを対象として,シーケンスチャートから検証したい性質を表現するオブザーバを機械的に生成する手法を提案し,通信プロトコルのアプリケーションに適用してオーバーヘッドの評価を行った.

A component connection enables a component to use the functionality of other components directly, without generating adapters or other mechanisms at run-time. In conventional component connection models, the connection between components, particularly third-party components, is very costly for code reuse because the component source code must be modified if the types of requester-side and provider-side are different. This paper proposes a new component model, built upon an existing component architecture, which abandons a component service type and connects components based on a method type collection of the provider and requester components. Our model enables flexible connections owing to relaxed component matching, in which the system that implements our model automatically converts values of parameters, return values, and exceptions between required methods and provided ones within a well-defined range. As a result of experimental evaluations, it is found that our model is superior to conventional models in terms of the component-use cost and the capability of changing connections.

多種のシステムを低コストで短期間に開発しなければならない組込みソフトウェアなどの分野でも、ソフトウェアの大規模化が進む一方で大量販売により出荷後の不具合修正コストは大きく、モデル検査手法のような設計検証の自動化技術がより容易に使えるようになることに期待が高まっている。設計者にとってモデル検査の敷居が高い理由のひとつは、検証したい性質を時相論理式で与える点がある。本稿では、モデル検査ツールUPPAALを対象として、シーケンスチャートから検証したい性質を表現するオブザーバを機械的に生成する手法を提案する。注目するシーケンスに対応する可能性のある挙動の完全な監視と、注目しない事象の透明化を特徴とする。また、本手法を通信プロトコルのアプリケーションに適用してオーバーヘッドの評価を行った。In the software field of mass products such as embedded systems, an error cause high correction cost after shipping. But many kinds of systems must be developed in a short term and low-cost. Then it may be impossible comprehensive design review by human resources. So model checking that is one of automatic design verification techniques is expected to be easy to use for software designer. In this paper, a method generating a observer for the model checking tool UPPAAL from a sequence chart, which is usually made by designers, is proposed. Also it is reported the result of applying this method to a communication systems.

近年、コンピュータおよびネットワークは世界的に広く普及し、社会生活を送るのための重要な役割をもちつつある。それに伴い、障害を持った人々にとってもコンピュータ利用の必要性は大きくなってきている。しかしコンピュータのソフトウェアは必ずしも、障害を持つ人にとっても利用可能なものになっておらず、それらの人々を考慮して構築する事が急務である。また、ガイドラインや支援ツールが豊富なWebサイトに比べ、ソフトウェアの方は対応が遅れている。そこで本研究ではJavaで書かれたGUIのプログラムのソースコードを解析し、障害者や高齢者にとって問題となる部分をガイドラインに基づいて見つけ出すためのチェックツールについて提案する。

When a software component is used, it is often necessary to set initial values in many of its attributes. To set these initial values appropriately, the user of the component must ascertain which attributes are needed to be initialized, and set them programmatically to suitable initial values. The work involved in this sort of initialization can be alleviated by attaching a wizard interface to the target component itself and setting the initial values visually from the wizard. However, there are large development costs associated with devising suitable initial value candidates and producing a new wizard to use these initial values for each individual component. In this paper, we propose a system whereby application programs that use a target component are subjected to dynamic analysis to discover which attributes and initial values are set most often during the running of the component. The proposed system generates and attaches a wizard, which supports application programmers to initialize the component visually by using these initial values, to the component. The proposed system can be recognized as a system for applying the Wizard pattern to each component automatically. Experiments have shown that the attributes and their initial values chosen for initialization by generated wizards closely resemble the expectations of the component's original developers. We have thus confirmed that the proposed system can bring about a substantial reduction in wizard development costs.

Recently, the expansion of the range of users has led to the increase in the importance of software usability. To realize usable software, it is efficient to repeat the process of evaluating and improving GUIs. In this process, it is often necessary to replace the GUI widgets. In this case, we have to change the connection between GUI codes and logic codes. However, it is difficult for developers to find and modify the codes to be changed in the source code. In this research, we propose a method of finding the modification codes in the source code automatically and of suggesting instructions on developers how to modify them.

Social insects perform complex tasks without top-down-style control, by sensing and depositing chemical markers called "pheromone". We have examined applications of this pheromone paradigm towards realizing intelligent transportation systems (ITS). Many of the current traffic management approaches require central processing with the usual risks of overload, bottlenecks and delay. Our work points towards a more decentralized approach that may overcome those risks. We use new category of the ITS infrastructure called the probe-car system. The probe-car system is an emerging data collection method, in which a number of vehicles are used as moving sensors to detect actual traffic situations. In this paper, a car is regarded as a social insect that deposits multi-semantics of (digital) pheromone on the basis of sensed traffic information. We have developed a basic model for predicting traffic congestion in the immediate future using pheromone. In the course of our experimentation, we have identified the need to properly tune the model to achieve acceptable performance. Therefore, we refined the model for practical use. We evaluate our method using real-world traffic data and results indicate applicability to prediction. Furthermore, we describe the practical implications of this method in the real world. Copyright 2006 ACM.

Recent complicated software functions have made it difficult for end users to operate them. Thus, it becomes important to learn how to operate them easily and effectively. Employing a tutorial system is the most suitable approach for learning how to operate software functions. A tutorial system demonstrates the how to operate using the actual software. As a result, end users can learn the usage as if they were actually using the software. However, development of tutorial systems requires much time and costs. Therefore, we propose a method of generating tutorial systems based on use case diagrams, sequence diagrams and test cases. In our method, a generated tutorial system shows function names extracted from use case diagrams, the how to operate along with sequence diagrams, and text string input and item selection using data from test cases. The generated tutorial system is then added to the source code for use in AOP (aspect-oriented programming).

With the spread of mobile phones, the use of Mobile Adhoc NETworks (MANETs) for disaster recovery finally becomes feasible. Information retrieval from the catastrophic place is attended in an energy-efficient manner using the Geographically Bound Mobile Agent (GBMA) model. The GBMA, which is a mobile agent on MANETs that retrieves geographically bound data, migrates to remain in a designated region to maintain low energy consumption for data retrieval, and provides location based migration scheme to eliminate needless migration to reduce energy consumption. In the data retrieval using the GBMA model, survivability of the agent is important. In a MANET, a GBMA with retrieved data may be lost due to its host's death. The lost of the agent causes re-execution of the retrieval process, which depraves energy efficiency. We propose migration strategies of the GBMA to improve its survivability. In the migration strategies, the selection of the next host node is parameterized by node location, speed, connectivity, and battery level. Moreover, in the strategies, multiple migration trigger policies are defined to escape from a dying node. We present the implementation of migration strategies and confirm the achievements with several simulations. This finally leads to the adaptive Geographically Bound Mobile Agent model, which consumes even less energy.

In general, a component-based system uses only a part of the functions of its software components. Therefore, precise structural testing for components requires to specify what functions of the components are used in the system. In addition, in the case with an object-oriented component, some existing studies point out that testing of all possible bindings between a call site and the methods that the site may invoke is extremely ineffective. In this paper, we propose a method for precisely estimating test coverage of components on an object-oriented frame work by using its deployment descriptor and evaluate its effectiveness.

Remote-component-based software systems (CBS) must provide high maintainability to support operation over long periods of time and correspond to changes in enterprise requirements/environments. Measurements of the degree of complexity of a system are one technique for evaluating maintainability. However, conventional complexity metrics are unable to reflect the overall complexity of the system, because they do not incorporate a procedure to account for characteristics of CBS. To help maintenance work proceed smoothly, we propose a new metric that measures the coupling-based complexity of CBS by abstracting the target system's structure through a step-wise process and taking into consideration the characteristics of remote components. Our metric can be applied to CBS based on the Enterprise JavaBeans component architecture. As a result of experimental evaluations, it is found that our metric better reflects the maintainability than conventional metrics. It is also found that our metric is nonredundant with existing metrics such as Coupling Factor.

Component-based software development (CBD) is based on building software systems from previously-existing software components. In CBD, reuse of common parts in component form can reduce the development cost of new systems, and reduce the maintenance cost associated with the support of these systems. However, existing programs have usually been built using another paradigm, such as the object-oriented (00) paradigm. 00 programs cannot be reused rapidly or effectively in the CBD paradigm even if they contain reusable functions. In this paper, we propose a technique for extracting components from existing 00 programs by our new refactoring "Extract Component". Our technique of refactoring can identify and extract reusable components composed of classes from 00 programs, and modify the surrounding parts of extracted components in original programs. We have developed a system that performs our refactoring automatically and extracts Java-Beans components from Java programs. As a result of evaluation experiments, it is found that our system is useful for extracting reusable components along with usage examples from Java programs. (c) 2004 Elsevier B.V. All rights reserved.

コンポーネントは, 組み込まれるシステムによって, その機能の利用範囲が異なる. よって, 構造テストによりコンポーネントに対する品質を評価する場合, その利用範囲を特定しなければ, 正しい品質指標を算出できない. また, オブジェクト指向言語で実装されたコンポーネントの場合, その多態的な振舞いを全網羅する構造テストは, 非効率であることが指摘されている. この解決のため, 本提案では, オブジェクト指向フレームワークを基盤としたシステムにおける配置記述にコンポーネント間の呼び出し関係を特定する記述があることに注目した. 本稿では, 配置記述を用い, テストすべきコンポーネントの機能を特定し, 精度の高い品質指標を算出する方式について示す.

In software development, many kinds of knowledge are shared and reused as software patterns. However the relation analysis among software patterns by hand is difficult on the large scale. In this paper we propose a technique for the automatic relation analysis among the patterns. Our technique is based on a new pattern model to treat various patterns, and utilizes exiting text processing techniques to extract patterns from documents and to calculate the strength of pattern relations. As a result of experiments, the system that implements our technique has extracted appropriate relations among patterns without information on relations described in original pattern documents. Moreover our system has the ability to suggest relations among patterns that the author has not noticed.

本稿では，命令レベル並列プロセッサを対象としたレジスタ割付けとコードスケジューリング技法を提案する．我々は，命令レベル並列性（ILP: Instruction Level Parallelism）を抽出する手法として，ガード付きプログラム依存グラフ（Guarded Program Dependence Graph）から生成されるレジスタ生存グラフを用いた手法を提案してきた．この手法は，レジスタアロケータとコードスケジューラの協調動作を考慮した手法の1 つであり，これまでの手法では抽出するのが困難な，高いILP を抽出できるという特徴を持っている．しかし，この手法は，プログラム中の変数の値を表す仮想レジスタどうしの生存区間の干渉を，プロセッサの並列度を考慮せずにレジスタ数以下に低減しているため，資源割付け時にレジスタ不足が起きる可能性があるという問題があった．このため，不必要なnop 命令や，レジスタの値をメモリに退避するスピルコードが挿入されてしまい，性能が低下してしまうことがあった．そこで，本手法ではプレスケジューリングを導入することにより，さらなるILP の抽出を図るとともに，コード割付け時のレジスタ不足問題を解決する．SPECint2000 の中から，特徴的なループを持つプログラムの最内ループに対して本手法を適用したところ，実行サイクル数において従来手法より平均8%の性能向上が見られた．We propose a register allocation and a code scheduling technique for instruction level parallel processors. We have suggested a method using Register Existence Graph generated from Guarded Program Dependence Graph in order to extract instruction level parallelism (ILP) in a program. This method is one of the methods considering both of the register allocation and the code scheduling, and can extract higher ILP compared to the previous methods. However, this method has a possibility of register shortage at the resource allocation phase because it reduces the interference among values in the live variables as if the processor has an infinite number of execution units, and therefore, unnecessary NOP instructions or spill instructions that move register values to and from memory are inserted at the resource allocation phase. In this paper, we introduce a method using pre-scheduling in order to extract higher ILP and avoid the above mentioned register shortage. The performance of this method is about 8% better than that of a previous method when applying it to some loop-intensive programs in the SPECint2000 benchmarks.

In software development, many kinds of knowledge are shared and reused as software patterns. However the relation analysis among software patterns by hand is difficult on the large scale. In this paper we propose a technique for the automatic relation analysis among the patterns. Our technique is based on a new pattern model to treat various patterns, and utilizes exiting text processing techniques to extract patterns from documents and to calculate the strength of pattern relations. As a result of experiments, the system that implements our technique has extracted appropriate relations among patterns without information on relations described in original pattern documents. Moreover our system has the ability to suggest relations among patterns that the author has not noticed.

The activity of the software process improvement can be supported by reusing various kinds of knowledge on existing successful software processes in the form of process patterns. There are several catalogs of process patterns available on WWW; however, all of relations among patterns are closed in each pattern catalog. To acquire the cross-cutting relations over the different process pattern catalogs, we have applied the technique for the automatic relation analysis among the patterns. Our technique utilizes existing text processing techniques to extract patterns from documents and to calculate the strength of pattern relations. As a result of experimental evaluations, it is found that the system implementing our technique has extracted appropriate cross-cutting relations over the different process pattern catalogs without information on relations described in original pattern documents. These cross-cutting relations will be useful for dealing with larger problems than those dealt with by individual process patterns.

Social insects perform complex tasks without top-down style control, by sensing and depositing chemical markers called "pheromone" We have examined applications of this pheromone paradigm towards intelligent transportation systems (ITS). Many of the current traffic management approaches require central processing with the usual risk for overload, bottlenecks and delays. Our work points towards a more decentralized approach that may overcome those risks. In this paper, a car is regarded as a social insect that deposits (electronic) pheromone on the road network. The pheromone represents density of traffic. We propose a method to predict traffic congestion of the immediate future through a pheromone mechanism without resorting to the use of a traffic control center. We evaluate our method using a simulation based on real-world traffic data and the results indicate applicability to prediction of immediate future traffic congestion. Furthermore, we describe the relationship between pheromone parameters and accuracy of prediction.

A location-specific data retrieval, which is data retrieval from nodes in a designated region at the time, is an attractive application in a Mobile Ad-hon Network (MANET). However, almost all nodes in a MANET are powered by batteries, the location-specific data retrieval should involve a small number of messages. In this paper, we use a mobile agent to retrieve the location-specific data. A mobile agent migrates to a node in a designated region, and retrieves data from nodes in this region. Since, after migration, the agent can communicate with nodes in the designated region through low overhead short length hops, the mobile agent can retrieve data at low message cost for long periods, even if the owner of this agent moves around. However, even after migrating to node in the designated region, in order to stay near this region, a mobile agent should migrate to other nodes in response to the movement of the node hosting this agent. In this paper, we propose the Geographically Bound Mobile Agent (GBMA) which is a mobile agent that periodically migrates in order to always be located in a designated region. In order to clarify where the GBMA should be located and when the GBMA starts to migrate, two geographic zones are set to the GBMA: required zone and expected zone. The required zone ease tracking of the GBMA, and the expected zone ease adjustment of the GBMA migration timing.

Location-specific data retrieval is an attractive application in a Mobile Ad-hoc Network (MANET). Simple solution for it is that an observer retrieves the data by geocasting from an observer node, but its overhead highly depends on location of the observer and the designated region. We propose a mobile agent approach. A mobile agent migrates from the observer node to a node in the designated region, retrieves data from there, and summarizes, filters, and compresses the retrieved data, This data is sent back to the observer, when the observer request. Since the data is retrieved by the mobile agent located near the data Sources, the data retrieval in the mobile agent approach would involve low overhead, even if the observer is far from the target region or moves around. In the MANET, however, even after the first migration; to stay near data Sources, a mobile agent should migrate to another node in response to node movements.. In this paper, we propose the Geographically Bound Mobile Agent (GBMA) which is a mobile agent that migrates to always be located in a designated region. Moreover, to clarify where the GBMA should be located and when the GBMA starts to migrate, we introduce two geographic zones: required zone and expected zone, Compared with the conventional methods with geocast or with a conventional mobile agent, the GBMA with these zones for retrieving location-specific data can reduce the total number of messages.

Model 2アーキテクチャに基づくWebアプリケーションは、MVCパターンに基づいた3つのコンポーネント間の関係を考慮して開発しなければならない。本研究は、各コンポーネント間の関係を仕様として定義することで、Webアプリケーションの変更・拡張を支援する。開発対象のWebアプリケーションに対し部分的な仕様の記述を許可することで、短い期間の開発であっても部分的に支援を可能とすることを目指す。