good intro for JSF but...
343422
I am currently reading David Gearys Core JavaServer Faces book. I have read Chapters 1-9 and Chapter 12 (Ch 10 talks about JSF/ external service, Ch 11 about JSF/wireless clients).

One thing that annoyed me right away was he starts talking about the core JSF classes (UIInput, FacesContext etc) in early chapters without a formal introduction to the JSF class hierarchy. He does do a good job in laying out the JSF and HTML tags, but he never does the same for the classes. Well, I think that maybe the class hierarchy will come soon, but as I finished chapter 9 (custom components), I realized he never did that. As a programmer, I feel that this is a serious lacking in a book. Again, as a programmer, I managed to overcome this lacking by referring to the JSF Javadocs for the class hierarchy as I was reading thru the chapters. David Geary's own article on JSF does a good job of introducing the classes (although the names are a little outdated).

His examples are very good (the downloaded code builds/works great), but I did not find any that "pushed the envelope" of JSF. For example, in the custom components chapter, he talks about building a custom spinner :roll:; yes, this is a good intro to howto, but I would like to see something more complicated and exciting, like a tree or a list component. After all, the ability to plugin custom components as tags is one of the enticing features of the JSF specification. It would have also been nice if he had talked more about JavaScript/JSF interaction.

The book is about 600+ pages long, but I think half the pages are just code printed (a lot of the code is also repeated in the discussion within the chapters). I don't know if this is good (lot of printed code) or bad (lot of wasted trees). The longer chapters kind of meander between discussion of code and printed code, and by the time I was with the chapter, I had to go back and put the pieces together myself. It would have been nice if he summarized the concepts in the end. (I plan to summarize the `Custom Components' chapter soon)

