All language subtitles for aula_0

DAVID MALAN, All right.

This is CS50, Harvard University's
Introduction to the Intellectual

of Computer Science and the Art of
Programming. My name is David Malan, and

actually took this class myself some
years ago, but I almost didn't. It was

first year in college, and my roommates
and I were living in Matthews Hall, for

those familiar.

Nice, Matthews.

Our claim to fame, actually, at the time
was that our room was literally Matt

Damon's just three years prior.

So onward from that.

But my first year, I didn't really have
the nerves to set foot in this

classroom, let alone computer science.

In fact, for me, computer science, and
CS50 in particular, was very much this

class to beware.

I was kind of comfortable with
computers, but I certainly wasn't among

more comfortable with computers.

And so I shied away my first year.
Instead, I actually took a whole lot of

classes in government. In fact, in high
school, I was really enjoying history. I

loved this constitutional law class that
I took my senior year of high school.

And so I figured, okay, if that's what I
liked in high school, and if that's

where my comfort zone was, that's
probably what I should be doing in

And so I essentially declared as my
concentration or major, government for

first year, year and a half of school.

But my sophomore year, when I was living
actually in Mather House instead,

OK, no one for Mather.

In Mather House instead, it was, I sort
of followed some friends, I think, the

first week of class in September of that
year to a class called CS50. And

honestly, once I stepped foot in that
classroom, the professor at the time was

famous computer scientist by the name of
Brian Kernaghan now at Princeton.

I was hooked. And literally, would I go
back thereafter on Friday evenings when

at the time problem sets were released
and sit down at 7, 8 PM on Friday nights

and dive into homework, which isn't
necessarily something we recommend per

But for me, it was like this sign that,
wow, I've sort of found my calling. I

found my classmates here on campus. And
that's not going to be the case for

everyone. Certainly, we have no
expectations that after taking one

science class that you will or might
want to take take others. But what's so

empowering about computer science, and
CS50 in particular, is it's so

to the broader world, whether you're in
the arts, humanities, social sciences,

natural sciences, or beyond. It's just
so applicable, the concepts and the

practical programming skills with which
you will exit a class like this.

Now, it's going to be challenging along
the way. And indeed, I put in my time

back in the day, and even I did find it
challenging.

And here, for instance, is a photograph
of a very famous MIT hack. so to speak,

from down the road, whereby it
communicates that getting an education

is like trying to drink from a fire
hose, which is to say there's going to

much information, like so much new
stuff, that certainly on any given day

week, you're not going to be able to
absorb all of it that first time around.

But at the end of the day, it's through
that challenge, putting the time in,

that the returns are therefore just so
much higher at the end of the course.

indeed, will you walk out of the course
with a much better understanding not

only of computer science and
programming, but ultimately how to teach

new technologies and beyond.

For the next three plus months, well, we
have teaching fellows, teaching

assistants, course assistants, and
myself by your side sort of guiding you

through the course's material.

But the goal by term's end is to take
those and leave those training wheels

so that you're well equipped to sort of
go teach yourself new ideas beyond the

class itself.

Take comfort, though, in knowing that
most CS50 students have never taken a CS

course before. And indeed, as per the
syllabus, what ultimately matters in

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 when you began is thus today.

And so consider just how comfortable or
uncomfortable you are with computing,

let alone computer science and
programming, particularly if you've

explored either in a classroom before.

And consider the delta just a few months
from now that will really describe how

far you have come. And that is all that
matters, not how much the student to the

left, to the right, in front, or behind
you right now knows.

With that said, let me add some
additional inspiration, if I may.

Here's a photograph of my own very first
homework assignment in CS50 from 1996.

And I will draw your attention to the
fact that even though this is a so

Hello World program that we'll play with
ourselves next week, it is pretty much

literally the shortest, easiest program
you can write in a programming language

called C. I still somehow got minus 2 on
my very first homework assignment,

which is to say we're all going to make
mistakes along the way, but the goal

will be to learn and enjoy that process
here on out.

At the end of the day, too, like me,
you'll exit with your own proudly held

Hightook CS50 t -shirt, as is our
tradition, too.

With that said, there's so many other
traditions within CS50. both on campus

off? And in particular, do we try in
CS50 to provide not only the academic

support structure that you might want
going through the class, but also a

collective shared community experience?
Which is to say, in just a few days,

we'll start off the term formally with
CS50 Puzzle Day, which is not only an

opportunity to get together with friends
with pizza and prizes and also logic

puzzles of sorts, but really to send the
message that computer science itself is

not about programming. It's not about C.
It's not about Python. It's not about

programming languages per se. but about
problem solving, ever more so

collaboratively with other smart people
by your side in this class or beyond.

And indeed, toward the end of the
semester, reinforcements of the same by

a little something that we call the CS50
Hackathon, which will be an opportunity

overnight to dive into your own final
projects. The capstone of this course

thereafter followed by the CS50 Fair,
which will be a campus -wide exhibition

for students, faculty, and staff across
campus of your very own final projects,

be it your very own web app or mobile
app or anything else you decide to

by term's end. And indeed, the sort of
objective at the end of the day, truly

with that final project in particular,
is going to be to create for yourselves,

for your classmates, for attendees,
something that we didn't even teach you

to do. And indeed, that will signal
ultimately that you're indeed on your

and ready.

Toward that end, thought we would give
you a sense of CS50's past by way of

short video, if we could dim the light,
that paints a picture of all that awaits

here and beyond.

All right DAVID J. All right, so welcome
aboard to CS50 and computer science

itself. So what is computer science?

Well, put simply, it's the study of
information, like how do you represent

and how do you process it. But more
fundamentally, what we'll teach in this

class is computational thinking. That is
to say, the application of ideas from

computer science to problems of interest
to us within the class and problems of

interest to you after the class.

And so at the end of the day, what
computer science really is is about

solving, ergo that sort of global
applicability. And by problem solving,

something quite simple. In fact, we can
distill it as follows with this mental

image. This is problem solving. You've
got some problem to solve, thus known as

the input that you want to solve. And
the goal, of course, to problem solving

to actually produce a solution.

So the output in this model would be the
solution.

The interesting part, ultimately, is
going to be in how you process that

and turn it into that output, ergo
solving problems.

But before we can do that, we all kind
of have to agree how to represent these

inputs and outputs, especially if we
want to do it in a standardized global

using literally computers, be them
laptops, desktops, phones, or most any

kind of electronic device nowadays.

So how can we do that? Well, there's
different ways to represent information

the world. For instance, if I were to
take attendance, old school style, Maybe

in a smaller room, I might do 1, 2, 3,
4, 5, 6, 7, and so forth, and just count

people on my human hands.

That's actually known as unary notation,
otherwise mathematically known as base

1, because you're using your fingers
literally in this model as digits.

But a little quick question. How high
can you count with one human hand?

5 is incorrect if you use a different
base system than 1. So it's obviously

correct if you're just using unary and
just counting 1, 2, 3, 4, 5.

But I dare say I can come up with more
patterns in my human hand alone that

would enable me, without a second hand
or a couple of feet, to count higher

5. In fact, maybe for those more
comfortable, how high could you actually

on a single human hand, perhaps?

So 31, believe it or not.

is, in fact, the correct answer. But
why?

Well, here I initially started pretty
naively, 1, 2, 3, 4, 5.

And I just kind of combined all of my
fingers and counted the collective

But what if I'm a little more clever and
take into account the pattern of

fingers that go up? So maybe this is
still 0.

This is 1.

But now maybe we just agree universally
that this is 2, even though it's just my

single pointer finger.

Maybe we all just agree that this is 3
with two fingers up. Maybe we agree that

this is often offensive with just one
middle finger up. But this would then be

4. This could then be 5.

This could then be 6.

This could be 7. And if I keep permuting
my fingers in this way, allow me to

spoil it, this would be, in fact, 31.

But again, why?

But the difference here is that we're no
longer using unary, or base 1, as a

mathematician would say, but rather base
2. Because if we take into account not

just the total number of fingers that
I'm using, but whether each finger is

or up, being therefore in two potential
states, down, up, A, B, black, white,

however you want to distinguish those
two states of the world, you're now

operating what's called base 2. And
perhaps more familiarly, even if you're

a computer person per se,

the so -called binary system.

And odds are, even if you're not a
computer science person at all, you

generally know that computers only
understand or speak what alphabet, so to

speak.

So what's ones and zeros? Zeros and
ones, otherwise known as the binary

And in fact, there's a term of art here
that's worth noting. When you're using

zeros and ones, which of course are a
total of two digits, you have binary

digits, so to speak, by implying two,
which means there's two possibilities,

zero or one. If we actually get rid of
some of these letters and then join

two phrases, here you have a technical
term that is a bit. A bit is just a

binary digit, which is to say it's a
zero or one.

And this is in contrast, of course. with
the system you and I know as the

decimal system, dec implying 10, because
in the real world, you and I daily use

0 through 9, which is 10 possibilities.

Computers only use 0 and 1, that is to
say two bits, to represent information

instead. So how do we represent this
information, especially when at the end

the day, what we're using are indeed
computers and electronic devices?

Well, if I want to represent 0, I can
actually think of this as kind of

analogous to the physical world.

light bulb that's off or on, controlled
by a switch that turns it off or on. So

you can think of a binary digit that is
a zero as really just being a light bulb

that is off.

By contrast, if you think of a one in
the digital world as, of course, being

second of two possibilities, you can
think of that in the human or analog

the physical world, as being a light
bulb that is on.

And in fact, what's inside of your Mac,
your PC, your Android phone, your iPhone

are millions of tiny little light
switches known as transistors that just

turned on or off, on or off. And
essentially, you can use those

store information.

Because if you want to store a 0, you
turn one of those switches off. If you

want to store a 1, you turn one of those
switches on.

Of course, that sort of invites the
question, well, how do we count higher

0 or 1?

Well, we would seem to need to use more
than just maybe a single bit.

a single light bulb. So if we wanted to
count higher than, for instance, 0 or 1,

why don't we go ahead and maybe do this?

So just so I have some place to put
these, let me borrow some of our actual

physical light bulbs here from the
stage.

And let me propose that now with three
bits on the stage, three light switches,

three transistors, whatever metaphor
you're most comfortable with, this is

computer would represent a 0, because
all of them are off. So it's off, off,

off.

But if a computer wanted to count to
one, we could do naively this.

We could turn this on. And if a computer
wanted to represent two, we could do

this. And if a computer wanted to
represent three, we could do this.

But I'm kind of painting myself into a
corner and not using these light bulbs

cleverly as I could, because at the
moment, I've only counted as high as

So if I want to count to four, to five,
to six, I'm going to need more and more

light bulbs. Can we be a little more
clever?

Well, again, someone else who's among
those more comfortable, what's the

here? How high, using binary zeros and
ones, could I count with three light

bulbs total? And back?

Yeah. So 7 here is the answer.

And if that's 2, you're sort of
wondering, how are people figuring out

That's the goal at hand here. So let me
do this. Let me turn all of these off

again so that my three light bulbs or
switches, again, represent 0.

And the first one's easy. This is how a
computer would represent the number 1.

It would be on, off, off.

How, though, is the computer going to
represent 2?

Well, just like my proposed finger
example, let's do this. Let's turn this

off. and this one on, that is how a
computer would represent 2, by saying

on, off.

In other words, 0, 1, 0 would be the way
to pronounce it digitally.

What if I instead want to represent 3?
That's how on my finger I did this, with

two fingers.

Well, I'm going to turn this one on.
This is 3.

Now, this will, for those less
comfortable, be non -obvious. This now

would represent the number 4.

This is how I would represent 5.

This is how I would represent 6.

And this, as per the spoiler, is how I
would represent 7. So perhaps very non

-obvious what it was I just did or why I
chose those patterns, but I dare say if

you sort of rewind in your mind's eye or
literally later on video, you'll find

that I actually did show you eight
distinct patterns of light bulbs. The

one was off, off, off. The last one was
on, on, on.

