Ajax is taking us into the next generation of web applications. Ajax has broken the client-server barrier by decoupling the client from the server, but an Ajax application still needs a server to extract content from. The most effective use of Ajax and the server requires an understanding of REST, an architectural style used to define Web services. Ajax Patterns and Best Practices explores dynamic web applications that combine Ajax and REST as a single solution. A major advantage of REST is that like Ajax, it can be used with today’s existing technologies. This is an ideal book whether or not you have already created an Ajax application. Because the book outlines various patterns and best practices, you can quickly check and verify that you’re building an efficient Ajax application. Inside the book, the patterns will answer the following questions: What is Ajax, and REST and why do you even care? And if I should care what are some examples of websites that make effective use of Ajax and REST? What are the absolute basics of Ajax and REST and what parts of those basics should I use? How should deal with large amounts of data? Should I cache the data?Should I get the data piece fed to me?

(Patterns: Cache Controller, and Infinite Data) People keep telling me that sessions and cookies are bad? Are they bad? What should I do? And while I think about how about generating content for other devices? (Permutations pattern) I want to fix the back-button problem of the HTML browser. (State Navigation pattern) What is the best way to create a mashup? (REST Based Model View Controller pattern) My page has so many links managed by JavaScript, and I am loosing control, help me make this more organized! (Decoupled Navigation pattern) I understand that HTTP means I send data to the server, how about the server sending me some data without asking for it? (Persistent Communications pattern) My server side code looks like a mess with tags and code pieces everywhere how can I organize and make my HTML page behave like a SOA client and use REST based web services? (Content chunking pattern)

Ajax is taking us into the next generation of web applications. Ajax has broken the client-server barrier by decoupling the client from the server, but an Ajax application still needs a server to extract content from. The most effective use of Ajax and the server requires an understanding of REST, an architectural style used to define Web services.

Ajax Patterns and Best Practices explores dynamic web applications that combine Ajax and REST as a single solution. A major advantage of REST is that like Ajax, it can be used with today’s existing technologies.

This is an ideal book whether or not you have already created an Ajax application. Because the book outlines various patterns and best practices, you can quickly check and verify that you’re building an efficient Ajax application.

Inside the book, the patterns will answer the following questions:

• What is Ajax, and REST and why do you even care? And if I should care what are some examples of websites that make effective use of Ajax and REST?
• What are the absolute basics of Ajax and REST and what parts of those basics should I use?
• How should deal with large amounts of data? Should I cache the data? Should I get the data piece fed to me? (Patterns: Cache Controller, and Infinite Data)
• People keep telling me that sessions and cookies are bad? Are they bad? What should I do? And while I think about how about generating content for other devices? (Permutations pattern)
• I want to fix the back-button problem of the HTML browser. (State Navigation pattern)
• What is the best way to create a mashup? (REST Based Model View Controller pattern)
• My page has so many links managed by JavaScript, and I am loosing control, help me make this more organized! (Decoupled Navigation pattern)
• I understand that HTTP means I send data to the server, how about the server sending me some data without asking for it? (Persistent Communications pattern)
• My server side code looks like a mess with tags and code pieces everywhere how can I organize and make my HTML page behave like a SOA client and use REST based web services? (Content chunking pattern)

Ajax is taking us into the next generation of web applications. Ajax has broken the client-server barrier by decoupling the client from the server, but an Ajax application still needs a server to extract content from. The most effective use of Ajax and the server requires an understanding of REST, an architectural style used to define Web services.

Ajax Patterns and Best Practices explores dynamic web applications that combine Ajax and REST as a single solution. A major advantage of REST is that like Ajax, it can be used with today’s existing technologies.

This is an ideal book whether or not you have already created an Ajax application. Because the book outlines various patterns and best practices, you can quickly check and verify that you’re building an efficient Ajax application.

Inside the book, the patterns will answer the following questions:

