Rabeb Mizouni

Merging partial system behaviours : composition of use-case automata

Modelling the behaviour of a system under development has proved to be a very effective way to ensure that it will be constructed correctly. However, building up this model is a difficult task that requires a significant time investment and a high level of expertise. Consequently, incremental approaches that construct a system model from partial behavioural descriptions have been widely adopted. The challenge in such approaches lies in finding both the adequate behavioural formalism that fits the needs of the analyst and a formal composition mechanism that facilitates the generation of the expected behavioural model and produces a verifiable model. Within this framework, use-case approaches have been also accepted in industry because they make the process of requirements elicitation simpler. Their main shortcoming is their lack of formalisation, which makes validation difficult. A formal approach for composing partial system behaviours where partial system behaviours are defined as finite state automata is proposed. Each automaton represents a use-case that describes a certain system concern, hence the name use-case automaton (UCA). The composition of different UCAs could be performed with respect to a set of states or transitions specified by the analyst, using certain composition operators. Each of these operators has a precise semantics, which is defined by how the composition is performed. The formalization of use-case composition is based on label matching between the UCAs to be composed. Our approach is fully automated and provides the advantage of generating a UCA that meets the intended behaviour without unexpected scenarios. Finally, the UMACT, which implements our composition approach, is presented.

Towards a framework for estimating system NFRs on behavioral models

Complete and precise software requirements description is critical in successful development of software systems. This description should specify both functional requirements (FRs), that define the different functionalities the system should perform, and non-functional requirements (NFRs), that define attributes of how the system should perform these functional requirements. Even though their satisfaction is of capital importance to the final product acceptance, little has been done in order to consider NFRs as early as possible in the development process. To date, NFRs are often dismissed in first stages, causing an eventual failure of the final product. In scenario-based approaches, behavioral models (BMs) representing formalization of different use cases are commonly generated. These BMs are composed to generate a formal specification of the system under development. In current practices, these BMs do not handle NFRs, a shortcoming of these approaches. We address this issue and we propose a framework where NFRs are defined as a set of non-functional goals. The framework assists the analyst to: (1) distribute the NFRs of the system among the partial behavioral models defining its specification (2) define estimations of the NFR goals each partial behavior should fulfill with respect to a system NFR goal (3) compose the different behavioral models and their NFRs. Afterward, the resulting NFR is verified against the NFR goal of the system to validate the estimations the analyst has made.

Modeling Human Decision Behaviors for Accurate Prediction of Project Schedule Duration

Simulation techniques have been widely applied in many disciplines to predict duration and cost of projects. However, as projects grew in size, they also grew in complexity making effective project planning a challenging task. Despite several attempts to achieve accurate predictions, simulation models in use are still considered to be oversimplified. They often fail to cope with uncertainty due to the complex modeling of the high number of interrelated factors. In this paper we propose a simulation model to cope with human resources uncertainty. We use the proxel-based simulation method to analyze and predict duration of project schedules exhibiting high uncertainty and typical human resources reallocation. The proxel-based simulation is an approximate simulation method that is proven to be more precise than discrete-event simulation. To model uncertainty, we introduce a new type of task, state-dependent (floating) task that supports and demonstrates a high degree of uncertainty in human resources allocation. In fact, it allows attributing different probability distributions to the same activity, depending on the team that may perform it. We use software development scheduling to illustrate our approach.

Floating Task: Introducing and Simulating a Higher Degree of Uncertainty in Project Schedules

Despite several attempts to accurately predict duration and cost of projects, simulation models in use are still over simplified and nonrealistic. They often fail to cope with real-life scenarios and uncertainty. In this paper we use the proxel-based simulation method to analyze and predict duration of project schedules exhibiting high uncertainty due to typical on-the-fly human decision behavior. The proxel-based simulation is an approximate simulation method that is more precise than discrete-event simulation. To model uncertainty, we introduce a new type of task, state-dependent (floating) task that supports and demonstrates a high degree of uncertainty and depends on various parameters in the schedule. For example, the probability distribution of the duration of a task can change depending on the team that performs it. Thus, this kind of task can be used to model the frequent re-scheduling in a project. We use software development process to illustrate our approach.

