Thinking in Java

by Eckel, Bruce

• ISBN13: 9780131872486
• ISBN10: 0131872486
• Edition: 4th
• Format: Paperback
• Copyright: 2006-02-10
• Publisher: PEARSO

Summary

Bruce Eckel's Classic, award-winning Thinking in Java, Fourth Edition - now fully updated and revised for J2SE 5.0!

Author Biography

Bruce Eckel is president of MindView, Inc. (www.MindView.net), which provides public and private training seminars, consulting, mentoring, and design reviews in object-oriented technology and design patterns. He is the author of several books, has written more than fifty articles, and has given lectures and seminars throughout the world for more than twenty years. Bruce has served as a voting member of the C++ Standards Committee. He holds a B.S. in applied physics and an M.S. in computer engineering.

Table of Contents

Preface	1	(1)
Java SE5 and SE6	2	(1)
Java SE6	3	(1)
The 4th edition	3	(1)
Changes	4	(2)
Note on the cover design	6	(1)
Acknowledgements	7	(6)
Introduction	13	(10)
Prerequisites	14	(1)
Learning Java	14	(1)
Goals	15	(1)
Teaching from this book	16	(1)
JDK HTML documentation	17	(1)
Exercises	17	(1)
Foundations for Java	18	(1)
Source code	18	(3)
Coding standards	21	(1)
Errors	21	(2)
Introduction to Objects	23	(38)
The progress of abstraction	24	(2)
An object has an interface	26	(3)
An object provides services	29	(1)
The hidden implementation	30	(2)
Reusing the implementation	32	(1)
Inheritance	33	(5)
Is-a vs. is-like-a relationships	37	(1)
Interchangeable objects with polymorphism	38	(5)
The singly rooted hierarchy	43	(1)
Containers	44	(2)
Parameterized types (Generics)	45	(1)
Object creation & lifetime	46	(3)
Exception handling: dealing with errors	49	(1)
Concurrent programming	50	(1)
Java and the Internet	51	(9)
What is the Web?	51	(2)
Client-side programming	53	(6)
Server-side programming	59	(1)
Summary	60	(1)
Everything Is an Object	61	(32)
You manipulate objects with references	61	(2)
You must create all the objects	63	(4)
Where storage lives	63	(2)
Special case: primitive types	65	(1)
Arrays in Java	66	(1)
You never need to destroy an object	67	(2)
Scoping	67	(1)
Scope of objects	68	(1)
Creating new data types: class	69	(3)
Fields and methods	70	(2)
Methods, arguments, and return values	72	(2)
The argument list	73	(1)
Building a Java program	74	(4)
Name visibility	74	(1)
Using other components	75	(1)
The static keyword	76	(2)
Your first Java program	78	(3)
Compiling and running	80	(1)
Comments and embedded documentation	81	(7)
Comment documentation	82	(1)
Syntax	83	(1)
Embedded HTML	84	(1)
Some example tags	85	(2)
Documentation example	87	(1)
Coding style	88	(1)
Summary	89	(1)
Exercises	89	(4)
Operators	93	(42)
Simpler print statements	93	(1)
Using Java operators	94	(1)
Precedence	95	(1)
Assignment	95	(3)
Aliasing during method calls	97	(1)
Mathematical operators	98	(3)
Unary minus and plus operators	101	(1)
Auto increment and decrement	101	(2)
Relational operators	103	(2)
Testing object equivalence	103	(2)
Logical operators	105	(3)
Short-circuiting	106	(2)
Literals	108	(3)
Exponential notation	109	(2)
Bitwise operators	111	(1)
Shift operators	112	(4)
Ternary if-else operator	116	(2)
String operator + and +=	118	(1)
Common pitfalls when using operators	119	(1)
Casting operators	120	(2)
Truncation and rounding	121	(1)
Promotion	122	(1)
Java has no ``sizeof''	122	(1)
A compendium of operators	123	(10)
Summary	133	(2)
Controlling Execution	135	(20)
true and false	135	(1)
if-else	135	(2)
Iteration	137	(3)
do-while	138	(1)
for	138	(2)
The comma operator	140	(1)
Foreach syntax	140	(3)
return	143	(1)
break and continue	144	(2)
The infamous ``goto''	146	(5)
switch	151	(3)
Summary	154	(1)
Initialization & Cleanup	155	(54)
Guaranteed initialization with the constructor	155	(3)
Method overloading	158	(8)
Distinguishing overloaded methods	160	(1)
Overloading with primitives	161	(4)
Overloading on return values	165	(1)
Default constructors	166	(1)
The this keyword	167	(6)
Calling constructors from constructors	170	(2)
The meaning of static	172	(1)
Cleanup: finalization and garbage collection	173	(8)
What is finalize() for?	174	(1)
You must perform cleanup	175	(1)
The termination condition	176	(2)
How a garbage collector works	178	(3)
Member initialization	181	(4)
Specifying initialization	183	(2)
Constructor initialization	185	(8)
Order of initialization	185	(1)
static data initialization	186	(4)
Explicit static initialization	190	(1)
Non-static instance initialization	191	(2)
Array initialization	193	(11)
Variable argument lists	198	(6)
Enumerated types	204	(3)
Summary	207	(2)
Access Control	209	(28)
package: the library unit	210	(11)
Code organization	212	(1)
Creating unique package names	213	(4)
A custom tool library	217	(3)
Using imports to change behavior	220	(1)
Package caveat	220	(1)
Java access specifiers	221	(7)
Package access	221	(1)
public: interface access	222	(2)
private: you can't touch that!	224	(1)
protected: inheritance access	225	(3)
Interface and implementation	228	(1)
Class access	229	(4)
Summary	233	(4)
Reusing Classes	237	(40)
Composition syntax	237	(4)
Inheritance syntax	241	(5)
Initializing the base class	244	(2)
Delegation	246	(3)
Combining composition and inheritance	249	(7)
Guaranteeing proper cleanup	251	(4)
Name hiding	255	(1)
Choosing composition vs. inheritance	256	(2)
protected	258	(2)
Upcasting	260	(2)
Why ``upcasting''?	261	(1)
Composition vs. inheritance revisited	261	(1)
The final keyword	262	(10)
final data	262	(5)
final methods	267	(3)
final classes	270	(1)
final caution	271	(1)
Initialization and class loading	272	(2)
Initialization with inheritance	272	(2)
Summary	274	(3)
Polymorphism	277	(34)
Upcasting revisited	278	(3)
Forgetting the object type	279	(2)
The twist	281	(12)
Method-call binding	281	(1)
Producing the right behavior	282	(4)
Extensibility	286	(4)
Pitfall: ``overriding'' private methods	290	(1)
Pitfall: fields and static methods	290	(3)
Constructors and polymorphism	293	(10)
Order of constructor calls	293	(2)
Inheritance and cleanup	295	(6)
Behavior of polymorphic methods inside constructors	301	(2)
Covariant return types	303	(1)
Designing with inheritance	304	(6)
Substitution vs. extension	306	(2)
Downcasting and runtime type information	308	(2)
Summary	310	(1)
Interfaces	311	(34)
Abstract classes and methods	311	(5)
Interfaces	316	(4)
Complete decoupling	320	(6)
``Multiple inheritance'' in Java	326	(3)
Extending an interface with inheritance	329	(2)
Name collisions when combining interfaces	330	(1)
Adapting to an interface	331	(4)
Fields in interfaces	335	(1)
Initializing fields in interfaces	335	(1)
Nesting interfaces	336	(3)
Interfaces and factories	339	(4)
Summary	343	(2)
Inner Classes	345	(44)
Creating inner classes	345	(2)
The link to the outer class	347	(3)
Using .this and .new	350	(2)
Inner classes and upcasting	352	(2)
Inner classes in methods and scopes	354	(2)
Anonymous inner classes	356	(8)
Factory Method revisited	361	(3)
Nested classes	364	(5)
Classes inside interfaces	366	(2)
Reaching outward from a multiply nested class	368	(1)
Why inner classes?	369	(13)
Closures & callbacks	372	(3)
Inner classes & control frameworks	375	(7)
Inheriting from inner classes	382	(1)
Can inner classes be overridden?	383	(2)
Local inner classes	385	(2)
Inner-class identifiers	387	(1)
Summary	388	(1)
Holding Your Objects	389	(54)
Generics and type-safe containers	390	(4)
Basic concepts	394	(2)
Adding groups of elements	396	(2)
Printing containers	398	(3)
List	401	(5)
Iterator	406	(4)
ListIterator	409	(1)
LinkedList	410	(2)
Stack	412	(3)
Set	415	(4)
Map	419	(4)
Queue	423	(4)
PriorityQueue	425	(2)
Collection vs. Iterator	427	(4)
Foreach and iterators	431	(6)
The Adapter Method idiom	434	(3)
Summary	437	(6)
Error Handling with Exception's	443	(60)
Concepts	444	(1)
Basic exceptions	445	(2)
Exception arguments	446	(1)
Catching an exception	447	(2)
The try block	447	(1)
Exception handlers	448	(1)
Creating your own exceptions	449	(8)
Exceptions and logging	452	(5)
The exception specification	457	(1)
Catching any exception	458	(10)
The stack trace	460	(1)
Rethrowing an exception	461	(3)
Exception chaining	464	(4)
Standard Java exceptions	468	(3)
Special case: RuntimeException	469	(2)
Performing cleanup with finally	471	(8)
What's finally for?	473	(3)
Using finally during return	476	(1)
Pitfall: the lost exception	477	(2)
Exception restrictions	479	(4)
Constructors	483	(6)
Exception matching	489	(1)
Alternative approaches	490	(10)
History	492	(2)
Perspectives	494	(3)
Passing exceptions to the console	497	(1)
Converting checked to unchecked exceptions	497	(3)
Exception guidelines	500	(1)
Summary	501	(2)
Strings	503	(50)
Immutable Strings	503	(1)
Overloading `+' vs. StringBuilder	504	(5)
Unintended recursion	509	(2)
Operations on Strings	511	(3)
Formatting output	514	(9)
printf()	514	(1)
System.out.format()	514	(1)
The Formatter class	515	(1)
Format specifiers	516	(2)
Formatter conversions	518	(3)
String.format()	521	(2)
Regular expressions	523	(23)
Basics	524	(3)
Creating regular expressions	527	(2)
Quantifiers	529	(2)
Pattern and Matcher	531	(9)
split()	540	(1)
Replace operations	541	(3)
reset()	544	(1)
Regular expressions and Java I/O	544	(2)
Scanning input	546	(5)
Scanner delimiters	549	(1)
Scanning with regular expressions	550	(1)
StringTokenizer	551	(1)
Summary	552	(1)
Type Information	553	(64)
The need for RTTI	553	(3)
The Class object	556	(13)
Class literals	562	(3)
Generic class references	565	(3)
New cast syntax	568	(1)
Checking before a cast	569	(13)
Using class literals	576	(2)
A dynamic instanceof	578	(2)
Counting recursively	580	(2)
Registered factories	582	(4)
instanceof vs. Class equivalence	586	(2)
Reflection: runtime class information	588	(5)
A class method extractor	590	(3)
Dynamic proxies	593	(5)
Null Objects	598	(9)
Mock Objects & Stubs	606	(1)
Interfaces and type information	607	(6)
Summary	613	(4)
Generics	617	(130)
Comparison with C++	618	(1)
Simple generics	619	(8)
A tuple library	621	(4)
A stack class	625	(1)
RandomList	626	(1)
Generic interfaces	627	(4)
Generic methods	631	(14)
Leveraging type argument inference	633	(2)
Varargs and generic methods	635	(1)
A generic method to use with Generators	636	(1)
A general-purpose Generator	637	(2)
Simplifying tuple use	639	(2)
A Set utility	641	(4)
Anonymous inner classes	645	(2)
Building complex models	647	(3)
The mystery of erasure	650	(12)
The C++ approach	652	(3)
Migration compatibility	655	(1)
The problem with erasure	656	(2)
The action at the boundaries	658	(4)
Compensating for erasure	662	(11)
Creating instances of types	664	(3)
Arrays of generics	667	(6)
Bounds	673	(4)
Wildcards	677	(17)
How smart is the compiler?	680	(2)
Contravariance	682	(4)
Unbounded wildcards	686	(6)
Capture conversion	692	(2)
Issues	694	(7)
No primitives as type parameters	694	(2)
Implementing parameterized interfaces	696	(1)
Casting and warnings	697	(2)
Overloading	699	(1)
Base class hijacks an interface	700	(1)
Self-bounded types	701	(9)
Curiously-recurring generics	701	(2)
Self-bounding	703	(3)
Argument covariance	706	(4)
Dynamic type safety	710	(1)
Exceptions	711	(2)
Mixins	713	(8)
Mixins in C++	714	(1)
Mixing with interfaces	715	(2)
Using the Decorator pattern	717	(2)
Mixins with dynamic proxies	719	(2)
Latent typing	721	(5)
Compensating for the lack of latent typing	726	(11)
Reflection	726	(2)
Applying a method to a sequence	728	(3)
When you don't happen to have the right interface	731	(2)
Simulating latent typing with adapters	733	(4)
Using function objects as strategies	737	(6)
Summary: Is casting really so bad?	743	(4)
Further reading	746	(1)
Arrays	747	(44)
Why arrays are special	747	(2)
Arrays are first-class objects	749	(4)
Returning an array	753	(1)
Multidimensional arrays	754	(5)
Arrays and generics	759	(3)
Creating test data	762	(13)
Arrays.fill()	762	(1)
Data Generators	763	(7)
Creating arrays from Generators	770	(5)
Arrays utilities	775	(11)
Copying an array	775	(2)
Comparing arrays	777	(1)
Array element comparisons	778	(4)
Sorting an array	782	(2)
Searching a sorted array	784	(2)
Summary	786	(5)
Containers in Depth	791	(110)
Full container taxonomy	791	(2)
Filling containers	793	(16)
A Generator solution	794	(2)
Map generators	796	(4)
Using Abstract classes	800	(9)
Collection functionality	809	(4)
Optional operations	813	(4)
Unsupported operations	815	(2)
List functionality	817	(4)
Sets and storage order	821	(6)
SortedSet	825	(2)
Queues	827	(4)
Priority queues	828	(1)
Deques	829	(2)
Understanding Maps	831	(8)
Performance	833	(4)
SortedMap	837	(1)
LinkedHashMap	838	(1)
Hashing and hash codes	839	(19)
Understanding hashCode()	843	(4)
Hashing for speed	847	(4)
Overriding hashCode()	851	(7)
Choosing an implementation	858	(21)
A performance test framework	859	(4)
Choosing between Lists	863	(8)
Microbenchmarking dangers	871	(1)
Choosing between Sets	872	(3)
Choosing between Maps	875	(4)
Utilities	879	(10)
Sorting and searching Lists	884	(1)
Making a Collection or Map unmodifiable	885	(2)
Synchronizing a Collection or Map	887	(2)
Holding references	889	(4)
The WeakHashMap	892	(1)
Java 1.0/1.1 containers	893	(7)
Vector & Enumeration	894	(1)
Hashtable	895	(1)
Stack	895	(2)
BitSet	897	(3)
Summary	900	(1)
I/O	901	(110)
The File class	901	(13)
A directory lister	902	(4)
Directory utilities	906	(6)
Checking for and creating directories	912	(2)
Input and output	914	(4)
Types of InputStream	915	(2)
Types of OutputStream	917	(1)
Adding attributes and useful interfaces	918	(4)
Reading from an InputStream with FilterInputStream	919	(2)
Writing to an OutputStream with FilterOutputStream	921	(1)
Readers & Writers	922	(4)
Sources and sinks of data	923	(1)
Modifying stream behavior	924	(1)
Unchanged classes	925	(1)
Off by itself: RandomAccessFile	926	(1)
Typical uses of I/O streams	927	(9)
Buffered input file	927	(1)
Input from memory	928	(1)
Formatted memory input	929	(1)
Basic file output	930	(2)
Storing and recovering data	932	(2)
Reading and writing random-access files	934	(2)
Piped streams	936	(1)
File reading & writing utilities	936	(5)
Reading binary files	940	(1)
Standard I/O	941	(3)
Reading from standard input	941	(1)
Changing System.out to a PrintWriter	942	(1)
Redirecting standard I/O	942	(2)
Process control	944	(2)
New I/O	946	(27)
Converting data	950	(3)
Fetching primitives	953	(2)
View buffers	955	(5)
Data manipulation with buffers	960	(2)
Buffer details	962	(4)
Memory-mapped files	966	(4)
File locking	970	(3)
Compression	973	(7)
Simple compression with GZIP	974	(1)
Multifile storage with Zip	975	(3)
Java ARchives (JARs)	978	(2)
Object serialization	980	(23)
Finding the class	984	(2)
Controlling serialization	986	(10)
Using persistence	996	(7)
XML	1003	(3)
Preferences	1006	(2)
Summary	1008	(3)
Enumerated Types	1011	(48)
Basic enum features	1011	(3)
Using static imports with enums	1013	(1)
Adding methods to an enum	1014	(2)
Overriding enum methods	1015	(1)
enums in switch statements	1016	(1)
The mystery of values()	1017	(3)
Implements, not inherits	1020	(1)
Random selection	1021	(1)
Using interfaces for organization	1022	(6)
Using EnumSet instead of flags	1028	(2)
Using EnumMap	1030	(2)
Constant-specific methods	1032	(15)
Chain of Responsibility with enums	1036	(5)
State machines with enums	1041	(6)
Multiple dispatching	1047	(10)
Dispatching with enums	1050	(3)
Using constant-specific methods	1053	(2)
Dispatching with EnumMaps	1055	(1)
Using a 2-D array	1056	(1)
Summary	1057	(2)
Annotations	1059	(50)
Basic syntax	1060	(4)
Defining annotations	1061	(2)
Meta-annotations	1063	(1)
Writing annotation processors	1064	(10)
Annotation elements	1065	(1)
Default value constraints	1065	(1)
Generating external files	1066	(4)
Annotations don't support inheritance	1070	(1)
Implementing the processor	1071	(3)
Using apt to process annotations	1074	(5)
Using the Visitor pattern with apt	1079	(4)
Annotation-based unit testing	1083	(23)
Using @Unit with generics	1094	(1)
No ``suites'' necessary	1095	(1)
Implementing @Unit	1096	(8)
Removing test code	1104	(2)
Summary	1106	(3)
Concurrency	1109	(194)
The many faces of concurrency	1111	(5)
Faster execution	1111	(3)
Improving code design	1114	(2)
Basic threading	1116	(34)
Defining tasks	1116	(2)
The Thread class	1118	(2)
Using Executors	1120	(4)
Producing return values from tasks	1124	(2)
Sleeping	1126	(1)
Priority	1127	(2)
Yielding	1129	(1)
Daemon threads	1130	(5)
Coding variations	1135	(7)
Terminology	1142	(1)
Joining a thread	1143	(2)
Creating responsive user interfaces	1145	(1)
Thread groups	1146	(1)
Catching exceptions	1147	(3)
Sharing resources	1150	(29)
Improperly accessing resources	1150	(3)
Resolving shared resource contention	1153	(7)
Atomicity and volatility	1160	(7)
Atomic classes	1167	(2)
Critical sections	1169	(6)
Synchronizing on other objects	1175	(2)
Thread local storage	1177	(2)
Terminating tasks	1179	(18)
The ornamental garden	1179	(4)
Terminating when blocked	1183	(2)
Interruption	1185	(9)
Checking for an interrupt	1194	(3)
Cooperation between tasks	1197	(26)
wait() and notifyAll()	1198	(6)
notify() vs. notifyAll()	1204	(4)
Producers and consumers	1208	(7)
Producer-consumers and queues	1215	(6)
Using pipes for I/O between tasks	1221	(2)
Deadlock	1223	(6)
New library components	1229	(24)
CountDownLatch	1230	(2)
CyclicBarrier	1232	(3)
DelayQueue	1235	(4)
Priority BlockingQueue	1239	(3)
The greenhouse controller with ScheduledExecutor	1242	(4)
Semaphore	1246	(4)
Exchanger	1250	(3)
Simulation	1253	(17)
Bank teller simulation	1253	(6)
The restaurant simulation	1259	(5)
Distributing work	1264	(6)
Performance tuning	1270	(25)
Comparing mutex technologies	1271	(10)
Lock-free containers	1281	(9)
Optimistic locking	1290	(2)
ReadWriteLocks	1292	(3)
Active objects	1295	(5)
Summary	1300	(3)
Further reading	1302	(1)
Graphical User Interfaces	1303	(146)
Applets	1306	(1)
Swing basics	1307	(4)
A display framework	1310	(1)
Making a button	1311	(1)
Capturing an event	1312	(3)
Text areas	1315	(2)
Controlling layout	1317	(4)
BorderLayout	1317	(1)
FlowLayout	1318	(1)
GridLayout	1319	(1)
GridBagLayout	1320	(1)
Absolute positioning	1320	(1)
BoxLayout	1320	(1)
The best approach?	1321	(1)
The Swing event model	1321	(11)
Event and listener types	1322	(7)
Tracking multiple events	1329	(3)
A selection of Swing components	1332	(44)
Buttons	1333	(2)
Icons	1335	(2)
Tool tips	1337	(1)
Text fields	1338	(2)
Borders	1340	(1)
A mini-editor	1341	(1)
Check boxes	1342	(2)
Radio buttons	1344	(1)
Combo boxes (drop-down lists)	1345	(2)
List boxes	1347	(2)
Tabbed panes	1349	(1)
Message boxes	1350	(2)
Menus	1352	(7)
Pop-up menus	1359	(1)
Drawing	1360	(4)
Dialog boxes	1364	(4)
File dialogs	1368	(2)
HTML on Swing components	1370	(1)
Sliders and progress bars	1371	(2)
Selecting look & feel	1373	(3)
Trees, tables & clipboard	1376	(1)
JNLP and Java Web Start	1376	(6)
Concurrency & Swing	1382	(11)
Long-running tasks	1382	(9)
Visual threading	1391	(2)
Visual programming and JavaBeans	1393	(22)
What is a JavaBean?	1395	(2)
Extracting BeanInfo with the Introspector	1397	(6)
A more sophisticated Bean	1403	(4)
JavaBeans and synchronization	1407	(5)
Packaging a Bean	1412	(2)
More complex Bean support	1414	(1)
More to Beans	1415	(1)
Alternatives to Swing	1415	(1)
Building Flash Web clients with Flex	1416	(14)
Hello, Flex	1416	(2)
Compiling MXML	1418	(1)
MXML and ActionScript	1419	(1)
Containers and controls	1420	(2)
Effects and styles	1422	(1)
Events	1423	(1)
Connecting to Java	1424	(3)
Data models and data binding	1427	(1)
Building and deploying	1428	(2)
Creating SWT applications	1430	(17)
Installing SWT	1431	(1)
Hello, SWT	1431	(3)
Eliminating redundant code	1434	(2)
Menus	1436	(2)
Tabbed panes, buttons, and events	1438	(4)
Graphics	1442	(2)
Concurrency in SWT	1444	(3)
SWT vs. Swing?	1447	(1)
Summary	1447	(2)
Resources	1448	(1)
A: Supplements	1449	(6)
Downloadable supplements	1449	(1)
Thinking in C: Foundations for Java	1449	(1)
Thinking in Java seminar	1450	(1)
Hands-On Java seminar-on-CD	1450	(1)
Thinking in Objects seminar	1450	(1)
Thinking in Enterprise Java	1451	(1)
Thinking in Patterns (with Java)	1452	(1)
Thinking in Patterns seminar	1452	(1)
Design consulting and reviews	1453	(2)
B: Resources	1455	(8)
Software	1455	(1)
Editors & IDEs	1455	(1)
Books	1456	(7)
Analysis & design	1457	(3)
Python	1460	(1)
My own list of books	1460	(3)
Index	1463

Excerpts

I originally approached Java as "just another programming language," which in many senses it is. But as time passed and I studied it more deeply, I began to see that the fundamental intent of this language was different from other languages I had seen up to that point. Programming is about managing complexity: the complexity of the problem you want to solve, laid upon the complexity of the machine in which it is solved. Because of this complexity, most of our programming projects fail. And yet, of all the programming languages of which I am aware, almost none have gone all out and decided that theirmaindesign goal would be to conquer the complexity of developing and maintaining programs. 1 Of course, many language design decisions were made with complexity in mind, but at some point there were always other issues that were considered essential to be added into the mix. Inevitably, those other issues are what cause programmers to eventually "hit the wall" with that language. For example, C++ had to be backwards-compatible with C (to allow easy migration for C programmers), as well as efficient. Those are both very useful goals and account for much of the success of C++, but they also expose extra complexity that prevents some projects from being finished (certainly, you can blame programmers and management, but if a language can help by catching your mistakes, why shouldn't it?). As another example, Visual BASIC (VB) was tied to BASIC, which wasn't really designed to be an extensible language, so all the extensions piled upon VB have produced some truly unmaintainable syntax. Perl is backwards-compatible with awk, sed, grep, and other Unix tools it was meant to replace, and as a result it is often accused of producing "write-only code" (that is, after a while you can't read it). On the other hand, C++, VB, Perl, and other languages like Smalltalk hadsomeof their design efforts focused on the issue of complexity and as a result are remarkably successful in solving certain types of problems. What has impressed me most as I have come to understand Java is that somewhere in the mix of Sun's design objectives, it seems that there was a goal of reducing complexityfor the programmer.As if to say, "We care about reducing the time and difficulty of producing robust code." In the early days, this goal resulted in code that didn't run very fast (although this has improved over time), but it has indeed produced amazing reductions in development timehalf or less of the time that it takes to create an equivalent C++ program. This result alone can save incredible amounts of time and money, but Java doesn't stop there. It goes on to wrap many of the complex tasks that have become important, such as multithreading and network programming, in language features or libraries that can at times make those tasks easy. And finally, it tackles some really big complexity problems: cross-platform programs, dynamic code changes, and even security, each of which can fit on your complexity spectrum anywhere from "impediment" to "show-stopper." So despite the performance problems that we've seen, the promise of Java is tremendous: It can make us significantly more productive programmers. In all wayscreating the programs, working in teams, building user interfaces to communicate with the user, running the programs on different types of machines, and easily writing programs that communicate across the InternetJava increases the communication bandwidthbetween people. I think that the results of the communication revolution may not be seen from the effects of moving large quantities of bits around. We shall see the true revolution because we will all communica