And there were another six total in
between then. Well, wait, why seven?

if you start counting at zero, And I
claim there's eight possibilities. You

only count from 0 to 7, as we will soon
see.

So how are these patterns coming about?
And what is it that our computers are

actually doing?

Well, it's actually doing something a
little like this, quite like in decimal.

So in the human world, you and I are
very much in the habit of using base 10,

through 9, AKA decimal.

Well, how do we use it instinctively as
humans?

Well, what's this number, obviously, on
the screen?

123.

But why is it 123?

For years, you haven't really thought
about why this pattern of symbols or

digits on the screen, 1, 2, 3,
represents mathematically this number

know, obviously, as 123.

But if you rewind to grade school, odds
are, like me, you were taught that the

rightmost digit is in the ones column,
this second digit is in the tens column,

this digit is in the hundreds column,
and so forth. So even though none of us

have to do this math explicitly, what
you're instantly doing is 100 times 1.

plus 10 times 2 plus 1 times 3, which
gives you 100 plus 20 plus 3. Oh, that's

why it is 123, because these digits in
this order have that significance.

The digits to the left have more weight,
so to speak, than the digits to the

right.

So what can we take away from this?
Well, let's generalize it first as just

three -digit number. So number, number,
number. The ones column, the tens

column, the hundreds column.

But there's some math going on there.
And it's not particularly sophisticated.

Those are actually powers of 10.

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

And there's your decimal system. Because
the base in this value is a 10, that's

because there's 10 possibilities for
each of those placeholders 0 through 9.

But in the binary world, in the world of
computers, where all they have are 0s

and 1s, why? Because all they have
physically is transistors, tiny, tiny,

light bulbs that can be off or on.

If you only have two digits to play
with, the 10 base should, of course,

a 2 base.

And now if we do some math here, 2 to
the 0, 2 to the 1, and 2 to the 2, you

the ones column, the twos column, the
fours column.

And if we keep going, 8, 16, 32, 64,
128, and so forth, it's powers of 2

of powers of 10.

But this is to say computers represent
information in exactly the same way you

and I have since childhood.

But they have fewer digits at their
disposal, so these columns need to be

weighted differently. So we can still
count from 0 all the way up towards

infinity. So what does this mean?

Well, here we have three bits on the
screen, 0, 0, 0.

If we were to convert this now mentally
or on paper pencil to decimal, how do we

do it? Well, 4 times 0 plus 2 times 0
plus 1 times 0, that gives us the

mathematical number you and I know as 0.

That was three light bulbs off, off,
off.

Well, what if we turn on one light bulb
all the way on the right?

What decimal number does this binary
number 001 represent?

Just 1, because it's 4 times 0, 2 times
0, 1 times 1.

Here's where things got more
interesting, even if non -obvious in

form or even physical hand form.

010 in binary is what in decimal?

2, because it's 2 times 1, and that's
it.

011 in binary is, of course, now.

3, this is now 4, this is now 5, this is
now 6, and 7, on, on, on, or 1, 1, 1,

is the highest we can count with these
three bits.

All right, so how might a computer
intuitively count as high as 8?

What do you need to do, presumably?

You're going to need to add a bit. So
you need another light bulb, another

switch. You need more memory, so to
speak, to use nomenclature with which

probably familiar.

So in fact, if we change all of those to
0, but we give ourselves one more bit

for a total of 4, ah, that's got to be
the 8th place, because it's just another

power of 2.

So 1, 0, 0, 0 is the decimal number 8.
You don't say 1 ,000 in binary. You

literally say 1, 0, 0, 0.

But that is the number you and I know as
8. And you can keep going up and up and

up. And how, then, computers?

Excel or any kind of number crunching
software counts really high and keep

of really big numbers, the computer just
throws more and more transistors at it,

more and more bits to count higher and
higher and higher than this.

Turns out, though, one bit, three bits,
even four bits aren't that useful in

practice because literally you can count
as high as seven or maybe 15 or 31.

So more commonly, as is commonly known,
is to use a byte.

of bits instead.

How many bits is in a byte for those
familiar?

So it's just 8. Why 8? It's just more
useful than 1 or 2 or 3 or some other

number. And as an aside, it happens to
be a power of 2, which is just useful

electronically as well.

So a byte, then, is just 8 bits.

And here are those columns I rattled off
off the top of my head.

Here is how a computer would represent 0
in decimal, but using 8.

binary digits or bits.

A little trivia, and again, this is not
what computer science is about, but it

helps to know the lower bounds and the
upper bounds of these kinds of values.

How high can you count with 8 bits or 1
byte if this is 0?

Yeah, so it's actually 255. So if I were
to change all of these 0s to 1s and

then do some quick mental or calculator
math, 128 plus 64 plus 32, 16, 8, 4, 2,

and 1 would actually give me 255 total,
plus 0, which gives me 256

total possibilities.

So this is only to say, this is not,
again, the kind of math we'll frequently

do, but you'll commonly see in the
computer world and programming world,

of two, numbers like 255, 256. Why?

Because these are the common units of
measures that systems tend to use.

So let me pause here and see, with
respect to binary, zeros, ones,

and the like, any questions or confusion
we can clear up.

A really good question. Why are bits
just on or off instead of maybe 0%,

50%, 100 % by playing with voltages? So
the voltage inference of yours is

actually correct.

That's what computers typically do.

Maybe they use 0 -ish volts to represent
0, maybe 5 -ish volts to represent

1. It turns out it's just really easy to
do extremes in computers.

If you start to split that range of
voltage levels, for those who remember

of their electricity It just gets harder
and harder to be exact.

And if you get things a little too
murky, you might mistake a 0 for a 1 or

or a 3. So it turns out it's just
simpler to use the binary system. But

exist computers known as ternary
computers that actually use three

and 2, which is somewhere, of course,
between binary and decimal. But you can

different things. It's just simple on
and off. And case in point, I don't want

to really be dramatic and turn off my
computer, but if I pulled out the power

plug, that could be off, literally, aka
0.

Plug it back in, that's a 1. There's
just a cleanliness and simplicity to

Other questions or confusion that we can
clear up?

No? OK.

So if you're in agreement for the moment
that, OK, using just zeros and ones, we

can represent any number we want from
zero on up, let me propose that we do

useful things with our computers and our
pockets and desktops and laptops, like

represent letters for the sake of Google
Docs, Microsoft Word, or any kind of

text that we might want to write.

So knowing now that computers only use
zeros and ones and therefore only

hardware like transistors, how could you
represent something like a capital

letter A in English inside of a
computer, which, of course, is not a

anymore?

What could we do? Yeah.

OK, yeah, so we could take the alphabet,
A through Z in English, and we could

just assign each letter a number. And
honestly, that is not only the correct

answer, it's really the only answer.
Because at the end of the day, if all

have are 0s and 1s available to you,
that is the entirety of the potential

solution to this problem.

So it turns out that, yes, capital
letter A, some years ago, was decided by

bunch of people in a room, shall be
represented with this pattern of 0s and

0, 1, 0, 0, 0, 0, 0.

And now, trained as you are to do a bit
of quick binary math, what decimal

number is used to represent, apparently,
capital A?

So 65, because it's 64 plus 1.

plus 1 times 1 is 65.

What is b? Turns out it's 66.

What is c? 67.

So they kept things simple there on out.

It might have been nice if a were 0 or
maybe a were 1. But nope, we're stuck

with 65 instead.

But everything after that is very much
predictable.

And in fact, for lowercase letters,
there's a whole other set of numbers,

as lowercase a happens to be 97,
lowercase b happens to be 98, and so

again, this is sort of like CS trivia.

What's important here is that they're
indeed contiguous from 65 to 66 to 67 on

up. That's something we're going to be
able to leverage beyond the letter A

alone. What is this system? What is this
mapping that you yourself proposed?

It's ASCII, the American Standard Code
for Information Interchange. And indeed,

it was a bunch of Americans years ago
who came up with this system.

Unfortunately, at the time, they only
allocated seven and eventually eight

total.

for representing letters, both uppercase
and lowercase, numbers on the keyboard

as well, punctuation symbols as well.
And so per our conversation a moment

if the Americans in this room, so to
speak, only used 8 -bit total, how many

different characters can we represent
with a computer in this story?

So only 255, technically 256 if we,
again, start counting from zero.

So that's not nearly enough to represent
all human languages, but it is enough

to represent at least English among some
others.

So here, for instance, is a chart of the
ASCII mapping.

And sure enough, if we zoom in on this
column here, 65 is capital A, 66 is

capital B, dot, dot, dot, 72 is H, 73 is
I, and so forth.

So there is a standardized mapping for
at least all of these English letters.

Well, suppose you were to receive an
email or a text message or like a Google

Doc containing this pattern of zeros and
ones.

So 0, 1, 0, 0, 1, 0, 0, 0, and so forth
and so forth. So three bytes worth.

Three sets of eight bits, that is to say
three bytes, each of which represents a

single letter in ASCII.

message have you received? Well, I'll do
the math this time, so we don't have

to. Suppose what you really received was
decimal 72, 73, 33.

What message did you just receive?

If you recall the previous chart.

High was, in fact, correct. Why? Because
H is 72, I is 73, and wait a minute,

33. So here's H, here's I.

33, if we highlight it instead, happens
to be an exclamation point. So that is

literally what is going on underneath
the hood, so to speak, when you get a

message today that literally says in all
caps and an exclamation point.

Hi, your phone has received at least
three bytes, each of which represents a

letter of the alphabet.

Your computer is quickly doing the
mental math to figure out exactly what

numbers those are and then looking up in
the so -called ASCII chart in its

memories, in some sense, what letter
should you actually see on the screen

there. And so if you were to then
display that message, you would see it

in English as opposed to those numeric
equivalents.

How else might we use this then? Well,
here again is that chart.

And maybe just to vary things, maybe
take a little pressure off of me here,

don't we try spelling something else,
this time a different three -letter

but maybe eight volunteers.

Could we get a bite's worth of
volunteers?

And I can sweeten the deal with some
stress balls in exchange.

You just have to be comfortable coming
up on stage and being on the internet.

yes, one, two, how about three, four,
how about five, six, seven, and how

eight? Come on up. A round of applause
for our volunteers.

All right.

So what I'm going to have each of you do
is represent a bit in a particular

order. So if you want to just, in any
order, line yourselves up here facing

audience. Come on over.

All right.

And we will have you represent.

Well, we've got to see who ends up
where.

Scooch this way a little bit.

This way, this way.

All right, so you shall be the 1's
place, and just hold that in front of

2's place,

4's place, 8's place, 16, 32,

64.

And 128.

And just compress yourselves a little
bit if you could. So each of these folks

represents a bit in a particular place.

And let's say this. If you're just
standing there sort of uncomfortably

any hand raised, we'll assume that
you're representing a 0, quite simply.

your hand goes up, though, the audience
should assume that you're representing a

1. And therefore, what we'll do is fill
out a three -letter word.

And on each round of this, you'll either
stay Stay like this, or you'll raise

your hand. But first, let's actually
meet some of our volunteers here,

with position number one, if you'd like
to say your name, perhaps where you're

from and or studying.

Hi, my name is Brooke.

I'm from Indiana, and I'm studying
biology and computer science.

Nice. Welcome.

Hi, I'm Becca. I'm from like Maryland, D
.C. area, and I'm studying electrical

engineering.

Welcome.

Engineering. Hi, I'm Sharon. I'm from
Rwanda, and I'm studying CS in math.

Welcome. Hi, I'm Grace. I'm from
Alabama, and I'm studying electrical

engineering.

Welcome. Hi, I'm Angelina. I'm from
Maryland, and also I stay in Matthews.

Matthews. Nice.

And I'm studying applied math and econ,
as well as viral science and public

policy. Welcome.

I'm Owen Bells, and I'm from rural
Virginia, and I'm studying CS.

Nice. Welcome, Ant.

And my name is Max. I'm from London.

I'm also staying in Matthews. And I'm
studying computer science and

