Sponsored links


Valid XHTML 1.0!
Valid CSS!



Product: Book - Paperback
Title: PC Hardware in a Nutshell, 3rd Edition
Publisher: O'Reilly
Authors: Robert Bruce Thompson, Barbara Fritchman Thompson
Rating: 5/5
Customer opinion - 5 stars out of 5
A lifesaver


My wife's PC died and the repair place said it'd cost $225 parts and labor to replace the power supply. That seemed awfully expensive given what new PC's sell for, so I hauled it back home. On the way I got to thinking about fixing it myself, so I stopped by the mall and looked at PC hardware books. This one had more details about power supplies than the others so I bought it.
I'd never worked on a PC before and was a little nervous about opening my wife's system but I figured if I killed it it'd be no great loss. I bought a new power supply for about $50 and installed it. When I crossed my fingers and turned the system back on it started normally and has been working ever since. That means this book already saved me $150 over its cost.
Even if you're a PC novice like me this book tells you everything you need to know to fix or upgrade your system. I don't know how this book compares to other PC hardware books because I've never read any of them. But as far as I'm concerned it definitely deserves five stars.



Product: Book - Paperback
Title: Exceptional C++: 47 Engineering Puzzles, Programming Problems, and Solutions
Publisher: Addison-Wesley Professional
Authors: Herb Sutter
Rating: 5/5
Customer opinion - 5 stars out of 5
challenging book for C++ experts


I strongly recommend this book to anyone who is a C++ expert. Someone at work recommended the book to me, and it took me a while to get to it, thinking it would be just another book of familiar C++ ideas and idioms. Nope, far from it, this book is thought provoking, challenging, and enlightening. It is organized as a series of challenging C++ questions. I consider myself pretty expert in C++, but I don't think there was a single question where I completely nailed the answer. Check it out!



Product: Book - Paperback
Title: Thinking in Java (3rd Edition)
Publisher: Prentice Hall PTR
Authors: Bruce Eckel
Rating: 4/5
Customer opinion - 4 stars out of 5
the continuation of my previous article


