>> SPEAKER: OK, so, you won't believe it, but last week, on Monday, in Pierce, I
was down in the basement.
I never go to Pierce.
And I'm never going back again, because I left my stuff alone for,
like, five minutes and somebody stole my computer and my
phone out of my backpack.
Which means I got it back, and then less than a week later
it got stolen again.
>> And then it got turned on--
Find My iPhone continues to be unhelpful.
So I continue to encourage you not to use it.
It turned on once, and it was in MIT, like 15 minutes later, and the person
called this phone number that showed up in my AT&T call log.
>> So I went online, called that phone number, and it went straight to this
answering machine in Spanish.
And I haven't heard of it since.
So I had to get a new computer and phone.
I know.
Yeah.
But if you guys want to chip in to my computer fund after this, that's why
I've asked you here.
Just kidding.
But that was really sad and traumatic.
>> But it's all back now, and that was why the p-set 8 took so long, because
I didn't have a computer.
And somebody stole it.
And I emailed, asking if they would grade your p-set 8.
But they said no.
And I was like, can I have my computer back?
And they're like, no.
Just kidding.
>> OK.
This is our final section, and I have a couple of-- we only have three
things on the agenda.
We're going to talk a bit about the Q guide.
Then we're going to spend 15 minutes on a cool demo.
Then we're going to all say goodbye to one another.
You don't really need your computers or a pen or paper to take notes, or
follow along.
So I assume if you have your computer up, then you're on Facebook.
Just saying.
Unless you're filling out the Q guide, which is first.
>> The Q guide is open.
You've had an email about it.
Once all the Q stuff is submitted at the end of the year, I get all of the
Q comments in scores from everybody who chooses to give me feedback.
And so when you go in the Q--
I don't know if you can do this, Jeff, because you're and extension student.
But when you go in the Q, if you haven't done it before, you pick your
teacher, which is David Malan.
You have to do him.
>> And then you can pick TFs.
And you can pick as many TFs as you want.
But there are 60 of us.
You don't have to pick everybody.
You can just pick me, or just pick a couple other people, if you want, to
give them feedback as well.
And then you get scores on all these different axes, and then you can leave
them feedback.
>> And then, like a month later, I'll get all that feedback.
And just like the feedback you've been giving me throughout the semester, I
read all of that.
And it's really helpful, and it helps me grow as a teacher and as an
individual.
So, please, take some time to do it.
We're only going to be here for, like, 30 minutes.
So if you want, at the end of this, to take five minutes, and just fill out
the Q, because it doesn't take any more time than that.
That would be wonderful, and you also get your grades back more quickly if
you fill out the Q.
>> So most of you have done that before--
or no, about half of you have done that before.
But if you're a freshman, that's what that is.
It'll be the same for all the classes.
Do it.
It takes five minutes.
But also, if you do it a bit seriously, that's not the worst thing
in the world, because I certainly take it seriously.
>> So if you leave me a smiley face, I will appreciate that.
But I would also appreciate if you left me more than a smiley face.
But it's up to you.
I can't tell you-- or like a big smiley face, with a capital D. That'd
be even better.
>> OK, that's all I have for the Q. If you have any questions, you can ask
me, but pretty self-explanatory.
Just, please, fill it out.
I would really appreciate it, and it means a lot to me.
>> OK, this is what we're going to spend 15 minutes going through.
I'm going to show you some code.
I think this is really cool, and this got me more
excited in computer science.
So I hope it will do the same for you all.
>> We are going to open up-- and all this code I'll send to you later.
But we're just going to open up--
I'm in my terminal--
we're going to open up this program called [? MySum. ?]
>> Can everybody read that, or should I make it bigger?
Can anybody tell me what this code will do when I run it, or what this
program will do when I run it?
>> [? Avi, ?] what do you think it's going to do?
Finish chewing.
You shouldn't talk with your mouth open.
>> AUDIENCE: Does it take a bunch of arguments, find sum of them returning
sum, and then print it out?
Or it takes in two arguments, and then it does [INAUDIBLE].
And then it prints out whatever the results are.
>> SPEAKER: Close, really close.
Anybody want to add to [? what Avi ?] said?
Do you need to give this program any command-line arguments?
>> AUDIENCE: No.
>> SPEAKER: No.
What happens if you don't give it any command-line arguments?
I just write dot slash MySum.
>> AUDIENCE: 1 plus 2 equals 3.
>> SPEAKER: 1 plus 2 equals 3.
And it'll print that out.
That's exactly right.
You'll see that print f line at the bottom.
It'll print out a, b, and then the sum of a and b.
And I guess you assume that sum works correctly.
Good assumption.
>> OK, and what happens if I give it what argument?
[? Manu? ?]
>> AUDIENCE: It'll add whatever the first argument is to b.
Or to 2, sorry.
>> SPEAKER: Right, to 2.
Does anybody know what strtol does?
It's basically atoi.
Atoi is actually a fancy version of--
or a simpler version of strtol.
But it actually uses strtol.
And I found that out because I wanted something like atoi, and then when I
did atoi, I read down here.
And I found "this behavior is the same as" strtol.
So it's basically atoi for all intents and purposes.
And you see I even use null and 10.
>> This actually lets you take a string, and turn it into a number, and choose
what base you want to do it in.
So this is base 10 right here.
I could have done base two for decimal, base 16 for hexadecimal.
It's pretty cool.
But long story short, this takes two numbers and adds them together.
>> So let's run it.
And you'll also notice, there are some things--
so I have a makefile right here, and if you open that up, some things
you'll notice are different.
In particular, this argument right here, you probably
haven't seen that before.
Generally, we compile things with dash zero, zero.
Dash zero, zero, means don't do any optimizations, compiler.
Don't try and make anything fancy, or make anything run more quickly, or get
rid of variables that are necessary.
Don't optimize this code at all,
>> I'm asking for third-level optimization.
So I'm asking compiler to do a lot of optimizations.
You can change that in the makefile when you have this code, if you want
to see different stuff.
Which we'll show in a second.
So we run my sum 1 plus 2 plus 3.
Somebody give me two arguments.
>> AUDIENCE: 4 and 5.
>> SPEAKER: 4 and 5.
Thank you.
Great, it works.
What are some other good arguments to try, to make sure this works?
Anyone?
>> AUDIENCE: 0.
>> SPEAKER: 0 and?
>> AUDIENCE: Negative 3.
>> SPEAKER: It works.
But those were good choices.
OK, so let's go back here.
This is mysum.c.
You'll notice there's also something called sumfunction.c.
And this says, oh, there's something defined in sumfunction.c.
I don't include this file in here because I don't need to.
But I link it in when I compile, which you noticed.
>> Let's scroll up.
We saw when we compiled mysum, right there, we linked in the binary from
sumfunction.o.
And I don't need the header file because, of course, there's the
function declaration.
So sharp include normally just puts in a function declaration.
Here I've just put it straight in the code.
And so I need to do is link in the binary, which I do.
>> Any guesses for what is in sumfunction.c?
What code I've written in sumfunction.c?
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER: Any guesses?
Yeah?
>> AUDIENCE: I think, defines some [INAUDIBLE].
>> SPEAKER: Yes.
So I do write int sum int a.
I write this line, and then I have open curly brace, closed curly brace.
What do you think I write inside those curly braces, inside that function?
Yeah?
>> AUDIENCE: Return equals a.
>> PROCESSOR: That's a really good guess.
Who thinks [? Manu ?] is right?
It says return a plus b.
OK, not everybody.
[? Akshar, ?]
you do, too?
You sure?
OK.
What?
>> AUDIENCE: You spelled it wrong.
>> SPEAKER: No, I didn't.
Yeah, just kidding.
You're right.
That's exactly what it says.
It's return a plus b.
That makes a lot of sense.
>> OK, let's go back here.
We see how the header--
that's the return type.
Remember, we've seen that day one, the return type of the function, but goes
before the name of the int function.
Here, I've written int.
What do you think will happen if in this function, I don't write int, but
I write unsigned?
The difference, of course, being that unsigned represents only positive
integers, and int can be positive or negative.
>> So I've changed the return type of this function.
This code does not match this return type here.
What do you think will happen when I compile?
You should yell at me.
No yelling.
>> What about when I run the program?
Let's do before 0 negative 3, or negative 1.
It still works, even though I'm saying it's returning an unsigned integer.
Clearly it's not returning an unsigned integer.
It's returning a signed integer.
It's returning negative 1.
OK, that's weird.
>> What about if I go in here and do that?
So I've changed everything from int to unsigned.
It can only take unsigned integers.
But do we still think it'll run?
>> AUDIENCE: Yes.
>> SPEAKER: It will.
That's crazy.
And we pass in a clearly assigned integer, we can pass two signed
integer, it still works.
>> OK, any ideas of why it still works, or what's going on?
Yeah, Jeff.
>> AUDIENCE: It has something to do with your optimization that you
highlighted.
>> SPEAKER: No.
We could change the optimization, it would still work.
I can do that for you, but--
>> AUDIENCE: I'll take your word for it.
>> SPEAKER: Yeah.
If you open the makefile right here, I changed the optimization.
So you can do dash zero, zero.
It will still work.
Other thoughts?
>> You guys all expected to work, so why'd you expect it to work?
No?
Silence.
OK.
I have to wait seven seconds, because I asked a question.
>> So the cool thing about C, and you've probably experienced before-- you
might not have, this might be the first time.
But as you all know, when I write something in C, it does not save like
this on the computer.
It's saved as ones and zeroes.
It goes from C code to assembly code.
>> Has anybody seen assembly code before, machine assembly code?
We'll look at in a second.
It goes from C code to assembly code.
And you guys know the stages of compilation.
You had to memorize that for quiz one, and then write it out on quiz zero.
Most people got it wrong.
I think you guys nailed it.
>> But, you guys are the best section for quizzes, by the way.
Which is awesome.
It won't hurt you.
Don't be worried.
But it's really cool.
Good job.
>> So it goes to assembly language, and then it goes to ones and zeroes.
And the ones and zeroes are saved on the computer, and that's what saved in
the a.out, or in this case, the executable file.
And the computer runs ones and zeroes.
Right?
We've learned this before.
>> So the cool thing is, this unsigned idea, the idea of types ints unsigned,
et cetera, et cetera, that's up here in the C language.
Those exist.
But types don't exist at the ones and zeroes.
Types don't even really exist at the assembly language level.
So that's something that exists in C world but doesn't exist in computer
world or processor world.
That's some abstraction that the C language has included, to make our
lives easier.
>> So at the end of the day, I can write many different things here, and it
doesn't make a difference.
Because that only exists in the C world.
It doesn't exist in the ones and zeroes world.
And our program's executing in the ones and zeroes world.
So your mind's clearly not blown yet.
But I think that's cool.
Yeah, Jeff.
>> AUDIENCE: So, if instead of doing int, you do char.
And you were--
>> SPEAKER: Let's do it in a sec.
>> AUDIENCE: Because then you get an unsigned going from negative 128 to
127 or 0 to 255.
>> SPEAKER: So char is problematic.
Does anybody know why char would be problematic, and it would actually
change things in the ones and zeroes world?
>> AUDIENCE: Because of the size of char.
>> SPEAKER: Size of char is 1.
So unsigned is also 4 bytes.
So char would screw things up.
But what is 4 bytes that's related to a char?
Or at that adds one additional--
you can put one more character after char.
>> AUDIENCE: Char star.
>> SPEAKER: Char star has 4 bytes.
So let's do something that's a char star.
>> So this would probably work, but we're going to do something even
crazier than this.
In my opinion, crazier.
>> I've now written a function that returns a pointer, and it takes a
pointer and an unsigned value-- we'll change this back to int so we're not
making too many changes at once.
And it has an array called a, indexes into the array, and returns the
address of.
We've seen these operators before.
This, what do you think this is going to do, in return, when I run it?
What do you think it's going to do?
Any guesses?
>> AUDIENCE: Segfault.
>> SPEAKER: What?
Segfault?
That's a good guess.
Tom says the same thing.
Any other guesses?
>> Who thinks it's going to do the same thing?
Who thinks it's going to segfault?
It does the same thing.
Sorry.
>> But, of course, we put in 1 and 2.
And those are both valid, right?
Let's see, we can go to the second place of an array.
But what if we made b a negative number?
That is probably a better guess for something segfaulting.
It still works.
>> OK, this is now crazy.
This is of equally valid sum function.
This does the same exact thing as return a and b.
Can anybody explain why this is a good sum function, or why this works?
What is happening here?
Why does this do the exact same thing as our old sum function?
[? Akshar, ?]
what's going on?
>> AUDIENCE: Because when you have an a that's an address to
the location memory--
and when you do the ampersand, it goes to that memory address.
And when you go to b, you're kind of moving steps from that memory address,
you're returning that.
So you're actually, in fact, adding a and b [INAUDIBLE].
Where are standard operations on that return?
Like, where do the parentheses fall?
Is the return of the address on a before or after [INAUDIBLE]?
>> SPEAKER: It's going to index into b--
or index into a-- and then return the address.
OK, so did everybody understand what [? Akshar ?]
said, and explained, why this works?
I didn't, the first time somebody explained this to me.
Would anybody like a picture to explain this?
We're going to draw a picture, with no markers, that's great.
Found some.
>> So we have an array that's a series of boxes.
The first one is an index 0, index 1, 2, 3, 4, dot, dot, dot.
A typical array.
And in addition to having indices, they all have memory addresses.
So let's give this memory address 13, 14, 15, 16, 17, et cetera.
Everybody's here so far.
>> So a is an address.
The name of an array, a pointer is saved there.
It's a pointer, it's a memory location, to the start of the array.
So if this were the array, a would be a value of 13.
And, of course, we can give a any value we want.
Char star a, we can give a any memory address we want.
We can give it 0, we can give it negative 1-- negative 1 doesn't exist,
so that's probably problematic, but you saw that it still worked.
So we can give a any number we want, any memory address we want.
>> Then, int b says, OK, go this number of steps into the array.
So if b equals 2, and a equals 13, we're at memory address 13.
And we go two steps in, and so we're here.
And the ampersand means return the address of this location.
And the address is, of course, 15.
So we get 13 plus 2, or a plus b, which is 15.
>> The question is, though--
I'm sorry.
Does that clarify things for why this works?
>> AUDIENCE: Why would it work going--
so you can have an array and go to a negative index?
>> SPEAKER: Right.
So we did negative numbers, so that's the--
does this make sense though, first, [? Avi, ?]
for you?
>> AUDIENCE: Yeah I'm just [INAUDIBLE], but--
>> SPEAKER: Yeah, this would return 15.
If a was 13, and b was 2, this would return 15.
>> AUDIENCE: So the zero indexing doesn't become an issue, right?
Because you're moving from 0.
>> SPEAKER: Right.
So you're moving-- so if b was 0, you wouldn't move anywhere.
And you'd just returned the address--
if b was 0, that's essentially returning that address of a.
Passing in char star a and returning the address of a is just returning a,
essentially.
>> OK, the question is why do negative numbers work?
And that's the really cool thing about this, because this should segfault.
And it would segfault if we did something like this.
Let's say, int.
So this code looks identical and should behave identically.
Essentially, x is a garbage variable, and so this should behave identically.
>> Let's make this--
oops--
in star.
OK, we're already getting errors here, because it's already going to be angry
at me, because it already knows what's coming.
In particular, the second one.
Address of stacked memory associated with a local variable.
>> Essentially, I'm not going to compile this, and then I'm going to undo do
what we just did.
But because we're never actually accessing what's at the memory
location, it's not going to segfault.
We're never actually looking at what's in the second box or what's in any box
of this array.
We're only saying, here's the address of the thing we're looking for and
return that address.
We're never actually going into the array to look at that location.
And because we never touch the memory, we don't get in trouble.
We don't get a segfault.
>> If we tried to, again, touch that memory, touch what was at a or b--
or a bracket b, and assuming a was 0 and--
if a was 0, even, that would be pretty bad, because we can't go
down all the way there.
If a and b were both 0, and we tried to touch what was there, then we would
get in trouble.
But if we don't touch what's there, we just return the address, it is
actually not going to segfault because it lets you perform those operations.
It only gets mad at you, and gets super angry, when you try and touch
the actual memory and return what's at that memory location.
>> Does that make sense?
That's just a crazy part of C. So, we have one more of these.
>> Who thinks this is cool?
More people.
That's good.
OK, this is our last one.
And I would like you to tell me whether or not you think this is going
to do the same exact thing.
>> I have these written down somewhere.
I'm not memorizing them.
>> Let's see, 8, b 4, 4, 2, 4, 0, 8, 0, 3, 4, 4, 2, 4, 0, 4.
So this is an array, now, not a function.
And it's an array because we have square brackets, not curly braces.
And it's an array of what type?
Anyone, hmm?
>> AUDIENCE: Their hexadecimal numbers?
>> SPEAKER: But what's the C type?
They all have hexadecimal numbers.
What's the C type?
It tells you.
>> AUDIENCE: It's unsigned chars.
>> SPEAKER: Right, unsigned chars.
And two hexadecimal numbers is one byte.
So these are 1, 2, 3, 4, 5, 6, 7, 8, 9 bytes.
It's an array of 9 bytes.
>> OK, you probably already know the answer to this question.
But, what do you think will happen when I run this?
I say, again, in mysum.c, I'm expecting a function
that takes two integers.
And I'm instead saying that sum is an array of characters.
What is going to happen when I run ./mysum and make?
>> Well, first, most of you will probably agree that make-- oh no, just kidding.
What'd I do wrong?
Uh oh.
That should be curly braces.
That's how you initialize an array.
My bad.
>> So we already saw before that types are a C-level abstraction, not a
computer level abstraction.
So most of you probably expected it to make, or assuming that it would make.
But what when I run ./mysum?
What's going to happen?
Any guesses?
>> AUDIENCE: It's going to print out a word.
>> SPEAKER: It's going to print out a word.
What word?
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER: Any other guesses?
OK, print out a phrase.
You can have any phrase.
That will be your side.
Anybody who has a different guess?
Anna, what's your guess?
>> AUDIENCE: It'll print out--
two letters, or [INAUDIBLE] one letter.
>> SPEAKER: One letter.
>> AUDIENCE: Can I count how many [INAUDIBLE]?
>> SPEAKER: Nine.
Well, I'm going to run it.
It does the same exact thing.
It adds two numbers together.
Well, let's pass the two arguments.
It doesn't take arguments.
So I don't know where it could possibly get these arguments.
But let's pass at 100 and 0.
And it adds 100 and 0.
That's insane.
I think so.
>> Negative 4, that works too.
You can do anything you want.
This is an equally valid sum function.
This is a sum function.
But, no, you're saying it's an array of bytes.
So what is going on here?
>> So, again, let's go back to this idea that we said at the very beginning.
You go from C-level code, to assembly language, to ones and zeroes.
This is hexadecimal.
But this is really just a lot of ones and zeroes.
This is 72 ones and zeroes, right?
72 ones and zeroes.
9 bytes.
Each byte has 8 bits.
Each bit is a one or a zero.
So 72 ones or zeroes.
I've just written them like this-- rather than writing it out as a lot of
ones and zeroes.
>> But this will go from C-level language, to assembly
language, to code.
And this will print out in code, somewhere, these 72 ones and zeroes
that I've written here.
So somewhere in that--
let's go here--
somewhere in mysum, the program, there are these 72 ones and zeroes that I've
written and told it to write.
>> Now, any guesses for what those 72 ones and zeroes mean?
>> AUDIENCE: Probably the same thing as return a plus b.
>> SPEAKER: Probably the same thing as return a plus b.
Let's verify that.
Let's figure out how I did this.
>> So if you go back here, I tell you to run this command, objdump -S
sumfunction.o.
Let's go run it. objdump--
obj, dump.
Basically it can give me whatever I want to see.
It can give me the assembly language.
It can give me the ones and zeroes.
It has a ton of flags.
This is the one we're going to use for now.
Dot--
as you see in the slides--
dash capital S says, intersperse, source code--
this line's from C-- with the assembly code and with the ones and zeroes.
And we're going to run it on sumfunction.o.
Because it'll be easier to see.
Again-- hmm?
>> AUDIENCE: You spelled it wrong.
>> SPEAKER: But I'm actually going to clear it for a second.
I'm first going to open just sumfuntion.o.
>> AUDIENCE: You spelled it wrong the first time.
>> SPEAKER: Classic.
Sum--
that is a hard word, though.
You'd be surprised.
OK, so this is sumfunction.o.
I couldn't even tell you.
There's a lot of zeroes, clearly a lot of zeroes, and there's some other
stuff that's not zeroes.
But mostly zeroes.
Looks like there's some ones.
So clearly, this is hard to read.
That's the binary language.
>> Let's now open it--
what?
What am I doing wrong?
Did I spell it correctly?
OK, this is awkward.
I need one second to figure out what I'm doing wrong.
That's one error.
That's weird.
Oh, that's why.
>> I'm going to go back to our initial one, so we can look at the
object code of this.
Because there's not really going to be anything when we just put the
ones and zeroes in.
There we go.
OK, so everybody can see this.
This function, as I said, put out the C lines--
source code lines--
with some assembly instructions.
>> Here is our source code line.
Here's one, here's another.
Here is the assembly instruction.
That's what they look like.
Assembly instructions--
you can learn more of these if you take other CS classes, but they're
generally an instruction.
And then a source and a destination.
>> And then over here is the binary code that corresponds to that assembly
instruction.
So as you can see, this sum function, at the end of the day, is three
assembly instructions.
Only three.
One mov--
this m-o-v stands for a Move.
Add stands for Add.
And r-e-t stands for Return.
So one mov, one add, one return.
And these, over here, are the zeroes and ones that correspond to that code.
>> So those zeroes and ones, if you know those, you can just put
those straight in.
And then it'll do the same exact thing.
Because, at the end of the day, all you're executing is a long series of
zeroes and ones.
And that's what your code really is.
>> And the reason--
let's look at one thing.
Did I have the makefile open?
So if we went back to dash zero, zero up here--
sorry, capital o, capital o zero, not zero, zero.
And we did make, it would still work the same.
But now you notice that there are a lot more assembly instructions.
That's because, again, I asked the compiler not to do any optimization.
>> So I could still take all of these zeroes and ones, and throw them in,
and that would work.
I just did the optimizations, because it's a bit easier, then,
to write that array.
But this would work just as well.
>> OK, we're going to do one final thing, because I think is the coolest part.
Even though everybody's clearly already blown and speechless.
Our minds are blown.
[INAUDIBLE]
>> So, these are from a different CS class, which is super interesting,
that I have taken--
CS61.
I highly encourage you to take it.
But the cool part about this fact, that things are just zeroes and ones,
are that everything is zeroes and ones.
>> So you can take a file that has the correct zeroes and ones you want
somewhere in it, and use that section of zeroes and ones as a sum function.
>> What do I mean by that?
I mean you can take an image file that has the correct series of zeroes and
ones, that print something out to an image.
And one program might interpret is an image, but you can interpret it, if
you want, as a sum function.
>> So if we wanted to open, for example, this image.
Let's go, Hello Kitty.
Wonderful little image.
In here there is that string of zeroes and ones.
Those 72 zeroes and ones exist in this image.
>> So what I can do, then, is write--
I have to remember where they are.
I'll find that in a second.
But we do--
let me find out where they are.
One sec.
Let's do--
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER: Thanks.
So if we execute this program, which instead reads in a file, then it goes
to this index in the file.
And then, again, just like mysum, takes two numbers.
We can add numbers exactly the same as we were doing before, which goes to
show you how the fact that, at the end of the day, all these things are
zeroes and ones.
And it's just how you choose to interpret them.
>> And if you actually look at this image--
let's zoom in a bit.
Can everybody see it?
You'll notice right here, there's some weird smudge.
Let's go-- this is the original image.
You'll notice here there's no smudge.
That is the code for the sum function, is that little smudge right there.
>> And actually, again, if you learn more about this, you'll realize that this
Hello Kitty, which has even a bigger smudge, has code that can take over a
computer if it's not protected appropriately.
So you can actually run this.
I'm not going to run it right now.
But you can run this Hello Kitty image, and it can
take over your computer.
>> So that's all for the demo.
Does anybody have any questions, comments, concerns?
I think this stuff is fascinating.
It inspired me to learn more.
I highly recommend, if you're interested at all on CS, talk to me.
Even though I'm a Social Studies Concentrator, I'm a CS, secondary, so
I still know a little bit.
But I certainly know what classes you should take.
I think it's all really interesting, and I encourage you, certainly, to
learn more if you're interested.
>> OK, I have one final thing.
Sorry.
Any questions?
I didn't pause to wait if anybody had any questions about that.
>> Is anybody going to be a CS Concentrator?
Or thinking about it?
One, two, three, four.
One-- only one.
Anna's is the only hand that's raised authoritatively.
OK, that's cool.
Assam, what are you going to do?
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER: Constantine?
>> AUDIENCE: Physics.
>> SPEAKER: Whoa, that was fast.
You had a bad experience in CS50?
[INAUDIBLE], what are you going to do?
>> AUDIENCE: I have no idea.
>> SPEAKER: Curt?
>> AUDIENCE: Econ or CS.
>> SPEAKER: Econ or CS.
Tom?
>> AUDIENCE: I'm doing Stat.
>> SPEAKER: Stat?
OK.
What are you?
>> AUDIENCE: Me?
>> SPEAKER: Yeah.
>> AUDIENCE: Stat.
>> SPEAKER: Stat.
Oh, there you go.
Tom, talk to Alden.
Emily, what are you?
>> AUDIENCE: Biomedical--
>> SPEAKER: Are you in this section?
>> AUDIENCE: No.
>> SPEAKER: OK, that's Emily.
She's my friend.
Clearly not that good of a friend, because she gives me a hard time.
You could be nicer to me in front of everyone, my student--
>> AUDIENCE: I'm doing your Q guide.
>> SPEAKER: Really?
Uh oh.
OK, you're amazing.
I love you so much.
Oh boy.
>> Anyway, I, last night, like everything--
I'm sure everybody seems really stressed right now.
I don't know, are freshman-- are you guys feeling stressed?
I'm feeling stressed.
It was like, you go home for Thanksgiving.
You're like, I'm going to do all these things.
>> AUDIENCE: It's so different.
>> SPEAKER: Yeah, and you come back.
Jeff, you don't feel that way?
>> AUDIENCE: I just thought I'd do a little bit.
>> SPEAKER: OK, great.
So I come back, and I haven't done anything.
And it's all super stressful.
And I'm concerned, genuinely concerned, about whether or not I'm
going to finish everything I have to.
But last night, I was not stressed, I was just a little bit sad.
So I wrote in my journal about what I was sad about.
And I was sad about this section in this class coming to an end.
>> So I was just going to read for you guys a little snippet of my journal,
from last night.
Can I get some napkins, some tissues from Tom?
No, I'm going to cry.
I don't cry.
Not that you can't cry, I just don't cry.
I don't even know if my tear glands worked-- tear ducts.
I haven't cried in a long time.
>> AUDIENCE: [INAUDIBLE].
>> SPEAKER: OK, thanks.
OK, there's a little preface--
there's some other parts of my journal entry, because I try to journal every
night before I got to bed.
I highly recommend journaling.
It helps you process things, and also be very appreciative of your day.
And it makes it a lot easier to look back on your day and realize that
there were a lot of good things that happened.
Even if you feel really stressed at night or really upset, or
really sad or tired.
>> Oh, my god.
I don't even know if it's written that well because I didn't proofread it.
But we'll read it.
I usually don't read my journal, obviously.
>> "Tomorrow, I'll teach my final CS50 section of the year.
It's crazy how fast time flies.
Yet, I'm struck by just how different my experience teaching this year was
than when I was a sophomore.
For starters, I definitely know the material better.
But don't tell my first cohort of students that.
More importantly, however, I realized that the joy that comes from standing
up in front of a room of what starts out as strangers, but ends up as, at
least, Facebook friends, is not a first-year fluke.
Rather, it's from knowing that, in some small way, you're helping
talented, thoughtful, delightful, and passionate people learn a bit more
about computer science.
>> You're shifting that light bulb just a bit in its socket, so that it's able
to shine brighter than you, or they, could have imagined at semester start.
You're helping turn those frowns upside down and asking questions that
provide support, but still allow students to stand up on their own.
>> It's certainly not an exaggeration to say that this section is my favorite
part of the week.
Or even that I hesitate to say, that's all, at 5:30 PM each week, knowing
that it'll be way too long until we meet again.
>> Yet, I'm incredibly thankful to everyone who's given me this
opportunity to give back to others.
To David, for his patience and trust.
To the film and production crew, for making me look somewhat respectable.
And, most importantly, to my students, without whom I'd have no reason to
spend 10 hours figuring out the best way to draw pointers, or lay out a
table of dolphins, via JavaScript.
As always, it's been a blessing."
>> So with that, thank you guys.
I'll see you all at the CS50 fair, and the hackathon, if you're there.
And if you have questions, I'll stick around until there are no more.
But I thank you guys for a wonderful year.
>> [APPLAUSE]
>> SPEAKER: I might cry.