Goal-oriented requirements analysis such as iStar are one of the promising approaches to elicit requirements from stakeholders. However, poor goal models lead to missing requirements and eliciting incorrect requirements as well as less comprehensiveness ones. This paper picks up iStar and proposes a technique to automate detecting bad smells of iStar models, i.e., symptoms of poor models. Firstly, to clarify bad smells, we collected iStar models and developed a list of bad smells. We classified the listed bad smells into two categories: 9 structural bad smells and 4 semantic ones. In the structural bad smells, we focused on the number of graph nodes and the depth of element relationships in iStar models, while in the semantic ones, we used the semantic similarity between descriptions of iStar elements written in natural language. Furthermore, we have developed an automated smell detector for 13 bad smells. Through experiments conducted to evaluate the usefulness of this automated detection tool, our detector could detect 79% of the structural bad smells and 50% of the semantic bad smells, including those that our human subjects overlooked. In addition, the experimental results allowed us to add new 3 bad smells to our smell list.

Some documents, such as use case descriptions, describe features consisting of multiple concepts with following a procedural flow. Because existing feature location techniques lack a relation between concepts in such features, it is difficult to identify the concepts in the source code with high accuracy. This paper presents a technique to locate concepts in a feature described in a structured document consisting of multiple procedural steps, such as a use case description, using dependency between the concepts. We apply an existing concept location technique to descriptions of concepts and obtain a list of modules. Modules failing to match the dependency between concepts are filtered out. Then, we can obtain a more precise list of modules. The conducted experiment underscores the effectiveness of our technique.

It is necessary to gather real refactoring instances while conducting empirical studies on refactoring. However, existing refactoring detection approaches are insufficient in terms of their accuracy and coverage. Reducing the manual effort of curating refactoring data is challenging in terms of obtaining various refactoring data accurately. This paper proposes a tool named RefactorHub, which supports users to manually annotate potential refactoring-related commits obtained from existing refactoring detection approaches to make their refactoring information more accurate and complete with rich details. In the proposed approach, the parameters of each refactoring operation are defined as a meaningful set of code elements in the versions before or after refactoring. RefactorHub provides interfaces and supporting features to annotate each parameter, such as the automated filling of dependent parameters, thereby avoiding wrong or uncertain selections. A preliminary user study showed that RefactorHub reduced annotation effort and improved the degree of agreement among users. Source code and demo video are available at https://github.com/salab/RefactorHub

Problem: Modern systems contain parts that are themselves systems. Such complex systems thus have sets of subsystems that have their own variability. These subsystems contribute to the functionality of a whole system-of-systems (SoS). Such systems have a very high degree of variability. Therefore, a modeling technique for the variability of an entire SoS is required to express two different levels of variability: variability of the SoS as a whole and variability of subsystems. If these levels are described together, the model becomes hard to understand. When the variability model of the SoS is described separately, each variability model is represented by a tree structure and these models are combined in a further tree structure. For each node in a variability model, a quantity is assigned to express the multiplicity of its instances per one instance of its parent node. Quantities of the whole system may refer to the number of subsystem instances in the system. From the viewpoint of the entire system, constraints and requirements written in natural language are often ambiguous regarding the quantities of subsystems. Such ambiguous constraints and requirements may lead to misunderstandings or conflicts in an SoS configuration. Approach: A separate notion is proposed for variability of an SoS; one model considers the SoS as an undivided entity, while the other considers it as a combination of subsystems. Moreover, a domain-specific notation is proposed to express relationships among the variability properties of systems, to solve the ambiguity of quantities and establish the total validity. This notation adapts an approach, named Pincer Movement, which can then be used to automatically deduce the quantities for the constraints and requirements. Validation: The descriptive capability of the proposed notation was validated with four examples of cloud providers. In addition, the proposed method and description tool were validated through a simple experiment on describing variability models with real practitioners.

In the world of the Internet of Things (IoT), heterogeneous systems and devices need to be connected and exchange data with others. How data exchange can be automatically realized becomes a critical issue. An information model (IM) is frequently adopted and utilized to solve the data interoperability problem. Meanwhile, as IoT systems and devices can have different IMs with different modeling methodologies and formats such as UML, IEC 61360, etc., automated data interoperability based on various IMs is recognized as an urgent problem. In this paper, we propose an approach to automate the data interoperability, i.e. data exchange among similar entities in different IMs. First, similarity scores among entities are calculated based on their syntactic and semantic features. Then, in order to precisely get similar candidates to exchange data, a concept of class distance calculated with a Virtual Distance Graph (VDG) is proposed to narrow down obtained similar properties for data exchange. Through analyzing the results of a case study, the class distance based on VDG can effectively improve the precisions of calculated similar properties. Furthermore, data exchange rules can be generated automatically. The results reveal that the approach of this research can efficiently contribute to resolving the data interoperability problem.

