I am web designer and i have a multimedia and web developer company. I buy this book because i think that AJAX is the next generation of code for web API. This book is very good, it talk in developer language and you can learn about AJAX with single excercise.

Well, I bought the book, went to samspublishing/register, and registered it. I answered their (way-too-long) "profiling" survey. I found the "book support and downloads" link [...] and entered the ISBN. There's nothing there but the TOC and a sample chapter.

So, like other readers, I ask: where's the source? (and the errata?)


As for the book itself... I had high expectations, but I was rather disappointed. I agree with an earlier reviewer that the examples demonstrate good coding practices, but I wouldn't recommend it for anyone who doesn't already have a firm grasp of Ajax and OO concepts. If you're coming from the Javascript side with no grounding in OOP, you're probably going to be lost.

The author makes a lot of assumptions and unsupported assertions (not necessarily incorrect, mind you, just irritatingly unsupported) about the approaches he's chosen. There's "what," but not much "why."

Some of his examples make me wonder about his grasp of web standards and design. For instance, he builds an webmail "datagrid" (an inbox listing From, Subject, and Date) using DIVs (fixed-width, absolute-unit DIVs at that). Why DIVs? I'm all about web standards, but web standards say "use a table (TABLE, TR, TD) for tabular data" and this is clearly tabular data. Using a table would also allow for more appropriate column widths--I don't know about you, but I need more width for a Subject column than for Date--while remaining eminently stylable with CSS. If there's some reason he chose to use DIVs instead, he doesn't give it. ("This way of structuring data is common practice among web applications," he says--another unsupported assertion.)

Last but not least, I'm not crazy about the author's writing style. For instance, I'd like to see him excise the words "simple/simply" (as in, "instantiating an object is simply the act of...," "object constructors are simply a regular Javascript function...") from his writing. It seems to occur about three times per two-page spread, and that's simply too often. It's simple to avoid this verbal tic; simply search for the word, or ask your editor to-- well, you get the idea. If it's all so simple, why bother writing a book about it?

Things I liked:
- all meat, no filler
- the merciful omission of the "history of Ajax" chapter that most books seem to insist upon :-)
- the explicit linking of design patterns to code snippets
- a good discussion of error handling
- some clever ideas in the feedback/warning section (though also some bad ones, like

Well, I bought the book, went to samspublishing/register, and registered it. I answered their (way-too-long) "profiling" survey. I found the "book support and downloads" link (http://www.samspublishing.com/search/support.asp?rl=1) and entered the ISBN. There's nothing there but the TOC and a sample chapter.

So, like other readers, I ask: where's the source? (and the errata?)


As for the book itself... I had high expectations, but I was rather disappointed. I agree with an earlier reviewer that the examples demonstrate good coding practices, but I wouldn't recommend it for anyone who doesn't already have a firm grasp of Ajax and OO concepts. If you're coming from the Javascript side with no grounding in OOP, you're probably going to be lost.

The author makes a lot of assumptions and unsupported assertions (not necessarily incorrect, mind you, just irritatingly unsupported) about the approaches he's chosen. There's "what," but not much "why."

Some of his examples make me wonder about his grasp of web standards and design. For instance, he builds an webmail "datagrid" (an inbox listing From, Subject, and Date) using DIVs (fixed-width, absolute-unit DIVs at that). Why DIVs? I'm all about web standards, but web standards say "use a table (TABLE, TR, TD) for tabular data" and this is clearly tabular data. Using a table would also allow for more appropriate column widths--I don't know about you, but I need more width for a Subject column than for Date--while remaining eminently stylable with CSS. If there's some reason he chose to use DIVs instead, he doesn't give it. ("This way of structuring data is common practice among web applications," he says--another unsupported assertion.)

Last but not least, I'm not crazy about the author's writing style. For instance, I'd like to see him excise the words "simple/simply" (as in, "instantiating an object is simply the act of...," "object constructors are simply a regular Javascript function...") from his writing. It seems to occur about three times per two-page spread, and that's simply too often. It's simple to avoid this verbal tic; simply search for the word, or ask your editor to-- well, you get the idea. If it's all so simple, why bother writing a book about it?

Things I liked:
- all meat, no filler
- the merciful omission of the "history of Ajax" chapter that most books seem to insist upon :-)
- the explicit linking of design patterns to code snippets
- a good discussion of error handling
- some clever ideas in the feedback/warning section (though also some bad ones, like

Kris did a really good job to be developer friendly. Even thought there are some "TODO" list in he sample, the coding style is very clean, show real world Ajax MVC implementation. It could be better if Kris can go little deep, for example, mini-MVC inside view object, feel the "display" will be too heavy if object has lots of events attached. Overall, it's a nice reading.

I have attended Kris Hadlock's presentation in AJAXWORLD Conference & EXPO last week. I am glad I did because I really wanted to learn how to write reusable JavaScript libraries in my projects. His book is all about AJAX but engineering side of it. Why? because I found not many books out there show you how to capture server errors and record them for debugging and improvement in your project. Not many books show you how to implement the back-end for your frond-end applications. Not many books give you real-world examples. "
Ajax for Web Application Developers" does all for you. It's very simple to understand Kris' codings and explanations because his book is neatly coded and implemented the coding standards.

SOURCE CODES: Demonstrated examples in the book can be downloaded from the publisher. All you need to do is to create an account.

I personally have many AJAX books in my library but specifically liked "Ajax for Web Application Developers".

I strongly recommend it to those who are willing to learn in an easy way to create reusable JavaScript object-oriented libraries and understand the AJAX object methodology.

Good luck

Bought the book, liked the author's intent but I ran into one big problem. No source code for the book. I emailed the publisher last week and heard zero back from them.

Note to publishers: Take care of your readers.

I'm afraid customer service is dead. Maybe it has been outsourced.

First, let me agree with the previous reviewer who noted that this isn't an AJAX book for beginners. It isn't. I don't think anyone claimed that it was. It's a book for web application developers seeking to incorporate AJAX technology into web applications. I wouldn't expect a book with that kind of scope to be appropriate for beginners. This one certainly isn't, and I'm glad, having read enough beginner AJAX books that go over what an XmlHttpRequest is and explain some of the commonly used "stupid JavaScript tricks", dropping the names of popular frameworks and toolkits along the way without really supplying much information about them.

Having said that: I've been seeking a book with the scope of this book for quite a while now. Not since Nicholas Zakas' book "Professional JavaScript for Web Developers" (which I still highly recommend) has this kind of in-depth coverage of the inner workings of AJAX been offered up. Zakas' book (only two years old) went into great detail about using Javascript to do all the cool things we now know as "AJAX"... without once using the word. (Two years ago the word "AJAX" hadn't reached its present buzzword saturation level, if it had been used much at all.)

Hadlock revisits the technology now that AJAX and the various toolkits and frameworks supporting it (Dojo, script.aculo.us, Google Web Toolkit, etc.) have become commonplace. He doesn't provide a tutorial on how to use a particular toolkit or framework; instead, he explains how you can write an "engine" of your own. He starts with a good intro to AJAX, including explanations of how to use both XML and JSON in the response, moves on to the basic principles of object-oriented JavaScript, and then provides examples of reusable JavaScript components to include in your own JavaScript/AJAX engine. Whether you're seeking to reinvent the wheel and write such an engine yourself, or just have a hankering to understand how a toolkit like Dojo or script.aculo.us is constructed, this is great information. Where Zakas' book was an all-encompassing head first dive into deep JavaScript, this book is a briefer but still quite thorough tutorial that gets to the critical information quickly.

The book also includes useful chapters on security and best practices.

Where the book is lacking is in its coverage of server-side interaction. While it concentrates on PHP, it provides some examples of connecting to ASP.NET and ColdFusion, but... there's no mention whatsoever about Java/J2EE. (Ryan Asleson's "Pro Ajax and Java Frameworks" does provide that very sort of information, covering Struts, Spring, and JSF.) Still, where this book shines is in its in-depth explanation of how JavaScript/AJAX toolkits work and how you build your own or extend existing ones. This is still the only book I've seen that even attempts to do that.

