B1 Intermediate US 161 Folder Collection
After playing the video, you can click or select the word to look it up in the dictionary.
Report Subtitle Errors
DAVID MALAN: This is CS50, Harvard University's introduction
to the intellectual enterprises of computer science
and the art of programming.
My name is David Malan, and if you are among those
in the room who are thinking, why am I in a class of computer science,
realize that I too felt that exact same way.
In fact, my freshman year, I didn't quite
get up the nerve to take this class or computer science more generally,
and that was largely because I was intimidated by it.
I was a little nervous.
It felt well out of my comfort zone.
And I really didn't know at the end of the day what it actually was.
But realize if you, too, are feeling a little bit of that,
or even if you're among those more comfortable who
have dabbled in computer science or programming,
realize that there's so many blanks that we can fill in along the way
so that ultimately, at the end of the semester, everyone
will feel themselves on the same page.
And until then, rest assured that 68% of the people sitting to your left
and to your right and behind and in front
have never taken a CS course before, which may very well be
the demographic into which you fit.
But realize, too, that with such an amazing support
structure with so many office hours and sections and materials and beyond,
realize that what's ultimately important in this course
is not so much where you end up relative to your classmates
in week 10, our final week, but where you end up relative to yourself
in week zero.
And indeed, that is where we now are.
And as it turns out, computer scientists start counting at zero.
And so over the next 11 weeks, we will take you
from being among those less comfortable or perhaps
somewhere in between less comfortable and more
to feeling much more comfortable and confident and capable than that.
But to get there, we need to understand what computer science really is.
And this was something I didn't understand until I set foot in a room
like this.
And I dare say we can distill computer science into just this picture.
Computer science is about problem solving.
And I know that high school courses typically do kind of paint
a misleading picture that it's only about
and it's entirely about programming and people with their heads
down in the computer lab working fairly anti-socially on code,
but the reality is it's all about solving problems, and very often,
solving problems collaboratively either in person or by leveraging code,
programs that others have written in the past.
And what does it mean to solve a problem?
Well, you need inputs.
So there's a problem you're trying to solve.
That is the input.
And you want output.
You want the solution to that problem.
And the sort of secret sauce of computer science
is going to be everything in this proverbial black box
in the middle over the next several weeks,
where you begin to understand exactly what you can do with that.
But in order to start solving problems, we kind of just
need to decide as a group how we're going to represent these problems
and what might a problem be.
Well, in this room, there's a whole bunch of people.
If we wanted to take attendance or count the number of people in this room,
I might need to start keeping track of how many people I see.
But how do I represent the number of people I see?
Well, I can do it sort of old school and I can just take out a piece of chalk
or whatnot and say, all right.
I see 1, 2, 3, 4, 5.
I can do little stylistic conventions like that
to save space and remind myself.
6, 7, 8, 9, 10, and so forth.
Or I can, of course, just do that on my own hand.
So 1, 2, 3, 4, 5, and so forth.
But obviously, how high can I count on just one hand?
So 5 you would think, but that's just because we haven't really
thought hard enough about this problem.
It turns out that with just these five fingers, let alone these five more,
I can actually count rather higher because after all, the system
I'm using of hashmarks on the board or just
now with my fingers is just kind of keeping my fingers down and putting
them up to represent ones, really.
But what if I actually took into account the order of my fingers
and sort of permuted them, so to speak, so that it's really patterns of fingers
that represent the number of people in the room,
and not just the mere presence of a finger going up or down.
In other words, this can remain zero.
This could still be one.
But what if two is not just this, the obvious?
But what if it's just this?
So raising just one, my second finger.
What if, then, three is this?
So we have 0, 1, 2, 3.
That's going to lead us to four somewhat offensively.
But if we begin to jump ahead to five, I might now
permute this finger and this finger up.
And if I want to now represent six, I could do this.
And now seven.
In other words, I've expressed so many more patterns on my hand already
and if we keep doing this, I think I can actually
represent painfully perhaps like 32 different patterns, and therefore
32 different people, on my hands alone.
Or 31 people if I start counting at zero.
So what is that-- what's the relationship
and how did we even get here?
Well, it turns out that computers are kind of simplistic,
much like our hands here.
At the end of the day, your computer is plugged into the wall
or it's got a battery, so it either has or it does not have electricity.
At the end of the day, that is the physical resource
that drives these things and our phones and all of technology today.
So if there is either electricity or not, that kind of maps nicely
to no finger or yes finger.
And indeed, computers, as you probably know, only speak what language?
What alphabet, so to speak?
Bi meaning two.
And indeed, that refers to the fact that in binary in computers,
you only have two digits--
zero and one.
We humans, of course, have 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
and then we can combine those to count even higher.
But computers only have 0, 1, and then that's it.
Because at the end of the day, there's actually
a direct mapping between power being off and it being a zero or power being on
and it being one, or some electrons or whatever flowing from your battery
or from the wall.
So this is why computers tend to speak only binary,
because at the end of the day, it just maps really cleanly
to what it is that's powering them in the first place.
But how is this actually useful?
If computers only have zeros and ones, how can they do anything useful?
Well, think about our human world, where you might have this pattern of symbols.
This is decimal, dec meaning 10 because you have 0 through 9.
And this is, of course, 123.
But why?
If you haven't thought about this in quite some time,
this is really just a pattern of three symbols, one and two and three shapes,
or glyphs, on the screen.
But we humans, ever since grade school, have started ascribing meaning
to each of these numbers, right?
If you think back, this is the ones column, this is the tens column,
this is the hundreds column, and so forth, and we could keep going.
And so why does this pattern-- one, two, three-- mean 123?
Well, it's because all of us sort of intuitively
nowadays are just quickly in our head doing 100 times 1 plus 10 times
2 plus 1 times 3, which of course gives us 100 plus 20 plus three,
and then the number we know mathematically as 123.
But we're all doing this so quickly, you don't really think about this anymore.
Well, computers work fundamentally the same way.
They don't have as many digits--
0 through 9-- as we do.
They only have zeros and ones.
And so if they were to store values, you're
only going to see zeros and ones on the screen,
but those zeros and ones just mean different things.
Instead of having a ones place, tens, a hundreds,
they're going to have a ones place, a twos place, a fours place,
and then eights and 16 and beyond.
Now, why?
Well, one and 10 and 100, turns out those are powers of 10.
10 to the 0 is technically 1.
10 to the 1 is just 10.
10 to the 2 is 100.
And that's why you have ones, tens hundreds, thousands, and so forth.
Computers are apparently using powers of 2.
Not surprising.
Binary-- two.
So if you only have ones, twos, and fours as your placeholders,
if a computer were storing these digits--
0, 0, 0-- that computer is presumably storing what number so far as we
humans understand it?
Well, that's how a computer would store zero.
If a computer is storing literally 0, 0, 0, just
like in our human world, that also is 0, but that's technically
because it's 4 times 0 plus 2 times 0 plus 1 times zero, which is obviously
Meanwhile, if a computer is actually storing not just,
say, 0, 0, 0, but instead is storing this value in binary,
what does that map to in decimal?
So that's one.
And now, why, if we change this 0 and 1 to this value here, is this two?
Well, mathematically, for the exact same reasons.
And so earlier, I had five fingers, but if you consider just my first three,
when I did this holding up one finger, I was representing two.
And if I want to represent three, recall that I put up the second finger.
And so the reason that could nicely represent three
is because all I was doing with my human hand was counting in binary.
And I could keep counting more and more and more.
And so if I have five fingers or five bits, bit meaning binary digits,
I could count up, it turns out, if we do the math,
as high as 31 by starting to zero.
It's going to be hard to physically do that, but we could.
So why is this useful?
At the end of the day, a computer, therefore,
can represent any number of values from 0 to 1 to 2 to 3 to some number much,
much, much higher than that.
All it needs is enough bits, enough zeros and ones.
Well, what are those bits?
Well, all of us have these days in our phones sources of light, for instance.
So I could actually say that this physical device right now--
might be a little hard to tell--
it does have a flashlight and it's technically off at the moment.
But if I turn this flashlight on, thereby using some of the electricity,
now, I'm storing a one.
And so the phone is on.
Now, it's off.
Now, it's on.
And if I see--
can I borrow someone's phone real quick?
May I?
And flashlight.
How do I turn on the flashlight?
Shake it.
That's OK.
Thank you.
Thank you.
So this is great.
Now, I can count higher.
Now, this represents the number what if I have two light bulbs or two switches
on at the moment?
Because I have a one, I have a one, and I
have two, which of course is going to end up equaling three.
And if I pick up a third phone somehow, I could count even higher.
Technically, if I had three light bulbs on--
one, one, one-- what would that value be?
Because it's a four plus a two plus a one, and so forth.
Thank you so much for the spontaneity.
So why does this not lead to limitations for us?
I can count in decimal as high as I want.
I can now count in binary as high as I want, so long as I have enough bits.
But how do I actually represent other information?
Well, if I want to represent something like a letter, how do I get there?
If computers only have electricity in them and they use binary to count,
and yet somehow they're much more useful than just doing math--
they can have text messages and e-mails and websites and videos and more--
how do we get from zeros and ones to letters?
Well, we-- yeah.
A little louder.
We just need to kind of relate the numbers to letters.
In other words, all the people in this room just need to decide at some point
that, you know what?
If we want to represent something like the capital letter A,
we just need to decide on a pattern of bits,
a pattern of fingers, that's going to represent A.
And it turns out humans years ago just unilaterally
decided 65 shall be the decimal number that represents capital letter A.
And you might guess capital B is represented by what decimal number?
And then C is 67 and so forth.
And there's a mapping of like 128 or even 256 possible values
for all the keys you might see on a typical keyboard
in order to represent letters.
Now, how does a computer distinguish, though, numbers from letters?
Well, just depends on the context.
If you're using like a calculator program on your Mac
or PC or iPhone or Android, well, the computer, the device,
is just going to know contextually, let me interpret this pattern of zeros
and ones as actual numbers to do math.
But if you're using the SMS app or the messages app on your phone,
you're going to actually be in the context of text,
and so your phone is going to interpret that same pattern of zeros and ones,
or light bulbs being off, or, at the end of the day, transistors,
tiny pieces of hardware and computers that are either on or off--
it's going to interpret those patterns as just representing a letter.
If you're in the context of a text messaging application or Microsoft Word
or Google Docs or the like, it completely depends on context.
The system we humans came up with just called ASCII, American Standard Code
for Information Interchange.
The name isn't interesting, but the fact that we all agreed years ago
that 65 is A and so forth is what's important.
And so for instance, if we look at this mapping here
of just the first few letters, what does this mean?
If I were to now get a text message and I had the ability somehow
to look underneath the hood, so to speak, at the pattern of zeros and ones
that someone had just texted me, and that pattern,
if I convert it to decimal, technically said, let's say, 72 and 73--
so I get a whole bunch of zeros and ones.
I do some math and I realize, OK, I just received 72 and 73,
but this is texting, and so it's not just numbers my friend is sending me.
It's a message.
What message did my friend likely send me if he or she sent 72 and then 73?
H-I. Because if you skim ahead at the right there,
that just happens to be in ASCII the mapping between 72 and 73, H and I.
If technically, the message had a third byte, if you will.
A byte, if you've ever wondered, is just eight bits.
It's convenient to talk not in terms of single bits,
where you can't count very high, but with a byte, or eight bits,
you can count higher.
And so it turns out if I received a third byte, another sequence of eight
zeros and ones together--
How would we know what this message now is?
So it turns out you would not know this other
than by guessing or Googling or just coming in with this knowledge.
This is now "HI!"
with an exclamation point because 33 just so happens, if you look it up,
to map to an exclamation point, as well.
Now, if we actually looked at the binary of this,
you would actually see this pattern of zeros and ones.
This is how you represent 72 in binary.
This is you represent 73.
And this is how you represent 33.
And notice I've only used one, two, three, four, five, six bits,
even though I technically tend to receive things in units of 8,
units of bytes.
But why did I not bother writing another 00 here and another 0 here?
Does it matter when you write these things out?
Not really.
Like in English, in our human world, if you were to write one, two, three,
that's 123.
If you were to write 0, 1, 2, 3, that's still 123.
So even though we tend to get them in clusters of 8,
we don't necessarily need to write those when just talking about them.
So what have we done?
Well, let me introduce a fancier word now known as abstraction.
Abstraction is just a term generally used in computer science and we'll soon
see in programming for taking some low level-- like literally low level--
implementation details, like minutiae even, and understanding them
at some point, but then deciding this is not a useful level conceptually
to think about problems.
I really don't want to solve problems in this world of thinking in 0's and 1's.
I'd much rather think about things minimally in decimal, or better yet,
in the context of letters if I'm actually receiving text, or even
some other representation.
So abstraction is about taking fairly low level details
and just simplifying them so that we can have a more useful conversation
and never again worry about where the electricity is coming from.
We can just stipulate my computer can represent zeros and ones.
Therefore, it can represent numbers.
Therefore, it can also represent ASCII or letters.
And we can kind of move on and start solving more interesting problems.
But it would seem that we can't solve all problems because on my keyboard
here, this American keyboard here, there's a whole bunch of symbols,
like a 100 or 200 maybe in total if we actually hit shift and option and all
of that.
But what you don't see are some pretty common characters.
Especially in a very international audience,
what can I apparently not even type on this keyboard?
What kinds of symbols?
Anything with an accent.
If you have accents over vowels or other letters.
What else?
I'm sorry.
Umlauts or other characters above letters.
Like pound symbol?
Like the UK pound symbol.
And other countries, too.
Any number of Asian languages.
There's so many symbols that are not depicted on this keyboard,
and yet somehow, all of us with international keyboards or phones
can surely express themselves.
But that's because phones and computers these days don't just use ASCII.
ASCII literally used just eight bits total.
Technically seven, but then, ultimately, really eight.
And with eight bits, if you actually do the math--
if you have eight bits or eight fingers, you
can only permute them in 256 total possible ways, which
is to say that you can only represent 256 characters using ASCII with numbers
underneath the hood, and that's not enough to represent
so many different symbols like those enumerated here.
You can't represent any of the accents that you can nonetheless
type on your Macs and PCs and you certainly
can't type these things, which are very much in vogue.
Which even though they're pictures, they're actually just characters.
Because it turns out some years ago, the world decided eight bits is not enough.
Let's start using something called Unicode, where you actually use
one or two or three or even four bytes.
So eight bits or 16 bits, 24 bits, or even 32 bits to represent characters.
And now, we have the ability to represent thousands or even
millions of characters.
And frankly, daresay, the result of that huge amount of availability
is partly why there are so many of these things these days.
And they just keep making more because there's just so many different numbers
available to us.
So Unicode is often a specific version of it called UTF-8,
which we'll see before long.
But let me ask this question here.
This is a crying face with joy, I think this is called.
So it turns out, according to Apple or iOS,
this is the most popular emoji that at least iPhone people
are sending to each other.
So when you're receiving this, though, if we can really take the fun out
of this, what pattern of bits are you actually receiving from your friend?
He or she is clearly trying to express some emotion,
but really, what your friend is sending you-- the decimal number 128,514.
Or really, if you looked at the zeros and ones coming
to you over the internet or airwaves, you're
getting this pattern of zeros and ones, which is hardly joyful or hardly
descriptive, but all your phone or computer
are doing is seeing this pattern of bits,
looking it up in like a little cheat sheet, and saying, oh.
Whenever I see this pattern of bits in the context of text like texting,
I should actually display it as that picture.
Now, that picture has a lot of yellow and other colors
in it, but how do we even get there?
Well, it turns out that this same pattern of numbers--
72, 73, 33-- which just to be sure, a moment ago, meant what?
In the context of a textual program like Microsoft Word, Google Docs, texting,
this means hi.
But what if you saw this same pattern of bytes--
and again, we could draw the zeros and ones,
but it's not interesting anymore, so we're going
to abstract away at the decimal level.
If you got this same pattern of zeros and ones
or numbers in the context of like Photoshop or a browser
or some kind of photo program, well, it might make more sense
to interpret it not as text, but as imagery, some kind of colors.
Well, it turns out there's this other system in the world--
you might have seen this acronym before--
called RGB-- red, green, blue.
And this is just a way of humans having standardized years
ago that you know what?
If we want to represent a dot on someone's screen, otherwise known
as a pixel a tiny little square on the screen
of your phone, your laptop, or even TV these days,
we're going to use three bytes--
one byte to specify how much red should be in that specific pixel,
one more byte to specify how much green should be combined with red to form
that pixel, and then one more byte, a third,
to represent how much blue to combine with those other two colors
to make a new color all together.
So it's kind of like combining paints, except in this case,
it's more really waves of light in order to get a specific color using just
red, green, and blue as your palette.
And so if we were to see this red, green, blue pattern and say,
you know what?
Give me 72 red, 73 of green, and 33 of blue.
If the total possible range that I alluded to earlier is like 0 to 256,
or technically 0 to 255 if you start counting in computer science from zero,
this is like a medium amount of red, medium amount of green,
and just a little bit of blue, if the range goes from 0 to 255.
So if you combine these three things together
and you want to know what color you get--
So it's kind of a light yellow that looks like this.
So if a computer is storing a single dot on the screen that
happens to be in yellow, what the computer's actually storing
is not this dot physically, but a pattern of three
bytes-- how much red, how much green, how much blue should the computer
display at this particular point.
So if we look at this crying face of joy and we kind of enhance or zoom in
on it here, you can actually see it start to pixelate, so to speak,
where you start to see the dots.
If I punch in a little more, now you can really
start to see the dots on the screen.
And if I go an even further, you can actually
see the tiny little squares that compose this image, most of which
at the zoom level are yellow, but a bunch of which are black,
a bunch of which are light black or dark yellow.
And that's what composes this image ultimately.
So this is to say if you count up all of the pixels on the screen
and then multiply it by one, two, three bytes, that's
how many bytes or kilobytes or megabytes, if you've heard those terms,
are going to be stored on your computer just to represent an image.
So we've gone from electricity to down here, so to speak, to zeros and ones,
to decimal, now to colors.
Well, with colors, you can get images.
What comes after images?
Well, we've all watched videos or movies certainly digitally these days.
Well, what is a movie or a video file?
How might that be implemented?
Say it a little louder.
It's a collection of images.
If you've ever heard of frames per second--
like movies tend to be 24 frames per second or 30 frames per second--
that just means that a typical movie, every second
is showing you 24 or 30 images per second
and they're just flying by so quickly that you actually
don't notice you're just watching a sequence of static images.
It's like as a kid, if you ever had one of those paper flip books where there's
tons of drawings in them, and as you flip through the pages,
you see things moving, but that's just because your eyes are just
seeing little snapshots ever so quickly of something moving on the paper.
That's all a video file actually is.
So if you have an iPhone and you've ever played with these animojis,
so to speak, well, all those are are little video files
composed of lots and lots and lots of images
that you have saved on your phone or texted to someone else.
And if we just think, now, we're at the point of video, but that's OK.
Videos are just bunches of images.
Images are just bunches of colors.
Colors are just patterns of bits.
And bits, at the end of the day, are just
the result of electricity coming into my machine or transistors
turning switches on and off.
Like we've all of a sudden to hold this entire story, but none of us
ever is going to need to really think about binary in the context of videos
because a video is just an abstraction on top of bunches of images,
and images are just an abstraction on top bunches of pixels, and so forth.
So we can keep painting this hierarchy that
just allows us to talk about things at a more useful level,
and the reason we had this conversation is
just because we needed a way to represent
inputs and outputs to problems.
Let me pause there for just a second to see if there's any questions.
Anything at all?
All right.
So what's inside this black box?
Well, it turns out this is where the really interesting work starts
to happen and the thought starts to come in.
This is the proverbial algorithms, step by step instructions
for solving some problem.
And some of you might have solved this problem before,
either digitally or textually, but of course,
if you have contacts in your phone these days
and you've got bunches of friends and family,
odds are they're alphabetized by first name or last name.
And you have auto complete these days, but it really is just
a long list of names and numbers.
That's not all that different from yesteryear's implementation
of the same problem, which was this device here, a phonebook.
Now, this phonebook might have a friend of ours in it, say Mike Smith,
whose last name starts with S. And I could, of course,
if trying to find Mike Smith, start by looking
at the first page, the second page, the third page, the fourth page,
and eventually, just hopefully find Mike Smith.
Indeed, is this algorithm, this step by step process,
correct for finding someone like Mike Smith?
It's correct.
It's stupid and slow perhaps because it's
going to take forever in a phone book of this size,
but it is correct because if Mike's in here, I will, in fact, find him.
But I could do this better.
I could do it sort of two at a time.
So two, four, six, eight, 10-- or imperfectly--
10, 12, 14.
Is that faster?
Obviously, it's going twice as fast.
Is it correct?
Why is it not correct?
I might miss him, right?
Mike just accidentally might eventually get sandwiched between two pages
and I have the unlucky experience of just missing him.
Now, is it fixable?
I can probably, once I hit like SN or the T section, for instance--
I can just say, obviously, I've gone too far for Mike.
Let me just double back one or just a few pages.
So it is fixable.
And so long as I've saved time by flying through this twice as fast,
can I at least afford to spend a few more steps at the very end just
to find Mike Smith?
But none of us are going to do that.
And our Apple devices and Android devices certainly
don't do that for efficiency today.
Odds are most of us are going to do what to find someone in any book like this?
Open to roughly the middle or maybe bias ourselves toward the end
because S is after the middle.
But you know, I'm in the middle of the phonebook here.
And now, if I know that Mike is in the S's and therefore over here,
where do I know he's not?
He's not in the beginning and I can literally
tear a problem like this in half, throw figuratively and literally half
of the problem away, and be left with fundamentally the same problem,
but it's half as big.
I went from like-- whatever--
1,000 pages to 500 pages and I can now repeat this algorithm.
I look down.
I'm a little too far.
I'm in the T section now.
I can again tear the problem in half, throw that half away,
taking a 500 page byte out, a 250 page byte out, now leaving myself
with just 250 pages more.
And notice just how quickly I got here.
The first two algorithms got me from 1,000 to 999 to 998, or 1,000 to 998
to 996.
But here, I went from 1,000 to 500 to 250.
Feels like we're making up time here.
And indeed, if I keep repeating this process,
hopefully, I'll be left with just one page of the book
that Mike is either on or not, at which point, I will call him.
And so that's an algorithm that honestly leverages probably all the intuition we
have and a lot of what programming is going to be,
is thinking about a problem like this, figuring out how to divide and conquer
it, and then expressing yourself in a way
that the computer can then solve that problem for you.
And just to paint a picture of how much better this algorithm is, well,
if this is just a very abstract chart where we have on the vertical,
or y-axis, how much time it takes to solve a problem,
and on the horizontal axis how big the problem is--
so the farther out you go this way, the more pages in the problem,
the more pages in the phonebook.
And the higher you go up here, the more seconds or page
turns it's going to take.
That first algorithm is just like a linear slope,
so to speak, because for every additional page in the book,
it might take me one more second.
Right, up.
Right, up.
It's just a one for one relationship with pages.
The second algorithm, if I plot it, where
I'm flying through twice as fast, what is
that line going to look like instead?
It's going to look lower than this one.
It's still going to be a straight line because now, there's a two to one
relationship, but if you've got a phone book that's got this many pages,
and in the first algorithm, it took this long, here,
well, in the second algorithm, it will take half as many steps, plus or minus
or two if you need to actually double back a little bit.
But that third algorithm is what we'll call logarithmic.
If n is the number of pages in the phone book,
the first algorithm, in the very worst case,
might take all n pages to find Mike Smith.
The second algorithm is going to take half as many steps because I'm
flying through it two at a time.
But the third algorithm is going to look and feel like this.
It's going to be curved and ever so slowly rising and rising and rising,
the implication of which is if Verizon or the phone company
doubles the number of pages in the phonebook
next year because Cambridge and Somerville merged together in the phone
book and we now have 2,000 pages.
Well, how many more steps does my third algorithm take?
Just one.
Because I can take a 1,000 page bite out of the problem
with that clever algorithm, whereas my first two algorithms would take it
one or just two pages at a time.
So that is to say we have to hugely increase the size of this problem
just for the number of seconds or page turns to appreciably actually increase.
And so as we start to learn about programming,
it's, again, going to be leveraging of this intuition in order
to actually solve problems and code more effectively than we
might without that intuition alone.
So let's formalize this now.
So that was kind of a very intuitive way of dividing and conquering a problem.
Just kind of made sense to go in the middle,
tear it, then go to the other half or the other half
and tear it again, and so forth.
But a computer, even as cool as Alexa and Google Home and all of this are,
you can't really just talk to them as another human
and have them execute things correctly.
I struggle just to get Siri to set a timer on my phone.
So we're not quite there yet, so we're still at the age
where we have to be ever so precise with computers,
voice activated or otherwise, and so thus enter pseudocode for now.
Pseudocode has no formal definition.
This is just a way of saying use English like syntax or any spoken language
and just express yourself succinctly and correctly
so that a computer or a robot or even another person
can understand what it is you're trying to say.
So here, I propose, is an algorithm written
in pseudocode, English like syntax, that just gets my point across.
And I could write this in any number of ways.
I've numbered the steps from zero on up, just for the sake of discussion,
but this would seem to capture what I did there.
Pick up the phone book.
Open to the middle of the phone.
Look at the names.
If Smith is among the names, call Mike.
Else, if Mike Smith is earlier in the book,
go to the left, specifically the middle of the left half of the book,
and then go back to step two.
Because indeed, I was just doing the same thing again and again,
and the reason I wasn't doing it forever was because every time I
repeated myself by opening and tearing, I was shrinking the problem.
And I can only shrink a problem of some fixed finite size
so many times until I get just one page, and so
if I continue this logic looking to the right or to the left or just quitting,
if I don't find Mike at all on the last page,
this would seem to capture more precisely that code.
Well, let's actually excerpt from this now a few concepts
and then start to apply them to actual code.
Highlighted in yellow here, I dare say, are all of the verbs or actions.
These are the functions, as we're going to start calling them,
in this algorithm.
A function is just a specific step, a specific action
you take in order to do something.
And so in yellow here-- pick up, open to, look at, call, open, quit
are all actions or verbs.
Are henceforth, we'll call them functions.
Meanwhile, highlighted in yellow here-- if, else if, else if, else.
These are kind of starting to ask questions.
What might these be called if you have some familiarity?
Turns out many programming languages, if you've seen any before,
would call these conditions.
They're branches, or proverbial forks in the road.
If this is true, go this way.
Else, maybe go this other way, or perhaps a third or fourth direction
Meanwhile, if we actually look at these highlighted phrases--
if Smith is among names or if Smith is earlier in book
or Smith is later in book--
these are the specific questions we're asking in order to make that decision.
These are known as Boolean expressions, named after a gentleman
by the last name of Boole some years ago.
And so a Boolean expression is just a question
that has a yes or no answer, a true false answer, a one zero
answer, if you will.
And that's a nice mapping to what computers are really good at.
So within conditions, you have Boolean expressions
to decide which fork in the road you want to go down.
And then lastly, highlighted in yellow here
is go back to step 2 in a couple of places.
This is inducing some kind of cycle or loop
that's telling the computer to do something again and again and again.
So in short, we have these building blocks already conceptually.
And it turns out, we can now start to translate these
to an actual programming language.
The first of the languages we'll introduce in CS50
is something called Scratch.
Turns out this is not a text based language,
like in my English pseudocode there, but it's graphical
and things look like puzzle pieces that you can drag and drop
and they interconnect if it makes logical sense to do so.
And in fact, some of you might have played this back in the day as kids
or even more recently because it's actually targeted typically
at students in like after school programs who
just want to learn more methodical, more algorithmic, or computational thinking.
And we're going to use it to explore not only these building
blocks, but a few others, as well.
It turns out in the other languages we'll explore in CS50 and beyond,
are languages like C that we'll actually transition to as quickly as next week,
to then translate what we do this week in Scratch to next week in C.
And in languages like Python and JavaScript
and SQL, which we'll also explore, do we have other capabilities--
the ability to store data in variables, so to speak,
to use threads, which means get the computer to do multiple things at once,
events, to mean listen for things happening, like a click
on the page or a human typing or even saying something.
We'll be able to do all of the things that you take
for granted in your very own phones.
And we'll do this first by way of this guy.
So this is Scratch, the default cat that comes with this programming
language from MIT's media lab.
And via Scratch can we start programming him to move up,
down, left, right, say something, utter something, and other commands
all together.
In fact, let me go ahead and switch contexts here
to show you the very first thing I ever wrote in Scratch.
It was back in the day when I was in graduate school
and Scratch had just been invented by MIT.
Let me go ahead and open this.
And I called it Oscar Time.
And if we could perhaps have a volunteer come on up for just a moment.
You have to be comfortable being on stage and on the internet.
How about here in the white shirt?
I saw your hand first.
Come on down.
So this is Oscar Time.
It's implemented in a language called Scratch.
And at the end of the day, all that is underneath the hood of this program
is functions and loops and conditions and a few other of these concepts.
What's your name?
AVIVA: Aviva.
Nice to meet you.
Come on over here.
And in just a moment, I'm going to go ahead and click
the green flag at the top left hand corner, which
is going to play this game.
And we'll see on the screen the instructions.
OSCAR: (SINGING) Oh, I love trash.
Anything dirty or dingy or dusty.
Anything ragged or rotten or rusty.
Yes, I love trash.
If you really want to see something trashy, look at this.
I have here a sneaker that's tattered and worn.
It's all full of holes and the laces are torn.
A gift from my mother the day I was born.
I love it because it's trash.
Oh, I love trash.
Anything dirty or dingy or dusty.
Anything ragged or rotten or rusty.
Yes, I love trash.
Here's some more rotten stuff.
I have here some newspaper 13 months old.
DAVID MALAN: All right.
Everybody, give a round of applause for Aviva for coming on up.
Thank you.
A little CS50 stress ball.
So suffice it to say, if you're tired of this song,
consider how tired I was eight hours later while debugging and building
this program.
But consider what it is we just saw.
It's this interactive game and stuff is animated and music is playing.
But if you focus on decomposing, so to speak, this program into just
basic building blocks, this is just kind of a big abstraction over some lower
level pieces of functionality.
Like this trash can here.
At the moment, it's just a picture, and on occasion,
as soon as Aviva dropped something into the trash, the lid came up
and Oscar came out, he said something, and then he went back down.
But that animation is super simplistic.
It was just a sequence of 1, 2, 3, or so images displaying and then
going back down to create the illusion of animation.
Meanwhile, every time Oscar said something,
that was keeping track of her score in what's called a variable.
In algebra, you have x and y and z, but in programming, you have the same idea,
but it's generally more useful to call them more descriptively,
like your score.
And so there's probably a variable in this game called
score that was just keeping track of how many times
Aviva had dropped something into the trash.
Meanwhile, the trash itself and the shoe and the newspaper-- and even more
things happen eventually-- were falling from the sky
at sort of random locations, and that's because I programmed the game
to sort of start the trash here or over here, just
to make it a little more challenging as the game picked up.
And in fact, things start falling faster and faster over time,
like a typical game, getting more and more difficult.
So how do we get to something like that?
Well, let me go ahead and open up Scratch itself
and introduce the environment.
So in Scratch, you essentially have three general areas.
And it's web based, and so you can do this on any computer.
And in the left hand side here, you have those puzzle pieces
to which I referred earlier.
These puzzle pieces are all mapping to functions or loops or conditions
or variables, things that we saw before, and I'm
going to able to drag and drop them into the middle in order
to interconnect them and write my program,
which we'll do in just a moment.
Meanwhile, Scratch lives in this stage, this world, where he can move up,
down, left, right.
You can change what Scratch looks like.
You can add other characters, otherwise known as sprites,
in order to have multiple things happening at once.
And of course, you can fullscreen it.
And so the Oscar Time game a moment ago was actually a whole bunch of sprites.
Oscar's trash can was one.
Each piece of trash was another sprite.
The newspaper was a sprite, and so forth.
So each of them were separate programs running in parallel at the same time.
So let's actually make him do something.
It turns out that if I jump down to, say, events,
I'm going to see one of the most powerful blocks
from the get go, which is this when green flag clicked.
That's indeed how I started the game with Aviva,
by clicking just above Scratch's world this green flag.
And if I wanted to stop it, as I did, you
can click the red stop sign to say stop.
Meanwhile, the green flag, I can constantly
listen for by dragging and dropping this puzzle piece.
When the green flag is clicked, what do I want to do?
Well, let me go up to looks.
And these are just different categories.
And we can scroll through all the different colorful blocks,
but they pretty much just do what they say.
I'm going to go under looks, where I know there to be a block that's called
say, and I'm going to go ahead and type the most canonical computer science
thing-- hello world--
in this box.
So notice that functions themselves can actually
take inputs and the input to this function, say,
is going to be hello world.
If I now go over to the green flag and click it--
hello world.
All right.
So not all that difficult. Not all that interesting.
But it actually got the job done, and so my program is indeed just this.
Well, how might I make this a little more interesting?
Just saying, hello world all the time isn't all that compelling.
Well, you know what?
Let me think.
Let me undo this.
Let me scroll down to sensing.
And notice this.
Functions can also take input from a human
and functions can hand you back a value, a so-called return value.
So this block here, ask something-- by default, it says,
what's your name and weight--
is another function built into Scratch that allows me to do this.
So I'm going to go ahead and drag this here
and I'm going to let it say, what's your name?
Notice now that below this block is a special block,
whatever it is the block returns.
So answer is whatever the human is going to type in.
And if I want to now say what the human typed in, let me go again to looks.
Go to say.
And notice that these blocks are kind of magnetic.
They want to snap together.
So I'm going to go ahead and let go there.
And if I go back to sensing and grab answer,
notice that even though it's not quite the same size,
it's going to grow to fill, and now, I can
have my program ask the user what his or her name is and then
say whatever that answer is.
So let me go ahead and stop and click play again.
Notice it's asking me for my name, so let me go ahead and type in David.
It's a little weird way to greet someone.
So it'd be nice to clean that up a bit.
So you know what?
I know this only from having poked around before.
Not all of this is obvious at first glance.
But it turns out that under operators, the category,
there's this thing here-- join apple and banana.
Which are just default values.
You can change them.
Because what do I want to do?
I want to say hello, David, or whoever, so I kind of want to say hello, comma,
and then, David-- whatever the human typed in.
And that's what join lets you do.
It lets you join or concatenate two phrases that are somehow
provided by you or the user.
So let me pull this out, the answer.
Let me go ahead and grab the join block.
Notice it, too, is going to grow to fill.
Let me go ahead and say, hello, comma, space, and now, drag answer into there.
And notice this nesting.
Just like in math.
This nesting of functions.
I can first join hello and answer by taking those two things as input
and then pass them to say as another input
because these things are layered on top.
And so now, if I stop this and play it again and say, David--
hello, David.
Now, we have the makings of a more interesting interactive program
that isn't just hardcoded.
Of course, it's not nearly as audible as something like Oscar Time a moment ago.
So let me go ahead and do this.
Let me start over altogether and treat Scratch like the cat he is
and just start the sound called meow.
So it turns out there's a category of blocks called sound,
and within sound, there is play some default sounds.
So start sound meow.
And now, things will get a little cuter.
And now, again.
And I can kind of simulate a cat by [MEOW] standing here for a while
and keeping to click this button.
But you know what?
Let me make him meow few times because that's more realistic.
So let me grab a second one and a third one.
And you can get this infinite supply of blocks.
Let me hit play.
Seems like a bug.
Let's try again.
This is my first bug, or mistake.
This looks correct.
It says when green flag clicked, start sound meow, start sound meow,
start sound meow.
Why am I only hearing one meow?
They're kind of at the same time or so close to the same time
that the sounds are kind of tripping over each other and just overlapping,
The block literally says, start sound meow.
But computers are really fast.
If you've heard of the expression gigahertz, that's a unit of measure.
And if your computer has a one gigahertz CPU, central processing unit, or brain,
that means it can literally do like a billion things per second.
It can certainly start three sounds super fast.
And if they're effectively all happening one after the other
before the sound even finishes, you're just hearing one net effect.
So how can we fix this?
Well, I can actually go and fix this with this block here--
play sound meow until done.
Play sound meow until done.
Play sound meow until done.
And now.
It's a little unhappy, this particular cat,
but at least it's now more correct.
And, as it turns out, if I go to control--
you know what?
There's this block here-- wait some number of seconds.
I can go ahead and insert this here.
Let me do another one here.
And now, hit play.
You know, it's not bad.
It now sounds a little more realistic.
But honestly, if I keep doing this-- or you know what?
You can actually right click or control click on blocks,
duplicate them, and just copy and paste even more if you want them.
So if I were to do this, now, it's just going to go six times.
And then I could copy it again and go 12 times.
But there's got to be a better way, right?
This is now bad programming.
This is bad design.
Because I'm literally copying and pasting, albeit, graphically.
But we've already seen a building block with which
we can design this program better.
It's correct, but it's not well designed.
What would the building block be that I need to make this a little cleaner?
A four loop.
Doesn't quite exist in Scratch.
But a loop fundamentally does something cyclically.
And indeed, if I go under control and start poking around,
you'll notice that there's a few blocks that might apply here.
There's the repeat block some number of times
or the forever block, both of which sound like loops, or cycles.
So sure enough, let me go ahead here and I can throw away blocks
by just dragging them to the left.
Let me pull this out for a second.
And then just say forever play this sound, and then wait one second.
So now, my program looks like this.
You know, we'll never know if it's technically correct because it's just
going to go, we think, forever, but it looks like this is correct.
And it was a lot less code and it's a lot easier
to maintain because if I want him to kind of get sleepy,
I can then maybe say two seconds instead.
You know, and we can adjust this on the fly as we go.
But let's start to combine some of these ideas
now and change what it is the ultimate effect is.
Let me go ahead and open an example I made in advance.
This one's called Count Zero.
And we'll put this on the website later so that you can play with if you like.
And this is kind of the opposite of counting sheep.
Rather than me or the person sleeping counting sheep,
this sheep will count itself.
So let me go ahead and just play.
And adorably, he seems to just be counting 1, 2, 3.
But why is that?
He's just going to count forever.
But let's look at the blocks with which he is counting forever.
When green flag clicked, set counter.
Turns out this orange box is what we called a variable.
So in algebra, it would be like x or y or z.
Those are not descriptive.
I called this one counter instead, but I could have called it x or y or z.
And then I forever say the counter for one second, then wait one second,
and then change the counter by one, which
technically means just increment it.
Add 1 to it.
And the sheep is just going to therefore count up and up and up.
Now, this is a little tedious, but that's
kind of the point of counting sheep, of course, to fall asleep.
But what if the sheep actually kind of liked counting a little faster?
Well, let me go under operators here.
Multiplication sounds like it could get us places quicker.
And let me go ahead and go to variables.
And instead of changing the counter by one,
let me go ahead and just keep setting it to something else.
So let me drag and drop this.
Set the counter equal to something times something, specifically
the counter times two, thereby doubling, doubling, doubling, doubling.
That would seem to grow, so to speak, a lot faster.
Let's see.
1, 2, 4.
So he's counting faster, but it's still kind of tedious.
What if we instead do this?
Let's stop waiting and let's go ahead and, with the looks,
not say counter for one second, but let's just quickly say counter.
So I'm going to say the counter.
I'm going to say the counter and then I'm going to set it to itself times 2.
So here's where we're at.
Initialize, or set the counter to 1 initially, say it, then double it,
then double it, then double it, saying it along the way.
So here we go.
That's impressive.
So now the sheep has counted up to 10 to the 60th so far.
10 to the 100th.
Now, it doesn't even fit in the speech bubble, but he's still going.
How high can he go?
What's the biggest number you can count to in a computer?
Anyone want to guess?
Could be here a while.
10 to the 270th now.
How high can you count, or rather--
So we gave up and just called it infinity.
So it turns out infinity does have a precise value--
10 to the 250th or so.
But what happens here?
Well, because computers, at the end of the day,
are just storing information digitally-- but that information digitally has
to be physically stored using electricity, using these lower level
switches called transistors.
At the end of the day, my phone, my laptop, whatever device in question
only has a finite amount of those things.
I only have a finite number of fingers.
Using unary, my old school hashmark approach,
I can count to five on this hand.
Using binary, I claimed I could count to 31 on this hand.
But it's still finite.
I cannot count to infinity on this hand because I only have five fingers.
Similarly does a computer only have so many transistors or so
many bytes or bits of memory, and at some point,
the programmer has to think about what is he
or she going to do when the user wants to count so high that you
can't physically fit it anymore.
You have to give up like this and say something semi accurately
or you have to handle that issue in some other way.
And we'll see when we get to C that how you handle this problem is not
necessarily straightforward, and indeed a lot of software
out there does not handle this problem.
And odds are, all of us have programs that if you
type big enough words or big enough numbers into them,
they might very well break or crash or freeze
because the humans, unlike MIT, did not anticipate that that might actually
happen and handle it.
Well, let me go ahead and do this.
Let me open up this program and see if we can't read the code now.
This is called Pet Zero and this is a program that simulates petting.
So if I click play and don't touch the keyboard,
nothing seems to be happening, but if I now move my cursor over to the cat--
It's kind of cute.
Right now, it's more only meowing on demand when you pet the cat.
Well, notice I've added some other building blocks.
We haven't used this one before, but it intuitively
probably makes pretty clear sense.
When the green flag is clicked, forever do the following.
If the cat is touching the mouse pointer-- this thing in blue
is what we called earlier a Boolean expression.
It has a yes/no, a true/false, a one/zero answer.
And touching mouse pointer is one of the options in the little drop
down here if you tinker with it.
So if the cat is touching the mouse pointer, then and only then,
play sound meow until done.
So we've combined now functions with loops with a condition.
But why the loop?
The cat's only meowing once when I pet him.
Why am I doing anything forever here?
Someone-- yeah.
I might want to pet it again, so I want the program to anticipate that.
And honestly, if I omitted this forever block and my program
instead looked just like this--
so let me get rid of that and this--
and then I clicked play, and now, I hover over him,
why is it not working even once?
Say it again.
So I mean, at this point, if I can summarize,
the computer is so damn fast that this already
happened by the time I moved my cursor over to the cat, and at the moment
I clicked play, I was not touching the cat.
Those blocks executed, so to speak, top to bottom.
That's it for the program.
So by the time I move the cursor over to the cat, the program is over.
It's not listening.
And so forever, this way I can actually listen in perpetuity for something
to actually happen.
What if I want to do something not just if something is true,
but handle two cases?
If or else.
Well, let me go ahead and open up Pet One.
And this is another example.
And could someone perhaps describe, after reading this code, what
this program is going to do instead?
And let me summarize more verbally.
So if this time, you're touching the cat, it's going to roar instead.
Else, it's just going to meow sweetly.
So this time, it is meowing perpetually once every second,
but if you touch this particular cat, it doesn't like it.
So play.
And now.
Don't touch the cat.
So now, we might interact in two different ways
by having two different roads that you can go down.
Well, let's actually make something a little more interactive.
Let me go ahead and open another example.
This one's called Bounce Zero because now, we
can start to see some design elements from what Oscar Time was.
Like this now it's getting a little interesting.
What is actually going on here?
So let me zoom in on the blocks here.
This block is just saying forever move 10 steps, which
is another block we haven't seen.
But 10 steps is like 10 pixels.
So move 10 pixels on the screen.
But if you're touching the edge, then turn around 180 degrees.
And you can see exactly that happening.
Scratch is turning around 180 degrees and this rotation style just
means double back.
Don't like loop around 180 degrees.
So that's kind of cool.
But this is not how humans or cats walk.
Like what is obviously unnatural about this?
I mean, I mean, I can't even simulate it, right?
Like his feet are in static position, yet sliding back and forth
on the screen.
And yet, that is not what walking is.
Like walking presumably has some kind of movement and what?
Well, we could just kind of simulate it like--
OK, I could just walk--
walking and you can imagine taking like really quick photographs of my legs
or the cat's leg moving and then just deciding this photo
will be representative of one step.
This photo will be representative another.
And you know, with just two of those steps,
I'd wager we could actually do a pretty good job of simulating
what walking looks like.
In fact, if I go back to where we began, this picture of Scratch,
what if I just move his legs ever so slightly, then go back,
then go forward?
And even just in my PDF, I can simulate animation by hitting up arrow,
down arrow, up arrow, down arrow because it kind of
looks like he's walking now, when really, your human eyes are just seeing
two different pictures again and again.
So how can I do this?
Well, if I go back to Scratch, he's still walking.
Let me go ahead and open up Bounce One, the second version of this, and now,
do this.
So how did I add this?
There's a little purple block that we haven't seen yet,
but if you poke around the categories, you'll
see other blocks like this next costume that just keeps
changing the costume that he's wearing.
It turns out Scratch exists as a picture and his default picture
is him not moving, but if I go up here to top left and click costumes,
you can actually see that here's his one costume.
Here's his second costume.
And so that purple block that says next costume, because it's
in the forever loop, it just keeps doing next, next, next, next, next, just
showing one costume or the other.
They're clearly mimicking walking.
Now, this is not very unnatural.
Why don't we slow him down to, say, five steps at a time and have him go again?
Now, this is still going pretty fast.
Let me go ahead and say--
we could have control.
We could have him wait a second after moving very dramatically.
We could probably speed this up.
So let's wait 1/10 of a second, 0.1.
Or maybe let's do 0.01, 1/100 of a second.
Now, it's getting a little more realistic.
But this is what animation is.
If you've ever watched a cartoon or a movie based on pictures like this,
you're just tinkering with some of these parameters, these inputs,
in order to produce this output by understanding
what the fundamental representation of these things is, which in this case
are just pictures, again and again and again in order
to create that animation.
But what about interactivity?
Let me do this one myself.
Let me go ahead and get rid of this, go back to events, and say,
when green flag clicked.
Then, let me go ahead and grab a forever block
so that this keeps going again and again.
And then, let me go ahead to go to motion.
It turns out that under motion, there's this block we haven't seen--
point towards the mouse pointer.
And let me go ahead and pull this in here.
And then, let me have it move just like one step at a time, instead of 10.
What is this going to do?
What's this program do?
Say it again.
Follow the mouse.
This is kind of like a way of taking your cat for a walk.
Perhaps not quite the animal we intended, but he'll follow the cursor.
And I can actually speed this up a little bit.
So let's have him move 10 steps.
Now, there we go.
So now, he's moving up and down, and so now, it's interactive.
So you might recall that when we were playing Oscar Time earlier and picking
Don't do that.
See, that's a bug.
He's just confused.
He's constantly moving toward it, but you're already--
So we're going to stop.
So now, he's following, but that's how we might now create,
for instance, the ability to move those pieces of trash
around and have them follow the mouse cursor.
If you think back to Oscar Time, every time you picked up a piece of trash,
he'd follow the cursor because there was a forever loop and a block like this
pointing toward the mouse pointer.
Well, now, let's integrate multiple ideas
and actually have multiple scripts.
I proposed earlier that programs can actually have multiple threads.
A thread is just a fancy way of saying, in our context, multiple scripts.
Multiple scripts in one program that are happening essentially in parallel.
A computer can effectively do multiple things at a time thanks to threading,
and more on that down the road.
So these are more involved, but let's see
if we can-- let's understand first what this program does.
Let me go ahead and hit play.
And this one tends to be a little loud.
So the sea lion is just barking endlessly, annoyingly.
So by reading the code, how can I stop him from barking?
Hit the spacebar.
All right.
So hit the spacebar.
I could just stop the program, obviously,
but this program is still running, technically.
But why did that work?
Well, notice this on the left hand side is the first script.
When the green flag is clicked, set this variable that I called muted to false.
Could have called it x or y or z or counter, but none of those
really make sense, so I called it muted.
And I set it equal to false, which is, again, a Boolean value.
True or false just mean yes or no.
Forever, if the keyspace is pressed, then do this.
If muted is currently false, then change muted to true.
Else, change muted to false.
So if muted is false, change it to true.
If muted is true, change it to false.
Any time the human hits the spacebar, update that variable.
Now, if we look at the other script, which is also driving the sea lion,
what is he doing?
Forever, if muted is false.
So if he's not muted.
If muted is false means not muted.
Start the sound sea lion and then think hi, hi, hi for two seconds,
and then wait for one more second.
And then just repeat, repeat, repeat.
But if I change with the spacebar muted to true,
he's going to say if muted equals false, that's not so.
I'm not going to play a sound this time.
And so now, we have the ability to integrate multiple scripts together
in order to achieve a more interactive result.
And what about this?
Back when I was a kid, might have played in the summers Marco Polo.
Super simple game.
We played it in the pool, for some reason, where
one person in the pool very safely is blindfolded,
and then he or she yells Marco.
And then, everyone around him or her is supposed to yell polo.
And then, the person who's blindfolded is
supposed to go chase the other kids in the pool and tag them,
and then they become it.
But in other words, it's this like signaling mechanism.
Someone yells, Marco and everyone else responds
to that broadcast of the word Marco.
Well, it turns out we can simulate this with these two puppets.
This guy here-- notice that I've highlighted the orange puppet
because there's a second blue puppet there.
Separate sprites.
And these are just photographs we uploaded to the game.
Forever, if the key space is pressed, so if the spacebar is pressed,
say Marco for two seconds and then broadcast an event.
Meanwhile, the blue puppet here has a super simple block,
but it's fundamentally different from the ones we've seen.
He's not starting when the green flag is clicked.
He is starting only when he receives an event.
So it turns out that sprites and Scratch can't hear or see
what the other one is saying in those speech bubbles.
You have to use a fancier technique, which
is the special block called broadcast, which
is like passing a note digitally from one sprite to another
that the other one can read or receive, so to speak.
So only when he receives this event, so to speak,
does he say polo for two seconds.
And again, the orange puppet sends that secret message
just using this other puzzle piece.
Broadcast an event, like passing a note that the human doesn't actually see.
So if I now hit the green flag and hit the spacebar, orange yells Marco.
Blue guy yells polo in response.
But those aren't timed together.
Rather, the blue guy is hearing with the orange one has said,
thereby allowing multiple sprites to actually intercommunicate.
So how did we get here?
Well, recall that we had all of these building blocks a moment ago.
First, we started out with just functions and conditions
and Boolean expressions and loops.
We've now added to that the ability to store information
in variables and threads to do multiple things at once, and then, if you do
have multiple things happening, events, where
they can enter communicate somehow.
Yet another building block.
So if we now take a step back and consider
how we can make functions of our own, we have the final piece
of the puzzle, so to speak.
Let me go ahead and do this.
Let me go ahead and create a simple program with, when green flag clipped,
that simply simulates coughing for a cat.
So this cat is going to say not hello, but cough for one second.
And then he's going to go ahead and wait for one second.
And then I'm going to go ahead and copy paste, as I did before--
this is one of those do as I say, not as I do-- to implement this program here,
where he coughs three times.
We already know, though, from earlier that this is not good design.
You're repeating yourself.
Don't repeat yourself.
DRY is an acronym, actually.
Don't repeat yourself because you're doing
three times as many times something that you only really need to do once.
The solution before, of course, was just use a loop of some sort.
So let me actually take that out.
Let me use a repeat block, change 10 to three,
and then just use two of these blocks.
And notice already, the program is so much more compact.
And now, if I want to change the three to a 30 or to a 10 or any number,
I just change one simple value.
I don't have to rewrite or copy paste or delete things.
I can update the program much more readily,
and now, the same thing is going to happen with just cough, cough, cough.
But it turns out that it would be nice to henceforth abstract away from this,
I just want any program I write to know how to cough.
And coughing is really just saying something, perhaps
some number of times.
But it turns out we can abstract this away in code.
Let me go down to my blocks here and this allows
me to click this button-- make a block.
It allows me to make my own function.
I get this dialog window here.
And I'm just going to call this block cough.
I'm going to go ahead and click OK.
And now, I have this new pink block that itself can have blocks underneath it.
And you know what I'm going to do?
I'm going to go ahead and do this.
I'm going to go ahead and say cough under there.
And now, notice on the left, I now have access to this new pink piece.
I can now put this in here.
So now, notice even though, yes, this is how coughing is implemented
on the left hand side here, next time, when I write a program,
I just want to call cough.
And I don't care about those lower level implementation details.
I don't care about the party or any of that.
I just want this to be an abstraction.
But I could do better than this wouldn't it
be nice if instead of just repeating cough three times,
what if I made that a feature of cough?
So let me do this.
I can go ahead and right click on this pink piece and I can edit it.
That brings up that same window from before.
And notice this.
Add an input.
So when I make a custom block, I can actually make pretty fancy blocks
just like the ones MIT gives us with the software,
and now, I can type in something like n.
And if I add a label just to make it more descriptive, I can just say times.
So now, I've made a special custom puzzle
piece that says cough some number of times, where n for number
is just the go to variable that programmers tend to use.
So now, I can actually move this repeat block into cough itself,
but rather than hard code 3, notice this.
I can steal that variable and now say cough this many times by repeating
saying this again and again and again.
And now, when I cough in my actual program, I just type in three here.
So I have this beautiful abstraction now, so to speak.
Cough this many times and I and no one else in the world
never again needs to care about what it means to cough because we've already
implemented that before.
And so just as MIT has given us so much functionality
that we ourselves don't have to think about, so can
I now make functionality that I don't have to think about.
And as we progress to higher level languages like C and JavaScript
and Python, we're going to continue this process, sometimes
solving problems ourselves by making our own custom puzzle pieces,
but very often using things called libraries,
code that other humans wrote before us that's just useful to get the job done,
just as Scratch has done here in part for us.
Let me go ahead, then, and bring all of this
together by opening this other example here.
Let me go ahead and open up this one, which isn't something we've seen,
but it's kind of an interactive game like this made by a former student.
Should we have an apple?
A little animation.
That didn't end well.
Let's try again.
Play again.
And notice the say block is happening.
There's some kind of ask block.
The student was checking if the human typed in yes or no.
Let's type no this time.
No apple.
Don't do that.
One more life.
Here we go.
No apple.
No cupcake.
Little variable.
So I won the game.
In our final moments here, let me go ahead and open one final example.
As you know, CS50 is offered not only at Harvard, but at Yale, as well,
so it seems fitting to perhaps end on a note that
pits one campus perhaps against the other by way of another game
that a former student wrote called Ivy's Hardest Game.
But for this, I think we need one final volunteer who's company coming up.
First hand.
Right there.
Come on down.
So in Ivy's Hardest Game, it's a game played with the keyboard.
And even though it might look a little overwhelming at first glance,
just like Oscar Time did and just like the gingerbread animation might,
realize that if you decompose it in just your mind's eye thinking about what
those individual building blocks are, you can probably
guess what the puzzle pieces are.
What's your name?
I'm Andrea.
Nice to meet you.
Here is Ivy's Hardest Game.
Pits you against all of the Ivies here.
And then right after this will we adjourn for cupcakes in the transept.
MC HAMMER: (SINGING) You can't touch this.
You can't touch this.
You can't touch this.
MC HAMMER: (SINGING) You can't touch this.
My, my, my, my.
Music hits you so hard.
Makes me say, oh my lord.
Thank you for blessing me with a mind to rhyme and two hype feet.
It feels good when you know you're down.
A super dope homeboy from the Oaktown.
And I'm known as such.
And this is the beat you can't touch.
I told you, homeboy, you can't touch this.
That's how we're living and you know you can't touch this.
Look in my eyes.
Man, you can't touch this.
(SINGING) Fresh new kicks and pants.
You got it like that and now you know you want to dance.
So move out of your seat and get a fly girl
and catch this beat while it's rolling.
Hold on.
Pump a little bit and let me know it's going on like that.
Like that.
Cold on a mission so pull on back.
Let them know that you're too much and this is the beat you can't touch.
Yo, I told you, you can't touch this.
Why you standing there, man?
You can't touch this.
Yo, sound the bells.
School is in, sucker.
You can't touch this.
Give me a song or rhythm.
Making them sweat.
That's what I'm giving them.
Now they know when you talk about the Hammer,
you talking about a show that's hyped and tight.
Singers are sweating so pass them a wipe or a tape
to learn what it's going to take in the 90s to burn the charts.
DAVID MALAN: Second to last level.
MC HAMMER: (SINGING) Either work hard or you might as well quit.
That's word because you know you can't touch this.
You can't touch this.
Break it down.
Hammer time.
Go with the flow, it is said.
If you can't groove to this, then you probably are dead.
So wave your hands in the air.
Bust a few moves.
Run your fingers through your hair.
This is it for a winner.
Dance to this and you're going to get thinner.
Slide your rump.
Just for a minute, let's all do the bump, bump, bump.
You can't touch this.
Look, man.
You can't touch this.
You better get hype, boy, because you know--
(SINGING) Break it down.
It's OK.
One more life.
Hammer time.
DAVID MALAN: All right.
A round of applause for Andrea, if we could.
That's it for CS50.
See the website for details.
We'll see you for cake in the transept.
Welcome aboard.
    You must  Log in  to get the function.
Tip: Click on the article or the word in the subtitle to get translation quickly!


CS50 2018 - Lecture 0 - Computational Thinking, Scratch

161 Folder Collection
小克 published on September 18, 2018
More Recommended Videos
  1. 1. Search word

    Select word on the caption to look it up in the dictionary!

  2. 2. Repeat single sentence

    Repeat the same sentence to enhance listening ability

  3. 3. Shortcut


  4. 4. Close caption

    Close the English caption

  5. 5. Embed

    Embed the video to your blog

  6. 6. Unfold

    Hide right panel

  1. Listening Quiz

    Listening Quiz!

  1. Click to open your notebook

  1. UrbanDictionary 俚語字典整合查詢。一般字典查詢不到你滿意的解譯,不妨使用「俚語字典」,或許會讓你有滿意的答案喔