Towards developing consistent misuse case models

Secure software development should begin at the early stages of the development life cycle. Misuse case modeling is a technique that stems from traditional use case modeling, which facilitates the elicitation and modeling functional security requirements at the requirements phase. Misuse case modeling is an effective vehicle to potentially identify a large subset of these threats. It is therefore crucial to develop high quality misuse case models otherwise end system developed will be vulnerable to security threats. Templates to describe misuse cases are populated with syntax-free natural language content. The inherent ambiguity of syntax-free natural language coupled with the crucial role of misuse case models in development can have a very detrimental effect. This paper proposes a structure that will guide misuse case authors towards developing consistent misuse case models. This paper also presents a process that utilizes this structure to ensure the consistency of misuse case models as they evolve, eliminating potential damages caused by inconsistencies. A tool was developed to provide automation support for the proposed structure and process. The feasibility and application of this approach were demonstrated using two real-world case studies.     

Using model transformation to refactor use case models based on antipatterns

Use Case modeling is a popular technique for documenting functional requirements of software systems. Refactoring is the process of enhancing the structure of a software artifact without changing its intended behavior. Refactoring, which was first introduced for source code, has been extended for use case models. Antipatterns are low quality solutions to commonly occurring design problems. The presence of antipatterns in a use case model is likely to propagate defects to other software artifacts. Therefore, detection and refactoring of antipatterns in use case models is crucial for ensuring the overall quality of a software system. Model transformation can greatly ease several software development activities including model refactoring. In this paper, a model transformation approach is proposed for improving the quality of use case models. Model transformations which can detect antipattern instances in a given use case model, and refactor them appropriately are defined and implemented. The practicability of the approach is demonstrated by applying it on a case study that pertains to biodiversity database system. The results show that model transformations can efficiently improve quality of use case models by saving time and effort.     

Automatic test generation: a use case driven approach

Use cases are believed to be a good basis for system testing. Yet, to automate the test generation process, there is a large gap to bridge between high-level use cases and concrete test cases. We propose a new approach for automating the generation of system test scenarios in the context of object-oriented embedded software, taking into account traceability problems between high-level views and concrete test case execution. Starting from a formalization of the requirements based on use cases extended with contracts, we automatically build a transition system from which we synthesize test cases. Our objective is to cover the system in terms of statement coverage with those generated tests: an empirical evaluation of our approach is given based on this objective and several case studies. We briefly discuss the experimental deployment of our approach in the field at Thales Airborne Systems.     

Constructing high quality use case models: a systematic review of current practices

There is an increasing recognition for the need to develop high quality use case models from the professional and academic communities. Quality in use case models is of particular importance when they are utilized within a use case driven development process, whereby every aspect of development is driven by the models and influenced by their quality. Many practitioners and researchers have provided guidelines, suggestions and techniques to construct high quality use case models. This invaluable body of knowledge is disseminated across numerous literature resources. Without unifying this knowledge into one resource, it cannot be expected that a use case modeler would be fully aware of the entire body of knowledge and benefitting from it. This paper presents a systematic review that was conducted in order to identify and amalgamate this knowledge. The amalgamated knowledge is presented in a unified form, specifically as a set of 26 anti-patterns, which modelers can use to improve the quality of their models.     

Partial order semantics for use case and task models

Use case models are the specification medium of choice for functional requirements, while task models are employed to capture User Interface (UI) requirements and design information. In current practice, both entities are treated independently and are often developed by different teams, which have their own philosophies and lifecycles. This lack of integration is problematic and often results in inconsistent functional and UI design specifications causing duplication of effort while increasing the maintenance overhead. To address these shortcomings, we propose a formal semantic framework for the integrated development of use case and task models. The semantic mapping is defined in a two step manner from a particular use case or task model notation to the common semantic domain of sets of partially ordered sets. This two-step mapping results in a semantic framework that can be more easily reused and extended. The intermediate semantic domains have been carefully chosen by taking into consideration the intrinsic characteristics of use case and task models. As a concrete example, we provide a semantics for our own DSRG use case formalism and an extended version of ConcurTaskTrees, one of the most popular task model notations. Furthermore, we use the common semantic model to formally define a set of refinement relations for use case and task models.     

Configuring use case models in product families

