Placeholder Image

Subtitles section Play video

  • [Introduction]

  • DAVID MALAN: This is CS50, Harvard University's introduction

  • to the intellectual enterprises of computer science

  • and the art of programming.

  • My name is David Malan, and if you are among those

  • in the room who are thinking, why am I in a class of computer science,

  • realize that I too felt that exact same way.

  • In fact, my freshman year, I didn't quite

  • get up the nerve to take this class or computer science more generally,

  • and that was largely because I was intimidated by it.

  • I was a little nervous.

  • It felt well out of my comfort zone.

  • And I really didn't know at the end of the day what it actually was.

  • But realize if you, too, are feeling a little bit of that,

  • or even if you're among those more comfortable who

  • have dabbled in computer science or programming,

  • realize that there's so many blanks that we can fill in along the way

  • so that ultimately, at the end of the semester, everyone

  • will feel themselves on the same page.

  • And until then, rest assured that 68% of the people sitting to your left

  • and to your right and behind and in front

  • have never taken a CS course before, which may very well be

  • the demographic into which you fit.

  • But realize, too, that with such an amazing support

  • structure with so many office hours and sections and materials and beyond,

  • realize that what's ultimately important in this course

  • is not so much where you end up relative to your classmates

  • in week 10, our final week, but where you end up relative to yourself

  • in week zero.

  • And indeed, that is where we now are.

  • And as it turns out, computer scientists start counting at zero.

  • And so over the next 11 weeks, we will take you

  • from being among those less comfortable or perhaps

  • somewhere in between less comfortable and more

  • to feeling much more comfortable and confident and capable than that.

  • But to get there, we need to understand what computer science really is.

  • And this was something I didn't understand until I set foot in a room

  • like this.

  • And I dare say we can distill computer science into just this picture.

  • Computer science is about problem solving.

  • And I know that high school courses typically do kind of paint

  • a misleading picture that it's only about

  • and it's entirely about programming and people with their heads

  • down in the computer lab working fairly anti-socially on code,

  • but the reality is it's all about solving problems, and very often,

  • solving problems collaboratively either in person or by leveraging code,

  • programs that others have written in the past.

  • And what does it mean to solve a problem?

  • Well, you need inputs.

  • So there's a problem you're trying to solve.

  • That is the input.

  • And you want output.

  • You want the solution to that problem.

  • And the sort of secret sauce of computer science

  • is going to be everything in this proverbial black box

  • in the middle over the next several weeks,

  • where you begin to understand exactly what you can do with that.

  • But in order to start solving problems, we kind of just

  • need to decide as a group how we're going to represent these problems

  • and what might a problem be.

  • Well, in this room, there's a whole bunch of people.

  • If we wanted to take attendance or count the number of people in this room,

  • I might need to start keeping track of how many people I see.

  • But how do I represent the number of people I see?

  • Well, I can do it sort of old school and I can just take out a piece of chalk

  • or whatnot and say, all right.

  • I see 1, 2, 3, 4, 5.

  • I can do little stylistic conventions like that

  • to save space and remind myself.

  • 6, 7, 8, 9, 10, and so forth.

  • Or I can, of course, just do that on my own hand.

  • So 1, 2, 3, 4, 5, and so forth.

  • But obviously, how high can I count on just one hand?

  • So 5 you would think, but that's just because we haven't really

  • thought hard enough about this problem.

  • It turns out that with just these five fingers, let alone these five more,

  • I can actually count rather higher because after all, the system

  • I'm using of hashmarks on the board or just

  • now with my fingers is just kind of keeping my fingers down and putting

  • them up to represent ones, really.

  • But what if I actually took into account the order of my fingers

  • and sort of permuted them, so to speak, so that it's really patterns of fingers

  • that represent the number of people in the room,

  • and not just the mere presence of a finger going up or down.

  • In other words, this can remain zero.

  • This could still be one.

  • But what if two is not just this, the obvious?

  • But what if it's just this?

  • So raising just one, my second finger.

  • What if, then, three is this?

  • So we have 0, 1, 2, 3.

  • That's going to lead us to four somewhat offensively.

  • But if we begin to jump ahead to five, I might now

  • permute this finger and this finger up.

  • And if I want to now represent six, I could do this.

  • And now seven.

  • In other words, I've expressed so many more patterns on my hand already

  • and if we keep doing this, I think I can actually

  • represent painfully perhaps like 32 different patterns, and therefore

  • 32 different people, on my hands alone.

  • Or 31 people if I start counting at zero.

  • So what is that-- what's the relationship

  • and how did we even get here?

  • Well, it turns out that computers are kind of simplistic,

  • much like our hands here.

  • At the end of the day, your computer is plugged into the wall

  • or it's got a battery, so it either has or it does not have electricity.

  • At the end of the day, that is the physical resource

  • that drives these things and our phones and all of technology today.

  • So if there is either electricity or not, that kind of maps nicely

  • to no finger or yes finger.

  • And indeed, computers, as you probably know, only speak what language?

  • What alphabet, so to speak?

  • Yeah.

  • Binary.

  • Bi meaning two.

  • And indeed, that refers to the fact that in binary in computers,

  • you only have two digits--

  • zero and one.

  • We humans, of course, have 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

  • and then we can combine those to count even higher.

  • But computers only have 0, 1, and then that's it.

  • Because at the end of the day, there's actually

  • a direct mapping between power being off and it being a zero or power being on

  • and it being one, or some electrons or whatever flowing from your battery

  • or from the wall.

  • So this is why computers tend to speak only binary,

  • because at the end of the day, it just maps really cleanly

  • to what it is that's powering them in the first place.

  • But how is this actually useful?

  • If computers only have zeros and ones, how can they do anything useful?

  • Well, think about our human world, where you might have this pattern of symbols.

  • This is decimal, dec meaning 10 because you have 0 through 9.

  • And this is, of course, 123.

  • But why?

  • If you haven't thought about this in quite some time,

  • this is really just a pattern of three symbols, one and two and three shapes,

  • or glyphs, on the screen.

  • But we humans, ever since grade school, have started ascribing meaning

  • to each of these numbers, right?

  • If you think back, this is the ones column, this is the tens column,

  • this is the hundreds column, and so forth, and we could keep going.

  • And so why does this pattern-- one, two, three-- mean 123?

  • Well, it's because all of us sort of intuitively

  • nowadays are just quickly in our head doing 100 times 1 plus 10 times

  • 2 plus 1 times 3, which of course gives us 100 plus 20 plus three,

  • and then the number we know mathematically as 123.

  • But we're all doing this so quickly, you don't really think about this anymore.

  • Well, computers work fundamentally the same way.

  • They don't have as many digits--

  • 0 through 9-- as we do.

  • They only have zeros and ones.

  • And so if they were to store values, you're

  • only going to see zeros and ones on the screen,

  • but those zeros and ones just mean different things.

  • Instead of having a ones place, tens, a hundreds,

  • they're going to have a ones place, a twos place, a fours place,

  • and then eights and 16 and beyond.

  • Now, why?

  • Well, one and 10 and 100, turns out those are powers of 10.

  • 10 to the 0 is technically 1.

  • 10 to the 1 is just 10.

  • 10 to the 2 is 100.

  • And that's why you have ones, tens hundreds, thousands, and so forth.

  • Computers are apparently using powers of 2.

  • Not surprising.

  • Binary-- two.

  • So if you only have ones, twos, and fours as your placeholders,

  • if a computer were storing these digits--

  • 0, 0, 0-- that computer is presumably storing what number so far as we

  • humans understand it?

  • Well, that's how a computer would store zero.

  • If a computer is storing literally 0, 0, 0, just

  • like in our human world, that also is 0, but that's technically

  • because it's 4 times 0 plus 2 times 0 plus 1 times zero, which is obviously

  • zero.

  • Meanwhile, if a computer is actually storing not just,

  • say, 0, 0, 0, but instead is storing this value in binary,

  • what does that map to in decimal?

  • So that's one.

  • And now, why, if we change this 0 and 1 to this value here, is this two?

  • Well, mathematically, for the exact same reasons.

  • And so earlier, I had five fingers, but if you consider just my first three,

  • when I did this holding up one finger, I was representing two.

  • And if I want to represent three, recall that I put up the second finger.

  • And so the reason that could nicely represent three

  • is because all I was doing with my human hand was counting in binary.

  • And I could keep counting more and more and more.

  • And so if I have five fingers or five bits, bit meaning binary digits,

  • I could count up, it turns out, if we do the math,

  • as high as 31 by starting to zero.

  • It's going to be hard to physically do that, but we could.

  • So why is this useful?

  • At the end of the day, a computer, therefore,

  • can represent any number of values from 0 to 1 to 2 to 3 to some number much,

  • much, much higher than that.

  • All it needs is enough bits, enough zeros and ones.

  • Well, what are those bits?

  • Well, all of us have these days in our phones sources of light, for instance.

  • So I could actually say that this physical device right now--

  • might be a little hard to tell--

  • it does have a flashlight and it's technically off at the moment.

  • But if I turn this flashlight on, thereby using some of the electricity,

  • now, I'm storing a one.

  • And so the phone is on.

  • Now, it's off.

  • Now, it's on.

  • And if I see--

  • can I borrow someone's phone real quick?

  • May I?

  • OK.

  • And flashlight.

  • How do I turn on the flashlight?

  • Oh.

  • Shake it.

  • That's OK.

  • OK.

  • Thank you.

  • Oh.

  • Thank you.

  • OK.

  • So this is great.

  • Now, I can count higher.

  • Now, this represents the number what if I have two light bulbs or two switches

  • on at the moment?

  • Yeah.

  • Three.

  • Because I have a one, I have a one, and I

  • have two, which of course is going to end up equaling three.

  • And if I pick up a third phone somehow, I could count even higher.

  • Technically, if I had three light bulbs on--

  • one, one, one-- what would that value be?

  • Seven.

  • Because it's a four plus a two plus a one, and so forth.

  • Thank you so much for the spontaneity.

  • So why does this not lead to limitations for us?

  • I can count in decimal as high as I want.

  • I can now count in binary as high as I want, so long as I have enough bits.

  • But how do I actually represent other information?

  • Well, if I want to represent something like a letter, how do I get there?

  • If computers only have electricity in them and they use binary to count,

  • and yet somehow they're much more useful than just doing math--

  • they can have text messages and e-mails and websites and videos and more--

  • how do we get from zeros and ones to letters?

  • Well, we-- yeah.

  • Sorry.

  • A little louder.

  • Yeah.

  • We just need to kind of relate the numbers to letters.

  • In other words, all the people in this room just need to decide at some point

  • that, you know what?

  • If we want to represent something like the capital letter A,

  • we just need to decide on a pattern of bits,

  • a pattern of fingers, that's going to represent A.

  • And it turns out humans years ago just unilaterally

  • decided 65 shall be the decimal number that represents capital letter A.

  • And you might guess capital B is represented by what decimal number?

  • 66.

  • And then C is 67 and so forth.

  • And there's a mapping of like 128 or even 256 possible values

  • for all the keys you might see on a typical keyboard

  • in order to represent letters.

  • Now, how does a computer distinguish, though, numbers from letters?

  • Well, just depends on the context.

  • If you're using like a calculator program on your Mac

  • or PC or iPhone or Android, well, the computer, the device,

  • is just going to know contextually, let me interpret this pattern of zeros

  • and ones as actual numbers to do math.

  • But if you're using the SMS app or the messages app on your phone,

  • you're going to actually be in the context of text,

  • and so your phone is going to interpret that same pattern of zeros and ones,

  • or light bulbs being off, or, at the end of the day, transistors,

  • tiny pieces of hardware and computers that are either on or off--

  • it's going to interpret those patterns as just representing a letter.

  • If you're in the context of a text messaging application or Microsoft Word

  • or Google Docs or the like, it completely depends on context.

  • The system we humans came up with just called ASCII, American Standard Code

  • for Information Interchange.

  • The name isn't interesting, but the fact that we all agreed years ago

  • that 65 is A and so forth is what's important.

  • And so for instance, if we look at this mapping here

  • of just the first few letters, what does this mean?

  • If I were to now get a text message and I had the ability somehow

  • to look underneath the hood, so to speak, at the pattern of zeros and ones

  • that someone had just texted me, and that pattern,

  • if I convert it to decimal, technically said, let's say, 72 and 73--

  • so I get a whole bunch of zeros and ones.

  • I do some math and I realize, OK, I just received 72 and 73,

  • but this is texting, and so it's not just numbers my friend is sending me.

  • It's a message.

  • What message did my friend likely send me if he or she sent 72 and then 73?

  • Yeah.

  • Hi.

  • H-I. Because if you skim ahead at the right there,

  • that just happens to be in ASCII the mapping between 72 and 73, H and I.

  • If technically, the message had a third byte, if you will.

  • A byte, if you've ever wondered, is just eight bits.

  • It's convenient to talk not in terms of single bits,

  • where you can't count very high, but with a byte, or eight bits,

  • you can count higher.

  • And so it turns out if I received a third byte, another sequence of eight

  • zeros and ones together--

  • 33.

  • How would we know what this message now is?

  • Yeah.

  • So it turns out you would not know this other

  • than by guessing or Googling or just coming in with this knowledge.

  • This is now "HI!"

  • with an exclamation point because 33 just so happens, if you look it up,

  • to map to an exclamation point, as well.

  • Now, if we actually looked at the binary of this,

  • you would actually see this pattern of zeros and ones.

  • This is how you represent 72 in binary.

  • This is you represent 73.

  • And this is how you represent 33.

  • And notice I've only used one, two, three, four, five, six bits,

  • even though I technically tend to receive things in units of 8,

  • units of bytes.

  • But why did I not bother writing another 00 here and another 0 here?

  • Does it matter when you write these things out?

  • No.

  • Not really.

  • Like in English, in our human world, if you were to write one, two, three,

  • that's 123.

  • If you were to write 0, 1, 2, 3, that's still 123.

  • So even though we tend to get them in clusters of 8,

  • we don't necessarily need to write those when just talking about them.

  • So what have we done?

  • Well, let me introduce a fancier word now known as abstraction.

  • Abstraction is just a term generally used in computer science and we'll soon

  • see in programming for taking some low level-- like literally low level--

  • implementation details, like minutiae even, and understanding them

  • at some point, but then deciding this is not a useful level conceptually

  • to think about problems.

  • I really don't want to solve problems in this world of thinking in 0's and 1's.

  • I'd much rather think about things minimally in decimal, or better yet,

  • in the context of letters if I'm actually receiving text, or even

  • some other representation.

  • So abstraction is about taking fairly low level details

  • and just simplifying them so that we can have a more useful conversation

  • and never again worry about where the electricity is coming from.

  • We can just stipulate my computer can represent zeros and ones.

  • Therefore, it can represent numbers.

  • Therefore, it can also represent ASCII or letters.

  • And we can kind of move on and start solving more interesting problems.

  • But it would seem that we can't solve all problems because on my keyboard

  • here, this American keyboard here, there's a whole bunch of symbols,

  • like a 100 or 200 maybe in total if we actually hit shift and option and all

  • of that.

  • But what you don't see are some pretty common characters.

  • Especially in a very international audience,

  • what can I apparently not even type on this keyboard?

  • What kinds of symbols?

  • Yeah.

  • Anything with an accent.

  • If you have accents over vowels or other letters.

  • What else?

  • I'm sorry.

  • Umlauts or other characters above letters.

  • Yeah.

  • Like pound symbol?

  • Oh.

  • Like the UK pound symbol.

  • Sure.

  • And other countries, too.

  • Any number of Asian languages.

  • There's so many symbols that are not depicted on this keyboard,

  • and yet somehow, all of us with international keyboards or phones

  • can surely express themselves.

  • But that's because phones and computers these days don't just use ASCII.

  • ASCII literally used just eight bits total.

  • Technically seven, but then, ultimately, really eight.

  • And with eight bits, if you actually do the math--

  • if you have eight bits or eight fingers, you

  • can only permute them in 256 total possible ways, which

  • is to say that you can only represent 256 characters using ASCII with numbers

  • underneath the hood, and that's not enough to represent

  • so many different symbols like those enumerated here.

  • You can't represent any of the accents that you can nonetheless

  • type on your Macs and PCs and you certainly

  • can't type these things, which are very much in vogue.

  • Which even though they're pictures, they're actually just characters.

  • Because it turns out some years ago, the world decided eight bits is not enough.

  • Let's start using something called Unicode, where you actually use

  • one or two or three or even four bytes.

  • So eight bits or 16 bits, 24 bits, or even 32 bits to represent characters.

  • And now, we have the ability to represent thousands or even

  • millions of characters.

  • And frankly, daresay, the result of that huge amount of availability

  • is partly why there are so many of these things these days.

  • And they just keep making more because there's just so many different numbers

  • available to us.

  • So Unicode is often a specific version of it called UTF-8,

  • which we'll see before long.

  • But let me ask this question here.

  • This is a crying face with joy, I think this is called.

  • So it turns out, according to Apple or iOS,

  • this is the most popular emoji that at least iPhone people

  • are sending to each other.

  • So when you're receiving this, though, if we can really take the fun out

  • of this, what pattern of bits are you actually receiving from your friend?

  • He or she is clearly trying to express some emotion,

  • but really, what your friend is sending you-- the decimal number 128,514.

  • Or really, if you looked at the zeros and ones coming

  • to you over the internet or airwaves, you're

  • getting this pattern of zeros and ones, which is hardly joyful or hardly

  • descriptive, but all your phone or computer

  • are doing is seeing this pattern of bits,

  • looking it up in like a little cheat sheet, and saying, oh.

  • Whenever I see this pattern of bits in the context of text like texting,

  • I should actually display it as that picture.

  • Now, that picture has a lot of yellow and other colors

  • in it, but how do we even get there?

  • Well, it turns out that this same pattern of numbers--

  • 72, 73, 33-- which just to be sure, a moment ago, meant what?

  • Hi.

  • In the context of a textual program like Microsoft Word, Google Docs, texting,

  • this means hi.

  • But what if you saw this same pattern of bytes--

  • and again, we could draw the zeros and ones,

  • but it's not interesting anymore, so we're going

  • to abstract away at the decimal level.

  • If you got this same pattern of zeros and ones

  • or numbers in the context of like Photoshop or a browser

  • or some kind of photo program, well, it might make more sense

  • to interpret it not as text, but as imagery, some kind of colors.

  • Well, it turns out there's this other system in the world--

  • you might have seen this acronym before--

  • called RGB-- red, green, blue.

  • And this is just a way of humans having standardized years

  • ago that you know what?

  • If we want to represent a dot on someone's screen, otherwise known

  • as a pixel a tiny little square on the screen

  • of your phone, your laptop, or even TV these days,

  • we're going to use three bytes--

  • one byte to specify how much red should be in that specific pixel,

  • one more byte to specify how much green should be combined with red to form

  • that pixel, and then one more byte, a third,

  • to represent how much blue to combine with those other two colors

  • to make a new color all together.

  • So it's kind of like combining paints, except in this case,

  • it's more really waves of light in order to get a specific color using just

  • red, green, and blue as your palette.

  • And so if we were to see this red, green, blue pattern and say,

  • you know what?

  • Give me 72 red, 73 of green, and 33 of blue.

  • If the total possible range that I alluded to earlier is like 0 to 256,

  • or technically 0 to 255 if you start counting in computer science from zero,

  • this is like a medium amount of red, medium amount of green,

  • and just a little bit of blue, if the range goes from 0 to 255.

  • So if you combine these three things together

  • and you want to know what color you get--

  • yeah.

  • So it's kind of a light yellow that looks like this.

  • So if a computer is storing a single dot on the screen that

  • happens to be in yellow, what the computer's actually storing

  • is not this dot physically, but a pattern of three

  • bytes-- how much red, how much green, how much blue should the computer

  • display at this particular point.

  • So if we look at this crying face of joy and we kind of enhance or zoom in

  • on it here, you can actually see it start to pixelate, so to speak,

  • where you start to see the dots.

  • If I punch in a little more, now you can really

  • start to see the dots on the screen.

  • And if I go an even further, you can actually

  • see the tiny little squares that compose this image, most of which

  • at the zoom level are yellow, but a bunch of which are black,

  • a bunch of which are light black or dark yellow.

  • And that's what composes this image ultimately.

  • So this is to say if you count up all of the pixels on the screen

  • and then multiply it by one, two, three bytes, that's

  • how many bytes or kilobytes or megabytes, if you've heard those terms,

  • are going to be stored on your computer just to represent an image.

  • So we've gone from electricity to down here, so to speak, to zeros and ones,

  • to decimal, now to colors.

  • Well, with colors, you can get images.

  • What comes after images?

  • Well, we've all watched videos or movies certainly digitally these days.

  • Well, what is a movie or a video file?

  • How might that be implemented?

  • Say it a little louder.

  • Yeah.

  • It's a collection of images.

  • If you've ever heard of frames per second--

  • like movies tend to be 24 frames per second or 30 frames per second--

  • that just means that a typical movie, every second

  • is showing you 24 or 30 images per second

  • and they're just flying by so quickly that you actually

  • don't notice you're just watching a sequence of static images.

  • It's like as a kid, if you ever had one of those paper flip books where there's

  • tons of drawings in them, and as you flip through the pages,

  • you see things moving, but that's just because your eyes are just

  • seeing little snapshots ever so quickly of something moving on the paper.

  • That's all a video file actually is.

  • So if you have an iPhone and you've ever played with these animojis,

  • so to speak, well, all those are are little video files

  • composed of lots and lots and lots of images

  • that you have saved on your phone or texted to someone else.

  • And if we just think, now, we're at the point of video, but that's OK.

  • Videos are just bunches of images.

  • Images are just bunches of colors.

  • Colors are just patterns of bits.

  • And bits, at the end of the day, are just

  • the result of electricity coming into my machine or transistors

  • turning switches on and off.

  • Like we've all of a sudden to hold this entire story, but none of us

  • ever is going to need to really think about binary in the context of videos

  • because a video is just an abstraction on top of bunches of images,

  • and images are just an abstraction on top bunches of pixels, and so forth.

  • So we can keep painting this hierarchy that

  • just allows us to talk about things at a more useful level,

  • and the reason we had this conversation is

  • just because we needed a way to represent

  • inputs and outputs to problems.

  • Let me pause there for just a second to see if there's any questions.

  • Anything at all?

  • No?

  • All right.

  • So what's inside this black box?

  • Well, it turns out this is where the really interesting work starts

  • to happen and the thought starts to come in.

  • This is the proverbial algorithms, step by step instructions

  • for solving some problem.

  • And some of you might have solved this problem before,

  • either digitally or textually, but of course,

  • if you have contacts in your phone these days

  • and you've got bunches of friends and family,

  • odds are they're alphabetized by first name or last name.

  • And you have auto complete these days, but it really is just

  • a long list of names and numbers.

  • That's not all that different from yesteryear's implementation

  • of the same problem, which was this device here, a phonebook.

  • Now, this phonebook might have a friend of ours in it, say Mike Smith,

  • whose last name starts with S. And I could, of course,

  • if trying to find Mike Smith, start by looking

  • at the first page, the second page, the third page, the fourth page,

  • and eventually, just hopefully find Mike Smith.

  • Indeed, is this algorithm, this step by step process,

  • correct for finding someone like Mike Smith?

  • Yeah.

  • It's correct.

  • It's stupid and slow perhaps because it's

  • going to take forever in a phone book of this size,

  • but it is correct because if Mike's in here, I will, in fact, find him.

  • But I could do this better.

  • I could do it sort of two at a time.

  • So two, four, six, eight, 10-- or imperfectly--

  • 10, 12, 14.

  • Is that faster?

  • Obviously, it's going twice as fast.

  • Is it correct?

  • No.

  • Why is it not correct?

  • Yeah.

  • I might miss him, right?

  • Mike just accidentally might eventually get sandwiched between two pages

  • and I have the unlucky experience of just missing him.

  • Now, is it fixable?

  • Yeah.

  • I can probably, once I hit like SN or the T section, for instance--

  • I can just say, obviously, I've gone too far for Mike.

  • Let me just double back one or just a few pages.

  • So it is fixable.

  • And so long as I've saved time by flying through this twice as fast,

  • can I at least afford to spend a few more steps at the very end just

  • to find Mike Smith?

  • But none of us are going to do that.

  • And our Apple devices and Android devices certainly

  • don't do that for efficiency today.

  • Odds are most of us are going to do what to find someone in any book like this?

  • Yeah.

  • Open to roughly the middle or maybe bias ourselves toward the end

  • because S is after the middle.

  • But you know, I'm in the middle of the phonebook here.

  • And now, if I know that Mike is in the S's and therefore over here,

  • where do I know he's not?

  • He's not in the beginning and I can literally

  • tear a problem like this in half, throw figuratively and literally half

  • of the problem away, and be left with fundamentally the same problem,

  • but it's half as big.

  • I went from like-- whatever--

  • 1,000 pages to 500 pages and I can now repeat this algorithm.

  • I look down.

  • I'm a little too far.

  • I'm in the T section now.

  • OK.

  • I can again tear the problem in half, throw that half away,

  • taking a 500 page byte out, a 250 page byte out, now leaving myself

  • with just 250 pages more.

  • And notice just how quickly I got here.

  • The first two algorithms got me from 1,000 to 999 to 998, or 1,000 to 998

  • to 996.

  • But here, I went from 1,000 to 500 to 250.

  • Feels like we're making up time here.

  • And indeed, if I keep repeating this process,

  • hopefully, I'll be left with just one page of the book

  • that Mike is either on or not, at which point, I will call him.

  • And so that's an algorithm that honestly leverages probably all the intuition we

  • have and a lot of what programming is going to be,

  • is thinking about a problem like this, figuring out how to divide and conquer

  • it, and then expressing yourself in a way

  • that the computer can then solve that problem for you.

  • And just to paint a picture of how much better this algorithm is, well,

  • if this is just a very abstract chart where we have on the vertical,

  • or y-axis, how much time it takes to solve a problem,

  • and on the horizontal axis how big the problem is--

  • so the farther out you go this way, the more pages in the problem,

  • the more pages in the phonebook.

  • And the higher you go up here, the more seconds or page

  • turns it's going to take.

  • That first algorithm is just like a linear slope,

  • so to speak, because for every additional page in the book,

  • it might take me one more second.

  • Right, up.

  • It's just a one for one relationship with pages.

  • The second algorithm, if I plot it, where

  • I'm flying through twice as fast, what is

  • that line going to look like instead?

  • Yeah.

  • It's going to look lower than this one.

  • It's still going to be a straight line because now, there's a two to one

  • relationship, but if you've got a phone book that's got this many pages,

  • and in the first algorithm, it took this long, here,

  • well, in the second algorithm, it will take half as many steps, plus or minus

  • or two if you need to actually double back a little bit.

  • But that third algorithm is what we'll call logarithmic.

  • If n is the number of pages in the phone book,

  • the first algorithm, in the very worst case,

  • might take all n pages to find Mike Smith.

  • The second algorithm is going to take half as many steps because I'm

  • flying through it two at a time.

  • But the third algorithm is going to look and feel like this.

  • It's going to be curved and ever so slowly rising and rising and rising,

  • the implication of which is if Verizon or the phone company

  • doubles the number of pages in the phonebook

  • next year because Cambridge and Somerville merged together in the phone

  • book and we now have 2,000 pages.

  • Well, how many more steps does my third algorithm take?

  • Just one.

  • Because I can take a 1,000 page bite out of the problem

  • with that clever algorithm, whereas my first two algorithms would take it

  • one or just two pages at a time.

  • So that is to say we have to hugely increase the size of this problem

  • just for the number of seconds or page turns to appreciably actually increase.

  • And so as we start to learn about programming,

  • it's, again, going to be leveraging of this intuition in order

  • to actually solve problems and code more effectively than we

  • might without that intuition alone.

  • So let's formalize this now.

  • So that was kind of a very intuitive way of dividing and conquering a problem.

  • Just kind of made sense to go in the middle,

  • tear it, then go to the other half or the other half

  • and tear it again, and so forth.

  • But a computer, even as cool as Alexa and Google Home and all of this are,

  • you can't really just talk to them as another human

  • and have them execute things correctly.

  • I struggle just to get Siri to set a timer on my phone.

  • So we're not quite there yet, so we're still at the age

  • where we have to be ever so precise with computers,

  • voice activated or otherwise, and so thus enter pseudocode for now.

  • Pseudocode has no formal definition.

  • This is just a way of saying use English like syntax or any spoken language

  • and just express yourself succinctly and correctly

  • so that a computer or a robot or even another person

  • can understand what it is you're trying to say.

  • So here, I propose, is an algorithm written

  • in pseudocode, English like syntax, that just gets my point across.

  • And I could write this in any number of ways.

  • I've numbered the steps from zero on up, just for the sake of discussion,

  • but this would seem to capture what I did there.

  • Pick up the phone book.

  • Open to the middle of the phone.

  • Look at the names.

  • If Smith is among the names, call Mike.

  • Else, if Mike Smith is earlier in the book,

  • go to the left, specifically the middle of the left half of the book,

  • and then go back to step two.

  • Because indeed, I was just doing the same thing again and again,

  • and the reason I wasn't doing it forever was because every time I

  • repeated myself by opening and tearing, I was shrinking the problem.

  • And I can only shrink a problem of some fixed finite size

  • so many times until I get just one page, and so

  • if I continue this logic looking to the right or to the left or just quitting,

  • if I don't find Mike at all on the last page,

  • this would seem to capture more precisely that code.

  • Well, let's actually excerpt from this now a few concepts

  • and then start to apply them to actual code.

  • Highlighted in yellow here, I dare say, are all of the verbs or actions.

  • These are the functions, as we're going to start calling them,

  • in this algorithm.

  • A function is just a specific step, a specific action

  • you take in order to do something.

  • And so in yellow here-- pick up, open to, look at, call, open, quit

  • are all actions or verbs.

  • Are henceforth, we'll call them functions.

  • Meanwhile, highlighted in yellow here-- if, else if, else if, else.

  • These are kind of starting to ask questions.

  • What might these be called if you have some familiarity?

  • Yes.

  • Turns out many programming languages, if you've seen any before,

  • would call these conditions.

  • They're branches, or proverbial forks in the road.

  • If this is true, go this way.

  • Else, maybe go this other way, or perhaps a third or fourth direction

  • altogether.

  • Meanwhile, if we actually look at these highlighted phrases--

  • if Smith is among names or if Smith is earlier in book

  • or Smith is later in book--

  • these are the specific questions we're asking in order to make that decision.

  • These are known as Boolean expressions, named after a gentleman

  • by the last name of Boole some years ago.

  • And so a Boolean expression is just a question

  • that has a yes or no answer, a true false answer, a one zero

  • answer, if you will.

  • And that's a nice mapping to what computers are really good at.

  • So within conditions, you have Boolean expressions

  • to decide which fork in the road you want to go down.

  • And then lastly, highlighted in yellow here

  • is go back to step 2 in a couple of places.

  • This is inducing some kind of cycle or loop

  • that's telling the computer to do something again and again and again.

  • So in short, we have these building blocks already conceptually.

  • And it turns out, we can now start to translate these

  • to an actual programming language.

  • The first of the languages we'll introduce in CS50

  • is something called Scratch.

  • Turns out this is not a text based language,

  • like in my English pseudocode there, but it's graphical

  • and things look like puzzle pieces that you can drag and drop

  • and they interconnect if it makes logical sense to do so.

  • And in fact, some of you might have played this back in the day as kids

  • or even more recently because it's actually targeted typically

  • at students in like after school programs who

  • just want to learn more methodical, more algorithmic, or computational thinking.

  • And we're going to use it to explore not only these building

  • blocks, but a few others, as well.

  • It turns out in the other languages we'll explore in CS50 and beyond,

  • are languages like C that we'll actually transition to as quickly as next week,

  • to then translate what we do this week in Scratch to next week in C.

  • And in languages like Python and JavaScript

  • and SQL, which we'll also explore, do we have other capabilities--

  • the ability to store data in variables, so to speak,

  • to use threads, which means get the computer to do multiple things at once,

  • events, to mean listen for things happening, like a click

  • on the page or a human typing or even saying something.

  • We'll be able to do all of the things that you take

  • for granted in your very own phones.

  • And we'll do this first by way of this guy.

  • So this is Scratch, the default cat that comes with this programming

  • language from MIT's media lab.

  • And via Scratch can we start programming him to move up,

  • down, left, right, say something, utter something, and other commands

  • all together.

  • In fact, let me go ahead and switch contexts here

  • to show you the very first thing I ever wrote in Scratch.

  • It was back in the day when I was in graduate school

  • and Scratch had just been invented by MIT.

  • Let me go ahead and open this.

  • And I called it Oscar Time.

  • And if we could perhaps have a volunteer come on up for just a moment.

  • You have to be comfortable being on stage and on the internet.

  • How about here in the white shirt?

  • I saw your hand first.

  • Come on down.

  • So this is Oscar Time.

  • It's implemented in a language called Scratch.

  • And at the end of the day, all that is underneath the hood of this program

  • is functions and loops and conditions and a few other of these concepts.

  • Hi.

  • What's your name?

  • AVIVA: Aviva.

  • DAVID MALAN: Aviva.

  • David.

  • Nice to meet you.

  • Come on over here.

  • And in just a moment, I'm going to go ahead and click

  • the green flag at the top left hand corner, which

  • is going to play this game.

  • And we'll see on the screen the instructions.

  • [MUSIC PLAYING]

  • OSCAR: (SINGING) Oh, I love trash.

  • Anything dirty or dingy or dusty.

  • Anything ragged or rotten or rusty.

  • Yes, I love trash.

  • If you really want to see something trashy, look at this.

  • I have here a sneaker that's tattered and worn.

  • It's all full of holes and the laces are torn.

  • A gift from my mother the day I was born.

  • I love it because it's trash.

  • Oh, I love trash.

  • Anything dirty or dingy or dusty.

  • Anything ragged or rotten or rusty.

  • Yes, I love trash.

  • Here's some more rotten stuff.

  • I have here some newspaper 13 months old.

  • DAVID MALAN: All right.

  • Everybody, give a round of applause for Aviva for coming on up.

  • Thank you.

  • Here.

  • Aviva.

  • [APPLAUSE]

  • A little CS50 stress ball.

  • So suffice it to say, if you're tired of this song,

  • consider how tired I was eight hours later while debugging and building

  • this program.

  • But consider what it is we just saw.

  • It's this interactive game and stuff is animated and music is playing.

  • But if you focus on decomposing, so to speak, this program into just

  • basic building blocks, this is just kind of a big abstraction over some lower

  • level pieces of functionality.

  • Like this trash can here.

  • At the moment, it's just a picture, and on occasion,

  • as soon as Aviva dropped something into the trash, the lid came up

  • and Oscar came out, he said something, and then he went back down.

  • But that animation is super simplistic.

  • It was just a sequence of 1, 2, 3, or so images displaying and then

  • going back down to create the illusion of animation.

  • Meanwhile, every time Oscar said something,

  • that was keeping track of her score in what's called a variable.

  • In algebra, you have x and y and z, but in programming, you have the same idea,

  • but it's generally more useful to call them more descriptively,

  • like your score.

  • And so there's probably a variable in this game called

  • score that was just keeping track of how many times

  • Aviva had dropped something into the trash.

  • Meanwhile, the trash itself and the shoe and the newspaper-- and even more

  • things happen eventually-- were falling from the sky

  • at sort of random locations, and that's because I programmed the game

  • to sort of start the trash here or over here, just

  • to make it a little more challenging as the game picked up.

  • And in fact, things start falling faster and faster over time,

  • like a typical game, getting more and more difficult.

  • So how do we get to something like that?

  • Well, let me go ahead and open up Scratch itself

  • and introduce the environment.

  • So in Scratch, you essentially have three general areas.

  • And it's web based, and so you can do this on any computer.

  • And in the left hand side here, you have those puzzle pieces

  • to which I referred earlier.

  • These puzzle pieces are all mapping to functions or loops or conditions

  • or variables, things that we saw before, and I'm

  • going to able to drag and drop them into the middle in order

  • to interconnect them and write my program,

  • which we'll do in just a moment.

  • Meanwhile, Scratch lives in this stage, this world, where he can move up,

  • down, left, right.

  • You can change what Scratch looks like.

  • You can add other characters, otherwise known as sprites,

  • in order to have multiple things happening at once.

  • And of course, you can fullscreen it.

  • And so the Oscar Time game a moment ago was actually a whole bunch of sprites.

  • Oscar's trash can was one.

  • Each piece of trash was another sprite.

  • The newspaper was a sprite, and so forth.

  • So each of them were separate programs running in parallel at the same time.

  • So let's actually make him do something.

  • It turns out that if I jump down to, say, events,

  • I'm going to see one of the most powerful blocks

  • from the get go, which is this when green flag clicked.

  • That's indeed how I started the game with Aviva,

  • by clicking just above Scratch's world this green flag.

  • And if I wanted to stop it, as I did, you

  • can click the red stop sign to say stop.

  • Meanwhile, the green flag, I can constantly

  • listen for by dragging and dropping this puzzle piece.

  • When the green flag is clicked, what do I want to do?

  • Well, let me go up to looks.

  • And these are just different categories.

  • And we can scroll through all the different colorful blocks,

  • but they pretty much just do what they say.

  • I'm going to go under looks, where I know there to be a block that's called

  • say, and I'm going to go ahead and type the most canonical computer science

  • thing-- hello world--

  • in this box.

  • So notice that functions themselves can actually

  • take inputs and the input to this function, say,

  • is going to be hello world.

  • If I now go over to the green flag and click it--

  • hello world.

  • All right.

  • So not all that difficult. Not all that interesting.

  • But it actually got the job done, and so my program is indeed just this.

  • Well, how might I make this a little more interesting?

  • Just saying, hello world all the time isn't all that compelling.

  • Well, you know what?

  • Let me think.

  • Let me undo this.

  • Let me scroll down to sensing.

  • And notice this.

  • Functions can also take input from a human

  • and functions can hand you back a value, a so-called return value.

  • So this block here, ask something-- by default, it says,

  • what's your name and weight--

  • is another function built into Scratch that allows me to do this.

  • So I'm going to go ahead and drag this here

  • and I'm going to let it say, what's your name?

  • Notice now that below this block is a special block,

  • whatever it is the block returns.

  • So answer is whatever the human is going to type in.

  • And if I want to now say what the human typed in, let me go again to looks.

  • Go to say.

  • And notice that these blocks are kind of magnetic.

  • They want to snap together.

  • So I'm going to go ahead and let go there.

  • And if I go back to sensing and grab answer,

  • notice that even though it's not quite the same size,

  • it's going to grow to fill, and now, I can

  • have my program ask the user what his or her name is and then

  • say whatever that answer is.

  • So let me go ahead and stop and click play again.

  • Notice it's asking me for my name, so let me go ahead and type in David.

  • Enter.

  • OK.

  • It's a little weird way to greet someone.

  • David.

  • So it'd be nice to clean that up a bit.

  • So you know what?

  • I know this only from having poked around before.

  • Not all of this is obvious at first glance.

  • But it turns out that under operators, the category,

  • there's this thing here-- join apple and banana.

  • Which are just default values.

  • You can change them.

  • Because what do I want to do?

  • I want to say hello, David, or whoever, so I kind of want to say hello, comma,

  • and then, David-- whatever the human typed in.

  • And that's what join lets you do.

  • It lets you join or concatenate two phrases that are somehow

  • provided by you or the user.

  • So let me pull this out, the answer.

  • Let me go ahead and grab the join block.

  • Notice it, too, is going to grow to fill.

  • Let me go ahead and say, hello, comma, space, and now, drag answer into there.

  • And notice this nesting.

  • Just like in math.

  • This nesting of functions.

  • I can first join hello and answer by taking those two things as input

  • and then pass them to say as another input

  • because these things are layered on top.

  • And so now, if I stop this and play it again and say, David--

  • hello, David.

  • Now, we have the makings of a more interesting interactive program

  • that isn't just hardcoded.

  • Of course, it's not nearly as audible as something like Oscar Time a moment ago.

  • So let me go ahead and do this.

  • Let me start over altogether and treat Scratch like the cat he is

  • and just start the sound called meow.

  • So it turns out there's a category of blocks called sound,

  • and within sound, there is play some default sounds.

  • So start sound meow.

  • And now, things will get a little cuter.

  • [MEOW]

  • Aw.

  • And now, again.

  • [MEOW]

  • And I can kind of simulate a cat by [MEOW] standing here for a while

  • and keeping to click this button.

  • But you know what?

  • Let me make him meow few times because that's more realistic.

  • So let me grab a second one and a third one.

  • And you can get this infinite supply of blocks.

  • Let me hit play.

  • [MEOW]

  • Seems like a bug.

  • Let's try again.

  • Play.

  • [MEOW]

  • This is my first bug, or mistake.

  • This looks correct.

  • It says when green flag clicked, start sound meow, start sound meow,

  • start sound meow.

  • Why am I only hearing one meow?

  • Yeah.

  • They're kind of at the same time or so close to the same time

  • that the sounds are kind of tripping over each other and just overlapping,

  • right?

  • The block literally says, start sound meow.

  • But computers are really fast.

  • If you've heard of the expression gigahertz, that's a unit of measure.

  • And if your computer has a one gigahertz CPU, central processing unit, or brain,

  • that means it can literally do like a billion things per second.

  • It can certainly start three sounds super fast.

  • And if they're effectively all happening one after the other

  • before the sound even finishes, you're just hearing one net effect.

  • So how can we fix this?

  • Well, I can actually go and fix this with this block here--

  • play sound meow until done.

  • Play sound meow until done.

  • And now.

  • [MEOWING]

  • OK.

  • It's a little unhappy, this particular cat,

  • but at least it's now more correct.

  • And, as it turns out, if I go to control--

  • you know what?

  • There's this block here-- wait some number of seconds.

  • I can go ahead and insert this here.

  • Let me do another one here.

  • And now, hit play.

  • [MEOWING]

  • You know, it's not bad.

  • It now sounds a little more realistic.

  • But honestly, if I keep doing this-- or you know what?

  • You can actually right click or control click on blocks,

  • duplicate them, and just copy and paste even more if you want them.

  • So if I were to do this, now, it's just going to go six times.

  • And then I could copy it again and go 12 times.

  • But there's got to be a better way, right?

  • This is now bad programming.

  • This is bad design.

  • Because I'm literally copying and pasting, albeit, graphically.

  • But we've already seen a building block with which

  • we can design this program better.

  • It's correct, but it's not well designed.

  • What would the building block be that I need to make this a little cleaner?

  • OK.

  • A four loop.

  • Doesn't quite exist in Scratch.

  • But a loop fundamentally does something cyclically.

  • And indeed, if I go under control and start poking around,

  • you'll notice that there's a few blocks that might apply here.

  • There's the repeat block some number of times

  • or the forever block, both of which sound like loops, or cycles.

  • So sure enough, let me go ahead here and I can throw away blocks

  • by just dragging them to the left.

  • Let me pull this out for a second.

  • And then just say forever play this sound, and then wait one second.

  • So now, my program looks like this.

  • [MEOWING]

  • You know, we'll never know if it's technically correct because it's just

  • going to go, we think, forever, but it looks like this is correct.

  • And it was a lot less code and it's a lot easier

  • to maintain because if I want him to kind of get sleepy,

  • I can then maybe say two seconds instead.

  • [MEOW]

  • You know, and we can adjust this on the fly as we go.

  • But let's start to combine some of these ideas

  • now and change what it is the ultimate effect is.

  • Let me go ahead and open an example I made in advance.

  • This one's called Count Zero.

  • And we'll put this on the website later so that you can play with if you like.

  • And this is kind of the opposite of counting sheep.

  • Rather than me or the person sleeping counting sheep,

  • this sheep will count itself.

  • So let me go ahead and just play.

  • And adorably, he seems to just be counting 1, 2, 3.

  • But why is that?

  • He's just going to count forever.

  • But let's look at the blocks with which he is counting forever.

  • When green flag clicked, set counter.

  • Turns out this orange box is what we called a variable.

  • So in algebra, it would be like x or y or z.

  • Those are not descriptive.

  • I called this one counter instead, but I could have called it x or y or z.

  • And then I forever say the counter for one second, then wait one second,

  • and then change the counter by one, which

  • technically means just increment it.

  • Add 1 to it.

  • And the sheep is just going to therefore count up and up and up.

  • Now, this is a little tedious, but that's

  • kind of the point of counting sheep, of course, to fall asleep.

  • But what if the sheep actually kind of liked counting a little faster?

  • Well, let me go under operators here.

  • Multiplication sounds like it could get us places quicker.

  • And let me go ahead and go to variables.

  • And instead of changing the counter by one,

  • let me go ahead and just keep setting it to something else.

  • So let me drag and drop this.

  • Set the counter equal to something times something, specifically

  • the counter times two, thereby doubling, doubling, doubling, doubling.

  • That would seem to grow, so to speak, a lot faster.

  • Let's see.

  • 1, 2, 4.

  • So he's counting faster, but it's still kind of tedious.

  • What if we instead do this?

  • Let's stop waiting and let's go ahead and, with the looks,

  • not say counter for one second, but let's just quickly say counter.

  • So I'm going to say the counter.

  • Whoops.

  • I'm going to say the counter and then I'm going to set it to itself times 2.

  • So here's where we're at.

  • Initialize, or set the counter to 1 initially, say it, then double it,

  • then double it, then double it, saying it along the way.

  • So here we go.

  • That's impressive.

  • So now the sheep has counted up to 10 to the 60th so far.

  • 10 to the 100th.

  • OK.

  • Now, it doesn't even fit in the speech bubble, but he's still going.

  • How high can he go?

  • What's the biggest number you can count to in a computer?

  • Anyone want to guess?

  • Could be here a while.

  • 10 to the 270th now.

  • How high can you count, or rather--

  • OK.

  • So we gave up and just called it infinity.

  • So it turns out infinity does have a precise value--

  • 10 to the 250th or so.

  • But what happens here?

  • Well, because computers, at the end of the day,

  • are just storing information digitally-- but that information digitally has

  • to be physically stored using electricity, using these lower level

  • switches called transistors.

  • At the end of the day, my phone, my laptop, whatever device in question

  • only has a finite amount of those things.

  • I only have a finite number of fingers.

  • Using unary, my old school hashmark approach,

  • I can count to five on this hand.

  • Using binary, I claimed I could count to 31 on this hand.

  • But it's still finite.

  • I cannot count to infinity on this hand because I only have five fingers.

  • Similarly does a computer only have so many transistors or so

  • many bytes or bits of memory, and at some point,

  • the programmer has to think about what is he

  • or she going to do when the user wants to count so high that you

  • can't physically fit it anymore.

  • You have to give up like this and say something semi accurately

  • or you have to handle that issue in some other way.

  • And we'll see when we get to C that how you handle this problem is not

  • necessarily straightforward, and indeed a lot of software

  • out there does not handle this problem.

  • And odds are, all of us have programs that if you

  • type big enough words or big enough numbers into them,

  • they might very well break or crash or freeze

  • because the humans, unlike MIT, did not anticipate that that might actually

  • happen and handle it.

  • Well, let me go ahead and do this.

  • Let me open up this program and see if we can't read the code now.

  • This is called Pet Zero and this is a program that simulates petting.

  • So if I click play and don't touch the keyboard,

  • nothing seems to be happening, but if I now move my cursor over to the cat--

  • [MEOW]

  • Aw.

  • It's kind of cute.

  • [MEOW]

  • Right now, it's more only meowing on demand when you pet the cat.

  • Why?

  • Well, notice I've added some other building blocks.

  • We haven't used this one before, but it intuitively

  • probably makes pretty clear sense.

  • When the green flag is clicked, forever do the following.

  • If the cat is touching the mouse pointer-- this thing in blue

  • is what we called earlier a Boolean expression.

  • It has a yes/no, a true/false, a one/zero answer.

  • And touching mouse pointer is one of the options in the little drop

  • down here if you tinker with it.

  • So if the cat is touching the mouse pointer, then and only then,

  • play sound meow until done.

  • So we've combined now functions with loops with a condition.

  • But why the loop?

  • The cat's only meowing once when I pet him.

  • Why am I doing anything forever here?

  • Someone-- yeah.

  • Yeah.

  • I might want to pet it again, so I want the program to anticipate that.

  • And honestly, if I omitted this forever block and my program

  • instead looked just like this--

  • so let me get rid of that and this--

  • and then I clicked play, and now, I hover over him,

  • why is it not working even once?

  • Say it again.

  • Yeah.

  • So I mean, at this point, if I can summarize,

  • the computer is so damn fast that this already

  • happened by the time I moved my cursor over to the cat, and at the moment

  • I clicked play, I was not touching the cat.

  • Those blocks executed, so to speak, top to bottom.

  • That's it for the program.

  • So by the time I move the cursor over to the cat, the program is over.

  • It's not listening.

  • And so forever, this way I can actually listen in perpetuity for something

  • to actually happen.

  • What if I want to do something not just if something is true,

  • but handle two cases?

  • If or else.

  • Well, let me go ahead and open up Pet One.

  • And this is another example.

  • And could someone perhaps describe, after reading this code, what

  • this program is going to do instead?

  • Yeah.

  • Exactly.

  • And let me summarize more verbally.

  • So if this time, you're touching the cat, it's going to roar instead.

  • Else, it's just going to meow sweetly.

  • So this time, it is meowing perpetually once every second,

  • but if you touch this particular cat, it doesn't like it.

  • So play.

  • [MEOW]

  • Meow.

  • [MEOW]

  • Meow.

  • [MEOW]

  • And now.

  • [ROAR]

  • Don't touch the cat.

  • So now, we might interact in two different ways

  • by having two different roads that you can go down.

  • Well, let's actually make something a little more interactive.

  • Let me go ahead and open another example.

  • This one's called Bounce Zero because now, we

  • can start to see some design elements from what Oscar Time was.

  • Like this now it's getting a little interesting.

  • What is actually going on here?

  • So let me zoom in on the blocks here.

  • This block is just saying forever move 10 steps, which

  • is another block we haven't seen.

  • But 10 steps is like 10 pixels.

  • So move 10 pixels on the screen.

  • But if you're touching the edge, then turn around 180 degrees.

  • And you can see exactly that happening.

  • Scratch is turning around 180 degrees and this rotation style just

  • means double back.

  • Don't like loop around 180 degrees.

  • So that's kind of cool.

  • But this is not how humans or cats walk.

  • Like what is obviously unnatural about this?

  • Yeah.

  • I mean, I mean, I can't even simulate it, right?

  • Like his feet are in static position, yet sliding back and forth

  • on the screen.

  • And yet, that is not what walking is.

  • Like walking presumably has some kind of movement and what?

  • Well, we could just kind of simulate it like--

  • OK, I could just walk--

  • walking and you can imagine taking like really quick photographs of my legs

  • or the cat's leg moving and then just deciding this photo

  • will be representative of one step.

  • This photo will be representative another.

  • And you know, with just two of those steps,

  • I'd wager we could actually do a pretty good job of simulating

  • what walking looks like.

  • In fact, if I go back to where we began, this picture of Scratch,

  • what if I just move his legs ever so slightly, then go back,

  • then go forward?

  • And even just in my PDF, I can simulate animation by hitting up arrow,

  • down arrow, up arrow, down arrow because it kind of

  • looks like he's walking now, when really, your human eyes are just seeing

  • two different pictures again and again.

  • So how can I do this?

  • Well, if I go back to Scratch, he's still walking.

  • Let me go ahead and open up Bounce One, the second version of this, and now,

  • do this.

  • OK.

  • So how did I add this?

  • There's a little purple block that we haven't seen yet,

  • but if you poke around the categories, you'll

  • see other blocks like this next costume that just keeps

  • changing the costume that he's wearing.

  • It turns out Scratch exists as a picture and his default picture

  • is him not moving, but if I go up here to top left and click costumes,

  • you can actually see that here's his one costume.

  • Here's his second costume.

  • And so that purple block that says next costume, because it's

  • in the forever loop, it just keeps doing next, next, next, next, next, just

  • showing one costume or the other.

  • They're clearly mimicking walking.

  • Now, this is not very unnatural.

  • Why don't we slow him down to, say, five steps at a time and have him go again?

  • Now, this is still going pretty fast.

  • Let me go ahead and say--

  • we could have control.

  • We could have him wait a second after moving very dramatically.

  • We could probably speed this up.

  • So let's wait 1/10 of a second, 0.1.

  • Or maybe let's do 0.01, 1/100 of a second.

  • Now, it's getting a little more realistic.

  • But this is what animation is.

  • If you've ever watched a cartoon or a movie based on pictures like this,

  • you're just tinkering with some of these parameters, these inputs,

  • in order to produce this output by understanding

  • what the fundamental representation of these things is, which in this case

  • are just pictures, again and again and again in order

  • to create that animation.

  • But what about interactivity?

  • Let me do this one myself.

  • Let me go ahead and get rid of this, go back to events, and say,

  • when green flag clicked.

  • Then, let me go ahead and grab a forever block

  • so that this keeps going again and again.

  • And then, let me go ahead to go to motion.

  • It turns out that under motion, there's this block we haven't seen--

  • point towards the mouse pointer.

  • And let me go ahead and pull this in here.

  • And then, let me have it move just like one step at a time, instead of 10.

  • What is this going to do?

  • What's this program do?

  • Yeah.

  • Say it again.

  • Follow the mouse.

  • Yeah.

  • This is kind of like a way of taking your cat for a walk.

  • Perhaps not quite the animal we intended, but he'll follow the cursor.

  • And I can actually speed this up a little bit.

  • So let's have him move 10 steps.

  • OK.

  • Now, there we go.

  • So now, he's moving up and down, and so now, it's interactive.

  • So you might recall that when we were playing Oscar Time earlier and picking

  • up--

  • OK.

  • Don't do that.

  • See, that's a bug.

  • He's just confused.

  • He's constantly moving toward it, but you're already--

  • OK.

  • So we're going to stop.

  • OK.

  • So now, he's following, but that's how we might now create,

  • for instance, the ability to move those pieces of trash

  • around and have them follow the mouse cursor.

  • If you think back to Oscar Time, every time you picked up a piece of trash,

  • he'd follow the cursor because there was a forever loop and a block like this

  • pointing toward the mouse pointer.

  • Well, now, let's integrate multiple ideas

  • and actually have multiple scripts.

  • I proposed earlier that programs can actually have multiple threads.

  • A thread is just a fancy way of saying, in our context, multiple scripts.

  • Multiple scripts in one program that are happening essentially in parallel.

  • A computer can effectively do multiple things at a time thanks to threading,

  • and more on that down the road.

  • So these are more involved, but let's see

  • if we can-- let's understand first what this program does.

  • Let me go ahead and hit play.

  • And this one tends to be a little loud.

  • [SEA LION BARKING]

  • So the sea lion is just barking endlessly, annoyingly.

  • So by reading the code, how can I stop him from barking?

  • Hit the spacebar.

  • All right.

  • So hit the spacebar.

  • OK.

  • I could just stop the program, obviously,

  • but this program is still running, technically.

  • But why did that work?

  • Well, notice this on the left hand side is the first script.

  • When the green flag is clicked, set this variable that I called muted to false.

  • Could have called it x or y or z or counter, but none of those

  • really make sense, so I called it muted.

  • And I set it equal to false, which is, again, a Boolean value.

  • True or false just mean yes or no.

  • Forever, if the keyspace is pressed, then do this.

  • If muted is currently false, then change muted to true.

  • Else, change muted to false.

  • So if muted is false, change it to true.

  • If muted is true, change it to false.

  • Any time the human hits the spacebar, update that variable.

  • Now, if we look at the other script, which is also driving the sea lion,

  • what is he doing?

  • Forever, if muted is false.

  • So if he's not muted.

  • If muted is false means not muted.

  • Start the sound sea lion and then think hi, hi, hi for two seconds,

  • and then wait for one more second.

  • And then just repeat, repeat, repeat.

  • But if I change with the spacebar muted to true,

  • he's going to say if muted equals false, that's not so.

  • I'm not going to play a sound this time.

  • And so now, we have the ability to integrate multiple scripts together

  • in order to achieve a more interactive result.

  • And what about this?

  • Back when I was a kid, might have played in the summers Marco Polo.

  • Super simple game.

  • We played it in the pool, for some reason, where

  • one person in the pool very safely is blindfolded,

  • and then he or she yells Marco.

  • And then, everyone around him or her is supposed to yell polo.

  • And then, the person who's blindfolded is

  • supposed to go chase the other kids in the pool and tag them,

  • and then they become it.

  • But in other words, it's this like signaling mechanism.

  • Someone yells, Marco and everyone else responds

  • to that broadcast of the word Marco.

  • Well, it turns out we can simulate this with these two puppets.

  • This guy here-- notice that I've highlighted the orange puppet

  • because there's a second blue puppet there.

  • Separate sprites.

  • And these are just photographs we uploaded to the game.

  • Forever, if the key space is pressed, so if the spacebar is pressed,

  • say Marco for two seconds and then broadcast an event.

  • Meanwhile, the blue puppet here has a super simple block,

  • but it's fundamentally different from the ones we've seen.

  • He's not starting when the green flag is clicked.

  • He is starting only when he receives an event.

  • So it turns out that sprites and Scratch can't hear or see

  • what the other one is saying in those speech bubbles.

  • You have to use a fancier technique, which

  • is the special block called broadcast, which

  • is like passing a note digitally from one sprite to another

  • that the other one can read or receive, so to speak.

  • So only when he receives this event, so to speak,

  • does he say polo for two seconds.

  • And again, the orange puppet sends that secret message

  • just using this other puzzle piece.

  • Broadcast an event, like passing a note that the human doesn't actually see.

  • So if I now hit the green flag and hit the spacebar, orange yells Marco.

  • Blue guy yells polo in response.

  • But those aren't timed together.

  • Rather, the blue guy is hearing with the orange one has said,

  • thereby allowing multiple sprites to actually intercommunicate.

  • So how did we get here?

  • Well, recall that we had all of these building blocks a moment ago.

  • First, we started out with just functions and conditions

  • and Boolean expressions and loops.

  • We've now added to that the ability to store information

  • in variables and threads to do multiple things at once, and then, if you do

  • have multiple things happening, events, where

  • they can enter communicate somehow.

  • Yet another building block.

  • So if we now take a step back and consider

  • how we can make functions of our own, we have the final piece

  • of the puzzle, so to speak.

  • Let me go ahead and do this.

  • Let me go ahead and create a simple program with, when green flag clipped,

  • that simply simulates coughing for a cat.

  • So this cat is going to say not hello, but cough for one second.

  • And then he's going to go ahead and wait for one second.

  • And then I'm going to go ahead and copy paste, as I did before--

  • this is one of those do as I say, not as I do-- to implement this program here,

  • where he coughs three times.

  • We already know, though, from earlier that this is not good design.

  • Why?

  • You're repeating yourself.

  • Don't repeat yourself.

  • DRY is an acronym, actually.

  • Don't repeat yourself because you're doing

  • three times as many times something that you only really need to do once.

  • The solution before, of course, was just use a loop of some sort.

  • So let me actually take that out.

  • Let me use a repeat block, change 10 to three,

  • and then just use two of these blocks.

  • And notice already, the program is so much more compact.

  • And now, if I want to change the three to a 30 or to a 10 or any number,

  • I just change one simple value.

  • I don't have to rewrite or copy paste or delete things.

  • I can update the program much more readily,

  • and now, the same thing is going to happen with just cough, cough, cough.

  • But it turns out that it would be nice to henceforth abstract away from this,

  • right?

  • I just want any program I write to know how to cough.

  • And coughing is really just saying something, perhaps

  • some number of times.

  • But it turns out we can abstract this away in code.

  • Let me go down to my blocks here and this allows

  • me to click this button-- make a block.

  • It allows me to make my own function.

  • I get this dialog window here.

  • And I'm just going to call this block cough.

  • I'm going to go ahead and click OK.

  • And now, I have this new pink block that itself can have blocks underneath it.

  • And you know what I'm going to do?

  • I'm going to go ahead and do this.

  • I'm going to go ahead and say cough under there.

  • And now, notice on the left, I now have access to this new pink piece.

  • I can now put this in here.

  • So now, notice even though, yes, this is how coughing is implemented

  • on the left hand side here, next time, when I write a program,

  • I just want to call cough.

  • And I don't care about those lower level implementation details.

  • I don't care about the party or any of that.

  • I just want this to be an abstraction.

  • But I could do better than this wouldn't it

  • be nice if instead of just repeating cough three times,

  • what if I made that a feature of cough?

  • So let me do this.

  • I can go ahead and right click on this pink piece and I can edit it.

  • That brings up that same window from before.

  • And notice this.

  • Add an input.

  • So when I make a custom block, I can actually make pretty fancy blocks

  • just like the ones MIT gives us with the software,

  • and now, I can type in something like n.

  • And if I add a label just to make it more descriptive, I can just say times.

  • So now, I've made a special custom puzzle

  • piece that says cough some number of times, where n for number

  • is just the go to variable that programmers tend to use.

  • So now, I can actually move this repeat block into cough itself,

  • but rather than hard code 3, notice this.

  • I can steal that variable and now say cough this many times by repeating

  • saying this again and again and again.

  • And now, when I cough in my actual program, I just type in three here.

  • So I have this beautiful abstraction now, so to speak.

  • Cough this many times and I and no one else in the world

  • never again needs to care about what it means to cough because we've already

  • implemented that before.

  • And so just as MIT has given us so much functionality

  • that we ourselves don't have to think about, so can

  • I now make functionality that I don't have to think about.

  • And as we progress to higher level languages like C and JavaScript

  • and Python, we're going to continue this process, sometimes

  • solving problems ourselves by making our own custom puzzle pieces,

  • but very often using things called libraries,

  • code that other humans wrote before us that's just useful to get the job done,

  • just as Scratch has done here in part for us.

  • Let me go ahead, then, and bring all of this

  • together by opening this other example here.

  • Let me go ahead and open up this one, which isn't something we've seen,

  • but it's kind of an interactive game like this made by a former student.

  • [MUSIC PLAYING]

  • Should we have an apple?

  • Yes.

  • A little animation.

  • OK.

  • That didn't end well.

  • Let's try again.

  • Play again.

  • And notice the say block is happening.

  • There's some kind of ask block.

  • The student was checking if the human typed in yes or no.

  • Let's type no this time.

  • No apple.

  • Ooh.

  • Cupcake.

  • OK.

  • Yes.

  • Enter.

  • OK.

  • Don't do that.

  • One more life.

  • Here we go.

  • [MUSIC PLAYING]

  • OK.

  • No apple.

  • No cupcake.

  • Little variable.

  • [SCREAMING]

  • [LAUGHTER]

  • OK.

  • So I won the game.

  • In our final moments here, let me go ahead and open one final example.

  • As you know, CS50 is offered not only at Harvard, but at Yale, as well,

  • so it seems fitting to perhaps end on a note that

  • pits one campus perhaps against the other by way of another game

  • that a former student wrote called Ivy's Hardest Game.

  • But for this, I think we need one final volunteer who's company coming up.

  • OK.

  • First hand.

  • Right there.

  • Come on down.

  • So in Ivy's Hardest Game, it's a game played with the keyboard.

  • And even though it might look a little overwhelming at first glance,

  • just like Oscar Time did and just like the gingerbread animation might,

  • realize that if you decompose it in just your mind's eye thinking about what

  • those individual building blocks are, you can probably

  • guess what the puzzle pieces are.

  • Hi.

  • What's your name?

  • ANDREA: Hi.

  • I'm Andrea.

  • DAVID MALAN: Andrea.

  • David.

  • Nice to meet you.

  • Here is Ivy's Hardest Game.

  • Pits you against all of the Ivies here.

  • And then right after this will we adjourn for cupcakes in the transept.

  • Ready?

  • [MUSIC PLAYING]

  • [MUSIC - MC HAMMER, "U CAN'T TOUCH THIS"]

  • MC HAMMER: (SINGING) You can't touch this.

  • You can't touch this.

  • DAVID MALAN: Nice.

  • [MUSIC - MC HAMMER, "U CAN'T TOUCH THIS"]

  • MC HAMMER: (SINGING) You can't touch this.

  • My, my, my, my.

  • Music hits you so hard.

  • Makes me say, oh my lord.

  • Thank you for blessing me with a mind to rhyme and two hype feet.

  • It feels good when you know you're down.

  • A super dope homeboy from the Oaktown.

  • And I'm known as such.

  • And this is the beat you can't touch.

  • I told you, homeboy, you can't touch this.

  • Yeah.

  • That's how we're living and you know you can't touch this.

  • Look in my eyes.

  • Man, you can't touch this.

  • [APPLAUSE]

  • [MUSIC - MC HAMMER, "U CAN'T TOUCH THIS"]

  • (SINGING) Fresh new kicks and pants.

  • You got it like that and now you know you want to dance.

  • So move out of your seat and get a fly girl

  • and catch this beat while it's rolling.

  • Hold on.

  • Pump a little bit and let me know it's going on like that.

  • Like that.

  • Cold on a mission so pull on back.

  • Let them know that you're too much and this is the beat you can't touch.

  • Yo, I told you, you can't touch this.

  • Why you standing there, man?

  • You can't touch this.

  • Yo, sound the bells.

  • School is in, sucker.

  • You can't touch this.

  • Give me a song or rhythm.

  • Making them sweat.

  • That's what I'm giving them.

  • Now they know when you talk about the Hammer,

  • you talking about a show that's hyped and tight.

  • Singers are sweating so pass them a wipe or a tape

  • to learn what it's going to take in the 90s to burn the charts.

  • DAVID MALAN: Second to last level.

  • [MUSIC - MC HAMMER, "U CAN'T TOUCH THIS"]

  • MC HAMMER: (SINGING) Either work hard or you might as well quit.

  • That's word because you know you can't touch this.

  • You can't touch this.

  • Break it down.

  • Stop.

  • Hammer time.

  • Go with the flow, it is said.

  • If you can't groove to this, then you probably are dead.

  • So wave your hands in the air.

  • Bust a few moves.

  • Run your fingers through your hair.

  • This is it for a winner.

  • Dance to this and you're going to get thinner.

  • Move.

  • Slide your rump.

  • Just for a minute, let's all do the bump, bump, bump.

  • Yeah.

  • You can't touch this.

  • Look, man.

  • You can't touch this.

  • You better get hype, boy, because you know--

  • [CROWD YELLING]

  • [MUSIC - MC HAMMER, "U CAN'T TOUCH THIS"]

  • (SINGING) Break it down.

  • DAVID MALAN: [INAUDIBLE]

  • ANDREA: [INAUDIBLE]

  • DAVID MALAN: No.

  • It's OK.

  • [MUSIC - MC HAMMER, "U CAN'T TOUCH THIS"]

  • One more life.

  • [MUSIC - MC HAMMER, "U CAN'T TOUCH THIS"]

  • MC HAMMER: (SINGING) Stop.

  • Hammer time.

  • DAVID MALAN: All right.

  • A round of applause for Andrea, if we could.

  • [APPLAUSE]

  • OK.

  • That's it for CS50.

  • See the website for details.

  • We'll see you for cake in the transept.

  • Welcome aboard.

[Introduction]

Subtitles and vocabulary

Click the word to look it up Click the word to find further inforamtion about it