High Performance JavaScript (Amazon DevCon 2011)

High Performance JavaScript
Nicholas C. Zakas | Amazon DevCon | April 27, 2011

Who's this guy?

Presentation Contributor,
Architect Creator of YUI Test

Author Lead Author Contributor Lead Author

@slicknet

(Complaints: @robertduffy)

Does JavaScript performance
matter?

After all, all browsers now have
optimizing JavaScript engines

Tracemonkey/ V8 Squirrelfish Chakra Karakan
JaegarMonkey (all) (4+) (9+) (10.5+)
(3.5+)

So our scripts are getting really,
really fast

Old computers ran slow applications
Small amounts of CPU power and memory

New computers are generally faster but
slow applications still exist
More CPU + more memory = less disciplined application development

http://jeftek.com/1942/motorola-xoom-sunspider-results/

It's still possible to write slow
JavaScript on the new, faster
JavaScript engines

JavaScript performance
directly
affects user experience

"Know the enemy and know yourself;
in a hundred battles you will never be in peril."

-Sun Tzu, The Art of War

The UI Thread
The brains of the operation

The browser UI thread is responsible for
both UI updates and JavaScript execution
Only one can happen at a time

Jobs for UI updates and JavaScript execution
are added to a UI queue
Each job must wait in line for its turn to execute

<button id="btn" style="font-size: 30px; padding: 0.5em
1em">Click Me</button>

<script type="text/javascript">
window.onload = function(){
document.getElementById("btn").onclick = function(){
//do something
};
};
</script>

Before Click

UI Thread

time
UI Queue

When Clicked

UI Thread

time
UI Queue

UI Update

onclick

UI Update

When Clicked

UI Thread

UI Update

time
UI Queue

onclick
Draw down state
UI Update

When Clicked

UI Thread

UI Update onclick

time
UI Queue

UI Update

When Clicked

UI Thread

UI Update onclick UI Update

time
UI Queue

Draw up state

No UI updates while JavaScript is
executing

JavaScript May Cause UI Update

var div = document.createElement(“div”);
div.className = “tip”;
div.innerHTML = “You clicked me!”;
document.body.appendChild(div);
};
};
</script>

A UI update must use the latest
info available

Long-running JavaScript
=
Unresponsive UI

Responsive UI

UI Thread

UI Update JavaScript UI Update

time

Unresponsive UI

UI Thread


time

The longer JavaScript runs,
the worse the user experience

The runaway script timer prevents JavaScript
from running for too long
Each browser imposes its own limit (except Opera)

Runaway Script Timer Limits
• Internet Explorer: 5 million statements
• Firefox: 10 seconds
• Safari: 5 seconds
• Chrome: Unknown, hooks into normal crash
control mechanism
• Opera: none

Interpreted JavaScript

UI Thread

Interpret

time

JITed JavaScript (1st Run)

UI Thread

Compile Execute

time

JITed JavaScript (After 1st Run)

UI Thread

Execute

time

How Long Is Too Long?
“0.1 second [100ms] is about the limit for
having the user feel that the system is reacting
instantaneously, meaning that no special
feedback is necessary except to display the
result.”
- Jakob Nielsen

Translation:
No single JavaScript job should
execute for more than 100ms to
ensure a responsive UI

Recommendation:
Limit JavaScript execution to no more
than 50ms

measured on IE6 :)

Doing so makes your application awesome

Loadtime Techniques
Don't let JavaScript interfere with page load performance

During page load, JavaScript
takes more time on the UI thread

<!doctype html>
<html>
<head>
<title>Example</title>
</head>
<body>
<p>Hello world!</p>
<script src="foo.js"></script>
<p>See ya!</p>
</body>
</html>

Result

UI Thread


time

Result

UI Thread

Hello world! foo.js See ya!

time

Result

UI Thread

Hello world! Download Parse Run See ya!

time

The UI thread needs to wait for the script to
download, parse, and run before continuing

Result

UI Thread


Variable Constant

Download time takes the longest and is variable

Translation:
The page doesn't render while
JavaScript is downloading, parsing, or
executing during page load

<!doctype html>
<html>
<head>
</head>
<body>
<p>Hello world!</p>
<script src="bar.js"></script>
<p>See ya!</p>
<script src="baz.js"></script>
<p>Uh oh!</p>
</body>
</html>

Result

UI Thread

JavaScript UI Update JavaScript UI Update JavaScript

time

The more scripts to download in between UI
updates, the longer the page takes to render

Technique #1: Put scripts at the
bottom

<!doctype html>
<html>
<head>
</head>
<body>
<p>Hello world!</p>
<p>See ya!</p>
</body>
</html>

Put Scripts at Bottom

UI Thread

UI Update UI Update JavaScript JavaScript JavaScript

time

Even if there are multiple scripts, the page
renders quickly

Technique #2: Combine
JavaScript files