Bug localization is an important aspect of software maintenance because it can locate modules that should be changed to fix a specific bug. Our previous study showed that the accuracy of the information retrieval (IR)-based bug localization technique improved when used in combination with code smell information. Although this technique showed promise, the study showed limited usefulness because of the small number of: (1) projects in the dataset, (2) types of smell information, and (3) baseline bug localization techniques used for assessment. This paper presents an extension of our previous experiments on Bench4BL, the largest bug localization benchmark dataset available for bug localization. In addition, we generalized the smell-aware bug localization technique to allow different configurations of smell information, which were combined with various bug localization techniques. Our results confirmed that our technique can improve the performance of IR-based bug localization techniques for the class level even when large datasets are processed. Furthermore, because of the optimized configuration of the smell information, our technique can enhance the performance of most state-of-the-art bug localization techniques.

To improve the usability of a revision history, change untangling, which reconstructs the history to ensure that changes in each commit belong to one intentional task, is important. Although there are several untangling approaches based on the clustering of fine-grained editing operations of source code, they often produce unsuitable result for a developer, and manual tailoring of the result is necessary. In this paper, we propose ChangeBeadsThreader (CBT), an interactive environment for splitting and merging change clusters to support the manual tailoring of untangled changes. CBT provides two features: 1) a two-dimensional space where fine-grained change history is visualized to help users find the clusters to be merged and 2) an augmented diff view that enables users to confirm the consistency of the changes in a specific cluster for finding those to be split. These features allow users to easily tailor automatically untangled changes.

A decaying module refers to a module whose quality is getting worse and is likely to become smelly in the future. The concept has been proposed to mitigate the problem that developers cannot track the progression of code smells and prevent them from occurring. To support developers in proactive refactoring process to prevent code smells, a prediction approach has been proposed to detect modules that are likely to become decaying modules in the next milestone. Our prior study has shown that modules that developers will modify as an estimation of developers' context can be used to improve the performance of the prediction model significantly. Nevertheless, it requires the developer who has perfect knowledge of locations of changes to manually specify such information to the system. To this end, in this study, we explore the use of automated impact analysis techniques to estimate the developers' context. Such techniques will enable developers to improve the performance of the decaying module prediction model without the need of perfect knowledge or manual input to the system. Furthermore, we conduct a study on the relationship between the accuracy of an impact analysis technique and its effect on improving decaying module prediction, as well as the future direction that should be explored.

While extracting a subset of a commit history, specifying the necessary portion is a time-consuming task for developers. Several commit-based history slicing techniques have been proposed to identify dependencies between commits and to extract a related set of commits using a specific commit as a slicing criterion. However, the resulting subset of commits become large if commits for systematic edits whose changes do not depend on each other exist. We empirically investigated the impact of systematic edits on history slicing. In this study, commits in which systematic edits were detected are split between each file so that unnecessary dependencies between commits are eliminated. In several histories of open source systems, the size of history slices was reduced by 13.3-57.2% on average after splitting the commits for systematic edits.

Use case modeling is very popular to represent the functionality of the system to be developed, and it consists of two parts: use case diagram and use case description. Use case descriptions are written in structured natural language (NL), and the usage of NL can lead to poor descriptions such as ambiguous, inconsistent and/or incomplete descriptions, etc. Poor descriptions lead to missing requirements and eliciting incorrect requirements as well as less comprehensiveness of produced use case models. This paper proposes a technique to automate detecting bad smells of use case descriptions, symptoms of poor descriptions. At first, to clarify bad smells, we analyzed existing use case models to discover poor use case descriptions concretely and developed the list of bad smells, i.e., a catalogue of bad smells. Some of the bad smells can be refined into measures using the Goal-Question-Metric paradigm to automate their detection. The main contribution of this paper is the automated detection of bad smells. We have implemented an automated smell detector for 22 bad smells at first and assessed its usefulness by an experiment. As a result, the first version of our tool got a precision ratio of 0.591 and recall ratio of 0.981.

Developers often save multiple kinds of source code edits into a commit in a version control system, producing a tangled change, which is difficult to understand and revert. However, its separation using an existing sequence-based change representation is tough. We propose a new visualization technique to show the details of a tangled change and align its component edits in a tree structure for expressing multiple groups of changes. Our technique is combined with utilizing refactoring detection and change relevance calculation techniques for constructing the structural tree. Our combination allows us to divide the change into several associations. We have implemented a tool and conducted a controlled experiment with industrial developers to confirm its usefulness and efficiency. Results show that by using our tool with tree visualization, the subjects could understand and decompose tangled changes easier, faster, and higher accuracy than the baseline file list visualization.