I did find the chapter on Tiles and the `How do I' section on using the Commons Validator for client-side validation, quite interesting and informative :cool: (although, I think he should have delved more into these topics instead of a whole chapter on the JSF dataTable tag!)

Bottomline, Core JSF is a good introduction to JSF with some advanced discussion too. I recommend it to get started on JSF, but with a healthy dose of JSF JavaDocs and/or another book.

read the full review here ( [...] )
3569815
It turns out to be as much user manual for a validation tool, which is ok.  I'd been hoping to use it to check a complicated protocol for a product I was building, but couldn't make any progress in a month.  Partly this is my own inadequacy, partly its a problem of applying formal methods to real-world cases, and partly its a problem of examples that are too simple (reflecting the problems of formal methods).
On the other hand, the description of race conditions in the introductory material is lucid, and if you haven't designed in and debugged a few of those, you might find it valuble.  A bit pricey for that, though.
833200
The book provides a simple introduction to Tomcat 7. Its 270 pages cover basic aspects of running and configuring the servlet container including deployment, session management, security, filters, Apache integration, logging and JNDI. However it lacks details that an experienced user would probably expect to find.

The text is simple and easy to follow but quite awkward to read since articles are missing everywhere.
For each topic, Listings provide configuration samples and Tables give brief references for XML element attributes or configuration options available.

Several discrepancies between the text and the Listings/Tables exist all around the book. In some places sections have been moved around without adjusting the text. Especially Chapter 1 on installation is messy. This is not very encouraging, especially for a beginner.

I did not expect to find a discussion of JSPs in the book. The authors suggest that it is important to understand the JSP code samples in the rest of the book (but there are almost none). The Preface claims that this is the second edition of a book on Tomcat 4 and that the purpose of the book is to provide an introduction to developing with servlets and JSPs but the material is too short to be of any practical use and quite out of place since MVC frameworks and tag libraries have superseded JSP scriptlets in web application development.

Chapter 11 actually picks the Spring MVC framework and discusses it in 11 pages. Again, to me this is too short and pointless. You certainly bought a book or read the online documentation on your MVC of choice (which is not necessarily Spring) and there you found much more detail on it and how to integrate it with Tomcat. I think the book should have been entirely dedicated to configuring and running Tomcat (after all this is what I expect from a book entitled Apache Tomcat 7).
3485536
This is a good introduction to javascript and jquery. It certainly covers the basics of both.  My issue is with the binding. When you first open the book it is beautiful, especially compared to the dry layout of most beginner's programming books.

Unfortunately, after a week or so of use the binding has fallen apart with large groups of pages coming unattached. It's not nearly as attractive with a roll of packing tape holding it together and difficult to continue to use a reference.
722970
Kito Mann does a great job introducing JavaServer Faces in this book.  He breaks the book into parts that let the reader first learn about the architecture and fundamentals of JSF, then he gets into the UI side of JSF and finally to the application programming side of JSF.  This format provides a nice way to go from easy to learn concepts to the detailed programming environment.

I also feel the projecttrack example application that he builds through the book is an excellent way to get hands on with JSF.  My only complaint is it is for JDK 1.4 and not JDK 1.5 but I sent an email to Kito and he is working on the upgraded content.
4711054
The book is very helpful for beginners. Written by an industry professional, and gives you more relevant information to web coding, such as dealing with browsers and different audiences, rather than code only. Again, this is for beginners, so don't expect to learn all of XHTML after reading this book. It's a good start though.
3819760
It is clear to me that tutorial (i.e. an aide to "tutor") is what defines this book's purpose.  While I agree with the other reviewer's comments about what this book lacks, I would like to complement the authors  on what I believe is the greatest benefit of "The JFC Swing  Tutorial". This is it seems that no matter problem I'm having with a  particular aspect of Swing, this book gives me a "place to start"  (isn't this what a tutor is for?).  Yes, there are some gaps in its  explanation of the Abstract/Default Table and TableColumn Model classes and  some of the Event Handling material is too terse, etc.
However, time  and time again, I've been in able to jump into this book  "mid-trail" and wind up "on course" for solving a  Swing-related problem.  Some times the journey leads me to the constituent  WEB Pages. Other times it's a trip into a JAVA IDE Debugger and/or a look  at the javax.swing class soruce files.  In any case this book has been the  tutor I needed to learn Swing fundamentals and has led me to discover some  advanced Swing features as well.
3113163
If you want to start with JS go for it, if you already know JS, go for something more advance :)
2373932
[...]This book is written with very simple examples. Few things are here and there but over all, this book will help you to get started in right direction. What this book is missing is information about Mixin, Ajax, integration with spring and hibernate. But purpose of this book was to give a jump start and not to teach everything. So don't be discouraged by reading negative comments of few people. Get your copy today.
4034223
User Interface Design is a topic which I have always been interested in. I believe it was PCWorld Magazine that used to have a column dedicated to improving the design of a submitted interface, and there were many things I learned from that column. This book seems to work from the basis of that column, but doesn't go as far as I would have liked it to.
There are many anecdotes included in the book, and they were very illustrative as to the problems people encounter when working with a badly designed interface. I especially liked the concept of the mile-high menu bar that Mac users have, and how that compares to the small footprint that a Windows user must target to open a menu.
Still, I was left wanting more. The book serves as a great introduction, but if you're already done some UI Design, you might already be familiar with most of what is explained in the book. The anecdotes are what really make the book appealing, but I wouldn't recommend purchasing the book just for those.
It's a good book, it just falls short of what it could have been.
2528311
Personally, I don't really use this book too much. It is a very general primer to web 2.0 with AJAX. It covers the Dojo toolkit and Prototype / Scriptaculous JavaScript libraries, but doesn't show you the true power of JS and really leaves you wanting more.

However, if you are lost or new to the web development world, this book will give you a good foundation. I would recommend picking up the O'Reilly definitive Javascript book and Prototype / Scriptaculous "bungee" book by Pragrmatic Programmers immediately after.
3983083
I bought this book two months ago. As a beginner, I found it very easy to understand and to master the basic structure and basic syntax, however, when I finish reading this book and ready to put it into practice, I found  that this book lacks more details about the Cascading Style Sheet and some  other useful tags. In fact, I learned more things from Webmonkey about the  CSS rather than in Chapter 9 in HTML Definitive Guide.  Anyway, it is a  book for Freshman who wish to learn HTML.
1546612
This is a good book to get your feet wet when diving into mobile development.  It provides good examples on how to get started and gives a number of code snippets in each chapter.  The issue is many times they explain what you need to do only to throw all of that out when they put the code together.  For example, Chapter 8.  I was tasked to cover this chapter in a book review to other associates.  The chapter is clear, talks about using phonegap build to create the apk file that you download to the emulator or to your phone.  Good stuff.

The issue is as they are putting together the Tartan Hunt app the code deviates from the prior text covering the chapter.  On page 350, they even warn you that the code looks different than what was just discussed in the prior pages.  The captureImage method is way different and that required me to spend a bit more time trying to make sure I understood it completely.  The other issue is the book left out an important requirement - a feature to allow permission to store files.  It took me a couple of hours of searching on the forums to find out that you must add a feature to the config.xml so that once you take the photo that pressing done or check takes you back to the tartan and you see your photo added.  Otherwise, pressing done does nothing.  I understand that typos are common in books but the source code from the main site doesn't include the changes, yet the apk file they say use as a last resort does work.  Why not add an addendum or maybe a readme file to the root of the chapter source code giving this info?  Remember, your audience is new to mobile development and may not know about all of the feature permissions.

Keep in mind, the frameworks used in the book are constantly updated.  What you see in the book may not work as designed.  It's a good book to get a taste of mobile computing but you may need to get separate books on the various topics covered (like HTML 5, jQuery Mobile, and docs).  This might be daunting to the beginner who has never developed code for a mobile device.  Keep that in mind that if something doesn't work, you will need to do some research.  They do a decent job of providing the final code for each chapter so compare your code with theirs if you find your code doesn't work.
3747638
As opposed to the first and second edition which were fabulous in terms of conciseness and didactics some slatternliness has crept into the third edition.
Especially the chapters on container managed persistence could have been edited more precisely. Often it is not clearly stated how an entity bean is referenced (e.g., the beginning of the "one to one unidirectional" section of chapter 7). In terms of didactics it would have been good to have a summary of the hard rules, - like "relationship beans should always be local beans" -, something which is hidden somewhere within chapter 6 (I think).
On the other hand some things were added or discussed in more depth which are quite useful. Especially chapter 15 (Design Stretegies") can give you an excellent start after having processed all the theoretical stuff. Furthermore I like the introduction of online material which can be used for exercises with some EJB containers.
All in all, still one of the best and most comprehensive books on the subject! Don't forget to check Ed Roman's book on Enterprise Java Beans, however!
1068237
This is a good book for a beginner who is just approaching Java.  They definitely take the "for Dummies" approach here and assume that you have little to no knowledge of programming from the start.  The one gripe that I have is that all of the JDK installation and configuration appendices cover Windows only.  It would have been nice to see alternate instructions for Linux/UNIX/Mac OS.
658112
I'm somewhat new to web dev. I've dabbled with basic HTML forms and CSS before, and a little bit of PHP, but nothing about doing both backend and frontend web dev. What I liked about this book was the actual architecture of writing up a RESTful API via Express, which I thought was handled pretty well. The sections on Node and Express give you a pretty decent handle on routing, but I felt the intro to Angular was a little lacking. You'll learn basic Angular concepts like routing and dependency injections, but I had to look up a few Angular documents/presentations on the side to really get the core concepts around which Angular is built. Additionally, there was a bit of debugging as some of the Angular modules are now outdated, but this was generally as simple as searching around for the new module names.

Took me about 2 weeks to work through this book on and off. I'd recommend it if you're looking into this stack for the first time. If you're experienced to web dev and RESTful API's, you might be able to just get by off documentation and looking up best practices for an Express/Nodejs application.
786525
I just began coding GXT and found that without an understanding of the basic concepts of this environment the learning curve can be quite steep. Coming from a Swing background GXT's MVC programming pattern isn't entirely foreign but there are sufficient differences, introduced partially by the client-server nature of the code, to give me reason to scratch my head. Stores? Loaders? Models are a familiar SWT and Swing concept but GXT adds it's own quirks. Beanmodels?

I needed a way to be brought up to speed, to get a handle on just enough of GXT to 'take it from there'. Let's face it: GWT and Ext-GWT are technologies that are in rapid flux. It is almost impossible to keep up with it with literature. A work that is up-to-date today can be obsolete six months from now and I believe the book wisely understood that it could only get you started and did not intend to provide the reader with an indepth review of all the intracies of GXT. You won't find any highly detailed descriptions of classes and methods here - material that could not survive a year of usability. Instead, the author has focused on clarifying the basics that need understanding if the programmer even wants to begin to interpret the many source code examples GXT shows both online or the downloads. It intends to provide a mere foundation, to explain the principles behind GXT, the way it hangs together. Do not expect highly detailed examples - after all, they would be mere reproductions of the GXT examples.

The book attempts to provide the reader with answers to the most obvious questions a novice will have when studying GXT code - and after all, this *is* how you are going to learn to code using this framework and do not expect to find a comprehensive work on it like you would on Swing. It certainly got me jumpstarted and writing exploratory code in very little time until I found myself delving deeper after 'having gotten something to work'. And this is after all what the book wants you to empower to do: To be able to ask the right questions.

It will certainly not answer your question for a *specific* programming answer for this or that problem with specific twists to it. That you will likely have to take to the forums or a few hours of reading code. However, it will get you coding with GXT in a short amout of time and that was invaluable to me.

I was a bit disappointed at the brevity of the piece (it is quite short with 140 pages). It sometimes simply points out the existence of different concepts without so much as even elaborating on a complete code path from a to b. That is something I feel is worthwhile correcting and I feel the book would have fared better with another 70 pages or so - just to cover the basics.

Still, I was happy I bought it, particularly in light of the fact that there is almost no literature available on the subject matter.