An essential tool for developing node applications is Iron Node.

Iron Node let's us interactively debug applications in the browser

while the node application is running.

In this video, we'll install Iron Node and get set up with some basic usage.

To install Iron Node, we'll use npm with a -g flag.

This is because we want to install iron-node globally and

not in our node modules folder.

By installing it globally, we can use it for any node application on our machine.

When it comes to actually debugging applications,

break points are the core aspect of how you'll do it.

In Iron Node, there are two ways to set break points.

The first way is by writing a permanent break point into your application code.

And that looks like this.

Just writing in the debugger statement.

Now the way we'll use iron-node is just like we would use the node command, so

here I'll write iron-node instead of node, and then I'll provide a path to my server.

Iron-node launches our app and we can start setting break points.

Now when I refresh the page Iron Node stops at my debugger statement.

Now I'm also going to set a debugger statement in our API index.js file.

And notice.

I can actually edit this code right inside of Iron Node.

Now it's up to you how much editing you want to do directly in Iron Node.

I know for me I tend to use a text editor to do all of my heavy duty editing

because there's extra tools but

it's perfectly fine to make minor edits to your code directly in Iron Node.

Now I save the file.

I hit my first debugger statement.

I press play.

Now my server's actually running.

Now when I visit my landing page, the get request is run.

Notice my to dos haven't shown up.

And that's because the debugger stop in the middle of my get request.

Notice one other thing they're actually two versions of your files loaded

into Iron Node.

This version of the file is loaded into memory,

actually allows you interactively set break points.

And these are called temporary break points on the lines.

I can set these break points on any line.

And I can also turn them off and turn them on, or

turn all of them off, or turn all of them on at once.

Notice that the file was automatically loaded, when a debugger statement was hit.

The other way to manually load one of these files into memory, inside of

Iron Node, is with the Cmd+P function, and then you can search for your file.

So in our case let's pretend app.js wasn't loaded yet.

Type in app.js, okay there's a lot of files,

Type in, sourceapp.js, okay there's still a lot of files but notice that

the top two files match what I'm typing the second file here is your source file.

The first file here,

where it says no domain means that its been loaded into memory.

And so you can interactively set break points in this file.

So again, notice that this is wrapped with a few

different parameters friendly for Iron Node.

Then my actual source file looks just like we've written it.

And if you want to easily get back to your break point, you can go to the call stack.

You can actually click on anything that is being run.

This is our express back end here.

We are only going to debug our source code.

The magic of debugging is that any time

I'm stopped a break point I can actually hover over a variable.

To see what that variable is assigned to.

Here I see my to do objects.

I can also look at the local variables, the variables inside

of this given closure, as well as my global variables.

There's always going to be quite a few global variables.

And the final way to work with variables locally is actually in your console,

I can type in the to dos variable in our console.

I can actually type in the response or the request object as well to explore it.

And I can even run functions if I wanted to.

To manually set the status here to response using the console is

incredibly powerful, allowing you to interactively explore your

application as if you're inside the JavaScript interpreter.

Now to stop Iron Node, all you do is go back to the command line and hit CTRL+C.

That stops Iron Node, closes the debugger application.

And of course, running your application again everything is back to normal.

Now you know the basics of debugging a node application.

Next, we'll configure our API to use the to do model.