The teaching style is light and humorous and that's great and all (though definitely aimed heavily at 20-somethings), but when the code examples simply don't work, glib doesn't cut it any more. In a beginner's guide book the code must be solid, even more solid than a book aimed at experts, because the beginner doesn't have the knowledge base an expert would have to figure out obvious flaws. Unfortunately, what this book is presenting as valid working code contains major flaws.

This is the kind of book where you start doing the exercises and think "Oh, I can get this", then you end up banging your head on your desk because it seems so easy that you should be getting it, but nothing you do works. Then you lift the code verbatim from the book (and its *known* errata) and realize it also just doesn't work. Hmmm. Then you find reviews and blog postings complaining that the code doesn't work. Then you wonder how well the people that rated the book at 4 or 5 stars know the author...

In all fairness, the cute presentation does give a feel for the *conceptual* basis of the subject, but don't expect to come away from the book with anything concrete that you can set into a functional web project, unless the code has been re-written in a later edition or on the web.

Hopefully Head First's other Ajax book is a lot better to make amends for this lemon, or else I may have to give up on this series. That would be a shame. I agree with the series' stated educational precepts. Learning should be engaging, thought-provoking and fun, but folks, the code needs to work(!) or else it quickly stops being fun.

Notice the rest of the books in this series are all "Head First ...", but this one is "Head Rush ...". It was an alright introductory book at the time it was published, but there are now better choices. I assume it has been replaced in the O'Reilly / Head-First lineup by the recent "Head First Ajax" (seriously, I'm not kidding ... this is reminiscent of them remaking The Hulk, again).

Reviewing this book in a vacuum I'd say its strength is its very thorough, very tutorial, very well-illustrated coverage of the lifecycle of an XMLHttpRequest. Grokking asynchronous, callback-based programming is one of those quantum leaps in understanding ... like learning what a pointer is. So having a tutorial available is great. But I could swear that there were two chapters in a row that covered exactly the same example.

And does anyone know how I'm supposed to choose amongst these titles in the same series: "Head Rush Ajax (Head First)", "Head First Ajax", "Head First Javascript"?

Other worthy choices:
- "The Book of Javascript", Thau
- "Ajax: The Definitive Guide", Holdener
- "Adding AJAX", Powers
- "Building a Web Site with Ajax: Visual QuickProject Guide", Ullman

Now, go build some Web 2.0 thingy that replaces the Desktop OS!

The book is humourous and a pleasant read, and a fun way to learn Ajax in your easy chair by the fireplace.

But *don't* try using it on the job.

I tried building a real-world application with this as my guide - as I went through each chapter, I'd use the methods conveyed by the examples to build my own project. This went well until I got to the section on POST requests. As before, I adapted the example to my own project - and it didn't work. The problem is that the code on page 299 is flat-out wrong, and they don't tell you this until page 308 - after a several-page diversion into another subject. Then, on page 308, they finally reveal that on page 299 they had skipped an essential (but non-obvious) step.

Meanwhile, I had wasted about half an hour wondering why the back-end application wasn't receiving any of the form contents, putting in javascript in the front-end to display what it was sending before it sent it, putting logging in the back end to dump the inputs to files for analysis.

My copy now has "WRONG" written in one-inch letters across page 299.

(I was reminded of an episode of M*A*S*H. An unexploded bomb was in the camp, and Hawkeye was trying to defuse it while Radar read him the instructions - slowly, one step at a time - from a safe distance. The instructions were something like "Cut the red wire. But if there are also two black wires, you must not cut the red wire.")

Authors, I can appreciate your writing style and your general method of teaching - but please be aware that some programmers like to test our applications incrementally, and leaving a booby trap in the code just wastes our time.

A conceptually solid intro to AJAX plagued by errors in the code samples -- see http://www.oreilly.com/catalog/headra/errata/headra.unconfirmed. Even some of the sample ajax apps running on the headfirstlabs site don't work! For instance, visit http://www.headfirstlabs.com/books/hrajax/chapter02/breakneck/pizza.html, type in a phone#, and watch as the php incorrectly dumps out all the addresses in the mock database. Did the author even bother to test out the sample apps?

Some people prefer dense reference-like texts while others get droopy eyelids after just a few pages. Face it--this is complex material we are trying to learn. The O'Reilly Head First series has really figured out how to present concepts that can be difficult to understand, especially for people who are new to the field, in a way that makes it easy to learn.

If you are new to Ajax or if you have some experience with it but want to fill in the gaps, this is a great book.

This book does exactly what it claims to do: teach you what Ajax is, and the basics of using it. After finishing this book, I feel like I have an extremely solid base with which to read and understand a more advanced book. This book didn't teach me any best practices, common Ajax patterns, cool tricks, or anything else fancy; it just gave me a firm, solid understanding of how to use Ajax, and that's exactly what I needed.

The book spends about 20 pages introducing you to their genius learning methodologies that keep you interested and involved. That would be great if I was reading this book to kill time and had to be kept interested with pictures and games. In reality, I want to learn the material as quickly and directly as possible. If you are like this, skimming the book is about all you can do. I skimmed it in about 20 minutes (I have previous Ajax knowledge) and it was an OK Intro refresher. If you are serious about learning this and have an attention span greater than a 6 year old, you do NOT want to get this book. It's like playing Where's Waldo for relevant information among the spam of dialog boxes and arrows zig-zagging across the screen.