• What is Ajax, and REST and why do you even care? And if I should care what are some examples of websites that make effective use of Ajax and REST?
• What are the absolute basics of Ajax and REST and what parts of those basics should I use?
• How should deal with large amounts of data? Should I cache the data? Should I get the data piece fed to me? (Patterns: Cache Controller, and Infinite Data)
• People keep telling me that sessions and cookies are bad? Are they bad? What should I do? And while I think about how about generating content for other devices? (Permutations pattern)
• I want to fix the back-button problem of the HTML browser. (State Navigation pattern)
• What is the best way to create a mashup? (REST Based Model View Controller pattern)
• My page has so many links managed by JavaScript, and I am loosing control, help me make this more organized! (Decoupled Navigation pattern)
• I understand that HTTP means I send data to the server, how about the server sending me some data without asking for it? (Persistent Communications pattern)
• My server side code looks like a mess with tags and code pieces everywhere how can I organize and make my HTML page behave like a SOA client and use REST based web services? (Content chunking pattern)

Ajax is taking us into the next generation of web applications. Ajax has broken the client-server barrier by decoupling the client from the server, but an Ajax application still needs a server to extract content from. The most effective use of Ajax and the server requires an understanding of REST, an architectural style used to define Web services.

Ajax Patterns and Best Practices explores dynamic web applications that combine Ajax and REST as a single solution. A major advantage of REST is that like Ajax, it can be used with today’s existing technologies.

This is an ideal book whether or not you have already created an Ajax application. Because the book outlines various patterns and best practices, you can quickly check and verify that you’re building an efficient Ajax application.

Inside the book, the patterns will answer the following questions:

• What is Ajax, and REST and why do you even care? And if I should care what are some examples of websites that make effective use of Ajax and REST?
• What are the absolute basics of Ajax and REST and what parts of those basics should I use?
• How should deal with large amounts of data? Should I cache the data? Should I get the data piece fed to me? (Patterns: Cache Controller, and Infinite Data)
• People keep telling me that sessions and cookies are bad? Are they bad? What should I do? And while I think about how about generating content for other devices? (Permutations pattern)
• I want to fix the back-button problem of the HTML browser. (State Navigation pattern)
• What is the best way to create a mashup? (REST Based Model View Controller pattern)
• My page has so many links managed by JavaScript, and I am loosing control, help me make this more organized! (Decoupled Navigation pattern)
• I understand that HTTP means I send data to the server, how about the server sending me some data without asking for it? (Persistent Communications pattern)
• My server side code looks like a mess with tags and code pieces everywhere how can I organize and make my HTML page behave like a SOA client and use REST based web services? (Content chunking pattern)

Ajax is taking us into the next generation of web applications. Ajax has broken the client-server barrier by decoupling the client from the server, but an Ajax application still needs a server to extract content from. The most effective use of Ajax and the server requires an understanding of REST, an architectural style used to define Web services.

Ajax Patterns and Best Practices explores dynamic web applications that combine Ajax and REST as a single solution. A major advantage of REST is that like Ajax, it can be used with today’s existing technologies.

This is an ideal book whether or not you have already created an Ajax application. Because the book outlines various patterns and best practices, you can quickly check and verify that you’re building an efficient Ajax application.

Inside the book, the patterns will answer the following questions:

    What is Ajax, and REST and why do you even care? And if I should care what are some examples of websites that make effective use of Ajax and REST?
    What are the absolute basics of Ajax and REST and what parts of those basics should I use?
    How should deal with large amounts of data? Should I cache the data? Should I get the data piece fed to me? (Patterns: Cache Controller, and Infinite Data)
    People keep telling me that sessions and cookies are bad? Are they bad? What should I do? And while I think about how about generating content for other devices? (Permutations pattern)
    I want to fix the back-button problem of the HTML browser. (State Navigation pattern)
    What is the best way to create a mashup? (REST Based Model View Controller pattern)
    My page has so many links managed by JavaScript, and I am loosing control, help me make this more organized! (Decoupled Navigation pattern)
    I understand that HTTP means I send data to the server, how about the server sending me some data without asking for it? (Persistent Communications pattern)
    My server side code looks like a mess with tags and code pieces everywhere how can I organize and make my HTML page behave like a SOA client and use REST based web services? (Content chunking pattern)

