A Brief But Thorough Tour of Ajax

Bulletproof Ajax will surprise you at first at its slim 196 pages of content. But as with any book, it's the density of good information and quality of writing that count the most. I find both to be on the mark in both respects. The content is timely, relevant, and very up to date. As we all know, the landscape in web design can make one thing hot and another not in a matter of months. It is a credit to the New Riders/Peachpit group that they could get such a relevant book on shelves while it still packed a punch.

This book is best suited to the newcomer to Ajax that will appreciate the entire survey of how it came to be, how the XMLHttpRequest limitations hold you back from accessing any other domain than the one serving up the page. However, Jeremy quickly shows you the workaround -- JSON and the script tag, which have no such limitations. This is an example of the dense and useful content I said this book is notable for.

The author then explains his methodology for gracefully degrading Ajaxed pages that he calls the "Hijax" approach. You would be right to ask, why do I need the author to tell me about degrading? I just want to Ajax everything on my pages. But the author gives you insight into the hodgepodge of support the various Firefox, Internet Explorer, Opera, and Safari browsers provide, each with their own quirks. This is a real timesaving chapter. Learn from the author's research on this topic.

Lastly, the book gives you a full beginning-to-end tour of applying all you have learned in the book in a chapter they title "Putting it all together." As a "just get me to the code" kind of guy, this is the chapter I immediately turned to when I opened the book for the first time. I definitely think persons new to Ajax will covet this chapter. It assembles all the building blocks for Ajax in a way that will make it click for most developers.

In summary, this book is brief, and not exhaustive, but that's the very reason I purchased it. It doesn't get wordy, the chapters are accurate and information-packed, and the book concludes with a nice bringing-it-all-together example that lets you see a tangible manifestation to everything you have learned. This books comes with my strong commendations.

Bulletproof Ajax is an excellent intro to Ajax. It covers both coding Ajax and also design issues and other considerations, all in a very clear style. The coding examples start simple and are extended step-by-step so they're easy to follow.

So I heartily recommend it to anyone looking for an easy high-level intro to Ajax.

Two concerns:

The title is odd. You'd think "Bulletproof" would have to do with oh say... bulletproofing. But it doesn't. It's a broad high-level intro.

Jeremy strongly believes that the right approach to incorporating Ajax such that it's not required for the site to be usable. So, if say javascript isn't enabled on the browser the pages still work fine as traditional fetch-new-pages-from-the-server pages. He calls this the "Hijax" approach and the examples are structured this way. To me this makes sense and I wouldn't quibble, but it is a design choice and not the simplest one for starting with and learning Ajax.

This is an outstanding book. It is well written and easy to read and follow. I especially like that the author builds up the examples as he goes along rather than just putting the whole of the example code at the end of the section. It is another well written book from the Friends of Ed.

It you're looking for an introductory book into Ajax, then read this book. Good overall intro about "what Ajax is" and how the term "ajax" came about. Nice Javascript primer, the DOM concepts, and finally bringing it all together for some simple Ajax. Read entire book in one sitting.., reading the DOm Scripting which is a bit more advanced...

Bulletproof Ajax

This is one of the best written AJAX books I have read. Books designs with excellent user experience features like lighter weight book with 300 pages, beautiful designed book cover, and most importantly the paper quality goes from the rough lower graded paper printed in black to coated premium paper printed in color. This is the type of light-weight book I wouldn't mind to carry around to café, put inside my laptop carrier, and even put it next to my pillow. Author took a very practical way to explain AJAX from basic to advance concepts using many code examples. He shared valuable AJAX experience on XML, JSON, and HTML fragment innerHTML. He presented the latest design principles on how to support AJAX across browser types and versions, how to handle AJAX in disabled JavaScript-browsers similar to Progressive Enhancement in CSS, explain HIJAX approach to make AJAX bulletproof, degrade gracefully and maintain accessibility simultaneously. I would trade few AJAX books for one light-weight book that gives me practical tips and tricks in building AJAX-based Web 2.0 applications.

Bulletproof Ajax

Bulletproof AJAX is solidly assembled, and manages to provide a great introduction to to the fundamentals of writing an AJAX application without assuming that you're using one of the many popular javascript frameworks.

The book starts with a brief review of the fundamentals of the DOM and of Javascript, but it is not a book for teaching either of those. (I'd recommend the other Friends of ED title: _DOM Scripting_ if you're looking for a good introduction to Javascript and the DOM)

Next, the book takes you through the fundamentals of working with AJAX, including common usage scenarios and some gotchas to avoid when first starting out with AJAX.

