[ Silence ] 

>> This is CS50, Week 1, thought we'd begin with a cookie love story. 

[ Music ] 

>> So this was a Scratch project submitted by one of last year's students. And what's nice is because not only is it rather cute, it also draws in all of these fundamentals that we started talking about last week. And if you haven't yourself dived into your own problem set zero, whose PDFs are available online, realize that if something like this, given that it's a minute or so long, kind of looks you know, despite the cutesiness of it, kind of overwhelming in that you don't really know where to begin, how could you possibly sketch out this whole story line. Well, realize one of the themes in this course and really one of the themes in programming and solving any problem with a machine is going to be really to just take small bites one at a time out of these problems until the end result ultimately is that you've actually bitten off a fairly large fairly interesting problem and in the aggregate, you've actually implemented something pretty sophisticated. But if you set out trying to implement this whole story line at once, if you set out trying to implement a cookie love story, it's just not gonna fly. You're gonna run into innumerable bugs most likely, by bugs we mean mistakes, behaviors that you didn't quite intend and yet they seem to be--and yet your program seems to be misbehaving in some sense. And so with this example here, I thought I'd propose that we consider exactly how you'd go about tackling something like this. Let me restart it but in the smaller scope of this window. And there's a few things going on here, so clearly there is multiple sprite, multiple characters, and recall from last week that each sprite has its own set of strips or programs. The scripts are in the middle, the sprites are on the right hand side, so when I have the stage selected at the moment, I'm seeing the script that are associated with sort of the whole program itself, the so called stage. But I could home in on sprite 1 there and just see this particular sprite script. So now let me actually reverse this and go back to the beginning. So it's a lot just happened here. But how do you go about implementing something like this. Well, honestly start easy. The first thing you probably want to accomplish or at least one thing that seems easy is find the graphic of the cookie sheet that you happen to want for this project. Lay it down and make sure it's in the right position, right? Check. So, we're making progress already. It doesn't do anything but at least that's one bite out of this problem. Now, focus on just one of these sprites. For instance the cookie, the gingerbread man, the gingerbread woman or whichever one of the cookies you want to introduce first and focus just on getting that cookie to dance. And what do we mean by dance? Figure out how you can make it move a little to the left, a little to the right, up and down and then repeat in some kind of looping structure. And then after a few minutes or maybe an hour, you hopefully have at least one dancing cookie. Maybe there is no music, so it's just kind of dancing in the middle of a cookie sheet all by himself. But now at least you have a template that you can base cookies number 2 and 3 and 4 and 5. And if you haven't realized already, do realize per the tutorials that we've linked to online, you can do things like duplicating sprites, you don't have to re-implement the whole thing. And so you can really--the process starts to pick up traction pretty quickly. Now on the next screen, once this thing resumes, realize that--come on. 

[ Background Music ] 

>> Once we changes phases, realize that a whole lot more was happening on the next screen. In just a moment the hearts are gonna start flowing from bottom to top and the cookies are gonna start moving left and right and they seem to be somewhat synchronized with the music, perhaps based on trial and error by the student who implemented this one. Well, how do you get this hearts to move up and own and seemingly in these random patterns? Well, recall that very basic building block we introduced last week which allowed you to grab a random number between 1 and 10 or 1 or a hundred. And if you haven't realized already, the whole point of this stage being a rectangle is that ask him to buy the X and Y coordinates there, it's essentially a grid of dots, of so-called pixels that go up, down, left, right, and each of them is a specific address, X comma Y. So if you wanna pick a random location for one of those hearts so it starts from a different place, we'll pick a random X of random number between 1 and 200 or 300, or however wide the stage is, and then use the move block from the appropriate palette to put that's right there, and then start its movement. In other words, when you bite off your own project or when you start off by looking at someone else's projects, either that we looked at last week or some of the innumerable links we included in the specs, focus on just one piece of it, get that working, and then move on to the next. And this really is going to be a recurring theme throughout the course. You can very quickly drive yourself nuts by sitting down, thinking, oh, I can write this program, no sweat, and then you write it and then there's a tiny little mistake here, but then there's a tiny little mistake here and here, and all of these stupid little things cascade until you try running your program, and the thing just doesn't work. And then it's the situation where you just don't know where to begin. So honestly, one of the best strategies in this course and in programming in general is--generally speaking design, but it's these little tricks of the trade that will honestly make things much more fun, much more easier, and really allow you to focus on the juicy parts of the problem and not little tiny bugs that you may have started tripping over already. So hopefully, approach if you haven't already, problem set zero with that mindset. Take quite literally baby steps. And from each of these individual parts, well, you very likely come out with a very impressive whole. So, with that said, we like to Google ourselves sometimes and so we discovered that FlyBy last night mentioned CS50 among some other courses in its last minute shopping list. So this is to say, for those of you who are joining us today for the first time, that's totally fine. Nothing has been due yet. That's not till Friday, and last week's two lectures are both available online at cs50.net. I didn't quite know how to interpret the tag line that was up here. If you zoom in up top, which I can't quite do with a keynote here, it says, "This last minute shopping, bargain hunting." So, I'm not quite sure what the takeaway there is but realize you are perfectly welcome to shop and then still take the course. If you decide to opt in by a pass fail, I just need to sign your white study card or if you wanna decide before the 5th Monday, just grab the pink slip and I can sign that and you can turn that in at any point and I'm happy to chat during break today or after class if you have any questions or concerns. So, where is the support structure thus far? We haven't sectioned yet. That will officially start this Friday. So more details on sectioning on Friday, but do realize that office hours are very much in progress. Our 60 plus person staff has been hanging out in a couple of dining halls on campus, namely the Cabot and Quincy House. Moving forward, we'll actually move some place other than the dining halls but we thought this is a nice way to start the term in a more casual communal environment. But just go to cs50.net, click office hours and you'll see the Google Calendar with all of the office hours that are still happening tonight, as well as tomorrow and these are just an opportunity to chat, to ask questions one on one with the teaching fellows or course assistants or frankly just a way to hang out during brain break and work on projects and then see what some of your friends might be tackling themselves. As for sections, there will be what we call super sections this coming Sunday, Monday, Tuesday. CS50 sections are standardized on Sundays, Mondays and Tuesdays but we won't officially assign you to sections for a week or so but unofficially, well, there'll be open sections this coming Sunday, Monday, Tuesday. The schedule is also on the course's website under sections. And these are super sections in just that they are superset of the class. You can go to any one of these times more comfortable, less comfortable, somewhere in between, and the focus of these sections will be on the material cover this week as well as potentially the start of next week and with a focus on problem set 1, which is the second problem set, 0 index which will go out via PDF this weekend. So realize the support structure is now in place and in progress so do just let us know at help@cs50.net if you have questions that can't be addressed during office hours. So, we looked last week at Scratch, very briefly, but hopefully you found if you've dived in already that the interface is fairly intuitive and it really just allows you to implement ideas that you conjure up in your mind. Well today we're gonna transition to a more traditional programming language, a lower level programming language if you will where the ideas are pretty much identical to what we've seen last week in what you might have seen in prior courses, but what I thought I'd do is try to set your minds on the equivalence of the ideas we talked about last week, the ideas we'll talk about this week. And even though the syntax, the characters you are about to see on the screen and in programs today onward is a little more arcane, it's a little uglier looking, you've got semicolons and parentheses and fairly arcane syntax, realize that at the end of the day these are just arbitrary human conventions, the ideas are identical to this thing here. 