With that said, if you are learning Ajax grudgingly and don't care how much time you spend, this book will be great.

I have never read any of the "head rush" series before... If they are all like this one, I will read many more.

This book explains the core of Ajax in the first chapter and that is what sold me (I read it in the book store over some coffee).

This covered very clearly what I have been looking for on the subject. Those items were:
1) What is the purpose of Ajax? Why would you use it? How does it help? (Looks great for more than GUI/UI, it also reduces bandwidth.)
2) What is the overview of Ajax? What is the application design workflow?
(The request, response, process, and update model is very simple and easy to understand.)
3) How involved is it? IE: will I need to learn tons of new concepts to use it effectively? (I turns out to be pretty trivial in concept if you understand web programming basics.)
4) What are the "catches" with browser compatibility? (Turns out these are more easily compensated for than I originally imagined.)

I could really go on and on about the questions that I had that were answered but the point is clear so I won't write a book on this book...
=)

Buy it if you're new to Ajax but familiar with Web technologies (PHP, JavaScrip, HTML, XHTML, CSS, DOM).

If you're not ... ah... this could be really confusing or a VERY solid start to learning.

The PHP examples are simple PHP so you won't have any PHP epiphanies reading this.

This book is worth your time (and money) if you don't already understand the Ajax paradigm.

It was perfect for me.

Very nice book. I am enjoying reading it. It brings new view to asynchronous web javascript using non formal approach. I like Head First series.

For me, all the information in this 400 page book could have been effectively presented in about 50 pages, using a normal page layout with illustrations. While reading this book, I felt like I was wasting my time. Eventually, I found myself skimming the pages for nuggets of useful information buried in all the fluff (handwritten notes, arrows, and pictures of dogs and guys in ribbed sweaters.) I am willing to consider that perhaps the style of this book is just not right for me. But even for someone who likes/is compatible with this style, I believe the limited amount of actual information contained in this book makes it not a good value.

The top-most declaration on the front page of Head Rush Ajax is "Get it in your brain, FAST". A more appropriate comment would be: "Get it in your brain after taking a tedious journey down a long, winding road". I found some useful information about Ajax, but only after being frustrated by having to wade through an excessive amount of fluff, even if the dog pictured so often is really cute. Head Rush Ajax typically uses about 20 pages to present and explain material that anyone with any coding experience at all can learn in a paragraph or two. So, if you are an absolute beginner, this book might be just the thing, with entertaining inserts to give you a break if you need one. But if you're even a little experienced with html, css, javascript or php you will probably find the pace to be way too SLOW.

The content of this book is a little odd. It rushes through introductory topics for the browser side at the beginning to get you going, but has no discussion of what you might set up as a web server to model the back end for which they provide PHP code. This is especially odd given the emphasis on active learning; you can't actually model the whole system from their instructions without other references. Having configured enough open source servers, I know this isn't hard and could be handled in a short appendix. The comment in the editorial review to the effect of "have your first app working before the end of Chapter 1" needs to be evaluated in that light.

The Head Rush book series is likely something you like or hate. I find the tone of the authors smug and self-satisfied, and for me it works against their stated goal of really engaging the reader. The pedagogical concepts are not particularly new, but they have a theory they think is revolutionary so they have an overly assertive style: a "conversational" tone that is self-consciously hip, hard-to-read handwritten comments, and cheesy photographs and jokes. The same pedagogical methods could be presented in a much more neutral fashion. The style also means that this would be a poor reference after you gain some skills.

This book does one good thing, and that is introducing the reader to AJAX.

Compared to other Head First books it is a little more repetitive, takes longer to get the reader's head around the topic at hand and finally it has external requirements for the reader to be successful in going through the book in follow by example mode.

The external requirements of the book are:

1) You need to be able to understand PHP on a very basic level in order to follow through the examples in the book.

2) In order to follow step by step the book, you need to set-up your test box as a WEB/PHP server.

Requirement #1 is not problematic, #2 may be problematic to some folks, to others it may be even fun -- BTW: The page at [...]
I would have given this book four stars for beginners if the instructions for #2 would exist, at least in the head first site, but they are not there yet by 4/10/07.

Additional notes:

- Chapter 3 example runs dog slow in FireFox and does not render properlyin IE7.

This book does one good thing, and that is introducing the reader to AJAX.

Compared to other Head First books it is a little more repetitive, takes longer to get the reader's head around the topic at hand and finally it has external requirements for the reader to be successful in going through the book in follow by example mode.

The external requirements of the book are:

1) You need to be able to understand PHP on a very basic level in order to follow through the examples in the book.

2) In order to follow step by step the book, you need to set-up your test box as a WEB/PHP server.

Requirement #1 is not problematic, #2 may be problematic to some folks, to others it may be even fun -- BTW: The page at [...]
I would have given this book four stars for beginners if the instructions for #2 would exist, at least in the head first site, but they are not there yet by 4/10/07.

Additional notes:

- Chapter 3 example runs dog slow in FireFox and does not render properlyin IE7.

