Ajax in Action

• #14 in Best Javascript Books

63 Reviews

Sort by: Most Helpful ▲ Date Rating

Let me first preface this review by saying this is the first technical book that I've read cover to cover TWICE prior to posting a review. I had to make sure the stuff stuck, because the material covered in Manning's very excellent "Ajax in Action" is really deep. But bringing the next evolution of user experience, giving your web applications a rich client feel, isn't completely easy. This won't scare you away from using Ajax in your existing applications, but make you aware of exactly what to expect.

The book first starts out by presenting a healthy discussion of the key components of remote scripting - CSS, the DOM, JavaScript's XmlHttpRequest object and client callbacks - and how they interact within the scope of your project. Before diving into full-on Ajax development, authors Dave Crane and Eric Pascarello discuss the need for object-oriented JavaScript programing, which will be foreign and awkward to most developers, even those coming from procedural backgrounds like Java and C++. The authors familiarize you with the various ways of composing the unconventional constructs available (JSON-RPC, prototypes) for optimizing remote scripting.

Best practices are encouraged throughout the chapters and enforced in all code snippets. The use of patterns like Observer, Command and MVC and refactoring and module-based programming (mainly .NET assemblies and Java servlets) permeate the entire work. The actual meat of the book doesn't get started until Chapter 9, which the authors clearly state, dealing with the aforementioned discussion of raw JavaScript programming that'll be completely new to most people. But for those not wanting to engage in the massive task of writing syntax by hand, the major libraries available are thankfully referenced.

The book also isn't a "copyist's" title, one that can provide working code right out of the gate. Also, the audience for this work should be fairly sopisticated and experienced with modern-day web programming, as the book assumes a certain level of competency and doesn't waste time with rudimentary concepts or examples. Crane and Pascarello take a platform-agnostic look at incorporating Ajax-style programming into web applications, citing examples in PHP, Java and .NET, and accordingly the examples are all partial and abstracted, to be implemented in whatever platform the developer/reader is familiar with.

This is also one of the few books that I've ever recommended people read the appendices in addition to the chapters. Most titles have supplementary info that doesn't match the flow of the chapters, or exclusionary stuff you can skip, but this book is really a tome of good reading. Appendix B is an outstanding discussion on JavaScript OOP, providing an introduction to and examples in JSON.

Ajax programming is a lot more complex than it lets on, but not as daunting as you might think. This book is critical in your understanding of how to make the next big thing in web development to work for you. A must-have.

Ajax is a Web programming technique that lets you develop rich, dynamic, interactive interfaces using nothing but JavaScript, HTML and CSS on the desktop. It's changing the landscape of the Web, and this book will help you gear up to be part of the revolution. Renaissance men David Crane and Eric Pascarello show you how to weave together the many pieces that make up an Ajax application: JavaScript, server-side components, HTML, CSS, and XML. More importantly, they teach you the tools and techniques you'll need to develop industrial-strength applications using JavaScript, a language that doesn't always get as much respect as it deserves.

This is really two books in one: first, it's a look at the Ajax technologies and prescriptions for their effective use. There are detailed discussions of relevant design patterns and of strategies for designing usable and secure applications. There are substantial discussions of a number of Ajax frameworks, libraries, and development tools, as well as developer features of Web browsers that you've probably never learned about but can't live without.

The second half of the book is a cookbook, a compendium of detailed blueprints for concocting your own versions of a trifecta of Ajax showcases: dynamic double combo boxes, typeahead select boxes, and Web portals with selectable, draggable portlets. There are even recipes for assembling standalone Ajax applications that use existing third-party Web services as a back-end. I liked that the cookbook built on the earlier parts of the book by deliberately applying the design patterns and refactoring techniques therein described.

If you're serious about helping to revolutionize the Web, you need this book.

If you are an experienced programmer and already familiar with design patterns, refactoring, and application architecture, then you will probably find this book to be very frustrating.

The author seems to be on a crusade to rid the world of bad coding practices, and though I fully salute his efforts, I think this book is horribly mis-titled. A more appropriate title would have been "Principles of Web architecture and design... and a few words about Ajax".

All I wanted was to learn the mechanics of ajax, and after reading the first 100 pages and getting nothing (new) out of it, I felt like my time had been robbed.

When I first got this book, and as I read the first couple of chapters, I thought it was excellent. I was looking forward to getting into the nitty gritty, and programming in Ajax.

Unfortunately, that moment never arrived. The book gets progressively more annoying, talking in verbose detail about JavaScript and various in vogue design patterns that, whilst useful, should have been dealt with in a quarter of the space. It becomes disorganised, and is one of those books which never seems to get to the point.

Oh, and it insists on having the most mindless diagrams known to man.

To its credit, it has a fairly good OO JavaScript tutorial at the back, and each chapter has excellent online resources for further information. However, this does not make up for the tedious code examples (with no comments and obscure variable names). Oh, and there are 2 (identical) page 609s but no page 608. This last point is, though, the least of this book's problems.

In summary, although at first it seems useful, this book is rather too much hot air and not enough action. "Ajax almost in Action" would have been a better name for the book.

I feel better now...

Huh? Kind of a weird title! What I mean by it though is that this is an excellent book that covers so many things that even if you aren't especially interested in Ajax but are interested in client-side coding, this book would be a valuable addition to your bookshelf.

There is a good bit of "professional" Javascript coding here... Javascript, and client-side coding in general, has historically had a bad rap against it because it's so easy to throw together a ton of spaghetti code that is difficult to debug, extend and maintain. This book will show you how to avoid those pitfalls.

Things like properly applying patterns, implenting clean separation of concerns, advanced debugging techniques and reusing all the good OOP techniques you use on the back-end are covered very well.

Of course, Ajax is covered fantastically well too... while I would say this isn't a book for beginners (it dives in almost immediately with some code that would probably spin a beginners' head), if you already have a good grasp of Javascript, HTTP and web development in general then this will be the absolute perfect introduction to Ajax. The book starts by giving a solid description of what Ajax is, and more importantly, why it can represent such a paradigm shift for so many people.

