Original subtitles

DAVID J. All right.

This is CS50.

This is week one, because, of course, last week was week zero. And this is the

week where we'll actually start programming in a much more traditional

programming language we promised called C.

Of course, we started with this. And hopefully by now, with problem set one,

you've had a little bit of fun, even if you've played with it before. And the

goals of Scratch, beyond sort of making things feel very accessible and user

friendly, is really to elucidate some of the fundamental concepts that we'll see

again today.

And really, every week subsequently, like functions and conditionals and

and variables and so much more. And in fact, among the goals of Scratch is,

again, to kind of plant these visuals in your mind. So even as today onward

feels all the more like a fire hose, especially when it comes to really weird

cryptic textual syntax, the ideas are still going to be the same. So today,

program, Hello World, becomes this instead.

And in fact, just to color code things temporarily,

I dare say that what I've color coded here in orange, which looks probably, to

those of you who've never programmed, pretty cryptic, is the equivalent of the

when green flag clicked orange puzzle piece like this. What remains is just

line in purple with a bit of white, which is what ultimately is going to get

screen today to say hello world on the screen.

And of course, we had a name for something in purple.

In fact, if we rewind to week zero, this block in purple represented what type

of functionality?

A function itself, an action, a verb that gets the computer to do something.

what looked like this last week is about to look like this. Let's take away the

color coding and focus really on what we're going to now start calling source

code. So this is what programmers do.

in the real world. This is what software developers, software engineers do in

the real world. They write code that looks like this. And clearly, it's a

English -like, but it's not English in the way you would compose an essay or an

email. Clearly, there's some patterns and some special syntax to it that we'll

highlight ultimately today.

The problem is, though, that computers, of course, don't understand source code.

They only, per last week, understand zeros and ones. That is it, the so

binary system.

So somehow, we've got to get what already looks cryptic into something

looks at a glance even more cryptic than zeros and ones, the computers do

understand. And for today's purposes, just know that built into your Macs,

and phones, There is a built -in understanding of what these patterns

Maybe it means a number. Maybe it means a letter. But today, maybe it means an

instruction, like print something on the screen, or save something, or load

something. That is to say, computers use patterns of bits not only to represent

all the stuff we talked about last week, numbers, letters, colors, images,

sounds, and all of that. They also use patterns of bits to represent

fundamental functionality, print things, play things, much like those same

scratch blocks.

But no computer scientist really, unless they take out a paper pencil or write a

program or use a website to convert this, can sort of read this and know

going on. That's why we humans are actually going to use not machine code,

is called, the zeros and ones that computers understand.

We are going to start writing source code. And last week, you already wrote

source code, but in the form of dragging and dropping those puzzle pieces.

So this, too, is going to be the paradigm that sort of guides us through

entire semester.

Problem solving programming is really about input.

becoming output.

And we'll focus today then on a certain type of input becoming output.

Someone has to get the source code that's written in a language like C into

machine code, the zeros and ones that the computer actually understands.

So source code today is going to be our input.

Machine code is going to be our output. And we're going to give you today a

special program called a compiler, whose purpose in life is to translate one to

the other. And there's compilers for different languages in the world. We're

going to focus on one that supports today's language, known as C.

And here, as promised, is the programming environment we are going to

tailored to CS50, which is to say we've pre -installed certain software that you

might find useful during the term. But for all intents and purposes, the tool

you will use for CS50's problem set, henceforth, is a very popular industry

standard tool called Visual Studio Code, or VS Code for short.

We are using a cloud -based version of it that lives at literally this URL,

.dev. You can sign into that so long as you have a free GitHub account for which

you signed up, presumably, already. And that will give you access to not only an

industry standard programming environment, but again, an environment

some CS50 -specific things pre -installed.

And at the end of the semester, or even in the middle if you're so inclined, you

can actually download for free VS Code onto your Mac PC.

You can disconnect from the internet, and you can actually program on your own

computer. Caveat, though, is that you tend to hit technical support headaches

the very beginning of the term. So we suggest you do that later in the term

you're already comfortable with this cloud -based environment here.

And here it is. This is what programming shall look like, whether we're using C

now or Python in a few weeks or JavaScript or SQL thereafter.

So here is what is VS Code configured as follows.

At the top right, you'll generally have one or more tabs for code, much like

tabs in a browser. And this is where you'll write code that looks a little

something like this. And in fact, this is exactly the code that you saw a

ago. What VS Code does, among other things, is it actually highlights your

for you. It colorizes it in what's generally

in an illuminating way.

So I did not choose to make this red. I did not choose to make this blue and

this purple. The computer sort of automatically does that for you, as

see, to sort of draw your attention to different ideas in the program itself.

That all happens automatically.

At the bottom here, you're going to use a more advanced interface today onward

known as a command line interface in the form of a terminal window.

So you can still use your mouse or trackpad and click and drag and do

like that in this environment.

Many programmers prefer that it's much more efficient, ultimately, to use your

keyboard more often than the mouse or the trackpad. So we'll introduce you to

that text -based terminal window there.

Up here at top left, you'll have a file explorer.

So what's nice about VS Code is that not only will you have textual commands

with which you'll get comfy, you also have like a normal Mac or PC or phone

nowadays. Like literally files and folders will visually appear to you so

can play with or manipulate them there.

And then lastly, this is sort of like the menu. the so -called activity bar

just has icons for various features, including CS50's duck. So in fact, if

poke around, you'll see ultimately a duck icon when you log in, which is your

own CS50 -specific chat bot of which you can ask questions throughout the

process.

So now that we've got VS Code here, let's go ahead and actually consider

represents. So this is generally, for jargon's sake, a graphical user

which means buttons and icons and menus and all of that. We all take that for

granted on almost any device nowadays.

That's abbreviated, just so you know, as GUI, G -U -I.

But built into VS Code, again, is what not only the terminal window by name,

conceptually, this is a command line interface. So not a graphical user

interface, but a command line interface. interface, whereby there aren't icons

to click on or double click on. Rather, if you want to run a program, you use

the command line interface, or CLI, to type the name of the program that you

want to run.

And so this will feel like a step backwards initially today, because we

of tap and point and double click at things nowadays.

But again, it's going to give us more power, more efficiency, ultimately

this.

So with that said, let's go ahead and actually use it for just a moment.

class, you're welcome to follow along. But suffice it to say, we'll generally

somewhat quickly.

Really, you're going to learn how to program by way of the problem sets each

week. I'll introduce and focus on the concepts, the ideas, the sort of

primitives that will get you started.

But only through actually doing the problem sets is the muscle memory and

practice going to come. So not to worry if it doesn't all sort of go down easily

the first time around.

So here is the code that I claim is equivalent to last week's Hello World

program, let's actually go ahead and do this in the programming environment.

So I'm going to go ahead and switch over to VS Code itself, which is now running

on my Mac here. It's not just a screenshot.

And I'm going to go ahead and do the following to get started with

I'm going to write literally in my terminal window the word code.

And I might have to give it focus by clicking down in that quadrant of the

screen. And then I'm going to give the name of the file that I want to.

And in this case, I'm going to propose that we call it hello .c.

In the world of Scratch, when you downloaded it, you might have noticed

files are all called like SB3 or some such file extension.

When writing code in C, you literally name the file something .c by

But notice some other details, especially if I zoom in.

Everything I've typed thus far is lowercase.

There's no spaces.

And so this is going to be important.

And unfortunately, computers are not forgiving.

And odds are one of the first stupid mistakes you'll do is miscapitalize

something, misspell something, add too many spaces or the like. Not to worry.

time, that kind of muscle memory will come with practice.

So let me zoom out.

Let me now just hit Enter, and you'll see at top right the Code tab that I

promised. So I'm going to go ahead and type out this program pretty quickly,

because I've done it before.

Include standardio .h, int main void, and then some curly braces, as they're

called, and then printf quote unquote hello comma world backslash end close

quote.

All right, so that's a lot, but that too will come in time with practice. But

this is the exact same code that we saw just a moment ago.

Indeed, if I zoom in, it's color coded just as in the screenshot, and thus I

have written my first program.

VS Code will automatically save for you, but you can also hit Control or Command

S to ensure that it's saved. But notice what's happened at top left.

Not only do you see my code over here, you see a visual icon, just like on a

or PC that, yes, this file now exists in your account.

is what you're getting with VS Code for CS50. You're getting your own sort of

server in the cloud.

It's called a container nowadays. So there's some virtual disk space

in the cloud, a la iCloud or Google Drive, that's going to store all of your

files. And at the moment, because I refreshed my account before class, I

have one file in my own account.

What's this? What's this?

Well, this is like my ID number for GitHub.

Not really a big deal. That's just randomly generated by GitHub.

Urban Adventure is the name of my programming environment today, otherwise

as a code space.

This is just a GitHub thing, which is, again, one of these cloud companies.

Instead of choosing random letters and numbers to uniquely identify all of our

programming environments, it's popular in the tech industry nowadays to just

together random English words that sometimes sound kind of cool. But it's

by coincidence, not something I chose. Yours will be different.

All right, so I've written some code.

I created hello .c. I typed in all of that code. I confirmed visually at left

that it was created. I'm going to hide my file explorer, henceforth, just so we

can focus on the code. How do I actually run this program?

Well, on a Mac or PC, we would be in the habit of opening the folder and double

-clicking on it. Or on your phone, you would take it out and tap on an icon.

But not here. Here, we're focusing primarily on the command line interface

within this whole environment.

So I'm actually going to have to introduce a few commands.

You saw already the code command, which for our purposes is VS Code specific,

that just creates a new file called hello .c in this case. But I need two

commands to actually run this program.

The first, nicely, is called make. And then I specify what program I want to

make. And then a little weirdly, I have to type dot slash hello.

But just to take a step back, make hello. If this is about to be my second

command that I type, what does that step represent, perhaps?

given what I said just a minute or so ago.

Perfect. So make represents the compiler, so to speak, the program that

source code to machine code. I have to do that for now manually by running make

hello. Now, make is kind of smart. And even though I'm saying make hello, not

make hello .c, make is smart. And it's going to say, oh, if you want to make a

program called hello, I'm going to assume that there is somewhere in this

a file called hello .c. So you should not type make hello .c. You just type

hello. And then this third command, even more cryptic, what might it do?

If this is step three of three, that's going to run the machine code. It's

to tell the computer in this folder, sort of the dot implies this current

folder, and dot slash just means something in this current folder, run

program called hello.

So that's it. There's three steps to writing a program in C.

You create the file, as with the code command, but there are other ways to do

that too. And you don't even have to use VS Code. You can use dozens of other

alternative programs in the world. You run the compiler, which in this case is

called make.

Little white lie, make is not actually the compiler.

But more on that next week. But make is going to trigger compilation of this

code. And the last step three is to execute or run the program called hello.

So let me go back to VS Code here.

And you'll see that my code is still at the top. My terminal window is at the

bottom. I hid my file explorer, just because it's not that interesting

And I'm going to do what you proposed, which was m -a -k -e space hello, all

lowercase, Enter.

And ironically, thankfully, nothing happened.

And that's actually a good thing in this environment. If nothing seems to

happen, you probably did good. If anything does seem to happen on the

you probably screwed up and you've made some mistakes.

So seeing nothing is generally a good thing.

But what has happened? Well, let me actually go back and open up my file

explorer. And notice there's not only kylo .c, but there's a second file now.

Hello, which is the name of the program.

So hello is the program I want to run.

I'm going to go back to my terminal here. And to run this program, I'm going

do dot slash H -E -L -L -O. I'm going to cross my fingers, as I'll often now do.

And voila, my very first program in C.

How else can we see this file?

Well, down here in my terminal window, let me zoom in, you keep seeing a dollar

sign. That has nothing to do with currency. It's just a weird geeky

that you're prompt at a terminal window. Like, where you type commands generally

starts with a dollar sign. Sometimes it's a hash symbol. Sometimes it's an

angled bracket.

It depends on the system you're on. But dollar sign is very common. It just

means type your commands here.

Well, I've typed code. I've typed make. And I've typed dot slash hello.

But I can type other things, too, and more on these later, like ls.

which doesn't actually spell something, but is short for list, L -I -S -T.

Programmers tend to just be as succinct as they can, so most commands are not

full words. They're often abbreviations. If I hit Enter now, you'll see also two

things. You'll see hello .c, and you'll see in green, just to draw attention to

it, hello as well.

The asterisk here just means, in the programming environment, this program is

executable. You can actually run this by doing dot slash hello. The fact that

this is just white here, that just means it's some text file. It's, in fact,

source code.

So in other words, ls lists the file in my current folder, or you can use your

human eyes in the file explorer at top left and just look at what files exist.

These are one and the same. One is a GUI, one is a CLI, graphical, command

and so forth. And we'll start to take these kinds of paradigms soon for

But let me pause here and see thus far, now that we've written our first of many

C programs, any questions or confusion we can clear up.

So OK, if you don't understand most of the lines of code, that's what today is

about. Yeah?

I don't really understand the difference between hello and hello .c. DAVID J.

What's the difference between hello and hello .c? So hello .c is literally my

source code. It is a file that exists somewhere in the cloud that contains all

of the code I myself wrote.

The hello file is the file that the compiler created for me by converting

source code to the machine code. So inside of hello, theoretically, is a

bunch of zeros and ones.

We can't quite see them.

But if I do this, let me zoom out.

Let me click on Hello and notice that VS Code is going to yell at me. The file

is not displayed in the text editor because it is either binary, that is

and ones, or uses an unsupported text encoding, whatever that means. If I do

open it anyway, but I don't recommend this, like heed these warnings, you

see zeros and ones, but you will see sort of nonsense.

And this is because VS Code is trying to interpret those zeros and ones

incorrectly as ASCII text, like English text, but it's not.

They're instructions for the computer. So as soon as you see scary red stuff

like this, undo, close whatever tab you open, because odds are you can only

break the program you just created. It's not a huge deal. You can recreate it,

but that's what's inside of those files.

Yeah? What if we don't type dot slash hello, we just type hello? DAVID MALAN -

Really good question. What if we don't type dot slash hello, we just type

Well, let me do this. Let me hide my file explorer again, because it's not

interesting here on out.

I'm going to clear my terminal window by hitting Control -L just to be neat and

tidy in class. Or you can literally type clear, and it will clear it. But again,

that's just to keep things tidy. Your TF might do that in section two.

If I just type hello enter, I'm going to get this. Weirdly, bash hello command

not found.

So more on bash down the line. But this just means literally the command hello

is not found because you need to tell the computer where it is.

So dot slash hello means run the hello program that is in fact, right here. By

contrast, you don't run .slash for code, for make, or other commands that we'll

soon see, like ls. Because why? Those are installed in the system for

not just in your individual folder. So that's the difference. Any programs we

write, it'll be .slash something.

All right.

So let's tease apart what is actually going on here and see if we can lean

heavily today on Scratch, especially as the syntax gets weird, perhaps a little

overwhelming, still the same idea.

So this last time, of course, was our Scratch program that just said hello

world. I claim today that this is the nearest equivalent that any programmer

could convert Scratch into C. If we color coded accordingly, indeed, this

of lines up with when green flag clicked is the orange, and then the purple is

just the equivalent of the say block.

So the say block we said earlier was a function.

So let's compare these things side by side, because there's actually some

and reason to what MIT did with Scratch as to why these shapes look like they do

and so forth. So in Scratch, there's a function called say.