Bug localization is a technique that has been proposed to support the process of identifying the locations of bugs specified in a bug report. A traditional approach such as information retrieval (IR)-based bug localization calculates the similarity between the bug description and the source code and suggests locations that are likely to contain the bug. However, while many approaches have been proposed to improve the accuracy, the likelihood of each module having a bug is often overlooked or they are treated equally, whereas this may not be the case. For example, modules having code smells have been found to be more prone to changes and faults. Therefore, in this paper, we explore a first step toward leveraging code smells to improve bug localization. By combining the code smell severity with the textual similarity from IR-based bug localization, we can identify the modules that are not only similar to the bug description but also have a higher likelihood of containing bugs. Our preliminary evaluation on four open source projects shows that our technique can improve the baseline approach by 142.25% and 30.50% on average for method and class levels, respectively.

Existing techniques for detecting code smells (indicators of source code problems) do not consider the current context, which renders them unsuitable for developers who have a specific context, such as modules within their focus. Consequently, the developers must spend time identifying relevant smells. We propose a technique to prioritize code smells using the developers' context. Explicit data of the context are obtained using a list of issues extracted from an issue tracking system. We applied impact analysis to the list of issues and used the results to specify the context‐relevant smells. Results show that our approach can provide developers with a list of prioritized code smells related to their current context. We conducted several empirical studies to investigate the characteristics of our technique and factors that might affect the ranking quality. Additionally, we conducted a controlled experiment with professional developers to evaluate our technique. The results demonstrate the effectiveness of our technique.

Code smells are considered to be indicators of design flaws or problems in source code. Various tools and techniques have been proposed for detecting code smells. The number of code smells detected by these tools is generally large, so approaches have also been developed for prioritizing and filtering code smells. However, the lack of empirical data regarding how developers select and prioritize code smells hinders improvements to these approaches. In this study, we investigated professional developers to determine the factors they use for selecting and prioritizing code smells. We found that Task relevance and Smell severity were most commonly considered during code smell selection, while Module importance and Task relevance were employed most often for code smell prioritization. These results may facilitate further research into code smell detection, prioritization, and filtration to better focus on the actual needs of developers.

Feature location (FL) is an important activity for finding correspondence between software features and modules in source code. Although dynamic FL techniques are effective, the quality of their results depends on analysts to prepare sufficient scenarios for exercising the features. In this paper, we propose a technique for guiding identification of missing scenarios using the prior FL result. After applying FL, unexplored call dependencies are extracted by comparing the results of static and dynamic analyses, and analysts are advised to investigate them for finding missing scenarios. We propose several metrics that measure the potential impact of unexplored dependencies to help analysts sort out them. Through a preliminary evaluation using an example web application, we showed our technique was effective for recommending the clues to find missing scenarios.

To find opportunities for applying prefactoring, several techniques for detecting bad smells in source code have been proposed. Existing smell detectors are often unsuitable for developers who have a specific context because these detectors do not consider their current context and output the results that are mixed with both smells that are and are not related to such context. Consequently, the developers must spend a considerable amount of time identifying relevant smells. As described in this paper, we propose a technique to prioritize bad code smells using developers' context. The explicit data of the context are obtained using a list of issues extracted from an issue tracking system. We applied impact analysis to the list of issues and used the results to specify which smells are associated with the context. Consequently, our approach can provide developers with a list of prioritized bad code smells related to their current context. Several evaluations using open source projects demonstrate the effectiveness of our technique.

A socio-technical system (STS) consists of many different actors such as people, organizations, software applications and infrastructures. We call actors except both people and organizations machines. Machines should be carefully introduced into the STS because the machines are beneficial to some people or organization but harmful to others. We thus propose a goal-oriented requirements modelling language called GDMA based on i* so that machines with the following characteristics can be systematically specified. First, machines make the goals of each people be achieved more and better than ever. Second, machines make people achieve goals fewer and easier than ever. We also propose analysis techniques of GDMA to judge whether or not the introduction of machines are appropriate or not. Several machines are introduced into an as-is model of GDMA locally with the help of model transformation techniques. Then, such an introduction is evaluated globally on the basis of metrics derived from the model structure. We confirmed that GDMA could evaluate the successful and failure of existing projects.

This paper presents Historef, a tool for automating edit history refactoring on Eclipse IDE for Java programs. The aim of our history refactorings is to improve the understandability and/or usability of the history without changing its whole effect. Historef enables us to apply history refactorings to the recorded edit history in the middle of the source code editing process by a developer. By using our integrated tool, developers can commit the refactored edits into underlying SCM repository after applying edit history refactorings so that they are easy to manage their changes based on the performed edits.

