Tiffany, you reall
But first, you and
FTL is not possibl
Joe's Bar and Gril
Quietly, Quiggly s
Release me. Now. O
But first, you and
Stop dancing like
Tiffany, you reall
We've recently disChapter 1. Once
you run into a problem,
there's a sense of a
solution, and there's a
way of doing the solution
that you can just move on
and work on something else.
And so a person may spend
30 minutes of their day
thinking about a problem,
and they write a 10 page
email, and they're working
on the problem until lunch
or dinner, and then they
maybe write two more pages,
or maybe they don't get
it, and so they start
working on something else,
but that's just part of the
process.
And so as I said,
productivity in software
engineering is very high
when people are in the zone.
And there's a feeling that
this is hard, but once you
get it, it's a very valuable
skill that you can have.
The issue is, how do you get
into the zone?
And how do you get out of
the zone?
So this is where we talk
about time, and specifically
managing time.
You know, time is probably
the most valuable resource
you have.
And again, it's a really
common thing that it takes a
few seconds to recognize
when your mind is in the
zone, and the rest of the
time, you're probably
bothering, so it's the
amount of time it takes you
to start doing something,
and the amount of time it
takes you to start coding.
And there's a lot of things
to talk about that, but I
want to give you one example
of a way that we can measure
this.
And this is a talk that a
good friend of mine gave
named Dan O'Hara at PyCon.
If you've never seen it, he
wrote this talk, and he got
an A+, but he got a huge
round of applause at the end
for this.
And what it's about is this
problem called the Lobster
problem, and it was given by
an economist by the name of
James Hamilton.
It's just, in a nutshell,
take a lobster, throw it in
boiling water, let it boil
for five minutes, and then
take out the meat.
But the trick is, do you
want to kill the lobster by
putting it in boiling water?
Or do you just want to kill
it by boiling it for 5
minutes?
But the whole question is,
if you just boiled it for 5
minutes, you know what would
happen?
The lobster would stay alive
just the same.
But it wouldn't be cooked at
all.
And do you want to kill the
lobster or not?
And so the question that's
embedded in the name of this
thing is if you want to make
it cooked, is it okay to boil
it for 5 minutes, or should
you put it in hot water and
boil it for 5 minutes?
And the question is actually
a little bit subtle, but
understanding that, as an
engineer, how we look at this
is this, there are these two
variables, the amount of time
it takes to cook it, the time
it takes to cook it.
And then there's some
constraint, in this case,
there's a constraint that
says, this variable has to be
greater than this variable.
The question is, what does
the answer to the question
really depend on?
What's the effect on that
time, so the time it takes to
cook it, and the amount of
time it takes to cook it,
what's the effect of that?
And what you can do is take
the time that you boil it for
5 minutes, and then take the
amount of time it takes to
cook it.
And so the question is, what
happens if you were to boil
it for, for a given value of
N, so say for N equals 5,
boil it for 5 minutes, if you
didn't change anything.
And so what you're seeing is
this interesting curve of
some sort of function.
And you can see that, the
relationship here is time to
cook, and this is the amount
of time you boil it for, N.
But the question is, if I
find the value that maximizes
this, I'm going to get a value
that has, has, the number is
growing, the difference
between the two time.
The time that it takes to
boil it, and the time that it
takes to cook it.
And this is basically
equivalent to that.
So what's the question?
In order to find the right
number, you're really looking
at this as the question, in
order to cook it the best,
how much time do I need to
boil it?
Now, I don't mean to say,
after you boil it, how much
time you have to cook it.
The question is, how much
time you need to boil it?
And in order to boil it, you
need to let it heat up first.
And so this is actually a
really important point.
And what you find in order
find this is a lot of times,
this, this value is going to
be a piecewise function, like
this.
Because it's different ways
to cook something, what
matters here, is the amount
of time that it takes to boil
it.
It's not about cooking it.
It's not like it needs to be
something cooking it, it just
needs to be boiling it.
And you start to say, in
order to boil it, I need this
amount of time, and this
amount of time.
And so the amount of time you
need to boil it is a lot more
important than how much time
it takes you to cook it.
And if this is true, if this
function is a piecewise
function, it's not a linear
function, which means it
doesn't have a piecewise
function of some sort, and you
just see some smooth function.
And it's not hard to see
where this is the case.
Because the number of things
that you can boil in, let's
say, boiling water is
relatively high.
You can boil pots of water,
you can boil pans of water,
you can boil pans of water.
And so that this would be a
more efficient way to boil
water.
But let's say you're cooking
something, and let's say you
have this as your time.
So that's a total of N plus
the time it takes to boil it,
and so that's the limit of how
fast you can boil it.
And so you see, if this was
constant, you couldn't boil
anything.
But if this was a number that
got bigger, then it would get
faster to boil things.
And so, in the limit, it
doesn't, in the limit you
don't have to cook it.
And so the question is, it's
not a linear function, it's a
piecewise function.
And so the only way that
really the constraint is
linear is if the amount of
time it takes you to boil it
is completely independent of
how long you cook it.
And if the amount of time it
takes you to boil it was
completely independent of how
long you cook it, then it
would be a linear function.
And so that's not the case,
so the constraint function is
a piecewise function, and so
that's the thing that you can
see, that if you have a piece
wise function, you're not
going to get the function
completely for free.
And so in order to get the
best bang for the buck, we
have to take the lowest
amount of time to boil, to
pick the biggest value, and
so that's, if you do, this