One way that blocks are really useful is performing functionality or

running code before and after a block is executed.

This turns out to be really great for writing something like a benchmarker.

We're going to write a simple one now, and here's how we're gonna do it.

First, we'll create a class for our benchmarker.

The class will have one method called run.

The run method will take a block.

We'll take the current time before the block of code is run and

store it in a variable.

Then we'll run the block, and

store the current time after the block of code is executed.

From there, we only need to subtract the end time from the start time and

print the result.

Go ahead and give it a try now.

And then come back and take a look to see how I did.

And here's a hint.

You can use the method time.now to get the current time.

Okay, so let's go ahead and build our SimpleBenchmarker class.

Now we're going to use a new part of the standard library that we haven't used

before, called the Time class.

And Time is pretty interesting.

Now, that's not a metaphor, I mean the actual Time class.

We're only really interested in one particular method from the Time class.

And let's go ahead and scroll down here.

We're looking at the now method,

which creates a new Time object for the current time.

Let's go ahead and see how that works in irb, before we start coding our class.

And just see how that works real quick.

We call Time.now, and it returns the current time.

So this is something that we're going to use in our SimpleBenchmarker class.

So we're going to create a new file and call it simple_benchmarker.rb.

And that opens it up for us.

So now we can create our SimpleBenchmarker class.

And we're going to create a method called run.

And that's gonna take a block.

And what it's gonna do is run this block of code, and

then print out the time it took to run that code.

So we can do that by saying yield or block.call.

We'll just use block.call here.

No real reason behind that, just something that we're gonna do.

And let's go ahead and get the start_time before we call the block, and

the end_time after the block is called.

So once we do that, we have the end_time and the start_time.

All we need to do is subtract the two, and we'll know the elapsed time.

So we can just say elapsed is the end_time minus the start_time.

And let's go ahead, And print out how long elapsed.

There we go, this is our SimpleBenchmarker.

So how do we run this?

Well, we'll have to instantiate the class and assign it to a variable.

And now we can say benchmarker.run.

Now, anything we do in here is going to be printed out with

the amount of time it took.

So, let's just say 100.times.

We'll multiply 1,000 times 1,000.

And I am gonna save that.

I click down here, exit out of irb, clear my screen.

And if I run simple_benchmarker.rb, we can see not very long elapsed.

Because computers are really fast, and

they can do math a lot quicker than we can.

So let's go ahead and change this code.

And we'll just say we're gonna do something 5.times.

What I'm gonna do is tell the computer to sleep for a random amount of time.

We do that by using the sleep method.

And what sleep is gonna do is nothing.

It's just going to pause the interpretation of the code,

just kinda hang out.

And now I'm going to say, using the rand method,

between 0.1 and 1.0.

So all this piece of code is gonna do is just pause the computer,

the execution time, for a random amount of time between 0.1 seconds and 1.0 seconds.

These are a couple new methods, just trust me that they work.

And we could look them up in the documentation if we wanted.

So let me clear my screen here.

If we run this benchmarker again, we can see it's not doing anything.

And now we have the elapsed time of 3.13 seconds.

Let's go ahead and just write out seconds, to be safe.

If we wanted to, we could get a little bit more fancy with this and

print out a dot so we know how long each iteration is taking.

And that time, it only took 2.8 seconds.

In fact,

if we wanted to we could print out a new line here just to separate all those dots.

That looks a little bit better.

And then just for fun, let's go ahead and add a description.

And print out the description.

And then we could say benchmarker.run, sleep a random amount of time.

Clear the screen, run it one more time.

And that looks pretty good.