1. Preface 17
1.1 Introduction 17
1.2 History of HOOD 17
1.3 Structure of the book 18
1.4 About this book and other related materials 19
1.5 Acknowledgments 19
Part 1 : Industrial software design issues 21
2. Hierarchical and object oriented design issues 22
2.1 Design: breaking software into modules 22
2.2 Object orientation 23
2.3 Abstract state machines 23
2.4 Abstract data types 24
2.5 Aggregation 24
2.6 Classes and inheritance 24
2.7 Exceptions 25
2.8 Generics 26
2.9 Concurrency 26
2.10 The client-server model 27
2.11 Issues with distributed systems 28
3. Overview of HOOD 29
3.1 Objectives of industrial software design 29
3.2 The HOOD approach to design 30
3.2.1 The hierarchical approach 30
3.2.2 Balancing graphical and textual formalisms 31
3.2.3 Design quality control: HOOD rules 32
3.2.4 Supporting the method: HOOD tools 33
3.3 From analysis to design: scope of HOOD 34
3.4 HOOD compared to other methods 34
3.5 Summary 35
4. HOOD objects 36
4.1 Objects and modules 36
4.2 Description of objects 36
4.2.1 Synthetic view: the graphical description 37
4.2.2 Detailed view: the textual description 38
4.3 Design refinement: the "include" relationship 40
4.3.1 An example 41
4.3.2 Parent and child objects 41
4.4 Client-server and the "use" relationship 44
4.5 Uncles: Combining the "use" and "include" relationships 45
4.5.1 Uncles 45
4.5.2 Environment 47
4.6 Other design issues 48
4.6.1 Splitting operations: OP_Controls 48
4.6.2 Grouping operations: operation sets 49
4.6.3 Sequential or concurrent execution: active objects 50
4.7 Summary 50
5. Data modelling in HOOD 51
5.1 Data flows 51
5.2 HOOD types 52
5.3 Basic types 52
5.4 Abstract data types 53
5.4.1 Introduction 53
5.4.2 Data refinement: the structure view 54
5.4.3 Aggregation 55
5.5 Classes 56
5.5.1 Introduction 56
5.5.2 Inheritance 57
5.6 Example 58
5.7 Summary 59
6. Other HOOD features 60
6.1 Exceptions: designing for reliability 60
6.2 Generics: designing for reuse 61
6.2.1 Generic definition 61
6.2.2 Generic instantiation 62
6.3 Virtual nodes: designing with distribution 63
6.4 Summary 65
7. A design example 66
7.1 Introduction 66
7.2 General structure of the Electronic Mailing System 66
7.3 Structure of the GUI 68
7.4 Distribution 70
7.5 Comments on the design 70
Part 2 : Formalization 73
8. Formalization and refinement of the structural decomposition 74
8.1 "Include" relationship 74
8.2 Provided interface 75
8.3 Required interface 76
8.4 "Use" relationship 77
8.5 OP_Controls 78
8.6 Generics 78
8.6.1 Generic module 78
8.6.2 Generic instance 80
8.7 Practical tips 81
8.7.1 Provided interface 81
8.7.2 "Use" relationship 81
8.7.3 Environment or child object? 83
8.7.4 Starting active objects 83
8.7.5 Redundant systems 84
8.8 Summary 84
9. Formalization and refinement of functional aspects 85
9.1 Operations 85
9.1.1 Specification of operations 85
9.1.2 Implementation of operations 86
9.2 Operation sets 87
9.3 Exceptions 88
9.3.1 Server side 88
9.3.2 Client side 89
9.3.3 Internal exceptions 90
9.4 Practical tips 90
9.4.1 Naming conventions 90
9.4.2 Error managers 91
9.5 Summary 91
10. Formalization and refinement of data structures 92
10.1 Description of types 92
10.2 HADT and classes 93
10.2.1 Global and instance attributes and operations 93
10.2.2 Aggregation and inheritance formalization 94
10.2.3 Abstract classes 94
10.3 Constants, variables and parameters 95
10.3.1 Constants 95
10.3.2 Data 95
10.3.3 Data flows 95
10.4 Practical tips 96
10.4.1 Naming conventions 96
10.4.2 The "good" data 96
10.4.3 HADT or class? 97
10.4.4 Avoiding too many root classes: class libraries 97
10.4.5 Controlling instances: object factories 98
10.5 Summary 100
11. Formalization and refinement of behavioural aspects 101
11.1 Defining execution conditions: operation constraints 101
11.2 HOOD execution model 102
11.3 State constraints 103
11.4 Concurrency constraints 105
11.4.1 Mutual EXclusion Execution Request (MTEX) 106
11.4.2 Read Write Execution Request (RWER) 106
11.4.3 Read Only Execution Request (ROER) 106
11.5 Protocol constraints 106
11.5.1 Highly Synchronous Execution Request (HSER) 107
11.5.2 Loosely Synchronous Execution Request (LSER) 108
11.5.3 Asynchronous Execution Request (ASER) 109
11.5.4 Reporting Loosely Synchronous Execution Request (RLSER) 109
11.5.5 Reporting Asynchronous Execution Request (RASER) 109
11.6 Time-out constraint 110
11.7 Practical tips 111
11.7.1 State constraints 111
11.7.2 Consistency of protocol constraints 112
11.8 Summary 112
12. A model of the global project organization 113
12.1 The HOOD design tree 113
12.2 The global project picture 113
12.2.1 Object space 114
12.2.2 Generic space 114
12.2.3 Virtual node space 114
12.2.4 Physical node space 114
12.2.5 The global picture 115
12.3 System Configuration 115
12.4 Summary 116
Part 3 : The design process 117
13. The basic decomposition process 118
13.1 The iterative process 118
13.2 The refinement process 119
13.3 The basic design step 120
13.3.1 Understand the problem 120
13.3.2 Refinement lines 121
13.3.3 Design activities 122
13.3.4 Justification of the solution 123
13.3.5 Ordering of activities 123
13.4 A typical workout of the basic design step 124
13.4.1 Activity 1: problem definition 124
13.4.2 Activity 2: elaboration of an informal solution strategy 126
13.4.3 Activity 3: formalization of the strategy 127
13.4.4 Activity 4: formalization of the solution 129
13.4.5 Activity 5: analysis of the solution 130
13.5 Terminal implementation 131
13.6 Summary 131
14. Designing in the large 132
14.1 Prime contractor's activities 132
14.1.1 Activity 1: Define the logical architecture 132
14.1.2 Activity 2: Select reusable components 132
14.1.3 Activity 3: Decide the distribution strategy 132
14.1.4 Activity 4: Physical architecture 133
14.2 Initiating the design 133
14.3 Subcontracting 134
14.4 HOOD and development standards 136
14.5 Configuration management 136
14.6 Human factors and HOOD management 138
14.7 Summary 139
15. Design documentation 140
15.1 Why is documentation important? 140
15.2 Relations between documentation and design fragments 141
15.3 Generating standard documents 141
15.4 Trends in documentation 142
16. Design reviews 143
16.1 Authoring reviews and quality assurance 143
16.1.1 Author-readers cycles 143
16.1.2 Quality assurance 144
16.2 Preparing reviews 144
16.3 What to check in a HOOD design 145
16.3.1 Looking for the "good" design 145
16.3.2 Design evaluation process 146
16.3.3 Reviewing the tree structure 147
16.3.4 Reviewing ODSs 147
Part 4 : From design to code 149
17. Mapping HOOD to programming languages 150
17.1 Tool support issues 150
17.2 Principles of target language mapping 151
17.3 Ada mapping 154
17.3.1 Objects 154
17.3.2 "Implemented-by" relationship 154
17.3.3 HADT and Classes 155
17.3.4 Exceptions 155
17.3.5 Generics 155
17.3.6 Concurrency 155
17.3.7 Distribution 155
17.4 C and C++ mapping 156
17.4.1 Objects 156
17.4.2 "Implemented-by" relationship 156
17.4.3 HADT and Classes 156
17.4.4 Exceptions 156
17.4.5 Generics 156
17.4.6 Concurrency 157
17.4.7 Distribution 157
17.5 Other languages 157
17.6 Adjusting mapping rules: HOOD Pragmas 157
17.6.1 Target language 157
17.6.2 Mutex code generation control 158
17.6.3 Testing support 158
17.7 Summary 158
18. Hard real-time systems 159
18.1 Hard real-time specific issues 159
18.2 Additional features of HRT-HOOD 160
18.2.1 Sporadic, cyclic and protected objects 160
18.2.2 HRT rules 160
18.2.3 HRT execution model 161
18.2.4 Real-time attributes 162
18.3 HRT execution model theory 162
18.4 Tool support of HRT-HOOD 162
19. Preserving design investment: the HOOD "standard" 163
19.1 The HOOD Reference Manual 163
19.2 Formal definition of the ODS 163
19.3 Exchanging designs between tools: the Standard Interchange Format 164
Part 5 : A full design example 165
20. Starting the project 166
20.1 Requirements 166
20.2 Initiating the design 166
20.3 The first basic design step 167
20.3.1 Problem definition 167
20.3.2 Elaboration of an informal strategy 168
20.3.3 Formalization of the strategy 168
20.3.4 Formalization of the solution 170
20.3.5 Analysis of the solution 171
21. First level objects 172
21.1 The Mission_Manager 172
21.1.1 Problem definition 172
21.1.2 Elaboration of an informal strategy 172
21.1.3 Formalization of the strategy 173
21.1.4 Formalization of the solution 175
21.1.5 Analysis of the solution 175
21.2 The secured driver 175
21.3 Request controller 176
21.3.1 Problem definition 176
21.3.2 Elaboration of an informal strategy 176
21.3.3 Formalization of the strategy 176
21.3.4 Formalization of the solution 177
21.3.5 Analysis of the solution 177
21.4 Generic_Gate 177
21.4.1 Problem definition 177
21.4.2 Elaboration of an informal strategy 177
21.4.3 Formalization of the strategy 178
21.4.4 Formalization of the solution 179
21.4.5 Analysis of the solution 179
22. Other objects 180
22.1 Motors library 180
22.2 Lights_Controller and Pressure_Sensor 180
22.3 Protected counter and Flip_Flop 181
22.4 Gates instantiations 181
22.5 Hard_Configuration 181
22.6 System configuration 181
Annexes 183
A. Abbreviations 184
B. Summary of graphical notation 185
C. Glossary 187
D. References 190
E. ODS of the water-lock system 192
F. Index 219
Pricing and ordering information