Ajax is unique because it combines technologies to make traditional web pages interactive. Ajax Patterns and Best Practices enables you to quickly write applications that work properly. This book is not just about the technical, low-level details of the APIs, but about making things happen on both the client and server sides.

This book addresses the server side with the REST protocol. REST and Ajax blend elegantly together, but REST can also be used alone, with just a computer-to-computer solution. Like Ajax, REST can be used with today’s existing technologies. Millions of client computers are now Ajax-ready, and millions of servers are REST-ready.

This is an ideal book whether or not you have already created an Ajax application. Because the book outlines various patterns and best practices, you can quickly check and verify that you’re building an efficient Ajax application.

Not getting much out of this
I’ve been struggling through this book for the last week. I don’t seem to be getting a lot out of it so I’m giving up. I don’t know if it’s the book, or me. I thought it would be a lot about REST and Ajax (see title) but there’s not a lot of REST, a little bit of Ajax, and a lot of stuff about HTTP, dynamic HTML, and just a lot of paragraphs which seem to go on and on and say very little. I feel that the practical, applicable content could have been delivered in a book a quarter as long.

Waste Time
I had finished several Ajax and JavaScript books before I read this one. Be honest, I am totally lost in this book. Not sure whose fault it is, the writer or the editor. but it’s not good book.

First of all, too many words. Second too many puzzle words and sentence. I don’t care how great idea you have, if you cannot present it clearly, forget about it.

More than Dreadful

I just don’t get how this book even made it past an editor? The writing is horrible, which causes the reader to put the book down in frustration. At least there is consistency among the lowest rating reviewers.

More than Dreadful


I just don’t get how this book even made it past an editor? The writing is horrible, which causes the reader to put the book down in frustration. At least there is consistency among the lowest rating reviewers.

Moving from "can I?" to "should I?"...
It’s one thing to build Ajax applications because you can and they’re cool. But the real issue is building Ajax applications that actually solve problems and use established techniques to do so. This book can help you move from "cool" to "correct"... Ajax Patterns and Best Practices by Christian Gross.

Contents: Introduction to Ajax; The Nuts and Bolts of Ajax; Content Chunking Pattern; Cache Controller Pattern; Permutations Pattern; Decoupled Navigation Pattern; Representation Morphing Pattern; Persistent Communications Pattern; State Navigation Pattern; Infinite Data Pattern; REST-Based Model View Controller Pattern; Index

Gross uses the familiar formula of most books that deal with design patterns. First there’s the Intent (what is happening), followed by the Motivation (why the pattern is necessary). Applicability talks about when it should be used, and the Associated Patterns talks about other patterns that may work well with this one. The Architecture and Implementation sections go into the most detail, talking about how the pattern is laid out and built, as well as what issues might be encountered in the real world. The final section, Pattern Highlights, does a quick summary of the material and is a good overview/reminder of what was covered.

This is an important addition to the Ajax books that are currently out on the market. I’ve always been a believer in the maxim "just because you can doesn’t mean you should." Because Ajax is "hot" right now, it’s tempting to use it to build applications that might well be better designed without all the whistles and bells. This book helps the reader to make the leap from "how can I use Ajax in my next project" to "would Ajax be a good fit for my next project." It’s a subtle difference, but an important one to professional developers...

Dreadful
I read a lot of technical books in relation to my work as a software developer and also out of my interest in particular topics. I was highly motivated to read this book having a great deal of interest in the material. Frankly this is one of the worst technical books I have ever read. Actually I can only admit to getting to page 86 before giving up. Technically the material is good and the example code is well presented. Unfortunately the rambling text made the whole experience painful and ultimately I just gave up.

