The book is rich in content and you can definitely learn a lot about JSF. Unfortunately, a good author also needs to be a good teacher and story teller. Reading Bergsten is like listening to Ben Stein or Stephen Hawking talk, you will undoubtedly wish you were doing anything else except this. Things such as changing a diaper or jury duty will become more appealing after reading this book. I stopped once during reading and decided to clean my room instead. That's exactly how exciting it was to read Bergsten.

To give a contrary example, Kevin Yank from sitepoint or Joe Burns from HTMLGoodies are infinitely more fluid and entertaining to read. If you want a book for its content, this is a good book. If you have a crappy attention span like myself, this is a difficult book to read. To give a bit of background on myself (not that anybody cares) I've been a Java programmer for about 6 years so the book isn't above me, its just too dry in my opinion. That's my two cents. Good Luck and Happy Shopping!

This book is an "OK" starting point for someone learning JSF.

Here are some things to be aware of:
1) Does a poor job explaining the lifecycle of a JSF component; he writes the sequence of events out in paragraph style and does not provide diagrams (UML or otherwise) to help with the illustration

2) Constantly switches metaphors as he is explaining JSF; sometimes he will be talking about the implementation view of a JSF component and then other times he will be talking about the application view of a component. It would be better if there were one or two chapters that focused on the "how the heck does this work behind the scenes" and the rest of the book focused on applying JSF.

3) There are syntax errors throughout the examples; this includes the code examples (.jsp examples) and the configuration examples (web.xml and faces-config.xml). To his credit, he constantly references the appendix section for a more complete example. As a reader, I personally don't like flipping back and forth all the time.

4) His coverage of the application (using JSF actions) is very basic (academic). He doesn't go through the academically classified edge-cases, which is disapppointing because those are typically classified as real-world.

5) He forward references way too much; for example he will talk about / use something in say chapter 4, and then states something to the effect "oh, we'll come back to that later, don't worry about it now". From a learning perspective this is terrible. It causes your train of thought to be derailed and you end up asking yourself the question "what does that do?".

On the positive side, the flow does seem to make some sense from a learning perspective. He builds on the foundational concepts and frames the learning in the context of creating a "real-world" application.

I understand this book is a bit out of date (suprises me O'R hasn't encouraged an update). My suggestion is to buy this book used.

This book is an "OK" starting point for someone learning JSF.

Here are some things to be aware of:
1) Does a poor job explaining the lifecycle of a JSF component; he writes the sequence of events out in paragraph style and does not provide diagrams (UML or otherwise) to help with the illustration

2) Constantly switches metaphors as he is explaining JSF; sometimes he will be talking about the implementation view of a JSF component and then other times he will be talking about the application view of a component. It would be better if there were one or two chapters that focused on the "how the heck does this work behind the scenes" and the rest of the book focused on applying JSF.

3) There are syntax errors throughout the examples; this includes the code examples (.jsp examples) and the configuration examples (web.xml and faces-config.xml). To his credit, he constantly references the appendix section for a more complete example. As a reader, I personally don't like flipping back and forth all the time.

4) His coverage of the application (using JSF actions) is very basic (academic). He doesn't go through the academically classified edge-cases, which is disapppointing because those are typically classified as real-world.

5) He forward references way too much; for example he will talk about / use something in say chapter 4, and then states something to the effect "oh, we'll come back to that later, don't worry about it now". From a learning perspective this is terrible. It causes your train of thought to be derailed and you end up asking yourself the question "what does that do?".

On the positive side, the flow does seem to make some sense from a learning perspective. He builds on the foundational concepts and frames the learning in the context of creating a "real-world" application.

I understand this book is a bit out of date (suprises me O'R hasn't encouraged an update). My suggestion is to buy this book used.

I've been working on webapps for the past 3 years in PHP, Python, and most recently Ruby. I've been trying to learn J2EE and have found it very difficult to find a foothold, a solid piece of ground to get oriented as to how people write Java webapps. I tend to like tutorial-style books when learning a new subject, ones that pick a project and implement it step by step, explaining the importance and contextual relevance of each hunk of code along the way. Of the four or five J2EE books that I've read on O'Reilly's Safari, this book is by far the best one for my style of learning. Java webapps are unique in that there is such a wide variety of options for each layer of your application. The Model, View, and Controller layers are all completely independent, and the interfaces between them are all configurable. Not only are they configurable, but you can choose to implement the connections between layers in code, or by using xml configuration files. This is *very* different to any other framework that I've used, and the complexity and power it presents is immensely overwhelming.

Bergsten does an excellent job (in contrast to the Official J2EE Tutorial, imho) at presenting each concept with just enough background, context, and detail as is necessary for one to understand what is happenening at a given moment.

I really like the fact that all of the code is listed in its entirety in the text, with descriptions interspersed. I really dislike the style of tutorial that tells you to "download and install the source code" and then proceeds to discuss it. I find that by having the example provided to me, I tend to skip over the boring, but important, details and at the end of the read, I haven't retained much. I learn by "following along" and typing in the listings myself. It helps me to remember the concepts, and forces me to concentrate on what's happening.

