Foundations of Ajax (Foundation)

• #33 in Best Javascript Books

32 Reviews

Sort by: Most Helpful ▲ Date Rating

Ajax is an unusual beast. It's not a product. It's not a standard. It's not a tool. It's not proprietary. And it's not a proper noun -- it's an acronym (although it's usually spelled as if it were a proper noun). Instead, Ajax is a collection of techniques for building highly interactive Web based applications using industrial-strength JavaScript and asynchronous communications, and it's taking the Web development world by storm. This is one of the first books to appear on this very hot topic, and I have to say it's a very good one.

"Foundations of Ajax" takes you through the whys and wherefores of Ajax, as well as the meat and potatoes, at a brisk pace. The examples are crystal clear. One difficulty in describing Ajax applications is that they're inherently multi-language -- part is always JavaScript, and the rest is always written in a server-side language of your choice. Choosing a particular server language might have alienated some readers unfamiliar with it. This book neatly sidesteps the problem by using fixed XML files for the server component for most examples, which leads to startlingly simple descriptions.

As someone who has already learned the basics of Ajax, however, I found the second half of the book even more valuable. The last few chapters talk about tools and techniques for building real-life professional-grade applications. There is excellent, detailed information about documenting, unit testing and debugging for JavaScript, debugging Ajax communications, and using some of the newfangled Ajax frameworks that have begun to appear. These chapters credibly demonstrate that it's possible to treat JavaScript as a Serious Programming Language.

In sum, I think that "Foundations of Ajax" is an excellent piece of work which belongs on every Web developer's bookshelf.

This is a rather unambitious book. It's fairly good at what it tries to do, but it doesn't try to do very much. While Manning's Ajax in Action tackles the subject from the standpoint of engineering desktop-replacement applications, Foundations is content to talk about Ajax as a means of adding small-scale usability enhancements to a web application you're already building. Likewise, they assume you already know all you need to know about whatever HTML and about web development platform you're using, and just need to sprinkle some Ajaxy goodness on your site.

Of course, there's nothing wrong with that. And I have little doubt that there are a lot more people looking to use Ajax to spruce up an existing site or application than looking to build major web-based applications. And lots of those people will already know other aspects of web development and not need a rehash. For these sorts of developers, books like this one will fill an important niche. And Foundations has a lot to recommend it. It's well written and edited, and it has a friendly learning curve. It covers building a toolset for working effectively with JavaScript, like JavaDoc, JsUnit, GreaseMonkey, and Venkman.

The main way in which this book shoots too low is by providing its straightforward examples only for Java on the server side. For a book that clocks in a thin 273 pages, it surely would have been easy to take the 50 pages of Java examples in chapter 4 and provide parallel chapters that implement the same examples in, say, PHP and ASP.Net. If the authors had merely done that, I would have absolutely no hesitation in recommending this book to Ajax newcomers. As it is, I can't help thinking that this book should be called Foundations of Ajax in JavaScript and Java. And since only the simplest of examples (the ones without any server-side interaction) will work on other platforms, this book will be completely useless to a large portion of its target audience. What a shame.

"Foundations of Ajax" is the first book I've read about the technology, regardless of the astonishing hype it has received lately. It was an easy read, I learned a lot, and, while I was left wanting something more, still, I'd say this is a great book for getting started on Ajax.

The first half of the book runs through a quick history of web technologies and gives a pretty balanced view on the "why" and "why not" of Ajax, explains the fundamental technologies and techniques, and showcases some typical Ajax features like auto-completion, auto-refreshing pages, and a file upload progress bar. While at times the pace of the discussion seemed a bit slow even for myself (not being too familiar with JavaScript in general), I found the fundamentals given on XMLHttpRequest and DOM to be very valuable in terms of understanding what's happening "under the hood" when using those fancy Ajaxian features.

The second half of the book is more focused on tooling. The authors have done a huge favor to the reader by showing how to debug and test JavaScript code, although I had to re-read a page or two of the jsUnit chapter after falling off the sled on how and where the tests are actually executed. The first appendix gets an honorary mention as well, as I found the list of cross-browser compatibility tips to be extremely useful.

The downside to the book, in my opinion, is that while the second appendix does enumerate a long list of Ajax frameworks, only Taconite (the authors' own framework) is presented in any detail. Frankly, I would've wanted to see the authors present even short examples of more "mainstream" frameworks such as Dojo and Prototype. Somewhat related to this, while after reading the book, I feel I have a good foundation for Ajax and would certainly be capable of putting together some fancy Ajax widgets, I'm afraid I wouldn't get as much "done" as I could if the book would've allocated more inches on using state-of-the-art Ajax frameworks. Having said that, I knew that that wasn't a goal for the book so it's not really too big an issue for me.

In summary, a great book for building a foundation on Ajax technology. Get it, read it, hack on some JavaScript, and then go learn the latest and greatest Ajax framework.

Ok, I have to say, I am surprised to see only one other review mentioning that many of the examples in this book DON'T WORK. I tried them on PC with IE, PC with Firefox, even Linux with Firefox, and the result is the same. This is true even when downloading the code from the publisher's website. By the end of Chapter 3 I gave up trying to get them to work.

If your style of programming is to take working examples and tinker with them to see how their behavior changes, this book is unfortunately not for you. It also, quite frankly, undermines some of their credibility when talking about how to achieve cross-browser compatibility if the examples in the code don't work on either of my computers, not even using the WindowsXP/Internet Explorer combination that is most common among the general population. I'm assuming these examples worked on the authors' computers, but a bit more care in proofreading for typos (or whatever it is that keeps them from working) would have been a good idea.

Who knows, maybe there is a firewall or other security issue that is preventing both of my computers from executing these examples? Regardless, it made the book considerably less useful to me as a learning tool.

Which is a shame, because just reading it made everything seem much clearer. I really wanted to like this book. But the whole point, really, is to make working code, isn't it?

The technologies that are coined in term AJAX are not quite new, but the term AJAX is new, you can compare the same with the quote "OLD WINE IN NEW BOTTLE". AJAX is becoming hot day by day, as the companies are using this term to sell their products and obviously by using the Ajax one can design the better web based applications.

As per my knowledge the book "Foundations of Ajax" is the first book published on this hot Topic. The authors of the book Ryan and Schutta have done a great job. In my opinion this book will help two kind of developers. First to those who want to start understanding the basics of Ajax and in turn help them in implementing the AJAX in better way. This book explains the concept with good crystal clear examples. Secondly to the advanced developers who want to enhance their skills, I would say that especially the chapters 5,6,7,8 are more useful for them.

It would be better if the authors have added one chapter in this book to discuss the available frameworks on Ajax.

In nutshell I can say that this book is good book for developers and will help them in enhancing the skills on Ajax.

-:) Kavita
Founder ajaxgoals.com

With so much energy having been pumped into server-side programming over the last five years, the new trend is a return to developing rich clients. I've previously read several of the intermediate-to-advanced titles currently in print, so I appreciated this book's fundamental tone and approach to teaching what Ajax is and how web programmers can use it in their web applications. The book is what one just wanting to get up to speed with the next big thing would expect, and in that regard is very valuable: short chapters, lots of code and examples that can be directly copied into projects.

The main concerns of programming with XHTML, CSS, XML and JavaScript are dealt with properly. The basic construct used to create an XMLHttpRequest object and work with it is replicated throughout the book, showing how easy it us to get up and running with Ajax. There are a few minor syntactical differences in the coding styles used by either author, but those are minor. The book's first four chapters are really good learning tools towards learning Ajax programming, GET'ing and POST'ing data to the server, and processing both text- and XML-based responses.

The book is very modern, using several up-to-date examples of Ajax programming like those employed by NetFlix and A9, and makes frequent use of sidebars to note cross-browser incompatabilities for those unavoidable DOM quirks. Chapter 4's examples are very useful, pragmatic utilities most sites could use at some point.

The one glaring point of criticism I have is that the book should have been titled "Foundations of Ajax for Java". Not that it's a bad thing, but in contrast to most other books that take a framework-agnostic approach to showing Ajax, often using .NET, PHP, CGI and Java examples, this book sticks with the approach of using servlets (and later, JSPs) to processing remote scripts, and bases the later chapters on testing and debugging on available Java tools. Again, there isn't anything inherently wrong with this, but the approach is a little one-sided for those of us not working in Java shops.

Overall, this is a great read for any programmer at any level, to be followed by other APress titles on Ajax that deal with more advanced JavaScript programming. It also makes a good teaching reference for a classroom setting.

What you will NOT find in this book: XMLHttpRequest disection, best practices, POST examples (it says that GET is the one you will use, the POST is there just in case you need it), obviously Web Services are not covered either, actually no XML to XML of any kind.

Examples are quite repetitive (obvious if you don't use Web Services or POST methods) and some of them require a JAVA backend to run.

Nevertheless you WILL find almost half the book dedicated to javascript debug/documentation tools and techniques... BUT the examples in that sections are "foo-bar" examples, none of them related to AJAX in any way.

Bad bad choice for me. But i ordered together with DOM Scripting (Jeremy Keith) and Bulletproof Web Design (Dan Cederholm) and those two books are so good that made me forget about this one really soon.

If you have ever seen the new things that Google, Amazon, or Yahoo Mail can do -- having web pages act more like applications rather than static content and you said "wow that's neat" then you have already been introduced to the wonderful world that is Ajax.

Ajax simply is an acronym for 'Asynchronous Javascript +XML' and it basically allows regular web pages to make requests back and forth without having to send the entire page away from the user. Some examples of this power in action are Google's auto-complete suggestions page, Yahoo Mail being able to refresh your inbox without leaving the main page, and Amazon letting you rate items without being a total send back of the entire page contents.

The technology behind Ajax isn't anything crazy or hard to understand, the beauty of it is its ease of use. If you are new to Ajax and want to learn more about this incredible new technology (hint it's NOT a fad like many other technologies that have fallen by the wayside -- how often do you see Java applets nowadays), this book is an exceptional guide to this new wonder of the web.

From delving into the history of how modern browsers go to where they are today (and why Ajax is so fantastic) to simple examples to discussing tools such as JSUnit and Ajax frameworks that are currently available, this book is perfect for anyone that is looking to start their Ajax development asap.

I have no qualms about recommending this book, but keep in mind it's a bit short and is intended for newbies that just learning the technology. If you want a longer guide or something for more advanced developers of Ajax, you should look elsewhere.

***** HIGHLY RECOMMENDED

I am half-way through the book, and I must say the text has its strong points but has weaknesses that undermine the impression that authors have taken a solid approach.

Strong points:
-Well explained Ajax toolbox. Once you go over the basics of ajaxian coding, you are ready to use the tools that open-source community provided (aplenty, I would say) to ease the work. Some of the explanations here are even better than those given on some of the tools/frameworks websites).
-Clear and simple coding that makes the point very well. Examples are well designed to show the point that auhors want to make.
However, if you try the code yourself you'll be unpleasantly surprised by the fact that some of the examples don't work (chapter 3, the example with the states is one of them).

