Hi everyone, I'm Gil Tene.

I'm going to be talking about this subject
that I call "How NOT to Measure Latency".

It's a subject that I've been talking
about for 3 years or so.

I keep the title and change all
the slides every time.

A bunch of this stuff is new.

So if you've seen any of my previous "How NOT to",
you'll see only some things that are common.

A nickname for the subject is this...

Because I often will get that reaction
from some people in the audience.

Ever since I've told people that it's a
nickname,

They feel free to actually exclaim,
"Oh S@%#!".

And feel free to do that here in this talk.

I'll prompt you in a couple of places
where it is natural.

But if just have the urge, go ahead.

So just a tiny bit about me.

I am the co-founder of Azul Systems.

I play around with garbage collection a lot.

Here is some evidence of me playing around
with garbage collection in my kitchen.

That's a trash compactor.

The compaction function wasn't working right,
so I had to fix it.

I thought it'd be funny to take a picture
with a book.

I've also built a lot of things.

I've been playing with computers since
the early 80's.

I've built hardware.

I've helped design chips.

I've built software at many 
different levels.

Operating systems, drivers...
JVM's obviously.

And lots of big systems at the system level.

Built our own app server in the late 90's
because web logic wasn't around yet.

So, I've made a lot of mistakes,
and I've learned from a few of them.

This is actually a combination of a bunch
of those mistakes looking at latency.

I do have this hobby of depressing people
by pulling the wool up from over your eyes,

and this is what this talk is about.

So, I need to give you a choice right here.

There's the door.

You can take the blue pill, 
and you can leave.

Tomorrow you can keep believing whatever
it is you want to believe.

But if you stay here and take the red pill, 
I will show you a glimpse of how

far down the rabbit hole goes, 
and it will never be the same again.

Let's talk about latency.

And when I say latency, I'm talking about
latency response time, any of those things

where you measure time from 'here to here',
and you're interested in how long it took.

We do this all the time, but I see a lot 
of mish-mash in how people

treat the data, or think about it.

Latency is basically the time it took
something to happen once.

That one time, how long did it take.

And when we measure stuff, like we did 
a million operations in the last hour,

we have a million latencies. Not one,
we have a million of them.

Our actual goal is to figure out how to
describe that million.

How did that million behave?

For example, they're all really good, and
they're all exactly the same, will be a

behavior that you will never see, 
but that would be a great behavior.