Trini Coder

Elm is a functional programming language for building HTML apps.

To start playing with it on Ubuntu, you need:

A Node.js installation which you can learn how to setup here, and

The Elm Platform.

Just follow the instructions on the pages linked to above and you should be all set.

Resources

Get Started

What kind of runner can run as very fast as they can from the very start of a race? Only someone who runs really short races. But of course we're programmers and we're smarter than runners. Because we know how to fix that problem. We just fire the starting pistol every hundred yards and call it a new sprint.

Redux is a predictable state container for JavaScript applications.

In Redux, the entire state of the application is represented by one JavaScript object, called the state tree. The state tree is immutable.

Anytime you want to "change" the state you have to dispatch an action. An action is a plain JavaScript object that describes the state change.

The dispatched action along with the current state is given to a pure function, called a reducer, that calculates the next state.

In summary,

Immutable state tree, represents entire application state.

Actions, describe state changes.

Reducer, (state, action) -> state.

Continuing where we left off in "Creating Node.js modules with ES2015", wouldn't it be nice if we could write our test code in ES2015 as well.

We can and we're going to do it using Mocha and expect.

Let's install them.

Note: I recommend using nvm to manage your Node.js versions. I explain how to set it up here.

$ cd path/to/hello-world $ nvm use node $ npm i -D mocha expect $ mkdir test $ touch test/greet.spec.js

In test/greet.spec.js add the following ES2015 code:

import expect from 'expect' import greet from '../src' describe('greet', function() { context('with no arguments', function() { it('returns "Hello, world!"', function() { expect(greet()).toEqual('Hello, world!') }) }) context('with 1 argument, for e.g. Keisha', function() { it('returns "Hello, Keisha!"', function() { expect(greet('Keisha')).toEqual('Hello, Keisha!') }) }) })

Note: I didn't pass arrow functions to the describe and it blocks since Mocha discourages its use. It says "... Their lexical binding of the this value makes them unable to access the Mocha context, and statements like this.timeout(1000); will not work inside an arrow function.".

Before we can run the tests we also need to install babel-register. It allows us to use Babel through the require hook. Learn more here.

$ npm i -D babel-register

Now, to run the tests we type:

$ ./node_modules/.bin/mocha --compilers js:babel-register

which gives us

greet with no arguments ✓ returns "Hello, world!" with 1 argument, for e.g. Keisha ✓ returns "Hello, Keisha!" 2 passing (9ms)

All good. Finally let's make this easier to run by adding it to our scripts property in our package.json.

{ ... "scripts": { ... "test": "mocha --compilers js:babel-register" } ... }

Simply type npm run test or npm test to run the tests as before.