>> So this thing here, when green flag clicked say, oh, hi world, this was perhaps the simplest program we could write in Scratch. It's sort of the canonical hello world program as computer scientists call this very simple example. Well, starting today in a language called C, this is going to look like this. So again immediately on first glance, a little more arcane, there are some distracting details, these curly braces, the semicolon, the quotation marks. But if you avoid all of these minutia and focus really just on the idea, it looks like what was a blue say block, a so called statement, is now going to be something called printf where the F happens to stand for formatted. But the string, the sentence or the words that we're displaying on the screen, previously you clicked on a little white text field and typed it in, well now you're gonna do the same thing at the keyboard but you're gonna have to sandwich it in between double quotation marks. So it's these little differences that you'll very quickly acclimate to but it's these stupid little syntactic details that trips off, especially those less comfortable early on because if you leave out a single character, namely that semicolon on the right hand side, nothing will work. Which is an unfortunate design decision made many years ago with this particular language. More modern languages as we'll see toward the tail end of the semester are a little more generous with some of these details. Well, this statement here say "oh hi world" is going to map very specifically to this line here. What about some of the other constructs we looked at? Well loops are something we talked briefly about. There is something you perhaps employed. Certainly in the cookie love story was there a looping going on. The cookies were going back and forth and back and forth and the hearts up and down, well, this thing that we had that called a loop last week with a forever block with a statement inside of it is simply gonna look a little something like this. So while. And thankfully the jargon that the authors of this language chose early on conjures up the right ideas in your mind while something is true. So here I've hardcoded the word true which is actually deliberately inducing what we called what last week. So a loop or an infinite loop, because true is always true, there is no--nothing on the screen that seems to change this keyword true, so this is actually a deliberate infinite loop, but so was that thing up top to forever say hi or whatever it is you wanted to do. So the translation here is that whereas last week and in Scratch, the looping structures are yellow and have kind of this brace structure to them. Well in C and many similar languages, you have to implement that same bracing structure with your keyboard using an open curly brace and a closed curly brace, so a tiny little detail. On last week too we saw--and in your projects you might have seen a so-called repeat loop. Same idea. But whereas the other one was obviously forever, this allows you to specify a finite number of times that you wanna do something. Here I arbitrarily chose 10. How can you implement that same idea? Well in C and other languages that we'll see this semester, you use what's called the for loop, and this as syntax isn't quite as straightforward but once you know what to look for, it's very easy to understand. So for, so for the following definition. Now you have a set of parentheses as we'll see in actual code and then I have int I equal 0. So int is gonna stand for integer, it's just a number. I is the generic variable that you use when you really just wanna count something and don't really care what its name is. The semicolon just separates this from the rest. The I less than 10 says do the following as long as I is less than 10. And then on the right hand side I++, we saw that in pseudocode with our socks example last week that just says increment I. So, long story short after this fairly arcane syntax, the end result is completely straightforward, do the following 10 times. But because we're now programming a computer at a lower level and because as we said last week, you really have to be precise and then careful to instruct this machine, this fairly dumb machine that will only do what you tell it to do very specific instructions, do we have to use a more precise syntax than just a puzzle piece might have previously allowed. Well what about variables. Well, this block here on the left that I came up with arbitrarily sets a variable called counter equal to 0 and then it forever says that counters value and then it changes the counter by 1. So this is like counter ++. Well, what is code like that from the world of Scratch gonna look like? Well, you can implement this in a few different ways but here's one approach that uses some of the syntax we just looked at, int counter equals 0. So declare as we'll say a variable, a placeholder called counter. It's gonna hold integers so I have to say int as we'll see and set it equal to 0. Then we have to steal the code from earlier to do a forever loop, a while true loop and then I'm gonna go ahead and use that printf thing that we saw. So everything is kind of coming together now with then the counter ++. So again, idea on the left, fairly straightforward, idea on the right, same but just looks a little different. And lastly with these things called Boolean expressions that allow you to check if something is true or false, well, we've seen this in our loops just a moment ago but in Scratch we might have asked the question, is X less than Y or is X less than Y and Y is less than Z. So you can conjoin these expressions into ended expressions so to speak. Well, the syntax is gonna be pretty similar. The green block is gonna become a pair of parentheses. The less than side is gonna be a less than sign, and then the word and is going to become not one but two ampersands back to back, and we'll see why it's two and not one before long. But that's it in terms of the conversion. And with actually using those Boolean expressions on the left, if X is less than Y say, "X is less than Y" else if X is greater than Y say, "X is greater then Y" else say, "X is equal to Y." So, fairly simple idea, who knows why we actually care what the values of X or Y are at least in this out of context. But to translate this now to a language C, you've got some curly braces, you got an if, some parentheses, but now we're just building on some of the syntax we introduced before. So it's all fairly well convertible from one to the other. And lastly, you might have recalled the Fruit-craft RPG game that we played briefly with the little man that moves up and down, left and right and collects like oranges and apples and then brings them into the store. Well, that program was interesting because it had an inventory which was implemented in Scratch with a list which is kind of like a container that you can add things to again and again. Well, C has things that are similar to list. They're called arrays. We'll see they're not quite as versatile as Scratch's little inventory capability. You're gonna have to be a little more careful when it comes to adding stuff to an array and removing it from. But what looks like this orange block as of now in Scratch, add orange to your so called inventory, well, it's gonna take at least two lines of code in C to actually create the inventory array with this first line and then put something like the word orange inside of it. But at the end of the day, the point of the slides is not to expect you to now go write programs in C but really to just remind you that, hey, if you ever get distracted from some of the minutia that is the semicolons, parentheses, and what is very new to many of you, it's really no different than the fun and games we implemented with Scratch last week. So perhaps take some comfort from that. So here is the simplest program which is perhaps an ironic statement that you can implement with this language called C. So it takes a few lines of code to actually get something up and running and as you'll recall last Friday, I didn't even get this up and running because part of the process of writing a program is to one, write it. So write the so called source code which is in a specific language. Last week we did the socks thing and that was in pseudocode. It's just some bogus language we made up that's kind of English-like, kind of look C-like now that you've seen this syntax, but it was just an arbitrary language. Today, I'm gonna start writing C code with you but I can't just write it and expect it to do anything. What was the key step that I said I needed to do on Friday but failed very publicly to do so? 

[ Inaudible Remark ] 

>> Okay, I did a lot of things wrong. Okay, so a compiler. So I tried running a program in this little black and white window called GCC and we'll see it today working properly that is a so called compiler. So writing a program at least in this language is a two-step process. You write the source code, the stuff that looks like this and then you save your file, and now you just have a text file. The convention is not to call it something dot txt but something dot C, just a convention. But that's not enough because computers at the end of the day only understand 0s and 1s and what you [inaudible] and is clearly not a collection of 0s and 1s. So you have to somehow convert the source code, the C code into 0s and 1s and for that process there exist this tool called a compiler that someone else wrote that takes this stuff as input and produces this stuff as output. And it's the 0s and 1s, that notice they're in patterns of 8 generally or chunks of 8, the so called byte that the actual CPU understands. And later in the semester we will tease apart just a little bit what these patterns are and why they do what they do. But for those of you who decide to go on in computer science realize there is a whole interesting world that uses details like these in the world of networking, in hardware, to actually solve some real world problems. So with that said, let's write our first program. Probably I shouldn't have said it's a two-step process 'cause it's a three-step process to actually write and run it, and the third step is just going to be to run it. So, let's go ahead and do this. How am I gonna go about writing a program? Well, it turns out you can write a program on most any computer. For instance I have an Apple Mac here but you can do this on Windows computers, on Linux computers if you have a compiler installed. It's pretty easy to do this on Macintosh computers. You can just go to Apple's website and download the appropriate link. It's a little more involved on a PC but it's all free, the software you can download, and Linux in similar operating systems generally come with a compiler or you run a simple command to get it. But long story short, all of you who own laptops or desktops could probably be writing programs, trivial though this one is up until now even if you didn't actually know it. 