This book is very thorough and has lots of great sample code with explanations. The text can be amusing or annoying, depending on mood (since I'm not a total beginner, sometimes I just want to see code and resent all the conversation). However, this text is quite accessible to web beginners, which is one reason I chose it for a course in summer of 2006. Recommended for beginners, or for anyone who wants their hand held through the dirty details.

This is a good first book on Ajax. It shows you the basics, which is what this series of books is best at. It's probably what you need if you need to get started.

I purchased this book because it was the "required" book for the course I am taking for Masters. But being a programmer myself for many years, this book is a waste of time. The chapters are lengthy and drags the content too much. May be a good book for beinners, but not for anyone else. The book lacks in-depth discussion and not to the point.

This book is for people who know JavaScript and they are a step above the "pop-up windows, rollover images, and steal scripts from the Internet" crowd. It assumes at least a novice amount of knowledge.

I'm the kind of person who needs to understand a concept before I get details, else I get lost. I was an ActionScript expert, and mediocre at JavaScript... but didn't know what a DOM was. I read the book very quickly and I was up and running at work, where I was expected to be doing some very advanced stuff. This book helped me get going, but I couldn't have succeeded without "Ajax in Action".

One of the founders of the Head First series is Kathy Sierra who writes the "Creating Passionate Users" blog. I'm not a big fan of blogs, but I read her's everyday.

This book is very good if you have no idea what Ajax is and you want to get an idea of the basics. It is very effective at helping the reader understand the concepts behind Ajax, but once the user grasps these concepts the book becomes pretty useless. The book is so good at teaching the basics, that it is has no value as a reference book, which is exactly how it is advertised.

My sole complaint about the book is that it only demonstrates php scripts for the server-side scripting. I would have liked to at least see one example of a Microsoft ASP.NET script.

I checked this out from my public library last night, and now am thinking about writing a letter to ask why it wastes money on stuff like this.

This book takes 30 pages to explain what other books would in a page or two. If you like lots of white space around your text and diagrams, this is the book for you. The entire book could be presented in a couple of chapters.

But that's not the biggest problem. The book is solid on fundamentals but teaches nothing about Ajax design strategies or code refactoring. Many frameworks have evolved for developing Ajax applications. These can save programmers a huge amount of time and pain, but the book only mentions some of these in passing at the end. A better book, one like Ajax in Action, would make refactoring a big part of every chapter.

You may, like me, be wondering what the 'Head Rush' appelation is all about compared to the 'Head First' series. This is a slimmer book than the 'Head First' series, coming in at 400 pages (compared to 700-800 for the HF series). Also, it's focussed on a smaller topic. Apart from that, though, it's exactly the same format as the HF books, with some old HF characters popping up. HF stalwarts may be surprised to find that Frowning Woman In Denim is absent from this book, though.

As a prerequisite, you need to know HTML and CSS. You should also know a bit of Javascript. Nothing too fancy, just enough syntax to follow variable definitions, loops, conditionals and subroutines. If you don't know JS at all, I think you'll have trouble keeping up. The server side code is all in PHP. I don't know PHP, but it was close enough to Perl that I had no difficulty following it.

You also probably don't want to know too much about Ajax already. In fact, if you've done a lot of Javascript before, you may find the chapter on DOM a bit slow going. You'll find the pace just right if you're someone who's taking their first step in scripting on the browser side.

Brett McLaughlin proves he can do the HF style in this book. No worries there at all. In the first chapter, you could perhaps argue that some of the diagrams are over-annotated and have just too many arrows in them. In previous HF books, it was normally obvious what the flow of the diagrams were. Not so here, in a few places. However, from chapter 2 onwards, things are fine. In fact, the whole thing is a delight, as usual.

HR Ajax covers the basics very well and entertainingly so: what makes Ajax different from standard HTML requests, asynchrony, manipulating the DOM, and using XML versus JSON. Plus it mentions some browser-specific gotchas (including Opera and Safari), and provides very brief introductions to JS libraries like Rico and Prototype. Hardcore JS GUI-masters, this is not the book for you. Newcomers to Ajax, start here. You'll be glad you did.

This was my first "head first/rush" book from O'Reilly and it'll probably be my last.

The format/layout of this book is silly--even considering it's an introductory book meant for the masses. Finding specific information or examples is hit-or-miss. The "humorous" tone of the authors is anything but.

Only get it if you are completely new to computers and programming, pretty much of no use to everyone else.

I have read or started to read different books on Ajax. This is the first one I have completed. I have been programming javascript,PHP,ASP, database interfaces for over six years. Have been using the DOM model in programming for some time.

No, this does not completely cover DOM, XML, javascript by any means, but it is a good book that shows you how to better utilize them and tie them all together.

But after reading and working through this book I feel I have a much better understanding of what I can do and with my experience and the knowledge I gained from this book, feel that I have a better idea of when to employ it's use. I highly recommend this book for intermediate PHP html javascript programmers. Beginners may like this book and I wouldn't steer them away, but it might be a little above their heads. Experts, what the heck are you looking for a book for anyway. This isn't a reference.

Some of the plusses for me were:
This book used W3C standard compliant code. [ I never want to program browser specific code again ]

I use PHP 4.x. I read one book was coded using PHP 5.x, I started recoding the examples so they would run on PHP 4.x and got tired of that. Then installed a server with PHP 5.x. That helped but my head was still getting around PHP 5.x and what I could use on the servers at work which are still PHP 4.x.

[...] This was more browser independent and gave me some hints on browsers which I don't use all of the time, like Opera and safari.

Warning to others, yes you will need a server which runs PHP to run the code examples. But if I were to choose one scripting language over another I would choose PHP, because people can get the server software to run PHP for free. There are also some sites which have PHP webhosting for a very small amount.

I did at times get tired of the jokes. But I did like some of the different ways he presented information so that I knew I wasn't just reading it, my head was actually thinking about the different uses. It took me a couple of chapters to get in sync with the author, but after I became more comfortable with the format things progressed pretty fast. I finished the book in a weekend. Started Friday night on the first chapter. Did chapters 2,3 part of 4 in 5 hours on Saturday and finished the rest in 6 hours on Sunday. So roughly 14 hours on the whole book.

Head Rush Ajax is a great book covering the introductory topics of AJAX, however if you already know the basics of AJAX and want to expand your knowledge to more advanced topics this book is not for you.

If you are a complete beginner with respect to many of the skills needed for Ajax: HTML, CSS, DOM, JavaScript, then this book might be for you. All of the O'reilly Head First/Head Rush series are excellent teaching books and do a wonderful job at teaching skills in small bite-size chunks. Lots of pictures, exercises and games. This is about as fun as a book can get.

But once you've read the book, you'll realize that you really didn't cover much ground at all. 400 pages of Head Rush Ajax is about the same amount of Ajax technical material as 40 pages of Ajax in Action. All those fun pictures and games take up a lot of pages! Only the most basic topics of Ajax are covered. Much of the book is wasted explaining web-development 101 level subjects...

So it wasn't possible for me to give the book 2 different ratings. As a pure beginner's book - this is a 4 or 5 star book. But if you already know HTML, HTTP, DOM, and CSS -- then this book becomes a 2 star Ajax book because it teaches so little about Ajax.

Do you want to learn , understand, and remember Ajax, with a goal of developing more responsive web applications. If you do, then this book is for you. Author Brett McLaughlin, has done an outstanding job of writing a book that in no time will allow you to write JavaScript code that fires off asynchronous requests to web servers.

McLaughlin, begins with an overview of how to use Ajax. Then, the author shows you how to send requests on different browsers, master ready states and status codes, and even pick up a few extra dynamic HTML tricks along the way. Next, he shows you how to send your users' requests to a server, and let your users keep on working while they're waiting on a response. The author continues by taking you on a stroll through the Webville Tree Farm. He also shows you how to write a nifty DOM-based application. Then, he shows you how to post data. Next, the author delves into a discussion about XML. Finally, he provides an extensive overview of XML and JSON.

This most excellent book is designed to show you how to learn Ajax and asynchronous programming the right way. More importantly, this book provides a visually rich format that is designed for the way your brain works.

I bought 4 other head first series books, java, EJB, Design pattern, and Servlet. These books were fast, funny and of course, informative. I really love these series. However, when I read this book I was so disappointed. Most explanations are redundant and it made me boring and the reading pace was suspended. I think the author have to add more examples and shorten the explanation. I regret to buy this book. Not recommended.

It's a decent beginner's book. You really can boil the contents to about, say 25 pages or so. It feels like a Bill Ny the science guy version of an AJAX book (for those who remember who that is). The layout, is, honestly, a bit annoying - and looks geared towards 13 year olds. But if you can get past that, and the very slow pace, it's not bad. If they cut out half the silly skits like "project:chaos" and the interviews, and boil it down to about 100 pages - it would be a great book... for beginners.

The Head Rush series by O'Reilly is great fun! It's a fun and quick way to learn a new topic. They are not reference books
so you will always want to complement them with a "heavy tome". But they are a wonderful way to learn dry, technical subjects.

The book uses PHP so you may find it helpful if you know that language. But since the meat of Ajax is mainly Javascript it's not really necessary.

All the pictures and graphics in the book will give you a great understanding of how the client is talking to the server side and the different request states of Ajax. It can be rather complicated to understand at first. This book gets you through that hurdle with ease.

Many types of web developers may not know about callbacks and asynchronous programming. Here, the diagramming and frequently asked questions will be helpful.

If you don't know Javascript, the book's section on the Document Object Model will get you through the basics. But you will eventually want to buy a JavaScript book.

This book even includes a chapter an SQL Injection. This is not specifically an Ajax problem so it was rather surprising to find this chapter. It is good information though for any web programmer.

Near the end, a chapter talks about XML versus JSON. If you don't know Javascript, you may not understand JSON from this book. But if you catch on quickly by learning from example, you will be ok with the discussion.

The book gives a very quick overview of 3rd party Ajax libraries. Probably not enough in depth to get you started using them but the chapter will at least make you familiar enough with them so that you can go research the ones you like.

This book is going to give you a great foundation to understand how asynchronous programming works, how to make an XMLHTTPRequest, and how to process the response in a callback. Through this book, you will get the big picture of Ajax programming and understand its fundamentals. This book should appeal especially to web developers who only want to know enough to "talk" to the back-end programmers with Ajax.

Once you have the fundamentals from this book, you can then buy another "encyclopedic" book to use as a reference.

Probably not useful as a reference book but will serve well as introduction. The cluttered style with rather odd callouts can get a little distracting.
Having said all that, I still think it's worth 4 stars because it does cover the basics in a serial fashion and the callouts did address some questions as we proceeded. Perhaps if the balloons were more serious and a bit more direct instead of attempting to be so cool they would be more useful.

If you are completely new to web development, then this book is for you.

If you have at least a moderate understanding of HTML, JavaScript, and the request/response model, then you don't need a book on Ajax--especially this one. Ajax is a very simple concept and this book will probably be way too simplistic for you. Save your money and spend 10 minutes browsing the internet.

I was wanting to learn something about AJAX, and this book caught my eye online. I wish I had browsed it in a store, because I could have gotten a book that would have been more useful to me. I'm sure it is an excellent book, but I think it is targeted for people younger than myself (I'm 47). All of the "hand written" notes with arrows, the "thrown on the page" layout, too many different fonts, it all just makes my eyes hurt, and makes it very difficult for me to follow. Will either sell it, or it will collect dust on the shelf.