The elicitation of security requirements is a crucial issue to develop secure business processes and information systems of higher quality. Although we have several methods to elicit security requirements, most of them do not provide sufficient supports to identify security threats. Since threats do not occur so frequently, like exceptional events, it is much more difficult to determine the potentials of threats exhaustively rather than identifying normal behavior of a business process. To reduce this difficulty, accumulated knowledge of threats obtained from practical setting is necessary. In this paper, we present the technique to model knowledge of threats as patterns by deriving the negative scenarios that realize threats and to utilize them during business process modeling. The knowledge is extracted from Security Target documents, based on the international Common Criteria Standard, and the patterns are described with transformation rules on sequence diagrams. In our approach, an analyst composes normal scenarios of a business process with sequence diagrams, and the threat patterns matched to them derives negative scenarios. Our approach has been demonstrated on several examples, to show its practical application.

Feature location is an activity to identify correspondence between features in a system and program elements in source code. After a feature is located, developers need to understand implementation structure around the location from static and/or behavioral points of view. This paper proposes a semi-automatic technique both for locating features and exposing their implementation structures in source code, using a combination of dynamic analysis and two data analysis techniques, sequential pattern mining and formal concept analysis. We have implemented our technique in a supporting tool and applied it to an example of a web application. The result shows that the proposed technique is not only feasible but helpful to understand implementation of features just after they are located.

Goal-oriented requirements analysis (GORA) is one of the promising techniques to elicit software requirements, and it is natural to consider its application to security requirements analysis. In this paper, we proposed a method for goal-oriented security requirements analysis using security knowledge which is derived from several security targets (STs) compliant to Common Criteria (CC, ISO/IEC 15408). We call such knowledge security ontology for an application domain (SOAD). Three aspects of security such as confidentiality, integrity and availability are included in the scope of our method because the CC addresses these three aspects. We extract security-related concepts such as assets, threats, countermeasures and their relationships from STs, and utilize these concepts and relationships for security goal elicitation and refinement in GORA. The usage of certificated STs as knowledge source allows us to reuse efficiently security-related concepts of higher quality. To realize our proposed method as a supporting tool, we use an existing method GOORE (goal-oriented and ontology-driven requirements elicitation method) combining with SOAD. In GOORE, terms and their relationships in a domain ontology play an important role of semantic processing such as goal refinement and conflict identification. SOAD is defined based on concepts in STs. In contrast with other goal-oriented security requirements methods, the knowledge derived from actual STs contributes to eliciting security requirements in our method. In addition, the relationships among the assets, threats, objectives and security functional requirements can be directly reused for the refinement of security goals. We show an illustrative example to show the usefulness of our method and evaluate the method in comparison with other goal-oriented security requirements analysis methods.

When information systems are introduced in a social setting such as a business, the systems will give bad and good impacts on stakeholders in the setting. Requirements analysts have to predict such impacts in advance because stakeholders cannot decide whether the systems are really suitable for them without such prediction. In this paper, we propose a method based on model transformation patterns for introducing suitable information systems. We use metrics of a model to predict whether a system introduction is suitable for a social setting. Through a case study, we show our method can avoid an introduction of a system, which was actually bad for some stakeholders. In the case study, we use a strategic dependency model in i* to specify the model of systems and stakeholders, and attributed graph grammar for model transformation. We focus on the responsibility and the satisfaction of stakeholders as the criteria for suitability about systems introduction in this case study.

This paper proposes a concept for refactoring an edit history of source code and a technique for its automation. The aim of our history refactoring is to improve the clarity and usefulness of the history without changing its overall effect. We have defined primitive history refactorings including their preconditions and procedures, and large refactorings composed of these primitives. Moreover, we have implemented a supporting tool that automates the application of history refactorings in the middle of a source code editing process. Our tool enables developers to pursue some useful applications using history refactorings such as task level commit from an entangled edit history and selective undo of past edit operations.

This paper proposes structured location, a semiautomatic technique and its supporting tool both for locating features and exposing their structures in source code, using a combination of dynamic analysis, sequential pattern mining and formal concept analysis.

Comparing and understanding differences between old and new versions of source code are necessary in various software development situations. However, if refactoring is applied between those versions, then the source code differences are more complicated, and understanding them becomes more difficult. Although many techniques for extracting refactoring effects from the differences have been studied, it is necessary to exclude the extracted refactorings' effects and reconstruct the differences for meaningful and understandable ones with no refactoring effect. As described in this paper, we propose a novel technique to address this difficulty. Using our technique, we extract the refactoring effects and then apply them to the old version of source code to produce the differences without refactoring effects. We also implemented a support tool that helps separate refactorings automatically. An evaluation of open source software showed that our tool is applicable to all target refactorings. Our technique is therefore useful in real situations. Evaluation testing also demonstrated that the approach reduced the code differences more than 21%, on average, and that developers can understand more changes from the differences using our approach than when using the original one in the same limited time.

