Placeholder Image

字幕列表 影片播放

  • [MUSIC PLAYING]

  • DAVID MALAN: All right, this is CS50, Harvard University's introduction

  • to the intellectual enterprises of computer science

  • and the art of programming, back here on campus in beautiful Sanders Theatre

  • for the first time in quite a while.

  • So welcome to the class.

  • My name is David--

  • OK.

  • [CHEERING AND APPLAUSE]

  • So my name is David Malan.

  • And I took this class myself some time ago, but almost didn't.

  • It was sophomore fall and I was sitting in on the class.

  • And I was a little curious but, eh, it didn't really

  • feel like the field for me.

  • I was definitely a computer person, but computer science

  • felt like something altogether.

  • And I only got up the nerve to take the class,

  • ultimately, because the professor at the time, Brian Kernighan,

  • allowed me to take the class pass/fail, initially.

  • And that is what made all the difference.

  • I quickly found that computer science is not just

  • about programming and working in isolation on your computer.

  • It's really about problem solving more generally.

  • And there was something about homework, frankly,

  • that was, like, actually fun for perhaps the first time in, what, 19 years.

  • And there was something about this ability

  • that I discovered, along with all of my classmates,

  • to actually create something and bring a computer to life to solve a problem,

  • and sort of bring to bear something that I'd been using every day

  • but didn't really know how to harness, that's been gratifying ever since,

  • and definitely challenging and frustrating.

  • Like, to this day, all these years later,

  • you're going to run up against mistakes, otherwise known as bugs,

  • in programming, that just drive you nuts.

  • And you feel like you've hit a wall.

  • But the trick really is to give it enough time,

  • to take a step back, take a break when you need to.

  • And there's nothing better, I daresay, than that sense of gratification

  • and pride, really, when you get something

  • to work, and in a class like this, present, ultimately,

  • at term's end, something like your very own final project.

  • Now, this isn't to say that I took to it 100% perfectly.

  • In fact, just this past week, I looked in my old CS50 binder, which I still

  • have from some 25 years ago, and took a photo

  • of what was apparently the very first program that I wrote and submitted,

  • and quickly received minus 2 points on.

  • But this is a program that we'll soon see in the coming days that

  • does something quite simply like print "Hello, CS50," in this case,

  • to the screen.

  • And to be fair, I technically hadn't really

  • followed the directions, which is why I lost those couple of points.

  • But if you just look at this, especially if you've never programmed before,

  • you might have heard about programming language

  • but you've never typed something like this out,

  • undoubtedly it's going to look cryptic.

  • But unlike human languages, frankly, which

  • were a lot more sophisticated, a lot more vocabulary, a lot more

  • grammatical rules, programming, once you start to wrap your mind around what

  • it is and how it works and what these various languages are, it's so easy,

  • you'll see, after a few months of a class like this,

  • to start teaching yourself, subsequently,

  • other languages, as they may come, in the coming years as well.

  • So what ultimately matters in this particular course

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

  • but where you end up relative to yourself when you began.

  • And indeed, you'll begin today.

  • And the only experience that matters ultimately in this class is your own.

  • And so, consider where you are today.

  • Consider, perhaps, just how cryptic something like that

  • looked a few seconds ago.

  • And take comfort in knowing just some months from now all of that

  • will be within your own grasp.

  • And if you're thinking that, OK, surely the person in front of me, to the left,

  • to the right, behind me, knows more than me, that's statistically not the case.

  • 2/3 of CS50 students have never taken a CS course before, which is to say,

  • you're in very good company throughout this whole term.

  • So then, what is computer science?

  • I claim that it's problem solving.

  • And the upside of that is that problem solving is

  • something we sort of do all the time.

  • But a computer science class, learning to program,

  • I think kind of cleans up your thoughts.

  • It helps you learn how to think more methodically, more carefully, more

  • correctly, more precisely.

  • Because, honestly, the computer is not going

  • to do what you want unless you are correct and precise and methodical.

  • And so, as such, there's these fringe benefits

  • of just learning to think like a computer scientist and a programmer.

  • And it doesn't take all that much to start doing so.

  • This, for instance, is perhaps the simplest picture of computer science,

  • sure, but really problem solving in general.

  • Problems are all about taking input, like the problem you want to solve.

  • You want to get the solution, a.k.a.

  • output.

  • And so, something interesting has got to be happening in here,

  • in here, when you're trying to get from those inputs to outputs.

  • Now, in the world of computers specifically,

  • we need to decide in advance how we represent these inputs and outputs.

  • We all just need to decide, whether it's Macs or PCs or phones or something

  • else, that we're all going to speak some common language, irrespective

  • of our human languages as well.

  • And you may very well know that computers tend to speak only

  • what language, so to speak?

  • Assembly, one, but binary, two, might be your go-to.

  • And binary, by implying two, means that the world of computers

  • has just two digits at its disposal, 0 and 1.

  • And indeed, we humans have many more than that, certainly not just zeros

  • and ones alone.

  • But a computer indeed only has zeros and ones.

  • And yet, somehow they can do so much.

  • They can crunch numbers in Excel, send text messages,

  • create images and artwork and movies and more.

  • And so, how do you get from something as simple as a few zeros, a few ones,

  • to all of the stuff that we're doing today

  • in our pockets and laptops and desktops?

  • Well, it turns out that we can start quite simply.

  • If a computer were to want to do something as simple as count, well,

  • what could it do?

  • Well, in our human world, we might count doing this,

  • like 1, 2, 3, 4, 5, using so-called unitary notation, literally the digits

  • on your fingers where one finger represents one person in the room,

  • if I'm, for instance, taking attendance.

  • Now, we humans would typically actually count 1, 2, 3, 4, 5, 6.

  • And we'd go past just those five digits and count much higher,

  • using zeros through nines.

  • But computers, somehow, only have these zeros and ones.

  • So if a computer only somehow speaks binary, zeros and ones,

  • how does it even count past the number 1?

  • Well, here are 3 zeros, of course.

  • And if you translate this number in binary, 000,

  • to a more familiar number in decimal, we would just call this zero.

  • Enough said.

  • If we were to represent, with a computer, the number 1,

  • it would actually be 001, which, not surprisingly,

  • is exactly the same as we might do in our human world,

  • but we might not bother writing out the two zeros at the beginning.

  • But a computer, now, if it wants to count as high as two,

  • it doesn't have the digit 2.

  • And so it has to use a different pattern of zeros and ones.

  • And that happens to be 010.

  • So this is not 10 with a zero in front of it.

  • It's indeed zero one zero in the context of binary.

  • And if we want to count higher now than two,

  • we're going to have to tweak these zeros and ones further to get 3.

  • And then if we want 4 or 5 or 6 or 7, we're

  • just kind of toggling these zeros and ones, a.k.a.

  • bits, for binary digits that represent, via these different patterns,

  • different numbers that you and I, as humans, know,

  • of course, as the so-called decimal system, 0 through 9,

  • dec implying 10, 10 digits, those zeros through nine.

  • So why that particular pattern?

  • And why these particular zeros and ones?

  • Well, it turns out that representing one thing or the other

  • is just really simple for a computer.

  • Why?

  • At the end of the day, they're powered by electricity.

  • And it's a really simple thing to just either store some electricity

  • or don't store some electricity.

  • Like, that's as simple as the world can get, on or off.

  • 1 or 0, so to speak.

  • So, in fact, inside of a computer, a phone, anything

  • these days that's electronic, pretty much,

  • is some number of switches, otherwise known as transistors.

  • And they're tiny.

  • You've got thousands, millions of them in your Mac or PC or phone these days.

  • And these are just tiny little switches that can get turned on and off.

  • And by turning those things on and off in patterns,

  • a computer can count from 0 on up to 7, and even higher than that.

  • And so these switches, really, you can think of being as like switches

  • like this.

  • Let me just borrow one of our little stage lights here.

  • Here's a light bulb.

  • It's currently off.

  • And so, I could just think of this as representing,

  • in my laptop, a transistor, a switch, representing 0.

  • But if I allow some electricity to flow, now I, in fact, have a 1.

  • Well, how do I count higher than 1?

  • I, of course, need another light bulb.

  • So let me grab another one here.

  • And if I put it in that same kind of pattern, I don't want to just do this.

  • That's sort of the old finger counting way of unary, just 1, 2.

  • I want to actually take into account the pattern

  • of these things being on and off.

  • So if this was one a moment ago, what I think I did earlier was I turned it off

  • and let the next one over be on, a.k.a.

  • 010.

  • And let me get us a third bit, if you will.

  • And that feels like enough.

  • Here is that same pattern now, starting at the beginning with 3.

  • So here is 000.

  • Here is 001.

  • Here is 010, a.k.a., in our human world of decimal, 2.

  • And then we could, of course, keep counting further.

  • This now would be 3 and dot dot dot.

  • If this other bulb now goes on, and that switch is turned

  • and all three stay on-- this, again, was what number?

  • AUDIENCE: Seven.

  • DAVID MALAN: OK, so, seven.

  • So it's just as simple, relatively, as that, if you will.

  • But how is it that these patterns came to be?

  • Well, these patterns actually follow something very familiar.

  • You and I don't really think about it at this level

  • anymore because we've probably been doing math and numbers since grade

  • school or whatnot.

  • But if we consider something in decimal, like the number 123,

  • I immediately jump to that.

  • This looks like 123 in decimal.

  • But why?

  • It's really just three symbols, a 1, a 2 with a bit of curve, a 3

  • with a couple of curves, that you and I now instinctively

  • just assign meaning to.

  • But if we do rewind a few years, that is one hundred twenty-three

  • because you're assigning meaning to each of these columns.

  • The 3 is in the so-called ones place.

  • The 2 is in the so-called tens place.

  • And the 1 is in the so-called hundreds place.

  • And then the math ensues quickly in your head.

  • This is technically 100 times 1, plus 10 times 2, plus 1 times 3, a.k.a.

  • 100 plus 20 plus 3.

  • And there we get the sort of mathematical notion we know as 123.

  • Well, nicely enough, in binary, it's actually the same thing.

  • It's just these columns mean a little something different.

  • If you use three digits in decimal, and you have the ones place,

  • the tens place, and the hundreds place, well, why was that 1, 10, and 100?

  • They're technically just powers of 10.

  • So 10 to the 0, 10 to the 1, 10 to the 2.

  • Why 10?

  • Decimal system, "dec" meaning 10.

  • You have 8 and 10 digits, 0 through 9.

  • In the binary system, if you're going to use three digits,

  • just change the bases if you're using only zeros and ones.

  • So now it's powers of 2, 2 to the 0, 2 to the 1, 2 to the 2, a.k.a.

  • 1 and 2 and 4, respectively.

  • And if you keep going, it's going to be 8s column, 16s column, 32, 64,

  • and so forth.

  • So, why did we get these patterns that we did?

  • Here's your 000 because it's 4 times 0, 2 times 0, 1 times 0, obviously 0.

  • This is why we got the decimal number 1 in binary.

  • This is why we got the number 2 in binary, because it's 4 times

  • 0, plus 2 times 1, plus 1 times 0, and now 3, and now 4, and now 5, and now 6,

  • and now 7.

  • And, of course, if you wanted to count as high as 8, to be clear,

  • what do you have to do?

  • What does a computer need to do to count even higher than 7?

  • AUDIENCE: Add a bit.

  • DAVID MALAN: Add a bit.

  • Add another light bulb, another switch.

  • And, indeed, computers have standardized just how

  • many zeros and ones, or bits or switches,

  • they throw at these kinds of problems.

  • And, in fact, most computers would typically use at least eight at a time.

  • And even if you're only counting as high as three or seven,

  • you would still use eight and have a whole bunch of zeros.

  • But that's OK, because the computers these days certainly

  • have so many more, thousands, millions of transistors and switches

  • that that's quite OK.

  • All right, so, with that said, if we can now count as high as seven

  • or, frankly, as high as we want, that only

  • seems to make computers useful for things like Excel,

  • like number crunching.

  • But computers, of course, let you send text messages,

  • write documents, and so much more.

  • So how would a computer represent something like a letter,

  • like the letter A of the English alphabet, if, at the end of the day,

  • all they have is switches?

  • Any thoughts?

  • Yeah.

  • AUDIENCE: You can represent letters in numbers.

  • DAVID MALAN: OK, so we could represent letters using numbers.

  • OK, so what's a proposal?

  • What number should represent what?

  • AUDIENCE: Say if you were starting at the beginning of the alphabet,

  • you could say 1 is A, 2 is B, 3 is C.

  • DAVID MALAN: Perfect.

  • Yeah, we just all have to agree somehow that one number is

  • going to represent one letter.

  • So 1 is A, 2 is B, 3 is C, Z is 26, and so forth.

  • Maybe we can even take into account uppercase and lowercase.

  • We just have to agree and sort of write it down in some global standard.

  • And humans, indeed, did just that.

  • They didn't use 1, 2, 3.

  • It turns out they started a little higher up.

  • Capital A has been standardized as the number 65.

  • And capital B has been standardized as the number 66.

  • And you can kind of imagine how it goes up from there.

  • And that's because whatever you're representing,

  • ultimately, can only be stored, at the end of the day, as zeros and ones.

  • And so, some humans in a room before, decided that capital A shall be 65,

  • or, really, this pattern of zeros and ones inside of every computer

  • in the world, 01000001.

  • So if that pattern of zeros and ones ever appears in a computer,

  • it might be interpreted then as indeed a capital letter A, eight of those bits

  • at a time.

  • But I worry, just to be clear, we might have now created a problem.

  • It might seem, if I play this naively, that, OK,

  • how do I now actually do math with the number 65?

  • If now Excel displays 65 is an A, let alone Bs and Cs.

  • So how might a computer do as you've proposed,

  • have this mapping from numbers to letters, but still support numbers?

  • It feels like we've given something up.

  • Yeah?

  • AUDIENCE: By having a prefix for letters?

  • DAVID MALAN: By having a prefix?

  • AUDIENCE: You could have prefixes and suffixes.

  • DAVID MALAN: OK, so we could perhaps have some kind of prefix,

  • like some pattern of zeros and ones--

  • I like this-- that indicates to the computer

  • here comes another pattern that represents a letter.

  • Here comes another pattern that represents a number or a letter.

  • So, not bad.

  • I like that.

  • Other thoughts?

  • How might a computer distinguish these two?

  • Yeah.

  • AUDIENCE: Have a different file format, so,

  • like, odd text or just check the graphic or--

  • DAVID MALAN: Indeed, and that's spot-on.

  • Nothing wrong with what you suggested, but the world generally does just that.

  • The reason we have all of these different file formats in the world,

  • like JPEG and GIF and PNGs and Word documents, .docx,

  • and Excel files and so forth, is because a bunch of humans got in a room

  • and decided, well, in the context of this type of file, or really,

  • more specifically, in the context of this type of program,

  • Excel versus Photoshop versus Google Docs or the like,

  • we shall interpret any patterns of zeros and ones as being maybe numbers

  • for Excel, maybe letters in, like, a text messaging program or Google Docs,

  • or maybe even colors of the rainbow in something like Photoshop and more.

  • So it's context dependent.

  • And we'll see, when we ourselves start programming,

  • you the programmer will ultimately provide

  • some hints to the computer that tells the computer, interpret it as follows.

  • So, similar in spirit to that, but not quite a standardized with these

  • prefixes.

  • So this system here actually has a name ASCII, the American Standard

  • Code for Information Interchange.

  • And indeed, it began here in the US, and that's

  • why it's actually a little biased toward A's through Z's

  • and a bit of punctuation as well.

  • And that quickly became a problem.

  • But if we start simply now, in English, the mapping

  • itself is fairly straightforward.

  • So if A is 65, B it 66, and dot dot dot, suppose

  • that you received a text message, an email, from a friend,

  • and underneath the hood, so to speak, if you kind of

  • looked inside the computer, what you technically received in this text

  • or this email happened to be the numbers 72, 73, 33,

  • or, really, the underlying pattern of zeros and ones.

  • What might your friend have sent you as a message, if it's 72, 73, 33?

  • AUDIENCE: Hey.

  • DAVID MALAN: Hey?

  • Close.

  • AUDIENCE: Hi.

  • DAVID MALAN: Hi.

  • It's, indeed, hi.

  • Why?

  • Well, apparently, according to this little cheat sheet, H is 72, I is 73.

  • It's not obvious from this chart what the 33 is,

  • but indeed, this pattern represents "hi."

  • And anyone want to guess, or if you know, what 33 is?

  • AUDIENCE: Exclamation point.

  • DAVID MALAN: Exclamation point.

  • And this is, frankly, not the kind of thing most people know.

  • But it's easily accessible by a nice user-friendly chart like this.

  • So this is an ASCII chart.

  • When I said that we just need to write down this mapping earlier,

  • this is what people did.

  • They wrote it down in a book or in a chart.

  • And, for instance, here is our 72 for H, here is our 73 for I,

  • and here is our 33 for exclamation point.

  • And computers, Macs, PCs, iPhones, Android devices,

  • just know this mapping by heart, if you will.

  • They've been designed to understand those letters.

  • So here, I might have received "hi."

  • Technically, what I've received is these patterns of zeros and ones.

  • But it's important to note that when you get these patterns of zeros and ones

  • in any format, be it email or text or a file,

  • they do tend to come in standard lengths,

  • with a certain number of zeros and ones altogether.

  • And this happens to be 8 plus 8, plus 8.

  • So just to get the message "hi, exclamation point,"

  • you would have received at least, it would seem, some 24 bits.

  • But frankly, bits are so tiny, literally and mathematically,

  • that we don't tend to think or talk, generally, in terms of bits.

  • You're probably more familiar with bytes.

  • B-Y-T-E-S is a byte, is a byte, is a byte.

  • A byte is just 8 bits.

  • And even those, frankly, aren't that useful if we do out the math.

  • How high can you count if you have eight bits?

  • Anyone know?

  • Say it again?

  • Higher than that.

  • Unless you want to go negative, that's fine.

  • 256, technically 255.

  • Long story short, if we actually got into the weeds of all of these zeros

  • and ones, and we figured out what 11111111 mathematically adds up

  • to in decimal, it would indeed be 255, or less

  • if you want to represent negative numbers as well.

  • So this is useful because now we can speak, not just in terms of bytes

  • but, if the files are bigger, kilobytes is thousands of bytes,

  • megabytes is millions of bytes, gigabytes is billions of bytes,

  • terabytes are trillions of bytes, and so forth.

  • We have a vocabulary for these increasingly large quantities of data.

  • The problem is that, if you're using ASCII and, therefore, eight bits or one

  • byte per character, and originally, only seven, you

  • can only represent 255 characters.

  • And that's actually 256 total characters, including zero.

  • And that's fine if you're using literally English, in this case,

  • plus a bunch of punctuation.

  • But there's many human languages in the world

  • that need many more symbols and, therefore, many more bits.

  • So, thankfully, the world decided that we'll indeed

  • support not just the US English keyboard, but all

  • of the accented characters that you might want for some languages.

  • And heck, if we use enough bits, zeros and ones,

  • not only can we represent all human languages in written form,

  • as well as some emotions along the way, we

  • can capture the latter with these things called emojis.

  • And indeed, these are very much in vogue these days.

  • You probably send and/or receive many of these things any given day.

  • These are just characters, like letters of an alphabet, patterns

  • of zeros and ones that you're receiving, that the world has also standardized.

  • For instance, there are certain emojis that

  • are represented with certain patterns of bits.

  • And when you receive them, your phone, your laptop, your desktop,

  • displays them as such.

  • And this newer standard is called Unicode.

  • So it's a superset of what we called ASCII.

  • And Unicode is just a mapping of many more numbers to many more letters

  • or characters, more generally, that might

  • use eight bits for backwards compatibility

  • with the old way of doing things with ASCII, but they might also use 16 bits.

  • And if you have 16 bits, you can actually

  • represent more than 65,000 possible letters.

  • And that's getting up there.

  • And heck, Unicode might even use 32 bits to represent letters and numbers

  • and punctuation symbols and emojis.

  • And that would give you up to 4 billion possibilities.

  • And, I daresay, one of the reasons we see so many emojis these days is we

  • have so much room.

  • I mean, we've got room for billions more, literally.

  • So, in fact, just as a little bit of trivia,

  • has anyone ever received this decimal number, or if you prefer binary now,

  • has anyone ever received this pattern of zeros and ones on your phone,

  • in a text or an email, perhaps this past year?

  • Well, if you actually look this up, this esoteric sequence of zeros and ones

  • happens to represent face with medical mask.

  • And notice that if you've got an iPhone or an Android device,

  • you might be seeing different things.

  • In fact, this is the Android version of this, most recently.

  • This is the iOS version of it, most recently.

  • And there's bunches of other interpretations by other companies

  • as well.

  • So Unicode, as a consortium, if you will,

  • has standardized the descriptions of what these things are.

  • But the companies themselves, manufacturers out there,

  • have generally interpreted it as you see fit.

  • And this can lead to some human miscommunications.

  • In fact, for like, literally, embarrassingly, like a year or two,

  • I started being in the habit of using the emoji that kind of looks

  • like this because I thought it was like woo, happy face, or whatever.

  • I didn't realize this is the emoji for hug

  • because whatever device I was using sort of looks like this, not like this.

  • And that's because of their interpretation of the data.

  • This has happened too when what was a gun became a water

  • pistol in some manufacturers' eyes.

  • And so it's an interesting dichotomy between what information we all

  • want to represent and how we choose, ultimately, to represent it.

  • Questions, then, on these representations of formats,

  • be it numbers or letters, or soon more.

  • Yeah?

  • AUDIENCE: Why is decimal popular for a computer

  • if binary is the basis for everything?

  • DAVID MALAN: Sorry, why is what so popular?

  • AUDIENCE: Why is the decimal popular if binary is the fundamental--

  • DAVID MALAN: Yeah, so we'll come back to this in a few weeks, in fact.

  • There are other ways to represent numbers.

  • Binary is one.

  • Decimal is another.

  • Unary is another.

  • And hexadecimal is yet a fourth that uses 16 total digits, literally 0

  • through 9 plus A, B, C, D, E, F. And somehow,

  • you can similarly count even higher with those.

  • We'll see in a few weeks why this is compelling.

  • But hexadecimal, long story short, uses four bits per digit.

  • And so, four bits, if you have two digits in hex, that gives you eight.

  • And it's just a very convenient unit of measure.

  • And it's also human convention in the world of files and other things.

  • But we'll come back to that soon.

  • Other questions?

  • AUDIENCE: Do the lights on the stage supposedly say that--

  • DAVID MALAN: Do the lights on the stage supposedly say anything?

  • Well, if we had thought in advance to use maybe 64 light bulbs,

  • that would seem to give us 8 total bytes on stage, 8 times 8,

  • giving us just that.

  • Maybe.

  • Good question.

  • Other questions on 0's and 1's?

  • It's a little bright in here.

  • No?

  • Oh, yes?

  • Where everyone's pointing somewhere specific.

  • There we go.

  • Sorry.

  • Very bright in this corner.

  • AUDIENCE: I was just going to ask about the 255 bits,

  • like with the maximum characters.

  • [INAUDIBLE]

  • DAVID MALAN: Ah, sure, and we'll come back to this, in some form,

  • in the coming days too, at a slower pace too,

  • we have, with eight bits, two possible values for the first

  • and then two for the next, two for the next, and so forth.

  • So that's 2 times 2 times 2.

  • That's 2 to the eighth power total, which

  • means you can have 256 total possible patterns of zeros and ones.

  • But as we'll see soon computer scientists, programmers,

  • software often starts counting at 0 by convention and if you use one of those

  • patterns, 00000000 to represent the decimal number we know is zero,

  • you only have 255 other patterns left to count as high as therefore 255.

  • That's all.

  • Good question.

  • All right, so what then might we have besides these emojis and letters

  • and numbers?

  • Well, we of course have things like colors and programs

  • like Photoshop and pictures and photos.

  • Well let me ask the question again.

  • How might a computer, do you think, knowing what you know now, represents

  • something like a color?

  • Like what are our options if all we've got are zeros and ones and switches?

  • Yeah?

  • AUDIENCE: RGB

  • DAVID MALAN: RGB.

  • RGB indeed is this acronym that represents some amount of red

  • and some amount of green and blue and indeed computers

  • can represent colors by just doing that.

  • Remembering, for instance, this dot.

  • This yellow dot on the screen that might be part of any of those emojis

  • these days, well that's some amount of red, some amount of green,

  • some amount of blue.

  • And if you sort of mix those colors together,

  • you can indeed get a very specific one.

  • And we'll see you in just a moment just that.

  • So indeed earlier on, humans only used seven bits total.

  • And it was only once they decided, well, let's add an eighth bit that they

  • got extended ASCII and that was initially in part

  • a solution to the same problem of not having enough room, if you will,

  • in those patterns of zeros and ones to represent all of the characters

  • that you might want.

  • But even that wasn't enough and that's why we've now gone up to 16 and 32

  • and long past 7.

  • So if we come back now to this one particular color.

  • RGB was proposed as a scheme, but how might this work?

  • Well, consider for instance this.

  • If we do indeed decide as a group to represent any color of the rainbow

  • with some mixture of some red, some green, and some blue,

  • we have to decide how to represent the amount of red and green and blue.

  • Well, it turns out if all we have are zeros and ones, ergo numbers,

  • let's do just that.

  • For instance, suppose a computer we're using, these three numbers 72, 73, 33,

  • no longer in the context of an email or a text message,

  • but now in the context of something like Photoshop, a program for editing

  • and creating graphical files, maybe this first number

  • could be interpreted as representing some amount of red, green, and blue,

  • respectively.

  • And that's exactly what happens.

  • You can think of the first digit as red, second as green, third as blue.

  • And so ultimately when you combine that amount of red, that amount of green,

  • that amount of blue, it turns out it's going to resemble the shade of yellow.

  • And indeed, you can come up with a numbers between 0 and 255

  • for each of those colors to mix any other color that you might want.

  • And you can actually see this in practice.

  • Even though our screens, admittedly, are getting really good

  • on our phones and laptops such that you barely see the dots, they are there.

  • You might have heard the term pixel before.

  • Pixel's just a dot on the screen and you've

  • got thousands, millions of them these days horizontally and vertically.

  • If I take even this emoji, which again happens

  • to be one company's interpretation of a face with medical mask

  • and zoom in a bit, maybe zoom in a bit more,

  • you can actually start to see these pixels.

  • Things get pixelated because what you're seeing

  • is each of the individual dots that compose this particular image.

  • And apparently each of these individual dots

  • are probably using 24 bits, eight bits for red, eight bits for green, eight

  • bits for blue, in some pattern.

  • This program or some other like Photoshop is interpreting one pattern

  • and it's white or yellow or black or some brown in between.

  • So if you look sort of awkwardly, but up close to your phone or your laptop

  • or maybe your TV, you can see exactly this, too.

  • All right, well, what about things that we also

  • watch every day on YouTube or the like?

  • Things like videos.

  • How would a computer, knowing what we know now,

  • represent something like a video?

  • How might you represent a video using only zeros and ones?

  • Yeah?

  • AUDIENCE: As we can see here, they represent images, right?

  • [INAUDIBLE] sounds of the 0 and 1s as well.

  • [INAUDIBLE]

  • DAVID MALAN: Yeah, exactly.

  • To summarize, what video really adds is just some notion of time.

  • It's not just one image, it's not just one letter or a number,

  • it's presumably some kind of sequence because time is passing.

  • So with a whole bunch of images, maybe 24 maybe 30 per second,

  • if you fly them by the human's eyes, we can

  • interpret them using our eyes and brain that there is now

  • movement and therefore video.

  • Similarly with audio or music.

  • If we just came up with some convention for representing those same notes

  • on a musical instrument, could we have the computer synthesize them, too?

  • And this might be actually pretty familiar.

  • Let me pull up a quick video here, which happens to be an old school

  • version of the same idea.

  • You might remember from childhood.

  • [MUSIC PLAYING]

  • [CLICKING]

  • So granted that particular video is an actual video

  • of a paper-based animation, but indeed, that's really all you need,

  • is some sequence of these images, which themselves of course

  • are just zeros and ones because they're just this grid of these pixels or dots.

  • Now something like musical notes like these, those of you who are musicians

  • might just naturally play these on physical devices,

  • but computers can certainly represent those sounds, too.

  • For instance, a popular format for audio is

  • called MIDI and MIDI might just represent

  • each note that you saw a moment ago essentially as a sequence of numbers.

  • But more generally, you might think about music as having notes,

  • for instance, A through G, maybe some flats and some sharps,

  • you might have the duration like how long is the note being heard or played

  • on a piano or some other device, and then

  • just the volume like how hard does a human in the real world

  • press down on that key and therefore how loud is that sound?

  • It would seem that just remembering little details like that quantitatively

  • we can then represent really all of these otherwise analog human realities.

  • So that then is really a laundry list of ways

  • that we can just represent information.

  • Again, computers or digital have all of these different formats,

  • but at the end of the day and as fancy as those devices in years

  • are, it's just zeros and ones, tiny little switches or light bulbs,

  • if you will, represented in some way and it's up to the software

  • that you and I and others write to use those zeros

  • and ones in ways we want to get the computers to do something

  • more powerfully.

  • Questions, then, on this representation of information, which I daresay

  • is ultimately what problem solving is all about, taking in information

  • and producing new via some process in between.

  • Any questions there?

  • Yeah, in back.

  • AUDIENCE: Yeah, so we talked about how different file formats kind of allow

  • you to interpret information.

  • How does a file format like .mp4 discriminate between audio and video

  • within itself as a value?

  • DAVID MALAN: So a really good question.

  • There are many other file formats out there.

  • You allude to MP4 for video and more generally the use

  • are these things called codecs and containers.

  • It's not quite as simple when using larger files, for instance,

  • in more modern formats that a video is just a sequence of images,

  • for instance.

  • Why?

  • If you stored that many images for like a Hollywood movie,

  • like 24 or 30 of them per second, that's a huge number of images.

  • And if you've ever taken photos on your phone,

  • you might know how many megabytes or larger even individual photographs

  • might be.

  • So humans have developed over the years a fancier software

  • that uses much more math to represent the same information more minimally

  • just using somehow shorter patterns of zeros and ones

  • than are most simplistic representation here.

  • And they use what might be called compression.

  • If you've ever used a zip file or something else,

  • somehow your computer is using fewer zeros and ones

  • to represent the same amount of information,

  • ideally without losing any information.

  • In the world of multimedia, which we'll touch on a little bit in a few weeks,

  • there are both lossy and lossless formats out there.

  • Lossless means you lose no information whatsoever.

  • But more commonly as you're alluding to one is lossy compression, L-O-S-S-Y,

  • where you're actually throwing away some amount of quality.

  • You're getting some amount of pixelation that might not

  • look perfect to the human, but heck it's a lot cheaper and a lot easier

  • to distribute.

  • And in the world of multimedia, you have containers like QuickTime

  • and other MPEG containers that can combine

  • different formats of video, different formats of audio in one file,

  • but there, too, do designers have discretion.

  • So more in a few weeks, too.

  • Other questions, then, on information here as well?

  • Yeah?

  • AUDIENCE: So I know computers used to be very big

  • and taking up like a whole room and stuff.

  • Is the reason they've gotten smaller because we can store

  • this information piecemeal or what?

  • DAVID MALAN: Exactly.

  • I mean, back in the day you might have heard of the expression a vacuum

  • tube, which is like some physically large device that

  • might have only stored some 0 or 1.

  • Yes, it is the miniaturization of hardware these days

  • that has allowed us to store as many and many more zeros and ones much more

  • closely together.

  • And as we've built more fancy machines that

  • can sort of design this hardware at an even smaller scale,

  • we're just packing more and more into these devices.

  • But there, too, is a trade off.

  • For instance, you might know by using your phone or your laptop

  • for quite a while, maybe on your lap, starts to get warm.

  • So there are these literal physical side effects

  • of this where now some of our devices run hot.

  • This is why like a data center in the real world

  • might need more air conditioning than a typical place,

  • because there are these physical artifacts as well.

  • In fact, if you'd like to see one of the earliest computers from decades ago,

  • across the river here in now Allston in the new engineering building

  • is the Harvard Mark 1 computer that will give you a much better mental model

  • of just that.

  • Well if we come back now to this first picture

  • being computer science or really problem solving,

  • I daresay we have more than enough ways now

  • to represent information, input and output, so long as we all just agree

  • on something and thankfully all of those before us have given us

  • things like ASCII and Unicode.

  • Not to mention MP4s, word documents, and the like.

  • But what's inside of this proverbial black box into which these inputs are

  • going in the outputs are coming?

  • Well that's where we get this term you might have heard, too.

  • An algorithm, which is just step-by-step instructions for solving some problem

  • incarnated in the world of computers by software.

  • When you write software aka programs, you

  • are implementing one or more algorithms, one or more sets of instructions

  • for solving some problem, and maybe you're using this language or that,

  • but at the end of the day, no matter the language

  • you use the computer is going to represent what you type

  • using just zeros and ones.

  • So what might be a representative algorithm?

  • Nowadays you might use your phone quite a bit

  • to make calls or send texts or emails and therefore you

  • have a whole bunch of contacts in your address book.

  • Nowadays, of course, this is very digital,

  • but whether on iOS or Android or the like,

  • you might have a whole bunch of names, first name

  • and/or last, as well as numbers and emails and the like.

  • You might be in the habit of like scrolling through on your phone

  • all of those names to find the person you want to call.

  • It's probably sorted alphabetically by first name or last name, A through Z,

  • or some other symbol.

  • This is frankly quite the same as we used to do back in my day, CS50,

  • when we just used a physical book.

  • In this physical book might be a whole bunch

  • of names alphabetically sorted from left to right

  • corresponding to a whole bunch of numbers.

  • So suppose that in this old Harvard phone book

  • we want to search for John Harvard.

  • We might of course start quite simply at the beginning

  • here, looking at one page at a time, and this is an algorithm.

  • This is like literally step-by-step looking for the solution

  • to this problem.

  • In that sense, if John Harvard's in the phone book,

  • is this algorithm page-by-page correct, would you say?

  • AUDIENCE: Yes.

  • DAVID MALAN: Yes.

  • Like if John Harvard's in the phone book,

  • obviously I'm eventually going to get to him, so that's what we mean by correct.

  • Is it efficient?

  • Is it well designed, would you say?

  • No.

  • I mean this is going to take forever even just to get to the Js or the Hs,

  • depending how this thing's sorted.

  • All right, well let me go a little faster.

  • I'll start like two pages at a time.

  • 2, 4, 6, 8, 10, 12, and so forth.

  • Sounds faster, is faster, is it correct?

  • AUDIENCE: No.

  • DAVID MALAN: OK, why is it not correct?

  • Yeah?

  • AUDIENCE: So if you're starting on page 1,

  • you're only going odd number of pages, so if it's on an even number page,

  • you'll miss it.

  • DAVID MALAN: Exactly.

  • If I start on an odd number of pages and I'm going two at a time

  • I might miss pages in between.

  • And if I therefore conclude when I get to the back

  • of the book there was no John Harvard, I might have just errored.

  • This would be again one of these bugs.

  • But if I try a little harder, I feel like there's a solution.

  • We don't have to completely throw out this algorithm.

  • I think we can probably go roughly twice as fast still.

  • But what should we do instead to fix this?

  • Yeah, in back.

  • AUDIENCE: [INAUDIBLE]

  • DAVID MALAN: Nice.

  • So I think what many of us, most of us, if we even use this technology any more

  • these days, we might go roughly to the middle of the phone book

  • just to kind of get us started.

  • And now I'm looking down, I'm looking for J, assuming first name, J Harvard,

  • and it looks like I'm in the M section.

  • So just to be clear, what should I do next?

  • AUDIENCE: [INAUDIBLE]

  • DAVID MALAN: OK, and presumably it is John Harvard

  • would be to the left of this.

  • So here's an opportunity to figuratively and literally tear

  • this particular problem in half, throw half of the problem away.

  • It's actually pretty easy if you just do it that way.

  • The hard way is this way.

  • But I've now just decreased the size of this problem really in half.

  • So if I started with 1,000 pages of phone numbers and names, now

  • I'm down to 500.

  • And already we haven't found John Harvard,

  • but that's a big bite out of this problem.

  • I do think it's correct because if J is to the left of M, of course,

  • he's definitely not going to be over there.

  • I think if I repeat this again dividing and conquering, if you will,

  • here I might have gone a little too far.

  • Now I'm in like the E section.

  • So let me tear the problem in half again, throw another 250 pages away,

  • and again repeat, dividing and dividing and conquering

  • until finally, presumably, I end up with just one page of a phone

  • book on which John Harvard's name either is or is not,

  • but because of the algorithm you proposed, step by step,

  • I know that he's not in anything I discarded.

  • So traumatic is that might have been made out

  • to be, it's actually just harnessing pretty good human intuition.

  • Indeed, this is what programming is all about, too.

  • It's not about learning a completely new world,

  • but really just how to harness intuition and ideas that you might already

  • have and take naturally but learning how to express

  • them now more succinctly, more precisely,

  • using things called programming languages.

  • Why is an algorithm like that if I found John Harvard better than, ultimately,

  • just doing the first one or even the second

  • and maybe doubling back to check those even pages?

  • Well let's just look at little charts here.

  • Again, we don't have to get into the nuances of numbers,

  • but if we've got like a chart here, xy plot, on the x-axis

  • here I claim as the size of the problem.

  • So measured in the numbers of pages in the phone book.

  • So the farther you go out here, the more pages are in the phone book.

  • And here we have time to solve on the y-axis.

  • So the higher you go up, the more time it's

  • going to be taking to solve that particular problem.

  • So let's just arbitrarily say that the first algorithm, involving

  • like n pages, might be represented graphically like this.

  • No matter the slope, it's a straight line

  • because there's presumably a one to one relationship

  • between numbers of pages and number of seconds or number of page turns.

  • Why?

  • If the phone company adds another page next year

  • because some new people move to town, that's

  • going to require one additional page for me.

  • One to one.

  • If, though, we use the second algorithm, flawed though it was,

  • unless we double back a little bit to fix someone being in between,

  • that's too going to be a straight line, but it's

  • going to be a different slope because now there's a 2 to 1 or a 1 to 2

  • relationship because I'm going to pages at a time.

  • So if the phone company adds another page or another two pages,

  • that still only just one more step.

  • You can see the difference if I kind of draw this.

  • If this is the phone book in question, this number of pages,

  • it might take this many seconds on the yellow line

  • to represent or to find someone like John Harvard.

  • But of course on the first algorithm, the red line,

  • it's literally going to take twice as many steps.

  • And what do the n here mean? n is the go-to variable

  • for computer scientist or programmer just generically representing a number.

  • So if the number of pages in the phone book is n,

  • the number of steps the second algorithm would have taken

  • would be in the worst case n over 2.

  • Half as many because you're going twice as fast.

  • But the third algorithm, actually if you recall your logarithms,

  • looks a little something like this.

  • There's a fundamentally different relationship

  • between the size of the problem and the amount of time required to solve it

  • that technically is log-based, too, again,

  • but it's really the shape that's different.

  • The implication there is that if, for instance, Cambridge and Allston,

  • two different towns here in Massachusetts, merge next year

  • and there's just one phone book that's twice as big,

  • no big deal for that third and final algorithm.

  • Why?

  • You just tear the problem one more time in half,

  • taking one more byte, that's it, not another 1,000

  • bytes just to get to the solution.

  • Put another way, you can walk it way, way,

  • way out here to a much bigger phone book and ultimately

  • that green line is barely going to have budged.

  • So this then is just a way of now formalizing and thinking

  • about what the performance or quality of these algorithms might be.

  • Before we now make one more formalization of the algorithm itself,

  • any questions then on this notion of efficiency or now performance of ideas?

  • Yeah.

  • AUDIENCE: How many phone books have you got?

  • DAVID MALAN: (LAUGHING) A lot of phone books over the years

  • and if you or your parents have any more still somewhere we could definitely

  • use them because they're hard to find.

  • Other questions?

  • But thanks.

  • Other questions here, too?

  • No.

  • Oh, was that a murmur?

  • Yes, over here.

  • AUDIENCE: You could get Harry Potter as a guest speaker.

  • DAVID MALAN: Sorry, say again.

  • AUDIENCE: You could get Harry Potter as a guest speaker.

  • DAVID MALAN: (LAUGHING) Oh, yeah.

  • Hopefully.

  • Then we'd have a little something more to use here.

  • So now if we want to formalize further what it is we just did,

  • we can go ahead and introduce this.

  • A form of code aka pseudocode.

  • Pseudocode is not a specific language, it's not like something

  • we're about to start coding in, it's just a way of expressing yourself

  • in English or any human language succinctly

  • correctly toward an end of getting your idea for an algorithm across.

  • So for instance, here might be how we could

  • formalize the code, the pseudocode for that same algorithm.

  • Step one was pick up the phone book, as I did.

  • Step two might be open to the middle of the phone book,

  • as you proposed that we do first.

  • Step three was probably to look down at the pages, I did.

  • And step four gets a little more interesting

  • because I had to quickly make a decision and ask myself a question.

  • If person is on page, then I should probably just

  • go ahead and call that person.

  • But that probably wasn't the case at least for John Harvard,

  • and I opened the M section.

  • So there's this other question I should now

  • ask else if the person is earlier in the book,

  • then I should tear the problem in half as I did but go left, so

  • to speak, and then not just open to the middle of the left half of the book,

  • but really just go back to step three, repeat myself.

  • Why?

  • Because I can just repeat what I just did, but with a smaller problem

  • having taken this big bite.

  • But, if the person was later in the book,

  • as might have happened with a different person than John Harvard,

  • then I should open to the middle of the right half of the book,

  • again go back to line three, but again, I'm

  • not going to get sucked doing something forever like this

  • because I keep shrinking the size of the problem.

  • Lastly, the only possible scenario that's

  • left, if John Harvard is not on the page and he's not to the left

  • and he's not to the right, what should our conclusion be?

  • AUDIENCE: He's not there.

  • DAVID MALAN: He's not there.

  • He's not listed.

  • So we need to quit in some other form.

  • Now as an aside, it's kind of deliberate that I buried that last question

  • at the end because this is what happens all too often in programming,

  • whether you're new at it or professional,

  • just not considering all possible cases, corner cases if you will,

  • that might not happen that often, but if you don't anticipate them

  • in your own code, pseudocode or otherwise,

  • this is when and why programs might crash

  • or you might say stupid little spinning beach balls or hourglasses

  • or your computer might reboot.

  • Why?

  • It's doing something sort of unpredictable

  • if a human, maybe myself, didn't anticipate this.

  • Like what does this program do if John Harvard is not in the phone book

  • if I had omitted lines 12 and 13?

  • I don't know.

  • Maybe it would behave differently on a Mac or PC

  • because it's sort of undefined behavior.

  • These are the kinds of omissions that frankly you're invariably

  • going to make, bugs you're going to introduce,

  • mistakes you're going to make early on, and me, too, 25 years later.

  • But you'll get better at thinking about those corner cases

  • and handling anything that can possibly go wrong and as a result,

  • your code will be all the better for it.

  • Now the problem ultimately with learning how to program,

  • especially if you've never had experience

  • or even if you do but you learned one language only,

  • is that they all look a little cryptic at first glance.

  • But they do share certain commonalities.

  • In fact, we'll use this pseudocode to define those first.

  • Highlighted in yellow here are what henceforth

  • we're going to start calling functions.

  • Lots of different programming languages exist, but most of them

  • have what we might call functions, which are actions

  • or verbs that solve some smaller problem.

  • That is to say, you might use a whole bunch of functions

  • to solve a bigger problem because each function tends to do

  • something very specific or precise.

  • These then in English might be translated in code, actual computer

  • code, to these things called functions.

  • Highlighted in yellow now are what we might call conditionals.

  • Conditionals are things that you do conditionally

  • based on the answer to some question.

  • You can think of them kind of like forks in the road.

  • Do you go left or go right or some other direction

  • based on the answer to some question?

  • Well, what are those questions?

  • Highlighted now in yellow or what we would call Boolean expressions, named

  • after a mathematician last name Bool, that simply have yes no answers.

  • Or, if you prefer, true or false answers or, heck, if you prefer 1 or 0 answers.

  • We just need to distinguish one scenario from another.

  • The last thing manifests in this pseudocode

  • is what I might highlight now and call loops.

  • Some kind of cycle, some kind of directive that tells us to do something

  • again and again so that I don't need a 1,000-line program to search

  • a 1,000-page phone book, I can get away with a 13-line program but sort

  • of repeat myself inherently in order to solve some problem until I get to that

  • last step.

  • So this then is what we might call pseudocode

  • and indeed there are other characteristics

  • of programs that we'll touch on before long, things like arguments and return

  • values, variables, and more, but unfortunately in most languages,

  • including some we will very deliberately use in this class

  • and that everyone in the real world these days still uses,

  • its programs tend to look like this.

  • This for instance, is a distillation of that very first program

  • I wrote in 1996 in CS50 itself just to print something on the screen.

  • In fact, this version here just tries to print quote unquote, "Hello, world."

  • Which is, dare say, the most canonical first thing that most

  • any programmer ever gets a computer to say just because,

  • but look at this mess.

  • I mean, there's a hash symbol, these angled brackets, parentheses,

  • words like int, curly braces, quotes, parentheses, semicolons, and back

  • slashes.

  • I mean there's more overhead and more syntax and clutter

  • than there is an actual idea.

  • Now that's not to say that you won't be able to understand this before long,

  • because honestly there's not that many patterns, indeed programming languages

  • have typically a much smaller vocabulary than any actual human language,

  • but at first it might indeed look quite cryptic.

  • But you can perhaps infer I have no idea what these other lines do yet,

  • but "Hello, world." is presumably quote unquote what

  • will be printed on the screen.

  • But what we'll do today, after a short break,

  • and set the stage for next week is introduce

  • these exact same ideas in just a bit using Scratch,

  • something that you yourselves might have used

  • when you're quite younger but without the same vocabulary applied

  • to those ideas.

  • The upside of what we'll soon do using Scratch, this graphical programming

  • language from our friends down the road at MIT, it'll let us today

  • start to drag and drop things that look like puzzle pieces that interlock

  • together if it makes logical sense to do so,

  • but without the distraction of hashes, parentheses,

  • curly braces, angle brackets, semicolons, and things

  • that are quite beside the point.

  • But for now, let's go ahead and take a 10 minute break here

  • and when we resume, we will start programming.

  • So this on the screen is a language called

  • C something that will dive into next week and thankfully

  • this now on the screen is another language called Python

  • that we'll also take a look at in a few weeks before long along

  • with other languages along the way.

  • Today though, and for this first week, week zero, so to speak,

  • we use Scratch because again it will allow

  • us to explore some of those programming fundamentals

  • that will be in C and in Python and in JavaScript and other languages, too,

  • but in a way where we don't have to worry about the distractions of syntax.

  • So the world of Scratch looks like this.

  • It's a web-based or downloadable programming environment

  • that has this layout here by default. On the left here

  • we'll soon see is a palette of puzzle pieces, programming blocks that

  • represent all of those ideas we just discussed.

  • And by dragging and dropping these puzzle pieces

  • or blocks over this big area and connecting them together,

  • if it makes logical sense to do so, we'll

  • start programming in this environment.

  • The environment allows you to have multiple sprites, so to speak.

  • Multiple characters, things like a cat or anything

  • else, and those sprites exist in this rectangular world

  • up here that you can full screen to make bigger and this here by default

  • is Scratch, who can move up, down, left, right and do many more things, too.

  • Within its Scratch's world you can think of it

  • as perhaps a familiar coordinate system with Xs and Ys

  • which is helpful only when it comes time to position things on the screen.

  • Right now Scratch is at the default, 0,0, where x equals 0 and y equals 0.

  • If you were to move the cat way up to the top, x would stay zero,

  • y would be positive 180.

  • If you move the cat all the way to the bottom, x would stay zero,

  • but y would now be negative 180.

  • And if you went left, x would become negative 240 but y would stay 0,

  • or to the right x would be 240 and y would stay zero.

  • So those numbers generally don't so much matter because you can just

  • move relatively in this world up, down, left, right,

  • but when it comes time to precisely position

  • some of these sprites or other imagery, it'll

  • be helpful just to have that mental model off up, down, left, and right.

  • Well let's go ahead and make perhaps the simplest of programs here.

  • I'm going to switch over to the same programming environment

  • now for a tour of the left hand side.

  • So by default selected here are the category in blue motion,

  • which has a whole bunch of puzzle pieces or blocks that relate to motion.

  • And whereas Scratch as a graphical language

  • categorizes things by the type of things that these pieces do,

  • we'll see that throughout this whole palette

  • we'll have functions and variables and conditionals

  • and Boolean expressions and more each in a different color and shape.

  • So for instance, moving 10 steps or turning one way or the other

  • would be functions categorized here as things like motion.

  • Under looks in purple, you might have speech bubbles

  • that you can create by dragging and dropping

  • these that might say "hello" or whatever for some number of seconds.

  • Or you could switch costumes, change the cat to look like a dog or a bird

  • or anything else in between.

  • Sounds, too.

  • You can play sounds like "meow" or anything you might import or record,

  • yourself.

  • Then there's these things Scratch calls events and the most important of these

  • is the first, when green flag clicked.

  • Because if we look over to the right of Scratch's world here,

  • this rectangular region has this green flag and red stop

  • sign up above, one of which is for Play one of which is for Stop

  • and so that's going to allow us to start and stop our actual programs

  • when that green flag is initially clicked.

  • But you can listen for other types of events when the spacebar is pressed

  • or something else, when this sprite is clicked or something else.

  • Here you already see like a programmer's incarnation of things

  • you and I take for granted like every day now on our phones.

  • Any time you tap an icon or drag your finger or hit a button on the side.

  • These are what a programmer would call events,

  • things that happen and are often triggered by us

  • humans and things that a program be it in Scratch or Python

  • or C or anything else can listen for and respond to.

  • Indeed, that's why when you tap the phone icon on your phone,

  • the phone application starts up because someone

  • wrote software that's listening for a finger press on that particular icon.

  • So Scratch has these same things, too.

  • Under Control in orange, you can see that we

  • can wait for one second or repeat something

  • some number of times, 10 by default, but we

  • can change anything in these white circles to anything else.

  • There's another puzzle piece here forever,

  • which implies some kind of loop where we can do something again and again.

  • Even though it seems a little tight, there's

  • not much room to fit something there, Scratch

  • is going to have these things grow and shrink

  • however we want to fill similarly shaped pieces.

  • Here are those conditionals.

  • If something is true or false, then do this next thing.

  • And that's how we can put in this little trapezoid-like shape.

  • Some form of Boolean expression, a question with a yes/no, true/false,

  • or one/zero answer and decide whether to do something or not.

  • You can combine these things, too.

  • If something is true, do this, else do this other thing.

  • And you can even tuck one inside of the other

  • if you want to ask three or four or more questions.

  • Sensing, too, is going to be a thing.

  • You can ask questions aka Boolean expressions like is the sprite touching

  • the mouse pointer, the arrow on the screen?

  • So that you can start to interact with these programs.

  • What is the distance between a sprite and a mouse pointer?

  • You can do simple calculations just to figure out maybe

  • if the enemy is getting close to the cat.

  • Under Operator some lower level stuff like math, but also the ability

  • to pick random numbers, which for a game is great

  • because then you can kind of vary the difficulty

  • or what's happening in a game without the same game playing

  • the same way every time.

  • And you can combine ideas.

  • Something and something must be true in order to make that kind of decision

  • before.

  • Or we can even join two words together.

  • Says apple and banana by default, but you can type in or drag and drop

  • whatever you want there to combine multiple words into full,

  • larger sentences.

  • Then lastly down here, there's in orange things called variables.

  • In math we've obviously got x and y and whatnot.

  • In programming we'll have the same ability

  • to store in these named symbols, x or y, values that we care about.

  • Numbers or letters or words or colors or anything, ultimately.

  • But in programming you'll see that it's much more conventional not to just

  • use simple letters like x and y and z, but to actually

  • give variables full singular or plural words to describe what they are.

  • Then lastly, if this isn't enough color blocks for you,

  • you can create your own blocks.

  • Indeed, this is going to be a programming principle we'll apply today

  • and with the first problem set whereby once you start to assemble these puzzle

  • pieces and you realize, oh, would have been nice if those several pieces could

  • have just been replaced by one had MIT thought to give me that

  • one puzzle piece, you yourself can make your own blocks

  • by connecting these all together, giving them a name, and boom,

  • a new puzzle piece will exist.

  • So let's do the simplest, most canonical programs

  • here, starting up with control, and I'm going

  • to click and drag and drop this thing here when green flag clicked.

  • Then I'm going to grab one more, for instance under Looks,

  • and under Looks I'm going to go ahead and just say

  • something like initially not just Hello but the more canonical

  • Hello comma world.

  • Now you might guess that in this programming environment,

  • I can go over here now and click the green flag and voila,

  • Hello comma world.

  • So that's my first program and obviously much

  • more user friendly than typing out the much more cryptic text that we

  • saw on the screen that you, too, will type out next week.

  • But for now, we'll just focus on these ideas, in this case, a function.

  • So what it is that just happened?

  • This purple block here is Say, that's the function,

  • and it seems to take some form of input in the white oval, specifically Hello

  • comma world.

  • Well this actually fits the paradigm that we looked

  • at earlier of just inputs and outputs.

  • So if I may, if you consider what this puzzle piece is doing,

  • it actually fits this model.

  • The input in this case is going to be Hello comma world in white.

  • The algorithm is going to be implemented as a function by MIT called Say

  • and the output of that is going to be some kind of side effect,

  • like the cat and the speech bubble are saying Hello, world.

  • So already even that simple drag and drop

  • mimics exactly this relatively simple mental model.

  • So let's take things further.

  • Let's go ahead now and make the program a little more interactive so

  • that it says something like Hello, David, or Hello, Carter,

  • or Hello to you specifically.

  • And for this, I'm going to go under Sensing.

  • And you might have to poke around to find these things the first time

  • around, but I've done this a few times so I kind of know where things are

  • and what color.

  • There's this function here.

  • Ask what's your name, but that's in white,

  • so we can change the question to anything

  • we want, and it's going to wait for the human to type in their answer.

  • This function called Ask is a little different

  • from the Say block, which just had this side effect of printing a speech

  • bubble to the screen.

  • The ask function is even more powerful in that after it asks the human to type

  • something in.

  • This function is going to hand you back what

  • they typed in in the form of what's called a return value, which

  • is stored ultimately and by default this thing called Answer.

  • This little blue oval here called Answer is again

  • one of these variables that in math would

  • be called just x or y but in programming we're saying what it does.

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

  • Let me go ahead and drag and drop this block

  • and I want to ask the question before saying anything,

  • but you'll notice that Scratch is smart and it's

  • going to realize I want to insert something in between

  • and it's just going to move things up and down.

  • I'm going to let go and ask the default question, what's your name?

  • And now if I want to go ahead and say hello, David or Carter,

  • let's just do Hello comma, because I obviously

  • don't know when I'm writing the program who's going to use it.

  • So let me now grab another looks block up here, say something again, and now

  • let me go back to Sensing and now grab the return value, represented

  • by this other puzzle piece, and let me just drag and drop it here.

  • Notice it's the same shape, even if it's not quite the same size.

  • Things will grow or shrink as needed.

  • All right, so let's now zoom out.

  • Let me go and stop the old version because I don't want to say Hello,

  • world anymore.

  • Let me hit the green flag and what's my name?

  • All right, David.

  • Enter.

  • Huh.

  • All right, maybe I just wasn't paying close enough attention.

  • Let me try it again.

  • Green flag, D-A-V-I-D, Enter.

  • This seems like a bug.

  • What's the bug or mistake might you think?

  • Yeah?

  • AUDIENCE: Do you need to somehow add them together in the same text box?

  • DAVID MALAN: Yeah, we kind of want to combine them in the same text box.

  • And it's technically a bug because this just looks kind of stupid.

  • It's just saying David after I asked for my name.

  • I'd like it to say maybe Hello then David,

  • but it's just blowing past the Hello and printing David.

  • But let's put our finger on why this is happening.

  • You're right for the solution, but what's the actual fundamental problem?

  • In back.

  • AUDIENCE: So it says hello, but it gets to that last step

  • so quickly you can't see it.

  • DAVID MALAN: Perfect.

  • I mean, computers are really darn fast these days.

  • It is saying Hello, all of us are just too slow in this room

  • to even see it because it's then saying David on the screen so fast as well.

  • So there's a couple of solutions here, and yours is spot on,

  • but just to poke around, you'll see the first example

  • of how many ways in programming be it Scratch or C or Python or anything

  • else, that there are going to be to solve problems?

  • We'll teach you over the course of these weeks,

  • sometimes some ways are better relatively than others,

  • but rarely is there a best way necessarily,

  • because again reasonable people will disagree.

  • And what we'll try to teach you over the coming weeks

  • is how to kind of think through those nuances.

  • And it's not going to be obvious at first glance,

  • but the more programs you write, the more feedback

  • you get, the more bugs that you introduce,

  • the more you'll get your footing with exactly this kind of problem solving.

  • So let me try this in a couple of ways.

  • Up here would be one solution to the problem.

  • MIT anticipated this kind of issue, especially with first-time programmers,

  • and I could just use a puzzle piece that says

  • say the following for two seconds or one second

  • or whatever, then do the same with the next word

  • and it might be kind of a bit of a pause,

  • Hello, one second, two seconds, David, one second, two seconds, but at least

  • it would look a little more grammatically correct.

  • But I can do it a little more elegantly, as you've proposed.

  • Let me go ahead and throw away one of these blocks,

  • and you can just drag and let go and it'll delete itself.

  • Let me go down to Operators because this Join block here is the right shape.

  • So even if you're not sure what goes where, just focus on the shapes first.

  • Let me drag this over here.

  • It grew to fill that.

  • Let me go ahead and say hello comma space.

  • Now it could just say by default Hello, banana,

  • but let me go back to Sensing, Drag answer,

  • and that's going to drag and drop there.

  • So now notice we're sort of stacking or nesting one block on another

  • so that the output of one becomes the input to another, but that's OK here.

  • Let me go ahead and zoom out, hit Stop, and hit Play.

  • All right, what's your name?

  • D-A-V-I-D, Enter, and voila.

  • Now it's presumably as we first intended.

  • [APPLAUSE]

  • (LAUGHING) Oh, thank you.

  • Thank you.

  • No minus 2 this time.

  • So consider that even with this additional example,

  • it still fits the same mental model, but in a little more interesting way.

  • Here's that new function Ask something and wait.

  • And notice that in this case too there's an input, otherwise known

  • henceforth as an argument or a parameter, programming

  • speak for just an input in the context of a function.

  • If we use our drawing as before to represent this thing here,

  • we'll see that the input now is going to be quote unquote "What's your name?"

  • The algorithm is going to be implemented by way of this new puzzle piece,

  • the function called Ask, and the output of that thing this time

  • is not going to be the cat saying anything yet,

  • but rather it's going to be the actual answer.

  • So instead of the visual side effect of the speech bubble appearing,

  • now nothing visible is happening yet.

  • Thanks to this function it's sort of handing me back like a scrap of paper

  • with whatever I typed in written on it so I can reuse D-A-V-I-D one or more

  • times even like I did.

  • Now what did I then do with that value?

  • Well consider that with the subsequent function

  • we had this Say block, too, combined with a join.

  • So we have this variable called Answer, we're joining it

  • with that first argument, Hello.

  • So already we see that some functions like Join

  • can take not one but two arguments, or inputs, and that's fine.

  • The output of Join is presumably going to be Hello, David or Hello, Carter

  • or whatever the human typed in.

  • That output notice is essentially becoming the input to another function,

  • Say, just because we've kind of stacked things

  • or nested them on top of one another.

  • But methodically, it's really the same idea.

  • The input now are two things, Hello comma and the return value

  • from the previous Ask function.

  • The function now is going to be Join, the output is going to be Hello, David.

  • But that Hello, David output is now going

  • to become the input to another function, namely that first block called Say,

  • and that's then going to have the side effect of printing out Hello, David

  • on the screen.

  • So again as sort of sophisticated as ours as yours as others programs

  • are going to get, they really do fit this very simple mental model

  • of inputs and outputs and you just have to learn to recognize the vocabulary

  • and to know what kinds of puzzle pieces or concepts ultimately to apply.

  • But you can ultimately really kind of spice these things up.

  • Let me go back to my program here that just is

  • using the speech bubble at the moment.

  • Scratch's inside has some pretty fancy interactive features, too.

  • I click the Extensions button in the bottom left corner.

  • And let me go ahead and choose the Text to Speech extension.

  • This is using a Cloud service, so if you have an internet connection

  • it can actually talk to the Cloud or a third party service,

  • and this one is going to give me a few new green puzzle pieces, namely

  • the ability to speak something from my speakers

  • instead of just saying it textually.

  • So let me go ahead and drag this.

  • Now notice I don't have to interlock them if I'm just kind of playing around

  • and I want to move some things around.

  • I just want to use this as like a canvas temporarily.

  • Let me go ahead and steal the Join from here,

  • put it there, let me throw away the Say block by just moving it

  • left and letting go, and now let me join this in

  • so I've now changed my program to be a little more interesting.

  • So now let me stop the old version.

  • Let me start the new.

  • What's your name?

  • Type in David.

  • And voila:

  • PROGRAM: Hello, banana.

  • DAVID MALAN: (LAUGHING) OK, minus 2 for real.

  • All right, so what I accidentally threw away there, intentionally

  • for instructional purposes, was the actual answer

  • that came back from the ask block.

  • That's embarrassing.

  • So now if I play this again, let's click the green icon.

  • What's your name?

  • David.

  • And now:

  • PROGRAM: Hello, David.

  • DAVID MALAN: There we go.

  • Hello, David.

  • All right, thank you.

  • [APPLAUSE]

  • OK, so we have these functions then in place, but what more can we do?

  • Well what about those conditionals and loops and other constructs?

  • How can we bring these programs to life so it's not just

  • clicking a button and voila, something's happening?

  • Let's go ahead and make this now even more interactive.

  • Let me go ahead and throw away most of these pieces

  • and let me just spice things up with some more audio under Sound.

  • I'm going to go to Play Sound Meow until done.

  • Here we go, green flag.

  • [MEOW]

  • OK, it's a little loud, but it did exactly do what it said.

  • Let's hear it again.

  • [QUIETER MEOW]

  • OK.

  • It's kind of an underwhelming program eventually

  • since you'd like to think that the cat would just meow on its own, but.

  • [MEOW]

  • I have to keep hitting the button.

  • Well this seems like an opportunity for doing something again and again.

  • So all right, well if I wanted to meow, meow, meow,

  • let me just grab a few of these, or you can even right click or Control click

  • and you can Copy Paste even in code here.

  • Let me play this now.

  • [THREE MEOWS]

  • All right, so now like it's not really emoting

  • happiness in quite the same way.

  • It might be hungry or upset.

  • So let's slow it down.

  • Let me go to Control, wait one second in between,

  • which might be a little less worrisome.

  • Here we go, Play.

  • [THREE SLOWER MEOWS]

  • OK, so if my goal was to make the cat meow three times,

  • I dare say this code or algorithm is correct.

  • But let's now critique its design.

  • Is this well-designed?

  • And if not, why not?

  • What are your thoughts here?

  • Yeah?

  • AUDIENCE: You could use the forever or a repeat to make it more--

  • DAVID MALAN: Yeah, so yeah, agreed.

  • I could use forever or repeat, but let me push a little harder.

  • But why?

  • Like this works, I'm kind of done with the assignments, what's bad about it?

  • AUDIENCE: There's too much repetition.

  • DAVID MALAN: Yeah, there's too much repetition, right?

  • If I wanted to change the sound that the cat is making

  • to a different variant of meow or have it bark instead like a dog,

  • I could change it from the dropdown here apparently,

  • but then I'd have to change it here and then I'd have to change it here,

  • and God, if this were even longer that just gets tedious quickly

  • and you're probably increasing the probability

  • that you're going to screw up and you're going

  • to miss one of the dropdowns or something stupid and introduce a bug.

  • Or, if you wanted to change the number of seconds you're waiting,

  • you've got to change it in two, maybe even more places.

  • Again, you're just creating risk for yourself

  • and potential bugs in the program.

  • So I do like the repeat or the forever idea so that I don't repeat myself.

  • And indeed, what I alluded to being possible,

  • copy pasting earlier, doesn't mean it's a good thing.

  • And in code, generally speaking, when you

  • start to copy and paste puzzle pieces or text next week,

  • you're probably not doing something quite well.

  • So let me go ahead and throw away most of these to get rid of the duplication,

  • keeping just two of the blocks that I care about.

  • Let me grab the Repeat block for now, let me move this inside of the Repeat

  • block, it's going to grow to fit it, let me reconnect all this

  • and change the 10 just to a 3, and now, Play.

  • [THREE SLOW MEOWS]

  • So, better.

  • It's the same thing.

  • It's still correct, but now I've set the stage

  • to let the cat meow, for instance, four times by changing one thing,

  • 40 times by changing one thing, or it could just use the Forever block

  • and just walk away and it will meow forever instead.

  • If that's your goal, that would be better.

  • A better design but still correct.

  • But you know what?

  • Now that I have a program that's designed

  • to have a cat meow, wow like why?

  • I mean, MIT invented Scratch, Scratch as a cat,

  • why is there no puzzle piece called Meow?

  • This feels like a missed opportunity.

  • Now to be fair, they gave us all the building blocks

  • with which we could implement that idea, but a principle of programming

  • and really computer science is to leverage what we're

  • going to now start calling Abstraction.

  • We have step-by-step instructions here, the Repeat, the Play,

  • and the Wait that collectively implements this idea

  • that we humans would call meowing.

  • Wouldn't it be nice to abstract away those several puzzle

  • pieces into just one that literally just says what it does, meow?

  • Well here's where we can make our own blocks.

  • Let me go over here to Scratch under the pink block category

  • here and let me click Make a Block.

  • Here I see a slightly different interface

  • where I can choose a name for it and I'm going to call it Meow.

  • I'm going to keep it simple.

  • That's it.

  • No inputs to meow yet.

  • I'm just going to click OK.

  • Now I'm just going to clean this up a bit here.

  • Let me drag and drop Play Sound and Wait over here.

  • And you know what?

  • I'm just going to drag this way down here, way down

  • here because now that I'm done implementing Meow,

  • I'm going to literally abstract it away, sort of out of sight,

  • out of mind, because now notice at top left there is a new pink puzzle

  • piece called Meow.

  • So at this point, I'd argue it doesn't really matter how Meow is implemented.

  • Frankly, I don't know how Ask or Say was implemented by MIT.

  • They abstracted those things away for us.

  • Now I have a brand new puzzle piece that just says what it is.

  • And this is now still correct, but arguably better design.

  • Why?

  • Because it's just more readable to me, to you,

  • it's more maintainable when you look at your code

  • a year from now for the first time because you're sort of finally looking

  • back at the very first program you wrote.

  • It says what it does.

  • The function itself has semantics, which conveys what's going on.

  • If you really care about how Meow is implemented,

  • you could scroll down and start to tinker with the underlying

  • implementation details, but otherwise you don't need to care anymore.

  • Now I feel like there's an even additional opportunity

  • here for abstraction and to factor out some of this functionality.

  • It's kind of lame that I have this Repeat block that

  • lets me call the Meow function, so to speak, use the Meow function

  • three times.

  • Wouldn't it be nice if I could just call them Meow function,

  • aka use the Meow function, and pass it in input that tells the puzzle

  • piece how many times I want it to meow?

  • Well let me go ahead and zoom out and scroll down.

  • Let me right click or Control click on the pink piece here and choose Edit,

  • or I could just start from scratch, no pun intended, with a new one.

  • Now here, rather than just give this thing a name Meow, let me go ahead

  • and add an input here.

  • I'm going to go ahead and type in, for instance, n,

  • for number of times to meow, and just to make

  • this even more user friendly and self descriptive,

  • I'm going to add a label, which has no functional impact,

  • it's just an aesthetic, and I'm just going

  • to say Times, just to make it read more like English

  • in this case that tells me what the puzzle piece does.

  • Now I'm going to click OK.

  • And now I need to refine this a little bit.

  • Let me go ahead and grab under Control a repeat block,

  • let me move the Play, Sound, and Wait, into the repeat block.

  • I don't want 10 and I also don't want 3 here.

  • What I want now is this n that is my actual variable that Scratch

  • is creating for me that represents whatever input the human programmer

  • provides.

  • Notice that snaps right in place.

  • Let me connect this and now voila, I have an even fancier version of Meow

  • that is parameterized.

  • It takes input that affects its behavior accordingly.

  • Now I'm going to scroll back up, because out of sight, out of mind,

  • I just care that Meow exists.

  • Now I can tighten up my code, so to speak, use even fewer lines

  • to do the same thing by throwing away the Repeat block,

  • reconnecting this new puzzle piece here that takes an input like 3 and voila,

  • now we're really programming, right?

  • We've not made any forward progress functionally.

  • The thing just mouse three times.

  • But it's a better design.

  • As you program more and more, these are the kinds

  • of instincts still start to acquire so that one,

  • you can start to take a big assignment, a big problem set, something

  • for homework even, that feels kind of overwhelming at first, like, oh my God

  • where do I even begin?

  • But if you start to identify what are the subproblems of a bigger problem?

  • Then you can start making progress.

  • I do this to this day where if I have to tackle some programming-related project

  • it's so easy to drag my feet and ugh, it's going to take forever to start,

  • until I just start writing down like a to do list

  • and I start to modularize the program and say, all right, well

  • what do I want this thing to do?

  • Meowing.

  • What's that mean?

  • I've got to have it say something on the screen.

  • All right, I need to have it say something on the screen

  • some number of times.

  • Like literally a mental or written checklist, or pseudocode code,

  • if you will, in English on a piece of paper or text file,

  • and then you can decide, OK, the first thing I

  • need to do for homework to solve this real world problem,

  • I just need a Meow function.

  • I need to use a bunch of other code, too,

  • but I need to create a Meow function and boom,

  • now you have a piece of the problem solved not unlike we did with the phone

  • book there, but in this case, we'll have presumably other problems to solve.

  • All right, so what more can we do?

  • Let's add a few more pieces to the puzzle here.

  • Let's actually interact with the cat now.

  • Let me go ahead and now when the green flag is clicked, let me go ahead

  • and ask a question using an event here.

  • Let me go ahead and say, let's see, I want

  • to do something like implement the notion of petting the cat.

  • So if the cursor is touching the cat like here, something like this,

  • it'd be cute if the cat meows like you're petting a cat.

  • So I'm going to ask the question, when the green flag is clicked,

  • if let's see I think I need Sensing.

  • So if touching mouse pointer, this is way too big

  • but again the shape is fine, so there goes.

  • Grew to fill.

  • And then if it's touching the mouse pointer,

  • that is if the cat to whom this script or this program,

  • any time I attach puzzle pieces MIT calls them a script

  • or like a program, if you will, let me go ahead then and choose a sound

  • and say play sound meow until done.

  • All right, so here it is to be clear.

  • When the green flag is clicked, ask the question,

  • if the cat is touching the mouse pointer then place sound meow.

  • Here we go.

  • Play.

  • [SILENCE]

  • All right, let's try again.

  • Play.

  • [SILENCE]

  • Huh.

  • I'm worried it's not Scratch's fault. Feels like mine.

  • What's the bug here?

  • Why doesn't this work?

  • Yeah, in back, who just turned.

  • AUDIENCE: [INAUDIBLE]

  • DAVID MALAN: Yeah, the problem is the moment I click that green flag,

  • Scratch asks the question, is the cat touching the mouse pointer?

  • And obviously it's not because the cursor was like up there a moment ago

  • and it's not down there.

  • It's fine if I move the cursor down there, but too late.

  • The program already asked the question.

  • The answer was no or false or zero, however you want to think about it,

  • so no sound was played.

  • So what might be the solution here be?

  • I could move my cursor quickly, but that feels

  • like never going to work out right.

  • Other solutions here?

  • Yeah, in way back?

  • Could you use the forever loop?

  • The Forever loop.

  • So I could indeed use this Forever loop because if I want my program

  • to just constantly listen to me, well let's literally do something forever,

  • or at least forever as long as the program is

  • running until I explicitly hit Stop.

  • So let me grab that.

  • Let me go to Control, let me grab the Forever block,

  • let me move the If inside of this Forever block, reconnect this,

  • go back up here, click the green flag, and now nothing's happened yet,

  • but let me try moving my cursor now.

  • [MEOW]

  • Oh.

  • So now.

  • [MEOW]

  • That's kind of cute.

  • So now the cat is actually responding and it's

  • going to keep doing this again and again.

  • So now we have this idea of taking these different ideas, these different puzzle

  • pieces, assembling them into something more complicated.

  • I could definitely put a name to this.

  • I could create a custom block, but for now

  • let's just consider what kind of more interactivity we can do.

  • Let me go ahead and do this.

  • By again grabbing a, when green flag clicked,

  • let me go ahead and click the video sensing,

  • and I'm going to rotate the laptop because otherwise we're

  • going to get a little inception thing here where the camera is picking up

  • the camera is up there.

  • So I'm going to go reveal to you what's inside the lectern

  • here while we rotate this.

  • Now that we have a non video backdrop, I'm going to say this.

  • Instead of the green flag clicked, actually, I'm

  • going to say when the video motion is greater than some arbitrary

  • measurement of motion, I'm going to go ahead and play sound meow until done.

  • And then I'm going to get out of the way.

  • So here's the cat.

  • We'll put them on top of there.

  • [MEOW]

  • OK.

  • All right, and here we go.

  • [MEOW]

  • So my hand is moving faster than 50 something or other,

  • whatever the unit of measure is.

  • [MEOW]

  • AUDIENCE: Aw.

  • DAVID MALAN: (LAUGHING) Thank you.

  • So now we have an even more interactive version.

  • [MEOW]

  • But I think if I sort of slowly.

  • [LAUGHING]

  • (LAUGHING) Right?

  • It's completely creepy, but I'm not like exceeding the threshold--

  • [MEOW]

  • Until finally my hand moves as fast as that.

  • And so here actually is an opportunity to show you

  • something a former student did.

  • Let me go ahead here and--

  • [MEOW TWICE]

  • OK, got to stop this.

  • Let me go ahead and zoom out of this in just a moment.

  • [MEOW]

  • If someone would be--

  • [LAUGHING]

  • (LAUGHING) If someone would be comfortable

  • coming up not only masked but also on camera on the internet

  • I thought we'd play one of your former classmate's projects here up on stage.

  • Would anyone like to volunteer here and be up on stage?

  • Who's that?

  • Yeah.

  • Come on down.

  • What's your name?

  • AUDIENCE: Sahar.

  • DAVID MALAN: Sahar.

  • All right, come on down.

  • Let me get it set up for you here.

  • [MEOW]

  • [APPLAUSE]

  • [MEOW]

  • All right, let me go ahead and full screen this here.

  • So this is whack-a-mole by one of your firmer predecessors.

  • It's going to use the camera focusing on your head, which will have

  • to position inside of this rectangle.

  • Have you ever played the whack-a-mole game at an arcade?

  • AUDIENCE: Yeah.

  • DAVID MALAN: OK.

  • So for those who haven't, these little moles pop up

  • and with a very fuzzy hammer you sort of hit down.

  • You though, if you don't mind, you're going

  • to use your head to do this virtually.

  • So let's line up your head with this red rectangle, if you could,

  • we'll do beginner.

  • [MUSIC PLAYING]

  • All right, here we go.

  • Sahar.

  • Give it a moment.

  • OK, come a little closer.

  • [DINGING]

  • And now hit the moles with your head.

  • [DING]

  • There we go, one point.

  • [DING]

  • One point.

  • [DINGING]

  • Nice.

  • 15 seconds to go.

  • There we go.

  • Oh yeah.

  • One point.

  • [LAUGHING]

  • [DINGING]

  • Six seconds.

  • AUDIENCE: Oh no.

  • DAVID MALAN: There we go.

  • Quick!

  • [DINGING]

  • All right, a round of applause for Sahar.

  • Thank you.

  • [APPLAUSE]

  • So beyond having a little bit of fun here,

  • the goal was to demonstrate that by using

  • some fairly simple, primitive, some basic building blocks

  • but assembling them in a fun way with some music, maybe

  • some new costumes or artwork, you can really bring programs to life.

  • But at the end of the day, the only puzzle pieces really involved

  • were ones like the ones I just dragged and dropped and a few more,

  • because there were clearly lots of moles.

  • So the student probably created a few different sprites, not a single cap,

  • but at least four different moles.

  • They had like some kind of graphic on the screen that showed Sahar

  • where to position her head.

  • There were some kind of timer, maybe a variable

  • that every second was counting down.

  • So you can imagine taking what looks like a pretty impressive project

  • at first glance, and perhaps overwhelming

  • to solve yourself, but just think about what are the basic building blocks?

  • And pluck off one piece of the puzzle, so to speak, at a time.

  • So indeed if we rewind a little bit.

  • Let me go ahead here and introduce a program

  • that I myself made back in graduate school

  • when Scratch was first being developed by MIT.

  • Let me go ahead and open here, give me just one second,

  • something that I called back in the day Oscar Time that

  • looks a little something like this.

  • If I fullscreen it and hit Play.

  • [MUSIC - SESAME STREET, "I LOVE TRASH"]

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

  • DAVID MALAN: So you'll notice a piece of trash is falling.

  • I can click on it and drag and as I get close and close to the trash can notice

  • OSCAR THE GROUCH: (SINGING) Anything ragged or--

  • DAVID MALAN: It wants to go in, it seems.

  • And if I let go--

  • OSCAR THE GROUCH: (SINGING) Yes, I--

  • DAVID MALAN: One point.

  • Here comes another.

  • OSCAR THE GROUCH: (SINGING) If you really want to see something trashy--

  • DAVID MALAN: I'll do the same, two points.

  • OSCAR THE GROUCH: (SINGING) I have here a sneaker that's tattered and worn--

  • DAVID MALAN: There's a sneaker falling from the sky,

  • so another sprite of some sort.

  • OSCAR THE GROUCH: (SINGING) The laces are torn.

  • A gift from my mother--

  • DAVID MALAN: I can also get just a little lazy

  • and just let them fall into the trash themself if I want to.

  • So you can see it doesn't have to do with my mouse cursor,

  • it has to do apparently with the distance here.

  • Let's listen a little further.

  • I think some additional trash is about to make its appearance.

  • Presumably there's some kind of variable that's keeping track of this score.

  • OSCAR THE GROUCH: (SINGING) I love--

  • DAVID MALAN: OK, let's see what the last chorus here is.

  • OSCAR THE GROUCH: (SINGING) Rotten stuff.

  • I have here some newspaper, crusty and

  • DAVID MALAN: OK, and thus he continues.

  • And the song actually goes on and on and on

  • and I do not have fond memories of implementing this and hearing

  • this song for like 10 straight hours, but it's

  • a good example to just consider how was this program composed?

  • How did I go about implementing it the first time around?

  • And let me go ahead and open up some programs now

  • that I wrote in advance just so that we could

  • see how these things are assembled.

  • Honestly, the first thing I probably did was probably

  • to do something a little like this.

  • Here is just a version of the program where

  • I set out to solve just one problem first

  • of planting a lamp post in the program.

  • Right?

  • I kind of had a vision of what I wanted.

  • You know, it evolved over time, certainly,

  • but I knew I wanted trash to fall, I wanted

  • a cute little Oscar the Grouch to pop out

  • of the trashcan, and some other stuff, but wow that's a lot

  • to just tackle all at once.

  • I'm going to start easy, download a picture of a lamp post,

  • and then drag and drop it into the stage as a costume and boom, that's

  • version one.

  • It doesn't functionally do anything.

  • I mean, literally that's the code that I wrote to do this.

  • All I did was use like the Backdrops feature

  • and drag and drop and move things around,

  • but it got me to version one of my program.

  • Then what might version two be?

  • Well I considered what piece of functionality

  • frankly might be the easiest to pluck off next and the trash can.

  • That seems like a pretty core piece of functionality.

  • It just needs to sit there most of the time.

  • So the next thing I probably did was to open up,

  • for instance, the trash can version here that looks a little something now

  • like this.

  • So this time I'll show you what's inside here.

  • There is some code, but not much.

  • Notice at bottom right I change the default cat to a picture of a trashcan,

  • instead, but it's the same principle that I can control.

  • And then over here I added this code.

  • When the green flag is clicked, switch the costume

  • to something I arbitrarily called Oscar 1.

  • So I found a couple of different pictures

  • of a trash can, one that looks closed, one that looks partly open,

  • and eventually one that has Oscar coming out,

  • and I just gave them different names.

  • So I said Switch to Oscar 1, which is the closed one by default,

  • then forever do the following: if touching the mouse pointer,

  • then switch the costume to Oscar 2, else switch to Oscar 1.

  • That is to say, I just wanted to implement this idea of the can opening

  • and closing, even if it's not exactly what I wanted ultimately,

  • I just wanted to make some forward progress.

  • So here, when I run this program by clicking Play, notice what happens.

  • Nothing yet, but if I get closer to the trash can,

  • it indeed pops open because it's forever listening

  • for whether the sprite, the trash can in this case,

  • is touching the mouse pointer.

  • And that's it.

  • That was version 2, if you will.

  • If I went in now and added the lamp post and compose the program together,

  • now we're starting to make progress.

  • Right?

  • Now it would look a little something more like the program

  • I intended ultimately to create.

  • What piece did I probably bite off after that?

  • Well, I think what I did is I probably decided

  • let me implement one of the pieces of trash, not the shoe in the newspaper

  • all at once.

  • Let's just get one piece of trash working correctly first.

  • So let me go ahead and open this one.

  • And again, all of these examples will be available on the course's website

  • so you can see all of these examples, too.

  • It's not terribly long, I just implement it in advance

  • so we could flip through kind of quickly.

  • Here's what I did here.

  • On the right hand side, I turned my sprite into a piece of trash

  • this time instead of a cat, instead of a trash can,

  • and I also created, with Carter's help, a second sprite, this one a floor.

  • It's literally just a black line because I just wanted initially

  • to have some notion of a floor so I could detect

  • if the trash is touching the floor.

  • Now without seeing the code yet, just hearing that description,

  • why might I have wanted the second sprite and this black line for a floor

  • with the trash intending to fall from the sky?

  • What might I have been thinking?

  • Like what problem might I be trying to solve?

  • Yeah?

  • AUDIENCE: You don't want the first sprite to go through it.

  • DAVID MALAN: Yeah, you don't want the first sprite to start at the top,

  • go through, and then boom, you completely lose it.

  • That would not be a very useful thing.

  • Or it would seem to maybe eat up more and more of the computer's memory

  • if the trash is just endlessly falling and I can't grab it.

  • It might be a little traumatic if you tried to get it

  • and you can't pull it back out and you can't fix the program.

  • So I just wanted the thing to stop.

  • So how might I have implemented this?

  • Let's look at the code at left.

  • Here I have a bit of randomness, like I proposed earlier exists.

  • There's this blue function called Go To x,

  • y that lets me move a sprite to any position,

  • up, down, left, right, I picked a random x location, either here or over here,

  • negative 240 to positive 240, and then a y value of 180, which is the top.

  • This just makes the game more interesting.

  • It's kind of lame pretty quickly if the trash always falls from the same spot.

  • Here's this a little bit of randomness, like most any game would have,

  • that spices things up.

  • So now if I click the green flag, you'll see that it just falls,

  • nothing interesting is going to happen, but it

  • does stop when it touches the black line because notice what we did here.

  • I'm forever asking the question if the distance of the sprite, the trash,

  • is to the floor is greater than zero, that's fine.

  • Change the y location by negative 3.

  • So move it down 3 pixels, down 3 pixels, until the distance to the floor

  • is not greater than zero, it is zero or even negative, at which point

  • it should just stop moving altogether.

  • There's other ways we could have implemented this,

  • but this felt like a nice, clean way that logically, just

  • made it make sense.

  • OK, now I got some trash falling, I got a trash can that opens and closes,

  • I have a lamp post, now I'm a good three steps into the program.

  • We're making progress.

  • If we consider one or two final pieces, something

  • like the dragging of the trash, let me go ahead and open up this version 2.

  • Dragging the trash requires a different type of question.

  • Let me zoom in here.

  • Here's the piece of trash.

  • I only need one sprite, no floor here because I just

  • want the human to move it up, down, left, right and the human's

  • not going to physically be able to move it outside of the world.

  • If we zoom in on this code, the way we've solved this is as follows.

  • We're using that And conjunction that we glimpsed earlier because when

  • the green flag is clicked, we're forever asking this question or really

  • these questions, plural, if the mouse is down

  • and the trash is touching the mouse pointer, that's equivalent

  • logically to clicking on the trash.

  • Go ahead and move the trash to the mouse pointer.

  • So again it takes this very familiar idea

  • that you and I take for granted every day on Macs and PCs of clicking

  • and dragging and dropping.

  • How is that implemented?

  • Well Mac OS or Windows are probably asking a question.

  • For every icon, is the mouse down and is the icon touching the mouse?

  • If so, go to the location of the mouse forever

  • while the mouse button is clicked down.

  • So how does this work in reality now?

  • Let me go ahead and click on the Play.

  • Nothing happens at first, but if I click on it, I can move it up,

  • down, left, right.

  • It doesn't move thereafter.

  • So I now need to kind of combine this idea of dragging with falling,

  • but I bet I could just start to use just one single program.

  • Right now I'm using separate ones to show different ideas,

  • but now that's another bite out of the problem.

  • If we do one last one, something like the scorekeeping

  • is interesting, because recall that every time we dragged a piece of trash

  • into the can, Oscar popped out and told us the current score.

  • So let me go ahead and find this one, Oscar variables,

  • and let me zoom in on this one.

  • This one is longer because we combined all of these elements.

  • So this is the kind of thing that if you looked at first glance, like,

  • I have no idea how I would have implemented this

  • from nothing, from scratch literally.

  • But again, if you take your vision and componenitize it

  • into these smaller, bite-sized problems, you

  • could take these baby steps, so to speak, and then

  • solve everything collectively.

  • So what's new here is this bottom one.

  • Forever do the following: if the trash is touching

  • Oscar, the other sprite that we've now added to the program,

  • change the score by 1.

  • This is an orange and indeed if we poke around

  • we'll see that orange is a variable, like an x or y but with a better name,

  • changing it means to add 1 or if it's negative subtract 1.

  • Then go ahead and have the trash go to pick random.

  • What is this all about?

  • Well, let me show you what it's doing and then we can infer backwards.

  • Let me go ahead and hit Play.

  • All right, it's falling, I'm clicking and dragging it, I'm moving it over,

  • and I'm letting go.

  • All right, let me do it once more.

  • Letting go, let me stop.

  • Why do I have this function at the end called Go To x and y randomly?

  • Like what problem is this solving here?

  • Yeah, in way back.

  • AUDIENCE: Just the same track teleported to the top

  • after you put it in the trash can.

  • DAVID MALAN: Yeah, exactly.

  • Even though the human perceives this as like a lot of trash falling

  • from the sky, it's actually the same piece

  • of trash, just kind of being magically moved back to the top

  • as though it's a new one.

  • There, too, you have this idea of reusable code.

  • If you were constantly copying and pasting your pieces of trash

  • and creating 20 pieces of trash, 30 pieces of trash, just because you

  • want the game to have that many levels, probably doing something wrong.

  • Reuse the code that you wrote, reuse the sprites that you wrote,

  • and that would give you not just correctness, but also a better design.

  • Well let's take a look at one final set of building blocks

  • that we can compose ultimately into something

  • particularly interactive as follows.

  • Let me go ahead and zoom out here and let

  • me propose that we implement something like some kind of maze-based game.

  • Let me go ahead here.

  • So I want to implement some maze-based game that

  • looks at first glance like this.

  • Let me hit Play.

  • It's not a very fun game yet, but here's a little Harvard

  • shield, a couple of black lines, this time vertical instead of horizontal,

  • but notice you can't quite see my hand here,

  • but I'm using my arrow keys to go down, to go up, to go left, to go right,

  • but if I keep going right, right, right, right, right, right,

  • right it's not going anywhere.

  • And left, left, left, left, left, left, left, left, left, left, left, left,

  • left it eventually stops.

  • So before we look at the code, how might this be working?

  • What kinds of scripts, collections of puzzle pieces,

  • might collectively help us implement this?

  • What do you think?

  • AUDIENCE: [INAUDIBLE]

  • DAVID MALAN: Perfect, yeah.

  • There's probably some question being asked, if touching the black line,

  • and it happens to be a couple of sprites, each of which

  • is just literally a vertical black line we're probably asking a question like,

  • are you touching it?

  • Is the distance to it zero or close to zero?

  • And if so, we just ignore the left or the right arrow at that point.

  • So that works.

  • But otherwise, if we're not touching a wall,

  • what are we probably doing instead forever here?

  • How is the movement working presumably?

  • Yeah and back.

  • Oh are you scratching?

  • OK, sure.

  • Let's go on.

  • AUDIENCE: [INAUDIBLE]

  • DAVID MALAN: Sorry, say a little louder.

  • AUDIENCE: Presumably it's continually looking for you to hit the arrow keys

  • and then moving when you do.

  • DAVID MALAN: Exactly.

  • It's continually, forever listening for the arrow keys up, down, left, right,

  • and if the up arrow is pressed, we're probably

  • changing the y by a positive value.

  • If the down arrow is pressed, we're going down by y,

  • and left and right accordingly.

  • So let's actually take a quick look.

  • If I zoom out here and take a look at the code that implements this,

  • there's a lot going on at first glance, but let's see.

  • First of all, let me drag some stuff out of the way

  • because it's kind of overwhelming at first glance,

  • especially if you, for instance, were poking around online as for problem set

  • 0 just to get inspiration, most projects out there

  • are going to look overwhelming at first glance

  • until you start to wrap your mind around what's going on.

  • But in this case, we've implemented some abstractions

  • from the get go to explain to ourselves and to anyone else looking

  • at the code what's going on.

  • This is that program with the two black lines and the Harvard shield going up,

  • down, left, and right.

  • It initially puts the shield in the middle, 0,0, then

  • forever listens for keyboard, as I think you were describing,

  • and it feels for the walls, as I think you were describing.

  • Now how is that implemented?

  • Don't know yet.

  • These are custom blocks we created as abstractions to kind of hide

  • those implementation details because honestly that's

  • all I need to know right now.

  • But, as aspiring programmers, if we're curious now,

  • let's scroll down to the actual implementation

  • of listening for keyboard.

  • This is the one on the left and it is a little long,

  • but it's a lot of similar structure.

  • We're doing the following, if the up arrow is pressed, then change y by 1.

  • Go up.

  • If the down arrow is pressed, then change y by negative 1.

  • Go down.

  • Right arrow, left arrow, and that's it.

  • So it just assembles all of those ideas, combines it

  • into one new block just because it's kind of overwhelming,

  • let's just implement it once and tuck it away.

  • And if we scroll now over to the Feel for Walls function,

  • this now is asking the question as hypothesized,

  • if I'm touching the left wall, change my x value by 1, sort of move away from it

  • a little bit.

  • If I'm touching the right wall, then move x by negative 1

  • to move a little bit away from it.

  • So it kind of bounces off the wall.

  • Just in case it slightly went over, we keep the crest within those two walls.

  • All right, then a couple of more pieces here to introduce.

  • What if we want to actually add some kind of adversary or opponent

  • to this game?

  • Well, let me go ahead to maybe this one here where the adversary in this game

  • might, for instance, be designed to be bouncing to stand in your way.

  • This is like a maze and you're trying to get the Harvard shield from the bottom

  • to the top or vice versa.

  • Uh oh, Yale is in the way and it seems to be automatically bouncing

  • back and forth here.

  • Well, let me ask someone else.

  • Hypothesize.

  • How is this working?

  • This is an idea you have, this as an idea you see.

  • Let's reverse engineer in your head how it works.

  • How might this be working?

  • Yeah, in back.

  • AUDIENCE: If the Yale symbol is touching a right wall or left wall,

  • then have it bounce.

  • DAVID MALAN: Yeah, so if the Yale symbol is

  • touching the left wall or the right wall, we somehow have it bounce.

  • And indeed we'll see there's a puzzle piece that can do exactly

  • that technically off the edge, as we'll see,

  • but there's another way we can do this.

  • Let's look at the code.

  • The way we ourselves can implement exactly

  • that idea bounce is just with a little bit of logic.

  • So here's what this version of the program is doing.

  • It's moving Yale by default to 0,0 just to arbitrarily put it somewhere,

  • pointing it direction 90 degrees, which means just horizontally, essentially,

  • and then it's forever doing this: if touching the left wall

  • or touching the right wall, here's our translation of bounce.

  • We're just turning 180 degrees.

  • And the nice thing about that is we don't

  • have to worry if we're going from right to left or left to right.

  • 180 degrees is going to work on both of the walls.

  • And that's it.

  • After we do that, we just move one step, one pixel, at a time

  • but we're doing it forever so something is happening continually

  • and the Yale icon is bouncing back and forth.

  • Well one final piece here, what if now we

  • want another adversary, a more advanced adversary down the road for instance,

  • to go and follow us wherever we are such that this time

  • we want the other sprite to not just bounce back and forth,

  • but literally follow us no matter where we go.

  • How might this be implemented on the screen?

  • I bet it's another forever block, but what's inside?

  • AUDIENCE: So forever get the location of the of the Harvard shield

  • and move one step towards it.

  • DAVID MALAN: Yeah, forever point at the location of the Harvard shield

  • and go one step toward it.

  • This is just going to go on forever if I just give up, at least in this version.

  • Notice it's sort of twitching back and forth because it goes one

  • pixel then one pixel then one pixel.

  • It's sort of in a frantic state here.

  • We haven't finished the game yet, but if we see inside, we'll see exactly that.

  • It didn't take much to implement this simple idea.

  • Go to a random position just to make it kind of fair,

  • initially, then forever point towards Harvard,

  • which is what we called the Harvard crest sprite, move one step.

  • Suppose we now wanted to make a more advanced level.

  • What's a minor change I could logically make to this code just

  • to make MIT even better at this?

  • AUDIENCE: Change the number of steps to two.

  • DAVID MALAN: All right, change the number of steps to two.

  • So let's try that.

  • So now they got twice as fast.

  • Let me go ahead and just get this out of the way.

  • Oops, let me make it a fair fight.

  • Green flag.

  • All right, I unfortunately am still moving one pixel at a time,

  • so this isn't going to end well.

  • It caught up to me.

  • And if we're really aggressive and do something like 20 steps at a time,

  • click the green flag.

  • Jesus, OK, so that's how you might then make your levels progressively

  • harder and harder.

  • So it's not an accident that we chose these particular examples

  • here involving these particular schools because we have one more

  • demonstration we thought we'd introduce today

  • if we could get one other volunteer to come up and play

  • what was called by one of your predecessors Ivy's Hardest Game.

  • Let's see, you in the middle.

  • Do you want to come on up?

  • What's your name?

  • AUDIENCE: Celeste.

  • DAVID MALAN: Say again?

  • AUDIENCE: Celeste.

  • DAVID MALAN: Come a little closer, actually.

  • Sorry, hard to hear here.

  • All right, round of applause here if we could, too.

  • [APPLAUSE]

  • OK, sorry, what was your name?

  • AUDIENCE: Celeste.

  • DAVID MALAN: Ceweste

  • AUDIENCE: Celeste.

  • DAVID MALAN: Celeste.

  • AUDIENCE: Yes.

  • DAVID MALAN: Come on over.

  • Nice to meet you, too.

  • So here we have on this other screen Ivy's Hardest Game

  • written by a former CS50 student.

  • I think you'll see that it combines these same principles.

  • The maze is clearly a little more advanced.

  • The goal at hand is to initially move the Harvard crest to the sprite all

  • the way on the right so that you catch up to him in this case,

  • but you'll see that there's different levels

  • and different levels of sophistication.

  • So if you're up for it, you can use just these arrow keys up, down, left, right.

  • You'll be controlling the Harvard sprite and if we

  • could raise the volume just a little bit, we'll make this our final example.

  • Here we go, clicking the green flag.

  • [MUSIC PLAYING]

  • Feeling ready?

  • AUDIENCE: Yep.

  • DAVID MALAN: Spacebar.

  • [MUSIC - MC HAMMER, "U CAN'T TOUCH THIS"]

  • MC HAMMER: (SINGING) Can't touch this.

  • You can't touch this.

  • You can't touch this.

  • Can't touch this.

  • My, my, my, my music--

  • DAVID MALAN: Excellent.

  • MC HAMMER: (SINGING) so hard.

  • Makes me want to say, oh my Lord.

  • Thank you for blessing me--

  • DAVID MALAN: Two Yales now.

  • MC HAMMER: (SINGING) Feels good when you know you're down.

  • A super dope homeboy--

  • AUDIENCE: Oh!

  • DAVID MALAN: Oh!

  • Keep going.

  • MC HAMMER: (SINGING) You can't touch this.

  • I told you, homeboy.

  • Can't touch this.

  • Yeah, that's how living--

  • DAVID MALAN: All right.

  • MC HAMMER: (SINGING) Can't touch this.

  • Look at my eyes, man.

  • You can't touch this.

  • You let me bust the funky lyrics.

  • You can't touch this.

  • Fresh new kicks and pants.

  • You got it like that and you know you want to dance.

  • So move out of your seat and get a fly girl and catch this beat.

  • [LAUGHING]

  • Hold on.

  • Pump a little bit and let them know what's going on like that, like that.

  • Cold on a mission, so fall on back.

  • Let them know that you're too--

  • DAVID MALAN: There you go.

  • There you go.

  • [APPLAUSE]

  • MC HAMMER: (SINGING) Can't touch this.

  • Why you standing there, man?

  • You can't touch this.

  • Yo, sound the bell.

  • School's in, sucker.

  • Can't touch this.

  • Give me a song or rhythm, making them sweat that's what give them.

  • [CHEERING]

  • They know.

  • You talking the Hammer when you're talking about a show.

  • That's hyped and tight.

  • Singers are sweating so them a wipe or a tame to learn.

  • DAVID MALAN: Second to last level.

  • Oh!

  • MC HAMMER: (SINGING) That chart's legit.

  • Either work hard or you might as well quit.

  • That word because you know--

  • DAVID MALAN: Oh!

  • Keep going, keep going!

  • Yes!

  • MC HAMMER: (SINGING) You can't touch this.

  • DAVID MALAN: You're almost there.

  • MC HAMMER: (SINGING) Break it down.

  • DAVID MALAN: There you go.

  • Go, go, go!

  • Oh.

  • One more.

  • Yes!

  • [CHEERING]

  • There you go.

  • MC HAMMER: (SINGING) Stop, Hammer time.

  • "Go with the flow," it is said.

  • If you can't groove to this, then you're probably 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.

  • Now move, slide your rump.

  • Just for a minute let's all do the bump.

  • [CHEERING]

  • DAVID MALAN: Yes!

  • [APPLAUSE]

  • Congratulations.

  • All right, that's it for CS50.

  • Welcome to the class.

  • We'll see you next time.

  • [MUSIC PLAYING]

[MUSIC PLAYING]

字幕與單字

單字即點即查 點擊單字可以查詢單字解釋

B1 中級 美國腔

第0章-從頭開始(CS50 2021 in HDR - Lecture 0 - Scratch)

  • 5 0
    卓佑 發佈於 2022 年 04 月 24 日
影片單字