>> So this time I had the foresight to install this compiler but what I'm gonna do is this. I'm gonna run the command called Nano which is a very simple program. It is similar in spirit to Text Edit on a Mac or Notepad on a PC. I'm gonna call my file hello.c. There's a little bit of distraction here but this is because this is not a GUI, a graphical user interface, this is a CLI, command-line interface, which just means there are no windows and icons. It's really a text based interface. Now just to get used to the conventions, because this is the program you'll use not for problems at 0 but for 1 to start writing programs, notice at the top in this window just reminds you what you're working on. The top left tells you what program you're actually using. The interesting stuff is at the bottom. And most of these commands you don't actually need but this little caret symbol means control, so every keyboard these days has a control key so you hold that and hit X for instance to exit the program. You hit control O to write out your program. I'm not sure why it's not S for save but it's write out and that means save. And so frankly this is pretty much all you need to know with Nano to get up and running. So now let me recreate this program from memory. I think the first thing I saw on the slide was include standard io.h, then I said int main, some parentheses and curly braces. And then I said printf "Oh hi world!". For some reason I had this backslash N, a close quote, parenthesis, semicolon, close curly brace. Alright, so maybe a little underwhelming and we saw already what this program is going to do but let's just go through this process once before we start doing more interesting things and then we'll come back and at least give you a hint of what some of these syntactic details are doing. So I hit control X. It's very unnecessarily arcanely saying save modified buffer, and then answering no will destroy changes. So that part is pretty clear, so hit Y for yes. Then it's saying name filename to write. It's just asking you if you wanna change the name. I'm just gonna hit enter to leave it alone, and now I'm back at the prompt. So generally, if you don't get an error message in a command line environment like this, that's good. If nothing bad happens, it means what didn't happen is good. So with the fact that I'm now just back at my prompt is a good thing so now if I type this command GCC hello.c, this is gonna run this program that Apple wrote in this case or someone else wrote called GCC. It's gonna take as input hello.c and what it's gonna produce as output is something called a.out. Nothing happened. Why? That's good. That means there is in fact something there. So this has created a file that just by convention happens to be called a.out. Why? Well, out presumably 'cause it's output, a because it's the first letter of the alphabet. It was really that creative. Now I'm typing dot slash as a convention. So little tricks you'll start to pick up. Because I know this program was saved by default into my current folder, my current directory, so dot slash means run the program called a.out that's right here in my current directory not in, like, my applications folder or somewhere else. So now I hit enter and voila! I see, oh, hi world. So how did this actually work? Well, let's just give a teaser of some of the details before we move on to actual interesting functionality. So, we'll see in a moment that that first line at the very top, sharp include, says include some code, some source code that someone else wrote. Because what you don't see in this file is any code that actually says put a letter of the alphabet at the top left hand corner of the screen and then put the next character to the right in other words, I'm taking for granted at this moment in time that my computer knows how to print something to the screen. But that was not always the case. Someone--or someone had to implement, had to write a tool called printf that itself takes input between quotes and produces as output some characters on the screen. Now, how can I use code that someone else wrote? Well, I include what's called a header file as we'll call it. This file here is called standard I/O or stdio.h and this is just another text file someone else wrote many years ago and by using that line of code there, I'm telling the computer, give me acces to this code that this other person wrote that's in that file. What's in that file? Well, a whole bunch of stuff but the only one I care about right now is a tool called printf. And henceforth I'm gonna start calling these tools, these monickers that I can use as building blocks in my own program, it's gonna be called a function as we'll see. Now this other stuff here, int, we'll come back to that. Main is relevant because when you start writing a program in Scratch, you used what block as the very first usually? 

[ Inaudible Remark ] 

>> Yeah, so when green flag clicked, and that's kind of the very explicit way of saying when you start this program by clicking in the green flag, here is what's gonna get executed first. Well in C, the counterpart is main. And for now I'm just doing main open paren and close paren. Before long we'll see that you can actually put things inside those parentheses which make your programs even more useful. The curly brace is kind of similar to Scratch's interlocking mechanism that you really see explicitly with for loops. Well, for a thing called main which itself is a function but a function I wrote, a tool I am writing at the moment not like printf which someone else wrote long ago, I have to say where does main start, where does main end, and I do that by using these curly braces. Everything inside of the curly braces is the code I am writing. Finally, what code did I write? Well, just this line of code here. Now, you can probably guess what this piece of syntax does. So the double quote says here comes the input. This is what you typed into the white box in Scratch and anyone perhaps already familiar, the backslash N is the shorthand way of saying what? 

[ Inaudible Remark ] 

>> So it's a new line character. So things break if you try--if the computer tries to take you too literally so it would not be correct generally to do something like that. Even though this looks like what the out--this looks like the output you want, "Oh, hi world" and then everything else should go on the next line. Things generally break and this is also not very readable. You can imagine having many lines of code where all of a sudden your closed quote is on the next line all the way on the left. Things very quickly get ugly and you might even already be feeling this tension in Scratch if you're dragging and dropping and moving things around. Once your programs get fairly complex, it becomes harder and harder to find things and to tweak things if you're not being organized. So you have what are called escape characters like backslash N that is the shorthand notation of telling the computer put a new line character here. So I'm gonna go ahead and save this again. And to recap, we just did three steps. We did Nano for hello.c or whatever I called it, GCC to actually compile into 0s and 1, and then step three is to actually run it. Well a.out is a pretty stupid name for a program, right? It would kind of be unfortunate if every program that Microsoft made and Apple made by default was called a.out. You couldn't really distinguish them, so certainly it has the worlds come up with names for programs. Well, how do you do this with GCC? Well, you can specify what's called a switch or a flag. So in general, when you're running command line programs, they can take input or arguments or parameters or switches or flags. There are so many synonyms for these things. It's just hard to keep track of them at first but they all generally mean the same thing, provide additional input to this program called GCC by just specifying it on the command line. So you see two similarities between the first version, GCC hello.c, and the second version but obviously I've just added which part for that second line. 

[ Inaudible Remark ] 

