The total number and diversity of smartphone users are increasing. Additionally, their usage varies such as communication, document processing and online shopping. Applications realize different usages to meet users’ requirements. However, some users are unfamiliar with smartphones. They have difficulty learning the operations and need support. A tutorial system, which provides operations along with users’ status, is effective to resolve these issues. However, showing both the target application’s screen and the tutorial on a smartphone display is challenging. Herein we propose a method to generate a system that shows tutorials on a Personal Computer (PC). The target application on a smartphone and the tutorial system on a PC are connected. The user’s status is sent to the tutorial system to realize a customized tutorial. To generate the tutorial system, a log obtaining function is added to the target application without modifying the source program. The log data of user’s operations are recorded. Operation flows in the target application are constructed and frequent operations are weighted. Then tutorials are generated and shown based on the weighting. Our method allows a user to view appropriate tutorials for the current status of the operation on a large display of a PC.

Resource-constrained environments, such as embedded devices, have limited amounts of memory and storage. Practical programming languages such as C++ and Rust tend to output multiple similar functions by monomorphizing polymorphic functions. An optimization technique called Function Merging, which merges similar functions into a single function, has been studied. However, in the state-of-the-art approach, the number of functions that can be merged at once is limited to two; thus, efficiently merging three or more functions, which are often generated from polymorphic functions, has been impossible. In this study, we propose Multiple Function Merging optimization, which targets merging three or more similar functions into a single function using a multiple sequence alignment algorithm. With multiple aligned information, Multiple Function Merging can increase merge opportunities and reduce extra branching overheads at the code generation stage. We evaluated it using the SPEC CPU benchmark suite and some large-scale C/C++ programs, and the results show that it reduces code size by as much as 7.61% compared with the state-of-the-art approach.

Multi-View Modeling Framework for ML Systems (M3S) provides a framework to synchronize the experimental nature of machine learning and the deterministic side of traditional software engineering. However, understanding the framework's generality and limitations still requires further investigation. This paper compares the existing validation case study to a new case study of the OCT image diagnosis support system. The comparison between the two case studies shows M3S capability to handle variations in the nature of ML system analysis. However, the framework's capability to handle different ML tasks other than multi-class classification still requires further investigation.

Advancements in large language models (LLMs) are transforming software engineering through innovative prompt engineering strategies. By analyzing prompt-driven enhancements across key software engineering tasks, we present a sys-tematic literature review and a pioneering taxonomy elucidating the practical applications of prompt engineering in software engineering. Our taxonomy offers a foundational framework that clarifies the roles of prompt engineering and measures its impact, thereby guiding evolving AI -driven software engineering research and practices.

In this study, we employ causal inference models, specifically Bayesian Networks (BN) and Linear Non-Gaussian Acyclic Models (LiNGAM), to investigate the determinants of Bug Fixing Time (BFT) in software development. Moving beyond traditional statistical analyses, our approach aims to identify the true causal factors influencing BFT. Our findings indicate that ’Reporter Reputation’, ’Severity’, and ’Blocker’ status are significant determinants of BFT, with notable differences between bugs reported by users versus developers. This research challenges existing assumptions about the necessity of comprehensive bug reports and underscores the importance of understanding bug resolution’s complexity and organizational context. By applying causal inference models, we offer actionable insights for improving bug prioritization, operational efficiency, and predictive management of development bottlenecks, enhancing the software development lifecycle. Our study bridges the theoretical and practical aspects of software quality optimization and introduces a novel perspective on managing software development processes. Additionally, our analysis reveals counterintuitive results that further contribute to our understanding of the dynamics influencing BFT.

Teachers often utilize automatic program repair methods to provide feedback on submitted student code using model answer code. A state-of-the-art tool is Refactory, which achieves a high repair success rate and small patch size (less code repair) by refactoring code to expand the variety of correct code samples that can be referenced. However, Refactory has two major limitations. First, it cannot fix code with syntax errors. Second, it has difficulty fixing code when there are few correct submissions. Herein we propose a new method that combines Refactory and OpenAI's GPT models to address these issues and conduct a performance measurement experiment. The experiment uses a dataset consisting of 5 programming assignment problems and almost 1,800 real-life incorrect Python program submissions from 361 students for an introductory programming course at a large public university. The proposed method improves the repair success rate by 1-21% when the set of correct code samples is sufficient and the patch size is smaller than Refactory alone in 16-45% of the cases. When there was no set of correct code samples at all (only the model answer code was used as a reference for repair), method improves the repair success rate by 1-43% and the patch size is smaller than Refactory alone in 42-68% of the cases.

