to the intellectual enterprises of computer science

and the art of programming.

And this was apparently me around the time

that I sat where are you guys now sitting thanks to a teaching

fellow who spent a little too much time trolling around Lemont Library, where

the 1995 freshman registers apparently still are.

And I point this out because this was a big deal for me

back when I was a freshman and ultimately

sophomore considering to take a class like this, CS50, but more generally,

computer science.

And if you, like me, have this perception of computer science

from high school or even middle school, you

might have the perception that it's entirely based about programming.

It's perhaps a bit antisocial.

It's perhaps the computer lab, heads down,

sort of coding away on something that you don't necessarily understand.

And yeah, I too had that perception freshman year in this course

and, dare say, the field more generally, really did

have this reputation to beware.

I certainly assumed that most everyone around me

certainly knew more than I did.

And this wasn't just true of CS for me.

This was true of most any field at Harvard in the course catalog

that I had no familiarity with.

And so I instead gravitated toward the more comfortable.

I took a lot of gov classes and economics and history

just because that's kind of what I knew and liked in high school.

I wouldn't say I loved it, but I knew it and it was within my comfort zone.

And it wasn't until sophomore year that I got up

the nerve to take this class, CS50.

And I only did because the professor at the time let me take it pass-fail,

now called SAT/UNSAT.

And that allowed me to get over this sort of mental hurdle

that I imposed upon myself, sort of fear of failure

or simply not doing as well as I might have been accustomed to.

And so I bewared a class like this until then.

And I always kind of regretted not exploring earlier on.

And that doesn't have to be this class.

It doesn't have to be CS but can be really any field more generally.

But those really were my takeaways around the time I looked like this.

And I've taken comfort since in taking over this class

and have found it inspiring that these days, 68% of the students in this room

and in this room last year had never taken a CS course before.

So if you do have that mental model of everyone to your left

and your right surely must know more than you, odds are it is not,

in fact, the case.

In fact, within CS50, we have these different tracks, different types

of sections for students less comfortable, students more comfortable

and students somewhere in between.

And there's no formal definition to these labels.

You just sort of know it if you are.

And if you kind of have one foot mentally out the door today

because you're not really sure this is for you,

you're probably among those less comfortable.

But as such, you're in the majority, 56% of last year's students.

If by contrast, you have been programming

since you were eight years old, 10 years old,

whatever but you're largely self-taught and therefore

maybe have lots of gaps in your knowledge

or don't really understand all the formalities,

you just kind of figure things out, you might be among those more comfortable.

And if not, maybe you're somewhere in between.

And so in CS50 sections, do we have similar students together,

similar comfort level, similar backgrounds,

so that everyone can kind of feel comfortable speaking up not knowing

things, knowing things, and beyond.

Because ultimately, the course is graded and assessed ultimately very much

manually, very much very delicately with respect

to students' prior background or lack thereof.

Indeed, what's most important at the end of the semester

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

but where you end up in week 11, our very last week, relative to yourself

today in week 0.

And in fact, thanks to CS50's own Haley James and a whole bunch

of CS50 team members-- this summer, they spent

a while traveling around the country bringing folks back

to campus, alumni and former students and staff who had some connection

taking or teaching CS50 in some form.

And if you'd like to see stories of some of your predecessors and folks who sort

have found their way-- accidentally, even--

to computer science finding challenge along the way,

check out this domain that the team put together-- project5050.org.

Now the course itself ultimately is not about programming per se.

That's indeed a tool that we'll use.

It's really about this.

And that's really what CS is, the field more generally.

Whether you're starting hardware or graphics or theory or any number

of fields, artificial intelligence these days, machine learning and beyond,

it's really just about solving problems.

And what's really cool about CS I found early on

is that it doesn't necessarily-- it's not an end unto itself.

It's this field that empowers you to go do more interesting, more powerful

things in the humanities, social sciences, physical sciences, the arts,

anything because you have this new mental model for how you can solve

problems better, more efficiently, how you can solve them correctly,

and how you can sort of analyze large datasets

or solve problems that might have otherwise been beyond your grasp.

So what does this mean?

What is problem solving?

Well we could perhaps distill it as simply

as this-- a big black box, some secret sauce,

into which go inputs, like the problem we want to solve,

and out of which comes outputs, the solutions that we want.

So a very generic way of describing it, but what's

pictured here in the black box is the so-called algorithms.

And we'll come back to that in just a bit

the actual ingredients for solving problems.

But how do we represent inputs and outputs?

Odds are even if you're not a computer person and don't really think like one,