Decent content, awful writing style
While this book does present useful topics that are particularly relevant to AJAX applications, my main problem with it is the poorly edited and structured way it is written.

The book is full of paragraphs like this one (found at the very beginning of the "Applicability section" of the "Decoupled Navigation Pattern"):

"The Decoupled Navigation pattern is used when content is navigated. The statement is obtuse and does not really say anything because HTML content is always navigated. However, because of the way Dynamic HTML is used, content navigation is sometimes used to generate an effect. When links are used to generate effects, the Decoupled Navigation pattern does not apply."

That’s the whole paragraph beginning to end -- what the heck is this trying to say? Apparently aware of how non-sensical this is, the author starts the next paragraph with "To clarify this explanation..." and then goes on to present an example of a website in Swiss German (I think), with no translation given. Two pages of more examples and a summary rules-of-thumb later, and the only implied take-away is that the Pattern applies when decision-making and data processing are required, and the contents of the page change but not completely.

A few sections like this could be forgiven (and you could quibble as to why he had to write this example this way), but stuff like this prevails throughout every chapter. More often than not, ideas which with some thought could have been condensed into a few sentences, result in half a page of digressions and logical dead-ends.

Here’s another one:

"The need to separate the resource from the representation has not been adequately explained, and some developers may wonder why it is necessary at all. After all, may websites work well and nobody has complained too loudly. The reason why many websites work well is because they have probably implemented the separation of resource from representation. And those that have not done so have received complaints."

Upon reading this, I feel some irreplaceable portion of my lifespan has just been wasted.

At least one good thing this book does is that it only focuses on Patterns that are particular to an AJAX environment (e.g. Persistent Communications, Decouple Navigation, etc.), without wasting time on stuff that is applicable to other more general software design settings (which plenty of other books already cover of course).

While the ideas in this book are interesting and potentially useful to somebody beginning to design an AJAX application, the writing style makes reading it a true chore. Surely there is better written stuff out there on AJAX software design.

DHTML best practice, with a sprinkling of AJAX
Take note of the Amazon title for the book, not the one on the front cover, which doesn’t mention "REST".

Bought this in a hurry and was disappointed ... the first chapter gives some background to AJAX, the second gives basic practical techniques - enough to start you coding - but the rest of the book is not really focused on AJAX: more general DHTML best practice with a grudging references to AJAX.

The book is flagged on it’s back cover as "intermediate to advanced" where I would place it as "intermediate with very strong leanings to beginners". The technical content is not poor - it’s just not targetted and it’s difficult to see who would get good use out of the book. The writing style is readable but there are irritating quirks like illustrative screen-shots of amazon.ch ... OK, so I read German, but it’s hardly a lucid example for an English-language book.

If you already know a little about dynamic web programming, and want to learn how best to lever AJAX functionality in a professional fashion, you won’t get much out of this book.

DHTML best practice, with a sprinkling of AJAX
Take note of the Amazon title for the book, not the one on the front cover, which doesn’t mention "REST".

Bought this in a hurry and was disappointed ... the first chapter gives some background to AJAX, the second gives basic practical techniques - enough to start you coding - but the rest of the book is not really focused on AJAX: more general DHTML best practice with a grudging references to AJAX.

The book is flagged on it’s back cover as "intermediate to advanced" where I would place it as "intermediate with very strong leanings to beginners". The technical content is not poor - it’s just not targetted and it’s difficult to see who would get good use out of the book. The writing style is readable but there are irritating quirks like illustrative screen-shots of amazon.ch ... OK, so I read German, but it’s hardly a lucid example for an English-language book.

If you already know a little about dynamic web programming, and want to learn how best to lever AJAX functionality in a professional fashion, you won’t get much out of this book.

