DAVID J. MALAN: All right, this is CS50 and this is a lecture four.

So we're here in beautiful Lowell Lecture Hall

and Sanders is in use today.

And we're joined by some friends that will soon

be clear and present in just a moment.

But before then, recall that last time we took a look at CS50 IDE.

This was a new web-based programming environment similar in spirit

to CS50 Sandbox and CS50 Lab, but added a few features.

For instance, what features did it add to you--

to your capabilities?

Yeah?

AUDIENCE: Debugger.

DAVID J. MALAN: What's that?

AUDIENCE: The debugger.

DAVID J. MALAN: The debugger.

So debug50, which opens that side panel that

allows you to step through your code, step by step, and see variables.

Yeah?

AUDIENCE: Check50.

DAVID J. MALAN: Sorry, say again?

AUDIENCE: Check50.

DAVID J. MALAN: Check50 as well, which is a CS50 specific tool that

allows you to check the correctness of your code

much like the teaching fellows would when providing feedback on it.

Running a series of tests that pretty much are

the same tests that a lot of the homework's

will encourage you yourself to run manually,

but it just automates the process.

And anything else?

AUDIENCE: [INAUDIBLE]

DAVID J. MALAN: So that is true too.

There's a little hidden Easter egg that we don't use this semester,

but yes indeed.

If you look for a small puzzle piece, you

can actually convert your C code back to Scratch like puzzle pieces

and back and forth, and back to forth, thanks to Kareem and some of the team.

So that is there, but by now, it's probably better

to get comfortable with text as well.

So there's a couple of our other tools that we've

used over time of course besides check50 and debug50.

We've of course used printf and when is printf useful?

Like when might you want to use it beyond needing to just print something

because the problem set tells you to.

Yeah?

AUDIENCE: To find where your bug is.

DAVID J. MALAN: Yeah, so to find where your bug is.

If you just, kind of, want to print out variables, value or some kind of text

so you know what's going on and you don't necessarily

want to deploy debug50, you can do that.

When else?

AUDIENCE: If you have a long formula for something [INAUDIBLE]

and you want to see [INAUDIBLE].

DAVID J. MALAN: Good.

Yeah.

AUDIENCE: How running-- like going through debug50 50 times.

DAVID J. MALAN: Indeed.

Well, in real life-- so you might want to use printf

when you have maybe a nested loop, and you want to put a printf inside loop

so as to see when it kicks in.

Of course, you could use debug50, but you

might end up running debug50 or clicking next, next, next, next, next, next,

next so many times that gets a little tedious.

But do keep in mind, you can just put a breakpoint deeper into your code

as well and perhaps remove an earlier breakpoint as well.

And honestly, all the time, whether it's in C or other languages,

do I find myself occasionally using printf just to type out printf in here

just so that I can literally see if my code got to a certain point in here

to see if something's printed.

But the debugger you're going to find now

and hence forth so much more powerful, so much more versatile.

So if you haven't already gotten to the habit of using debug50 by all

means start and use those breakpoints to actually walk through your code

where you care to see what's going on.

So style50, of course, checks the style of your code much like the teaching

fellows might, and it shows you in red or green

what spaces you might want to delete, what spaces you might

want to add just to pretty things up.

So it's more readable for you and others.

And then what about help50?

When should you instinctively reach for help50?

AUDIENCE: When you don't understand an error message.

DAVID J. MALAN: Exactly.

Yeah, when you don't understand an error message.

So you're compiling something.

You're running a command.

It doesn't really quite work and you're seeing a cryptic error message.

Eventually, you'll get the muscle memory and the sort of exposure

to just know, oh, I remember what that means.

But until then, run help50 at the beginning of that same command,

and it's going to try to detect what your error is

and provide TF-like feedback on how to actually work around that.

You'll see two on the course's website is a wonderful handout made

by Emily Hong, one of our own teaching fellows,

that introduces all of these tools, and a few more,

and gets you into the habit of thinking about things.

It's kind of a flow chart.

If I have this problem, then do this or else

if I have this problem do this other thing.

So to check that out as well.

But today, let's introduce really the last, certainly for C,

of our command line tools that's going to help

you chase down problems in your code.

Last week, recall that we had talked about memory a lot.

We talked about malloc, allocating memory,

and we talked about freeing memory and the like.

But it turns out, you can do a lot of damage

when you start playing with memory.

In fact, probably by now, almost everyone-- segmentation fault?

[LAUGHTER]

Yeah, so that's just one of the errors that you might run into,

and frankly, you might have errors in your code now

and hence forth that have bugs but you don't even realize it

because you're just getting lucky.

And the program is just not crashing or it's not freezing,

but this can still happen.

And so Valgrind is a command line program that is probably