Although programming is part of primary school curricula in many countries, barriers persist for elementary students learning programming such as an insufficient understanding of the underlying mathematics, complex concepts, and purpose of programming. These challenges often lead to disinterest. Herein we present an innovative game-design-based programming education tool. Students progressively enhance a classic game, Puyo Puyo, using fundamental programming concepts and selecting the appropriate code. This engaging approach improves students' computational thinking abilities as they transform code into a functional game. Here, we describe the tool's background and structure. Then we detail a workshop using the tool, including analyzing the changes in students' programming skills, computational thinking, and interest in programming. Finally, we summarize the findings and future research directions.

Abstract Development of machine learning (ML) systems differs from traditional approaches. The probabilistic nature of ML leads to a more experimentative development approach, which often results in a disparity between the quality of ML models with other aspects such as business, safety, and the overall system architecture. Herein the Multi-view Modeling Framework for ML Systems (M3S) is proposed as a solution to this problem. M3S provides an analysis framework that integrates different views. It is supported by an integrated metamodel to ensure the connection and consistency between different models. To facilitate the experimentative nature of ML training, M3S provides an integrated platform between the modeling environment and the ML training pipeline. M3S is validated through a case study and a controlled experiment. M3S shows promise, but future research needs to confirm its generality.

As machine learning expands to various domains, the demand for reusable solutions to similar problems increases. Machine learning design patterns are reusable solutions to design problems of machine learning applications. They can significantly enhance programmers' productivity in programming that requires machine learning algorithms. Given the critical role of machine learning design patterns, the automated detection of them becomes equally vital. However, identifying design patterns can be time-consuming and error-prone. We propose an approach to detect their occurrences in Python files. Our approach uses an Abstract Syntax Tree (AST) of Python files to build a corpus of data and train a refined Text-CNN model to automatically identify machine learning design patterns. We empirically validate our approach by conducting an exploratory study to detect four common machine learning design patterns: Embedding, Multilabel, Feature Cross, and Hashed Feature. We manually label 450 Python code files containing these design patterns from repositories of projects in GitHub. Our approach achieves accuracy values ranging from 80 % to 92% for each of the four patterns.

Machine learning system analysis requires different approaches for each different task and domain. Selecting a proper set of analytic models can be challenging for a specific problem. This paper discusses the extensibility of the Multi-View Modeling Framework for ML Systems approach using process mapping and extensible metamodel. We conducted a case study to evaluate the feasibility of such extensibility by extending the approach to facilitate an activity-driven analysis for an optical character recognition system. Based on the result of the case study, we found that Multi-View Modeling Framework for ML Systems is likely to be extensible.

Most client software employs a bug-tracking system, which utilizes user-submitted reports (bug reports) that contain information necessary for software developers to fix bugs. The quality of bug reports drastically differs. Bug reports can include severity, priority, and associated issues determined by researching the addressed bug. Herein we investigate the influence of bug report qualities on successfully fixing a bug and estimating the fixing time. We also examine the claim in previous studies that bias and differences in the treatment of bug reports exist due to broad expertness among the reporters. Our approach examines the relationship between the qualities within the bug-fixing cycle and modeling graphical causal dependencies through a Bayesian Network. Bug reports with attachments, dependencies on another bug, and frequent discussions are more likely to be fixed. In addition, bug reports with a high severity tend to be fixed faster. Moreover, the difficulty of the bug itself may influence the fixing rate such that a straightforward bug will be fixed easier and faster regardless of the bug report quality.

The purpose of this study is to identify the characteristics of Agile development processes that impact user satisfaction. We used user reviews of OSS smartphone apps and various data from version control systems to examine the relationships, especially time-series correlations, between user satisfaction and development metrics that are expected to be related to user satisfaction. Although no metrics conclusively indicate an improved user satisfaction, motivation of the development team, the ability to set appropriate work units, the appropriateness of work rules, and the improvement of code maintainability should be considered as they are correlated with improved user satisfaction. In contrast, changes in the release frequency and workload are not correlated.

