All right, so let's get working on this next issue here.

So, first actually look before I gotta close this, so

we can open up this, this one we should always close.

It feels so good to close issues.

Let's go back and look at the issues.

Now, it's only five and the next one that's open is the counting gets

bogus after every card has been viewed once.

Since we asked for the cards to be spread out evenly, but

strange things are afoot on the card page.

The steps to reproduce, look at all the cards once and

watch the numbers of viewed jump around.

Cards are seen multiple times before all of the cards are seen for the second time.

We want equality.

Gotcha, okay, let's go ahead.

Let's restart the server and make sure that we know what that's talk about.

I wanna go ahead and I wanna mute all these break points,

I wanna restart the debugger.

And one thing that we need to do is we need to make sure that we

approach this like we're a new user each time.

And something I can get a little hard to do.

One thing that you can do,

a nice trick is, the sessions that we're using are cookie-based, right?

So I'm gonna open up the Chrome toolbar here, I'm gonna go under Resources.

And I'm gonna go under Cookies, I'm gonna go under localhost.

I'm gonna delete this JSESSIONID.

So that's one way to make a brand new session appear.

So now this person has only seen that one time.

So we keep clicking next, two, three, four, five, six,

seven and I wanna try to pause it before we see him again.

So set, it was at eight.

Shoot, I missed it.

Shoot.

Whoa, look at that, yes, you see there going up and over and around and we're.

Okay, so I don't wanna have to count each time as you saw,

I’m not very good at that.

So what we want to do is take a look at our current breakpoints, so

let's take a look.

We don't really need that one anymore as we know what the card counts are.

We don't need to know what happens in the showFlashCard.

We're kind of interested in what happens when the showNextFlashCard happens, right?

So you wanna come here and let's undo the muting.

Now we don't want this to stop every time, right, cuz it's just gonna stop or

after I click play and then stop and click play and stop and click play.

It would be really nice if we can make it just stop when there is eight, right?

So that's like a condition.

So check this out.

So I'm gonna right-click and in the condition here,

we're gonna choose, we want when there's eight, right?

So when cardCounts, sorry, let's do that.

We're in the wrong line here.

We need to get have a hold of cardCounts first, so we're gonna come here.

The condition is cardCounts.size is greater than or equal to 8.

Every time it's past that, we'll stop.

That should work, right?

So we'll drop that there.

Let's go ahead, we'll kill this cookie.

We'll be like a brand new user.

And I should be able to.

Hm.

The condition didn't stick?

Yeah, the condition didn't stick.

That happens sometimes.

CardCounts greater than or equal to 8.

Sorry, that didn't go away.

That one, okay.

That's what was happening.

Okay, so keep going, keep going and

it should stop as soon as I think it's this one yeah, awesome.

So did you see that?

It went up to eight and then it stopped.

So that's super handy when you have something that needs to process a certain

amount of times and you want to stop only then.

Or if you only want it to happen when it's this one specific card of the specific

thing, that's a nice feature to have.

So let's go ahead and make sure that our object is marked as counts still.

If we take a look, we've got eight views here and look,

every single one of the ids has been viewed once, perfect.

Okay, I am ready to step in and find our bug cuz as we know,

we saw it's not working, right, so let's do that.

So let's step in, okay, so it's gonna find,

get the next unseen flash card and we've seen a mole.

So there should be nothing that comes back, right, cool.

So nothing came back.

So if the cards not equal in all.

Okay, so now we're in some new code here in some new territory.

Boy, there are some continues and breaks at play.

If you haven't seen these before, they are known to make some squirrelly logic and

sometimes infinite loop.

So let's run it until we hit one and then we'll discuss.

Okay, so we're gonna initialize a leastViewedId,

we're gonna loop through each of the entries.

So remember the key of that is the id and

the value is the how many times has been viewed.

Okay, so if leastViewedid is equal to null, which it is.

Okay, cuz it was instantiated outside of here.

We're gonna come in and we're gonna set the key which was 1.

We're gonna set the leastViewedId to that.

I guess just set it to something, right?

Okay, and here's the continue keyword.

Okay, so in loops what this does is it allows you to say go ahead and

skip all the remaining code down here.

And just come back up to the top, right?

Come back up to the top of the for loop, the rest of this code will not run.

There's some more in the teacher's notes, but let's go ahead, let's step over this.

We're gonna step into the continue, watch what happens.

Boom!

It pop right back up to the for loop.

And we're on the next iteration of it, we have the next entry.

Okay, so, this time leastViewedId is set, okay?

And then we're gonna come in, we're gonna say,

we're gonna pull out what the lowest score is based on what the leastViewedId is.

So, it's gonna get the leastViewedId.

And the idToViewCounts, it's gonna pull up the smallest card there, okay?

Okay, so the lowest score is one and it's gonna say if the current entry,

the entry id 2 is greater than or equal to the lowest score.