Recall that it takes an input, otherwise known as an argument, or a parameter is

another name. And that's always provided in these white ovals, zero or more

white ovals. In C, we've already seen, but let's do it a little more

pedantically, the equivalent of say is essentially the word print.

Why did MIT say you say?

Just because.

It's a little more kid -friendly. But print is the idea in our environment.

It's actually not print. It's printf, because we're going to be able to format

our text in interesting ways. More on that in a moment. But notice, the

parentheses and closing parentheses here sort of conjure up the idea of that

white oval.

So that's kind of intentional on MIT's part.

What, though, in C goes between these parentheses? Well, literally the input

the argument you want to pass to the function, like hello world.

But in C, you have to be a little more pedantic because you don't have a nice

little graphic like this purple block with the white oval. You have to

everything in double quotes.

Those of you with prior programming experience, in C, you need double

not single quotes in this context.

And then there's this arcane detail here, backslash n, which we'll come back

in just a moment.

But that's essentially what's going on. Line by line, from scratch to C, there's

kind of an equality between those two, even though they, of course, look a

little bit different.

Well, let's see what that backslash n is doing, just to highlight some details

here. So let me actually zoom in a little bit here.

And let me go up to my code. And let me just sort of recklessly delete the

backslash n.

I'm going to let it autosave. I'll zoom out. In my terminal window now, I'm

going to run make hello to recompile the code from source code to machine code,

because I changed the source code.

Nothing seems to happen. That's good.

Now I'm going to type dot slash hello, Enter.

And there's a subtle bug since I made that change. What looks wrong to your

eye now?

Yeah, the dollar sign, our so -called prompt, is at the end of the line

of on its new line.

I mean, this isn't really a deal breaker. The code works, and you can

a new command. But it just looks a little stupid. This was not the intent

program. It's sort of good practice to move the prompt to the next line. And

that's because the backslash n is what we're going to call an escape sequence.

So it turns out in programming, you have to tell the computer exactly what you

want it to do. So if you want a new line, the equivalent of hitting Enter on

screen, you have to tell the computer computer to put a new line there.

What you do not do is this. If I zoom out and I go into my code here, and I'll

zoom in on the code, if you want to put a new line, you don't do this.

Why? It's just confusing for the computer. Like, wait a minute, is that a

Did your lines just wrap?

Do you want to put a new line there? It just looks stupid. And it makes it less

line -based, the code itself.

So humans decided years ago, if you want an actual line break, don't just

naively hit the Enter key.

Literally tell the computer, put a new line here.

If you want to move two lines down, just do two of those. If you want three,

just do three of those.

Well, why the backslash? Again, these are what are called escape sequences.

And you don't literally want an N.

let alone nnn, what you want is a new line which is represented in code as

simply backslash n.

Now, for the mathematicians among you, what we're doing now by using functions

like printf is just sort of like f of x notation, if you recall that from high

school or prior, where f is a function, x is an argument or an input thereto.

And we're using parentheses in code just like mathematicians would to write

functions like these.

And the types of functions we're using right now still follow this model.

got input. You want output.

In this case, the input to printf, for instance, just like the say block, is

what's called an argument.

Output, though, of the function printf is what we call a side effect.

And the easiest way to think about that is a side effect is just something that

sort of like happens on the screen.

Visually, audially, it just sort of happens. And there's that effect on the

screen. And we'll contrast this with other types of outputs from functions.

for now, we're focusing on just this, which is reminiscent, of course, of what

we did last week, which is if you type hello world into the white oval, use the

say. Puzzle piece, you get out the side effect of the cat appearing to have

said, hello, world.

Now, as for those escape sequences in C, there's bunches of them, but very few

of them will we actually use in practice.

Backslash n is a new line.

Backslash r is a little more subtle, and it's kind of a feature of yesteryear.

It moves the cursor not to the new line, but to the beginning of the line, kind

of like an old -timey typewriter, if you've seen how those work.

Sometimes, though.

you might want to print out an actual double quote.

But there's a problem, of course. If this is my code here, and I'm already

double quotes as sort of special symbols to surround the text I want printf to

say, it would probably be a little worse. Like, if you wanted to say,

world, with sort of finger quotes, why might this not be a good idea,

if you think about this from the computer's perspective?

Why is this probably not the right way to do this? Yeah.

Yeah, exactly. The computer is indeed going to read your code top to bottom,

left to right. And when it sees the first open quote, OK, that's fine. It

understands that. But when it gets to the second quote, it's going to assume,

oh, wait a minute. Maybe you only want me to say, hello, comma.

And then it's going to keep reading and be like, wait a minute. Why is there the

word world here? And then, wait a minute. Now there's two more quotes.

confusing. It's ambiguous.

And computers need you to be, again, very precise.

So if you want a quotation mark to literally be displayed on the screen,

would escape it, so to speak. speak, which looks a little weird and takes

getting into the habit of. But this just solves that kind of problem.

And similarly, might you use single quotes in other contexts? More on that

And if you really want to bend your mind, how do you actually print a

backslash if you ever care to? It's not that common a character to type. But if

you ever want it on the screen, it seems that we're using backslash as a special

character that says, hey, give me a new line, or give me a carriage return, or

give me a double quote.

Weirdly, in programming, if you want to type a literal backslash, on the screen,

you literally do backslash, backslash. But that's it for sort of weirdness for

now. But this is to say, humans tripped over the same problems years ago. They

came up with solutions.

And now we indeed have these conventions in code.

All right.

So let's tease apart some other features of this in every program we're going to

write, namely what's at the top of this file.

So at the very top of this file, there is this cryptic -looking hash include or

pound include standard IO dot h in angle brackets.

So this is a little weird. We'll talk more about this next week, too. But this

is what's called a header file.

Any file that ends in dot h is not a

Source, well, any file that ends in .h is what we're going to call a header

file. And inside of that header file is functionality that maybe came with the

system, came with the programming language itself.

So for instance, I'm going to do this.

I'm going to go back to my code here, and I'm going to make a very common

mistake that you yourselves might make in the coming days, where I just forget

that line, because I don't even understand it in the first place, so I

didn't think to type it here.

Now, if I go back to my terminal window after clearing it, and I run make hello,

because I want to recompile it, because I've changed the source code, I'm going

to see a fairly cryptic error. I mean, there's more error on the screen than

there is code up here.

But you'll get the hang of sort of reading it to try to figure out what's

on. And I'm seeing this.

Hello .c line 3 character 5.

So that just means line 3 colon character 5 from left to right. It's

visual cue as to where the problem is.

Call to undeclared library function printf with type dot, dot, dot. And then

rest kind of overwhelms me visually at this point.

But that's a hint.

If you do not include that header file at the top of the code you've written,

you do not have access to what's generally called a library.

A library is a collection of code that someone else wrote for you. Maybe it was

MIT. Maybe it was the authors of the C language itself years ago. Maybe it was

CS50 if we wrote some code for you. A library is a collection of code that

someone else wrote for you. And you access it again by including header

that those same people wrote for you.

So if I go back to my code now, let me clear my terminal window just to be Less

overwhelmed. Let me undo what I just did and put that file back.

Can you perhaps infer, just functionally, what is inside of standard

again, someone else wrote?

What must be inside?

Printf. So whoever invented printf decades ago probably put that code in

file. And so by including it, so to speak, in my code, I now have access to

printf functionality.

So that's all. And again, C is lower level than Scratch. It's obviously text

-based, which means you have to be a little more pedantic yourself as to what

you want the computer to do for you. And if you want to use someone else's code,

you indeed have to include it. Scratch didn't bother with this, but we indeed

need to do this in the context of C.

As an aside, just to preempt some unnecessary headache, this word is not

.h. Every year, a non -zero number of people can't understand why their code's

not working because studio .h is not found. It's standard io, s -t -d -i -o

That's one of the first frequently made mistakes otherwise.

All right, so remember that. Let me undo now the unnecessary quotes I added

here. And let me propose that.

We show you where you can learn more. So all of these libraries generally are

documented. People wrote instructions for how to use them. So you don't just

have to listen and pay attention only in class. You don't have to pull up a

book. There tends to be online documentation as well, for instance, for

standard IO header file.

And the documentation in the world of programming for C specifically, are

manual pages, or man pages for short.

Unfortunately, they're really written decades ago for the more comfortable

you, those who have an eye already for programming.

And so what CS50 has done at this URL, manual .cs50 .io, is we essentially have

more user -friendly versions of the documentation for this header file and

others. So for instance, if I pull up manual .cs50 .io, you'll see a web page

like this.

And if I just scroll quickly, you'll see a whole bunch of header files, .h

files, and a whole bunch of functions beneath them. And there's only a couple

dozen or so here. And indeed, per this checkbox at the top, frequently used in

CS50, we have sort of highlighted the functions that odds are over the next

month and a half you will probably want to use.

If I turn off that less comfortable mode, there's actually hundreds of

that come with C. And no programmer knows all of these functions. What they

is they read the manual when they want to find some new piece of functionality.

So I'm going to simplify this. I'm going to scroll down, though, to standardio

.h. for instance, here. And you'll see more functions that we'll eventually get

to. But if I click on printf, you'll see, hopefully, some fairly user

instructions for how this thing works. For instance, under synopsis, you'll see

that we tell you what header file you should include in order to use it.

Below that is something called a prototype.

More on that later.

But below that is a description.

And here is where we, the CS50 staff, have written in layperson's terms

explanations of how this function works, how to use it, and so forth.

But if you'd rather see what the real world uses, you can turn off that mode,

and you'll see much more arcanely the original language.

So in short, these are sort of like training wheels that you can turn on and

at your leisure.

But ultimately, this is real world documentation as well.

So if we want to see something else, for instance, let me go back to the main

menu. And as we'll see today, there are actually function in a header file

called cs50 .h that, for a few weeks, we're going to lean on heavily.

Long story short, it's actually kind of hard. It's annoying in C to get user

input, ironically, to get the human to type in a word or a number.

You have to jump through some technical hoops to make that happen. And we'll

show you how to do it the real way in a few weeks. But for now, among the first

training wheels is a CS50 library code that we wrote that will just make your

life easier.

And indeed, we're going going to give you access to functions that simplify

process of actually getting input from the user. So case in point, we're going

to give you access to a function like getString when you want to get a string

text from the user. String is just text. So if you want to get one character,

one word, one sentence, one paragraph, you can call a function called

We're going to give you another one called getInt when you want to get an

integer from the user, like 1 or 0 or negative 1 or anything else. You can use

that function as well. And we'll see today, too, there's other functions you

use from CS50's library.

In a few weeks' time, we'll take these away once you sort of don't need them

anymore. And you'll see what those library functions have been doing all

for you. But for now, let's focus on this.

perhaps the most useful of them, getString, and solve a problem that we

already pretty easily in Scratch. So recall in Scratch, this was a program

used two functions.

Three, in fact. Ask, to ask a question of the user.

Say, to actually display something on the screen. And join, to combine the

default of Apple banana, or in this case, hello, and whatever the human's

was. So this made our hello program a little more interactive last time. How

we actually translate this into a similar paradigm now? So input and

the story as always. In this case, we have arguments going into those

But now we're going to introduce not side effects, which is stuff that

visually. We're going to revisit that blue circle called answer or the blue

called answer that represented last week what we called a return value.

And this is what many functions will actually do for us. They're not just

to display something presumptuously on the screen or play a sound or a video or

something like that. They're going to hand you back virtually a value.

text or integers or sounds or images that you can then do with what you see

So the paradigm we'll now have is, much like in Scratch, if the input is what's

your name and the function is ask and you get back a return value of answer,

want to actually do this now in C.

So side by side, what code like this in Scratch is going to look like today

onward is this.

Instead of using the ask block, you literally use CS50's function called get

string. It takes input.

So we put the parentheses on the left and the right to kind of conjure the

of this white oval.

Inside of that string, you can put a prompt, so to speak. Like, what do you

the human to be asked in this case?

And I'm missing something still, per the placeholders here. What's missing?

So quotation marks, so literally quotation marks on the left and the

I'm going to be a little anal here. I'm going to put a space at the end because

I don't want to. I could, but I don't want the cursor to go to the next line,

hence no backslash n. If I want the cursor just to sit there kind of

waiting for the user after the question mark, I'm just going to put a space so

it will stay there for me. But this is just an aesthetic detail using the same

idea as before.

So that is the analog of this block.

But how do I get access to the so -called return value?

MIT just plopped it on the screen for me. for us automatically.

In C, we have to write a little more code to get access to that return value.

And the way we do this is on the left -hand side of this line of code, we come

up with a name for the return value.

You can call it anything you want, but answer is a nice equivalent to what MIT

did. You could more generically call it x or y or z, but that's not really

useful. And so computer scientists, unlike mathematicians, will tend to use

variables that are a little more verbose, like the word answer.

But in C, it's, again, a little lower level. You have to tell the computer

type of variable this is going to be.

So I'm kind of conflating variable and return value, but they're being used in

an intertwined way.

The get string function, just like the ask block, returns the value.

If you want to do something with it, you need to put it in something called a

variable, which is denoted in text here.

But again, per last week, the computer doesn't know if it's looking at numbers

or characters or images or sounds. You have to tell it as the programmer that

the zeros and ones that are somehow involved here underneath the computer's

are, in fact, to be treated as text, a .k .a.

string.

Now there's one stupid subtlety still missing from this line of code. Does

anyone know, especially if you've programmed before? OK, all of you have

programmed before. Yes?

semicolon. So one of the headaches of C in a lot of languages is you actually

have to finish your thought explicitly so the computer knows that that line of

code is done. And it's not a period like in English. It's, in fact, a semicolon.

Now, you don't use these everywhere.

We'll see where you use them. But that, too, is a very common mistake to

overlook something simple.

But again, in the coming weeks, even though this might look very cryptic with

muscle memory and practice, you'll start to see these things instantly, even if

for a few days you sort of bang your head against the screen, so to speak.

seeing what the TFs and I much more readily see.

So let's go ahead and do this. Let me go back over to VS Code here.

Let me zoom in just a little bit.

And let me go ahead and do this.

I'm going to get rid of my single use of printf. And I'm going to say the exact

same thing. String answer equals get string quote unquote what's

your name question mark space close quote.

semicolon, and now I want to print out that answer. Well, let me do this

incorrectly deliberately for the moment. Let me just say printf quote unquote

hello answer if I want to plug in answer and I want to add a new line at the end

semicolon. So let me try this.

But there's multiple mistakes now in my code. Let's trip over them deliberately.

Let me go down to my terminal window by clicking at the bottom of the screen.

Let me run make hello again, Enter.

And oh my god, there's even more errors now than there were before. But not a

problem. Let me click on this little triangle here, which is just going to

in on the terminal window so it takes up my full screen.

And just generally, all you have to do is find a few keywords visually that

you a clue as to what's going on. Or as before, you can always ask the CS50

duck. So here's the command I ran, make hello.

Somehow that induced all of these errors. Always read them top to bottom,

bottom up. So from top to bottom, there's a problem on line 5, character

of undeclared identifier string.

Did I mean standard in? No, no, no. I didn't there.

And then also, two errors generated, too many errors remitted.

What did I do wrong?

Well, it turns out what I do need to do at the top of this file, let me click

the triangle to zoom back out.

If I want to use the get string function to get a string, I actually need to

include another header file, which is probably called include CS50 .h.

Technically, any order is fine. I tend to alphabetize because I just know,

