5 comments about Java Swing, Second Edition.

1. Man, has Swing grown; no wonder it took 5 authors to write this book! Anyway, they do a good job describing a very complex subject. The text is definitely more of a reference than a tutorial, but if that's what you're looking for then definitely check out this book...
   *IF* you have another source for layout managers. Other reviewers have pointed this out as well. In my opinion, this topic deserves its own chapter because every time you put a component in a container you have to be aware of its layout manager. And when a dialog box gets complicated, as they are wont to do, you have layout managers dealing with each other ad infinitum - and that is precisely when you really need to understand how they work so you can make sense of what is going on when you resize something.



2. I can't recall a tech book so thoroughly unreadable! Maybe if I was more well versed in Swing this might make a little more sense, but seriously....it's great that these folks know all the inheritance lines and can spit them out in eight words or less, but seriously...imagine this as a classroom lecture..anybody awake? anybody still here? well, this class inherits from that or this implemements that interface, and if you look closely, you'll see how this references what we said 47 pages ago (or better yet, what we're gonna say 36 pages down the road!)...all well and good...but we're trying to write real programs and solve real problems....c'mon guys, we're not experts here, else we wouldn't be buying the book!! how about a litle real world usage...I don't have to time to check out the API docs to try and figure out what these guys are yakking about...a major disappointment.



3. This is for people who have a working knowledge of Swing and who want a comprehensive reference on their desks. I am preparing for the java Developer exam and thought this would help me get up to speed with Swing. But this is an over kill. Trying to learn Swing with this book is like trying to open a can of Coke with a bulldozer. It would have been more helpful if the Title was something like 'Swing Reference'. If you want to learn some Swing to get some work done very quickly stay away. If you are in the Guru class then go for it. 4 stars because it is indeed a well written reference (Juding from Chapter 1 and 3 and some skimming) But not 5 stars because the Title is misleading



4. This extremely hefty book on Swing has just about everything in it. However, it is intended to be a reference on Swing, not a tutorial. The problem with the Java Swing API is that it is so large and unwieldy itself that it is difficult to write a complete and useful reference that does not reflect that fact. If you need a good tutorial on Java Swing, you might want to look at the Core Java books by Cornell and read the chapters that apply to Swing. Cornell manages to carve out the basics of writing a Swing application very clearly without getting wrapped around the axle in details you do not need if you are a beginner. Then, come back to this book when you need to write an application to get the details you need. Since everything in Swing is a JavaBean, much of each component's behavior is controlled by a set of properties that are manipulated by accessor methods. Thus, this book has a table for each class that presents the class properties, the data type for each property, the accessor methods, and the default values. In addition, the book has plenty of demonstration code that shows how to use just about all of the various Swing components. The book even has chapters dedicated to changing the look and feel of components and also repainting issues, which loom large in Swing. You can download all of the book's code from the book's website at O'Reilly and Associates. I highly recommend this book to anyone who already knows the bare basics of writing applications with Swing and needs a useful reference. There is no better one out there in publication of which I am aware.



5. This book does a very good job of consolidating all of the information regarding Swing that can be found on the internet and putting it into one book. Just be sure to note that it is HUGE.
   
   It contains many interesting code examples and pictures. It takes every JObject (such as JLabel, JFrame, JTable) and compares what they would look like among different look and feels.
   
   I highly reccomend it for any Java desktop programmer.

2 comments about Integrating and Extending BIRT (2nd Edition) (Eclipse Series).

1. This book is an impressive extension on "BIRT: A Field Guide to Reporting". The latter described BIRT to a newcomer, showing how to use its features. With a minimal discussion of scripting for customisation. While the scripting certainly involved programming, it was rather minimal, and most of the text showed a declarative layout approach to using BIRT.
   
   The Integrating book is the sequel. Strictly a programmer's book. It assumes you've read the earlier book. But now you need to take the customising [much] further. So here the text shows how to program in Java, not just JavaScript. Essentially, the bulk of the book explains the package org.eclipse.birt, which is freely available and has been built out with many classes. The problem to a programmer is the sheer multitude of those classes. An embarrassment of riches which the book tackles.
   
   Some classes relate to customising the UI. There is a charting API built on top of Java Swing. So you can key off your pre-existing Swing expertise. Swing is pretty easy to learn, and the BIRT graphics classes seem to continue this property.
   
   The only possible problem might be if you prefer SWT widgets for the better native look and feel. But the BIRT contributors correctly decided to support the most popular widget set, which is Swing.
   
   Other BIRT classes relate to getting data at the back end, from various possible sources.



