working build

dynajoe · dynajoe · commit 041f3a87718d · 2014-03-02T21:44:07.000-06:00
diff --git a/Gemfile b/Gemfile
@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gem 'github-pages'
diff --git a/Gemfile.lock b/Gemfile.lock
@@ -0,0 +1,62 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    RedCloth (4.2.9)
+    blankslate (2.1.2.4)
+    classifier (1.3.4)
+      fast-stemmer (>= 1.0.0)
+    colorator (0.1)
+    commander (4.1.6)
+      highline (~> 1.6.11)
+    fast-stemmer (1.0.2)
+    ffi (1.9.3)
+    github-pages (15)
+      RedCloth (= 4.2.9)
+      jekyll (= 1.4.3)
+      kramdown (= 1.3.1)
+      liquid (= 2.5.5)
+      maruku (= 0.7.0)
+      rdiscount (= 2.1.7)
+      redcarpet (= 2.3.0)
+    highline (1.6.21)
+    jekyll (1.4.3)
+      classifier (~> 1.3)
+      colorator (~> 0.1)
+      commander (~> 4.1.3)
+      liquid (~> 2.5.5)
+      listen (~> 1.3)
+      maruku (~> 0.7.0)
+      pygments.rb (~> 0.5.0)
+      redcarpet (~> 2.3.0)
+      safe_yaml (~> 0.9.7)
+      toml (~> 0.1.0)
+    kramdown (1.3.1)
+    liquid (2.5.5)
+    listen (1.3.1)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+      rb-kqueue (>= 0.2)
+    maruku (0.7.0)
+    parslet (1.5.0)
+      blankslate (~> 2.0)
+    posix-spawn (0.3.8)
+    pygments.rb (0.5.4)
+      posix-spawn (~> 0.3.6)
+      yajl-ruby (~> 1.1.0)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.3)
+      ffi (>= 0.5.0)
+    rb-kqueue (0.2.2)
+      ffi (>= 0.5.0)
+    rdiscount (2.1.7)
+    redcarpet (2.3.0)
+    safe_yaml (0.9.7)
+    toml (0.1.1)
+      parslet (~> 1.5.0)
+    yajl-ruby (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  github-pages
diff --git a/_posts/2014-2-17-javascript-gotchas.md b/_posts/2014-2-17-javascript-gotchas.md
@@ -7,9 +7,9 @@ tags:
 
 # JavaScript gotchas
 
-JavaScript is a language that many developers are familiar with but lack a deep understanding. The language lends itself to new programmers because its simple syntax. Many of the core fundamentals can be avoided provided that the application being built is sufficiently simple. The goal of this lab is to give you a better understanding of some core concepts and things to look for with JavaScript. 
+JavaScript is a language that many developers are familiar with but lack a deep understanding. The language lends itself to new programmers, in part, because of its simple syntax. Many fundamental concepts and features of the language can be overlooked with a simple procedural approach. The goal of this lab is to give you a better understanding of some core concepts and important language features to understand about JavaScript.
 
-## What's ```this```?
+## What is ```this```?
 
 Have a look at this snippet and pay special attention to the use of the keyword ```this```.
 
@@ -31,43 +31,46 @@ var obj = {
 obj.doSomething();
 {% endhighlight %}
 
-Those unfamiliar with how ```this``` is handled may think the call to ```obj.doSomething``` might think the output of running the above snippet is this:
+Those unfamiliar with how ```this``` is handled may think the call to ```obj.doSomething``` would output the following (assuming the snippet above is saved in a file named `this.js`:
 
-```
+{% highlight bash %}
+> node this.js
 Name: bob
 Name: bob
-```
+{% endhighlight %}
+
+This is a very common mistake. What is actually output is this:
 
-What's actually output is this:
 
-```
+{% highlight bash %}
+> node this.js
 Name: bob
 Name: undefined
-```
+{% endhighlight %}
 
-Here's another example and then we'll explain what's going on.
+Here is another example and then we will explain what is going on.
 
 {% highlight javascript %}
 function Adder (a) {
    this.a = a;
 };
- 
+
 Adder.prototype.addAsync = function (b) {
    setTimeout(function () {
       console.log(this.a + b);
    }, 10);
 };
- 
+
 var r = new Adder(5);
 r.addAsync(10);
 
 {% endhighlight %}
 
-This example is supposed to add two numbers together after 10 milliseconds. What's the output of this example? Some may think it would print 15, the result of 5 + 10. The correct answer is ```NaN```. Why? The answer lies in the value of ```this```.
+This example is supposed to add two numbers together after 10 milliseconds. What is the output of this example? Some may think it would print 15, the result of 5 + 10. The correct answer is ```NaN```. Why? The answer lies in the value of ```this```.
 
-If there's anything you'll walk away from after this lab I hope you'll no longer write bugs that involve ```this```.
+If there is anything you will walk away from after this lab I hope you no longer write bugs that involve ```this```.
 
-The value of ```this``` is the object that a function is defined on. Inner functions or function calls that aren't a part of the object will have the default object set to ```this```. The default object in browsers is ```window``` and in Node.js is ```global```. 
+The value of ```this``` is the object that a function is defined on. Inner functions or function calls that are not a part of the object will have the default object set to ```this```. The default object in browsers is ```window``` and in Node.js is ```global```.
 
 {% highlight javascript %}
 var obj = { a: "Example" };
@@ -84,15 +87,15 @@ printer() // => undefined
 obj.p() // => Example
 {% endhighlight %}
 
-Notice how the value of the call to ```printer``` that wasn't attached to an object was ```undefined```. Once we set the property p to the printer function and invoke it you'll see that this now refers to the object defined. When an object is created from a constructor function using the new keyword, a brand new object is set to ```this```. For example:
+Notice how the value of the call to ```printer``` that was not attached to an object was ```undefined```. Once we set the property p to the printer function and invoke it you will see that this now refers to the object defined. When an object is created from a constructor function using the new keyword, a brand new object is set to ```this```. For example:
 
 {% highlight javascript %}
 var ctor = function (a) {
    this.a = a;
 };
 
 ctor.prototype.print = function () {
-   console.log(this.a);   
+   console.log(this.a);
 };
 
 var o1 = new ctor('test1');
@@ -102,7 +105,7 @@ var o2 = new ctor('test2');
 o2.print(); // => test2
 {% endhighlight %}
 
-So, you've seen the default behavior of how JavaScript handles the ```this``` keyword. The value of ```this``` can be controlled in a function call via a few methods available on Function.prototype ```apply```, ```call```, and ```bind```. Each of these methods allow you to modify the value of this when the function is called. The first two options (apply and call) invoke the function immediately, whereas the third (bind) provides a new function with ```this``` bound. The value of ```this``` is the first argument to each of these methods. Here's an example: 
+So, you have seen the default behavior of how JavaScript handles the ```this``` keyword. The value of ```this``` can be controlled in a function call via a few methods available on Function.prototype ```apply```, ```call```, and ```bind```. Each of these methods allow you to modify the value of this when the function is called. The first two options (apply and call) invoke the function immediately, whereas the third (bind) provides a new function with ```this``` bound. The value of ```this``` is the first argument to each of these methods. Here is an example:
 
 {% highlight javascript %}
 var obj = { a: "Example" };
@@ -119,30 +122,30 @@ printer.apply(obj); // => "Example"
 printer.call(obj);  // => "Example"
 {% endhighlight %}
 
-The difference between ```apply``` and ```call``` is that apply allows you to invoke the function with the arguments as an array; ```call`` requires the parameters to be listed explicitly.
+The difference between ```apply``` and ```call``` is that `apply` allows you to invoke the function with the arguments as an array; ```call``` requires the parameters to be listed explicitly.
 
 
 # Var
 
-The keyword ```var``` is used to define variables. Unfortunately, JavaScript does not require the use of this keyword when defining variables. Forgetting to leave off the var keyword can pollute the global object with unnecessary properties. It can also create innocent looking bugs. Have a look at the following example, What's the output?
+The keyword ```var``` is used to define variables. Unfortunately, JavaScript does not require the use of this keyword when defining variables. Forgetting to leave off the var keyword can pollute the global object with unnecessary properties. It can also create innocent looking bugs. Have a look at the following example, What is the output?
 
 {% highlight javascript %}
 function doStuff() {
    for (i = 0; i < 5; i++) {
       console.log(i);
    }
 }
- 
+
 function example() {
    for (i = 0; i < 5; i++) {
       doStuff();
    }
 }
- 
+
 example();
 {% endhighlight %}
 
-At first glance it looks like it would output the numbers 0 to 5 - 5 times. Sadly, it doesn't; instead it outputs the number 0 - 5 just once! What's the problem? It's the fact that this example omits the use of the var keyword. To fix this we must declare the loop control variables within the function. Fixing the above example looks like this (note the use of var):
+At first glance it looks like it would output the numbers 0 to 5 - 5 times. Sadly, it does not; instead it outputs the number 0 - 5 just once! What is the problem? It is the fact that this example omits the use of the var keyword. To fix this we must declare the loop control variables within the function. Fixing the above example looks like this (note the use of var):
 
 {% highlight javascript %}
 function doStuff() {
@@ -151,22 +154,22 @@ function doStuff() {
       console.log(i);
    }
 }
- 
+
 function example() {
    for (var i = 0; i < 5; i++) {
       doStuff();
    }
 }
- 
+
 example();
 {% endhighlight %}
 
-Using JavaScripts strict mode will prevent you from defining properties on the global object. There are other advantages to using strict mode, but this one is my favorite. Strict mode is applied within an execution context instead of over the entire JavaScript VM. To enable strict mode simple include the string ```"use strict";``` at the top of an execution context. Here's an example of using strict mode just for a single function.
+Using JavaScripts strict mode will prevent you from defining properties on the global object. There are other advantages to using strict mode, but this one is my favorite. Strict mode is applied within an execution context instead of over the entire JavaScript VM. To enable strict mode simple include the string ```"use strict";``` at the top of an execution context. Here is an example of using strict mode just for a single function.
 
 {% highlight javascript %}
 var strictFunction = function () {
   "use strict";
-  x = 1; // => Throws error because of strict mode! 
+  x = 1; // => Throws error because of strict mode!
 };
 
 var notSoStrictFunction = function () {
@@ -179,9 +182,9 @@ var notSoStrictFunction = function () {
 
 {% highlight javascript %}
 var input = "10";
- 
-if (input == 10) { 
+
+if (input == 10) {
    console.log(input * 5);
-   console.log(input + 5); 
+   console.log(input + 5);
 }
 {% endhighlight %}
diff --git a/_posts/2014-2-19-deploying.md b/_posts/2014-2-19-deploying.md
@@ -14,47 +14,47 @@ EC2 -> Launch Instance -> Free tier -> Ubuntu Server 13.10 - ami-ace67f9c (64-bi
 
 Locate the public ip address for the virtual machine you just created. You can ssh into it with the following command. Assuming your .pem file is in the same directory as you're running the command.
 
-```
+{% highlight bash %}
 ssh -i node.pem ubuntu@54.213.246.161
-```
+{% endhighlight %}
 
 ## Installing Node
 
 Node has great instructions on how to install from apt-get [here](https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager).  The important part is here:
 
-```
+{% highlight bash %}
 sudo apt-get update
 sudo apt-get install -y python-software-properties python g++ make
 sudo add-apt-repository ppa:chris-lea/node.js
 sudo apt-get update
 sudo apt-get install nodejs
 
 sudo ln -s /usr/bin/node /usr/bin/nodejs
-```
+{% endhighlight %}
 
 This sets up a new aptitude repository where the most recent stable version of node should be available. At the time of this writing the official ubuntu repositories had an out-dated version of node.
 
 Verify your installation
 
-```
+{% highlight bash %}
 node -v
-```
+{% endhighlight %}
 
 # Setting up a node process
 
 Let's start by creating a simple node web application using express. From your home directory:
 
-```
+{% highlight bash %}
 > mkdir node_app
 > cd node_app
 > npm init
-```
+{% endhighlight%}
 
 Run through the prompts to initialize your package.json file.
 
-```
+{% highlight bash %}
 npm install express --save
-```
+{% endhighlight %}
 
 This will install express and update your package.json file.
 
@@ -81,20 +81,21 @@ console.log('Server listening on port ' + app.get('port'));
 
 Let's start the process and run a quick curl request. Notice that the port specified is 3000.
 
-```
+{% highlight bash %}
 node server.js&
 curl -I localhost:3000
-```
+{% endhighlight %}
 
 Now kill the process and let's continue.
 
-```
+{% highlight bash %}
 killall node
-```
+{% endhighlight %}
 
 ## Cluster
 
-We'll start scaling Node using a built in technique. The cluster module that's part of the core node library is an option. In the current version of node (v0.10.*) the cluster module doesn't appropriately route traffic to child processes. Node leaves the routing of incoming connections to the operating system.  Unix based operating systems do a poor job of distributing new connections amongst child processes. Windows is not affected by this issue. In the next stable version of Node the distribution of incoming connections will be handled by node and by default use a round-robin approach. Despite the fact that it's not a great choice to use at this time we're going to cover how it works.
+We'll start scaling Node using a built in technique. The cluster module that's part of the core node library is an option. In the current version of node (v0.10.\*) the cluster module doesn't appropriately route traffic to child processes. Node leaves the routing of incoming connections to the operating system.  Unix based operating systems do a poor job of distributing new connections amongst child processes. Windows is not affected by this issue. In the next stable version of Node the distribution of incoming connections will be handled by node and by default use a round-robin approach. Despite the fact that it's not a great choice to use at this time we're going to cover how it works.
+
 
 ### Master and child
 
@@ -144,57 +145,57 @@ app.set('port', process.env.PORT || 3000);
 
 Now when we launch our process we can set the PORT environment variable. Let's try it by running passing different ports to a few node processes.
 
-```
+{% highlight bash %}
 PORT=4000 node server.js&
 PORT=4001 node server.js&
-```
+{% endhighlight %}
 
 and test them:
 
-```
+{% highlight bash %}
 curl -I localhost:4000
 curl -I localhost:4001
-```
+{% endhighlight %}
 
 and kill them
 
-```
+{% highlight bash %}
 killall node
-```
+{% endhighlight %}
 
 Alright, now we see how we can configure node process to listen on different ports via an environment variable. Let's see how to manage the lifetime several processes.
 
 ## Forever
 
 Forever is an executable that's responsible for keeping a given process alive. If the process crashes, it's the responsibility of forever to start it again. Processes will die. This is a fundamental fact. It's worth mentioning that if a process encounters an unexpected exception it should terminate completely. This is recommended because the state of the process may be unknown. It's usually just as easy to start a brand new process than to deal with one in possibly an invalid state.
 
-```
+{% highlight bash %}
 sudo npm install forever -g
-```
+{% endhighlight %}
 
 Now we can use forever to ensure our node server continues running.
 
-```
+{% highlight bash %}
 PORT=4000 forever start server.js
-```
+{% endhighlight %}
 
 Now, let's find the process id of the newly started process and kill it.
 
-```
+{% highlight bash %}
 ps -ax | grep node
-```
+{% endhighlight %}
 
 You'll see a line like this:
 
-```
+{% highlight bash %}
 7076 ?        Sl     0:00 /usr/bin/nodejs /home/ubuntu/node_app/server.js
-```
+{% endhighlight %}
 
 Let's kill that process.
 
-```
+{% highlight bash %}
 kill -9 7076
-```
+{% endhighlight %}
 
 Re-run the process grep and you should see a new process id assigned to the node process! Great! Now we have a way to keep the process running. The next step handle keeping processes running after a system restart.
 
diff --git a/_posts/2014-2-27-streams.md b/_posts/2014-2-27-streams.md

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+source 'https://rubygems.org'`
	`2`	`+gem 'github-pages'`