Customer Reviews

Adding Ajax

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

 

 

§
The book title delivers a vital clue. "Adding Ajax" has a special, limited focus that may be right up your alley -- if you are evaluating enhancing existing Web applications by adding Ajax effects. Developers looking to evaluate building an Ajax-based application architecture from the ground up may not be satisfied.

The book itself is a fast read. That is not because of lack of content -- there is plenty of that! Still, Shelley Powers has organized the information so that most of the chapters can be read out of order, as independently as possible from the others. Chapter 5, which deals with accordion menus, tabbed paging, and overlays with Ajax and common script libraries can be skipped if you are most interested in user updates of live data in Chapter 6 without a problem.

The author cites known experts for related material (like Jeremy Keith and Eric Meyer) and gives lots of URLs for follow-up material.

The book is pretty much practice-oriented and contains lots of code. That leads to my one quibble: there is a lot of code here that does not seem to be available in downloadable form. Some people would find it convenient to have the code examples in a way that could be immediately tested on a server. Re-typing is a drag. The O'Reilly page for this book has a *very* impressive Table of Contents, with content previews -- but no code download.

Other than that, this is a very fine book.
§

Ajax can be added to existing web applications without redoing everything - and ADDING AJAX by Shelley Powers is the perfect web programmer's guide to doing so with ease. Chapters not only cover methods of adding Ajax, but how to use Ajax to enhance an application, how to work with Ajax libraries and interactive elements, and how to understand the effects Ajax has on Web applications. Any web programmer's collection should have ADDING AJAX: it discusses easy integration of Ajax into existing systems and operations.

The book describes a number of ways in which Ajax changes the traditional state of the web. However, to start with the author describes what you need to do to prepare yourself for Ajax. I especially like the Start Clean section in which Shelly claims that the default CSS values are not necessarily good. For example, link underlining in a-tag is not always a good idea. I have heard this concept of starting from a clean sheet a number of times, it is a popular idea in the design community.

Also in the first chapter the author introduces the notion of Progressive enhancement, a web development methodology. Basically it says that the web site should work in various environments, even in the simplest. The idea is to make sure that your web site is still accessible on various devices after adding new features to it. The author stresses the concept of accessibility throughout the book. Indeed, web is an open platform for everybody - people in developing world, people with disabilities, etc.

Then there is a chapter on various web frameworks. The author explains the tradeoffs associated with using them. Obviously, a web framework often includes features you don't need and that increases the loading time of your page, an important issue for people with slower connections. Among the frameworks, Prototype offers the best value. Its goal is to provide a cross-browser layer while staying quite minimal in size.

In Chapter 4 the book describes interactive effects that Ajax allows to add, for example instant previews, fade ins and outs, etc. Then it describes the widgets that Ajax allows one to use: accordion, tabs, overlays. After that, the book deals with more complex issues such as in-place editing and live validation which requires interacting with a server. Besides home-grown solutions that book mentions a variety of web frameworks and tools, for example JotForm - a nice framework for building forms and putting them on your web site. JotForm simplifies life of web developers.

A special chapter is dedicated to advanced effects such as using Ajax with SVG. Finally, the author explains how to build mashups using web APIs. In this chapter the author explains the tradeoffs of using client-side and server-side mashups and explains how to implement a mashup in a non-scripting environment. Despite the fact that this is a book on Ajax the case in which Javascript is disabled is also dealt with. The reason is that many people prefer to browse unfamiliar sites without Javascript, the author claims.

Despite all its gorgeous content the book has drawbacks. The main disadvantage is that it is a bit hackish in nature. For example, there are well defined Javascript design patterns which the book does not mention. Instead, it offers its solutions as functions or snippets of code that the web developers are supposed to paste wherever appropriate. If next editions of the book are to appear it needs to take an object-oriented approach to all the beauty that it has developed.

It is not necessary to read this book sequentially from start to finish. Most chapters largely stand alone, although there is some small degree of building on previous chapters' content, primarily in the use of an "Adding Ajax" library that is created as the book proceeds. However, all of the material is included in the downloadable examples, so you can skip around without too much confusion. What is probably essential is that you read chapters one and two before reading any other chapters. The book assumes the reader is already a web developer who wants to learn to add Ajax effects to his/her web applications. It is assumed that the reader has experience with HTML, XHTML, XML basics, CSS, and JavaScript. Finally, it is assumed that the reader is familiar with relational databases and has worked with them before. The PHP language is what is used in this book for all of the server-side components of the Ajax applications. The following is a description of the book's contents:

