In this video, I want to introduce one of the most important elements of the course.
The How To Design Functions recipe, where we call it the HTDF Recipe for short.
The HTDF Recipe systematizes the design of a function.
What I mean by that, is it tells us what to do first,
and second, and third, all the way through the design of a function.
So it helps us know what to do, and
it also helps us be sure that we end up with a high quality function.
That really does what we need it to do, and that's been well-tested.
Now, there's a funny thing about design recipes or design
methods, as they're sometimes called, particularly effects when you learn them.
What a design recipe does, is it makes hard problems easier.
It lets us take a big, hard problem and break it down and work through
it in a systematic fashion.
The price we pay for that is
that it actually makes easy problems more cumbersome.
That's right, the HTDF Recipe is going to make hard functions
easier to design, and easy functions a little harder to design.
In fact, once you get good at designing functions,
you won't use the HDTF recipe for really simple functions.
But for now, we want you to use the HDTF recipe even
for simple functions.
That's because the way this is going to work, is
that you're going to use simple functions to learn the recipe.
And then you're going to use the recipe to do the hard functions.
So what I need to ask for now is two kinds of patience.
If you've never programmed before, it's going to seem like
there's a lot going on, when we introduce this recipe.
So, I'm going to need to ask, that you be patient, and go through
it with me at the pace we're going
through, and I promise you it will become familiar.
If you have programmed before, this is going to seem like overkill.
We're going to start with a very simple function, and by using the
recipe it's going to take us quite a long time to do it.
I need to ask you to be patient too.
I promise you within a few weeks by using the recipe,
we're going to be designing much harder functions than we can design otherwise.
Here's how we're going to go through this material.
There's going to be this video and
the next one.
In the first video, I'm going to go through the design of a function
step by step, and I'm going to tell you what I'm doing at each step.
But I'm going to describe it, as if
you already knew the terminology of the design recipe.
I know that sounds silly because you don't.
But we've learned from teaching this to many, many students
at UBC, that the right thing to do first is
to kind of go through it at almost normal speed.
Then in the next video, the next video is going to
kind of be a slow motion version of this video.
In that next video, as we go through it piece by piece, I'll elaborate
on each piece we're doing and why we're doing it and how it works.
So what we're going to ask you to do is watch this video once at speed,
then watch the next video with Dr. Racket open following along.
And then it'll probably help you to watch this video again at speed.
Everything we do, the entire design recipe, you can
find on the course webpage, under the Design Recipes link.
That example, that's used on the website, is the one
we're going to do here, so you'll be able to follow along.
Again, be patient with the material, and be patient with yourself.
There's a lot going on in the HTDF Recipe.
You're not going to pick it up the first time through.
You're not going to pick it up the second time through.
But you'll be going through the recipe hundreds of times through the course.
And I promise you, within a couple weeks, it's going to seem quite familiar.
And you'll just be learning more nuances about it as we go forward.
Okay, what I've done here is I've opened the double
starter Dr Racket file that I got from the one webpage.
I've opened it and I'm getting it tells me the problem we need to do.
We need to design a function that consumes a number that produces twice that number.
We're going to call the function double, and we need to follow the
How To Design Funstion recipe, and show the stub and the template.
And remember, I'm doing this at full
speed, I'm not explaining every step of it.
This video will take just a couple of minutes and then in the
next video, we'll do it slower and I'll explain every bit of it.
But whenever I follow the How To Design Functions recipe, I
like to have an overview of the recipe in front of me.
So what I've done is to go to the first website.
And I went to the Design Recipes overview tab.
And over here on the side is a
sub, overview of the How To Design Functions recipe.
And I've taken that and copied it in my video editor and set it right here,
so that you could see it while I work.
Okay, so step one is signature, purpose, and stub.
So, this function is going to consume a number and
it's going to produce a number, so that's my signature.
It's purpose is going to be to produce two times the given number.
Okay,
and the stop, let's see, this function is called double and it consumes
a single argument which is number. I'll call it n.
And it produces a number, so for now we'll have it produce zero.
And this is the stub.
Okay?
Now the next step I've gotta do is the examples
wrapped in check-expect, and those are going to go right here actually.
What I'm going to say is I'm going to say check-expect.
Expect that if I call double with 3, I'll get 6.
And I'll give another one, check-expect
that if I call double, with 4.2, I'll
get 8.4 like that. And then I'm going to run
my check-expects and let's see, they're failing
but both of them are running. So I'm quite happy
they're both running.
Now I'll come back up here and the stub
has done its job, it let me run my check-expects.
So I'm going to commend out the stub, and I'll go on the next step of
the recipe is to write the templates, so I'll say define double of n.
And the template for this function is dot dot dot n.
That's the template.
And actually, what I'm going to do is make a copy of the template.
And I won't mark the template, the copy saying it is the copy.
I'm going to copy out, comment out the actual template.
The next to the last step of the recipe is to code the function body.
So it might be useful to me at this point to
be a little bit more clear for myself why that's 8.4.
The reason that's 8.4 is that it's really times 2 of 4.2.
Oh, and now I understand how this function works.
It just multiplies whatever n is,
[SOUND]
by 2. Now I'll run it, and both tests pass.
So that's a first pass through the HTDF Design Recipe.
Again, I certainly don't expect you to have fully
absorbed the HTDF Recipe from that quick pass through it.
What I want you to do now is go to the next video.
Which is going to be the slow motion version of this video, in
which I'll talk about the different parts of the recipe in more detail.