We propose an ontology-based technique for recovering trace ability links between a natural language sentence specifying features of a software product and the source code of the product. Some software products have been released without detailed documentation. To automatically detect code fragments associated with sentences describing a feature, the relations between source code structures and problem domains are important. We model the knowledge of the problem domains as domain ontologies having concepts of the domains and their relations. Using semantic relations on the ontologies in addition to method invocation relations and the similarity between an identifier on the code and words in the sentences, we locate the code fragments corresponding to the given sentences. Additionally, our prioritization mechanism which orders the located results of code fragments based on the ontologies enables users to select and analyze the results effectively. To show effectiveness of our approach in terms of accuracy, a case study was carried out with our proof-of-concept tool and summarized.

To elicit software requirements, we have to have knowledge about a problem domain, e.g., healthcare, shopping or banking where the software is applied. A description of domain knowledge such as a domain ontology helps requirements analysts to elicit requirements completely and correctly to some extent even if they do not have such knowledge sufficiently. Several requirements elicitation methods and tools using domain knowledge description have been thus proposed, but how to develop and to enhance such description is rarely discussed. Summarizing existing documents related to the domain is one of the typical ways to develop such description, and an interview to domain experts is another typical way. However, requirements cannot be elicited completely only with such domain-specific knowledge because a user of such knowledge, i.e., a requirements analyst is not a domain expert in general. Requirements could be also elicited more correctly with both specific and general knowledge because general knowledge sometimes improves understandings of analysts about domain-specific knowledge. In this paper, we propose a method and a tool to enhance an ontology of domain knowledge for requirements elicitation by using Web mining. In our method and our tool, a domain ontology consists of concepts and their relationships. Our method and tool helps an analyst with a domain ontology to mine general concepts necessary for his requirements elicitation from documents on Web and to add such concepts to the ontology. We confirmed enhanced ontologies contribute to improving the completeness and correctness of elicited requirements through a comparative experiment.

We propose iFL, an interactive environment that is useful for effectively understanding feature implementation by application of feature location (FL). With iFL, the inputs for FL are improved incrementally by interactions between users and the FL system. By understanding a code fragment obtained using FL, users can find more appropriate queries from the identifiers in the fragment. Furthermore, the relevance feedback obtained by partially judging whether or not a fragment is relevant improves the evaluation score of FL. Users can then obtain more accurate results. Case studies with iFL show that our interactive approach is feasible and that it can reduce the understanding cost more effectively than the non-interactive approach.

This paper proposes an ontology-based technique for recovering traceability links between a natural language sentence specifying features of a software product and the source code of the product. Some software products have been released without detailed documentation. To automatically detect code fragments associated with the functional descriptions written in the form of simple sentences, the relationships between source code structures and problem domains are important. In our approach, we model the knowledge of the problem domains as domain ontologies. By using semantic relationships of the ontologies in addition to method invocation relationships and the similarity between an identifier on the code and words in the sentences, we can detect code fragments corresponding to the sentences. A case study within a domain of painting software shows that we obtained results of higher quality than without ontologies.

This paper presents an integrated supporting tool for Attributed Goal-Oriented Requirements Analysis (AGORA), which is an extended version of goal-oriented analysis. Our tool assists seamlessly requirements analysts and stakeholders in their activities throughout AGORA steps including constructing goal graphs with group work, prioritizing goals, and version control of goal graphs.

This paper proposes a novel technique to detect the occurrences of refactoring from a version archive, in order to reduce the effort spent in understanding what modifications have been applied. In a real software development process, a refactoring operation may sometimes be performed together with other modifications at the same revision. This means that understanding the differences between two versions stored in the archive is not usually an easily process. In order to detect these impure refactorings, we model the detection within a graph search. Our technique considers a version of a program as a state and a refactoring as a transition. It then searches for the path that approaches from the initial to the final state. To improve the efficiency of the search, we use the source code differences between the current and the final state for choosing the candidates of refactoring to be applied next and estimating the heuristic distance to the final state. We have clearly demonstrated the feasibility of our approach through a case study.