This study utilizes the game rules of a falling-puzzle game, developed as a consumer-oriented digital game, in programming education for young people. When digital games are used in programming education, they are often designed specifically for that purpose. In this study, we focused on the game rules of the consumer falling-object puzzle game, “Puyo Puyo.” Learning impact was investigated on 23 Japanese elementary, junior high, and senior high school students. The results show that the concepts of branching and arraying in programming were taught effectively; thus, consumer digital game rules can be used as a case study for programming education.

This study investigates the Computational Thinking skill differences among novice programmers in relation to gender. Block-based visual programming languages such as Scratch particularly benefit K-12 programmers because they learn how to code intuitively. Our study analyzed 124 (62 males, 62 females) Scratch projects on the Scratch website, categorized projects on the basis of each user's gender and project type, and compared their Computational Thinking scores. The results of this study suggest that project types preferred by males require more programming construct reflected in the Computational Thinking score than that of females. Because gender differences appear by project type, project type presumably influences the gender gap in scores.

Machine learning-based system requires specific attention towards their safety characteristics while considering the higher-level requirements. This study describes our approach for analyzing machine learning safety requirements top-down from higher-level business requirements, functional requirements, and risks to be mitigated. Our approach utilizes six different modeling techniques: AI Project Canvas, Machine Learning Canvas, KAOS Goal Modeling, UML Components Diagram, STAMP/STPA, and Safety Case Analysis. As a case study, we also demonstrated our approach for lane and other vehicle detection functions of self-driving cars.

Automated program repair (APR) can realize efficient debugging in software development.Automated program corrections using genetic algorithms (GA) can repair programs, including those with multiple bugs, but the repair process of GA-based APR is difficult to understand using logs because many modification program codes are generated.Consequently, Matsumoto et al. implemented a methodology for visualizing the process.Their proposed methodology provides an intuitive understanding of the conformance values (test case pass rates), generations, states, and operations performed to generate each variant; however, it lacks sufficient information to analyze whether defect localization is appropriate in APR.Herein we propose a new methodology to visualize the impact of fault localization on program evolution in GA-based APR and create a new tool.Additionally, a case study demonstrates the effectiveness of the proposed methodology and future works are considered.

Detecting software design pattern is an important part of software reverse engineering because design patterns can provide the most intuitive design idea of software products, which can be useful for maintenance engineers. In past studies, a lot of approaches have been proposed to detect design patterns, and the machine learning-based approach is a new trend in recent years. In this paper, we propose a preliminary idea of a deep learning-based approach to detect design patterns from UML class diagrams of software products, which can be used in some cases that traditional approaches may not work. We propose an overall process, which is divided into preparation phase and application phase. In preparation phase, we train a deep learning-based classifier to do the image classification task. In application phase, users may input the UML class diagram of a micro-architecture into the model and get the pattern it belongs to. We conduct a preliminary experiment to show the effectiveness of our approach, we train a Convolutional Neural Network (CNN) as the classifier and test it on our image dataset, which is constructed with UML images we collected from the Internet. We also use Gradient-weighted Class Activation Mapping (Grad-CAM) to do the visualization and use it to explain why our approach works. Lastly, we analyze the potential advantages and disadvantages of our approach.

The use of anomaly detection for log monitoring requires parsing model input features from raw, unstructured data. Log parsing methods come in many forms, but are generally categorized as being either offline or online. In this study, a systematic literature review of anomaly detection approaches utilizing online parsing methods is performed. An inventory of these approaches is taken, research gaps are explored, and suggestions for future exploration and study are presented.

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.

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.

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.

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

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

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.

Binary similarity has been widely used in function recognition and vulnerability detection. How to define a proper similarity is the key element in implementing a fast detection method. We proposed a scalable method to detect binary vulnerabilities based on similarity. Procedures lifted from binaries are divided into several comparable strands by data dependency, and those strands are transformed into a normalized form by our tool named VulneraBin, so that similarity can be determined between two procedures through a hash value comparison. The low computational complexity allows semantically equivalent code to be identified in binaries compiled from million lines of source code in a fast and accurate way.