therefore, where to look alphabetically for a certain header file.

Now that that's in place, let me again run make hello, enter.

And now we're back in business.

No error message.

So even though you might have more errors than you have code, odds are it's

the computer is confused, and it could be something simple and an easy fix like

that. So just to be clear, standardio .h, because I'm including it, I can use

printf. CS50 .h, I can use get string, because the people who invented C and

people who invented CS50 wrote those two files, so to speak.

respectively. All right, unfortunately, even though the program compiles, that

doesn't mean it's correct.

It just means it's syntactically valid. It's valid C code. If I go ahead and run

dot slash hello and hit Enter now, I'm going to be prompted for my name. So

type it, D -A -V -I -D. And notice there's a space to the right of the

mark, as promised.

Enter. But it just says hello answer, which of course is not the intent. I

wanted to say hello.

David. So how can we do this? Well, in Scratch, it took a couple of puzzle

pieces, but it was pretty straightforward.

If I wanted to say the combination of two phrases, hello and something else, I

joined those two and then passed that output to the input of say.

In C, it's going to be a little different here.

Just because it's an old language and this is how it's done.

Still use printf, because that's the same thing as say.

I got my parentheses. I got my semicolon. Good to go.

But inside of that, this is where printf is different.

If you want to say something followed by something else, in the world of C, you

tend to use placeholders.

So you don't just join things together, as we will do in Python and other

languages. You say to the compiler,

give me the word hello, comma.

and then something else. And the %s means put another string here.

It's sort of like leaving a placeholder in your code or a template where you'll

actually plug in some values.

Now, if this is what I want to display, I still use my quotes as before.

And I might, in fact, have a backslash n if I want to move the cursor to the

next line.

But this is where printf is a little different.

Unlike say, which took one input, Printf is kind of like join. It can take two

or more input if you so choose.

You just have to separate them with a comma.

So much like the join block has two ovals here that are initially white,

and banana, until we dragged and dropped answer on top of it, printf and really

any function in C, if you want to pass in multiple inputs, that's fine. If

they're supported, just separate them with commas. There's no multiple

parentheses. There's no multiple ovals. Just separate them with commas.

And now notice a potential point of confusion.

What's different about this comma and this one, just instinctively?

Sort of minor detail, but important. Yeah?

Inside. DAVID J.

So one is inside, one is outside. So the one that's inside the quotes is

literally the English grammatical comma that you want the human to see. The one

out here is a C thing that's separating the first input to this function printf.

from the second.

Strictly speaking, you don't need a space there. But it's good practice,

stylistically, to separate your arguments with single spaces, just as

there. So let me go ahead and now do something with this. Let me go back to

code here.

I'm going to clear my terminal window, just to get rid of that distraction.

And now I'm going to change answer to %s.

And then outside of the double quotes on line 7, I'm going to do comma, answer.

And then after it autosaves, I'm going to go back to my terminal window.

And just to make another deliberate mistake, dot slash hello, enter.

What's your name? David, enter. It's still broken.

But why?

I still have to recompile it. So again, you just get into the habit. When you

change your code, you have to recompile it so you get new machine code in the

file hello. So let's do it again.

Make hello.

No errors is good.

Dot slash hello, enter. What's your name again?

D -A -V -I -D. And now, hello, comma.

David. So again, a lot of this is still cryptic, but it's going to start to

follow patterns like this. Functions like in math class f of x are written

function name, parentheses, input, comma, input, comma, input, however many

have. They're going to follow these patterns. But notice too, on line six

seven, I have finished each of my thoughts with a semicolon.

So what are the other commands that you can run in your terminal window besides

something like ls? Well, it turns out there's a whole bunch of them. LS, of

course, was simply short for list, which shows you the files in your current

folder. But there's also CD for change directory, which is the command

equivalent of double clicking on a folder to open it up in a graphical

environment. There's CP, which is short for copy, which allows you to make a

copy of a file or folder.

There's Mkdir, M -K -D -I -R, which is short for make directory, which is how

you could make a new folder.

There's MV, which is short for move, which would allow you to move one file

folder. folder from one place to another or simply rename one of those to a

different name. There's rm, which is short for remove, and there's rmdir,

is short for remove directory.

So in fact, let's play around with a couple of these.

Let me go back to VS Code here.

Let me go ahead and open up my file explorer and recall that at this point,

got two files, hello .c, which contains my source code, and then hello, which

contains my machine code, the executable program that I previously generated by

running make.

Well, let me go ahead and propose that I'd like to

prepare to keep all of my files and folders very orderly. So for every

write or for every problem on a problem set I write, maybe I want to store my

relevant files in a specific folder for that problem.

So suppose, then, that I want to put hello .c in a folder, otherwise known as

directory, called hello.

Well, I can't do that quite yet because I already have a program called hello.

So let me use one of those new commands, rm.

space hello will delete or remove hello from my current directory. So I'm going

to hit Enter. I'm going to be prompted to confirm with y for yes or n for no,

remove regular file hello. I'm going to hit y and Enter. And as I hit Enter,

watch the top left of my screen as the hello file would seem to disappear.

Voila, it's now gone.

So now I'm going to go ahead and use a different command. Let me go ahead and

mkdir for make directory.

I'm going to call the directory itself hello. And watch again at top left what

happens. Enter.

Now I have not a file, but a folder called hello. And in this GUI, the fact

it's a folder is indicated, one, by its icon, and two, by that little right

-facing triangle, which means I can expand it to see what's inside.

And in fact, if I do that, I'll see, of course, that nothing's in it, because we

literally just created it.

All right, well, what if I want to move?

Hello .c into the new Hello folder. Well, I could, just like on Mac OS or

Windows. I could actually, in my file explorer, click and drag one into the

other. But let's do this entirely within the terminal window.

So let me do this. Let me move, or MV for short, my file called Hello .c into

new destination folder.

And I can optionally put a slash at the end of hello just to make super clear

that it's a directory, but that's not strictly necessary.

But if I say mv hello .c hello with spaces in between, assuming hello exists

a folder, watch what happens at top left now. It's a little more subtle, but

hello .c is going to move inside of the hello folder right now.

And indeed, it's only slightly more indented. But notice if I collapse the

folder, notice that it seems to be gone because hello .c is now inside of that

folder. Of course, if I expand that, I'll see it again. If I go back to my

terminal window and type ls for list, now I don't see Hello .c. And I don't

an executable program anymore, but I do see hello. And the slash there just

makes super clear to me, the user, that it's indeed a folder.

So how do I change into that folder?

Well, I can obviously use the graphical interface at left and click and expand

and sort of see what's going on. But there's no direct connection between the

file explorer at top left and my terminal window at bottom right. Rather,

are just two different ways to explore the underlying system.

So if I want to change my terminal window into this new directory, I can do

for change directory, hello, and then enter. And now notice my terminal

prompt changes slightly.

There's still a dollar sign, which indicates type my commands here.

But before that dollar sign, just so that I have a reminder, sort of

that visually remind me what folder I am now in, I see that I'm inside of hello.

If I now type ls, I should see the file I expect to be in there, which is indeed

hello .c.

Now, suppose I want to try out some of those other commands. And suppose I want

to maybe rename this file. I really want this file to be called something else.

So maybe I might do something like this, mv hello .c space, and now a new name

for the file.

Well, maybe I want to save this as an old version of my code, because I wanted

to start fresh with something new. So I could do something like this, mv hello

.c old .c.

And watch what happens at top left.

Hello .c, of course, gets renamed via the move command.

So I can use move to move a file into a folder, or I can use it to rename a file

or folder, as I've just done here.

Now, suppose I want to undo that. Well, I can't just type undo. I can't just hit

Control -C, but I can do the opposite, in effect.

mv old .c hello .c will now, per top left, Change it back into that file.

If I want to make a copy of this file, maybe as an actual backup, because I'm

really happy with this version and I'm worried about breaking it, well, I could

do cp for short. I can then do hello .c. And then I can do something like backup

.c or any other file name. I'm taking care to use the same file extension so

that if I do open this file later, it still opens and gets highlighted and

colorized in the same way. But watch what happens now at top left when I type

Enter. I now have two files in this hello folder. And indeed, if I type ls

I can see exactly the same.

So long story short, there's this whole list of commands, and even more than

these, that allow you to manipulate the underlying system in exactly the same

way that you and I have probably done for years by using a mouse and pointing

and clicking and double clicking.

But for now, let's undo all of this, because I haven't really written that

programs today. And I'm going to keep things simple today and keep everything

my same folder. So let's undo all of this.

Let me go ahead and now remove backup .c, because I don't particularly care

about that. I'm going to be prompted to confirm as much. Then let me go ahead

and move hello .c out of this folder and into the original folder. And

conceptually, the original folder is what we would call the parent folder,

folder that contains this hello folder.

And the way you can specify the parent folder, like back up from once you came,

is with .dot. So a single dot, as we've actually seen, .slash hello, .slash a

.out means execute a program in this directory, dot. But .dot refers to to

parent directory.

So watch what happens at top left when I move this hello .c file out of this

folder.

shifts a little bit to the left to indicate that it's no longer in that

I'm going to go ahead and type cd dot dot, which will bring me back to my

folder. Or even more useful, especially if you get confused or lost somewhere

within your folders, you can actually just type cd and nothing, and that will

whisk you back to that original folder no matter where you are. So it's a nice

shortcut, and it's a nice way of undoing any confusion you might have caused for

yourself. Lastly, let's go ahead and get rid of the hello.

directory with rm dir hello enter.

And that now disappears at top left as well. Now, what I was hinting at here,

whereby I had my hello .c file in a folder and I was moving things around

renaming things and backing things up isn't strictly necessary because there's

actually other features still inside of VS Code that you're welcome and

encouraged to play around with. In fact, if I go to my so -called timeline at

the bottom of my file explorer here, you can actually see that there's been

automatic backups made over time of this file. So if you click, click, click

through those backups, you can actually see different versions of the same file

slightly in the past, which might save you the trouble. of having to manually

create files.

And in fact, in the world of software development in industry, there's

standard tools very similar in spirit to what we've been using GitHub for that

allow you manually to make different versions of your code so that you can

proactively keep track of all the changes you've made without manually

things as you might typically on your own Mac or PC.

All right, let me clear my terminal window and ask if there are any

Yes, over here.

DAVID J. Yeah, a really good question. If we had something other than a string

of text, and we had an integer, would you still use %s? No, you would use

something else. And indeed, %i is what we're going to use, and we're going to

actually do that.

Perfect segue to other types that C actually has.

So up until now, we've been calling a string of text literally a string. And

this is common in many programming languages, including Python and

Strings in the programming world just mean text.

whether it's zero or more characters thereof. But C does have other data

just a few of which we'll dabble with today, but you'll use more over time.

We've already seen string, for instance, which is indeed a string of text. But

let's focus as well on an integer.

As an aside, there's other types, too. There's Boolean values, like true or

false. There's chars, which are single characters instead of full phrases or

sentences. There's doubles and floats, which are real numbers, something with a

decimal point, the equivalent of fractions.

And there's longs. which are integers, but longer integers, even bigger

than you might type by default. So let's focus on ints, because so many computer

programs, of course, manipulate numbers in some way. So what can we do with

this? Well, if we want to be able to get an integer, lucky enough, CS50's

library comes not just with get string, but also get int. So that's going to be

a third function we now use in C.

And we need to know what are generally called format codes. So that placeholder

I called before %s is indeed for a string. If we want to place an integer

of something we're printing to the screen, We are, in fact, going to use %i

instead. So let's now actually use these building blocks, get int and %i, to

actually get numbers in some way to sort of solve a problem.

Well, what problem could we solve? Let's introduce another concept from scratch

and programming more generally known as conditionals, like those proverbial

forks in the road. If something is true, do this.

Else, maybe do this other thing. So in Scratch, we might have had a set of

puzzle pieces that looked like this. If x is less than y, then say, or have the

cat say, x is less than y.

So it's sort of a stupid program, but it just demonstrates how we have two

variables, x and y, in the context of Scratch. We're comparing them with a

Boolean expression.

We're using a conditional to then conditionally say or not say this phrase

depending on whether this question has the answer of true or false, yes or no.

In C, it doesn't look all that different. It's a little more cryptic,

say literally if.

You use parentheses, similar to functions, but confusingly, by

put a space after the word if. So you don't put spaces after function names.

do put spaces after words like if. And you use the parentheses to conjure up

this weird trapezoidal -like shape. So there's no real keys that kind of

that. So C uses parentheses, like most languages.

And then there's these weird curly braces, which, at least in English, we

use all that often. But they're there on your keyboard, English or otherwise.

And they essentially allow us to create this sort hugging shape to the puzzle

piece. Anything inside of those curly braces is going to be equivalent to

anything inside of this yellow hug that's sort of grabbing one or more

inside. So what do we put inside?

Well, this part is straightforward.

Printf, quote unquote, x is less than y, backslash n, semicolon. So nothing new

here. The only bit of new code is this if construct instead.

What if you have an if else, so a two -way fork in the road? This is what that

looked like in Scratch.

Same question. If x is less than y, then say x is less than y. Else, say x is

not less than y.

In C, the code is going to be set up initially like this. So two sets of

braces to represent this pair of yellow bars and this pair of yellow bars.

And what's inside of them, indented no less, just like our pseudocode last

is two printfs. x is less than y.

x is not less than y.

So that's it. So the only new stuff here, really, is now the else.

keyword, which does not need parentheses, because you're just saying,

this other thing.

But what if it's a three -way fork in the road? And we'll stop after that.

Here's a three -way fork in the road in Scratch. If x is less than y, then say

this. Else if x is greater than y, say this.

Else if x equals y, then say this.

So this is a little more precise, because now we're handling equality, not

greater than or the opposite.

In C, it's going to look similar to before, but we're adding this element

And at first glance, especially if you've never programmed before, it looks

I'm an idiot and I made a typo.

What looks wrong?

There's like two equal signs, like not a typo. So it turns out Recall from

earlier, when we used the equal sign the first time around, we used it in the

context of getting a return value back from a function, like the get string

function handed me back the user's answer.

So unfortunately, because humans decades ago decided, hey, let's use the equal

sign to assign a return value from the right -hand side of a line of code to

left -hand side, we sort of painted ourselves into a corner and were like,

shoot. What do we do when we actually want to test for equality of two values

the left? left and right. So what most languages, including C, do is use double

equal signs. So you can say double equals or equals equals or whatever, but

is, in fact, syntactically correct.

What's inside of these three sets of curly braces?

Same idea, printf, printf, printf, based on what English phrase you want to

print out.

So this code, both in Scratch and C, I'll claim is correct.

It won't run because we still need the other stuff, the equivalent of the when

green flag clicked. But out of context, this code is correct.

But there's a subtle weakness in design.

And we'll talk a lot about this this week and beyond. Correctness just means

code does what it's supposed to do.

Design is more subjective, like how well have you written your arguments in an

English paper? How well have you written your code is design.

This code is not designed as well as it could be, because I'm doing more work

than I need to.

Yeah, and back.

Yeah, I don't need the x equals equals y, but why, logically?

Exactly. That's just a math thing. Like either x is less than y.

Or it's greater than y. Or the third and final option is they must be equal.

So it's subtle.

But why would you bother wasting time writing a line of code and expecting the

computer to run a line of code that is just going to answer a question that

logically you could have concluded already?

Because if x is not less than y and x is not greater than y, then my god, just

