Immediate and personalized feedback on students' programming assignments is important for improving their programming skills. However, it is challenging for instructors to give personalized feedback to every student since each program is written differently. To address this problem, the Automated Feedback Generation (AFG) technique has been proposed, which identifies faults from the wrong program, generates patches, and provides feedback if validation is passed. AFG relies on students' correct programs to find faults and generate patches. Therefore, having diverse correct programs is important for the performance of AFG. However, in small-scale programming courses or new online judge problems, there might be a lack of diversity in correct programs. In this paper, we propose Mentored, a new AFG for students' programming assignments through diversification. Mentored generates new structures of programs through various combinations of programs to gener-ate modifications optimized for wrong programs while solving the problem of dependency on correct programs. Additionally, Mentored provides transparent feedback on the process of repairing wrong programs. We evaluate Mentored on real student programming assignments and compare it with state-of-the-art AFG approaches. Our dataset includes real university in-troductory programming assignments and online judge problems. Experimental results show that Mentored generates higher repair rates and more diverse program structures than other AFG approaches. Moreover, by providing a transparent sequence of repair processes, Mentored is expected to improve students' programming skills and reduce instructors' manual effort in feedback generation. These results indicate that Mentored can be a useful tool in proaramming education.

Solid-State Drive (SSD) firmware manages complex internal states, including flash memory maintenance. Due to nondeterministic I/O operations, traditional testing methods struggle to rapidly achieve coverage of firmware code areas that require extensive I/O accumulation. To address this challenge, we propose a state data-aware fuzzing approach that leverages SSD firmware’s internal state to guide input generation under nondeterministic I/O conditions and accelerate coverage discovery. Our experiments with an open-source SSD firmware emulator show that the proposed method achieves the same firmware test coverage as a state-of-the-art coverage-based fuzzer (AFL++) while requiring approximately 67% fewer commands, without reducing the number of crashes or hangs detected. Moreover, we extend our experiments by incorporating various I/O commands beyond basic write/read operations to reflect real user scenarios, and we confirm that our strategy remains effective even for multiple types of I/O tests. We further validate the effectiveness of state data-aware fuzzing for firmware testing under I/O environments and suggest that this approach can be extended to other storage firmware or threshold-based embedded systems in the future.

Automated Program Repair (APR) automatically generates patches for identified defects. As a result, APR can encourage novice students to learn coding by providing appropriate patches. Since students have their coding conventions, we should be able to deal with many types of defects. Existing studies have used predefined RuleId-driven templates to automatically fix defects in Static Analysis Tools(SATs). However, the community periodically adds, deletes, or changes SAT’s RuleIds. This is difficult for existing RuleId-based templates to reflect those changes immediately. Existing studies only cover about 10 RuleIds, making it difficult to address all defects faced by all students. Therefore, it is necessary to establish appropriate criteria for classifying templates. The SAT has a predefined format for how Error Messages are written, and since Error Messages contain fixing actions, defects with similar Error Messages tend to have similar fixing actions. These characteristics of the Error Message are suitable for reproducible template classification criteria. Our preliminary study demonstrated that by classifying patterns based on Error Messages, we could effectively address various defects, including those in different programming languages, using a single template. This means that if a newly added RuleId corresponds to an Error Message format already in the predefined Error Message-based template, it can be modified without additional effort. We plan to construct reproducible templates for each Error Message and provide ongoing patching of defects to students.

Research on automated program repairs using transformer-based models has recently gained considerable attention.The comprehension of the erroneous behavior of a model enables the identification of its inherent capacity and provides insights for improvement.However, the current landscape of research on program repair models lacks an investigation of their false behavior.Thus, we propose a methodology for diagnosing and treating the false behaviors of transformer-based program repair models.Specifically, we propose 1) a behavior vector that quantifies the behavior of the model when it generates an output, 2) a behavior discriminator (BeDisc) that identifies false behaviors, and 3) two methods for false behavior treatment.Through a large-scale experiment on 55,562 instances employing four datasets and three models, the BeDisc exhibited a balanced accuracy of 86.6% for false behavior classification.The first treatment, namely, early abortion, successfully eliminated 60.4% of false behavior while preserving 97.4% repair accuracy.Furthermore, the second treatment, namely, masked bypassing, resulted in an average improvement of 40.5% in the top-1 repair accuracy.These experimental results demonstrated the importance of investigating false behaviors in program repair models.* corresponding author 1 We refer to these as bugs in a broad sense.