The Smart Systems and Services Innovative Professional Education (Smart SE) program is a certification program developed as part of the education network for the Practical information Technologies (enPiT-Pro) project, which is funded by the Japan Ministry of Education, Culture, Sports, Science and Technology. The Smart SE program provides industry professionals working in fields related to information and communication technology (ICT) with additional training and education in smart systems and services that utilize various technologies such as IoT, Cloud, Big Data, and Artificial Intelligence (AI) for businesses. Here, we illustrate its purpose, curriculum and features to respond to the needs of industrial professional education.

Here, we present a systematic literature review of mob programming. Mob programming is a new software development approach, a whole team (more than two people) works together on a code at the same time, in the same space, and on the same computer. The objective is to determine the current reported knowledge of mob programming. We searched two digital libraries, but only ten papers were found. These papers were analyzed and the benefits and risks of mob programming as well as the future research directions are discussed.

The highest share of cost for a software product is software maintenance. Identifying the quality merit of the software architecture is extremely vital as the quality directly relates to software maintenance. A good design always exhibits good quality characteristics because it is directly related to good architecture. Although C language is a major language in the software industry, few studies investigate the quality of the architecture in C language. This study aims to evaluate the quality of C language projects in a quantifiable form by focusing on dependency graphs, associated metrics, and software architecture. In particular, this study (i) formulates the architecture representation of C projects, (ii) determines the metrics capturing the quality of architecture, (iii) defines code smell and metrics relations and (iv) conducts an empirical analysis on 58 C projects. We show which metrics derived from dependency graphs can detect architectural issues and verify their relation to software architecture quality.

Application Programming Interfaces (APIs) are common in software development to reuse other products. Although the documentation allows API consumers to learn about API usages, it can be unreliable. Here, we investigate the characteristics of inappropriate usage examples in web API documentation by extracting and comparing OpenAPI Specifications from usage example-response pairs. About 65.5% of the endpoints have some form of inappropriate usage examples. Furthermore, mismatches are classified into four categories: undocumented keys pattern, dynamic keys pattern, unreturned keys pattern, and type mismatched pattern. Our results suggest that the number of keys in the response is correlated with the number of mismatches. These findings should assist both API providers and consumers who deal with unreliable documentation in web APIs.

Background: Traditional programming education focuses on training students' ability to write correct code that meets the specifications in programming assignments. In addition to correctness, software engineering studies argue that code quality is important. Problem: Nurturing students' ability to write high-quality code in programming assignments is difficult due to two main reasons. (1) Considering code quality while grading is undesirable because there are no objective and fair measurement metrics. (2) Grading assignments from multiple viewpoints (correctness and quality) is difficult and time-consuming. Approach: We propose applying gamification with code metrics to measure code quality in programming assignments. Our approach can motivate students to write code with good metric scores independent of grading. We implemented our approach and conducted a control experiment in a programming course at a university. Result: Our approach did not interfere with students' submissions but improved metric scores significantly. Hence, our approach can engage students to write high-quality code.

Bugs must be resolved efficiently for developers' limited resources. Bug reports are necessary for the bug modification process. Service user reports a bug as a bug report. Developer read bug reports and fix bugs. The developer can make discussion by posting comments on reported bug reports. There are several researches on the initial report of the bug report so that bugs can be fixed efficiently. But there are few researches on bug report comments. We focus on comments on bug reports. Currently, everyone is free to comment, but the modification time may be affected by how to comment. We investigate the topic of comments of the bug report. As a result of the investigation, the fact that the topics are mixed does not affect the modification time, however we found a tendency to shorten the modification time when the topic of the solution started early.

As more children are exposed to computer science and programming, numerous indicators have been proposed to evaluate programming learning. Because these indicators are not divided by step in a learning goal, learner's growth cannot be evaluated in detail. Our research focuses on resolving this issue in the field of programming. Herein we propose a rubric to measure the progress of programming learning for elementary school students. This rubric, which is comprised of indices, aims to evaluate learning achievement of logical skills such as logical thinking and problem solving using a unified learning goal. Furthermore, this rubric consists of 30 evaluation items in 8 categories. Then we investigate whether this rubric can be adapted to existing workshops of programming learning. The workshops occurred in 2016 and 2017. in addition, A total of 101 students between 6 and 12 years old participated in the workshops. The rubric successfully evaluates programming learning workshops as it provides a unified evaluation that covers common learning objectives in existing indicators. Our rubric is available at https://g7programming.jp/plr/.

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.