print out x is equal to y because you know at that point logically it's true.

You don't need to waste your time or the computer's asking a third question

unnecessarily. In reality, it's not a huge deal. No one's going to notice in

real world on a Mac or PC that there's this extra line of code. But it's a bad

habit. Keep it simple. Don't write code that doesn't need to be there if

logically you can conclude otherwise. So in fact, let's clean this up both in

Scratch and in C. I can tighten this up, so to speak, use less code here, less

code here.

And honestly, if only statistically, the less code I write, the less likely I am

going to make mistakes.

So that too is probably a net positive.

overall. Writing less code is generally better than writing more code, not

unlike English essays, too, perhaps.

All right, questions about this feature of C, conditionals, and this syntax?

Yeah.

Oh, a really good question. And yes, jumping the gun, there are alternative

to solve problems like these. And the question was to summarize when to use

else, if, else versus what's called a switch statement. More on those another

time. But this is going to be true in general in programming, not just C, not

just in Scratch, but every language.

There are going to be several.

dozens, hundreds, an infinite number of ways to solve problems. Among the things

we're going to teach you, though, is indeed how to do things well or better

you might otherwise.

And we're going to introduce you eventually to another feature of the

that can even simplify this code too.

So for now, let's actually use this then. So let me go over to VS Code

I'm going to go ahead now and clear my terminal window.

Down here, I'm going to go ahead and close the hello .c tab, just so that

going to create a new program. And let's just do something a little simple using

some operator, so to speak. And I haven't used this word by name, but it

out that there's lots of operators that come with C, just like a lot of

operators that came with Scratch for doing assignments or less than or less

or equal to, greater than, greater than or equal to, actually equal to, not

equal to. Now, some of these are a little cryptic, but There's no easily

key on your US English keyboard, at least, where you can do less than or

or greater than or equals. So what most programming languages do is you don't

use a special symbol where there's an angle bracket and then a line below it.

You actually just use two characters.

So greater than or equal is literally this this. Less than or equal is

this this. We already saw that equals is this this.

And not equals is to use an exclamation point. So this, too, is a thing in

programming. Using the exclamation point, pronounced bang, is how you

logically certain things. So bang equals or not equals is how you would express

exactly that idea.

It's just a symbol on the keyboard that some human decided, let's use this one

to invert the idea.

But we're going to need one other thing for this program, specifically

variables, which we've used already sort of because in Scratch we got one for

free. We had that answer variable that stored the return value of the ask

But let's consider in general how you can, and probably did for problem set 0,

use a variable of your own, like keeping track of a counter or a score or the

like. In Scratch, if you want to create a variable called counter, you can set

it equal to some initial value like 0.

In C, that code's going to look similar.

You literally just write whatever name you want to give the variable, then an

equal sign, and then the value you want to give that variable.

And because the equal sign is the assignment operator, it will behave

essentially right to left and copy the 0 into counter.

But this isn't enough for C.

Remember that you, the programmer, have to tell the computer, is this indeed a

number? Is it a letter? Is it an image? Is it a sound?

You have to tell the computer that this is an integer.

otherwise written as int for short in C.

But there's one other stupid detail that's missing, which is now semicolon

finish the thought here.

But this, then, is equivalent to this in Scratch. Let's do another. In Scratch,

if you wanted to increment the counter, that is, add 1 to it, you could

literally use this puzzle piece here and specify you want to add 1.

In C, it's going to look like this.

Counter equals counter plus 1 semicolon. Now, at a glance, this seems like a

paradox of sorts. Like, how can counter equal counter plus 1.

I can't make that math expression true, but it's not math in this case. The

single equal sign is assignment.

So this means take the current value of counter, whatever it is, add 1 to it,

and then copy that value from right to left into the same variable, thereby

changing it from 1 to 2, 2 to 3, and so forth.

This, though, is so common in programming, to be able to increment or

decrement numbers by 1 or 2 or more, is that you can tighten it like this.

This is the exact same thing, a little faster to type, saves you keystrokes,

maybe less chance for error.

Counter plus equals one semicolon is the exact same idea.

Better still, this is so common in C and C++ and Java that there's a third way

to do this. To my comment earlier about solving problems in different ways, the

most canonical, the most popular way is probably just to say counter plus plus

semicolon, which literally automatically adds one semicolon.

to that value. Only works for one. If you want to do two or three or some

increment, you have to use one of the other approaches.

But this simply does the same thing as this.

And if you want to invert it to negative 1, you change the plus plus to a minus

minus instead.

So again, just little things that we'll see and pick up over time.

Invariably, you'll have to look them up or check the notes or look back at the

lecture slides.

But in time, this will get familiar if you are not already familiar.

So let's consider just logically.

how we might implement this in code. Let's go back to VS Code here. And let

propose that we create a program called compare .c, whose purpose in life is

just to compare a couple of values.

I'm going to go ahead and proactively, based on the previous chat, include

CS50's library from the get go. I'm going to include standardio .h from the

go, so I can use get int and printf respectively.

I'm going to just on face type int main void.

And today, we won't explain what that does. More on that to come. For now,

assume it's like when green flag clicked.

But in this program, let's do a couple of things. Let's declare an integer

called x and assign it the return value of get int. And let's just keep it

simple. Let's ask the user not what's their name, but what's x, question mark,

semicolon. Now, so that we have something to compare, let's do it again,

with y.

int y equals get int, quote unquote, what's y, question mark. And I'm

again, a space just visually so the cursor nudges over a bit, followed by a

semicolon. At this point in the story, my users will be prompted for x and y,

respectively. Let's do something with those values. How about if x is less

y, then go ahead and print out, quote unquote, x is less than y,

backslash n, close quote, semicolon.

All right, and let me hide my terminal window for just a moment. This is a 13

-line program at the moment, but really it's like five or six interesting lines.

The rest has been copy -paste from previous programs.

Notice a few details.

One, I've indeed used my curly braces here.

And notice if you highlight lines, you'll actually see little dots that can

you make sure, oh, there are indeed four spaces there.

I've been indenting, just like we did last week with pseudocode.

Strictly speaking, it's not necessary, but it's going to be way easier to read

your code if you do add all of this white space, so to speak, than if you

and then submit to us as homework a program that looks sort of god awful

this, which is to make it much more much harder for the human to read it, for

you to read it, your colleagues in the real world to read it. But the computer

is actually not going to care. In fact, as an aside, one of the tools we have

built into VS Code for CS50 is this button at top called Style 50.

This is a program that we indeed wrote that will give you suggestions on how to

improve the style of your code so it looks like the right way that

would generally write it. As an aside, The computer world is fraught with

religious debate, so to speak, as to what code should look like. And people

the real world will have really stupid arguments over how many spaces to use

indentation and what lines code should go on and so forth.

Generally, in the real world or in a class, there's an official style guide

someone sort of autocratically declares, this is how everyone should write their

code, so that just everyone's code in the company or course looks the same.

you'll find in the real world,

reasonable people will disagree.

When you click style 50, it will be formatted as we ourselves recommend in

And in fact, let me zoom out here.

And this looks a little cryptic at first glance, but on the left is the code

that I just wrote and made a mess of by deleting all that white space.

On the right is the way the code should look if it is well styled.

So whereas correctness is all about does the code work the way it's supposed to,

design is about how well have you written that code?

Is it efficient?

Did you make good decisions?

Style is purely aesthetic.

Is it readable?

Does it follow a standard?

Can another human sort of easily skim it top to bottom, left to right, and

understand what's going on? So these green highlights are saying, please add

white space there.

And so I can actually change my code to match.

On the left -hand side here, if I realize, oh, my code's looking pretty

watch on line six at left as I hit the space bar to, whoops, sorry, on the

1, 2, 3, 4.

Notice that the right -hand side is starting to be happier with my code by

getting rid of the green indicators.

And I can do 1, 2, 3, 4.

That fixed that. Over here, I can do 1, 2, 3, 4.

I can move this onto its own line by hitting Enter.

And you know what? If it's taking too long, once you get into the habit of

things, you can just apply changes. It will give you the suggestions

automatically, and we're done and on our way. But for practice's sake, I would

get into the habit of doing things manually until it gets boring and

which point you might as well automate the process with a single click.

All right. So let's actually run this code. I'm going to go ahead and open my

terminal window again and clear it for clarity.

I'm going to run make.

Compare and hope that I didn't make any mistake.

I don't seem to have yet.

Dot slash compare.

And now notice I'm prompted. For x, let's type 1.

For y, let's type 2.

Enter. And x is less than y.

Let's do a little sanity check, so to speak. Let's rerun it. Dot slash

What's x? Let's do 2 this time.

1 for y.

And this time it said nothing.

So that's to be expected, because I didn't have a two -way or a three -way

in the road. The only time this code should say anything is if indeed x is

than y.

So for those of you who might be more visual when it comes to learning, here's

flow chart that represents this same exact program.

If you read it top to bottom.

You start the program with dot slash compare.

You are then prompted for x and y, and you're asked this. Is x less than y?

And the fact that this is a diamond means this is a Boolean expression, a

question that the computer is asking itself.

If the answer to that question is true, then quote unquote x is less than y gets

printed, and the program stops.

Else, if x is not less than y, as in the second scenario, the answer is, of

course, false, and nothing more happens.

But we can build out this tree, so to speak, by adding a bit more code. So

make it look like the second Scratch example.

If I go back here, it's not hard to just say, else if x is not less than y,

let's say that.

x is not less than y, backslash n, close quote, semicolon.

Let me now go ahead and rerun, make, compare, enter, dot slash compare,

And again, I'll do the second example, 2, which is bigger, and 1, which is

smaller. And this time, I will see.

x is not less than y.

If then we were to look not at this flow chart, but a slightly bigger one, you

can sort of visualize it this way. Everything in the left -hand side of

picture is the same.

But if it's not true that x is less than y, the answer is thus false. This time

we say, quote unquote, x is not less than y.

And we can do this, obviously, one final time just to bring the point home. If I

go back to my code.

And I even more pedantically compare these three values.

Let me go ahead and do this.

So else, I don't want an else, actually. So let's go ahead and do this.

Else if x is greater than y, let's then say x is greater than y

in English. And then finally have an else that says printf x is equal

to y.

close quote, or rather, backslash n, close quote, semicolon. So just to show

this all on the screen at once, this is identical now to that Scratch version.

It's well -designed, because I'm not asking the equals equals question

unnecessarily. If I go back to my terminal window here, clear the screen,

make compare, Enter, and then dot slash compare again, Enter.

What's x? Let's do 1.

Let's do 2.

x is less than y. Let's run it again.

Dot slash compare.

What's 2?

And 1, x is greater than y. Once more time, dot slash compare.

What's x1?

What's y1?

And now x is equal to y.

As an aside, if I seem to be typing fairly fast, you can actually kind of

with your keyboard. If you go up or down, you can scroll through all of the

commands that you've typed. So it's actually.

Excuse me, very useful. If you just hit up, it will pre -write the previous

command for you, at which point you can just say enter.

Or there's other fancy features built into this programming environment.

If you do dot slash S -C -O -M and then get kind of bored with typing out the

whole English word, you can hit tab for tab completion, like in a web browser,

and it, too, will autocomplete if it finds a file that starts with those

letters. A little efficiencies here.

Questions, then?

On the code here. Yeah.

I have a question about libraries.

Sure. Is there any downside to just putting in all of the libraries?

A good question. Is there any downside to just putting in all of the libraries?

Like we saw in the manual pages a moment ago, performance.

So generally speaking, C is meant to be a very efficient language, so much so

that even though it's decades old, it's still used omnipresently nowadays

because it's so fast.

It therefore minimizes time. It minimizes energy use. So it's still

heavily. you would slow things down if you told the compiler, by the way, give

me all of these other functions that I'm never going to use.

So in short, just don't do that because it's unnecessary.

But a good question.

Other questions on what we've done here?

Yeah, in front.

Just a follow -up.

What is it?

A YSC faster?

A YSC faster than other languages? Let me answer that in more detail in week

when you'll see.

how much easier it is to write code in other languages because someone else is

doing a lot of the work for you. So as an introductory course, we're sort of

teaching you bottom up, like how do you write code? How does the computer

understand code?

Eventually, this kind of stuff, certainly after like five, six weeks of

it's going to get tedious doing some of these things.

We're going to switch to another language that takes away the tedium and

us to really focus on the problems to be solved once we've sort of graduated to

that point.

Yeah?

Sure, to repeat the keyboard shortcuts, you can just go up, up, up, up, up, and

that will go through all of your previous commands, at which point you

hit Enter.

Or you can use tab completion. So you can start typing a word like code, and C

-O -D tab will finish the thought, or dot slash C -O -M tab will finish that

thought, just to save yourself some keystrokes. And clearing the screen is

Control -L, which has no functional purpose other than keeping things neat

tidy in class.

So a design question.

So this code, I dare say, is correct. Let me zoom in a little bit here.

Let me change the code to just do this, even though we already saw from scratch

that we probably shouldn't do this.

Why should we not do this?

If, especially, I'm just more comfortable asking three separate

if x is less than y, if x is greater than y, if x equals y, do this. It's a

world to live in. Just ask your questions. You don't have to worry about

else, if, else, if, forks in the road. You can just ask three questions. But

let's put a finger on why is this correct, yes, but not well -designed.

Yeah, and back again.

OK, so there could be cases that are potentially outside of these three.

this is relatively simple math comparing numbers, we don't have to worry about

that here. But yes, in general, you might miss a scenario without using a

-all like else.

Yeah, so maybe more than one of them could be evaluated as true. Not going to

happen here, but yes, you could accidentally create a situation where

print or three things print because you didn't really think about the boundaries

among these questions that you're asking. Again, not applicable here, but

general, a good concern.

DAVID J. Really good. Really what's concerning here in this example is

slowing the computer down by wasting its time having it do work that is

logically unnecessary, even more so than the scratch in the first C example.

Why? Suppose that I type in 1 for x and 1 for y.

Because I wrote this code top to bottom, this question is going to be asked no

matter what.

The answer is going to be false.

This question is going to be asked no matter what. The answer is going to be

false. This question is going to be asked, and no matter what, the answer is

going to be true. We're OK there because we had to ask all three questions.

But suppose I did the first thing. x is 1, y is 2.

Then this first question is going to be true because x is 1. is less than y, 1

is less than 2, so this is going to print.

And yet then I'm wasting everyone's time asking, is x greater than y? Even

though it obviously isn't. Is x equal to y?

It obviously isn't. You're doing three times as much work in that particular

case. It's just not good design.

And again, for those of you who think a little more visually, we can actually

make this picture.

To match, here is a final flowchart for bad code, bad design.

Why? Because no matter what, when you start the program and you want to stop

program, you're going through all three of those darn questions no matter what.

Whereas the previous flowchart got us to the stop.

Bubble faster by taking alternative arrows based on true or false answers.

short, still correct, but bad design.

And so again, even for problem set one, when we start writing C code, consider

not just getting the job done, but how you might get the job done better than

you might otherwise.

All right, let's add a few other features into the mix.

Here we have those same data types that are supported by C. Let's focus for a

moment on something a little simpler, just chars, single characters.

Unfortunately, for better or for worse in C, the language makes a distinction

between strings of text, which are generally words, phrases.

They can confusingly be single characters or even zero characters if

type anything in between the quotes, but more on that another time. But when you

know from the get -go that you only want to get a a single character back from

the user, like y for yes, n for no, for instance, which is super common in