In software development with frameworks, it is essential to use the framework with which given software requirements are implementable. This paper focuses on use cases as the requirements specifications and proposes a technique to check whether the given use cases are implementable with the framework. To check the implementability, consistency of branch conditions of the frameworks and the requirements specification has to be checked as well as equivalence of action sequences between the frameworks and the requirements specification. To this end, a novel approach based on a satisfiability problem for deriving the consistent truth assignments of the branch conditions is introduced. The approach can be incorporated in bi-simulation checking for assuring the equivalence of the action sequences, and therefore, the implementability can be checked. Furthermore, this paper shows a feasibility of the proposed technique by using Compositional Reachability Analysis as a mean of bi-simulation checking.

Requirements changes frequently occur at any time of a software development process and their management is a crucial issue to develop software of high quality. Meanwhile, recently goal-oriented analysis techniques are being put into practice to elicit requirements. In this situation, the change management of goal graphs and its support is necessary. This paper presents two topics related to change management of goal graphs; 1) version control of goal graphs and 2) impact analysis on a goal graph when its modifications occur. In our version control system, we extract the differences between successive versions of a goal graph by means of monitoring modification operations performed through a goal graph editor, and store them in a repository. Our impact analysis detects conflicts that arise when a new goal is added, and investigates the achievability of the other goals when the existing goal is deleted.

Domain knowledge is one of crucial factors to get a great success in requirements elicitation of high quality, and only domain experts, not requirements analysts, have it. We propose a new requirements elicitation method ORE (ontology based requirements elicitation), where a domain ontology can be used as domain knowledge. In our method, a domain ontology plays a role on semantic domain which gives meanings to requirements statements by using a semantic function. By using inference rules on the ontology and a quality metrics on the semantic function, an analyst can be navigated which requirements should be added for improving completeness of the current version of the requirements and/or which requirements should be deleted from the current version for keeping consistency. We define this process as a method and evaluate it by an experimental case study of software music players

This paper proposes an extension of goal-oriented analysis method where an idea generation method is combined. Goal-oriented analysis methods are one of the promising approaches for requirements elicitation. However, they have two major shortcomings; 1) little support for goal elicitation and decomposition into sub-goals and 2) no explicit support for collaborative activities by stakeholders to elicit goals. In particular, stakeholders as the knowledge source play an important role on eliciting requirements of high quality and all of them should participate in requirements elicitation activities. In our technique, an idea generation method like Brainstorming is used to identify sub-goals. The team of stakeholders focuses on a goal and generates the ideas related to the goal. And then the team groups the generated ideas together into sub-goals. These steps are intertwined by an idea generation method and all of the stakeholders can participate in idea generation and grouping tasks.

In iterative software development methodology, a version control system is used in order to record and manage modification histories of products such as source codes and models described in diagrams. However, conventional version control systems cannot manage the models in a logical unit because the systems mainly handle with source codes. In this paper, we propose a technique of version control based in a logical unit for models described in diagrams. Then we illustrate the feasibility of our approach with the implementation of version control functions on a meta-CASE tool that is able to generate a modeling tool in order to deal with various diagrams.

Goal oriented requirements analysis is one of the useful method to bridge the gaps between stakeholders needs and a requirements specification. Goals are structured as a directed graph, and its upper parts show the needs and its lower parts show the requirements. Although goals come from several different viewpoints, such viewpoints are not separated explicitly in such a goal graph. As a result, following kinds of problems can be occurred. First, we cannot easily remove or modify one viewpoint which affects several different goals. Second, it is difficult to analyze several different viewpoints separately and/or incrementally. For example, we cannot analyze a family of products simultaneously. Third, such a graph is not intrinsically scalable. In this paper, we propose a method to weave several goal graphs each of which represents a viewpoint. Several candidates of a weaved graph are systematically generated based on the structural characteristics of graphs for each viewpoint. By using this method, we can overcome the problems above, and we can easily propose alternative requirements specification if a specification is rejected by stakeholders.

We propose a new requirements elicitation method in the domains of ERP, CRM, and SCM by using specifications of several existing package software. We have analyzed the requirements elicitation processes of experienced analysts in a specific domain, and found that they clarify requirements by referring the specifications of existing packages that seem to be satisfied with customer's needs. This process can be formulated into two subprocesses: 1) package selection, where an analyst compares the customer's needs with functions/nonfunctions of packages and selects the suitable candidates of packages; and 2) requirements evolution, where he examines the selected packages with his customer and an approved part of specifications of packages are added into their requirements. The proposed method, called PAORE (package oriented requirements elicitation method) is designed based on the analysis. We applied this method to a simple but realistic example of Web-based sales supporting system and assessed it.

We present an extended version of goal-oriented analysis methods where an idea generation method is combined to reinforce the support of the step for identifying subgoals by a team of stakeholders. To assess our method, experimental results are also discussed.