But unfortunately not good for an experienced programmer. Headrush books are really good at teaching if you like to hear everything three times, each time taught a different way to you. That's the headrush style; They use cute examples, drawings, and text to teach.

If you learn best by reading a reference book with concise examples, this book is the complete opposite. I'm one of the concise reference types, so this book was a poor choice for me. I have to dig to find the code examples, and when I do find them they're tied together with lines or hidden on the branches of a tree.

Is this a good book? Yes, it's incredibly well written. But it has a very unique teaching style that works for some, but not for me. If you're experienced in HTML and CSS, and have used an object oriented language before, I'd recommend another book.

I am no new-comer to AJAX having read a number of books including AJAX in Action (Crane), AJAX Patterns and Best Practices (Gross), CSS Mastery (Budd), DOM Scripting (Keith), etc.

I felt compelled to read the book based on my past experience with the other books in the Head First series, of which I have read all of them. Reading this pointed out some basic things that I didn't pick up in the other texts.

The book is an excellent intro to AJAX and will give you a firm grounding so that you can facilitate your understanding of the concepts with the more advanced texts mentioned above.

Some people object to the style. I find it to be didactically refreshing. It's very different - there's interactivity - almost like having classroom training.

Some complain that it is repetitive. It is repetitive because it's a known fact that we learn and understand key notions by having them explained to us in different ways - and it enhances remembering. It's a form of diadactics. That's a good thing.