programs, you can get that using a char, and CS50's own function, getChar.

So how might we use this? Well, let's go back to VS Code here. I'm going to

close compare .c. And let's write a third program altogether.

Let's call this one agree .c.

And this is meant to represent terms and conditions where you have to check a

box, yes or no, or something like that.

In this program, I'm going to go ahead and do the following.

I'm going to go ahead and, as before, include CS50 .h so we've got it, include

standardio .h so that we've got it.

Int main void, because we have to do that for now. More on that another time.

And now let's ask the user a question. Do they agree?

So I'm going to call get char and then pass in a prompt of do you agree

mark with a space.

semicolon. But as before, with get string and get int, those functions

value. So I want to assign that value from right to left to a variable, which

could call answer again. But honestly, this program's so short, I'm just going

to use the letter c, which is conventional.

So c for char, i for int, or n for number are very common. But one more

what's still missing for my variable here?

I need to say this shall be a char, not an int, not a string, a single char.

All right, now what do I want to do? I can ask a question. If c equals equals

lowercase y, then go ahead and print out, just so we see something on the

screen, agreed period backslash n, as though they agreed to the terms and

conditions. Else, if c equals equals lowercase n, go ahead and print out, for

instance, not agreed, just so we see something.

on the screen.

So let me hide my terminal window and focus on the code. There's a couple of

details here that are a little interesting.

So one, what did I do on line 7 and 11 that is not consistent with what I've

done before?

Subtle.

So I'm using apostrophes or single quotes now instead of double quotes.

It's a C thing. When you're using strings, you use double quotes. When you

single chars, You use single quotes.

So the argument to get char, that's still a string. It's a whole sentence

I'm passing in. So that is just like get in, just like get string.

But when I get the answer back, the return value, and put it in this

and I want to check what is that one char, I have to surround the char I'm

comparing against in single quotes or apostrophes, both for the y and for the

So this program is not super well designed, because it's not going to

uppercase. It's not going to handle weird inputs very well. But let me open

terminal window, make agree, Enter.

The code compiles OK, dot slash agree.

Do I agree? Let's try it. Y for yes.

OK. Let's try it again.

Dot slash agree.

N for no.

Not agreed. Let's do it one more time. Let's very enthusiastically say yes in

all caps.

And it just kind of ignores me.

But why?

Well, this is a feature of CS50's get char function.

If you tell us you want to get a char, we're not going to tolerate a whole

string of text from the user. We're going to prompt them again and again and

again until they give us just one char.

So yes is three times too long. So let's actually just do a single capital Y and

see what happens. Return.

The program ignores me altogether.

So all right, this is kind of a poorly designed program. It's a little annoying

that we'll just ignore humans, even if they type in y or n. That just happens

be uppercase. So let's improve this. Let me go ahead and add a couple more

conditions. Else if c equals equals uppercase y, then go ahead and print out

agreed, same as before.

And then down here, else if c equals equals capital N, then let's go ahead

print out again not Agreed. So this is now more correct.

It's still going to ignore bogus input that makes no sense if it's just like

word, if it's a different letter altogether.

But this to code, while correct in some sense, is still poorly designed.

Even if you've never programmed before, what rubs you the wrong way about this

code now?

Be critical. Yeah?

Yeah, it'd be nice to just merge the lowercase and the uppercase Y together.

The same thing for the lowercase and the uppercase N. Why?

If only because literally lines 9 and 12 are identical.

Lines 17 and 21 are identical.

And while not a huge deal, if I go in and I change this sentence, odds are,

the course of my lifetime programming, I'm going to forget to change this one,

even though I changed this one. Or I'm going to forget to change this one and

this one. So you don't want the code to get out of sync, potentially.

to repeat yourself.

So don't repeat yourself is a tenet of programming, too. If you can avoid that

by somehow factoring out some commonality, you should do so, similar

to math, when you factor out variables or the like.

So let me tighten this up, so to speak. Let me get rid of what we just did so

that it's a little shorter as before.

And let me express myself with two conditions using the following syntax.

I want to check if c equals equals lowercase y or C equals equals uppercase

So you can actually use what's called a logical operator, two vertical bars,

which means or, and we can do this down here, or C equals equals capital

N. So same exact functionality, but to your point, we've now eliminated what,

like another one?

It was like, what, one, four? It's like eight lines of code now are gone, which

is eight fewer lines that I might screw up in this program, less opportunity for

mistakes or bugs.

Probably a good thing. So now if I run this, let me open my terminal window.

Let me run make agree, enter, dot slash agree, enter. Do I agree?

Capital Y.

Now it seems to be handling both of those situations.

So just a little tighter. As an aside, we won't use it here. But if you want to

say and, which would be nonsensical, it, a little confusingly, is 2 ampersand,

means a logical.

and whereby the left thing has to be true and the right thing has to be true.

it's two Boolean expressions at once.

This one makes no logical sense, though, because the character cannot be

simultaneously lowercase and uppercase. It's got to be one or the other. So two

vertical bars is logically correct. That represents our notion here of or.

Question?

No?

Yeah.

You could not write or. So I'm saying or just because that's a little more

normal, but this is incorrect.

However, sneak preview, in the language of Python, you actually will literally

say or among other things, which gets a little more user -friendly.

Other questions on this here?

Searching? Yes, in back.

Is there an easier way to handle case sensitivity?

Yes, and we'll show you that next week, in fact. So we can combine this code to

be even tighter.

All right, let's do one final set of examples before taking a cookie break,

we could. But let's go ahead and close agree .c here.

Let me open my terminal window. And let's go ahead and implement a sort of

virtual cat, as we did last week. I'm going to code up a file called cat .c.

I'm going to implement this in a few different ways, the first of them pretty

foolish. So here, I'm going to include standardio .h. No need for CS50 just

int main void.

Inside of these curly braces, let's go ahead and do printf meow to get the cat

to meow.

And then to save time, I'm going to copy paste that two more times. So this cat

shall meow three times in total.

All right. I'm going to go ahead and make the cat, so to speak. All good.

Dot slash cat. Enter. And it meows three times, just like our scratch cat last

time. I'll stipulate this is correct.

This is a really well implemented cat, correctness wise.

But why is it bad design intuitively?

Just like last week.

I keep repeating the code. I mean, I literally copied and pasted, which is

of your first obvious sign I'm probably doing something wrong if I'm copying and

pasting, because I'm literally repeating myself.

So to spoil it, like odds are a loop is probably going to be our friend here.

And so in fact, in C, we have those features as well.

So in the world of C, we can implement some of last week's same ideas in a few

different ways.

These are a little more mechanical, but suppose we want to repeat something

literally three times.

Scratch gives us a repeat.

A block with an input, so easy.

C, in a lot of languages, is going to be a little more mechanical. And it's

going to look ugly at first. It will take some getting used to. But it is a

paradigm you will use again and again and again. This will become very rote

memory before long. Well, the most direct translation of this scratch code

is probably something that looks a little something like this, whereby I

initialize a variable, here called i, and set it equal to 3. That's the code

equivalent in C of putting up three fingers.

Then what I want to do is while i is greater than 0, that is to say, while I

have at least one finger up, go ahead and do the following. And then once I've

done that, for instance, say meow on the screen, I want to go ahead and

decrement i.

and then do this whole thing again.

Now, I could have called this variable counter for consistency with earlier.

But it turns out it's conventional. When you've only got one variable involved

in your code and all it's doing is something simple like counting, you can

ahead and call the variable i for integer, for instance. But it would not

wrong to instead call i counter.

But notice, too, that in this so -called while loop, as we'll start to call it,

there is this parenthetical. And that parenthetical is actually itself a

expression. But unlike an if statement, whereby the Boolean an expression is

evaluated just once, and if the answer is true or yes, you do that thing.

The Boolean expression in a while loop here in C is evaluated again and again

and again every time you go through the loop to check if you should keep going

through the loop. So for instance, if the goal at hand is to say meow, well,

course, the comparable C function is going to be printf. And I want to print

on the screen meow, followed by a new line. Well, what's going on? Well,

I initialize i to 3.

I then check, is i greater than 0?

And of course it is, because effectively in the computer's memory,

I decrement i, which means to put down one of those fingers, and then.

I check the Boolean expression again. Is 2 greater than 0? Of course it is. So I

print out meow. And then I decrement i, putting down one more finger. Then I

check the expression again. Is 1 greater than 0? Of course it is. I print out

meow. And then I decrement i. And now I'm down to 0.

I check again.

Is 0 greater than 0?

Well, no.

And so the loop will automatically, by the definition of how this C code works,

terminate for me and proceed to any other lines if there are more lines of

that I've written.

So how do we actually implement this then in code and get it running, well,

going to be pretty much the same idea. Let me go back to VS Code here. I'm

to get rid of all of this copy paste. And inside of my main function, I'm

to do exactly what we saw.

Int i equals 3.

semicolon, while i is greater than 0, then go ahead and print out with printf,

meow, backslash n, and then be sure you decrement i.

And notice that lines 8 and 9 are not only indented, they are inside of that

while loop, so to speak, which means they will both happen again.

And again and again, because what's happening in code here is those curly

are kind of like the yellow pieces that are hugging the other puzzle pieces in

Scratch. It will keep doing this, this, this.

But every time through that loop or cycle, this Boolean expression will be

checked again and again and again until the answer is false, at which point the

computer is going to jump to the last line. And if there's nothing left,

it for the program.

No more to be done.

So same exact idea in Scratch, even though it's a little more mechanical.

So that's how we might implement this.

And you can think of it sort of these variables.

This is perhaps a little gratuitous, but let's do this. So if you have a

variable inside of a computer's memory, and that's a detail we'll get to in more

detail before long, you can really think of it just as like a container that

stores value.

So for instance, this.

Clear plastic bowl can be thought of as a variable. It just stores values.

And right now, there's obviously three stress balls in it, so it represents the

number three.

So what's really happening in code like this is we've initialized i to three,

which is this ball. We're then checking the question on line six, is i greater

than zero?

Obviously. So we proceed inside of the curly braces, and we print out meow.

We then decrement i.

So for the sake of unnecessary drama, like that's decrementing the variable.

what's being stored in this container now is 1 less.

We do it again. Check the count. Nope, 2 is greater than 0, so we keep going.

Meow. Decrement i.

Check the variable.

1 is greater than 0, so we print meow.

Decrement i.

We check the condition again.

i is not greater than 0, because 0 is not greater than 0.

And so the rest of the code stops executing.

I'm not sure if that was any more effective than fingers on my hand. But

the ball. We had the ball. So same exact idea.

Variables are just storing some value. And incrementing and decrementing would

just be adding or subtracting stress balls in this case.

But there's other ways we could do this.

In fact, let me zoom in on my code here.

And it's not really conventional in programming to count down.

Nothing wrong with it. It's just not really a thing we would typically count

So we could alternatively do this.

Set i equal to 1 initially. So we count 1, 2, 3, like a normal person.

And we can change our condition.

If I'm going to count from 1 to 3, what should my comparison be in my Boolean

expression here?

i is less than 3?

Less than or equal to 3, I think. So if i is initialized to 1, we're going to go

through this one time, two times.

three times, i is going to eventually get incremented to four. But at that

point, four is not less than or equal to three. So it's only going to execute a

total of three times. But there's still a bug in this code. What other line

needs to change?

Yeah, so line 9 needs to become plus plus.

So this code is just as correct. And honestly, you could, reasonable people

disagree. Your TF might say, do it this way and not this way. But this is still

correct. But it's not the most conventional way. As per last week,

scientists and programmers generally actually start counting from 0 by

convention for reasons we'll soon see.

So the better way, the more conventional way, arguably, would be always start

counting from 0.

count up to, but not through the number you care about.

And so this form of the code is probably the most popular way to do it. Start at

0, count up to 3, but not through 3, as with less than or equals than. All three

are correct.

Can't really do counting up as easily with the ball without picking up the

balls, but the exact same logic applies.

And in fact, this version of the code is so commonly done that there's a

different way to implement it all. There's a similar way to implement it

together. In fact, this code here, same exact thing, repeating three times,

because it's so commonly done that you want to initialize something to 0 and

keep doing something until the value 3, you can actually use a different

preposition, 4, which is another keyword in C.

And it looks a little more cryptic, but it just tightens things up.

This is what's called a for loop.

Previous is what's called a while loop.

And honestly, even though it probably to the newbie still looks just as cryptic,

it's just a little tighter, because you're expressing all of these ideas on

line. You specify the variable you want to create and initialize.

You specify the Boolean expression you want to check again and again.

You specify what increment or decrements you want to happen. And confusingly,

you do use semicolons here, not commas. You do not put a semicolon here.

You, of course, don't put them after these things. You generally only put

after function thus far.

So we do have one semicolon here.

But in short, this you'll get more comfortable with. This is how I, for

instance, almost always write a loop. But it's doing the exact same thing

mechanically as this. Same thing as counting. Same thing as counting the

balls. There's just different ways to express the exact same idea.

But there are ways to screw up. So in fact, let me go ahead and do this.

Suppose that the cat, we'd like the cat to live as long as possible.

And we don't want it to stop meowing after just three or a finite number of

times. How can you do something forever, again and again and again?

Well, let me go back into VS Code here.

Let me delete all of the code from earlier. And let me go ahead and say

Something is true. I'll come back to that. Let's just go ahead and print out

meow backslash n, ideally forever.

But what do I want to put in here? Well, if I want to do something forever, I

could do something kind of stupid, like while 1 is less than 2, which is always

going to be the case, or while 50 is less than 51, which is always going to

I could just ask an arbitrary question, but like arbitrary, not good in general.

Like you should have meaning behind your code. So if you want the expression to

be true all of the time, just say while true, because true is not changing

anytime soon. If it's literally true, it's always going to be true. The only

caveat is to use this trick for now.

you will need to include the CS50 library, which, for today's purposes,

that possible.

But there's a problem, of course. If the cat's going to live forever, if I do

make cat dot slash cat enter.

Like, you can very quickly lose control over your terminal window.

And you can see the meows are flying across the screen, at least based on the

bottom from what we're seeing. Like, this cat will never stop meowing. And

is either a feature or a bug, so to speak, depending on how long the cat

should live virtually.

But how do you terminate a program that is out of control like this infinitely.

So one of the takeaways for today is Control -C is your friend for cancel or

interrupt the program.

If you ever sort of lose control over a program because you've got intentionally

or unintentionally an infinite loop, you can go into your terminal window, hit

Control -C, sometimes multiple times if it's ignoring you, and that will break

out of the program and just essentially force quit it, like in Mac or PCs.

But let's make one improvement here still.

The last thing we did with our cat in Scratch, before now we'll take a break

a moment, was we defined our own functions. And recall that we did that

abstract away the idea of meowing, because Scratch didn't come with a meow

puzzle piece.

C definitely does not come with a meow function.

We have to implement it ourselves.

So quickly toward the end of week 0, we did this.

Define a function called meow that just plays the meow sound.

And now we have a meow puzzle piece we can use and reuse.

In C, we're about to do this.

And this is going to look a little cryptic, but it's going to lay the

for future weeks when we do this even more. I've got a meow function.

Weird mentions of void.

That just means there's no input and there's no output for this function. It

just does one thing simply.

And that one thing is printf meow.

So how do I use this here code? Here in Scratch is how we used it last week.

When the green flag is clicked, repeat three times the meow.

