From Use Case to Use Case Slices: An Automated Approach

Introduction

Jacobson et al. (1992) propose that a use case is a specific way of using the system by performing some part of the functionality. Rumbaugh et al. (2004) introduce the use case model into the unified model languages (UML) (2011). The famous software development process, called the Rational Unified Process, is a use case-driven process (Jacobson et al., 1999). Use case-driven analysis and design methods have been widely used in modern software engineering since their formal introduction by Jacobson et al. (1992).

A complete set of use cases specifies all the different ways to use the system, and accordingly defines all required behavior of the system. Use cases are a common technique to capture system functionality and requirements. The implementation of use cases using traditional object-oriented languages and techniques typically breaks use case modularity into their implementation. But a big use case may be too complex and too difficult to understand during software development process. Even the simplest use case will cover multiple slices which consist of one or more stories. The slices enable the use cases to be broken down into appropriately sized pieces of work for the development team to tackle. By slicing up the use cases we can achieve the finer grained control required to maximize the value in each release during agile software development process. We need to slice the use cases and select the stories to be implemented. This is the observation that Jacobson and Ng (2005) exploited to make the connection with the work on aspects. They proposed use case slices as a modularization unit to address these problems. Use case slices are pieces of the use case model and other UML models that deal with a specific concern, which have become the core concept of Use-Case 2.0 which is proposed by Jacobson et al. (2016).

A use case model can be created on a high abstraction level or a very detailed level. A use case model with a very detailed level can be a lot more useful for requirements elicitation, but such a model may become very complex and difficult to understand the whole context. It is necessary to slice a use case into slices to understand easily and facilitate the development (Jacobson et al. 2016). Each slice contains one or more stories selected from a use case, forming a work item that is of value to the stakeholders. Most existing work, e.g., Jacobson and Ng (2005), Silva et al. (2016) and Cruz et al. (2014), have proposed approaches for obtaining use case slices from use cases in the agile incremental development process. But these slices are not automatically (or semi-automatically) generated.

In this paper, we present an automated approach for dividing a use case into use case slices. The approach is one of formal methods. Formal methods are techniques used to model complex systems as mathematical entities. By building a mathematically rigorous model of a complex system, designers can not only verify the system’s properties in a more thorough fashion, but also use mathematical proof as a complement to system testing to ensure correct behavior. Our approach first decomposes a use case into multiple use case stories, and then these stories can be composed into different use case slices according to different requirements. All the possible use case slices cover all the functionality of the original use case. To fulfil the automatic translation, we first present an abstract structure (called a flow structure) which is closer to the use case description. The structure specifies the relations of events in a use case and then presents the semantics of the flow structure. Then it is translated into a formal model called a dependency structure (Jiang et al., 2011, Jiang et al., 2013, Jiang et al., 2017 and Jiang et al., 2018). The dependency structure model generalizes the traditional event-based formal models such as event structures (Winskel & Nielsen 1995). Moreover, a flow structure can directly and simply be translated into a dependency structure. Base on the dependency structure, we propose a decomposition theory and develop the corresponding algorithm. With the help of the prototype tool, case studies demonstrate the correctness of the approach. The automatic decomposition approach reduces errors, improve efficiency and shorten time compared with the traditional manual decomposition. No matter how simple or complex a system is, our approach can help us get all use case stories quickly and clearly from event flows.