2 comments about Beginning Java Objects: From Concepts to Code.

1. This book is good on objects, even if you don't want to program in Java. It's also good for beginners as well as those who think they know a lot!



2. This is a fantastic book that takes a close look at objects and their design in Java. It takes the reader through a painstakingly detailed design of objects in a java program. This is why it got 4 stars from me. The first half of the book is pseudo code, and while that does a quick job of getting the point of object design across, it gets tired and old after a while. That said, this book is definitely one of the best texts on java object design I have read.

4 comments about Starting Struts 2.

1. Author has not given any thought on developing the subject matter from ground up while he present this new framework. By the time I read, page 35, I was totally confused. And there are lots of typos with the text and the code. I guess we will have to wait for Struts 2 in Action.



2. This book isn't intended as a complete reference (the on-line documentation is much better for that), but for getting a reasonably experienced developer pointed in the right direction, it's a great start. It describes the core components of Struts 2 (a major change from Struts 1), and gives you a bunch of productivity tips. At just over 100 pages, I found it concise and helpful. Don't rely on it alone if you've never used Struts before, but if you're looking to jump into Struts 2, this book is handy and easy to flip through.



3. I purchased this guide because at the time it was the only available book on Struts 2. It now has the distinction of being only the second book I've ever wanted to return to the store.
   
   It's true that there is some content here. But it's hard to find the value in all the typos, grammatical errors (the author desperately needs to learn what an apostrophe is for) and brief, incomplete surveys of topics found in the Struts 2 Wiki. Worst of all, the back cover promises "lots" of examples, and there's hardly any code at all in the book, and not a single complete example.
   
   The whole book feels like it was rushed out in a weekend. Avoid it like the plague until any "real" books come along. The author himself apparently has a full book in the works. I would have purchased it, but after this unprofessional hash job, I'll never buy anything from this author again.



4. This was the first book I read on Struts-2, and my reaction was "If the documentation of Struts-2 is this bad, why would anyone want to adoopt it?" I found run-on sentences and comma splices that made wading through the book torture. If I could return the book, I would.
   
   It is badly organized. It assumes too much prior knowledge; in some cases, the information you need to understand one part isn't covered until much later in the book.

5 comments about The Struts Framework: Practical Guide for Java Programmers (The Practical Guides).

1. If you are an experienced programmer and just want to know about Struts, I would say this is a good start. You can learn about Struts quickly using this book, the author brings readers straight to the point.



2. Hate to say this, but this book is useless. It is poorly edited and more confusing than helpful. This book may be of some help to those who have used struts extensively but if you are a beginner, SAVE YOUR MONEY!