function. In C, it's going to look like this, int made void and all of that. And

I can use a for loop, a while loop. I'm copying and pasting the for loop version

of the code. Set i equals 0.

Make sure it stays below 3.

Increment it on each iteration or cycle.

And just call meow.

So what's nice here is that we have fairly simply a way in C to create our

functions called meow or anything else that lines up perfectly with what we did

in Scratch. We'll take some time to get comfy with the syntax and remember it,

have to look it up frequently for reference. But let's go ahead and

this. If I go back to VS Code, clear my screen,

let me hide my terminal window temporarily.

Let me go ahead and invent this meow function.

Per the code earlier, I'm going to go ahead and do this.

void meow void.

And again, the two voids mean no input, no output. It just does one thing well.

Printf quote unquote meow backslash n.

And now down here, I can use a for loop. So for, and I know this from memory,

int i equals 0, i less than 3, i plus plus. And then inside of curly braces,

going to go ahead and call the meow function.

Notice When I'm creating the function up here, I explicitly, pedantically say

void, void, no input, no output.

When I use the function on line 13, you just say open parenthesis, close

parenthesis. That's the equivalent of a scratch puzzle piece without a white

oval. You just put nothing there. You don't put the word void.

So that's it. Let me open my terminal window.

Let me run make cat to recompile dot slash cat. And I think I have a working

cat. Now, this is correct.

The only thing I don't love about this version, if I hide my terminal window,

that when I start writing bigger and bigger programs, it'd be nice if my main

function which I told you to take on faith for today, is at the top of the

If only because literally the name main means this is the main part of my

program, it'd be nice if it's the first thing I see.

Which is to say, just to be pedantic, it's very common to put any functions

write at the bottom of your file, maybe alphabetically, maybe organized some

other way.

But you put main first by convention, just like the when the green flag

It was the first thing you always started with last week.

But watch what happens now. If I go into my terminal window.

And Command or Control J is hiding and showing it if you are curious, but

probably you'll just leave it open on your own all the time. Let me do make

again.

And huh, I've screwed up somehow. All I did was move the meow function from top

to bottom, and I'm getting call to undeclared function meow something,

something, something.

Well, what's going on?

Well, C is pretty naive and simplistic.

It's only going to do what you tell it to do, and it's only going to do things

top to bottom, left to right. And unfortunately, on line 8, you are

call a function called meow.

But that does not exist in CS50's header file.

That does not exist in standard IO's header file. It exists at the bottom of

file, at which point it's too late, because I'm trying to use it before it

exists. So I could just undo that and put this meow function at the top of the

file. But you're going to eventually get into a perverse scenario where you

can't put all of your functions above all of your functions. You've got to

a lane at some point. So the solution to this, albeit a little weird and the one

time

in CS50 and programming that it is encouraged and necessary to copy -paste

what you can do at the top of your code above main is just copy -paste the first

line of your own function.

This is the so -called prototype of the function, and it simply describes how to

use the function.

And funny enough, we actually saw this earlier, but I sort of swept it under

rug a moment ago.

Or a bit ago, when we looked at standardio .h and we looked at the

function in the manual pages, I highlighted the header file.

But I also glossed over the so -called prototype, which is, sorry, the first

line of the printf function, just as this is the first line of my meow

This is like a little clue. This is like saying to see, hey, there's going to be

a function called meow that takes no input, has no input, takes no input, has

output. Just know that it exists eventually.

And that will satisfy the compiler.

Because if I go back to my terminal, rerun make cat, it now knows on face,

line four, this function will eventually exist.

And indeed, once it gets to the bottom of my code line, 14 onward, there it in

fact is. So you just copy the one and only first line of your function's code

the top called the prototype.

And now if I do dot slash cat, I get finally, meow, meow, meow, yet again in

this case.

Questions on these here cats?

No? All right.

Last flourish before I keep promising cookies that I promise they exist.

So last flourish, like just as we did in Scratch. So in Scratch, recall that we

parameterized our meow function by letting us tell meow how many times to

so that we didn't need to use our loop inside of our when green flag clicked

block. In other words, if I want to actually have the cat meow a specific

of times, I can actually go ahead and do that proactively with some of my own

code, such as this here in Scratch. When I edited my meow function last week in

Scratch, I specified that I want it now to take an input called n, which

represents some number of times.

And I changed my repeat block not to be 3 perpetually, but to actually have n

generally baked in there instead.

Or actually, instead of just saying place on meow, I had a repeat block

as the placeholder instead of a hard -coded 3.

So how can I now use this in C?

In C, it's almost the same.

It's still void at the beginning of my function name, which means no output

still. It only has side effects.

But what did change vis -a -vis the previous version of meow?

What has changed?

Exactly. Instead of saying void a second time in parentheses, it literally says

int n inside of those parentheses, which means in C, this function called meow

take input. It means the exact same thing as the pink on the left. And

this is why we keep emphasizing the scratch blocks. No new ideas with a lot

these features.

It's just different syntax that you'll get used to over time.

So if I go back into VS Code here and I change this function, let's do that.

Let's change my prototype to be int n, where n represents some number of times.

Let's change the actual function on line 14 to also have int n here.

And let's actually move the for loop from main into the meow function, such

I now have my curly braces here.

I have my print statement inside of those curly braces.

And now, in main, I can get rid of all of that code, just say meow.

any number of times, like three, and just like I did with Scratch, let me hit

Enter, an arbitrary number of times, sort of out of sight, out of mind, now

essence of my program is like one real line of code, meow three times, because

I've abstracted away the idea of meowing and told the cat instead exactly how

many times to meow by way of that function.

OK, I can't keep stringing along cookies so long.

Let's go ahead and take a 10 minute break here. And when we come back, more

cats, more code.

DAVID J. All right.

So we are back and want to add one final flourish to this program because now,

more so than a lot of the examples, now the programs are starting to grow in

length. And indeed, soon there'll be a few dozen lines of code, which is not

uncommon. But let's suppose that we want to stop hard coding three everywhere

and actually prompt the user for some number of meows here. Well, let me do

this. In VS Code, I'm going to go ahead and Get rid of this one line for now,

and let's do something like this.

Let's ask the user for an integer. So int, maybe n for number equals get int.

And we'll say something like just number to give a number of meows. And then

we'll go ahead and actually call meow, passing in not three this time, but

passing in n.

So we are using the return value of get int to store it in a variable called n

on line 8. And then we are passing n as the input or argument to the function

called meow on line 9. And again, the actual implementation of meow on line 22

onward, like who cares, out of sight, out of mind, once it exists. We can sort

of abstract it away mentally, but I'll keep it uptight here anyway.

All right, so let me go ahead and open my terminal window, make cath, dot slash

cath, number.

I can still type in three and it works.

Or I can go ahead and type in five, meow, meow, meow, but it's not actually

meowing five times. Why?

I didn't realize this either. But there's a bug.

DAVID J. Yeah, exactly. So the for loop, when I copy pasted it before, before

break, I actually kind of got lazy and I forgot to change the three to an n so

that it matches the name of the argument that's being passed into meow.

So that was a bug, unintentional on my part, but we have now fixed it here. And

now we are passing this in from main to meow.

So if I make cat dot slash cat.

And type 5 this time, I indeed get 5 meows. But it's worth noting there's

subtleties here in my code in that I've used n a couple of times.

So this is actually deliberate that I've used n twice in this way to induce a

bit of confusion.

But it turns out this n It's actually not the same as this n nor this one. So

what's going on here? Well, it turns out in programming, there's often this idea

of scope.

And long story short, generally speaking, variables only exist in the

which you create them. More down to earth, variables only exist inside of

curly braces in which you define them.

So for instance, suppose I got a little floppy, and suppose I didn't bother

giving meow an input, and I didn't bother giving its prototype an input,

just used n on line 14.

Because why? Well, I already defined n on line 8.

So this is just an alternate universe in which I'm not changing meow to take

input. I'm just using n in two different functions. In main, on line 8 and 9.

Actually, I don't even need that. On line 8 and 9.

And also, again, on line 14.

This code will not work. The compiler will not like this. Why?

Because n does not exist inside of meow. Why? Per the heuristic I offered, n

exists only inside of the curly braces in which it was defined, namely these

curly braces here.

So n is in scope in main, so to speak.

But it is not in scope in meow.

And that's why we kind of have to jump through these hoops and use inputs and

outputs and inputs and outputs and pass things around among functions without

sort of sharing things across functions instead.

Now, I could clarify this and maybe change my argument here from n to times.

If I want to make clear that, oh, this is the number of times I want meow to be

said, I don't have to use n for both. But just realize that if you do, it's

a coincidence.

They are not usable in two different scopes.

All right. Let's do one other thing, though. Let's not only prompt the user

the number here. Let's make sure that it makes sense what number they give us.

So if I do make cat, just to clean things up, dot slash cat, suppose I type

OK, I suppose that's correct. If I say meow zero times and it doesn't meow at

all, that's arguably correct.

But if I type in something like negative 5, it ignores me, which I guess is

better than crashing or freezing or something. But ideally, it might be nice

handle this situation.

And if they give me a negative number, prompt them again for a positive number.

Prompt them again for a positive number. Make the program make sense.

So how could we do that? Well, a couple of ways.

If I go back into my code here, I could do this. I could maybe do something like

a loop, or let's see. So if I get n, so if n is less than 1, then

it makes no sense. So what do I want to do if n is less than Well, I could just

prompt the user again. And I'd say, OK, let's get n again.

And then I can say, if n is less than 1, what do I want to do? I guess we could

ask the user again.

And then if n is less than 1, I could just, again, I can give them three

four tries to get this right. This is obviously stupid. I'm copying and

I'm repeating myself.

There's no end in sight.

I can't do this forever, surely.

So this just feels like the wrong solution.

So there are different ways to solve this problem. And funny enough, a while

loop is not really the best way. A do while loop is not the best way. A for

is not the best way. It turns out there's one other type of loop that we

to introduce that's super useful for getting user input potentially again and

again and again so that the user cooperates.

Specifically, what I'm going to do is this.

I'm going to literally say do the following while something is true.

So it's more of a mouthful. I'm spreading it out over multiple lines.

am I going to put inside of the do block here? I'm going to say int n equals get

int and ask for that number as before, close quote semicolon. And I'm going to

keep asking while, sorry, accidental enter, while n is less than

1 semicolon. So notice the semantics of this. Even though it's a little weird

looking, it does read in English, do the following.

OK, get an int stored in n, and keep doing that while n is less than 1.

But this code, as written, is not quite going to work yet.

Let me try opening my terminal window, make cat enter.

Ugh, damn it. Like, use of undeclared identifier n.

Well, here's where the line number is helpful.

The line number is indicated here, 12, and it's repeated here, 12.

So I clearly screwed up at line 12.

There's not that much going on at line 12.

Why is n undeclared?

in line 12, even though I literally just declared it in line 10.

Exactly, because I declared n inside the scope of the do block, so to speak,

inside the curly braces on lines 9 and 11.

That variable n no longer exists by the time we get to line 12. It'd be great if

it did, but it doesn't, because it violates that heuristic I proposed,

that variables only exist in the scope of the curly braces in which they were

defined. So how do I fix this? Well, it turns out you can declare a variable in

advance. outside of one scope, but then define it, that is, initialize it

elsewhere. So the solution here is actually this.

Inside of the loop, just set n equal to the return value of get int. But per the

heuristic, you've got to declare n, make it exist inside of the outermost scope

of this function.

So it's a little weird, and we're kind of breaking this down into two steps,

this is valid, recommended, correct.

C code.

You declare a variable without giving it any value initially.

And then in line 11, you proceed to give it a value, potentially again and again

and again.

Now, what's useful about a do while loop? So a do while loop, as the name

implies, will do something no matter what. But it will potentially do it

and again and again while some question is true, like n being less than 1 in

this case.

All right, as an aside, why did we not do a while loop? Well, let's think about

that. While n is less than 1, but wait a minute, n doesn't have a value.

OK, so I guess we have to go back to doing get int number colon semicolon.

but while n is less than 1, we're back to the same problem where we have to

repeat ourselves again. So this is why for loops, while loops.

Not the right solution when you want to do something at least once, but

potentially again and again. So the right solution here, again, is this new

final looping construct. I'm just hitting Control -Z a lot, whereby we've

it as follows.

All right, let's try this. Clear the screen.

Make CAS.

Enter. Dot slash CAS.

Let's type in 5.

Still works. Let's type in negative 5. And notice, it doesn't just ignore me.

prompts me again and again and again. Even if I type in 0, I've got to at

give it a positive integer.

Well, this actually seems like kind of a common paradigm. Like, what if we want

to prompt the user for a positive number in other programs, too?

We're nearing the point already, even after just week one, it would be nice to

write our own reusable functions that solve common problems. And eventually,

maybe we can put them in header files as well. But for now, let's go ahead and

do this. I'm going to actually copy all of this code. And I'm going to create

one more function in this file below main called get positive int for

And I'm going to specify that it doesn't need any input, because the only thing

this function is going to do is that exact same thing.

So notice that I've just moved my code from main into a function that's name

describes what it does, get positive int.

I'm declaring n here.

I'm doing this again and again.

And I'm doing that while n is less than 1.

And what am I going to do up here?

I can do something like this. Give me a variable called times for how many times

you want to meow, and just call get positive int.

Let me call in. So now, again, we've abstracted things away. And just like in

Scratch, our final example, which we're called looked a little something like

this, where we just called a function to meow three times. Now we're calling a

function to getText. If I hit Enter an arbitrary dramatic number of times, out

of sight, out of mind, I now have two functions in this world, getPositiveInt

and meow that are collectively implementing this entire program.

But it's not quite correct.

There's one mistake here still.

Notice that getPositiveInt is written slightly differently from the meow

function. And just to be clear, too, let me copy its prototype to the top of the

file, just so we don't make that same mistake I made earlier where I didn't

the prototype at top, so C didn't know what it was.

What is different about these two prototypes at a glance?

Yeah?

GetPositiveInt.

Okay, so GetPositiveInt apparently, and we've not talked much about this,

apparently does have an output.

of type integer.

It's supposed to return an int, hand me back an int. It doesn't have any input.

That's what the void in parentheses meant.

No input, but yes output. And meow, funny enough, is the opposite. Yes

output. Why? Because it has a side effect, the visual thing, where it

something to the screen but doesn't hand me any useful value back like the ask

function or the ask puzzle piece did.

So these are sort of opposite in functionality, which means I actually

return an integer from this function to whatever function wants to use it.

So if I want the assignment operator to work here on line 9, I need to do what

all this time get int, get string, and other CS50 functions have been doing. I

need to, in my own function, return that value, literally with a new keyword

called return.

And this is why I keep sticking out my hand. When you want a function to hand

you back a value, you literally use return and then that value.

That's why we have return value as a term of art, literally this return

So if I open my terminal window now, make cat enter,

huh, I did screw up accidentally.

How? Yeah.

Yeah, so on lines 9 and 10, I made a quick change. I changed my variable to

times, but I stupidly didn't change this. So that's fine. That's why n was

undeclared in that context.

Let me clear my terminal. Make cat once more.

OK, that worked. Dot slash cat. Let's type in 5.

And it's still working.

So again, even though the code is kind of growing and growing and growing, it's

the exact same program we wrote super simply before break. But now we're sort

modularizing it. We're creating reusable functions.

And this is why functions like getStringExists, getIntExists, like CS50

those years ago.

