Consolidating and applying the SDL-pattern approach: a detailed case study

https://doi.org/10.1016/S0950-5849(03)00069-7Get rights and content

Abstract

This paper is on design methodology for communication systems. The SDL-pattern approach proposed recently is consolidated and applied rigorously and in detail to the design of a typical communication system on two levels of abstraction. The design is decomposed into a number of steps, each of which is carried out systematically, building on well-proven, generic pieces of solutions that have proven useful in previous projects. These generic solutions—termed SDL patterns—support reuse-driven design of communication systems, raise the vocabulary of protocol engineer to a problem-oriented level, assist the discovery and exploitation of commonalities, and lead to well-justified designs. The selection and use of SDL patterns is supported by a fine-grained incremental design process, the pattern definition takes advantage of formal design languages, and a set of heuristics addresses the decomposition of communication requirements. All these elements are presented and applied in detail to the design of a simple, but functionally complete communication system.

Introduction

In some respects, communication system design is still more an art rather than an engineering discipline. While design languages as well as analysis techniques have matured over three decades and to-day are state-of-the-art in industry, reuse-oriented design methodologies are still underdeveloped. Design of communication systems usually starts from scratch, design solutions have little commonalities, the vocabulary of the protocol engineer is rather low level, existing design methodologies are often vague, informal, and of coarse granularity. Getting from the communication requirements to a detailed design typically is one large step, usually with little justification.

Several methodologies for the development of communication systems that also cover the design phase have been proposed:

  • In Ref. [20], the SOMT (SDL-oriented Object Modeling Technique) methodology, which addresses requirements analysis and the design of distributed systems, is documented. SOMT is based on UML [18] to describe class and object diagrams, MSC [15] for use cases, and SDL [13] for system structure and behavior. The design starts from an analysis model consisting of a conceptual object model and a set of use cases, and yields an SDL design specification. The design phase is further refined into system design (structural aspects), object design (behavior), and testing (analysis), with SDL as design language. SOMT identifies several development activities and documents, and establishes relationships between them. All activities are supported by commercial tools of the Tau suite [21]. Reuse is not explicitly addressed by the SOMT methodology, although it may be incorporated as a refinement. The design basically consists of two large steps, system design and object design, which are of coarse granularity especially for large systems. No guidance on how to decompose these steps further, for instance, by an incremental design, is given.

  • In Ref. [16], the SDL+ methodology framework, which identifies and outlines development activities and provides some guidelines, is introduced. SDL+ features the combination of MSC, SDL, and ASN.1 [14]. Unlike SOMT, no detailed description of specific development activities is provided. Rather, the objective of SDL+ is to provide a generic framework that is instantiated for domains, projects, or companies. Activities during the requirements analysis and the design are supported by a reuse library, which contains various kinds of documents considered useful for reuse purposes. These documents are produced during a project, and may be transferred to subsequent projects. SDL+ distinguishes between a draft design, containing a domain object model, an architecture out-line, use cases and data interfaces, and the complete formal design specification. Systems may be designed incrementally, however, no specific guidelines for decomposition are given.

  • Another methodology is TIMe (The Integrated Method) [1], which is centered around the use of SDL frameworks [2]. A framework is the skeleton of a system that has to be adapted by the system developer. As such, it can be understood as the blueprint of a system family or product line, which makes TIMe a reuse-directed development methodology. The first member of a system family is developed together with a family-specific framework. In a particular system development, requirements analysis and design activities are performed, leading to the framework and its adaptations. Reusable artifacts are kept in a reuse library that is used across project boundaries. TIMe does not provide any SDL frameworks, as they are usually company- and domain-specific.

  • The SDL-pattern approach [7], [9] focuses on the design activity, which is part of an overall system development process. Starting point for the design activity is a set of system requirements, which is decomposed into a sequence of subsets. The objective of this decomposition is to incrementally develop the SDL design specification by taking the subsets of the sequence into account one by one. For each subset, an analysis is performed, and a detailed design is devised based on a pool of design patterns.

SOMT, SDL+, and TIMe have in common that they address the development of distributed systems, with SDL as the formal design language, covering the entire development trajectory from requirements analysis to implementation. The fact that development activities are identified and outlined makes them rather flexible, however, with the drawback that the amount of guidelines provided to the developer is quite restricted. Also, individual development activities such as the system design remain quite coarse. For the design activity, this situation can be improved. As shown in Ref. [9], the SDL-pattern approach can be integrated with these methodologies as a refinement of the design activity.

In this paper, we consolidate the SDL-pattern approach and apply it rigorously and in detail to the design of a simple, but functionally complete communication system on two levels of abstraction. The design is decomposed into a number of steps, each of which is carried out systematically, building on well-proven, generic pieces of solutions that have proven useful in previous projects. These generic solutions—termed SDL patterns—support reuse-driven design of communication systems, raise the vocabulary of protocol engineers to a problem-oriented level, assist the recognition and exploitation of commonalities, and lead to well-justified designs. The selection and use of SDL patterns is supported by a fine-grained, incremental design process, the pattern definition takes advantage of formal design languages, and a set of heuristics addresses the decomposition of communication requirements.