I can't speak for how effective this book would be for someone who already knew J2EE in some capacity, but for me, a J2EE newbie who likes a hands-on, applied approach, this book was the perfect fit.

I have this book and Core Javaserver Faces; this is the book that lies open on the desk, is dog eared, and has coffee spills on it. It's not perfect, but it's the best there is in this space.

1/4 of the book goes explains how to use JSP, JSTL
2/4 of the book API reprint
1/4 of the book actual JSF stuff - not real world related - unless you know exactly what you are looking for you'll never find it...
i'm surprised this book went into print - probably somebody upstairs decided to have at least something rather than nothing.
waste of time and money.

It describes very details about JSP, HTML and web architechure. However, I think it's not necessary as the readers should have basic knowledge of Java.

There are many examples to demonstrate how to use JSF. It's good for beginner. It lets reader to get knowledge faster and neatly. However, the codes must be downloaded from Internet. It's not convenience for us.

There are some parts for intermediate and expert JSP developers. "Developing Custom Renders and Components" are good topics.

The Appendix is very useful for developer to get syntax of JSF quickly. I appreciate it.

Okay... if you have any modicum of experience with Java web technologies, but are looking at expanding your horizons, DO NOT BUY THIS BOOK! It will frustrate you beyond belief.

1. The author spends over 60 pages just introducing JSP: If I wanted a book on JSP there are already plenty available, and much better at explaining it since the author does a very sparse job of it.

2. The author spends 7 pages just discussing HTTP! If you don't know what HTTP is, once again there are better introductory books on web technologies.

3. The author's examples are rarely fully explained, but instead he continuously uses mere 'snippets' without ever giving the entire code. I understand that the code is available online, but I don't want to toggle between reading code on my computer and then having to flip through pages in a book: Keep it all in one place.

4. The author also spends a fair portion of the book talking about other non-JSF related issues: Internationalization, CSS, Tabular data???? (which, by the way, is a horrible example that does not model anything close to a real-world example.)

5. Over 200 pages of the book are simply reference pages which are available to anyone online (which is when you want them since that's when you're coding!)

6. He has 36 pages (in appendix C pp. 444-476) on the HTML-Specific Component classes... read through these and see exactly how useful this reference is: It only lists the components and the litany of methods with absolutely no explanation.

7. He never really adequately puts all the pieces together and shows the JSF novice how to create anything that resembles something that would be a good starting point for real-world development.

These are just some of the incredible deficiencies of this book. My opinion of O'Reilly has been tainted as of late and this book certainly doesn't do O'Reilly any favors. Overall, this is by far the very worst Java book I've ever read and a definite waste of my money and time.

I'll say it again: I think Hans Bergsten is a great author. (Before I forget, I've never met him and have no incentive for saying this.) Writing technical books is hard work; making them informative, accurate, and understandable is even harder. He pulled it off here just like he pulled it off in his "JavaServer Pages" book. Buy 'em both if this is your area of interest.

The book is
- PRACTICAL - the example application has everything you use in data-processing web-app (CRUD, table with paging + filter + sorting, multiform processing, rule-based data-processing)
- STRAIGHTFORWARD - from HTTP+Servlet+JSP introduction to JSF; no chapters with manager's rumours ;-)
- EASY ENGLISH - if english is not your mother-language you will like it. Its easy to read; simple straight sentences without garbage words !!!

This is the best intro to JavaServer Faces for someone with experience in developing Java web applications. I started out with Core JavaServer Faces based on recommendations here, but I was disappointed. JavaServer Faces does a much better job of explaining the implementation of JSF components, converters, validators, events, renderers, etc. And the author does so with a lot fewer pages, and fewer code listings.

The book is about half "how to and why to" and half reference material. The first half of the book does a good job of explaining how everything works, and I actually find myself using the reference material once in a while.

but overall fails to deliver. I bought this book alongwith Core JSF. The latter turned out to be much better for getting into JSF. This book has some coverage on creating views in code or using html/xml etc, but otherwise it lacks any depth in other topics.
One annoying thing is there are no subsections in this book...the only way to tell which section you are in is by deciphering the font SIZE (its the same font, same style)!!

This is one of the best O'Reilly Java books I have read in some time. The use of graphics is very effectively coupled with tightly written and interesting exposition. Nowhere is this more evident than in chapter four which works through an entire web transaction both on the client and the server.

About two thirds of the book covers JSF in-depth. The last third, in the appendices, gives an O'Reilly style reference for the components. Before the reference section the book covers the basics, like forms. Then goes into advanced topics like internationalization and finished off by covering the creation of custom components and layout systems.

This is a must read for anyone using or evaluating JSF. It's well written, and teaches the topic, as opposed to just translating the documentation.

I thought the book was well written. I thought some of the code examples were good. I did find the book a challenge. Knowledge of JSP and SERVLETS will help you get through this book. I struggled with some of book's code. This book is great for a beginner. I would reccomend this book to anyone who wants to get a deep understand of JAVASERVER FACES.