JavaScript – Mike Barlow (BarDev)

Super Simple systemJS Module Loader Tutorial

I’m currently in the process of building a new web application. I want to use a module loader. I have used Required as a AMD loader, but with ES2015 (ES6) around the corner and supports module loading, I would like to use something that is somewhat future proof. So, I’ve decided to investigate SystemJS.

To learn SystemJS , I wanted to create a very simple application with no frills and uses ES5. Once I have this figured out, I will start using ES6 and/or TypeScript.

SystemJS

SystemJS is a universal module loader. It can load modules synchronously or asynchronously. In this post I’m going to load a very simple global module dynamically. SystemJS can load these additional modual formats:

esm: ECMAScript Module (previously referred to as es6)
cjs: CommonJS
amd: Asynchronous Module Definition
global: Global shim module format
register: System.register or System.registerDynamic compatibility module format

Assumption of Reader

I assume the reader has the following knowledge

Some knowledge node.js and npm
JavaScript
Chrome Developer Tools

I assume that since you want to learn about systemJS, which is a more advanced tool, that you understand NPM and how to install
libraries using package.json. I also assume you know how to create a server to run the examples on. In this example, I’m using HTTP-Server that I installed using NPM.

Tools and Version I used

Here’s the structure of the application

package.json: is used to install systemJS
.gitmore: can be ignored. It’s used with Git source code repository.
node_modules: where npm installs systemJS
main.js: the module to be dynamically loaded and execute by systemjs

All source code can be found here:

Example without using systemJS: https://github.com/BarDev/Learning-SystemJS/tree/b.1.0

Example using systemJS:https://github.com/BarDev/Learning-SystemJS/tree/b.1.1

First run “npm install”. This will look in package.json and find dependencies to install. The only client dependency that is required is systemjs.

Let’s now display a very simple HTML page. Here’s the code:

Let’s do a a sanity check to validate that the server is working. You can use any server. I have decided to use http-server for it’s simplicity and no bloat. Below in the images, you will notice I install http-server globally, and then ran it by just call “http-server”. I then load the page using the port that http-server provided.

Everything should be working now.

Let’s create a module. I’m using the term module somewhat loosely here. Since the code is in a separate file, systemJS will treat it like a module. Here I’m using the Revealing Module Pattern.

Let’s create a new folder called app and add the file main.js. Here’s the code to include in main.js.

We aren’t using systemJS and not doing module loading yet, but we will soon. For the time being, let’s see how main.js is loaded.

Add a reference in index.html to main.js. This can be added in the <head> element. Then add the script that calls the domUpdater after the last div. The script must be after the div, because of how the HTML page loads and is executed.

Lets run the web page and see how the modules are loaded. In the image below you will see that in Chrome Developer Tools, I added a breakpoint in the index.html. This allows me to see what files have been loaded in the network tab. As we can see the main.js file has been loaded. The main.js file is loaded as soon as the page is loaded. Imagine if you had 20 files that need to be loaded. Bundling can take care of this somewhat; but what if you had multiple bundles and not all bundles are needed when the page loads?

Now let’s do some module loading using systemJS.

In index.html, remove the script in the Head that is referencing main.js. Also remove the script after the div that is calling domUpdated

Now we need to add the systemJS library and load mainJS using SystemJS.

In index.html, reference the system.js file in the <head>.

Now, refresh the page and put a breakpoint on the console.debug, and refresh again. If you look at the Network tab in Chrome Developer Tools, you will see that main.js has not been loaded yet.

Continue the application and you will see in the network tab that main.js is loaded dynamically in the process..

Resources

Duck Typing

In this post I will describe Duck Typing in regards to dynamic languages (JavaScript, PHP, Python, Ruby).

If you ever read or heard about Duck Typing, you have probably seen the following quote:

If it walks like a duck and quacks like a duck, it must be a duck.

Without context, this quote doesn’t mean much. Hopefully at the end of this post the previous quote will make much more sense.

Below is an excerpt from Wikipedia. Without understanding Duck Typing, the following excerpt doesn’t make much sense either.

Duck Typing requires that type checking is deferred to runtime, and is implemented by means of dynamic typing or reflection.

Duck typing is concerned with establishing the suitability of an object for some purpose. With normal typing, suitability is assumed to be determined by an object’s type only. In duck typing, an object’s suitability is determined by the presence of certain methods and properties (with appropriate meaning), rather than the actual type of the object.

https://en.wikipedia.org/wiki/Duck_typing

Duck Typing in JavaScript – Dynamic Language

In the following examples, we are going to create following 3 different objects in JavaScript

point2D
point3D
me

All three objects will include properties: name, x and y, they also include a calculate() function. The Me object will include the properties occupation and birthDate. See image below for a visualization for object model.