In many domains such as automotive and avionics, the size and complexity of software systems is quickly increasing. At the same time, many stakeholders tend to be involved in the development of such systems, which typically must also be configured for multiple customers with varying needs. Product Line Engineering (PLE) is therefore an inevitable practice for such systems. Furthermore, because in many areas requirements must be explicit and traceability to them is required by standards, use cases and domain models are common practice for requirements elicitation and analysis. In this paper, based on the above observations, we aim at supporting PLE in the context of use case-centric development. Therefore, we propose, apply, and assess a use case-driven configuration approach which interactively receives configuration decisions from the analysts to generate product-specific (PS) use case and domain models. Our approach provides the following: (1) a use case-centric product line modeling method (PUM), (2) automated, interactive configuration support based on PUM, and (3) an automatic generation of PS use case and domain models from Product Line (PL) models and configuration decisions. The approach is supported by a tool relying on Natural Language Processing (NLP) and integrated with an industrial requirements management tool, i.e., IBM DOORS. We successfully applied and evaluated our approach to an industrial case study in the automotive domain, thus showing evidence that the approach is practical and beneficial to capture variability at the appropriate level of granularity and to configure PS use case and domain models in industrial settings.     

A knowledge-based system for improving the consistency between object models and use case narratives

In today’s systems development environments, object models are playing an increasingly important role in contributing to the agility and flexibility expected of the information systems being built. While current computer-aided software engineering tools can aid in creating object models, they do not provide much support in ensuring that the object models created are consistent with the specifications in use case narratives. This paper presents a methodology and a knowledge-based system to facilitate the verification of consistency of a given object model against a set of use case narratives. The methodology is implemented as a prototype knowledge-based extension to an open source CASE tool. The prototype’s ability to reliably extract relevant information from use case narratives and its role in verifying the consistency of object models have been evaluated using a laboratory experiment. By analyzing use case narratives utilizing natural language processing techniques and applying collaboration patterns and heuristics, this methodology can determine missing and invalid model elements to guide the analyst in creating object models that are consistent with the requirements specified in a set of use case narratives. The results from this design science research indicate that the prototype system can be a useful tool to assist in this process.     

Data mining source code for locating software bugs: A case study in telecommunication industry

In a large software system knowing which files are most likely to be fault-prone is valuable information for project managers. They can use such information in prioritizing software testing and allocating resources accordingly. However, our experience shows that it is difficult to collect and analyze fine-grained test defects in a large and complex software system. On the other hand, previous research has shown that companies can safely use cross-company data with nearest neighbor sampling to predict their defects in case they are unable to collect local data. In this study we analyzed 25 projects of a large telecommunication system. To predict defect proneness of modules we trained models on publicly available Nasa MDP data. In our experiments we used static call graph based ranking (CGBR) as well as nearest neighbor sampling for constructing method level defect predictors. Our results suggest that, for the analyzed projects, at least 70% of the defects can be detected by inspecting only (i) 6% of the code using a Naïve Bayes model, (ii) 3% of the code using CGBR framework.     

Using use case patterns to estimate reusability in software systems

The applicability of using use case patterns as a basis for software cost estimation in the early stages of software development is described. This required the construction of a use case patterns catalogue using a novel process. The catalogue has been analysed to estimate the potential reusability in different software applications. This has shown that 43% of system functions are generally application domain independent, whereas 57% are application domain dependent. Statistical tests showed that the level of specialisation in software systems could be as low as 20%, which supports the direction taken in this research to build a use case patterns catalogue as a basis for the development of use case based software cost estimation models.     

Data Mining of Software Development Databases

Software quality models can predict which modules will have high risk, enabling developers to target enhancement activities to the most problematic modules. However, many find collection of the underlying software product and process metrics a daunting task.Many software development organizations routinely use very large databases for project management, configuration management, and problem reporting which record data on events during development. These large databases can be an unintrusive source of data for software quality modeling. However, multiplied by many releases of a legacy system or a broad product line, the amount of data can overwhelm manual analysis. The field of data mining is developing ways to find valuable bits of information in very large databases. This aptly describes our software quality modeling situation.This paper presents a case study that applied data mining techniques to software quality modeling of a very large legacy telecommunications software system's configuration management and problem reporting databases. The case study illustrates how useful models can be built and applied without interfering with development.     

An investigation of use case quality in a large safety-critical software development project

Use case modelling is a much-used technique for eliciting and documenting functional requirements. The quality of the use cases may have an important impact on the development project and on the resulting software product. This paper presents an empirical study of the changes that were made to the use case models in a large software project during the analysis phase. The results show (a) which were the most difficult aspects of use case modelling in this project and (b) how the quality of the functional requirements, in particular correctness, completeness, and clarity, was improved through the use case modelling process.     

Test-driven modeling for model-driven development

