AngularJS - Overcoming performance issues. Limits.

AngularJS.
Performance &
Limits.
Dragos Rusu - CodeCamp Iasi 2014
(dragos.rusu@bytex.ro)

Our story
From
"We have to rethink this whole module, remove time navigation... it's just too sluggish." ★
to
"It's awesome, really fast, it's like going from night to day!" ★
(★) SOFTVISION customer

A few words about me
Dragos Rusu @ SOFTVISION
WEB/ZEND ENGINEER since 2007 (backend, frontend)
ARTICLE WRITER (PHP Architect)
PROJECTS: platforms for airlines (Cathay Pacific, Singapore Airlines, Air Berlin), tourism agencies,
home automation and security, agriculture

We will discuss about...
1. View watches / data bindings
2. What you see is what you show
3. The risk of polluting scopes
4. Core directives to avoid
5. Splitting the page
6. Miscellaneous
7. Limits
Q / A

disclaimer
PERFORMANCE principles for heavy apps (+500 man days)
* many items are not covered here.
* code samples - only in AngularJS
never used AngularJS before? no problem, principles are general, yet the solutions are particular.

GENERAL CONTEXT
"more of 2000 watchers can lag the UI" (angular-tips.com)
"the expressions in curly braces denote bindings" ({{ ... }}) (docs.angularjs.org)
"AngularJS internally creates a $watch for each ng-* directive" (github.com/Pasvaz/bindonce)
"ngRepeat directive instantiates a template once per item [...] each template instance gets its own
scope" (docs.angularjs.org)

Ok... but why would I be counting watches?

AngularJS - Overcoming performance issues. Limits.

Every watcher is run at the digest cycle. The digest cycle is repeated until none of the results has
changed value
(Brian Ford - AngularJS contributor)

