Variants Books

Let me start by pointing out that his target audience includes people who currently develop Java web applications. So its fair then to say that if you are new to JSP and servlets, this isn't quite the book for you. So forget about getting any hand holding with setting up a servlet container or a gentle introduction to JSP actions.

That said, if you know the top end of a web application from its bottom one, and you want to get up to speed on JSF, you're in for a good ride.

1. Architecture (5 out of 5)
--------------------------------
This book shines in the area of general architecture. And, I can't say enough good things about Kito's diagrams.

The first diagram of note provides a birds eye view of a JSF application. If you take the time to read through each textual element in the diagram, you'll get a very comprehensive view of your application's place in the world, when implemented using JSF.

His basic introduction to HTTP and Servlets is just that - basic. But his discussion on what frameworks bring to the table is a must read for web developers. That section culminates in another worthwhile diagram - this time a depiction of web application infrastructure as a stack of services. You can clearly see the benefit you accrue from using JSF, vs. say coding using the servlet API. It overlays Struts on there as well, so you get a nice comparison of the two frameworks.

His first application requires a leap of faith. There's a lot of code here just for a simple Hello World application, and its hard to follow along without a reasonable knowledge of what a standard JSP might look like, so you can spot the differences introduced by JSF. It doesn't help that this basic application starts out of the gate with a roar - you're dynamically adding controls to a component using an action listener! Not good.

His class model of the various JSF components is another must see. Its a very informative overview with the UI Component as the center of attention, surrounded by its minions.

The second chapter is another gem - it provides a detailed description of the various classes that comprise JSF. There's a lot to take in, so you'll find yourself returning here after you've read the rest of the book, to help everything fall in place in your mind.

One thing I had difficulty with was that the topics seemed to jump from low level to high level and back again, leaving me a bit winded. The net result is that I couldn't read this very linearly, and had to backtrack ever so often to find my bearings.

For e.g., the first time you get to building a JSF web application is over 100 pages into the book. Fortunately the structure of a WAR is well known, especially to the target audience of this book, so there's no surprises here, other than to note the specific JARs that are required by your JSF implementation.

In the spirit of the topic organization of this book, one of the most engaging chapters on high level architecture is placed right at the end (chapter 11). There again you find a diagram that maps all of JSF's application classes, grouped as component classes, context classes, application classes, and event handling classes. This chapter is a must read as it provides in depth coverage of the APIs that underpin the JSF classes.

The UI Component's singular importance in JSF is honored by an entire chapter. A table classifies components by family (input, output, etc.), JSF implementation class (UIInput, UIOutput), and HTML subclass (HtmlInputText, HtmlOutputLabel).

The components are treated well with the standard components described in sufficient detail. In a rare fashion, he provides examples of how a component tag is rendered as HTML, and presented in a browser. This gives you a clear picture of the additional scripting that is added for a component.

This includes single- and multi- select controls, and their data models set via UISelectItem instances and UISelectItems.

2. Request Processing (5 out of 5)
--------------------------------------
The life cycle stages are defined clearly and precisely. Its hard to think of any information that might have been missed.

A key concept is that of component and client identifiers - which defines how naming containers influence the name of a child component in the rendered HTML code. This is very clearly portrayed, by yet another diagram that maps the component tree on the server to form components on the client.

All in all, a very satisfying tour of the life cycle.

The coverage of converters and validators is just as complete - including creating custom converters and customizing error messages using message bundles.

3. Templating (4 out of 5)
------------------------------
JSF implementations must support JSP as a templating technology. It's a rare book that doesn't cover the use of JSP actions, custom actions, and JSTL within a JSP page adequately - and this one doesn't disappoint. A key issue with JSP/JSF is that there are certain constraints with using JSF/JSTL tags (such as the tag) - and these are called out adequately. While the coverage is decent, this is not a book on JSP, and it shows.

4. Navigation and Event Handling (3 out of 5)
-------------------------------------------------
This information is spread out across multiple chapters - not something that I prefer. While no details are lost its still a bit of work to piece together the whole story. For example, the default ActionListener is covered a number of chapters away from the topic on declaring an action listener.