The importance of APIs in software development, especially web APIs, has increased Developers read documentation, which is available on the internet, and use the corresponding APIs in their products. However, documentation occasionally contains mistakes. Such mistakes can confuse developers or lead to defects that lower the quality of the product. In this paper, we investigate the reliability of web APIs by extracting and comparing OpenAPI specifications from both the documentations and the results of the API calls. Almost half of the documentations are somehow unreliable. Mismatches between documentation and the response can be categorized into four types: 1) Undocumented Keys, 2) Dynamic Keys, 3) Unreturned Keys, and 4) Type Mismatched. This study will help developers design more reliable products.

Evolvability defects are non-understandable and non-modifiable states that do not directly produce runtime behavioral failures. Automatic source code evaluation by metrics and thresholds can help reduce the burden of a manual inspection. This study addresses two problems. (1) Evolvability defects are not usually managed in bug tracking systems. (2) Conventional methods cannot fully interpret the relations among the metrics in a given context (e.g., programming language, application domain). The key actions of our method are to (1) gather training-data for machine learning by experts' manual inspection of some of the files in given systems (benchmark) and (2) employ a classification-tree learner algorithm, C5.0, which can deal with non-orthogonal relations between metrics. Furthermore, we experimentally confirm that, even with less training-data, our method provides a more precise evaluation than four conventional methods (the percentile, Alves' method, Bender's method, and the ROC curve-based method).

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.

Aligning business goals and strategies to software requirement is becoming more critical as corporate relies more on software for their business activities. While GQM+Strategies gives the solution to this problem, GQM+Strategies does not explicitly offer attention to relationships between various stakeholders. We propose an integration of Balanced Scorecard's perspectives into GQM+Strategies framework to solve that problem. We evaluated the possibilities by classifying goals and strategies of three existing grids totaling 73 goals and 127 strategies. We also analyzed the relationship between those perspectives in those grids. We found that current application of GQM+Strategies followed balanced scorecard's principles of perspective and concluded that it is possible to use balanced scorecard's perspectives on GQM+Strategies framework.

As the number of web services has increased, the number of services with the same functions has steadily risen. Consequently, many QoS (Quality of Service)-based service selection algorithms have been proposed to determine which service should be selected among those with the same functions. The prediction accuracy of the QoS attribute depends on the selection algorithm. In addition, the appropriate selection algorithm depends on the type of domain. For example, a stock notification service, which relies on real-time transactions, should employ a selection algorithm with a highly accurate response time. However, an automated method to recommend the optimal service selection algorithm has yet to be established. In this paper, we propose a method to recommend selection algorithms.

Successful software implementation needs high-quality software requirement specifications (SRSs). However, SRSs are not only difficult to evaluate quantitatively, but there is not an effective indicator to predict which SRSs are prone to modifications. Moreover, few studies have investigated the impact of SRS quality on software quality. Herein we use two specification metrics for SRSs to evaluate their effectiveness to predict future modifications in two actual developments. The results show that our metrics are useful to predict future specification modifications and our specifications are closely related with software quality.

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.

The concept of memory management in C programming language is particularly challenging for novice programmers. Consequently, many researchers have proposed program visualization tools to alleviate these difficulties: for example, SeeC is one of the state-of-the-art tools for visualizing the behavior and execution status of C programs. However, three problems (P1-3) remain in SeeC, as well as in other existing visualization tools. P1 (Usability): SeeC requires many steps to revisualize modified source code. P2 (Capability): SeeC does not fully support dynamic memory allocation. P3 (Installability): novice programmers often find installation of SeeC challenging due to its dependency on Clang. We propose a new visualization tool named PlayVisualizerC (PVC) for novice C programmers, which provides three solutions (S1-3) for P1-3. S1: PVC reduces the steps required for revisualization. S2: complete support for dynamic memory allocation. S3: designed to be installed in the user's web browser. From a small-scale experiment and a questionnaire given to 20 students, we found that a set of four programming tasks were solved 1.8 times faster and 24% more correctly using PVC.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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

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 stake-holders 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 Plug in 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 Plug in 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 Plug in 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 Plug in to software development project continuously to assess their effectiveness in the long term.

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 Similar Highlight, which extracted all possible matching elements via similarity patterns from recently modified elements using a sub syntax tree comparison. Similar Highlight 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 Similar Highlight can improve programming productivity. Currently, Similar Highlight supports C, C#, JAVA, Java Script, and PHP, but in the future we will expand it to other languages.

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

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.

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.

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.

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, Open Office and Virtual Box, 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.

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.