From there they dive into the theory behind it, how it works, how it differs from what you probably have done before, and also how to do the same thing without Ajax.

After that it's example city! Plenty of demonstrations of the techniques being talked about, and all the while they continue to explain it from a theoretical standpoint too so that you not only can copy the code as-is and use it, you understand why it is done how it is, so you can apply that knowledge on your own later.

One thing very much worth mentioning is that there are examples in .Net, Java and PHP, and if I remember correctly there is an equal number of examples in each. I think this is a wonderful decision on the authors' part. Everyone should find something here. And of course most of it is actually client-side anyway, so even if you aren't a PHP guy for instance, you should have little difficulty following the PHP examples along too.

To summarize, if you are in the market for a book on Ajax, or indeed just a book on how to code Javascript on the client in a "good" way, you need not look any further than this book in my opinion. It's sitting on my bookshelf, and I'm sure I'll be referring to it as time goes on without question. Highly recommended!

First couple of chapters are ok.
Thereafter, the book has a nice discussion on oo patterns for javascript. Along the way, the book tries to give many ideas on how to design application framework. Yet I would expect to have learned all of this somewhere else! IMHO, a good book on AJAX would introduce the subject and show how AJAX changes the old ways of app design. Who needs the explanation of old concepts again.

I found this book annoying to read. It is not going straight to the point.

"Ajax in Action" is not only an excellent book on Ajax, but the best JavaScript book I have ever read. The authors note early on that Ajax is a process, not a technology. This theme permeates the book. There is an emphasis on requirements, design, implementation, testing and maintenance. So the book shows how to do a real project, not just how to code.

Keeping with the real project theme, there is information throughout on refactoring and design patterns. The authors present low level coding idioms as well. All this creates a language for coding Ajax applications. The second half of the book walks you through the entire development process for five sample applications.

The book targets a wide audience range, from enterprise developers to self-taught scripters. Basic concepts are explained concisely for newcomers and experienced developers may skim certain sections. However these sections are a very small part of the 600+ page book.

An appendix covers an introduction to JavaScript. While you would want to supplement it with materials from the web, it clearly covers the advanced topics that are hard to find elsewhere. There are also introductions and tips on CSS and DOM. In short, I learned a ton about non-Ajax development and page manipulations too.

And the book even has a screenshot of JavaRanch! I was expecting a good book when I saw Bear and Ernest's comments on the back. But it still managed to exceed my expections!

I just stumbled across a book called Ajax in Action and it is wonderful. I had no idea this book was even out. It provides a more comprehensive overview of Ajax technologies than any book on the market (or even in beta) including a great section on Ajax Design Patterns.

The coverage is nice and varied. They show you how to write Ajax from scratch first, including lots of details about how it works and how to use it well in your application. They then go on to detail the many libraries and frameworks available, and show you how to refactor your code with these libraries. Finally, there are plenty of examples of Ajax applications toward the end of the book.

Highly recommended for anyone developing what you might call a Web 2.0 application. The only Ajax book I would keep on my shelf.

I have bought
Ajax Patterns and Best Practise (accademic),
Foundations of AJAX (accademic),
Professional AJAX (pragmatic)
and Ajax in Action (pragmatic)

Ajax Patterns is good at telling you the kind of patterns to use for different solutions, where as Ajax in Action is a little lighter here but after each chapter the is a Refactoring phase.
The "accademic" books are a too much up their own butts, like I am more OO than you. Like any new Fad, you will always have the scolars/purists padding out a point. The pragmatic books seem to be by real world developers, so you have less include files, better formed objects and useful samples. The WROX download samples are missing so you will have to contact the webmaster. All four books are good in their own way. Eg Patterns is good for designing data factories. None of then cover ASP3.0 some do Java, PHP or .NET for server side activies. on two books cover XML and only In Action covers SOAP and webservices. The others just use JSON which is not supported in ASP but well in php/ruby/js etc. "Ajax Patterns and Best Practise" is good if you are planning a large project and developing a in house tool kit. But "Professional AJAX" and "Ajax in Action" are ones I use all the time.

I brought two books, one for my friend and one for myself. Both of us read the book and find the book is not nearly as good as other reviews say. It covers lots of topics which are not directly related to Ajax. Thus it wastes lot of your time. After reading the book, you still won't get the clear picture of Ajax. Then, we read another book, "Foundations of Ajax", we understand the topic right away. It is not as bulky, but right to the point.

This book does talk about ajax, which is good. On the other hand, after 200 pages you still see the planet example, which is simple, not finished. If you don't need write code and you don't need to put ajax in a web site, this is a good book for you, which talked a lot concepts. If you want truely develop ajax on a cool site, you would be disappointed by samples in the book (too simple) and few explanations of codes that are relevant. For example, the book's context is somehow disconnected from the samples downloaded.

To find if this book is right for you, I strongly suggest that you read the book in a local bookstore before you buy it. Even download the source code from book web site and set up to run the examples, which is simple and may take a couple of hours to set up. Or you run those examples online on Internet sites such as www.usanalyst.com (for registered users only. It may take 20 seconds to join).

The first chapter or two were good. If you look for something that can jumpstart you in real projects, see the screenshot of the planet example and how this book spend half of pages to explain it. However, I do understant why the author spend much time on old patterns -- There are many guys out there who were not conviced about Ajax, the author want some buyins. But, Ajax is about making money and state of the art (because speed is the most important issue, not a bulgy design). If those guys don't want make money from ajax, that is their lose. They will miss the next revolution on internet.

John the Builder, www.usanalyst.com (Run Ajax book examples online at www.usanalyst.com. It may take 20 seconds to register).

The book does explain the basics of Ajax, but there is so much verbal filler, I eventually was flipping pages looking for the substance. I wouldn't recommend this book.