Pass any extra command-line options to mocha as follows npm test -- [extra-options]. For e.g. to watch files for changes and rerun the tests type npm test -- --watch. Learn about all the options here (though I've found that ./node_modules/.bin/mocha --help is better to use since it has the relevant options for your version of the installation).

Excited about ES2015? Not sure how to start creating Node.js modules using it? Here's a quick tutorial to get you started.

We're going to create a hello-world package containing a single module written in ES2015. At the end we will be able to install and use the package as follows:

Note: I recommend using nvm to manage your Node.js versions. I explain how to set it up here.

$ nvm use node $ npm install path/to/hello-world $ node > greet = require('hello-world').default > greet() 'Hello, world!' > greet('Dwayne') 'Hello, Dwayne!'

Note: I don't cover publishing the package but if you're interested in that then here is where you can learn to do it.

In the process you will learn how to structure your package and how to use Babel 6 to transpile your ES2015 (formerly ES6) code into ES5 code that uses the CommonJS module format.

Let's get started.

Set up a directory to contain your package, a package.json file and a src/index.js file.

Note: I go into more detail about package.json here. If you follow that post then a simple npm init or npm init -y will get you a really sweet package.json with much less typing.

$ mkdir -p hello-world/src $ cd hello-world $ touch package.json src/index.js

A package.json file:

Serves as documentation for your dependencies.

Allows you to use semantic versioning rules to specify the versions of your dependencies.

Makes your build reproducible and easier to share with other developers.

Keeps track of useful metadata about your project.

Now, in your package.json file add the following:

{ "name": "hello-world", "version": "0.0.0", "description": "A hello world package for creating hello world applications", "keywords": ["hello", "world", "hello-world", "helloworld"], "author": { "name": "Dwayne R. Crooks", "email": "[email protected]", "url": "http://dwaynecrooks.com/" }, "license": "MIT" }

name and version

These are required as your package won't install without them. The name and version together form an identifier that is assumed to be completely unique. The name is what your package is called. The version should follow semver.

Since we're in initial development and may change anything at anytime I chose to start the version number at 0.0.0. As we continue to develop and make releases we can increment the minor version number each time giving a sequence of releases as 0.1.0, 0.2.0, 0.3.0 etc. Once we've reached the point where we feel the public API is stable we can make a 1.0.0 release. The way in which the version number is incremented after this release is dependent on this public API and how it changes.

description and keywords

It's recommended to add these since they help people to discover your package.

author

Lets everyone know who wrote the package and how to contact you. If you got help along way then there's a contributors field just for that.

license

I'm told you should have one. Which makes sense, since it allows people to know how they are permitted to use your code and any restrictions you're placing on it. Even if you think you don't need one because you don't care how people use you're code, you should still have one because not having one doesn't mean you're opting out of copyright law.

In summary, be explicit and choose a license.

Note: Learn more about these (name, version, description, keywords, author and license) and the rest of the options here.

The src/index.js file will contain our ES2015 code.

export default function(who = 'world') { return `Hello, ${who}!` }

This module has a default export. The exported function takes a default value for the who parameter and returns a string constructed from who using a template string. Hence, if the function is called with no arguments it returns Hello, world! but if it is called with an argument, say 'Dwayne', then it returns Hello, Dwayne!.

Babel

Babel is a JavaScript compiler that we can use to transpile our ES2015 code into ES5 code. We need to do this since Node.js won't understand our ES2015 code.

Let's install babel-cli and run it on our module.

$ npm install --save-dev babel-cli $ ./node_modules/.bin/babel src/index.js

Nothing happens. The output is our original module. The problem is that Babel 6.x does not ship with any transformations enabled. You need to tell it explicitly what transformations to run. The simplest way to do this is by using a preset, such as the ES2015 Preset. Presets are sharable configurations that bundle a collection of plugins. Plugins are extensions to Babel that allow it to parse specific types of syntax or apply transformations to your code.

Let's install and use the ES2015 Preset.

$ npm install --save-dev babel-preset-es2015 $ ./node_modules/.bin/babel --presets=es2015 src/index.js

This outputs the following ES5 code in CommonJS module format:

'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = function () { var who = arguments.length

Rather than display the transformed code on standard output let's save it to a file and test with node.

$ ./node_modules/.bin/babel --presets=es2015 src -d lib $ node > greet = require('./lib/index.js').default > greet() 'Hello, world!' > greet('Dwayne') 'Hello, Dwayne'

Final Touches

Make building easier

I hate having to type ./node_modules/.bin/babel all the time to compile the code. Luckily the package.json file provides a scripts property we can use to run various commands. Learn more about the scripts property here.

{ ... "scripts": { "build": "babel --presets=es2015 src -d lib" }, ... }

We can now simply execute npm run build.

Better Babel configuration

Passing options to Babel via the command-line is fine when there aren't that many options to pass. But things can start to get unwieldly rather quickly. A better practice will be to either use the .babelrc file (see here) or the babel property inside of the package.json file (see here).

{ "presets": ["es2015"] }

or

{ ... "babel": { "presets": ["es2015"] }, ... }

Set the entry point of the package

{ ... "main": "lib/index.js", ... }

Remember, we use the ES5 build because that's what Node.js understands.

Point ES2015-aware tools like Rollup to the entry point of the package

{ ... "jsnext:main": "src/index.js", ... }

Learn more here.

Specify the files we want included in our package

{ ... "files": [ "lib", "src" ], ... }

Clean the lib directory

$ npm install --save-dev rimraf

{ ... "scripts": [ "clean": "rimraf lib", ... ], ... }

Ensure lib is built before publishing the package

{ ... "scripts": [ ... "prepublish": "npm run clean && npm run build" ] ... }

This hook is also run on local npm install which we will take advantage of in order to test install the package and use it.

Test install the package and use it

$ cd /tmp $ npm install path/to/hello-world $ node > greet = require('hello-world').default > greet('Keisha') 'Hello, Keisha!'

Set up a Git repo

Note: If you need help installing Git, I did an extensive write-up here.

$ git init $ echo -e 'lib\nnode_modules' > .gitignore $ git add . $ git commit -m "Initial development release"

Next Steps

Here are some other things you can do.

Publish your package to npm.

Push your repository to GitHub so that others can contribute.

Lint your code.

Test your code.

Set up code coverage.

...

Email me if you need assistance. Happy hacking :).

