This is CS50 and this is lecture 1.

And you'll recall, of course, that just a few days ago, we

introduced programming and some fundamentals of computing

and computational thinking, so to speak.

And today, we're going to build on those ideas

but begin to transition to a more cryptic looking

but nonetheless much more powerful language-- transitioning ultimately

from Scratch.

So odds are by now, you had an opportunity with problem

set zero to experiment with Scratch and drag and drop puzzle pieces

and recall that the real point of Scratch,

beyond having a bit of fun in showing off,

which you can do with something like that,

is to explore ideas like loops and functions and conditions.

Maybe some Boolean expressions or events.

Really depends on how you pull those ingredients together.

But today, we introduce a language that's

been around for quite awhile longer--

decades-- called C. And it's an older language

and frankly, after CS50, odds are you're not likely

to use this language all that much, if ever.

But it's been a foundation for a lot of the more modern languages that

have come in.

So roughly mid-semester when we transition to another language--

Python and then thereafter SQL and then thereafter

JavaScript-- you'll see a lot of those same origins and syntax and ideas.

And indeed, everything we did last week in Scratch, you're going to see

permeates all of these various languages.

Because at the end of the day, you're not learning C in CS50.

You're not learning Scratch or Python or JavaScript.

You're learning the fundamentals of computer science and ultimately,

the tool of programming.

So today, let's begin to translate some of last times ideas

into more cryptic looking but nonetheless fundamentally identical

ideas as follows.

So this was a super simple program that simply

displayed on the screen out of the mouth of a cat by default, hello world.

Well, let's begin to translate this to something textual

as most programming languages actually are,

by first focusing on just this block.

This purple puzzle piece--

we called an example of what kind of programming construct?

It was like a function.

A verb or an action, do something in Scratch.

MIT decided to make them purple but that was just arbitrary

but they're consistent in the program because they're all

very similar in spirit.

Now in C, starting today and for several weeks hereafter,

that same purple puzzle piece is going to start to look like this.

And we saw a glimpse of this last time-- printf, hello, world.

But notice there's a few salient characteristics

beyond just the words, hello world.

There's printf and we'll see what the f stands for today.

There's a parenthesis and a closed parenthesis over here.

And that kind of balance is going to be important, not intellectually, but just

syntactically because the computer is going

to expect you to be super precise.

The quote and unquote, we'll see, surround words

that you write in a program.

So whereas last time in Scratch, you simply typed a word in a white box,

now you're going to do the same thing on your keyboard

but surrounding it with quotes.

And then lastly, there's going to be this nuisance, this semi-colon, which

a lot of languages have which simply says, end of thought.

It's like the programmer's equivalent of a period in an English sentence.

And you'll find that among the frustrations

that new programmers experience, myself included back in the day,

is you don't really notice these things from the get go.

And you might type out all of your logic and feel good

about your program try to run it and the thing doesn't work because of something

stupid like you forgot this.

So the key takeaway for today especially is don't

get frustrated by the stupid stuff.

You're absolutely going to bump against walls, not quite

seeing what someone like I might see after all these years of practice.

But in just a few weeks time, you'll start to notice patterns.

And the mistakes you might make in the first week

are going to be much more obvious to you in the second and third and beyond.

So this then would be a function in C. Let's

combine it as a complete program, which we did see a glimpse of last time.

So if you were to implement this same program,

hello, world in C, these are the several lines you would have to type.

You can't just type printf.

You have to sort of set up the program.

Now why is that?

Well, we can tease this apart by looking at just a few of the keywords

in this example here.

So highlighted now in yellow is main.

And some humans, years ago, just decided,

you know what, when another human is writing a program,

he or she has just got to call their function, as we'll soon see, main.

They could have called it anything they want

but main is kind of a nice word for it the main part of your program.

So this is the equivalent of our when green flag clicked in the language

called C.

Meanwhile, if we highlight another key word printf,

this is going to be the C equivalent of the say block in purple.

So printf is just going to print something on the screen.

Meanwhile, in yellow here now is what we're going to start calling a string.

A string is just a technical word for sequence of characters or words,

phrases, paragraphs, whatever it is.

So that is a string highlighted now in yellow.

And notice that it's sort of being supplied, as we'll see, to printf.

If it's immediately coming after the word printf just like hello,

world in the white box immediately came after the word say.

And now things get a little more arcane now highlighted in yellow is stdio.h.

Definitely the most cryptic of the key word so far.

This happens the stand for standard inputs and outputs.

And that's just a fancy way of saying this file, as we'll soon see,

is somehow related to printing and somehow, which is output,