The weak points of this book:
-lengthy explanation to how the Web came to being, from the first text browser to commercial web application. Most of chapter 1 is totally unnecessary, unless authors were told to write certain number of pages. If authors aim at the versed web developers as their audience, don't those developers already know all the history? The unnecessary length of debate seems to repeat itself in some other parts of the book where entire groups of paragraphs can be summed up in couple of sentences;
-some of the example code is not working, and it doesn't seem that it was tested either since even if you download the source code from the book's website and try it yourself, it won't work. One of those examples does not even involve server-side processing, so it is not the back-end or server or browser. Reviewing and testing the code would be helpfull;
-authors exclusively rely on Java server-side technologies for Ajax backend applications, one would wonder if there is any other way to process XMLHttp requests beside Java. Although it is mentioned repeatedly that there are other server-side technologies for processing, there is no example to show it. If you have at least fair knowledge of any of the server-side languages that is not Java, you'd be better off saving your money and stick with the plenty of online tutorials on Ajax interaction with your choice for server-side processing. Any improved version of this book (or downloadable code from the book's website) would have to include at least some non-Java server-side processing examples;
Just like the Ajax itself (no new technology, just a new point of view), this book won't show you a new thing- just a different view. Ajax may be a good accompaniment to server-side processing, but isn't a new way of doing things.

