Customer Reviews

Foundations of Ajax (Books for Professionals by Professionals)

5 star:		(13)
4 star:		(12)
3 star:		(6)
2 star:		(2)
1 star:		(0)

 

 

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.

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

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.

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.

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

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.

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.

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?

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.