>> Yeah, dash O hello. And this is arbitrary, but dash O probably means output. So output, what do you wanna output? A file called hello and not the default a.out. So, let's try this, let me go ahead and run GCC again on hello.c but let me move my cursor over and say dash little o, capitalization is usually important, and hello, then hit enter and now I can do dot slash, just say run the hello program I put right here by default, it's not elsewhere on my hard drive, hello, enter and there in fact is that program. So, it's getting more interesting but we'll soon see that things don't always compile as easily as this command suggests. The lines of commands we have to write get increasingly complex. So it turns out a really nice shortcut on most systems, oops, is to say if you have a file called hello.c and you wanna turn it into a program called hello, well, just write in the command makeHello and it will do all of that for you automatically and hand you a program called hello. And we'll see why this is increasingly useful as our programs get more and more interesting. So with that said, where are you actually going to run these programs? So, I'm doing this on my Mac. You might have a Mac, you might have a PC, you might have a Linux machine or any number of other devices and this very quickly becomes a bit of a nightmare because everyone has a slightly different configuration. It's hard to answer questions and whatnot and you don't necessarily have access to the same tools unless you yourself go through the process of configuring your machine manually by following many long sequences of steps. So, an alternative to that that is incredibly common in just the programming world and in industry is to actually not write programs on your own personal computer but to actually write and run them on a server, someplace where the software is all standardized. It is internet accessible so you can access it most anywhere anytime and you can also access tools and software and tricks that the staff have made available. So what you'll see in problem set 0 or problem set 1 is that you'll soon have access to what we call the CS50 cloud which is a bunch of servers that live on campus and on which you will all have a username and password. By default, it's gonna be the same username as you got for your FAS accounts because FAS also has its own systems and you use those usernames and passwords to log into the labs and whatnot. But just realize as a teaser coming for problem set 1 will be instructions on how to activate your so called cloud account and it's on the CS50 cloud that you'll be writing your programs, compiling your programs, testing your programs, running your websites ultimately. Just to fast forward to the end of the course with a little teaser, a lot of students for final projects in the CS50 fair like to host their final projects, if they're websites, at a real domain name, for instance isawyouharvard.com or any--or shuttleboy.com or whatever name you actually find available and you can buy for like 9.99 from various websites. 

>> Well, what we'll be able to do this fall for you because all of the code will live centrally on this cluster of systems called the cloud is if you do decide, mostly for fun or for entrepreneurial reasons that you wanna go buy your own domain name, it's very easy to map that domain name to our servers so that even though the server itself is gonna be called cloud.cs50.net, your users, your friends, your family can actually visit isawyouharvard.com and the internet will know that isawyouhavard.com or your own domain name actually lives here. So, we'll do all of that hosting for you which will be a nice way of giving a little more personal touch to your final projects if you decide to implement something web based and would like your own so called domain. Alright, so let's now start doing more interesting things than just saying hello ad nauseam to ourselves. So, the jargon with that will--with which we'll proceed is this. So a function is just a little tool. It's like a miniature program that you can write or use that someone else wrote and the first one we ourselves wrote is main and henceforth in this language called C just like every Scratch project begins with one green flag clicked so our program is gonna be called--start with this thing called main. The standard library, that first line of code, it's not strictly necessary but any time you use a function, a tool that someone else wrote that lives in that so called library, you do need that include line as we'll see. And if you don't include it, GCC, the compiler will yell at you. And we'll see innumerable error messages today and onward as with you working at home ends on the problem sets 'cause this is the way you learn. And it's actually a useful feedback mechanism. But because C is a fairly old language and fairly low level, it's actually hard to do easy things. Even those of you who've taken AP computer science or something similar perhaps recall that even just getting a piece of input from the user is ridiculously not obvious. You need multiple lines of code, you need these days to use something called a scanner class. You have to jump through hoops just to ask the user for a piece of input which should be really the thing a language prioritizes. So, what we do at the start of the semester, and these are essentially training wheels we very quickly take off once you get more comfortable, we provide you with our own library. It's not called standard io.h, it's called cs50.h. That's where the code we wrote for you will live and then we'll see how to do this in examples today onward but we wrote for you some tools, some functions that calls GetChar for get a character. If you just want a single letter from the user, GetDouble. This is a type of number that we'll see in a bit. GetFloating--GetFloat for a floating point number. GetInt, GetLong long, we'll see what that redundancy means, and GetString. And the last is perhaps the most useful at least at first glance. So, let's go ahead and do a little something with these. I'm gonna go away from my own Mac and I'm gonna go to the standard environment. And the means by which I connect to the so called cloud is with a command line program or GUI program. You'll see how to do this via some tutorials online for problem set 1. But on the Mac, I'm gonna run this program called Terminal. It comes with all Macs by default. PC users will wanna use something called PuTTY which is free or secureCRT with Harvard has available. But again, more on that in problem set 1. I'm gonna go ahead and run this command, SSH, which stands for Secure Shell. This just means making encrypted connection to someone else's server. Malan@cloud.cs50.net, enter. It's asking me now for my password. And now I met a prompt that says who I am as a little reminder. Where I am? And then in the parentheses we'll see in a moment, it tells me what folder I am inside of. So let's go ahead and write a slightly more interesting program. Among your printouts today, even though I generally won't bother printing slides since they're fairly minimalist, we will typically print source codes. You can actually take notes and don't have to scribble everything down that you see on the screen. Every file or program that you see here in this packet is alphabetically listed. So if I say hello.c which actually doesn't exist in here but hi1.c does, you'll find it alphabetically. So let's take a look at this, hi2.c. Actually I'm gonna use a different--I'm gonna do a small cheat today. Rather than use nano on this computer, I'm gonna use a program called Vim, which is just another text editor. It's more like a word processor than it is a simple text editor. So, let's go ahead and open in your printouts if you would hi2.c. So first of all, there're a few more lines of code here. There's a whole bunch of stuff at the top which is wrapping in an ugly way 'cause I've made my font so big. But there're a few details to take away. So when you're writing a program in this language and many others, if you wanna make a comment to yourself or for other people who are reading this with their TF or fellow colleagues, you use what are called comments. So at top left we have a slash and a star and that says everything that follows that--those symbols is just a comment. It's not going to get converted into 0s and 1s. It's just for humans. The fact that I have this star here, this star here, this star here, is really just 'cause I'm a little anal and it looks pretty to make a little box out of everything but it's not strictly necessary. The only thing that matters is the slash star here and the slash star at the bottom of this. All of those are comments. So let's actually scroll down to the interesting stuff here. And as an aside, those in the room who are among those more comfortable, even if we're not quite filling in blanks today, realize we will very quickly entice you with details that you don't already know. Today is meant to level the playing field so to speak. So here we have the code you have printed before you. I'm gonna zoom in a little more and notice it's pretty much 1, 2, 3, 4, 5, 6, 7, 8, 9 lines of code and that's kind of rounding up because of the white space. So what's going on? Well, the first line of code, I'll fix the purple next time around so it's more legible. But this says include and this says include a file called cs50.h that lives in some special place on the server that the cs50 staff wrote. The next line of code says include standard io.h which just as a little sanity check contains among other things, printf. So not the actual function as we'll see printf. Just the .h file as we'll see is obviously named different than a .c file. In a .h file, it's generally the names of functions other people wrote. In .c files are the actual co--is the actual code that other people wrote. All you have to include in your own programs is the so-called header file. And that's what cs50.h and--standard io.h are but we'll see those in more detail before long. So for now, just take it on faith that you'll have to say int before you say main. Then you say main, open parenthesis, close parenthesis, open curly brace. So now after all these stupid setup, we can finally dive in to the actual program. Now this program's a little different from what we saw before because it's obviously not gonna say oh, hi world. It's going to say oh, hi David presumably. That part is uninteresting but how is it doing this? Well, a few details, a few building blocks we can start using in more compelling ways. So previously in the slides, I said there's gonna be things like ints or integers. Well, ints are only so useful. Sometimes you actually want words and characters. Fast forward mid-semester when we talk about cryptography and scrambling information, we need the ability to express ourselves in words, not just numbers, and we have that already. So if I want to use a string as we'll call it which is a word or phrase generally, they always go between double quotes, hence the quotes around David, and they are double quotes not single quotes intentionally. On the left hand side string name equals, well, what would we call this thing called name, in general, using last week's nomenclature? That's just a variable, right? It's more interestingly named an X or Y or Z. If we named it based on what it is, it's a name. So it's--the name of the variable is name. Now, what type of variable is this? Well, unfortunately in C, you have to be ever so specific as to what you wanna put in the variable. So whereas before I mentioned int, turns out if you wanna put a string in a variable, you have to say this is a string. Now at this point in the story, I have a variable called name, stored inside of that is the string, literally David. What do I now want to do with this variable? Well, here is the F in printf for formatted printing. Well, before I just hardcoded a string inside of printf's double quotes. This time, I've done the same thing but there's a little curiosity here. There's this percent S sign. So this is a so-called format string. It's just a placeholder that says I don't yet know what I wanna put here but I wanna put something, let me get back to you in just a moment. Well, in just a moment, it happens right after the comma. Notice I close the quotes after I'm putting a new line--after I'm putting this new line, but then to the right hand side is comma name. So before we use printf, a function, and we passed in one input and input henceforth we're gonna call arguments or parameters. It's just an input to a function, the thing inside parentheses. But sometimes you can pass multiple things inside those parentheses, and so you separate them by commas. What do I wanna pass in name? And so now if you follow the intuition here, percent S is the placeholder, name is what I want to place there. So the end result, because someone wrote this function years ago is that printf takes this thing, takes this thing, plops David inside the middle of that formatted string and then renders the whole result. So let me go ahead and quit from this program. And let me go ahead and run--how do I compile this? GCC, hi2.c, enter. It seems to work. A.out enter and oh, hi David. Alright, so now let's make things a little more interesting. Let's go into hi3.c. So again I have some comments up top. As a matter of convention and good style which is another theme of the course that we'll focus more on on Friday onward, it's generally good to--good style to actually describe in English even succinct English, what your program is doing. Because as you'll soon find, when you're writing programs that aren't just four lines long but are 40 or 400 which very quickly becomes easy, you'll find that even you the next morning have no idea what this code does for whatever reason, and just having some English comments is a huge boon to comprehension for yourself and others. 