neuroscience. Welcome aboard as well. If
you're wondering, too, why I was

wearing these glasses at the start, so
very common on the internet nowadays is

these POV videos. So it turns out these
Ray -Bans actually record video footage.

And we have a couple of them. And we
thought we'd offer them to a couple of

volunteers if anyone wants to record
their point of view for everyone here.

And Vlad here is going to help make sure
they're recording.

Second volunteer? Yes, number two.

All right. So as Vlad gets those set, on
the backs of your pieces of paper, you

have instructions for the following
three rounds. Each round represents a

letter. The audience participation part
of this is to actually do the mental

math to figure out what number these
volunteers are representing.

So go ahead and execute round one,
either keeping your hand down or raising

appropriately.

DAVID J. OK. What number are our
volunteers here representing?

66. DAVID J. 66, because we have a 64
plus a 2. That then maps to what ASCII

letter? B. DAVID J. B was the first
letter. OK, hands down. Round two, go.

A little harder.

What's now being represented?

I'm starting to hear it.

9 is, in fact, correct. 79, because we
have a 64, and an 8, and a 4, and a 2,

and a 1. So if it's a 79, we have the
ASCII letter O.

OK, so we've got B, O, and then lastly,
third round, go.

We have 01010111.

What number is this?

87, which spells the letter?

W, which spells the word?

Not bow, take a bow if you could. All
right, a round of applause for our

volunteers here.

And come on up this way and help
yourself to a CS50 stress ball.

Thank you to our volunteers. So this is
only to say we've now agreed on how we

can represent numbers from zero on up.
We've agreed on how we can represent

letters, but at least letters using
ASCII. And in fact, these are more than

decoration. In fact, as a little bit of
trivia by lecture's end, if you want to

come up for your very own CS50 stress
ball, turns out there's 64 light bulbs

the foot of the stage here. If you break
them down into eight bytes, or single 8

-bit or single byte chunk.

There's an eight -letter word that
happens to be spelled out today using

here ASCII chart. So today's mystery is,
what exactly is that there word?

But of course, if you have only 8 bits,
you can only represent like 256

characters, which sounds like plenty for
English.

And indeed it is.

0 through 9, A through B, capital and
uppercase and lowercase, as well as

punctuation. But there's so many other
human languages in the world that have

other characters. For instance, we have
not just the English alphabet. We might

see here on a US English keyboard.

We have accented characters.

We have various Asian languages, have
even many more glyphs. We need more than

256 possible characters.

And so nowadays, computers do not just
use seven or even eight bits.

They might use eight bits for some
letters. like all of the English

they might use 16 bits for certain other
languages, maybe even 24 or 32 bits.

And fun fact, if you have 32 bits, and
we have more than that on the stage, if

you've got 32 bits, you can actually
represent as many as 4 billion possible

characters, which is quite a bit.

No pun intended.

So what else can we represent?

Well, the goal of this system, not just
ASCII, but something known as Unicode,

which is a newer standard, is to be
backwards compatible with ASCII. So

left all of those other numbers alone,
65, 66, 67, and so forth. But they added

to it a superset of representations that
maybe are 16, 24, or 32 bits. The goal

being to be able digitally to represent
all human languages, past, present, and

future, and even through pictograms,
things like

smiley faces and the like, even people
places things in emotions that transcend

human language.

And in fact, odds are, within the past
few minutes or hours, most of you have

used one or more of these here emoji,
these pictograms, which it turns out are

just characters on a keyboard.

You might have to hit a special button
to pull up that form of the keyboard,

these are just here characters.

And so these emoji have exploded in
popularity for a number of reasons, one

which is, my god, what are we going to
do with 4 billion possible patterns of

zeros and ones, we can start to kind of
have some fun with it and represent

things beyond English and human
languages alone.

Now, as an aside, when it comes to
Unicode, it turns out Unicode years ago

standardized this pattern of 32 zeros
and ones to represent just one of those

emoji. So emoji tend to use even more
bits here.

Anyone know what decimal number this is?

This is not a fun mathematical exercise.
The spoiler is.

4 ,036 ,991 ,106 is the decimal number
that actually represents,

as of present, the most popular emoji in
the world.

Does anyone want to hazard a guess what
emoji this here number represents?

Hearts? Hearts?

No, but it's actually this so -called
face.

with tears of joy.

So perhaps think about the frequency
with which you send that one. And even

though it's obviously a picture on the
screen, sure, it actually is more like a

font. Because underneath the hood, it's
indeed just a pattern of zeros and ones

or a decimal number that the computer is
storing. But the computer, be it Mac OS

or Windows or iOS or Android, know to
display that pattern as this here

But the pictures might look different
depending on the hardware. Why? Because

there's companies like Google and
Microsoft and Meta and others that have

own artists on staff as employees.

And those artists interpret the
descriptions, like face with tears of

differently. So those of you with an
Android phone actually see face with

of joy looking a little something like
this. And if you have Telegram, for

instance, installed on your phone, it's
even more animated than that. It's this

here emoji using the same pattern of
zeros and ones. So different artists

these here emoji in different ways. But
all they are here are patterns.

Another answer, save one, that was
shouted out a moment ago. This is a sort

cloud diagram of the most popular emoji
as of a couple of years ago per Unicode,

whereby the size of the emoji indicates
its relative popularity. So heart, I did

here over here, is indeed one of the
most popular ones as well.

Question.

A really good question. Why do certain
emoji not show up on one device or

another? It depends on how recent the
software is. Pretty much every year, the

humans behind the Unicode Consortium
release new emoji, which is to say they

decide that this other pattern will
represent this new emoji. This other

will represent this new emoji. And
unless you update your phone, your

your desktop to the very latest
software, and the manufacturer of that

software also updates by hiring an
artist to draw those pictures in their

font, in their own style, you're going
to see usually just like an empty black

square or maybe just like a black and
white heart instead of something more

colorful, really just placeholders.
Because it's as though you don't have

right font installed, or really you have
an older version of that same font

installed. But it's become sort of an
annual tradition that new and more emoji

are released every year, which is among
the reasons why these updates contain

more and more. Yeah?

That is an amazing segue. How do you
represent color in bytes?

Well, you use RGB, which happens to be,
by coincidence, the next slide. So let's

again recap.

We know how to represent letters.

We know how to represent numbers. We can
even represent emoji. But those emoji,

technically, on the screen are, of
course, composed of colors, like a whole

bunch of yellow for that there smiley
face.

How do computers then, using only zeros
and ones, represent colors?

Well, by convention, they typically use
a system that by an acronym is called

RGB, red, green, blue.

And this is to say that a computer, to
represent a single dot on the screen,

maybe this one, this one, this one, will
allocate some number of bits.

or some number of bytes to represent the
color of just that there dot, otherwise

known as a pixel. You can actually see
pixels on your phone or even on your TV

or monitor. If you go really close,
especially if it's an older monitor, you

see the tiny little squares.

Each of those has some number of bits
telling the device what color to use.

In particular, these devices typically
use three numbers in total, three bytes.

So that is to say 24 bits per pixel. And
they do this.

If you were to represent a single dot on
the screen using these three numbers,

just by intent here, this is 72, 73, 33,
which in the context of a text message,

an email, a Google Doc, represents, of
course, high.

Textually, what if a computer uses that
same pattern of zeros and ones, that is

the same pattern of decimal digits, to
represent the color on a screen, which

germane if you're opening an image using
Photoshop. So you're using a different

piece of software that knows about
colors and images and not just text.

this would imply that you want that dot
on the screen to have a medium amount of

red, a medium amount of green, and a
little bit of blue.

Why do I see medium and little?

Well, again, if each of these numbers is
using 8 bits or 1 byte, the highest we

can count, as we discovered, was 255.

So I'm kind of averaging here. So 72 out
of 255 feels to me like a medium amount

of red.

33 feels like relatively little blue.

But if now the computer combines those
wavelengths of light, so to speak, a

medium amount of red, medium amount of
green, a little bit of blue, what you

is the color code for a single dot. And
does anyone want to guess what color

roughly this represents?

These three bytes?

Not white, not purple, not brown.

Yellow, in fact, is the answer. So it
represents, in a single pixel, roughly

this shade here of yellow.

Which is to say, if we look back at any
of those emoji, which, again, are

represented by patterns of zeros and
ones, but you and I as humans perceive

as images on the screen, let me actually
go ahead and zoom and zoom in further

to one such sample emoji.

And when you zoom in far enough, or you
put the phone close enough to your face,

you can actually see all of those little
dots known as pixels, all of the little

squares.

that so many of these pixels are yellow,
that is to say that that pattern of

three bytes, 72, 73, 33, is used to
represent this pixel.

Another three identical bytes are used
to represent this pixel, this one, this

one, and so forth. So now if you've
taken digital photos on your phone or a

camera, you're probably generally
familiar from the internet and hardware

that a photograph is what, like one
megabyte?

10 megabytes, depending on the
resolution of it. Well, megabyte means

of bytes.

Where are all of these bytes inside of
these photographs or these images you're

taking or downloading?

They correspond to every one of the
single pixels on the screen. There's at

least three bytes being used to
represent every one of those dots.

As an aside, bit of a white lie, because
nowadays there's fancy compression

software that can use fewer than that
many bytes. But in general, that's where

all of those bytes, those millions of
bytes, are coming from.

So how was that for an answer to how do
we represent colors?

Thank you.

So if we agreed now that there's this
way and perhaps others to represent

colors, well, how do we represent not
just images but videos?

Well, videos, once upon a time, or
movies, were called motion pictures.

So most pictures with motion. Why is
that? Well, it's analogous to growing

If you ever played with one of these
picture books, and in fact, there's

nowadays that have made these popular
again, whereby you have a whole bunch of

images on individual sheets of paper.

through them fast enough, your human
mind and eyes perceive it as actual

even though you're just seeing image,
image, image, image, image, image, but

it's so fast it looks like motion.

That's all a video is on your screen.

That's all a film is on your TV. It is
not, in fact, continuous motion.

It's maybe 30 frames.

or images per second, maybe 24 frames or
images per second, which is to say we

know how to represent numbers. We know
how to represent letters.

We know how to represent colors and
those images. Now we kind of get videos

free because it's just more of the same.
Use more and more of those patterns.

Why are videos so darn large?

Why are they gigabytes to download,
billions of bytes? Because there's so

darn images, 30 some odd images per
second in those kinds of videos.

And maybe lastly, just to top off our
multimedia, how could you represent

Maybe musicians in the room, how, using
only zeros and ones, could you represent

something as sonorous as music?

Something analog as digital, yeah.

Yeah, so each number that we store in
the computer could correspond to a

frequency, which has a direct
relationship to the sound or the pitch

For instance, in the world of piano and
many other instruments, you've got like

your A, your B, your C. Maybe you have
sharps and flats as well. We could just

agree, like the ASCII people did years
ago, to represent the musical note A,

let's use this pattern. Musical note A
sharp, let's use this pattern, and so

forth. But maybe pitch alone or
frequency alone is not enough. Maybe we

that number.

but maybe a second number for the
volume, the sort of digital equivalent

hard are you hitting the key on the
piano. Maybe a third number for how long

you holding the key down.

So maybe the pitch and the volume and
the duration, kind of like RGB, we could

use three bytes to represent every
musical note in some piece.

And if we wanted to keep track of what
instrument should be played by the

computer to sound that music, well,
maybe that's just a fourth byte or

else is well, which is to say at the end
of the day, all we have are these 0s

and 1s to throw at the problem.

So for now, that's it for representing
information.

We've got our numbers. We've got our
letters. We've got our colors and

our videos, and now sound.

Any questions on how computers then are
representing, as promised, those inputs

and outputs using just 0s and 1s? Yeah,
in the middle.

Correct. So the computer is taking as
input, at the end of the day, 0s and 1s

and is outputting 0s and 1s. However, as
we'll learn in this class, by writing

software, by writing code that
understands those zeros and ones, we

not just literally seeing zeros and
ones. We will see A, B, C. We will see