I have to say, I've been extremely impressed with all the Manning books I've read. These books remind me of O'reilly books back in the day. Ajax in Action is no exception, although it was not what I was expecting. To be honest, I didn't know what I was looking for in an Ajax book, but I looked through many of the latest crop of books and chose this one based on the reviews I've seen people give it and the strength of the imprint.

This book, and more books like it, are exactly the sort of books that are so hard to find for scripting languages, it isn't primarily a book about language or syntax, but a book about programming. They spend the first half of the book discussing techniques, referencing heavily Model-View-Controller and the Gang of Four's design patterns (which is also must read!). If they mentioned and showed their process of refactoring one more time in the book, I would have had to put it down to wipe away the tears of joy.

The second half of the book walks through several examples of application building. The examples are clear and useful. Their thought processes are well explained and even when you don't agree with the way they are doing something, it is really beneficial to learn why they do things the way they did. And their process of starting broadly and then refining and refactoring each example is extremely helpful to see how one can actually put into practice these techniques in javascript.

This book is for someone who already has a decent familiarity with javascript as well as with basic AJAX principles. They cover, broadly, http requests, working with the DOM and CSS, and the event model. But they cover it more as a refresher as well as with an eye towards the best ways to implement them in your programming. They also talk throughout the book and extensively in the very interesting appendices, different toolkits and development tools that one can use with javascript.

There were some downsides, to this book however. I think because of the way they were structuring the book they often introduce a code snippet with some complex logic and hand wave around the complexity until several pages afterwards when they get to the section where it becomes the topic of discussion. If one isn't immersed in javascript it can become a bit difficult to separate what should be obvious and what they will be talking about later.

They also spend a lot of time and space on the server side of things, giving examples in a several languages (although they give very short shrift to perl). I'm not sure that that is overly helpful, I think they should have assumed that you knew the server side language and simply referenced what the server side should be returning. The scope of the book simply didn't allow them to go into depth with these languages and if you can program the language already the examples were uneccessary and if you don't know the language it wasn't enough for you to usefully do anything with them.

But those two problems are far outweighed by all the other goodness they've packed into this book. I highly recommend this book to anyone doing any javascript development.

Asynchronous JAvascript and Xml (AJAX) doesn't really have anything new from a technology standpoint. And yes, it's really JavaScript, as per the old Netscape idea, not Sun's Java. We're talking client side processing here. Instead it's a kind of looking at some older technologies in some new ways. The basic concept is to provide a great deal more client side processing on web pages, that is, use the power of the visiting computer to manipulate the screen without having to go to the host for everything. As the current buzz word says it provides for a 'Rich Content.'

This book is divided into four parts.

Part 1 covers the Ajax concept, explains why its useful, introduces the tools.

Part 2 is on the techniques that make an Ajax application work

Part 3 continues this discussion to cover what is needed to go from proof of concept to production ready software.

Part 4 builds five Ajax projects step by step that are then refactored into drop-in components that you can use in your own web applications.

The authors have been involved in using Ajax since its beginning. They are very familiar with the concepts and are also good writers that have an ability to explain these concepts in a clear and concise manner. I would suggest that this not be your absolute first venture into JavaScript (or CSS or XML) a bit of background makes the extension of the Ajax environmnent that much easier.

As a whole the authors do an excellent job of covering AJAX. Their stance of treating AJAX as a fully fledged application framework on it own and that structured, patterned development techniques are required for successful projects is realistic and welcomed. The examples are "real-world" and relevant, such as "live search" and "web portals". As is expected, each successive part of the book builds on the previous content. Often examples in the book are presented as a first edition that functions well, but then the examples are refactored to make them more scalable and re-useable. This "get something that works and then make it better" style is refreshing to see as it is how most of us actually code in the real life.
If you are looking for a "cookbook" style text with example after example hurled at you, this book may not be for you but for those of you looking for a new approach to web application design, you've come to the right place. As many of the "In Action" books in the past, I feel Ajax In Action is destined to be added to the standard reading list for anyone interested in serious AJAX development.

If you're managing your career as an IT professional, you probably keep a watch on new technologies that might interest or affect you. Sometimes that means learning a whole new batch of skills. Occasionally you can get lucky and find that you only need to learn how to combine existing skills in a new way. That rare situation now exists with a "new" technology called Ajax. There's significant buzz around it right now, and it's definitely worth checking out. To help you get a handle on Ajax, Manning Publications has just released a book titled Ajax In Action by Dave Crane, Eric Pascarello, and Darren James. It's one of the first books out on the subject, and it's worth some consideration as your next book purchase.

Ajax In Action doesn't try and teach you Javascript and CSS from scratch. The assumption is that you're already generally familiar with those parts. Being comfortable with the DOM is also helpful as you start to work your way through the material. But even if you're not at the point you'd like to be with those things, the examples and explanations are clear enough to follow and understand. The authors have done an excellent job in providing copious code samples, too. Between their samples and your ideas, you should be able to get some basic examples of your own up and running in short order. I also appreciate how the authors treat Ajax as a programming discipline, complete with patterns and architectural information. The end result is that you'll end up being a much better programmer on all fronts by the time you finish.

Rather than play catch-up with yet another technology, try catching the front part of this wave. Buy a copy of Ajax In Action and blow some users away with what you can do.

Finally, I am so happy to see what some other reviewers say. This book is not really that much about AJAX. I feel that I have wasted my AJAX budget. Sure, there is lots of valuable stuff here but the percentage of this book that is about AJAX proper.
I would say that 5 of the 13 chapters are about AJAX but that of course means that 8 are not at all about AJAX. At the same time, I got "Pragmatic AJAX" by the always funny Ben Galbraith. If you need to focus on AJAX--read Pragmatic AJAX.

I agree with one of the reviewers (D. Klebanov) who suggested to re-name this book to "Principles of Web architecture and design... and a few words about Ajax"

I wanted a book that focuses strictly on Ajax functionality. This book is often vague and verbose and lacks unity.

It feels like the Authors took the Ajax concept and stretched it onto the set of many different topics. Some topics are pertinent to Ajax others are just subtly related.

