Sponsored links


Valid XHTML 1.0!
Valid CSS!
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: Special Edition Using Lotus Notes and Domino 6
Publisher: Que
Authors: Jeff Gunther, Randall Tamura
Rating: 5/5
Customer opinion - 5 stars out of 5
Great All Around Notes/Domino Book!


As an experienced Notes and Domino developer, I enjoyed reading this book. It helped me familiarize myself with the new R6 features and had enough detail to give me some excellent development tips and ideas. It's strength is that it is a broad reference covering all three clients and the web, including installation, development and administration. It will certainly be an excellent guide for the notes user up to the moderately experienced developer. A book any serious Notes user or developer would want on their shelf!



Product: Book - Paperback
Title: Programming Perl (3rd Edition)
Publisher: O'Reilly
Authors: Larry Wall, Tom Christiansen, Jon Orwant
Rating: 2/5
Customer opinion - 2 stars out of 5
! Concise && ( not very good with the examples)


If you're like me, and you're shopping for a book, you immediately start reading the negative reviews and work upwards. So I started reading the reviews and read through them all, bought the book despite the many negative, and frankly, snippish comments made by many reviewers and decided that I need to respond.
Many say that the examples are convoluted, or that he focuses on obscure language references. One says the book starts quickly with a discussion of the splice function. The first mention of splice is on page 355, which I certainly don't define as 'quickly'....
Others say that there are no examples, or they are not explained clearly, but there's a short sample program right on page 18, and then 4 pages are devoted to analyzing the program and how it works. Further review through the book shows many small examples, especially in the sections that outline the core functions of Perl, and the core modules of Perl.
Others come here and criticize Perl the language, and use this as a platform for their own advocacy of other languages. This is just silly. If you're interested in Perl, or you've been using Perl and you want to know more, buy this book. In the universe of computer programming, every language choice you make is controversial, and subject to debate, and just because some reviewers do not like Perl the language, it does not mitigate the quality of this book.
That all being said, and debunking the frankly lousy reviews, I'll caution that this is NOT for beginning programmers, or people with limited technical knowledge. O'Reilly knows this, and anyone who has read this book should know this too. There is a book called 'Beginning Perl', also from O'Reilly, and written by one of the other top minds in Perl. It is easy to follow, provides many concrete examples and is where a beginning programer should begin. If you have a technical background, you will probably be able to start with this book, though Learning Perl is still worth reading.
What this book provides is not only an exhaustive guide to the language of Perl, and it's abilities, but also insight into it's design, the decisions of the creator of the language (Larry Wall, the main author of the book created Perl), and the major philosophy behind Perl.
This is a valuable reference and worth having.
This is the book that I turn to when I have Perl questions.
And this book is worth every penny I spent to get it.



Product: Book - Paperback
Title: Professional SQL Server 2000 Programming (Programmer to Programmer)
Publisher: Wrox
Authors: Robert Vieira
Rating: 1/5
Customer opinion - 1 stars out of 5
Not a good reference book


For such a thick, heavy book, this one just doesn't seem to have much worthwhile content in it... lotta screen shots though. I basically bought this hoping to use it as a reference. This book is not a reference book at all. "o man, I forgot what order to put the arguements of the DATEADD function in... where do I look?" To make things easy to find, it's mentioned in the table of contents as one of the first topics in the Views section. His book on SQL 7 was better than this one. Looking at the picture on the cover gives me a headache too.