This paper presents an extended version of the goal-oriented requirements analysis method called AGORA, where attribute values, e.g. contribution values and preference matrices, are added to goal graphs. An analyst attaches contribution values and preference values to edges and nodes of a goal graph respectively during the process for refining and decomposing the goals. The contribution value of an edge stands for the degree of the contribution of the sub-goal to the achievement of its parent goal, while the preference matrix of a goal represents the preference of the goal for each stakeholder. These values can help an analyst to choose and adopt a goal from the alternatives of the goals, to recognize the conflicts among the goals, and to analyze the impact of requirements changes. Furthermore the values on a goal graph and its structural characteristics allow the analyst to estimate the quality of the resulting requirements specification, such as correctness, unambiguity, completeness etc. The estimated quality values can suggest which goals should be improved and/or refined. In addition, we have applied AGORA to a user account system and assessed it.

The quality of an architectural design of a software system has a great influence on achieving non-functional requirements to the system. In this paper, we present a technique for describing behavioral aspects of software architectures formally based on Coloured Petri Nets (CPNs) and a technique for evaluating their non-functional qualities by analyzing CPNs with a supporting tool. We provide quality models for evaluating security, efficiency and reliability, and integrate them with CPN descriptions of software architectures. Their qualities are evaluated by simulating the CPNs on CPN analysis tool called Design/CPN. To show the effectiveness of our techniques, we illustrate Applet architecture and CGI one in a web computing application, and evaluate their quality of security on network, of time-efficiency and of reliability on network by using Design/CPN. It allows us to clarify trade-off on issues of selecting which architecture should be selected.

Experts in requirements elicitation interview stakeholders using various levels of knowledge to grasp and elicit users' requirements. This paper analyzes expert interview processes and explores a computation model for simulating them. This model can be used to navigate a novice analyst's interview processes. It consists of a blackboard model and a state transition model in order to narrow the candidates for questions that an expert analyst will ask stakeholders next in the interview process. The candidates are selected based on information that has been elicited from stakeholders, and the blackboard model is for holding this information in the form of IEEE 830, a standard form of requirements specification documents. We have analyzed experts' interview processes and constructed a computation model in the sales management domain. We also recorded novice processes and showed that we could improve them by means of the model.

The scenario-based approach is a promising technique not only to elicit requirements from stakeholders but also to achieve user-participatory development. Techniques to construct scenarios of high quality with less effort are necessary. In addition, since during the development of a system its requirements are frequently changed by customers and/or users, the techniques to manage changes to the scenarios and to handle the change propagations in the scenarios are also crucial. This paper proposes a solution to the above issues based on reusable pattern techniques and a case grammar of natural-language processing techniques. We abstract case frames as reusable primitive parts to write sentences in a scenario and patterns to combine the case frames so that we can get consistent scenario episodes.

Software patterns such as gang-of-four (GOF) design patterns are a promising approach for developing software of high quality with less effort. To design larger and complicated software, we often combine design patterns into a larger one, and in this situation obtaining a consistent combination of patterns is important. More concretely, the techniques for checking if the combined patterns are consistently collaborated from a behavioral view is a crucial issue. We propose a technique to define the behavior of the design patterns based on the formal description technique LOTOS (Language of Temporal Ordering Specification). By executing the behavioral descriptions on a LOTOS simulator, we can check the behavioral consistency of the patterns. We also illustrate how our technique works well by using the combination of GOF composite and command patterns.

This paper discusses a supporting tool for developing software specifications in collaboration of a team — for cooperative specification processes. Typical cooperative specification processes consist of three phases — (1) making a working plan by a team in face-to-face session, (2) performing an assigned task, i.e. designing an assigned part by each member in distributed session, and (3) integrating the developed products in face-to-face session. In this paper, we focus on the support for the second phase, i.e. performing the distributed individual task that a team leader has assigned in the first phase. Our supporting tool consists of two parts; one is called method base, a kind of CASE tool for individual use, and the other is a structured E-mail system for communication use. Method base has various catalogued specification and design methods, so a worker can select a suitable method for his problem domain. He can be navigated through the CASE tool, e.g. the diagram editor, that supports the selected method. Method base has information about product structures and the relationships among the product structures of the different methods. Thus method base can integrate the products developed with the multiple methods by different workers into one. The tools for communications among other members are necessary, and especially a kind of structured E-mail system is very useful for the members to communicate with each other in the second phase. Our E-mail system supports (1) sending and receiving the products with messages or with comments by using hyper-link mechanism, (2) composing comprehensive messages easily by using templates, (3) storing messages in structured mail folders and retrieving them, and (4) automatically notifying the modification of products and the progress status of development activities to the workers.

