Okay quick, so I don't forget, watches.

So you can create expressions that constantly stay bookmarked, so

let's do that over here.

Okay, so I'm gonna click our cardCounts variable that we determined up here,

it was so important.

And I'm gonna right click it, I'm going to choose Add to Watches and

it adds a little glasses like on here with cardCounts.

There's a way that you can make a separate panel.

I like this version a little bit better.

They made it so that you can have more space but

I'm gonna click this and now you'll see that there are separate,

you got Variables and Watches as two separate things.

One of my favorite things about these watches is that they stick across frames.

So for instance, we're basically done with our current frame right?

We're gonna return this value and the frame is gonna be popped from the stack.

Are we ready?

Boom, and now we're back where we started.

Now notice our current execution point,

we haven't set the cardCounts variable yet and that's why this right here can't find

the local variable cardCounts because it doesn't exist yet,

so I'm gonna go ahead and step over and now that it exists, look it's stuck there.

So we can see know that there is the cardCounts value here and

it's the cardCounts values here as well but it's also showing over in our

Watches because we're remembering that that's what we wanna watch.

There could be tons of variables there but one thing I wanna point out is that

the reason why this is working is because the name is the same, okay?

So we're watching in expression called cardCounts.

Okay, so let's step in to our next method here which is getNextFlashCardBasedOnViews

and we're gonna pass in the object reference cardCounts.

Okay, so here we go.

So we'll step in and here, uh-oh,

it says cardCounts can't find the local variable cardCounts.

And that's because it's been changed.

It's called idToViewCounts, it's more specific, okay?

So, well, that actually helps a little bit, right?

So that's helping me understand what this is.

So its id must be the key and

the value must be how many times a card's been viewed.

That's my current assumption at least.

So what now though?

Our watch isn't picking up this value in the current frame.

Now I could, of course, add another watch super easily, right?

Like I could just right click that, choose Add to Watches, it's there, and

then if I switch between the frames here, when I'm looking at this,

this one can't find the variable and when I look at the other one,

it can't find the cardCounts, fixes the problem more or less, right?

That's probably enough for most situations, but there's a pretty nice work

around that we can use if you don't mind going on a slight detour with me.

Okay, so there's a trick, right?

It's possible that you can label or mark objects.

So the usage of labeling is for various reasons.

Maybe we don't like the way a variable's named or

we want to add specific metadata about that object specifically.

Or in our case, we want to see when it's pointing to the same object.

So when you mark an object,

you're marking the object, not the name, not the expression of it.

Okay, so we can do that.

So lets, you right-click and choose Mark Object and you choose a Label.

Now, we know what we're talking about, right?

We know it's card counts and we know that it's this idToViewCounts.

So let's call it counts because that's what we wanna see.

So now, see when I go back and

forth between the frames, the counts sticks, right?

So the counts is labelled there.

It's also labelled in our watch over here.

See that?

So the awesome trick is that you can actually watch

a label not the variable name.

You can make it be an expression, right?

So let's go ahead, let's remove our watches, you can do that,

you can press backspace or

down here, underneath this, you can press the minus key.

All right, so we're gonna add a new watch and

watches can basically be any expression.

So, I'm gonna say counts and

then intelligent was nice enough to expose them.

So, I can say DebugLabel, right?

And if I press Enter, now it's watching counts.

So anything that counts it, so I'm both,

there's one watch across multiple variables and it's using this count.

Cool, right?

The fact that you can add any sort of expression there is super powerful,

you can put whatever in there and

it will keep evaluating kind of like a spreadsheet cell.

So back to our originally scheduled program.

So we're just about ready to call this method, right,

this method is getNextUnseenFlashCard and we're gonna pass in our

idtoViewCounts.keyset which at the moment remember that was empty, right?

We're looking down here.

This counts object is empty.

So there are no keys, so it's going to return an empty set.

So what's gonna happen, terminology wise, when I step into this method call?

Can you recall the terms?

What's gonna happen?

That's right, it's going to push a new frame onto the stack for

this specific method call.

Okay, so yeah look at this.

The parameter name is seenIds and we've passed in the keys of that ID to count.

So I'm fairly certain that my assumption was correct, our accounts label here is

a map of IDs to the number of times that things were viewed, cool.

So let's walk this logic.

Okay, so there's no IDs at all yet as we haven't seen anything,

it just returns a list of all of them,

right, so yup, there's no seen so it's gonna turn all of them.

So unseen here should be every card, right?

Remember there's 8 cards.

Okay, and since there is no unseen, we're gonna go ahead and

come in here and it's gonna pull out a random card.

So I can just go ahead and like we saw before,

I can highlight this and we'll see that it's gonna pull out a number, right?

It's gonna pull out an index between zero and whatever the number is.

So if I do this, if I highlight all this, this should give us a random card.

Yeah, so there so I ran that expression and

pulled out a random card, pulled randomly the first time of all that you're gonna

need because it created a new random and it was somewhere in between zero and

the top of the array, so that's how you pull something random, cool.

So I'm gonna step over to that, and

the card that we got pulled out is Java EE Enterprise Edition.

Okay, so that card got pulled out.

So now our frame is gonna pop off the stack and

it's gonna return to the getNextFlashCardBasedOnViews.

Since we have one, I'm sorry getNextUnseenFlashCards, so

there was one that was unseen, so we're gonna make sure that we show that.

So that returns a card and that pops off and we're in the last one here,

and so we do have a card and we're gonna return redirect link.

And if you accidentally click step over like I did right there,

you'll be dropped into the magic of what's going on.

It will give you some great experience in how amazing

this open source stuff is that we're using because of all this code that's right

there no matter what we're thinking about but if you don't want to sit there and

spend the time walking through it, you just press this Continue button.

Now if we look back over, we'll see our Java EE.

So let's just finish the flow once through just to feel a sense of accomplishment.

Okay, so let's see what happens.

So it generated flash card ID which is mapped here so

let's drop this, we're gonna go ahead and call next.

And here we are we're stopped and now we'll see that our counts as a size of 1

and 5, I'm assuming must be the ID of the Java EE,

right, so it's calling getcardCounts, right,

cuz we have a breakpoint in our getcardCounts up here.

So it's calling that and it's gonna get it out of the session.

Cool, so Java EE has been seen once, right?

And so we're gonna return the card counts.

Step over that.

Okay, so what is this doing?

This is Java 8 new map compute function, okay?

So what that does is it takes a key and a remapping function.

So let's suppose that we wanted to break into this lambda right here to see

actually what is this doing so I'm going to click right here.

And you'll see that I get a choice between the lambda and

the line itself, so I'm gonna use the lambda and

I'm gonna click the run and now we're actually in here, okay?

So we're here, so the key, I got passed in is 4 which must be the new cad that

we're looking at, must have the idea 4 and it hasn't been seen yet before.

Okay, so what it's gonna do is, it's gonna say, if it is null, which it is,

it's gonna be 1.

Otherwise, it's gonna increment, cool.

So it will increment if it exists, and then if we continue out of this,

we'll see that the card gets pushed in the template so

the second was Java SE and it was seen one time.

Awesome, and let's click Next one more time and we'll see that our cardCount

has now has 4 which is that idea we saw and 5 and they both of you at one time.

Cool, all right.

So now that we've got the basic idea for the flow, let's take a quick break.

I'm gonna go jog around my yard real quick and get my brain working.

I find it's good to take breaks and let all that we just learned about the way

that our app is working kind of work its way into our brains.

Then when we're refreshed, let's go grab another one of those issues.