Bugs in source files (SFs) may cause software malfunction, inconveniencing users and even leading to catastrophic accidents. Therefore, the bugs in SFs should be found and fixed quickly. However, from hundreds of candidate SFs, finding buggy SFs is tedious and time consuming. To lessen the burden on developers, deep learning-based bug localization (DLBL) tools can be utilized. Text terms in bug reports and SFs play an important role. However, some terms provide incorrect information and degrade bug localization performance. Therefore, those terms are defined here as "misguiding terms," and an explainable-artificial-intelligence-based identification method is proposed. The effectiveness of the proposed method for DLBL was investigated. When misguiding terms were removed, the mean average precision of the bug localization model improved by 33% on average.

Automated program repair(APR) is in the spotlight in academia and the field to reduce the time and cost of maintenance for developers. Recently, APR has continued to study based on deep-learning models to understand and learn how to fix software bugs. Text-to-Text Transfer Transformer(T5), which scored state-of-the-art in natural language processing benchmarks, also showed promising results on program repair in recent studies. In deep-learning-based program repair studies, studies commonly propose code abstraction techniques to avoid vocabulary problems and learn fine code transformation to generate bug-fixing patches. However, there is not enough systematic analysis of code abstraction according to each bug type in deep-learning-based program repair. Therefore, We leverage TFix, T5-based program repair, to evaluate how code abstraction techniques affect neural program repair. Our experimental results showed that defect-specific code abstraction achives a higher average BLEU score than the existing code abstraction technique in both T5 and multilingual-T5(mT5) model-based TFix results. Also, mT5 model-based TFix, which is applied defect-specific code abstraction, gets a higher BLEU score in 37 error types of 52 ESLint error types than TFix.

Deep learning-based automatic program repair (DL-APR) returns a patch code when given a defect code. Recent studies on DL-APR techniques have focused on the training phase to generate more accurate patches; however, a trained model cannot always generate an accurate patch for every new defect code, as the training dataset does not completely represent the new defects to be input in the future. DL-APR researchers should study a method to elicit the best performance on new inputs from the trained and deployed model. A new defect instance (i.e., defect codes and their context codes) is one of the crucial input data that determine the accuracy of the DL-APR, which can be changed and improved. We improve the quality of new input defect instances by focusing on the presence of noise tokens which compromise the defect instances’ quality, thus impairing the accuracy of generated patches. This paper shows that 1) there are noise tokens which prevent correct patch generation (inference) in a new defect instance, and 2) it is necessary to mask these noise tokens to avoid their usage in inferencing patch codes. In order to validate these two assertions, we use a state-of-the-art DL-APR technique and a genetic algorithm to generate near-optimal defect instances which maximize the patch generation accuracy (i.e., the BLEU score) of 4,573 defect instances. Based on optimization results, we found that 1) noise tokens impair patch generation accuracy in approximately 49% of instances, and 2) if these tokens are precluded from inference by masking them, we can improve patch generation accuracy by 88%. The results suggest that future work is required to automatically remove noise tokens from new defect instances so that the trained patch generator generates better patches.

As the impact of deep-learning-based software (DLSW) increases, automatic debugging techniques for guaranteeing DLSW quality are becoming increasingly important. Information-retrieval-based bug localization (IRBL) techniques can aid in debugging by automatically localizing buggy entities (files and functions). The low-cost advantage of IRBL can alleviate the difficulty of identifying bug locations due to the complexity of DLSW. However, there are significant differences between DLSW and traditional software, and these differences lead to differences in search space and query quality for IRBL. That is, IRBL performance must be validated in DLSW. We empirically validated IRBL performance for DLSW from the following four perspectives: 1) similarity model, 2) query generation, 3) ranking model for buggy file localization, and 4) ranking model for buggy function localization. Based on four research questions and a large-scale experiment using 2,365 bug reports from 136 DLSW projects, we confirmed the salient char-acteristics of DLSW from the perspective of IRBL and derived four recommendations for practical IRBL usage in DLSW from the empirical results. Regarding IRBL performance, we validated that IRBL performance with the combination of bug-related features outperformed that of using only file similarity by 15 % and IRBL ranked buggy files and functions on average of 1.6th and 2.9th, respectively. Our study is valuable as a baseline for IRBL researchers and as a guideline for DLSW developers who wish to apply IRBL to ensure DLSW quality.

