It is evident that “Thinking in Java” encourage the reader to not only learn Java, but to focus software development problems from the point of view of a language that from its birth incorporates object orientation (OO), concurrency, garbage collection and portability like its more important characteristics. The book is composed of 16 chapters, it’s extensive because it covers almost all aspects of Java programming. Perhaps, chapters at all have been organized with good sense begining from foundations toward more advanced themes. The author give practical examples in Java based on Java 2 specification and JDK 1.4, at the same time proposing exercices at the end of each chapter. The CDROM “Foundations for Java” accompaning the book, contents HTML versions of the two first editions and some topics not included at the 3rd edition; none sources for the examples are included, they must be accesed from the site of the author. This book is not recomended like a basic programming book. The concepts presented are supossing that the reader has experience with programming languages. Chapters 1 and 2, give an overview of topics presented further; it is made and introduction to OO taking the premise that “all is an object”. This is a principle and must be asimilated by the reader before he takes more contact with Java. In chapter 3, the author makes a complete overview of Java sintaxis and its basics control structures. Since chapter 4 are presented themes related to OOP, beginning from object initialization and destruction. This is the first difference when comparing with other programming languages, because garbage collection is viewed like a main characteristic. Chapters 5, 6 and 7 present OOP clasic concepts from the point of view of Java, those are hiding information, class reusing and polimophism. Don’t confound this book with others of type “learning OOP with...”, since OO is inherent to Java. “Thinking in Java” presents its chapters by a practical way, so the reader is encouraged to interact with the examples and exercises. Eckel covers the topics by a clear manner, specially when talking about polimorphism, despite the fact that this is complicated to understand. Beginning from chapter 8, the level of abstraction is high, the reader wil find advanced design topics. It is viewed the concepts of “interface” and “inner classes”, some of the most relevant things concerning to other programming languages like C/C++. Some developers very familiarized with the use of abstract methods and callbacks will find interesting this high level conception. Next chapters develop themes that programmers must pay attention for developing more robust systems. Then in chapter 9 is viewed error handling by controlling exceptions, all the examples are well formulated and they teach how to lead with differents kinds of exceptions. Useful recomendations are made at the final of this chapter and must be considerated during development stage. After a brief presentation about Java resources for RTTI in chapter 10, chapter 11 treats about containers. For who are familiarized with other libraries like C++ STL (Standard Template Library), it would be easy to follow this chapter, the examples are suficcient and it is made a complete overview of Java containers family; Arrays, Collections, Lists, Maps, Stacks and Bitsets between others. Due to its importance, Java I/O system and resources for concurrent programming are treated by extensive in chapters 12 and 13. Both topics are language fortress and the treatment the author makes about them is useful for who are looking for references to exploite better these resources. Explanation of I/O system includes topics about object serialization and data compression. In special, chapter about concurrency is good. Questions abnout threads, critical sections and shared resources are explained with clarity. The illustration is made about deadlocks by means of clasical problem of “dinning philosophers” is excellent. Creation of graphical interfaces (GUI) with Java 2 Swing is viewed in chapter 14 and it is introduced the concept of application framework for constructing applets. It is made a complete overview of Swing components, from simple buttons to clipboards. It is treated questions about concurrency and it’s made an aproximation to Java Beans. On last part (chapters 15 and 16) are mentioned technics for finding and solving problems during design and development phases with Java. It’s is made a revision to resources that Java gives for unit testing, design by contracts, logging, debugging, profiling, versions control and project management. Also are given useful guidelines to follow when Java is going to be used profesionally. Definitively, this book is a good tool to discover Java’s OO world and a complete enough source of technical information for who are pretending to develop advanced applications with Java.