5. Miscellaneous (5 out of 5)
--------------------------------
Interestingly, this is one of the rare books that addresses a rarely considered concept - which JSF implementation should you choose. The RI is a reasonable choice, but the larger question is when an alternative implementation such as MyFaces would be preferable.

The Managed Bean Creation Facility is an interesting implementation of inversion of control - much like Spring - where a configuration file drives the creation and initialization of beans. He actually provides guidelines as to which objects should be constructed using this facility, and which ones would be better served by initialization at web application startup - say using a ServletContextListener, so as not to incur inordinate delays in the middle of a user's interaction. And there's even an example later on in the book, if you didn't get the hint.

Internationalization coverage is pretty complete - in terms of configuration in faces-config.xml (and a warning that without these locale-config elements, the JSF implementation may only support the default locale of the application's JVM); determining the user's locale (using the tag, Java code, or the browser's locale settings); and creating resource bundles to house your locale specific properties.

This book is peppered with relevant tips such as the warning here that you can't use the "." character in resource bundle keys.

On the client side it describes the use of , especially the use of the basename attribute and how it is set based on where in the classpath the resource bundle is located. For bundles located in WEB-INF/classes no prefix is necessary - since that's the root of the classpath. However, bundles any deeper than that require to be prefixed appropriately.

Another rare topic for a JSF book is the creation of a global error page and registering it in web.xml and as a global navigation rule.

Finally, there's an example of the use of a servlet filter for security.

6. Examples (3 out of 5)
----------------------------
While I typically don't favor overblown monolithic projects that require you to follow along across multiple chapters, the provided example has all the bells and whistles of a typical application you might encounter - including user roles, workflows, and a common toolbar component.

In addition, Kito provides a really interesting approach to application development - by starting out with a dummy user interface using hard coded beans and static navigation outcomes, and slowly evolving the application.

The result is a bit mixed - the first couple of chapters flow wonderfully. However the latter chapters of the examples felt a bit hurried in their execution, especially once we're into the more difficult aspects of JSF development, such as backing bean design.

7. Conclusion (overall score: 4.5 out of 5)
-----------------------------------------------
You'll be hard pressed to find a book that has such excellent coverage of so many diverse topics - many that are not JSF specific.

You'll also find gems of practical advice throughout the book - for e.g., that you have 3 alternatives as to where to place your action methods (in your backing beans, within independent action classes, or within service classes) along with the tradeoffs associated with each.

A couple of reservations (albeit subjective):

I'm not a big fan on how the topics are organized. As I read this book, I had to keep jumping back and forth - many many times, and that got to be very tiresome.

I typically like related information to be as physically close as possible, preferably within the same chapter. It is hard to use this as a reference book given the geographical distance between related concepts. This may actually fare better as a search-able e-book.

The example application is very comprehensive and well thought through. However, the example is built over multiple chapters, and the latter chapters are not as coherent as the initial ones. I found the change of pace a bit unsettling.

On the whole, though, its been a satisfying read.

Damodar Chetty (swengsol.com)

I agree with some of the reviewers that this book has too many typo errors. Some of the errors are so obvious that they make me wonder whether the book has been proof read before it goes into printing. There are also obvious discrepancies between the code listing and the accompanying explanation. For example, in a few examples, the code listed one thing and the accompanying text just after it refers to something that is not found in the code listing or contradicts the code listing.

The upside about these typos errors is it kept me alert when I come across something that doesn't make sense. It also helped me in my understanding of JSF as I identify and correct the errors.

Nevertheless, it could have been a much better book if it has been professionally proof read and edited.

This book does not compare to "Core Java Server Faces" first edition by Geary and Horstman. The book provides fery few and not very useful code examples. The content is not very organized. Also, it does not address more advanced topics such as displaying very large result sets.

The book is nice in overall but the examples should be better.
Core JSF is better and I recommend that one over this.

I purchased this book based on my previously great experience with Manning Press books. I've found other books by this publisher to be easy to read and easy to comprehend. They usually give you just enough background information and then details on different aspects of the subject matter. This book just goes on and on and on about background information and implementation details that are of little use to anyone after they configure their first application. It takes too long to get to the meat of writing JSF applications. And once you get to where the meat is supposed to be, most of that has to be downloaded as a 300 page PDF from their web site. Not very useful at all.

If you are looking for good JSF information, I now use the Core book for information and the O'Reilly book for a quick API reference. If you want examples of great Manning Press books, please check out their "Spring In Action" and "JSTL In Action" books. Both are fantastic reads and full of great information.

Sadly, this particular book left a lot to be desired both as an instructional text or as an API reference.

I bought two books at the same time when I start to learn rmi. One is this book, another one is "java.rmi Guide".
Before I start, the second one seems more attractive as its name implies,so I decided to use "java.rmi Guide" as the main book, use the Distributed programming with Java only as a reference, but when I start learning, I read the "java.rmi Guide", I was totally lost, the book full of concepts with few examples.
So finally, I spent most of my time on "Distributed programming in Java" because this book not only explains the concepts very clearly, but also gives out many good examples. At least, when I read it and run the codes in this book, I know what I am doing and why.
As some readers suggested: maybe the java.rmi Guide is good for experienced, but not for beginners.
For beginners who want to learn RMI and CORBA, "Distributed Programming with Java" is the most appropiate book for them.

I have been looking for a good book to learn sockets programming. I saw this book @ BN and I liked the stuff on sockets. I bought it and I have enjoyed the chapters on sockets programming -- cool stuff with lots of sample examples. There are some minor errors here and there but it was worth the money.

I bought this book for its coverage on RMI. When comparing similar books at the bookstore I simply bought the book with the most pages of coverage for RMI. Well, I made a terrible choice. I've read and reread the coverage of RMI in this book. It IS frought with errors and the coverage of the topic is shallow. Examples are presented without sufficient explanation (besides containing errors). If you want to learn RMI, PLEASE STAY AWAY FROM THIS BOOK!

The book was a required text for a 4th year course at my university. I bought the book and I found it to be great. The stuff on sockets and RMI is superb -- provides implementations for several protocols.

I am new to network programming. I bought this book to learn about it. I like the book very much. The easy-to-understand examples throughout the book are very helpful in understanding network programming. Well written.

I think this book is fantastic. I've used this book for coding standards and just to generally improve coding techniques. While it's not quite as good as Refactoring I think it's a good introductory level book with enough content for intermediate programmers.

Being a code style book it's nice to see well laid out code. The explanations are thorough although sometimes confused. Of course, he dodges the curly brace question.

I wrote Essential Java Style six years ago. At that time, Java was still a new language, yet lots and lots of poorly written code already existed.

Today, there is significantly more poorly written code, and unfortunately, only proportionately more well-written code. It seems like we haven't learned how to write maintainable systems in Java.

I wouldn't change much of the core message in EJS were I to do a rewrite of it. But I would emphasize the three central "patterns" even more: Composed Method, Naming, and the Comment antipattern. Using only these three guidelines as a basis will immediately improve the maintainability of your system.

A rewrite would certainly include more detail based on my experiences in Java. More dramatically, however, the core message would be tempered with the admonition to always write tests for your code. Through test-driven development (TDD) I've found that it's very easy to get into a good habit of keeping your code clean.

To answer some of the review comments:
- the book states the obvious only to those who know what good code is already. Unfortunately this is less than one in five developers.
- I admit that it was intentionally subtitled with the word "patterns" to attract more attention. The material presented within *is* in pattern form.
- a few readers complained about non-standard style. There were only two things that were supposedly non-standard: brace placement, and the use of underscores for fields. Honestly, there is no absolute standard for either of these.
- the book takes a lot of ideas that work well in Smalltalk and applies them to Java. For the most part, this is a valid approach. I'll admit thought that the Smalltalk-like collections approach, unfortunately, isn't a great fit in Java; I no longer bother with them.
- I counted the number of references that denigrate the Java language (mostly for being slow). There were 6. Chalk it up to a sense of humor and frustration at an immature language.

Thanks if you purchased the book! I still see people's references to their dog-eared copy and their happiness with the extent to which they've taken the ideas to heart.

The "patterns" in the title of this book refers to a collection of coding principles for translating object-oriented designs into Java programs. This is not a design patterns book, but rather a book on Java style, usage, idioms, and best practices.

Because the author comes from a Smalltalk background, the patterns are highly object-oriented. This may be disorienting to developers from a C++ or procedural background, but the longer I program in Java the more I'm convinced that purer OO code is better code. Developers who use UML or object modeling in the design phase will get the most mileage out of this book.

One of the main uses of the book is for use during code reviews. The patterns are named so that you can say "this code should use the Default Value Constant pattern" rather than "I think rule #87 should be applied here". Some of the patterns will be obvious to experienced Java programmers, but are included because many teams have junior programmers who are new to Java. Unfortunately, the book is not organized so that you can quickly find the discussion of a particular pattern. The Pattern Summary does not include page numbers and the Index includes all page numbers where each pattern is mentioned, without bolding or italicizing the pages where the pattern is described.

There are a number of idioms specific to Java that are not covered well in the book. The section on equals does not cover the important case of implementing equals in subclasses and doesn't mention that hashCode should be consistant with equals. There is no coverage of using clone to make copies of objects. In addition, there is a significant amount of outdated and incorrect information. I would recommend using this book in conjuction with another book on Java idioms, such as Effective Java or Practical Java.

Much of the book is distracting because the author continually points out the "deficiencies" of Java. I do agree with many of his comments, but they serve no purpose in this book and quickly become irritating. The frequent comparisons to Smalltalk and C++ are also of little use. I did find that the brace and variable naming conventions did not adhere to Sun's coding conventions, but other than that the book uses standard Java programming style.

Overall, the book is a good one, but I look forward to a new edition that is expanded, corrected, updated, and doesn't have so many useless comments.

When I first read this book it was hard to keep an open mind. The author constantly compares Java with Small Talk. Unfortunately in keeping an open mind I over looked the bad coding style. This could have been an excellent book for beginner programmers that wanted to write professional code. However, the author writes code in the style of C++ and Small Talk. The author's code should not be used as a template, which is what most beginner programmers will do. Another problem with this book is that the author has made assumptions that all the techniques he has learned from other languages will work the same way in Java. This is not the case. While this book does contain some valuable techniques, I believe that the poor coding style and the author's lack of understanding of Java will mislead beginner programmers. Therefore I can only rate this book 1 star.

I guess the author didn't think his book would sell without the word patterns in the title. This is not a patterns book. It is a book of very basic coding techniques that every junior programmer should be taught. However, I have to agree with a previous review that this is 'Not Java Style'! The author uses a non-standard style, at least not standard Java style. If you decide to read this book be prepared for the incessant comparisons to SmallTalk.

This is an okay book for those who are beginners in the Java language. I wouldn't recommend this book because there not much meat in the text. Even if you have never programmed before, this book just doesn't give much to work with. The book mostly focuses on simple code and java background, not really useful for more than just getting your feet wet. I would suggest another book that has more complex and useful java code.

This book is a aimed at the terminally retarded. The simplicity of this book is beyond belief. The worst part is that in an effort to be ultra-simple, the author is just flat wrong. Anyone who can't explain the difference between a class and an object should not be allowed to write a book on java. This book is a total waste of money

The book contains straightforward, economical explanations that cut directly to the point. Ms. Smith's explanations of what constitutes an Object, an Instance, a method, instance variables, and the Class, are the best I've seen, and I've been programming for many years.
I appreciate also that, while the book is very clear and friendly, it does not insult the reader's intelligence.
I am reminded of a quote by Einstein. He said, "If you can speak of technical things only in technical terms, you do not understand them." That Ms. Smith has explained Java in such direct, common-sense terms proves that she indeed possess a master's understanding. We are indebted to her for sharing it. You will learn a great deal from this book, and you do so virtually effortlessly.

It's hard to find a book at the right level for me--I know how to program in C++, so I didn't need a lesson in loops and decision structures. I needed to learn how to use AWT components, and all the other books I have don't talk about applets and GUI components until the end of the book. Most books are pushing Java2, which isn't even supported by the compiler or browsers I have! This book is perfect! It assumes programming experience, but it doesn't assume any Java knowledge. It really gives you a QuickStart--getting down and dirty with code right away, but not biting off too much at one time! It stays with Java 1, which is what I needed. Dori Smith is a fantastic teacher. Her style and wit and choice of topics and sequence were superb. The appendix, explaining the new event model of JDK 1.1, finally showed me what all the other books had been confusing me with.

I don't feel this book covered the fundamentals of Java very well, and I think if you are new to learning it this book would confuse you more than help. I was very disappointed in this book and I am a fan of the "visual quick start guides " I also start with them first and work my way through the books. This one in particular did not live up to them. I guess they can't all be winners. Unless you really already know Java and even then you will not understand the purpose of the book. If you are new to Java don't start with this book.

I've used this book for several months now - and there are just too many mistakes in the text. Mistakes that will lead a J2EE component developer to make design/coding mistakes that will take a lot of hard work to figure out.

For example: page 217: Introduction to Entity Beans
"Rules for Implementing ejbFinder methods" ...
"The method must not throw the java.rmi.RemoteException"
Note: the NOT - wrong - it must declare that it throws RemoteException!

This is just one of many examples - and if you check the errata on the web site - it doesn't contain very many of the mistakes (not this one) so one is left with very poor misleading information.

Do technical books not get edited by technical editors? Demand better books - vote with you money - buy a different book! Or buy mine use - I'll sell it cheep!

This book is probably one of the worst EJB book one can buy. It's short on theory and long on practical using Sun's J2EE. There are a lots of books better than this one. Eg "Professional EJB", "Mastering Enterprise JavaBeans". Both of the above books is very good on theory. For more practical book "Sam Teach YourSelf EJB IN 21 Days" is much better than this book.? Why because it uses weblogic 7 for the practical. Even though it is also short on theory but at least it's exercises are usefull in the sense you learn how to use it in Weblogic 7.0. Lastly, I am writing these negative comments about this book because the more pages I read from this book, the more I felt I got cheated.

As a recently unemployed Java developer, I was at a local Borders looking at EJB books to update my skill. I picked several EJB books and then sat down with a coffee to find a easy to understand and a practical book. In my opinion the EJBs are too complicated and I was looking for hands-on book with step-by-step guide and this book was it. I was able to understand and start writing stateless session bean within few hours. I liked the fact Mr. Tulachan used Sun's J2EE Reference Implmentation, which is free, small and easy to use unlike commercial application servers that take over 150MB of disk space and require atleast 256MB -a bit complicated and difficult to use for a beginner like me.
The only negative from my perspective are the typos so be sure to download the errata.
As a beginner I found the step-by-step approach to EJB development very helpful and I hope it will also help me get a job as an EJB developer soon....
--raj

I wish the author spent more time on the quality of the book and its contents, as opposed to just getting it out the door for JavaOne. I found it really annoying when I downloaded the errata of the book, it needed an errata itself too....

Even if you only want to learn the reference implementation (which is what most of the book is all about), you'll have to compile/deploy the examples by trial-and-error. Correction for most of the technical errors have not made it to the errata either.

Reading this book is not a very pleasant experience. There are so many typos that I actually stopped reading after 1/3 of the book. I really do not understand how Sun can publish such a book.

A little technical note (to justify the title). It does not really teach you great (or even average) insights into EJBs. No real techy info on what the consequences are of using CMP vs BMP (only info from the spec),...

It basically is just a rehash of the spec. The examples are for the Sun reference implementation, which would not be that bad if it wasn't half of every chapter (I want to learn EJB not a how to use a reference implementation which is not made for running in production!). All the advantages of EJBs are straight from the Sun EJB marketing book.

O yes one plus: it does mention EJB patterns.

Let me start off by saying, I had very high expectations of this book. The author had written "Visual Basic 6 Black Book" which was an excellent book. I bought this book based on this previous experience. Unfortunately, this book was not up to the standard set by the author's previous work. However, this book does have its merits.

I found the sections on applets and frames useful, as well as the discussions on AWT and Swing (I wish it had done a better job at explaining the layout managers). I also found the sections on file I/O useful. I do agree with an earlier reviewer that this book is lacking in its discussion of interfaces. I found the examples the book gave for interfaces to be contrived and not useful in explaining the concept. In general, I have found that the examples many times demonstrated bad coding techniques which was probably done to simplify the example. Just keep this in mind when writing your own code.

As a reference, this book can be useful. When introducing the Java classes, a comprehensive list of methods is provided; but I have found Sun's online documentation a better (and more complete) source for this type of information.

Overall, this is a decent book. It can be helpful sometimes and infuriating at other times.

Thank you. This book rocks. it covers almost all the stuff that i need from work.

This book was hard to track down but I did manage to find one on the west coast. It was worth every penny spent on it. Great reference book to turn to when you are just needing a refresher or even better if it is a completely new subject for you to learn. 5 stars plus!!!

Java 2 Black Book is an awesome reference book! The author does a good job at covering most of the details of Java programming. There are a few subjects missing from the book, but if you are using this book as a reference for Java, chances are that you aren't ready for those subjects anyways. Sometimes finding a code example is easy and they are plentiful, and other times they are not what you are looking for. It's kind of like hit and miss. I recommend this book for all beginner to intermediate Java programmers.

This isn't really a tutorial; it's a reference. In fact, it seems like most computer books I pick up these days are references. That's understandable: a tutorial is much harder to write than a reference. (It's probably harder to sell, too, since a tutorial has to be pretty squarely aimed, so I don't necessarily blame the author.) Of the 1,000+ pages this book, I'd say half just list all the attributes of Java objects, and a good portion of the remaining page consist of code listings showing help-file-level examples of how to use them. In cases where things are built up incrementally, often an entire page of code is repeated to show one or two new lines.

It'll definitely boost your ego and possibly your reputation among those who might be impressed by your "reading" of a 1,000 page book in a few hours, and it won't hurt your Java skills. But you won't see any serious Java programs in here either, or learn how to make them, or learn anything about object-oriented design--a pretty important topic if you're going to work in Java.

This Black Book is constructed in the form of a running dialogue between yourself--apparently a master of Java already--and a gallery of irritating "characters" like the "Novice Programmer", the "Big Boss", the "Product Market Specialist", etc. Sometimes these dialogues have the right hint of smat-alec, but by page 500, a sense of deja vu sets in, and they begin to seem like a crutch.

There are some seriously irksome things about this book, too. A third or more is dedicated to the "Advanced Windows Toolkit" (AWT) of Java. OK, no problem. Java's "Swing" system has taken over from that, but you might still use AWT, right? Except the Swing section begins with a discussion of how bug-ridden AWT was. What? How can I have read a book's worth of material on a subject and this be the first I've heard about the bugs?

Swing is relatively glossed over, but not as badly as interfaces, threading, beans, and a bunch of other topics where reading a list of attributes does not give you a good sense of how to use them.

I expected a lot more from a Coriolis Black Book.

Although it's several years out of print, I haven't found a better introduction to J2EE textbook and thus, am still using it in my classes. Think it's not worth it? ... better buy one fast because the price of the used ones is going up instead of down.

Another remarkable feature of the book is that the original code still runs fine on Tomcat 5.

Multi-author? yes, but since one of them is Rod Johnson, it also has historical relevance. No, I'm not associated with Interface21.

I got mine for $5.99 at a "Building #19" store in MA. Although it's quite dated (J2EE 1.3 - EJB 2.0, JSP 1.2 and Servlet 2.3) there's not been too many changes to J2EE 1.4 (1.5 though is a whole different matter with annotations and the "back-to-POJOs" approach). I'd still pick up a copy if you can get it cheap and before J2EE 1.5 goes mainstream.

This product listing does not allow normal sellers to list their item here. Thus, the prices for this book are higher than they should be, because a few preferred sellers are able to monopolize the listing. If you want to buy this book, click on the "other offers" link below the usual "used & new link". Normal sellers are selling the same book for a lot cheaper.

This is overall a good book. The earlier version of the same book was better because it had more diagrams, more examples, more chapters, etc. This book lacks the meat contained in the previous version, including fewer pages and smaller font size. Don't know why these enlightened authors have taken this step... So, think twice before you buy this book...

This is overall a good book. The earlier version of the same book was better because it had more diagrams, more examples, more chapters, etc. This book lacks the meat contained in the previous version, including fewer pages and smaller font size. Don't know why these enlightened authors have taken this step... So, think twice before you buy this book...

Definitely a "Java Geek" must-read as you'll uncover a lot of performance results that you might have assumed would be very different - however due to API implementations and/or JDK changes you get unexpected results. With Haggar's "Practical Java" you've got two good books for Senior Developers to help avoid performance and scalability issues in code. Probably the conclusions in the book need to be verified under newer JDKs 1.3 and above, as so much has changed since this book was released

After I read thought the book, i found many bad practice mentioned in book occured in my current project / previous project. And it ready solve some of my problem at work... So i say this is practical book .....

There are many good tips and tricks in this book but thats where it ends. I expected a bit more continuity on issues definitively surrounding server side development. It seems like it competes with "Effective Java" which the title does not imply.

I have to work with Chinese, Pakistani and Indian programmers who were handed a copy of "Learn Java in 24 hours" Then they start hacking on my project. This book helps me fight with them when they do stupid things over and over. I already knew 90% of what is in this book, but it's nice to have everything laid out for you clearly. Where is Volume 2?

This book covers the basics of improving the performance of server side java programs by writing different java statements. I like the fact that it had just the answers, not excessive amounts of padding. I especially liked the chapter on taking an existing, well written java program that was a web server, and optimising it in several stages. The stages were consistent with the optimisations discussed in the preceding chapters which helped put it those chapters into context nicely. The optimisations turned a good web server written in Java into a much faster one, which was good to see.

I describe this as a "basic" book on optimisation because the chapter on RMI was rather light, presumably because of the 80:20 rule wereby the biggest gains can be had with the simplest of coding changes. Going into more detail would have made the book thicker so perhaps it was best it was left as it was. There is perhaps an opportunity for someone to write an "advanced" version at some later stage.

I'd recommend this book to someone who is an experienced java programmer who wants to make their java programs run quicker. I certainly found it useful in my own java programs.

For someone already familiar with C type programming this is probably an excellent book. It has lots of examples, great linked online resources, a pretty good index, and is one of the most error-free technical books I have read in 5 years of programming. However, this is NOT the book for those with no C (or maybe VB) type programming background.

The authors jump right in using the Java language. While this makes it more interesting it leaves non-C programmers to wonder about the constructs. Examples area great IF they explain everything new that is introduced. For example, the following are used in the first part of the book:

String[ ] args
String args[ ]
String[ ][ ]

But it is not until nearly halfway through the book (end of Ch 4 of 10) that array constructs are discussed. And even then I don't recall any discussion of the difference between the first and second example above. Another example:

Sleep((int)(Math.random() ...))

What is this? Casting maybe? Casting is not even in the index so you just have to guess.

This book needs 2 things to make it excellent: First, an appendix that clearly and thoroughly explains the constructs, syntax rules, and naming conventions - all in one place. For example, what do the curly braces signify, why are empty parens or empty curly braces or semi-colons used, when do you use String[ ] args vs String args[ ] - the works. Secondly, it needs more comments in the examples, including the reasoning involved (eg why variable was declared outside instead of inside method) and an explanation when anything new is used. Admittedly, experienced programmers will not want heavily commented examples, so making those available on line would be a good solution.

Before you buy this book, go to your local bookstore and read the second chapter. If it makes sense to you, get on line and buy it from Amazon. If, on the other hand, the chapter reads like a series of magical incantations pulled out of thin air, run the other way! There is absolutely nothing worse than reading a technical book where the authors keep on telling you "not to worry if you don't understand this for now because it will be covered in detail later." I am glad I bought the book used for half price!

This book is at best a jumble of words with a few readable sentences, and at worst could be written in greek for all the good it does. Without a clear path, the book bounces around off different subjects, and all to often goes ahead of itself in the examples. NOTHING is more anoying then finding a piece of code that you've never seen, and isn't explained for another 4 chapters afterwords. Especially in the first few sections its not uncomon to find an 'ignore this line "..." you'll find out what its for later'. On the upside, it has very few typo's, which doesn't help much as the chapters are so confusing. The best part of this book would have to be its analogies, which are amazingly sensable, such as relating objects and classes to bicycles (One class, 'bicycle' objects of the class such as 'racing' or 'mountain'). In all, its a bit above average but there are much better choices out there for the same price

Well written, easy to follow. A real "page-turner".

(I can't wait for the movie version...)

Alas, the hazards of bound books. Note that this was published in 2001. It covers JDK 1.3, also known as Java 2. The current revision is JDK 5 (which would be 1.5 if they kept the old naming conventions, I think).

That said,it should be sufficient for a lot of folks - but likely frustrating if you have the latest releases of software, since all the detailed commands will have changed (along with some of the function calls...).

Sun keeps up to date copies (downloadable) on line of all these tutorials, so I'd suggest going there first, although having two disparate copies on the go may be more trouble than it's worth, and you may end up ignoring the print version in favor of the on-line. Me, I'm keeping these for reference and have gone out and bought up to date books from other publishers.

I've been learning JavaScript off and on, with some success, for three months. In doing so, I've skimmed about a half-dozen books and tried the following three, so far, "graded" below:

Learning JavaScript (Powers B-)
VQS JavaScript and Ajax (Negrino & Smith C+)
O'Reilly JavaScript Pocket Reference (Flanagan B)

It's hard to find good books on JavaScript and no one should expect a pocket reference to be an instructional book. Despite that, I found this reference guide to be surprisingly helpful at times as I searched for clear explanations of the underlying concepts in learning JavaScript.

The copy I have contained printing errors. the first 66 pages was the beginning section to "vi editor pocket reference" then it picks up on page 73 with what seems to be the rest of the javascript pocket reference.

I'm new to javascript and programming in general.. and took me couple of days of trying to understand it before someone pointed out to me that i was trying to make sence of the wrong content.

This is the first time I have seen errors of this sort from a major publisher.

thanks o'reilly, for wasting hours out of my life.

I realize it's a pocket reference, but this is a brief guide to syntax and then the DOM for the rest of the book. It doesn't cover any of the API stuff like the Date class. It'd be nice to have more information at the price of needing slightly larger pockets.

I am not a big fan of these 'Pocket Reference' books by O'Reilly. Although I have 8 of them, I find them too brief to be very helpful as a reference. Usually they come up short on many parts of the language.

Recently I needed a refresher in JavaScript, and turned to Flanagan. I read the first part of the book to the API Reference on page 52. This seemed like a concentrated and intense refresher. For that one purpose, I think I received good value for my time. I would never use it as a real reference because each subject is just barely mentioned, not covered in any kind of detail. There is no index, plus examples are too few and short to learn from it. So for my limited purpose, I liked it, but would never consider it as a learning tool or actual reference. If this meets your need, fine. Otherwise do not expect too much from this book.

This is an un-paid real opinion. Not all ratings and opinions are honest or unbiased. Some are bought and paid for. Follow the 'See all my ...' and judge for yourself. Learn the industry secret when you see many such high score opinions from one person particularly right after the dates of publication. Educate yourself before you rely on someone who has been paid to deceive you.

If you are new to JavaScript and looking for a helper title, this isn't it. If you're already familiar with JavaScript, and need specific information, you probably need more than an extremely condensed pocket reference is going to provide. There really isn't anything wrong with the pocket reference - it has correct information, formatted pretty well, and contains the most common parts of the core language as well as the common DHTML references one needs for general use. What it doesn't have, and shouldn't for a pocket reference, are complete explanations for the components, or any usage examples - two things needed by people who are turning to a reference book. JavaScript is really too complex to be summarized along with DHTML elements in 127 half-sized pages. If you're looking for a JavaScript reference, purchase the authors full-sized reference guide, "JavaScript: The Definitive Guide" (ISBN: 0596000480) instead.