I'd been playing with ajax for a few weeks when I saw this book at my local B&N's. I'd been experimenting with the idea of creating a set of xml tags that would contain an xhtml fragment and describe an action to perform against a target element. The xml could be parsed either on the server or on the client to automatically produce the javascript code to be executed on the client. I'd never seen anything like that, but I bought this book hoping that it might give me some ideas about how to implement it.

If you understand the basic concept behind ajax, you can safely skip chapter one. That is, unless you're especially sentimental about web technologies. But chapters two three and four do a wonderful job of explaining the techniques of ajax. They concentrate on the client side, and that's cool because that's where all the action is. They assume that you're a web developer, and if you're considering using ajax, you probably are. You won't have any problem envisioning what to do on the server.

I almost skipped chapters five, six and seven because they weren't really about ajax, but were more about javascript development. I'm glad I read them. They almost turned out to be my favorite part of the book. I learned about many javascript tools that I wasn't aware of. And armed with these new tools, I actually feel like a real programmer again when I write javascript, complete with a real debugger, a documentation tool, and a unit testing framework. But as much as I loved chapters five, six and seven, they turned out not to be my favorite.

Imagine my surprise when I got to chapter eight. Not only did the authors already think of the idea that I described earlier, but they'd already implemented it!!! It's an open source project called Taconite! It's hosted on sourceforge, and it Rocks!!