Chapter 1. Getting Ready to Make a Move to Ajax - Provides an overview of the Ajax technologies, but also covers the importance of developing a strategy for change to your site before sitting down to code.
Section 1.1. The Technologies That Are Ajax
Section 1.2. Start Clean
Section 1.3. Converting Tables to CSS Layouts
Section 1.4. Continuing the Conversion: Element by Element
Section 1.5. Dealing with Browser-Specific Quirks
Section 1.6. Understanding Your Client Base
Section 1.7. Designing a Framework for Your Site
Section 1.8. Progressive Enhancement Versus Massive Overhaul

Chapter 2. The Ajax Bits - Provides a nuts-and-bolts coverage of the heart and soul of Ajax: how to work with the XMLHttpRequest object.
Section 2.1. The Web Application
Section 2.2. Preparing the Object for Use
Section 2.3. Preparing and Sending a Request
Section 2.4. Processing the Ajax Response
Section 2.5. Endpoints, the JavaScript Sandbox, and Widgets
Section 2.6. That Security Stuff
Section 2.7. A First Look at Performance
Section 2.8. One Last Word on Asynchronous Versus Synchronous

Chapter 3. Ajax Tools and Terminology - Introduces and demonstrates several of the more important Ajax libraries.
Section 3.1. Prototype
Section 3.2. aculo
Section 3.3. Rico
Section 3.4. Dojo
Section 3.5. Other Libraries

Chapter 4. Interactive Effects - Gets into the interactive element that is Ajax, including how to work with events and event handlers that work across browsers, what works if more than one library is used, building tool tips, pulling in help data from external sources, creating an Ajax "fade" to signal changes, live previews, and merging live previews with live updates.
Section 4.1. Ajax-Friendly Event Handling
Section 4.2. Just-In-Time Information
Section 4.3. In-Page Previews
Section 4.4. Color Fades for Success or Failure

Chapter 5. Space: The Final Frontier - Explores the concept of web page as space and covers three popular approaches to managing web space - the accordion, the tabbed page, and the overlay. Also shows how to package complete effects for any number of applications.
Section 5.1. Horizontal Spacing: The Accordion
Section 5.2. Tabbed Pages
Section 5.3. Overlays

Chapter 6. Dynamic Data - Covers how to make data updates, including adding new data, deleting, and making updates, all from within a single page. It also discusses extending existing web applications and incorporating the use of "fades". Some of the performance and security issues associated with database access through Ajax are also covered, as is the use of "live" updates and effects like drag-and-drop sorting.
Section 6.1. In-Place Editing
Section 6.2. In-Place Editing: Performance, Security, and Accessibility
Section 6.3. Highlighting Changes
Section 6.4. Revisiting In-Page Update Accessibility One More Time
Section 6.5. Live Validation
Section 6.6. Performance and Two-Phase Commits
Section 6.7. External Library Data Effects

Chapter 7. History, Navigation, and Place with Single-Page Applications - Explores Ajax effects on the Web including breaking the Back button, losing the browser history, dynamic effects that disappear when the page is refreshed, and being able to link or bookmark an Ajax "page."
Section 7.1. Introducing the Challenger: Paged Content
Section 7.2. Remembering Place
Section 7.3. Old and New Persistence: Side by Side
Section 7.4. The New Page View
Section 7.5. Post-Mortem

Chapter 8. Adding Advanced Visual Effects - This chapter is pure fun and covers some advanced CSS effects including drag-and-drop "scrollbars," pagination, the use of SVG, and the Canvas object.
Section 8.1. Advanced CSS Tricks
Section 8.2. Scalable Vector Graphics
Section 8.3. SVG Quick View
Section 8.4. Mixer: SVG and Ajax
Section 8.5. The Future of Graphics

Chapter 9. Mashup Your Site - This chapter takes maps from Google, photo information from Flickr, and weblog information from Technorati, "mashes" it all up in a nice tabbed page interface, and then shows how all of that can be implemented in such a way that it works whether scripting is enabled or not.
Section 9.1. Mapping with Google
Section 9.2. A Second Service: Flickr
Section 9.3. Adding Technorati to Our Mashup
Section 9.4. Reengineering the Mashup
Section 9.5. The Reengineered Clients
Section 9.6. Summarizing Mashups

Chapter 10. Scaling, Infrastructure, and Starting from Scratch - Discusses the privacy of web services, distributing resource needs, and how tightly coupled you want your server and client components to be. The chapter also looks at starting Ajax from scratch by briefly introducing some of the frameworks that are available.
Section 10.1. Frameworks: Tight Versus Loose Coupling
Section 10.2. The Web Service: Resource and Security
Section 10.3. Ajax Libraries: Homegrown or Borrowed
Section 10.4. Designing Ajax from the Ground Up
Section 10.5. Frameworks du Jour
Section 10.6. Go Forth and Ajax

This book is a complete disappointment. Not enough detail where it matters, and too much useless filler in the latter portions of the book.

Don't waste your time or money on this one.