you probably know that computers only understand a very limited vocabulary.

Like, what is the alphabet, so to speak, that they speak?

ASCII maybe, but more--

AUDIENCE: Binary.

SPEAKER 1: Binary, binary, bi meaning two for zeros and ones.

So whereas we humans typically use decimal--

dec meaning 10, 0 through 9-- as in our alphabet of letters,

computers of course, as you may have heard, only use zeros and ones.

Now why is this powerful?

Well, turns out as soon as you have at least two digits in your alphabet,

you can start to represent things much more powerfully and much more

efficiently.

For instance, how many-- if I wanted to count the people in this room,

how many of you could I count on just one hand?

Hopefully five.

So I could call five.

It would be one, two, three, four, five.

But you know what?

If I were a little more clever, I bet I could use the same hand

and count as many as 32, maybe 31 of you.

Well, how is that?

Well, right now, I'm kind of using the unary system, uno meaning one.

So it's just one digit in your alphabet-- the finger or no finger.

It's not quite the same as zero or one--

so one person, two, three, four, five.

But what if I instead permuted my fingers in some way

so that the pattern of fingers that are up actually matters,

not just the quantity?

So maybe this is still 0 this now is 1.

And instead of 2 being this, maybe two could be this.

So if my second finger is up, I'm going to call that two.

And if my first two fingers are up, I might call that three.

Somewhat offensively, if just this finger is up,

I might call this four and then five.

And then this gets kind of painful--

six, seven.

And what I'm actually doing is counting in binary.

Now that might have looked completely cryptic,

but it turns out as soon as you have two digits, that's

enough to represent anything you want and to do so pretty darn efficiently.

But why?

So odds are, if you're like me, you probably grew up learning,

of course, the decimal system, zero through nine.

And you might have written on the board some points like this number--

123.

But why do you think of that as 123?

It's really just a pretty pattern of symbols--

glyphs, so to speak-- on the screen that we ascribe some kind of mathematical

meaning to--

123.

But really, it's just like someone drew in ink on the screen some symbols.

Well, if you're like me back in grade school,

you probably learned that the right-most number here

is in the so-called what place?

The ones place, right?

And so if we wanted to label these things,

we might put ones place there and then of course the tens place

and the hundreds place, maybe the thousands, 10,000, and so forth.

So we had this sort of mental models for the columns.

And notice they happen to be powers of 10.

10 to the 0 is 1.

10 to the 1 is 10.

10 to the 2 is 100 and so forth.

So that's the pattern even if your grade school teacher didn't

talk about exponentiation at the time.

So why is this number 123?

Well, it's because we have a one in the hundreds column--

so 100 times 1.

We have a two in the tens column.

We have a three in the ones column.

Them.

And of course, if we start to do the arithmetic now,

that's 100 plus 20 plus 3 or obviously 123.

And all of us take that certainly for granted these days.

You see a number, you know what it is mathematically.

But computers fundamentally work in the same way.

So even if you up until now have never thought of yourself as a computer

person or had no idea really what it means

for computers to speak just zeros and ones, all you have to do

is update the places.

Instead of powers of 10 dec, meaning decimal, we're going to powers of two

for binary.

So now we're going to have 2 to the 0 2 to 1, 2 to the 2, 2

to the 3, same idea.

It's just a different base.

We change tend to 2.

And so now we have places like this--

1, 2, 4, and if we kept going, 8 16, 32, 64, and so forth.

So as such, what number is this on the screen in binary if you convert it

in your head to decimal?

It's just the number one, right?

Because you've got a 1 in the ones place and then a zero in every other place.

So it's just 1 times 1 equals 1.

Now if I were using unary or my hands, the sort of traditional way, two

would be this where you put up two fingers.

But not if you're trying to use patterns as well as quantities.

And so in binary, how do I represent the number two?

010.

It's the equivalent of putting up just my index finger here.

And if I want to count to three, now I need to add a 1 to the mix.

So I add the ones place.

And now if you start to visualize this, it's

like one of those really old school clocks where

the numbers flip around and roll over.

Now those ones are going to kind of flip and become zeros

and the zero is going to become a one.

And so now we have five and then six and then seven.

And then dang it, how does a computer count to eight?

Yeah, you just need to add another place, right?

Just like we humans don't have an infinite number of numbers

when we write something down-- we sort of stop

when it's not necessary-- all we need is another bit.

We just need to add another 0 or 1 to the left, specifically a one.

Then all these ones can become zeros.

And we can do this toward infinity.

But where are these bits coming from?