A new software development process called test-driven modeling applies the Extreme Programming test-driven paradigm in a model-driven development environment. (The basis of this article is a project in Motorola's iDEN division that is extending and migrating a large legacy telecommunication system to new platforms using TDM.) This process involves automatic testing through simulation and using executable models as living software system architecture documents. In TDM, we use the same message sequence charts (MSCs) for both system analysis (or design documents) and unit test cases. Similarly, we use the same high-level modeling diagrams for both automatic code generation and living software architecture documents to guide the system's detailed implementation in later phases. Practical results show that developers can effectively apply TDM to large projects with high productivity and quality in terms of the number of code defects.     

用例模型重构工具的设计与实现

用例模型重构是一种保持模型中系统与外部实体的交互不变而重新组织模型的活动。采用用例模型重构工具，可以快速建立高质量的用例模型。针对重构工具的开发，提出了用于存储用例模型的DTD结构，描述了实现该工具的软件结构。     

Developing comprehensive acceptance tests from use cases and robustness diagrams

In agile development processes, the rewards from acceptance testing are maximized by using the practice to drive the development process. Traditionally, User Stories are used in agile projects to describe a system’s usage scenarios and are utilized as a basis for developing acceptance tests. This paper introduces a technique that aims to achieve the benefits of acceptance testing within large-scale development projects that deploy a V-model development process, specifically those that utilize use case models. The approach is based on utilizing a number of artifacts: use case models supported by robustness diagrams and domain models. The feasibility of the proposed approach is demonstrated by applying it to a real-world system—the RestoMapper system. The results show that a comprehensive set of acceptance tests can be developed based upon use case models.     

Developing a diagnostic system through integration of fuzzy case-based reasoning and fuzzy ant colony system

This study intends to propose a hybrid Case-Based Reasoning (CBR) system with the integration of fuzzy sets theory and Ant System-based Clustering Algorithm (ASCA) in order to enhance the accuracy and speed in case matching. The cases in the case base are fuzzified in advance, and then grouped into several clusters by their own similarity with fuzzified ASCA. When a new case occurs, the system will find the closest group for the new case. Then the new case is matched using the fuzzy matching technique only by cases in the closest group. Through these two steps, if the number of cases is very large for the case base, the searching time will be dramatically saved. In the practical application, there is a diagnostic system for vehicle maintaining and repairing, and the results show a dramatic increase in searching efficiency.     

The application of use cases in systems analysis and design specification

This paper begins by reviewing the application of use cases in the analysis and design phases of software development. At present, a use case derived in analysis is generally mapped into design through the synthesis of object behaviour for all scenarios associated with the use case. Hence the use case level of abstraction is not directly used in this process and a semantic gap exists between analysis and design. With informal textually based use case definitions this is to be expected, however, if the use cases themselves are given a more concrete structure, for example in the form of a statechart, then their direct use becomes more feasible.In this paper we therefore investigate the application of use case structures in the initial design phases of software development. A novel approach is proposed that applies a state based use case model directly to each object in the design architecture. This requires the derivation of a set of repeatable refinement procedures, which remove redundancy and allow the assignment of behaviour to objects with respect to their responsibilities. It is then shown how such procedures may be used in design, filling the semantic gap between analysis and design. By applying the procedures to a case study we identify and evaluate the characteristics of the mapping from use case model to object behaviour and review our approach with respect to other methods. It is concluded that state based use case structures not only represent a succinct analysis format, but may also be used to map analysis models directly into the design process.     

Studying the impact of social interactions on software quality

Correcting software defects accounts for a significant amount of resources in a software project. To make best use of testing efforts, researchers have studied statistical models to predict in which parts of a software system future defects are likely to occur. By studying the mathematical relations between predictor variables used in these models, researchers can form an increased understanding of the important connections between development activities and software quality. Predictor variables used in past top-performing models are largely based on source code-oriented metrics, such as lines of code or number of changes. However, source code is the end product of numerous interlaced and collaborative activities carried out by developers. Traces of such activities can be found in the various repositories used to manage development efforts. In this paper, we develop statistical models to study the impact of social interactions in a software project on software quality. These models use predictor variables based on social information mined from the issue tracking and version control repositories of two large open-source software projects. The results of our case studies demonstrate the impact of metrics from four different dimensions of social interaction on post-release defects. Our findings show that statistical models based on social information have a similar degree of explanatory power as traditional models. Furthermore, our results demonstrate that social information does not substitute, but rather augments traditional source code-based metrics used in defect prediction models.     

Applications of linguistic techniques for use case analysis

Use cases are effective techniques to express the functional requirements of a system in a very simple and easy-to-learn way. Use cases are mainly composed of natural language (NL) sentences, and the use of NL to describe the behaviour of a system is always a critical point, due to the inherent ambiguities originating from the different possible interpretations of NL sentences. We discuss in this paper the application of analysis techniques based on a linguistic approach to detect, within requirements documents, defects related to such an inherent ambiguity. Starting from the proposed analysis techniques, we will define some metrics that will be used to perform a quality evaluation of requirements documents. Some available automatic tools supporting the linguistic analysis of NL requirements have been used to evaluate an industrial use cases document according to the defined metrics. A discussion on the application of linguistic analysis techniques to support the semantic analysis of use cases is also reported.