JavaScript for Line of Business Applications

Welcome to the resource page for my talk on Scalable JavaScript Design Patterns last presented at Web Directions (South). It's an extended version of the talk I gave at Fronteers and includes more information about a highly-decoupled architecture for building large applications I've been discussing recently. This version of the talk also covered live code demos of 'Aura', a framework based on some of the ideas in the presentation (see lower down for some code examples). Many of the concepts presented build upon previous work by Nicholas Zakas.

In this talk, I describe a JavaScript application architecture that:

* Is highly decoupled, encouraging modules to only publish and subscribe to events of interest rather than directly communicating with each other
* Supports your application continuing to function even if particular modules fail
* Supports improved module management, where a central body is able to manage when modules start, stop or need to be restarted
* Supports module-level security, whereby modules are only able to execute behaviour they've been permitted to
* Supports optional framework agnosisty - this is an opt-in component of the architecture whereby an abstracted API layer is created around specific JavaScript frameworks and toolkits allowing you to easily swap one for another without the need to rewrite any of your code (eg. you can switch your modules from using jQuery to Dojo in just one line).

Recently I was working with a client to train their internal teams on how to build web applications. During this process it occurred to me that the way we presently architect the front-end is very strange and even a bit broken. In many instances you’re either copying huge chunks of HTML out of some doc and then pasting that into your app (Bootstrap, Foundation, etc.), or you’re sprinkling the page with jQuery plugins which have to be configured using JavaScript . It puts us in the rather unfortunate position of having to choose between bloated HTML or mysterious HTML, and often we choose both.

In an ideal scenario, the HTML language would be expressive enough to create complex UI widgets and also extensible so that we, the developers, could fill in any gaps with our own tags. Today, this is finally possible through a new set of standards called Web Components.

* Building your First App (basic concepts)

One of the biggest benefits to building a single page app (SPA) is the ability to host flat files, rather than needing to build and service a back-end infrastructure.

However, most of the applications that we will build need to be powered by a back-end server with custom data. There are a growing number of options to enable us developers to focus on building only our front-end code and leave the back-ends alone.

Amazon released a new option for us late last week to allow us to build server-less web applications from right inside the browser: Amazon AWS Javascript SDK.

Their browser-based (and server-side with NodeJS) SDK allows us to confidently host our applications and interact with production-grade back-end services.

Now, it’s possible to host our application stack entirely on Amazon infrastructure, using S3 to host our application and files, DynamoDB as a NoSQL store, and other web-scale services. We can even securely accept payments from the client side and get all the benefits of the Amazon CDN.

With this release, the Javascript SDK now allows us to interact with 5 of the dozens of Amazon AWS services. These five services are:

* DynamoDB
* Simple Notification Service (SNS)
* Simple Queue Service (SQS)
* Simple Storage Service (S3)
* Security Token Service (STS)

First, let’s decide the nature of the app we want to build. In this guide, we’d prefer not to spend too much time on the back-end, so we’ll write something based on data that’s easily attainable on the Internet—like a sports feed app!

Since I happen to be a huge fan of motor racing and Formula 1, I’ll use an autosport API service to act as our back-end. Luckily, the guys at Ergast are kind enough to provide a free motorsport API that will be perfect for us.

For a sneak peak at what we’re going to build, take a look at the live demo. To prettify the demo and show off some Angular templating, I applied the awesome Plastic Admin Bootstrap theme; but seeing as this article isn’t about CSS, I’ll just abstract it away from the examples and leave it out.

With the release of Ember.js 1.0, it’s just about time to consider giving it a try. This article aims to introduce Ember.js to newcomers who want to learn about this framework.

First, we will clarify the main concepts of the framework. Next, we’ll go in depth with a step-by-step tutorial that teaches you how to build a simple Web app with Ember.js and Ember-Data, which is Ember’s data storage layer. Then, we will see how views and components help with handling user interactions. Finally, we will dig a little more into Ember-Data and template precompiling.

Since I’ve been working with the GitHub API lately as well as AngularJS I decided to refactor his code using AngularJS instead of jQuery. I tried to make minimal changes from Jake’s example to make comparison easy.

The results show the power of AngularJS’ data binding and separation of logic and view.  There was no need to manipulate the DOM in Javascript or output HTML from Javascript.

It’s a simple, but very nice example, so the refactor wasn’t very difficult. Removing jQuery and using AngularJS, the initial form, getting the user data and displaying it which is two calls to the GitHub API. One to get the user information and another to get a list of that users repositories.

Twitter Bootstrap happens to be the easiest and the best CSS framework on the Internet today. It allows developers with no CSS knowledge to build basic templates without any efforts. But this doesn’t stop designers from using Bootstrap.

This article is a review of the JavaScript ES3 parts that, for whatever reason, fade over time in my mind or I outright forget about. Some of the parts mentioned are quirks and some are just plain language realities that I personally find difficult to keep straight.

The eluding parts I discuss here are not focused on method nuances that can be resolved by referring to a JavaScript reference. I have tried to mainly focus on the parts of JavaScript that cannot easily be found in a language reference (i.e the difference between apply()and call()).

Additionally, before I begin, I need to clarify the following three points about what I am NOT suggesting by writing this article:...

Browser cache isn’t enough
You might ask, “isn’t this what the cache is for?” Yes! In many cases when you visit a website the browser avoids making costly HTTP requests and just reads the necessary resources from disk cache. But there are many situations when the cache offers no help:

* first visit – The cache only comes into play on subsequent visits to a site. The first time you visit a site it hasn’t had time to cache any resources.
* cleared – The cache gets cleared more than you think. In addition to occasional clearing by the user, the cache can also be cleared by anti-virus software and browser bugs. (19% of Chrome users have their cache cleared at least once a week due to a bug.)
* purged – Since the cache is shared by every website the user visits, it’s possible for one website’s resources to get purged from the cache to make room for another’s.
* expired – 69% of resources don’t have any caching headers or are cacheable for less than one day. If the user revisits these pages and the browser determines the resource is expired, an HTTP request is needed to check for updates. Even if the response indicates the cached resource is still valid, these network delays still make pages load more slowly, especially on mobile.
* revved – Even if the website’s resources are in the cache from a previous visit, the website might have changed and uses different resources.
Something more is needed.

ponyedit allows us to interact with a contentEditable element by following the Obey and Report pattern. It emits events whenever its state changes, and it takes commands that alter this state. This enables us to completely decouple the user interface from the component's functionality. In this article, we'll dig a little deeper into the pattern, analyzing the decisions made in ponyedit, how it came together, its resulting API, and the sample bare bones UI implementation.