If you want to learn about ajax, then you need to read this book. Really.

This week-end I bought this book, I wanted to learn about ajax. I started reading, the first day I read chapters 1-4 and the second day chapters 5-8. I like the book and if you are new to ajax I truly recommend this book. I do think the book is a little bit short and as a reference book not the one I want to have.

I like the way the examples are presented, with complete source code, screen dumps and downloadable sources from the website. The source code is easy to read and well structured. One of the best parts of the book is the discussion of the framework both writers are involved in : taconite. I cannot wait to try it out.

I guess the best part is the readability, for a non-native english speaker the book is very good to read.

Conclusion, a good book, easy to read, nice examples

I finished reading this book a few weeks ago, but really haven't had time to sit down and write a review that will do it justice. Yet, I've heard that you never find time unless you make time, so I figure now is as good an opportunity as any. First off, let me say that while I have the utmost respect for the guys over at Particletree, I'm really not attempting to just rip off their book reviews as featured in Treehouse Magazine. The reason I mention this is I wrote a book review awhile ago on DOM Scripting around the same time theirs came out.

No folks, I found this little gem of knowledge Foundations of AJAX all on my own while in Barnes & Noble drinking Starbucks coffee with my wife. I was surprised to see a title with the buzz-word AJAX already on the shelves of a mainstream bookstore. It wasn't until later when I read the November issue of Treehouse that I realized it was also featured by them. So there, enough disclaimers and name-dropping. On with the review!

If you are looking to instantly become a master of cool AJAX wizardry, in order to employ the next bit "Web 2.0" application overnight, this book might not be for you. The authors, Ryan Asleson and Nathanial Schutta have written this book with developers in mind. From their introductory chapter:

"Our motto while writing this book was, 'Everything you need to know; nothing you don't.' We assume that as a reader of this book you are already an experienced web application developer."

If that doesn't sound like you, perhaps you should also pick up a few books on both JavaScript and a server-side programming language. This isn't to say you won't benefit from reading Foundations of AJAX, but you will certainly get a lot more out of it if you are already familiar with one or the other.

Much of the book revolves around usage of XMLHttpRequest. This stands for Extensible Markup Language HypterText Transfer Protocol Request, quite a mouthful! Essentially, it is the primary method of data retrieval involved in "invisible" server calls. Basically, it's what puts the Asynchronous aspect in AJAX. Throughout, there are helpful examples of using it for form validation, as well as a few eye-candy excercises such as creating loading progress bars, typical of Flash animations as data is being buffered / cached.

What I found most interesting is that XMLHttpRequest is not actually an officially adopted standard by the W3C. Rather, it has just become so widespread that most major browsers support it in some form or another. Due to this, there is a slight bit of code forking involved when initially creating an instance of the object:

