Table of Contents


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


Table of Contents