This is the continuation of my previous article, which has been crippled off at the 1000-word-boundary. It starts off with the next word where the previous article ended.
************************************
ponents (still existing in Core Java 3rd ed Vol1 but NOT in the most recent edition) and using the AWT event queue is great. Basic clipboard operations (Core Java 3rd ed Vol2 discussed the subject much more thoroughly) and JavaBeans are also discussed here. Basics of Swing are introduced - this section is one of the worst in the book. There is no MVC and the author doesn't even describe panes in a JFrame. This chapter is one of the chapters in the book that need complete rewrite.
Chapter 14 discusses multithreading. It also describes why suspend/resume/stop are deprecated - it's also the only book to discuss this subject. Compared to SL-276, the first explanation of the deprecated stop() methods is a bit problematic, albeit the later use (and explanation) of a stop flag is OK. Explanation java.net. Both TCP sockets and UDP datagrams are thoroughly presented (with presenting the usual multithreaded server application too). JDBC is also quite thoroughly (8 pages) discussed in the chapter, which closes with RMI (also a thorough description - it should have presented a working, large example, though, just like Core Java vol2).
Later chapters discuss design patterns at a high level (unique with a Java book! The other general Java book that discusses this subject I've read is Wiley's Programming Mobile Objects with Java - a real failure), some real-world examples (without Swing), JNI, CORBA. A separate chapter is devoted to comparing C++ to Java - the book excels in this area, too. Java authors should emphasize this subject in their books more. The performance comparison in appendix D rocks.
What did I compare?
I tried to evaluate each book in a comparative fashion. Unfortunately, when it's time to evaluate a book's being comprehensive AND discussing / mentioning everything with ONE rating, it's hard do decide which to prefer. Should we give a better mark to a book that is more comprehensive but less wide-reaching, that is, lacking the discussion of some features of the language? Should we do the opposite? Fortunately, there weren't many cases where this caused me headache, as, in general, the books are both comprehensive AND fully discuss everything. Nevertheless, I included a row in the table. This row evaluates each book's being both beginner-friendly (that is, whether it's intended to a newcomer) and discussing everything at much higher depth than the API docs. The higher the mark, the better suited for the target audience (beginners or the experienced) the book. These two ratings, of course, don't have to be equally high for a good book - for example, Java in a Nutshell, an outstanding reference, would hardly get a rating higher than 2 when evaluating its suitability for beginners. A book, on the other hand, that receives ratings that are both below 3, isn't intended for outstanding, far better than any other book
References in italic reference for the experienced or an introduction for beginners?
5* (1) Basics of procedural programming (w/o OOP)
4 (3) OOP comprehensibility
5/5 Threads / 1.2 thread deprecation
5 Exceptions, error handling
5 (8) Packages
5 AWT 1.0 event model
4 (no GBL, Box) Layout managers
4 AWT 1.1 event model
2 Basic Swing widgets
2 Advanced Swing widgets
4 1.1 I/O
1 java.math - BigInteger, BigDecimal
5 Java.net
5* Collections
5* inner classes
0 JDK 1.2 security
4 1.1 clipboard handling
4 Java Beans
5* RTTI, Reflection, Class
5 CORBA et al (DCOM etc)
4 RMI
0 i18n
4 JDBC
5* Comparing Java to C++
5*/0/0 Object serialization / versioning / object file format
5* JNI
4/0 Applets / conversion to applications and vice versa
5/5 Describing / Using naming break/continue is very cool; so is the "Ulcer addicts really like C a of the books reviewed in this article discusses packages as they should be discussed - that is, the relationship between the packages and the file system is introduced at a very late stage, if ever. All books miss crucial information of actually compiling classes that belong to a specific package. This is why there is no clear winner in this subject - this is a bit annoying, as, for a beginner, it's one of the most complicated questions to understand how the packages are located in the file system and what CLASSPATH is. Unfortunately, this subject is only introduced by Sun's own SL-276 revision B course book, the book that discusses mapping of packages, object locks, synchronization, wait/notify and 1.2 thread deprecation (suspend/resume/stop) the best. Core Java is the only to mention some practical info (the compiler doesn't automatically place .class files of a given package to the subdirectories in the current dir). It doesn't show the user how the -d parameter should be used of javac to avoid manually copying the compiled .class files. All books that have been reviewed lack this, extremely important, explanation (except for Sun's far as Swing widgets are concerned. The only exception is Core Java. This book doesn't cover many widgets (only the basic ones), but is very thorough. Let's hope vol2 will cover all the missing widgets.
There is no clear winner. Core Java, Just Java and Thinking in Java are all great for a beginner. Core Java is more of a reference, so you are not guaranteed to understand OOP from that book - a reason for getting Just Java as well. Just Java, on the other hand, is a bit superficial and terse - a reason for getting the other two books. Also, as can be seen from the table, these books are strong sometimes in entirely different areas. Just Java's strength lies in its comprehensibility, while it's not suited for the experienced. Core Java is much harder for a beginner to understand, but is a great reference. Thinking in Java excels at some areas, while there are certain subjects that the books just suck at. You indeed should get the book, but don't expect to become a Swing programmer after reading it. The same stands for the emphasis on the 1.0 event model - most AWT components are presented using the 1.0 event model. It's indeed a bad move from Eckel. Nobody wants to learn / code the old event model any more.
Rather than trying to say which is the one perfect Java book, I recommend that readers look at the strengths and weaknesses of each, and choose from any of the 3 excellent books according to their needs. For example anyone that hate the JDK 1.0 events knows to avoid the Thinking in Java book, but they might buy it for its great coverage of Collections.
There are clear losers. IDG's Java 1.2 Bible and Steyer's Java 1.2 Kompendium are plain bad.
Java 1.2 Bible is just an outdated compendium with a lot of mistakes. The biggest error is that it says we synchronize on a method, so 2 or more threads can't call the same METHOD. The author doesn't seem to understand what he writes about. Furthermore, some information on Java is wrong (e.g. private protected) as they have been removed from the language a long ago (that is, in JDK 1.0.1).
Java 1.2 Kompendium is a real disaster. It's one of the worst books I've ever read on Java. As can be seen from the table above, it doesn't discuss the 1.1 I/O classes. It introduces the AWT widgets using the 1.0 event model - this is also a big problem in Thinking in Java. There are NO practical examples of using the new event model. And the list continues - the author just collected some outdated information on Java 1.0 and tried to re-sell it by including some new info on the capabilities of the newer Java versions. This info is practically useless. The cover has the buzzwords RMI, JavaBeans etc... on it - too bad only 2-3 pages are devoted to these subjects (if any). If you happen to know German, do NOT buy anything from Ralph Steyer before thoroughly scrutinizing it!
Werner Zsolt
Leader of Sun Microsystems Hungary's Java courses
Budapest, Hungary
werner@ttt-atm.ttt.bme.h



Product: Book - Paperback
Title: JDBC API Tutorial and Reference, Third Edition
Publisher: Addison-Wesley Professional
Authors: Maydene Fisher, Jon Ellis, Jonathan Bruce
Rating: 4/5
Customer opinion - 4 stars out of 5
Mature and stable


Almost all practical commercial deployments of Java involve hooking to a back end database. Of the latter, relational databases are the dominant form. The first version of JDBC arose soon after Java was released, because of this compelling need. Since then, Sun has extended the functionality while still striving to keep its learning curve shallow, as compared to Microsoft's ODBC. Indeed, the latest Java 1.4 Standard Edition includes JDBC 3.0 in its entirety.
To document JDBC 3.0, Sun has put out the third edition of this book. The maturity of JDBC is reflected in its heft. The reference portion is voluminous. The tutorial section is like aged whisky; it goes down smoothly. Sun has had plenty of time to sandpaper rough edges and, based on user feedback, to add popularly requested capabilities.
The attraction of this book is that it describes a mature and stable product. In corporate terms, it is safe and conservative. In other words, you can develop with JDBC according to the book and be highly confident of success. At least insofar as your Java GUI conversing with the database. (The design of a GUI or a database is outside the purview of the book.)