(...)
If you plan on doing any sort of AJAX work, you will likely have that bit of code above seared into your memory. The first statement checks if the browser understands ActiveX, to deal Internet Explorer's odd behavior (big surprise). Failing that, all other browsers will treat it as a simple XMLHttpRequest. Thankfully, that's about all the code forking that is necessary, as the rest of the computation usually takes place on the server accessing a database.

What I would liked to have seen were more "online" examples, utilizing server-side languages. This is just a personal preference though, as the book certainly delivers in all the areas it promised. For a relative newcomer to the game, I would have gotten more out of the tutorials if I'd seen how they interacted with say, PHP or Ruby on Rails. Again, this goes back to the initial assumption that the reader is an experienced web application developer.

Thankfully, the authors have developed a framework which may help you to expediate your development process. It's called Taconite, and despite the name has nothing to do with eating Mexican cuisine in the evening. Taconite is a framework that simplifies the creation of AJAX enabled Web applications. It can be used with any server-side technology including Java Enterprise Edition and Microsoft's .NET Framework.

The book doesn't stop there though, and mentions a variety of other server-side technologies that could be used in web applications. Their main point of emphasis is that AJAX is not a rigid set of guidelines, but rather a flexible method of enhancing a user experience. While the ways of deploying these sites may vary, we all know when we've seen a site that does it well. Such examples would include Gmail, Google Maps and Netflix.

If sites like these intrigue you and quicken your pulse, then Foundations of AJAX is for you. Just remember, using AJAX is like consuming alcohol in public. It is best when done responsibly, lest you get a reputation for being an annoyance to others. Use your newfound knowledge to enhance the user experience, rather than make it unnecessarily complicated. Strive to make your websites seamlessly streamlined, and you will be using AJAX to its fullest potential.

The Ajax phenomenon is quite new - even though the underlying technologies have been around for years - but in a few months it's already become mainstream. It's still in the early-adopters, pre-oreilly-book phase, but some books are already starting to appear. Kudos to Apress for being able to publish a quality product so early.

This is really a foundations book, as the title says. It does a good job of explaining the underpinnings of Ajax, even though the initial chapter on the history of the Internet could have been edited out without much harm. It explains very plainly and clearly the basic Ajax techniques and presents a good overview of some of the best tools available to the Ajaxan craftsman.

Being an introductory text, you can't really blame the authors for not going too deep into the most complex technical and architectural issue. However, if you already tried doing some simple Ajax applications, there's not much here that you haven't probably already read somewhere else. To be honest, there's a good number of hints, tips, and tricks and many pitfalls are dutifully pointed out, but you are left wondering whether there a more systematic approach wouldn't have been better suited.

This is the main defect of the book, in my opinion. It feels rather disorganized at times. There just doesn't seem to be a linear progression from the basic to the more complex issues. Some subjects are barely skimmed over whereas for others (the Venkman debuggers for instance) there's even too much detail.

In particular, the final chapter on Ajax frameworks would have been great if it hadn't dedicated just a few lines to each framework.

If it were not for this, I would have given "Foundations of Ajax" a five-star rating. As it stands, it's only four.

I knew very little about AJAX when I got a copy of this book. I am glad I did. I enjoyed the book quite a lot. The early chapters explained the concepts of AJAX and the xmlhttprequest object. After that, the details and examples helped me put a few AJAX validations on my web applications. If you are interested in the AJAX hype, or just want to write web apps that are a little more interactive, check this book out.

If you are an experienced web developer ready for a concise yet quality introduction to Ajax, then you have found your book. Written in a friendly conversational tone by experienced web developers for experienced web developers, it would be hard to imagine a better introduction to XMLHttpRequest and the related technologies needed to leverage its benefits. A rare, for me at least, five-star recommendation.

This little book's helped me a lot, and I can't recommend it enough. It's short and to the point - the authors give you the history, the technology and the inspiration. Marvellous. Go buy it!

I am a professional Java guy but i can't get what I want (knowledge about Javascript/AJAX programming objects) from this book because the book highlights on advanced concepts from related technologies to explain things. So unless you are a pretty competent Javascript programmer you will struggle to understand this book and struggle to understand the significance of what you are being told and why.