Great book on Ajax development
Many Ajax books have come to press this year and this one is an exception because it explains Ajax from an architecture style as opposed from a development style. What this means is that the book explains how REST is used in developing Ajax web applications.
REST is a style on how to send data between a client and a server. Until now, the basics client/server or browser/server requests has been the same for years no matter what server technology you use (ASP, PHP, and JSP). With Ajax the way data is passed and retrieved to the client id different now. So, the way we architect web applications must be different too. Common sense right? Well, this is the first book that I’ve seen so far that explains Ajax in this way.

The first chapter goes into an overview of Ajax and how it has changed how web applications work. It gives some good examples of various Google web applications and explains how the data is sent to the client behind the scenes. It also talks about the various architectural styles of development.

The second chapter starts focuses on REST theory and data will be sent via the XMLHttpRequest object. It gives a good detailed explanation of the methods and properties and a sample class written in JavaScript that can be used. It also illustrates a debugging process of this class (in Firebox) and shows you how to run through the different states of the XMLHttpRequest.

The third chapter reviews a new pattern ("content chunking") which the author shows you how to incrementally build an HTML page while separating the logic so that each section of the site can be loaded by user interaction. It’s something I’ve never even thought about as I’ve recently read different Ajax books. Unfortunately, I cannot go into detail of this chapter (otherwise I’d be writing a book), but believe me it is an eye opener.

The fourth chapter reviews another pattern ("cache controller") which is the pattern how Google created Google Maps in how the site temporarily stores data per session. This is another reason to buy this book as well. Again, I’ve never seen this methodology discussed in any other Ajax book.

The rest of the book goes through other patterns in developing Ajax web applications that will enlighten you in helping you create the next generation of web apps (web 2.0). This book is skinny (less than 400), but each chapter really goes straight to the point in explaining each pattern and how Ajax can really be used correctly.

A definite must buy for any web developer wanting to truly understand Ajax.

Great info, POOR presentation...
...which is ironic, because the author himself mentions that the reason Ajax is becoming so popular is that people demand better fit and finish in their presentation.

This man DESPERATELY needs an editor (or a new/better one). Sentances run on and on, without ever getting directly to the point. Here’s a great example of what’s wrong with the book: in the first two chapters, he describes Ajax in painstaking (almost insulting) detail, but never really nails down WHAT "REST" is. Even after reading a section in the begining of Chapter 2, "Understanding REST Theory," I had to go to the Wikipedia page to learn just EXACTLY what it is.

This is a good resource for learning Ajax, but there are other good reasources out there, too -- ones that are better written and won’t leave you fighting to understand what’s going on through every page.

Good Book, poor title...
This book was very useful as an introduction to AJAX. There are definitely practices that look useful, and ways to go about things that I will keep in mind.

The author does not seem to know what a Design Pattern is. Most of the "patterns" that are introduced in this book are specific solutions. Design patterns are solutions to generic problems. The author jumps from pre-existing patterns being implemented for specific problems to introducing new "patterns" that only solve specific problems.

The book is well written, but I think comprehension would be easier if he used a little UML. An example of this is his book class. Rather than building the whole class, he could have built a single class diagram, and then only shown the implementation of the non-trivial methods and properties. This would have taken less space, and been easier to read.

Nothing in this book is rocket-science, but there are things that it might take a few projects to work out on your own. I think it is a great book for anyone who is interested in learning AJAX.

Excellent 2nd or 3rd book on Ajax
Buy whatever Ajax primer you want, work with it, get excited about it, but before you use it in a real application, buy and read this book. Never expect to learn about a subject from a patterns book, just expect to leapfrog some painful learning experiences. This book helps you jump from experienced beginner to reasonable competence status without having to build a lot of bad applications first.