I suggest that one read the Head First HTML and CSS book before reading this one if you don't have the background - but I think the book doesn't assume much, and can be read by just about anyone.

It also motivates the reader to seek more advanced texts on DOM manipulation, Javascript, CSS, and even server side technologies.

I really think that this series of books should be put into an online course format. Maybe using Moodle with a plugin that would allow simulating the examples. It would be great for learning because it would facilitate the hands-on interactivity that one needs to truly understand the concepts that they are trying to get across in these books.

If the course is developed properly, the book could be used to complement the online course - so the publisher would actually benefit with increased book sales. And, if there is a course designer/developer working along side the authors, it would also be very efficient to create.

Ajax is a hot topic, now and Head Rush Ajax can get you started, quickly. While it uses the same learning principles as the Head First books, it follows a somewhat different format. It has less humor, less repetition, and a third less pages, really! Starting with a basic page using asynchronous communication, the book guides the reader into more complex examples. The final two chapters cover XML and JSON responses from the server script. The pre-requisites for the book should be a solid knowledge of html and some JavaScript exposure. Specific JavaScript functionality is introduced as required.

The example code is available from the book website. The server code is PHP script which may require some setup. Thanks to Apache Friends for XAMPP which will quickly install Apache http server, PHP, and MySQL quickly. If you do not want to create such an environment locally, links are available to run the examples from the book website.

Part of what makes the Head Rush book is the excellent explanations and the illustrations that convey certain concepts more successfully than text alone. A good example is the depiction of the HTTP ready states. It is also easier to retain and recall a graphic. The chapter on the Document Object Model (DOM) is particularly effective. This topic is extremely important in not only manipulating the page in the browser memory, but also in managing an xml document response from the server.

While I would have preferred the use of Java for the server side code, and the text contains a number of errors that should have been edited out, this is a solid introduction to Ajax. The code examples, illustrations, and easy to read text are combined to create an engaging learning tool. Enjoy.

It's very interesting,funny, concise and comprehensive. I really enjoyed reading it.

Easily the best Ajax book at the moment. The material is both entertaining and infomative. The asynchronous and client/server aspects of Ajax can make it tougher to understand, and the author does a good job of working through those issues in a way that makes it easy to understand.

The book also covers the DOM and DHTML issues that you need to get the most out of the browser environment.

HI this is good for Beginners. not for experts.
Lot of things repeated 3,4 times. Which is not there in other headfirst books?

Good for who wants to know Some Javascript/HTML basics + Good AJAX