Computational thinking is one of the most important skills for using computers. Most existing learning systems for computational thinking work only on desktop or laptop computers, although the popularity of smartphones has rapidly been growing. Moreover, most existing programming languages to teach are based on English and most learning systems employ poor user interfaces. Thus, such programming languages and learning systems are not suitable for users who are not familiar with English or who are enchanted to such user interfaces. We propose a gamified learning system using an appealing user interface with a novel icon-based non-verbal programming language. Our system works on smartphones with which many Japanese teenager students are more familiar than PCs. Our system employs an appealing interface that a female student designs for other female students and icons to motivate university students to learn programming through playing. We conducted an experiment with 16 female students from Waseda University to evaluate our system. We confirmed our system motivated the students to learn programming and helped learn computational thinking concepts.

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.

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.

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.

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.

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.

UML class diagrams representing the static structure of the relations between different concepts existing in a problem are widely used in model-based software development. However, no effective measures of a class diagram's understandability yet exist. We have devised quantitative measures of a class diagram's understandability and evaluated their validity. We obtained strong correlations between the domain experts' subjective evaluations of the understandability of a class diagram and the measurements of our methods. These results indicate that our measures can effectively quantify the understandability of class diagrams.

The spread of open-software services through the Internet increases the importance of security. A security pattern is one of the techniques in which developers utilize security experts' knowledge. Security patterns contain typical solutions about security problems. However there is a possibility that developers may apply security patterns in inappropriate ways due to a lack of consideration on dependencies among patterns. Application techniques of security patterns that consider such dependencies have not been proposed yet. In this paper, we propose an automated application technique of security patterns in model driven software development by defining applications procedures of security patterns to models as model transformation rules with consideration for pattern dependencies. Our technique prevents inappropriate applications such as the application of security patterns to wrong model elements and that in wrong orders. Therefore our technique supports developers apply security patterns to their own models automatically in appropriate ways.

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.

Interactions between users and software are usually described as scenarios so that it is easy to reflect users' viewpoints in software development. In many cases, scenarios are written in a natural language so that users can communicate with software developers smoothly. However, it is difficult to validate correspondences between the flows of operations written in scenarios and those in software. We assume that the flows of software can be expressed by the flows of Graphical User Interface (GUI) operations. In this paper, we propose a method for validating the correspondences between the flows of operations in scenarios and those of actual GUIs. This validation can be performed by analyzing the historic data of GUI operations heuristically. The label names on widgets are extracted from the histories, terms corresponding to label names on widgets are extracted from scenarios, and then the orders of appearance of label names and f terms are validated.

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.

Demand for reliability in Web applications has increased greatly in recent years as they have begun to be used more for enterprise applications. Model checking is an effective way to increase software reliability, but because most Web applications have short delivery times, preparation and application costs make it difficult to introduce model-checking techniques into the development process. In this paper, we propose a technique for automatically extracting page transitions from a Web application that has been developed using a Web application framework, such as Struts configuration files and Java Server Page templates, and transforming it into a format that can be used by existing model-checking tools. Using the proposed technique, Web application developers will be able to reduce the preparation and application costs of introducing model-checking techniques.

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.

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

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

As mobile computing becomes common, the battery issue of mobile computing devices has become increasingly notable. To this end, research and development of various power-conservation devices and methods are actively taking place. However, the conventional method of extending the battery life through power-conservation can never prevent the unintentional shutdowns of applications due to a dead battery. This research aims to realize the evacuation of applications on a mobile computing device to another device before the battery runs out by creating the application as a mobile agent. In particular, by introducing the concept of the Crisis Management Center, dynamic and smooth evacuation of multiple application agents will become possible. The paper explains and verifies the effectiveness of the EASTER (Escape Agent System from dying batTERy), a system developed for the purpose of recovering the applications when a battery is running out through the use of a mobile agent system.

In developing an application software, it is important to pay attention to end-users' viewpoints. In particular, in designing Graphical User Interfaces (GUIs), it is effective to develop a prototype and to show it to end-users in order to reflect end-users' viewpoints, because the design of the GUI strongly affects the usability of the application. Use case diagrams and scenarios are described from end-users' viewpoints, so it is considered that GUIs reflecting end-users' viewpoints can be developed using use case diagrams. In this paper, we propose a method for generating GUI prototypes from given use case diagrams and scenarios. GUI prototypes can be generated based on the extracted control structure with appended simple widget information.

