You are previewing Strategies for Real-Time System Specification.
O'Reilly logo
Strategies for Real-Time System Specification

Book Description

This is the digital version of the printed book (Copyright © 1987).

Here is a casebook, a practical reference, and an indispensable guide for creating a systematic, formal methodology for large, real-time, software-based systems.

The book introduces the widely implemented Hatley/Pirbhai methods, a major extension of the DeMarco analysis method describing how external events control the system's operating behavior. The techniques are used in major avionics and electronics companies worldwide, and are automated by most major CASE tools, including TurboCASE/Sys by StructSoft, Inc.

Large software-based systems, especially those for real-time applications, require multi-mode operation, direct interaction with a rapidly changing physical environment, and fast response times. In the past, the development of such systems was prone to massive cost and schedule overruns, and to inadequate performance and reliability. Strategies for Real-Time System Specification addresses these problems by integrating a finite-state machine structure into classical analysis methods.

The book contains nearly 200 diagrams, many of which illustrate the requirements specification of a flight management system for a major avionics developer.

Table of Contents

  1. About This eBook
  2. Title Page
  3. Copyright Page
  4. Dedication Page
  5. Acknowledgments
  6. Contents
  7. List of Figures
  8. Foreword
  9. Preface
    1. Organization and audience of the book
  10. Part I: The Overall Strategy
    1. Chapter 1. Overview
      1. 1.1. The Birth of the Requirements Model
      2. 1.2. The Birth of the Architecture Model
      3. 1.3. Compatibility of the Models
      4. 1.4. Applicability of the Models
      5. 1.5. The System Life Cycle
    2. Chapter 2. The Role of the Methods
      1. 2.1. Structured Methods: What They Are
      2. 2.2. System Requirements Model
      3. 2.3. System Architecture Model
      4. 2.4. System Specification Model
      5. 2.5. The Development Life Cycle
      6. 2.6. Structured Methods: What They Are Not
      7. 2.7. Summary
  11. Part II: The Requirements Model
    1. Chapter 3. Overview
      1. 3.1. The Structure of the Model
    2. Chapter 4. The Process Model
      1. 4.1. Data Context Diagrams
      2. 4.2. Data Flow Diagrams
      3. 4.3. Leveling and Balancing
      4. 4.4. The Numbering System
      5. 4.5. Data Flows
      6. 4.6. Data Stores
      7. 4.7. Process Specifications
      8. 4.8. Interpreting the Process Model
      9. 4.9. Summary
    3. Chapter 5. The Control Model
      1. 5.1. Control Context Diagrams
      2. 5.2. Control Flow Diagrams
      3. 5.3. Control Flows
      4. 5.4. Data Conditions
      5. 5.5. Control Stores
      6. 5.6. Control Specifications
      7. 5.7. Process Controls
      8. 5.8. Summary
    4. Chapter 6. Finite State Machines
      1. 6.1. Combinational Machines
      2. 6.2. Sequential Machines
      3. 6.3. Incorporating Finite State Machines into CSPECs
      4. 6.4. Summary
    5. Chapter 7. Timing Requirements
      1. 7.1. Repetition Rate
      2. 7.2. Input-to-Output Response Time
      3. 7.3. Summary
    6. Chapter 8. Requirements Dictionary
      1. 8.1. Primitive Attributes
      2. 8.2. Group Structure
      3. 8.3. Dictionary Data Bases
      4. 8.4. Summary
    7. Chapter 9. Requirements Model Interpretation and Summary
      1. 9.1. The Requirements Model Interpreted
      2. 9.2. Requirements Model Summary
  12. Part III: Building the Requirements Model
    1. Chapter 10. Overview
      1. 10.1. Model Users and Builders
      2. 10.2. The Sources of Requirements
      3. 10.3. The Model Building Process
    2. Chapter 11. Getting Started
      1. 11.1. User Requirements Statements
      2. 11.2. Separating Data and Control
      3. 11.3. Establishing the System Context
      4. 11.4. Partitioning the Top Levels
      5. 11.5. Summary
    3. Chapter 12. Developing the Model’s Structure
      1. 12.1. Abstraction and Decomposition
      2. 12.2. The Seven-Plus-or-Minus-Two Principle
      3. 12.3. Grouping and Decomposing Processes
      4. 12.4. Grouping and Decomposing Flows
      5. 12.5. Naming Processes and Flows
      6. 12.6. Use of Stores
      7. 12.7. Functionally Identical Processes
      8. 12.8. De-emphasizing the Control Model
      9. 12.9. Control Intensive Systems
      10. 12.10. The Dilemma of Detail: Requirements Versus Design
      11. 12.11. The Final Product
      12. 12.12. Summary
    4. Chapter 13. Preparing Process Specifications
      1. 13.1. The Role of Process Specifications
      2. 13.2. The Different Types of PSPECs
      3. 13.3. Some Important Signal Conventions
      4. 13.4. Structured English
      5. 13.5. Annotating with Comments
      6. 13.6. Summary
    5. Chapter 14. Preparing Control Specifications
      1. 14.1. Avoiding Control Specifications
      2. 14.2. Combinational Control
      3. 14.3. Sequential Control
      4. 14.4. Multi-Sheet CSPECs
      5. 14.5. Fitting CSPECs In
      6. 14.6. Summary
    6. Chapter 15. Defining Timing
      1. 15.1. Timing Overview
      2. 15.2. Response Time Specification
      3. 15.3. Summary
    7. Chapter 16. Managing the Dictionary
      1. 16.1. Flow Types
      2. 16.2. Dictionary Symbols
      3. 16.3. Summary
  13. Part IV: The Architecture Model
    1. Chapter 17. Overview
      1. 17.1. Requirements-to-Architecture Template
      2. 17.2. Architecture Model Symbols
    2. Chapter 18. Architecture Diagrams
      1. 18.1. Architecture Context Diagrams
      2. 18.2. Flows and Interconnects
      3. 18.3. Architecture Flow Diagrams
      4. 18.4. Architecture Interconnect Diagrams
      5. 18.5. Summary
    3. Chapter 19. Architecture Dictionary and Module Specifications
      1. 19.1. Architecture Module Specification
      2. 19.2. Architecture Interconnect Specification
      3. 19.3. Timing Requirements
      4. 19.4. Architecture Dictionary
      5. 19.5. Summary
    4. Chapter 20. Completing the Architecture Model
      1. 20.1. Allocation to Hardware and Software
      2. 20.2. The Hardware and Software Architectures
      3. 20.3. The Complete Architecture Model
  14. Part V: Building the Architecture Model
    1. Chapter 21. Overview
      1. 21.1. Architecture Development Process
      2. 21.2. Systems Come in Hierarchies
    2. Chapter 22. Enhancing the Requirements Model
      1. 22.1. Input and Output Processing
      2. 22.2. User Interface Processing
      3. 22.3. Maintenance and Self-Test Processing
      4. 22.4. The Complete Enhanced Requirements Model
      5. 22.5. Technology-Independent Versus Technology-Nonspecific
      6. 22.6. Organizational Implications
      7. 22.7. Summary
    3. Chapter 23. Creating the System Architecture Model
      1. 23.1. Architecture Context Diagram
      2. 23.2. Architecture Flow and Interconnect Diagrams
      3. 23.3. Example of AFD and AID Mapping
      4. 23.4. Model Consistency and Balancing
      5. 23.5. The Complete Architecture Model
      6. 23.6. Summary
    4. Chapter 24. Creating the Hardware and Software Architecture Models
      1. 24.1. Hardware and Software Partitioning
      2. 24.2. Applying the Template to Software Requirements
      3. 24.3. Developing the Software Architecture
      4. 24.4. The Hardware and Software Architecture Process
      5. 24.5. Summary
    5. Chapter 25. Architecture Development Summary
      1. 25.1. Partitioning the Modeling Process
  15. Part VI: Examples
    1. Chapter 26. Automobile Management System
      1. 26.1. Problem Statement
      2. 26.2. Requirements and Architecture Development
      3. 26.3. Requirements Model
      4. 26.4. Architecture Model
    2. Chapter 27. Home Heating System
      1. 27.1. Problem Statement
      2. 27.2. Requirements Model
      3. 27.3. Architecture Model
    3. Chapter 28. Vending Machine
      1. 28.1. Customer Dialogue
      2. 28.2. Requirements Model
      3. 28.3. Architecture Model
  16. Appendices
    1. Appendix A. Standard Symbols and Definitions
      1. A.1. Introduction
      2. A.2. Standard Symbols
      3. A.3. Requirements Model
      4. A.4. Architecture Model
    2. Appendix B. Making the Models into Documents
      1. B.1. Organizing the Models
      2. B.2. Military Standards
    3. Appendix C. Information Modeling: The Third Perspective
  17. References
    1. Additional information
  18. Index
  19. More Comments From Early Reviewers