Customer Reviews

JavaServer Pages

5 star:		(5)
4 star:		(9)
3 star:		(11)
2 star:		(10)
1 star:		(3)

 

 

This book provides a relatively good overview of the JSP technology. The first few chapters were very clear and informative. However, in later chapters the author jumps into JavaBeans without much explanation and the remainder of the book feeds off of that. I also found many grammatical errors and even a completely erroneous code listing. Consequently, I would say save your $40.00 and wait for a better book on JSP.

I've created PHP and ASP websites in the last three years, so I do have some programming experience, but I haven't done anything with Java! After I started reading this book, I couldn't put it down. The information is presented so that you always know enough to understand what's going on in the code being developed for the main theme of the book, developing a dynamic news site. It also has short examples of code sprinkled throughout the book, that don't require you to follow the theme in order to see what's going on in a particular chapter. Author often presents a simple solution, then gives advice on what needs to be done to make the solution more robust. I love this book. It explains the technology as well as teaches the techique to to use it. I was able to create a dynamic JSP page that queries a MySQL database and neatly displays results within four hours of putting the book down (OK, I admit it, I had to take a few peeks). I'm impressed. If you are new to JSP, buy this book. Not new to JSP? Buy it anyway - it's great (and it talks about Beans and Servlets).

I have to say that the book is a great overview of JSP. Larne Pekowsky does a great job of explaining how JSP works and how to incorporate Java into your page. It's a good book for beginners.

However, watch out for the examples in the book. Most have some minor problems with them such as the wrong package name. So, if you try to use the beans that are supplied on the cd, they won't necessarily work.

If you are an inexperience Java programmer starting to learn JSP, this is the book for you. The author holds your hand as he goes through the features one by one.

While there are codes sprinkled over the text, it is not too excessive and serves their points very well. It's a good refresher for the experienced, though it might not be worth the $$$. Hardcore programmers should be reading the book "Web Development with JavaServer Pages" by by Fields, Duane K. / Kolb, Mark A.

The information from this book can easily be grabbed from the web at Sun's JSP site. This book lacks depth. It basically tells you some JSP basics but won't get you far in developing any serious applications. I relate it to an HTML for dummies book that tells you how to code basic HTML for your homepage. Get Web Development with JavaServer Pages. Much more bang for the buck, for beginners and beyond.

Unless you're doing simple JSPs this book is not for you. If you're already a java programmer and are familiar with servlets (at least in concept), this book probably isn't for you. If you're doing complex or industrial strength JSPs, this book is not for you.
First, the book actually teaches the wrong approach, in my opinion. One big criticism of JSPs is that they do not do a good job separating view (GUI, display) from business logic. They aren't good because you can embed java code in the JSP. The apache group hated this ability so much they went off and did some template engine stuff (worth looking at.. Velocity/Turbine projects). This book actually encourages embedding your biz logic in the JSP, thus making the web designers have to know java. In fact, the book has whole sections dedicated to nothing other than understanding Java. Another criticism is that the industry would like to have the folks that do the front end GUI (web designers) and the folks that do the back end business logic and complex tasks (the programmers) be as separate as possible. Engineers can't make things pretty and web designers write horrible code. Keep the two apart, but give them the tools to work together. This book doesn't even talk about that approach, or worse yet, does talk about it and presents its material as a good approach to do this. It's not!
The one good thing that JSPs have that can save it from this embedded java code, the custom JSP tags, is barely covered.. a cursory view at best, irresponsible documentation at worst.
Thus, instead of teaching something worthwhile, like the model-view-controller using JSP custom tags and the concept of trying to keep the java code OUT of the JSP, this book teaches bad practices. If all the author wanted to teach was what JSPs CAN do(not should do), it's an ok book.

I consider myself fairly auto-didactic, and indeed this book starts out OK for someone with HTML experience and a general technical background. But the implementation of the CD seems like the author passed it off to someone else and never did any quality control. I abandoned the Tomcat server on the CD, got a great one for free off the net (Allaire Jrun 3.0) and with the help of an experienced Java programmer managed to debug the examples up to the chapter on databases. At this point, I realized that there is no way to duplicate this books examples without previous experience at compiling and installing a database from it's source code - hardly the realm of the target reader. Computer books should be better than this.

If you want to know how to include a bean in your jsp's than this is a graet book, otherwise it is not very helpful. Unless you look at the online version from the cd you will be lost as to why and what the beans are doing. Beans are also used very extensively. the author does not seem to concentrate very much on the true subject.

This is an OK book for beginners. However, if you are a seasoned Java Engineer looking for discussions and examples of different architectures for distributed applications using JSP as a front end, look elsewhere.

This book is a good introduction to JavaServer Pages. It covers a variety of topics such as using Java Beans, the standard tag library, using databases, using XML, Servlets, and Controllers. Additionally, creating your own tag libraries and some advanced topics like threads are covered. Since so many topics are addressed, the coverage is more of an overview. The book focuses on the new JSP 2.0 specification with the new expression tags being emphasized. A sample project is implemented gradually. As new topics are addressed in the book, they are added to the project.

The book has some nice features such as the included CD that has an installation of Tomcat 5 that implements JSP 2.0. The installation includes the working examples and the database already configured for the examples. The examples are organized as a website by chapter which allows the reader to easily navigate to see the example work or to examine the code. This allows the author not to inundate the book with code examples, but rather to add the appropriate amount of code to illustrate a point.

I have a few criticisms for the book. Exercises for the reader should be added to the book to reinforce the text explanations, improve the learning process, and aid the retention of the reader. Likewise more illustrations should be added to the text to break up the blocks of text and enhance the reader's understanding. Perhaps, the MVC pattern could have been introduced earlier in the book since it is generally considered part of good design.

The book is a solid resource for developers moving to JSP. The reader should keep in mind that some of the topics would require more study to prepare for Production quality development.