The Computer Science industry suffers from a vivid gender gap. To understand this gap, Computational Thinking skills in Computer Science education are analyzed by binary gender roles using block-based programming languages such as Scratch since they are intuitive for beginners. Platforms such as Dr. Scratch, aid learners in improving their coding skills by earning a Computational Thinking score while supporting effective assessments of students' projects and fostering basic computer programming. Although previous studies have examined gender differences using Scratch programs, few have analyzed the Scratch project type's impact on the evaluation process when comparing genders. Herein, the influence of project type is analyzed using instances of 124 (62 male, 62 female) projects on the Scratch website. Initially, projects were categorized based on the user's gender and project type. Hypothetical testing of each case shows that the scoring system has a bias based on the project type. As gender differences appear by project type, the project type may significantly affect the gender gap in Computational Thinking scores. This study demonstrates the importance of incorporating the project type's effect into the Scratch projects' evaluation process when assessing gender differences.

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.

Online judges are often used in programming education for beginners. Although they help improve coding skills, students may not obtain sufficient educational effects with much assignment difficulty. Instead of presenting a model answer to an assignment, we propose an approach to provide students contents of problems and answer source code similar to the assignment. We implemented the approach as a system and conducted an intervention experiment in a university lecture course to evaluate its effectiveness. There was a statistically significant improvement in the number of correct answers compared to the same course in another year without the proposed system. Therefore, it is suggested that the proposed approach can aid in the understanding of an assignment and improve the educational effect.

The digital transformation of society and universities has been accelerating in the COVID-19 pandemic. The digital transformation of education will advance beyond distance and time by utilizing digital technology and develop international and industry-university collaboration. The Japanese Society for Engineering Education initiated a survey and research committee in April 2021. First, the direction of the digital transformation of engineering education will be presented through a multifaceted survey of social needs, information technology, international collaboration, and industry-academia-government collaboration. Secondly, as an advanced model, the realization of graduate and recurrent education in international inter-university and industry-academia collaboration is investigated. This paper is an interim report.

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.

For effective vulnerability management, vulnerability and attack information must be collected quickly and efficiently. A security knowledge repository can collect such information. The Common Vulnerabilities and Exposures (CVE) provides known vulnerabilities of products, while the Common Attack Pattern Enumeration and Classification (CAPEC) stores attack patterns, which are descriptions of common attributes and approaches employed by adversaries to exploit known weaknesses. Due to the fact that the information in these two repositories are not linked, identifying related CAPEC attack information from CVE vulnerability information is challenging. Currently, the related CAPEC-ID can be traced from the CVE-ID using Common Weakness Enumeration (CWE) in some but not all cases. Here, we propose a method to automatically trace the related CAPEC-IDs from CVE-ID using three similarity measures: TF–IDF, Universal Sentence Encoder (USE), and Sentence-BERT (SBERT). We prepared and used 58 CVE-IDs as test input data. Then, we tested whether we could trace CAPEC-IDs related to each of the 58 CVE-IDs. Additionally, we experimentally confirm that TF–IDF is the best similarity measure, as it traced 48 of the 58 CVE-IDs to the related CAPEC-ID.

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.

In evaluating the learning achievement of programming-thinking skills, the method of using a rubric that describes evaluation items and evaluation stages is widely employed. However, few studies have evaluated the reliability, validity, and consistency of the rubrics themselves. In this study, we introduced a statistical method for evaluating the characteristics of rubrics using the goal question metric (GQM) method. Furthermore, we proposed a method for measuring four evaluation results and characteristics obtained from rubrics developed using this statistical method. Moreover, we showed and confirmed the consistency and validity of the statistical method using the GQM method of the resulting developed rubrics. We show how to verify the consistency and validity of the rubric using the GQM method.</p>