looks the scariest of the tools we've used,

but you can also use it with help50, that

just tries to find what are called memory leaks in your program.

Recall that last week we introduced malloc,

and malloc lets you allocate memory.

But if you don't free that memory, by literally calling the free function,

you're going to constantly ask your operating system, MacOS, Linux,

Windows, whatever, can I have more memory?

Can I have more memory?

Can I have more memory?

And if you never, literally, hand it back by calling free your computer

may very well slow down or freeze or crash.

And frankly, if you've ever had that happen on your Mac or PC, very likely

that's what some human accidentally did.

He or she just allocated more and more memory

but never really got around to freeing that memory.

So Valgrind can help you find those mistakes before you or your users do.

So let's do a quick example, let me go CS50 IDE, and let me go ahead

and make one new program here.

We'll call it memory.c because we'll see later today how

I might chase down those memory leaks.

But for now, let's start with something even simpler, which all of you

may be done by now, which is to accidentally touch memory

that you shouldn't, changing it, reading it and let's see what this might mean.

So let me do the familiar at the top here.

Include standard IO.

Well, let's not even do that yet.

Let's just do this first.

Let's do int, main(void), just to start a simple program

and in here let me go ahead and just call a function called f.

I don't really care what its name is for today.

I just want to call a function f, and then that's it.

Now this function f, let me go ahead and define it as follows, void f(void).

It's not going to do much of anything at all.

But let's suppose, just for the sake of discussion, that f's purpose in life

is just to allocate memory for whatever useful purpose,

but for now it's just for demonstration's sake.

So what's the function with which you can allocate memory?

AUDIENCE: Malloc.

DAVID J. MALAN: Malloc.

So suppose I want malloc space for, I don't know,

something simple like just one integer.

We're just doing this for demonstration purposes,

or actually let's do more, 10 integers, 10 integers.

I could, of course, do-- well, give me 10, but how many bytes do what I want?

How many bytes do I need for 10 integers?

AUDIENCE: sizeof(int).

DAVID J. MALAN: Yeah, so I can do literally sizeof(int)

and most likely the size of an int is going to be?

AUDIENCE: Four.

DAVID J. MALAN: Four, probably.

On many systems today, it's just 4 bytes or 32 bits,

but you don't want to hard code that lest someone else's computer not use

those same values.

So the size of an int.

So 10 times the size of an int.

Malloc returns what type of data?

What does that hand me back?

AUDIENCE: [INAUDIBLE]

DAVID J. MALAN: Yeah, returns an address or a pointer.

Specifically, the address, 100, 900, whatever, of the chunk of memory

it just allocated for you.

So if I want to keep that around, I need to declare a pointer.

Let's just call it x for today that stores that address.

Could call it x, y, z, whatever, but it's not an int that it's returning.

It's the address of an int.

And remember, that's what the star operator now means.

The address of some data type.

It's just a number.

All right, so now if I were to--

first, let's clean this up.

Turns out that you use malloc, I need to use stdlib.h.

We saw that last week, albeit briefly, and then of course

if I'm going to call f, what do I have to do to fix this code?

AUDIENCE: You need to declare.

DAVID J. MALAN: Yeah, I need to declare it up here,

or I could just move f's implementation up top.

So I think this works, even though this program at the moment

is completely stupid.

It doesn't do anything useful, but it will allocate memory.

And I'll do something with it as follows.

If I want to change the first value in this chunk of memory,

well how might I do that?

Well, I've asked the computer for 10 integers or rather space

for 10 integers.

What's interesting about malloc is that when

it returns a chunk of memory for you it's contiguous, back-to-back.

And when you hear contiguous or back-to-back,

what kind of data structure does that recall to mind?

AUDIENCE: An array.

DAVID J. MALAN: An array.

So it turns out we can treat this just random chunk of memory

like it's an array.

So if we want to go to the first location in that array of memory,

I can just do this and put in the number say 50.

Or if I want to go to the next location, I can do this.

Or if I want to do the next location, I can do this.

Or if I want to go to the last location, I might do this,

but is that good or bad?

AUDIENCE: Bad.

DAVID J. MALAN: Why bad?

AUDIENCE: It's-- it's out of bounds

DAVID J. MALAN: Yeah, so it's out of bounds.

Right?

This is sort of week one style mistakes when it came to loops.

Recall, with for loops or while loops, you might go a little too far,

and that's fine.

But now we actually will see we have a tool that

can help us notice these things.

So hopefully, just visually, it's apparent that what I have going on here

is just-- on line 12, I have a variable x

that storing the address of that chunk of memory.

And then on line 13, I'm just trying to access location 10

and set the value 50 there.

But as you note, there is no location 10.