>> So now we can finally do something more interactive. Right now, we're finally getting to the point of scratch which can take some input from the user. It's not nearly as graphical but at least we're not hardcoding programs that are otherwise uninteresting. So here we go. The top of this program is the same. Include our library, include the standard library. Here's my pro--here's my function called main. What do I now wanna do? Well, I don't have to call printf just once. If I wanna say something, do something, then say something else, I just call printf twice. So notice here I'm printing out state your name, a colon and a space. No new line just 'cause I made an aesthetic call that this looks kinda nice if the prompt stays on the same line. Now, I'm using this thing. So unlike printf which someone else wrote and is in the standard library, as we--I mentioned a moment ago, GetString is in the--says 50 library. So this is again part of the package we provide you within the server for the first few weeks to just make this kind of intuitively easy stuff, mechanically easy as well. So let's see what's going on here. Well, printf's job in like is to print something in the screen--to the screen. But GetString as its name implies is supposed to get something from the user. But odds are it's not sufficient just to get it from the user, I, the human need to be handed whatever this function got from the user in some form. Odds are when this function called GetString gets a string from the user by expecting them to manipulate their keyboard with their fingers, I need to--initiatively I'm gonna get back a sentence or a word or a phrase or something. And the reason that we now on the second line have the equal sign is because this function GetString has what's called a return value. It not only does something, as we'll see, it also gets something and it has to hand it back to me. Otherwise, what was the point of getting a string from the user if I'm not handed the result to actually do something interesting with. So, thankfully I know I have storage space for return values. I can just whip out a variable, this time it's gonna be dynamically stored there. I'm not hardcoding in D-A-V-I-D anymore but I can still use a variable. So long as I say I'm gonna put a string here, it doesn't matter what string it is, GetString is gonna take care of the job of getting it from the user. And then I'm gonna use the same printf line after that to actually plop it into this formatted string. Let me go ahead and run this now. So, GCC hi3.c and I'm getting a little tired of a.out. So if I wanna give this thing a name I do, you know, dash oh hi 3 or whatever I wanna call it. Enter. Problem, first of many, but let's solve it together. And then remember how you solve this 'cause otherwise completely useless exercise. So what's the error here? Well, the font is big. Normally the errors don't look this complicated but they still look fairly arcane. So, on the one hand, I've run this command here, GCC dash O and this projector I'm highlighting things all day long on the screen here and you're not seeing any of it unfortunately it seems on this projector. But what I ran was GCC and then I get back this big error message. So this thing here that starts with slash temp, that's pretty useless information. It's just that GCC when compiling your program was apparently using some temporary storage space in a folder called temp, not of real consequence to me. But now the error message gets interesting. It says undefined reference to GetString then collect to LD, LD stands for loader and that will be a useful detail to keep in mind later on. Loader returned 1 exit status. So, what is it sound like is the problem intuitively here? So if you know the answer and know what the fix is don't answer this. But if intuitively, you just have a sense of what the problem is. 

>> You can't find GetString. 

>> It can't find GetString right? Someone else--thank you. Someone else wrote GetString namely CS50. I have included it using the cs50.h but that only gives me access in the source code to actually using it by name. The bits, the zeros and ones that compose the library are actually in that file called cs50.c but those bits live or--even that's a white lie. They technically live in a file, as we'll eventually see called cs50.o. But for now, I have made no mentioned of cs50.c. I've made no mentioned of cs50.o. So, the problem at hand really reduces to GSS knowing that I wanna use a function called GetString but it doesn't know where the zeros and ones are so how can it possibly integrate our zeros and ones that the staff wrote into the zeros and ones you wrote to produce one collective whole. So it turns out that there's a two-step process. When you want to use a library like CS50's, you can't just run GCC on your program. You also have to tell the compiler at the very end of your command--you know what, let me use the library with the so called switch/l so that's an L not a 1. So a dash lowercase L and then what library? The CS50 library. So this is pretty--similarly might we say this dash L STD for standard, for Standard I/O. But it turns out that because the Standard I/O Library is so common they don't force people to type this all day long because it's just so commonly used. Whereas CS50 is not nearly as popular a library in the world, and so you'll have to explicitly say dash L CS50. Why is there no space? Stupid convention, but you have to do dash L and then the name of the library. So now let's hit Enter. Better! So no error messages means success is probably what has happened. HI3 Enter. Oh-oh. Command not found. Why is this now a problem? I did call it hi3 right? I did use the dash O and I said hi3 dash O. So why is the command not found? Yeah? 

>> It didn't know where hi3 is. 