Template-based automatic program repair (T-APR) techniques depend on the quality of bug-fixing templates. For such templates to be of sufficient quality for T-APR techniques to succeed, they must satisfy three criteria: applicability, fixability, and efficiency. Existing template mining approaches select templates based only on the first criteria, and are thus suboptimal in their performance. This study proposes a multi-objective optimization-based bug-fixing template mining method for T-APR in which we estimate template quality based on nine code abstraction tasks and three objective functions. Our method determines the optimal code abstraction strategy (i.e., the optimal combination of abstraction tasks) which maximizes the values of three objective functions and generates a final set of bug-fixing templates by clustering template candidates to which the optimal abstraction strategy is applied. Our preliminary experiment demonstrated that our optimized strategy can improve templates’ applicability and efficiency by 7% and 146% over the existing mining technique, respectively. We therefore conclude that the multi-objective optimization-based template mining technique effectively finds high-quality bug-fixing templates.

With the introduction of smart contacts, Ethereum has become one of the most popular blockchain networks. In the wake of its popularity, an increasing number of Ethereum-based software have been developed. However, the carbon emissions resulting from these software has been pointed out as a global issue. It is necessary to reduce the energy consumed by these software to reduce carbon emissions. Recently, most studies have focused on smart contracts and proposed energy-efficient methods for the development of carbon friendly Ethereum networks. However, in addition to smart contracts, the energy used by client software in Ethereum networks should also be reviewed. This is because the client software performs all functions occurring in the Ethereum network, including smart contracts. Therefore, energy bugs that waste energy in Ethereum client software should be investigated and solved. The first task to enable this is to build an energy bug benchmark of Ethereum client software. This study introduces ECench, an energy bug benchmark of Ethereum client software. ECench includes 507 energy buggy commits from 7 series of client software that are officially operated in the Ethereum network. We carefully collected and manually reviewed them for cleaner commits. A key strength of our benchmark is that it provides eight energy wastage categories, which can serve as a cornerstone for researchers to identify energy waste codes. ECench can provide a valuable starting point for studies on energy reduction and carbon reduction in Ethereum.

Deep learning-based automated program repair (DL-APR) can automatically fix software bugs and has received significant attention in the industry because of its potential to significantly reduce software development and maintenance costs. The Samsung mobile experience (MX) team is currently switching from Java to Kotlin projects. This study reviews the application of DL-APR, which automatically fixes defects that arise during this switching process; however, the shortage of Kotlin defect-fixing datasets in Samsung MX team precludes us from fully utilizing the power of deep learning. Therefore, strategies are needed to effectively reuse the pretrained DL-APR model. This demand can be met using the Kotlin defect-fixing datasets constructed from industrial and open-source repositories, and transfer learning. This study aims to validate the performance of the pretrained DL-APR model in fixing defects in the Samsung Kotlin projects, then improve its performance by applying transfer learning. We show that transfer learning with open source and industrial Kotlin defect-fixing datasets can improve the defect-fixing performance of the existing DL-APR by 307%. Furthermore, we confirmed that the performance was improved by 532% compared with the baseline DL-APR model as a result of transferring the knowledge of an industrial (non-defect) bug-fixing dataset. We also discovered that the embedded vectors and overlapping code tokens of the code-change pairs are valuable features for selecting useful knowledge transfer instances by improving the performance of APR models by up to 696%. Our study demonstrates the possibility of applying transfer learning to practitioners who review the application of DL-APR to industrial software.

Automated Feedback Generation (AFG) was proposed to automatically generate personalized feedback on students' programming assignments. Existing AFG techniques have been developed mainly for novice programmers, so feedback on complex programs cannot be generated. Therefore, we propose MUNCK, which automatically generates feedback for multiple function programs, one of the complex programs. Our experiment shows that MUNCK can generate feedback for 90% of multiple function programs.

Information retrieval-based bug localization (IRBL) aims at finding buggy files using a bug report as a query. IRBL performance is highly dependent on the query quality. To improve the query quality for IRBL, automatic query expansion (AQE) method has been proposed for identifying query-related terms from the first-retrieved source files. This approach inevitably depends on two determinant of post- retrieval results, the retrieval model and the initial query quality. We propose a novel word embedding-based AQE technique, WEQE, to avoid the heavy dependency of the current AQE approach. Word embedding model enables to fetch terms semantically related to a query by representing words in a vector space. Our method embeds the words from both the global corpus and project-specific-corpus. The initial query is extended by adding words semantically similar to it based on vector representations from our embedding model. We validated the effectiveness of WEQE by using 4,583 bug reports from seven projects, four IRBL models, and two em-bedding models. Our large-scale experimental results show that WEQE can improve the average precision for bug localization for at least 42% of all queries. Our expanded queries on the best IRBL model achieve a 6% higher mean average precision for bug localization than the initial query.

