Rating: 
Summary: thin paper and too many words
Review: With so many highly rated reviews, I'm just amazed.This book is wordy to the point of being boring. And when I do find a nugget of information, my highliter bleeds through the paper. I buy most of my books through Amazon.com, and then only those books that have significant favorable reviews. Unfortunately I didn't see the review titled "I don't see what all the fuss is about?, December 7, 2000". Had I, I might have purchased some other equally well rated book.
Rating: 
Summary: Excellent Java Book
Review: This is a very well-written book on programming. I say programming in general because programmers can't write, they only program! But this book is so well-written I could not put it down. You can develop big sophisticated applications with this book. It not only teaches about the language, but a core understanding of how it works...more than a programmer needs to know, but the more knowledge, the merrier. I am also impressed with the cleanliness and simplicity of the code. I highly recommend it.
Rating:
Summary: Best of Breed
Review: I have owned and used this book (both editions) for 18 months now. It has taken me from a novice JSP developer to what I consider to be a solid intermediate developer. I have purchased and read what must be at least 10-15 other books on server side Java programming, and I must say that this book has been the one that I keep re-reading. The explinations are clear, and well thought out. The concepts of architecture and design are sound. Of the code examples, there are a couple places where things could have been a bit better done (if you try to implement them in real world applications you will begin to realize what they are). This book will put your feet on the right path.
Rating: 
Summary: Well-written, but definitely NOT for beginners.
Review: I purchased this book after reading K.N. King's "Java Programming, From the Beginning" (an excellent tutorial for those who want a general overview of the Java language and syntax). I had worked with ASP briefly several years ago, and thought that I was prepared for an introduction to JSP. The first eight chapters of the Fields/Kolb/Bayern book were fairly straightforward, with incremental explanations the relationships between JSP pages, Java beans and servlets. Starting with Chapter 9 ("Working with databases"), I suddenly realized that I had reached a stumbling block in terms of my Java expertise. There were many examples of JDBC syntax, but the text indicates that a thorough discussion of JDBC was beyond the scope of the book. I would have settled for a brief overview, but none was provided. Also, there were no explanations of advanced code such as "Class.forName" and the "Iterator" class. Chapter 11 deals solely with an enterprise programming project which creates a "FAQ" application. Although the code modules are logically structured, the explanations of each module are less than thorough, and assume familiarity with advanced topics such as the "Collections" API, "HashMaps" and "toHex" conversions for session tokens. I read Chapter 11 several times to absorb whatever I could understand or deduce, but overall, it was unwieldy. The book works best where the authors provide thorough explanations of their code, avoiding assumptions about the reader's familiarity with more advanced Java API's, and avoiding the temptation to adopt a "core-dump" mentality which lends itself to poor clarity, the curse of most books on computer technology.
Rating:
Summary: Great coverage of the entire JSP spec.
Review: This is a great text. It provides in depth coverage of the entire JSP spec. I would recommend it to anyone getting started with JSPs.
Rating:
Summary: Excellent Book - Two Thumbs Up!
Review: This is not just another JSP book. Rather, it is a complete presentation tier design book covering JSP architecture, JSP design, Servlets, and JavaBeans. As with other Manning books I have read and reviewed, this book is complete, and leaves no stone unturned. This book is very well written, and easy to understand. The authors have added tips and tricks, and they interject "real-world" notes throughout the book. The coding examples are clear, concise, and fit well with the concepts described. I found so much useful information in this book I was marking almost every other page. The book starts out with a review of other dynamic content techniques (CGI, ASP, Cold Fusion, etc.), which gives the reader a context in which to place the JSP technology. After a somewhat slow start, the book really picks up speed and gets into the guts of JSP and Servlet architecture. Topics such as session management, buffering, and exception handling are covered in great detail, with issues and alternatives introduced. I was very impressed with how the authors introduced these concepts and applied them to the technology in a clear and concise manner. There is an entire chapter devoted to the JSP directives and scripting elements, which I also found very complete and full of clear and relevant examples. The treatment of JSP implicit objects (request, response, session, out, page, etc.) was also very clear and easy to understand. It is here that you will see a big difference between this book and others; in this book the authors not only explain these concepts, but also illustrate how and why they are used in the overall picture. One recommendation I would make is to read chapter 8 on JavaBeans before reading chapter 7 on the JSP component model. It seemed to me that these chapters are somewhat out of order. I thought that the chapter on JavaBeans (chapter 8) was the best chapter in the book, and gave the cleanest explanation of the role of JavaBeans within the overall presentation tier architecture I have read to date. The scope of this chapter was perfect for the context of the book, and the examples were very clear and understandable. For me, this chapter cleared up questions I had regarding the difference between JavaBean components and value objects. One thing that impressed me about the JDBC section was that the authors presented and discussed many real-world issues such as techniques for handling large result sets and creating persistent result sets. The following chapter then discussed the overall presentation tier architecture, including page-centric design and Servlet-centric design (dispatcher design). Within this section the authors once again presented real-world issues, limitations, and design considerations within each of these two presentation tier designs. Chapter 11 is devoted exclusively to building a sample app from the information learned in the previous chapters. I went through the example, and thought it was clear, and in sync with the information and content previously presented. I saw this chapter as ending what I call "part 1" of the book. The chapters following this one were more advanced, and a little more difficult to follow. For example, I felt that the treatment of listeners and filters, which covered several chapters in the book, was useful material, but the authors dove straight into code rather than spending enough time on the concepts. However, the chapter on JSP deployment with WAR files was extremely thorough, and covered all aspects of WAR files and JSP deployment. The section on cookies, error handling, and shopping cart processing was great. However, the chapters after that (Chapters 17 and 18) seemed very out of place in the book. I did not find these particular chapters useful at all. However, the treatment of JSP custom tags, which spanned 3 entire chapters of the book, was the best coverage of this topic I have seen. The book is full of all sorts of goodies at the end, including changes in the JSP specification, installing and configuring Tomcat, a very extensive JSP reference listing, and a JSP syntax and API reference. Whether you are a JSP novice or a presentation tier architect, I would highly recommend this book. After reading it I found it is valuable as a learning tool and a quick reference. Without hesitation I give this book a big thumbs up.
Rating: 
Summary: Total waste
Review: Can this book be anymore dry. I could hardly get past the first chapter. I've gone on to better books on JSP. I'm using this one to stand my monitor on top of it.
Rating:
Summary: A solid beginning
Review: I bought this book a couple of years and didn't have a chance to read it until recently. It's a thorough coverage of the basics of JSPs, enough to get you started and on your way to developing with JSPs. It's not an 'advanced' reference, and could use some more examples, but overall a solid book.
Rating:
Summary: Well organized with simple examples, good explainations.
Review: Very well balanced- Does not overwhelm one with the internal workings of web servers but gives you just enough background to understand the fundamentals while leading you into more advanced topics. I've been a professional programmer for 16 years, using many languages and so far Java is my favorite one. This book concentrated on the very things I needed to do: connect to a database, etc. I recommend it.
Rating:
Summary: Worth getting
Review: If you're new to JSP technology (and already understand HTML, javascript and CGI concepts) then this is an excellent book to start with. It's a "next step" beyond the standard HTML, and begins by covering the technology and differences between JSP and CGI. Then it steps into the different components that make up JSPs, and finally real examples. The book finishes with a 3-chapter overview of Tag Libraries, but since this isn't the primary focus of the book (and is really its own subject) it doesn't cover the subject adequately and did cause some confusion. There are some errors in the book (lack of definition between jsp:includes, directive.includes and jsp:forward for example), but with some experience this book can become a good reference.
| 