The demand for Graphical User Interface (GUI) applications has witnessed an increase. However, it is difficult to develop such GUI applications, because their structures are complicated. Therefore, we propose an approach for the automatic generation of GUIs for the purpose of facilitating GUI applications' development from dialog description. These dialogs are described using a Petri net which includes GUI information. A special-purpose Petri net editor is developed for this purpose, so system designers can work in an environment which is suitable for developing GUI applications. The most important feature of this system is as follows: after generating GUI application, users can customize the detailed size and arrangement of widgets to suit the user's needs. This customization does not require the use of any special software tools. In this research, we assumed that GUI application development is divided into three roles, system designers who are in charge of dialog description, graphic designers who are in charge of the customization of GUI, and application programmers who are in charge of programming of applications. The system designers describe the dialog, then the graphic designers and application programmers work independently or simultaneously.

Optimizing compilation is very important for generating code sequences in order to utilize the characteristics of processor architectures. One of the most essential optimization techniques is register allocation. In register allocation that takes account of instruction-level parallelism, anti-dependences generated when the same register is allocated to different variables, and spill code generated when the number of registers is insufficient should be handled in such a way that the parallelism in a program is not lost. In our method, we realized register allocation using a new data structure called the register existence graph, in which the parallelism in program is well expressed.

Nowadays, for GUI application development, there are a number of interface builders, which make it possible for the user to create user interfaces easily, and UIMSs, which help to specify and design user interfaces. However, interface builders lack the ability to select appropriate interaction items for a specific application, and UIMSs have little support for low-cost implementation techniques, because they have concentrated on the description technique. To solve these problems, we describe an approach to support both design and implementation activities in a GUI application development by generating a default interface from the described dialog and by customizing the generated interface interactively using an interface builder. This enables us to reduce development costs by supporting GUI development from the earliest stage and by excluding the necessity of specifying and preparing design rules for the presentation style.

Register allocation for instruction-level parallel processors involves problems that are not considered in register allocat,i on for scalar processors.First, when the same register is allocated to different variables, anti-dependence is gtmerated, which decreases instruction-level parallelism.Second, spill code should be inserted at a suitable position in its object, where it can be executed in parallel with other instructions.These problems do not exist for scalar processors, so existing register allocators take no account of them.This paper describes a new register allocation algorithm for solving these problems, using a graph structure that represents instructions and dependence between them.

Recently, many on-line help systems have been developed that provide usage explanation for applications. However, it is difficult to find out necessary information in help contents and to understand how to obtain complete information. A navigation mechanism which can provide a user with essential information and guide the user so that he can carry out intended actions is indispensable. In this paper, we propose an adaptive navigation system which does not display navigation information on decisions that a user has already made by reflecting the current state of an application. In this research, in order to describe the structure of an application, Petri nets which are suitable for modeling event-driven systems are used. The application system is constructed based on these Petri nets. By communicating between the application system and its navigation system through these Petri nets, user navigation system reflecting the execution state of the application is realized.

Recently, there have been many online help systems that provide usage explanations for applications. However, it is difficult to find out necessary information in help contents and to understand how to obtain complete information. A navigation mechanism which can provide a user with essential information and guide the user so that he can achieve intended actions is indispensable. In this paper, we propose an adaptive navigation system which prevents the display of navigation information on decisions that a user has already made by reflecting the current state of an application. In this research, in order to describe the structure of an application, Petri nets which are suitable for modeling event-driven systems are used. The application system is constructed based on these Petri nets. By communicating between the application system and its navigation system through these Petri nets, a user navigation system reflecting the execution state of the application can be realized.>

GUIs (graphical user interfaces) have been developed to make applications easier to use. However, effective methods to support the development process for GUI-based applications are highly required as applications have become increasingly complex. As the supporting methods, we propose a representation technique to suitably describe the structure of an application using Petri nets. The technique supports all development activities of GUI-based applications during the analysis, design and implementation stage. On the other hand, concise explanations are indispensable to easily use complex applications and to help achieve a user's intended actions. We also present a user navigation method for changing messages depending on the present state of the Petri net based application.>