2. It is a very useful book for anybody starting to use BIRT. However, some sections are slightly out of date vs. the new versions (2.2.2) of BIRT in 2007.
   
   The basic concepts in this book are still very useful, otherwise it is hard to find online information explained in such a systematic way and in such details.

3 comments about DB2 for the COBOL Programmer, Part 1, 2nd Ed..

1. This is an excellent resource for all those baffled programmers who need to learn DB2 fast. Thos book provides clear-cut examples, syntax, and the results of the various SQL commands that are most likely to be needed by any programmer. All the basics from simple SELECT statements are covered all the way up to ORDER BY clauses, joins and so on. A special chapter on using SPUFI was also a big help. The emphasis here is on the COBOL language and mainframe computers, but it is an excellent learning tool for anyone. The book teaches by example and can be finished easily within a week (The example programs are what make it look so big). A must-read for anyone interested in relationall databases.



2. Buy this book!!! ... I wanted
   to refresh my basic DB2/COBOL skills, so I ordered a copy of this book.
   "DB2 for the COBOL Programmer" is written in a clear and concise fashion
   which even a novice programmer can start using immediately. SQL theory and
   application are presented in a way that can only be described as inspired.
   Curtis Garvin and Steve Eckols have done an outstanding job taking the
   reader from zero to competent professional in this book. I only wish that
   more 'techie' books were written like this one (and it's companion, Part 2).



3. I use this book at work all the time for projects where we are adding DB2 to old COBOL programs. I have a little bit of SQL experience, so I generally use this book as a reference. It also helps me use a variety of DB2 features to make the queries simpler and do what I really want.

5 comments about Pro PHP Security.

1. PHP applications written without a concern for security risk cross-site scripting, SQL injection, session hijacking, and a multitude of other potential problems. This book examines how to setup a secure environment including encryption, hashing, SSL and using PHP to connect to SSL servers. The authors also examine how to install and configure OpenSSH and using it with PHP applications. Of course they also deal with the usual concerns of user authentication, permissions, restrictions, validating input, preventing SQL injection, preventing cross-site scripting, preventing remote execution (including PHP code injection and embedding), security for temporary files, and preventing session hijacking. The Pro PHP Security is written specifically for PHP programmers working in the Apache, MySQL, and PHP 5 environment and is highly recommended



2. Unless you're already very well-versed in the subject matter, ( sql injection, cross-site scripting, session hijacking, remote execution, sanitizing user data/input, ssh, encryption, ssl, dangers of shared-host scenarios, bulletproofing db installations, user verification, captchas, remote procedure calls ) this material is relatively comprehensive and valuable. Well-organized, well thought out, I won't hesitate to recommend this one.



3. The book is entitled PHP security. But the actual content covers very little PHP at
   all: less than 20 percent. It tries to cover everything from UNIX permission,SSH
   and all other security issues, but really doesn't have much to do with PHP. So I
   think the title is highly misleading. For someone interested in the general
   security issues, it might be a fine book. But not for programmers want to know
   the security about PHP.



4. Like the title states this book tells you about a lot of security issues you should be aware of, but doesn't go in depth for many solutions. Especially xss which is the only reason i bought the book. For how much the book costs i figured it would include some really good php solutions. I mean the thing is in black and white, what's with the price tag that doesn't tell me anything that i can't find on the web.



5. I found Pro PHP Security a very informative book. I received this book around the same time that I began developing online financial software. This book lived up to the name and answered a lot of my questions.
   
   I found the chapter on encryption and hashing very interesting. I knew what each system of protection accomplished but not how. Next the authors proceeded to discuss Secure Sockets Layer (SSL) and how certificates are created. It was fun to be able to create my own certificate and keys, and gain a better understanding of how the whole process works.
   
   After covering server security and connection security, the authors moved onto secure programming. The first chapter covers user input validation. This is one area that many programmers, myself included, do not devote much time. If you can sanitize the data you get from the user, you have overcome one of the largest hurdles of securing your code.
   
   After that chapter, each following chapter begins with the presentation of an exploit and how it works, followed by discussions of sites affected by these exploits, and concluding with how to prevent it. SQL injection, cross-site scripting, remote execution and session hijacking are some of the exploits discussed. This section of the book gave me plenty to think about and more than enough to work on implementing.
   
   If anyone is a PHP programmer and deals with any kind of sensitive data, then this book is a must read. The authors attempt to provide all the best practices because one method may not work in a given situation, but they also let you know the disadvantages of each method. As Snyder and Southwell discuss in the first chapter, as developers we cannot eliminate risk but we can do our best to mitigate it.

5 comments about XML for the World Wide Web (Visual QuickStart Guide).

1. 37 errors are listed on the author's site. I think I found some new ones as well. The material moves from the specific to general, so that the reader must skip around quite a bit. The aforementioned errors make learning XML very tedious and frustrating. An edit should have done - it is apparent none was. I have used Castro's books in the past and have never experienced the problems I have with this one. I recommend against purchasing this book and I hope Peachpit will not repeat the problems encountered within.



2. This book though perhaps has many errors, it is still one of the best concept books out there. This will really get you started with XML smoothly. Some of the XML standards are rather complex, and I find this to be the most palatable material for understanding stuff like XSD and XSLT.
   
   The book covers the basics of XML, how to define your XML schema through DTD, and then several chapters on XSD ("XML Schema and Namespaces") that include simple and complex types. The book follows up with XSML, usage of XPath and text expressions. Later there's coverage of cascading style sheets, XLink and XPointer.
   
   I think there should be a newer version that will make corrections and update the material. I would love a chapter on RELAX-NG, as this is becoming popular to define schema for XML in some circles.
   
   Overall, this is great book to get you started, and I would highly recommend this book as a quick spring board in the world of XML.



3. The book came fast and was in good condition. The price was really cheap too.



4. Well I bought this book when there was already a new edition on amazom which was not yet released but you could buy it and get it when it comes. I did not know that this one was old edition and that the new one with hundred pages more was on the way. It should be written somewhere on your internet pages near the old edition which would be replaced with tho new one...



5. I've read through 2/3 of the book for an XML class. This book did not provide a good picture of what could be accomplished with XML. Nor did it explain steps well. I found myself getting very confused in many places and wondering why the author did what they did.
   
   While the steps are succinct, you do need other resources to learn XML. I was very frustrated with the book.

5 comments about XSLT 2.0 Programmer's Reference (Programmer to Programmer).

1. I would not think this book is a "start learning xslt book". It is not meant to be start of with. It is a definately a great reference book for xslt 1.0 and updates for xslt 2.0. This is a kind of book in which you work your way from the index at the back of the book to the desired topic.



2. From the book's introduction: "In previous editions, XSLT and XPath were covered in a single volume. This time, they have been divided into two separate books: this one covers XSLT 2.0, while the companion book 'XPath 2.0 Programmer's Reference" describes XPath." ... "This book is intended to be used alongside the companion volume ... Since XSLT 2.0 has such a strong dependence on XPath 2.0, you really need both books."
   
   It turns out, most of the questions I needed answered aren't even covered in this book. That was frustrating for me.
   
   I later purchased the companion XPath 2.0 book. In their favor, I will say that I have never had a question about XSLT or XPath that wasn't answered by these books.
   
   However, both books are perhaps the worst-formatted reference books I have ever seen. Much of the book consists of an alphabetical reference of XML elements or XPath functions. Unfortunately, the page headers and footers only contain page numbers and chapter titles. They do not contain the name of the element or function that is described on that page. So you can't just riff through the pages watching for your function to appear in the footer.
   
   There is a heading for each element or function name, but the font used for the sub-headings are as large as (if not larger than) the major headings. There are no page breaks between functions or elements. So you can't even visually scan the pages looking for your functions.
   
   Finally, the table of contents consists largely of function or element names on the left, with page numbers on the right, separated by about five inches. But there are no dot leaders between them. So, even when you resort to using the table of contents to find the section you need, you have to use a ruler to find the page number.



3. In addition to his obvious authority on the subject of XSLT Michael Kay is one of the best writers out there. This book gives a thorough explication of the history and concepts behind XSLT that is valuable for newcomers and informative for more experienced hands. It is written for those with experience with programming languages but new to XSLT or new to XSLT 2.0. It presents thorough documentation for elements and functions, with examples of their use.



4. This is exactly what I want from a technical book on a tricky, subtle topic: it is *serious* and does not kid around. If you're new to programming, XML, declarative languages, or regular expressions: this is not the book for you. If you're familar with all those things and want to put a new tool in your toolbelt, this is the book. It explains the semantics and the processing model thoroughly, instead of just describing the syntax. It also serves as a reference for XSLT 1.0, because the author carefully indicates what features are available in which version.
   I recommend getting the companion XPath book XPath 2.0 Programmer's Reference (Programmer to Programmer) at the same time; the XSLT book doesn't cover XPath, but you really need solid XPath skills to accomplish anything with XSLT.
   Just one problem: the diagrams are really ugly. They weren't designed for print; they're jaggy and blurry. I've seen the same diagrams in other materials though; I think it's part of the XSLT spec.



5. I purchased this book primarily as a reference when I need a little more detail on a tag or function. The author has done what seems to be an entirely thorough job documenting each tag and function in a consistent and useful manner. Once I find it, the content is all I need. I have yet to read through the other chapters; I have a feeling they will provide useful insights.
   
   Unfortunately, it is all but impossible to thumb through the book to find a specific tag. Because the tags and function names are all lowercase, they appear almost identical to the next-level headings which are mixed case. A rule under the paragraph or something would have helped a lot (I have been marking each with a highlighter). I'm not sure why they didn't maintain the boldface from the TOC (see below); that would have helped.
   
   The headers and footers display nothing more than the chapter name/number and page number-- contrast this with a typical O'Reilly design (JavaScript 5th Edition) where the page headers in the Core JS Reference chapter show the first and last entries on the spread just like a (good) dictionary.
   
   So, you can expect to have to refer to the Table of Contents often. Unfortunately, there is typically 4"+ (10-12cm) of blank space between an entry and its page number in the table of contents. This would be another usability disaster except that they at least boldface the tag and function names along with their page numbers. (Hint to designer: dot leaders have been around for a while now...)
   
   I will avoid purchasing reference works from Wrox/Wiley in the future.

5 comments about Beginning Game Development with Python and Pygame: From Novice to Professional (Beginning from Novice to Professional).

1. Here's my Pro/Con Opinions about this book:
   Pros:
   - Very easy to read.
   - Great examples that actually work
   - Chapters 1 & 2 give a great intro to python, so this would actually be a good book if you've never touched python before (but did have some programming experience)
   - Lots of info using pygame+opengl
   - A lot of examples use his gameobjects library, so a lot of the grunt-work coding is available to use already.
   
   Cons:
   - My biggest complaint is the lack of discussion on Sprites. Pygame is really a 2D library, and I think he left out a lot of very important information by not discussing how the Sprite class can be used.
   - Only cursory discussion Sound. If you're writing a game and just want the basic sound effects and/or background music, this is ok. However, if you want to do something really interesting with sound, you'll need to dig way beyond what this book offers.
   
   Overall, I think the book is worth getting unless you've already done
   a few significant projects using pygame. It's definately an Intro
   book, and it does a really good job giving the user an idea how to put
   a project together.



2. I wanted to write some simples game for my 3 yr. old son and looking for starting point as I don't know anything about Game programming. I am halfway done reading the book and so far I find this book very useful. The chapters are well laid out and I feel encourages to read page after next, unlike some 500 pages books that goes too far to make one sleep or loose interest. I am assuming some advance game programmer may expect more but a novice like me found this book very helpful and I found the information that I was looking. I think both me and my son will make some use of the money spend on the book



3. I have to say up front that I fit the "Novice" part of the title for this book, but if the book is really intended for such an audience then my review may be helpful for those in the same situation... What I am a Novice at is Python and Device driven programming. Although this is really a very good AND much needed book for the much under documented Pygame library, it missed an excellent opportunity to provide a novice level tutorial in "device driven" programming as supported by Pygame. Although it is possible to muddle through to an understanding (much as I did) by thinking through the implications of the example code, it leaves a lot to be desired to provide a working basis for a real "Novice". As an example, the need to know the function of the lines of code "while True:" combined with "pygame,display,update()" and what they mean about the code that lie between them is really crucial to getting any code using the library to work at all. Although this is addressed to some extent, I found quite a bit of experimentation (on my part) necessary to discover what code needed to be included in this loop and what did not... I hope Mr. McGugan , with his excellent writing skills and obvious enthusiasim for this kind of work, will soon provide us with a second edition that will provide us with more insight into how Pygame actually works, so we won't be programming by rote...



4. I bought this book for my son a few weeks ago. He likes the book and finds it helpful. But the book is falling apart at the binding. Very disappointing.



5. Ch3-6 provide a nice introduction to the basics of writing simple programs in pygame. The example code in these chapters was clear and effective at demonstrating the particular topic. Overall this book was helpful to me in developing a pygame centric design flow for the programs that I am writing.
   
   I would recommend this book to help in jump starting your understanding of this useful python module.
   
   Bryce Himebaugh

5 comments about Foundations of Python Network Programming (Foundations).

1. Apress has two books on Python that I really like. This one and "Dive Into Python". The thing I like about this book is it delves into some deep concepts, like client/server code, but does so in such a way that even people new to Python should have no problem understanding it.
   
   I have been a programmer for about 15 years, and made heavy use of Python for the last 5 or 6 years. My brother is new to programming. Both of us found this book to be very useful and easy to understand. I recommend it to programmers of all levels.



2. This is a well presented, well paced introduction to network programming in Python. He presents programs both as interactive sessions (follow along in the comfort of home) and as scripts (programs) available to download from his web site at Apress.
   
   It serves as a good, general purpose, introduction to network programming as wall as a Python-specific network programming tutorial.
   
   I do, however, have some complaints. Although the author attempts to present information in a platform-neutral manner, it is obvious that he is much more familiar with *nixes than with Windows. There are several minor factual errors in the Windows information he presents. [I have submitted these as error reports on the Apress web site.]
   
   Fortunately none of these disrupt the actual presentation. Experienced Windows programmers will be able to correct the mistakes on-the fly. As a minor example, Windows programmers know they can type "script.py" to run a python program even though Windows doesn't honor the #! line at the beginning of the script.
   
   My other complaint has to do with the use of PyDNS to discuss DNS issues. As far as I can tell PyDNS is dead, or at least it is dying. dnspython would have been a much better choice. However given that the book is three years old, I can't really fault the author for picking the wrong package -- it's happened to all of us at some point in our careers.
   
   And a truly minor quibble: he starts with an example of downloading a file using the gopher protocol. Do you have any idea how hard it is to find a gopher server now days



3. It has everything you need to know about Networking Programming in Python. Easy to understand also. It can be made more detail and more advance for profesional use.



4. I'm giving this book 5 stars because I found it more useful than many books. There are some flaws, but overall I am happy that I own this book.
   
   This book uses a teach by example technique as discussed in other chapters. It is oriented towards application developers that find themselves in need of python networking rather than networking people that need python.
   
   The book is overall clearly written and the examples are generally interesting. The author shows an advanced understanding of most of the subject matter. Chapter strength is fairly variant. On the other hand, it's pretty likely that you do not have knowledge of all the topics in this book and will learn something interesting by reading it.
   
   Cons: The chapter on HTML tag matching felt really weak. They tried to treat HTML as a regular language by using state machines to match it, when it's clearly context-free, then he started to add a stack but he had already lost my interest as the examples got fairly unwieldy.



5. I have no background with Python and limited understanding of networking. So my comments are from a rookie. So here they are:
   
   1) Readable: technical enough but gets right to implementable examples. You can jump around in the book and find what you need with out having to read the whole thing.
   2) Applicable: I used examples from the book to gain an understanding of my Linux system and my home network.
   3) Python is free so use it.
   
   That is all.

