DailyJS

JavaScript Performance Rocks: Review

Alex R. Young

Subscribe

@dailyjs

Facebook

Google+

performance benchmarks books reviews

JavaScript Performance Rocks: Review

Posted by Alex R. Young on .
Featured

performance benchmarks books reviews

JavaScript Performance Rocks: Review

Posted by Alex R. Young on .

JavaScript Performance Rocks!
is written by Amy Hoy & Thomas Fuchs (of
Script.aculo.us fame). Since Jeff Bezos cited the link between page load times and Amazon's sales performance, it
seems like everyone wants to make faster pages. This book is a set of
PDFs and bundled tools, benchmarks and demos to help you write faster
JavaScript.

A copy of the book will set you back \$39, and your company can buy a
site license for 100 individuals for \$249. Your \$39 gets you:

  • 4 PDFs, with diagrams and screenshots
  • Benchmarks, exploring the performance of different language-oriented features and demonstrating how to compare algorithms
  • Demos relating to the text
  • The DOM Monster bookmarklet that helps analyse the DOM and other features of the page you're on
  • An example of how to use console.log

Book Structure

The book is split into 4 parts:

  1. Understanding and Measuring Performance (71 pages)
  2. Loadtime (74 pages)
  3. Runtime (110 pages)
  4. Interface Coping Strategies (27 pages)

Each of these parts is split into chapters. Chapters are usually
bite-sized essays -- 2-3 pages in size. Each part is 30-100 pages.

Understanding and Measuring Performance

This part introduces performance in the context of web apps. It helps
you decide on how to strike the balance between things you can control,
those you can't, those that the business requires and those that your
customers require. Here's a choice quote:

Here you must rely on the inexact science of knowing how much crap people will take before they leave.

This sums up the tone of the book -- it's casual but without being
inaccurate or annoying. The authors go on to explain the differences
between the major versions of JavaScript, engines, and even includes
benchmarks for major browsers, iPhone, Android and Palm Pre. This is
where you can go to get a graph to explain to your boss or client why IE
is such a problem!

The next chapter, Is Your App Behaving Badly? helps you determine if
your app has performance issues. The Toolbox chapter explores tools
like Firebug and YSlow, and even has some help for IE. The next chapter
explains how to use the DOM Monster, and how to combine it with other
tools. This chapter really helps to get to the heart of a lot of
DOM-based performance issues -- or at least understand why they're
happening.

There are also chapters on inspectors and how to use them for profiling.
Safari's Web Inspector and Firebug are used for detailed profiling
examples.

The final chapters explain how to write your own benchmarking code, with
common pitfalls and example code.

Loadtime

This part explains load order, caching and concatenation. Sprockets is
used as an example of a tool that does concatenation. There's also
detailed coverage on how to set up Apache to cache properly, with
solutions for gotchas like JSON and generated JavaScript.

The chapter on inlining is interesting. It explains when it's safe to
inline for performance reasons, and shows how to do it whilst retaining
some level of sanity. It also talks about pre-caching -- loading
JavaScript and other resources while the user is doing something
relatively slow (like filling out a form). Similarly, Chapter 9: Reduce
Complexity
gives strategies for reducing the overheads introduced by
DOM elements and browser-based solutions.

Runtime

This part covers the really juicy stuff -- the part that many of the
readers of this blog would think of first when looking for a book about
JavaScript performance. It covers everything from the use of operators
and expression tuning, to run away timers and the advantages of JSON
over XML.

This chapter includes many benchmarks and examples. Even basic
statements are compared, like if vs. switch.
Use of (function (){ })(); is explored, with performance
and style notes. Even loop unrolling is covered, which is fairly
low-level in terms of performance tuning but still useful.

There's also a chapter on iPhone tips and tricks. This is useful if
you're a Cocoa iPhone developer and you use WebKit to wrap content or
functionality, or if you're a web developer targeting the iPhone
browser.

UI Coping

This part gives advice on how to structure your app to perform well,
even when technical fixes might not be possible. It gives overall
architectural advice, and design techniques like progress bars and
loading screens. This part is lighter on technical examples but has
useful tips for getting JavaScript developers and designers to create
something customers will enjoy to use.

Conclusion

This book is a treasure trove for web app developers. It covers the
whole life-cycle: UI design, JavaScript performance, server-side and
infrastructure issues. It's written in a casual tone, and the authors
make deeply technical aspects of JavaScript performance easy to
understand.

If your web app is slow you're going to love it -- if you're a hardcore
JavaScript hacker exploring node.js and beyond it
might not appeal as much (depending on the day job).

Disclaimer: We've got affiliate links for JavaScript Performance Rocks -- although I bought my own copy with my hard-earned cash and I
wouldn't post a review of something that wasn't worth buying! Buying a
copy through the affiliate link will also help support DailyJS, which
currently makes negative dollars.