colors. We will see video.

We will hear sound so long as we write
the code to interpret those zeros and

ones. And indeed, it's worth noting now
that that same pattern I keep using for

an example, 72, 73, 33.

How does a computer know is that the
message high?

Is that the color yellow?

Is it a dot in a video alone?

Just depends on the context.

Simply put, if you're opening that
pattern of zeros and ones with Excel or

calculator program, odds are the
software will interpret those three

numbers, of course. If, though, you open
that same pattern in a text messaging

program, Google Docs, Microsoft Word,
that same pattern will be interpreted as

sequence of letters. Instead, if you
open Photoshop that same pattern, you'll

probably see a single dot that happens
to be yellow.

Conversely, once you yourself are a
programmer or even better programmer,

will be able to write in code how you
want the computer to treat these

of zeros and ones. You can essentially
tell the computer, use this to store a

number or a letter or a color or
something else. That's the power the

themselves have at the end of the day.

Other questions on representing things
with bits?

All right.

So lastly, then, in this middle of this
black box, so to speak, is the sort of

secret sauce that solves problems, that
converts those inputs to outputs, those

problems to solutions. So what is an
algorithm? It's really just step -by

instructions for solving some problem.
And indeed, I think back to my own first

time in CS50, where we learned the same
from Professor Brian Kernaghan. And as

luck would have it, just had my 25th
reunion, where we pulled some video

from 1996.

And so we're actually fortunate. to have
the very first few minutes of CS50 over

25 years ago when I myself took it. But
the lessons back then as today are

fundamentally the same. And what's
important indeed is to not only express

yourself correctly, but precisely, as
we'll explore today.

This then is Professor Brian Kernaghan,
who years ago very memorably introduced

us and my classmates to algorithms by
actually in class shaving his beard.

if we could dim the lights here for
Brian.

The other thing that we're going to talk
about in this class is the notion of an

algorithm. An algorithm is a very
precise description of how to do

And the operative word there is precise.

It has to be very, very, very, very
precise.

And the task that I am going to do is
that I'm going to trim my beard, which

gotten out of whack.

And I brought a variety of things which
one might use to

trim beards with.

So suffice it to say, I don't have much
of a beard, but I do have this here

other technology known once upon a time
as a phone book. And these phone books,

of course, have lots of information in
them, happen to be storing numbers and

letters in particular. For those
unfamiliar, they are storing human names

to Z here in English and associated with
everyone's name is a number. So even if

you've never had occasion to physically
use this kind of device, turns out it's

pretty much equivalent to the contacts
or the address book app on your iOS

or your Android phone as well. Why?
Because if you pull up your contacts, of

course, you see some familiar names here
alphabetized by first name or last

name. And if you click on any of those
names, you reach the person you're

presumably trying to call or text.

Pictured here, then, is John Harvard's,
whose number here is plus 1 -949 -468

-2750, which you're welcome to call or
text at your leisure.

But here is John Harvard that's partway
through the phone.

Well, it turns out that physically in
the phone book, we might use an

step -by -step instructions for finding
John Harvard in pretty much the same way

as iOS, Android, Mac OS, Windows, or
other operating systems themselves use.

So I could, when looking for John
Harvard, first name starting with J, I

start at the beginning of the phone book
and start looking page by page.

by page for John Harvard. And if he's
there, I can call.

This is an algorithm. It's indeed step
by step, but that was a bug. It's a few

pages turned.

But is this algorithm correct?

Step by step, assuming I'm paying
attention.

So yes, if John Harvard is in here, I
will eventually find him once I get to

J section. Now, this is a little
tedious. It's going to take a while, a

dozen, a few hundred pages. So maybe I
could do things a little smarter from

grade school, like 2, 4, 6.

8, 10, 12, 14, 16, and so forth going
twice as fast.

Is that algorithm correct?

So no, but why?

I could miss him, right? I could just
get unlucky, really, with 50 -50

probability because John Harvard could
be sandwiched between two pages.

Now, this isn't a complete loss, this
algorithm.

Maybe what I could do is if I get past
the j section to k, I could double back

at least one page just to make sure I
didn't miss John Harvard. So I can still

go twice as fast plus an extra step just
to make sure I didn't mess up. So the

first algorithm might take as many pages
as there are in the phone book. So if

this phone book has 1 ,000 pages, pages,
in the worst case, if I'm not looking

for John Harvard but someone whose name
starts with Z, might take me 1 ,000

pages to actually get there.

Second algorithm, twice as fast
literally, might take me 500.

plus one step to get there, because I'm
going two at a time, so long as I indeed

fix that bug.

But what we used to do back in the day,
and what your phone is doing today,

albeit digitally, is going roughly to
the middle of the phone book, looking

and realizing, oh, I'm accidentally in
the M section, so halfway through the

phone book. But what do I now know about
John Harvard? Is he to the left or to

the right?

So he's obviously to the left, because j
comes before m.

So what I can do literally, and what
your computer does figuratively, is tear

the problem in half, throw half of the
problem away, leaving us now with the

same fundamental problem, but it's half
as big.

So I've gone from 1 ,000 pages suddenly
to 500 pages. And compare this to the

other two.

1 ,000 pages, 999, 998, versus 1 ,000
pages, 998, 996,

994. That's still slow.

I went from 1 ,000 to 500 in just one
step of this algorithm.

What do I do next? I go roughly to the
middle here.

Oh, I went a little too far. I'm in the
E section now. So is John Harvard to the

left or right now?

So he's to the right. So I can, again,
tear the problem in half, throw the left

half away, knowing now that John Harvard
must alphabetically be in here. And I

can divide and divide and divide and
conquer this problem again and again by

using that heuristic of going left or
going right. And I dare say, if I do

correctly, I'll eventually be left with
one single page on which John Harvard's

number actually is, or maybe he's not in
the phone book at all.

So how many steps maximally might that
third and final algorithm take? It's not

1 ,000. It's not even 500 or 501.

How many times can you divide 1 ,000
pages in half again and again and again?

Roughly.

9, 10, so typically 10 times, give or
take. There's a bit of rounding there

because it's not a perfect power of 2,
but roughly 10 times. That is

fundamentally better than both of the
two algorithms because I go from 1 ,000

pages to 500 to 250 to 125 and so forth,
literally having the problem again

and again.

So we can actually appreciate and see
this even more so graphically. And this

among the things we'll do later in the
term when we speak to not only writing

correct code, But is your code well
designed?

Is it better than your previous code? Is
it better than someone else's code? Is

it better than some other product? If
you have given more thought to the

algorithms and the quality thereof, you
can perhaps minimize the time required

to solve problems, but no less
correctly.

So if we have a simple xy plus here, on
the y -axis or vertical is the amount of

time to solve in whatever unit of
measure, seconds, pages, however you

count. On the horizontal or x -axis is
the size of the problem.

measured in, for instance, numbers of
pages.

So this would mean zero pages in the
phone book. This would mean a lot of

in the phone book. This would mean no
time to solve. This would mean a lot of

time to solve. What's the relationship,
then, among those three algorithms?

Well, the first one is essentially a
straight line, a slope of 1.

And if the phone book has n pages in it,
we'll describe the slope here as

essentially 1 over 1 for the first
algorithm, turning page by page by page,

which is to say, If we were to add one
more page to the phone book next year,

first algorithm is going to take one
more step.

But the second algorithm is definitely
better. It's definitely faster, but it's

still a straight line.

So it's going to take roughly n over 2
steps on average, because you only have

to go through half of the phone book,
because you're going two pages at a

instead of the whole phone book, in the
worst case, if someone's name is Z, to

go through every page in total.

So if we actually compare these, let me
just draw some dashed lines.

Suppose that you have this many pages in
the phone book. If you just draw this

vertical white line here, it's going to
take this much time in red using the

first algorithm, but it's going to
literally take half as much time in

for the second algorithm, because you're
literally going two pages at once.

But the third and final algorithm is a
fundamentally different shape. It

looks a little something like this.

It looks like it's flatter and flatter
and flatter. It's always increasing.

It never gets perfectly flat.

But it grows so much more slowly as a
function of phone book size.

And for those who recall their
logarithms, this would be described as

of n.

And in fact, that's where the math came
from. Log base 2 of 1 ,000 is roughly 10

in total, even if you need a calculator
to confirm as much.

But this shape is fundamentally
different. Why?

Well, suppose that Cambridge, where we
are, and Alston, the town across the

street next year, combine their two
phone books. And they go from 1 ,000

each to one phone book with 2 ,000
pages.

The first algorithm is going to
literally take twice as many steps or

Second algorithm is going to take half
as many, or 50 % more, because you're

going two at a time. But the third
algorithm is going to barely miss a

Why?

This is 1 ,000 pages here, and 2 ,000
pages is over there.

Just inferring from the shape of the
green line, it's not going to be much

higher on the vertical axis than the
other two were.

So more specifically, if you have a 2
,000 page phone book next year, how many

more steps will it take you using that
third and final algorithm?

Just one, because you'll divide and
conquer a 2 ,000 -page phone book into a

,000 -page phone book, and then you're
back at the original story.

And that's the sort of power of learning
algorithms. That's the power of

learning computer science and learning
how to program is to be able to navigate

big data, so to speak, things the size
of Google, things the size of artificial

intelligence training data sets using
better and better, more clever

that perform faster and therefore not
only make the software more competitive,

but also make it more usable.

and more favorable for people like you
and me when using that software.

So when it comes to implementing
algorithms as programmers, as computer

scientists, what you're really doing is
taking these algorithms, which might be

expressed in English conceptually as we
just did, but really just translating

them to code, be it C or C++ or Python
or R or Ruby or any number of other

languages that exist in the world. But
for now, let's consider how we might

implement that algorithm using something
that's literally still English but

pseudocode, something that is still
correct, but precise and finite, as per

Professor Kernighan's advice, which is
to say, use your own vernacular of

English and just say what you mean, but
very succinctly. There's no one way to

write pseudocode. It's not some formal
language.

I'm just going to convert the steps I
did intuitively to step -by -step

instructions as follows.

Step one, what I did was pretty much
pick up the phone book.

Step two, what I did was pretty much
open to middle of phone book for the

algorithm. Step three, look at page.

Step four.

If person is on page, then step five,
call person.

If that does not prove to be the case,
step six, else if the person is earlier

in the book, then open to the middle of
the left half of the book, and then go

back to line three.

Then, else if the person is later in the
book, open to the middle of the right

half of the book, and again, go to line
three.

Else, there's a fourth and final case.

If the person like John Harvard is not
on the page, is not earlier, is not

later, what's the fourth scenario we'd
best consider?

He's just not there, else we should do
something specific like quit. Now, as an

aside, everyone in this room has
probably had one of these stupid

support issues where your phone or your
laptop or your desktop computer just

freeze all of a sudden, or maybe it
spontaneously reboots for no reason.

Odds are that's because not you, but
some other human made a mistake.

They probably wrote code working at
Microsoft or Apple or Google or

else, and they didn't actually
anticipate that, oh, there could be a

scenario that could happen in the real
world. world, but if there's no code

tells the computer what to do in that
fourth and final scenario, who knows

the computer is going to do. It might,
by default, reboot.

It might, by default, freeze.

That's just a hint of the bugs, the
mistakes in software to come.

But even though this is just one way to
write this code, a .k .a.

pseudocode, there are some salient
characteristics that we'll use

today. One, there are these verbs, these
actions. And henceforth, as aspiring

computer scientists or programmers,
we're going to start to call these by

more technical audience would. These are
functions.

A function is an action or a verb.

It's like a bite -sized task that a
computer can do for you. Those, then,

functions in this here pseudocode. But
there's other types of code in here.

There are these things here.

else if, else if, else, those are
examples of what we're going to start

conditional. These are sort of
proverbial forks in the road where maybe

this way, maybe you go this way, but you
decide which way to go based on a

question. The questions that you ask are
what we'll technically call Boolean

expressions, named after mathematician
Boole. A Boolean expression is a