In the code below, I created the three object (point2D, point3d, me). I also created a function called calculate() for each object. The calculate() function for all the objects returns a string.

There is a displayPoint() function defined. This function could just have been called display(). The function displayPoint() has one parameter called “point”. The function signature looks like this:

function displayPoint(point)

The parameter name “point” doesn’t mean anything. I could have called it “obj”. I called the function “displayPoint” and the parameter “point” because contextually the function is created to work with points. Even though I created the function displayPoint(point) to work with points, but I can pass any type of object as a parameter in to the function.

In function displayPoint(point) the code accesses the property “name” and the method “calculate()” of the object “point”. It doesn’t matter what type of object is passed in to the function “displayPoint”, but the object must have the property “name” and the method “calculate()” to run without an error.

This is Duck Typing.

What is the “me” object? Is it a person or a point – both, neither? What do the properties x and y represents. The properties x and y could represent a point, but they could also be pointers (reference) to XY chromosomes. But in this context of the method “displayPoint”, the object “me”, and the properties x and y are points and treated like points.

Now, the following quote has context. I hope it makes more sense now.

If it walks like a duck and quacks like a duck, it must be a duck.

Resources

How Duck Typing Benefits C# Developers – Phil Haack
Wikipedia – Duck Typing
Why TypeScript – See Section: Types are Structural

Visual Studio Code, AngularJs, & Intellisense

My primary goal is to get VSCode intellisense to work with AngularJs.

I’m working on a new application and I’m developing it with AngularJS (Angular 1). I’m also using VSCode (Visual Studio Code) as the IDE. My understanding is that VSCode should provide intellisense for JavaScript code, which it does. In the following image, you can see that VSCode provides intellisense for the variable “d”. VSCode is smart enough to see that this is a string and displays a list of string functions to select from.

Since I’m developing with AngularJS, I would like to have intellisense here also. In the index.html page, I have reference to my AngularJs library, but in my JavaScript file intellisense is not working as expected.

To get intellisense working for AngularJS in VSCode. The following steps need to occur

Install node.js typings package globally
Run typings and install AngularJS types
Create a jsconfig.json file

Assumptions of reader

Have knowledge of node.js and npm

Tools and version

node.js 6.2.1
npm 3.9.5
Visual Studio Code 1.2
Windows

1. The Situation

I’m creating an AngularJS application. I have two files index.html and module.js. The index.html file references angular.js library and module.js. The module.js file is where the JavaScript and Angular 1.5 component will live.

By default, VSCode provides intellisense for JavaScript. In the following image you will notice that the variable “d” is a string and that VSCode provides intellisense based on the context of “d” being a string.

In module.js, when I enter “angular.” I expect that intellisense to display a list of AngularJS methods and properties, but as you can see in the image below, this does not occur. My goal in this blog post is to have intellisense display AngularJS methods and properties.

2. Install typings package

The typings package needs to be installed. Since this package will be used for this solution and others. I want to install it globally. First lets’ see what packages are installed currently on the computer.

To figure out what packages are installed globally, run the following command.

npm list -g –depth=0

This command will return all packages at a root depth and not include any children or dependencies of the base packages.

As we can see the typings package has not been install. Let’s install it globally.

npm install -g typings

Now that we installed typings it should now be available to use. Notice the version of typing is 1.3.0.

3. Install AngularJS types

When I initially attempted to install angular typings, I received the following error (see image). This worked just a few days ago. But I install typings 1.3.0. and my typing install didn’t use the same format as pre typings 1.0 used. You can read more about that here Updating Typings From 0.x to 1.0?

To install angular typings, I had to enter the following command:

typings install dt~angular –save –global

When the angular typing is installed the typings.json file and a folder called typings should be created. See image below for more information .

4. Create a jsconfig.json file

Now create an empty jsconfig.json file.

If we were using TypeScript and transpiling code, then this file would contain configuration. But since we are only need intellisense to work, this file can remain empty

5. Validate if Intellisense is working for Angular

Go back to the module.js file. Enter “angular.”. The intellisense should now display AngularJS methods and properties.

Resources

Kick-Start: Bower – A Simple Tutorial of Setting-Up and Using Bower.JS

The goal of this post is to provide a simple description of how to install Bower JS and how to use Bower JS to manage client side dependencies. The first time I tried to use Bower I had problems. Hopefully this tutorial will provide others a complete resource to navigate around the issues that I found.

Assumptions:

You are a Windows developer
You will use the Windows Command Prompt instead of Bash
You have little or no knowledge of Node.js
You have little or no knowledge of GIT

1. Download and install Node.js

To run Bower you will need to download and install Node.js. Go to http://nodejs.org/ website and select the “install” button (see image below). This should download the version of Node.js you need. For me, when I clicked the “install” the version for Windows 64-bit downloaded. Once Node.js is download, execute the file.

