We've talked about bugs or errors in our code in the past, but

we've never really talked about where that term came from.

It's a bit of lore these days, but back in 1946,

Grace Hopper was having some problems with a program she was running on the Mark Two.

After trying to figure out the flaw in her code for a while,

she found a moth trapped in the relay.

Once the bug was removed, the program worked correctly.

[SOUND] The program was properly debugged.

In most of today's popular programming languages,

there are tools that are provided to assist the the removal of bugs.

They are called debuggers, and they give you a better

overall understanding of how the code is actually working.

Let's go learn some bug extermination tricks.

Okay, so the first tool I'd like to use to introduce you to your debugger

is something called breakpoints.

Now it's possible to tell the code to pause at a certain line, and

you can do this with what is known as a code breakpoint.

Adding breakpoints is simple,

you just click the side of the editor over here where you want it to stop.

This area is called the gutter, so I was thinking we could insight this

karaoke machine run method, we'll stop on this line where it prompts for

the action, before we prompt for the action.

So I just clicked over here in this gutter, and

I clicked and it added a little stop sign here which is a break point.

And so under the run menu there is an option to debug your

current configuration.

So I'm going to do that, I'm going to choose debug karaoke and that's

gonna pop up the debugger, and notice how the line is now highlighted in blue.

That's the way of letting us know that we are paused here, it's suspended.

So, you'll see there's a debugger tab down here on the bottom and

over here under frames, what it's doing is it's showing us how we got there.

So this is the stack of code.

You've probably seen these in the stack traces, right?

So, right now we're in run in karaoke machine, but we got there from here,

from main.

So if I click onto main, you'll see that it's flipped to the proper file and

it's showing me highlighted there in blue, of how we got in there.

So it's kinda a good way of oh, how did we get here?

And kinda trace your steps back up, walk up the stack.

So from here we can do a couple of things.

We can move line by line or we can dive deeper into the code.

Let's do a deeper dive first.

So, let's say that I wanted to look at this promptAction method

that's here, right?

So I can come down here and I can choose the step into method.

It's an arrow pointing, so step into, and that's F7, so

what that's going to do is that's going to go into the definition of prompt action

on the karaoke machine file, right?

So, we've now stepped in to this code.

Cool, so now you'll see that we're inside the prompt action method definition and

we're still suspended.

And you'll see over here in the frames,

you'll see that we're now in prompt action from run from main.

So there's our stack, we're all the way down into prompt action.

And you can also see in the view over here that we have access to these variables.

So, if we look at this here's the mSong book that's private to the karaoke machine

and it has a private variable that mSongbook does called mSongs.

And we can open those up and we can take a look at the different songs and

we can keep on drilling down.

It's pretty cool, right?

So, we're paused on this line here, and if we step into this one,

so it's a single line that's on multiple lines, but

it's one line of code that's just spaced out better.

So if we step into this we're going to go and do the getSongCount on the SongBook.

So let's do that.

So now over here we're in the getSongCount from promptAction from run from main.

So in getSongCount,

if we press the step into you might think that it's going to do the size but we're

going to be blocked cuz we're really only concerned with what our code is, right?

So it jumped back out because it returned that value.

If you wanted to step in the code, this red one here,

this Force Step Into, this will actually go into the Java code.

We're not gonna do that right now, but

I just want to let you know that that's available.

If you wanted to go do some more exploring of what the Java API's are actually doing,

cuz most of them are going to show you Java code and

you can kind of walk through and see what things are doing.

And this is a great way to explore the APIs and

demystify what's actually happening.

Okay, so let's just go ahead and step into this for loop, here.

Oh, so now it's gonna run the line where it does the print.

Okay, so I'm gonna go ahead and I'm gonna quick step into, one more time, and

we're gonna step into the for loop.

And so now remember what this loop is doing is its looping through

each of the menu options we have and its setting the variable option for each loop.

So, now we can look at this first one is add, and so

lets just go ahead and we'll step into it step into it.

And you'll see as you move it puts the value of whats going on over there.

It's pretty cool.

So, we'll step into that.

Okay cool, so now we're on the next one.

Here which should give us play, which is the next option on there.

So, okay, so we kind of understand what this is doing, right?

So, we don't need to watch the whole for loop go through, so

what we could do is we could put our cursor outside and this function here.

Run to cursor will make the code all run until we get to there.

