JavaScript for Line of Business Applications

Mistakes:

Do any of the following sound familiar?

* It’s hard to debug your view, because you have no idea where that Scope member is coming from
* When you inspect a Scope, you double-take because you thought it was the window object
* You at some point needed to access a child Scope member from a parent Scope, so you either either a) used $broadcast/$on to call it, or b) just moved the member into the parent Scope
* It’s unclear what is happening after any given user action, because there are umpteen-hundred events being emitted or broadcast
* There’s at least one service that is 1,000 lines long and is full of just random settings
* You either have one entry point into $http, or $http calls are scattered about controllers

These are all mistakes, and they are easy mistakes to make. The solution to all of these problems is the same: refactor.

Lightweight Mozilla X-Tag add-on which allows to use React.js components as custom HTML elements.

We built our API and our JavaScript application as two completely separate applications. We had one repo that held a very basic Rails application with Ember on top and another repo that held the API built in Rails.

There are a lot of front end development tools that will allow you to build an EmberJS application using CoffeeScript, Sass and the other tools that we like to use on projects. After evaluating them we settled on using a basic Rails application instead; primarily for simplicity. The project had a short timeline and we didn't want to have to worry about another tool that we were not familiar with. In the future I would love to try building an Ember UI using a front end tool such as Tapas with Ember but we didn't have any complaints with using Rails in this case and it made our stack a bit simpler to use.

For Ember in our Rails app we used the ember-rails gem. It provides a basic folder structure for your Ember application inside the app/assets/javascripts directory. The directory structure is similar to a Rails application as you can see below...

Test driven development is now widely accepted as a JavaScript workflow, and it’s something we should all embrace because it saves us a great deal of time when coding.

In this article I’ll introduce you to QUnit, a testing framework that will help you spot errors and bugs in your code.

At first, this process may seem complex and tedious. Creating a test for all of your functions does take some time, but it will save you hours of debugging at the end of the project cycle.

Not only that, but you’ll save yourself the blushes we all get when a client emails us about a bug they’ve found.

As a further benefit, you’ll find that this workflow also benefits cross-browser testing, and using this approach you can test in several browsers straight out of the box.

Knockout 3.0 introduces a number of improvements in the binding pipeline, including a number of extension points for pre-processing binding values. For those just starting out and even those more experienced with MVVM, debugging bindings is still a key part of the development process. In this post I’ll run through some well known techniques for debugging bindings and touch on some changes that will impact debugging.

One of the great features of DozerJS is that it is extremely simple to work with, even for those new to NodeJS development.

In this post I'm going to walk through creating a basic Todo-List application to demonstrate basic usage and I/O.

1. Install the NPM
2. Start a New Project
3. Generate Modules
4. Build A Model
5. Inspect the API
6. Setup The Controller
7. The Public UI

I have been working in a prototype using the Twitter Streaming API with Socket.io and ReactJS for the frontend, Node.js in the backend, cool stuff!

I used several articles as a reference, the one using the streaming API using socket.io(but AngularJS and ntwitter npm package), real-time django using node.js and socket.io or a modern python stack for a real time web application.

In the end as I said I used nodejs, the twit package and socket.io in the backend. With all these tools was incredibly easy to have something running fast.

And these are the different parts composing the example, the installation of the different tools is beyond the scope of this article just because I want to focus more in functionality and I don't want the article to be very long.

Anyway if you have a question/criticism here I am. :-)

By running grunt locales:build you can get a set of JavaScript locale files that can be used to help translate content.

The basic angular-localize directive is used by adding the localize attribute to a tag. The text in the element will be used as the translation key, but you can uselocalize="key" to specify the key instead, which is useful if the final content hasn’t yet been copy edited.

The localize directive also observes data-* attributes and passes them as objects to translation functions, so data can be inserted into text dynamically.

There’s also a localize service for translating text in your JavaScript code, and there’s even a localizeFactory for creating your own attribute-based localize directives.