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.

5 comments about Mission-Critical Java(TM) Project Management: Business Strategies, Applications, and Development.

1. I picked up a copy of this book this morning, and it has already answered a number of my questions. It's a good tool for showing how your budget, tools and developers can/should impact your decisions about using Java to build applications. Also discusses potential pitfalls and how to avoid them, as well as analysis of time/cost benefits of using Java as opposed to other languages.



2. If you are looking at moving to Java and need answers to your business-related questions, check this book out. You won't be disappointed. From the pitfalls and drawbacks of using Java to developer motivation issues and more, you'll find lots of help here. And, all of which does not say to JAVA-cise NOW, no matter what. Includes several Case Studies, too, if you like that kind of thing.



3. When I first started reading this book, I was impressed, until I got to Chapter 3. This is where the book trickles off to a generalized Java advertisement peppered with good management practices which can be applied to any given development language or integrated development environment (IDE) out there, such as C++, Powerbuilder, VB, Delphi, and newer IDEs such as Visual Interdev, C++ builder and JBuilder, none of which are adequately treated in this book.

   What bothered me in particular was that the copyright is 1999 but the authors elaborate on Java projects managed in 1995-1997. Thus, for the less technologically savvy companies out there giving Java a first look, this book may be useful, but for the rest of us who have, essentially, tackled or are preparing to tackle similar problems, this book serves as a general guide to good Anderson-ish management practice. From this book one may glean tidbits of useful development ideas, such as how to embark on the installation of 3-tier or n-tier Java systems, but there remains a curious, more likely intentional, omission of project management details that matter.

   I expect managers out there to have already addressed similar issues with respect to large-scale development initiatives, specifically, staffing requirements, cross-training of existing personnel, capacity planning (not mentioned), performance metrics (glossed over) and hardware considerations (again glossed over) which seriously determine the success or failure of a Java-based development initiative. None of these are discussed in detail enough to warrant a study of this book.

   The strongest case study found in this book is the largest, albeit dated, system which the authors seemed to have managed first-hand, and which you'll find in Chapter 2. Extensive treatment of Java deficiencies and tackling the learning curve are covered, but may be less applicable to the JDK 1.2 (now officially JDK 2) since many developers have since brought

   themselves up to speed in Java and have engaged in at least minimal cross-training.

   Pros:

   1. Chapter 2 (the project on which the authors apparently worked, thus relevant) 2. Chapter 8 (a noble intro to conversion) 3. Chapter 9 (risk management, developing with an evolving standard - bad idea, but mentioned) 3. Chapter 14 (a good summary of Java performance problems encountered) 4. Good general management advice 5. One of the few books to tackle the subject 6. Specifically mentions Powerbuilder/C++ implementation (surprised to see it) 7. Useful project post-mortems 8. Treatment of cross-training.

   Cons:

   1. The ...but-we-got-it-to-work tone of items 1, 2, 3 above 2. Chapter 3,4,5 (fluffy references to other Java projects lacking sufficient detail) 3. Chapter 6, 7 (Browser compatibility and "Java isn't a fad" pep talk) 4. PR-rich e.g. no pointers, easier than C++, portable, multiplatform, secure, robust 5. Copyright 1999, Case studies: 1995-1997 (using pre JDK 1.1), thus nearly making the book obsolete 6. Utter lack of useful detail or omission such as: a. Analysis of the competition e.g. Microsoft and their implementation of COM/DCOM architecture b. Transaction servers/hardware and scalability of three-tier systems c. Project performance metrics, concurrency testing, bandwidth d. Distributed implementations and related problems e. The reporing deficiencies of Java (after finding a third-party, success!) f. Casting Java's third-party vendor and widgets in such a favorable light g. The emerging CORBA dialects and "factions" which may dilute Java's strength as the preferred distributed language h. The muddling of language vs. and integrated development environment (IDE). VB and PB were meant to remove C++ complexity for developers, but Java, by itself, is still a low-level language NOT a 4GL, thus one might expect at least a brief discussion of vendor selections in this area such as Visual Cafe, Jbuilder, J++, Sun's IDE, but there are few except mention of Unix-based or proprietary, home-grown tools.




4. It's out of date, but captures the spirit of early java, and is a good distraction from the textbooks.



5. This is the worst Java book that I ever had. Even for technical managers this doesn't do any good.
   I sold this book for $3.00 to a used book shop.

