[VIDEO PLAYBACK]

- --we know?

- That at 9:15, Ray Santoya was at the ATM.

- So the question is, what was he doing at 9:16?

- Shooting the nine-millimeter at something.

Maybe he saw the sniper.

- Or he was working with him.

- Right.

Go back one.

- What do you see?

- Bring his face up.

Full screen.

- His glasses.

- There's a reflection.

- That's Neuvitas baseball team.

That's their logo.

- And he's talking to whoever is wearing that jacket.

- We may have a witness.

- To both shootings.

[END PLAYBACK]

DAVID MALAN: This is he is CS50, and this is lecture 3, and that

is not how computer science works.

And indeed, by the end of today, we'll make

clear exactly what's right, what's not right about that,

and hopefully give you some pause any time you watch TV or movies hereafter

and notice these little things that all too many writers seem

to take for granted.

So recall that last time, we took a look lower level at what compiling actually

is.

And recall that it was a few things, these four steps of pre-processing

and compiling and assembling and linking,

so that when you start with their source cod,

that might look like this code that we have written in the past,

you first have to preprocess it, and the first step in pre-processing was

converting all of those processor instructions--

anything starting with a hash at the beginning-- to their equivalents.

So opening the files and effectively copying and pasting the contents

there so that programs and the compiler know what get_string

is and know what printf is.

The next step that came after that was actually

compiling, whereby compiling technically means taking that source

code, once it's been preprocessed, and printing and generating

this very cryptic-looking stuff called assembly code.

And those assembly codes or assembly instructions are really what the CPU--

the brain of your computer-- actually understands,

although technically the computer understands them only in the form

of 0's and 1's.

And so when you "assemble-- step three--

that assembly code, you actually get out those 0's and 1's.

But even that simplest of programs where we just prompt the user for a string

and then print out their name still involved a couple more files.

There was not only cs50.h and stdio.h at the top,

somewhere in the computer system there's probably files called cs50.c,

and in the case of stdio, printf.c, in which actually the code is

for those two functions, those two have to get compiled down

to 0's and 1's, and then we need to link everything together,

merging those 0's and 1's so that the computer has access to your code

and to printf's code and to the cs50 library's code And so forth.

But all of that we can just generally wrap up in the descriptor of compiling.

And so that's one of the looks we took last week.

And we also have introduced, last week and previously, a few tools.

And odds are, you're having as many frustrations perhaps already

with the p-sets as you are accomplishments

and sense of satisfaction.

And that's normal, and rest assured that the scales will eventually tip more

toward happiness and away from sadness, but we'll

give you indeed more tools today than these for actually finding

problems or shortcomings in your code.

help50, recall, helps you with what process?

When you instinctively consider using help50?

When you see error messages on the screen.

Something you don't understand that's the result of some mistake you

probably made but you don't quite understand what the computer is telling

you, run help50, and then that same command and we, the staff,

with our code will try to understand the message for you

and provide you with feedback.

style50 does exactly that.

It helps you see with red and green color coding exactly what spaces should

be there, shouldn't be there-- it just helps you pretty

your code so that you can read it better and other humans can as well.

And then printf, which is kind of like the coarsest tool in your tool box,

this is just helping you see not only messages you want to see,

but just the values of variables.

You can print ints and strings, whatever you want,

and then you can delete those lines of printf

once you're confident your program's working.

But that gets a little tedious, and honestly, as our programs get bigger,

we're going to want more powerful tools than like manually printing things

out, recompiling, rerunning, it very quickly it gets tedious.

And the goal of programming is not to be tedious, but to be empowering,

and that's where we'll step to today via this.

So CS50 IDE is sort of fancier version of what

you've been using called CS50 Sandbox, and in turn, CS50 Lab.

Now recall that both of those tools, the Sandbox and the Lab,

have a terminal window where you can type commands,

they have a code editor where you can actually write your code,

and then they have a file browser with icons and such

where you can actually see your files and folders.

So it turns out that CS50 IDE is another tool that at first glance

is very, very similar, even though it's laid out a little differently,

but it has as many features as the Sandbox and the Lab, but some more.

More features that actually help you solve problems in your code

and even collaborate come final project time with others if you would like.

So this we'll see is this is the CS50 IDE.

It comes with the so-called night mode so you

can make everything a little darker on your screen, especially if p-setting

at night, and let's actually take a look then

at what you can do with this kind of tool.

When you log into this tool for the very first time in the next problem set,

you'll see an interface that's almost the same as before.

