JavaScript for Line of Business Applications

We will develop a client application that will run on web browsers, so we need to decide what tools and/or frameworks we will use.

For the base stack we don't really have much of a choice: The layout will be done in HTML, styling will be done in CSS and scripting in Javascript. No surprises here. While there are other choices, these guarantee that most modern browsers will run our application.

But these technologies alone would make for a rough development experience. For example, while Javascript and CSS work in all browsers, implementations differ, many times in subtle or obscure ways. There are three areas in which we would benefit from higher level cross-browser frameworks:

Let's review each and evaluate what options there are.

Miško Hevery – the father of AngularJS – gave a very interesting presentation on AngularJS best practices in December of last year. This presentation is available on YouTube and the actual slides are on Google Docs.

I’m going to cover a few of the points he covered in his presentation and give my take on them.

The goal of this talk is not actually to teach you how to build an application with Ember. It’s to get you into the correct frame of reference. We could go through a todo list, but lets be honest, you don’t care.

I really don’t want to be the guy standing at a desk, building a demo, explaining every line of code. I’d rather share a few stories, why we at Embedly still like it and why you might want to give it a shot.

Read about how we solved displaying data from multiple arrays in the same list using a highly efficient custom class called `Ember.MergedArray`.

One thing that can be confusing when starting out Ember is the different way that scopes are resolved between template code and in javascript code. For example in a template you might have {{#if controllers.user.isLoggedIn}}, but in order to access the same property in a route, you need to have this.controllerFor('user').isLoggedIn (use of controllerFor in a controller is deprecated, but the point remains). This post is about how I inject handlebars into views for the sake of displaying alert messages.

The truth is more complex and ties into why we created Ember.js Persistence Foundation.

One way to shed light onto the situation is to give a simple enumeration of things that EmberData lacks and EPF provides. Having used ED for several years on a large project, these are things that, in our case, are major issues, but are perhaps surmountable for others. These are also issues that, based on my understanding of how ED is structured, are going to be fairly non-trivial to properly implement.

1. Create a Parent-Child Hierarchy
2. Know When a Transaction Completes
3. Change Models While Being Saved
4. Modify a Model in Isolation
5. Properly Handle Embedded Records
6. Deal With Errors
7. Handle "Conflicts"
8. Custom Actions
9. Load Data in the Background
10. Think in Terms of the Container

JavaScript has many great style guides. Thus, there is no need to write yet another one. Instead, this blog post describes commonly accepted meta style rules and conventions that I like that are controversial. The idea is to help you make a more informed decision about what is right for you.

* Existing style guides
* General tips
* Commonly accepted best practices
* Controversial rules

Whenever you are considering a style question, ask yourself: what makes my code easier to understand? Resist the temptation to be clever and leave most of the mechanical cleverness to JavaScript engines and minifiers.

Understanding the proper use of the Router in an Ember.js app is a fundamental core concept of the framework. The docs tell us that the router translates a URL into a series of nested templates and almost all available tutorials show how to nest routes as part of an explanation of how the Router works. This is great when you want a UI where a list of items are present at the same time a single item is shown. This leaves many beginners struggling, however, as they try and replace the entire contents of a page with another route’s template. Today we’ll explore two ways to tackle this problem.

In practice, everything is based off the router and templates. Ember handles the dynamic creation of views and controllers. You really don’t need them until you start dealing with data and events.

By default Ember sets up two routes for you: application and index.application is the container for your entire application while index is the route for the root of your site ‘/’. You can create the two templates for these routes in the templates directory.

In this video tutorial series, we look at how to build a client-side HTML5 application with jQuery and KnockoutJS. We'll look at binding DOM elements to a data model, defining event handlers, and pulling data from JSON and REST services.

parse-angular-demo - An opinionated, battle-tested boilerplate for building large, powerful, serverless apps with AngularJS, Backbone and Parse

The awesome thing about the Parse Javascript SDK is that it's a fork of Backbone, so we can make use of the kickass Model and Collection architecture, but still use AngularJS for all UI events and views (this is where Backbone loses out to other frameworks).

Let's implement a simple infinite scrolling pattern using Ember. 
First, we will start with a basic scaffolding app. Let's load some fake models in the index route.

We'll make sure our index controller is an array controller, since it will be showing a list of items (those returned from the route's `model` hook). 

We now have enough scaffolding to write up some simple templates to display this information. We'll create an 'application' template with an outlet, and an 'index' template that shows each object in the index controller's content.

Before we add the ability to automatically pull in content when the user scrolls, we'll add in a link the user can click to load more widgets manually. When that is working we'll figure out how to automatically trigger that code when the user scrolls to the bottom.