with a yes or no answer, a true or false
answer, a black or white answer, a one

or zero answer. There's two
possibilities, and there's a hint of the

underneath. A Boolean expression is
going to tell you yes or no, you should

down that fork in the road.

Notice what's important here is that
indentation mattered as a result.

Notice that on line four, when I first
asked if the person is on page question

mark, so to speak, I should only do line
five per its indentation if the answer

is yes or true.

I should only open to the middle of the
left half of the book and go back to

line three if.

Person is instead earlier in the book.
So indentation in pseudocode and in many

programming languages has a logical
significance.

It tells you whether to do things or
not.

But there's another construct in here,
go back to, go back to, which literally

makes me go back to line three,
potentially again and again and again,

some kind of cycle or what we'll
typically call a loop instead.

So even in this relatively simple real
-world algorithm, we have these four

fundamental characteristics of most
computer programs that we will write in

class and you might write beyond this
class, that we have some technical

now to describe them. But what's
important to note is that line 8 and

11, even though they're saying go back
to line 3, go back to line 3, you might

think you're running the risk of what
we'll call an infinite loop, where you

literally get stuck in a loop forever,
which doesn't sound like a good thing if

at some point you want to turn your
computer off, even though it's still

working. But these will not induce
infinite loops. Why? What is happening

this particular algorithm every time we
go back to line 3 that guarantees

eventually we will stop going back to
line 3?

Exactly. If the person is on the page,
we will call them or we will quit. But

more importantly, because we keep
dividing and conquering the problem, in

case, having the phone book, having the
phone book, eventually, we're going to

run out of phone book, in which case,
indeed, John Harvard is either on that

page or not, and we will call or we will
quit instead.

So we'll see in time. And in fact, allow
me to promise, odds are at some point,

you will write code that seems to take
control of the computer for you, where

it's doing something, doing something,
doing something, and it literally won't.

respond to you anymore, that's just
going to be because of a mistake, a so

-called bug that you yourself will
invariably have added to your code

accidentally, but will show you ways for
terminating it or breaking out of those

conditions. And indeed, what we'll do in
just a little bit after a break for

today's lecture is explore not just
these concepts, but some of the ways you

use them to solve real and very visual
and audio problems.

But for now, let's at least connect it
to something that's been all too germane

in recent months, the past few years.

namely artificial intelligence, which is
a topic we'll come back to at the end

of the course, too, to give you a sense
of what the connection is with what

everyone's been talking about in the
world of AI and what it is we're going

spend the next few weeks building up to
by writing code.

If you were to try to implement
something like a chat bot, for instance,

just answers questions and has a
conversation with you, you could do that

pseudocode. And as we'll soon see, you
can use C, Python, any number of other

languages, too.

That pseudocode might look like this.

implementing a chatbot. You could tell
the chatbot, if the student says hello

you, then say hello back.

And the indentation, as per earlier,
implies this is conditional.

Else, if the student says goodbye to
you, say goodbye to the student. Else,

the student asks you how you are, say
you are well. So you can just enumerate

question after question after question
and just handle all of these conditional

possibilities. But things kind of
escalate quickly, especially with the

today, like ChatGPT.

Are we really going to have the
wherewithal as programmers to write

conditional, like else if the student
asked why 1, 1, 1 in binary, 7 in

This kind of hints at, oh my god,
there's an infinite number of things

human could ask the chatbot. Do we
really have to write an infinite number

conditionals?

not possible. There's not enough time in
the day. There's not enough lines of

code available.

Artificial intelligence surely needs to
be able to figure some of this out

instead. And so indeed, this is not how
you implement AI. But rather, how you

implement an AI like a chatbot is you
typically train it based on lots and

of data. You give it lots of inputs,
lots of inputs, training data, and let

figure out what it should say in
response to certain questions. And it

down to a lot of probability, a lot of
statistics, otherwise known now as large

language models, which, if we really
peek under the hood, are actually

implemented with what are called neural
networks, inspired by the world of

biology, whereby we humans have all of
these neurons that transmit electrical

signals such that my brain tells my hand
to move this way, this way, and this

other way. And so what computer
scientists have been doing over the past

years is implementing in software using
literally zeros and ones, graphs or

networks, neural networks that look a
little something like this, where each

the circles represents a neuron, each of
the arrows represents a pathway between

them, and provides as input to these
networks huge amounts of data, like all

the internet, all of Wikipedia, all of
the books that it might consume as

And then the goal of this neural
network, as per this single final neuron

here, is to produce an answer to a
question. Maybe it's simple, like yes,

Or maybe it's something like the answer
to the 111 question, or how are you, or

goodbye, or hello, or the like.

And what these neural networks do is use
statistics and probability and try to

output the most probabilistically likely
answer to this question that's been

asked and really just hope.

that it is correct.

There is no programmer at OpenAI or
Google or Microsoft that's trying to

anticipate every one of these questions
we might ask, not only in English, but

in other languages as well.

So you might be wondering why there's
this eight -foot duck on the stage. So

persona that CS50's own AI takes is, in
fact, that of a rubber duck. Because it

turns out, in programming circles, and
this is true long before CS50, it has

often been recommended to students and
aspiring programmers that you keep

literally a physical rubber duck on your
desk. The idea being, in the absence of

a friend, family member, colleague, TA
who could answer technical questions for

you, if you're alone in your room and
mather at night, you can sort of talk to

the duck. maybe door closed, and ask the
duck your questions, or more

importantly, talk the duck through what
confusion you're having. And the mere

act of talking through the problem,
explaining logically what you're trying

do, what you're actually doing, and what
the error actually is, invariably that

sort of proverbial light bulb goes off
and you realize, oh, I'm an idiot.

I hear in my own words where I've gone
awry. And even though this duck will

never say anything back to you, that
alone, rubber duck debugging, or rubber

duck tends to be a valuable programming
technique, believe it or not.

But thanks to these large language
models, we have not only physical but

ducks as well. And so available to you
will be, in this class, not tools like

ChatGPT and the like, which are, through
policy, disallowed. It is not

reasonable to use ChatGPT and the like.
But you are allowed and encouraged to

use CS50's own AI -based tools, which
resemble those same tools but know

something about CS50 and aspire to
behave akin to a good team. teaching

guiding you to solutions as opposed to
handing you something outright.

So this is a tool that will be available
at literally this URL throughout the

course, cs50 .ai.

It will also be embedded in the
programming environment you'll soon

is called Visual Studio Code, a cloud
-based version thereof. The duck will

in that environment as well, as well as
on stage from time to time, which is to

say we'll not only talk about but use
throughout the course this thing known

AI.

But this is ultimately code that we're
going to start writing next week. And

unfortunately, this code here is written
in a language called C.

This is essentially the program that I
lost two points on, like some 25 plus

years ago.

And it does look admittedly cryptic. And
that's why today what we'll focus on is

not what this code looks like, nor the
zeros and ones that that code gets

converted to so your computer can
understand as input what you want it to

We're going to focus on a much more
visual incarnation of this. But I know

far this has been a lot. So let's go
ahead and take a five minute break here.

And when we come back in five, we'll do
some actual programming.

So see you in five.

All right.

So it's now time to solve with actual
code.

some actual problems, albeit in a fun
and visual and audio way. But recall

where we left off was this.

Starting next week, you'll be writing
code that ultimately looks like this.

thankfully, you will not be writing
zeros and ones. And no normal person,

included, can understand what all of
these zeros and ones are at a glance.

We could take out some paper pencil and
probably figure it out very tediously.

But this is exactly the point.

Computers only understand this stuff.
But what we as programmers will start

writing today and beyond is code at a
higher level.

And indeed, this is going to be frequent
within computer science, where there's

different levels of abstraction that we
operate at. And the lowest level, the

nittiest gritty, is the zeros and ones
the computer understands.

That's it in this class for zeros and
ones. Hopefully, you at least have

your mind around why zeros and ones can
be used in triples and in bytes to

represent higher and higher numbers.

But let's just now agree that computers
can do that. let's abstract away from

that detail and focus on higher level
languages than zeros and ones, namely a

language like this. So this is an
example of the very first programming

I learned back in the day as per that
homework in a language called C.

It's an older language, but it remains
one of the most popular languages and

omnipresent languages nowadays because
it's incredibly fast, and it's

particularly good at making devices
operate quickly.

For us pedagogically, the value of C is
not that you're probably in Silicon

Valley and other such jobs going to be
using C yourself that much, but because

it's going to provide a conceptual
foundation on top of which we introduce

languages like Python, which is newer
and improved, so to speak, that gives

more and more functionality sort of for
free out of the box by abstracting away

some of the stuff we'll focus on in the
coming days first. So at the end of the

day, you should better understand
languages like Python. and JavaScript

because of your underlying understanding
of a language like C.

But this is too much for the first day.
Many of you will think that this is too

much for the second week. But in fact, C
is really only sort of scary looking

because all this darn punctuation in
syntax, the semicolon, the parentheses,

double quotes, the curly braces, and the
like. And I concur.

This is intellectually uninteresting.
And a lot of the challenges early on

learning programming is you just don't
have the muscle memory like that I or

some of the teaching fellows might, for
knowing what symbols should be where.

But that's going to come with time and
practice. I guarantee it. What we'll do

for today, though, is just throw away
all of that intellectually uninteresting

detail and focus really on ideas.

And some of you might be in your comfort
zone here, because if back in middle

school you were playing with a
programming language called Scratch, you

probably using it at the time just to
have fun in class or out of class,

games, animations, interactive art, what
you probably probably didn't use it

for, at least in middle school, was to
consider and explore programming

languages themselves.

But what's wonderful about Scratch,
which is this graphical programming

from down the street at MIT where it was
invented some years ago, is you can

program not by using your keyboard, per
se, but by dragging and dropping puzzle

pieces, otherwise known as blocks, that
will snap together if it makes logical

sense to do so. And what you won't have
to deal with is parentheses and double

quotes and semicolons and all of that.

at least until next week. But the nice
thing about Scratch is that after this

week and after the so -called problems
at zero, the first assignment in which

you'll use Scratch, you'll have a mental
model via which it will be easier to

pick up all of the subsequent syntax as
well.

So let's see how we can start
programming in Scratch by making the

programs first.

You can do this.

at scratch .mit .edu.

You needn't do this now in the moment.
Problems at zero will walk you through

all of these steps.

But what I've done here is opened up at
scratch .mit .edu, precisely the default

web page therein. This is after having
clicked the Create button in Scratch,

which is going to allow me to create my
first program. But first, a tour of the

user interface here and what is
ultimately available to you. Well,

Scratch environment,

We'll see a few different regions of the
screen. One, we have this palette of

puzzle pieces at left.

The blue ones relate to motion.

The purple ones relate to looks. The
pink ones relate to sound and so forth.

the color of the block just roughly
categorizes what that block's purpose in

life is.

We're going to be able to use those
puzzle pieces by dragging and dropping

from left to right.

In the right here, in the middle of the
screen, is where I'm going to write my

actual programs. This is where I'll drag
and drop these puzzle pieces, lock them

together, and actually write them. write
my code.

What am I going to be coding? Well, I'm
going to be controlling one or more

sprites. Much like in the world of
games, if familiar, a sprite is like a

character that you might see on the
screen.

The default character in the world of
Scratch is, in fact, a cat that looks

this. And if, in this case, I have just
one cat, I can then make that cat do

things in his own little world at top
right by making the cat move up, down,

left, right, spinning around, or doing
other things as well. But if you want to

introduce a dog or a bird or any number
of other custom characters, You just add

more sprites, and they get their own
place in that same world.

As for how to think about movement in
this world, it's actually pretty

even though it gets a little numeric for
a moment. If scratch at the moment is

in the middle of the screen, the cat is
at 0 comma 0. If you think about xy

coordinates or latitude longitude, if
you move the cat all the way up, this

would still be x equals 0. But it would
be y 180.

What's the 180?

180 pixels vertically, or dots on the
screen. This is negative 180 pixels. on