Business-to-Business (B-to-B) software development companies develop services to satisfy their customers’ requirements. Developers should prioritize customer satisfaction because customers greatly influence agile software development. However, satisfying current customer’s requirements may not fulfill actual users or future customers’ requirements because customers’ requirements are not always derived from actual users. To reconcile these differences, developers should identify conflicts in their strategic plan. This plan should consider current commitments to end users and their intentions as well as employ a data-driven approach to adapt to rapid market changes. A persona models an end user representation in human-centered design. Although previous works have applied personas to software development and proposed data-driven software engineering frameworks with gap analysis between the effectiveness of commitments and expectations, the significance of developers’ commitment and quantitative decision-making are not considered. Developers often do not achieve their business goal due to conflicts. Hence, the target of commitments should be validated. To address these issues, we propose Data-Driven Persona Retrospective (DDR) to help developers plan future releases. DDR, which includes the Persona Significance Index (PerSI) to reflect developers’ commitments to end users’ personas, helps developers identify a gap between developers’ commitments to personas and expectations. In addition, DDR identifies release situations with conflicts based on PerSI. Specifically, we define four release cases, which include different situations and issues, and provide a method to determine the release case based on PerSI. Then we validate the release cases and their determinations through a case study involving a Japanese cloud application and discuss the effectiveness of DDR.

Security and privacy in cloud systems are critical. To address security and privacy concerns, many security patterns, privacy patterns, and non-pattern-based knowledge have been reported. However, knowing which pattern or combination of patterns to use in a specific scenario is challenging due to the sheer volume of options and the layered cloud stack. To deal with security and privacy in cloud services, this study proposes the cloud security and privacy metamodel (CSPM). CSPM uses a consistent approach to classify and handle existing security and privacy patterns. In addition, CSPM is used to develop a security and privacy awareness process to develop cloud systems. The effectiveness and practicality of CSPM is demonstrated via several case studies.

In this study, we evaluated the abilities elementary school students can cultivate through education using programming. We focused on using programming in subject education, e.g., arithmetic and science. The effect of programming education in computer science has been reported extensively; however, it is unclear what abilities utilization of programming in may cultivate in other subjects. Therefore, in this study, we created a rubric to evaluate programming thinking skills. The rubric was applied to actual elementary school math and science classes for evaluation. As a result, in mathematics, the ability to analyze events improved, and, in science, the ability to branch improved. In this paper, we present the rubric and corresponding evaluation results.

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.

Security patterns encapsulate security-related problems and solutions that recur in certain contexts for secure software system development and operations. Almost 500 security patterns have been proposed since the late 1990s. Technical investigations on their applications have advanced implementation, but the direction, overall picture, and significant technical challenges remain unclear. In this study, we propose a taxonomy for security pattern research by conducting a systematic literature review. Over 200 papers are categorized based on the taxonomy. The taxonomy is expected to guide practitioners to choose existing security pattern methods and tools. In addition, the taxonomy and the survey results should support communications among practitioners and researchers, and improve the quality of security pattern research and the effectiveness of security patterns.

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.

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.

学生奨励賞

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.

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.

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.

Crawling JavaScript heavy Rich Internet Applications has been a hot topic in recent years, giving us automated tools for indexing content, test generation, and security- and accessibility evaluation to mention a few examples. However, existing crawling techniques 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 finding and exercising mouse, keyboard, and touch interactions when crawling highly interactive JavaScript-based websites 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 RIA's, we find that the technique discovers many states and transitions resulting from such interactions. Our findings indicate the technique could be useful for automatic test generation, error discovery, and accessibility evaluation, especially for mobile web applications with advanced interaction options.

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.

In this paper, we report two case studies of applying aspect-oriented programming for achieving high performance and low energy consumption while keeping or improving maintainability: multi-threading existing unit test framework (JUnit) to reduce testing time on multi-core processing environments, and, adding and changing hardware control strategies and algorithms to reduce energy consumption while controlling robotics.

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.

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.

Accessibility guidelines provide methods to make Web sites accessible for handicapped people using assistive technology. However, guidelines have large contents, therefore great cost and efforts are required to apply guidelines to Web contents. In our research, we propose a method for automatically evaluating accessibility of Rich Internet Application, especially MA using JavaScript. Using our method, it is easy to reduce developers' efforts and cost to apply guidelines to Web sites.