>> So it doesn't know where hi3 is. Now this is--again, testament to the fact that computers, you know, sophisticated or scary as they might seem to some, they're pretty stupid devices. Unless you tell them what to do they're not gonna know how to do it. And by default a Mac and a PC generally only know programs that happen to live in your C colon backslash programs file or in the Mac on slash applications. Whereas Hi3, I just created, it happens to live in this directory but my computer doesn't know that so you do dot slash which says current directory. Dot is my current directory, slash means Hi3 is located here. So now my program's running. State your name, excellent. We have just recreated what I could've implemented moments ago with something more dynamic. Well--or with something static. Let's do this once more. So, state your name. Let's do Cansu, enter. An S in the side so Cansu, that was spelled C-A-N-S-U. Her name is pronounced Cansu so she will appreciate your keeping that in mind when you say hello to her in person, Cansu being our head TF. So Cansu, oh hi Cansu! And we can do this all day long. So we can provide any form of input here and the program will just keep working. But we can also get a little manipulative. So, it turns out and this is a hint at some of the security issues we'll discuss. Sometimes you can mess with the computer, for better or for worse. And give it for instance nothing. Well, this is weird. This time I did nothing and so it just said oh, hi null. So that's kind of interesting. And it turns out--a little teaser for our security discussion as time passes that a lot of the times when software is compromised and you download like a cracked version of Photoshop or something like that. Or a lot of the times when a website is compromised and you're able to steal someone's usernames and passwords, very often are the result of simple little things like this. Notice in this program I have not checked whether or not the user actually provided input. I have not checked the length of the variable called nan. I have not checked that something actually came back to GetString. In fact, if I don't hit the right key on the keyboard like D-A-V-I-D and enter but instead hit a special command that says, I'm not gonna give you a string at all. Weird things, bad things can happen and so one of the lessons too that will be repeated throughout the course is to actually rigorously error check and make sure that you're always thinking about your user being a bad guy. So an adversary who's actually trying to break your programs 'cause frankly too much software these days is not written with a paranoia in mind. So with that said, any questions on some the basic thus far? 

>> Yes. 

>> Yeah. 

>> Okay. Now, I mean. I got string and it went along [inaudible] but what does that actually mean? Is it is just like a string of words or-- 

>> What does--what does what mean? A string? 

>> Like what is that actually behind it? 

>> So a good question. So just--and we will come back to this and flush out some of these lower level details. But for now, today's teaser will be this. We know already and we know last week from our demonstration of the floppy disks and such that there're various forms of memory inside of a computer. We know that there're hard disks for instance but there's also RAM. RAM being the one--the memory where things are stored temporarily when you're running a program. Well, RAM you might have a gigabyte of RAM these days or two gigabytes. Now the byte is the key word there. Even though we say gigabyte that really means billion bytes. So that means if you--whether you own a Mac, PC or whatever, you have a whole chunk of RAM memory which you can draw for instance as a rectangle, if you can't quite see. It's just a rectangle. And because there are a billion bytes accessible to us, that's--essentially means well we can just call that byte number zero. We can call this byte number one, byte number two, byte number three. Again, for those--for whom this is blocked, I'm just dividing the rectangle into smaller squares which is to say that memory is addressable. You can number every single byte just like you can number every house on a street. So now, in a program and you're asking the user for a string. A string is just a sequence of characters. In this case, it's a sequence of ASCII characters. And ASCII recalls the code that we talked about last week. Capital A is number 65. So we talked about how the computers represent characters. So when you get a string like D-A-V-I-D, what's really happening is inside your computer's RAM is going a byte where there's some zeros and ones. 

>> But if you actually do the math, those zeros and ones translate to an ASCII character which is D which is gonna be a 65, 66, 67, 68 would be the letter D. So similarly would there be the number 65 next to this then the corresponding number for V-I-D and then there's generally a special character at the end that looks like a zero that says end of string here. So when we call GetString, the function that the cs50 staff wrote. What we are doing is figuring out how to get input from the user at the keyboard into individual chunks of memory like that. And when we return the string to you we're essentially telling you where this chunk of memory is. So I can now proceed to print it, change it, manipulate it, or what now. 

[ Inaudible Remark ] 

>> Those bytes in the row are called-- 

>> A string. 

>> Exactly. A string is a contiguous sequence of characters aka bytes. Other questions? Yes? 

>> What exactly is the difference with this system that we have here of compiling and say another compiler for one like the C++? 

>> Good question. What is the difference between this program here at GCC and for instance various other compilers DEV++, Visual Studio, Eclipse is another one, NetBeans and so forth? Fundamentally, very little. So generally and those of you coming from high school computer science background probably used what's called an IDE. An Integrated Development Environment which actually is a gooey with menus and icons and such. And you can write your source code in it but to compile something you don't run a command like GCC and then the name of the file, you instead click a button. We'll actually get back to that point. But as part of a more rigorous introduction to understanding how the machines work and writing programs at this lower level. We start at this lower level with GCC. So really it's just a matter of features. GCC is probably the most popular compiler in the world these days 'cause it's been around so long and a lot of tools are based on it. But it's more limited in its feature set but again will build backup to those features. Other questions? Yeah? 

>> Before we had the Makefile? 

>> Uh hmm. 

>> What's the difference between a compiler and a Makefile? 

>> Good question, so we didn't have a Makefile yet, more on that in the future. But I do use the command make. Essentially, this command make is just another program that uses GCC to compile my program for me but make is configurable. So where as I currently am manually typing like dash L cs50 and dash O hello. All of this--pain in the neck right? If you're writing a program and you're testing it and recompiling. This very quickly gets tedious. Typing the same commands again and again and again make can be configured, as you'll soon see in problem set 2 or 3 to do all these for you. So that we take very quickly the tedium out of--what is otherwise--could be a very repetitive process. One more question? Alright, so just to--yup? 

>> So the dot slash the A out thing-- 

>> Uh hmm. 

>> They only use that when the program that you're running--the program that you're referring to is going to your computer? 

>> That's correct. When the program is on your computer you say dot slash and this means on my computer. 

>> And that's the [inaudible] this other stuff that you would use, the GCC oh hi-- 

>> Exactly. Now GCC was installed by a special installer. It's elsewhere on my hardware. It's not in my current folder but because I installed it with like a normal installer, double click and all of that. It configured the Mac or in this case, the Linux server to put it into my so-called path which just means I know where it is automatically. But we'll pull back these layers too before long. So a couple of commands and then an interesting code and then the teaser, that's a teaser. So I just type the command LS. So at first this might seem very limited in terms of functionality for you but when I first logged in to that cloud, recall that my prompt looked like this. LS is the list command, those of you who played with DOS before might recall DIR. When you type LS it just lists what's in your current folder, my current folder or my so-called home directory. The folder that I own on the cloud or that I own on my own Mac or my own PC apparently has two folders in it at the moment. One is called SRC for Source and one is called SRC.back which was my backup of today's source code in case I screw up. If I want to move into a directory and you'll see--all of these will be walked through in the first problem set. So realize if it doesn't quite sink in today, not a problems in terms of these low level details. CD is Change Directory. So, I'm gonna go ahead and type CD source, enter. And now notice my prompt changed a little bit. In parenthesis now is a tilde which is shorthand notation for My Home Directory. And then Source which is the current directory I'm in. So now if I type LS again and hit Enter, I see a whole bunch of stuff. And what's in this output are all the C files that we happened to have printouts of for this particular week. This is just the folder containing all of that stuff that we created a PDF out of ultimately. Now, the things in green are special things that I ran. So what's nice if you configure your command line environment appropriately is that things that are so-called executable, programs that you wrote like a.out happened to show up as green. Hi3 is green. And then all of these other white files are just source code files, dot C file. And I thought I would tease you with this one here. This is a file called Holloway.c. This is--to be clear, not a program. We'd expect you to write now or perhaps ever since this program was written as part of an obfuscated C contest. So there're a lot of geeks in this world that like to compete against each other by writing the most complicated looking compact programs possible. Even though it would take a computer to even understand how they work. So here is a program. It's not necessary very well formatted but it looks pretty complex, right? I will be happy to admit that I read through this I probably cannot tell you what it did unless I really obsessed over these details. And there's some syntax we haven't seen before. This define keyword is something we'll see later on. It turns out long is another keyword we'll see. These curly--these square brackets, this is a pretty complicated looking program. So for those more comfortable what does it do? Could you tell? So the winner of this year's contest, this is like 2003 or so. I included the length, let me go ahead and compile this program called Holloway.c. No errors which means that's good. I'm gonna run a.out and your teaser for the kinds of programs you can write after years and years and years of practice will give you output like this. Let's take a break. 