the screen at the bottom. By contrast,
if you go left and right, your x value

might change, negative 240, but y is 0,
or positive 240, and y is 0 as well. But

most of the time, you won't need to know
or care about what the pixel

coordinates of the cat are.

All you're generally going to care
about, as the programmer most likely, is

you want the cat to go relatively up,
down, left, or right, and let MIT figure

out the mathematics of moving this thing
around in most cases.

All right, so let's go ahead and
introduce the first of these programs by

something quite simple, as we did in C
there, but a little more simply by

writing code as follows.

I'm going to go back to scratch .mit
.edu.

I've already clicked per before the
Create button.

And if I click on the yellow category of
blocks here at left, and I'll zoom in,

we'll see a whole bunch of yellow puzzle
pieces. And probably the most common

one you will use to write code in
Scratch for just this first week is

when green flag clicked.

Why? Well, if we go back over to the
cat's world at top right, notice that

the cat's rectangular world, there's not
only a green flag for starting, there's

a red stop sign.

for stopping as well. So let's do this.
Let me go ahead and click and drag when

green flag clicked anywhere into the
middle and let go.

And now I'm going to go to look.

And it looks like there's a whole bunch
of purple puzzle pieces here. I'm going

to choose something simple like say
hello, drag it. And notice if I get just

close enough, it's going to want to
magnetically snap together. So I'll just

that. And it does its thing. The fact
that there's this white oval with text

means that is an input to this say
puzzle piece.

I can literally then change what the
input is if I want to more

say hello comma world, which in fact,
according to Lore, was the very first

program written in C. And nowadays, in
most every language, including in Brian

Kernaghan's book, so hello world is
generally the first program that most

programmer first writes.

So that's it. As programs go, let me go
ahead and zoom out here. Let me go over

to the right and click the green flag.
And somewhat excitingly, maybe

underwhelmingly, We've now written a
program that quite simply says, hello

world, on the screen.

Now let's make this a little more
technical for just a moment. What is

here, puzzle piece, as I keep calling
it?

It's actually a similar, it's an
incarnation of one of the ideas from our

pseudocode before.

What did we call those actions and verbs
last time in my pseudocode?

Functions, that's right.

So these purple puzzle pieces here are
indeed functions. And some functions, as

we can see, take inputs, like hello
comma world. After all, how does Scratch

know what to say? You have to provide
the cat with input, which is to say

functions can indeed take inputs like
this. In this case, one input, but we'll

see opportunities for passing in more
input as well.

What the cat is doing, though, visually
on the screen here at top right is

what's generally called a side effect.

Sometimes when you call a function, it
does something visually.

And in this case, you're seeing
literally a cartoon speech bubble, hello

That is the side effect of this
function.

So if we now want to map this to our
world of inputs and outputs and see

this side effect is, this is the
paradigm I proposed at the start of

is computer science in a nutshell and
will be the framework we use literally

throughout the class, no matter how...

no matter how the languages in
particular evolve.

So what's the input to this particular
program?

Well, this white oval, hello world is my
input. The algorithm, step -by -step

instructions for solving some problem,
is implemented in code, this language

called Scratch, by way of this purple
puzzle piece. And the output...

of that function, given this input, is
the side effect whereby the cat indeed

says hello world visually on the screen
in that speech bubble. So the exact same

paradigm with which we began today
governs how exactly this cat here works.

Well, let's actually go back to this
program and make it a little more

interesting than that.

Let me go ahead and click the red stop
sign.

And let me actually use a different type
of puzzle piece, another function that

does something a little different.

First, I'm going to get rid of the say
block.

So I'm going to not only pull it away,
I'm going to drag it over anywhere it

left and just let go, and it will delete
itself.

automatically, or I could right click or
control click. And from a little menu,

I could also explicitly say delete.

And what I'm going to do now is under
sensing, which is a light blue shade of

puzzle piece. There's a whole bunch
here, but I'm going to focus on this

Ask something and wait.

And the default text is, what's your
name? And that's fine. But because it's

white oval, that input can be manually
changed by me if I wanted to change the

question. I'm going to drag it over
here. It's going to magnetically snap

together. And I'm OK with that question.
But what do I want to say with the

answer? Well, let's go ahead and do
this. I could go to looks again.

I could grab another say block, let it
snap in. And I could say something like,

hello, David.

But this is going to be the first of
many bugs that I make, intentionally or

otherwise. Let me click the green flag.

Scratch is now, just like in a web
browser, prompting me for some input

let me go ahead and type in my name,
David.

Enter. And voila, like it worked.

Hello, David.

I'm kind of cheating though, right?
Because if I zoom out, stop, and play

let me type in like Yulia's name here.

Enter. And it still says hello comma
David.

So that didn't really implement the idea
that I wanted. All right, so how can I

fix this? Well, it seems that this time
I want more than a side effect.

I want to use the value that the human
types in. And for this, we need another

feature of functions, which is that not
only can they sometimes have Side

effect, something visually happens.

Some functions can hand you back a
value, a so -called return value, that

allow you to actually reuse whatever the
human typed in. So a return value is

something that gets virtually handed
back to you. And you can store it in

something called a variable, like x, y,
and z in mathematics.

And you can generally reuse it.

one or more times.

So let me actually draw our attention
then to, at left, not only the blue

piece, ask what's your name and wait,
but notice that there's a special puzzle

piece below it, this blue oval called
answer.

And that represents what a computer
scientist would call a return value.

So MIT has kind of bundled it together
side by side to make clear that one of

those pieces relates to the other.

What it means is that I can do this.

I can drag this oval and use this oval
as the input to the Now, notice it's not

the same size, but it is the right
shape. So that's OK.

Scratch will sort of grow or shrink
things to fit properly.

But this too isn't quite right.

Let me go ahead and do this.

Let me go ahead and stop that, click the
green flag. I'll type in my name again,

D -A -V -I -D, Enter.

And it's just kind of weird or rude.

I wanted a hello, at least, and it just
said David on the screen. OK, so I can

fix that. Let me stop with the red stop
sign.

Let me just separate these temporarily.

And I can leave it in the middle there,
but they have no logical connection

temporarily. Let me go back up to look.

Let me grab a say block, a second one.

And let me go ahead and say, just to be
grammatical, like hello, comma, space.

And then I'll reconnect this here.

So at the moment, it looks like what I
want. I want a hello, comma, and then

return value printed out based on
whatever the human typed in. So let me

out. Let me click the green flag.

Again, what's your name? D -A -V -I -D.
And watch the cat side effect enter.

still not greeting me properly.

There's no hello. And if in case it was
too fast, let's do it again.

Green flag, D -A -V -I -D, enter. It
just, it rudely just says my name, which

weird. What's the bug here though? It's
a little more subtle.

Why? Yeah.

Yeah, it's just too quickly going over
the say command or the say function in

this case. My Mac, your PC, your phone,
it's just so darn fast.

Both are happening, but too fast for my
human eyes to even notice. So we can

solve this in a number of ways.

I could actually use a different puzzle
piece altogether.

In fact, MIT kind of anticipated this.
Notice the first puzzle piece in purple

is say hello for a specific number of
seconds.

And you can specify not just the
message, but the number of seconds, ergo

inputs, otherwise now known as arguments
to a function, an input. to a function

is just an argument now.

And that would be a fix here. I could
maybe a little more explicitly do this.

could go under Events, scroll down a
little bit. And sorry, under Control in

orange, I could grab a weight block.

And I could kind of insert it in the
middle. And this might actually help. So

could click on the green flag, D -A -V
-I -D, Enter.

Hello.

And I can change the timing to be a
little more natural. But what if I want

cat to just say, hello, comma, David,
all in one breath, so to speak?

Well, for that, I'm going to need to use
a slightly different technique as

follows. Let me go ahead and get rid of
the wait. Let me get rid of the second

say block and stop the cat with the stop
sign.

Let me go under operators here.

And let me somewhat cleverly grab this,
a join block at the bottom. By default,

it's using apple and banana as
placeholders, but those are white ovals,

change those. Let me drag this over the
white oval for the save function and let

go, and it will snap to fill.

Let me go ahead here and type hello
comma space instead of apple.

And what should I do instead of banana?

Yeah, so the answer return value.

So let me go under sensing again.

Let me just drag another copy of it. And
you can use these again and again and

again. They don't disappear.

I want to drag answer over banana so
that the second input to join is

if you will, the output of the ask
block.

Like that.

And it snaps to fit.

So now, if I go ahead and click the
green flag once more, D -A -V -I -D,

now we have the sort of behavior
aesthetically that I cared about.

But beyond the aesthetics of this, the
goal here really was to map it to,

the same paradigm, which we'll see here.

The algorithm and the output and the
input for this example are as follows.

input to the say block was quote
unquote, what's your name?

The function, of course, implementing
that algorithm in code was the ask and

wait block.

The output, though, of the ask block,
recall, is not some visual side effect.

is a return value called answer, like a
variable, a special variable like x, y,

and z in math. But in this one, we
generally, in programming, describe

with actual words, not just letters.

But this output of the say block, I kind
of want to make room for it to pass it

into the say block as a second argument.
So let's do this. Let's take one step

back and propose that now for the join
block, that I just used, it takes two

inputs, hello comma space and answer.

The function in question is indeed the
join block.

The output of this had better be hello
comma David. What do I want to do with

the output of the join block?

Well, let me clear the screen.

Let me move this over, because now the
output of the join block is going to

instantly become the input to the save
block so that the output now in this

multi -step process is the side effect
of hello David.

So the fact that I nested these blocks
on top of one another was very much

deliberate. If I zoom in here, notice
that hello and answer are on top of

Join is on top of the say block. And if
you think back to high school math, this

is like when you had parentheses and you
had to do the things inside parentheses

before the things outside parentheses.
It's the same idea, but I'm just

stacking them instead.

But output can become input depending on
what the function there expects.

Let me pause here and see if there's any
questions about, not so much like what

the cat is doing, but how the cat is
doing this.

Questions at hand.

All right, well let's...

Let's make the cat more cat -like and do
this. Let me throw away all the say

block and just let go there.

And let me introduce at bottom left a
nice feature of Scratch whereby there's

also these extensions that tend to use
the cloud, the internet, to give you

more functionality.

And in fact, I'm going to click on this
extension up here, text to speech.

And if I click on that, I suddenly get a
whole new category of blocks at the

bottom, text to speech.

They happen to be green.

But what's nice here is that I can
actually now have the cat say something

audibly.

a speak block here instead of the say
block.

I don't want it to just say hello.

Let me stop that.

So let me go back under Operators. Let
me grab another join block, because I

threw the other one away.

Let me change apple to hello comma space
again.

Let me go to Sensing. Let me drag answer
to banana again.

And now let me hit the green flag.

And let me type in my name, D -A -V -I
-D.

And in a moment, I'll hit Enter. And
hello, David.

All right, it's not exactly cat -like,
but it was synthesized. But it turns out

under these text -to -speech blocks,
there's some others.

Set voice to Alto, for instance, seems
to be the default. But let's change

So notice that some puzzle pieces don't
just take white ovals. They might even

have dropdowns. So whoever created that
puzzle piece decided in advance what the

available choices are for that input per
the dropdown.

So I'm going to change it to squeak, or
actually kitten. Sounds even more apt.

Let me zoom out.

Click the green flag.

Type my name, D -A -V -I -D. Enter.

Meow, meow.

That's interesting. So it doesn't seem
to matter what I type. So how about

Malin? Meow, meow, meow.

So it seems to meow proportional to how
long the phrase is that I typed in. It

can get a little creepy quickly. Like if
I change kitten to giant, let me go

ahead and hit play. D -A -V -I -D.

Enter.

Hello, David.

So you can sort of...

for very non -academic ways, start to
have fun with this, but just playing

around with these various inputs and
outputs. But let's actually make the cat

something more cat -like and indeed meow
instead of saying any words at all. So

let me throw all of that away.

Let me go now under sound.

Let me drag the play sound until done.