5 comments about Programming the Perl DBI.

1. It's hard to imagine an entire book about this. It's not bad, for what it is though. If you have any database knowledge and read the appropriate sections already in Programming Perl or the Perl Cookbook, I don't imagine you'll get too much use from this.



2. This book has been a valuable reference of mine for several years for web database programming projects. I bought the book soon after it was released and continue to use it - sometimes on a daily basis depending upon the project I am currently developing. I realized from the beginning that much of the material in this book came from the online documentation and have still found the book to be useful enough to stay on my A-list of reference materials. Applications like CGIScripter need to utilize up to half a dozen different databases so I have found the reference section on each database be the section I often turn to first. I have not found this info available anywhere in the online documentation. When you program and debug on multiple computers with multiple windows open simultaneously, having a reference book is often more manageable than opening another window on the computer. And for those times when I am struggling with an especially troublesome programming issue, I have found it very helpful to sit in my easy chair with a reference book like the Perl DBI book in order to research the problem. The only reason I am not giving the book 5 stars is that it hasn't been updated in a few years so it doesn't include info on some of the new DBI supported databases like SQLite.



3. The database-oriented view of programming has become increasingly popular, and it is of great importance for all serious programmers to understand how to use their favorite language to manipulate the database systems. With the variety of database systems out there, it can be a real challenge to learn what there is to know. For the Perl programmer, however, there is this book on the matter, and it will probably be all you'll need to get started working with database programming in no time. Other reviewers have stated that this is a regurgitation of the docs. This is partially true. But the docs are very bland, and this book presents the information in a much more informative, and easy to read manner. With it, you can begin programming the DBI within a week (a day if you already know SQL and skip the chapter on the Berkley DB system). Recommended for anyone interested in learning how to use Databases with Perl. If you already know the DBI, the book wont be of much help, maybe as a reference, but I'd only pick it up if you don't know it, or are still inexperienced at it.