A growing interest in deep learning (DL) has instigated a concomitant rise in DL-related software (DLSW). Therefore, the importance of DLSW quality has emerged as a vital issue. Simultaneously, researchers have found DLSW more complicated than traditional SW and more difficult to debug owing to the black-box nature of DL. These studies indicate the necessity of automatic debugging techniques for DLSW. Although several validated debugging techniques exist for general SW, no such techniques exist for DLSW. There is no standard bug benchmark to validate these automatic debugging techniques. In this study, we introduce a novel bug benchmark for DLSW, Denchmark, consisting of 4,577 bug reports from 193 popular DLSW projects, collected through a systematic dataset construction process. These DLSW projects are further classified into eight categories: framework, platform, engine, compiler, tool, library, DL-based application, and others. All bug reports in Denchmark contain rich textual information and links with bug-fixing commits, as well as three levels of buggy entities, such as files, methods, and lines. Our dataset aims to provide an invaluable starting point for the automatic debugging techniques of DLSW.

Deep learning-based bug localization (DLBL) can effectively reduce software maintenance costs. However, the inherent hub ness problem of the high-dimensional vector of the source code file used in DLBL leads to inaccurate bug localization. To solve this problem, we analyzed 10,359 defects and found that the call graph and flow of the program can distinguish buggy files from non-buggy files, and provide functional semantic information for bug localization. Based on our observations, we propose a feature combination to alleviate the hubness problem of the source file representation by using functional semantic information. Our proposed method models the functional semantics with the call graph and program flow based on the raw abstract syntax tree. We evaluated the effectiveness of the proposed approach on 19 widely used projects and conducted an ablation study. The experimental results show that the proposed method can improve the current approaches by 12 % to 45 %, with differentiating buggy files and non-buggy files. In our ablation study, functional information shows its significance as the absence of functional semantics deteriorates performance by 8.5 %.

This paper proposes an evolved Self-Adaptive Interactive Navigation Tool (SAINT+) to reduce the delivery time of emergency services and to improve navigation efficiency for the vehicles influenced by accidents. To the best of our knowledge, SAINT+ is the first attempt to optimize the delivery of emergency services as well as the navigation routes of vehicles around accident areas. Based on the congestion contribution model of SAINT and aggregated information from vehicles in the vehicular cloud, we propose a virtual path reservation strategy for emergency vehicles to guarantee a fast emergency service delivery. We also develop an accident area protection scheme based on an adjusted congestion contribution matrix and protection zones to evacuate vehicles in the accident area. To further reduce travel delay of neighbor vehicles in the accident area, we also present a dynamic traffic flow control model. Through extensive simulations with a real-world map, SAINT+ outperforms other state-of-the-art schemes for the travel delay of emergency vehicles. In scenarios with a high vehicle density, SAINT+ reduces the travel delay of emergency vehicles by 42.2%.

From regression tests, developers seek to determine not only the existence of faults, but also failure information such as what test cases failed. Failure information can assist in identifying suspicious modules or functions in order to fix the detected faults. In continuous integration environments, this can also help managers of the source code repository address unexpected situations caused by regression faults. We introduce an approach, referred to as AFSAC, which is a test case prioritization technique based on history data, that can be used to effectively obtain failure information. Our approach is composed of two stages. First, we statistically analyze the failure history for each test case to order the test cases. Next, we reorder the test cases utilizing the correlation data of test cases acquired by previous test results. We performed an empirical study on two open-source Apache software projects (i.e., Tomcat and Camel) to evaluate our approach. The results of the empirical study show that our approach provides failure information to testers and developers more effectively than other prioritization techniques, and each prioritizing method of our approach improves the ability to obtain failure information.

A bug report is mainly used to find a fault location in software maintenance. It contains several fields such as summary, description, status and version. The description field includes detail scenario and stack traces if exceptional messages are presented. Recently researchers have proposed several approaches for automatic bug localization by using information retrieval and data mining. We propose BLIA, a statically integrated analysis approach of IR-based bug localization by utilizing texts and stack traces in bug reports, structured information of source files, and source code change histories. We performed experiments on three open source projects, namely AspectJ, SWT and ZXing. Compared with prior tools, our experiment results showed that BLIA outperforms the existing tools in terms of mean average precision. Our approach on average improved the metric of BugLocator, BLUiR, BRTracer and AmaLgam by 34%, 23%, 17% and 8%, respectively.

