DAVID J MALAN: All right.

This is CS50, Harvard University's introduction

to the intellectual enterprises of computer science

and the art of programming.

And ordinarily we would all be here on campus in this beautiful Sanders

Theater together.

This, of course, is a little bit different this year,

for more than one reason.

But we're here instead in the Loeb Drama Center at Harvard University.

Thanks to our friends in collaboration with the American Repertory Theater,

we have this new space, including even such amenities as a prop shop in back,

where we've been working with an amazingly talented team

over the course of the summer to prepare for this semester and CS50.

And so I daresay we'll have some new and improved demonstrations along the way.

So our thanks to our hosts, the American Repertory Theater.

Now we wanted to evoke memories, at least,

or some imagery of the campus itself, particularly

for the many of you who could not be here in person this semester.

And so we went into the Harvard Archives, where among their collections

was this watercolor painting, painted by a Harvard graduate student

over 200 years ago in the year 1794.

Jonathan Fisher, who sat in what is now Harvard Square,

looking in on some of the earliest buildings of Harvard's campus.

And thanks to technology, we took what is a relatively small watercolor

that this graduate student painted some 200 years ago,

and now adorns the stage here in the Loeb Drama Center.

So if unfamiliar, we have Holden Chapel here at left,

Hollis Hall to its right, which is one of the undergraduate dormitories

in Harvard Yard, Harvard Hall, which is one of the classroom

buildings on campus, and then Massachusetts Hall,

where both first years and Harvard's president live and work respectively.

So welcome, then, to CS50.

And I can say that not quite as long ago,

but, nonetheless, feels rather long ago, some 20 years ago,

did I take the same class.

But as you know, I myself had some trepidation

when it came to studying CS50, when it came to studying computer science.

Because it was a very unfamiliar field.

I had followed a path when I got to college of sticking within my comfort

zone, studying government early on, thinking I would major

or concentrate in government.

And it wasn't until I got up the nerve to shop, that is, sit in

on this class CS50, that I realized that homework can actually be fun.

And I found that computer science and CS50 is not about programming per se,

even though that's how many of us perceive it in high school,

whether it's us or our classmates taking the class.

But it really is about problem solving.

And as such, it's so very applicable not only

to computer science and the engineering fields,

but really to the arts, humanities, social sciences, sciences, and beyond.

And so if you're feeling a little uncomfortable

with the idea of taking a class like CS50,

know that almost every year, nearly two thirds of the students who take CS50

have never taken a computer science course before.

So if you look up, down, left, right, right now, odds are more than many

of the classmates joining you here today are in a very similar position.

You're indeed in very good company.

And what's ultimately important in CS50 too, we emphasize, as in the syllabus,

that what ultimately matters in this course is not so much where

you end up relative to your classmates, but where you end

up relative to yourself when you began.

Indeed, taking into account where you currently are, perhaps

with no prior background, and considering

where you will be in just three or so months

is ultimately meant to be the measure of your own success.

And so toward that end, we'll start off this class programming

a little something from yesteryear.

An image here of Super Mario Brothers and the pyramid

that the character has to ascend.

We'll recreate a portion of this game, albeit using text--

otherwise known as ASCII art-- but we'll do that in just the course's second

or so week.

So this will be among the first programs you write.

And then fast forward just several problem sets or programming

assignments later, or several weeks later, too,

and you'll be building what we call CS50 Finance, a web

application of your very own that runs on the internet,

pulling down nearly real-time stock quotes from a third party service,

allowing your own users to log in and register to buy and sell stocks,

so to speak, using virtual currency.

So over the course of the class's several months,

will you go, truly, from building a pyramid in Mario

to building your very own web application and more,

followed by the course's capstone experience, which

will be your very own final project.

But what exactly is computer science?

What we thought we would do in this week zero, the very first week of the class,

is consider exactly what it means to solve problems.

And let me propose that this is computer science.

This is problem solving.

You have some input, which is the problem you care about

that you want to solve, and you care about the solution to that problem,

which is the so-called output.

And in between that input and output is this black box

of sorts, inside of which is the magic that happens,

the magic that you'll eventually be able to harness and compel computers

to solve problems for you.

Inside of that black box, ultimately, is going to be the code that you write.

But for us to begin doing that, we all kind of

need to agree on how we're going to represent these inputs and outputs.

We all kind of have to speak a common language, so to speak.

And so we need to agree how these inputs are going to be represented.

So how might we typically represent information?

Well, maybe the simplest thing to do at the very first class, whether we're