I've been working on the Web for a handful+ of years, but save for a brief stunt back in the late 90s, I haven't had much use for JavaScript (with the exception of a few one/two-liners). As such, I came to this book as a new-comer to Ajax.

I also like to learn by way of example, instead of explanation, so code examples are a big plus, if not a requirement.

Unfortunately, from this background, my expectations for this book appear to have been set too high. Granted, it may be because of the lack of full examples in the book (and that they are not available online - more on this momentarily). In fact, that's probably the only thing holding me back.

There's minor errors in code in the book as well, but that's to be expected, and a second edition/printing will fix most of these. By itself, this shouldn't hold you back.

But as a beginner's resource, I'm not sure that this is the book you'd want to pick up. I actually recommend that you take a look elsewhere, particularly online, for how to start with Ajax.

Once you've got the basics down, then you can take a look at this book, as it does provide from very good tips as far as keeping your code standardized.

Had I been the first reviewer, I would have given this book four stars. Since I was not, I have decided to give it three. This is because I feel it's a good book, but not for as large an audience as you may think, based upon reading the description. Again, I feel that this book is more for if you've worked with Ajax, but not in a standard/formal way.


Regarding the code I mentioned above, while it's true that there is a zip file of the code files, I don't feel that it truly contains all of the necessary code. Again, keep in mind that I like to work with full code examples, especially when we're talking about JavaScript (since code is sometimes required in the HEAD, and sometimes not).

I have another Developer's Library book, PHP and MySQL Web Development (the Third Edition), so that's part of why my expectations may have been so high. But, I wasn't expecting the amount of full code that the ColdFusion MX 7 'blue books' provides. ;)

Even if you don't have a working application, let me see where you, the author, are at the end of a section or chapter, even if we're just creating one new file and/or adding code to an existing/new file. This goes for whether you write online or not. If there's code in a chapter, and it's not a snippet, than I'd like to see how the full document's code looks.

I don't care that it's not a complete application, I just may want to have your code on screen while I read through the chapter.

With all the recent buzz (hype) about Ajax, Hadlock goes back to first principles. He shows that it all centres about the XMLHttpRequest object, which he thankfully elides to XHR. This lets a web page get data from the web server, or post data to it, in the form of a background command. Crucially, it does not need the browser to be refreshed. Basically, it can be seen as a loophole, through which the entire Ajax methodology has emerged.

The book explains that XHR gives rise to a programming "style" that is quite different from traditional http coding. As though you are writing a standard application that runs locally. For many programmers, this may have been how you started programming anyway. Plus, http coding has always had a certain stilted awkwardness about it. The coding narrative of the book might seem more natural and easier. One benefit to the programmer is increased productivity. You should be able to code more functionality, and have fewer bugs.