Customer Reviews

Ajax Patterns and Best Practices (Expert's Voice)

5 star:		(8)
4 star:		(4)
3 star:		(1)
2 star:		(1)
1 star:		(3)

 

 

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.

...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.

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

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.

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.

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.

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.

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.

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.

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".