For those that do not know, Ajax is not a computer language, but a methodology to allow you to make a web-browser an application run-time environment, by combining html/xml, javascript, css/xlst, the XMLHttpRequest object and server side scripts/servlets/programs to asynchronously modify the DOM on the client. You basically use javascript to write your application logic, xml/html to define the data-model, and css/xlst to control the L&F of the interface. The XMLHttpRequest Object is used to asynchronously request application data JIT from the server (so it doesn't have to be downloaded with the app). Because the browser stores a page in a DOM, if you modify it this cause the page the redraw/repaint (NB not refresh) itself using the css/xlst associated with the page. This means that the server only needs to send a small subset of the page (a bit like how mpeg encoding partly compresses by recording only pixels that change), and these requests can get cached by the browser.

This is a very readable introduction, however the head first style does not make it easy to use the book as a reference afterwards as the key information is spread over several pages. this is probably my only complaint (hence 4-stars).

I think that Ajax in Action is better. because it offers more detailed coverage, and shows you a fuller set of examples and kits/libraries.

However if you have been tasked to 2.0 the website yesterday. this book will show how to put the basics together in less than a day by pointing you at some handy resource. If you understood the above description you probably don't need to buy this book if you're a good googler, which is probably why there are quite a few second hand copies available.

It focuses mainly on the client side of Ajax, as the server side job is to determine the subset of data to return, which should be encoded in the client request.

This book takes a unique approach to learning. It focuses on redundancy - metacognition and such. I would recommend getting your Javascript and PHP down cold before moving into Ajax. That was my drawback. I give the book four stars because I realize the information is presented well, although some may find its approach a little too "dumbed down". I just wasn't ready for it when I read it. You may consider checking out Sitepoints Javascript Anthology if you are an inexperienced client side scripter. Also, check out Larry Ulman's PHP books... It will help!!!

As my first HeadRush book, I was impressed. Their techniques for learning and remembering the material are sound and moderately useful. It's been a while (nearly a year) since the last time I've programmed and this book was able to quickly get me back into the mindset. Although it definitely leaves a certain something to be yearned for from an advanced programmer, this book is good for exactly what it says: A jumpstart into the language and style and an overview of why and when to use AJAX. This book is good for people who have at least some familiarity with scripting and web programming and are looking for a new technique to use.

I like the concept of this line of books and for me they definately help me get off the ground with new programming techniques.

Unfortunately, this book is just a bit too basic, and after I was done with it, I still felt like I had only a very minor understanding of the subject matter.

Cons:

-- The first two application examples are nearly identical, so if you understood the first chapter, you get very little out of going through the second one.

-- One chapter isn't even devoted to Ajax. It teaches you how to create a DOM only application. While it is a nice introduction to the DOM, I bought this book to learn Ajax and I would have much preferred another Ajax application example.

Pros:

-- At least I now am off the ground and should be able to understand more complex books.

The book is intended for someone familiar with HTML and some knowledge of CSS and JavaScript. I am the intended audience. When I wrote this, I had read the first 90 pages of the 400 page book.

This book employs a new learning style, there are many pages in the introduction bragging about it. It doesn't work, at least not for me. There is so much repetition, non-nutritive filler and attitude, that new information is delivered in drips and drabs every few pages. I found the constant flood of useless information made it hard to concentrate. Even though I was very interested in the subject matter, the presentation style bored me and angered me at the same time. More on this below.

Every computer programming book starts with a "Hello World" example. And for a good reason. The way to learn a programming language is to start small (and nothing is smaller than a Hello World example) and build on it. That is not the approach taken here and it is a big reason why this is a bad book. The book starts with a medium sized example (mistake one) and then instead of presenting it as a whole, bits and pieces of it are presented across the first 60 pages. You couldn't take a worse approach if you tried.

As someone familiar with the old web programming paradigm, I was yearning for an example showing the exact same functionality done the old way and the new Ajax way. Side by side. The book doesn't do this. It doesn't do it at all, let alone side by side. The reader is never shown the whole project. How can you get your mental arms around an application you can't see? Not seeing the whole thing together made it harder for me to mentally envision where all the pieces go.

It seems to have had the same effect on the author(s) as shown in the disgraceful choice of variable names, which do not make it obvious where the piece fits into the puzzle. The lack of a naming standard is amateurish. At one point the same string of characters is used as a JavaScript variable, the ID of an HTML element and the NAME of an HTML element. Thus when the reader sees that character string, they have to work to figure out, based on the context, which of the three things is being referenced.

In making the case that Ajax style programming is better than classic web applications, the point is repeatedly made that with Ajax only the parts of the web page that need to be updated are. This point screams out for an example, but there is none.

Some of the screen shots are of Netflix.com showing the window that pops up when you mouseover the name of a movie. Nowhere is this mentioned in the text. This is a huge opportunity missed. Personally, I find the Netflix functionality very interesting. Instead, the entire beginning of the book uses a lame and cutesy example of selling snowboards, something so brutally artificial that it doesn't generate any interest on its own. There is a place for artificial examples, but if you're going to devote a lot of time to an application, it should be one that has, at least, a hint of usefulness.

An introductory article on Ajax on OReilly's web site uses an excellent example, chosing a userid when registering with a website/service online. Everyone can appreciate having their desired new userid validated in real time before entering all the other required fields. Ajax is a fascinating topic with many very interesting real life examples. Instead, the book uses a totally artificial one that no reader can relate to.

Writing style

No doubt O'Reilly is proud of the new writing style used in this book and, I suppose, other "Head Rush" books. It's bragged about in the introduction. I wasn't impressed. The style involves tons of repetition, even of simple easy trivial facts. This is both insulting to the reader and a waste of time and ink. It also includes lots of corny jokes along the way.

The style results in lots of whitespace. That is, there is very little information on a single page. My guess is that 3 pages or so in this book is equal to one in a book written in a more conventional style. So what? Sometimes when learning a topic, you need to see the forest. This book teaches one tree at a time, making learning more difficult. Tree. Tree. Tree. Makes is harder than necessary to visualize the forest.

When I read a computer book, I write in it. This helps me learn and makes, what I consider the important points, easier to review later. However, the books' style includes scribbles already. I had to read it with a red pen in hand, black doesn't stand out.

From the code samples page at headfirstlabs.com: "If you've ever read a Head First book, you know what to expect: a visually rich format designed for the way your brain works. Head Rush ramps up the intensity with an even faster look and feel..." I found the intensity lowered and the learning process extremely slow.

O'Reilly studied how people learn. They should, instead, have studied how people explain. A good explanation can be learned using any printing style. A bad one is bad, no matter what. The grammar in a letter does not improve if its printed on fancy paper with many colors and fonts. Bad is bad.

To me, being a good explainer is the only thing that matters. It is even more important than knowledge of the topic at hand (which can always be learned). Someone who explains things well, will explain any topic well. I don't have to have read Mark Minasi's OS/2 book to know that it explains the topic well. All his computer books are well written, regardless of the topic. Computer topics can always be studied and learned. Explaining things well can not.

I see this pattern over and over again - just because you know something doesn't mean you can explain it. Two separate skills. For still more, see computergripes.com

The book is intended for someone familiar with HTML and some knowledge of CSS and JavaScript. I am the intended audience. When I wrote this, I had read the first 90 pages of the 400 page book.

This book employs a new learning style, there are many pages in the introduction bragging about it. It doesn't work, at least not for me. There is so much repetition, non-nutritive filler and attitude, that new information is delivered in drips and drabs every few pages. I found the constant flood of useless information made it hard to concentrate. Even though I was very interested in the subject matter, the presentation style bored me and angered me at the same time. More on this below.

Every computer programming book starts with a "Hello World" example. And for a good reason. The way to learn a programming language is to start small (and nothing is smaller than a Hello World example) and build on it. That is not the approach taken here and it is a big reason why this is a bad book. The book starts with a medium sized example (mistake one) and then instead of presenting it as a whole, bits and pieces of it are presented across the first 60 pages. You couldn't take a worse approach if you tried.

As someone familiar with the old web programming paradigm, I was yearning for an example showing the exact same functionality done the old way and the new Ajax way. Side by side. The book doesn't do this. It doesn't do it at all, let alone side by side. The reader is never shown the whole project. How can you get your mental arms around an application you can't see? Not seeing the whole thing together made it harder for me to mentally envision where all the pieces go.

It seems to have had the same effect on the author(s) as shown in the disgraceful choice of variable names, which do not make it obvious where the piece fits into the puzzle. The lack of a naming standard is amateurish. At one point the same string of characters is used as a JavaScript variable, the ID of an HTML element and the NAME of an HTML element. Thus when the reader sees that character string, they have to work to figure out, based on the context, which of the three things is being referenced.

In making the case that Ajax style programming is better than classic web applications, the point is repeatedly made that with Ajax only the parts of the web page that need to be updated are. This point screams out for an example, but there is none.

Some of the screen shots are of Netflix.com showing the window that pops up when you mouseover the name of a movie. Nowhere is this mentioned in the text. This is a huge opportunity missed. Personally, I find the Netflix functionality very interesting. Instead, the entire beginning of the book uses a lame and cutesy example of selling snowboards, something so brutally artificial that it doesn't generate any interest on its own. There is a place for artificial examples, but if you're going to devote a lot of time to an application, it should be one that has, at least, a hint of usefulness.
Writing style

No doubt O'Reilly is proud of the new writing style used in this book and, I suppose, other "Head Rush" books. It's bragged about in the introduction. I wasn't impressed. The style involves tons of repetition, even of simple easy trivial facts. This is both insulting to the reader and a waste of time and ink. It also includes lots of corny jokes along the way.

The style results in lots of whitespace. That is, there is very little information on a single page. My guess is that 3 pages or so in this book is equal to one in a book written in a more conventional style. So what? Sometimes when learning a topic, you need to see the forest. This book teaches one tree at a time, making learning more difficult. Tree. Tree. Tree. Makes is harder than necessary to visualize the forest.

When I read a computer book, I write in it. This helps me learn and makes, what I consider the important points, easier to review later. However, the books' style includes scribbles already. I had to read it with a red pen in hand, black doesn't stand out.

From the code samples page at headfirstlabs.com: "If you've ever read a Head First book, you know what to expect: a visually rich format designed for the way your brain works. Head Rush ramps up the intensity with an even faster look and feel..." I found the intensity lowered and the learning process extremely slow.

O'Reilly studied how people learn. They should, instead, have studied how people explain. A good explanation can be learned using any printing style. A bad one is bad, no matter what. The grammar in a letter does not improve if its printed on fancy paper with many colors and fonts. Bad is bad.

To me, being a good explainer is the only thing that matters. It is even more important than knowledge of the topic at hand (which can always be learned). Someone who explains things well, will explain any topic well. I don't have to have read Mark Minasi's OS/2 book to know that it explains the topic well. All his computer books are well written, regardless of the topic. Computer topics can always be studied and learned. Explaining things well can not.

I see this pattern over and over again - just because you know something doesn't mean you can explain it. Two separate skills. For still more, see computergripes.com

Other reviews have supplied the synopsis, and table of contents for this book, so I'm just going to put my 2 cents in regarding the Head Rush/Head First format.

Some people might think it's too cute, but to get an entry level understanding of a technical topic, there is none better than this series. This is the second book in the series I have owned. The other is 'Head First Java'. If you are serious about learning something new, understanding fundamentals is the key, and teaching the fundamentals is what this series is about, and it excels at.

In the future, I will pass up the 'Dummies' and 'Idiots' books for quick fixes that I might forget, and look for a Head First/Head Rush book to gain a better understanding of concepts.

This book doesn't teach you anything. Instead of telling you how to do it, the author is wasting your time explaining what you can do with AJAX.
If you want to impress your nondeveloper friends, this book might be an asset.

'Head Rush AJAX' is a unique but effective way of learning AJAX. This "Head Rush" book is unlike anything I have ever seen before. Instead of a 'normal' layout with a bland approach, this book feels very BUSY from start to finish. While this might sound like a negative connotation for a lot of other things that could be reviewed, I found that this AJAX book was an effective, and heavily entertaining learning tool. AJAX is a pretty straightforward topic and while I do agree with other reviewers that the author probably droned on a bit too long as it relates to some of the topics/examples (certainly this 400+ page book could have been trimmed down to 250-300 pages), it's enjoyable ride to take. The author writes well, and it feels like a total "Generation X+" book that caters to a new breed of programmer which is probably right on because AJAX is a new breed of programming.

***** HIGHLY RECOMMENDED

The "Head Rush" is very much like notebook scribles. Not really suitable for developers but maybe ok for understand what its all about, like a technical breifing. There are far better books for developers such as AJAX in Action and Professional AJAX.
If you are a project manager and just want AJAX in 5mins then this is good one to read on the train, your deveopment team would not want it.

I was casually browsing Ajax books in the local Borders store, and was pleasantly surprised to find Head Rush Ajax. Having been a great fan of Head First Design Patterns, I decided to buy Head Rush Ajax on the spot. But I have to say I was a tad disappointed, and returned the book.

Likes:
------
1. For people new to the Head First teaching approach, there's a high probability that they will like and embrace this style. People already familiar with it will know what to expect and won't be disappointed.

2. Each major concept of Ajax (Asynchronous requests, GET, POST, XML, DOM) has been explained in a separate chapter with examples that make sense.

3. The author clearly states that the intention is only to teach the basic minimum needed to understand and build an Ajax application, and he lives up to that promise.

Dislikes:
---------
1. Even though the author states his intention about teaching the basic minimum early on, he takes far too many pages to do the same. An experienced web developer can easily get all that he/she can from this book in a single day of reading. At the end, I was left with the feeling "Is that it? For all these pages?"

2. On a few occasions, I felt the Head First approach had been stretched way beyond limit. The notion of repeating a piece of information so that it sticks in the brain has been done one time too many. It has been done right in Head First Design Patterns, but not here.

AJAX is all the hype now and everybody wants to learn how to create cool web 2.0 web applications. The "Head Rush" series of books teaches topics in more "visual" way than normal books. It helps readers really understand the topics with a fun and visually pleasing way.

Most books have text and maybe one picture or illustration here and there. With this book (and all Head Rush books) for every page of text there are illustrations that explain visually what the author is trying to say. It has been found that the brain retains better if multiple techniqes are used such as: repetition, conversational style, activites, fun and interesting visual guides. Its a great way for a book to teach something while not trying to overload the reader. Its like little breaks after sections of instruction and code so you have time to digest what was covered.

Now on to the book...

The book covers the basics of AJAX in disecting the parts of it (DOM, JavaScript, XML and a little PHP). Each chapter focuses on different types of web pages that can benefit from using AJAX.

The first chapter goes into detail how AJAX works and what is involved. It compares how a regular web page would send and receive data from a server and have to recreate the page every time a new request is received versus how only a small part of the page really needs to be changed using AJAX.

The second chapter goes into more detail with JavaScript and DOM in how specific parts of the page can be updated and/or how specific events can case an update (onChange, onFocus, onBlur). More detail is also given on the HTTP ready states of the request object that is created and how data is exchanged from the server to the browser. I've never seen a book really explain this part in such detail. Awesome...

The third chapter goes into detail about asynchronous callbacks to the server and how you can use JavaScript to parse the data to be sed throughout the pages. It has a great example of re-populating forms with updated data from the server to make it look seemless. Very interesting...

The next two chapters (4 and 4.5) are something I wish was in every other JavaScript book I ever read. It goes into great length explaining the DOM and the concept of nodes and the how a browser really sees the elements on a web page. Even if you do not want to learn AJAX, you should buy this book just for these two chapters if you really want to understand the DOM. Excellent...

The rest of the book (5, 6,and 7) go into talking abot how data is really sent back and forth (HTTP); how to code for error handling; POST and GET differences; changing your PHP scripts to accomodate for AJAX; and how to XML and JSON to store data to be used in your web apps.

A great book that can be used for anybody wanting to learn advanced JavaScript (DOM), AJAX or even to learn more about XML and JSON. A book for everyone in my opinion...