Agile development methods are being recognized as popular and efficient approaches to the development of software systems that have features such as a short delivery period and unclear requirements. They emphasize customer satisfaction, fast response to changes, and release in less time. According to a recent survey, SCRUM is one of the most popular methods that are currently being used. Some backlogs, especially high priority backlogs that are functional requirements of customers, are developed repeatedly at each sprint period. Despite the known advantages of SCRUM, however, its backlogs focus only on functional features. Thus, it is difficult to effectively reflect the softwares quality attributes. As known, the failure of a software project is caused by the non-satisfaction not of functional features but of quality attributes, such as performance, usability, and reliability. This paper introduces the ACRUM that is a quality attribute driven agile development method. The main characteristic of the proposed solution is that it is derived from values and practices of SCRUM to be compatible with the SCRUM process and to keep its agility intact. The effect of ACRUM was evaluated through an agile process evaluation checklist and applying it into a commercial project of Samsung Electronics. The results showed that ACRUM is more efficient than the legacy agile development process.

Cloud computing allows users to use only a Web browser to receive computing services via the Internet. Users only need to pay for the services they actually use. It appears that a wide adoption of cloud computing in the foreseeable future is inevitable, and its adoption will bring about a sea change in the pricing and distribution practices for both software and hardware. There are, however, various issues that will impede adoption of cloud computing. Most of them can be solved. We discuss the status of cloud computing today and various adoption issues. We also provide a market prognosis.

Cloud computing allows users to use only a Web browser to receive computing services via the Internet. Users only need to pay for the services they actually use. It appears that a wide adoption of cloud computing in the foreseeable future is inevitable, and its adoption will bring about a sea change in the pricing and distribution practices for both software and hardware. There are, however, various issues that will impede adoption of cloud computing. Most of them can be solved. We discuss the status of cloud computing today and various adoption issues. We also provide a market prognosis.

In maintenance, the lack of documentation leads to high costs of reverse engineering. Generally, design-pattern is a reusable solution to a commonly occurring problem in software design. If design-patterns could be captured and reused in reverse engineering, the reverse engineering would be very helpful those who develops and maintains software. So there have been many attempts to detect design-patterns during reverse engineering. However, the approaches suffer from serious drawbacks to its practical implementation; false positive, false negative rate, the number of detected patterns. In this paper, we propose a new taxonomy of GoF design patterns that can guide the reverse-engineering process. This approach not only combines static analysis with dynamic analysis but also adds what we call the implementation- specific analysis. We apply a number of existing and new applications, including PURE toolkit, JINI based home application system, project management tool, MP3 player, and we demonstrate that the reverse engineering process is more accurate.

It is an important issue for software architects to estimate the performance of software in the early stage of development process due to the needs to verify QoS. Queueing network model is a very useful tool to analyze the performance of a system from abstract model. In this paper, we propose a transformation technique from UML into queueing network model. This approach avoids the need for a prototype implementation since we can determine the overall form of performance equation from the architectural design description. We prove the accuracy of derived queueing network model, which is summarized at 85 percent, through a ubiquitous commerce system which extends mobile commerce system developed by our prior work.

In ubiquitous environments, which involve an even greater number of computing devices, with more informal modes of operation, this type of problem have rather serious consequences. In order to solve these problems when they arise, effective reliable systems are required. Also, system management is changing from a conventional central administration, to autonomic computing. However, most existing research focuses on healing after a problem has already occurred. In order to solve this problem, a prediction model is required to recognize operating environments and predict error occurrence. In this paper, a hybrid prediction model through four algorithms supporting self-healing in autonomic computing is proposed. This prediction model adopts a selective healing model, according to system situations for self-diagnosing and prediction of problems using four algorithms. In this paper, a hybrid prediction model is adopted to evaluate the proposed model in a self-healing system. In addition, prediction is compared with existing research and the effectiveness is demonstrated by experiment

