>> DAVID J. MALAN: All right, this is CS50.

And this is week one.

So recall that last time in week zero, we focused on computational thinking.

And we transitioned from that to Scratch, a graphical programming

language from our friends at MIT's Media Lab.

>> And with Scratch, did we explore ideas like functions, and conditions,

and loops, and variables, and even events, and threads, and more.

And today, we're going to continue using those ideas,

and really taking them for granted, but translate them

to another language known as C. Now, C is a more traditional language.

It's a lower level language, if you will.

>> It's purely textual.

And so at first glance, it's all going to look rather cryptic

if you've never programmed before.

We're going to have semi-colons, and parentheses,

and curly braces, and more.

But realize that even though the syntax is

about to look a little unfamiliar to most of you, see past that.

And try to see the ideas that are, indeed, familiar,

because here in week one what we'll begin to do is to compare,

initially, Scratch versus C.

>> So, for instance, recall that when we implemented the first of our programs

last time, we had a block that looked a little something like this-- when

green flag clicked, and then we had one or more puzzle pieces below it,

in this case, say, hello world.

So, indeed, in Scratch, when I click that green flag

to run my program, so to speak, these are

the blocks that get executed, or run.

And, specifically, Scratch said, hello, world.

>> Now, I could have specified different words here.

But we'll see that, indeed, many of these blocks-- and indeed,

in C many functions-- can be parametrized or customized

to do different things.

In fact, in C if we want to convert, now,

this Scratch program to this other language,

we're going to write a little something like this.

>> Granted, there is some unfamiliar syntax there most likely, int,

and parentheses, and void.

But printf-- even though you would think it would just be print.

But print means print formatted, as we'll soon see.

This literally will print to the screen whatever

is inside of those parentheses, which of course in this case is, hello world.

>> But you'll notice some other syntax, some double quotes,

that the parentheses at the end, the semi-colon and the like.

So there's a bit of overhead, so to speak, both cognitively

and syntactically, that we're going to have to remember before long.

But realize that with practice, this will start to jump out at you.

>> In fact, let's focus on that one function specifically-- in this case,

say hello world.

So say is the function.

Hello world is its parameter, or argument, its customisation.

>> And the equivalence in C is just going to be this one line here,

where printf is equivalent to, say, the double quoted string, hello

world is equivalent, of course, to what's in the white box there.

And the backslash n, though a little strange and absent from Scratch,

simply is going to have the effect we'll see in a computer, like my Mac or a PC,

of just moving the cursor to the next line.

It's like hitting Enter on your keyboard.

>> So we'll see that again before long.

But first, let's take a look at this other example in the case of loops.

We had this forever loop last time, which was a series of puzzle pieces

that did something literally forever-- in this case,

say, hello world, hello world, hello world, hello world.

So it's an infinite loop by design.

>> In C, if we want to implement this same idea, we might simply do this.

While true, printf hello world-- now while, just semantically, kind of

conjures up the idea of doing something again, and again, and again,

and for how long?

Well, true-- recall that true is just on or one.

>> And true is, of course, always true.

So it's kind of a meaningless statement just to say true.

But indeed, this is deliberate, because if true is just always true,

than while true just implies, if a little indirectly,

that the following lines of code in between those curly braces

should just execute again, and again, and again, and never actually stop.

>> But if you do want your loop to stop, as we

did last time with something like this, repeat the following 50 times,

in C we can do the same with what's called a for loop-- the keyword

not being while, but for.

And then we have some new syntax here, with int i equals 0, i less than 50,

i++.

And we'll come back to that.

But this is simply how we would translate the set of Scratch blocks

to a set of C lines of code.

>> Meanwhile, consider variables.

And, in fact, we just saw one a moment ago.

And in the case of Scratch, if we wanted to declare a variable called i

for i being integer, just a number, and we want to set it to some value,

we would use this orange block here-- set i to 0.

>> And we'll see today and beyond, just like last week,

programmers do almost always start counting from zero, really

by convention.

But also because recall from our discussion of binary,

the smallest number you can represent with any number of bits

is just going to be 0 itself.

And so we'll generally start initializing even our variables to 0.

>> And in C to do the same, we're going to say int

for integer, i just by convention.

I could have called this variable anything I want, just like in Scratch.

And then equals 0 just assigns the value 0 from the right

and puts it into the variable, or the storage container there, on the left.

And the semi-colon as we'll see-- and we've seen a few of these already--

just means end of thought.

Proceed to do something else on the lines that follow.

>> Now, what about Boolean expressions?

Recall that in Scratch, these were expressions

that are either true or false-- questions,

really, that are either true or false.