Formal Composition of Distributed Scenarios

Eliciting, modeling, and analyzing the requirements are the main challenges to face up when you want to produce a formal specification for distributed systems. The distribution and the race conditions between events make it difficult to include all the possible scenario combinations and thus to get a complete specification. Most research about formal methods dealt with languages and neglected the process of how getting a formal specification. This paper describes a scenario-based process to synthesize a formal specification in the case of a distributed system. The requirements are represented by a set of use cases where each one is composed of a collection of distributed scenarios. The architectural assumptions about the communication between the objects of the distributed system imply some completions and reorganizations in the use cases. Then, the latter are composed into a global finite state machine (FSM) from which we derive a communicating FSM per object in the distributed system.

Bridging the gap: empowering use cases with task models

Use cases have become the standard for modeling functional requirements, whereas task models are used to capture UI requirements. Despite recent advances, software engineering (SE) and user interface (UI) design methods are poorly integrated making it difficult for SE and UI teams to collaborate, synchronize their efforts and avoid inconsistencies. To address these issues, we propose an integrated development methodology for use cases and task models. Both artifacts are used to specify software requirements, but emphasize two different aspects in a complementary manner. The integration consists of using CTT task models to iteratively enrich UI related steps in the use case model. We demonstrate that such an approach allows for a clear separation of concerns and therefore avoids potential inconsistencies between the two artifacts.

Composition of use cases using synchronization and model checking

Capturing the behavior of a system by use cases have been intensively investigated in the last decade. The challenge is to find both the adequate model that fits the needs of the analyst and a formal composition mechanism which helps the generation of the expected behavior. In this paper, we propose a formal approach for specifying and composing use cases based on assignments. Those assignments are used to express new use cases. An assignment provides the join points and the composition operators that will be taken into account during the composition. These join points are, in fact, determined through a model checking step. They represent states where a property defined by the analyst holds. In order to evaluate these assignments, we define a composition mechanism based on the well known concept of synchronized product.

Enriching Use Cases with CTTs

User interface (UI) development methods are poorly integrated with standard software engineering (SE) practices. Despite current efforts of closing the conceptual gap between these two disciplines, there is still a lack of methodologies supporting a collaborative and synchronized development approach. To address this shortcoming, we propose an integrated development methodology for use cases and task models. Use cases have become the standard to model functional requirements, whereas task models are used to specify UI requirements. Based on this understanding we propose using CTT task models to incrementally enrich the UI-related steps in the use case model, thus achieving a clear separation of concerns and avoiding potential inconsistencies between the two artifacts.

Tool Support for Composition and Verification of Formal Behavior

In this paper, we present a tool support for formal modeling, automated composition, and formal verification of partial system behaviors described as use case automata (UCAs). The tool, called UCOMV, supports visual modeling of formal behaviors and their merging through the notion of composition expressions. These expressions specify the extension points in the UCAs where the composition is performed, as well as the semantics of the intended composition. UCOMV supports a new incremental approach of building the desired behavioral model by using a formal automated mechanism of composition. In addition, it allows the verification of UCAs over behavioral properties defined as temporal property specifications.

Hybrid tool integrating HOL theorem proving with MDG model checking

We describe a hybrid tool for hardware formal verification that links the HOL theorem prover and the MDG (multiway decision graphs) model checker. Our tool supports abstract datatypes and uninterpreted function symbols available in MDG, allowing the verification of high level specifications. The hybrid tool, HOL-MDG, is based on an embedding in HOL of the grammar of the hardware modeling language, MDG-HDL, as well as an embedding of the first-order temporal logic L/sub mdg/ used to express properties for the MDG model checker. Verification with the hybrid tool is faster and more tractable than using either tools separately. We hence obtain the advantages of both verification paradigms.