I did find a lot of useful information in this book, but for the most part those things had nothing to do with Ajax. Just general strategies of web development. So I give it 2 stars because it is well written, although rather verbose. But really this is like ordering an apple and getting an orange and then trying to write a review on how oranges are also good.

This is the most systematic book on Ajax usage and patterns I've seen so far, giving you way more than just the technology overview and recipes. I also liked the very clean and thorough approach to JavaScript coding emphasized in an Appendix (which is, BTW, also one of the best JavaScript texts I've encountered).

Unfortunately, this book is also one of the wordiest I've read recently, occasionally giving you the feeling the authors just had to reach a certain page count, so they go into minor details and explain them in great length, while in other cases they just skip important topics they don't like (for example, using IFRAME POST instead of XmlHttpRequest).

This is an extremely well thought-out book. This is an excellent indepth lesson on Ajax in an easy to understand, easy to read format. This is the best book I've read on programming, period. And I've read quite a few, including another favorite, Paul Graham's ANSI Lisp book.

What's interesting about this book is that it teaches (or reviews) MANY basic concepts of APPLIED, IN-THE-FIELD programming. MVC is the most obvious of these, but there is much more in the nuances. Good practice is always mentioned throughout the book, which is critical to writing good applications. The text of this book is applicable in realms outside of Ajax, but exciting because you are learning something (kindof) new, Ajax, while reviewing these solid programming concepts. Stuff you don't necessarily learn in school or in courses, but you learn working/hacking in the wild.

This was a great review of these concepts for me, and now I can hand this very relevant book to anyone and say "read this" so that they can work together with me on a project, regardless of their background. And while you get this refreshing breath of best practices, you learn to program full-scale Ajax programs in a systematic way. Those who do not read this book aren't only missing out, they're at a significant disadvantage compared to those who have.

About the author of this review: I already knew many of the tenants of Ajax going into reading this book, and (like most of us) I created Ajax-like things before there was a name for it. One of my past Ajax-like projects, developed back in 2000-2001, garnered over 15,000 downloads -- before the era of blogs. It wasn't a masterpeice or anything, the point is that some of you reading these reviews might be thinking - yeah I know Ajax, it's just a buzzword. But seriously, I know C, Java, Lisp, ASP, .NET, SQL, JavaScript, You Name It... but sometimes it's good to read a book espousing good practices, especially if it's a well written, and even comical, read. Think your best college teacher, for instance. For those of you who aspire to elegance in your code, who think of your code as an art more than a science: well these developers are of the same feather. Don't get me wrong though, they are very practical in their application.

So, this book is powerful; well thought out. I find it hard to skip sections, since they are all filled with gold, and I don't have to filter out dirt and fluff as with many other books. Not a minute/paragraph wasted. I'm going to re-read it for leasure.

These authors elevate to the status of "hackers" (in the sense of extremely proficient) in my eyes. Excellent!

I'd heard good things about this book before picking it up, but I was still impressed with how good it is.

Firstly I should add a disclaimer - I know one of the authors, Eric Pascarello. I once tried to get him evicted from the JavaRanch. I do not believe this effects my impression of the book in any way.

The main feature that I really enjoyed was the professionalism behind every part of the book. Everything is approached in terms of creating a well designed, maintainable and stable application. Many JavaScript and client-side books I've seen present quick and easy solutions, and while this isn't a JavaScript book, it could still have concentrated on presenting flashy tricks to the reader. Instead it concentrates on building a library of useful and reusable functions, it concentrates on designing client and server interaction as a cohesive whole, and it concentrates on applications rather than showy examples which are useful for a single purpose and not much else.

There is still plenty of source code provided to assist in getting you started in your own Ajax applications, and I have been making great use of these. The book however is about Ajax, if you are not experienced in HTML, JavaScript, CSS, or server side functionality you will probably want to find some resources to help with these. Each of these technologies are covered in the book, but depending on your level you'd be advised to pick up some complementary material.

I have read reviews where they found some of the areas of discussion, such as design patterns, distracting and of limited use, but I think ignoring these is potentially dangerous. The book presents Ajax as a powerful tool for redesigning the way we interact with the web. To do so without observing the many years of lessons learnt would be detrimental to the technology.

My link to the authors aside, this book was a lot more than I was expecting, and I was pleased to see the effort dedicated to teaching people to get it right the first time.

(brief disclaimer: i am acquainted with one of the authors, and have corresponded with him for a number of years)

The authors of Ajax in Action state in their introduction that the book is not intended for beginning programmers, or for those without JavaScript experience. This is a warning worth heeding: members of either group will find themselves at a loss with this book.

However, that's because the book does what it says on the tin; it gets right to the core of Ajax, and very quickly. After a brief explanation of what Ajax is, and where it comes from, the authors move onto what you can (and cannot) do with Ajax, and from there on, it's all "how", with extremely practical examples.

And that's perhaps the greatest feature of this book: it's practical examples, includin word-completion and live searches. And the book's guiding philosophy, "getting it working first, then make it look pretty", is sure to be appreciated by those of you have suddenly found yourselves working on a web app with a deadline. To that end, there's also discussion of a few of the more popular Ajax frameworks and libraries, and how to get started with them.

The book also contains two helpful appendixes: one of useful tools for those working with JavaScript, and the other covering important aspects of JavaScript itself. Finally, the book has a reasonably complete list of available Ajax frameworks and their talking points.

Combine the above with the authors' clear language and understanding of the topic at hand, and Ajax in Action becomes an excellent book for those needing to get up and running quickly.

If you are arriving at AJAX with a basic web development foundation, you will find "Ajax in Action" to be challenging to digest. From the introduction, the overall level of the book jumps right into code samples and skips most of the basics, making it an intermediate book at best.

I found the chapter on Ajax portal architecture using Java to be particularly useful, along with the Live Search chapter. But besides that, I didn't find as accessible as another book titled "Foundations of Ajax". I would recommend "Ajax in Action" only to developers who have at least a couple of years of web dev under their belt.

