Now, Code Racer is a very complex project,

and that means we don't have time to do all of the different parts

of Code Racer in these videos.

But what we will do is create a project that has the major components of Code Racer

and see how to build it piece by piece with Node.js,

Express, and Socket.io.

Let's get started.

[? Music ?]

The first thing that we need to do on this project is create

a basic skeleton application.

This will be the application that we're going to get running

as fast as possible so that

the developers have something to work off of

as well as having the designers be able to create the templates

directly in the application.

Now, it's going to be a little while before we actually need to integrate

the designs from the designers into our real application.

But the sooner we get the environment for them to actually code

real-live templates in, the better, so that's what we want to do right now

is get a basic Node server up and running

and some basic templates that our designers can work with

and experiment with.

[nodejs.org]

The main technologies we're going to be working with are Node.js,

and to install this, we'll just go to nodejs.org,

and we can use the Macintosh installer.

I've actually installed it via Homebrew,

which is the package manager, which you can read about down here.

But any of these options will get a Node installation up and running fairly quickly.

So, we can see that I've installed it, and we can actually check on our Node version

by typing in "node -v."

And we'll see we're running 0.6.7, which is a fairly recent release for us.

Now obviously, depending on when you download and install Node,

you'll get a different version, but 0.6.7 is what we'll be using right now.

So notice the programming environment we'll be using,

but we'll also be using another tool called NPM,

and as of now, NPM is actually installed alongside of Node,

so if we type in "npm -v" we'll see we get

an NPM version of 1.1.0-beta-10.

NPM is the tool we'll be using to manage the dependencies in our projects

to bring in outside libraries as well as to manage the version of those libraries

and even just keep track of the meta information of our application.

You can learn more at npmjs.org.

We'll also be working in CoffeeScript, which is a small language

built on top of JavaScript that compiles to JavaScript.

It has much of the same semantics but a slightly different syntax.

Typically, CoffeeScript tends to be a little bit smaller

in the amount of characters used to express certain objects.

If you want to learn more about CoffeeScript and the type of JavaScript it creates,

you can learn more at coffeescript.org.

We'll be using a couple of libraries as we go along.

The first one we're going to encounter is called Express,

and this is a small web application framework for Node.js

that allows us to easily create different pages

and some different interactions on our site.

A little bit later on we'll be learning about Socket.io or Socket IO,

which is a library for using web sockets.

And this will allow us to create an application

that runs in sort of real time,

meaning that the server can actually push data down to each of the players

so all of them can keep their state in sync.

As one player does one thing, it will be communicated instantly

to all of the other players, which is what we want for our game.

This is the main reason we're choosing Node.js for our game application

because the support for sockets in Socket.io is pretty good.

The architecture of Node lends itself well to using sockets,

which require a lot of connections to be left open at once,

even though they're going to be mostly idle.

This is where the event-based Node.js is the strongest.

What I have right now is an empty folder called Code Racer,

and this is where all of our code will be, and I have a terminal window open

to that directory.

I also have my editor looking at this directory right here.

This is our Code Racer directory, and right now there is nothing in it.

The first thing I want to do is set up our project.

Now, there's actually a couple of dependencies I want to install

globally on my system via NPM.

These 2 packages are CoffeeScript, which obviously allows us

to run CoffeeScript files directly, and Supervisor,

which is a way for us to run our application,

but any time the application crashes, Supervisor will restart it.

Also, any time we save a file, Supervisor will again restart our application.

This is great for development since you can simply save a file

and immediately go to your server without having to stop and start your server

to reload your code changes.

We're going to install Supervisor and CoffeeScript via NPM.

I'm going to type "npm install coffee-script"

as well as "supervisor."

And I'm going to pass it the -g flag for global.

This will install it to our global environment

instead of installing it as a dependency of this particular application.

We got a little bit of an error here, and that's because

the way this computer is set up, we don't have the permissions

in the right place for us to simply run this command,

so instead I'll have to write "sudo,"

and I'm going to use ! ! to run sudo on the last application.

And when I hit Enter here, you can see that my shell has brought up

"sudo npm install coffee-script supervisor -g."

When I hit Enter, we'll now run it with sudo,

which will actually run it as a privileged user,

which means we should be able to install into the directories

that we didn't have access to as our normal user.

I'll just type in my password,

and everything is running just fine.

If I type in "coffee -v," you can see we have a CoffeeScript version,

so that means we have installed it properly.

The next step for us is to initialize a new NPM package.

This will allow us to declare the dependencies for our application

and manage its version through NPM.

This is very easy to do.

We'll type in "npm init,"

and now it's going to interactively prompt us for some information.

Right now we'll call our package name Code Racer.

We'll say its description is "An awesome game."

And all of this stuff besides the package name is optional

and not really necessary for us to worry about right now.

We'll just enter through it.

It confirms "Is this okay?"

We'll say yes.

And now if we go to our editor here,

we'll see there is now a package.json file,

and our package.json file includes the information

that we just put in through the interactive prompt.

But what we're going to be worrying about here is

the dependencies object here, and this is where we'll be defining

the dependencies that we're going to be using in our application.

For instance, things like Express.

The way we define our dependencies is

we will give it key value pairs where a key

is the name of the package we want to use

and the value is going to be a version string.

Right now, I want to include CoffeeScript

since we'll be writing our project in CoffeeScript.

So write "coffee-script,"

and for its version string, I'm just going to use * for right now

because I don't know what the latest version of CoffeeScript is.

However, later on we'll put a more specific version number in here

to lock it down so we have a little bit more control

over what version of each package is compatible

with our Code Racer package.

And the next one I'm going to want to do is to install Express.

And that's just using Express, and again,

we'll use the wild card version here.

We'll be coming back to this file every time we need a new dependency

for our application, but let's just save this right now.

So, our NPM command will always be working off of this package.json file.

We saw how to use the npm init command to

create our package.json, but we'll see another command

called install.

We'll type in "npm install."

And what this will do is it will read the package.json file,

grab all the packages and install them

into a local directory called "node modules."

So, if we hit Enter, we can see it's going out to get some information,

grab our packages, and this will include

all of the sub dependencies of our packages.

For instance, Express itself depends on qs, mime, mkdirp and connect.

NPM manages all those dependencies for us

and makes them available in our project.

So, if we were to go into our editor here,

we'll see we have a new directory called "node_modules."

And this is where all of our modules have been installed.

The way Node works when looking for dependencies

when we use the require statement is it will try to find

Node modules folders in the directory that it's executing in.

Otherwise it will try to find any globally installed modules,

like we had globally installed CoffeeScript,

and then it will fail if it can't find those packages in any of those directories.

Let's create what will be our server file.

We'll create a new file, and I'm going to save it

as server.coffee.

And I'm going to just change our indentation here to 2 spaces.

Let's just do a very simple file, and let's just create a Hello world file

for our server.coffee right now.

What we'll do is console.log "Hello."

And let's go to our terminal and see if we can run this file.