[ Laughter ] 

>> Let's take five-minute break. Alright, so we are back. Just to plant a couple of seeds so that you've seen it before and then we can revisit in more useful context. Printf, again it's a function, it's a tool someone else wrote. You can invoke it with zero or more arguments or parameters. The result--or one or more arguments or parameters that result of which is--that will influence its behavior. So these format strings we saw earlier. We saw percent S which is a placeholder for a string, turns out as you'll see over time there are other placeholders. If you know you're not gonna output a full string but a single character, percent C will get that job done. Percent D is for a digit, like a number or--one or more digits. If you want to output an integer or other types as we'll see. F is for floating point value which is the fancy way of saying real number. Something with a decimal point and numbers thereafter. And then LLD, we'll see in a moment, this is for particularly long numbers which will become relevant especially as you're trying to process lots of information. This backlash N, it's also a recurring theme and not just in C but in PHP, JavaScript, other languages as well. If you want to escape certain characters, you need to use these so-called escape sequences. So this is a way of experiencing various succinctly. Usually with just two, maybe three characters, a character that you can't really see as well on the screen, otherwise, so a new line character. You can certainly hit Enter but as we saw--seen that very quickly makes a mess of your code and such and so backslash N is new line. There's also this backslash R. Anyone know what backslash R is? Yeah, so this is a carriage return. So if you've ever seen or used an old school typewriter, you might recall that when you're typing something out on an old mechanical typewriter, when you like hit the char--when you hit the enter key to move the head back to the left hand side to the next line or you would pull down some lever, it was really a two part process. Pulling this lever or pushing the button would actually rotate the paper enough so that you'd be on a new line and it would also move the little imprinting head that prints the letters of the alphabet and such all the way to the left. So you can think of a new line as being rolling the paper up so you're on a new line but a carriage return moves the cursor or moves that writing head all the way back to the left. Now, in the world of Linux and Unix more generally, both of which are our operating systems that had been around for many, many years, Mac OS is based on one of--one version thereof. I mean, you'll play with it in great--with great delight this semester, you will see that backslash N is the standard in any text file for creating what we know as new line characters. In other words, if you pull up on a Linux system, the equivalent nano or this thing called Vim or the equivalent in general of Text Edit or Notepad and you save that text file, what is--and anytime you hit the enter key, what's really being stored in memory, what's really being stored in one of these bytes on disk or in RAM is backslash N. Unfortunately, in the Windows world, they decided years ago that they would store not only backslash N but much like a typewriter they would store backslash N, backslash--backslash, sorry, backslash R, backslash N. They store 2 bytes at the end of every line. Every time you hit the enter key in Notepad or in Microsoft Word, small white lie, those two characters end up getting saved in the file. Now, for who knows what reason, Apple decided they would use not backslash N, not backslash or backslash N, they would just use backslash R. This is a complete pain in the neck and at some point in your life, even if it's after the course working in some lab or in some project where you're processing files or just opening files in a program, you'll run into this stupid issue that really is just a result of humans not agreeing on some standard or just doing things differently. 

>> You can see this frankly in the consumer world. If you've ever noticed, Mac OS has its Apple menu on the top left and Windows has its start menu in the bottom left, really for no compelling reason. In the other context, you know in a Window and a Windows machine, you close it with the X on the top right hand corner, where do you close it in the Mac? Top left hand corner, it's completely stupid, right? It's just different for the sake of being different. Whoever got there first, who cares, same issue with these things here. Now I mention this only because over time, this will become important when you're not reading in files necessarily but writing files. When we get to the spell checking, the dictionary assignment, when you're actually manipulating text files, maybe writing some output, these lower level details that actually empower you to solve problems properly. But there're others, backslash T. Folks in the consulting world and finance world like to share files in Excel format or in Text format that looks like Excel. A CSV file, if you've ever opened a dot CSV file, comma-separated values, that just means it's rows and columns where each of the columns is represented with a comma but you can open them in things like Excel. A TSV file, tab-separated values uses the same thing but a tab character, if you wanna output an actual tab character, the result of hitting the tab key, you do use backslash T. That's so those kinds of files are made. And then sometimes we'll see you need to escape even more useful characters. Sometimes you need to escape a single quote as we'll see. Sometimes you need to escape a double quote. And just intuitively, when might you need to put a backslash in front of a double quote given the examples we've seen thus far? 

[ Inaudible Remark ] 

>> What's that? Someone speak up more boldly. 

[ Inaudible Remark ] 

>> If it's in the middle of the string. So thus far, the things I put between quotes are just simple things like David or David backslash N, but what if I want to do call my self David in quotes, right? I would need to surround my self with quotes just to pass my self into printf. But if I want those quotes to also appear in the output, I now need to also include not another pair of double quotes but escaped double quotes. The reason being, again, computers are not very bright. If I do this and this but then I also put some other quotes inside, what's the computer potentially gonna think? That it's actually two strings, right? One starts here, one ends here, then there's another and then another. But this is not legit. You can't just take a quoted string back to back with another quoted string so you'd get some kind of compiler error. GCC would yell at you for some reason. But if I instead put backslash there and backslash there, so now I have double quote, backslash double quote, backslash double quote, double quote, this will actually print properly. So, when in doubt, if you're having some weird character issue, odds are you need to escape it in some way. It gets really kind of trippy if you wanna output a backslash, you can't just use the backslash, you need to use backslash backslash because otherwise a single backslash is confused with the so called escape character. And we'll also see backslash 0 which is actually the special character that's used at the end of a string to say no more string after this point in memory. Okay, not to dwell too much on math because you can very quickly bore someone in computer science by dwelling too much on math but it's useful even for logical constructs as we'll see with loops. You do have mathematical operators in C and most every language. Most of these are probably self explanatory, addition, subtraction, multiplication, division, and anyone? 

[ Inaudible Remark ] 