Most distributed computing environments today are extremely complex and time-consuming for human administrators to manage. Thus, there is increasing demand for the self-healing and self-diagnosing of problems or errors arising in systems operating within today's ubiquitous computing environment. This paper proposes a proactive self-healing system that monitors, diagnoses and heals its own internal problems using self-awareness as contextual information. The proposed system consists of Multi-Agents that analyze the log context, error events and resource status in order to perform self-healing and self-diagnosis. To minimize the resources used by the Adapters, which monitor the logs in an existing system, we place a single process in memory. By this, we mean a single Monitoring Agent monitors the context of the logs generated by the different system components. For rapid and efficient self-healing, we use a 6-step process. The effectiveness of the proposed system is confirmed through practical experiments conducted with a prototype system.

Agent based development is a new technology that has been recently used in many domains. However, the development of an agent-based system can be difficult and time-consuming for inexperienced developers. To address this problem, in this paper, we propose a pattern based agent development and support tool. This approach facilitates rapid agent development and addresses common design problem. The agent patterns are classified according to function. We apply this approach for agent development, based on a travel assistant scenario.

Process planning plays a key role by linking CAD and CAM. Its front-end is feature recognition, but feature recognition research has not been in accord with the requirements of process planning. This paper presents an effort for integrating the two activities: feature-based machining sequence generation primarily based on tool capabilities. The system recognizes only manufacturable features by consulting the tool database, and simultaneously constructs dependencies among the features. Then, the A* algorithm is used to search for an optimal machining sequence by the aid of the feature dependencies and a manufacturing cost function.

With the increasing importance of EC (Electronic Commerce) across the Internet, the need for agents to support both customers and suppliers is growing rapidly. But the lack of standard on product ontology, message and negotiation protocol between agents and brokering makes full automation of EC infeasible. In this paper, we describe an open infrastructure for agent-based EC and design a virtual market server. As an open infrastructure, we propose a complete architecture and message protocol for inter-agent negotiation. We designed and partially implemented a virtual marker server, named ICOMA (Intelligent electronic COmmerce system based on Multi-Agent) based on the advanced agent technologies. The goal of ICOMA is to construct the decentralized, dynamic, and diverse EC environment.

LOTOS formal description technique (FDT) is applied to the formal description of distributed systems and the specification of OSI protocol layers. LOTOS is difficult to understand and to learn because it is based on a mathematical model. In this paper, for supporting the knowledge acquisition of learners studying basic LOTOS, we suggest a new algorithm that can verify an equivalence relation, find an error location, and correct an error when the error occurs at another process. Finally, we give an example of a prototype program for an educational support system for basic LOTOS.

The core of the problem of Information Gathering is how to generate a concise, high-quality response to the information needs of a user. However, this task is becoming difficult due to the explosion in the amount of electronic information. Agent-based solutions have become an popular approach for locating information in an growing distributed heterogeneous environment like Internet. We first survey the existing non-agent and partially agent-based solutions; then to overcome their drawbacks we propose a completely agent-based solutions, when the different types of agents introduced-named user agent, machine agent, manager-cooperate to decrease user load and gain efficiency in the retrieval process.

Proposes a completely agent-based approach for information gathering on information networks with a large number of distributed heterogeneous sources, such as Internet. Locating and accessing information in such a large distributed system which changes dynamically is challenging. An agent-based solution is the most suitable in such situations. We first review the drawbacks of existing non-agent and partially agent-based solutions for locating information on Internet. We introduce a CAS model to express a Society of Cooperative Agents and then explain how our completely agent based solution based on the proposed CAS model overcomes the weak points of existing approaches.

The reuse of existing software is one of the most effective ways for software development. We have focused on the specification process with FDTs (Formal Description Techniques), and have proposed a new concept of similarity based on LTSs (Labelled Transition Systems) as a criterion to reuse specifications. However, it's definition has some problems, such that (a) it can't be applied to an LTS with some loops, and (b) the definition of similarity between actions is not clearly expressed. In this paper, we remove these problems in order for our approach to be widely applicable. For the first problem, we extend the definition of similarity to be able to apply to an LTSs with some loops. For the second one, we consider that the similarity of actions is defined based on not only the name of actions, but also the attribute of actions and the way of occurrence of actions as the temporal ordering.

To flexibly develop services on communication systems, support for specification description is more important than others in development processes. We have developed a specification description language HSC for communication systems. In this paper, we propose a new design method, and its support environment. The method and system effectively utilize the features of HSC and also apply the CBR technique for reusing service specifications being developed. We have experimented with service specifications of communication systems by using this system. Through these experiments, the effectiveness of this method and its support environment is ensured.