And we realized, why are we copying and pasting these functions in all of these

different CS50 programs?

Let's factor out that functionality into a function of our own. Get int, get

string. Just like here, I'm proposing to factor out this functionality.

Get a positive integer that gives you even more precise functionality.

So theoretically, you could use and reuse it in other programs, too. By not

just putting it here, we could go put it in a file of your own name.

and include it in future programs as well. That's all a library is. Someone

realized, gee, other people, including myself, might find this function useful

again and again.

Let's package it up in our own custom function, just like our custom meow

piece last week, so we can indeed use it again and again.

And the takeaways for now is that unlike Scratch, which was a little more user

friendly, in C, you have to specify if you want your functions to have inputs,

and you must specify if you want them to have

outputs as well.

But more on that syntax to come.

So where does that bring us? So after all this discussion of code, at the end

the day, this is what's important in the world of programming.

Not surprisingly, it's what's important when it comes to grading and evaluating

the quality of code.

One, and first and foremost, is correctness. If the code does not do

supposed to do, what was the point of writing the code? So correctness sort of

goes without saying.

Design, again, is much more qualitative.

It's like getting feedback again on an English essay.

Where reasonable people might disagree, you can make your argument better. You

can structure the paper better. You can structure the code better in the case of

programming. And style is purely aesthetic.

Does it look good? Is it pretty printed, so to speak? Can other people,

colleagues, future, and classmates present actually read and understand it?

That's what we mean by style.

Nicely enough, within CS50's programming environment, you will have tools to

evaluate the quality of all three of these axes, so to speak. So in problem

one onward, you'll be introduced to a command line tool that you type its name

at the prompt called check 50 that will check for you the correctness of your

code. Not necessarily exhaustively, like there might be mistakes you've made

that we don't catch, which doesn't make your code correct, but it is a tool for

finding many of the mistakes in your code. In the real world, you would have

colleagues or yourself would write tests for code you wrote or someone else

wrote.

It is a real -world thing to ensure that systems are designed to work.

We saw the Style 50 tool in VS Code already. You click the Style 50 button.

There is now, thanks to the duck, a Design 50 button, too, also in that top

right -hand corner, whereby once your code is correct and working, like

of my programs have been, you can click Design 50, and the duck will not just

quack, but give you qualitative advice, if it can, on how you can make that code

even better, even before you submit. And of course, there's all of us humans in

the room and online that you can ask these same questions of.

as well.

So let's now solve some sort of real world but still simple problems as

to emphasizing small bite size as we have thus far. So the first of these

programs falls into this category. It's having side effects. So let's implement

one or more functions that takes an argument's input and as its output

these visual side effects. We'll draw inspiration from Super Mario Brothers,

surprisingly, perhaps here. The original one, which was very two -dimensional,

side scroller, left to right, Mario or Luigi move from left to right, and

generally have to jump over things like pyramids or other shapes on the screen.

So how might we go about implementing some of the screens from Super Mario

Brothers, albeit textually? Well, we'll make it a little black and white and

ASCII art, so to speak, here using just our keyboard.

But suppose we want to write a program.

called mario .c that just prints out four question marks. It's not going to

nearly as pretty as what's on the screen here, but the logic is going to be the

exact same as what Nintendo presumably did years ago.

So let me open VS Code, my terminal window. Let's code a program called

.c. In mario .c, I'm going to kind of start with some boilerplate. I know I

to print, so even if I don't know how to do this yet, I'm going to include

standardio .h.

For today's purposes, I'm going to copy, paste, or type out that same line again

and again, int main void.

And inside of my main function, akin to the green flag being clicked, I want to

go ahead and print out four question marks. Well, honestly, the simplest way

can think of doing this is with printf, question mark, question mark, question

mark, question mark, maybe a backslash n to move the cursor, and that's it.

So that is arguably correct.

So let's do make Mario in the terminal, dot slash Mario.

And it's not quite as pretty as the game version of it, but it is, in fact, the

exact same idea.

But here's sort of an opportunity, stepping stone, to do better design.

Like this game changes over time, and not all of the screens have just four

question marks. It might be five, six, or even more.

So what's the right programming construct with which we could generalize

many question marks are printing here?

Like what feature of C do we want?

Like a loop, like a for loop, a while loop, or something like that. And

different ways to do this. But honestly, I proposed earlier that we get into the

habit of reaching for for loops as just very conventional.

So let's do that. For int i equals 0, i less than 4, because that's how many I

want for the moment, i plus plus. And then inside of my curly braces there,

let's go ahead and print out, quote unquote, a single question mark, but no

line.

Let me now go ahead and make Mario.

And can you anticipate a arguably aesthetic bug when I hit Enter?

It's not going to move the cursor to the next line.

But the solution here is a little non -obvious. I don't think this helps me.

I put the backslash n there and I do make Mario again and dot slash Mario,

is this output going to look like instead?

Yeah, like a vertical column of question marks, which, while nice enough, is not

the goal at hand. The goal is these horizontal ones.

So someone else, what's the fix here? It's clearly putting the backslash in

inside of line 7 is wrong.

Yeah, so put it after the loop, and not after the printf line specifically.

after and thus outside of the loop so that after that loop is finished

three total times, it's totally fine to just print nothing other than a

backslash n so long as we now recompile the code, make Mario, dot slash Mario,

and voila.

Now we have four in a row. It's a little generalized.

OK, so we've sort of plucked off a fairly easy problem.

Well, let's go back to the world of Mario and try something that is, in

vertical like this. So this is another scene with three bricks here. Instead of

using question marks, we'll use hash symbols to represent bricks. This

is the incarnation of my mistake a moment ago.

So let me undo this by getting rid of that printf.

Let me change the inside one from a question mark to a hash symbol, which

most similar in ASCII to a brick.

And let's go ahead and put in backslash n after that.

If I do go ahead and do make Mario, dot slash Mario, it's not that interesting.

But, and it's actually not that correct, because I wanted three.

So no big deal.

I can, of course, go back to my code and change the four to a three. Or better

yet, I could use get int or my new get positive int function and just

this further so that I can print out any number of them. But for now, dot slash

Mario gives me three.

All right, so we've plucked off the second of two problems.

Let's now let things escalate a bit. So it turns out once you get to like world

two and beyond, there's some underground parts of Mario where you actually have

bigger, more solid bricks like these here.

And just by eyeballing it, this is like a three by three grid of bricks. Like

nine of them total will conjecture. So how can I go about implementing this?

Well, now is where the program gets a little more interesting.

And the poorly designed way to do this would be like,

printf, hash, hash, hash, backslash n, semicolon, and then maybe printf,

printf. That's kind of correct, but not well -designed. So make Mario, dot slash

Mario. It doesn't look like a square, just because these hashes are more

vertical than they are horizontal.

But it is correct, this example. But it's not very generalizable. And this is

literally hard coding. I copy -paste. And I'm just doing a lot of bad

here. So what could I do instead?

Well, it turns out we can combine today's ideas, including loops, to do

again and again.

So what is this grid of bricks?

It's a three by three.

So it's like a row and a row and a row.

And then within each row, there's column, column, column.

So it too is like an old timey typewriter that sort of prints one line,

next line, then the next line, and so forth. So how can we conjure that in

Well, let me go ahead and do this.

I think an approach would work is like this. For int i equals 0, i less than 3,

i plus plus, because I know I want to do something three times.

But what do I want to do three times? This loop kind of represents in my

eye rho, rho, rho.

So in fact, I could be more pedantic. If I want my i to mean something beyond

int, I could say rho equals 0, rho less than 3.

row plus plus, just to help me think about it.

And then what do I want to do on each row?

What do I want to print?

Like column, column, column.

So brick, brick, brick.

So how do I print three bricks or any number of bricks? Well, I could kind of

cheat and just do printf hash, hash, hash, backslash n. But again, I can't

generalize. I can't take an input from the user and print four or five or six

bricks. So that's going to get me into trouble eventually.

So maybe I could use a loop. So I could do like for int i equals 0, i less than

3, i plus plus inside of my loop. And then in here, I could print out one

And that's kind of on the right direction, the right path, because now

using the simple building block or brick.

but reusing it again and again. And it's totally fine to have nested these

columns in this way.

I used i out of habit, but what would a better name be?

Well, maybe column, or maybe just col, call for short, so that my code is sort

of saying what it does for me.

And I don't have to use row or column explicitly. I don't need to print them,

but I am using them as counters, one after the other.

So let me go ahead and run make Mario, dot slash Mario.

And I'm feeling good about this, but .

Damn it. There's nine brick, but they're not really laid out right.

Why? What's the fix? Yeah.

Yeah, I never went to a new line. And let me do what I think you're not going

suggest I do. Let me just go the obvious place. All right, well, let's put one

right after the brick. But of course, if I do make Mario, dot slash Mario, I'm

making the same mistake as before. I'm printing out too many new lines. So in

between, what lines do I actually want to print a new line?

Between, yeah.

Yeah, so 10 and 11. So outside of the inner loop, but inside of the outer

So it happens again and again. So let's just print out as before, single

backslash n, semicolon. Now let's do make Mario, dot slash Mario, enter. Ah,

it's generalized as I see fit. And if I really wanted to dwell on this.

I could go in, and I could prompt the user with get int or with get positive

int, figure out what row and or column should be. We can make any size brick

that we want. But now we have sort of a nice starting point.

But there's another way to think about this. Because I dare say, especially for

your first CS50 problem set, if you're trying to print bricks and the world of

Mario in this way, it's probably not going to be obvious to come up with

like this and just magically get it working after like 45 seconds in total.

It'll be a struggle at first.

there are some patterns to follow. So one, it's pretty conventional.

Nonetheless... to use just i and then j and then k and then l. And if you've got

nested, nested, nested, nested for loops, at some point nesting, you're

writing bad code. It's not well -designed. But one or two or maybe three

nestings could be an OK thing.

But you cannot use and reuse i again and again. Why?

Because if you're counting i here, but then you're changing i here to do your

columns left to right, you're going to get all of your math out of sync. So you

need two separate variables.

i and j are conventional.

row and column would work too.

But if we go back to this idea of rows and columns, well, let me actually

something out here.

And this might help you instead.

Suppose that you set out on this problem.

You know you want to do something like three times, but you don't quite

understand how to print those rows.

Well, take a baby step, a bite out of the problem, and maybe do this.

Create a function with no output.

just a side effect, whose purpose in life is to print a row.

And how many rows?

Well, maybe n for some number of bricks.

How do you print a row of brick?

Well, let me just think about this in isolation.

How do I print a single row of brick? That's easy. For int i equals 0, i is

than n, if I'm generalizing, i plus plus, and then, whoops, i plus plus, and

then. Inside of my curly braces, go ahead and just print out a single hash.

And at the end, as you suggested, print out a single new line. In other words,

abstract away the idea of printing a single row.

And in fact, at this point in the story, especially if you're struggling to get

started, you don't even need to start with main. Take a byte out of the

that makes sense to you that's smaller than the whole problem.

printing a single row.

Because then you can come in and iterate.

Then you can go in and say, OK, now let's write my actual main function.

So int main void, as always.

And now what do I want to do? I want to print out a whole bunch of rows.

How do I print out a whole bunch of rows? Oh my god, it's like the same

int i equals 0. i is less than, let's call it 3 for now, but we can generalize

that. i plus plus.

And what do I want to do on each iteration of this loop?

My gosh, just print row.

with three bricks.

And then we're sort of done.

Again, out of sight, out of mind. This function can go away and never be seen

before, because once print row exists, that's what it, in fact, does for me.

Now, this isn't 100 % correct.

I still need my prototype, because if I've made my own function, I need to

see in advance that it shall exist. So I need to copy and paste that one line of

code. If I were really being pedantic, this is bad design.

In general, when you have the same number in multiple places in a program,

programmer would call this a magic number. How is that working? You're just

honor system that you're using the same number again and again.

So a better solution here, even if you're not going to take user input,

to do this.

int n equals 3.

and then use n here, and then use n here, or you could call it anything you

want, but now you've specified three in one.

and only one place.

And we can go one step further. It turns out in C and in other languages, you

can protect yourself against yourself.

If you know that a variable should never change its value, it should always stay

3 in this case, you can use what's called a constant, where you can

say, I don't want just n to be an int. I want it to be a const int, const for

short for constant. And this means even if I try to change n in my code, the

compiler will not let me. So I can protect myself from myself or in the

world, you can use a variable that none of your colleagues can foolishly change

on you without you realizing that it has happened.

So a lot of programming, honestly, is just not trusting yourself the next

morning when you've forgotten what code you wrote, let alone the next month, the

next year when you're writing code in the real world. So constants just give

a feature to defend against ourselves.

There's another feature that's useful too, especially when you wake up the

day and you're like, oh my god, how does this code work? What does it do?

Well, there's comments in code. And some of you might have used this in Scratch.

You could add little yellow sticky notes in Scratch for comments.

In code, you can do something like this.

You can, if you want to put an English reminder to yourself, or if you speak

some other human language, a comment in Spanish or any other human language, you

can write it with a slash slash at the start of the line. And then you can say

something like print n.

And then this tells you in a comment what those subsequent lines of code are

doing. It's sort of a note to self. It has no functionality. For the computer's

sake, it just is a note to yourself.

Or you can say something like this, like, never change n, because you're

clear that it's indeed constant. But that, too, is a little pedantic, since

const says the same. But comments are notes to self to help you remember what

something is doing or why you did it this way.

Questions now on any of these Mario problems that we have solved?

No?

All right. So one final set of examples that puts the limit of what computers

can actually do. That's why we've solved every problem I proposed.

That's because I've kind of been skirting some of the underlying

So it turns out that we have not only functions that give us side effects,

visually on the screen, we again have functions that have return values. So

let's focus on those and where things can go wrong. And let's use a bunch of

other operators as well.

Suffice it to say, computers got their start by being really good calculators.

So computer support, addition, subtraction, multiplication, division,

operators represented by the percent sign here, which says take the remainder

something over something else. And there's even more operators than this.

let's go ahead and implement our own calculator of sorts that actually has

bugs along the way. Let me go back over to VS Code here. I'll close mario .c,

open my terminal, and code up one final file called calculator .c. And in this

calculator file, let's go ahead and do something super simple initially.

Let's go ahead and include cs50 .h.

Let's include standardio .h.

Let's do int main void, as always, all boilerplate thus far.

And now let's do something more interesting.

int x equals get int.

And we'll prompt the user for an x value.

int y, prompt the user for a y value, as we've done previously for comparing

numbers. And let's just do something super simple. Let's give myself another

variable, int z equals x plus y.

And then let's print out the sum.

So printf, quote unquote, and I don't want %s here. If I want to print out a

number, someone said it earlier, we want %s for string, but %i for integer,

backslash n.

and print out the value of z.

So it's a little silly, this calculator.

It just adds two numbers together, but it's going to demonstrate some points.

make calculator, enter.

So far, so good. Dot slash calculator.

Let's just say x is 1, y is 2, z is going to be 3. This code is correct,

though it is. Is there an opportunity for marginally better design?

Could we tighten this up, make it shorter? Fewer lines means lower

of bugs, probably?

Yeah.

Yeah, we don't really need a separate variable z.

I mean, it's fine if it's clearer to you, if it's clearer to your TF, if it's

clearer to your colleagues. But honestly, this is so relatively simple,

we just get rid of z and just say something like x plus y here, which is

reasonable as well.