<!doctype html>
<html>
<head>
</head>
<body>
<p>Hello world!</p>
<p>See ya!</p>
<script src="bar.js"></script>
<script src="baz.js"></script>
</body>
</html>

UI Thread

UI Update JavaScript JavaScript JavaScript

time

Each script has overhead of downloading

UI Thread

UI Update JavaScript

time

Combining all of the files limits the network
overhead and gets scripts onto the page faster

<!doctype html>
<html>
<head>
</head>
<body>
<p>Hello world!</p>
<p>See ya!</p>
<script src="foo-and-bar-and-baz.js"></script>
</body>
</html>

Technique #3: Load scripts
dynamically

Basic Technique
var script = document.createElement("script"),
body;
script.type = "text/javascript";
script.src = "foo.js";
body.insertBefore(script, body.firstChild);

Dynamically loaded scripts are non-blocking

Downloads no longer block the
UI thread

Using HTML <script>

UI Thread


time

<!doctype html>
<html>
<head>
</head>
<body>
<p>Hello world!</p>
<script>
body = document.body;
script.src = "foo.js";
</script>
<p>See ya!</p>
</body>
</html>

Using Dynamic Scripts

UI Thread

Hello world! See ya! Run UI Update

time

Download Parse

Only code execution happens on the UI thread,
which means less blocking of UI updates

Usage

loadScript("foo.js", function(){
alert("Loaded!");
});

Timing Note:
Script execution begins immediately
after download and parse – timing of
execution is not guaranteed

Using Dynamic Scripts

UI Thread

Hello world! Run See ya! UI Update

time

Download Parse

Depending on time to download and script size,
execution may happen before next UI update

<!doctype html>
<html>
<head>
</head>
<body>
<p>Hello world!</p>
<script defer src="foo.js"></script>
<p>See ya!</p>

</body>
</html>

Support for <script defer>

3.5 7.0 5.0 4.0 ?

Deferred scripts begin to
download immediately,
but don't execute until all UI
updates complete

Using <script defer>

UI Thread

Hello world! See ya! More UI More UI Run

time

Download Parse

Similar to dynamic script nodes, but with a
guarantee that execution will happen last

Timing Note:
Although scripts always execute after
UI updates complete, the order of
multiple <script defer> scripts is not
guaranteed across browsers

Technique #5: Asynchronous
scripts

<!doctype html>
<html>
<head>
</head>
<body>
<p>Hello world!</p>
<script async src="foo.js"></script>
<p>See ya!</p>

</body>
</html>

Support for <script async>

3.6 7.0 5.0 ? ?

Asynchronous scripts behave a
lot like dynamic scripts

Using <script async>

UI Thread

Hello world! See ya! Run UI Update

time

Download Parse

Download begins immediately and execution is
slotted in at first available spot

Note:
Order of execution is explicitly not
preserved for asynchronous scripts

Runtime Techniques
Ways to ensure JavaScript doesn't run away

function processArray(items, process, callback){
for (var i=0,len=items.length; i < len; i++){
process(items[i]);
}
callback();
}

//create a new timer and delay by 500ms
setTimeout(function(){

//code to execute here

}, 500)

setTimeout() schedules a function to be
added to the UI queue after a delay

When Clicked

UI Thread

UI Update

time
UI Queue

onclick

UI Update

When Clicked

UI Thread


time
UI Queue

After 25ms

UI Thread


time
UI Queue

JavaScript

After 25ms

UI Thread

UI Update onclick UI Update JavaScript

time
UI Queue

After Another 25ms

UI Thread

UI Update onclick UI Update JavaScript

time
UI Queue

JavaScript

After Another 25ms

UI Thread

UI Update onclick UI Update JavaScript JavaScript

time
UI Queue

Web Workers
●
Asynchronous JavaScript execution
●
Execution happens outside of UI thread
●
Not on the UI thread = no UI delays
●
Data-driven API
●
Data is serialized when sending data into or
out of Worker
●
No access to DOM, BOM
●
Completely separate execution environment

//in page
var worker = new Worker("process.js");
worker.onmessage = function(event){
useData(event.data);
};
worker.postMessage(values);

//in process.js
self.onmessage = function(event){
var items = event.data;
for (var i=0,len=items.length; i < len; i++){
process(items[i]);
}
self.postMessage(items);
};

When Clicked

UI Thread

UI Update onclick

time

Worker Thread UI Queue

UI Update

When Clicked

UI Thread


time

Worker Thread UI Queue

JavaScript

Worker Thread Complete

UI Thread


time
UI Queue

onmessage

Worker Thread Complete

UI Thread

UI Update onclick UI Update onmessage

time
UI Queue

Support for Web Workers

3.5 4.0 4.0 ? 10.6

Repaint and Reflow
Hidden performance costs of common operations

Long UI updates
=
Unresponsive UI

JavaScript can cause
long UI updates by triggering
repaint and reflow