4. This is a (the definitive) book on Perl DBI. I swapped book-for-book with a former co-worker for this. I keep it in the office for the newbies.
   
   If you're already a pro at PERL, you should be able to get by with just the CPAN documentation. However, if your employer is footing the bill, get it. :-)
   
   However if you're new to PERL and need to use DBI, get it.
   
   Very nice tips and tricks you can pick up, even a few for the pros.



5. If you are serious about using Perl to interface with any database, then this is the only book will will ever need. Amazon was the only place I could find a copy, since the book is currently out-of-print.

5 comments about Java 1.5 Tiger: A Developer's Notebook (Java 5,Version 1.5).

1. This book delivers on what it promises - quick and dirty introductions to the new features of Tiger. It does a great job of getting one familiar with all of the new features, though, as noted by other reviewers, it is not intended to be an in depth reference. The chapters on generics and concurrency could certainly be deeper, but the book provides a good grounding in the basics, opens the door to more complete study, and provides enough sample code to get one writing code.



2. First off, i sincerely appreciate O'Reilly on their innovative idea of a notebook series. This series is targetted towards busy developers who dont find the time to crunch through big fat books and learn about every grain of sand; rather they would spend less time and learn what is absolutely required. This is certainly a welcome concept.
   
   That said, this book is about the new additions that sun incroporated into java 5 (Tiger). Yes, there are so many additions that it requires a book in itself. The author covers all the significant additions like Generics, Enums, Autoboxing, Varargs, Annotations, Enhanced For-Loop, Static Imports, printf and Threading. Isnt that a mouthful? Yet, he covers them in under 200 pages. That in itself is an achievement. Also, the conversational tone and the humour with which the author writes makes the text very interesting.
   
   Now, for the bad news. This book is edited pretty poorly. There are a lot of typos both in the text and code. I understand that, this book is conceptualized saying that it is a scribbling of an alpha geek who takes down notes as he researches new technologies. But, that doesnt mean that we get to read the same scribbling without even getting edited, though we pay for it.
   
   More than the typos, the author establishes certain technical claims, which are both wrong and misleadging. For example, the author claims that it is IMPOSSIBLE to use the enhanced-for-loop for generating a comma-seperated string from a list of strings, where the resulting comma-seperated string doesnt end with a comma, so as to display formateed output. The author justifies this by saying that a developer doesnt have access to the counter variable in the enhanced-for-loop. Though i agree that we dont have access to the count variable, the use-case is ofcourse possible. This piece of code can be used to achieve what the author claims IMPOSSIBLE.
   
   import java.util.List;
   import java.util.ArrayList;
   
   public class CommaString {
   public static void main(String[] args) {
   List numList = new ArrayList();
   numList.add("1"); numList.add("2"); numList.add("3");
   
   String numStr="";
   for(String num: numList)
   numStr = numStr.equals("") ? (numStr+num) : (numStr+", "+ num);
   
   System.out.println(numStr);
   }
   }
   
   This may not be the most efficient implementation, but, it atleast proves that what author claims as impossible is rather possible. There were some statements like this in the threading chapter as well, where the author compares synchronized keyword and lock. So, beware not to always go with author's opinions, but ofcourse, the technical content can be trusted.
   
   In the end, i would say that this book achieved its goal by neatly summarizing all the significant improvements/additions in tiger and we sure can learn every feature from this book. There are some issues, but it will not affect the overall value of the book as long as you dont overlook them.



3. This is a great book. If you know Java 4 and you want to upgrade your knowledge, this book is short-and-sweet -- only 170 pages. It tells you quickly what is new in Java 5 so that you can make the transition from Java 4 prograamming to Java 5 programming.



4. There's nothing in this book that you couldn't find on Sun's website, but it's a good quick reference book.



5. This book delivers most of what it promises to, which is a good introduction to the latest and greatest features of Java 1.5 Tiger. Considering the extent of changes Sun introduced in the new version, I think the authors did a decent job explaining them. If you are new to 1.5 version though, you would probably need to read another book that explains the concepts in greater detail.
   
   My only complaint is with the "Threading" chapter which was full of of API methods instead of letting the users know the concepts behind the changes. Looked like the authors were in a hurry to get the book finished and the "Threading" chapter got affected.
   
   Overall, it is a good read.