Index
Symbols
- % remainder operator, Java, 756
- & operator. Java, 816
- + operator, Java, 815
- ++ operator, Java, 755
- ++ operator, C++, 309-311
- += operator, Java, 756
- -- operator, Java, 756
- -3 interfaces, Thread, 730
- -classpath command-line argument (Java), 794
- 68000 code, Smalltalk, 71
- == operator, Java, 805
- #include, C++, 313
- | operator, Java, 816
A
- abstract classes
- C++, 252-253
- Java, 863-865
- abstract data types, C++, 232
- abstract methods, Java, 863-865
- abstract parent classes, 8
- abstract structure type (AST), 13
- abstract types, Modula-3, 670
- abstractions
- C++, 306
- generic, 307
- pointers, 325-326, 329-331
- constants, 332-333
- dynamic memory allocation, 332
- OOP, 307
- references, 325-328
- variable-length character strings, 306
- Eiffel, 493
- Acceptor pattern, Web servers, 31
- Access objects, Ada, 635
- accessing in Java
- array elements, 811
- class members, 796
- classes, 796
- methods, 833
- object data, 833
- objects, 807
- packages, 796
- Accessor methods, Smalltalk, 107, 180
- accidental complexities (communication software), 18
- ACE framework, 18, 23
- architecture, 24
- C++ language, 27
- C++ wrappers, 24-25
- SOCK Acceptor, 30
- SOCK Stream, 30
- components, 24-26
- self-contained, 27
- middleware, 28
- operating systems, 25
- OS adaption layer, 25
- Web servers, 28
- dispatcher, 28
- event dispatcher, 29
- handlers, 29
- HTTP Acceptor, 30
- HTTP Handler, 30
- requester, 28
- SOCK Acceptor, 30
- SOCK Stream, 30
- acknowledgments (C++) Stroustrup, Bjarne, 298
- acquisitions, Smalltalk, 88
- Active Object pattern, Web servers, 34
- ACVC (Ada Compiler Validation Capability), 565
- Ada 83, 555
- Ada 95, 555, 563
- Annexes, 563
- GNAT, 564
- GNU, 564
- Ada
- access objects, 633
- Ada.Calendar, 579
- Base parameter, 584
- Integer, 583
- Show Date, 580
- Show Date and Time, 582
- Width parameter, 584
- arrays, 588
- homogenous, 588
- type composition, 589, 592
- unconstrained, 596, 610-612
- books, 657
- brevity, 585
- Byron, Lord, 562
- civilian applications, 571
- command parameters, 592
- comments, 578
- compilers
- ACVC (Ada Compiler Validation Capability), 565
- availability, 574
- validation, 565-566
- concurrency, 646
- compilers, 657
- Dining Philosophers, 657
- guarded command, 655
- mutual exclusion, 649
- operating systems, 656
- random number generator, 648, 653
- screen manager, 648, 651
- Show Tasks program, 650
- STEELMAN Report, 646
- subtasks, 647
- context clauses, 577-578
- declarations, elaborating, 583
- defense projects, 570
- dynamic data structures, 638
- deallocating memory, 639
- garbage collection, 639
- heap, 639
- storage pool, 639
- education, 573
- encapsulation, 599-600
- constructor functions, 600
- infix operators, 600
- exception handling, 592, 596
- locally, 597
- propagating exceptions, 609
- expressions
- aggregated, 610
- initial expressions, 583
- files, 576
- garbage collection, application-specific, 641
- Hello, World, 577
- high order languages
- AJPO, 560
- ANSI, 562
- C, 560
- DoD, 557, 559
- HOLWG, 559
- Ichbiah, Jean, 559
- Taft, S. Tucker, 562
- Information Systems Annex, 592
- inheritance, 623
- layout, 578
- libraries, 579
- Ada.Finalization, 641
- Calendar, 579
- linked lists, 632
- AddToEnd, 640
- dashboard, building, 633
- heterogenous, 633
- MakeEmpty, 639
- loops, 586-589
- Lovelace, Countess Augusta Ada, 561
- matrices, 615-616
- generic package, 618-623
- memory heap, 639
- non-defense projects, 571
- numbers, decimal, 595
- objects, 576
- constrained, 611
- operations
- Adjust, 642
- Finalize, 642
- Initialize, 642
- overloading, 586
- packages, 576
- Ada.Command Line, 592
- encapsulation, 599, 616
- generic, 614-616
- generic matrices, 618-621
- HB.Instruments, 627, 635
- HB.Instruments.Aux, 631
- HB.Instruments.Basic, 628, 636
- HB.Instruments.Clocks, 629, 637
- HB.Lists Generic, 642
- HB.Lists.Generic, 633, 638
- HB.Random Task, 653, 648
- HB.Rationals, 601
- HB.Rationals.IO, 604, 607, 610
- HB.Screen, 649, 653
- HB.Vectors, 621
- rational-number arithmetic, 604
- Rationals, 607
- root, 601
- pointers, 633-635
- access objects, 635
- polymorphism, 623-625
- variant records, 625
- procedures, 578
- Display, 631
- main, 577
- records, fields, 591
- reserved words, 578
- subtypes, 586-588
- ranges, 589
- textbooks, 573
- type composition, 589, 592
- type extension, 623, 627
- types, 576
- Ada.Finalization.Controlled, 641
- hierarchies, 630
- overriding, 628
- primitive, 628
- subtypes, 580, 586-589
- validation, 565
- ACVC (Ada Compiler Validation Capability), 565
- AJPO, 565
- AVFs, 566
- certification, 566
- debugging, 569
- limitations, 569
- performance, 569
- test profile, 567
- vectors, 611-614
- web sites, 555, 657
- Whitaker, William, 556
- Ada.Command Line (Ada), 592
- Ada.Finalization (Ada), 641
- Ada.Finalization.Controlled (Ada), 641
- Adaptor pattern, Web servers, 36
- adaptors, C++, 400-401
- ADDRESS (Modula-3), 683
- AddToEnd (Ada linked lists), 640
- adjust operation (Ada), 642
- advantages, Smalltalk, 185
- AJPO
- Ada validation, 565
- Ada (high order languages), 560
- Algol languages, Modula-3, 669
- Algorithms
- C++, 370-371, 400
- communication software design, 18
- aliases, C++, 454-456
- allocated type, Modula-3, 678
- allocation
- dynamic memory pointers, 332
- memory
- Smalltalk, 169
- Java objects, 757, 807
- Althoff, Jim (Smalltalk), 78
- analysts, Smalltalk, 82
- anchored declarations (Eiffel inheritance), 535
- Anderson, Jim (Smalltalk), 89
- annexes
- Ada, Information Systems Annex, 592
- Ada 95, 563
- Annotated C++ Reference Manual, 254
- ANSI
- Ada (high order languages), 562
- C++, 255
- standards, Smalltalk, 182
- APIs (application programming interfaces), 780
- Apple
- Jobs, Steve (Smalltalk), 69
- lawsuit against Microsoft, 82
- Squeak (Smalltalk), 166
- applets
- compiling, 789
- example, 786-790
- Java, 786, 790
- Java 1.1 changes, 890-891
- Web page integration, 789-790
- applications, distributed, ACE framework (reusable components), 27
- application programming interfaces, 780
- application-specific garbage collection (Ada), 641
- applicators, C++, 391
- architecture
- ACE framework, 24
- Smalltalk composition, 78
- Web
- dispatcher, 28
- event dispatchers, 29
- handlers, 29
- HTTP Acceptor, 30
- HTTP Handler, 30
- requester, 28
- SOCK Acceptor, 30
- SOCK Stream, 30
- arguments, 5
- C++
- passing to functions, 336
- pointers, const, 422-423
- templates, 267
- Java
- command-line arguments, 791
- declaring in arrays, 812-813
- Smalltalk, blocks, 118
- arithmetic operators
- C++, order of precedence, 324
- Modula-3 expressions, 720-722
- ARM (Annotated C++ Reference Manual), 254
- Array (collection classes), 157
- arrays
- Ada
- homogenous, 588
- type composition, 589, 592
- unconstrained, 596, 610-612
- C++, 325, 328-329, 431
- associative, 309
- bounds, 446, 449
- clearing, 331
- deleting, 430
- multidimensional, 427
- of arrays, 429
- pointers, 329-331
- two variable dimensions, 430
- Java, 762, 791, 803, 806-808
- accessing elements from, 811
- arguments, declaring, 812-813
- copying, 805
- destroying, 809
- multidimensional, 809-811
- variables, declaring, 812-813
- versus objects, 812
- Modula-3
- assignable, 680
- constructors, 718
- fixed, 679
- indexing, 680
- open, 679
- shape, 679
- subtyping, 690
- arrow symbol (Smalltalk), 57
- assertions, Eiffel, 463, 498
- classes, 502-504
- reliability, 500
- runtime monitoring, 500-502
- assignment inheritance (C++ OOP), 374
- assignment attempts, Eiffel, 464, 533
- assignment operators, C++, 324, 360
- associative arrays, C++, map, 309
- associative containers, C++, 396
- AST (abstract structure type) modules, 13
- asymetric bounds (C++ libraries), 310
- asynchronous events, C++, exception handling, 270
- Asynchronous Thread Pool model, Web servers, concurrency, 43
- AtAllPut message (collection classes), 157
- attributes. Eiffel
- constant, 539
- features, 478
- Austern, Matt (C++), 267
- automatic objects, C++, memory, 239
- autoprototyping, C with Classes, 213
- AVFs (Ada Validation Facilities), 566
- AWT event model, Java 1.1, 877-878
B
- Babcisky, Karel (C++), 244
- Bag (collection class), 116
- banking, Smalltalk, 191
- base, Ada.Calendar, 584
- base classes, C++, 432-434
- BCPL comments, C++, 231
- BCPL languages, Modula-3, 668
- behaviors
- objects, 12
- Smalltalk objects, 75, 99
- Bell Labs, C with Classes, 222
- binary messages, Smalltalk, 100
- binding
- Eiffel, 463, 513-515
- methods, 8
- bitwise operators, C++, order of precedence, 324
- block constructors, Smalltalk control structures, 117
- block statements
- C++, 340
- Modula-3, 695
- blocks
- Java (flow of control), 754
- Smalltalk
- arguments, 118
- combining control structures, 120
- full closure, 76
- iterative execution, 118
- messages selectors, 124
- Smalltalk, 181
- books
- A Little Smalltalk, 4
- Ada, textbooks, 573
- Adding Classes to the C Language, 203
- C++, 286, 298, 458
- Annotated C++ Reference Manual, 254
- The C++ Programming Language, 243, 258
- The Design and Evolution of C++, 258
- Parallel Programming Using C++, 296
- Classes, An Abstract Data Type Facility for the C Language, 4
- Eiffel, 548
- An Introduction to Object-Oriented Programming, 5
- OOP, 15
- Smalltalk, 80, 90, 194
- The Language and Its Implementation, 3
- boolean
- data type, Java, 802
- objects, Smalltalk, 137
- operations, Modula-3 expressions, 723
- Borning, Alan (Smalltalk), 87
- bounds, arrays (C++), 446, 449
- Box class, Smalltalk, 63
- braces, C++, 319
- branded types, Modula-3, subtyping, 690
- brands (Modula-3 references), 683
- BRAVO (Smalltalk), 65
- break statement
- C++, 342
- Java, 818-819
- brevity
- Ada, 585
- arrays, 588
- BrouHaHa (Smalltalk), 88
- browsers
- Smalltalk, 64
- Smalltalk IDE, 182
- Bruck, Dag (C++), 260
- Budd, Tim (Smalltalk), 86
- Byron, Lord (Ada), 562
- Byte Magazine, Smalltalk, 167
- byte-code verification, Java, 782
- ByteArray (collection classes), 145, 157
- bytecodes, Java, 750
C
- C
- Ada (high order languages), 560
- C++, 240, 313
- compatibility, 240
- Koenig, Andrew, 241
- classes
- friends, 219
- protection, 219
- compilers, 214
- flexibility, 214
- functions
- call, 221
- guarantees, 219
- invariants, 219
- return, 221
- virtual, 218, 221
- inheritance, multiple, 221
- Java, 790, 830-831
- low-level semantics, 214
- pitfalls, 407-408, 412-416
- portability, 214
- protection, 218
- reasons for using, 214
- Simula, 215
- stacks, size, 219
- static members, 222
- syntax, 216-217
- templates, 221
- virtual machines, Smalltalk, 168
- wrappers, 221
- C with Classes, 199
- Bell Labs, 222
- C++
- Adding Classes to the C Language, 203
- class stack, 206
- classes, 206
- compilers, 211
- concurrency, 203
- debugging, 204
- f(void), 213
- features, 205
- functions, 207
- implicit conversions, 214
- inline functions, 208
- linker, 210
- linking, 209
- low-level operations, 204
- members, 207
- new operator, 208
- non-pointer types, 207
- objects, 207
- pointers, 207
- prototypes, 213
- runtime efficiency, 208
- runtime speed, 204
- SIGPLAN paper, 203
- static type checking, 212
- types, 207
- classes, layout information, 210
- development, 223
- Fraser, Sandy, 223
- into C++, 224
- Johnson, Steve, 224
- McIlroy, Doug, 224
- Ritchie, Dennis, 224
- C++, 305
- #include, 313
- abstract data types, 232
- abstractions, 306
- generic, 307
- OOP, 307
- pointers, 325-326, 329-331
- constants, 332-333
- dynamic memory allocation, 332
- references, 325-328
- variable-length character strings, 306
- ACE framework, 27
- adaptors, 400-401
- algorithms, 400
- aliases, 454-456
- Annotated C++ Reference Manual, 254
- applicators, 391
- arrays, 325, 328-329, 431
- associative, 309
- bounds, 446, 449
- clearing, 331
- deleting, 430
- multidimensional, 427
- of arrays, 429
- pointers, 329-331
- two variable dimensions, 430
- assignment operators, 360
- Austern, Matt, 267
- Babcisky, Karel, 244
- beginnings, 197
- books, 286, 298, 458
- The C++ Programming Language, 243, 258
- The Design and Evolution of C++, 258
- Parallel Programming Using C++, 296
- braces, 319
- Bruck, Dag, 260
- C, 240, 313
- compatibility, 240
- Koenig, Andrew, 241
- C with Classes, 199
- Adding Classes to the C Language, 203
- class stack, 206
- classes, 206
- compilers, 211
- concurrency, 203
- debugging, 204
- f(void), 213
- features, 205
- functions, 207
- header files, 210
- implicit conversations, 214
- inline functions, 208
- layout information in classes, 210
- linker, 210
- linking, 209
- low-level operations, 204
- members, 207
- new operator, 208
- non-pointer types, 207
- objects, 207
- pointers, 207
- prototypes, 213
- runtime efficiency, 208
- runtime speed, 204
- SIGPLAN paper, 203
- static type checking, 212
- types, 207
- casting, 259
- characters, 321
- cin, 309
- class templates, 262
- classes
- abstract, 252-253
- base class conversions, 432-434
- complex template class, 393
- containers, 435-436, 439
- defining, 350
- derived, 217
- dynamic binding, 374
- istream, 389
- multiple inheritance, 250
- nested, 257
- ostream, 389
- private, 379
- protected, 379
- public, 379
- size concerns, 295
- templates, 368-369
- valarray, 393
- comments, 307
- competitors, 288
- compilers, 211, 286
- conferences, 285
- const, 408, 412, 422
- declarations, 412
- pointer arguments, 422-423
- constants, pointers, 332-333
- constructors, 357-358
- copy, 358-359
- explicit, 258
- containers, 394
- associative, 396
- compound, 397
- sequential, 394-395
- Cornfield, Sean, 260
- cout, 308
- data abstraction, 350, 362-366
- data types
- enumerated, 322
- fixing, 366
- declarations, conditions, used as, 261
- Denert, Jim, 267
- destructors, 361, 377
- development, 224
- additions to language, 230
- aims, 226
- BCPL comments, 231
- Cfront, 226-230
- Coplien, Jim, 227
- Rose, Leonie, 227
- Shopiro, Jonathan, 227
- Ellis, Margaret, 254
- environments, 287
- exception handling, 246, 268
- asynchronous events, 270
- groups of exceptions, 268
- resources, 269
- execution, 445
- expressions, new, 427
- features, major and minor, 258
- floating-point arithmetic, 321
- functions, 335-337
- default arguments, 337
- definitions, 335
- exceptions, 339, 346
- exiting, 338-339
- modifiable memory, 422
- numeric library functions, 392-394
- operators, 347
- overloaded, 347
- parameters, 336
- passing arguments to, 336
- pure virtual functions, 378
- recursion, 337
- references, 423, 426
- strlen, 335
- templates, 366-367
- type checking, 239
- virtual, 231, 234, 432
- virtual functions, 374, 376
- generic programming, 366
- hash tables, 282
- header files, 210
- Hello, World, 313
- increments, postfix and prefix, 257
- inheritance
- base class conversions, 432
- multiple, 247, 249-251
- integer arithmetic, 319
- integers, 317
- operators, 318
- signed, 317
- unsigned, 317
- Internet, 284
- iostream, 314
- iterators, 310, 397-399
- Java, 290
- journals, 286
- jumps, 342
- Krogdahl, Stein, 250
- Lenkov, Dmitry, 255
- libraries, 312
- asymetric bounds, 310
- dynamic memory, 312
- early, 287
- I/O libraries, 388-389
- language, in relation to, 312
- standard I/O, 307
- string library, 391-392
- see also standard library
- loops, 341
- lvalues, 326
- manipulators, 308, 390
- member functions, 352-355
- effects on program organization, 354
- exclusivity, 355, 357
- implementation, 355
- private, 355
- protected, 355
- public, 355
- memory, 238
- automatic objects, 239
- delete operator, 238
- free store, 238
- new operator, 238
- static objects, 239
- modifiers, const, 332
- Moo, Barbara, 278
- namespaces, 271-272, 348-350
- numeric conversions, 323
- objects, members, pointers, 361
- OOP, 371, 380-386
- dynamic binding, 374
- dynamic casts, 378
- inheritance, 372, 379
- assignment, 374
- constructors, 373-374
- destructors, 374
- pure virtual functions, 378
- virtual destructors, 377
- virtual functions, 374-376
- operators, 309
- ++, 309-311
- constants, 238
- floating-point arithmetic, 321
- integer arithmetic, 318
- overloading, 235
- postfix ++, 319
- precedence, 323-325
- readonly, 238
- references, 237
- relational, 318
- order relations, 439
- parameterized types, 246
- pitfalls, 405, 407
- pointers
- dangling, 452
- dynamically allocated memory, 452
- functions, 454
- local variables, 452
- preprocessing, 313
- program structure, 313
- Randell, Brian, 268
- references, 454-456
- resources, 402
- retrospective, 291-293
- additions, 295
- changes, 293-295
- future, 297
- mistakes, 297
- Rosler, Larry, 255
- Rowe, Keith, 271
- runtime type identification, 273
- Schwarz, Jerry, 277
- semantics, 419, 445
- setw, 311
- Simula, 199
- classes, 199
- compiling, 200
- debugging, 200
- linking, 200
- tools, 201
- Simula, 200
- smart pointers, 257
- source files, 313
- defining, 316
- maintaining consistency, 315
- stacks, constructors and destructors, 220
- standard library, 274, 387-388
- facilities, 282
- foundation libraries, 275
- stream I/O, 276
- templates, 278-282
- standardization, 253
- accepted features, 274
- ANSI, 255
- ISO, 255
- statements, 339
- blocks, 340
- break, 342
- conditional, 341
- continue, 342
- expression, 340
- goto, 342
- if, 319, 341
- null, 339
- pass, 338
- precedence, 339
- return expression, 338
- switch, 344-346
- throw, 338, 346
- while, 341
- Stepanov, Alexander, 278
- strchr function, 419
- string literals, 334-335
- Stroustrup, Bjarne, 197
- acknowledgments, 298
- references, 298
- structures
- defining, 351
- reversing, 370-371
- syntax, 409, 418
- const, 413-416
- constructor initializers, 417
- declarations, 411
- lexical analysis, 409
- member functions, 414
- specifiers, 411
- symbol spacing, 410
- tokens, 409
- templates, 262
- arguments, 267
- class, 262
- compilation, 266
- instantiation, 266
- member, 264-265
- partial specialization, 264
- tools, 242, 287
- translation units, 313
- truth values, 320
- type checking, 239, 245
- type conversion, 259
- UNIX kernel, 202
- user population, 284
- variables, local, 310
- version 2.0, 247-248
- version 2.1, 257
- versus Java, 779, 790
- What is Object-Oriented Programming? (paper), 244
- white space, 319
- width (setw), 311
- Wilcox, John, 267
- wrappers, ACE framework, 24-25
- SOCK Acceptor, 30
- SOCK Stream, 30
- The C++ Programming Language (Stroustrup), 243, 258
- Calendar (Ada), 579
- Base parameter, 584
- Integer, 583
- Show Date, 580
- Show Date and Time, 582
- Width parameter, 584
- Call function, C, 221
- Call rule, Eiffel, 490
- calls, Eiffel, 482
- Canada (Smalltalk), 88
- Cardelli (Modula-3), 743
- Cardelli, Luca (Modula-3), 665
- Carter, Ron (Smalltalk), 83
- CASE statement (Modula-3), 700
- cast unary operator, C++, 323
- casting C++, 259
- Catch clause (Java try/catch/finally statement), 823
- categories, Eiffel, 485
- Cedar, Modula-3, 669
- certification, Ada validation, 566
- Cfront
- C++ development, 226-227
- drivers, 229
- linkers, 229
- versions, 230
- Coplien, Jim, 227
- Rose, Leonie, 227
- Shopiro, Jonathan, 227
- Char data type, Java, 802
- character literals
- Modula-3 expressions, 717
- Smalltalk objects, 97
- character objects, Smalltalk, 139
- characters
- C++, 321
- Smalltalk, 56-57
- checked runtime error
- Thread.Join, 730
- Word.Extract, 732
- Word.Insert, 732
- child classes, 8
- CIA, Smalltalk, 81
- Cin, C++, 309
- civilian applications, Ada, 571
- class fields (Java objects), 758
- class files, Java, 792
- class instance variables, Smalltalk, 113
- class libraries, Smalltalk, 130, 170, 183
- protocols, 132
- Smalltalk-80, 73
- class members, Java
- access to, 796
- hiding, 862
- private, 859-862
- protected, 859-862
- public, 859-862
- class methods
- Java, 761, 840-844
- Smalltalk, 112
- class templates, C++, 262
- class variables
- classes (Smalltalk), 75
- Java, 837
- accessing, 838
- naming scheme, 839
- Class.newInstance() method, Java, 807
- ClassDescription, Smalltalk, 135
- classes, 7, 12
- An Abstract Data Type Facility for the C Language, 4
- C
- friends, 219
- protection, 219
- C with Classes, 206
- class stack, 206
- layout information, 210
- members, 207
- objects, 207
- types, 207
- C++
- abstract, 252-253
- base class conversions, 432-434
- complex template class, 393
- constructor initializers, 417
- containers, 435-436, 439
- defining, 350
- derived, 217
- dynamic binding, 374
- inheritance in OOP, 372
- istream, 389
- multiple inheritance, 250
- nested, 257
- ostream, 389
- private, 379
- protected, 379
- public, 379
- size concerns, 295
- templates, 368-369
- valarray, 393
- child, 8
- Eiffel, 462, 472, 479
- assertions, 502, 504
- deferred, 463, 515, 518
- generic, 464
- instances, 476
- invariants, 523
- parameterized, 464
- relations, 473
- structural property, 520
- systems, 472
- f(void), C with Classes, 213
- frameworks, 22
- inheritance structure, 8
- Java, 749, 757, 778, 831-832
- abbreviating names with import statement, 796
- abstract classes, 863-865
- access to, 796
- directory paths, 794
- extending, 765, 847-848
- fields, 757
- final classes, 848
- hierarchy, 849
- inheritance, 847
- instances, 749, 832
- interfaces, 769
- invoking methods from superclass, 767
- loading dynamically, 780
- main method, 750
- mapping, 798
- members, 792
- methods, 749, 757
- Object, 849
- Point class, 757
- public, 795-796
- SecurityManager, 783
- subclasses, 765
- testing for frequency of use, 838
- type, 775
- utility, 775
- java.lang package, Thread, 784
- object-oriented programming, 778
- parent, 8
- Simula, C++, 199
- Smalltalk, 57, 62, 104, 178
- behaviors, 75
- blocks, 181
- box, 63
- class instance variables, 113
- class variables, 75
- code, 180
- definitions, 111
- hierarchy, 74
- inheritance, 108
- instance variables, 75
- instances, 104
- metaclasses, 74
- methods, 106, 168
- names, 104
- objects, 136, 169
- pool variables, 75
- self identifier, 110
- subclasses, 108
- super identifier, 111
- superclasses, 108
- variables, 105
- CLASSPATH environment variable, Java, 794
- Clone() method, Java, 805
- closed colon symbol (Smalltalk), 57
- closure blocks (Smalltalk), 76
- Clu, Modula-3, 668
- clusters, Eiffel, 466, 475
- code, Smalltalk
- classes, 180
- methods, 181
- collection classes
- adding elements, 150
- Array, 145
- atAllPut message, 157
- Bag, 151
- ByteArray, 145
- concatentation, 155
- copy messages, 155
- Dictionary, 151
- index of messages, 155
- initializing, 146
- iteration messages, 156
- messages, 148
- new, 146
- OrderCollection, 145
- OrderedCollection, 160-161
- positioning, 145
- read-only, 145
- removing elements, 151
- replace message, 157
- reverse message, 155
- Set, 145, 151
- SortedCollection, 145
- String, 145
- collection classes (Smalltalk) protocols, 144
- colons (Smalltalk symbols), 57
- Comma operator, C++, order of precedence, 324
- command parameters, Ada, 592
- command-line arguments, Java, 791, 794
- commands, Eiffel features, 478
- comments
- Ada, 578
- C++, 307
- Java, 753, 797
- Modula-3 syntax, 739
- Smalltalk, 97
- Committee (Modula-3), 667
- common-use components, ACE framework, 27
- communication software, 17
- algorithmic design, 18
- complexities
- accidental, 18
- inherent, 17
- frameworks, 19, 22
- ACE, 18, 23
- classes, 22
- reuse, 22
- OOP, 12, 18
- patterns, 19, 21
- strategic, 31
- tactical, 35
- problems, 19
- solutions, 21
- Web servers, 31
- Community, Smalltalk, 71
- comparisons , C++
- containers, 435, 439
- pointers, 439
- compatibility, C++ with C, 240
- competitors, C++, 288
- compilers
- Ada
- ACVC (Ada Compiler Validation Capability), 565
- availability, 574
- concurrency, 657
- validation, 565-566
- C, 214
- C with Classes, 211
- C++, 286
- Eiffel, 469, 550
- Java, just in time compilers, 784
- Smalltalk, 72
- compiling
- applets, 789
- Java programs, 785, 799
- Simula, C++, 200
- Smalltalk, 168
- templates (C++), 266
- unit productions, Modula-3 syntax, 740
- complex template class, C++, 393
- Complexities communication software, 17-18
- components
- ACE framework, 24-27
- Eiffel, 463, 546
- Web servers
- concurrency, 36
- event dispatcher, 29
- HTTP Acceptor, 30
- HTTP Handler, 30
- SOCK Acceptor, 30
- SOCK Stream, 30
- composition architecture, Smalltalk, 78
- compound containers, C++, 397
- concatenating text, Modula-3, 726
- concurrency
- ACE framework components, 26
- Ada, 646
- compilers, 657
- Dining Philosophers, 657
- guarded command, 655
- mutual exclusion, 649
- operating systems, 656
- random number generator, 648, 653
- screen manager, 648, 651
- Show Tasks program, 650
- STEELMAN Report, 647
- subtasks, 647
- C++, C with Classes, 203
- Eiffel, SCOOP, 544
- Web servers, 36
- asynchronous Thread Pool model, 43
- components, 36
- handle-based synchronous Thread Pool model, 40
- patterns, 36
- queue-based synchronous Thread Pool model, 42
- Single-Threaded Reactive model, 36
- Thread Pool model, 40
- Thread-per-Request model, 39
- Thread-per-Session model, 44
- conditional
- compilation, Java programs, 799
- execution, Smalltalk control structures, 116
- instructions, Eiffel, 540
- statements, C++, 341
- conditions, C++, declarations used as, 261, 285
- const
- C++, 408, 412
- declarations, 412
- member functions, 414-416
- modifiable memory, 422
- modifier, 332
- point arguments, 422-423
- pointers to constants, 413
- pointers to members, 414-416
- strchr function, 419, 422
- constants
- C++, 238
- const modifier, 413
- const pointers, 416
- pointers, 332-333
- readonly, 238
- Eiffel, attributes, 539
- Java, 753, 839
- defining, 797
- interfaces, 868
- named, 753
- unicode characters, 754
- Modula-3
- declarations, 703
- expressions, 677, 726
- procedures, 684
- constrained genericity, Eiffel, 495, 532
- constrained objects, Ada, 611
- Constructor functions, Ada encapsulation, 600
- constructors
- C++, 357-358
- explicit, 258
- initializers, 417
- stacks, 220
- inheritance, (C++ OOP), 373-374
- Java, 834
- chaining, 850-851
- declaring, 835
- default constructors, 851-852
- defining, 835
- for subclasses, 849-850
- multiple, 835-837
- naming, 835
- Modula-3
- arrays, 718
- records, 718
- set, 718
- containers, C++, 394, 435, 439
- associative, 396
- comparisons, 435
- compound, 397
- functions, 436
- sequential, 394-395
- Context clauses, Ada, 577-578
- Continue statement
- C++, 342
- Java, 818-819
- contracts, Eiffel, 497, 508
- consistency, 500
- inheritance, 522, 526
- subcontracting, 522
- contributors, Smalltalk, 52
- control structures, Smalltalk, 73, 115
- block constructors, 117
- combining, 120
- conditional execution, 116
- iterative execution, 118
- controls (GUIs), Smalltalk, 176
- conventions, Modula-3 syntax, 739-740
- conversions, implicit, C with Classes, 214
- converting base classes (C++), 432
- Coplien, Jim (Cfront), 227
- copy constructors, C++, 358-359
- Copy message, Smalltalk objects, 134
- copying in Java
- arrays , 805
- objects, 804
- CORBA
- Eiffel, 546
- ORB, 28
- core modules, Smalltalk
- DLLs, 171
- OCXs, 171
- Cornfield, Sean (C++), 260
- cout, C++, 308
- covariance, Eiffel inheritance, 535
- critical sections, Java programs, 819
- Culture, Smalltalk, 185
- development cycle, 187
- freeware, 190
- object technology centers (OTCs), 186
- vendors, 187
D
- dangling pointers
- C++, 452
- Modula-3, 674
- data abstraction, C++, 350, 362-366
- data fields, Modula-3, objects, 686
- data types
- C++
- enumerated, 322
- fixing, 366
- user-defined, 350
- Java, 830
- boolean, 802
- char, 802
- floating-point, 803
- integral, 802
- naming schemes, 830
- primitives, 801
- reference, 803, 806
- databases, Eiffel, 546
- Date, Ada (Show Date), 580
- deallocating memory, Ada, dynamic data structures, 639
- Debug instruction, Eiffel, 542
- debuggers
- Smalltalk, 64
- Smalltalk IDE, 182
- debugging
- Ada validation, 569
- C with Classes, 204
- Simula, C++, 200
- DEC statement (Modula-3), 702
- decimal integer literals, Smalltalk objects, 96
- decimal numbers, Ada, 595
- declarations
- Ada, 583
- C++
- conditions, used as, 261
- pitfalls, 411
- Eiffel
- types, 484
- inheritance, anchored, 535
- Modula-3, 676, 702
- constants, 703
- exceptions, 704
- opaque types, 704
- procedures, 704
- recursive, 706
- revelations, 705
- scope, 676
- types, 703
- variables, 703
- declaring
- Java
- arguments, 812-813
- constructors, 835
- exceptions, 824-825
- local variables, 827
- variables, 812-813
- C++
- arrays, 328
- pointers, 326
- references, 327
- deep operations, Eiffel, 488
- default arguments, C++ functions, 337
- default constructors, Java, 851-852
- defense projects. Ada, 570
- Deferred classes (Eiffel), 463, 515, 518, 520
- Deferred features (Eiffel), 515, 518
- defining
- C++
- classes, 350
- structures, 351
- Java
- constants, 797
- constructors, 835
- exceptions, 825-827
- definitions
- functions, C with Classes, 207
- Smalltalk, 111, 178
- Delete operator, C++, 238
- demos, Eiffel, 468
- demultiplexing
- ACE framework components, 26
- OS adaption layer (ACE framework), 25
- Denert, Jim (C++), 267
- dependencies, Smalltalk, 174
- Deque sequential container, C++, 394
- dereferencing (Modula-3 designators), 715
- derived classes, C++, 217
- The Design and Evolution of C++ (Stroustrup), 258
- designators, Modula-3
- dereferencing, 715
- expressions, 676, 715
- LOOPHOLE, 715
- selection, 715
- SUBARRAY, 715
- subscripting, 715
- designers, Modula-3, 743
- destructors
- C++, 361
- stacks, 220
- virtual destructors, 377
- inheritance, (C++ OOP), 374
- Deutsch, Peter (Smalltalk), 83
- development
- C with Classes, 223
- Fraser, Sandy, 223
- into C++, 224
- Johnson, Steve, 224
- McIlroy, Doug, 224
- Ritchie, Dennis, 224
- C++, 224
- additions to language, 230
- aims, 226
- BCPL comments, 231
- Cfront, 226-230
- Coplien, Jim, 227
- Rose, Leonie, 227
- Shopiro, Jonathan, 227
- Smalltalk, 65, 187
- Smalltalk IDE teams, 185
- environments, 83
- tools, 183
- Dictionary (collection class), 145
- Digital Equipment Corporation, Modula-3, 667
- digital signatures, Java, 783
- Digitalk, Parts Workbench, 85
- Dining Philosophers (Ada concurrency), 657
- directory paths, Java, 792, 794
- Dispatcher, Web, 28
- Display procedure, Ada, 631
- distributed applications, ACE framework (reusable components), 27
- distributed object computing (DOC) communication software, 20
- distribution, Smalltalk, 71
- DLLs, Smalltalk, 171
- Do statement, Java, 816
- documentation, Eiffel, 463
- DoD (Department of Defense), Ada, 556, 570
- AJPO, 560
- ANSI, 562
- C, 560
- high order languages, 557-559
- HOLWG, 559
- Ichbiah, Jean, 559
- mandate, 570
- Taft, S. Tucker, 562
- Dolphins, Smalltalk, 70
- Donahue, Jim (Modula-3), 665, 743
- Dorados, Smalltalk, 70
- drivers, Cfront, 229
- Dynabook
- Kay, Alan (Smalltalk), 51
- Smalltalk, 55
- dynamic binding
- Eiffel, 463, 513-515
- OOP in C++, 374
- Smalltalk, VisualWorks, 85
- dynamic casts, OOP in C++, 378
- dynamic data structures, Ada, 638
- deallocating memory, 639
- pointers, 332
- pointers(C++), 452
- garbage collection, 639
- heap, 639
- storage pool, 639
- dynamic memory, C++ libraries, 312
- Dynamic method lookup, 856
- dynamically bound, Smalltalk, 169
E
- early libraries, C++, 287
- education
- Ada, 573
- Smalltalk, 59-61
- Eiffel, 461
- abstraction, 493
- assertions, 463, 498
- classes, 502-504
- reliability, 500
- runtime monitoring, 500-502
- assignment attempts, 464
- attributes, constant, 539
- binding, 463, 513-515
- books, 548
- call rule, 490
- calls, 482
- classes, 462, 472, 479
- deferred, 463, 515, 518
- generic, 464
- instances, 476
- invariants, 523
- parameterized, 464
- relations, 473
- short form, 502-504
- structural property, 520
- clusters, 475
- compilers, sources, 550
- components, 463, 546
- concurrency, SCOOP, 544
- contracts, 497, 508
- consistency, 500
- inheritance, 522, 526
- subcontracting, 522
- CORBA, 546
- databases, 546
- deep operations, 489
- documentation, 463
- entities, 481, 486
- exceptions, 463, 504, 507
- execution, 476, 491
- abstraction, 493
- call rule, 490
- calls, 482
- classes, 476, 479
- deep operations, 488
- entities, 481, 486
- expressions, 486
- features, 477-478
- infixes, 483
- information hiding, 490
- memory, 489
- objects, 476-480
- persistence, 489
- prefixes, 483
- type categories, 485
- type declaration, 484
- expressions, operations, 486
- external software, 475
- features, 477
- attributes, 478
- commands, 478
- deferred, 515, 518
- queries, 478
- renaming, 464, 521
- routines, 478
- garbage collection, 464
- genericity, 464, 494, 496
- constrained, 495
- parameters, 495
- Hello, World, 470-471
- history, 546
- infixes, 483
- information hiding, 463, 490
- inheritance, 463, 508
- assignment attempts, 533
- contracts, 522, 526
- covariance, 535
- declarations, anchored, 535
- deferred classes, 515, 518
- deferred features, 515, 518
- dynamic binding, 513-515
- export status, 527
- flat forms, 528
- genericity, 532
- global, 474
- joining, 526
- multiple, 464, 521
- polymorphism, 511-513
- redefinition, 509
- repeated, 464, 529
- structural property classes, 520
- uneffecting, 526
- instructions, 540
- conditional, 540
- debug, 542
- loops, 541
- interfaces, 462
- Java, 546
- lexical conventions, 543
- libraries, 464, 546
- memory, 489
- method, 462
- Microsoft OLE, 546
- modularity, 464
- objects, 476
- creating, 479
- deep operations, 488
- fields, 477
- initializing, 480
- references, 477
- shared, 537
- OOP, 462
- persistence, 489
- polymorphism, 463
- prefixes, 483
- process, 466
- clusters, 466, 475
- compilers, 469
- external software, 475
- generalization, 468
- global inheritance, 474
- quality development, 469
- reuse, 468
- reversibility, 468
- seamlessness, 468
- working demos, 468
- redefinition, 463
- routines, 464, 537
- subcontracting, 463
- systems, 472
- type system, 462
- categories, 485
- declaration, 484
- static typing, 464
- web sites, 550
- elaborating declarations, Ada, 583
- Ellis, Margaret (C++), 254
- Else statement, Java, 816
- encapsulation
- Ada, 599-600
- constructor functions, 600
- generic packages, 617
- infix operators, 600
- Java, 858-859
- Smalltalk, 99
- Smalltalk IDE, 184
- Endl manipulator, C++, 390
- enterprise APIs, Java 1.1, 890
- entities, Eiffel, 481, 489
- enumerated data types, C++, 322
- environments, C++, 287
- ENVY (Smalltalk), 89
- equality objects (Smalltalk), 134
- errors, Modula-3
- runtime, 677
- static, 677
- unchecked runtime, 677
- see also exception handling
- European vendors (Smalltalk), 87
- Eval bind symbol (Smalltalk), 57
- EVAL statement (Modula-3), 695
- event dispatchers, Web, 29
- event frameworks, Smalltalk, 174-176
- exception handling
- Ada, 592, 596
- locally, 597
- propagating exceptions, 609
- C++, 246, 268
- asynchronous events, 270
- groups of exceptions, 268
- resources, 269
- Eiffel, 504, 507
- Java, 770-771, 782, 822-824
- Modula-3, 674
- Smalltalk, 126-127, 171, 174
- exiting handler blocks, 129
- resumability, 128
- see also errors
- exceptions
- C++ functions, 339, 346
- Eiffel, 463
- Java, 782, 821
- catching, 821
- declaring, 824-825
- defining, 825-827
- generating, 825-827
- propagation, 821
- throwing, 821
- Modula-3, declarations, 704
- execution
- C++, 445
- Eiffel, 476, 491
- abstraction, 493
- call rule, 490
- calls, 482
- classes, 476, 479
- deep operations, 488
- entities, 481, 486
- expressions, 486
- features, 477-478
- infixes, 483
- information hiding, 490
- memory, 489
- objects, 476-480
- persistence, 489
- prefixes, 483
- type categories, 485
- type declaration, 484
- execution path, Smalltalk, 169
- EXIT statement (Modula-3), 697
- exiting
- C++ functions, 338-339
- handler blocks (Smalltalk), 129
- explicit constructors, C++, 258
- explicit dynamic linking, OS adaption layer (ACE framework), 25
- export status, Eiffel inheritance, 527
- expression productions, Modula-3 syntax, 741-742
- Expression statement, C++, 340
- expressions
- Ada
- initial expressions, 583
- C++, new, 427
- Eiffel, operations, 486
- Modula-3, 676, 713
- arithmetic operations, 720-722
- array constructors, 718
- Boolean operations, 723
- character literals, 717
- constant expressions, 677, 726
- designators, 676, 715
- integer codes, 724
- NEW, 719
- NIL, 718
- numeric literals, 716
- operation syntax, 714
- operations, 713
- procedural operators, 715
- procedure call, 718
- record constructors, 718
- relations, 722
- set constructors, 718
- text concatenation, 726
- type operations, 724-726
- text literals, 717
- extended interface, Modula-3, 733
- ExtendedFloat interface, Modula-3, 734-735
- extending in Java
- classes, 765, 847-848
- interfaces, 769, 868
- external interfaces (Eiffel), 462
- external software, Eiffel, 475
- Eyeball symbol (Smalltalk), 57
F
- f(void), C with Classes, 213
- facilities, C++, standard template library, 282
- FastTalk see Smalltalk-74
- features
- C++, 258
- Eiffel, 477
- attributes, 478
- commands, 478
- deferred, 515, 518
- queries, 478
- renaming, 464, 521
- routines, 478
- Fiboncci sequence, Java, 751
- fields
- Ada records, 591
- Eiffel objects, 477
- Java, 792
- class, 749, 757-758
- objects, 758
- static, 758
- Modula-3, 681
- filenames, Java, 792
- files, Ada, 576
- final classes, Java, 848
- final keyword, Java, 829
- final methods, Java, 855, 858
- Finalize operation (Ada), 642
- finalizer methods, Java, 852
- finalizing objects in Java, 846-847
- finally clause (Java try/catch/finally statement), 823
- find algorithm, C++, 400
- fixed arrays, Modula-3, 679
- flat forms, Eiffel inheritance, 528
- FLEX machine (Smalltalk), 53
- Floating-point
- arithmetic, C++, 321
- data types, Java, 803
- protocol, Smalltalk, 143
- Modula-3, interfaces, 734-737
- FloatMode interface (Modula-3), 735-737
- flow of control, Java, 754
- blocks, 754
- if/else, 756
- For loop, Java, 755
- For statement, Java, 817
- FOR statement (Modula-3), 699
- forms, Eiffel inheritance, 528
- forward references, Java, 828
- foundation libraries, C++, 275
- Fraction protocol (Smalltalk), 143
- frameworks
- communication software, 19, 22
- ACE, 18, 23
- architecture, 24
- C++ language, 27
- C++ wrappers, 24-25
- components, 24-27
- middleware, 28
- operating systems, 25
- OS adaption layer, 25
- Web servers, 28
- classes, 22
- reuse, 22
- Smalltalk, 186
- events, 174-176
- exception handling, 171, 174
- Fraser, Sandy (C with Classes), 223
- Free store, C++, 238
- freeware, Smalltalk, 190
- GNU Smalltalk, 190
- LearningWorks, 166, 190
- Little Smalltalk, 190
- SmalltalkExpress, 166, 190
- Squeak, 166, 190
- Friends, C classes, 219
- function procedures, Modula-3, 684
- functions, 352
- C
- call, 221
- guarantees, 219
- invariants, 219
- return, 221
- virtual, 218, 221
- C with Classes, 208
- definitions, 207
- new( ), 207
- types, 207
- C++, 335-337
- containers, 436
- default arguments, 337
- definitions, 335
- exceptions, 339, 346
- exiting, 338-339
- numeric library functions, 392-394
- operators, 347
- overloaded, 347
- parameters, 336
- passing arguments to, 336
- pointers, 454
- pure virtual functions, 378
- recursion, 337
- references, 423, 426
- strchr, 419, 422
- strlen, 335
- templates, 366-367
- type checking, 239
- virtual, 231, 234, 374-376, 432
- lexical closure, 121
- new( ), 207
G
- Galley editor (Smalltalk), 67
- garbage collection
- Ada
- application-specific, 641
- dynamic data structures, 639
- Eiffel, 464
- Java, 759, 808, 844-845
- Modula-3, 669, 674
- Smalltalk, 169
- generalization, Eiffel, 468
- generic abstraction, C++, 307
- generic algorithms, C++, 370-371
- generic packages, Ada, 614-616
- matrices, 618-619, 621
- parameters, 615
- generic programming. C++, 366
- genericity,
- Eiffel, 464, 494-496
- constrained, 495, 532
- parameters, 495
- Modula-3, 671, 710-712
- global inheritance, Eiffel, 474
- GNAT. Ada, 564
- GNU
- Ada, 564
- Smalltalk freeware, 190
- Gosling, James (Java), 747
- goto statement, C++, 342
- government, Smalltalk, 192
- graphical user interfaces, see GUI (Graphical user interfaces)
- Griswold, David (Smalltalk), 88
- guarantees, C functions, 219
- Guarded command (Ada concurrency), 655
- GUIs (graphical user interfaces)
- frameworks (OOP), 10
- lawsuits, Apple and Microsoft, 82, 176
H
- Half-sync/Half-async pattern, Web servers, 34
- handle-based synchronous Thread Pool model, Web servers, concurrency, 40
- handlers, web, 29
- hardware, Smalltalk, 70
- Hash tables
- C++, standard template library, 282
- Smalltalk, 134
- HB.Instruments (Ada package), 627, 636
- HB.Instruments.Aux (Ada package), 631
- HB.Instruments.Basic (Ada package), 628, 636
- HB.Instruments.Clocks (Ada package), 629, 637
- HB.Lists.Generic (Ada package), 633, 639, 642
- HB.Random Task (Ada concurrency), 648, 653
- HB.Rationals (Ada packages), 601
- HB.Rationals.IO (Ada packages), 604, 607, 610
- HB.Screen (Ada concurrency),649, 653
- HB.Vectors (Ada), 621
- header files, C with Classes, 210
- heap
- Ada, dynamic data structures, 639
- Java object, 757
- Heeg, Georg (Smalltalk), 87-88
- Hello, World program
- Ada, 577
- C++, 307, 313
- Eiffel, 470-471
- Java, 750, 785
- heterogenous lists (Ada), 633
- hierarchies
- Ada, types 630
- Smalltalk, classes 74
- high order languages, Ada
- AJPO, 560
- ANSI, 562
- C, 560
- DARPA, 560
- DoD, 557-559
- HOLWG, 559
- Ichbiah, Jean, 559
- Taft, S. Tucker, 562
- history
- Eiffel, 546
- Smalltalk, 52, 166
- Dynabook, 55
- Ingalls, Dan, 55
- PARC, 54
- Hoare, C. A. R. (Modula-3), 676
- HOLWG, Ada (high order languages), 559
- homogenous arrays, Ada, 588
- HTTP Acceptor, web, 30
- HTTP Handler, web, 30
I
- I/O, Java, 775
- I/O libraries, C++, 388-389
- IBM
- Smalltalk, 89
- Visual Age, 85
- Ichbiah, Jean (Ada), 559
- IDE (integrated development environment), Smalltalk, 83
- browsers, 182
- debugger, 182
- development teams, 185
- development tools, 183
- encapsulation, 184
- image file, 184
- libraries, 183
- visual environments, 183
- identical messages, Smalltalk, 103
- identifiers, Modula-3, 676
- Identity objects (Smalltalk), 133
- If statement
- C++, 319, 341
- Java, 816
- IF statement (Modula-3), 698
- If/else, Java (flow of control), 756
- image file, Smalltalk IDE, 184
- implicit conversions, C with Classes, 214
- Import statement
- Java, 795-796, 820
- Modula-3, 707
- INC statement (Modula-3), 702
- include files, Modula-3 interfaces, 670
- incremental compilation, Smalltalk, 168
- increments, C++, prefix and postfix, 257
- indexing arrays, Modula-3, 680
- indirect repeated inheritance, Eiffel, 529
- Infix operators, Ada encapsulation, 600
- infixes, Eiffel, 483
- information hiding, 6
- Eiffel, 463, 490
- OOP modules, 13
- Information Systems Annex, Ada, 592
- Ingalls, Dan (Smalltalk), 62
- inherent complexities (communication software), 17
- inheritance, 7
- Ada, 623-625
- C, multiple, 221
- C++
- base class conversions, 432
- multiple, 247-251
- classes, 8, 847
- Eiffel, 463, 508
- assignment attempts, 533
- contracts, 522, 526
- covariance, 535
- declarations, anchored, 535
- deferred classes, 515, 518
- deferred features, 515, 518
- dynamic binding, 513-515
- export status, 527
- flat forms, 528
- genericity, 532
- global, 474
- joining, 526
- multiple, 464, 521
- polymorphism, 511, 513
- redefinition, 509
- repeated, 464, 529
- structural property classes, 520
- uneffecting, 526
- hierarchy, 12
- Java classes, 765
- OOP, 14
- OOP in C++, 372, 379
- assignment, 374
- constructors, 373-374
- destructors, 374
- Smalltalk classes, 108, 109
- initial expressions, Ada, 583
- Initialize operation (Ada), 642
- initializers
- constructors (C++), 417
- Java methods, 842-844
- initializing
- collection classes, 146
- Eiffel objects, 480
- Modula-3 modules and interfaces, 712
- inline functions, C with Classes, 208
- inner classes, Java 1.1, 877
- input iterators, C++, 397
- inspectors, Smalltalk, 64
- instance methods, Java, 841-844
- Instance variables
- classes (Smalltalk), 75
- Java, 837
- Instanceof operator, Java, 815
- instances, 7
- Java, 749
- Smalltalk, 53
- classes, 104
- variables, 105
- instantiation
- object, Java, 757
- templates (C++), 266
- instructions, Eiffel
-
- conditional, 540
- debug, 542
- loops, 541
- insurance, Smalltalk, 191
- INTEGER (Modula-3), 678
- integer arithmetic (C++), 319
- Integer protocol (Smalltalk), 142
- integers, C++, 317
- operators, 318
- signed, 317
- unsigned, 317
- integral data types, Java, 802
- integrated development environment, see IDE
- interfaces
- Eiffel, 462
- Java, 768, 865-866
- classes, 769
- constants, 868
- extending, 769, 868
- implementing, 866-867
- marker interfaces, 869
- methods, 768
- multiple, 867
- Modula-3, 669, 707-708
- Extended, 733
- ExtendedFloat, 734-735
- FloatMode, 735-737
- generics, 710-712
- import statements, 707
- include files, 670
- LongFloat, 734-735
- Longreal, 733
- order of execution, 712
- Real, 733
- RealFloat, 734-735
- required, 728
- safety, 712
- stacks, 709
- Word, 731
- pluggable (Smalltalk), 78
- internationalization, Java 1.1, 884-886
- Internet, C++, 284
- interpreted languages, Java, 779
- Interprocess communication (IPC), OS adaption layer (ACE framework), 25
- An Introduction to Object-Oriented Programming, 5
- invariants
- C functions, 219
- Eiffel classes, 523
- invoking
- Java programs, 790
- methods (Java), 760, 767
- overridden methods in Java, 856-858
- Iostream, C++, 314
- IPC, ACE framework components, 26
- ISO, C++, 255
- ISO-Latin-1 (Modula-3), 679
- Istream class, C++, 389
- iteration messages (collection classes), 145
- iterative execution, Smalltalk control structures, 118
- iterators, C++, 280, 310, 397-399
J
- Java, 747, 749
- APIs, RMI, 780
- applets
- compiling, 789
- example, 786, 790
- Web page integration, 789-790
- arrays, 762, 791, 803, 806-808
- accessing elements from, 811
- arguments, declaring, 812-813
- copying, 805
- creating, 809
- destroying, 809
- multidimensional, 809-811
- variables, declaring, 812-813
- versus objects, 812
- bytecodes, 750, 782
- C++, 290, 869-870
- characteristics of, 778
- class files, 792
- class members
- access to, 796
- hiding, 862
- private, 859-862
- protected, 859-862
- public, 859-862
- classes, 749, 757, 778, 831-832
- abbreviating names with import statement, 796
- abstract classes, 863-865
- access to, 796
- directory paths, 794
- extending, 765, 847-848
- fields, 749, 757
- final classes, 848
- hierarchy, 849
- inheritance, 847
- instances, 749, 832
- interfaces, 769
- invoking methods from superclass, 767
- loading dynamically, 780
- main method, 750
- mapping, 798
- members, 792
- methods, 757
- Object, 849
- Point class, 757
- public, 795-796
- SecurityManager, 783
- subclasses, 765
- testing for frequency of use, 838
- type, 775
- utility, 775
- CLASSPATH environment variable, 794
- command-line arguments, 791, 794
- comments, 753, 797
- constants, 753
- defining, 797
- named, 753
- unicode characters, 754
- constructors, 834
- chaining, 850-851
- declaring, 835
- default constructors, 851-852
- defining, 835
- for subclasses, 849-850
- multiple, 835-837
- naming, 835
- data types, 830
- boolean, 802
- char, 802
- floating-point, 803
- integral, 802
- naming schemes, 830
- primitives, 801
- reference, 803, 806
- defined, 747
- digital signatures, 783
- directory paths, 792
- distribution, 780
- dynamic nature of, 780
- Eiffel, 546
- encapsulation, 858-859
- evolution, 747
- exception handling, 770-771, 782, 822-824
- exceptions, 782, 821
- catching, 821
- declaring, 824-825
- defining, 825-827
- generating, 825-827
- propagation, 821
- throwing, 821
- feature overview, 870-872
- Fibonacci sequence, 751
- fields, 792
- filenames, 792
- flow of control, 754
- blocks, 754
- if/else, 756
- forward references, 828
- garbage collection, 808, 844-845
- Gosling, James, 747
- Hello, World program, 750
- I/O, 775
- interfaces, 768, 865-866
- constants, 868
- extending, 769, 868
- implementing, 866-867
- marker interfaces, 869
- multiple, 867
- Internet compatibility, 780
- interpreted language environment, 779
- introduction of, 777
- just in time compilers, 784
- keywords
- final, 829
- native, 829
- new, 807
- super, 850
- synchronized, 784, 820, 829
- this, 836
- transient, 829
- void, 828
- volatile, 830
- loops, 754
- for, 755, 817
- while statement, 752
- macros, 798
- methods, 759, 790-792, 832
- abstract methods, 863-865
- accessing, 833
- class, 761
- class methods, 840-844
- Class.newInstance( ), 807
- clone( ), 805
- dynamic lookup, 856
- final methods, 855, 858
- finalizer methods, 852
- instance methods, 841-844
- interfaces, 768
- invoking, 760
- invoking from superclass, 767
- invoking overridden methods, 856-858
- main( ), 790
- mechanics of, 833-834
- overloading, 828, 836
- overriding, 854-855
- passing to one another, 830
- receiving object, 760
- returning multiple values, 760
- static, 761
- System.exit( ), 791
- System.getProperty( ), 791
- this reference, 761
- namespace issues, 792
- naming, 772
- null value, 806
- Oak, 747
- object-oriented programming, 778
- objects, 749, 757, 778, 803, 806, 830-832
- accessing, 807
- accessing data from, 833
- allocation, 757
- checking for equality, 805
- class fields, 758
- copying, 804
- creating, 807, 834
- destroying, 844-845
- fields, 758
- finalizing, 846-847
- garbage collection, 759
- heap, 757
- instantiation, 757
- memory allocation, 807
- null, 757
- passing by reference, 804
- references, 757
- relationship to classes, 832
- static fields, 758
- operators, 813-816
- % (remainder), 756
- ++, 755
- +=, 756
- --, 756
- packages, 772, 778, 793
- access to, 796
- naming schemes, 794-795
- parameters, 759
- performance of, 783
- platform independence, 774
- platform independence of, 779
- pointers, lack of, 781, 805
- portability, 774, 779
- primitives, 751
- programs
- compiling, 785
- compiling conditionally, 799
- components, 790
- critical sections, 819
- environment, 790
- Hello, World, 785
- invoking, 790
- returning values, 791
- running, 785
- structure, 790
- properties, looking up values for, 791
- robustness of, 781-782
- sandbox, 782
- security, 782-783
- simplicity of, 780
- Smalltalk comparison, 165
- speed of, 783
- statements, 816
- break, 818-819
- continue, 818-819
- do, 816
- else, 816
- for, 817
- if, 816
- import, 795-796, 820
- package, 795, 820
- switch, 817
- synchronized, 819
- try/catch/finally, 822
- while, 816
- string objects, 763
- strings, 803, 813
- system properties list, 791
- threads, 775, 784
- Unicode escape sequences, 799-800
- variables, 751
- class variables, 837-839
- constants, 839
- instance variables, 837
- local variables, 797, 827
- shadowed, 852-853
- static final, 798
- static variables, 837-838
- undefined, 752
- version 1.1, 777
- applet changes, 890-891
- AWT event model, 877-878
- cursor specification, 883
- cut-and-paste features, 880-881
- deprecated features, 878-879
- desktop color, 882
- Enterprise APIs, 890
- font treatments, 882
- image manipulation, 883
- inner classes, 877
- internationalization, 884-886
- JavaBeans, 888-889
- JDK utilities, 892
- keyboard focus traversal, 881-882
- lightweight components, 883
- menu shortcut features, 881
- new features, 872-873
- object serialization, 886-887
- package library, 873-876
- popup menu features, 881
- printing features, 879-880
- reflection, 887-888
- scrolling GUI components, 883
- C, compared, 790, 830-831
- C++, compared, 779, 790
- virtual machines, 750, 774
- visibility modifiers, 859-862
- Java Virtual Machine, 779
- Java.lang package, Thread classes, 784
- JavaBeans, Java 1.1, 888-889
- JAWS, ACE framework, middleware, 28
- JDK (Java Development Kit), 785, 892
- Jobs, Steve (Smalltalk), 69
- Johnson, Ralph (Smalltalk), 88
- Johnson, Steve (C with Classes), 224
- Joining Eiffel inheritance, 526
- Jordan, Mick (Modula-3), 665, 743
- journals, C++, 286
- jumps, C++, 342
- just in time compilers, Java, 784
- JVM (Java Virtual Machine), 779
K
- Kaslow, Bill (Modula-3), 665, 743
- Kay, Alan
- OOP, 14
- Smalltalk, 51, 166
- Dynabook, 51, 55
- KiddiKomp, 54
- PARC, 54
- kernels, UNIX, C++, 202
- keyboard focus traversal, Java 1.1, 881-882
- Keyhole (Smalltalk symbol), 57
- keyword messages, Smalltalk, 102
- keywords
- Java
- final, 829
- native, 829
- new, 807
- super, 850
- synchronized, 784, 820, 829
- this, 836
- transient, 829
- void, 828
- volatile, 830
- Modula-3 syntax, 738
- KiddiKomp (Smalltalk), 54
- Koenig, Andrew (C++ with C), 241
- Krasner, Glenn (Smalltalk), 83
- Krogdahl, Stein (C++), 250
L
- LaLonde, Wilf (Smalltalk), 88
- language definition, Modula-3, 667
- lawsuits, Apple and Microsoft, 82
- layout, Ada, 578
- layout information, classes, C with Classes, 210
- LearningWorks
- Smalltalk, 166
- Smalltalk freeware, 190
- Leibs, David (Smalltalk), 83
- Lenkov, Dmitry (C++), 255
- lexical analysis, C++ pitfalls, 409
- lexical closure (functions), 121
- lexical conventions, Eiffel, 543
- libraries
- Ada, 579
- Ada.Finalization, 641
- Calendar, 579
- C++, 312
- asymetric bounds, 310
- dynamic memory, 312
- early, 287
- foundation, 275
- I/O libraries, 388-389
- language, in relation to, 312
- standard, 274
- standard I/O, 307
- standard library, 387-388
- standard library facilities, 282
- stream I/O, 276
- string library, 391-392
- templates, 278-280, 282
- Eiffel, 464, 546
- Smalltalk, 130, 132, 183
- licenses, Smalltalk, 79
- linked lists (Ada), 63a2
- AddToEnd, 640
- dashboard, building, 633
- heterogenous, 633
- MakeEmpty, 639
- Linker tool, C with Classes, 210
- linkers, Cfront, 229
- linking
- C with Classes, 209
- Simula, C++, 200
- Lippman, Stanley, 402
- Lisp, Modula-3, 668
- list sequential container, C++, 394
- lists, see Linked lists (Ada)
- literals, Smalltalk objects, 96
- character, 97
- decimal integer, 96
- reserved identifiers, 97
- Little Smalltalk
- A, 4
- Budd, 86
- Smalltalk freeware, 190
- local exception handling (Ada), 597
- local variables
- C++, 310
- declaring in Java, 797, 827
- pointers (C++), 452
- locations, Modula-3, 676
- LOCK statement (Modula-3), 702
- logical operators, C++, order of precedence, 324
- LOGO (Smalltalk), 60
- LongFloat interface, Modula-3, 734-735
- Longreal interface, Modula-3, 733
- LOOM (large object-oriented memory), Smalltalk, 77
- loop instructions, Eiffel, 541
- LOOP statement (Modula-3), 697
- LOOPHOLE (Modula-3 designators), 715
- loops
- Ada, 586, 588-589
- C++, 341
- Java, 754
- for, 755, 817
- while statement, 752
- Lovelace, Countess Augusta Ada (Ada), 561
- low-level
- operations, C with Classes, 204
- semantics, C, 214
- Lvalues, C++, 326
- Lyons, Bill (Smalltalk), 89
M
- macros, Java, 798
- main procedures, Ada, 577
- Main() method, Java, 750, 790
- MakeEmpty (Ada linked lists), 639
- Mandate (Ada defense projects), 570
- manipulators, C++, 308, 390
- map associative container, C++, 396
- Map data structure (C++), 309
- mapping classes in Java, 798
- Marker interfaces, Java, 869
- matrices, Ada, 615-623
- McIlroy, Doug (C with Classes), 224
- member functions, C++, 352-355, 414
- assignment operators, 360
- const, 414-416
- constructors, 357
- copy constructors, 358
- destructors, 361
- effects on program organization, 354
- exclusivity, 355, 357
- implementation, 355
- private, 355
- protected, 355
- public, 355
- member templates (C++), 264-265
- members
- C, static, 222
- C with Classes, 207
- Java classes, 749, 792
- fields, 749, 757
- methods, 749, 757
- memory
- ACE framework components, 26
- Ada heap, 639
- allocating for Java objects, 807
- C++, 238
- automatic objects, 239
- delete operator, 238
- free store, 238
- libraries, 312
- new operator, 238
- static objects, 239
- Eiffel, 464, 489
- objects, 12
- pointers (C++), dynamically allocated, 452
- Smalltalk
- allocation, 169
- LOOM (large object-oriented memory), 77
- Mesa Smalltalk (Star Workstation), 80
- messages, 5-6
- OOP
- interpretation, 14
- passing, 14
- Smalltalk, 54, 178
- atAllPut (collection classes), 157
- binary, 100
- collection classes, 148
- control structures, 73
- copy (collection classes), 155
- identical, 103
- index of (collection classes), 155
- iteration (collection classes), 156
- keyword, 102
- objects, 99
- polymorphism, 103
- protocols, 132
- replace (collection classes), 157
- reverse (collection classes), 155
- selectors, 122-125
- unary, 99
- with (collection class), 145
- Metaclasses, Smalltalk, 74
- Method (Eiffel), 462
- methods, 6, 8
- binding, 8
- Java, 759, 790, 792, 832
- abstract, 863-865
- accessing, 833
- class, 749, 757, 761, 840-844
- Class.newInstance( ), 807
- clone( ), 805
- dynamic lookup, 856
- final methods, 855, 858
- finalizer, 852
- instance, 841-844
- interfaces, 768
- invoking, 760
- invoking from superclass, 767
- invoking overridden, 856, 858
- main( ), 750, 790
- mechanics of, 833-834
- overloading, 828, 836
- overriding, 854-855
- passing to one another, 830
- receiving object, 760
- returning multiple values, 760
- static, 761
- System.exit( ), 791
- System.getProperty( ), 791
- this reference, 761
- Modula-3
- declaration, 687
- objects, 686
- overriding, 687-689
- overriding, 8
- Smalltalk, 86, 168
- doesNotUnderstand
- aMessage, 169
- accessor, 107, 180
- blocks, 181
- class methods, 112
- classes, 106
- code, 181
- new, 112
- return, 106
- Microsoft
- lawsuits against Apple, 82
- Visual Basic, 85
- Microsoft OLE, Eiffel, 546
- Middleware ACE framework, JAWS and ORB, 28
- Mighty Mouse (Smalltalk), 58
- Miranda, Eliot (Smalltalk), 88
- ML, Modula-3, 668
- models
- Smalltalk, 175
- Web servers
- asynchronous Thread Pool, 43
- handle-based synchronous Thread Pool, 40
- queue-based synchronous Thread Pool, 42
- Single-Threaded Reactive, 36
- Thread Pool, 40
- Thread-per-Request, 39
- Thread-per-Session, 44
- modifiers
- C++, const, 332
- Java, 829
- Modula-2+, 743
- Modula-3, 665
- abstract types, 670
- Algol languages (comparison), 669
- arrays
- assignable, 680
- fixed, 679
- indexing, 680
- open, 679
- shape, 679
- subtyping, 690
- branded types, subtyping, 690
- Cardelli, Luca, 665
- Cedar, 669
- Clu (comparison), 668
- committee, 667
- dangling pointers, 674
- declarations, 676, 702
- constants, 703
- exceptions, 704
- opaque types, 704
- procedures, 704
- recursive, 706
- revelations, 705
- scope, 676
- types, 703
- variables, 703
- designers, 665, 743
- Digital Equipment Corporation, 667
- Donahue, Jim, 665
- errors, 677
- exception handling, 674, 704
- expressions, 676, 713
- arithmetic operations, 720-722
- array constructors, 718
- Boolean operations, 723
- character literals, 717
- constant expressions, 677, 726
- designators, 676, 715
- integer codes, 724
- NEW, 719
- NIL, 718
- numeric literals, 716
- operation syntax, 714
- operations, 713
- procedural operators, 715
- procedure call, 718
- record constructors, 718
- relations, 722
- set constructors, 718
- text concatenation, 726
- text literals, 717
- type operations, 724-726
- garbage collection, 669, 674
- generics, 671, 710-712
- Hoare, C. A. R., 676
- identifiers, 676
- interfaces, 669, 707-708
- Extended, 733
- ExtendedFloat, 734-735
- FloatMode, 735-737
- import statements, 707
- include files, 670
- LongFloat, 734-735
- Longreal, 733
- order of execution, 712
- Real, 733
- RealFloat, 734-735
- required, 728
- stacks, 709
- Thread, 730
- Word, 731
- Jordan, Mick, 665, 743
- Kaslow, Bill, 665
- language definition, 667
- Lisp (comparison), 668
- locations, 676
- ML (comparison), 668
- Modula-2+, 743
- modules, 707-708
- generics, 671, 710-712
- import statements, 707
- interfaces, 669
- order of execution, 712
- stacks, 709
- Nelson, Greg, 665, 743
- Oberon, 669
- objects, 670, 686
- data fields, 686
- method declaration, 687
- methods, 686-687
- object-oriented techniques, 671
- overriding methods, 687-689
- partially opaque types, 671
- subtyping, 690
- Olivetti, 667
- overview, 667
- procedures, 684
- calls (statements), 693-695
- constant, 684
- declarations, 704
- function, 684
- parameter declaration, 684
- proper, 684
- signatures, 684-685
- subtyping, 690
- top-level, 684
- type declaration, 684
- records, 681
- references, 682
- ADDRESS, 683
- brands, 683
- NULL, 683
- REFANY, 683
- subtyping, 690
- traced, 683
- untraced, 683
- Rovner, Paul, 743
- safety, 673, 712
- scope of declarations, 676
- simplicity, 676
- Smalltalk (comparison), 668
- statements, 692
- assignable, 692-693
- block, 695
- CASE, 700
- DEC, 702
- EVAL, 695
- EXIT, 697
- FOR, 699
- IF, 698
- import, 707
- LOCK, 702
- LOOP, 697
- RAISE, 696
- REPEAT, 699
- RETURN, 698
- return-reception, 692
- sequential, 695
- TRY-EXCEPT, 696
- TRY-FINALLY, 697
- TYPECASE, 701
- WHILE, 699
- WITH, 699
- subtyping, 689
- arrays, 690
- branded types, 690
- objects, 690
- procedures, 690
- references, 690
- syntax, 737
- comments, 739
- compilation unit productions, 740
- conventions, 739-740
- expression productions, 741-742
- keywords, 738
- miscellaneous productions, 742
- operators, 738
- pragmas, 739
- reserved identifiers, 738
- statement productions, 740-741
- token productions, 742-743
- type productions, 741
- threads, 672
- type system, 675-677
- allocated type, 678
- declarations, 703
- floating-point types, 679
- ordinal, 678
- packed types, 682
- referent types, 683
- sets, 682
- subtyping, 687-689
- unsafe operations, 669, 673, 726
- address arithmetic, 727
- DEC, 727
- INC, 727
- variables, 676, 703
- Wilkes, Maurice, 667
- Wirth, Niklaus, 667
- modularity, Eiffel, 464
- modules
- Modula-3, 707-708
- generics, 671, 710-712
- import statements, 707
- interfaces, 669
- include files, 670
- order of execution, 712
- safety, 712
- stacks, 709
- OOP, 13
- Moo, Barbara (C++), 278
- More, Trenchard, 325
- Moss, Eliot (Smalltalk), 87
- multidimensional arrays
- C++, 427, 429
- Java, 809-811
- multimap associative container, 396
- multiple constructors, Java, 835-837
- multiple inheritance
- C, 221
- C++, 247, 249-251
- Eiffel, 464, 521
- multiprocessing, Smalltalk, 170
- multiset associative container, 396
- multithreading, Java, 784
- MUTEXT (predeclared opaque type, Modula-3), 691
- mutual exclusion (Ada concurrency), 649
- MVC (Model, View, Controller), Smalltalk, 78, 175
N
- named constants, Java, 753
- names, Smalltalk classes, 104
- namespaces
- C++, 271-272, 348-350
- Java, 792
- native keyword, Java, 829
- Nelson, Greg (Modula-3), 665, 743
- nested classes, C++, 257
- New (collection class), 146
- New expression, C++, 427
- New keyword, Java, 807
- New method
- C with Classes, functions, 207
- Smalltalk, 112
- NEW, Modula-3 expression, 719
- New operator
- C with Classes, 208
- C++, 238
- NIL, Modula-3 expressions, 718
- non-defense projects, Ada, 571
- non-pointer types, C with Classes, 207
- NoteTaker (Smalltalk), 68
- NULL (Modula-3), 683
- null objects, Java, 757
- Null statement, C++, 339
- null value, Java, 806
- Number protocol (Smalltalk), 140
- numbers, Ada
- decimal, 595
- rational-number arithmetic, 602-604
- numeric conversions, C++, 323
- numeric library functions, C++, 392-394
- numeric literals, Modula-3 expressions, 716
- numeric protocols, Smalltalk, 140
O
- Oak, Java, 747
- OBB adapters, ACE framework components, 27
- Oberon, Modula-3, 669
- Object class, Java, 849
- object technology centers (OTCs), Smalltalk, 186
- object-oriented programming, see OOP (Object-oriented programming)
- objects, 5, 7, 12
- Ada, 576, 611
- behavior, 12
- C with Classes, 207
- C++, pointers, 361
- Eiffel, 476
- creating, 479
- deep operations, 488
- fields, 477
- initializing, 480
- references, 477
- shared, 537
- Java, 749, 757, 778, 803, 806, 830-832
- accessing, 807
- accessing data from, 833
- allocation, 757
- checking for equality, 805
- class fields, 758
- copying, 804
- creating, 807, 834
- destroying, 844-845
- fields, 758
- finalizing, 846-847
- garbage collection, 759
- hap, 757
- instantiation, 757
- memory allocation, 807
- null, 757
- passing by reference, 804
- references, 757
- relationship to classes, 832
- static fields, 758
- strings, 763
- memory, 12
- Modula-3, 670, 686
- data fields, 686
- method declaration, 687
- methods, 686-687
- object-oriented techniques, 671
- overriding methods, 687-689
- partially opaque types, 671
- subtyping, 690
- object-oriented programming, 778
- Smalltalk, 53, 62, 96, 169, 178
- behavior, 99
- boolean, 137
- character, 139
- classDescription, 135
- collection classes, 144
- control structures, 73
- copy message, 134
- dependencies, 174
- description of class, 136
- equality, 134
- identity, 133
- literals, 96
- messages, 99
- MVC (Model, View, Controller), 175
- numeric, 140
- printString, 135
- properties, 75
- protocols, 133
- referencing, 96-97
- value models, 85
- variables, 97
- ObjectShare (Smalltalk), 90
- OCXs, Smalltalk, 171
- Olivetti
- Modula-3, 667
- Smalltalk, 86
- Once routines, Eiffel, 537
- OOP (Object-oriented programming), 3, 11, 18, 371
- arguments, 5
- books, 15
- C++, 371, 380-386
- abstraction, 307
- dynamic binding, 374
- dynamic casts, 378
- inheritance, 372, 379
- assignment, 374
- constructors, 373-374
- destructors, 374
- pure virtual functions, 378
- virtual destructors, 377
- virtual functions, 374-376
- classes, 7, 12, 778
- abstract parent, 8
- child, 8
- inheritance structure, 8
- parent, 8
- communication, 12
- design, 11
- Eiffel, 462
- frameworks, 18, 23
- fundamental concept, 5
- information hiding, 6, 13
- inheritance, 7, 12, 14
- instances, 7
- Java, 778
- Kay, Alan, 14
- messages, 5-6
- interpretation, 14
- passing, 14
- methods, 6
- binding, 8
- overriding, 8
- methods, 8
- modules, AST (abstract structure type), 13
- objects, 5, 778
- behavior, 12
- memory, 12
- patterns, 19
- polymorphism, 10, 14
- receiver, 6-7
- reference books, 15
- variables values, 10
- What is Object-Oriented Programming? (Stroustrup), 245
- OOPSLA (Smalltalk ), 83
- OOZE (Smalltalk), 66
- opaque types, Modula-3
- declarations, 704
- MUTEXT, 691
- TEXT, 691
- open arrays, Modula-3, 679
- open colon symbol (Smalltalk), 57
- operating systems
- ACE framework, 25
- Ada concurrency, 656
- Smalltalk
- multiprocessing, 170
- threads, 170
- operations
- Ada
- Adjust, 642
- Finalize, 642
- Initialize, 642
- Modula-3 arithmetic, 720-722
- Modula-3 expressions, 713
- overloading, 713
- procedural, 715
- syntax, 714
- operators
- C with Classes, new, 208
- C++, 309
- ++, 309-311
- constants, 238
- delete, 238
- functions, 347
- integer arithmetic, 318
- new, 238
- overloading, 235
- postfix ++, 319
- precedence, 323-325
- references, 237
- relational, 318
- Java, 813, 815-816
- % (remainder), 756
- ++, 755
- +=, 756
- --, 756
- ==, 805
- Modula-3 syntax, 738
- ORB, ACE framework, middleware, 28
- order of execution, Modula-3, 712
- order relations, C++, 439
- OrderedCollection (collection classes), 160-161
- ordinal types, Modula-3, 678
- INTEGER, 678
- ISO-Latin-1, 679
- Orwell (Smalltalk), 88
- OS adaption layer, ACE framework, 25
- Ostream class, C++, 389
- OTCs (object technology centers), Smalltalk, 186
- output, C++, setw, 311
- output iterators, C++, 397
- overloaded functions, C++, 347
- overloading
- Ada, 586
- C++, 235-238
- Java methods, 828, 836
- Modula-3 expressions, 713
- overriding
- methods, 8, 854-855
- Modula-3, 687-689
- types in Ada, 628
- overview, Modula-3, 667
P
- Package statement, Java, 795, 820
- packages
- Ada, 576
- Ada.Command Line, 592
- encapsulation, 599, 617
- generic, 614-616
- generic matrices, 618-621
- HB.Instruments, 627, 636
- HB.Instruments.Aux, 631
- HB.Instruments.Basic, 628, 636
- HB.Instruments.Clocks, 629, 637
- HB.Lists Generic, 642
- HB.Lists.Generic, 633, 639
- HB.Random Task, 648, 653
- HB.Rationals, 601
- HB.Rationals.IO, 604, 607, 610
- HB.Screen, 649, 653
- HB.Vectors, 621
- rational-number arithmetic, 604
- Rationals, 607
- root, 601
- Java, 772, 778, 793, 873-876
- access to, 796
- naming schemes, 794-795
- packed types, Modula-3, 682
- Parallel Programming Using C++, 296
- parameter declaration, Modula-3 procedures, 684
- parameterized types, C++, 246
- parameters
- Ada, generic packages, 616
- C++ functions, 336
- Eiffel
- classes, 464
- genericity, 495
- Java, 759
- PARC, Smalltalk, 54
- ParcPlace Holders, Smalltalk, 82-83
- ParcPlace Systems (Smalltalk), 83
- portability, 83
- VisualWorks, 84
- parent classes, 8
- partial specialization (C++ templates), 264
- Parts Workbench (Digitalk), 85
- Pass statement, C++, 338
- passing
- arguments to C++ functions, 336
- Java objects by reference, 804
- messages, 14
- paths, Smalltalk, execution, 169
- patterns, 19
- communication software, 19-21
- Smalltalk, 186
- web servers, 28
- Acceptor, 31
- Active Object, 34
- Adaptor, 36
- concurrency, 36
- dispatcher, 28
- event dispatcher, 29
- Half-sync/Half-async, 34
- handlers, 29
- HTTP Acceptor, 30
- HTTP Handler, 30
- Proactor, 32
- Reactor, 32
- requester, 28
- Singleton, 36
- SOCK Acceptor, 30
- SOCK Stream, 30
- State, 36
- strategic, 31
- Strategy, 35
- tactical, 35
- Patterson, Dave (Smalltalk), 88
- Pencin, Russ (Smalltalk), 83
- Perform message (Smalltalk), 125
- performance, Ada validation, 569
- persistence, Eiffel, 489
- pitfalls of C++, 405, 457
- aliases, 454-456
- arrays, 431
- bounds, 446, 449
- deleting, 430
- multidimensional, 427
- of arrays, 429
- two variable dimensions, 430
- C, 407
- classes
- base class conversions, 432-434
- containers, 435-436, 439
- const, 408, 412, 414, 416
- declarations, 412
- member functions, 414
- pointer arguments, 422-423
- pointers to constants, 413
- constructor initializers, 417
- declarations, 411
- execution, 445
- expressions, new, 427
- functions
- modifiable memory, 422
- references, 423, 426
- virtual, 432
- inheritance, 432
- lexical analysis, 409
- order relations, 439
- pointers
- dangling, 452
- dynamically allocated memory, 452
- functions, 454
- local variables, 452
- references, 454-456
- semantics, 419, 445
- specifiers, 411
- strchr function, 419, 422
- symbol spacing, 410
- syntactic, 409, 418
- tokens, 409
- platform independence
- Java, 774
- Smalltalk, 168
- pluggable interfaces, Smalltalk, 78
- Point class (Java), 757
- pointer-to-member operators, C++, 324
- pointers
- Ada, 633-635
- C with Classes, types, 207
- C++, 325-326
- arithmetic with, 331
- const, 413-416, 422-423
- constants, 332-333
- dangling, 452
- dynamic memory allocation, 332, 452
- functions, 454
- iterators, 310
- local variables, 452
- object members, 361
- smart, 257
- using with arrays, 329-331
- iterators, 280
- Java, lack of, 781, 805
- polymorphism, 10
- Ada, 623-625
- Eiffel, 463, 511-513
- OOP, 14
- Smalltalk, 103, 179
- Pool variables classes (Smalltalk), 75
- Pope, Steven (Smalltalk), 83
- portability
- C, 214
- Java, 774
- Smalltalk, 68
- intermediate representation, 73
- ParcPlace Systems, 83
- Posfix operator ++, C++, 319
- positioning (collection class elements), 155
- postfix increments, C++, 257
- pragmas, Modula-3 syntax, 739
- precedence, C++
- operators, 323-325
- statements, 339
- predeclared opaque types, Modula-3, TEXT and MUTEXT, 691
- prefix increments, C++, 257
- prefixes, Eiffel, 483
- primitive data types, Java, 801
- primitive operations (Ada types), 628
- primitives, Java, 751
- PrintString, Smalltalk objects, 135
- private classes
- C++, 379
- member functions. 355
- Java members, 859-862
- Proactor pattern, Web servers, 32
- problems, communication software, 19
- procedural operators, Modula-3, 715
- procedures
- Ada, 578
- Display, 631
- main, 577
- Modula-3, 684
- calls, 693-695
- constant, 684
- declarations, 704
- expressions, 718
- function, 684
- parameter declaration, 684
- proper, 684
- signatures, 684-685
- subtyping, 690
- top-level, 684
- type declaration, 684
- process (Eiffel), 466
- clusters, 466, 475
- compilers, 469
- external software, 475
- generalization, 468
- global inheritance, 474
- quality development, 469
- reuse, 468
- reversibility, 468
- seamlessness, 468
- working demos, 468
- program structure, C++, 313
- programs, Java
- compiling, 785
- compiling conditionally, 799
- components, 790
- critical sections, 819
- environment, 790
- Hello, World, 785
- invoking, 790
- linking C with Classes, 209-210
- returning values, 791
- running, 785
- structure, 790
- projects, Smalltalk
- banking, 191
- government, 192
- insurance, 191
- manufacturing, 192
- telecommunications, 192
- trading, 191
- Web servers, 191
- propagating exceptions, Ada, 609
- proper procedures, Modula-3, 684
- properties
- Java, looking up values for, 791
- Smalltalk objects, 75
- protected class members, Java, 859-862
- protected classes
- C, 218-219
- C++, 379
- protected member functions, C++, 355
- protocols
- Smalltalk, 131
- class libraries, 132
- collection classes, 144
- conforming, 132
- floating-point, 143
- fraction, 143
- integer, 142
- message signatures, 132
- number, 140
- numeric, 140
- objects, 133
- Prototypes. C with Classes, 213
- PS Smalltalk, 70
- public classes
- C++, 379
- Java, 795-796, 859-862
- public member functions, C++, 355
- publishing Smalltalk, 71, 79
- Pugh, John (Smalltalk), 88
- pure virtual functions, OOP in C++, 378
- Putz, Steve (Smalltalk), 78
Q-R
- quality development, Eiffel, 469
- queries, Eiffel features, 478
- queue-based synchronous Thread Pool model, Web servers, concurrency, 42
- RAISE statement (Modula-3), 696
- Randell, Brian (C++), 268
- random number generator (Ada concurrency), 648, 653
- ranges, Ada subtypes, 589
- rapid change (Smalltalk), 67
- rational-number arithmetic packages (Ada), 604
- rationals (Ada packages), implementing, 607
- Reactor pattern, Web servers, 32
- read-only (collection classes), 238
- read/write (collection classes), 145
- Real interface, Modula-3, 733
- RealFloat interface, Modula-3, 734-735
- Receiver, 6
- receiving object, Java methods, 760-761
- records
- Ada fields, 591
- Modula-3, 681
- constructors, 718
- fields, 681
- recursion, C++ functions, 337
- recursive declarations, Modula-3, 706
- redefinition, Eiffel, 463, 509
- Reenskaug, Trygve (Smalltalk), 78
- REFANY (Modula-3), 683
- reference books
- C++, 298, 458
- Eiffel, 548
- OOP, 15
- Smalltalk, 80, 90, 194
- reference data types, Java, 803, 806
- references
- C++, 237, 325-328, 454-456
- functions, 423, 426
- Stroustrup, Bjarne, 298
- Eiffel objects, 477
- Java
- forward references, 828
- objects, 757
- Modula-3, 682
- ADDRESS, 683
- brands, 683
- NULL, 683
- REFANY, 683
- subtyping, 690
- traced, 682
- untraced, 683
- referencing Smalltalk
- literals, 96
- objects, 96-97
- referent types (Modula-3), 683
- reflection, Java 1.1 classes, 887-888
- reflective capabilities, Smalltalk, 177
- relational operators, C++, 318, 324
- relations
- Eiffel classes, 473
- Modula-3 expressions, 722
- remainder operator, Java, 756
- renaming features, Eiffel, 464, 521
- REPEAT statement (Modula-3), 699
- repeated inheritance, Eiffel, 464, 529
- Replace message (collection classes), 145
- requesters, web, 28
- required interfaces (Modula-3), 728
- reserved identifiers
- Modula-3 syntax, 738
- Smalltalk objects, 97
- reserved words, Ada, 578
- resources, C++, exception handling, 269
- resumability, exception handlers (Smalltalk), 128
- Retrospective, C++, 291-293
- additions, 295
- changes, 293-295
- future, 297
- mistakes, 297
- return expression statement, C++, 338
- Return function, C, 221
- Return methods, Smalltalk, 106
- RETURN statement (Modula-3), 698
- return-reception (Modula-3 statements), 692
- reusable components, ACE framework, 27
- revelations, Modula-3, declarations, 705
- reverse message (collection classes), 155
- reversibility, Eiffel, 468
- reversing C++ structures, 370-371
- Ritchie, Dennis (C with Classes), 224
- RMI API, Java, 780
- root packages (Ada), 601
- Rose, Leonie (Cfront), 227
- Rosetta Smalltalk, 86
- Rosler, Larry (C++), 255
- routines, Eiffel, 464
- features, 478
- once, 537
- Rovner, Paul (Modula-3), 743
- Rowe, Keith (C++), 271
- runtime, C with Classes, 204, 208
- runtime errors, Modula-3, 677
- runtime type identification, C++, 273
S
- safety, Modula-3, 673, 726-727
- address arithmetic, 727
- modules and interfaces, 712
- Sandbox security model, Java, 782
- SCG (Systems Concepts Group), Smalltalk, 71
- Schwarz, Jerry (C++), 277
- SCOOP (Eiffel), 544
- scope, Modula-3 declarations, 676
- screen manager (Ada concurrency), 648, 651
- seamlessness, Eiffel, 468
- security, Java, 782-783
- selection (Modula-3 designators), 715
- selectors, messages (Smalltalk), 122
- blocks, 124
- perform, 125
- SELF (Smalltalk), 88
- self identifier, Smalltalk classes, 110
- self variable, Smalltalk, 63
- self-contained components, ACE framework, 27
- semantics, C++, 419, 445
- sequential containers, C++, 394-395
- sequential statements, Modula-3, 695
- serialization, Java 1.1 objects, 886-887
- servers, Web
- ACE framework, 28
- communication software, 31
- concurrency models, 36
- JAWS, 28
- patterns, 31, 35
- Smalltalk, 191
- service configuration/initialization, , ACE framework components, 27
- Set (collection class), 145
- set associative container, C++, 396
- set constructors, Modula-3 expressions, 718
- sets, Modula-3, 682
- Setw, C++, 311
- Setw manipulator, C++, 390
- shadowed variables, Java, 852-853
- shared objects, Eiffel, 537
- shift operators, C++, order of precedence, 324
- Shopiro, Jonathan (Cfront), 227
- short form, Eiffel classes, 502-504
- Show Date, Ada.Calendar, 580
- Show Date and Time, Ada.Calendar, 582
- Show Tasks program (Ada concurrency), 650
- signatures
- Modula-3 procedures, 684-685
- Smalltalk message protocols, 132
- signed integers (C++), 317
- SIGPLAN paper (C with Classes), 203
- simplicity, Modula-3, 676
- Simula
- C, 215
- C++, 199-200
- classes, 199
- compiling, 200
- debugging, 200
- linking, 200
- tools, 201
- runtime efficiency, 208
- Simulation kit (Smalltalk), 66
- Single-Threaded Reactive model, Web servers, concurrency, 36
- Singleton pattern, Web servers, 36
- size, stacks, C, 219
- Smalltalk, 165
- 68000 code, 71
- acquisitions, 88
- advantages, 185
- Althoff, Jim, 78
- Analyst, 82
- Anderson, Jim, 89
- ANSI standards, 182
- blocks, 181
- arguments, 118
- full closure, 76
- books, 80
- BRAVO, 65
- browsers, 64
- Budd, Tim, 86
- Byte Magazine, 167
- Carter, Ron, 83
- characters, 56
- closed colon, 57
- eval bind, 57
- eyeball, 57
- keyhole, 57
- open colon, 57
- right arrow, 57
- uneval bind, 57
- CIA, 81
- class libraries, 130, 170
- protocols, 132
- Smalltalk-80, 73
- classes, 57, 62, 104, 178
- behavior, 75
- box, 63
- class instance variables, 113
- class variables, 75
- code, 180
- definitions, 111
- hierarchy, 74
- inheritance, 108-109
- instance variables, 75
- instances, 104
- metaclasses, 74
- methods, 106
- names, 104
- pool variables, 75
- self identifier, 110
- subclasses, 108
- super identifier, 111
- superclasses, 108
- variables, 105
- collection classes
- adding elements, 150
- Array, 145
- atAllPut message, 157
- Bag, 145, 151
- ByteArray, 145
- concatenation, 155
- copy messages, 155
- Dictionary, 151
- index of messages, 155
- initializing, 146
- Interval, 145
- iteration messages, 156
- messages, 148
- new, 146
- OrderCollection, 145
- OrderedCollection, 160-161
- positioning, 145
- read-only, 145
- read/write, 145
- removing elements, 151
- replace message, 157
- reverse message, 155
- Set, 145, 151
- SortedCollection, 145
- String, 145
- strings, 145
- comments, 97
- commercial outcome, 90
- community, 71
- compiler, 72
- composition architecture, 78
- contributors, 52
- control structures, 73, 115
- block constructors, 117
- combining, 120
- conditional execution, 145
- iterative execution, 118
- culture, 185
- curriculum for designing applications, 65
- debuggers, 64
- defined, 178
- dependencies, 174
- Deutsch, Peter, 83
- development, 65
- development cycle, 187
- development environment, 83
- disadvantages, 185
- distribution, 71
- DLLs, 171
- Dolphins, 70
- Dorados, 70
- Dynabook, 55
- dynamic binding, 85, 169
- education, 59-61
- encapsulated data, 99
- event frameworks, 174-176
- exception handlers, 126-127, 171, 174
- exiting handler blocks, 129
- resumability, 128
- execution path, 169
- FLEX machine, 53
- frameworks, 186
- freeware, 166, 190
- GNU Smalltalk, 190
- LearningWorks, 190
- Little Smalltalk, 190
- SmalltalkExpress, 190
- Squeak, 190
- galley editor, 67
- garbage collection, 169
- GUIs, controls and widgets, 176
- hardware, 70
- hash tables, 134
- history, 52, 166
- IBM, 89
- IDE
- browsers, 182
- debugger, 182
- development teams, 185
- development tools, 183
- encapsulation, 184
- image file, 184
- visual environments, 183
- incremental compilation, 168
- Ingalls, Dan, 62
- inspectors, 64
- instances, 53
- Java comparison, 165
- Jobs, Steve, 69
- Kay, Alan, 51, 166
- Dynabook, 51
- KiddiKomp, 54
- Krasner, Glenn, 83
- LearningWorks, 166
- Leibs, David, 83
- libraries, 183
- licenses, 79
- Little Smalltalk, 86
- LOGO, 60
- Lyons, Bill, 89
- memory
- allocation, 169
- LOOM (large object-oriented memory), 77
- messages, 54, 178
- binary, 100
- control structures, 73
- identical, 103
- keyword, 102
- polymorphism, 103
- selectors, 122-125
- unary, 99
- Methods, 86, 106, 168
- methods
- accessor, 107, 180
- aMessage, 169
- class methods, 112
- code, 181
- new, 112
- return, 106
- Mighty Mouse, 58
- MVC (Model, View, Controller), 175
- Modula-3, 668
- multiprocessing, 170
- NoteTaker, 68
- objects, 53, 62, 96, 169, 178
- behavior, 99
- control structures, 73
- dependencies, 174
- equality, 134
- identity, 133
- literals, 96
- messages, 99
- properties, 75
- referencing, 96-97
- value models, 85
- variables, 97
- ObjectShare, 90
- OCXs, 171
- Olivetti, 86
- OOPSLA, 83
- OOZE, 66
- PARC, 54
- ParcPlace Holders, 82-83
- ParcPlace Systems, 83
- portability, 83
- VisualWorks, 84
- patterns, 186
- Pencin, Russ, 83
- platform independence, 168
- pluggable interfaces, 78
- polymorphism, 179
- Pope, Steven, 83
- portability, 68, 73
- projects
- banking, 191
- government, 192
- insurance, 191
- manufacturing, 192
- telecommunications, 192
- trading, 191
- Web servers, 191
- protocols, 131
- collection classes, 144
- conforming, 132
- floating-point, 143
- fraction, 143
- integer, 142
- message signatures, 132
- number, 140
- numeric, 140
- objects, 133-139
- PS Smalltalk, 70
- publishing, 71
- Putz, Steve, 78
- rapid change, 67
- Reenskaug, Trygve, 78
- reference books, 90
- references, 194
- reflective capabilities, 177
- Rosetta Smalltalk, 86
- simulation kit, 66
- SmalltalkExpress, 166
- source code, 177
- Squeak, 166
- Star Workstation, 80
- symbols, 56-57
- syntax, 61, 178
- system services, 178
- Taylor, Bob, 65
- Tesler, Larry, 64
- third party products, 171, 185
- threads, 170
- Turtle Geometry, 60
- Twinkle, 81
- types, 179
- universities, 87
- Borning, Alan, 87
- BrouHaHa, 88
- Canada, 88
- ENVY, 89
- Griswold, David, 88
- Johnson, Ralph, 88
- LaLond, Wilf, 88
- Miranda, Eliot, 88
- Moss, Eliot, 87
- Orwell, 88
- Patterson, Dave, 88
- Pugh, John, 88
- SELF, 88
- StrongTalk, 88
- Suzuki, Nori, 88
- ThingLab, 87
- Thomas, Dave, 88
- Typed Smalltalk, 88
- Ungar, David, 88
- value models, VisualWorks, 85
- variables
- instances, 105
- self, 63
- super, 63
- vendors, 85, 187
- European, 87
- Softsmarts, 87
- Tektronix, 87
- versions, 53
- Smalltalk 2.1, 83
- Smalltalk V, 86
- Smalltalk-71, 53
- Smalltalk-72, 53
- Smalltalk-74, 59
- Smalltalk-76, 59
- Smalltalk-80, 3, 71-73
- SmalltalkExpress,166, 190
- virtual image, 72
- virtual machine, 72, 168
- Web servers, 191
- Web sites, 193
- XSIS, 81
- Zydbel, Frank, 80
- Smalltalk 2.1, 83
- Smalltalk V, 86
- Smalltalk-71, 53
- Smalltalk-72, 53
- Smalltalk-74, 59
- Smalltalk-76, 59
- Smalltalk-80, 3, 71
- class library, 73
- The Language and Its Implementation, 3
- SmalltalkExpress, 166, 190
- smart pointers, C++, 257
- SOCK Acceptor, Web, 30
- SOCK Stream, Web, 30
- Softsmarts (Smalltalk), 87
- software, communication, 17
- ACE framework, 18
- algorithmic design, 18
- classes, 22
- complexities, 17-18
- frameworks, 19, 22
- OOP, 18
- patterns, 19-21
- problems, 19
- solutions, 21
- Web servers, 31
- solutions, communication software, 21
- SortedCollection (collection classes), 160
- source code, Smalltalk, 177
- source files, C++, 313
- defining, 316
- maintaining consistency, 315
- specifiers, C++, pitfalls, 411
- Squeak, 166, 190
- stacks
- C, size, 219
- C++, 220
- Modula-3, 709
- standard I/O library, C++, 307
- standard library, C++, 274, 387-388
- facilities, 282
- foundation libraries, 275
- stream I/O, 276
- templates, 278-282
- standardization, C++, 253
- accepted features, 274
- ANSI, 255
- ISO, 255
- Star Workstation, Smalltalk, 80
- State pattern, Web servers, 36
- statement productions, Modula-3 syntax, 740-741
- statements
- C++, 339
- blocks, 340
- break, 342
- conditional, 341
- continue, 342
- expression, 340
- goto, 342
- if, 341
- null, 339
- pass, 338
- precedence, 339
- return expression, 338
- switch, 344-346
- throw, 338, 346
- while, 341
- Java, 816
- break, 818-819
- continue, 818-819
- do, 816
- else, 816
- for, 817
- if, 816
- import, 795-796, 820
- package, 795, 820
- switch, 817
- synchronized, 819
- try/catch/finally, 822
- while, 816
- Modula-3, 692
- assignable, 692-693
- block, 695
- CASE, 700
- DEC, 702
- EVAL, 695
- EXIT, 697
- FOR, 699
- IF, 698
- INC, 702
- LOCK, 702
- LOOP, 697
- procedure calls, 693-695
- RAISE, 696
- REPEAT, 699
- RETURN, 698
- return-reception, 692
- sequential, 695
- TRY-EXCEPT, 696
- TRY-FINALLY, 697
- TYPECASE, 701
- WHILE, 699
- WITH, 699
- static errors, Modula-3, 677
- static fields (Java objects), 758
- static variables, Java, 798, 837-838
- static members, C, 222
- static methods, Java, 761
- static objects, C++, memory, 239
- static type checking
- C with Classes, 212
- C++, 245
- Eiffel, 464
- STEELMAN Report (Ada concurrency), 647
- Stepanov, Alexander (C++), 278
- storage pool, Ada, dynamic data structures, 639
- strategic patterns, Web
- Acceptor, 31
- Active Object, 34
- Adaptor, 36
- Half-sync/Half-async, 34
- Proactor, 32
- Reactor, 32
- Singleton, 36
- State, 36
- Strategy, 35
- Strategy pattern, Web servers, 35
- Strchr function, C++, 419, 422
- Stream I/O library, C++, 276
- streams, ACE framework components, 27
- String (collection class), 145
- string library, C++, 391-392
- string literals, C++, 334-335
- string objects, Java, 763
- strings
- Ada, picture, 598
- Java, 803, 813
- Smalltalk, collection classes, 145
- Strlen function, C++, 335
- StrongTalk (Smalltalk), 88
- Stroustrup, Bjarne, 197, 402
- acknowledgments, 298
- beginnings of C++, 197
- references, 298
- Annotated C++ Reference Manual, 254
- The C++ Programming Language, 243, 258
- The Design and Evolution of C++, 258
- What is Object-Oriented Programming?, 244
- structural property classes, Eiffel, 520
- structures
- C syntax, 217
- C++
- defining, 351
- reversing, 370-371
- SUBARRAY (Modula-3 designators), 715
- subclasses
- Java, 765, 847
- object-oriented programming, 778
- Smalltalk, 108
- inheritance, 109
- self identifier, 110
- super identifier, 111
- subcontracting Eiffel, 463, 522
- subscripting Modula-3 designators, 715
- subtasks (Ada concurrency), 647
- subtypes, Ada, 580, 586-589
- subtyping Modula-3, 689
- arrays, 690
- branded types, 690
- objects, 690
- procedures, 690
- references, 690
- super identifier, Smalltalk classes, 111
- Super keyword, Java, 850
- Super variable, Smalltalk, 63
- superclasses
- Java, 767, 849
- object-oriented programming, 778
- Smalltalk, 108
- Suzuki, Nori (Smalltalk), 88
- Switch statement
- C++, 344-346
- Java, 817
- symbols, Smalltalk, 56-57
- symbols (spacing in C++), 410
- synchronization, ACE framework components, 26
- Synchronized keyword, Java, 784, 820, 829
- Synchronized statement, Java, 819
- syntax
- C, 216-217
- C++, 409
- const, 412-416
- constructor initializers, 417
- declarations, 411
- lexical analysis, 409
- pitfalls, 418
- specifiers, 411
- symbol spacing, 410
- tokens, 409
- Modula-3, 737
- comments, 739
- compilation unit productions, 740
- conventions, 739-740
- expression productions, 741-742
- keywords, 738
- miscellaneous productions, 742
- operators, 714, 738
- pragmas, 739
- reserved identifiers, 738
- statement productions, 740-741
- token productions, 742-743
- type productions, 741
- Smalltalk, 61, 178
- system properties list, Java, 791
- system services, Smalltalk, 178
- System.exit() method, Java, 791
- System.getProperty() method, Java, 791
- systems, Eiffel, 471-472
T
- tactical patterns, Web, 35
- Taft, S. Tucker (Ada), 562
- Taylor, Bob (Smalltalk), 65
- Tektronix (Smalltalk), 87
- telecommunications, Smalltalk, 192
- template classes, C++, 368-369
- template functions, C++, 366-367
- templates
- C, 221
- C++, 262
- arguments, 267
- class, 262
- compilation, 266
- instantiation, 266
- member, 264-265
- partial specialization, 264
- standard template library, 278-279
- Ternary operators, C++, order of precedence, 324
- Tesler, Larry (Smalltalk), 64
- test profile, Ada validation, 567
- text, Modula-3 concatenation, 726
- TEXT (predeclared opaque type, Modula-3), 691
- Text interface, Modula-3, 729
- text literals, Modula-3 expressions, 717
- textbooks, Ada, 573
- ThingLab (Smalltalk), 87
- third party products, Smalltalk, 171, 185
- This keyword, Java, 836
- this reference, Java methods, 761
- Thomas, Dave (Smalltalk), 88
- Thread class, java.lang package, 784
- Thread interface, Modula-3, 730
- Thread-per-Session model, web servers, concurrency, 44
- Thread Pool model, web servers, concurrency, 40
- Thread-per-Request model, web servers, concurrency, 39
- threads
- Java, 775, 784
- Modula-3, 672
- Smalltalk, 170
- Throw statement, C++, 338, 346
- throwing exceptions in Java, 821
- Tiemann, Mike (C wrappers), 221
- time, Ada (Show Date and Time), 582
- token productions,Modula-3 syntax, 742-743
- tokens, C++, pitfalls, 409
- tools, C++, 201, 242, 287
- top-level procedures, Modula-3, 684
- traced references, Modula-3, 683
- trading, Smalltalk, 191
- Transient keyword, Java, 829
- translation units, C++, 313
- truth values, C++, 320
- TRY-EXCEPT statement (Modula-3), 696
- TRY-FINALLY statement (Modula-3), 697
- try/catch/finally statement, Java, 822
- Turtle Geometry (Smalltalk), 60
- Twinkle, Smalltalk, 81
- type checking, C++, 239, 245
- type classes, Java, 775
- type composition, Ada, 589, 592
- type conversion, C++, 259
- type declaration, Modula-3 procedures, 684
- type extension, Ada, 623, 627
- type operations, Modula-3 expressions, 724-726
- type productions, Modula-3 syntax, 741
- TYPECASE statement (Modula-3), 701
- Typed Smalltalk (Smalltalk), 88
- types
- Ada, 576
- Ada.Finalization.Controlled, 641
- hierarchies, 630
- overriding, 628
- primitive, 628
- subtypes, 580, 586-589
- type extension, 627
- C with Classes, 207
- functions, 207
- static checking, 212
- Modula-3
- abstract, 670
- declarations, 703
- partially opaque types, 671
- parameterized, 246
- Smalltalk, 179
- typing
- Eiffel, 462
- categories, 485
- declarations, 484
- static, 464
- Modula-3, 675-677
- allocated type, 678
- floating-point types, 679
- ordinal, 678
- packed types, 682
- referent types, 683
- sets, 682
- subtyping, 687-689
U
- unary messages, Smalltalk, 99
- unary operators, C++, order of precedence, 323
- unchecked runtime errors, Modula-3, 677
- unconstrained arrays, Ada, 596, 610-612
- undefined variables, Java, 752
- uneval bind symbol (Smalltalk), 57
- Ungar, David (Smalltalk), 88
- unicode characters, Java, 754
- unicode escape sequences, Java, 799-800
- universities
- Smalltalk, 87
- Borning, Alan, 87
- Canada, 88
- ENVY, 89
- Griswold, David, 88
- Johnson, Ralph, 88
- LaLonde, Wilf, 88
- Moss, Eliot, 87
- Orwell, 88
- Patterson, Dave, 88
- Pugh, John, 88
- SELF, 88
- StrongTalk, 88
- Suzuki, Nori, 88
- ThingLab, 87-88
- Thomas, Dave, 88
- Typed Smalltalk, 88
- Ungar, David, 88
- Softsmarts, BrouHaHa, 88
- UNIX kernel, C++, 202
- unsafe operations, Modula-3, 669, 673, 726
- address arithmetic, 727
- DEC, 727
- INC, 727
- unsigned integers (C++), 317
- untraced references, Modula-3, 683
- user population, C++, 284
- user-defined data types, C++, 350
- Using declaration, C++ namespaces, 272
- utility classes, Java, 775
V
- Valarray class, C++, 393
- validation, Ada, 565
- ACVC (Ada Compiler Validation Capability), 565
- AJPO, 565
- AVFs, 566
- certification, 566
- debugging, 569
- limitations, 569
- performance, 569
- test profile, 567
- value models, Smalltalk, VisualWorks, 85
- variable-length character strings (C++ abstraction), 306
- variables
- C++
- arrays (two dimensions), 430
- local, 310
- pointers, 452
- Java, see Java, variables
- Modula-3, 676, 703
- polymorphism, 10
- Smalltalk
- instances, 105
- referencing, 97
- self, 63
- super, 63
- values, 10
- variant records, polymorphism (Ada), 625
- vector sequential container, C++, 394
- vectors, Ada, 611-614
- vendors, Smalltalk, 85, 187
- European, 87
- Heeg, Georg, 87-88
- Softsmarts, 87
- Tektronix, 87
- virtual destructors, OOP in C++, 377
- virtual functions, see functions, virtual
- virtual image, Smalltalk, 72
- virtual machines
- Java, 750, 774
- Smalltalk, 72, 168
- visibility modifiers, Java, 859-862
- Visual Age, 85
- Visual Basic, 85
- visual environments, Smalltalk IDE, 183
- visual languages, 85
- VisualWorks (Smalltalk) ), 84-85
- dynamic binding, 85
- value models, 85
- Void keyword, Java, 828
- Volatile keyword, Java, 830
W
- Web
- ACE framework, 28-30
- dispatcher, 28
- event dispatcher, 29
- handlers, 29
- HTTP Acceptor, 30
- HTTP Handler, 30
- requester, 28
- SOCK Acceptor, 30
- SOCK Stream, 30
- architecture
- dispatcher, 28
- event dispatchers, 29
- handlers, 29
- HTTP Acceptor, 30
- HTTP Handler, 30
- requester, 28
- SOCK Acceptor, 30
- SOCK Stream, 30
- servers
- communication software, 31
- concurrency models, 36
- JAWS, 28
- patterns, 31, 35
- Smalltalk, 191
- sites
- Smalltalk, 193
- Eiffel, 550
- What is Object-Oriented Programming? (Stroustrup), 244
- While statement
- C++, 341
- Java, 752, 816
- Modula-3, 699
- Whitaker, William (Ada), 556
- white space, C++, 319
- Widgets (GUIs), Smalltalk, 176
- width, Ada.Calendar, 584
- Wilcox, John (C++), 267
- Wilkes, Maurice (Modula-3), 667
- Wirth, Niklaus (Modula-3), 667
- With message (collection class), 146
- WITH statement (Modula-3), 699
- Word interface, Modula-3, 731
- wrappers, C, 221
- WWW
- Ada 95, 555
- Ada reference, 657
X-Z
- XSIS, Smalltalk, 81
- Yaac, C++ tools, 242
- Zydbel, Frank (Smalltalk), 80
|