
# Scoping Down & Scaling Up

I began my career-change journey into software engineering over 7 years ago. I took a risk and used the remaining moments (moduloMoments) of my days to start studying front-end development at [Udacity](https://www.udacity.com/). Then I decided to go all in and attended [Hack Reactor](https://www.hackreactor.com/) and it paid off. I couldn't be more grateful for the jobs, projects, and co-workers that I've met along the way and where I am now.

## New Focuses

While on this journey, I neglected this blog to the point that it recently went down when it's previous hosting platform was acquired. This prompted me to pick up not where I left off, but where I am now.

In the coming months, I'll be attempting to share lessons I've been learning through articles that cover three main areas:

- Code
- Communication
- Career

At my current company, I'm deep in the weeds in a hybrid role where I get to contribute to a huge codebase, communicate across multiple contexts, and lead people entrusted to my care.

## New Technology

Since this site went down, I also got to do the fun work of upgrades and code migration. Over the past couple of days, I upgraded to the newest versions of [react](https://reactjs.org/) and [next.js](https://nextjs.org/), fixed all the breaking changes, updated the content a bit, found a new deployment host with [Vercel](https://vercel.com/), and converted the site to [Typescript](https://www.typescriptlang.org/).

## New Theme

While it was really fun to update the blog, I'm even more excited about the new sub-heading, "Scoping Down & Scaling Up". I plan to write in more detail on this theme in particular. In my career, I have found it easy to be like an athlete who overtrains. We tend to take on too much, get injured, or burn ourselves out.

Instead of massive scopes, projects, and goals, I have found that focused, scoped-down action has been key to my most successful endeavors. When I isolate small scopes and act on those, this is when I have seen impacts that scale well beyond myself.

I'm excited to have a "new" place to reflect and share, and for those who engage, I hope you come away a little richer or at the very least with better questions.


Scoping Down & Scaling Up


# Reducing reduce: Recursion & ES6

Coding challenges and websites abound and I enjoy tackling new problems, but sometimes it is fun to tweak or improve old toy problems and come up with alternate creative solutions. It is especially cool if you can do so with even less code. One way I like to challenge myself is to solve problems using recursion, not always because it is better, but simply because I like recursion. This can lead to difficulties because some problems are more efficient with a simple 'while' loop, but recursion is still fun. Another common challenge I give myself is using 'reduce' or 'reduceRight' in a solution. The extra level of abstraction is almost always more fun than standard loops.

Recently, a friend told me about a refactoring puzzle that incorporates both of my favorite additional challenges. He was asked to reimplement 'reduce' in JavaScript using recursion! To top it off, he was told to do it in two lines. Well, I was eager to solve this problem and below I'll break it down.

```javascript
var reduce = function (collection, callback, startVal) {
  var initVal = arguments.length > 2;
  collection.forEach(function (element) {
    if (!initVal) {
      startVal = element;
      initVal = true;
    } else {
      startVal = callback(startVal, element);
    }
  });
  return startVal;
  console.log(
    reduce(
      [1, 2, 3, 4, 5],
      function (a, b) {
        return a + b;
      },
      1
    )
  ); // 16
};
```

Above you can see a basic implementation of reduce. The function checks whether an initial value is passed into the invocation using the '.length' method on the arguments object. If not, the start value is set to the first element in the collection. The provided callback is invoked on the start value and each element of the collection. The 'startVal' is reassigned to the return value of the callback on each iteration. Finally, the startVal is returned after each item in the collection has been reduced or folded using the provided callback. Now let's try to refactor so that it is only two lines of code and uses recursion. For this challenge, I'll also use some ES6!

```javascript
let reduce = (collection, callback, startVal = 0) => {
  if (collection.length === 0) return startVal;
  return reduce(collection, callback, callback(startVal, collection.shift()));
};
console.log(
  reduce(
    [1, 2, 3, 4, 5],
    function (a, b) {
      return a + b;
    },
    1
  )
); // 16
```

The body of this solution is only two lines of code! We remove the initial agruments test by using the new ES6 'defaults' in the parameter. (This isn't as comprehensive because it defaults to zero instead of the first item in the collection, but it will work for an array of numbers) The function can now start with a base case which ends the recursion when the length of the collection is equal to zero. The reduce function is then called recursively passing in the collection, the callback, and the reduce magic. The startVal is reassigned to the return value of the callback within the recursive invocation. The `startVal` from the previous call is the first parameter in the callback invocation, and using the `.shift` method, the second parameter is set to the first item in the array. Since, arrays are in memory objects, when `.shift` is called, the array shortens by one and moves it one step closer to the base case!

There you have it, reduce in two lines using recursion and ES6! What other fun refactors might be possible?


Reducing reduce: Recursion & ES6


# Buidler Basics: Node.js Server Pt. 2: 'GET','POST' & 'OPTIONS'

The server we built last week had the simple ability to post "Hello World" to the browser window, but what if you wanted to return something more complicated or send data to a database? This would require some sort of method that handles a variety of http requests. Thankfully, in Node we have the ability to take specific requests and handle them in a variety of ways. We'll look at three today, 'GET', 'POST', and 'OPTIONS'.

Node is a RESTful API exactly because it can handle common http requests. In order to handle those requests, we'll need to build up our request handler and give it access to specific actions. Those actions will be stored in a separate reference object like so:

```javascript
var actions = {
  GET: function (req, res) {
    //TODO: Query Database to get requested data
    var dataPulledFromDB = { result: "Here is your requested data!" };
    sendResponse(dataPulledFromDB, headers);
  },
  POST: function (req, res) {
    collectData(req, function (data) {
      //TODO: Insert new data to database and then...
      var successData = { result: "You posted some data!" };
      sendResponse(successData, headers, 201);
    });
  },
  OPTIONS: function (req, res) {
    sendResponse(res, null);
  },
};
```

You may have noticed, we now have two other http requests, 'POST', and 'OPTIONS', but how can we access this object using the previous request handler function from last week? We will need to evaluate the incoming request methods against the actions stored in our new object.

```javascript
var requestHandler = function (request, response) {
  if (actions[request.method]) {
    var action = actions[request.method];
    action(request, response);
  } else {
    sendResponse(res, { error: "NOT FOUND" }, 404);
  }
};
```

The request hanlder now checks the actions object for the method. If it is found, it is invoked with the incoming information. The correct method then takes over. You may also have noticed some other new functions and variables called in these new http actions. First, we now have a collectData function.

```javascript
var collectData = function (req, cb) {
  var data = "";
  req.on("data", function (chunk) {
    data += chunk;
  });
  req.on("end", function () {
    cb(JSON.parse(data));
  });
};
```

The 'POST' action calls this collectData function seen above which takes the data of the request in chunks and concatenates it into a string before parsing the data into JSON and running a callback on that data. This callback structure allows for all data to be collected before the server attempts to act on it.

```javascript
var headers = {
  "access-control-allow-origin": "*",
  "access-control-allow-methods": "GET, POST, PUT, DELETE, OPTIONS",
  "access-control-allow-headers": "content-type, accept",
  "access-control-max-age": 10, // Seconds.
  "Content-Type": "application/json",
};
```

The 'headers' object above specifies access control and the data format of our responses. The access-control properties will enable 'CORS' or Cross Origin Resource Sharing. By default 'OPTIONS' requests are not allowed, but these requests can be granted to share access with other applications. This allows for requests from other origins (those not hosted by your server) to access data through your server.

```javascript
var sendResponse = function (res, data, statusCode) {
  statusCode = statusCode || 200;
  res.writeHead(statusCode, headers);
  res.end(JSON.stringify(data));
};
```

Lastly, you may have also noticed the sendResponse function in each http action above. This is simply a way to write less code. Every action needs to call 'res.writeHead' and 'res.end'. This helper function allows us to pass the statusCode in where necessary and write less code in each action. Below you can find our more powerful server in its entirety! We can now handle 'GET', 'POST', and 'OPTIONS' requests. This server is now ready to be hooked up to a database.

```javascript
var http = require("http");

var headers = {
  "access-control-allow-origin": "*",
  "access-control-allow-methods": "GET, POST, PUT, DELETE, OPTIONS",
  "access-control-allow-headers": "content-type, accept",
  "access-control-max-age": 10, // Seconds.
  "Content-Type": "application/json",
};

var sendResponse = function (res, data, statusCode) {
  statusCode = statusCode || 200;
  res.writeHead(statusCode, headers);
  res.end(JSON.stringify(data));
};

var collectData = function (req, cb) {
  var data = "";
  req.on("data", function (chunk) {
    data += chunk;
  });
  req.on("end", function () {
    cb(JSON.parse(data));
  });
};

var actions = {
  GET: function (req, res) {
    //TODO: Query Database to get requested data
    var dataPulledFromDB = { result: "Here is your requested data!" };
    sendResponse(dataPulledFromDB, headers);
  },
  POST: function (req, res) {
    collectData(req, function (data) {
      //TODO: Insert new data to database and then...
      var successData = { result: "You posted some data!" };
      sendResponse(successData, headers, 201);
    });
  },
  OPTIONS: function (req, res) {
    sendResponse(res, null);
  },
};

var requestHandler = function (request, response) {
  if (actions[request.method]) {
    var action = actions[request.method];
    action(request, response);
  } else {
    sendResponse(res, { error: "NOT FOUND" }, 404);
  }
};

var ip = "127.0.0.1";
var port = 3000;
var server = http.createServer(requestHandler);

server.listen(port, ip);
```


Buidler Basics: Node.js Server Pt. 2: 'GET','POST' & 'OPTIONS'


# Buidler Basics: Node.js Pt. 1.5

This morning I wrote about setting up a basic server and how to build a very basic response to a 'GET' request using the 'http' module that is part of the node library. Tonight, I'm going to take a brief look at another useful module, 'url', which helps break apart a url and route your requests to the proper location.

"url" is incredibly useful for a number of reasons, but I'm going to focus on one for the time being. To use the module, you must first require it like so:

```javascript
var url = require("url");
```

You then have access to a few helpful methods, one of which is `.parse`. This is the one we will look at in this post. `url.parse()` returns an object with a number of properties based on the url that is attached to a request. Every request has a .url property and often contains important information that will need to be read and handled by the server.

To access this information in the handler you would need to write something like this:

```javascript
var parsedUrl = url.parse(request.url);
```

You then have an object with all the properties of that url including really useful .pathname.

```javascript
var pathname = parsedUrl.pathname;
```

With the pathname you could then point the request to any number of locations to handle whatever you decide should happen at that pathname. Below is a basic representation of what happens in the comments:

```javascript
// access to url methods
var url = require("url");
// request.url = "http://somesite.com/pictures/friends"
var parsedUrl = url.parse(request.url);
/_
parsedUrl = {
protocol: 'http:',
slashes: true,
host: "somesite.com",
pathname: "/pictures/friends"
}
_/
var pathname = parsedUrl.pathname;
// pathname = "/pictures/friends"
```

"url" has a few other useful methods like formatting a string from an object (reversing parse), but this basic parse function will be very helpful in building our basic node server in the coming days!


Buidler Basics: Node.js Pt. 1.5


# Buidler Basics: Node.js Server Pt. 1

Time got away from me last week, but I'm kicking off my first series in a collection called "Builder Basics". Today, I'll be building a Node.js server that I can host locally and simply returns "Hello World!" to the screen. In the following posts, I will go through how to handle basic requests like "GET" and "POST" and even some server testing.

First, in order to build a successful server like I'll build today, we will need [node.js](https://nodejs.org/en/) Once this dependency is in place, we simply need to open up a new javascript directory and create a new javascript file. In this case, I created a file called testServe.js.

In the file, the first line of code for the basic server is:

```javascript
var http = require("http");
```

This simple line tells node that you need the "http" module. This "require" word allows you to pull from the node library and use prebuilt code to construct the server. Once you have required "http" you can then use it and all its methods, but first we need to specify where we will use it. Every server needs an ip address and a port to access the address. You can think of the ip address like the address to a mall, and ports like the multiple entrances that give you access. Sometimes only certain ports are open.

```javascript
var ip = "127.0.0.1";
var port = 3000;
```

After specifying the location, you'll want to actually create the server with the http method aptly named "createServer".

```javascript
var server = http.createServer(requestHandler);
server.listen(port, ip);
```

We also need to add a .listen method and pass in our "port" and "ip" from above. Now, you may have noticed that the server takes a parameter that handles requests. This is a callback function that should take two parameters, "request" and "response". I could simply pass in an anonymous function, but because next week I will need a more powerful handler, I'm going to create a separate function.

```javascript
var requestHandler = function (request, response) {
  response.end("Hello World!");
};
```

Now this handler is bare bones, it simply takes any request at the specified port and returns the text "Hello world!" Every response needs to have a ".end" no matter what request comes into the server. Today, to add a little more filtration I'm going to only respond to "GET" requests and I'm going to add a header to my response.

```javascript
var requestHandler = function (request, response) {
  if (request.method === "GET") {
    response.writeHead(200, { "Content-Type": "text/plain" });
    response.end("Hello World!");
  } else {
    response.writeHead(404, { "Content-Type": "text/plain" });
    response.end("NOT FOUND");
  }
};
```

Each .writeHead method returns a header on the http message that is sent back to the client making the request. Headers give important details about the response like status code and content-type. In this case, if they sent a "GET" request they recieve the plain text message "Hello World!", and a status code 200. If they do anything else, the get "NOT FOUND" and 404. Let's take a look at how our code looks all together.

```javascript
var http = require("http");

var requestHandler = function (request, response) {
  if (request.method === "GET") {
    response.writeHead(200, { "Content-Type": "text/plain" });
    response.end("Hello World!");
  } else {
    response.writeHead(404, { "Content-Type": "text/plain" });
    response.end("NOT FOUND");
  }
};

var ip = "127.0.0.1";
var port = 3000;
var server = http.createServer(requestHandler);

server.listen(port, ip);
```

Above you can see the finished product. I can now spool up my server on the local host by opening the directory in the command line and typing "node testServe.js". If I then navigate to 127.0.0.1:3000 in my browser, I can see "Hello World!"

I hope you enjoyed how to setup a bare bones basic Node server! I'm looking forward to next week when we'll give this server more power. Let me know what you think below!


Buidler Basics: Node.js Server Pt. 1

# Preparing and Prototypes

Another week of preparation down in the weeks leading to Hack Reactor Remote! I'm working through all the required material and building a plan for the last month before complete immersion.

Preparation

On top of the pre-course material, I've been working through algorithm challenges on <a rel="noopener" href="http://www.freecodecamp.com/" target="_blank">Free Code Camp</a>, reviewing jQuery on Code School, freshening up my knowledge of <a rel="noopener" href="https://www.udacity.com/course/object-oriented-javascript--ud015" target="_blank">Object-Oriented Programming</a> on Udacity, and this week  I'll continue to work through a class on <a rel="noopener" href="https://www.udemy.com/understand-nodejs/learn/#/" target="_blank">node.js at Udemy</a>! There are so many great resources out there! I've got an even bigger list of material I hope to finish before Feb. 29th, but I doubt I'll get through them all.

Prototypes

This week, among other things, I learned a very important distinction between use of the word 'prototype' when speaking about classes in the pseudoclassical pattern of creating new objects. Classes are functions that are used to build new objects that all share a similar list of properties and methods.

The first use of 'prototype' is in reference to the constructor function that builds new instances of a class.  When that function is created, javascript automatically creates a 'prototype' of the same name. This prototype includes an invisible '.constructor' method that refers to the function that created it. For example, if we have a function called 'Knight' it will be connected to the function 'Knight.prototype'.  If we log the '.constructor' property on a new instance created by 'Knight', it will return the function that created it, in this case the function assigned to 'Knight'.

```javascript
var Knight = function (name, weapon) {
 this.name = name;
 this.weapon = weapon;
};

Knight.prototype.strike = function () {
 console.log(this.name + " hit you with the " + this.weapon);
};

var steve = new Knight("Steve", "Mace");

steve.strike();
console.log(steve.constructor);
//Knight.strike(); Does not work!!!
```

The first use of 'prototype' refers to the link to the class constructor function. The second use of 'prototype' refers to the link to new instances of that constructor and the same prototype.

In the pseudoclassical pattern, a prototype('Knight.prototype') is linked to its class creating function('Knight')of the same name, and to all new instances of that class. The function 'Knight' is linked for the purpose of assigning new instances to 'Knight.prototype'.  The instances are then linked for the purpose of fall through after failed look ups. For example, in the code above you can call steve.strike(); but you could not call Knight.strike();

All of this is explained really well by Marcus Phillips in a Udacity course I highly recommend on <a rel="noopener" href="https://www.udacity.com/course/object-oriented-javascript--ud015" target="_blank">Object-Oriented Programming</a>.

Preparing and Prototypes


# Hack Reactor Ready

My last post was right after my first technical interview with Hack Reactor. Well, I was not accepted on my first attempt, _but_ they told me to study up and apply again in about two weeks.  I took my time reviewing materials and preparing to solve the problems they might present.  I am happy to say that the time and studies paid off.  *I was accepted into [Hack Reactor Remote](http://www.hackreactor.com/remote-beta)!!!* I elected to enroll in the cohort that starts on Feb. 29th, 2016.

The past couple weeks I've been digging into the required pre-course materials including building my first web application in javascript! I'm enjoying every project and can't wait to start working and learning with others next month.  I am so thankful for the opportunity to attend Hack Reactor's Remote program! It includes all the content and methodology from the on-site, but instead creates a virtual classroom and will give me just a little more time to connect with my wife and kids throughout each week.

So far, I'm in an ever-growing cohort of students from all over the US, London, and even Japan. We have been asked to rewrite part of a library of functions, write a simple clone of a well-known web-app, and implement a couple challenging functions using recursion.  There have been lots of helpful tutorials, slides, and links to get us ready for the first week.  The goal of the pre-course is to make sure we are all on the same page and I'm really excited to see where we progress from there! I have a decent idea of some of what the first week may include, but anticipate that even that first week will be challenging and surprising.

Each week, I hope to share a little more of what I'm learning and my favorite new resource, aside from the stuff you have to pay Hack Reactor to see ;-) .

This week, I'll stick to the announcement, but will share my favorite new resource. One of my classmates sent me [this video on recursion](https://youtu.be/k7-N8R0-KY4).  It is hilarious and informative and I've already subscribed to his youtube channel.


Hack Reactor Ready

# Bootcamps abound...let's narrow it down.

Last week, I stepped up the speed and time that I was investing in creating a stronger foundation in JavaScript.  I ended up completing the JavaScript Road Trip and <a rel="noopener" href="http://campus.codeschool.com/courses/javascript-best-practices/contents">JavaScript Best Practices</a> on Code School.  I also tackled the first 5 chapters of <a rel="noopener" href="http://eloquentjavascript.net/">Eloquent JavaScript</a>. I worked on a number of challenge questions to strengthen my ability with callbacks, modular programming, and more.  It was a lot to digest in a week, but it had a purpose.

Today, I had a technical interview with <a rel="noopener" href="http://www.hackreactor.com/">Hack Reactor</a> and it was a lot of fun.  Going into it, I wasn't positive if I was prepared well enough, but overall I really enjoyed the experience.  It was my first time coding with someone and being evaluated live.  The initial questions weren't challenging and I tried to talk through what I was doing out loud to make sure my interviewer understood my thought process. At one point I was asked to build my own simple callback function.  Later, I was able to ask questions and learn as we walked through a couple challenges with higher-order functions that I had never used. At a couple points I went in the wrong direction doing more work than was necessary and overthinking the challenge, but with some help, I was able to fix my mistakes and learn from them.  Overall, the interview was a great learning experience and quickly showed me the value of coding with someone much more experienced.  It was a pleasure working through the challenges with my interviewer and hearing more about his experience in the immersive program. I'm excited to hear from them later this week!

Last week, I also spent a lot of time researching and applying to other online bootcamps.  Using sites like Quora and Skilledup, I've been trying to get a feel for strengths and weaknesses of online bootcamps that meet my needs and desires. This <a rel="noopener" href="https://www.coursereport.com/blog/free-webinar-which-online-coding-bootcamp-is-best-for-you">course report on Online Bootcamps</a> was especially helpful.

<ul>
<li>Family- I need something online that allows me to still occasionally say "Hi" to my wife and kids.  They'll be making a sacrifice either way, but a 12-week immersive just might be better than a combination of working full-time while in 72-week part-time program.</li>
</ul>
<ul>
<li>Rigorous - I'm looking for a program that doesn't pull punches, but gives me the best preparation possible. Hack Reactor is definitely at the top of this list, but I am also considering a new program through Bloc called their <a rel="noopener" href="https://www.bloc.io/software-engineering-track">Software Engineering Track</a>.  I'll be attending an info. session this week to learn more.</li>
</ul>
<ul>
<li>Finances- This actually isn't much of a concern as I've looked at the options.  Most programs have partnership with solid lender options. Initially, I felt the more expensive programs seemed riskier, but now I feel that if anyone is serious about investing in any of these programs, they will get results. The most expensive programs might actually prove to have less risk because you finish better prepared, and some even have guaranteed refunds. <a rel="noopener" href="http://www.vikingcodeschool.com/">Viking Code School</a> only gets paid once you get a job and then they take 18% of you first year of salary which gives them a lot of incentive to prepare you well.</li>
</ul>
<ul>
<li>Acceptance- That's the last criteria. I need to be accepted into the program. Hack Reactor was the first on the list and I'm in process with Bloc, Viking Code School, and planning on learning more about Firehose.  All of these options sound good for a number of reasons, but after today, Hack Reactor may likely be the road I choose.  If I'm not accepted this go around, they have a new program called <a rel="noopener" href="http://www.hackreactor.com/blog/fulcrum-pilot">Fulcrum</a> that I will heavily consider to prepare for a second interview attempt.</li>
</ul>
This week, I'll be continuing to work through Eloquent JS, I may mess around with Ruby, and I'll be building my own projects using JavaScript. I took a look at some of the <a rel="noopener" href="http://www.hackreactor.com/blog/purify-css-tool-vaults-remote-students-into-hacker-news-limelight">projects that Hack Reactor students have built </a>and got excited about potentially being involved in similar work. The interview felt like an accomplishment no matter the result. I'm excited to move forward.

Bootcamps abound...let's narrow it down.


# Making the Most of Modulo Moments

I'm starting this blog to share my experiences learning to code. I'll be posting about projects I'm tackling and reflecting on how I'm growing as a developer. As I find new resources, best practices, and work through new challenges, I hope to compile everything into helpful guides, reviews, and stories from the world of coding. I'm currently in a number of online self-driven programs and I'm considering a number of bootcamp options for the future.  I'm excited to tackle this challenge and hope to post at least once a week with increasing frequency as I get deeper into the world of coding.

For the moment, my coding experience is only in the remainders of life. I recently learned how to use this [operator in javascript:](http://www.w3schools.com/js/js_operators.asp) '%'. The _modulo_ or _modulus_ is used to find a remainder between two numbers. In my 'remainder' moments this past year, I started to play around with html and css to change some basic appearance on my current employers' website.  I realized I really enjoyed trying to learn how to alter and create new elements on the site. I was hooked.

Over the past year, I've worked on a couple projects and explored multiple languages, frameworks, and possibilities for growing in knowledge and experience as a developer. I've only gotten my feet wet, but I'm picking up speed. This past week, I plowed through [codecademy's Javascript Course](https://www.codecademy.com/en/learn/javascript) and can't wait to tackle the final project.

Working full-time, spending time with my wife, and raising two kids, fills up my time quickly, but I'm hoping to spend even more of my remainder moments learning and creating.  Truly, I hope that the blog will be a record of a great journey from front-end padawan to full-stack Jedi! Only time will tell, but for the moment, I can't wait to build something new!


Making the Most of Modulo Moments

# While Learning to Code...

Learning to code sometimes feels like an infinite loop. This week I finished my second attempt at a portfolio and worked my way through <a rel="noopener" href="https://www.codecademy.com/en/learn/web" target="_blank">Codecademy's HTML/CSS track</a> and their <a rel="noopener" href="https://www.codecademy.com/en/learn/javascript" target="_blank">JavaScript Track</a>. I also began the <a rel="noopener" href="https://www.codeschool.com/paths/javascript" target="_blank">Code School JavaScript Road Trip</a>.  I had already taken <a rel="noopener" href="https://www.udacity.com/course/javascript-basics--ud804" target="_blank">Udacity's JavaScript Basics</a>.  Why do I list all these courses?

Every time I repeated a study of a concept, especially when building objects or functions on my own, I found myself with stronger content retention.  This <a rel="noopener" href="http://rdbruhn.github.io/" target="_blank">most recent attempt</a> at a portfolio page has helped me get faster and more efficient and building in HTML and CSS. I also picked up some new tricks.

As I continue this journey, I'm positive I am going to be repeating myself a lot, but this seems to be where the real learning is taking place.  This next week I'm continuing that strategy, but also venturing into new territory.  I'm currently reading <a rel="noopener" href="http://eloquentjavascript.net/" target="_blank">Eloquent JavaScript</a> and working through the exercises in each chapter.  I'll be moving into JQuery on Codecademy and moving further on the Code School JavaScript Track.

After all that, I'll be tackling a new project building my first JavaScript "Choose Your Own Adventure" game. I hope all this repetition will pay off. No really, I hope I'll get paid for it someday soon.

Archive