And notice in the dropdown here, by
default, you just get the cat sound.

You can record your own sounds. There's
a whole library of dogs and birds and

all sorts of sounds you can import into
the program.

I'll keep it simple with cat.

And let me click the green flag.

All right. So the cat meowed once. If I
want the cat to meow again, I could do

this.

If I want the cat to meow a third time,
I could again hit play.

So this is kind of tedious. If to play
this game, I have to keep clicking the

button, keep clicking the button to keep
the cat alive virtually in this way. So

maybe I want this to happen again and
again and again.

Well, let me just do that. Let me sort
of drag and drop.

Or I could right click or Control click,
and then a little menu would let me

copy paste or duplicate blocks.

But I'll just keep dragging and
dropping.

Let's do this.

Cat's kind of hungry, unhappy.

So let's slow things down so it's
adorable again. So let me go under

Let me grab one of those wait one
second, and I'll plop this here.

Another one, let me plop it here.

Click Play again.

Cuter. Less hungry? Sure.

But this program is now, I dare say,
correct, if my goal is to get the cat to

meow three times.

But now, even if you've never programmed
before, critique this program.

It is not well -designed, even though it
is correct.

In other words, it could be better.

How, might you think?

Yeah.

So using a loop. And why? Why are you
encouraging me to use a loop, even

it works as is?

Yeah, so to summarize, it's just easier
to use a loop because I could specify

explicitly in one place how many times I
wanted to loop. And moreover, frankly,

any time you are copying and pasting
something in code or dragging the same

thing again and again, odds are you're
doing something foolish. Why?

Because you're repeating yourself
unnecessarily. And this is a bit

suppose I want to change this program
later so that the cat pauses two seconds

in between mouths. Well, obviously, I
can just go in here and do two.

But what if I forget?

And suppose this program isn't like five
or six puzzle pieces. Suppose it's 50

or 60 or 500 or 600.

Eventually, I or a colleague I'm working
with is going to screw up. They're

going to change a value in one place,
forget to change it in another. So why

you inviting the probability of making a
mistake?

Just simplify things so that you only
have to change inputs in one place.

So how can I do this? Let me zoom out.
Let me throw most of this duplication

away, leaving me with just the play and
the wait function.

Let me now, under Control as well, Grab
one of these. I could, for instance,

repeat as follows.

Let me grab a repeat.

I'm going to have to kind of move these
in two parts. So I'm going to move this

down. It's too small, but it will grow
to fit the right shape.

Then let me reattach it up here.

Let me change the default 10 to a 3.

And now I think I've done exactly what
you were encouraging, which is simplify.

And I click Play Now.

Meow. And?

Yeah, so still correct, but arguably
better designed as a result. I can keep

things simple and change things now in
just one place, and it will continue to

work. But this is getting a little
tedious now, I claim.

Why am I re -implementing the idea of
meowing?

Wouldn't MIT have been better to have
just implemented a meow puzzle piece for

us? Because the whole thing is themed
around a cat. Why is there not a meow

puzzle piece?

Why do I need to go through all of this
complexity to build that functionality?

Well, what's nice about Scratch is And
what's nice about programming languages

in general is you can generally invent
your own puzzle pieces, your own

function, and then use and reuse them.

So let me go ahead and do this. I'm
going to go under my block.

in pink down here.

I'm going to go ahead and click Make a
Block.

And I'm going to be prompted with this
interface here. And I'm going to call

this block literally Meow, because
apparently MIT forgot to implement it

And I'm just going to go ahead and
immediately click OK.

And what you'll see now is two things.
One, on the screen, I've been given this

placeholder pink piece that says Define
Meow.

as follows.

So anything I attach to the bottom of
that define block is going to define the

meaning of meowing.

And at top left, notice what I have
under my blocks. I now have a pink

piece called meow that is a new function
that will do whatever that other block

of code tells the cat to do.

So what do I want to do here? Well, I'm
going to keep it simple for now.

I'm going to move the play sound meow
until done and wait two seconds. So

change it back to one second to move
things along.

And now let me drag the meow puzzle
piece over to my loop such that now

it going to do? It's going to meow three
times. And just to be...

dramatic, out of sight, out of mind. Let
me, for no technical reason, just drag

this all the way to the bottom of the
screen and then scroll back up just to

make the point visually that now meowing
exists.

That is an implementation detail that we
can abstract away, not caring how it

exists, because I now know at a higher
conceptual level, if I want to meow, I

just use the meow puzzle piece. And I or
someone else dealt with already how to

implement meowing.

So now let me go ahead and hit play.

OK, so same exact code, but arguably
better design, because I've now given

myself reusable code. So I don't have to
copy -paste those several blocks. I can

just use meow again and again.

But let's make one refinement. Let me
actually scroll down to where I did, in

fact, implement this. Let me Control
-click or right -click on it. And let me

edit the pink block that I created a
moment ago, because I want to practice

I've been preaching about input.

So I don't want this function just to be
called meow.

I want this function to also take an
input.

And just for consistency with our use of
n earlier, which in computer science

generally means number, let me meow.

n times. And just so that this puzzle
piece is even more programmer friendly,

let me add just a textual label that has
no technical significance other than to

make this function sort of read left to
right in a more English friendly way.

Meow n times.

Let me click OK.

And now notice this thing at the bottom
has changed such that it's not only

called meow, there's explicit mention of
n, which is a circle, which is exactly

the variable shape that we saw earlier.

when it was called answer.

This is not a return value, though.

This is what, again, we're going to call
an argument, an input two -way

function. So let me do that.

I'm going to move this back up to the
top so I can see everything in one

And I'm going to make one modification,
because my goal now is to make a new and

improved version of meowing that
actually takes into account how many

want the cat to meow.

So instead of using a loop in my own
program under when green flag clicked,

going to detach this temporarily.

I'm going to move this away.

I'm going to move this code over here.

And I'm going to reattach it here.

So focusing for the moment on just the
left, meow is now defined as repeating

three times the following two functions,
play sound and wait. But that's not

quite right. I want to get rid of the
three.

So what can I do?

Because I created this input to the meow
function myself a moment ago, I can

actually drag a copy of it overwrite,
that is, change the 3 to be generally an

n. So now I have a function called meow
that will meow any number of times.

And what's nice now is my actual program
that is governed by that green flag, I

can type in 3, I can type in 10, I can
type in 100, and it will just work. And

henceforth, I can again dramatically
sort of scroll this down so we don't

or care about it anymore. Now my program
is a single line whereby this notion of

meowing has been abstracted away by just
defining my own function or custom

block.

Questions then about just this idea,
this principle of creating your own

functions to kind of hide implementation
details.

Once you've solved the problem,
therefore, you don't want to have to

that same problem ever again.

And that's the beauty of programming
typically.

Questions on what here?

We just did.

All right. Well, let's do this.

Let's now make this a little more
interactive in code. Let me go to this

flag. Let me scroll down and just throw
all of this hard work away that we have

copies on the course's website of all of
these programs step by step if you want

to review them in slower detail.

Let's do this. Under control, turns out
there's other ways to loop. There's this

forever block that will just do
something forever.

So in the forever block, there's some
place for some other code. And I'm going

to move to the control section here and
grab one of these, if.

So one of these conditionals. Let's plug
that in here.

And now notice if, and then there's this
sort of trapezoid -like placeholder

that's going to probably fit what?

The if is a conditional.

Forever is a loop.

Say and so forth have been functions.

What was the other key term we used?

So a Boolean expression.

We need to put one of those yes, no, or
true, false questions here. So what are

those? Well, I've been using Scratch for
some years, so I know under sensing

there's one of these shapes here.

Touching mouse pointer question mark.
The question mark literally evokes the

whole idea of a Boolean expression being
yes, no. It's way too big to fit, but

it is the right shape. So let me drag
it, let go.

It's going to grow to fill.

And now let me go to sound. Let me grab
that play sound meow until done and put

it inside that conditional such that
what kind of program have I just

implemented here, arguably?

What will this program do when I click
the green flag?

Well, nothing at the moment.

But I'm not touching the cat. So if I
move the mouse pointer to the cat,

again,

Kind of like implementing the idea of
petting a cat, if you will, because I'm

forever just waiting and waiting and
waiting.

Is the mouse pointer touching that
sprite, touching that cat? And only if

ahead and play that sound meow until
done.

But now we can make things a little more
interesting. Let me stop this, and let

me do something actually completely
different. Let me throw all this hard

away. Let me go under extensions.

Let me go to video sensing, because lots
of laptops, my own included, has a

little webcam nowadays.

Let me approve use of that. And you can
see me in the frame. And let me do this.

Let me drag one of these when motion
exceeds some measure. And for the trial

error, I figured out that 50 tends to
work well. Let me step out of frame here

and program off to the side.

And if I go to play sound meow until
done, Notice that this is an alternative

using when green flag clicked.

This is a category of block that's
constantly waiting for what we'll call

event. An event is just something that
can happen on the screen, a click, a

drag, a mouse movement, and so forth. So
let me zoom out here.

And now, if I can do this, here we go.

No, too slow.

Still too slow.

Oh, wait, did I click play? Let's see.

Try again.

There we go.

OK, 50 is a little too high, apparently.
So let's make this a little gentler.

10. OK, well, there we go.

There we go.

OK, so we've implemented now more
physically the idea of actually

petting a cat.

So, oh, damn it.

OK.

OK, so this is a bug. Like, now.

That might fall.

So it's not stopping in response to the
red stop sign. So what do you do in

doubt? Most extremely reboot. For now,
I'm just going to close the window.

OK, so now we've seen all of those
primitives that we saw in that

but incarnated in this graphical
programming language. And again, without

parentheses and semicolons and double
quotes and all the punctuation that we

will introduce before long. But for now,
we have the mechanisms in place where

we can do some really interesting
things.

So in fact, I thought, in the spirit of
sort of thinking back on olden times,

thought I'd open up the very first
program I wrote when I actually took, I

cross -registered in an MIT class and
took a class that introduced but

teachers to scratch. And I implemented
this program here called Oscar Time,

which was a game that used a childhood
song that I was a fan of. And it allows

you to sort of drag trash into a trash
can.

But to bring this to life, and perhaps
in exchange for one stress ball, could

get one brave volunteer who wants to
come up and control this here keyboard.

saw your hand first. Come on up.

Come on up.

And you'll see, thanks to the team, we
also have this amazing lamppost here

being on Quincy Street as we are. Do you
want to introduce yourself to the

group? Hi, my name is Anna.

I'm from Richmond, Virginia, and I'm in
Weld.

Nice, Weld. All right, come on over.

So here, Andy, you'll have a chance to
play the very first game I wrote in

Scratch, which admittedly is more
complicated typically than we would

a student doing this for the very first
time, as in problem set zero.

But what I'm going to do is full screen
this year.

I'm going to click the green flag. And
what you'll see on the screen are these

instructions. Drag as much falling trash
as you can to Oscar's trash can before

his song ends. And here we go.

Oh, I love.

Anything 30 or 50 or 60.

Anything racket or rotten or rusty. Yes,
I love.

Oh, there we go.

Nice. So as Anna continues to play,
let's kind of tease this apart a little

So one, there's some costumes on the
stage. Like that lamppost is actually

going to move. But there's a couple of
sprites.

There's the trash can, which seems to be
a character unto itself.

There's this piece of trash that keeps
coming back and back. That is a sprite.

There's now this sneaker, which is
another sprite.

And in fact, notice that Oscar, of
course, keeps popping up from his sprite

in a while. So Oscar seems to have
multiple costumes.

So I offer this as an example is you
keep playing, if you would. Very good

so far.

This song goes on forever. This was a
nightmare to implement, to listen to

all day long.

But how do we implement the rest of
this? Well, notice that the trash, every

time she throws it into the trash can,
does reappear somewhere different. So

there's some kind of randomness
involved.

And indeed, Scratch will let you pick
random numbers in a range. So maybe it

could be negative 240.

Maybe it could be positive 240 at the
180 point on the top of the screen. So