3. I just completed a 5-month corporate contract, prototyping an intranet app using BEA Weblogic/Workshop, without prior Struts experience. Now this book makes more sense to me than when I first picked it up in 2003!
   
   Workshop "page flows" provide a layer over Struts, aggregating related actions into one construct, not unlike Struts "modules"?! Too bad this book does not cover these, they certainly were available with Struts 1.1, which this book covers (see http://www.onjava.com/pub/a/onjava/2002/10/30/jakarta.html)
   
   Still though this book has its value. For instance, section 4.1, "Creating An Action" describes some practices for working around what is seen particularly by the Spring community (I spent the first month and a half using Spring rather than Workshop) as the major drawback of Struts -- that the Struts action class must be directly extended, resulting in unnecessary coupling to the framework, lowering testability, etc.
   
   Fair enough, but the Struts examples in the Spring literature are typically shoddy. This volume has a couple of valuable recommendations in this regard, the first being to create "a base action class for the application", which will helps focus the coupling. Next "to enforce the contract between the base class and any subclasses, make the base class abstract".
   
   It is nuggets like these that make this book worthwhile, though, recalling my own attempts with this volume a couple of years ago, I would not recommend it to anybody who is not at least mid-level.



4. A good effort to produce a small book that introduces Struts. It does it decently, but the quality of explanations is simply far from what one is used to by reading other Java technology top-sellers. I found that the book takes more effort and concentration to understand than needed, due to the lack of simplicity and straightforwardness. But otherwise it is a decent introduction whose great merit is conciseness.



5. Let's face it: what makes a good book (primarily when it comes to programming) is the ability to convey the concept with step-by-step examples. This book was sooooo wordy with almost no examples. I couldn't see the BIG PICTURE I couldn't see the relation between the classes and all xml files. Struts is not easy to explain and a good book will walk you through with all the relation and EXAMPLES!!!! This one didn't
   
   :-(

4 comments about JDBC Pocket Reference.

1. The O'Reilly JDBC books are the worst of their Java selection: too short and only cover the bare minimum to get simple tasks done.



2. "JDBC Pocket Reference" by Donald Bales is another great reference book from O'Reilly. Like many of O'Reilly's pocket reference books, the book has a small form factor. You can easily carry the book in your briefcase or back pocket. The book is only 145 pages long. The first 45 pages give a terse and concise explanation of how to use the JDBC API and the last 100 pages provides a quick reference to the JDBC 2.0 API. The following paragraphs provide more detail on how the book can be used by a programmer.

   The book is intended for programmers, but could also be applicable to ambitious database administrators (DBA) that want to create Java utilities to monitor and automate some of their DBA tasks. If you are familiar with SQL and database topics the book can provide you with a quick reference on syntax and procedures that you might forget. The book is not a tutorial on SQL, client/server programming, or relational databases. If you are not familiar with these topics or you want to learn more the JDBC Pocket Reference is not for you.

   The first 45 pages of the book are packed with helpful examples of how to use the JDBC API. Most JDBC programmers are familiar with these examples but often need reminders on proper syntax for different database vendors and drivers. Here are a few examples of explanations I found helpful:

   1. JDBC Driver types: There are four classes of JDBC drivers called type 1, 2, 3, and 4 respectively. Type 4 is the only pure 100% Java driver and is the only type described in the book, but it is helpful to understand what driver types are available.

   2. Database URL Syntax: Getting the proper database connection string can be frustrating since every database vendor is different. This task is usually done only once at the start of a project so it is easy to forget the correct syntax. The Pocket Reference describes 9 different database drivers giving the appropriate connection information, online references, archive file name, and supported properties for the driver.

   3. Using JNDI to obtain a data source.

   4. Using DatabaseMetaData API to find information about the database properties and capabilities.

   5. Good examples for executing standard SQL statements and retrieving the results through the ResultSet interface.

   6. Store Procedures: Using the CallableStatement object to execute a stored procedure is one of the most difficult JDBC calls because stored procedures are vendor dependent. The book outlines how to set input and output parameters appropriately to make the call. I found this very helpful since a lot of the documentation from database vendors do not describe this operation very well.

   7. Properly handling "null" values in JDBC. This is important because a database NULL is different than a Java null.

   8. Inserting and updating binary blobs is explained.

   9. Describes and explains how to use User-Defined Data Types (UDTs) to help you map objects to a relational database.

   10. Describes proper escape sequences ensure that your JDBC code is portable across database vendors.

   The only criticism I have for the book is its lack of examples for database connection pooling and transaction support. Committing and rolling back transactions was mentioned briefly, but the book didn't give any examples. Also, the only reference to distributed transaction support was in the JDBC API reference under the XAConnection class. Distributed transaction support is a big part of the Java 2 Enterprise Edition (J2EE) and comes standard with most J2EE containers. Then again this is just a pocket reference so the author couldn't include everything.

   ... I highly recommend it for any programmer that works with database systems. The books provides a quick reminder on proper syntax and procedures without requiring you to carry a backpack full of 500 page books.




3. The first third or so of this book consists of a nice, concise overview of JDBC, with an example for each concept. The rest is basically a printed copy of API documentation you can get online. These really are easier to read it online — the docs for DatabaseMetaData, for example, are about twenty pages long and much easier to deal with in hyperlinked format. The descriptions have been reworded (and shortened) and sometimes are a little easier to understand in the book.
   
   The book is probably enough to get you started using JDBC, especially if you have some experience using database APIs in the past (ODBC or a vendor-proprietary one).
   
   So, my recommendation is: It's half useful, so buy it used for half price. ;-)



4. A friendly and well-written book recommended for anyone ready to learn JDBC. This JDBC Pocket Reference well-written and well-organized introduction to the JDBC. It uses a careful, example-based, easy to understand approach. Contains many examples and other useful information.
   Thank you

2 comments about Java Jump Start: A Beginner's Guide to Internet Programming.

1. This was recommended to me as an introductory book. But, like most of the others I've bought, it soon broke the rules. A concepts is clearly explained, then an example buries you in advanced material that is not even introduced, let alone explained. However, one can see this is an original book with many interesting perspectives and examples, and I mean to return to it once I've really mastered the basics of OOP and Java. Yet this was not a "Jump Start" except in the sense of jumping over a cliff into the sea. You'd better know how to swim!



2. Java Jumpstart provides a good background into how this languauge works with so many different OSes. It also gives some insight into the creation of the Virtual Machine, and how Java is related to programing in C++. This book is a great start into a new programing language for those who understand basic programing concepts. If necessary, use the CD-ROM enclosed to view the applets created in this book to help you further understand how the applets work.

5 comments about Wireless J2ME Platform Programming.

1. I didn't find this book very helpful. What it refers to as "advanced topics" such as persistent storage and networking are basic concepts that aren't explained very clearly. Seems put together too quickly with only average coverage of j2me.



2. A good introduction to j2me, but the links to download the code samples don't work, they go to an under construction apge, and no one will reply to emails to say when they will be available.



3. Finally I learn this hard lesson: One who knows something DOES NOT necessarily know how to teach it.

   I was attracted by the impressive background of the author, and it's part of SUN's Java series. But I am stunned by the poor quality of the book as a teach-yourself material. Come on, Mr. Piroumian, of course you know this is a book for Java learners, not a RFC, or API specification. But it reads like the latter.

   I got my Java Programmer Certificate two years ago and consider myself an experienced Java programmer. But, I couldn't follow the book. It's that a hard and boring read. Those examples are dry, non-intuitive and useless in real world. After finishing the book, I still don't know how to do some quite simple tasks.

   Very disappointed.




4. I found this book to be an excellent introduction to J2ME wireless development. The author's clear and consise writing style gets the reader up to speed almost immediately with a minimal degree of effort. The fine examples and graphical illustrations couples nicely with the text. I especially found the chapter on Internationalization particularly useful. This is a good book for the beginning wireless developer.



5. I found the book to be a good book on J2ME.

   I met the author while working for a big company.
   I thought he was a great person and a good looking man.

   I found the book to be an excellent book on not just J2ME, but
   a great introduction to the world of wireless communication

1 comments about JavaScript Examples Bible: The Essential Companion to JavaScript Bible.

1. Working with JavaScript is certainly becoming more and more a part of the web pages I am involved with, from wanting a clock to form validation to buttons. There is so many things and uses for JavaScript that the list seems endless.

   What I found most helpful about this book was not only was the cd filled with over 300 pre-written scripts, but that the book also has coding examples for you to follow and learn from. For me learning JavaScript is a challenge and using the examples in this book has certainly it easier to produce quality JavaScripts.

   Overall an excellent add-on the already highly successful JavaScript Bible, as you'll see when you look at the chapter headings. For example Chapter 1 in this book refers to chapter 15 in the JavaScript Bible.

2 comments about Java Event Handling.

1. Java Event Handling has to be the most complete collection of documentation in one book on the Delegation Event API provided by java. Not only an easy reference with lots of excellent examples to demonstrate, the explanitory texts are well written, easy to follow, well organized and gives more than enough information to model effective event handling and management routines in your application. You won't find a better source of information on this topic anywhere else.



2. Believe it or not, we really do need a book on event handling in Java. Events are a pervasive form throughout the SDK classes, not just to AWT and Swing. They inform the structure of JavaBeans, Java Messaging Service (JMS), and are important to EJB, Jini, and Jiro. An OO methodologist may say events are "just" an expression of the Observer design pattern, but from that simple pattern spring at least four major variants used in Java, each one worth careful study. Once you understand event-handling in Java, the structure of many classes become quite clear.

   But 590 pages? Why so many? Oh...it's a reference book, another API treatment that re-documents some classes, and adds some light code examples. I'd estimate 460-70 pages of the book do that and only that. The opening text tells the reader it will reveal the power of event handling -- which to me is like learning a meal will be best when it's hot -- but then concludes that learning by doing is the only way, and delegates many important side-trips to other sources.

   There's little graphic relief, and no visual modelling at all. Discounting the lists of class methods, there are 2-3 class hierarchy diagrams in the book, and one screen shot. The latter is located somewhere after the bulky reference section -- bad placement, in my opinion.

   There is no mention of how events drive JavaBeans, nor any satisfying description of local versus remote event-handling. That's not a crime, but that's what I wanted in place of another javadoc rewrite. The Jini overview is only two pages; and it's now somehow been covered? Even the Jini code samples themselves are borrowed from Core Jini. The reader is referred to that book for an explanation; it's unreasonable to think the reader can make that leap easily.

   An example using RMI would be simpler and more appropriate. Remote event-handling has been covered for years in the periodicals. Why not cross the tee on those discussions with a full-length treatment here?

   This book feels like it lost its way through the tedious business of describing classes. The event handling book I hope for is suggested in these pages, but doesn't materialize. I think the real work got left off until the end, when there was no time to think and the deadline was in sight.

   If events were "new," this book might have reason to be an API reference. But they aren't new, and certainly not mysterious. To write API treatments, you need an eager, information-deprived audience, and it's essential in my opinion that the author show a reading of the source behind the API in order to comment with authority. javadoc is not completely helpful, sure, but the shortcomings aren't so egregious we need to publish every "better" set of class definitions either.

5 comments about Beginning JSP Web Development.

1. I found this book to be very useful. I have been developing we applications now for 4 years using ASP, and I still found this book useful. I have been trying to find a good book about developing we apps, especially in JSP. It has great examples for developing the JSP page and the presentation is also excellent.The one star missing due to lack of robust code in some sections.Nevertheless,a must have book for all.



2. This book is a solid introduction that covers all the key basics. Be aware that over half the book is spent teaching Java, not JSP. Since I already know the basics of java, the numerous Java chapters were a distraction to the main point of JSP/Servlet programming. Also, being a beginner to JSP, I have to agree with an earlier reviewer that the book hurries on to each next chapter with only the barest of examples to illustrate the topic, and usually the examples are just "toys". You have to wait until the end of the book where two chapters are devoted to developing a realistic web application. The result is that you don't get a chance, as you go along, to really practice a concept and see it in various contexts. Also, I like to get into database access early in a book, since using a database is the main point of a web application. In this one, you have to wait until near the end before you learn how. Aside from these caveats, the book is clearly written, the concepts are well explained, and it covers the subject quite well.



3. Thanks to everyone who mentioned the numerous errors in this book in their reviews. I only wish I had read them before buying the book. Not only is it full of every type of error you can think of, it is also poorly organized with a heavy-duty chapter on tag libraries sandwiched between otherwise introductory material. Also, the last half of the book is meant to be a case study but the sections are pasted together with little or no indication as to what is part of the case study and what is an overall observation making it impossible to follow along. If you do buy the book (and I recommend you don't) print out the errata list from their website -- it'll save you hours of frustration. However, don't expect it to be complete.



4. The book says that the source code can be downloaded from wrox.com. But that is not true. The book does not have a CD nor does it have source code at wrox.com. Beaware of it.



5. This book presents ideas from top-down. They show you something and then explain the pieces that they think are important. They are fairly good at this but the problem is they don't explain everything in detail. They tell you just enough about a subject to make you think you understand it but gloss over pitfalls. They keep telling you not to worry about certain parts of the code - they will explain them later. I think learning a language from the bottom up is better. That way one understands all the pieces that are being assembled. This book is getting the job done but I'm often confused about what code (explained in later chapters) is doing. Maybe I should read the book in reverse order...

4 comments about Oracle XSQL.

1. The author has done a excellent job. It describes about the important pieces in a dedicated chapter - XSQL architecture. After that he delves into SQL, PLSQL, XSQL , XSLT. The best part is chapter 14 on Building XSQL web applications. This explains how all the above pieces are put into a working model. The material is written keeping oracle 9i in mind. As a whole, I felt very comfortable reading the whole book.

   Especially for database developers who come from sql, plsql background and are trying to get into web development world ( without the hassle of learning Java Servlets, Jsp etc ... ), I would definitely recommend it.




2. This book describes a new and interesting approach to some well-known web development problems. Though not all of the technologies described are mature (yet), they are largely standards-based and likely to grow in popularity in the coming years. The author does a good job of showing how several different technologies (SQL, XML, XSLT, HTML and others) can be focused into a coherent whole. Probably not for beginners, but anyone with web development experience should be able to learn a lot from this book.



3. Mike has done an outstanding job with a complicated topic, a remarkable achievment from a Carolina fellow!



4. There are few books out that deal with Oracle Text and XSQL. Applying the methodologies, practices, etc. I found no need to search for another reference.