5 comments about Special Edition Using Java Server Pages and Servlets (Special Edition Using).

1. Correct cover of Servlets and JSPs issues and the relationships between them. How to work with each one, and how to combine them in different architectures. Also a good and useful explanation of the MVC paradigm and good examples of web applications develpment.



2. I've never been so happy to find a book as I've been to find this one! If you're like me, this is the perfect book for you, and from what I can tell, it's one of a kind.

   I'd seen books on Java (servlets), books on JSP, books on XML, and understand the concepts of presentation/application/data layers for web applications. Unfortunately, all the books seemed to treat these techonologies as if they were stand-alone solutions. The clear focus of this book is how to get these technologies to work together to provide an elegant, modular, and easily maintainable solution to application problems.

   Even in the first chapters (basic JSP application), the book is already laying out it's primary theme. It specifically draws your attention to the way the JSP's use Java in two basic areas. The first half being the creation and manipulation of objects, and the second half being the presentation of the data. It then explains that in a few chapters you'll learn that the top half should be in a servlet and the JSP should focus on the second half.

   IRT some of the other reviews I've read...

   Yes, you need to know some Java. This book isn't going to explain classes, polymorphism, inheritance, or interfaces to you -- it expects that you know what they mean. But simply working through a few Sun trails or a Java-in-24-hours type book will be enough.

   Also, if the phrase "multi-tier application architecture" sounds like a foreign language phrase, then this book isn't really focused toward the obstacles that you're currently dealing with. A good chunk (about 1/2, I'd say) of the book is meant to clear up how to use these technologies in a multi-tier environment. If you don't know what one is, then a lot of the book is going to seem irrelevant.

   But if you do know what "multi-tier" means, and you have understanding of the technologies, this is the book that fills in the gaps involved with integrating them together in a single solution.




3. I've never been so happy to find a book as I've been to find this one! If you're like me, this is the perfect book for you, and from what I can tell, it's one of a kind.

   I'd seen books on Java (servlets), books on JSP, books on XML, and understand the concepts of presentation/application/data layers for web applications. Unfortunately, all the books seemed to treat these techonologies as if they were stand-alone solutions. The clear focus of this book is how to get these technologies to work together to provide an elegant, modular, and easily maintainable solution to application problems.

   Even in the first chapters (basic JSP application), the book is already laying out it's primary theme. It specifically draws your attention to the way the JSP's use Java in two basic areas. The first half being the creation and manipulation of objects, and the second half being the presentation of the data. It then explains that in a few chapters you'll learn that the top half should be in a servlet and the JSP should focus on the second half.

   IRT some of the other reviews I've read...

   Yes, you need to know some Java. This book isn't going to explain classes, polymorphism, inheritance, or interfaces to you -- it expects that you know what they mean. But simply working through a few Sun trails or a Java-in-24-hours type book will be enough.

   Also, if the phrase "multi-tier application architecture" sounds like a foreign language phrase, then this book isn't really focused toward the obstacles that you're currently dealing with. A good chunk (about 1/2, I'd say) of the book is meant to clear up how to use these technologies in a multi-tier environment. If you don't know what one is, then a lot of the book is going to seem irrelevant.

   But if you do know what "multi-tier" means, and you have understanding of the technologies, this is the book that fills in the gaps involved with integrating them together in a single solution.




4. I normally don't write book reviews but I saw this book had some poor reviews and felt it necessary to add my two-cents worth. This is probably the best servlet book I've ever read and I've read several. The book explains obscure points that aren't entirely clear in the specification itself and cautions against problems that aren't obvious unless you're a very experienced programmer. It also provides lots of invaluable suggestions for those of us trying to figure out exactly how the J2EE architecture should be implemented. If you're just learning servlets, Java, or web programming you probably want to start with a simpler book.



5. This book has an excellent first few chapters. It really introduces the Java language, explains how it works, and makes it fairly easy to keep up. Once you start getting into the technologies that surround Java, such as database connections and CORBA, this book gets tough to follow. There is code example after code example with little or no explanation of what the code is doing step by step. I know that I like when the author walks me through code so I can understand the first time, and not have to look at more examples. This book does not do that. Overall I think there is material to be learned from this book, though I'm not sure if it's easily extracted. I haven't read the WROX JSP book, but from what I have seen, that might be a better way to go.