Cool, right?

So now we're still paused inside of the prompt action, but

we jump through that for loop and all that code ran.

But we didn't need to step and watch each one of them.

So, we can also step out of methods and go back to the frame where we started, okay?

So, that's this arrow, of course, the one stepping up and that's called Step Out and

that's Shift F8 to get out.

So, we're just gonna go up the stack.

Okay, and now it looks like it paused so there's no frames that are available.

So, What's going on?

Oh, that's right.

Prompt action, right here, this line called read line.

It's waiting for us to answer the action.

So, let's go ahead, and let's say choose.

That's the thing that we wanna do from the menu, we wanna choose to sing a song.

Cool, okay.

Now bam. Now we're back, and

the debugger's stopped.

We're back in run, we're at this choice line here.

Cool, so let's just go ahead and let's step here and again,

so now we typed in the choice to be choose, so we're on the switch statement,

so let's go ahead and let's step into this choose statement.

Okay, so we just wrote this prompt for singer name.

I don't really want to see how it works, so

the next feature is here, there's this step over, and that's F8.

Okay, so if I press F8, it's gonna step over that, and

it looks like again like it paused.

Oh, that's right it's prompting, so I'm gonna flip over to the console, I'm gonna

enter the singer's name which is me, and now I'm gonna go back to the debugger.

Oh there, okay we're stopped.

I'm gonna press F8 again, stopped again, it's prompting for the artist.

All right, let's say Wilson Phillips, what do you say?

Okay, so I think I pressed enter without pressing nine.

All right, so let's come back.

Let's undo this break point, and let's do this break point.

Okay, so we're gonna get right to here.

Actually, let's get to the point where we ask for the song, okay?

So we can continue through and let it stop, okay?

So I'm gonna start that again.

So up here, on the debugger, there's karaoke play,

there's also a little debug icon here, so I can click this.

Okay, so what do you wanna do?

We wanna choose a song.

It's me, I wanna to listen to some Wilson Phillips, boom and it's stopped.

Awesome, right?

Okay, so let's step over the prompts song for artists and

again flip over to the counsel, let's hold on for one more day.

So, now we're at the song request.

Let's go ahead and step over that.

It's going to build a the new song request object.

Okay, awesome.

So, in our debugger we have this song request.

And I want to show you a little tool that's a lot like the ripple that we saw

that we can use to run our own code.

So if you choose run and then you choose evaluate expression.

Okay, so option F8.

You can actually run some codes.

So, remember what we were looking at here is we're looking at song requests.

Right, so if we say song, oh look at that, it auto completes here too.

Song request, type in singer name.

It will run and this is the result that came back.

So, that's very similar to the ripple that we were using, right?

So we can actually even change the state here in the program.

So, that's also a nice fun feature.

So I'm going to go ahead and I'm gonna redefine what song request is, okay?

So remember we're stopped on this line here so

I'm gonna say songRequest = new SongRequest.

Once actually sign Ben up to sing that, right?

He'd probably sing that one really good.

Okay, so I'm going to press enter, and bam, so it got set.

Okay, so now I come back here and I look at song request,

Ben is the singer, even though the singer name that I said before was.

So, it's kinda cool, so you kind of punch variables into different situations if

you're trying to catch a certain thing in there.

Okay, so we can press the button over here to resume program execution.

Okay, and that's gonna keep on going and we're stuck here at the console again.

So if we did choose, we'll sing another one.

This time let's sing The Cure.

Okay, bam. So it stopped again.

So it'll keep on going.

So you can also toggle these on and

off using the Cmd+F8 key, will toggle the breakpoint on and off.

Or Ctrl+F8 on Windows.

So now when I press resume, it will keep going and not stop.

Cool, welcome to your debugger.

Okay, so that's a nice basic introduction to some of the key concepts

of the powerful debugger tool.

This is one of those things that most of the popular IDE's have and

they all kind of work the same way.

It is possible to have the debugger kick in when specific exceptions are thrown.

As you can imagine, this is super handy.

It's also possible to launch it when certain conditions are met,

even when fields are set or accessed.

I've added some notes on where to learn more of this.

Check below in the teacher's notes.

It's a little out of the scope of this course, but

I'd love to dive deeper into more advanced features in an upcoming workshop.

Let's take a look at how to work with a team using Intelliga,

right after this exercise