We applied the technique of network analysis to collection site Portland Pattern Repository (henceforth, PPR) of the software pattern, and centrality was calculated. And the feature of the relation between software patterns was clarified. Moreover, metrics analysis was conducted about the history information of each software pattern. As a result, The degree centrality of the frequently-used software pattern was high value. This is useful to select a software pattern and the extraction of a new software pattern.

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.

卒業論文認定

Bug localization technique is effectual approach for locating software bugs using the number of failing and passing test cases that execute the statement. However, existing bug localization tools only support one type of programming languages and one type of suspiciousness metrics. In this paper, We presents customizable bug localization framework supporting multiple programming languages and multiple suspiciousness metrics. By apply each suspiciousness metrics to multiple programming languages and comparing, we show the availability of our proposed.

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.

As traceability is a factor in software maintainability, various methods have been reported to preserve it. However, perception of traceability tends to be subjective because there is no indicator which represents the degree of it. We propose an approach to measure traceability between a design model described in UML and source code written in object-oriented language. In detail, our approach maps a design to its implementation with the semi-automatic original algorithm and measures traceability with the Goal-Question-Metric approach. We apply the approach to pairs of a design model and source code and find that the degree of traceability can be presumed with a little work even by a third person.

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 model is suitable for embedded software development. On the other hand, it is difficult to fix, often tend to be large and complicated model. Understandability of the model is low abstraction is dependent on developers by subsystem, the model. Therefore, we conducted an appropriate abstraction aims to improve the maintainability of the Simulink model to apply the clustering method does not depend on the developer. In addition, we propose a two-way conversion of Simulink models and UML models. By converting to static and dynamic model of the UML model, to improve the understanding and clarifying the responsibilities. And to maintain the correspondence between the model in two-way conversion.

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.

Dynamic integration of Web services has been studied actively, and description and execution languages for services integration are widely used. Services integration is executed across multiple clouds. However, the WS-BPEL standard assumes that the integration is executed on a centralized engine, thus the network latency problem occurs when the target data is very large. We propose a cloud control framework for services integration to reduce the latency, by applying dynamic deployment of service components onto adequate clouds. We separate clouds control and component deployment behavior from the integration flow and represent them as rules to append integration logic. This separation enables to add and modify the behavior easily without modifying the integration logic.

When performing maintenance and expansion for the group of products derived, it is important to clarify traceability between requirements and implementation. However, for the large group of products, these tasks manually are difficult. First, we analyze commonality and variability in requirements and source codes. Next, using the configuration management log, we analyze the correspondence of those results. Finally, using the results of this study, we propose a method to extract traceability links between requirements and implements automatically. Result of applying the proposed method to derived products group of a certain size. we were able to extract the appropriate traceability links in a practical time.

We are working on software metrics to measure maintainability of Ajax application software. There are a number of previous studies about software maintainability metrics of classical Web application software. However, they do not consider characteristic properties of Ajax application software. We obtained concrete maintenance data by observing and recording the progress of iterative modifications on an actual Ajax application software through the software development process. It is expected that the software maintainability changes through the iterative modifications. We defined a suite of software maintainability metrics by a regression analysis based on those observed data.

When performing maintenance and expansion for the group of products derived, it is important to clarify traceability between requirements and implementation. However, for the large group of products, these tasks manually are difficult. First, we analyze commonality and variability in requirements and source codes. Next, using the configuration management log, we analyze the correspondence of those results. Finally, using the results of this study, we propose a method to extract traceability links between requirements and implements automatically. Result of applying the proposed method to derived products group of a certain size, we were able to extract the appropriate traceability links in a practical time.

Simulink models represent program as block diagrams for usually control system design. In large scale models or a large number of models, duplicated parts called "clones" could reduces the maintainability of models. To overcome such issue, there are existing researches on detecting perfect-matching clones; however these researches are not adequate for detecting imperfect-matching clones made by some partial modifications after copied and pasted. We propose a technique for detecting imperfect-matching clones in Simulink models efficiently by combining the existing perfect-matching clone detection technique and a fast apriori-based graph mining algorithm. We implemented the proposed technique as a detection tool and confirmed that the tool can detect imperfect-matching tools by applying it to several control system models. It is expected that models could be easily maintained by detecting such clones by the technique, and recording and managing them.

