 Alrighty, welcome back to 105, our last lecture, minus the review session we will do right before the final. Probably Friday, April 26th. So before we do that, let us recap our journey today and gather your questions throughout the break. Go ahead, look at past final exams, try them out. Let me know on Discord or email me any specific questions you want me to take me up or you want me to take up during the final review session. So with that, let's recap our journey of what we learned. So we started by saying, well, we want to write source code. We want to write source code in the C programming language for this course. We used our C compiler, which is just another program to generate machine code, which was our executables that we ran and we compiled many a program throughout the semester. So started off by not knowing anything and the first thing we did is we did assignment. So hopefully everyone remembers assignment. So if we want to declare a variable, this is the syntax we used. We used the type, which we discovered many types on our journey, we give it a name, and then we can actually say it equals some initial value and we give an initial value. That means we initialize a variable to some value. So some types we used in this course and these are the ones you need to know for the exam. It, so those are whole numbers, they can go negative, they are integers, no decimal places whatsoever, doubles for anything with a decimal place in it, then char, so that was for an individual character, AKA something you can type on your keyboard and then it had that fun thing where like, oh, well, how do you represent the enter key or something like that? And then we talked about escape characters and all that fun stuff. And enter is backslash n, what are some other ones? That's about the only one you really need to know for this course, but like a tab character backslash t, if you want to use an actual backslash, literal backslash character, it's backslash backslash. I think that's pretty much all the ones we need for this course. Then we saw bool, so bool, we have to include a header file for that and bool is just something that is either true or false and then void, which is basically nothing. So if it was in a function argument, that means that it didn't actually return anything or if it was in the inputs, it means that there were no inputs to said function. Then we got scared by pointers. So pointers, just that type and then a star and that means we're pointing to a value, AKA just where it's stored in memory will just be some old memory address because computers are stupid and it's basically, memory is just like a big array of bytes and you have to tell it what each byte actually means, otherwise it'll just use it for random values as some of you saw in your labs when you had some memory errors and some things went off the rails. Then finally, we had arrays, so that was like a type name and then the square brackets and we'll revisit them in a little bit. So then we had input output because our programs were useless and they couldn't do anything, so these are functions you definitely need to know for the final, at least print F, so that outputs the string on your terminal and if we want to print out values of variables, while we discovered we could use format specifiers. So format specifiers you should definitely know. So percent LF, that is the format specifier for a double, percent D is the format specifier for an int, C for char, that one straightforward and P for pointers, don't really need that for an exam, should be no reason you look at memory addresses but you can, if you find that fun for whatever reason. And then we had scan F so that will read input from the terminal. We can use format specifiers to change the values at addresses because remember we had to give scan F the address of any variable we wanted it to change. Then we talked about different operators in C so these are definitely ones you should know, plus plus and it's post fix and prefix variants. I wouldn't really care about the difference, just make sure they're on different lines and always prefer the prefix one unless you really mean it. Then we saw like type casting, we didn't really ever need to use that one, the ampersand. So if we have a variable and we use an ampersand on it, that was the address of that variable so that was where in memory it is. Then we saw size of, so we can use size of a type or size of a name to get how many bytes large it is. Then we had ampersand, divide, mod. So all of those operations, mod was basically just the remainder, had really weird rules with negative values. Don't worry about remembering all those weird rules, just the exam probably won't have negative values with mods, just raise alarm bells if you ever have to use mod with negative values in your real life. So just know that behaves kind of weird. Then we have addition, subtraction, and then assignment statements. So we could go ahead and just a single equal sign is to change the value of a variable. And then we saw shortcuts like plus equals that will just reassign that variable with its current value plus another value. We had minus equals, times equals, divide equals, mod equals, can choose to use them if you want, doesn't really matter. Then we went through all a whole lack of math functions. Did we ever? Do you need to know really any of these for the exam? Probably not. So most of them you could probably make up if you needed to. So if it said, I don't know, take the sign of something, you can just guess at it. So it's functions called sign. I would not worry about that too much. I wouldn't worry about any of these. And except for RAND, you should probably know what RAND is. That came up in your midterm. Other than that, I wouldn't worry about it. I will double check on the review session if that is true after I know what your exam looks like. But basically shouldn't have to know any of these aside from RAND. And if you did, you could probably guess its name or guess something similar. So I wouldn't worry about it too, too much. And again, I will let you know in the review session whether or not that is correct. Then that was all of the basics. Then we got into if statements because at this point we just ran our code starting at main, statement by statement until our program exited. It didn't really do anything exciting. So then we introduced if statements. So if statements, let us skip forward. We can write if else. We can chain together like if else, else, or sorry. If, else, if, else, if, else, if, else. We can chain them all together like that. That lets us skip over statements. And then we go and execute inside of the if statement if that expression evaluates to true. Otherwise, if it evaluates to false, then we skip it. So we saw a whole bunch of, a whole whack of other operators that produce Booleans. So we saw a comparison operators that work between numbers. So there's equal, equal. And that meant, hey, are these two numbers of equal value, not to be confused with a single equal sign that is assignment. Then we saw not equals greater than, less than or equal to, less than, less than or equal to. And those all compared two numbers and then gave us back a Boolean, true or false. And then there was logic operators that only operate on Booleans. So there's a knot that flips it from a true to a false or false to a true. The double ampersand, which is and. So both of the conditions have to be true for the whole expression to be true. And then or, which just means a single one has to be true for the whole thing to be true. It's only false if both arguments are false. So that was fun. Then we kind of went to our bread and butter in programming our friend, the loop. And our first loop was the while loop. So while loop had an expression, bunch of statements, and that would allow us to repeat code so it lets us kind of go backwards in execution. So whenever we had the while loop, well, if we evaluate that expression to true, it'll run the statements and then try and reevaluate that expression again. If it's still true, it'll run these statements again and do that until that expression eventually is false. And if it's initially false, we'll just skip over the whole while loop entirely. If we wanted the statements in the loop to always execute at least once, we saw it do while loop and that always executes the statements once, then checks the expression, then it's basically like a while loop again. So those were our two options. And then we went into four loops and that's usually for bounded repetition. So it basically a while loop, but we can stuff some initialization and increment expressions into it and it will go ahead and do it automatically for us. Just makes it a bit better to read if we have some bounded repetition. So how it works is this initialization statement happens before any checks or anything are done in the loop. Then every time through like the while loop, it'll check the conditional expression. If it's true, then it will execute the statements and then after it's done executing the statements, it will run this increment expression and then check the conditional again and keep on going through it over and over again, just like the while loop, except it will always do this increment expression at the end. And most of the time, our conditional expression was fairly simple because made it easier to reason about, but watch out on the exam, some of the other sections like putting ands and stuff in there to make it a bit, in my opinion, weirder to read, but works the same way. So after that, we learned about how to write our own functions and how to write function prototypes. So if we wanted to write our own function called add to and we want to put it after main, which uses that function, we have to make sure to add a function prototype, that's what this is called, ahead of it because the C compiler is silly, well, not silly, it is dumb, it just reads line by line starting at the top from the bottom, unlike our code that always starts executing in main and then goes line by line. Yeah. Yeah. So the question is, are we expected to know how to do a multivariable for loop? Yeah, so that initialization statement, so like if we wanted to, we could create two variables online and do like int i comma j or something like that and I'd create an i and a j, you could do that in a for loop if you wanted to. We didn't really use it because it got weird once we started doing pointers. So remember pointers, if we did like int star x comma y, then x was a pointer to an int and y was just an int and it had weird rules like that, that's why I avoided using it, but yeah, it could show up, you can do commas as part of, you can do commas as part of the initialization statement to create more variables in one line. Generally, yeah, generally it's easier just to read if there are different lines but comes down to a style thing. Yep. All right, oh yeah. So yeah, here's our function, function prototype comes before anything, then we can, or we could optionally go ahead and just add our function definition just here, we could add that before main and that would be perfectly valid too if we wanted to just get rid of the prototype, just the prototype has to at least come before we use it for the first time since the C compiler reads things from top to bottom. All right, after that we took a detour on scope, that was fun, so variable declaration basically only exists between a pair of curly brackets, so C declares function arguments and like for loop initializers are technically kind of in the next curly bracket, so if you define a variable in like our for loop in our initialization statement, you can only use it within the curly brackets of the for loop, outside of it you can't use it. So that's what that means, same thing for function arguments, you can only use them within the function, after the function, all of the function arguments are now gone. We went over C being copied by value, so functions just get a copy of the value for arguments and that's it, so you can't, if you pass an int into a function, you get a separate copy of that int if you try to modify it, well then you're only modifying your copy of that variable and it won't change anything, so that's why if we want to modify the value of something you pass in, someone passes it in via a pointer so that we get a copy of the address and then we can de-reference it and then actually modify that value if we want it to. And then we had this weird problem of shadowing, I'm not sure if the other sections went over it but that's whenever we had a new scope and then we use the same name of a variable that already existed, generally confusing, the rule of C is it won't give you an error or anything, it will just use the most recent definition of that name, kind of weird, probably will cause weird bugs. Generally I just would advise just completely never ever doing that unless you like debugging for a few days. So then the course got interesting, right? Pointers, yes, everyone really enjoyed pointers, it was everyone's favorite subject. All right, well pointers is the whole reason this course exists because guess what, that is how a computer works and it will help you in later courses, believe it or not, we did not do this just to torture you even though, okay, I was gonna say that sounds like fun but that sounds kind of sadistic too. So pointers were great though. So a pointer is just like the starting address of a value in memory, we saw the ampersand operator that took the address of a variable and we were able to know its address actually in physical memory. If a value takes up multiple bytes it's always the lowest address because it always starts at the starting address there and then however many bytes that value consumes depends on its type. We went over the size of different things like an int was four bytes, a double was eight bytes, a char was one byte, a boolean was one byte because one byte is like the smallest unit of memory you can access at a single time. So we saw that, we introduced pointers and then basically the rules are each time you take the address of a variable you can add an ampersand to its type. So if I have int x and then I do address of x well then the type of that is int star or a pointer to an integer. So that's one way you can remember it every time we take the address of it if you're keeping track of the type of the variables you just add an ampersand to its type or star or whatever you wanna call it. You can then use the star operator to dereference or basically access the value at an address. So same kind of rule applies here that the value of the type that you use the star operator or I think asterisk operator on basically just remove one star from the type. So if I have an int star and then I go ahead and I dereference it well then it's an int. All right, so then after we discovered what pointers were we were like oh well we can use an array so that is just a large contiguous block of memory and we can have multiple values of the same type all together in memory. So the syntax to create an array was just type so that is the type of every single element in that array we gave it a name and then optionally in the square brackets we could give it an array size and then optionally we could also initialize it between curly brackets and that was comma separated values. We could emit the array size if we had a bunch of values C we'll go ahead and figure out the length of it for us and we could go ahead and omit the comma separated values if we wanted to as well. Also we could just like give an array size that is somewhat huge like say we did a array size of eight and then we only gave it two values like a one and a two C we'll go ahead and just initialize the rest of that array as all zeros. So it would be like one two zero zero zero zero six zeros however many that is. I don't wanna try and say it and say something that's a mistake. So are we all good up to this point? So pointers, arrays, loops, if statements, functions heaps and heaps of fun. All right so then we add pointer arithmetic. All right that got people. So if we assume like we have an array called grades so grades would be a pointer because of that weird pointer array decay rule where basically arrays are just pointers. So if we do like grades plus one that is a pointer to the second element. Always remember arrays are index zero so index zero is the first one. So if I do plus one that's index one that's technically in our human speak the second element and that will go ahead and move the address forward depending on the type of the depending on the type. So we could go ahead and dereference that. So if we do grades plus one and then dereference that that's how we access the second value. Then we realize that that is really really ugly and pointer arithmetic kind of sucks. So if we want to access an array element generally we just do grades and then if it was called grades and then square brackets so that will do the same thing for us and at least briefly lets us forget that it's a pointer when we read it. So gives us some visual difference that lets us forget about pointers a little bit but you should still know that they're basically pointers and yeah what tripped up people on the exam so that is like arithmetic of like pointer plus number like pointer plus integer equals pointer but you could move the pointers around so if I did the arithmetic with two pointer values then the result is going to be an integer. So if we can think about it so like if I just took grades plus one and assign it to a variable the type of that variable would be like an int pointer so grades plus one, let's say I call it, I don't know, x. And then I could later do x minus grades and then x minus grades would be equal to one. So one plus grades is a pointer to the second element. Yeah, yeah one plus grades is a pointer to the second element so it's just like pointer arithmetic is you get a pointer result from a pointer plus a number so just like normal arithmetic I could just do a pointer minus a pointer and that gives me that integer back so that would just say how many which is basically like how many elements are there between these two pointers is another way to think of it. So yeah, that was on the midterm. Do you not blame me for that? I did not write that question. And that was also weird because it was like one of the first things there so it was kind of borderline kind of mean. So hopefully the final is a bit better than that. So oh yeah, then we got to everyone's favorite. We did malloc, all right. We had more special memory stuff. So in C definitely a function you should know malloc. So if you malloc you just request size bytes you get back a pointer to that many contiguous bytes unless it fails in which case it returns null and then your world's probably on fire because your machine ran out of memory so all your programs are probably gonna fail anyways so I wouldn't worry about errors too much at this point of your career because yeah malloc fails and really bad things are gonna happen. And then yeah, another question. Right now do you need to know Valgrind for the exam? And no because on the exam you do not have a computer unfortunately. So don't need to know how it works but you may have to be a human Valgrind to figure out like any potential memory errors or anything going on. So they could ask, they could give you a question and be like hey does this code have any issues? Oh you should probably fix it. So Valgrind just kind of helped you just kind of helped you figure out while you were developing. Unfortunately our exam not on a computer but yeah so with this we got back a pointer to that many contiguous bytes. We could go ahead, we could use it to allocate space for an integer, we could use it as an integer, we could do size of int times whatever number and basically that's the same as an array. So we could just have an array and generally we use malloc because well we wanted memory to survive like a function. We wanted to create a new like some new space for a new variable and we wanted to return it to whoever called that function and while we couldn't do it in a local variable because it only exists for that function then it's gone. So if we wanted to allocate new memory and give it to whoever called us we had to use something like malloc but yeah malloc posed its own problems because yeah then we had to free it. Everyone's favorite thing to do. So tricky to get correct and generally malloc and free is why people use other programming languages so they don't have to deal with this but managing it yourself as long as you do it correctly which is a big asterisk means your program will be really really fast but it's like that live free or die no not live free or die I don't know isn't that like the license plate for New Hampshire or something like that? I don't know. Do you haven't heard of that quote? All right ish live free or die hard is like the movie and then I think just live free or die go check it out it's on some license plate somewhere. Pretty sure it's in Breaking Bad at least. No it's like New Hampshire or something. Yeah pretty sure look up New Hampshire license plate motto I swear it's not just me making it up but basically think of that when you think of dynamic memory it goes really really fast but if you misuse it you'll crash and burn as you might have noticed on some of the labs once you we use strings and we had like really weird memory errors and things like that we're just spit out pages of nonsense yeah that's because you messed up memory. So how to use it correctly we need to remember to free it once we're done using it and then we have to remember after we free it we never touch the memory again so we don't have any use after freeze we're also not allowed to call free twice on the same pointer and the things we should be freeing are the pointers we get back from malloc right and of course we shouldn't access invalid memory past like the size we got back from malloc so only use dynamic memory like I said before if your function needs to return a pointer to valid memory that did not exist before you called the function or you don't know the amount of memory you need at compile time so you could just like ask the user hey how many integers do you want to have you want to use or whatever and then you can allocate it using malloc yeah yeah if you free twice C says it can just crash your program immediately and generally that's what happens so generally your program just stops immediately and that's if you're lucky so don't do that if you did do that on a lab it probably crashed yeah if you're unlucky it works for a while and then it suddenly doesn't and it doesn't happen a long time after the error happened and you pull out your hair for three days figuring it out not like that's ever happened to me before or and probably not you so if that hasn't happened to you yet you are lucky and you will probably one time forget and chatGPT is really bad at it too so you might have to correct that error all right so also then we went to 2D arrays ooh 2D arrays was fun so syntax for that well we just slapped on another set of square brackets and now it was a 2D array so we can have just and you can think of it as like an array of arrays or a matrix or however you want to think of it we could go longer so we could have 3D arrays we could have 4D arrays could have as many D arrays as we want but in this course we just kept it at 2 just to keep us sane so we just left off at 2D arrays so when we initialized a 2D array it was like a set of curly brackets for the array of arrays and then we could have another set of curly brackets for each individual array so here I was saying that and it's always row major so rows come first if you think of a table so I want I don't know how many rows and three columns and then we could define it like this and leave out some so we should have three values in a row so here we only give two and the rule with C is if you leave it out it will go ahead and fill the rest with zero just like with 1D arrays so here we should have three columns so we only have two so it would fill it in as 1, 2, 0 and then this as 5, 4, 0 and then because we omitted the first argument here it would figure out that oh there are two rows so it would be a 2 by 3 we get so okay with this all right 2D arrays it also had some other weird rules where if we used it in function arguments because if it was a real 2D array we had to use it like this so in a function prototype we had to at least have an argument for the number of rows and we have to tell it or sorry columns and we have to tell it how many columns are in our array and that number always has to come before it so before this num columns I use in this 2D array I have to have int num columns before that and then I could have num rows wherever the only dependency is before I have table with numcalls I have to define numcalls so I cannot write something like this because the table comes before or before the numcalls and if I wanted to I could write it like this as well and put in the number of rows but that is completely optional we don't really need it so if you have to write a function that use 2D arrays just remember that you always have to give it this argument here you always have to give it the number of columns and you should or yeah sorry you should give it the number of columns and you always have to define the number of columns before it so if a question comes up on the exam about 2D arrays and says write a function using it make sure you remember that alright not that I drop any hints or anything during this lecture alright I just need to shut up, okay I didn't say that you didn't hear that alright so if I wanted to if I had like a true multidimensional array so if I if C actually knows like the number of columns they are basically it just performed some arithmetic to figure out how to access an individual element and your 2D array is in memory just like a giant 1D array but it just figures out what you want to access what you want to access instead but we could go ahead if we wanted to allocate a 2D array dynamically well what we did is it was basically an array of pointers or an array of arrays so what we did before is table was an array of arrays so each individual element was an int pointer that represented our array and then in this array we could access the actual column in that row so if we did that dynamically then basically we could think of it as an array of int pointers but we know that we have array decay so this is actually a pointer and that was our first use of a double pointer so basically if you see a double pointer you can just think of it as oh okay well hopefully it's either a pointer to a pointer and then to whatever or it is an array of pointers and then that could be whatever we want we saw it later once we had strings and yeah strings was the next topic that was fun so it was basic strings were basically an array of characters but it had a slight caveat where to know where the string ends C adds a zero byte at the end or a null byte so it always has to have the character backslash zero or the value zero if you just read it in memory at the end so that was the little trick with C strings so the format specifier that you should always use for printf is just percent S you need to make sure there's enough memory to hold the string buffer overflows serious security issue has cost billions of dollars in problems so for user input you should you can technically use scanf with it but in practice it never works because you don't know how much the user is going to type ahead of time so you should use functions like F get S or get line which actually restrained the number of bytes you input so that it makes sure that it always ends with the null byte and it's always a valid C string so if I will make it my duty that if they say they use like a scanf with a percent S I will make them say that assume it always works don't worry about any potential issues with that because if you see scanf and then percent S you should run far away and if you ever write that I will I will not say anything other than I will be slightly disappointed so do not write scanf with just the string format specifier alright then we got into a whole whack of string functions which some of which are good for you to know for the exam so for the exam there are like versions of this that constrain the maximum length just in case you know someone didn't alternate the string or it was too large or something like that so initially I might correct myself later but initially I would just assume that the strings are proper you have enough memory for everything so I would pretty much forget everything with an N so just if you need to remember some which you probably should string length probably good tells you how many care or how many characters not including the null byte are in the string string copy probably also a good one to know that I'll copy a string concatenating strings may or may not be useful string comparison probably good to know so that will return zero if the strings are equal a negative number if the first one's less than the other one a positive number if the first one's greater than the second one and then we saw a string string like searching for a string in another string and searching for a character in a string we kind of know how to implement that it's unlikely that you could just use those on the exam so I wouldn't worry about these too much but I might look at when we implemented them as kind of practice and then the last two like converting a string to an int converting a string to a double mmm might be good to know I would question how useful that would be for the exam so I wouldn't worry about too much but in your real programs probably won't worry about it alright then ooh recursive recursive uh wow I can't even say it recursion yeah that was fun so we did like the hardest recursive problem that you know parents give to their babies so that was a fun lecture so if you can solve the baby tower of doom you should be good so recursion just remember recursive functions are functions that call itself we need two things we did this for like this was the first slide in like three lectures in a row so we need a base case so a simple solution we know and then a recursive step to reduce the problem to a smaller version of itself if I was a betting person and I'm probably probably not a good person to bet against what will be on your exam there will be questions that say right a recursive solution to something so you should know how to write recursive solutions to stuff I think after we introduce this when we talked about link lists and stuff we wrote recursive versions of that we wrote recursive versions of string stuff we wrote recursion recursive functions of like everything we went wild with it right so we should have had lots of practice with that so then one of the last ish things we went over was structures and that was basically grouping variables together within a structure so we can give a name and then a whole bunch of variable declarations so that's as many variables as we want within that structure and it kind of just groups all of those variables together so they should all be related to the same concept so if we want to use an error code it would be below the includes not within a function then we saw a type defing to rename a type so we just did that so we didn't have to type struct anymore basically because when we use struct generally the style in this course and the style in the exam is to write it like this so we do type def struct point then give it all the fields and then I like using like point underscore t the exam just so you're not surprised they like using capital letters which you'll use in like c++ it's generally a c++ way of doing it so if they did it they would just do capital p point then afterwards I can create a variable like point p1 and then to access the variables within the structure if it's not a pointer or anything I can just use a dot so I could access x by doing p1.x if I want to access y it's p1.y if p1 is a pointer well then I access the fields using p1 then the arrow because the arrow was just a shortcut for like dereferencing it and it had to be in brackets and then we access the field and it was just ugly so we use the arrow and just remember whenever we access the field so like the type of this is going to match the type of the variable so p1 arrow x that's just going to be a double nothing nothing too special about and then if we want to initialize the structures like array we can do the same thing and set values in curly brackets so if we did 1, 2 c will go ahead and set these values in whatever order are in the structure so if I did 1 first well the first variable I defined here is an x so it would set x to 1 and then y to 2 and if I reverse them then it would switch the order so if I did y then x well then it would just sign 1 to y and then 2 to x so always in the order that they're defined within the struct alright then we did link list ooh yeah so link list lots of fun lots of pointers and what I say more pointers more fun so it was a sequence of nodes so our link list we only we like made nodes and each node kept track of which one was next and then to represent the link list we only need to keep track of the first node and then every other node what knows what's next in the link list and that gave us some flexibility over arrays in certain circumstances if we wanted to like remove the first one without shifting everything over if it was an array or anything like that we could just remove the first one and then the order is preserved we don't really have to do anything different and we just updated one pointer instead of like changing all the values in memory if they were arrays and we had to move them so we implemented like all of these in one day right so that was a lot you should go ahead review these ones um modifying the nodes all the fun stuff so just review this we went through all of it if if you ever have problems visualizing it just try and draw it out draw out all the links always remember you might also have to update the head of the link list and all of that fun stuff so definitely be something about link list on the exam I guarantee that so all good practice to do and then we also wrote different ones in the exercise lecture that used the value right so it didn't work on nodes like remove node it actually found the node with the value and then removed it then we jumped into sorting so yeah computers are really fast they don't care about the order of the data however we're humans we like things to be presentable and in order so we discussed several sorting algorithms you should only really know bubble sort selection sort the other sections ran out of time it never got to insertion sort and goes without saying no quick sort and goes with I hopefully without saying no bozo sort so again do not write that on the exam I will probably get in trouble for that or at least that your TAs are going to laugh at you and then they're going to laugh at you and be like what section are they in and they're going to say my section and then yeah that's not going to be good so do not do those joke sorting algorithms so just concentrate bubble sort selection sort you should know how those work you should be able to write them you might want to check some of those notes how she wrote them to just if you want to see a different style I wrote them pretty short you can see hers for how they might be on the exam and I'll probably go I'll go over that to in the review session as well just in case you don't want to all right then we ended off with searching so if the array was sorted we could search it really really fast if it was unsorted right we had to do linear search which was just iterating through it one by one to try and find what we're looking for however if it was sorted we can use a binary search so that starts in the middle and then if it's sorted we can check if it's less than or equal to the value and then knowing that we can cut our search space in half then we search whatever half the array the number could be in then cut that in half and do that over and over again cutting it in half every time just search very very quickly so that was where we ended off in the course that's all you have to know for the exam so what's next in your career so in second year there is EC 243 that's computer organization you will more or less design your own CPU that's more of a hardware course you'll have a good understanding of hardware that machine code I showed you that the compiler generates to you'll basically be using that machine code so you will know how a CPU actually works right down to the lowest level in EC 244 you will be doing more programming so that will be in C++ that adds some niceties over C whatever things get more complicated you'll do that big O complexity analysis we kind of introduced in this course but you'll go over it in more detail there and then how to test and debug your programs a little bit more formally then EC 297 that's your first large software project so at least what it is right now it's a giant mapping it's basically like Google Maps kind of so you work on that all semester and have a big project on that at the end and everyone really likes that third year EC 344 near and dear to my heart because I'm the one that teaches it so I will probably hopefully still be teaching that so a detour if you haven't already please fill out your course evaluations because believe it or not those are very very important they really really matter especially to me because if you don't fill them out and they're not good I do not have a job anymore so I want to see you in 344 I hope to see you again I hope to see you again in that course so you need to fill those out so you make sure I'm still around by the time you get to third year otherwise I will not be here and it will be sad for all of us um... there's also EC 3 45 which is more algorithms and data structure so it's basically a continuation of 344 despite the name I don't know why Operating Systems is 344 and not that probably the numbers should be switched don't ask me I just work here um... alright with that that's the whole course thank you for bearing with me this course this is my first time teaching the course so hopefully it was okay so with that just remember pulling for you we're all in this together