The colors are a little different, the font sizes are a little different,

but at the bottom by default, you have your so-called terminal window,

though instead of the dollar sign now, you'll

see a little more detailed workspace, but more on that in a bit.

Up here you just have the code editor window,

nothing's really going on there.

And then we have the added feature of Ceiling Cat

in the top right-hand corner.

And we'll also see some other features along the way.

So let's actually write a program in CS50 IDE, which, to be clear,

is just another web-based programming environment that also gives you

access to your own cloud-based server.

It, too, is running Ubuntu Linux, which is a popular operating system that

is not macOS and it's not Windows.

But unlike the sandbox environment where you don't even log in

and you lose your files eventually, as you

may know from when your cookies are lost or something goes wrong,

the IDE saves everything.

And you'll log in with your account, and whatever

you put there last week is going to be there this week and next week

and beyond.

So let me go ahead up to File, New File, or I could just click this little plus

icon in the top right-hand corner, and let me go ahead and preemptively hit

Control-S or Command-S or go to File, Save--

you should find the interface very similar to any Mac or PC program--

and let me go ahead and save this file as follows.

I'm going to call this hello.c.

And it's important to mention the file extension,

otherwise the IDE, like the Sandbox and the Lab,

won't know what type of program you're writing.

And then let me go ahead and just write my simplest of programs.

So let me go ahead and include stdio.h, int main void.

Let me go ahead and open my curly braces, printf--

hello, world, backslash n, and a semi-colon.

So you'll notice that almost everything is the same.

The colors are a little different, perhaps,

and you might see some different assistive

features as you're typing your code, but the end result is the same.

And the color coding you just get for free because it's helping

draw your attention to different parts of the code.

Let me go ahead now and--

oh notice this.

There's one difference.

The IDE is a more powerful tool, but as such, it's a more manual tool

and it's not just going to auto-save your code for you.

Nice as that's been with the Sandbox, such that you'd never

actually had the hit Command-S or Control-S--

and if you were, you didn't need to be, the IDE

is only going to save things when you want it to so that nothing

will happen magically anymore.

So what I'm going to have to do is go back up here, File, Save, or Command-S

or Control-S, you'll see a little green dot

briefly, and now and back at my prompt.

I'm going to go ahead now and type my familiar command, make hello, Enter,

and you'll see pretty much the same cryptic-looking client

command as before because the IDE is configured quite like the Sandbox.

And if I want to go ahead and run this now, how do I run this program?

Quick check?

./hello, it's exactly the same as before.

./hello, and there we have it, hello, world.

So long story short, the user interface thus far is a little different,

but functionally it's the same.

We're just going to now start to see some more features.

So what are those features?

And let's introduce new some capabilities that were actually

possible in the Sandbox, we just didn't really introduce them at the time.

If I click this folder icon at top left, you'll see all of my files and folders.

And today for lecture I have a lot of pre-made examples

that are already on the course's website, some of which we'll look at,

some of which we'll refer to the website,

but these are just familiar files and folders.

And you can see that everything in my account

is apparently in something called Workspace, which

is just a folder, name, or a directory.

Here's my sc3 directory, which again, comes

from the website for today's lecture, lecture 3.

And then here's the file I just compiled in the program and the file

that I wrote, hello.c.

You'll notice too that there's this funky symbol here, tilde,

that you might not have occasion to write often in English,

but in Spanish in other languages you might use this character.

This is actually a shorthand notation for what's called your home directory.

In this environment, CS50 IDE, you have your own home directory, which

means your folder of files and other folders that you get to create,

you own, and that persists every time you log in-- you're not

going to lose the contents therein.

So this just means that in your home directory, a.k.a. tilde,

there is a folder called workspace in which I'm currently working.

And that's just one folder in which all of my work is going to be done,

because there's so many other files and folders in this cloud environment,

just like there are in your Mac and PC, we just generally

don't care what they are.

But notice what we can do at this terminal window besides compile

and run code.

There are other commands.

For instance, this blue text here, similarly to the file browser up top,

indicates now not just that this is my prompt per the dollar sign,

but that in my home directory's workspace directory.

So that means I can be elsewhere even though I haven't

specified where I want to go yet.

And in fact, I can do this. ls stands for list,

it's just shorthand notation for that.

And now I see a textual version of my file tree, so to speak.

So you'll see here, sc3 is a folder, and you

can tell as much because there's a slash at the end of it.

hello.c is of course the file I wrote a moment ago.

And then hello in green is my program that I compiled, and the star

or asterisk there is just--