Excellent book on Ajax design strategies
This is an excellent theory and strategy book for AJAX. For the uninitiated, AJAX stands for Asynchronous Javascript and XML. In short, it’s the technology behind Web 2.0. New data is fetched from the server and/or presented dynamically through client side Javascript that calls server side sources, commonly XML. Instead of refreshing the entire page, individual elements are changed based on user input and new data pulled from the server. The level of interaction and sophistication involved in using AJAX makes it a force to be reckoned with. Because of that, it’s essential to have a book that covers the underpinnings of this technology.
True to the title of this book, it is packed with good theoretical discussions of how AJAX works and good strategies for how to use AJAX. Knowing all of the tricks isn’t worth much unless you can apply your knowledge in a meaningful way. An example of what I considered impressive was the material on caching strategies: AJAX has always struck me as being a high-transfer way to presenting information and instead this section makes AJAX into a means of saving traffic.
Unlike other books on AJAX, this book covers design patterns for the technology. How do you divide data for distribution? Answer: Use the Content Chunking Patterns. How do you effectively maintain state or at least the impression of maintenance? Answer: the persistent communications pattern. How do you make all of the potential data available at the user’s fingertips? Answer: the infinite data pattern. In the nine patterns presented the author explores much of theory, and that helps you strategize when it comes time to code your own applications. Each pattern has a dedicated chapter that first presents the intent of the pattern, then the motivation for using it in the context of AJAX, a list of possible applications of the design pattern, and associated design patterns. Next, the design pattern’s architecture is explained in the context of solving an actual problem. Finally, the implementation is shown via code and the user’s interaction with various webpages. At the end of each pattern’s chapter there are "highlights" of what has just been presented.
Up to now concrete examples of using AJAX were copious and usable theory has been hard to come by, making this book a welcome volume. I know how to write Javascript, I know what XML is. What I needed to know was how to bring it all together using design patterns that make sense for AJAX. This book accomplished that. My one criticism is that the introductory material in chapters one and two seems a bit rushed, so absolute beginners might benefit by reading "Head Rush Ajax" first, which is an excellent yet more introductory text.
I notice that Amazon does not show the table of contents, so I do that here:
CHAPTER 1 Introduction to Ajax 1
CHAPTER 2 The Nuts and Bolts of Ajax 19
CHAPTER 3 Content Chunking Pattern 53
CHAPTER 4 Cache Controller Pattern 79
CHAPTER 5 Permutations Pattern 111
CHAPTER 6 Decoupled Navigation Pattern 153
CHAPTER 7 Representation Morphing Pattern 197
CHAPTER 8 Persistent Communications Pattern 225
CHAPTER 9 State Navigation Pattern 265
CHAPTER 10 Infinite Data Pattern 303
CHAPTER 11 REST-Based Model View Controller Pattern 333

Seems right on target
I sat down at a book store and went through four Ajax books for an hour. This one stood out as the best by far. I read it exclusively for another hour and I was not let down. I like the idea that the author takes a stand on the technologies that make sense to him (using REST specifically) and presents solutions based on those technologies. I do wish this book gave some more insight into how the server-side REST implementation works. From what I saw it just says something like the server gets data from a database and presents it in the correct xml form when it recieves a request at a specific URL. Very well written, no fluff. I kept thinking to myself, "this is what I’ve been looking for".