This is a timely book for me on Ajax, I am absolutely comfortable with the read and particularly helping my POC. The authors did a great explaining this new technology. right from the concept, design, implementation, testing and maintenance. Infact the book shows how to deal with a real AJAX project, not just how to code.
The authors did an excellent job presenting how to do coding for Ajax client applications. The sample applications samples are perfect for a Javascript novice like me. Worth a buy.

Ajax In Action is a code-driven introduction to the collection of technologies and techniques that are known as Ajax. The book has many code examples and the last five chapters take you through the development of some Ajax applications including combo boxes, type-ahead help, and adding Ajax to a portal site.

The authors emphasize that developers and architects need to have a different mindset when developing applications that use Ajax versus traditional web applications. An asynchronous (the first A in Ajax) web application will act differently than a traditional web application and needs to be thought about and designed differently. There will be more JavaScript code to manage and the authors emphasize good coding and code management techniques.

The first chapter gives an overview of Ajax, why you'd want to use Ajax, how creating an Ajax client/application is different than a regular web application, and talks about some examples applications currently on the web. Chapter two discusses the technologies of Ajax: JavaScript, CSS, DOM, and XmlDocument/XMLHttpRequest. Chapters three through six discuss the major components of an Ajax application.

I really enjoyed the chapter on performance and the fact that it focused both on speed and memory use. The appendices cover Ajax tools for your toolkit, an excellent JavaScript overview, and Ajax-related frameworks and libraries. The appendices are really good but I appreciate that their information is located such that it does not break the flow of the book.

This book is a very good overview Ajax and its technologies. The book assumes you are reasonably familiar with JavaScript, CSS, DOM, and how web applications work. My one complaint is the feeling that the discussion of patterns and refactoring for a developer not familiar with these tools was a little light and could have been beefed up a bit.

Full disclosure: I received a complimentary copy of this book for review.

At 650 pages one would expect this book to be an AJAX Bible. Instead it meanders and wanders from topic to topic without getting into meaningful code examples or applications. The author could probably have written this book in under 300 pages and created a much better product.

On the other hand, the book isn't boring and, if you like rhetoric, find a comfortable chair and set in for a week of easy reading.

Somehow I got hold of my first book on AJAX: Head Rush Ajax (Head First) and sure it gave me an intro to XMLHttpRequest - but that's all it did. I browsed through the informal/conversational writings of the book in one evening. And wondered, is there all to it? The current web-world is spinning around Web2.0 and AJAX technology - there must be more than that. Then I went back to the store and picked this book up - I am glad I did. It covers many more areas that an AJAX programmer must equip himself/herself, topics relating to MVC pattern, working with the server side programs and performance, security, as well as the basic topic: building standalone RIA using CSS, DOM and DHTML.