In Section 2, the SDL-pattern approach is surveyed, with focus on the process model. Section 3 presents the refinement and application of the approach to the design of the InRes system, a simple, but functionally complete communication system providing reliable message exchange over an unreliable medium. The design is done incrementally and reuse-based, with specific emphasis on traceability. In Section 4, we summarize our experiences and lessons learned during our work with the SDL-pattern approach, address transfer to industry in Section 5, and draw conclusions in Section 6.

Section snippets

Survey of the SDL-pattern approach

Reuse of solutions and experience for recurring development problems is of the utmost importance for a pragmatic software engineering discipline. The earlier reuse is achieved in the development process, the larger its positive impact on the project. Design patterns [6] are a well-known reuse approach, and—in contrast to the usual reuse of code fragments—focus on the reuse of design decisions.

In Ref. [7], a specialization of the design pattern concept for the development of communication

The InRes case study

To demonstrate the principles and benefits of pattern-based communication system design, we apply it to the Initiator Responder (InRes) system on two levels of abstraction. The first level is the InRes service, the second level the InRes protocol [12]. Both abstractions have been introduced in the literature as a reference for the comparison of different approaches to the design of communication systems. Although it is not a real communication system, the InRes system has all its important

Experience and lessons learned

Reuse in protocol engineering has not been very successful in the past, so what is the reuse potential offered by the SDL-pattern approach? To get a better feeling here, we have conducted several experiments and have classified the various design steps. The first such experiment [4] has been a student assignment, where an SDL design for a subset of RTP (Real Time Transport Protocol) has been developed, starting from the RFC [19]. As shown in Fig. 16, about 40% of the design steps were supported

Transfer to industry

Currently, the SDL-pattern approach is being transferred to industry. As it has already turned out, it is possible to gradually integrate the approach even into running projects. We have developed a strategy with short term and strategic objectives.

Conclusions

The SDL-pattern approach consists of the SDL-pattern design process, a notation for the description of generic SDL fragments called PA-SDL, a template and rules for the definition of SDL patterns, and an SDL-pattern pool for the communication systems domain. It has been applied successfully to the engineering and re-engineering of several real-life, full size communication systems.

In this paper, we have consolidated the SDL-pattern approach and applied it rigorously and in detail to the design

Acknowledgements

The origin of this paper are the PhD projects of Birgit Geppert and Frank Rößler, who laid the foundations for SDL patterns and conducted several case studies while working in the Computer Networks Group at the University of Kaiserslautern from 1995 to 1999. Meanwhile, the SDL-pattern approach is being transferred to industry. This work has been supported by the Deutsche Forschungsgemeinschaft (DFG) as part of Sonderforschungsbereich (SFB) 501, Development of Large Systems with Generic Methods.

References (21)

  • B Geppert et al.

    Configuring communication protocols using SDL patterns

  • R Reed

    Methodology for real time systems

    Computer Networks and ISDN Systems

    (1996)
  • R Bræk et al.

    Engineering Real Time Systems

    (1993)
  • R Bræk et al.

    Frameworks by means of virtual types-exemplified by SDL

  • D Cisowski et al.

    Tool support for SDL patterns

  • R. Feldmann, B. Geppert, F. Rößler, First results from an experimental evaluation of SDL-pattern basedProtocolDesign,...
  • R. Feldmann, P. Schaible, unpublished notes, University of Kaiserslautern,...
  • E Gamma et al.

    Design Patterns: Elements of Reusable Object-Oriented Software

    (1995)
  • B Geppert et al.

    SDL-pattern based development of a communication subsystem for CAN

  • B. Geppert, The SDL-pattern approach-a reuse-driven SDL methodology for designing communication software systems, PhD...
There are more references available in the full text version of this article.

Cited by (10)

  • Developing safety-critical real-time systems with SDL design patterns and components

    2005, Computer Networks
    Citation Excerpt :

    The complete pattern definitions can be found in [23]. The SDL design pattern approach [6,24,25] consists of a pattern-based design process (see also Section 3), notations for the description of generic UML and SDL fragments called PA-UML and PA-SDL (pattern annotated UML/SDL), a template and rules for the definition of SDL design patterns, and an SDL design pattern pool. The approach has been successfully applied to the engineering and reengineering of several distributed applications and communication protocols, and has been transferred to industry (see Section 2).

  • Protocol engineering

    2012, Protocol Engineering
  • Modelling and verification of the system requirement specification of train control system using SDL

    2011, Proceedings - 2011 10th International Symposium on Autonomous Decentralized Systems, ISADS 2011
  • Model-driven protocol design based on component oriented modeling

    2010, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
View all citing articles on Scopus
View full text