 As welcome to the makeup lecture for Wednesday, February 24th, and we're going to continue talking about semantics. So the idea here is we've been talking about semantics and how we can really define what it means to be a programming language. So what are the semantics behind a programming language and how do we know? So we talked about the C scoping rules. So we've talked about that C uses block level scopings and that declarations are valid in the block that they're declared and they're not global unless their global decorations are valid for any program that can use them otherwise if the static keyword is used then the declaration is valid only in that file. So we left on Monday and we saw an example of block level scoping in C. So here we have a function main and we have our block and here inside this block we have an integer declared so we have a variable declared that's name is i and type is int we're setting int to be 10,000 we're printing it out then in another block we are printing out the value of i. So we saw that when trying to compile this C program we get an error where the compiler tells us that hey i is undeclared at line 11 which should be this line right here. i is undeclared because even though i is declared up here this i is valid only for this it's enclosing block. So in this other block we can't access that i in there. So this green brace shows us that this scoping rules that i is valid only within that block. So part of what you should be doing with these examples is I think it would help to try to execute run these examples to make sure you understand what's going on here in this program. So if we continue we can look at a different program very similar structure we have our int main function and inside this function we have one block where we declare the integer i we set i to be 10,000 and we print out i. In the second block we define a new and we declare an integer i and we print out the value of i. So now the question you should be asking yourself okay how does this change what we had in the previous example right? The previous example had only there's only one line that's been added here and that's the declaration of int i right here on this line. So now we want to think okay is this program going to compile? So if I compile this program with gcc is this program going to compile? So those are the type of questions you should be asking yourself so you should be thinking A is this program going to compile? B if it's not going to compile is it going to have the same error that it had in the previous example? Same error or different error right? The previous example said that hey this i is an undeclared identifier. So if we think about it okay and we try this we can see that okay this program does compile correctly and then this creates an executable program called a.out. We can execute a.out. So now the question in your mind needs to be what does this program output? So what is the output of this program? And this is a good self-check of your ability to understand and interpret C code and C synantics. And this is going to be important information that you're going to need for midterms and finals because you're going to be looking at a lot of code and having to simulate its execution by hand by that big beautiful computer called your brain. So let's step through this what we think should be executed. So we have in this first block we have the i is declared we set i to be 10,000 and so we're going to print out should be we're going to print out 10,000 and a new line. Then when we enter this next block we have a new i we're going to print out i but now the question is the key question is what is this i value that's going to be printed out? Is it going to print out 10,000? Is it going to print out something different? And so let's see one execution of this so one execution it prints out the 10,000. It's the wrong number of zeros there that's 10,000 that's 100,000 but it should be 10,000. Then it's going to output zero so this other print f is going to output zero so you think huh that's weird why did it output zero? So knowing what we know about programming languages right so we can know that this in i here so the key thing is when resolving this identifier i we want to resolve it to the closest declaration to this value so we know that this i refers to this declaration of i in this block that means that what happened to this i in this block even though it has the same name right these are different declarations which means they are considered different variables and should be completely separate so that setting i here to be 10,000 has absolutely nothing to do with this i over here and that's a key point that I want you to be thinking about is okay they may have the same name right but they actually refer to different declarations which is why they are different and why changing this i has no bearing on this i in this other block so now back to the question of okay what is being output here with this zero and it turns out that well if we look at this block right there's only two lines so it's pretty easy to reason about what's going on here so we have a declaration of a variable and then we're printing out that variable but we've never initialized i to any value so what we have here is basically a case of an uninitialized variable and so we're going to so c allows this and maybe the some of you have noticed or maybe you can notice now that I didn't add the dash capital W all flag here to gcc to show all warnings if I had it would have told me that hey there's a warning here because you're using i before it's initialized but that's not an error this isn't a that's not a compile time error that's actually not even a semantic error according to the program what it is is undefined behavior so the spec does not say in c the specification does not define what the value of uninitialized variables are and so the implementation is free to do whatever it wants so in this case in this first example is run on a sento s67 machine so here it outputs zero but if we run this on my mac which is actually going to use a completely different gcc it's actually going to use clang under the hood not gcc but that doesn't matter it's gonna we can compile it it's hopefully going to compile just fine right so if it's a valid c program it should compile both on linux and on mac and so once it compiles when we execute it it's going to successfully output 10 000 as it should yay and then it's going to output whoa some other junk what is that one two one one billion six hundred and sixty nine thousand no six hundred sixty nine million six hundred fifteen thousand six hundred and seventy okay so wow completely big difference but we can see here we've actually done some behavior that the specification does not define therefore it's completely okay from this the semantics of c that this program when run on two different the same c program when run on two different operating systems outputs different values because the output of an uninitialized variable the value of an uninitialized variable in c is not defined okay and then as we get closer and I think we'll actually get into what's being printed out here but for those that are curious it's essentially whatever was on the stack at that point in the program's execution so for whatever reason maybe because difference is the stack layout something zero is printed out in this case whereas this other value is printed out in this case which is probably some sort of address is my guess okay so now we've seen examples of c scoping and we've seen examples of c block level scoping now the real question that we want to try to answer is right this duality of declarations right so the semantics of how long a declaration is valid for right the flip side of that is how do we resolve a name so when we see an identifier we need to be able to map it to the declaration right and this is critical because we know that every every use of a declaration is going to be the same variable right so if we use so this is what's important right the name alone does not tell us that it's the same variable just as we saw in the previous example we had two different variables called i right exact same name but affecting one didn't affect the other even though they had the same name and this is because the important thing is the declaration not the actual name itself so resolving a name is key so that so when we see that identifier when the compiler sees the usage of id or i how does it map it back to that declaration so the compiler does this using a data structure that we're gonna that's called the symbol table and this is a very simple table it basically maps names right so it maps names to declarations and attributes so what would be a declaration well we saw so we'd see that hey this is the i online one two three four five and this is i online one two three four five six seven eight nine ten online ten and attributes would be any additional information about that declaration and that name for instance attributes can be types attributes can be class attributes so visibility symbols attributes can also be is it a function or is it a value right or is it a pointer right all these things are additional attributes about a declaration so when resolving a name there are two types of scoping rules that are used and one type which is the type that you're most familiar with so this will probably be pretty natural for you to understand and to use because this is how you're used to thinking about programming languages so static scoping rules the basic idea is you resolve a name to a declaration statically so you can actually look at the code just like we were able to look at those c examples and you can match up usage of an identifier usage of a name and you can match it up to that declaration and in essence what this means is that the compiler creates the symbol table and it does it statically while it's compiling the program so you can think of that the compiler is going through the parse tree and whenever it sees a new scope and new declarations it adds those declarations to its symbol table and then when it sees identifiers it looks up in its symbol table hey do I see an identifier in my symbol table if so then I know how to treat that that name right and so this is why this symbol table is is really important to compilers and this is exactly how the compiler is able to tell that you have an unidentified an undeclared identifier error because it sees an identifier right and we've actually seen how to define an identifier it's defined using tokens so when the parse tree is going through the parse tree when it encounters an identifier it's able to say and look up in its symbol table and say huh I actually have no recollection I have no entry for this name in my symbol table therefore this must be an error this has to be an error I can't compile this program it's it may be syntactically correct but it's semantically incorrect so the flip side of dynamic scoping which we're going to get into is that the resolution so the idea is this mapping of names to declarations actually changes dynamically when the program executes so the idea is instead of the compiler creating this symbol table statically while it compiles the program the symbol table is actually going to be created dynamically at runtime and this lookup mechanism is going to happen off the bat this lookup mechanism is going to happen right away so let's let's go back to our notes we're going to look at some examples here so we're talking about static scoping rules so the first key thing to understand is that scoping rules are hierarchical blocks are hierarchical right there's nested blocks so if we label this as block one and then inside there we have another block and I have some if condition I'm going to put dots in there because I can't think of what to put in there right but this would be block two block three right so by looking at that we can see that there's a parent child relationship between one two and three so if we were to draw this static scoping as a tree we'd have something like okay one and two and three right so I know that two and three are both siblings and then if there are any blocks let's say inside three this would be four and so on so at each of these blocks variables can be in each of these blocks variables can be declared right so let's take in this example so the question is okay okay let's say here in block one and here I'm going to use this kind of abstract tree structure for right now so I don't have to just write out a program and have everyone yell at me because it's not a valid program so let's say we have an an integer i right we have an integer i declared here and in two we have in x three we also have in x and in four we have an integer called i right so these are all declared so it should be fairly trivial and one thing you can do to check yourself is say can I take this tree block structure and turn it into blocks like this right you don't have to worry about this if this if statement but it should be pretty clear here so now to do static scoping right and to resolve a symbol so let's say inside block two right inside this code here it's a terrible arrow inside this code here I have we'll say x is equal to x plus one right and you can think about actually what we have here is a tree the parse tree for this but for right now we can not think so concretely in that terms and we'll deal with the code that we're used to thinking about so the compiler sees this x right and so we can think of okay it's already tokenized the lexer has already tokenized this so it's turned this x into the abstract token id it's created a parse tree out of this the parser has created a parse tree so there's a node that's called an id but I have as we've seen in our lexer we store the current the value of this token right so we'd have id and the string x right so now when I'm going through and I want to check the semantics I say okay how do I map this identifier x to a declaration is it a global is there some global in x how do I do that so what I'm going to do is starting in my current block I'm going to look up in my symbol table and say in my block and say okay is there an x declared in my block and here I say yeah so I see okay yeah bang that that right there that's good if it's not in my block then I go to my parents block and I say is there a if it wasn't here I would say is there an x declared in block one and then if that's not true then I would keep going up and up so for instance in three right so if we have right here if I say I is equal to I plus one so let's do something else let's do x is equal to I plus one right so when I get to this I I want to resolve this name I to a declaration so I would first look in block three and I say okay is I declared in block three and I say well no clearly the only thing here declared in block three is into x now note right I'm in here I'm in three I haven't entered block four so this in I has no bearing on it we don't even look at our children we look at the parent and say okay it's not in three so let's look at the parent of three okay here in block one is there an I and I say yes and so I can map that I to that declaration but in four right then the same thing with this x I can map the x I first look in block three it's not in there I look in block one now in this four now if I see an I when I look that up which block do I look in first well following the same pattern I look up in block four and I say is there an I declared in block four and we say yes so this I refers to this declaration of I so note that we have two names right in one and in four but this one refers to this I and this refers to this I so let's look at an actual example of a program so here I have a block I have an integer I I said I to be 10 these are all braces sorry my braces game is kind of sloppy right now so here I have an integer x I said x to be 10 and then here I say x is equal to x let's have an integer I I is equal to 100 x is equal to I plus x okay close close close close up here close up here right so this hierarchical nature essentially means that so here we just have so if I draw this I have one two three right and all of these scopes are nested within each other so there's a parent child relationship here and in here I have an int I in block two I have an int x and here block three I now have an int I so this use of I I can see is in block one this line of code is in block one and this line of code is going to change this variable and set this I to be 10 so we'll just add the value here and then I'm going to execute this I'm going to say okay how do I map this up oh that maps over here so this is going to set this x to be 10 and then I go here I say okay which is this I well I just look at this chain and I see oh it's this I so I'm going to set this I to be 100 and now here when I say x is equal to I plus x I'm in block two now I've left block three I'm in block two and so now I'm going to say okay x is equal to I plus x so I's current value is not defined a block two defined a block one is 10 x's value is 10 so I'm going to say x is 20 yeah that is 10 plus 10 good math but note that I didn't say x is equal to 110 right and that's the key thing so this I essentially what we call shadows this declaration of I because it's there's actually no way I can reference this outer I once I've declared this inner I variable okay so then let's look at a more complicated example so here we have we're including our standard IO.h function so we get access to the printf functions we declare an x and so self-check how far is this what how far is this scope valid how far is this declaration valid and so the answer is well it depends on what our semantic rules are so I'm telling you we use C style semantics here so this means that this is a global declaration of int x and so x is valid from here to the end of actually the program so any other files can include this x but right now we'll just focus on this file assuming this is a standalone file so I have another one so then if we're in class I would say so is this a declaration and we'd have a discussion about it and so hopefully you can convince yourself that yes this is the way you declare so what am I declaring here well I'm declaring so the first thing is what is the name of the thing I'm declaring and you can see by my highlighting that the name is bar but the idea here is that I'm declaring that there is such a thing called bar and what is the type of bar so here just like in this previous declaration I'm declaring a variable x and I'm declaring that x isn't has type integer just as here I'm declaring that there's a thing called bar and bar is a function right so what is the type of that function bar is a function that takes in no arguments which is indicated by the fact that there's nothing between the parentheses and it returns nothing so it returns void nothing but the key difference is with the semicolon here this is bar without a body so I'm saying there exists a function called bar and here is the here are the parameters here or what it returns but I don't know where the body like I haven't actually defined the body yet so this is just a declaration we're just declaring that there is a very there is a function called bar but we're not necessarily saying where it is or what the definition is flip side of this is I can declare and define a function right and so this should be pretty natural in seeing in your programming and once again the point is not to reiterate simple concepts but to get you to think more deeply about the current things that you already know so and inside this function foo so here now with these braces we've started a new block we started a new scope so inside this scope we define a character C and we set it to the character C then we call bar and then we print out the value of X and the value of C so important thing to note even here where is this bar resolved to right and saying well remember when we're doing resolutions we're trying to map names so here the name bar we're trying to map bar to the declaration where it's declared right so this bar would map to this declaration here just like this X maps to this X here and this C maps to this C here and we can define other functions let's call it Baz. Baz prints out the value of X and sets X to be 101,337 now we have the body of bar right so this is the function bar inside this function we set X to be a hundred and then we call Baz so finally we have our main function where we set X to be 10 then we create a new block we define a new variable right so let's pick this declaration of part based on the semantics we're defining we're declaring a variable whose name is X whose type is char star and whose value is initialized to the string testing and then we print out X if you don't understand the printf direction directives here like percent s percent d and percent c you should spend time studying what these directives do and what they mean this is something that I noticed last semester that tripped people up is not even knowing what a simple printf style things actually print out as far as complication I don't think you need to know too much more that's anything more complicated than that but you should be familiar with printf I mean this is one of the core bedrock kind of functions so after here then we call function foo so a first thing you can do is check yourself so what a so on an exam right I may give you some code like this and I might ask you hey what is this program output right it's not an outrageous question I think it's something that you all definitely can do and you should be able to do but so that's one step right it's okay what is it output but two is okay well how do I actually what are some strategies that I can use to actually do this right and so one thing can be okay let's try to think about for every one of these declarations what is the length of this program that it's actually valid right so what's the scope of all of the declarations in our program right so more self-check right so what is the scope of x well based on the semantics that we've been discussing for c right x is a global variable so it's going to be its scope is from its declaration all the way to the end of the file right we're gonna say int x exists all the way here and so what about bar right how far is bar declared how what's the scope of bar well it's from here right after it's declared all the way to the end of the file and so this is the key thing if you've ever wondered gosh in c why do I have to declare these variable declare these functions before I call them like it seems silly can't the can't the compiler go through and figure out all of my functions and then allow me to do this um and the reason is yes it could do that but the semantics of c means that it it really that's not how c programs work c programs work that uh a name and identifier a declaration is valid from where it's declared to the end of the file for global variables and so this is why you have to declare a function bar if you want to call bar in a function foo before you have the body of bar right and this is also how you resolve mutually recursive functions you have to declare them before you use them uh and in case you're wondering wow but then how do header files maybe mix into this well uh you put these declarations inside the header files and you'll notice the header files always go first right so inside standard i o dot h there is a declaration and definition of the printf function and this is how we're able to use and call those functions that are fined in standard i o dot h okay then moving along right so once again the difference between this bar and foo here is bar is declared here whereas foo is declared and defined so we have the body of the function foo here and also a declaration of a function called foo and so foo is going to be valid from here to the end of the program right and so this is actually if you think about well shouldn't it be after this declaration here like after the end of the function foo because that makes sense right bar is declared pretty much after the semicolon right anywhere after it can call bar so shouldn't be the case that foo is valid the scope is in effect after it's defined anywhere down there and the problem you get in there is okay this foo well then foo can't call itself it can't be a recursive function so that's why the scope of foo actually extends inside of its own body so that you can have recursive functions okay then let's step into the body of foo so important note right so that here foo has its own block right the body of foo has a block so this is a new scope so now when this char character c is declared right this means that where's the scope of c it's the scope of c extend all the way down can we access this c from main can we access this c from bas because they're next to each other maybe because they're neighbors we can do that so we know from the scoping rules of c that it's just in this block so c is going to be valid just in the block that's inside foo and here in bar right x is going to be valid just inside this block and here in this x this character pointer x is just going to be valid inside the block that's inside main so now that we've done this we've identified the length and the scope that all of these are are valid right you can see that actually if we turn this whole thing let's see angles two seven if we rotate it 90 degrees counterclockwise right we can see we have our nesting scopes which is what we're just drawing on the notes right we have the global scope and in the global scope x bar and foo are declared and then each of those has sub children's scopes right so this global scope has several sub sub blocks and subscopes where cx and x are declared so this means when the compiler is going through this code and when it encounters something like right so convince yourself that this first instance of bar here is actually the first usage of a name in the program so here we have in a parse tree it would be bar left bracket right bracket or left parentheses sees left parentheses right parentheses so the idea is now the compiler sees this and it wants to go okay what is bar it's just the name right I need to look up what that name means so it's going to look it up in the scopes just like we saw from the current scope to its parent scope to its parent scope until finally it either finds it or it doesn't find it so it's going to look up bar in this local scope and see nope no bar to find in this local scope and then it's going to look it up in the global scope and it's going to say aha this bar maps to this declaration of bar here awesome then it's going to see this x and it's going to say okay which x does this refer to well look in the local scope okay no x here and then look in the global scope hey there's an x to find so I know that this x refers to this declaration of x here or as I've written it here including the length of x's declaration this is where x is defined and then it looks up c and it says okay a c defined in my local scope uh yeah so that means this c refers to this character c right here great okay and then when we get to the print f right print f is just a name it's no different than bar or x or c right it's just the name that the compiler still has to resolve to a declaration and it will actually resolve it to a declaration in standard io.h so we can actually not worry about that okay moving along in baz so now when we get this x we say okay is there an x in the local scope no is there an x in the global scope yes it refers to that x and so the same thing with this next x here right on the next line we'll see that this x refers to the same int x and down here in this x right when we say x is equal to 10 well the question is is this x going to be point to this x because they're like close by right and the answer is no the exact same process occurs we look for x in its scope which is from here to here we say is there an x declared here in main no there's no x declared here in main therefore go to the global scope the parent scope in this case the parent scope is this x and so it won't point there it's not going to point to this character pointer x so why well this scope is a child of our current scope but we only look in the current scope and then parent scopes we never look in children so this x actually resolves to the global x but inside this block when we see this name x we need to resolve it to the declaration so we say okay what is this x well look in the current scope is there an x yep there's a character pointer x and so that refers to this x so we can see that this x here right has two completely different meanings in one case this x is referring to the global declaration of an integer x and in this other case this x is referring to an x that's declared in the local scope that's a character pointer so two different types same name but still everything works and the important thing is that we can know and we can look look so what happens when we compile this so question you should ask yourself is it going to compile are there any errors no yes yes no okay it compiles fine then what happens when we run it what's going to output so here's where you have to then be able to step through this program and be able to simulate the execution right so if we step through here right so the first thing to ask yourself is okay which function is going to be executed first well it's clear that main is the function that should be executed first that's the c standard and so when function main is executed or the first thing that happens is x is going to be 10 and so we've already resolved this x right so before execution we've gone through that process and we said okay this x refers to this declaration of x so this global x now has the value 10 then we enter this block we initialize a local x to be the string testing and so we print out a string percent s means print out a character pointer string and we print out this x this local x which we just did and so it's going to print out testing followed by a new line right so the first line of output is testing then foo is called so we call foo foo sets a character c to be the character c it then calls bar bars declares a local variable x to be 100 and then we call baz bazz prints out the value of x so what's the current value of x it's 10 right this call to main set out 10 please check with yourself to make sure you understand why it's not a hundred right so we print out 10 then we set x to be 1337 we return from baz to bar we return from bar back to foo and then we print out okay we first print out percent d means take that value print out of the decimal so we print out x so x is 1337 because this x refers to this global x this x also refers to that global x so we need to print out the value of that declaration of that variable and then we print out a character so then we print out c right from this c so we should print out first pen from our first line of baz and then we print out 1337 and c right so you should be able to do this and this is something you should be able to do you should be able to take code look at it and really try and understand okay what are the static scoping rules here so in static scoping we're creating these symbol tables of okay in this scope these variables and decorations are declared but when we already did this so in dynamic scoping the symbol table and the current scope is changing and updating at runtime so the idea is when we're trying to resolve a name a specific variable name let's say x we actually look up dynamically at runtime in the symbol table for the last encountered declaration of x so what does this mean in practice in practice it's kind of crazy because this means that x this name x the declaration could change the type could change depending on how a function is called right so actual languages actually use this so common list actually allows both dynamic and lexical scoping so let's look at an example to kind of help try to illustrate this point so before we were able to completely create essentially this tree or these symbol tables dynamically right we were able to look at the code and be able to create these symbol tables right that's where the static part of static scoping comes in we only think about these things statically we only create these we can create these symbol tables statically and we never have to think about them because they never change okay and to make the example i guess i'll be consistent all right print f and d slash n x okay i have in my main i'm declaring an integer x i'm saying it'd be 10 000 i call foo i set x to be 10 and then i'm gonna call some other function bar and then i call foo right so even just looking at this let's not talk about bar for right now let me get rid of some of this so here in this example we're declaring a global integer x and we're setting it be equal to be 10 so if we're talking about static scoping right just looking at this x if i construct this symbol table statically i say okay i want to resolve this x i have to look in the local scope of foo ah there's no x declared there therefore i have to look in the global scope it's parent which is the global scope and i see aha this x refers to this global x right and that's the important point it always refers to this global x it doesn't matter how or where foo is called this x always refers to that x in static scoping but in dynamic scoping that's no longer the case so in dynamic scoping we actually keep track of the symbol table as things are executed right so we first execute this instruction and so we create an entry in our symbol table so here we have let's say name value for now so the name here is x the value is currently 10 right so this is the global scope so we execute this we execute this so what's this going to do how's this going to change our symbol table well we're defining a new symbol called foo its value is the body right it's a function i didn't include other stuff here and then i get here right so i create a new symbol on my symbol table called main the value we're gonna say kind of points to this guy right and what happens when i get to this integer this main function right well i'm gonna start executing it so i execute this first line but first i've entered here i've entered a scope right so this right here is my global scope and now i have a child scope of this global scope right i've entered a block and then see i've done that so i'm gonna uh illustrate that here and i'm gonna delete these pointers because they're kind of annoying i'm gonna illustrate that here with an arrow and so now i start creating a new symbol table and i start updating it and now i say okay in x great i know how to deal with that i create a new entry in my symbol table called x the value of x is 1000 great everything is awesome okay then i execute this next function so it's gonna call foo so when i enter function foo notice i've added now a new block here right i've entered a new block so i create a new scope of the symbol table but there's no declarations in foo right so this is empty which i will kind of do like this and then we see okay now we see the x and we need to resolve x back to the declaration right actually right at this point we're actually executing the program so we're trying to say okay what is the current value of x so that we can print it out well i take this x and what i do is i look essentially up the symbol table right and i say okay is x in my local symbol table nope there's nothing in there so go to the parent okay is x here yeah x is here so the value of x right now is 10 000 so it's going to print out you know if i execute this it'll first output 10 000 and then after this executes we are leaving the block foo so this goes away because everything that was declared in foo is only valid for this specific block so we're going to completely get rid of that then we're going to return from the function foo and when we return from the function foo we're going to now go to this line and this line is going to say okay look up this x which x's value am i going to change well look up in your current scope okay the current scope in the table is here oh great the next is here set this value to be 10 perfect okay and i'm going to just in time write a function bar and i'm also going to just in time delete parts of the code so when we get to this function bar we start executing bar when we get to bar right we create a new scope because we've entered a new scope of the program and we say what are the declarations in here okay we've declared a variable x x has the value 42 we see a function call we go to function foo we create a new scope right we've entered a new block the scope has no declarations and so now right we get to x and we need to resolve x again and we say okay what is x going to output well we look up x we look at in our local scope there's nothing there right so remember we go up so we look here nope nothing here we go to the next scope say oh yeah there's an x great the value is 42 so output 42 so you can see that this x if we look at it here right the first time that we called it it actually resolved to this declaration in main but the next time we called it it actually resolved this declaration of x and bar and in fact it never ever referred to this global x for whatever reason when statically it would always print out the same it would always look at this value and print out 10 10 right and so this is the key idea behind dynamic scoping is this resolution and the resolution is done at runtime and the construction of the symbol table is done at runtime okay so on Friday we'll go into more examples of dynamic and static scoping thank you so much for taking the time and hanging out with me on this amazing monday afternoon but for you due to the amazing ability time traveling abilities i have you'll be listening to this sort of latest tuesday or wednesday so anyways i've missed you all and i look forward to seeing you on friday