and somehow related to keyboards, which is input.

So somewhere in that file, we'll see is this sort of functionality

that you would hope a computer would have.

Outputting stuff and taking input.

And so we'll see that that's where we get

that kind of standard functionality.

Scratch does not have an equivalent.

It just all kind of works, which is nice in Scratch.

Meanwhile, this keyword, include, we're going to see,

is literally just saying that.

Hey computer, please include standard input and output functionality

so that I can do something interesting with my program.

And without that line of code, you couldn't do as much

in this language, C.

Now let's look quickly at a few other puzzle

pieces, a few concepts that intuitively are probably pretty straightforward.

And then we'll transition partway through today

to actually writing code and lots of actual examples

and running the code as well.

But last time, you might have implemented

an infinite loop, one that just goes forever, with a forever block.

And in Scratch, you would then have a say block or something else

on the inside.

Starting today, that same puzzle piece is going to look a little weird.

It's going to look like this.

While (true) printf hello, world.

And frankly, there's a bunch of different ways

you could implement this.

I'm just sort of choosing the simplest, relatively speaking, or most canonical.

But why is this the same?

Well, I've highlighted in yellow the first line, while true.

And while-- it's kind of a nice word in English and so far,

it just kind of intuitively suggests like,

while something is happening-- that's kind of loop like.

And meanwhile in parentheses, this is a Boolean expression

Scratch had these by dragging and dropping

those puzzle pieces on the equivalent block when you had conditions.

But in this case here, we're just saying while (true).

So (true).

(true) is like yes.

And the other day, we said yes is kind of like the number 1 whereas no is

like false or the number 0.

And that's great because if we have a true, false world or a yes,

no world, or 1, 0 world that wonderful [INAUDIBLE] to the hardware

we all have on our laps and in our pockets, which

is a computer based on transistors and electricity and all

of that we're going to now abstract away from.

Don't care how electricity works today and I don't care how 1's and 0's.

I just know that I can represent 1's or 0's, 1's or 0's.

Or equivalently (true).

So while this lamp is on or while this lamp is (true), printf hello, world.

So the reason, logically, that the code you

have on the screen there prints hello, world forever

is because it's as though we've never turned the light bulb off.

It's just while it's on.

Keep doing this doing this doing this doing this again and again

and again, just like in Scratch.

Meanwhile, we might also do the following

after a number of iterations of that.

We might have a finite number of iterations with this repeat block.

This one says, of course, repeat the following 50 times.

Now this one is going to look a little uglier, for sure.

This is probably the most conventional way

to translate this Scratch block to C. Now it looks like a lot all at once

but again, after a couple of days, couple of weeks,

you'll start to see the patterns.

Let me highlight some of the features of this code.

So highlighted in yellow here is what we're just

going to call an initialization.

This says, hey computer, give me a variable, call it i, just because.

I could have called it anything.

And initialize it to 0.

So again, just like an algebra, you might

have x equals 0 or y equals 0 this is just equal 0.

And even though we haven't talked about this,

you might be able to guess what does this keyword, int, perhaps mean?

Integer.

That's right.

I mean, we didn't have the same idea in Scratch.

In Scratch, if you want a number, you just type it.

If you want a word, you just type it.

But in C, you have to be a little more uptight.

You have to actually tell the computer what type of value

you're putting in your variables.

They're not just going to be numbers, integers.

Turns out we can put strings, we can put trues and falses,

we can put other things as well down the road.

So this is just saying, hey computer, give me

a variable that's going to store an integer, a number, like negative 1, 0,

1, and so forth, but initialize it to 0.

Make it the number 0 by default. And that's it.

Succinct, if cryptic way of saying it.

Then this block of code says the following.

Hey computer, just to be safe, is i less than 50?

That's a Boolean expression, true or false?

So is i less than 50 at this moment in time?

Obviously, because it's 0.

That's of course, less than 50.

So the computer then does the following.

printf hello, world.

So it initializes the variable.

It checks that it is less than a certain number, 50 in this case.

And then if that condition is true, it proceeds to print hello, world.

And even if you've never seen code before,

perhaps by process of elimination, what step is probably going to come next?

What am I next probably going to highlight on the screen?

Yeah, the i plus plus.

Not obvious what it does quite yet but you can perhaps guess i plus plus

is a conventional way in this language to just say, you know what,

go ahead and change i's value by 1.

So if 0 becomes 1, 1 is going to become 2, 2 is going to become 3 and so forth.

But for now, we're just changing 0 to 1.

So at this point in the story, i is 1.

What does the computer do?

Now, it just kind of repeats things bunches of times.