So in the case of Scratch, we might ask a simple question like this,

is i less than 50?

So i, again, is an integer.

Maybe we're using it in a Scratch program

to keep track of a score or something like that.

So this syntax here in Scratch just means, is i less than 50?

Well, thankfully, something is simple in C. And to translate,

this we would simply say i less than 50, using the familiar key

on your keyboard.

>> Meanwhile, if you wanted to say something more general,

like, well, is x less than y where each of x and y are themselves variables?

We can do the same thing in C, so long as we've

created these variables already.

And we'll see how to do that before long.

We would simply say x less than y.

>> So you're starting to see some similarities.

And those folks who made Scratch were certainly

inspired by some of these basic ideas.

And you'll see this kind of syntax in many languages--

not just Scratch, not just C, but Python,

and JavaScript, and other languages still.

>> Let's consider another construct from C, the notion of a condition,

doing something conditionally.

If something is true, do this.

If something else is true, do that.

It's sort of the programming equivalent of a fork in the road.

Maybe it's a two-way fork, a three-way fork, or more.

And in Scratch, we might have seen something like this.

>> So this one's a big one.

But consider the relative simplicity of the logic.

If x is less than y, then say x is less than y, else if x is greater than y,

then say x is greater than y.

And then, logically, if you think back to Scratch

or just your own human intuition, well, if x is not greater than y, and x

is not less than y, then of course x is going to be equal to y.

So in this case, by nesting those Scratch blocks,

can we achieve a three way fork in the road?

>> Meanwhile, if we want to do that in C, it arguably

looks a little simpler-- at least once you get familiar with the syntax.

If x is less than y, printf x is less than y.

Else if x is greater than y, printf x is greater than y.

Else printf x is equal to y-- and, again, with those backslash ends just

for those new lines so that if you actually ran this kind of program

it would just move your cursor ultimately

to the next line of the screen.

>> Now, meanwhile Scratch had other more sophisticated features, only

some of which we're going to initially move over to the world of C.

And one of them was called a list in Scratch.

And this was a special type of variable that

allowed you to store multiple things in it back, to back, to back, to back.

>> In C, it doesn't have lists, per se, but something

that are more generally called arrays, although we'll

come back later this semester to looking at something

called a list, or really a linked list.

But for now, the closest equivalent in C for us

is going to be something called an array.

And an array is simply a special type of variable

that allows you to store data back, to back, to back, to back.

>> And, indeed, in Scratch, if we wanted to access

the first element of an array or a list-- and I'm going to call it,

by convention, argv, argument vector, but more on that before long.

If I want to get at the first element of argv, in the world of Scratch

you actually do typically start counting from 1.

>> And so I might get item 1 of argv.

That's just how MIT implemented the notion of lists.

But in C, I'm going to more simply just say, argv,

which again is the name of my list-- or to be clear, an array.

And if I want the first elements, I'm going

to use square brackets, which you might not often used under a keyboard.

>> But 0 just means, get me the first.

So on occasion and as time passes, we're going

to start to see these dichotomies between Scratch and C,

whereby Scratch uses one.

We in C use 0 here.

But you'll quickly see once you understand

the foundations of each language, that these things start to get all the more

familiar through practice and practice.

>> So let's actually look now at a program.

Here shall be the first of our C source code for complete programs.

And the program we're going to offer for consideration

is the one that's equivalent to that earlier Scratch piece.

>> So in here, we have what's arguably the simplest C program

you can write that actually does something.

Now, we'll look past, for now, has include,

standard io.h, and these angle brackets, and int, and void,

and the curly braces, and the like.

>> And let's just focus on what, at least intuitively,

might jump out at you already.

In fact, main, I don't necessarily know what this is,

but much like Scratch had that when green flag clicked puzzle piece,

so does C as a programming language have a main piece of code that

gets executed by default. And, indeed, it's literally going to be called main.

>> So main is a function.

And it's a special function that exists in C that when you run a program,

it is main that gets run by default. In the world of Scratch,

it was usually when green flag clicked that got run by default.

>> Meanwhile, we've seen this before, printf or print formatted, that's

going to be a function that comes with C, along with a whole bunch of others,

that will from time and time again, in order to do exactly

as its name suggests, print something.

What do we want to print?

Well, we'll see that by enclosing characters

like these-- hello world, backslash n in double quotes,

we can tell printf exactly what to print on the screen.

>> But in order to do that, we unfortunately

need to take something that is already cryptic to us humans,

but at least it's somewhat readable-- sharp include, standard io.h, int,

main, void, printf, all of the magical incantations we just saw on the screen.

But we actually have to go more arcane still.

We first need to translate the code that we write into machine code.