This one definitely shines over the rest on the topic, however, for a hands-on programmer (that's me), I would appreciate more code samples will help.

I'm a self-taught webmaster. The only languages I really "know" are html, css, php and mysql, and I'm not exactly a guru in the latter two. I do have a mere acquaintance with javascript, but I can't code it.

The reason for stating my background is that I found David Crane's (et al.) book "Ajax in Action" possibly the easiest-to-understand programming book I've ever read. He really has the talent of clear explanation, starting from the most basic knowledge. For instance (although it is not his best explanation) he takes the time to cover the basics of http headers for people who aren't familiar with the most fundamental knowledge of http, something you must know to use Ajax.

I have never before really understood the "DOM", or why it could possibly be important, at gut level. Crane accomplished this in a couple of pages. (As a happy side-effect, this explanation really clarifies the XML DOM and XSLT/XPath. In fact, Crane's explanations clear up all kind of confusion in a wide range of other areas.)

The first part of the book takes you through the most basic steps of Ajax. It clearly explains DHTML -- another subject I had considered utterly unimportant to my work -- and having done so, makes Ajax much easier to grasp. He makes the formerly mysterious "iframe" as easy as pie to grasp.

There is none of the constant heading off on tangents, repeated backtracking, or introducing of concepts that are explained later, which characterize most web-programming books. He states a principle, then states the code that derives from it. The method is so clear that even I, with only the most primitive grasp of javascript, am able to understand exactly what the javascript is doing is the examples.

He does spend a lot of time covering the advanced subject of good coding practice, but at least you can understand what he's saying, even if you work on comparatively small projects and thus the coding-practices advice is largely irrelevant to your work. At least these comments on "good code" will improve your work, although the benefit to the smaller website is marginal.

I highly recommend this book to a wide range of people: From anyone who wants to understand the basics of Ajax and has at least a passing acquaintance with javascript and at least one server-side scripting language, to the expert specialist looking to improve his Ajax coding for a major website.

(In fact, if you just want to understand the basis of DHTML, or various faces of XML, or don't know what an "iframe" really is, this book is worth the price just for that -- and you will have a good Ajax text when you decide to learn about it!)

The second part of the book is four complex "recipes" for specific Ajax applications. I have little use for these at the present. Again, however, I had no trouble understanding them, even though the first one uses VB Script -- and believe me, I neither have nor want a even a scrap of knowledge about VB Script. I feel confident that I could rewrite the code for this recipe, however, using PHP instead of VB Script; once again, this is due to the clarity of the presentation.

Ajax in Action by Dave Crane is the best Ajax book on the market today. With over 600 pages of content, this incredibly well-written text explains why Ajax is so powerful and how this simple programming feature (it really isn't difficult to learn at all) has changed web development forever. No longer are users and developers limited to a page reload world, as the power of this technology now has the ability to make the web work like regular applications. It's a trend that has been desired for a loooong time and boy does it ever deliver!!!

Chapter Overview:

01. Ajax background
02. Learning to use Ajax
03. Order with Ajax
04. Pages as applications
05. Serve role
06. User experience
07. Security and Ajax
08. Ajax performance
09. Dynamic double combo example
10. Type ahead example
11. Enhanced Ajax web portal
12. Live search using XSLT
13. Stand-Alone apps with Ajax

If this is any indication of the kind of finished product that Manning Publications puts out, then this is another major player in the software development publishing field. This is an absolutely MUST BUY book for anyone that is a web developer or needs to learn how to use Ajax to bring their web application into the 21st century. For newbies, amateurs, and experienced developers, this guide will easy give you a return on your investment as you become the uber web developer that you always knew you could be!!

***** HIGHEST POSSIBLE RECOMMENDATION

It's amazing how much the JavaScript world has changed.

This book has a relaxing style, and it was enjoyable to read. However, it no longer represents what I think of as "modern" JavaScript. For instance, it doesn't cover closures until appendix B, and even then it tells the reader to avoid them. These days, having studied Dojo, jQuery, and Douglas Crockford's videos, it's clear that closures are at the heart of how modern JavaScript is written.

The copyright for this book is 2006, yet the index doesn't even mention Firebug, YUI, dojo, or jQuery which are now staples of the JavaScript community. Although, dojo is at least mentioned in the list of Ajax frameworks and libraries.

This book is an interesting piece of the history of JavaScript, but for those wanting to learn modern JavaScript, I recommend watching Douglas Crockford's videos instead.

I have spent a lot of time thoroughly going through this excellent book - an almost complete reference on the subject. The only weakness in the book is the lack of discussion regarding the appropriate place to use it. Otherwise, this book covers all aspects of AJAX concerns: AJAX's weaknesses and strengths, refactoring code for maintainability, how it impacts user performance, security, graceful error recovery, and best of all, working example code - lots of it. The practical examples are significantly meatier than most books 'hello world' versions of technology normally presented.

A must read for anyone considering doing much more than just a couple of AJAX calls.

If you are looking for some Ajax code to copy and paste into your webpages, this is not the book for you. But if you are creating Ajax web applications on a large or small scale and need to consider such aspects as design and refactoring, security, speed and system resources, then this book will help answer some of these questions. Although the authors, Dave Crane, Eric Pascarello and Darren James, discuss mostly the client-side of Ajax, their approach for this book is to re-teach web programmers away from the standard/classical webpage and introduce a new way for the server, browser and webpage to work together through Ajax.

The first part of the book concentrates on what Ajax is and how it differs from standard/classical web programming. The authors discuss the four core technologies of Ajax (JavaScript, CSS, DOM and XMLHttpRequest) concentrating on the different ways each is used and how they work together in an Ajax application. Ajax takes the concept of separation of tasks to an advanced level.

Once you are familiar with this new approach to these four preexisting technologies, you are ready to work on refining the coding process. Ajax uses a larger amount of JavaScript compared to classical webpages and the webpages are refreshed less often. The author's approach to managing a large Ajax code base is by design framework and refactoring which is a fancy way of saying they teach you to write small, reusable chunks of code where each chunk has a specific task. They take this code component framework further by using the Model-View-Controller architecture which separates an Ajax application into three parts. The Model is the part that performs the task and the View is the part that presents the results. The Controller is the liaison between the other two. By keeping these parts separate, your code is more reusable and more easily maintained. Changes to one part do not directly affect the other part.

With Ajax, the user does not have that familiar "click and wait" routine as the webpage refreshes to reflect changes. With Ajax, as the information is passed to the server and data is returned to the browser, there is no need to refresh the webpage. Therefore we need new ways to keep the user informed as to the process. A few of the new visual feedback components discussed here are the status bar, pop up dialog and inline highlighting. All of these happen asynchronously.

Many books do not address the topic of security. One thing I liked about this book was that the authors discuss potential security issues when using Ajax and several possible ways to close these security holes. Another area covered was performance issues such as speed and system resources. First you learn ways to monitor the performance of your Ajax application and then how to analyze and improve your code.

The book finishes with five sample projects which are built step-by-step. The first is an Ajax web form. In this project you learn how to use Ajax to link form input fields in such a way as to pre-populate the values (choices) in the form fields. The choice made by the user in one form field causes the values for the second field to be updated as necessary. This can be done without reloading the webpage because the two fields are linked and Ajax does the updating in the background. Next you learn how to create an Ajax type-ahead suggest feature (such as the Google Suggest) and ways to possibly improve on this using an object-oriented TextSuggest component. Moving from forms to more advanced user interface features, you will learn how to create an Ajax portal project such as A9.com, an Ajax based live search system and how Ajax can work with external RSS protocol instead of a server.

The authors first walk you through coding these projects and then show you how to refactor each into reusable components. When you have finished, you should have a code library that you can apply to any Ajax web application.

Dave Crane is a computer programmer and simulation modeller. Eric Pascarello is an ASP.NET developer and the author of JavaScript: Your Visual Blueprint for Building Dynamic Web Pages (2nd ed.). Darren James is the architect of the open source Rico project.

Are you a professional enterprise developer? If you are, you're in luck! Authors Dave Crane, Eric Pascarello and Darren James, have done an outstanding job of writing a book that explains how to distribute the application between the client and the server, while retaining the integrity of the system.

Crane, Pascarello and James, begin by discussing the fundamental differences between Ajax and the classic web application, how to think about usability, and other conceptual items. Then, they emphasize where the technology is used differently, or behaves differently, as a result of being part of Ajax. The authors continue by introducing the third main theme for this book, managing the Ajax codebase. Next, they look at ways of keeping your code clean on the client itself, applying the old web work-horse, Model-View-Controller, in a new way. Then, the authors look at different ways of communicating between the client and the server and how various types of frameworks can be adapted to work with Ajax. The authors continue by addressing the user experience, and take an in-depth look at ways of keeping the user informed while asynchronous tasks are executing. Next, they look at the issue of security in Ajax from a number of angles. Then, the authors discuss that other showstopper: performance. They also look at a simple way to give the user a richer experience by enhancing HTML forms with Ajax. The authors continue by showing you how to implement a type-head and fetching data from the server in response to user keystrokes. Next, they explore the wider possibilities of Ajax user interfaces. They also show you how to develop an Ajax-based search system and demonstrate the power of client-side XSLT as a way of turning raw XML data into formatted, styled content. Finally, they present an Ajax client without a back-end implementation.

You'll learn in this most excellent book, how to ensure your application is flexible and maintainable. So, if you are a web developer who has prior experience with web technologies, this book is for you!

So far, this is the best coverage I've read on AJAX programming after buying two AJAX books. Although I am not a big fan of scripting and client-only rich applications I found this book does cover good basics which are critical to writing AJAXs. The code examples helps get going with learning/hacking AJAX concepts and some advanced Javascripting. I am still concerned about the industry acceptance of AJAX to use AJAX in my applications.

This book is good, however as I am exclusively programming for open source, server-side applications, the C#/ASP VBscript examples do absolutely nothing for me.

It teaches you generally what has to be done in order to get AJAX things to work, but the really good thing about AJAX is XMLHTTPREQUEST, which I don't think they explained adequately enough.

Overall, a good book, but I'm thinking about getting Professional AJAX as it deals with more PHP and better examples (from what I've read at the local bookstore) for real life application.

This book is exactly what I was looking for. It does a great job of taking you from introductory work through professional application.

It does more than introduce ajax to the reader. It also covers a little bit of programming methodology and some things to keep in mind when writing even a simple application. Overall it is a good book, but not if you are new to programming and especially if you are new to JavaScript.

I also will agree with the comment: "Principles of Web architecture and design... and a few words about Ajax". However, I find it to be an incredible book. It goes in depth about the Model View Controller, Design Patterns, and Refactoring. All terms that I did not know in depth. I actually skipped over a lot of the how-to AJAX stuff and read about the design theories. I can't wait to read it again.

The Appendix on how JavaScript works is worth the price of the book alone. NOW I understand how that crazy prototype works.

This book explain every aspect about the AJAX approach and was very useful to me. I would recommend this book both for beginners to learn about AJAX and professionals to consolidate their knowledge. The only thing I dind't like is that the writer uses several popular english expressions, difficulting non-native speakers to understand some comparations and explanations.

If you are not an AJAX expert, this book is required reading!

If you want to go into AJAX I recommend this book.

To be able to learn something usable from this book you'll need some background in one of the technologies oriented to enterprise web development, If you lack this knowledge you won't enjoy this book, in fact I'm almost sure that you'll abandon it after not more than 80 pages.

I like very much it's technology agnosticism and it's clarity.

This book is my first AJAX book and frankly speaking this book did keep up its promises with a good introduction and smooth-sailing examples. I am not a Client-side scripting expert, but I found this book feeds a lot basics about Javascript and even CSS. These scripting langaugaes are important when you are working with Ajax.
The book has lots of examples that you'll find useful to fully understand what is going on. I found I could modify several of the examples and drop them into my own Ajax project. I would recommend this book to anyone who wants to get introduced to Ajax programming and could also use a primer on Javascript and CSS.
I may probably buy another one other book on Ajax simply because it is still evolving and not standardized. Thus I feel sure there's more tricks to learn till AJAX hits all parts of the Internet. Worth reading + worth a buy and you will NOT be disappointed.

I never forget the first few encounters with Ajax. My friend called me and asked me if I had a Google mail account yet. I didn't since the beta just started. He said it's amazing... the web interface just felt so more natural than other mail clients. He didn't care about the gigabytes of space, just the web interface was the made the difference.
First encounter with Google maps for me was the same. As everyone, I looked for my house. Scrolling the map and my mouth felt open. How did they do this? Is my link so fast or...? No, it's not flash or a java applet.

Now you can find out how they did it. They used Ajax technology. If you are looking for an introduction to Ajax technology then this book is probably one of the best starting points. It describes the different technologies that make up Ajax and the ways they interact. It also gives concrete advise for developing your own Ajax applications.

For me, someone who didn't know much about Ajax, this book was exactly the type of introduction I needed to understand the concepts.

This book is a good overview of the technologies involved in Ajax development. I've not read it in its entirety (I don't really use tech books this way), but it seems quite complete.

Looking for the latest DHTML tricks and Javascript libraries? You came to the wrong place: this was published in 2005.

But I really liked this book. All you need is competence with HTML, CSS and Javascript, and Ajax in Action will help you understand what makes Ajax different from the traditional client-server architecture of web apps. It also introduces some design patterns and other basic considerations, e.g. cross browser issues. The second half of the book has several examples that illustrate what Ajax can buy you.

If you're already doing Ajax, there's not likely to be much here of any practical value, and a lot of the basic issues have been finessed away with the more common Javascript libraries. But if you're looking for a higher-level overview of the principles of Ajax and the issues involved in delivering the Ajax experience across browsers, this is still very relevant.

Reading Ajax in Action is not going to make you an expert. But this (or something like Head Rush Ajax) is a very good introduction.

As an experienced developer already using ajax and looking for some best practices, I was dissapointed. Perhaps the topic is too broad for a single book to give a working developer the desired depth.


I'm hoping the next book on Prototype will be more of what I need.

Making the change from traditional web programming to Ajax, requires a total mind-shift. Ajax in Action can help you do this with very few headaches.

I found that you do need quite a bit of previous knowledge of technologies like JavaScript, knowledge of OOP, CSS, XHTML standards and DOM programming. You need to know some server-side programming in a language such as Php.

The point is, the book is not exactly for beginners in the web-programming environment, but rather for programmers wanting to learn, understand and successfully implement the use of Ajax.

The chapters on Design Patterns were of much use to me too.

I highly recommend this book to any programmer wanting to master the concept of Ajax.

The authors seems to know what they're talking about.
But they didn't, in my view, design and organize
a good book about the subject. How-to-do-it programming
books should start with Hello World examples and build upwards
from there (see Rasmus Lerdorf's recent usenet post about AJAX).
This book seems to wend its way aimlessly from subject to subject
without making any coherent connections.

This is a great book. The writing style is very friendly and encourages the reader to keep turning pages. It is well organized and addresses areas (such as perfomance and profile) that very few Javascript books delve into. Also of value are the discussion of various third party libraries and the very relevant and detailed example chapters (e.g. implementing a type-ahead text component). Server side code is include for several common server side technologies (Java, PHP and .Net). All in all, this is an excellent book for those wishing to come up to speed on Ajax quickly.

I bought this book after a long time I was looking for a good book on AJAX. I read the revies on Amazon - and decided to give it a try - it was worth every cent paid for the book.

The authors take real life examples, and show how to implement the solution using AJAX. They pay attention to possible pitfalls, and the code that displayed in the book, can be used as is !

It is defenetly one of the best book I read in few years.

This book is detailed enough for explaining the revolutionary web technology in next generation, including not only introductory technical details and background reasons of ajax, but also couple of examples with patterns enhanced to let readers fully understand it's spirit. Beginner to intermediate level.

Excellent seller, book arrived in a timely fashion and was new as advertised. will buy from seller again

This book will teach you a lot about Javascript and even Cascading Style Sheets. You use both when working with Ajax.
This book offers several nice ways to do Ajax programming -- from a roll your own approach to a third party library such as Rico.
The book has lots of examples that you'll find useful to fully understand what is going on. I found I could modify several of the examples and drop them into my own Ajax project.

The second half of the book had projects. They were not as useful since most of them required Visual Basic and a database on the server side which I wasn't set up to run.

I do recommend this book to anyone who wants to do Ajax programming and could also use a primer on Javascript and CSS.

Ajax In Action was the first book out on Ajax. I probably will buy at least one other book on Ajax simply because it is still evolving and not standardized. Thus I feel sure there's more tricks to learn.

This book covers lots of ground coming in at 600 pages of real content. I almost gave this book 3 stars until I re-read it. It may seem verbose for the more experienced programmer, but I think would be a perfect read for the novice Javascript programmer. It really is packed full of great implementation ideas and good practices, such as the use of software patterns (MVC, singleton, adapter) and extensive code refactoring. There are tons of screen shots, images, diagrams, code examples and snippets, and external references. Although the AJAX protocol is server-side neutral, the author implements the backends in Java, C#, PHP, and VB.NET.

The biggest drawback is security coverage. Security issues in the AJAX world have really unfolded since this book was first published. This title does dedicate about 30 pages (chapter 7) to security. The author touches on the basics, like securely parsing XMLHttpRequest response data. However, I would highly recommend Ajax Security for a more in-depth study. "AJAX Security" is almost the size of this book, but entirely dedicated to security and about 2 years newer.

The book concludes with five big example applications. The fourth example implements a live search. It employs XSLT for XML parsing and presentation, which really piqued my interest. For me, the live search example is the highlight of the book.

I've bought the portuguese version of this book (AJAX em Ação), and I agree that it was incorrectly named.
I have a good experience with AJAX, and I was looking for an "AJAX bible", with hacks and something like this... but, like other people here, I am disappointed.
The book is excellent as a guide for project patterns that can be applied not just to AJAX, but to any web project. But the title, "AJAX in Action", suggest another type of content.

i am very interested in AJAX learn and this book is essential for any person that work in the web, how web developer, web desginer and others. you can learn the structure and the metodology about AJAX and JavaScript too. It is great and interesting

Spent a lot of time discussing non-Ajax related information - Patterns, best practices, Javascript OO. All of this is valuable (especially the latter, which few actually use prior to Ajax). The Ajax examples that were included had a lot of plumbing required (and provided) which is nice for re-usability, but misses the mark if you want to grow your understanding by starting easy and progressing to more complex examples.

This book is a little outdated at this point, but provides clear and practical examples of using AJAX. It was very easy to understand, and most of the content still remains up to date.

This book does a good job of introducing AJAX. Unfortunately, AJAX has not gone mainstream at this point and is difficult to fit into an existing architecture that was not originally based on AJAX.

Ajax in Action is an excellent way to get into Ajax easily. It provides great examples that help you understand Ajax's mechanics.

This is probably one of the best books I've read on computer technology. Pacing is excellent, examples cover enough for you to go read the rest in documentation, you're curious to see what happens next but always feel like you won't be disappointed, or left in the dark. The author knows what he is writing about and the questions you are used to asking when you've worked in programming for a few years, he answers.

This is an excellent book for who wants to explore the ocean of AJAX. This book is well organized and covers lot of areas in AJAX. The best thing about this book is it's not particular about any framework or software it covers the basic principles of AJAX and also gives introduction to various AJAX toolkits available.

Over the past months, the Ajax commando has been actively pursuing its little revolution on the web war field petitioning for a richer and more standardized interaction model. Everyday, the commando manages to substantially increase its headcount by enrolling a growing number of frustrated, yet admittedly lucid, web developers who were promised to an unavoidable execrable future.

With "Ajax in Action" finally out of press, the commando will now be able to drastically accelerate its evangelization process. The word is spreading that this book is a tremendously useful field guide specifically written for developers down in the trenches who are waiting for the killer solution that will help them build cutting-edge web applications of unprecedented quality. After showing how to switch from old-fashioned to Ajax web development, the authors present the core techniques underlying Ajax as well as a couple design patterns and how these fit into the Ajax development model. Furthermore, the book also contains a fair amount of tricks and best practices that can be used to considerably enhance the user experience and that teach you how to design Ajax applications with security and performance in mind. The second part of the book is fully dedicated to presenting five hardcore examples (type-ahead suggest, live search, double combo, etc.) whose main goal is to provide developers with ready-to-use off-the-shelf Ajax components that can be seamlessly integrated into any new or existing web application.

Whether you are frustrated by low tech web development or you are willing to discover why the potential of Ajax is greater than the sum of its parts, swallow this 600 pages bible and join the commando now. You won't regret it!!