All in all - a highly recommended read - certainly a must have for those who are just starting out with AJAX.

This tiny book is an excellent hands-on introduction to AJAX, the way AJAX should be done.

The biggest value I see in this book is the perspective it gives you as a website or web-application developer. Many people think that AJAX is cool and try to use it wherever they can. And this is wrong! Not only it confuses the users who already learned how to use "old-fashioned" web applications, but it also makes their new creations inaccessible.

The whole point of the book is to use AJAX carefully. Use it to progressively enhance the websites or web-applications. Remember that the web should be still accessible to people with disabilities and still usable even if you disable JavaScript.

I recommend this book to everybody who is looking to use AJAX on their website. I only wish this book was around when AJAX gained the hype. Many applications could have been written in a better way.

I was skeptical at the book's thinness and the basic review of JavaScript. But when I got into it I realized this book communicated more real information, more clearly, than most tech books I've read (and that's a lot). The book is very well written, with just enough theory to understand, enough code samples to be able to use, and lays out an approach which all Ajax implementers would be wise to follow. It is so good to see a tech author and editors care enough about a book to craft it well.

I admit I was misled by the book's title. Having completed a few AJAX applications I was looking for the icing on the cake (and a lot of hints how to make my applications more robust).

What I've got instead is 90 widely-spaced pages (half of the book) of introduction trying to cover JavaScript, XML, JSON, HTML, DOM and XmlHTTPRequest (and there are good reasons some of these topics get a whole book by themselves) ... obviously not useful for a somewhat experienced developer, and also not really useful for a beginner, who would be better off reading specialized books on each of the topics.

While there are a few interesting techniques described in the second half of the book (as well as potential pitfalls and methods to avoid them), they are simply not warranting the much-promising title; I'll still stick to my copy of Ajax in Action. It's too bad that someone with great ideas like Jeremy Keith (the brains behind Hijax, which is also described in this book) authors such a mis-titled book.

i am familiar with prototype and jQuery ajax framework. It really provide me a detail information under the framework, like what it have to consider, the call cycle of the XMLHttpRequest object, the pros and cons of different data type - XML, JSON and so on.

they mentions most Ajax challenges - back button, url changes...and so on. But they provide the solution just by showing the URL! You know, the site can be inaccessible as the time going on! That's make me deduct it 1 star.

If you want to finding a reference book, then it may not be that great for you.But if you want to find a book which clear ajax concept throughly, then here it is!

The reason I gave this book 4 stars instead of 5 is for its brevity. I bought this book to give me a basic understanding of Ajax, its components, its usefulness, and its pitfalls, and it certainly did that. Jeremy Keith cuts through the hype surrounding Ajax and shows that it's just another tool you can use. However, the book is stronger on methodology (which is explained in logical, clear language) than on multiple code examples and applications, which I could have used more of for the price.

This one is a breath of fresh air into the verbosity of the others ajax books. Keith keep the topics clear as they must be. I also found this book a valuable fast-reference for the DOM scripting. If you want a book to quickly understand tha ajax core-technologies, well, this is it!

"Bulletproof Ajax" is an indispensable resource for any front-end web designer, developer, or interaction designer who is involved or is planning on being involved in a project that includes Ajax techniques. Whether working on an in-house team or as an independent consultant, you'll need to understand the pros and cons of using this popular and somewhat controversial method of serving web pages.

This is not a book for web designers who don't want to code. In order to benefit from this book, you'll need a strong understanding of semantic XHTML and CSS. A passing familiarity with JavaScript is a definite plus as well. (Keith's previous book, DOM Scripting: Web Design with JavaScript and the Document Object Model, is a good place to start.) Chapter 2 begins with an excellent overview of JavaScript terms and functions--the best I've read. (Until you become familiar with JavaScript statements, variables, data types, etc., you'll no doubt be referring back to this chapter often!)

I found that "Bulletproof Ajax's" greatest strength is presenting ways to evaluate why and how a project should or shouldn't include Ajax:

1. Is Ajax appropriate for the project?
2. If yes, how will we most effectively implement Ajax?
3. How will we provide for site visitors who don't have JavaScript enabled on their browsers?
4. How will we address accessibility issues?

In Chapter 5, Keith elaborates on a technique he calls Hijax (which he introduced in DOM Scripting: Web Design with JavaScript and the Document Object Model). This technique applies two key concepts of modern web design: progressive enhancement and graceful degradation. Although Hijax isn't the answer to all Ajax issues, the idea goes a long way towards ensuring that your carefully crafted Ajax goodness doesn't alienate and/or exclude non-JavaScript site visitors.

Simply put, "Bulletproof Ajax" will allow YOU (the front-end guys and gals) to communicate with THEM (the back-end guys and gals) about Ajax and its implementation. This book can help you and your team clarify expectations about Ajax, implement user-centered solutions, and, in all likelihood, save you time and money too.

The trouble with most JavaScript and Ajax related books is they make certain assumptions about the reader, namely that he or she is coming from a server-side programming background. They often say things like: "For those of you who have coded in Python..." or "Perl style regular expressions..." This is good if indeed you are familiar with Python or Perl, etc. But what about the rest of us?

Thankfully, Jeremy Keith has stepped up to fill the void with Bulletproof Ajax. This book does not presuppose a heavy programming background. Instead, it is geared towards the web designer who wants to become more of a front-end developer. The prerequisites are: understanding of semantics, HTML and CSS. If that's you - good news! You already have a working knowledge of the Document Object Model, an essential piece of the Ajax puzzle. Who better to explain it, than co-lead of the DOM Scripting Task Force himself.

This book begins by laying the groundwork for an intelligible conversation. It defines JavaScript syntax such as: functions, methods, arrays and objects. With that vocabulary in place, it jumps into manipulating XHTML documents with JavaScript. It then explains unobtrusive concepts, and gets into the XMLHttpRequest and the world of possibilities that come with it.

This book is unique in that it actually acknowledges the drawbacks of Ajax and, like it's namesake Bulletproof Web Design, helps you plan for contingencies. Rather than referring to accessibility as something that must be added in later, he advocates not removing it in the first place. After all, HTML is already accessible. It's things we do to it with CSS and JavaScript that taint it. On page 102, he urges developers to:

1. Plan for Ajax from the start.
2. Implement Ajax at the end.

He also warns against using JavaScript alone to handle things like form validation and complex calculations. If you rely on this only, you have no fall-back plan. Ideally, JavaScript should be like a waiter going to a from a kitchen, serving things to the end-user. Let me share a few more quotes.

Page 99:

"Far too many Ajax applications are built on the assumption that JavaScript will be available. Instead of treating the language as a tool for enhancing functionality, these applications make JavaScript a requirement. Core functionality is carried out with JavaScript, resulting in an all-or-nothing situation for the user."

Page 116:

"Just because you've hired a waiter doesn't mean you can fire the cook. Yet this is exactly what some Ajax applications attempt to do. Not content with having a waiter take orders and bring food, they get the waiter to do all the cooking too. Cooking should happen in the kitchen. Application logic belongs on the server. It's better for everyone that way. Your application will work more consistently when it's server-based. The browser environment is simply too unpredictable."

I also appreciated Jeremy's subtle sense of humor throughout the book: telling of the origins of the name Ajax, dating back to Greek mythology, and adding a tie-in with the name Jason when referring to JSON. If you didn't know, he's quite a trivia guru, especially when it comes to Star Wars Trivial Pursuit.

I applaud that Jeremy is using XHTML 1.0 Strict throughout this book, as opposed to XHTML 1.1 as in DOM Scripting. It avoids confusion over content-type: text/html vs. application/xhtml+xml. After all, the W3C themselves serve XHTML 1.0 Strict as text/html.

Overall, this book was a delight to read. It covers all the important aspects of Ajax, and even shows a few server-side examples written in PHP. Multiple techniques are addressed, including XML, JSON and innerHTML.

It gets you thinking, rather than ignorantly assuming that you're working in a controlled environment. Many server-side developers neglect accessibility and usability because they're too busy using bloated frameworks without understanding the underlying client-side principles. Quite frankly, I'm sick of it. Luckily, there's finally a book teaching the right way.

Page 196:

"Question the way you implement Ajax. Question the impact Ajax will have on your users. Question the need to use Ajax at all."

Some years ago I found Dan Cederholm's book Web Standards Solutions: The Markup and Style Handbook (Pioneering Series) to be an ideal read from cover to cover. I went on to buy Dan's BulletProof Web Design and found the clarity and pared-down nature of his first book continued into this new 'Bulletproof' brand. So I was delighted to find another Bulletproof book that covered Ajax.

Jeremy Keith's Bulletproof Ajax is excellent. I know XHTML, CSS and a little PHP. Jeremy's book has introduced JavaScript to me (finally) in a way I can simply understand, same for the DOM. It worked for me becuase he analogised to the way CSS works. The emphasis on seperation continued through the book. He shows how to add Ajax but not as a piece of a jigsaw, more as a magnifying glass to look at the finished jigsaw with greater power. He shows how a page needs to be built to work and then the Ajax added as a dispensible layer that if unavailable (due to JavaScript being turned off), will not stop the page from working, graceful degrading. A bulletproof approach.

If I was a JavaScript guru and DOM master than this book would be a a luxury. As I am a newbie to writing my own JavaScript, traversing the DOM and keen to use Ajax safely to make better user experiences for my clients, I am delighted with this book.

I've written Ajax applications using the XMLhttp object a few times requesting both xml and text responses. I've also use the script.aculo.us library to write Ajax applications. Bulletproof Ajax does more than show you the basic ropes.

Bulletproof Ajax explains all the pieces, including xml after-processing. It also demonstrates what Jeremy Keith calls Hijax. I normally write applications for an intranet so had not given unobtrusive Ajax much thought. But just today I discovered that my personal laptop did not have the XML parser installed. So for non-intranet applications, to be sure that the viewer can access your application it had better run without ajax. Jeremy demonstrates how to use Ajax to enhance a web application without enforcing the presence of javascript or the XML parser.

Jeremy also presents JSON scripting which he explains is a way to perform defacto Ajax without the limitation of same-site sources. JSON permits, in essence, cross-site ajax.

I personally also learned more about javascript object programming than I'd clearly understood previously. Jeremy doesn't assume that you know unstated fundamentals and yet he takes you through these fundamentals without making it a chore. As with his previous book DOM Scripting, Jeremy leads you into confident programming. Using what I learned reading Bulletproof Ajax I just wrote my own object library for Ajax with enhancements I wanted. Now, when developing intranet applications I won't be stuck facing errors resulting from someone else's ajax library which I don't understand and wouldn't want to change or maintain.

Bulletproof AJAX by Jeremy Keith was an excellent beginners book to AJAX. For those who have read Bulletproof Web Design by Dan Cederholm, this book literally took the same approach. The book starts with the very basics and walks you to the end where you create a fictional bookstore that utilizes AJAX. Each chapter addresses what it means to make an AJAX application bulletproof. The author is brutally honest while informing you the barriers that AJAX faces, and how to get around them. Sometimes the best solution is: don't use AJAX. Obviously, this isn't the case for everything - or there wouldn't be a book to read. I appreciated the approach of making sure that your AJAX applications utilize progressive enhancement and are unobtrusive. These are two key elements when dealing with JavaScript as a whole. The entire journey of this brief (but informative) 200 page book looked a little like this:

Chapter 1 answers the question "What is AJAX?" and gives a brief introduction and history lesson as to it's origins. This is very basic, but begins to get your feet wet understanding that AJAX is not a new technology - but one that has recently hit the spotlight.

Chapter 2 gives a thorough overview of the Document Object Model. He explains what the DOM is, how it relates to your structured HTML and Javascript, and the methods associated with traversing the DOM. This is very important as he moves forward to create unobtrusive AJAX.

Chapter 3 dives into the XMLHttpRequest object, its origins, and how to create a bulletproof instance of the object. This handles the differences between IE and other browsers and how they implement the request. He creates a wrapper for use (and use through the rest of the book) that allows us to send requests, receive responses, and then position it accordingly in the DOM.

Chapter 4 covers the Data Formats that are returned by our request. These include XML, JSON, and HTML. He covers each data format, and creates another wrapper for retrieving the different data formats.

Chapter 5 introduces HIJAX. This is where he irons out some of his previous scripts. Initially inline scripts were used as examples, but with HIJAX we see how we can create bulletproof implementations of AJAX. Topics covered here include progressive enhancement, unobtrusive Javascript, and rich clients.

Chapter 6 forces us to hit a wall (briefly). This chapter discussed the challenges that AJAX faces (and has faced in the past). Some of the challenges revolve around web services and connecting to remote API's, making your application backwards compatible, how to work around browser inconsistencies and consistencies (The back button and bookmarking), and how to wireframe an application that will change in each section.

Chapter 7 discusses accessibility in relation to AJAX. One of the most frustrating parts for any application moving forward is dealing properly with screen readers. Screen readers are incredible tools, but since they sit on top of an existing browser it can make some things rather difficult (especially checking for the existence of Javascript).

Chapter 8 starts to wrap things up. Taking everything we have learned to this point, he discusses planning, applying, and bulletproofing your application.

Chapter 9, the final chapter, looks to the future of AJAX. Not only did it discuss the future - it covered many of the current frameworks available. He does a great job of discussing the good and bad of using frameworks - and where frameworks are best suited.

Overall, this book was a great read. This book is geared for the beginner, and I believe it will help a user have a complete grasp of AJAX. AJAX is a tricky subject, and Jeremy does a great job of tackling each subject in great detail. This book would go well with a Javascript book to help you bulletproof your applications. This is a must read for those who are interested in understanding AJAX and its place in the world of web standards.

Jeremy Keith has been on forefront of upcoming web practices for quite awhile now. He is a member of the Web Standards Project, joint lead of the DOM Scripting Task Force, stresses web standards and accessibly in web design. His website addaciao.com is a great resource of material on the subject and you can pretty much find him at almost any web conference in the world nowadays.

This is his second book (Dom Scripting), and it pretty much continues his relentless pursuits of accessibility and unobtrusiveness wherever JavaScript is involved. This book focuses on the creating well structured Ajax web applications but making sure the reader does not forget the most important thing about web sites: their content. If all this fancy-shaky, bells and whistles Ajax stuff prevents a disabled user using a screen reader to be able to view your website content, what is the point?

The book is aimed (like his first) at web designers as opposed to programmers. Jeremy does not use fancy techo-bable when regular simple English will suffice. He wants to make sure that anybody can understands the concepts of Ajax and its components (JavaScript, XML, XMLHTTPRequest) can be used properly by anybody who is willing to read it. Not too many books are written like this (unfortunately) and it is a joy to read. Though when you actually see it and how short it is (barely 200 pages with index), you may thing..."this is too short for me to get anything out of this". But you would be so wrong. There are around 10 or so Ajax books out there now (more on the way I'm sure), and I probably have at least half them. I would put this as probably I the top 2 of all the Ajax books out there. IF you are really going to immerse yourself in learning and using Ajax, I would suggest getting one more "BIG" reference type book on it and that would all you would need. This is a must-buy for anybody wanting to learn Ajax with standards, accessibility in mind.

Ok, enough about how much I like this book, on with some details about the book:

Chapter 1: A nicely illustrated introduction of what Ajax is what pieces comprise it, who started using it, how it is used and why it is so "hype" right now.

Chapter 2: A very nice introduction to JavaScript and DOM basics. Honestly, this chapters takes about the best of Jeremy's DOM Scripting Book and condenses it into about 10 pages. Of course it is just a overview of the DOM methods and a brief explanation of each, but it is all you really need to get started. You should buy his DOM Scripting book if you want to get some hands-on experience with the DOM. Or get the JavaScript Reference book from oreilly which is a JavaScript encyclopedia of everything there is to know about it.

Chapter 3: XMLHttpRequest - The "meat-and-potatoes" of how Ajax works. Jeremy does a great job of explaning the history of how this object got first developed (IE 5 - XMLRequest) and is used with proper object detection.

Chapter 4: Jeremy discusses the good and bad of using XML and JSON to transport data. Very helpful.

Chapter 5: Hijax: Jeremys own creating of progressive enhancement and Ajax. He continues his "unobtrusive JavaScript" techniques with DOM Scripting and goes into the Ajax arena. No other book that I have seen talks about this topic when dealing with Ajax. All I see in other books is using fancy APIs and Patterns, but what if JavaScript is unavailable? Now what will your web app do? Obviously not much unless you read this chapter.

Chapter 6: Tough obstacles when developing Ajax apps such as: Bookmarking, Back button, user feedback are discusses to make sure the user experience continues to be a good one.

Chapter 7: Screen readers and Ajax - A tough sell.

Chapter 8: Putting it all together - A nice complete Ajax web app (Book Shopping Cart) that takes everything Jeremy has talked about up till now

Chapter: The Future? A discussion of the different frameworks available: Dojo, prototype, script.aculo.us, Y! UI, JQuery and mochikit.

As I've said before even though this book is short, the bang for the buck is more than any other Ajax book on the market today, hands down. Go out and buy it!

If you liked Dom Scripting, you'll adore Bulletproof Ajax. The latter is very much an extension of the former, but this time Jeremy's wise words and clean code are all knocked up in the inimitable New Riders color and style. Nice price, too. Buy!

This book has 9 to 10 chapters of different things used in the web design.
This is useful only for a stater who is starting to used AJAX for very small usage. Every topic starts comparing to Javascript and shows the ajax way doing the same.Not all the topics are reviwed completely. It has some new topics called "HIJAX" etc....