Notes

{
http://blog.ionic.io/crosswalk-comes-to-ionic/ CROSSWALK { 10-15 MB size }
http://geeklearning.io/boost-your-ionic-app-performance/
https://github.com/crosswalk-project/crosswalk-website/wiki/Crosswalk-Project-Lite
},
{
We can enable it per view by placing following attribute on an ion-content tag
overflow-scroll=”true”
Or we can enable it for all views
$ionicConfigProvider.scrolling.jsScrolling(false);

If you’re already using collection-repeat, you might want to consider replacing it with a normal ng-repeat. I’ve experienced some stutter when using collection-repeat in combination with native scroll.
},
{
Angular TemplateCache
},
{
Using the Ionic lifecycle events
You might have experienced some lag or stutter when transitioning to another page. We can get rid of this lag by wrapping the data we want loaded in an Ionic lifecycle event.

Let’s say we want to load some appointments, we can wrap this service call inside the beforeEnter event

$scope.$on(‘$ionicView.beforeEnter’, function() {
appointmentsService.getAllAppointments();
}
This event will trigger when we’re about to enter the view, resulting in almost no lag in the transition animation.
},
{
AVOID PIXELS
}



http://tombuyse.com/improving-the-performance-of-your-ionic-application/
http://www.gajotres.net/speed-up-your-ionic-application-using-these-techniques/2/

###9.1 Bindings
Try and minimize your bindings. As of Angular 1.3, there is a new bind once and forget syntax in the shape of {{::scopeValue}}. This will interpolate from scope once without adding a watcher to the watchers array.
###9.2 $digest() and $apply()
scope.$apply is a powerful tool that allows you to introduce values from outside Angular into your application. It is fired under the hood by angular on all of its events (ng-click, etc). The problem arises in the fact that scope.$apply starts at $rootScope and walks the entire scope chain causing every scope to fire every watcher.
scope.$digest on the other hand starts at the specific scope calling it, and only walks down from there. The performance benefit should be fairly self evident. The trade off, of course, is that any parent scopes will not receieve this update until the next digest cycle.
###9.3 $watch()
scope.$watch() has now been discussed on several occasions. In general, scope.$watch is indicative of bad architecture. There are very few cases when some combination of services and reference bindings can not achieve the same results with lower overhead. If you must create a watcher, always remember to unbind it at the first available opportunity. You can unbind a watcher by calling the unbinding function returned by $watch.
var unbinder = scope.$watch('scopeValueToBeWatcher', function(newVal, oldVal){});
unbinder(); //this line removes the watch from $$watchers.
If you can not unbind earlier then that, remember to unbind in your $on('$destroy')
###9.4 $on, $broadcast , and $emit
Like $watch, these are slow as events (potentially) have to walk your entire scope hierarchy. On top of this, being glorified GOTO, they can make your application a convoluted mess to debug. Luckily, like with $watch, they can be unbound with the returned function if absolutely necessary (remember to unbind your $on('$destroy') in your $on('$destroy') and can almost always be avoided outright with judicious use of services and scope inheritance.
###9.5 $destroy
As outlined above, you should always explicitly call your $on('$destroy'), unbind all your watchers and event listeners, and cancel any instances of $timeout, or other asynchronous ongoing interactions. This is not only good practice to ensure safety, and flag your scope for garbage collection more rapidly. Not doing so will keep them running in the background, wasting your CPU and RAM.
It is especially important to remember to unbind any DOM event listeners defined on a directives element in the $destroy call. Failing to do so will cause memory leaks in older browser, and slow down your Garbage Collector in modern browsers. A very important corollary is that you need to remember to call scope.$destroy before you remove the DOM.

https://www.airpair.com/angularjs/posts/angularjs-performance-large-applications
http://www.gajotres.net/handling-native-view-animations-with-ionic-framework/
http://www.thomasmaximini.com/2015/01/12/improving-scroll-performance-for-lists-in-ionic-framework.html
http://julienrenaux.fr/2015/08/24/ultimate-angularjs-and-ionic-performance-cheat-sheet/
http://scottbolinger.com/4-ways-to-make-your-ionic-app-feel-native/
https://github.com/Telerik-Verified-Plugins/NativePageTransitions
https://github.com/shprink/ionic-native-transitions