>> Mod or remainder. So, there's subtle difference there. But we'll use this over time but the percent sign essentially gives you the remainder. So if you do for instance 11 divided by 10 in grade school, that's 1 with the remainder of 1. So if you actually do in a program 11 percent 10, what you'll get back is 1 because that is in fact the remainder of that arithmetic operation. So, there is more useful purposes than that than just taking remainders. We'll actually see it's a wonderful way of effectively looping yourself back around, for instance if you're at the end of the alphabet or for other tricks altogether. So what about those variables? Well, it turns out C, like a lot of languages, comes out of the box with a whole bunch of built-in variable types. So in C, this is not going to be the case as we'll see with PHP and in JavaScript, at least not as rigorously. In C, you really have to be specific as to what data type, what type of data you're gonna put in a variable partly because C gives us so low level access to your computer's hardware and memory that you have to tell your program what kind of variable you're gonna use so that the operating system knows how much memory to actually give you. And with this low level power as we'll see, as I hinted before, comes a lot of fun, interesting, scary security implications. 'Cause when you can actually manipulate a computer's memory at this low level, you can steal people's passwords, you can steal their data if you know how that memory is laid out. So we'll--more on that as time passes. So the types that come built into C are several but the most common ones or the most useful ones for our purposes are char. If you just wanna store a single character that maybe the user typed in, you just call the variable of type char. Float is a floating point number which is like a real number, something with the digits after the decimal point, and it's fairly small, it's what we're gonna call 32 bits. A double is also a float but it has twice as much storage capacity. So here is one of the interesting takeaways, a char, we've already spoiled this answer, takes up how many bits. Here is the char, here is the char, how many bits did we say each of these squares is? 

>> 8. 

>> So 8 bits, aka 1 byte. So a char size is 1 byte or 8 bits. This is convention, so on almost--and most any computer you overuse, if you're writing code that uses a char, you're gonna be handed 8 bits or 1 byte to store that particular char. This is useful especially when we get to details like forensics and looking at data on a hard drive, 'cause if you don't know how much store--how many bits are composing your file, you're never gonna recover that data or be able to access what you're looking for. Now a float is not 1 byte, it's 4 bytes, or 4 times 8, 32 bits. So, a 32 bit of float gives you a bunch of precision. So a floating point value again is a number with a decimal point, so it depends. It's a tradeoff. You can either have a big number and a small decimal point or small number and a big decimal point. But because you only have a finite number of bits, the takeaway for today is that there's only so much precision. With the computer today, you can, for the most part, not represent every possible number that mankind can think of. Because you can come up with an infinite number of values but if you have a finite amount of space and certainly a computer has a finite amount of disk space or RAM, you have to make approximations. And that turns out, approximations might sometimes be fine, certainly for the small programs we've seen thus far. But when you start doing scientific research or financial work, imprecision and rounding errors start to add up. Those of you may have seen Superman 3 or Office Space, this little scam where they make money in the financial markets by scheming fractions of pennies off. That kind of problem tends to arise because they're using a language or a computer that only has finite precision and so there are rounding errors. And so the guys in Office Space took that money and they--their for loop--way too fast is--was the takeaway in that movie, when they freaked out because they had million dollars or something like that overnight. Okay, too long of a digression. So, primitive type besides those three types, we have ints which are just integers which are similarly 32 bits. And just to plant this seed with 32 bits, what's the biggest number you can represent? So it's 2 to the 32, 'cause remember a bit is a 0 or 1. So if I have 32 bits, each of which can be a 0 or 1, that's two possibilities for every place, so 2 to the 32, that's 4 billion. So with an integer, an int data type, you can store any number between 0 and 4 billion roughly. Or if you want negative numbers, between negative 2 billion and positive 2 billion, but it's a finite range. And as we'll see, this can in fact be problematic. In fact, when Facebook first debuted, random aside, they used I believe an int to represent your profile IDs. But if you've looked at more recent [inaudible] or if you've looked at friends who relatively recently signed up for Facebook, their profile IDs which you sometimes see in the URL are actually pretty long and that's because I believe at some point they did transition to 64-bit values which tend to be called long longs. And this is so that they could have more possible user IDs not because they have billions and billions of users but surely people create accounts to lead accounts and they don't necessarily have to reuse numbers this way. So, that might be a complete lie but I think the numbers are now 64 bits, so we'll see, I'll take a look. Alright, so it turns out there're two other useful types that you don't get for free out of the box. One is a bool. So we talked about Mr. Bool briefly last week in this idea of true or false, but in C, you don't have a Boolean data type. There is no such thing as true or false. You have to fake it by using 0 or 1. This is just a little inelegant and so one of the things we'll introduce early on is this idea of abstraction or design whereby if you wanna represent the ideas of 0 and 1, true or false, well, let's give them a synonym like true or false. Let's not just arbitrarily say the number 0 is false, the number 1 is true. You can actually declare in C synonyms using special syntax that says, you know what, even though yes at the end of the day I'm implementing false as a 0 and true as a 1, I can abstract away from that detail and use words that are more intuitive to me like true and false. So earlier today when I showed these little snippets of infinite loops with while true, true is we've inserted it ourselves because we're assuming you're using the CS50 library. 

>> In other languages, C++, Java have the bool data type built in. Strings, this also is a little white lie. We've been using strings thus far to get input from user and store it in variables. String is actually not a data type in C. It actually is something called a char star and we'll come back to this before long. But a char we've seen, a character being a single character. A star is something called a pointer so it turns out a string is not quite what I'm describing it to be here. It turns out when we call string a string, we're really referring not to those characters but to the address, the location and memory of those characters. But, uninteresting for now but a teaser of details to come. This chart, very boring and uninteresting but useful over time and that is to say there are very well defined rules as to when you're writing code, what operators, like what syntax should get evaluated first. You might recall from grade school sometimes you put things in parentheses so that your addition happens first, then your multiplication, otherwise multiplication would happen by default first. Realize in programming languages like C, there is a set of very well-defined rules, and this is in the recommended books. There're various resources online. I just want to make mention of this in case there's ever doubt, generally parentheses do solve your problem as an arithmetic but do realize this is some lower level details we'll come back to over time. So we looked at a number of fairly small programs that at the end of the day did very little more than print hello world and the like. There are so many other constructs like loops and conditions and such, so what I thought we do in conclusion today is look at this program. So, we'll talk about this other axis of style on the course, writing code that looks pretty and as well aesthetically laid out. So this is kind of a misinterpretation of that idea. Writing code that just looks--I'm not even sure what this is supposed to look like, a little flower or pinwheel or something like that. It is in fact syntactically valid. The semicolons are where they could be or should be. I'm not quite sure what this is but it is--notice the familiar constructs, there's some ifs, some whiles, some fors, these are details we'll certainly start playing with in great detail. Let me go ahead and compile this. This two is from that obfuscated C contest so this is not where we're going but this is where some people choose to go. Let me go ahead and compile this. Lots of errors but we've seen this error before. Undefined reference, what was the solution last time? 

>> Library. 

>> So we need a library. It turns out there's other libraries we'll see over time. One is the math library. You might wanna say dash L math but it turns out it's so common that people just say dash LM. And then for this stuff up here, it turns out and I know this is just from experience, this is called the Ncurses library. This is a--somewhat graphical library that allows me to display graphics on the screen. So if I link in both of those libraries, now it compiles okay. If I now run a.out, your teaser for this Friday's lecture is this climax. 

[ Inaudible Remark ] 

>> I know. See you on Friday. 

[ Inaudible Discussion ] 

[ Music ] 

==== Transcribed by Automatic Sync Technologies ====