Hmm!!! What a great book!!!
Hmm!!! What a great book!!!
.
I have been a tech monkey for quite a long time (self made IT person coming from a "hard sciences" background). IMHO, books getting raving reviews just have like 15-20% genuinely good information. I constantly find myself skipping whole paragraphs, pages and even chapters occasionally. I tend to only give my opinion to say something new or criticize an author and/or posters who, in my opinion, are either under or overselling and author/a book. No, this is not the way to become "popular" and/or get high ratings at amazon, as many people have joked about already commenting on amazons’ posters.
.
Well, with this book I found myself slowing down and carefully reading/studying each single sentence ;-) I, generally speaking, dislike the pretension of some of us, tech monkeys, while talking about coding (software development or whichever way you would like to call it) as if it were NOT merely some sort of scripting carpentry. I haven’t still quite gotten where exactly the "science" in CS comes from. However, I thoroughly enjoyed Christian’s thoughtful discourse, even though his explanations had sometimes and over philosophizing ring to them.
.
This is not a book for "web designers" per se and/or people curious about AJAX. I would totally agree with the poster that said: "To date, I’ve read about four of the major Ajax titles from various publishers, and this is the best of them so far." I not only pleasantly discovered that but also found Gross to be "another kind of animal". I don’t quite follow the criticism of some other posters this book has densely way more good stuff that the few mistakes that might have here and there. Anyway here are the only "things" that I found "questionable", perhaps from my perspective/exposure/understanding or lack thereof:
.
1._ he tends to heavily use URLs as resource pointers in ways that I seem quite a bit unnatural at times. I like to think of the "/webapps" part of a URL as some sort of general/topical indicator. Page 123; I would tend to go "/comments/users?user_name", instead of "/users/[user_name]/comments" as he suggests. The topical issue, posting comments in this case, I find much more important than who is doing it.
.
2._ sometimes while reading his code I wondered if ghe person writing the book was the same one coding ;-) On page 90, where the "Book" class is defined; I would rather go:
public class Book{
private String[][] aBkAtts = new String[][]{
{"_ISBN",""},
{"_Author",""},
{"_Title",""}
};
...
}
.
and I think, he uses the same type of (to me constraining) coding style on page 350, when he talks about "Programmatically being specific and generic at the same time" and he goes on proposing the Extension pattern, when such a similar "expansive" attributes-values arrays would do, which he can also use while handling differences among search APIs.
I would actually use a DS based on associative arrays with some hash map to quickly find the attribute-value through their indexes, but then I could imagine some people would complain about his code not being readable or something ;-) Most explanatory code in books is like this.
.
3._ On page 205, he mistakenly considers some programming languages to be dynamic on the basis of being able to "define, add, or delete function modules or class types during execution and have the ability to persist those changes as work space for later execution". He says that "java and C# cannot do that, or at least as simply as dynamic languages". Well, I don’t know about C#, but I couldn’t find a -simpler- way to do exactly that in java or we might have a totally different interpretation of what "simplicity" means. All "languages" (including programming ones) as part of their very nature -must- have these abilities he enumerates.
.
4._ On chapter 8, Persistent Communications Pattern, he engages in a long discussion of what he calls "the broken Internet" ... the bad part of the story being?!?! ;-) I think he over dramatizes what he considers to be broken in order to make his point of why is it the client that must poll the server.
.
5._ on page 248, where he talks about one of AJAX Achilles heels the "waiting thread" server problem, I would probably used a centralized JMS-based asynchronous strategy to better deal with it.
.
6._ on page 272 ..., I wonder what he meant when he says cookies can not be distinguished among different UA. Cookies are just a string that could be defined whichever way you want. Including scribbling in some UA-specifying data.
.
7._ I would have spoken more about AJAX abuses, excesses and anti patterns in common used out there. Each "hot new thing" is overly abused and AJAX will/is. A good example of it you can find on chapter 11, "REST-based MVC pattern". For those of you that code java reread this article keeping in mind there is some superb technology called JavaWebStart as you read about the AJAX based "Lilina" blog aggregator you might have been salivating or wondering what the big deal was.
.
My final thoughts would be: Danke schoen Christian Gross!

Regarding InnerHTML
It *IS* cross-browser compatible, it isn’t a standard, but is implimented in Gecko (Firefox, Netscape6+) and Opera’s rendering engines. Although it isn’t the "standard" way to do things, it tends to be much faster than creating the object model node by node... there are also some gotchas in the standard way, opposed to using InnerHTML.

This aside, I just wanted to point out that AJAX is not a standard, so it is inherantly difficult to write about, and I commend any author who offers a pragmatic aproach to it... I personally have been developing web-based applications since the mid 90’s, and appreciate a lot of the work in the past year and a half towards bringing these techniques more into widespread use... "Selling" a more featureful application before the ajax craze was much harder than it is now.

A very good treatment but has some gremlins
I am currently part way into the book, however I can already say that it makes an excelent reference for Ajax development. The design pattern approach is a very approprite one, as is the focuse on REST.