We propose a framework for analyzing impact of team organization on education effects in practical lecture course on information systems development. Moreover we show the result of applying the framework to two lecture courses and several lessons learned.

Fault localization is the techniques that estimates location of bugs causing the test failure using test results. Fault localization is effective for debugging support. However, when test case is not sufficient, Fault-Localization result is not reliable because that cannot localize a bug enough. This paper presents the technique of improving a Fault-Localization result using program structure under the incremental operation along the actual form of development. By the method repeatedly to fix the bug and go over the top-ranking high accuracy of the result Fault-Localization, indicating the feasibility of efficient debugging.

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.

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.

Model checking techniques are being applied to application software for formal verifications. Regarded as results of development, especially UML models are spread as it. To utilize UML models for formal verification, a method for transforming UML models to automata is already proposed. We propose a method for transforming UML models of Web applications to automata. Although relevant study needs to supplement the information for generating automata, our method doesn't require any information except for that of UML modeling. We apply this method to Web applications for mobile phone, and set a verification condition as nonexistence of vulnerable security flaw concerned with session management.

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.

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.

Not only project managers but also customers, senior managers and sales persons (hereafter, planning stakeholders) are possible causers of serious problem projects (SPPs) in IT firm, which have magnificent adverse influences to social and economical activities. However, there has been no report, which clarified causal relations between the planning stakeholders and the SPPs, with objective method. In this paper, we clarify the causal relation between them, by analyzing actual SPP events, which were extracted from failure project events collected and disclosed by the Information-technology Promotion Agency, Japan, using a process to avoid leading intentional results. We also mention about the necessity of standards including planning stakeholders to prevent the SPPs.

Consistency is an essential factor of usability of GUIs. Consistent GUIs support us to learn software usage and to use more efficient. However, developing consistent GUIs is heavy burden for developers. We propose a method of automatically generating GUIs based on analyzed GUIs. In our method, existing GUIs are analyzed, details of GUI and layout rules are extracted, and new windows are generated using the extracted rules. Our method can make GUI development easier.

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.

In our research, we propose the method of improving accessibility automatically for RIA written by JavaFX Script. We develop a method for applying accessibility libraries to GUI component of JavaFX Script. Due to our method, it is possible to reduce costs of developing accessible GUIs of JavaFX Script.

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.

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.

In our research, we proposes a method for automatically evaluating usability of Graphical User Interfaces (GUIs) of software. Concretely, by obtaining and analyzing operation histories of tasks when users use the software using our method, we specify problems of usability of the target software. In these evaluations, operation time and order of windows are evaluated. Using our method, it is easy for developers to evaluate usability of software.

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ヤングリサーチャー賞

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.

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.

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 inter-ference 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.

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.

In the software field of embedded systems, where many kinds of systems must be developed in a short term and low-cost, a model checking that is one of automatic design verification techniques is expected to be easy to use for a software designers. In this paper, a method generating an observer for the model checking tool UPPAAL from sequence charts, which is usually made by designers, is proposed. Also it is reported the result of applying this method to a communication system.

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.

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 an 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.

In recent years, computers and networks spread widely and play important role for a social life. Then, necessity of the computer use becomes larger for the challenged persons. However, computer software are not always available for challenged persons. So, it is necessary to develop the software with considering those persons. Comparing with a Web site that has many kind of guidelines and support tools, correspondence of software is to slow. In our research, we propose a method for analyzing a source code of a GUI program written by Java, and finding the problems of the program for challenged persons and senior citizon based on the guidelines.

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 general, a component-based system partially uses functions of software components. Therefore, precious structural testing for components requires to specify what functions of the components are used in the system. Besides, 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 may be invoked by that site is extremely ineffective. In this paper, we propose a precious method for estimating test coverage metrics of components on an object-oriented framework by using its deployment descriptor.

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.

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.

Model2 architectures forces a developer to design in consideration of the relation among three components based on the MVC pattern. We are studying the relationship information defined as a specification, and go into applying it to support modifying and extending the application. By permitting description of partial specification to the Web application, it also realizes partial support in development of a short term.