Shane Sendall

From use cases to system operation specifications

The purpose of this paper is to first showcase the concept of an operation schema a precise form of system-level operation specification and secondly show how operation schemas enhance development when they are used as a supplement to use case descriptions. An operation schema declaratively describes the effects of a system operation by pre- and postconditions using the Object Constraint Language (OCL), as defined by the Unified Modeling Language (UML). In particular, the paper highlights techniques to map use cases to operation schemas and discusses the advantages of doing so in terms of clarifying the granularity and purpose of use cases and providing a precise specification of system behavior.

Specifying Concurrent System Behavior and Timing Constraints Using OCL and UML

Despite advances in implementation technologies for distributed systems during the last few years, little attention has been given to distributed systems within software development methodologies. The contribution of this paper is a UML-based approach for specifying concurrent behavior and timing constraints-- often inherent characteristics of distributed systems. We propose a novel approach for specifying concurrent behavior of reactive systems in OCL and several constructs for precisely describing timing constraints on UML statemachines.More precisely, we show how we enriched operation schemas--pre- and postcondition assertions of system operations written in OCL--by extending the current calculus with constructs for asserting synchronization on shared resources. Also, we describe how we use new and existing constructs for UML statemachines to specify timing constraints on the system interface protocol (SIP)--a restricted form of UML protocol statemachine. Finally, we discuss how both the extended system operation and SIP models are complementary.

Bridging the gap between IEEE 1471, an architecture description language, and UML

Abstract.A lot of attention has been paid to software architecture issues in academia, industrial research and standardization organizations working in the software area. The software architecture research community has focused on the creation and improvement of special-purpose languages: architecture description languages (ADLs). However, ADLs lack adequate support for separating various kinds of stakeholders’ concerns along different viewpoints. But also, they do not address the difference between the architecture of a software system and its representations. In contrast, ANSI/IEEE-Std-1471 makes a clear distinction between the architecture and the architectural description of a software system.In this paper, we propose ConcernBASE, a UML-based approach to software architecture, which instantiates the conceptual framework defined in ANSI/IEEE-Std-1471 and complements the abstractions and mechanisms found in current ADLs. ConcernBASE provides a viewpoint for structural descriptions of software architectures that supports key concepts of ADLs and defines a UML profile as a viewpoint language. We validate this profile through a mapping between a representative ADL, called Structural ADL (SADL), and the new profile and by providing a UML-based tool prototype, called ConcernBASE Modeler, which integrates with SADL tools.

Using OCL and UML to Specify System Behavior

Use cases are an excellent tool for capturing behavioral requirements of software systems, but they are not an ideal work product for driving design activities. We believe that there is value from complementing use case descriptions with pre- and postcondition descriptions, not only to better support reasoning about system properties and a basis for testing and debugging, but also to better support a predictable decomposition level on which one can base a systematic transition to design. Nevertheless, we recognize that pre- and postcondition descriptions are not widely used in practice. We believe this is in part due to the formalism used. Either the formalism is too heavy to learn and use, or the formalism does not offer sufficient abstraction from the vocabulary of implementation.Via an example, the paper highlights our approach for specifying system behavior, which uses the Unified Modeling Language (UML) and its Object Constraint Language (OCL). We focus the paper on pre- and postconditions descriptions and in particular propose a number of enhancements and interpretations to OCL that we made while refining our approach. In particular, we describe a number of issues that cover areas such as the frame problem, incremental descriptions, structuring schemas, and events and exceptions.

UML-based fusion analysis

In recent times, there has been an increased requirement for software to be distributed. The well-known Fusion development method, however, can only be used to develop sequential reactive systems, and certain restricted kinds of concurrent systems. In contrast, the Unified Modeling Language (UML) provides a rich set of notations that can be used to model systems that are distributed. In addition, UML provides the ability to introduce rigor into diagrams through its constraint language OCL. In this paper, we present a UML-based Fusion analysis phase by way of a simple bank case study, and we discuss some enhancements that were made in addition to a mapping of notations; our proposal is the first step towards providing a Fusion-based analysis phase which supports high-level modeling of distributed systems.

Integrating the ConcernBASE Approach with SADL

We describe ConcernBASE, a UML-based approach that is an instantiation of the IEEEs Conceptual Framework (Std 1471) for describing software architectures. We show how the approach supports advanced separation of concerns in software architecture by allowing one to identify and define multiple viewpoints, concern spaces and views of an architecture. Our work focuses on integrating the ConcernBASE approach with the Structural Architecture Description Language (SADL) in order to make the verification capabilities of SADL available to those who develop in UML. The result is a UML profile for structural description of software architecture. The paper also presents a prototype tool that supports this UML profile.

Requirements Elicitation with Use Cases

Nowadays, the complexity of the software systems that needs to be produced is staggering. Developing such systems requires that the development team first understands the problem, i.e., they have a global picture of what is required to be built, before they can make a sensible judgment on an architecture for the solution. Use cases offer a simple, storytelling-like way to capture the requirements. They provide a means for facilitating the capture and validation of requirements from stakeholders, technical and non-technical alike, which makes them an important tool to have in ones development kit. The simplicity of the use case concept is nevertheless deceptive, because writing effective use cases requires much practice and experience. In fact, there are many issues that must be addressed on the road to mastering requirements elicitation with use cases. In this tutorial, a number of these issues will be raised and addressed, giving the participants a better understanding of what an effective use case is, how to produce them, and where use cases in general can be appropriately applied.