✈ A peak into AngularJS source code
$apply:function(expr){
try{
beginPhase('$apply');
returnthis.$eval(expr);
}catch(e){$exceptionHandler(e);
}finally{
clearPhase();
try{
$rootScope.$digest();//Ouhmy...
//[...]
?
https://github.com/angular/angular.js/blob/
master/src/ng/rootScope.js#L943

(1) double-binding creates tons of listeners

SOLUTION:
Whenever feasible, use single-binding solutions
double binding DEMO / bindonce DEMO

Why? Is double-binding slow?
Not quite. The AngularJS way of implementing it is slow ($dirty flags instead of observable
properties).
pssst: ECMA6: Object.observe()

github.com/Pasvaz/bindonce
github.com/kseamon/fast-bind
pssst: bindonce will be part of AngularJS 1.3 release!

(2) direct function calls from templates are called very often
SOLUTION: pre-compute the values to shown in the view model (default values, totals, etc)
<ul>
<ling-repeat="iteminitems">
//{{item.name}}({{computeTotal(item)}})
{{item.name}}({{item.computedTotal}})
</li>
</ul>
?

EXAMPLE
vatTotal will be recomputed on each scope $digest, regardless if the values that vatTotal() depend on
are changed or not (DEMO)
//...controller...
$scope.vat=24;//%
$scope.vatTotal=function(){
return(
$scope.data.item.total*
(1+$scope.vat/100)
);
};
//...template...
{{vatTotal()}}
?

(3) iterating over large data sets slows down the page
SOLUTION: create a lightweight iterable view model
angular.module('codecamp').controller('testCtrl',[
'$scope','dm','$q',function($scope,dm,$q){
'usestrict';
$scope._init=function(){
$scope.testViewModel={};
$q.all([dm.getData1(),dm.getData2()])
.then(function(response){
$scope.computeViewModel(response.data);
}
);
};
$scope._init();
}
);
?

(4) ng-repeat extra DOM manipulations
SOLUTION: ng-repeat with track by id (DEMO)
<ul>
<ling-repeat="iteminitemstrackbyitem.id">
{{item.name}}
</li>
</ul>
?

(5) filters are called very often
SOLUTION: lightweight quasi-independent filters
<span>{{value}}</span>
<ul>
{{item.name|heavyFilteritem.value,$index}}
</li>
</ul>
?
WARNING: avoid touching DOM in filters and watches

(6) multiple recursive $watch might cause page flickering
SOLUTION: try to avoid recursive watch, where feasible
$scope.$watch('model.items',
function(newValue,oldValue){
//dosmth
},recursive=true);
);
?

(7) direct DOM watch functions might slow down the page
SOLUTION: try to avoid complex valueExpression, where feasible (use the data model instead)
//DirectiveLINKfunction
link:function($scope,$el,$attrs){
$scope.$watch(
function(){return$el[0].childNodes.length;},
function(newValue,oldValue){}
);
}
?
SOURCE: stackoverflow.com/questions/21332671

4. Core directives to avoid
5. Splitting the page
6. Miscellaneous
7. Limits

ng-if vs. ng-show (1)
ng-hide and ng-show makes no speed difference (DEMO)
<ulng-hide="hideCondition">
{{item.value}}
</li>
</ul>
?

ng-if vs. ng-show (2)
ng-if/ng-switch might make a difference on more content
(e.g. tabbed page)
<ulng-if="displayCondition">
//CONTENT
</ul>
?
* fewer bindings
* fewer linkers called at startup

remove non-visible elements in the scroll (1)
one easy way would be PAGINATION
doesn't always apply though...

DISPLAY elements, but ONLY THE VISIBLE ones
known as the VIRTUAL/INFINITE SCROLLING problem

usually occurs when large data sets need to be displayed
OpenSource solutions:
http://binarymuse.github.io/ngInfiniteScroll/
http://blog.stackfull.com/2013/02/AngularJS-virtual-scrolling-part-1/
DEMO / DEMO (with virtual scroll)

(1) relying on multiple $rootScope and appCtrl functions may slow down the $digest
SOLUTION: try to avoid polluting $rootScope/appCtrl/* scopes
angular.module('codecamp').service('appInit',[
'$rootScope',function($rootScope){
'usestrict';
$rootScope.computeStuff=function(){...};
$rootScope.getData=function(){...};
$rootScope.i18n=function(){...};
$rootScope.manageAppStates=function(){...};
$rootScope.manageFormatters=function(){...};
//...andsoforth
});
?
- dispatch to specialized services/factories/filters/*

... and have some privacy in all scopes
angular.module('codecamp').controller('testCtrl',[
'$scope',function($scope){
'usestrict';
$scope._privateMethod=function(){};
functionnotRecommended(){
//...
}
});
?

Remember what we've said earlier?
"more of 2000 watchers can lag the UI" (angular-tips.com)

varngEventDirectives={};forEach(
'clickdblclickmousedownmouseupmouseoverblur
mouseoutmousemovemouseentermouseleavecopy
keydownkeyupkeypresssubmitfocuscutpaste'
.split(''),function(name){//[...]
returnfunction(scope,element,attr){//LINK
element.on(lowercase(name),function(event){
//scope.$apply=>$rootScope.$apply
scope.$apply(function(){
fn(scope,{$event:event});
});
//[...]
?
SOURCE: github.com/angular/angular.js/blob/
master/src/ng/directive/ngEventDirs.js#L41

Does that really matter?
video not displayable
Quad core, 8 GB of RAM, Win7

Seems so...
video not displayable

SOLUTION: write custom directive(s), catch the events you need and...
.directive('customMouseEnter',[
function(){
'usestrict';
return{
restrict:'A',
link:function(scope,elem,attrs){
varfName=attrs.customMouseEnter,
func=function(ev){
scope[fName](ev);
};
elem.on('mouseenter',func);
scope.$on('$destroy',function(){
elem.off('mouseenter',func);
});
//[...]
?

...trigger local $digests (DEMO $digest over $apply)
//TEMPLATE
<trcustom-mouse-enter="ctrlMouseLeave">
//CONTROLLER/DIRECTIVE
scope.mouseLeave=function(ev){
//highlight,etc
//$digest()onlyonthescopeyouneed
scope.$digest();
};
?

Seems to be pretty common in the community
http://stackoverflow.com/questions/18421732/angularjs-how-to-override-directive-ngclick
http://briantford.com/blog/angular-hacking-core
(★) if you actually override default directives, remember to set a higher priority

identify what is shareable and what is not
avoid splitting the page in too many sub-components
design your components in a blackbox manner

(1) evalAsync(f) over $timeout(f)
More: http://www.bennadel.com/blog/2605-scope-evalasync-vs-timeout-in-angularjs.htm

(2) Watch out for external components performance and their usage
We had a problem with Moment.JS library (20% of the page load time, according to Chrome
Profiler)

(3) $eval your code from time to time - PERF wise
Batarang (identify $watchers), Chrome Profiler (memory, performance), performance.now()

$emit / $broadcast (1)
SOURCE: jsperf.com/rootscope-emit-vs-rootscope-broadcast/24

$emit / $broadcast (2)
SOURCE: jsperf.com/rootscope-emit-vs-rootscope-broadcast/25

Ok... but why?
AngularJS 1.2.6 and below ▶ 12-15x difference
AngularJS 1.2.7+ ▶ 1.1x difference
"limit propagation of $broadcast to scopes that have listeners for the event"
(github.com/angular/angular.js/blob/master/CHANGELOG.md#performance-improvements-3)
RECAP: Common sense still says we should use them according to their design

"you quickly reach the end of what Angular can do for you when it comes to structuring
applications, at which point the community fragments transform to best practices, and few people
have figured out how to write large-scale Angular apps" (EmberJS core member)

Technical limits
1. + 2.000 dynamic elements on the screen
2. + 3.000 watchers
3. real time apps, where data changes very often
(★) depending on the device

Some apps examples:
stocks exchange
google maps
office apps
OUTPUT: screen flickering, low UX, unresponsive screens
And there's nothing you can do about it... except rewriting it in a lightweight framework

Recap? (1)
(1) be aware of too many data bindings (bindonce)
(2) try to minimize the number of $digest cycles
(3) have pre-computed values at template level
(4) display only the visible elements (virtual scroll)

Recap? (2)
(5) be aware of core directives PERF problems
(6) don't pollute your scopes and make them TDD friendly
(7) watch out for external components (angular or non-angular) performance

What's next?
it's a good habit to think PERF (pre-$compile the code in your head)
don't assume the frameworks are fast, whatever you may write
watch out for memory leaks
REMINDER: AngularJS is quite easy, just try it!
... and last but not least important: find a company that would allow you to grow your skills!

AngularJS - Overcoming performance issues. Limits.

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to AngularJS - Overcoming performance issues. Limits. (20)

Recently uploaded (20)

AngularJS - Overcoming performance issues. Limits.