Now are equal cuz they're both one, it's gonna come in and it's gonna say break.

So what break does is it breaks out of the current loop, okay?

So when this line is hit, will exit out of the for loop.

No matter what's happening and

it's aptly named to use of break often breaks your code.

So some people claim that you shouldn't use continues and

breaks because it creates easy to miss logic mistakes.

So watch what happens here when I click step over.

So I'm gonna run this break statement, we're inside of the for loop.

We're not finished processing everything and there was a quick step over and

see how it popped out of the for loop.

And now we're gonna return the card that has the leastViewedId which was one.

Wait a second though, how could we be certain that this was the leastViewedId,

we didn't look at all of them.

That seems fishy.

I'd love to be able to go back in time and watch that flow one more time.

Well, guess what, there's a pretty good trick that is handy for times like this.

You can actually drop of this frame, so it'll be kind of like it never happened.

Now I say kind of because the code in frame could have

in fact change some global state.

But we just walked this code and nothing changed the global state,

nothing came outside of this.

So what do you say we go back in time,

now instead of walking into say a telephone booth.

We can just come here and click this, this drops the current frame, okay?

So, when I click it and boom, it's like nothing happened.

So we can again step into it and we'll be at the top again.

So, let's go ahead and let's put our cursor right here and

we'll say it run to cursor.

Cool, it's like we were never here before.

Most excellent.

Okay, so let's think this through once more.

If the views are greater than or equal to the lowest score,

then [LAUGH] we don't wanna break here, we wanna continue.

We don't wanna break out, we wanna say if it's greater than that,

we wanted to go again and find the next one, right?

So really what this is saying instead of using control flow logic.

Why don't we bump this into the if here.

We move this up and

change the logic, right?

So if the value is less than the lowest score, then it's the leastViewedId, cool.

So let's go ahead and let's restart.

Let's move this up, let's mute the breakpoints.

And if we come over here, I delete the session, cool, we'll click Next.

There they go, they're all even, awesome.

So it was just a little logic flow there.

We should do, we should make a new branch, right?

Cuz we just made some changes to the code and it's working.

So let's come back to our code here and we'll make a new branch.

And let's call this one strange-counting.

Yeah, well let's stick with the theme here, let's say bogus-counting.

That's what it said on the ticket, bogus-counting.

Okay, and let's go ahead and

let's commit and once let's take a look at our version control.

And we got some local changes, we want to commit this guy.

And let's say fixes number,

what is she was there, five.

Fixes #5 by making the cards displayed more standard.

And I'll go ahead and Commit and Push.

I'm gonna push bogus-counting up.

Okay, and so if I flip over to GitHub and I take a look here.

We'll see that I push the new branch.

I'm gonna go ahead and make a new pull request for my teammates.

I'm gonna make sure that I'm going into a mine and not the master one here.

So fixes number five by making the cards displayed more standard, that sounds good.

I think I wanna let you know here,

I was gonna say fixed the breakage by

removing the break, most excellent.

Okay, so when I go to create the pull request, you of course we'll take this,

look at it.

Think, all right and you click Merge pull request.

And you're gonna confirm the merge.

There we go.

So now, master is up to date and

one thing that you might wanna do is we can delete old branches.

So I'm gonna click this Delete branch, there we go.

I just realized that there are situations that you're dropped into where you don't

fully understand what's going on.

Either at the library or at the framework level.

Now we're currently in a spring boot application and

that might be familiar to you.

But let's assume just for a second that it wasn't.

Since spring uses a lot of dependency injection, you might be totally confused

as to [LAUGH] how some of these things are working.

For instance, if we come back to this file here,

this is probably super confusing, right?

How is this flashCardRepository here, how is this getting sent even?

So one thing that I wanted to show you,

because of the dependency injection that Spring uses, it might not be clear at all.

So one thing that you can do is you can come here and you can click this.

And in our Debug window here we must have these muted.

So we come in here and I'm gonna right-click this and

I'm gonna click Field access and Field modification will be done.

And what will happen then is every time somebody sets this or

accesses this it will come in.

So, let's go ahead and do that.

I'm gonna restart the debugger and

just assume that you didn't know where that was coming from.

Well, you didn't know how this worked.

So boom, right away this got kicked off and here the setFlashCardRepository.

And if you took a look at what was happening, you might be able to navigate

down here and find AutowiredAnnotationBeanPostProcessor.

So if you come back here and you look, you could see, look,

this is marked with Autowired.

And maybe you could start learning how that works.

So, okay, interesting.

Anyway I was just trying to show off kind of simulate how you can find things

that you're not sure exactly what's happening.

It helps you kind of explore what the framework is doing for you.

Okay, so let's take a break and why don't you imagine what it'd be like to demo our

changes that we just made to our client.

And then let's pick up in the next video with their imaginary feedback.

Sound good?