Object-oriented software construction

OOSC_IND.PDF......Page 0
Contents......Page 15
Preface......Page 3
Simple but powerful......Page 4
Organization of the text......Page 5
A Book-Wide Web......Page 6
The notation......Page 7
The environment......Page 8
Acknowledgments (quasi-absence thereof)......Page 9
Foreword to the second edition......Page 10
About the accompanying CD-ROM......Page 11
On the bibliography, Internet sources and exercise.........Page 13
1.1 EXTERNAL AND INTERNAL FACTORS......Page 27
Layers in software development......Page 28
Robustness versus correctness......Page 29
Definition: extendibility......Page 30
Definition: reusability......Page 31
Definition: compatibility......Page 32
Definition: efficiency......Page 33
Definition: ease of use......Page 35
Definition: functionality......Page 36
Osmond’s curves; after [Osmond 1995]......Page 37
About documentation......Page 38
Key concerns......Page 39
Breakdown of maintenance costs. Source: [Lientz 19.........Page 41
1.5 BIBLIOGRAPHICAL NOTES......Page 43
How dogmatic do we need to be?......Page 45
Seamlessness......Page 46
Assertions......Page 47
Feature-based computation......Page 48
Static typing......Page 49
Multiple inheritance......Page 50
Constrained genericity......Page 51
Polymorphism......Page 52
Run-time type interrogation......Page 53
Memory management and garbage collection......Page 54
Fast update......Page 55
Documentation......Page 56
Graphics and user interfaces......Page 57
2.6 BIBLIOGRAPHICAL NOTES AND OBJECT RESOURCES......Page 58
3 3 Modularity......Page 61
Decomposability......Page 62
A top-down hierarchy......Page 63
Composability......Page 64
Understan- dability......Page 65
Modular continuity......Page 66
Modular protection......Page 67
3.2 FIVE RULES......Page 68
Types of module interconnection structures......Page 69
Communication bandwidth between modules......Page 70
Data sharing......Page 72
A module under Information Hiding......Page 73
Linguistic Modular Units principle......Page 75
Self-Documentation principle......Page 76
Uniform Access......Page 77
Two representation for a bank account......Page 78
Open-Closed principle......Page 79
Old and new clients......Page 80
Adapting a module to new clients......Page 82
Single Choice......Page 83
Single Choice principle......Page 85
3.5 BIBLIOGRAPHICAL NOTES......Page 86
E3.4 Metrics for modularity (term project)......Page 87
E3.6 Configuration management and inheritance......Page 88
4 4 Approaches to reusability......Page 89
Expected benefits......Page 90
Reuse consumers, reuse producers......Page 91
Reuse of designs and specifications......Page 92
Design patterns......Page 93
Reusability through the source code......Page 94
Reuse of abstracted modules......Page 95
4.4 NON-TECHNICAL OBSTACLES......Page 96
The NIH syndrome......Page 97
Software companies and their strategies......Page 98
Accessing components......Page 99
A note about component indexing......Page 100
Formats for reusable component distribution......Page 101
Change and constancy......Page 103
The reuse-redo dilemma......Page 104
4.6 FIVE REQUIREMENTS ON MODULE STRUCTURES......Page 105
Representation Independence......Page 106
Factoring Out Common Behaviors......Page 107
Some possible table implementations......Page 108
Array representation of sequential table with cur.........Page 109
Sequential file representation of a sequential tab.........Page 110
Routines......Page 111
Packages......Page 112
Packages: an assessment......Page 114
Syntactic overloading......Page 115
Role of overloading......Page 116
Semantic overloading (a preview)......Page 117
Genericity......Page 118
Basic modularity techniques: an assessment......Page 119
4.9 KEY CONCEPTS INTRODUCED IN THIS CHAPTER......Page 120
4.10 BIBLIOGRAPHICAL NOTES......Page 121
The three forces of computation......Page 123
Continuity......Page 125
Top-down development......Page 126
Not just one function......Page 127
Structure of a simple payroll program......Page 128
Finding the top......Page 129
Functions and evolution......Page 130
Interfaces and software design......Page 131
Premature ordering......Page 132
Ordering and O-O development......Page 133
Reusability......Page 134
The context of a module in top-down design......Page 135
5.3 OBJECT-BASED DECOMPOSITION......Page 136
Compatibility......Page 137
OBJECT MOTTO......Page 138
Finding the object types......Page 139
Describing the relations and structuring software......Page 140
5.7 BIBLIOGRAPHICAL NOTES......Page 141
6 6 Abstract data types......Page 143
6.2 IMPLEMENTATION VARIATIONS......Page 144
Three possible representations for a stack......Page 145
Head-to-head representation for two stacks......Page 146
How long is a middle initial?......Page 147
Using the operations......Page 148
Name consistency......Page 149
How not to handle abstractions......Page 150
6.4 FORMALIZING THE SPECIFICATION......Page 151
Specifying types......Page 152
Genericity......Page 153
Listing the functions......Page 154
Applying the put function......Page 155
Function categories......Page 156
The AXIOMS paragraph......Page 157
Applying the put function......Page 158
Two or three things we know about stacks......Page 159
Preconditions......Page 160
ADT specification of stacks......Page 161
Nothing but the truth......Page 162
Stack manipulations......Page 163
Definition: deferred, effective class......Page 164
The role of deferred classes......Page 165
The ADT view of a module under information hiding......Page 166
Introducing a more imperative view......Page 167
Back to square one?......Page 168
6.6 BEYOND SOFTWARE......Page 169
6.7 SUPPLEMENTARY TOPICS......Page 170
More on implicitness......Page 171
Classes versus records......Page 172
Alternatives to partial functions......Page 173
Is my specification complete?......Page 175
Definition: correct ADT expression......Page 176
Definition: ADT consistency......Page 177
Weight Consistency rule......Page 178
STACK AXIOMS......Page 179
Canonical Reduction rule......Page 180
6.8 KEY CONCEPTS INTRODUCED IN THIS CHAPTER......Page 181
6.9 BIBLIOGRAPHICAL NOTES......Page 182
E6.6 Text......Page 183
E6.14 Consistency......Page 184
Definition: class......Page 185
What would you think of this?......Page 186
The mold and the instance......Page 187
Metaclasses......Page 188
7.3 THE ROLE OF CLASSES......Page 189
The class as module and type......Page 190
Object rule......Page 191
A point and its coordinates......Page 192
Representing a point in polar coordinates......Page 193
Feature classification, by role......Page 194
Feature classification, by implementation......Page 195
The class......Page 196
Recognizing feature kinds......Page 197
The indexing clause......Page 198
Denoting a function’s result......Page 199
Inheriting general-purpose facilities......Page 200
The current instance......Page 201
Definition: client, supplier......Page 202
Feature call......Page 203
Single Target principle......Page 204
The role of Current......Page 205
Qualified and unqualified calls......Page 206
Operator features......Page 207
Restricting client access......Page 211
Style for declaring secret features......Page 212
Exporting to yourself......Page 213
The Big Bang......Page 214
Definition: system execution......Page 215
Definition: system closure......Page 216
Not a main program......Page 217
Assembling a system......Page 218
A directory structure......Page 219
Printing your name......Page 220
Structure and order: the software developer as ars.........Page 221
Form of declarations......Page 223
Attributes vs. functions......Page 224
Exporting attributes......Page 225
The client’s privileges on an attribute......Page 226
Possible client privileges on an attribute......Page 227
Optimizing calls......Page 228
The architectural role of selective exports......Page 229
Denoting the result of a function......Page 230
7.11 KEY CONCEPTS INTRODUCED IN THIS CHAPTER......Page 233
7.12 BIBLIOGRAPHICAL NOTES......Page 235
E7.4 Polar coordinates......Page 236
8 8 The run-time structure: objects......Page 237
Definition: object......Page 238
Basic form......Page 239
Simple fields......Page 240
An object representing a book......Page 241
References......Page 242
Two “book” objects with “writer” subobjects......Page 243
An object with a void reference field......Page 244
Object identity......Page 245
Direct and indirect self- reference......Page 246
A possible run- time object structure......Page 247
8.2 OBJECTS AS A MODELING TOOL......Page 248
Molds and their instances......Page 249
Reality: a cousin twice removed......Page 250
Dynamic creation and reattachment......Page 251
The creation instruction......Page 252
Default initialization values......Page 253
The global picture......Page 254
Why explicit creation?......Page 255
Overriding the default initializations......Page 256
Effect of a creation call......Page 257
Rules on creation procedures......Page 258
Multiple creation and overloading......Page 259
Void references and calls......Page 260
Attaching a reference to an object......Page 262
After reference assignment......Page 263
The void value......Page 264
De-attaching a reference from an object......Page 265
Cloning an object......Page 266
Deep clone and comparison......Page 267
Definition: direct dependents, dependents......Page 270
“Book” and “Writer” objects......Page 271
Persistence Closure principle......Page 272
Expanded types......Page 274
Definition: expanded type......Page 275
The role of expanded types......Page 276
“Knows about” and “contains” relations between obj.........Page 277
Properties of expanded types......Page 278
Expanded Client rule......Page 279
A subobject with a reference to another object......Page 280
Attachment......Page 281
Reference and copy attachment......Page 282
Hybrid attachments......Page 283
Equality comparison......Page 284
Dynamic aliasing......Page 285
The semantics of aliasing......Page 286
Coming to terms with dynamic aliasing......Page 287
A linked circular list......Page 288
Encapsulating reference manipulations......Page 289
8.10 DISCUSSION......Page 290
Graphical conventions......Page 291
Simula-style notations for operations on reference.........Page 292
The form of clone and equality operations......Page 294
8.11 KEY CONCEPTS INTRODUCED IN THIS CHAPTER......Page 296
E8.2 Persons......Page 297
E8.3 Notation design......Page 298
Object creation......Page 299
The static mode......Page 300
The free (heap- based) mode......Page 301
Space reclamation in the three modes......Page 302
Detachment......Page 303
Detachment is not always death......Page 304
Reachable objects in classical approaches......Page 305
Live objects (in color) and dead objects (in black.........Page 306
Entity allocation for a procedure......Page 307
Reachability in the object- oriented model......Page 308
Objects attached to local entities......Page 309
The three answers......Page 310
Do we care about memory any more?......Page 311
A byte here, a byte there, and soon we will be tal.........Page 312
9.3 RECLAIMING MEMORY: THE ISSUES......Page 313
The reliability issue......Page 314
The ease of development issue......Page 315
Direct and indirect self- reference......Page 316
Managing space for a linked list......Page 317
Dealing with recycled objects......Page 319
Discussion......Page 320
The need for automatic techniques......Page 321
9.7 REFERENCE COUNTING......Page 322
Uncollectible cyclic structure......Page 323
The garbage collection mechanism......Page 324
Garbage collector properties......Page 325
All-or-nothing collection......Page 326
Parallel garbage collection algorithms......Page 328
Class MEMORY......Page 329
A disposal mechanism......Page 330
Garbage collection and external calls......Page 331
Challenges......Page 332
Garbage collection mechanism......Page 333
Garbage collector operation......Page 334
9.12 BIBLIOGRAPHICAL NOTES......Page 335
E9.4 Sharing more......Page 336
10.1 HORIZONTAL AND VERTICAL TYPE GENERALIZATION......Page 337
Generic abstract data types......Page 338
The role of typing......Page 339
10.3 GENERIC CLASSES......Page 340
Declaring a generic class......Page 341
Terminology......Page 342
The type rule......Page 343
Uses of entities of a formal generic type......Page 344
Arrays as objects......Page 345
Array properties......Page 346
Efficiency considerations......Page 347
10.5 THE COST OF GENERICITY......Page 348
10.6 DISCUSSION: NOT DONE YET......Page 349
E10.1 Constrained genericity......Page 350
E10.3 Using your own formal generic parameter as s.........Page 351
11 11 Design by Contract: building reliable softwa.........Page 353
11.1 BASIC RELIABILITY MECHANISMS......Page 354
Software Correctness property......Page 355
Correctness formulae......Page 356
Weak and strong conditions......Page 357
Sinecure 2......Page 358
11.4 INTRODUCING ASSERTIONS INTO SOFTWARE TEXTS......Page 359
A stack class......Page 360
A pedagogical note......Page 362
Rights and obligations......Page 363
Zen and the art of software reliability: guarantee.........Page 364
Non-Redundancy principle......Page 365
Assertions are not an input checking mechanism......Page 367
Assertion Violation rule (1)......Page 368
Terms to denote software woes......Page 369
Stack implemented with an array (see page 123 for .........Page 370
The imperative and the applicative......Page 373
A note on empty structures......Page 375
Precondition design: tolerant or demanding?......Page 376
Reasonable Precondition principle......Page 378
Preconditions and export status......Page 379
Precondition Availability rule......Page 380
A tolerant module......Page 381
Definition and example......Page 385
Form and properties of class invariants......Page 386
The life of an object......Page 387
Invariant rule......Page 388
The role of class invariants in software engineeri.........Page 389
Invariants and contracting......Page 390
The correctness of a class......Page 391
(This figure first appeared on page 366.)......Page 392
The role of creation procedures......Page 393
Arrays revisited......Page 394
Not just a collection of functions......Page 395
Expressing the axioms......Page 396
Class-ADT Consistency property......Page 397
Implementation invariants......Page 398
Same abstract object, two representations......Page 399
11.11 AN ASSERTION INSTRUCTION......Page 400
Loop trouble......Page 402
From [M 1990]......Page 403
Getting loops right......Page 404
Ingredients for a provably correct loop......Page 405
A loop computation (from [M 1990])......Page 406
Loop syntax......Page 408
Using assertions for documentation: the short form.........Page 411
Monitoring assertions at run time......Page 414
How much assertion monitoring?......Page 416
Why run-time monitoring?......Page 420
The expressive power of assertions......Page 421
Including functions in assertions......Page 422
Class invariants and reference semantics......Page 425
Consistency of forward and backward references......Page 426
Violating the invariant......Page 427
11.15 KEY CONCEPTS INTRODUCED IN THIS CHAPTER......Page 428
11.16 BIBLIOGRAPHICAL NOTES......Page 429
E11.2 A class and its ADT......Page 430
E11.9 Random number generators......Page 431
POSTSCRIPT: THE ARIANE 5 CRASH......Page 432
Failures......Page 433
Sources of exceptions......Page 434
Causes of failure......Page 435
How not to do it — a C-Unix example......Page 436
How not to do it — an Ada example......Page 437
Ada Exception rule......Page 438
Disciplined Exception Handling principle......Page 439
The call chain......Page 440
Rescue and Retry......Page 441
An exception history table......Page 442
An exception history table......Page 443
Fragile input......Page 444
Recovering from hardware or operating system excep.........Page 445
Retrying for software fault tolerance......Page 446
N-version programming......Page 448
The correctness of a rescue clause......Page 449
The life of an object......Page 450
A clear separation of roles......Page 451
When there is no rescue clause......Page 452
Exception queries......Page 453
Developer exceptions......Page 456
12.7 DISCUSSION......Page 457
Should exceptions be objects?......Page 458
12.8 KEY CONCEPTS INTRODUCED IN THIS CHAPTER......Page 459
E12.2 Exception objects......Page 460
External routines......Page 461
Advanced variants......Page 462
Object-oriented re-architecturing......Page 463
The compatibility issue: hybrid software or hybrid.........Page 465
13.2 ARGUMENT PASSING......Page 466
Permissible operations on a reference argument......Page 467
Qualified Call rule......Page 469
Conditional......Page 470
Multi-branch......Page 471
Loop......Page 473
Manifest constants......Page 474
Expressions with operators......Page 475
Non-strict boolean operators......Page 476
13.5 STRINGS......Page 478
13.7 LEXICAL CONVENTIONS......Page 479
E13.2 Avoiding non-strict operators......Page 480
14 14 Introduction to inheritance......Page 483
Polygons......Page 484
Rectangles......Page 486
An inheritance link......Page 488
Inheritance and creation......Page 489
Creation Inheritance rule......Page 490
Polymorphic attachment......Page 491
Figure type hierarchy......Page 492
Polymorphic reference reattachment......Page 493
Polymorphic data structures......Page 494
Dimensions of generalization......Page 495
Type consistency......Page 496
Feature Call rule......Page 497
Type Conformance rule......Page 498
Static type, dynamic type......Page 499
Are the restrictions justified?......Page 500
attachment......Page 501
When you want to force a type......Page 502
Polymorphic creation......Page 503
Using the right variant......Page 504
Redefinition and assertions......Page 505
Moving arbitrary figures......Page 506
The FIGURE hierarchy again......Page 507
Effecting a feature......Page 508
Definition: redeclaration......Page 509
Deferred class declaration rule......Page 510
Deferred Class No-Instantiation rule......Page 511
List with cursor......Page 512
Cursor positions......Page 514
Redeclaring a function into an attribute......Page 515
Not the other way around......Page 516
Using the original version in a redefinition......Page 517
The dual perspective......Page 518
The module view......Page 519
The type view......Page 521
Inheritance and decentralization......Page 522
The extension-specialization paradox......Page 524
Back to abstract data types......Page 525
Variants of the notion of table......Page 528
Don’t call us, we’ll call you......Page 529
Programs with holes......Page 530
Deferred classes for analysis and global design......Page 531
Dynamic binding and efficiency......Page 532
Estimating the overhead......Page 534
Static binding as an optimization......Page 535
Dynamic Binding principle......Page 536
The C++ approach to binding......Page 538
14.10 KEY CONCEPTS INTRODUCED IN THIS CHAPTER......Page 541
E14.2 How few vertices for a polygon?......Page 542
E14.8 Kinds of deferred feature......Page 543
E14.9 Complex numbers......Page 544
15.1 EXAMPLES OF MULTIPLE INHERITANCE......Page 545
º that is a case of repeated inheritance......Page 546
Company planes......Page 547
Numeric and comparable values......Page 548
Windows and subwindows......Page 550
Trees are lists and list elements......Page 551
Definition: tree......Page 552
A composite figure......Page 553
A composite figure is a figure and a list of figur.........Page 554
A marriage of convenience......Page 556
Facility inheritance......Page 558
Buttonholes......Page 559
An assessment......Page 560
Name clashes......Page 561
A name clash, removed......Page 563
Local name adaptation......Page 564
Using a parent’s creation procedure......Page 565
The flat form......Page 567
Uses of the flat form......Page 568
Repeated inheritance......Page 569
Sharing and replication......Page 570
Kinds of driver......Page 571
Repeated Inheritance rule......Page 572
Attribute replication......Page 573
Redundant inheritance......Page 574
Single Name rule......Page 575
Conflicts under sharing: undefinition and join......Page 577
Two parents with features to be merged......Page 578
The need for selection......Page 579
Keeping the original version of a redefined featur.........Page 581
An advanced example......Page 583
Window variants......Page 584
Repeated inheritance and genericity......Page 587
Name clashes: definition and rule......Page 588
Renaming......Page 589
O-O development and overloading......Page 590
15.6 KEY CONCEPTS INTRODUCED IN THIS CHAPTER......Page 592
E15.6 Circular lists and chains......Page 593
E15.10 Repeated inheritance for replication......Page 594
16.1 INHERITANCE AND ASSERTIONS......Page 595
The routine, the client and the contract......Page 596
The routine, the client, the contract and the desc.........Page 597
How to cheat clients......Page 598
An example......Page 599
The routine, the client and the sub- contractor......Page 601
Abstract preconditions......Page 602
Assertion Redeclaration rule (2)......Page 604
Redeclaring into attributes......Page 605
Universal Class rule......Page 606
The global inheritance structure......Page 607
Universal features......Page 608
Fixed semantics for copy, clone and equality featu.........Page 609
Addable vectors......Page 611
Adding two vectors, item by item......Page 613
Constraining the generic parameter......Page 614
Unconstrained genericity revisited......Page 616
When type rules become obnoxious......Page 617
The challenge......Page 618
The mechanism......Page 619
Using assignment attempt properly......Page 621
Devices and printers......Page 622
A linkable cell......Page 623
Parallel hierarchies......Page 624
Type inconsistencies......Page 625
Application-oriented examples......Page 626
A serious problem......Page 627
The notion of anchor......Page 628
Base classes revisited......Page 629
When not to use anchored declaration......Page 630
A static mechanism......Page 631
Applications......Page 632
Why the flexibility?......Page 633
Interface and implementation reuse......Page 634
The two styles......Page 635
16.9 KEY CONCEPTS INTRODUCED IN THIS CHAPTER......Page 636
E16.3 Extract?......Page 637
The Basic Construct......Page 639
Definition: statically typed language......Page 640
Realism......Page 641
Pessimism......Page 642
After [Boehm 1981]. Reproduced with permission.......Page 643
The ingredients of successful typing......Page 644
Multiple inheritance......Page 645
“A little bit typed”?......Page 646
Typing and binding......Page 647
Kinds of flying object......Page 648
Covariance......Page 649
Kinds of skier......Page 650
Skier hierarchy and redefinitions......Page 652
Parallel hierarchies......Page 653
Polymorphic perversity......Page 654
Descendant hiding......Page 655
Practical scope......Page 656
Using generic parameters......Page 657
17.5 RELYING ON ANCHORED TYPES......Page 658
17.6 GLOBAL ANALYSIS......Page 662
System Validity rule......Page 663
Catcall type rule......Page 665
Definition: Polymorphic entity......Page 666
17.8 AN ASSESSMENT......Page 667
17.9 THE PERFECT FIT......Page 668
17.11 BIBLIOGRAPHICAL NOTES......Page 670
18.1 CONSTANTS OF BASIC TYPES......Page 673
Constant attributes......Page 674
18.2 USE OF CONSTANTS......Page 675
Manifest constants are inappropriate for class typ.........Page 676
Once functions......Page 677
Shared objects......Page 678
Once functions returning results of basic types......Page 680
Arguments......Page 681
Once functions, anchoring and genericity......Page 682
18.5 CONSTANTS OF STRING TYPE......Page 683
18.6 UNIQUE VALUES......Page 684
Discrimination principle......Page 685
Initializing globals and shared objects: language .........Page 686
Unique values and enumerated types......Page 687
18.8 KEY CONCEPTS INTRODUCED IN THIS CHAPTER......Page 689
E18.4 Once attributes?......Page 690
19.1 SOFTWARE METHODOLOGY: WHY AND WHAT......Page 691
The need for methodology guidelines......Page 692
Practical Basis methodology principle......Page 693
Absolute positives......Page 694
Advisories......Page 695
Exceptions......Page 696
Abstraction and precision......Page 697
If it is baroque, fix it......Page 698
19.3 ON USING METAPHORS......Page 699
19.4 THE IMPORTANCE OF BEING HUMBLE......Page 701
E19.4 Metaphors on the Net......Page 702
20.1 MULTI-PANEL SYSTEMS......Page 705
A panel......Page 706
A transition diagram......Page 707
The transition function......Page 708
The routine architecture......Page 709
Top-down functional decomposition......Page 710
Statism......Page 712
The flow of data......Page 713
State as a class......Page 714
features......Page 715
Inheritance and deferred classes......Page 716
State class hierarchy......Page 717
Describing a complete system......Page 718
STATE and APPLICATION features......Page 719
The application class......Page 720
A polymorphic array of states......Page 722
20.6 DISCUSSION......Page 723
20.7 BIBLIOGRAPHICAL NOTE......Page 724
Undoing for fun and profit......Page 725
Practical issues......Page 726
Requirements on the solution......Page 727
Command as a class......Page 729
Command class hierarchy......Page 730
The basic interactive step......Page 731
Remembering the last command......Page 732
How to create a command object......Page 733
The history list......Page 734
Implementing Undo......Page 735
Implementing Redo......Page 736
Command arguments......Page 737
Precomputing command objects......Page 738
The array of command templates......Page 739
Bounded circular list implemented by an array......Page 740
A history window, before any undoing......Page 741
21.6 DISCUSSION......Page 742
The role of implementation......Page 743
Small classes......Page 744
E21.1 Putting together a small interactive system .........Page 745
E21.6 Composite commands......Page 746
E21.9 A history mechanism......Page 747
E21.11 Integrable functions......Page 748
22 22 How to find the classes......Page 749
Avoiding useless classes......Page 750
Is a new class necessary?......Page 751
Missing important classes......Page 753
Class Elicitation principle......Page 755
My class performsº......Page 756
Class Name rule......Page 757
Premature classification......Page 758
No-command classes......Page 759
The ideal class......Page 760
Class categories......Page 761
External objects: finding the analysis classes......Page 762
Finding the implementation classes......Page 763
Finding the design classes......Page 764
Adaptation through inheritance......Page 765
Hints from other approaches......Page 766
Files......Page 767
Use cases......Page 768
Use Case principle......Page 769
The bottom-up component......Page 770
22.6 THE METHOD FOR OBTAINING CLASSES......Page 771
Sources of possible classes......Page 772
22.7 KEY CONCEPTS INTRODUCED IN THIS CHAPTER......Page 773
22.8 BIBLIOGRAPHICAL NOTES......Page 774
E22.1 Floors as integers......Page 775
E22.2 Inspecting objects......Page 776
23 23 Principles of class design......Page 777
Forms of side effect......Page 778
Referential transparency......Page 779
Definition: referential transparency......Page 780
A list object as list machine......Page 781
A clean style for class interfaces......Page 782
Pseudo-random number generators: a design exercise.........Page 784
An infinite list as a machine......Page 785
Abstract state, concrete state......Page 786
Definition: abstract side effect......Page 787
Objections......Page 788
Legitimate side effects: an example......Page 789
The importance of argument counts......Page 794
Definition: operand and option arguments......Page 796
Operand principle......Page 797
Exceptions to the Operand principle?......Page 799
23.3 CLASS SIZE: THE SHOPPING LIST APPROACH......Page 800
Maintaining consistency......Page 801
Shopping List advice......Page 802
Laxity and restrictiveness......Page 803
Linked list representation......Page 804
Deletion in a linked list......Page 805
Passive classes......Page 806
Encapsulation and assertions......Page 810
Simple-minded solutions......Page 811
Evolution of a library class......Page 812
List with cursor......Page 813
Maintaining consistency: the implementation invari.........Page 814
List with sentinels......Page 815
The client’s view......Page 816
Cursor list representation (first variant)......Page 817
Cursor list representation (revised variant)......Page 819
Merging the list and the sentinels......Page 823
Header as sentinel (empty list)......Page 825
23.5 SELECTIVE EXPORTS......Page 827
23.6 DEALING WITH ABNORMAL CASES......Page 828
The a priori scheme......Page 829
Obstacles to the a priori scheme......Page 830
The a posteriori scheme......Page 831
The role of an exception mechanism......Page 832
23.7 CLASS EVOLUTION: THE OBSOLETE CLAUSE......Page 833
23.8 DOCUMENTING A CLASS AND A SYSTEM......Page 834
Documentation principle......Page 835
A system architecture diagram......Page 836
23.10 BIBLIOGRAPHICAL NOTES......Page 837
E23.7 Two-way lists......Page 838
E23.13 Self-documenting software......Page 839
24.1 HOW NOT TO USE INHERITANCE......Page 841
A proper model......Page 842
“Is-a” rule of inheritance......Page 843
To have and to be......Page 844
Another possible view......Page 845
Object and subobject......Page 846
The polymorphism rule......Page 848
24.3 AN APPLICATION: THE HANDLE TECHNIQUE......Page 849
Platform adaptation through inheritance......Page 850
Platform adaptation through a handle......Page 851
Taxomania rule......Page 852
Inheritance rule......Page 854
Wrong uses......Page 855
Classification of the valid categories of inherita.........Page 856
Definition: subtype inheritance......Page 857
Definition: extension inheritance......Page 858
Variation inheritance......Page 860
Definition: functional and type variation inherita.........Page 861
Definition: uneffecting inheritance......Page 862
Definition: structure inheritance......Page 863
Definition: facility inheritance......Page 864
24.6 ONE MECHANISM, OR MORE?......Page 865
Defining a subtype......Page 867
Enforcing the subtype view......Page 868
The need for descendant hiding......Page 869
A circle and its center......Page 870
Applications of descendant hiding......Page 871
Taxonomies and their limitations......Page 873
Reproduced with the author’s permission. Associate.........Page 874
Using descendant hiding......Page 875
It feels so good, but is it wrong?......Page 876
Doing without inheritance......Page 877
Using character codes......Page 879
Iterators......Page 880
Understanding facility inheritance......Page 882
Classifying through multiple criteria......Page 883
A messy classification......Page 884
Classification through views......Page 885
Is view inheritance appropriate?......Page 886
Multi-criteria classification through separate, cl.........Page 887
A view-based classification of fundamental computi.........Page 888
Building a data structure class by combination of .........Page 889
Specialization and abstraction......Page 890
Induction and deduction......Page 891
Factoring......Page 892
Elevating the level of abstraction......Page 893
24.12 A SUMMARY VIEW: USING INHERITANCE WELL......Page 894
24.14 BIBLIOGRAPHICAL NOTES......Page 895
From Aristotle to Darwin......Page 896
The modern scene......Page 898
After Mayr, 1961.......Page 899
Bibliography on taxonomy......Page 900
E24.6 Classification examples......Page 901
E24.9 Inheritance and polymorphism......Page 902
The structure of systems......Page 903
Designing feature interfaces......Page 904
Redeclaration......Page 905
Forms of inheritance......Page 906
Applying the rules in practice......Page 907
Terseness and explicitness......Page 908
The role of convention......Page 909
Discipline and creativity......Page 910
Composite Feature Name rule......Page 911
Local entities and routine arguments......Page 912
Grammatical categories......Page 913
Standard names for non- boolean queries......Page 914
The benefits of consistent naming......Page 915
Symbolic Constant principle......Page 916
Routine header comments: an exercise in corporate .........Page 918
Feature clause header comments......Page 921
Indexing clauses......Page 922
26.5 TEXT LAYOUT AND PRESENTATION......Page 923
The comb-like structure of software texts......Page 924
Indenting details......Page 926
Note: this class has no useful semantics!......Page 927
Spaces......Page 928
The War of the Semicolons......Page 929
Semicolon Syntax rule......Page 930
Semicolon Style principle......Page 931
Basic font rules......Page 932
Other font conventions......Page 933
E26.2 Semicolon ambiguity......Page 934
Tasks......Page 935
Requirements......Page 936
The clouds and the precipice......Page 937
Requirements analysis as a negotiation......Page 938
27.4 PROGRAMMING A TV STATION......Page 939
Schedules......Page 940
Segments......Page 941
Programs and commercials......Page 943
Assessment......Page 945
27.5 EXPRESSING THE ANALYSIS: MULTIPLE VIEWS......Page 946
Inheritance link......Page 947
27.6 ANALYSIS METHODS......Page 949
27.7 THE BUSINESS OBJECT NOTATION......Page 951
(After [Waldén 1995], used with permission.)......Page 953
27.8 BIBLIOGRAPHY......Page 954
28.1 CLUSTERS......Page 955
(WARNING: this is not the recommended process mode.........Page 956
Individual cluster lifecycle......Page 957
28.4 THE CLUSTER MODEL OF THE SOFTWARE LIFECYCLE......Page 958
The cluster model of the software lifecycle......Page 959
A project’s clusters as a set of abstraction layer.........Page 960
The reusability culture......Page 961
28.6 SEAMLESSNESS AND REVERSIBILITY......Page 962
Reversibility: wisdom sometimes blooms late in the.........Page 963
Individual cluster lifecycle, reversible......Page 964
28.7 WITH US, EVERYTHING IS THE FACE......Page 965
28.9 BIBLIOGRAPHICAL NOTES......Page 966
Initial training: the “hit them twice” strategy......Page 967
Advanced Curriculum principle......Page 968
Phylogeny and ontogeny......Page 969
Language choice......Page 970
29.3 OTHER COURSES......Page 972
Secondary and undergraduate studies......Page 973
The consumer-to-producer strategy......Page 974
Consumer-to-producer strategy......Page 975
Apprenticeship......Page 976
A long-term policy......Page 977
29.5 AN OBJECT-ORIENTED PLAN......Page 978
29.6 KEY CONCEPTS STUDIED IN THIS CHAPTER......Page 979
29.7 BIBLIOGRAPHICAL NOTES......Page 980
30.1 A SNEAK PREVIEW......Page 981
Multiprocessing......Page 983
Multiprogramming......Page 984
Remote execution......Page 985
30.3 FROM PROCESSES TO OBJECTS......Page 986
Active objects......Page 987
A simple producer- consumer scheme......Page 988
Active objects clash with inheritance......Page 989
Processes programmed......Page 990
Definition: processor......Page 994
Handling an object......Page 995
The dual semantics of calls......Page 996
Separate entities......Page 997
Obtaining separate objects......Page 998
Objects here, and objects there......Page 999
Two-level architecture for concurrency mechanism......Page 1000
Mapping the processors: the Concurrency Control Fi.........Page 1001
Library mechanisms......Page 1002
Separateness consistency rule (1)......Page 1003
Separateness consistency rule (2)......Page 1004
Passing to a separate call an object with referenc.........Page 1005
Importing object structures......Page 1006
Synchronization vs. communication......Page 1007
Semaphore operations......Page 1008
Communication-based mechanisms......Page 1009
Synchronization for concurrent O-O computation......Page 1010
(This figure first appeared on page 366.)......Page 1012
Reserving an object......Page 1013
Separate Call rule......Page 1015
Wait by necessity......Page 1017
A multi-launcher......Page 1018
Avoiding deadlock......Page 1019
A buffer is a separate queue......Page 1020
Bounded buffer implemented by an array......Page 1021
Preconditions under concurrent execution......Page 1023
(From the example for stacks on page 343.)......Page 1024
The concurrent semantics of preconditions......Page 1025
Separate call semantics......Page 1026
Assertion Argument rule......Page 1027
Object and processor states and transitions......Page 1028
Duels and their semantics......Page 1029
Interrupt handling: the Secretary-Receptionist Alg.........Page 1030
About the rest of this chapter......Page 1032
The philosophers’ spaghetti plate......Page 1033
Making full use of hardware parallelism......Page 1037
Locks......Page 1039
Coroutine sequencing......Page 1042
An elevator control system......Page 1044
A watchdog mechanism......Page 1049
Accessing buffers......Page 1051
30.10 TOWARDS A PROOF RULE......Page 1052
The basic sequential proof technique......Page 1053
Constraints......Page 1055
Definition: satisfiable call......Page 1056
Library mechanisms......Page 1057
Full use of inheritance and other object-oriented .........Page 1058
Support for command-query separation......Page 1059
Support for coroutine programming......Page 1060
Permitting concurrent access?......Page 1061
30.13 KEY CONCEPTS INTRODUCED IN THIS CHAPTER......Page 1062
30.14 BIBLIOGRAPHICAL NOTES......Page 1063
E30.5 Priorities......Page 1065
E30.14 Once routines and concurrency......Page 1066
Storing and retrieving object structures......Page 1067
Storable format variants......Page 1068
Small structure with reference to big shared struc.........Page 1069
Naïve approaches......Page 1071
Detection......Page 1072
Notification......Page 1074
Object mismatch......Page 1075
(What is wrong with this picture?)......Page 1076
31.4 FROM PERSISTENCE TO DATABASES......Page 1077
Operations......Page 1078
Queries......Page 1079
31.6 OBJECT-ORIENTED DATABASE FUNDAMENTALS......Page 1080
An object with a reference to another object......Page 1081
(Both bottom references are attached to the same o.........Page 1082
The threshold model......Page 1083
Long transactions......Page 1084
31.7 O-O DATABASE SYSTEMS: EXAMPLES......Page 1085
Matisse......Page 1086
Versant......Page 1087
The O-O view......Page 1088
Separating persistence from sharing......Page 1089
31.9 KEY CONCEPTS STUDIED IN THIS CHAPTER......Page 1090
31.10 BIBLIOGRAPHICAL NOTES......Page 1091
E31.2 Object-oriented queries......Page 1092
32 32 Some O-O techniques for graphical interactiv.........Page 1093
Graphical systems, window systems, toolkits......Page 1094
The library and the application builder......Page 1095
32.2 PORTABILITY AND PLATFORM ADAPTATION......Page 1096
Graphical libraries architecture......Page 1097
Figures......Page 1098
The graphical abstractions......Page 1099
Operations on windows......Page 1100
Events......Page 1101
32.5 HANDLING THE EVENTS......Page 1102
An exit command......Page 1103
Confirming a command......Page 1104
Partial state diagram for Vi......Page 1105
32.7 BIBLIOGRAPHICAL NOTES......Page 1106
33.1 A BIT OF CONTEXT......Page 1107
33.3 A STACK IMPLEMENTATION......Page 1109
A simple interface......Page 1110
Using a package......Page 1111
Genericity......Page 1112
33.4 HIDING THE REPRESENTATION: THE PRIVATE STORY......Page 1113
Raising and handling an exception......Page 1116
Discussion......Page 1117
33.6 TASKS......Page 1119
O-O mechanisms of Ada 95: an example......Page 1120
An Ada 95 package......Page 1121
Ada 95 and object technology: an assessment......Page 1122
Discussion: module and type inheritance......Page 1123
Towards an O-O Ada......Page 1124
33.9 BIBLIOGRAPHICAL NOTES......Page 1125
E33.5 Package-classes......Page 1126
34.1 LEVELS OF LANGUAGE SUPPORT......Page 1127
34.2 OBJECT-ORIENTED PROGRAMMING IN PASCAL?......Page 1128
Object-oriented extensions of Pascal......Page 1129
The COMMON technique......Page 1130
The multiple-entry subroutine technique......Page 1132
A stack module emulation in Fortran......Page 1134
Some context......Page 1135
Emulating objects......Page 1137
A C object with function references......Page 1138
Emulating classes......Page 1139
O-O C: an assessment......Page 1140
E34.3 Object-oriented programming in C (term proje.........Page 1141
35.1 SIMULA......Page 1143
Major language traits......Page 1144
An example......Page 1147
(This figure appeared originally on page 1012.)......Page 1148
A coroutine example......Page 1149
Sequencing and inheritance......Page 1151
Simulation......Page 1152
An event list......Page 1154
A simulation example......Page 1155
Language style......Page 1156
Messages......Page 1157
Smalltalk: an assessment......Page 1159
35.3 LISP EXTENSIONS......Page 1160
Objective-C......Page 1161
C++......Page 1162
Complexity......Page 1164
C++: an assessment......Page 1165
35.5 JAVA......Page 1166
35.6 OTHER O-O LANGUAGES......Page 1167
C extensions: Objective-C, C++......Page 1168
E35.2 Implicit resume......Page 1169
E35.5 Referring to a parent’s version......Page 1170
36.1 COMPONENTS......Page 1171
Compilation challenges......Page 1172
The Frozen and the Melted......Page 1173
Precompilation......Page 1174
Optimization......Page 1175
Bench and the development process......Page 1176
36.5 LIBRARIES......Page 1178
(Here on a Sparcstation with Motif, but versions .........Page 1179
Platforms......Page 1180
Tools......Page 1181
A Class Tool in default format......Page 1182
An object and its fields captured during execution.........Page 1183
Typed pick- and-throw......Page 1184
The ancestry of a class......Page 1186
36.7 BIBLIOGRAPHICAL NOTES......Page 1188
Epilogue, In Full Frankness Exposing the Language......Page 1189
A.1 ARRAYS......Page 1192
A.2 LINKABLE AND BI-LINKABLE ELEMENTS......Page 1208
A.3 LISTS......Page 1214
A.4 ARRAYED LISTS......Page 1217
A.5 LINKED LISTS......Page 1236
A.6 TWO-WAY LISTS......Page 1256
A.7 TWO-WAY TREES......Page 1270
A A Extracts from the Base libraries......Page 1191
B B Genericity versus inheritance......Page 1280
Unconstrained genericity......Page 1281
Constrained genericity......Page 1283
B.2 INHERITANCE......Page 1286
A simple inheritance hierarchy, with deferred and .........Page 1287
Emulating inheritance......Page 1288
Emulating constrained genericity: overview......Page 1289
Constrained genericity: routines......Page 1290
Emulating constrained genericity (1)......Page 1291
Constrained genericity: packages......Page 1292
Unconstrained genericity......Page 1294
Emulating unconstrained genericity......Page 1296
Unconstrained genericity......Page 1297
Constrained genericity......Page 1298
Emulating constrained genericity (2)......Page 1299
B.6 KEY CONCEPTS INTRODUCED IN THIS APPENDIX......Page 1300
E-B.4 Full queue implementations......Page 1301
C C Principles, rules, precepts and definitions......Page 1302
Behavior class......Page 1306
Current object (or: current instance)......Page 1307
Encapsulation......Page 1308
Generator (of an object)......Page 1309
Message......Page 1310
Organized panic......Page 1311
Program......Page 1312
Runtime (noun, one word)......Page 1313
Static......Page 1314
Variant......Page 1315
E.1 WORKS BY OTHER AUTHORS......Page 1316
E.2 WORKS BY THE AUTHOR OF THE PRESENT BOOK......Page 1334
A......Page 1340
B......Page 1342
C......Page 1343
D......Page 1347
E......Page 1348
F......Page 1350
G......Page 1351
H......Page 1352
I......Page 1353
J......Page 1354
L......Page 1355
M......Page 1356
N......Page 1357
O......Page 1358
P......Page 1360
R......Page 1362
S......Page 1364
T......Page 1366
V......Page 1368
Z......Page 1369