JavaScript for Line of Business Applications

In this article I will write about how to implement the Google Maps API version 3 in Meteor JS to achieve reactive Google Maps Marker functionality. When we are done we will be able to add markers reactively to our Google Map app so when MongoDB gets hit with new Geolocation data we see the new markers added automagically.

In this article I will assume you already know how to setup a new Meteor.js project. I use a folder structure that has client, server, collections and lib in the root directory. The clients directory has views, components and a few other folders not needed for the scope of this article. My example app has collections already set up with data that contains latitude and longitude data which will be used to add the Google Maps Markers to the map.

I will say just few words about AngularJS, specifically the module, the controller and the data binding in order to make sense of the given code, before describing Underscore in more detail.

AngularJS is a structural framework for dynamic web apps, is what HTML would have been had it been designed for applications. AngularJS lets you extend HTML vocabulary for your application. AngularJS is a toolset for building the framework most suited to your application development. It is fully extensible and works well with other libraries.

In JavaScript|MDN or in W3Schools you can find the generic methods in order to manipulate your data that you store in an array, an object or in a collection.

Just to remind you the 14 Array Object Methods. But is that all? Is there any way to enrich our utility belt?

UnderscoreJs is a javaScript library that provides a series of functional utilities. It makes working with collections, arrays, objects and functions much easier, compared to the native support found in the javaScript.

Manipulating an array, filtering a collection, applying a function over each item in a collection, extracting the keys or the values from an object  are much easier operations by means of the many more functions that you can just call like _.difference(array, *others)

I have just been learning AngularJS and decided to build demo application that cover more techniques than the tutorial on angularjs.org. This application is only demo so it do not have complete server side, some features have the todos and there is not any test. 

This demo application is some kind of automotive adverts portal, so I called it MotoAds. It has two main features:

* List of adverts – includes an advanced filtering and sorting.

* Add advert – a form with some client side field validations.

AngularJS makes everything else look obsolete. I’m looking at you Backbone and Ember… It is one of those things where in hindsight the approach appears obvious because it is so elegant. However it took the web a good 15 years to arrive at this point. It makes jQuery look like VHS.

AngularJS’s biggest strength is how it automatically binds form data and DOM state in an intuitive spot called $scope. It keeps track of populating everything, firing events, showing/hiding blocks, even looping, sorting and filtering of arrays. It just works.

While learning AngularJS I have often banged my head against the wall when being faced with values defined on my controller scopes that just won’t change along with the things they are representing. This post is about a common error that beginners are prone to make in such a situation, a small dive into the angular $digest loop, a short explanation of assignment of values in javascript and, finally, a way to confidently have values updated in your controllers.

So let’s say you are a mad scientist that is trying to create a living being that will commit acts of cruelty and murder driven by its loneliness and despair. Let’s also say you have set up your whole machinery and what-not, leaving you waiting for a thunderstorm that will provide enough energy through lightning to finally ‘shock’ your creature to life.

Riot.js is a client-side Model-View-Presenter (MVP) framework that weighs less than 1kb. Despite the unbelievable size, all the building blocks are there: a template engine, router, event library and a strict MVP pattern to keep things organized. Your views are automatically updated when the underlying model changes.

Riot.js is faster and simpler — in fact, on a completely different scale — and applications built with it are also faster and simpler. For real.

Let's go deeper...

Up until now, I have only ever defined my AngularJS components (ie, controllers, services, factories, etc.) before AngularJS has bootstrapped my JavaScript application. And, as it turns out, defining components after bootstrapping is somewhat tricky since it appears the given components don't get added to the right dependency-injection container.

The problem is that after your AngularJS application has been bootstrapped, you can only define new components using the relevant "providers". Furthermore, you can only gain access to these providers within the config() callbacks executed during the bootstrapping process. As such, you need to save a reference to these providers if you wish to load subsequent components after your AngularJS application has been bootstrapped.

In the following demo, I'm doing just that. Within the config() callback, I'm actually overwriting the original "shorthand" module methods with the provider-driven equivalents that can be used after bootstrapping. This way, the modules that I define after page-load don't have to use any special syntax - they can define components the same way you would pre-bootstrap.

In my last article I presented a simple tool for discovering senior developers from source code history, which imports Git history into a search engine. This lets you do searches like “who is our Sharepoint expert,” or “who fixed all our Oracle problems.” There are a few code search products that handle similiar problems, e.g. Krugle,Github, and Fisheye, however they tend to be focused on who made specific changes, rather than finding out who ran a project.

Version control history typically shows file changes using text diffs – in theory we could instead reconstruct a file before and after a change, then compare the parse trees instead. This is impractical in the general case, and if you read on I’ll show how to handle this correctly.

These results can be obtained from commit history, which includes metadata for commits (e.g. the author and commit comments), as well as the actual changes.

Single-Page Applications (SPAs) are Web apps that load a single HTML page and dynamically update that page as the user interacts with the app.

SPAs use AJAX and HTML5 to create fluid and responsive Web apps, without constant page reloads. However, this means much of the work happens on the client side, in JavaScript. For the traditional ASP.NET developer, it can be difficult to make the leap. Luckily, there are many open source JavaScript frameworks that make it easier to create SPAs.

In this article, I’ll walk through creating a simple SPA app. Along the way, I’ll introduce some fundamental concepts for building SPAs, including the Model-View-Controller (MVC) and Model-View-ViewModel (MVVM) patterns, data binding and routing.

This is part 2 of a quasi-series on hardening node.js for production systems. The previous articlecovered a process supervisor that creates multiple node.js processes, listening on different ports for load balancing. This article will focus on HTTP: how to lighten the incoming load on node.js processes.

Our stack consists of nginx serving external traffic by proxying to upstream node.js processes running express.js. As I’ll explain, nginx is used for almost everything: gzip encoding, static file serving, HTTP caching, SSL handling, load balancing and spoon feeding clients. The idea is use nginx to prevent unnecessary traffic from hitting our node.js processes. Furthermore, we remove as much overhead as possible for traffic that has to hit node.js.

Contrasting ideas and tools is a great way to understand them better. In this series of articles I will go down the list of the things we have to deal with day to day when building web applications, and show how Backbone and Angular can help with each of them.

Most of the things we do as web developers fall into one of the following categories:
* Implementing business logic
* Constructing the DOM
* Implementing view logic (declarative and imperative)
* Syncing up the model and view
* Managing complex UI interactions
* Managing state and routing
* Creating and wiring up components

Not surprisingly most client-side frameworks address these in one way or another.