This is one of the best technical books I have read. Bergsten wrote an in-depth, exhaustive tour of JavaServer Pages and the MANY related technologies, and it never once put me to sleep. It actually kept me up a few nights, but I'm a nerd like that.

For those of you new to web development, this book takes a slow and gentle approach to teaching you JSP. You will not only learn how to setup an environment and use JSP to build simple to moderately complex web applications; Bergsten filled his book with more best practices, pitfalls, supporting information, and general wisdom than I could have possibly hoped for. Taking his words to heart will set you well on your way to being a more solid, knowledgeable developer than most developers I've ever met.

For experienced developers, this book is a very fast read with a flowing style. Bergsten attacks every concept from a handful of angles to ensure complete coverage of the subject matter, so if you understand his meaning quickly, you can generally fly right by. I enjoyed reading this book so much that I rarely found myself flying over anything. The appendices are very useful as a reference, and if you're anything like myself, your copy will be filled with dog ears and highlighter.

In general, I don't hold high opinions for recent technical books. They are, in my experience, mostly superficial and lack any measure of depth. This book has set the bar as far as I'm concerned, being packed with content and wisdom without reading like an encyclopedia. Having said that, it's not without its faults.

To begin with, nobody should be fooled into thinking that using any of the JSP technology stack is NOT programming, and Bergsten tried to fool the reader far too many times. Using JSP, JSTL, and building tag libraries with either method is very much programming, and should be thought of as such. I think it does a disservice to reassure non-programmers that they don't have to learn Java or programming in general to work with JSP. That is how horrible code gets written, folks. Suffice it to say, if you're new to programming, accept that you're learning to program and absorb what you can!

In the later chapters, Bergsten's treatment of MVC was a bit off on a number of points. Views (the V in MVC [Model View Controller]) are defined as having direct access to Model objects, which creates a "template" with a lot more power and responsibility than the spirit of MVC denotes, if not eschewing the definition entirely. However, this idea of MVC fits very well with the power-hungry nature of JSP as a templating language, so I understand why it was stated that way. Just be aware, Bergsten / JSP's definition of MVC is not the same MVC you're likely to find in common MVC frameworks today. Also, the few MVC examples used bits of Struts, and I wished they wouldn't have. MVC is not that difficult; an extra page of code could have done a lot to illustrate and demystify the concept.

Another issue, albeit a small one, is that the editor appears to have taken a nap between pages 100 and 200. The code and spelling issues are slight, but there are a mess of them. (Cue Muphry's Law)

Finally, having said all that: I don't recommend this book. I have come to believe that JSP is a very confused technology, and should be avoided if you have a choice in the matter. Learn a nice framework like Rails, Cake, Django, CodeIgniter, Pylons, etc. instead, and save yourself a few hundred headaches and finger cramps. If you HAVE TO learn JSP as I did, then this is definitely a great book that will significantly help you on your way.

Even though I have such a strong distaste for JSP, I still give this book 5 stars. It was incredibly written and compiled. If I am ever in the position to write a tome on some technology, I will plan to model it after this book. It is that good (in my humble opinion).

Seller was great but this is 1 of the OReilly books that's to wordy and has mistakes in the examples. I would not recommend.

This is an extremely well written and informative book. I have
lots of experience with servlets, so I don't know how the book
will appeal to page designers, but I had no problem reading and
enjoying the chapters oriented more toward them. I used to look
at JSP and see the same kind of maintenance nightmare that comes
with something like PHP when your project gets large. I have
been using WebMacro/Velocity but am now a convert to JSP since
it has matured. I love the author's philosophy of no scriptlets
in your JSPs. I own many programing books, but I believe this
is the best written I've seen.

If you are looking for a quick cookbook this should not be your choice. If you want to learn JSP in depth, buy it right now. Hans guides you from the basics to comprehensive details of JSP technology in a very structured way.

In any case, (from my point of view) JSP is not the whole jigsaw for building web applications, it's just a piece of it. So don't expect to be able to build real web applications if you just have read this book. At least, consider reading also Java, Struts/MVC and SQL.

Perhaps this is as good a user guide as is possible for JSP, which is a good, but not great techology.

JSP integrates between web markup user interfaces (usually HTML) and back-end java technology (usually servlets), and best practices have most of the interesting work done in these technologies, not in JSP. JSP's flaws come from too many spurious features that lead the unsuspecting user far away from best practices.

JSP's strengths as a template technology for web view markup come in its 2.0 version with its addition of programmatic logic to markup (JSTL for logical branches and loops, and tags for subroutines) which allow for development of markup without repeated code. This is a great benefit of JSP, and this book does a fairly good job of explaining it for JSTL/logic, but talks around it with confusing examples for tags/subroutines. To this book's credit, it is the only decent reference I have found for JSP 2.0 tag library development.

Best practices with JSP as an integration technology involve what is called "Model 2 MVC" where the JSP page is strictly used only as a template for markup (the "view" which is the "V" from "MVC"), a JavaBean is used for the M-"model" and a single servlet is used for the C-"controller". This concept is mentioned in this book, but its up to you to figure out how to implement it, and the book is full of examples that show off unrealistic uses of JSP's spurious features and are anything but best practices. At some point in using JSP's and servlets, you are going to have to go head-to-head (actually, head-to-confusing-XML) with a real deployment descriptor, and this book will give you little help as to why it doesn't work.

Until someone writes a truly useful reference for JSP and servlets, you will have to follow the time-honored tradition of finding an example that works and cut-and-pasting it into your web application. Poring over this book will help some, as will poring over Craig McClanahan's online doc that comes with Tomcat. The best book I've found so far for explaining best practice design with JSP is Rod Johnson's "expert one-on-one J2EE Design and Development" (read the chapters on web-tier MVC design and views in the web tier) though it's description of JSP is somewhat dated, and it won't help you out with implementation details.