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:
List of Figures xv Foreword xxiii
Preface xxv
Part I: The Overall Strategy 1
Chapter 1: Overview 3
1.1 The Birth of the Requirements Model 4
1.2 The Birth of the Architecture Model 7
1.3 Compatibility of the Models 7
1.4 Applicability of the Models 8
1.5 The System Life Cycle 8
Chapter 2: The Role of the Methods 11
2.1 Structured Methods: What They Are 11
2.2 System Requirements Model 13
2.3 System Architecture Model 19
2.4 System Specification Model 25
2.5 The Development Life Cycle 27
2.6 Structured Methods: What They Are Not 31
2.7 Summary 32
PART II: The Requirements Model 33
Chapter 3: Overview 35
3.1 The Structure of the Model 37
Chapter 4: The Process Model 41
4.1 Data Context Diagrams 41
4.2 Data Flow Diagrams 44
4.3 Leveling and Balancing 47
4.4 The Numbering System 49
4.5 Data Flows 49
4.6 Data Stores 52
4.7 Process Specifications 53
4.8 Interpreting the Process Model 56
4.9 Summary 59
Chapter 5: The Control Model 61
5.1 Control Context Diagrams 61
5.2 Control Flow Diagrams 64
5.3 Control Flows 67
5.4 Data Conditions 69
5.5 Control Stores 70
5.6 Control Specifications 70
5.7 Process Controls 73
5.8 Summary 76
Chapter 6: Finite State Machines 77
6.1 Combinational Machines 79
6.2 Sequential Machines 83
6.3 Incorporating Finite State Machines into CSPECs 89
6.4 Summary 97
Chapter 7: Timing Requirements 98
7.1 Repetition Rate 99
7.2 Input-to-Output Response Time 99
7.3 Summary 102
Chapter 8: Requirements Dictionary 103
8.1 Primitive Attributes 104
8.2 Group Structure 105
8.3 Dictionary Data Bases 107
8.4 Summary 110
Chapter 9: Requirements Model Interpretation and Summary 111
9.1 The Requirements Model Interpreted 111
9.2 Requirements Model Summary 113
PART III: Building the Requirements Model 117
Chapter 10: Overview 119
10.1 Model Users and Builders 119
10.2 The Sources of Requirements 120
10.3 The Model Building Process 121
Chapter 11: Getting Started 124
11.1 User Requirements Statements 124
11.2 Separating Data and Control 125
11.3 Establishing the System Context 129
11.4 Partitioning the Top Levels 132
11.5 Summary 135
Chapter 12: Developing the Model's Structure 137
12.1 Abstraction and Decomposition 137
12.2 The Seven-Plus-or-Minus-Two Principle 138
12.3 Grouping and Decomposing Processes 139
12.4 Grouping and Decomposing Flows 140
12.5 Naming Processes and Flows 147
12.6 Use of Stores 149
12.7 Functionally Identical Processes 150
12.8 De-emphasizing the Control Model 151
12.9 Control Intensive Systems 153
12.10 The Dilemma of Detail: Requirements Versus Design 155
12.11 The Final Product 156
12.12 Summary 156
Chapter 13: Preparing Process Specifications 158
13.1 The Role of Process Specifications 158
13.2 The Different Types of PSPECs 159
13.3 Some Important Signal Conventions 162
13.4 Structured English 165
13.5 Annotating with Comments 167
13.6 Summary 167
Chapter 14: Preparing Control Specifications 169
14.1 Avoiding Control Specifications 169
14.2 Combinational Control 170
14.3 Sequential Control 176
14.4 Multi-Sheet CSPECs 182
14.5 Fitting CSPECs In 185
14.6 Summary 189
Chapter 15: Defining Timing 190
15.1 Timing Overview 190
15.2 Response Time Specification 192
15.3 Summary 193
Chapter 16: Managing the Dictionary 194
16.1 Flow Types 194
16.2 Dictionary Symbols 198
16.3 Summary 199
PART IV: The Architecture Model 201
Chapter 17: Overview 203
17.1 Requirements-to-Architecture Template 204
17.2 Architecture Model Symbols 207
Chapter 18: Architecture Diagrams 211
18.1 Architecture Context Diagrams 211
18.2 Flows and Interconnects 213
18.3 Architecture Flow Diagrams 213
18.4 Architecture Interconnect Diagrams 218
18.5 Summary 224
Chapter 19: Architecture Dictionary and Module Specifications 225
19.1 Architecture Module Specification 226
19.2 Architecture Interconnect Specification 229
19.3 Timing Requirements 232
19.4 Architecture Dictionary 233
19.5 Summary 234
Chapter 20: Completing the Architecture Model 235
20.1 Allocation to Hardware and Software 235
20.2 The Hardware and Software Architectures 236
20.3 The Complete Architecture Model 238
PART V: Building the Architecture Model 241
Chapter 21: Overview 243
21.1 Architecture Development Process 244
21.2 Systems Come in Hierarchies 246
Chapter 22: Enhancing the Requirements Model 248
22.1 Input and Output Processing 249
22.2 User Interface Processing 251
22.3 Maintenance and Self-Test Processing 254
22.4 The Complete Enhanced Requirements Model 256
22.5 Technology-Independent Versus Technology-Nonspecific 257
22.6 Organizational Implications 260
22.7 Summary 261
Chapter 23: Creating the System Architecture Model 263
23.1 Architecture Context Diagram 263
23.2 Architecture Flow and Interconnect Diagrams 264
23.3 Example of AFD and AID Mapping 266
23.4 Model Consistency and Balancing 268
23.5 The Complete Architecture Model 271
23.6 Summary 272
Chapter 24: Creating the Hardware and Software Architecture Models 273
24.1 Hardware and Software Partitioning 276
24.4 Applying the Template to Software Requirements 279
24.3 Developing the Software Architecture 282
24.4 The Hardware and Software Architecture Process 284
24.5 Summary 285
Chapter 25: Architecture Development Summary 286
25.1 Partitioning the Modeling Process 286
PART VI: Examples 293
Chapter 26: Automobile Management System 295
26.1 Problem Statement 295
26.2 Requirements and Architecture Development 297
26.3 Requirements Model 299
26.4 Architecture Model 319
Chapter 27: Home Heating System 326
27.1 Problem Statement 326
27.2 Requirements Model 330
27.3 Architecture Model 340
Chapter 28: Vending Machine 342
28.1 Customer Dialogue 342
28.2 Requirements Model 344
28.3 Architecture Model 355
Appendices 363
Appendix A: Standard Symbols and Definitions 363
A.1 Introduction 363
A.2 Standard Symbols 363
A.3 Requirements Model 367
A.4 Architecture Model 382
Appendix B: Making the Models into Documents 392
B.1 Organizing the Models 392
B.2 Military Standards 396
Appendix C: Information Modeling: The Third Perspective 398
References 403
Index 405
About the Author :
Derek J. Hatley previously was president of System Strategies, an international consulting and training firm based in Jenison, Michigan. Prior to founding System Strategies, he was a Staff Engineer at Smiths Industries, Avionic Systems Division, where he was responsible for systems and software development techniques. He developed the requirements model, managed its first major application, developed an instructional workshop to be given internally and to customers and suppliers, and has presented technical papers at numerous international professional conferences. An avid music lover for most of his life, he now spends part of his time writing and arranging music.
Imtiaz A. Pirbhai was a principal of Systems Methods in Seattle, Washington, specializing in real-time and general systems development training. He previously was responsible for the development of structured methods standards and procedures at the Boeing Commercial Airplane Co. He taught and consulted internationally, introducing the methods described in Strategies for Real-Time System Specification throughout the world. At the time of his death in August of 1992, he had begun work on Process for System Architecture and Requirements Engineering (Dorset House, 2000), coauthored with Derek Hatley and Peter Hruschka.