One of the books stregths is that it does discuss AJAX in general (from first priciples as it where) rather than how to do Ajax with framework X.

that said there are a couple of points which have annoyed me enough to drop a star

1) The InnerHTML attribute is used in scripts which claim to be cross browser, however this is an IE ownly atribut and does not
work in Mozilla based browsers.

2) While the decision not to use an exsting Framework is good
the justification for why not is rather contrived.
Early on Gross states that he does not belive in cross browser frameworks as javaacript is cross browser and hence the framework is reduendent. he then spends the rest of the book gradully building a light weight Ajax framework. Staring with an Asyncronus request object which hides the different browser
specific aproaches to getting a Request Object. The fact is that
javascript is not fully defined, every implementation is slighly
different and (has the occational bug.

In real development I fully intend to use an Ajax library However it is good to have an understading of hot only what
the framework is doing but why and how it could be done differently.

Another reviwer mentioned the lack of source code for the book.
At the time os this review, source code is available, and it
now contains both .Net and Java Servlet implementations of most
patterns.

Must-have overview of proper Ajax programming & pattern development
I very much enjoyed reading this book and got a lot out of it. To date, I’ve read about four of the major Ajax titles from various publishers, and this is the best of them so far. Christian Gross uses a very friendly voice and makes tacking the technical concepts behind modern-day web programming with Ajax - often a difficult task to simplify by the writing community - very easy to grasp.

But don’t think just because Gross slyly defines the relationship of JavaScript, XML and HTTP that this is merely a book for the newbie. He uses some very advanced patterns soon into the book, and bases his fundamental asynchronous calls on one of the better models of safe and reliable cross-browser object instantiation through the use of a simple factory pattern. It’s effective programming by way of intelligent design.
I appreciated the fact that the patterns described within the book aren’t those that are becoming commonplace among blogs, wikis and books, demonstrating the range of Ajax programming on today’s web. Gross also mentions the idiosyncrasies of the major browsers in handling things like HTTP headers, caching, output display (or lack thereof), and other things you’ll need to know.

Perfect examples of these helpful patterns are those used for persistent communications, cache controlling and permutations for multi-device UI rendering. (I still would have liked to see Gross’ take on the ’AutoSave’ feature that’s so copied by early Ajax adopters, but I won’t hold it against him.)

I also enjoyed the fact that the book kept coming back to REST-style programming, with the capstone chapter being an exhibit of MVC-style applications development on top of REST. Not enough has been published in mainstream print about working with, much less describing, REST systems, so this was another definite plus.

He also references several languages in describing patterns and concepts, such as PHP, Python, C# and Java. While it is a bit of a stretch for those of us not using each one of the languages, it does show cross-platform effectiveness.

Gross also breaks down the importance of coding object-oriented JavaScript, using prototypes, code reuse and other best practices concepts that may take a few re-reads to fully stick, but will make you a better overall programmer. This is a definite must-have.

Excellent book - pity about APRESS.COM
This is a excellent book and deals with constructive foundation patterns for AJAX. Talks about when and when NOT to use it.

APRESS.COM on the other hand - do not have any source code online for these books and support is ’indifferent’!

An additional book of note is "Pro Ajax and the .NET 2.0 Platform" ISBN: 1-59059-670-6 which is a simpler entry into AJAX.
Also checkout http://www.telerik.com/Default.aspx?PageId=2692 about pragmatic ajax toolkit - this is a whole set of the foundation patterns hardened and ready to use.

Ajax Patterns and Best Practices - Well Done
I thought the use of design patterns in the book and there use in Ajax is well done and refreshing. I’ve been a developer for a long time and have seen plenty of garbage code; you won’t find that here. The book has many good Ideas and serves as a good best practices on Ajax and Javascript. I enjoy the fact that the Author covers many of the problems a developer may face with Ajax. My Final thoughts is that it was money well spent.