Resources

Packages and Modules - Learn the vocabulary

package.json

Choosing an open source license doesn't need to be scary

Babel

Learn ES2015

One of the first steps in starting any new Node.js project should be to create a package.json file since it's the best way to manage locally installed npm packages.

If you're just experimenting then the quickest way to do it would be to open a text editor and type the following:

{ "name": "project-name", "version": "0.0.0", "private": true }

According to semver, major version zero (0.y.z) is for initial development. When you believe you have a stable public API then you can switch to version 1.0.0 and onwards. I also suggest to use private: true in the initial development or experimental phase so that npm prevents accidental publication of your work. Remove it when you're ready to share with the world.

However, if you're starting a project that you're going to make publicly available then I suggest you use npm init. It is a utility that steps you through creating a package.json file. It covers the most common items and tries to guess sensible defaults for most of them.

NOTE: This example makes use of nvm. Click here for instructions on how to install it.

$ mkdir example-project $ cd example-project $ nvm use node $ npm init ...

Click here to understand how each option works and to see their possible values.

Setting useful defaults

If you find yourself changing the given defaults over and over again then you can set your own defaults.

$ npm set init.version 0.0.0 $ npm set init.author.name "Dwayne R. Crooks" $ npm set init.author.email [email protected] $ npm set init.author.url http://dwaynecrooks.com/ $ npm set init.licence MIT

And, the next time you run npm init those would be used as the defaults. Sweet!

Tips:

If you execute npm help 7 config you'll get a list of all the configuration settings.

With your defaults configured you can be confident that the defaults it uses are the defaults you want. Hence, you can type npm init -y and it will use only defaults and not prompt you for any options. This is THE quickest way to a great starting package.json.

Happy hacking :).

Resources

Using a package.json

Specifics of npm's package.json handling

Set Your npm init Defaults

NodeUp - Episode 70

npm-init

npm-config

npm Documentation

In the past, which was about two months ago, I used to install Node.js from source into my home directory.

Click here to see how I used to do it.

The process was tedious because I had to redo most of it every time I needed to upgrade. And managing multiple versions of Node.js was a nightmare. That's why I'm so glad I decided to switch to nvm.

Installing nvm

One of the ways to install nvm is through Git. I'd describe that way below and you can check out nvm's own installation instructions if you need to use a different way.

Installing via Git

Note: If you don't have Git installed then you can install it using the instructions provided here.

$ git clone https://github.com/creationix/nvm.git ~/.nvm $ cd ~/.nvm $ git checkout `git describe --abbrev=0 --tags`

git describe --abbrev=0 --tags says to consider both annotated and lightweight tags and only show the tag name of the tag closest to HEAD.

Now, to activate nvm you need to source it from the shell.

$ . ~/.nvm/nvm.sh

Add these lines to your ~/.bashrc to have it automatically sourced when you open a shell.