This paper discusses a technique to model software patterns for supporting pattern based software development. Software development can be considered as the evolution of the artifacts to be produced. Software patterns are general structures that frequently appear in the artifacts and the patterns are also being evolved as the artifacts are being done. By specifying how to evolve software patterns as software processes progress, we can get a support for developing an artifact from the artifacts that were produced in the previous steps. In our approach, we consider that a software pattern consists of a pattern structure (a class diagram and/or an object diagram) and manipulation operations on the pattern structure. These operations are for pattern instantiation (applying a pattern to an actual problem) and for pattern evolution (evolving the artifacts of the previous steps into a new one). We model them with the object-oriented technique encapsulating these operations into patterns.

The paper presents a supporting technique for changing specification documents automatically so that the specifications can be consistent with source codes when the source codes are modified. In our technique, we represent a program with multiple graphs and we consider the changes on programs as the modification of the graphs. The modification of the graphs is formalized with a sequence of the operation on the graphs. We design the rules of how to relate the operations on program graphs to the operations on graphs that represent specification documents. By applying these rules, we can detect what modification and which parts of the specification document should be made to maintain the consistency between the specification and the program, when the program is modified.

We present reusable patterns appearing in use case based requirements analysis processes. In the processes, analysts have interviews with and questionnaires for the stakeholders to get information about their problems, and then they compose the requirements specifications that are readable to the stakeholders. We adopt the use case approach to specify the requirements. We abstract the requirements descriptions written in use cases into patterns, so that we can reuse the experience in requirements analysis. From a case study of a simple example problem, we design questionnaire forms and a set of patterns of reusable structured use cases.

This paper discusses a technique which shows how to integrate formal description techniques (FDTs) with specification & design methods such as OMT so that we can have new methods to support writing formal specifications. The integration mechanism is based on transformation rules of specification document produced following methods into the descriptions written in FDTs. The transformation rules specify the correspondences on two meta models; the method meta models and the FDT meta model, and are described as graph rewriting rules. As an example, we pick up OMT as a method and LOTOS as a FDT and define the transformation rule on their meta models.

Object-oriented software essentially has dynamic aspect such as object creation, deletion and dynamic binding during execution. This aspect makes behavior analysis and tests of object-oriented software significantly complicated. In this paper we propose a new technique of object-oriented software analysis and testing by using Coloured Petri Nets (CPN), which is an extended version of Petri Net, one of formal techniques having the ability to analyze concurrent behavior. We represent identified objects with colored tokens of a CPN expressing object oriented software in order to avoid the net-explosion problem. We provide translation rules of object-oriented software into a CPN and a technique to analyze and test effectively the net to investigate several behavioral properties. Our translation technique is essentially independent of which language we describe software. As an example, to show the effectiveness of our technique, we pick up UML (Unified Modeling Language) and translate a specification written in it into a CPN. The net is analyzed tested and simulated as a prototype of the specification.

In the process of requirements elicitation in software development, it is usual for participants with different roles to have a series of meetings and requirements analysts to compose specification documents between the meetings. There have many studies supporting these processes, such as cooperative working models in meetings, tools based on those models, and specification and design methods such as structured analyses and object-oriented analysis. However, there have been no studies describing specification documents based on contents of meetings. Participants communicate verbally with each other, so we consider that an effective method should be based on verbal histories. i.e. utterances appearing in meetings. We propose a method to write specification documents considering that structures of meetings are reflected into structures of specification documents. Briefly, the assumed basis of our method is that analysts put pairs of subsequently discussed topics (we call them "temporally adjacent topics") into close positions in the tree structures of the specification documents. We also assess the feasibility and the effectiveness of the method through several experiments and case studies.

Article Software development process from natural language specification Share on Authors: Motoshi Saeki Tokyo Institute of Technology, 2-12-1 Ookayama, Meguro-ku, Tokyo 152, Japan Tokyo Institute of Technology, 2-12-1 Ookayama, Meguro-ku, Tokyo 152, JapanView Profile , Hisayuki Horai Fujitsu Limited IIAS-SIS, 1-17-25 Shin-Kamata, Oota-ku, Tokyo 144, Japan Fujitsu Limited IIAS-SIS, 1-17-25 Shin-Kamata, Oota-ku, Tokyo 144, JapanView Profile , Hajime Enomoto Fujitsu Limited IIAS-SIS, 1-17-25 Shin-Kamata, Oota-ku, Tokyo 144, Japan Fujitsu Limited IIAS-SIS, 1-17-25 Shin-Kamata, Oota-ku, Tokyo 144, JapanView Profile Authors Info & Claims ICSE '89: Proceedings of the 11th international conference on Software engineeringMay 1989 Pages 64–73https://doi.org/10.1145/74587.74594Published:15 May 1989 26citation846DownloadsMetricsTotal Citations26Total Downloads846Last 12 Months63Last 6 weeks14 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access