A repaint occurs when a visual change doesn't
require recalculation of layout
Changes to visibility, colors (text/background), background images, etc.

Repaint

this.style.color = "#ff0";
};
};
</script> Repaint!

A reflow occurs when a visual change
requires a change in layout
Initial page load ▪ browser resize ▪ DOM structure change ▪ layout style change
layout information retrieved

Reflow

var div = document.createElement(“div”);
div.className = “tip”;
div.innerHTML = “You clicked me!”;
document.body.appendChild(div);
};
};
</script>
Reflow!

Repaints and reflows are queued
up as JavaScript executes
and then executed in order

Reflow

var list = document.getElementsByClassName("items")[0],
i, item;

for (i=0; i < 10; i++){
item = document.createElement("li");
item.innerHTML = "Item #" + i;
list.appendChild(item);
}

Reflow x 10!

Limiting repaints/reflows
improves overall performance

Technique #1
Perform DOM manipulations
off-document

Off-Document Operations
• Fast because there's no repaint/reflow
• Techniques:
– Remove element from the document, make
changes, insert back into document
– Set element's display to “none”, make
changes, set display back to default
– Build up DOM changes on a
DocumentFragment then apply all at once

DocumentFragment
• A document-like object
• Not visually represented
• Considered to be owned by the document from
which it was created
• When passed to appendChild(), appends all
of its children rather than itself

DocumentFragment

var list = document.getElementsByClassName("items")[0],
fragment = document.createDocumentFragment(),
i, item;

for (i=0; i < 10; i++){
item = document.createElement("li");
item.innerHTML = "Item #" + i;
fragment.appendChild(item);
}

list.appendChild(fragment);

1 Reflow

Technique #2
Group Style Changes

Repaint! Reflow!

element.style.color = "red";
element.style.height = "100px";
Reflow!
element.style.fontSize = "25px";
element.style.backgroundColor = "white";

Repaint!

Grouping Style Changes

.active {
color: red;
height: 100px;
fontSize: 25px;
background-color: white;
}

element.className = "active";

Reflow!

Grouping Style Changes

var item = document.getElementById("myItem");
item.style.cssText = "color:red;height:100px;" +
"font-size:25px;background-color: white");

Reflow!

Technique #3
Avoid Accidental Reflow

Accidental Reflow

element.width = "100px";

var width = element.offsetWidth;

Reflow!

What to do?
• Minimize access to layout information
– offsetTop, offsetLeft, offsetWidth, offsetHeight
– scrollTop, scrollLeft, scrollWidth, scrollHeight
– clientTop, clientLeft, clientWidth, clientHeight
– Most computed styles
• If a value is used more than once, store in
local variable

Does hardware acceleration
help?

Traditional Rendering

UI Thread

Compositing Drawing

time

Hardware Acceleration

UI Thread
Prep Wait

time
Rendering info Signal complete

Compositing Drawing

GPU

Avoid Slow Loading JavaScript
• Put scripts at the bottom
• Concatenate scripts into as few files as
possible
• Choose the right way to load your scripts
– Dynamically created scripts
– Deferred scripts
– Asynchronous scripts

Avoid Slow JavaScript
• Don't allow JavaScript to execute for more
than 50ms
• Break up long JavaScript processes using:
– Timers
– Web Workers

Avoid Long UI Updates
• Be careful of repaint and reflow
• Perform complex DOM operations off-
document
– Remove elements and re-add them
– Use DocumentFragment objects
• Group style changes together
• Avoid accidental reflow

Etcetera
• My blog:
www.nczonline.net

• Twitter:
@slicknet

• These Slides:
http://slideshare.net/nzakas/

Creative Commons Images Used
• http://www.flickr.com/photos/lrargerich/3115367361/
• http://www.flickr.com/photos/hippie/2406411610/
• http://www.flickr.com/photos/55733754@N00/3325000738/
• http://www.flickr.com/photos/eurleif/255241547/
• http://www.flickr.com/photos/off_the_wall/3444915939/
• http://www.flickr.com/photos/wwarby/3296379139/
• http://www.flickr.com/photos/derekgavey/4358797365/
• http://www.flickr.com/photos/mulad/286641998/
• http://www.flickr.com/photos/torley/2361164281/
• http://www.flickr.com/photos/ottoman42/455242/
• http://www.flickr.com/photos/goincase/3843348908/

High Performance JavaScript (Amazon DevCon 2011)

High Performance JavaScript (Amazon DevCon 2011)

Recommended

More Related Content

What's hot

What's hot(20)

Viewers also liked

Viewers also liked(8)

Similar to High Performance JavaScript (Amazon DevCon 2011)

Similar to High Performance JavaScript (Amazon DevCon 2011)(20)

More from Nicholas Zakas

More from Nicholas Zakas(8)

Recently uploaded

Recently uploaded(20)

High Performance JavaScript (Amazon DevCon 2011)