online or in person, is to take attendance

or to count the number of people in the room.

And so you might do this old school style on your hands

so as to represent every person in a room

with just a finger raised on your hands.

So how we might represent information boils down

to very simple digits on your hand.

Of course, you can't count very high with just this hand.

And there's actually a fancy word for what we're doing,

old school here, and that's unary notation-- uno, implying one,

or one finger being up or down.

And so you can count, it would seem, as high as five.

And of course, if I bring in a second hand,

I can go as high as 10, and then things get a little more difficult.

But it's a system for representing information

and it's fairly universal, certainly when we're all quite young.

But you and I tend to use a more useful system.

Not just digits on the hand, but other sorts of digits.

Namely, the decimal digits that you and I know.

So the numbers that are otherwise more technically called base 10--

and that's just a fancy way of describing the fact

that there's 10 digits that you and I as humans really tend to use typically.

Those digits, of course, are zero through nine,

and using these several digits, we can pose numbers like zero

through nine, but also 10 and 11 and 12, and as high up

as we want to go by using multiple digits still.

But computers don't really speak the same language as us.

They're, in some sense, much simpler than we humans,

even though they seem so complicated or so sophisticated and certainly so fast.

At the end of the day, these are all human-made devices,

and they're relatively simple at their core.

In fact, even if you don't quite know what you're saying,

but you've at least heard this to be the case,

what language do you understand computers to speak?

What language do computers speak, if not the system that you and I use

of zeros through nines or decimal?

Brian, could we see who might answer this?

What system do computers use, so far as you've heard,

whether or not you've taken a CS class before?

Keith, can we go to you first?

AUDIENCE: Yeah.

The computers use binary.

DAVID J MALAN: Binary.

And can you elaborate a little bit?

What do you mean by binary?

AUDIENCE: It's zeros and ones.

So, like, while we use zero through nine for base 10,

they use zero through one for base 2.

DAVID J MALAN: Yeah, exactly.

So computers use the so-called binary system, bi implying two.

And they, indeed, only use, as Keith notes, zero and one, two digits.

So on the one hand, this is actually pretty encouraging,

because, wow, this is actually a pretty simple system if we're only

using two of these digits.

But, of course, if you only have two digits,

how are we going to represent the number two or three or four

or any much larger number?

It would almost seem like a step backwards.

But it isn't actually.

And it turns out that this so-called system, or base 2--

two because there's two digits in the vocabulary, otherwise known,

as Keith says, as binary--

uses just zeros and ones, and it turns out there's other nomenclature here

we can toss out.

These zeros and ones are otherwise known as bits.

And bits actually derive from just two words, binary digits.

Binary, implying two possibilities, digits,

just being symbols on the screen.

So binary digits, or otherwise known as bits.

And computers speak binary using these things called bits.

But what does that mean and why is it the case?

Like, why didn't they invent computers decades ago

that just use zero through nine, rather than

come up with a whole new system for us to think about, let alone talk about?

Well, at the end of the day, computers are using what as their input?

Really just electricity.

Probably the only thing all of us do every day or every couple of days

with our laptop or desktop or phone is either make sure it's still plugged in,

or to plug it in so as to charge it.

So the only physical input to our devices

these days is electricity in some form.

And we don't have to get into the nuances of what electricity is,

but I think it's about electrons flowing into the device so as to charge it.

So it suffices for our purposes to know that there's

some physical input to the device, these computers and phones that we use.

But that's it.

And so if we harness this electricity, maybe we

can start to represent information with it.

For instance, here is a light bulb, this old ghost light in the theater here

that's currently off.

But it has the ability to turn on.

We just need to plug it in or throw on a switch.

And if that's the case, what's really quite

compelling about the metaphor of using lights

is that right now, this light bulb is currently off,

but as soon as I allow electricity to flow

as by plugging it in or maybe throwing a switch, now it's, of course, on.

And if I unplug it or throw the switch again, it's off.

Or if I plug it back in, it's on.

And the implication of this very simple idea

is that we can take a physical device, like a single light bulb,

and by plugging it in or unplugging it, we can represent information.

What did I just do?

I represented the light bulb being off or on,

but we can just call off and on something else.

We can call them zeros and ones.

And so this really is the germ of an idea

that gave us computers, and with it, their use of the binary system.

If, at the end of the day, all they have is physical input as electricity,

well, let's just use that to harness and keep track of information.

Let's store a little bit of electricity when we want to represent a one,

and let's let go of that electricity in some sense

when we want to represent a zero instead.