This book is terrible. The exposition is rather poor and shallow. Too focused on Java and not JavaScript/Ajax. The authors knowledge of JavaScript come across as being peripheral and unfocused. This book is simply riding the Ajax craze wave and if you're a self-respecting programmer, you'll be returning this book in no time. Terribly disappointed. There are two other books on Ajax/JavaScript that do a much, much better job at explaining the technology and its uses than this primer; I'd give the names, but don't want to cross-advertise.

We really liked the book as it's real easy to read. We appreciated the overview of JavaScript patterns and very much liked the overview of getting your JavaScript development environment in order with tools like: JSDoc, JSLint, JsUnit and GreaseMonkey.

We look forward to next related "Foundations" book: Foundations of Atlas!

Ryan Aselson and Nathaniel T. Schutta's FOUNDATIONS OF AJAX is for professional web developers and comes from two professional Web developers who have worked with Ajax and realizes its potentials. Ajax lends perfectly to programmer endeavors because it's built on existing Web technologies already familiar to programmers: HTML, Javascript and CSS, and it can be used with one's favorite server-side language choice. So what's left to review? FOUNDATIONS OF AJAX discusses how to blend Ajax into new or existing web applications, providing developers' experiences in such application blends. Chapters provide code, screen shots, and plenty of examples to cover a range of such blends.

If you're looking for an introduction to AJAX, this book is alright. WAY too many pages are devoted to a history lesson at the beginning and a summary of frameworks at the end. In the middle, however, is some good stuff. By chapter 3 you'll know enough to make some cool things happen. The discussion of working through and maniuplating the DOM in chapter 3 is really worth the price of the book.

If you know something about AJAX, this book probably isn't too helpful. If you're worked through a handful of tutorials on the web and are ready to invest some time to get a good handle on AJAX, this book is pretty good.

A decent intro to an evolving technology.

If your preferred server-side language is Java, then you will get more out of this book than I did, since most of the example code uses Java servlets.
Since I prefer to "learn by doing", it would have been much better to have example code in a broader range of languages such as PHP, etc.

This is a good Ajax book for the Java Developer who is already familiar with dynamic web development with Servlets and JSP. It covers a lot of material including the basics of Ajax that all books discuss: XMLHttpRequest, JSON data format, and XML DOM manipulation (classic Ajax). But it adds some other topics that are missing from other books such as alternative Remote Scripting (ex: iframes), Unit Testing, Web Services, JavaScript packaging, and tool selection.

If you like to see code samples, this book has them - they aren't that pretty to look at (the authors don't use a lot of flashy CSS or style tags), but they work. Code samples to common patterns/techniques are included: auto-complete, validation, progress bars, tooltips, etc...

What this book lacks is deep discussions. For that, Ajax in Action is better. But where Ajax in Action reads like a college textbook, Foundations reads more like an article written from one developer to another. I own both -- and liked Foundations as a starting point, and I liked Ajax in Action for reference purposes.