can sort of randomly put things on the
screen.

There's apparently what kind of
construct that makes the trash fall

again. I think no one's listening to me.
They're all just watching you. But

what's making the trash fall from top to
bottom?

So it's actually some kind of loop,
because there's a motion block inside of

forever loop, probably, that just keeps
moving the trash one pixel, one pixel,

one pixel, one pixel, one pixel,
creating the illusion, therefore, of

And if we can crank the song a little
bit more, you'll see that this is all

synchronized now.

Because they're trash.

Oh, I love trash.

Anything dirty or stingy or sassy.

The song keeps going forever, seemingly.

And now notice more and more sprites are
appearing because they waited for...

Here we go, climax.

All

right,

a big round of applause for Hannah.

Nicely done.

There you go, there you go.

All right. So this is an interminable
song.

And indeed, I spent hours building that.
And just listening to that song on loop

was not the best way to program.

But the goal here is to really use it as
just an intellectual exercise as to how

that was implemented.

And we won't do the entire thing in
detail, because I will say back in the

when I was younger, I didn't necessarily
write the cleanest code.

And in fact, if we see inside this and
we poke around the bottom of the screen

here, you can see all of my different
sprites.

And the code is kind of complex.

Things just kind of escalated quickly.

But I did not set out and write all of
these programs all at once for each

sprite. I pretty much took baby steps,
so to speak. And so for instance, let me

open up just a few sample building
blocks here that speak to this, that are

written in advance.

So here's version 0. Computer scientists
typically start counting at 0. And let

me show you this example here that only
has two sprites on the screen.

We have Oscar the trash can, and we have
the piece of trash.

And now notice, what does Oscar do?

Well, let me go ahead and zoom in on
this script, as it's called. A program

script. When the green flag is clicked,
Oscar switches his costume to Oscar 1.

That's his default costume where the lid
is closed.

Then Oscar does this forever.

If Oscar is touching the mouse pointer,
change the costume to Oscar 2.

Otherwise, change it back to Oscar 1.

So that whole idea of animation where
Oscar's popping in and out is just like

quick costume change based on a loop
inside of which is a conditional waiting

for the cursor, like Anna did, to get
near the trash can.

Meanwhile, if we look at the piece of
trash here, notice that the trash is

actually not doing anything in this
first version because I didn't even

implement falling first. So let me hit
the green flag.

Nothing is happening in this very first
version. But notice, if I click on the

trash and drag, as soon as I'm touching
Oscar, there comes that trash can lid.

And it was just the result of making
this one program respond to that input.

All right, what did I do next?

Well, next, after taking that single
baby step, I added one other feature.

see inside this version one.

Again, Oscar is behaving the exact same
way. But notice this time, the trash is

designed to do the following.

First, I'm telling the program that the
drag mode is draggable. That is, I want

the trash to be movable when the user
clicks on it.

Then I tell the piece of trash to go to
a random x location.

x is a horizontal, so it's going
somewhere between 0 and 240, but all the

the top of the screen, 180.

Then forever, the piece of trash just
changes by negative 1. So it just moves

down and down and down.

And without looking at the second script
yet, let me just hit Play. And notice,

without even doing anything, And
eventually, once there was lots of trash

falling, like Anna was struggling to
keep up with this, it's just moving one

pixel at a time forever until,
thankfully, MIT does stop things

they hit the bottom, lest a six -year
-old get upset that all of a sudden

sprite is gone forever. So there is some
special casing there.

But what else is this trash doing?

Let me zoom in here.

The piece of trash, also when the green
flag is clicked, it's forever asking

this question. If you are touching
Oscar.

Then pick a new random location between
0 and 240 at positive 180 and go back to

the top.

So in other words, as soon as this piece
of trash is dragged over to Oscar like

this and I let go.

It recreates itself at the top. It's
just sort of teleporting to the top, and

thus was born this feature.

And I won't slog through all of the
individual features here, but if we do

one more and see inside this one. So
now, let me go ahead and hit Play.

Notice at the top left of the screen,
there's a score, currently 0.

But now, when I click the trash and let
go, notice that the score is being

incremented by 1.

And this, in fact, is how, Anas, your
score kept going higher and higher and

higher. Every time I noticed, oh, the
trash is touching Oscar, let's not only

teleport, let's also increment a
variable. And we didn't see this before,

I go to this oscar scratch now, you'll
see that it is exactly the same. But if

now go to the trash piece here, And we
go to when green flag clicked, you'll

that I'm initializing a variable in
orange called score to zero.

But if we scroll down to the bottom,
Oscar is also doing another thing in

parallel at the same time. When the
green flag is clicked, Oscar is forever

checking, is the piece of trash touching
Oscar?

If so, change the score by one, and then
go to top, which is another location.

on there, that screen.

So in other words, even though at a
glance something like Oscar time might

very complicated and it did take me
hours, the goal, especially with

zero, is not going to be to bite off all
of that at once, but to take proverbial

baby steps. Implement one tiny feature
so that you feel like you're making

progress. Add another feature, another.

And invariably, you might run out of
time and not get to the best version of

your vision.

But hopefully, it'll be good. Hopefully,
it'll be better. But you'll have these

sort of mental milestones, hoping that
you at least get to that point, because

as you will soon discover everything in
the world of programming, unfortunately,

takes longer than you might expect. That
was true for me 25 years ago, and it's

still true today.

Well, let me introduce one final set of
examples here, this one written by one

of your own predecessors, a former
student.

Let me go ahead and open up three baby
steps, if you will, toward an end of

implementing a game called Ivy's Hardest
Game, whereby it's now more

interactive, quite like Oscar time.

So at top right here, notice, and I'll
zoom in, we have this world that's

initially very simple. Two black lines,
two walls, if you will, and a Harvard

sprite in the middle. But when you click
the green flag, notice, that nothing

happens initially except that the sprite
jumps to the middle.

But I can hit the up key or the down key
or the left key or the right key. But

if I try to go too far, even though it's
not the edge of the world, it's only

touching that there black line, it's
still going to stop as well.

So intuitively, how could you implement
that type of program?

How could you get a sprite, from what
we've seen, to respond to up, down,

right, but actually move when I touch my
arrow keys?

Like what does it mean to move? Yeah.

Exactly. So much like with representing
information, at the end of the day, all

we've got is zeros and ones. When it
comes to algorithms, at the moment, all

have are functions and loops and
conditionals and Boolean expressions and

some more things too.

But there's not all that much we have at
our disposal.

So let me zoom out from this. And let me
actually show you what the Harvard

sprite is doing. It's doing this.

When I go up to the green flag here, the
Harvard sprite is going to 0, 0, so

dead center in the middle. And then it's
forever doing two things, listening for

the key. and feeling for wall, left and
right. Now, those are not puzzle pieces

that come with Scratch. I created my own
custom blocks, my own functions, to

implement those ideas.

Let's not abstract away for now. Let's
actually look at these features. And

indeed, to your instincts at left here,
what does it mean to listen for the

keyboard? Well, if the up arrow key is
pressed, change y by 1. Move up.

If the down arrow key is pressed, change
y by negative 1. If the right arrow key

is pressed, change x by 1. If the left
arrow key is pressed, change x by

negative 1. So take sort of all the
magic out of moving up, down, left,

just quantizing it as plus, minus, this,
and that. It's all numbers indeed at

the end of the day.

But what else is it doing?

Notice that it did indeed bounce off the
wall. So my other custom function,

which I chose feelForWalls to kind of
evoke this idea, it's asking two

questions. If you're touching the left
wall, then change x by 1. So bounce in

the other direction. Else, if you're
touching the right wall, bounce in the

negative 1 direction.

And so what are left wall and right
wall?

I mean, I kind of cheated. I just used
two more sprites. These sprites are

literally nothing except black lines.

But because they exist, I can ask that
question in my conditional saying, are

you touching those other sprites? And I
could have colored them any way I want.

But this is enough, if I zoom in, to
implement this idea of going up, down,

left, and right. and preventing the
sprite from leaving that little world.

All right, so if you'll agree that
there's a way now to implement motion,

down, left, right, let's go ahead and
implement this idea by adding a rival

the mix, like a Yale sprite.

And what the Yale sprite is going to do,
if I click the green flag, is this.

So Harvard, at the moment, is still
going to be movable with the arrow keys

down, left, right.

But Yale, for better or for worse, is
just going to mindlessly bounce back and

forth from left to right forever, it
would seem, the operative word being

forever. So how is that working? Well,
let's look. Here is the Yale sprite at

the bottom.

Let's zoom in on its actual code here.

The Yale sprite starts at 0, 0.

It points in direction 90 degrees, which
means left, right, essentially.

And then it forever does this.

If touching the left wall or touching
the right wall, turn around 180 degrees.

So I don't want the Yale sprite to just
stop by moving it one pixel to bounce

off slightly.

I want it to wrap around and just keep
going and going and going forever.

And that's it. Everything else is the
same.

So one final flourish. Let's add a more
formidable adversary like MIT here,

whereby if I zoom in and hit Play,
notice that if I move the Harvard

MIT comes chasing me now.

Now, how is this actually working? Yale
is just kind of doing its thing,

bouncing back and forth. Now MIT is
really latched on to me.

And it's following me up, down, left,
right. So how is that logic now working?

Well, again, it's probably doing
something forever, because that's why

continually doing it. Let's click on
MIT.

This too is pretty simple, even though
it's a pretty fancy idea.

Initially, the MIT sprite goes to a
random position. But thereafter, it

points toward the Harvard logo outline,
which is just the long name that your

predecessor or former student gave the
name.

for that sprite.

And then it moves one step, one step,
one step.

So suppose this were an actual game.

And in games, things get harder and
harder. The adversary moves faster and

faster. How could we make MIT even
faster by changing just one thing here?

How do we level up?

Change the one to two pixels at a time,
two steps at a time. So let's see that.

Let's go ahead and zoom out. Let's hit
Play.

And now notice that MIT is coming in
much faster this time.

So it wasn't noticeably faster.

Let's do this. Let's move 10 steps at a
time, so 10 steps faster than

originally.

And now notice it's kind of twitching
back and forth in this way. Why?

Well, probably, if we worked out the
math, probably the MIT sprite is

the sprite and it's bouncing off of it.
But then it's realizing, oh, I went too

far. Wait a minute, I'm still touching
it. Let me move down. So you can get

these perverse situations where there is
actually a bug, be it logical or

aesthetical. But in this case, we
probably want to fix that. So 10 is

too fast for this to work particularly
well.

But the final, final flourish here
really is to show you the actual version

game. that one of your predecessors, a
past classmate, actually implemented.

Before thereafter, we will adjourn for
cake in the transept, which is the CS50

tradition. But can we get one more final
volunteer to come on up to play Ivy's

hardest game? I'm seeing your hand most
enthusiastically there. Yeah, come on

down. Very happily.

In just a moment, we will indeed
adjourn, but the goal here now is going

to navigate a maze that's a little more
difficult than the last.

Let's have you first, though, introduce
yourselves to your classmates in front.

Hi, y 'all. I'm Eric. I'm from
Philadelphia, and I'm also from Hollis

One person from Hollis. Nice.

Okay. Welcome.

All right. So, Eric, go ahead and take
the keyboard here. It, too, will be all

about up, down, left, right as soon as
you click the green flag.

And if we can crank the music.

So notice the black walls are a little
more involved than last time, but the

goal is to get to the sprite all the way
at right and just touch it, at which

point you move to the next level. At the
next level, of course, has Yale doing

its thing back and forth.

But you've made it to level three.

But now there's two Yale. So another
sprite is in the mix that's randomly

a little different in terms of
direction.

Three Yale.

Next level, MIT's in.

Nice.

The walls are now gone.

Princeton's in the mix.

Nice.

Two Princetons.

Oh.

Okay, new life.

Okay, another life.

Nice, nice.

Nice.

Second to last level. Three Princeton.

Last level.

Congratulations. All right. This then
was CS50.

Welcome aboard. Cake is now served.