I will not go thought the steps for installing Node.js; it’s very straight forward. During the install I used all default options.

Continue reading “Kick-Start: Bower – A Simple Tutorial of Setting-Up and Using Bower.JS”

Understanding AngularJS – Simple Example

I did a similar post as this post for Backbone.js Understanding Backbone.js – Simple Example. Based on readers’ comments the backbone.js post seemed to assist many people. My goal with this post is to help others understand the core parts of AngularJS and how they work together.

The AngularJS application that we are building will display a list of movies and will have the ability to add movies. We could create this application with very minimum code, but extensibility and maintainability will be limited. My primary objective is to show how to structure an AngularJS application that provides a base of knowledge to create other AngularJS applications extensible and maintainable.

My target audience will have some knowledge about AngularJS, but are having a difficult time implementing all but the most basic applications. By simple, I mean you should only have to focus on AngularJS. We will not be using jQuery, Twitter Bootstrap, or other 3^rd party libraries.

We could create this application with just a controller and a view. But in this post I will describe the following core AngularJS features:

Routes
Modules
Views
Controllers
Services

Above I mentioned I will keep this post simple, but we do need a web server. The AngularJS Theater application will load views and data (json files) from the server. I would like to do these examples by access “file:///E:/TempProjects/Theater/index.html#/” on local computer, but most browsers cannot access these files on local computer do to Cross Origin issues. Here a StackOverflow question and answer that describes this issue: Cross origin requests are only supported for HTTP but it’s not cross-domain. So we need a web server. Any web server will do, such as IIS, Node.js and Express or other server. In this example I will be using Node.js and Express. You will not need to know anything about Node.js; all that is need is for you to install Node.js and to execute a script that I will provide. I will step you through the complete process to get Node.js and Express up and running.

Google Chome will be the browser I use, but any current browser should work fine. The reason I pick Chome is for its development tools. I will be developing in JetBrains WebStorm IDE, but any IDE or text editor should be fine.

This post will be based on a contrived idea of displaying a list of movies at a theater. There is nothing fancy here.

The complete solution can be downloaded from here:
Source – Understand-AngularJS-Simple Example(Theater)

Based on comments from Hasan this example works with AngularJS 1.1.5. It does not work with AngularJS 1.2.3.

Continue reading “Understanding AngularJS – Simple Example”

How I Navigated to AngularJS

This article is about the process I’ve gone through of selecting AngularjS as my MV* JavaScript framework of choice. I will discuss the evolution I went through from learning jQuery, Knockout, Backbone.js, and eventually settling on AngularJS.

I’ve been programming in JavaScript since the late 90′s. JavaScript is not going anywhere. JavaScript is very popular today, and I believe it will only get more popular. For programming a browser, JavaScript is the least common denominator. This is the only language that all Browsers support. But, JavaScript has many pitfalls; just read the book JavaScript: The Good Parts by Douglas Crockford. In the early years, I used JavaScript mostly for validation and simple DOM manipulation. Writing different code for each browser sucked. Back in the early years JavaScript seemed like a toy, there weren’t many best practices and the expectations of what could be accomplished with JavaScript was limited.
Continue reading “How I Navigated to AngularJS”

Setting-up AngularJS, Angular Seed, Node.js and Karma

I’ve used AngularJS for a few months, but I have no knowledge when it comes to testing AngularJS apps. I have a subscription to PluralSight.com and wanted to go through their online video training course for AngularJS. Specifically with this course I want to learn how to use Karma to do testing.

I’m usually extremely happy with PluralSight.com course, but in the beginning of this course I was somewhat disappointed. In Section 7 (“Angular Seed”) new technologies were introduced. The author introduced Angular-Seed, Node.js and Karma. I’ve worked with Node.js, but there are probably many people who have never used it. I believe the author took for granted that the student knew Node.js. For those who have never used Node.js this could be an obstacle.

When I started the course I didn’t have Node.js installed. I installed Node.js and things didn’t work as intended. I couldn’t run tests in Node.js because Karma was not installed. Once I installed Karma, Chrome wouldn’t launch in the tests.

With all the issues I was having, I wondered if others were having the same problems. If others were having similar issues, were they discouraged and not continuing with the course. So I decided to create this blog post to help others to get stared with AngularJS, Angular-Seed, Node.js and Karma.

Here are my assumptions:

You are a windows developer
Google Chrome browser is installed
You will use the Windows Command Prompt instead of Bash
You have little or no knowledge of Node.js
You have little or no knowledge of Karma
You will use Node.js as the web server. I will step you through this.
You have access to and IDE. Visual Studio will be fine. NotePad++ would also probably work. I use JetBrains WebStorm. JetBrains has a free 30 day trial for WebStorm.

Here are the high level step we will follow:

Download and install Angular-Seed
Download and install JetBrains WebStorm (Optional)
Download and install Node.js
Confirm Node.js is installed
Run Karma Unit Tests – will fail because Karma is not installed
Install Karma
Run Karma Unit Tests again – Will fail because Chrome will not start
Add System Variable to Windows
Confirm System Variable Were Added
Run Unit Tests again – should succeed
Confirm that Units are being tracked by Karma
Start Web Server by using Node.js

Continue reading “Setting-up AngularJS, Angular Seed, Node.js and Karma”

Re-Learning Backbone.js – Require.js (AMD and Shim)

In this post we are going to learn how to use Require.js with Backbone.js and Underscore.js

This post build on the Re-Learning Backbone.js series.

As usual, the examples in this tutorial are extremely simple. We have one goal here and that is to load Underscore.js and Backbone.js using Require.js

We are going to start out with an example that doesn’t function correctly. Don’t worry, I believe it’s important to show you the evolution of creating an application from the very beginning to a working version. We will take very small steps to get where we need to go.

Here are the libraries and their version that we will use in this post:

jQuery – version: 1.8.3
RequireJS – version: 2.1.2
Backbone.js – version: 0.9.9
Underscore.js – version 1.4.3

Here’s the source code for the example below: Source

Getting Started

To get started we need a structure for our website such as this:

We also need the following libraries jQuery, Backbone.js, Underscore.js and Require.js. These libraries should be stored in the “libs” directory.

First create two files. The first file will be called Require1.html and this file will be in the root directory. Add the following code to the file.

Here’s the code for Require1.html

<html >
<head>
    <title></title>
</head>
<body>
    <script data-main="scripts/main1" src="scripts/libs/require.js"></script>
</body>
</html>

All the HTML file does is tell RequireJS to execute the main.js file in the script directory.

The second file will be called main1.js and this file will be in the “scripts” directory. Add the following code to the file.

requirejs.config({
    urlArgs: "bust=" + (new Date()).getTime(),  //Remove for prod
    paths: {
        "jquery": "libs/jquery-1.8.3",
        "underscore": "libs/underscore",
        "backbone": "libs/backbone"
    },
});

require(["jquery", "underscore", "backbone"],
    function ($, _, Backbone) {
        console.log("Test output");
        console.log("$: " + typeof $);
        console.log("_: " + typeof _);
        console.log("Backbone: " + typeof Backbone);
    }
);

The main1.js file has two parts, the config method and the require method. The config method is used to setup RequireJs. The config is not mandatory, but it does simplify the code. In the config we included only the “paths” option, but there are many other options available. To see a list of options go to RequireJs Config Options. In the paths option we identify the modules that will be needed. Each module file is in the “scripts/libs” directory. You will notice that each JavaScript file that is referenced does not include the “.js” extension. RequireJS assumes that all files are scripts and the “.js” is not needed. The order of the values in the config paths is not important; the files can be in any order. If we wanted we could have put backbone first.
Continue reading “Re-Learning Backbone.js – Require.js (AMD and Shim)”

Browser Script Loading

In this post I will discuss how scripts are loaded and executed by the browser.

It’s common to have scripts loaded by the browser by using the script tag (<script>) with a src (source) attribute. In the old days, the early versions of IE, FireFox, and Chrome, the script tags would load and execute synchronously. Today newer browsers support the ability to download scripts in parallel. The scripts are still executed in order they are declared.

Here’s a list of browser support for asynchronous downloading of scripts:

The previous image is from BrowserScope: http://www.browserscope.org/?category=network&v=2&ua=Chrome%204,Firefox%203.0,Firefox%203.5,Firefox%203.6,IE%206,IE%208,Opera%2010.10,Safari%203.2,Safari%204.0

In the following example we will load 6 scripts (note the script at the bottom). The order of the scripts does matter. Since backbone.js depends on underscore.js, underscore.js will be declared before backbone.js. Here’s the code that will be used to help us understand script loading.
Continue reading “Browser Script Loading”

Re-Learning Backbone.js – Multiple Views

In this post we will learn about how a view can monitor changes or events in other views. A common scenario is to display a list of items. When the user clicks an item from the list, the details of the item is displayed in a different view on the same page. The user can then edit and save the details back to the list.

In this example we will have a list of movies. When the user selects a movie from the list, the data for the movie will be populated in text boxes, which is in a different view. Once the user changes the data and clicks “Change Record” button the changes will be updated back to the list.

The fundamental concept to understand is that the child movie view is not aware of the detail movie view. Neither one of the views are aware of the other. This is important because it decouples the views; it allows us to remove or exchange views without modifying other views.

In a previous post Re-Learning Backbone.js – Events (Pub-Sub) we learned about PubSub in isolation. In this post we will use PubSub to notify the triggering of events when a change occurs in a view.
Continue reading “Re-Learning Backbone.js – Multiple Views”