export NVM_DIR="$HOME/.nvm" [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"

[ -s "$NVM_DIR/nvm.sh" ] returns True if the file exists and has a size greater than 0.

Using nvm

$ nvm install node $ nvm use node $ node -v v5.4.1 $ npm -v v3.3.12

You're all set and ready to begin exploring more of nvm and Node.js.

Bonus

To enable bash completion, add these lines to your ~/.bashrc.

[ -r "$NVM_DIR/bash_completion" ] && . "$NVM_DIR/bash_completion"

[ -r "$NVM_DIR/bash_completion" ] returns True if the file exists and is readable.

Note: The official docs use [[ -r $NVM_DIR/bash_completion ]] because the double-bracket syntax will ensure it fails fast in a non-bash environment.

Upgrading nvm

This isn't documented for nvm but it isn't that hard to do. Here are the steps:

$ cd "$NVM_DIR" $ git pull origin master $ git checkout `git describe --abbrev=0 --tags`

You don't have to worry about losing you're already installed versions of Node.js since the version directories, $NVM_DIR/versions/node/v*, are ignored by the repository and hence won't be touched during the upgrade.

Resources

nvm Usage

Git Tip of the Week: Tags

Git Basics - Tagging

Introduction to if

What is the difference between double and single square brackets in bash?

Git is a popular free and open source distributed version control system that is easy to learn. I use it daily for my software development as it helps me to keep track of any changes I make to my source code.

Install

Note: The instructions that follow were verified on a Ubuntu 14.04.3 LTS system.

To install Git on Ubuntu we can simply run

$ sudo apt-get update $ sudo apt-get install git

But, we won’t do that since it doesn’t install the latest version. See

$ apt-cache policy git git: Installed: (none) Candidate: 1:1.9.1-1ubuntu0.2 ...

So, to install the latest version we will instead use the PPA provided by the "Ubuntu Git Maintainers" team.

$ sudo add-apt-repository ppa:git-core/ppa $ sudo apt-get update

Now, if we check the version of Git that will be installed we see that it’s the latest version.

$ apt-cache policy git git: Installed: (none) Candidate: 1:2.7.0-0ppa1~ubuntu14.04.1 ...

This is what we want, so let’s install it.

$ sudo apt-get install git

Configure

Set your full name and email to be recorded in any newly created commits.

$ git config --global user.name "Dwayne R. Crooks" $ git config --global user.email "[email protected]"

Set the default text editor that Git will use when it needs to type in a message.

$ git config --global core.editor "atom -nw" # or $ git config --global core.editor "nano -iT 2"

Add some useful aliases.

$ git config --global alias.br branch $ git config --global alias.ci commit $ git config --global alias.co checkout $ git config --global alias.st status $ git config --global alias.hist "log --pretty=format:\"%h %ad | %s%d [%an]\" --graph --date=short"

Aliases allow you to reduce typing. For e.g. instead of typing

$ git log --pretty=format:\"%h %ad | %s%d [%an]\" --graph --date=short

You can now type

$ git hist

Finally, tell Git about all the patterns you want it to ignore in all situations.

$ echo '*~' > ~/.gitignore_global # Backup or temporary files generated by your editor # of choice usually go into this file $ git config --global core.excludesFile "$HOME/.gitignore_global"

Test

$ mkdir example $ cd example $ echo 'Hello, world!' > hello $ git init $ git add . $ git ci -m "Initial commit" $ git hist

The End

You’re all set to begin using version control in your next project.

Bonus

Click here to spin up a VM and play with the latest Git.

Resources

What is Git?

Learn Git in your browser for free with Try Git

Getting Started — First-Time Git Setup

git-config Documentation

For whatever reason you may want to use a different version of Python than what came with your Ubuntu distro. However, completely replacing the system version is not recommended. Here's how to install Python for the local user.

$ mkdir -p ~/local/python-3.5.1 $ cd ~/Downloads $ wget https://www.python.org/ftp/python/3.5.1/Python-3.5.1.tgz $ tar -zxvf Python-3.5.1.tgz $ cd Python-3.5.1 $ ./configure --prefix=$HOME/local/python-3.5.1/ $ make # Optional $ make test $ make install $ ~/local/python-3.5.1/bin/python3 --version

Tips

Take a look around while you're in the Python source directory, i.e. ~/Downloads/Python-3.5.1.

Check out the README for extra help on the installation process.

View the configuration help with ./configure --help.

Quick Start

$ mkdir ~/python3-playground $ cd ~/python3-playground $ ~/local/python-3.5.1/bin/pyvenv env $ . env/bin/activate (env) $ pip install django (env) $ ... (env) $ deactivate $ ...

Learn more about virtual environments in Python 3.5.1 here.

References

Python 3.5.1 Release

How to update Python version on Ubuntu 14.10

My team is currently using Gerrit for code review. Usually when a review is done, I'd need to pull down the change and edit a couple of the files in the commit based on the review that was given.

Here's my current workflow,

# download the change $ git review -d <id> # find and edit files in the last commit $ atom # commit updates # --no-edit means don't edit the commit message # though sometimes I may need to $ git commit -a --amend --no-edit # push new changes for further review $ git review -f dev

Usually it's a hassle to find all the files that may need editing from the last commit. But, I've been able to concoct a really nice solution.

According to this Stack Overflow answer, you can list all the files that were part of a given commit using

git diff-tree --no-commit-id --name-only -r <commit-hash>

And I recently learned a way to show the abbreviated commit hash of the most recent commit using

git log --pretty="%h" -n1

Combining the two I can now easily list the files that were in the last commit using

git diff-tree --no-commit-id --name-only -r `git log --pretty="%h" -n1`

Which would give the following output for example,

a.txt b.txt c.txt

The only remaining problem is how to get my editor to open up the list of files as given by the previous output. Turns out xargs is pretty neat and can handle precisely this problem (and a lot more). See here for examples of xargs in action.

Essentially, piping the output of the previous command through xargs would give

a.txt b.txt c.txt

And instructing xargs to execute the atom -n command on the input would yield the result we want.

Hence,

git diff-tree --no-commit-id --name-only -r `git log --pretty="%h" -n1` | xargs atom -n

will open all the files from the last commit in Atom.

Happy hacking!

I recently mistakenly misnamed my package.json file as project.json and started to npm install --save-dev some packages. Much to my surprise I didn't see my development dependencies update in my .json file. After fixing the name I just wanted to update my package.json file in one go.

Here's the command I used:

$ ls node_modules | xargs npm install --save-dev

References

http://stackoverflow.com/a/21123358/391924

Xargs

I'm currently on a project at work where we are migrating from a Sprockets based asset pipeline to one that is based on Gulp. Since I didn't know how to use Gulp I took the liberty to ramp myself up. Here are the notes I took (my future self will surely thank me).

TLDR; When you're writing a gulpfile.js you're essentially writing a node.js program (JavaScript) using streams.

A build system

Built on Node.js

Code over configuration (JavaScript/CoffeeScript)

Writing your gulpfile.js in CoffeeScript

Based on node streams

stream-handbook

Minimal API surface

src, dest, task, watch

Glob Primer

node-glob, minimatch

Depends on a rich plugin community for most of its tasks

Plugins are developed under strict guidelines and are curated

Introduction

Getting Started

Specifics of npm's package.json handling

Building with Gulp

IMPORTANT

gulp.task('build', ['css', 'js', 'imgs']);

These will be run asynchronously, so you can’t assume that the css task will have finished running by the time js starts — in fact, it probably won’t have.

Tutorials

Browserify Handbook

Gulp + Browserify: The Everything Post

Introduction to JavaScript Source Maps

Videos

Get started with gulp

gulp.js: Optimising Front-End Build Performance

Gulp - The Basics

Books

Developing a Gulp Edge

Getting Started with Gulp

Happy hacking!

I asked myself the question because I found it really strange that the official documentation as well as other sources recommended that you install gulp both globally and locally, i.e.

$ # Step 1 $ npm install -g gulp $ # Step 2 $ npm install --save-dev gulp $ # ...

After trying to find an explanation I wasn't satisfied with any of them so here's my attempt.

Explanation

Let's assume you're in your project's root directory and you decide you want to add gulp to your project. You already have your package.json file set up so all you need to do is run npm install --save-dev gulp in order to add gulp as a development dependency to your project. Hopefully, you already know why specifying dependencies (development or otherwise) is a good idea.

Now, you set up your gulpfile.js

var gulp = require('gulp'); gulp.task('build', function () { console.log('Building...'); }); gulp.task('default', function () { console.log('Hello, world!'); });

and type gulp at the command-line to run the default task of your gulpfile.js, as every tutorial tells you to do.

Well guess what?

You'd get a No such file or directory error.

Since your local node_modules/.bin/ directory (see the bin property for package.json) is not in your PATH (which it shouldn't be) the shell could not find the command to be executed.

There are many other ways to get your gulpfile.js to be executed though.

Way #1

$ ./node_modules/.bin/gulp

Way #2

In your package.json file set the scripts property.

{ // ... "scripts": { "gulp": "gulp" } // ... }

Then you can use npm run to execute gulp like so npm run gulp. If you want to run something other than the default task then type npm run gulp -- build, for example.

Way #3

Just install gulp globally as well and assuming your global npm node/bin directory is in your path (which should already be the case) then you can just type gulp or gulp build etc. as you've seen in many tutorials. The reason this works is because gulp tries to run your gulpfile.js using your locally installed version of gulp, see here. Hence the reason for a global and local install of gulp.

Happy hacking!

Recently (about 2 days ago) I started back playing with Node.js and I've come across a lot of great tutorials, videos, libraries and other resources in the process. Since I know I'd forget where to find most of this stuff when I need them I'm writing up some notes here to keep track and remind myself.

What is Node.js?

According to their website,

Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.

The about section also has a good overview.

How I Got Started?

I'm running Ubuntu 14.04 LTS on a 64-bit machine so I just followed some of my own instructions I wrote up a while back.

Resources

I think the best resources, to get started and up to speed with Node.js as quickly as possible, are at NodeSchool. I've done javascripting, learnyounode, stream-adventure and browserify-adventure to date. I plan to do most of them since these workshoppers are a pretty fun way to learn.

API Docs

Community resources

npm

npm docs

Express - Fast, unopinionated, minimalist web framework for Node.js

LoopBack - Powerful Node.js framework for creating APIs and easily connecting to backend data sources

StrongLoop has a nice selection of videos

Stormpath's user management API for developers

Lessons Learned: Building Authentication Libraries for Node

bcryptjs

client-sessions

csurf - CSRF token middleware

basic-auth

express-stormpath

socket.io

Node.js Certification

The study guide looks great

Happy hacking!

In many ways 2014 was one of my most challenging years. A lot of things changed in my life, mostly for good, but throughout the process I had a myriad of setbacks.

Top among them was the disappointing news I received to begin the year. You see, I had a desire to advance my career and become a Software Developer for an international company. But it turned out the company I set my sights on didn't feel the same desire for me. To understand how heart wrenching this news was you need to hear the full story.

Let's Move

Sometime around August-September 2013 my girlfriend and I decided that we didn't want to live in Trinidad and Tobago anymore. Both of us are Software Developers here and for a long while we were disappointed with the state of Software Development in the country. We had many reasons but at the top of the list included:

Not feeling excited about the work we were doing.

Not feeling technically challenged by the work we were doing.

Not being paid sufficiently for the demanding work and the long hours we had to endure.

Taking Action

Anyway, we reached our breaking point and felt that we needed to do something about it. In earnest, we began looking for relocation opportunities that were available for me. I say, me, because the plan was that I would be the first to relocate.

After applying to

HouseTrip

"Having reviewed your employment background and qualifications, we are sorry to inform you that you have not been selected to fill the role."

Booking.com

"We have reviewed your CV and application; however we are unable to offer you an interview at this time. While we were impressed with your background and experience, we have concluded that other candidates' qualifications more closely match the requirements for this position."

Hashrocket

I actually applied for their Apprentice job but because they weren't able to sponsor work visas for Apprentice candidates at the time, I was not accepted.

SponsorPay

Braintree

Platform45

Neil Henegan reached out but after that I didn't hear back from him when I followed up.

ThinkCERCA

... and some other places I can't recall

and either being rejected or not hearing back from them I finally got a break when AlphaSights showed interest on September 26th, 2013.

Interviewing

The following day I had an interview with David Griffiths and Oliver Martell over Skype. It went great and so it was on to the Technical Test. After 2 days of working on the problem in my spare time I sent them a solution and we scheduled a code review session for October 4th, 2013. That session went okay but due to some technical issues with Skype and me not feeling like I nailed it I decided to follow up with an email that helped to further explain my thought processes behind my solution.

Here's the email I sent:

Hi Tor and Oliver,

I just wanted to say thanks again for the opportunity and I apologize for any lag in the connection that may have caused the interview to not go as smoothly as it should have.

Also, I wanted to follow up with some of the resources I used to help me think through the architecture for the application:

The overall principle guiding my decisions was "If you're writing a bookmark app then the achitecture should scream bookmark app". I got this from Uncle Bob ( http://www.youtube.com/watch?v=WpkDN78P884 - Architecture the Lost Years and http://www.cleancoders.com/codecast/clean-code-episode-7/show - Architecture, Use Cases and High Level Design). Obviously this application I wrote is a bit small to incorporate all the practices but that's the direction I was heading with it.

The practicalities of building such a design in Rails was learnt from reading Avdi's book - Objects on Rails http://objectsonrails.com/.

I also tried to have a SOLID design and some of the ways in which I decoupled my services and injected external dependencies I learnt from reading Sandi Metz book - Practical OOP in Ruby http://www.poodr.com/

I'm no expert at TDD, but I understand the value of it and I'm constantly learning more and more each day. Some of the resources I found really useful in this regard are here http://www.youtube.com/playlist?list=PLXWV2GaylxT9vVzHbQpcMGoOfHgiXtnHP

Form objects: I learnt it by reading this blog post - http://pivotallabs.com/form-backing-objects-for-fun-and-profit/.

I also don't believe in fat models, and in fact ActiveRecord models violate SRP so I try to avoid too much business logic in my models and keep them lean and focused on persistence. Some other model thinning patterns I've learned about come from this article http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/

Essentially, I want you guys to get a sense that yes I'm new to Ruby and to Rails and to TDD. But I'm not new to programming. I have a ton of experience on the job and much more experience off the job learning on my own and honing my skills. I'm constantly striving for better. Always trying to craft the best code I can and constantly improving it with better patterns. I'm a voracious reader, especially when it comes to my craft and I HATE poorly written code (it actually irritates me). I just hope that from my previous interviews I did with you guys, the code I wrote and my additional take on it given above I have been able to represent myself accurately.

Thanks and have a great day guys.

That seemed to help because I immediately got the following response:

Hey Dwayne,

Thanks for the followup. We can see from the links that you really enjoy learning and care about code quality. We would like to schedule a pairing session some time next week. When is it a good time for you?

Have a nice weekend.

On October 10th, 2013 (my girlfriend's birthday) I had the pairing session which ended up taking the entire day. It was worth it at that point because it eventually (I'm skipping a ton of stuff because after all that I still had a lot more convinving to do, for e.g. Tor wasn't convinced of my ability to ship high quality working products) led to me being offered an opportunity to work with them for a week at their New York office (initially it was supposed to be London but Tor was visiting the New York office for Christmas so that was the better option for them).

Preparing to Leave My Current Employer

Since everything seemed to be going well with AlphaSights I decided it was time to let my management at Caribbean Ideas (Cordell, Brevard and Chike) know that I started looking for other opportunities and that I may be leaving them soon. They were very supportive and even offered to help me in anyway they could.

1-Week In-Person Interview

Oliver and I communicated back and forth and we arranged an Airbnb for me to stay at for my one week in-person interview from November 30th, 2013 to December 7th, 2013. It ended up being a great experience in many ways:

First time travelling to a foreign country on my own

First Christmas in New York

First Ice Hockey match

First time going to Madison Square Gardens

First time staying at an Airbnb

I got to work with talented individuals (Tor and Damon mostly)

And, I got to work on a couple interesting projects

The Rejection

However, as we come to the end of the backstory, it just was not meant to be. At this point I had invested almost 4 months of my time, energy and headspace to be greeted in the New Year of 2014 with this lovely email on January 13th (and no, it wasn't a Friday).

Hi Dwayne,

Happy new year! It has been a while so I wanted to get in touch with an update so you know where we stand. It was great to have you with us in NY, I am happy that we managed to organize the trip.

The work you produced whilst you were with us was of good quality. However, this is not the only criteria we use when evaluating a candidate. Team fit and alignment with company culture is also important, and on this dimension I am sorry to report that we were not convinced that we would be the best company for you. I have therefore decided not to progress any further with your application.

I hope you still enjoyed the trip on it's own merits, and I want to wish you the very best of luck in the future. I hope I get a chance to visit Trinidad some time in the future.

Tor

Out of Service

I was derailed (no pun intended) and I took a break from active job hunting for quite a while (6 -7 months). But in my heart I was still determined, more than ever, to improve my situation.

To be continued

Happy hacking!

I recently found out that I can pretty print JSON in the Chrome console using JSON.stringify simply by specifying some extra parameters.

Prior to this revelation, i.e. before I knew about these extra paramters, I would use JSON.stringify to get the object's JSON representation and then copy and paste the result into JSON Pretty Print.

Now I can do

JSON.stringify(obj, null, 2) // or JSON.stringify(obj, null, '\t')

without ever leaving the console. Hooray!!!

References

Annotated ES5 - stringify

MDN - JSON.stringify()

Happy hacking!