But you don't want to take this to an extreme.

Heck, if we don't need z, do we really need x and y?

Well, we could do something like this.

Let me actually delete these lines of code.

And claim, we can do this all in one very pretty one -liner.

We could do, say, get int x plus get int y.

And notice now, kind of like the join example last time, I'm calling get int

twice.

Both of them return a value.

which is going to be 1 and 2, respectively, based on what I typed

Then I'm doing 1 plus 2.

That's going into printf as the second argument. This is actually correct and

will work. It's just stupid.

Don't do this. We've crossed some ill -defined line where this is just harder

now to read.

And so even though the variables aren't strictly necessary,

I would argue, and I think most programmers would argue, This is just

readable. Each line is doing a little bit less work. There's less chance for

error. It just makes a little more sense. But reasonable people will

So therefore, this is to say, over time too, like you and your TF might

disagree. You and your colleagues might disagree.

And at that point is when the sort of religious debates kick in as to which

is the right way.

All right, so that's one calculator.

Let's do something else that maybe just doubles a number here.

So let me change this to just get one integer from the user. Let's just call

x. And let's just double it quite simply. So printf %i backslash n x times

2. We'll quite simply double it. The star operator is indeed multiplication

this case. So that's going to go ahead and double my number. So make calculator

again, dot slash calculator, Enter. And let's go ahead and type in 1.

And I get back 2. Let's run it again. Type in 2.

I get back 4.

Type it again. Let's type in 3.

I get back 6, and so forth. All right, so that's not bad in this case here.

But what if we actually want to write a proper program here?

In fact, yeah, let's see. This is sort of a meme that comes and goes.

Let me see if you recognize this.

I'm going to go ahead and say.

Another variable, not x. Let's be more specific, like int dollars equals 1.

And then let me deliberately induce an infinite loop. Sometimes it is useful to

induce an infinite loop so long as you eventually break out of it somehow if

don't want the program to run forever.

I'm going to ask the user a question, asking them for a char c using get char.

And I'm going to ask them, quote unquote, here's percent i, period.

Double it and give it to the next person, question mark.

This is ringing a bell. And then we can pass in to Getchar the dollars value

there. So actually, this looked a little cryptic already. I'm going to put a

dollar sign in front of it as though we're actually dealing with US currency.

And what do we want to do? How about if the user says Y for yes, double it and

give it to the next person, then let's go ahead and do dollars.

And let's double dollars. So I can do dollars equals dollars times two. Or

recall the trick for plus and minus. I can also do.

times equals 2, which just doubles it in one line as well. Just a little

syntactic sugar, as programmers call it, that just tighten up your code, even

though it's the exact same thing.

But what if the user does not type y and they want to keep the money?

Well, we have an else condition.

At that point, you don't want to keep asking, asking, asking, asking them with

get char.

Let's just break out.

of this loop instead.

So break is another keyword that if you're inside of a for loop, a while

do while loop, you can forcibly break out of the loop early if and when you

to. And so this sort of satisfies the goal of making sure that this doesn't

forever, but it is going to run again and again and again while we keep

prompting the user with this question.

So let's see now what happens.

Except at the end, let's go ahead and make sure the user knows how much money

they're walking away with.

Here's dollar sign, percent i, backslash n, dollar. So we will see at the end of

this whatever dollar amount the person ends up with.

Make calculator, enter, dot slash calculator.

And let me increase my terminal window size.

So here we go. Here's $1. Double it and give it to the next person. Yes.

Here's $2. Double it and give it to the next person.

Yes. Yes.

Yes. Yes.

Yes. So the Instagram reels aren't that long. But if you keep doubling it again

and again, this is called exponentiation, which will make you

quite quickly. Because notice, we're already in the thousands of dollars by

saying yes and yes and yes.

It's an interesting sort of societal question as to what dollar amount you

keep the money and no longer double it and pass it on. But for now, we'll just

keep doubling it, because this is just getting bigger and bigger, seemingly

infinitely large in the C program.

But oh my god, like apparently,

The Instagram reels cut off the meme too short because eventually it goes

negative and then zero.

Like, what's actually going on here?

Like, the code is actually correct, but we're bumping up against a different

kind of problem.

Any instinct for what is actually going wrong here? It's not doubling forever?

Yeah.

Yeah, there's not enough bits to store bigger and bigger numbers. Recall with

bits, which happens to be how big most ints are, you can count as high as 4

billion if you start at 0, or roughly as high as 2 billion if you want to handle

negative numbers as well, negative 2 billion to positive 2 billion. So

eventually, once I get to $1 billion, it goes negative, and then it just goes to

0 altogether.

This is because of something called integer overflow, whereby if you only

finite number of bits, And you keep incrementing them, incrementing them,

incrementing them.

Eventually, you can't just carry the 1, because there's no 33rd bit.

So all of the other bits wrap around from 1s to 0s. And it looks like all 32

your bits are 0.

Because the 33rd bit was supposed to be the one, but it's not there. They don't

have enough memory. So this is a fundamental problem with computers

you count high enough, things will just start to break, at least if you're using

C or C++ or certain other languages that don't anticipate this.

And there's a very real implication of this. So here's a photograph of

we'll look at more in time to come, like of memory inside of your computer or

phone or any electronic device.

Suffice it to say, there's only a finite amount of memory. And if you're only

using 32 bits then, or heck, even three bits, you will eventually overflow.

We used three bits last week. So here's an example. In binary, if you're only

using three bits per the white digits here, I've put in gray the fourth just

show you what carry we might want to have.

Here's 0, 1, 2, 3, 4, 5, 6, 7, just like last week. And

just like last week, someone said, how do we get to 8? We need another bit.

But if that bit is grayed out because it doesn't exist, we've just overflowed

this tiny integer and gotten back to 0, just like my money went to $0 instead.

So how do we actually avoid that?

One way to do this is this. Let me hit Control -C to break out of the program,

or I could just type no. Let me shrink my terminal window.

and clear it here, I could actually do this.

It turns out that ints use 32 bits typically, but there's another data type

was on the slide before called long, which is a longer version of an int,

is 64 bits, which is crazy big.

There's not that many dollars in the world, but it's still finite, even

can't pronounce the number that big. But if we change all of our int to long,

and we change our placeholder from percent i to percent li for long int, I

actually count higher and higher. So case in point, let me actually go back

my terminal, make calculator, Enter.

Make it larger again.

Dot slash calculator.

And I'm just going to keep saying yes, but faster this time. The sequence is

exactly the same. But recall that once we got into the billions, it started to

wrap to negative and then zero.

This is a lot of money now. Like longs are indeed longer. And I could do this

probably all day long.

Oh, interesting. No, I shouldn't have said that.

Can't do this all day long because eventually a long two will overflow. I

didn't think it was going to happen that fast.

So a long 2 will overflow because we'll need a 65th bit, but the computer has

not allocated it. So that 2 becomes an issue of overflow.

To read an excerpt, like these are very real world issues. And in fact, here's a

photograph of a Boeing.

787 years ago that actually had issues beyond the most recent issues with

airplanes, whereby after 248 days, the Boeing 787 years ago can lose all

of its electrical power due to the generator control unit simultaneously

into failsafe mode, whatever that means.

But if you dig into this, it turns out that there was a software counter in

these airplanes years ago that would overflow after 248 days of continuous

power.

248 days, why?

Well, Boeing was using a 32 -bit integer, and they were using it to

tenths of seconds.

And it turns out if you do the math, after 248 days, you have used too many

tenths such that you overflow the size of a 32 -bit integer. The plane would

essentially have this integer, this tiny, stupid little variable overflow.

But generally speaking, when your numbers suddenly go negative or zero,

things happen. The plane could literally lose its power mid -flight or on the

ground. And if you can believe it, anyone want to guess what Boeing's

was till they fixed the actual software?

What's that?

Not even.

Reboot the plane.

Like, they were told every few days, certainly every 248 days, turn the power

off, turn it back on, which stupidly is what all of us have been told for years

with our Macs and PCs and phones. Why?

Because sometimes, because of bugs in software, computers get into funky

which is a colloquial way of saying, like, some programmer made a mistake,

some counter overflowed, or some condition wasn't handled, and just

unexpected things happen.

So rebooting just resets all of your variables back to their original values

sort of gives you more time. more runway, in this case, no pun intended.

There are others. In fact, one of the most famous ones from the 1980s was the

original Pac -Man game. Only had support for 255 levels.

Why? They were using 8 bits.

Recall that 8 bits gives you 256.

But if you start counting at 0, you can only go to 255. So the crazy kids who

were so good at Pac -Man that they got to level 256, the makers of Pac -Man did

not anticipate that anyone was going to win that many levels. And just weird

stuff happened on the screen. All of the fruit sort of started overwriting

everything because they didn't have enough memory allocated to the level.

did they have a condition that says, if level equals equals 255, you win.

Like, there was just nothing handling that corner case, so to speak. So these

things abound even these days.

Thankfully, in some languages, There are better solutions where you can use big

integers. And you'll just use 64, maybe 128, maybe 256 bits. But you need to use

a language or a library that allows you to grow and shrink the amount of memory

being used. And many, if not most, languages do not do that for us.

So there's a few final problems to see that we've been taking for granted thus

far. And they also involve...

numbers, and memory.

So let's go back into our calculator.

Let's throw away all of this meme code here.

And instead, let's go ahead and do something simple again.

int x equals get int and prompt the user for a variable x. int y equals get int,

prompt the user for a variable y.

And this time, instead of addition, instead of doubling, let's do division.

So printf, quote unquote, percent i, backslash n, and then plug in.

x divided by y. So you use a single forward slash for division.

Let me go ahead and make calculator down here, dot slash calculator.

And let's go ahead and do 1 divided by 3, which should in fact be, well, it's

not really 0, right? It's like 0 .333.

Let's try this again. How about dot slash calculator? 3 divided by 2 should

.5. Nope. Computer thinks it's 1.

Well, what's happening here? Well, it turns out when you're using integers in

program, you are vulnerable to what's called truncation.

An integer plus an integer gives you an integer. An integer divided by an

integer, funny enough, gives you an integer.

So even if the answer is supposed to be 0 .333 or 1 .5, everything in the world

of integers throws away the decimal point onward, and you only get the

part of the value. So it's not even rounding.

It's truncating everything after the decimal.

So this program is just not correct. But there are solutions, potentially.

For instance, if I go back into my code here and I use a different format code

we haven't used yet. We had s for string, i for int. There's also f for

And a float was Like a real number, something with a decimal point in it by

definition. We just haven't used it yet. I could tell the computer to print this

as a float. So let me do make calculator again.

And now, hmm, it's specifying type double. There's an error here.

The problem is that I can't just tell the computer to format this number as a

float. I need to convert.

the number x divided by y to a float.

And I can do this in a couple of ways. One, I could literally change all of

to floats and just avoid the problem altogether.

Use float, use get float, use %f, and I'm done.

But if I want to use ints for whatever reason, because I want the user to type

in integers, but I want to show them real numbers with decimal points for

correct math, I can do what's called casting a value.

I can, in parentheses, which is a weird new use of parentheses, I can say, hey,

computer, please treat the following integer as a float instead, thereby

avoiding truncation. Do not truncate for me. So if I now run make calculator

again. dot slash calculator, and type in, for instance, 1 for x, 3 for y, now

get an actual floating point value.

I'm formatting it as such, and I'm telling the computer to actually

arithmetically calculate it as such as well.

But here, too, I'm kind of cheating you of a reality.

It turns out, let me clear this screen here, and it turns out that there are

fancy ways in printf to tell it how many digits to show you, how many

significant digits.

And the syntax is very weird. I have to look it up constantly. But instead of

just saying percent f, you literally put some numbers in between there. And you

say 0 .5.

And that will say, it's weird syntax, hey, printf, format this to five digits

instead. So let me go ahead and do make calculator again, dot slash calculator.

And let's do 1 divided by 3. And indeed, I get 5.

significant digits there. But suppose I get a little crazy and I want 50

significant digits.

Well, according to grade school, I should just see more like threes. But

this. Make calculator dot slash calculator.

And it turns out that whoever taught you grade school math was kind of telling

you some white lies. Because if you really do it with a powerful Mac or PC

phone, one third is actually 0 .33333334326744079.

Who's right?

Mr. and Mrs. So -and -so from grade school or like the internet?

What's going on here?

What explains this? It all comes down somehow to weak zeros, zeros, and ones.

Why is this floating point number imprecise, so to speak?

What's the intuition? Yeah.

Yes, similar in spirit.

Just as ints only use 32 bits, floats also use only 32 bits. If you want more,

just as int has long, floats have something called double. So I could kind

avoid some of the problem by switching to double, but that's still going to be

finite. And if you think about this intuitively, if you're using a finite

of bits, be it 32 or 64, you can only represent literally so many patterns and

thus so many floating point values, so many real numbers. But how many real

numbers are there in the world?

Like literally infinitely many is the challenge of real numbers. You can just

keep adding numbers after the digits. So how could a computer, Mac PC or

otherwise, possibly represent every floating point value super precisely if

there's not enough patterns to represent every number in the world? Moreover,

the way that computers use to represent numbers sometimes do not allow them to

represent numbers so precisely. We can get more significant digits maybe, but

not 100 % perfection or precision.

So floating point precision too. is a fundamental problem with computers

And unless, again, you're using a specialized language or library that

understands for scientific computing the implications of overflow or

imprecision, your code will have mistakes, much like Boeing discovered,

like Pac -Man discovered as well.

And in fact, just to end on a gloom and doom note, it turns out there's another

problem like this on the horizon already.

So back in my day, everyone was really worried about the Y2K problem, the year

2000 problem. Why?

when computers were invented, most systems were using just two digits,

independent of bits, two digits to represent years.

Why? Computers came out a few decades ago.

Who would think that a computer is still going to be running decades later?

Turns out they were, especially in government and corporations and the

if you're only using two digits to represent years, And the millennium

around, and it's 1999, about to roll over, about to roll over. What comes

1999?

Well, if you're only using two digits, ideally 2000.

But if you're only using two digits, the year zero comes after the year 1999.

And the whole world, truly, you can look it up nowadays on Wikipedia, was

freaking out because there was so much old software in the world that could

had this mistake. And who knows? Planes falling out of the sky, computers

rebooting, freezing. No one really knew because this was an unhandled situation

in code.

So thankfully, the world actually got its act together. The world did not end

the year 2000, and most systems were updated in time without crazy horror

stories. But we're going to have this happen again, because it turns out Just

few years from now, at this point, computers for years have been using 32

integers to keep track of time, in the sense of what time of day it is. And the

point in time they decided years ago was, hey, everyone, let's just keep

of how many seconds have passed since January 1, 1970.

And we can relatively compute time any time thereafter.

So that's great. That gives us a lot of decades worth. But 32 bits eventually

maxes out at like 4 billion. and positive, or 2 billion if you want

positive. And it turns out if you count the number of seconds between 1970 on

up, On the day, January 19, 2038, the world might again end because all of

clocks are going to overflow.

And we're going to end up in the year zero or negative something.

Now, what's the solution there?

I mean, my god, it's the exact same thing. Like, stop using so few bits. Use

more bits. But bits and memory and computers used to be expensive.

Nowadays, storage is so much more available.

But among the things we'll discuss then is how you can throw both hardware and

software at this problem. But for now, maybe set a Google Calendar reminder for

January. January 19th, 2038, and hopefully we'll see you next week.