The book does tend to repeat itself at times, and the authors shamelessly promote their own framework briefly for a few pages (Taconite - which isn't a leading Ajax framework).

But overall - its a great starting place for the Java Ajax developer.

This book describes clearly all the concepts you need to start rolling your AJAX applications. Nice explanations through all the book and examples that will help you to grab this new way of developing the Web 2.0.

A must have.

Foundations of Ajax
By Ryan Asleson & Nathaniel T. Schutta
296 pp., Oct 2005, Apress, Inc.
Review by Dave Myers

As a open source technology consultant for non-profit and community media organizations, my job is to keep on top of emerging "Web 2.0" and other social media technologies, and then clearly communicate to my clients any potential value these technologies might offer them. So when a buzz started happening around a "new" technology called Ajax a little more than a year ago, naturally I was intrigued.

Ajax (short for Asynchronous Javascript And Xml) isn't really a specific technology as much as it is a novel way of combining already existing technologies that allow developers to extend the user's browser with lightweight mini-applications. This is particularly useful when the goal is to enhance web page responsive by exchanging small amounts of data with the server behind the scenes. This approach allows users to make changes to interactive web pages without the entire web page needing to reload each time a change is made.

Because of the nature of my work, I found the opening chapter, "Introducing Ajax," very useful for walking me through a brief history of web applications and describing various approaches to building dynamic web pages. The remaining seven chapters provide techniques for communicating back to the server, useful Ajax examples, a toolbox and testing your JavaScript. The appendix covers cross-browser JavaScript and introduces Ajax frameworks.

In all, I found this book quite useful in that it provided me with a much deeper understanding of the advantages (and drawbacks) to using Ajax. A major plus would have been a chapter on incorporating Ajax techniques into some of the more advanced open source content management systems, such as Mambo/Joomla or Drupal. Even so, I think Foundations of Ajax is a worthy introduction to this innovative approach to web app development.

~ Reviewer: David J. Myers | Open Media Center & Open Forest Consortium | Portland, Oregon USA.

This book is a fast read for someone who wants to learn what AJAX is all about. The examples are very simple, but do provide a basis for understanding what AJAX is all about.

I found the second half of the book incredibly valuable. It talks about development tools, testing with JsUnit and debugging JavaScript. Some tools and techniques that I've never seen in one place (but I haven't looked ;) As fast as AJAX is growing in popularity I can see this entire book being covered in a couple of introductory chapters inside another book.

"Foundations of Ajax" provides perhaps the best foundation to get your feet wet with this new web development toolbox. From the introduction the writing is understandable and the examples provided, easy to follow. The overall tone of the book is never condescending and always has the web user's interest at heart. The book ties all the elements it presents fairly nicely in the "Putting It All Together" chapter, to help you move on from there.

On the downside, the book falls a bit short in terms of depth. It is not meant for intermediate-level web developers, but rather for those barely getting immersed in this world, with a decent understanding of JavaScript, DHTML, CSS and DOM.

Nothing to add to my review that hasn't been said in the other great reviews on the site already, but I wanted to add my two cents in and say that this book is a really superb reference and introduction to the Ajax development toolset. I have actually read this book cover to cover, which is something that rarely happens with programming books, but it was that good and helpful. It covers everything you need to know about, and answers a lot of questions and concerns you might have about it as well. All in all, a highly recommended title to get you started in Web 2.0 application development!

It is not a thick book. Easy to read, to finish. It does a good job to introduce Ajax to beginner. It introduces several situations you can start to use Ajax, like data checking, auto page refresh... Almost every web project can apply Ajax on these areas.

I do not give it 5 stars because it talks too much javascript. This is not a javascript book, why does auther need to tell reader how to debug javascript?

But it is still a very good book for beginner to quickly learn ajax with its great sample code.

Excellent book to start from the ground-up with AJAX (please note: not from the ground-up with Web dev!!). The title is truely relevant to the content.

Different readers will have different expectations for any book. If you want to learn and understand what AJAX is built on, how it puts things together, and do not expect the ready-cooked "recipies" for a multitude of effects and quick solutions, this is The Book. Just like the authors say in their introduction, this is not a book for a beginner Web developer, and an experienced developer will find just enough concepts and techniques to build his/her own AJAX snippets and apps (not a literal quote).

Great book, thanks, guys!

This is a good book if you are looking for an introduction to Ajax programming with straight to the point examples and common tools.

This book from Ryan Asleson and Nathaniel Schutta is a basic introduction to Ajax focused on the user interaction aspects. Therefore, most of the book focuses on how to use JavaScript to enhance user experience on web sites. After introducing the XMLHttpRequest object and server communication, the authors show how the Ajax approach can be used in various interaction contexts. The final chapters of the book are dedicated to tools than can ease JavaScript development, particularly for the testing and debugging activities.

Although it is targeted to developers that already master JavaScript and HTML, the clarity of examples makes this book accessible to a larger audience, even if you do not have a PhD in JavaScript. Some may think that the focus of the book (client side scripting) is limited, but I see this book is a good starting point for practical Ajax implementation, especially to enhance an existing web site. The fact that the few server code examples are in Java may however be seen as a disadvantage for readers using another server-side language and that are looking for a broader coverage on their specific configuration.