 Okay, so we're at office hours for, was it, 10.19? All right, so let's define how many parameters do we want in our function foo. Can you see? Three. Three? Let's do. Let's add one more. Yeah, four to four. One. E, no, too much. Too much. All right. Just D. We'll go with three. Does it need to be, all right. Four. What do we want the function to be? I don't know if statement is right. Some kind of if statement. Okay. Let's say. With addition. With addition, with arrays, with like. Oh, yeah, yeah, yeah. With addition, with arrays. See what else? It's like a random integer in there somewhere, too. Yeah, we have function inside it. We'll get slightly complicated. Let's see. How about that? Yeah. Okay, so our function foo takes in four parameters. A, B, C, D. Okay, so what does the tree look like? What's the top most node? What? Yeah. Yeah. Yeah. Oh, what's on the left side? Function. A, B, C, D. And then on the right? Was it? Yeah. The if. And then with the left most node of the if statement. Apply. Apply. Plus, apply. 10, 20. Less than. Less than. Less than. So I guess it depends kind of, we didn't parenthesize this, but we can kind of see it's, that's what we want, right? A plus B is less than 10. Right, so that would mean that the top most operator here is gonna be the less than. And the left hand side, what's that going to be? A plus three. Plus. Plus. There we go, plus. And then the left one here? A. Okay. And the right one here? Six. B or six? B. B. Wait, can we put a six? No, we have a 10. Okay. Less than, let's say 10. All right, what's our first if clause? So our then branch. Apply. Apply. And what's the function of replying? C. And what's the parameter, the first parameter of replying? C. And the left of the array operator? B. C. And the right? A. Thanks. See if you guys can do this. All right. This part is okay, but then. The else? It's gonna also be applied? Yep. And the left here? A. Can you, on the left? On the screen, you can't really see the glares. Can somebody jump up there and... It's the next one. It's the one in the Super Bowl corner. It's okay, don't worry. None of this stuff's important. Just grab a little bit of it. Except for that. Apply, let's bracket it. So what's the left of the apply operator? D. D. And the right? A. And what are we applying that function to? A. Is that it? All right. Thanks a lot. Did you explain what's... So... Yeah, that's a good question. Oh, we just did a syntax tree, right? So what is it now? On the far right? The L statement, what is L? Use, take the array, well, apply the array operator to D with the index A. Whatever that is, return as a function. Call that function with the parameter A. And you can see this is exactly how we wrote the L case here, right? Oh yeah. That's the little glaring. It's okay. There's only so much we can do. Maybe it's like HD arrays. There we go. Nice. Good job. Okay, perfect. Okay, so we have the apply. So yeah, so you can see just like this, there's really no difference here. Doesn't really matter that we're using, we could, I mean, you could add things and then use an array to get a function, whatever, we could pass on the parameters. So, question on that part. Sure. Is A being passed to D? Or is A being passed to... Where? Yeah. So A is being passed in as a parameter to what function? Or it gets an array that has A pass X also. So we're not passing it to the array D, right? Think of, well, in this case, we can see that you can think of an array of functions, right? No different than anything else, right? Functions are just objects, right, or data. So we can have an array of functions and then we can choose which one of those functions to call based on some index and we can pass something into that, right? So I haven't done this. I don't know if this type checks or not. I don't have any idea what's gonna happen, so. But that's what's fun, that's what we'll do. Okay, any other questions just on this? Okay, so we need to assign types to everything here, right? So, we're gonna first number all the nodes, right? We'll give it whatever. Type here. We'll give that a type and then this a type three, four, five, six, seven, eight, nine, 10. Wait, how did that get? Eight, 11, 12, 13, 14, 15, 16, 17, 18. 14, 15, 16, 17, 18. Is that right? 18 nodes in the tree. So I just did a depth first pre-order sort of the nodes, right? So it's super simple, one, two, three, four, five, six, seven. Okay. So I look at node one and I say, so what are the constraints on node one based on the types here? There's some type A, B, C, and D. There's not some type, right? A, B, and C, and D are variables. But they each have some type. And foo has a type which takes in, which is a function that takes in each of those types and returns what? A type. And what do we know about that type? We don't know. That's not true. What do we know about that type? It's the same as the F. Same as this node. Same as three, right? Because we know that whatever this returns, that's gonna be the return type of foo, right? So just by looking at this, right, we know foo is a function that takes in four parameters. We don't know any of the types and we don't know the type of the if statement. But this is basically what we have right now. So we'll kind of try to keep a list of the types here. So we have, let's see, how do I do this? The type of foo, the type of A, the type of B, the type of C, the type of D. Let's say type one and type nodes one and two don't really have a type, so we don't really care about it that much. So let's start with kind of the type of three. Okay. So I know just from looking at this, I have the following constraints. So I know foo is a function that takes in a TA, a TB, a TC, a TD and returns what? T three. So this type here is that whatever this type is, that's what foo is gonna return. Do I know anything else about A, B, C or D? A is an integer, how do you know that? Have we looked at five yet? What have we looked at? Just the first. Just the first, yeah. That's right, that's the first constraint that we have. Boom, just by looking at this first node. We can look at the second node, the second node really doesn't do anything. But now we wanna look at this third node, this if statement. So we have an if statement. So what does an if statement say about the types of T four, T nine and T 14? T four is a boolean. T four is a boolean, why? Because the condition, the statements inside if are a boolean. Yeah, so the condition of an if statement has to be a boolean, either true or false. So I know that T four has to be a boolean. Right, what else do I know? Nine and 14 are the same as foo and if same type as foo, basically, because those are gonna come up based off. Not the same type of foo, what's the type of foo? T three. Right, T three, perfect. So I'm gonna actually just kind of leave them here. I could write here that T nine is T three and T 14 is T three, two, but you can see we're gonna run out of room here at some point. So to keep it legible, when I visit these, I'll know that they return to type T three, right? And this makes sense, right? So if you have an if condition, no matter which one you go down, it has to return the same type, otherwise you're gonna get a type mismatch. Yes. When you say nine is T three, is it equal to or is it like arrow T three? Well, what I'm doing is I'm uniting the type T nine and T three, which means that those types must be equal. So I'm doing unification. So I'm doing type unification. T nine has to be equal to T three. Since I haven't touched T nine yet, I'm just gonna replace it with T three. So on my tables, I would do that. I would list all the types and then I'd say, okay, well, T nine is equal to T three. So I could do either one. I could replace all the T threes in there with T nines, and then I could place all the T nines with T 14s, or I could replace them all with T three. The point is right now, I know that these types have to be the same. So if it turns out that this type is something different, if this is an integer and this is a Boolean, then we have a type error, because I've just declared here that these are the same two types. And they're the same as the return value of foo. I have a doubt, actually. Why do we go on to assume that T three are there and T three are of the same type? Because what if it's if condition returns an integer, else it returns maybe a string or something on the different types? Why would we just go on to assume in one shot that it's gonna be the same type under the list block? So would that be a valid, I don't know, would you be able to have a consistent type system where if the code goes down one branch, it returns an integer, but if it goes down another branch, it returns a string? So for that is a possibility. I can say, for example, if x equal to 10, return an integer, else return a string. Because that is the right code. Well, you could write that program that doesn't make it a valid program in our type system. The function itself would have the return. Right, so you gotta think, so remember, now this is kind of different than we've been thinking about, probably what you've been thinking about if statements right here, right? Right here, we're saying that these actually return something. So you can think of them as a function. Right, so if you think about a function, could a function return down one branch an integer and return another branch a string? Oh, what if they were different functions and, I mean, I'm just saying, if they're different functions, it's fine. The point is that I need to be able to do, I could go down at either of these branches. So let's say I'm assigning this to a variable bar, right? So how do I know what the type of bar is? Well, it's gonna be consistent regardless of whatever branch gets taken, it has to be consistent. You could write a program like that, but it wouldn't pass my type system. Even though to you, it may be okay, like you could write a pro, you could, like in Python, you could do something weird like that. You could have sometimes be a list, sometimes be a string. But specifically in this type system, so that's actually the more valid, real reason is we're saying this language we created in this type system that these have to be the same. So the reason is that the if statement is not just a control flow operator, it returns something. So it returns whatever, if this statement is true, it returns what's ever in the then clause. If there's an else, it returns whatever's in the else clause. Then we didn't say it, but if it didn't have an else clause, we can say it returns null or something like that. Like for instance, this is how Ruby does it. So you can actually have like a variable assignment equals an if statement, and then it will, depending on the branch, return that value. So everything returns a value, which kind of becomes very nice. Also, that segment of course, if you've written that, it's not a valid C program as such, right? I don't think. We're not, is this, does anything here look like C? No, we're using more ML, OCaml style syntax and semantics because that's really where this kind of comes from. So it's a lot easier to apply that there. But there's nothing that says we can apply this to C, except we may change our if statements and say that they don't actually return anything. Okay. One more doubt. So what, how would I write this in C for example? How can I say, for example, function x is equal to something else? How can you, can you do that? You should write it. Like can you say? What's the difference? Oh, okay. This is what this means already. Yeah. Just different syntax. Anything else? So we are, so we just did T3. So now we wanna analyze T4. Right? So what do we know about the less than operator? It returns a Boolean, which is good. So we know this has to be a bool. So we know that T4 has to be a bool, which we know it is a bool. So that's good. If it was not a bool, it's a type error, right? We'd quit. So what else do we know about it? T5 and T8. Sorry, right. So arithmetic operator? Not an arithmetic. Relational. What's that? Relational. It's comparing two values. It's relating two values, right? So what do we know about it? So what the parameters will have a new omega type? They have to be numeric types, but we're ignoring that for now, right? That was just kind of for the display purposes, because we would wanna maybe say that. But let's say you can compare strings with less than, right? So we'll just say that these two types have to be the same, right? So T5 and T8 have to be the same. So I'm just gonna say they're both T5s. Do I know anything else about T5? No, right? I don't know anything yet. I just know that this, I know that these two have to be identical, have to be the same types. Okay, now let's go into this guy. So here, I have no idea what's gonna work, let's see. Okay. So here, so I have a T5, and then I say, okay, this is an addition operator. So what kind of operator is this? The plus operator. Oh, that's right. Yeah, so what do we know about that? It has to be two. Okay, it doesn't have to be numeric, right? We're getting kind of rid of that, because we can add strings together. You can concatenate them, right? So they have to be the same. They have to be the same, and the same is what? Integer. Integer. Okay. Integer. Don't have to be integers. So they have to be the same type, but what else has to be the same? When you add two integers together, what do you get? Well, they're integer. You have to get another integer, right? So that's what, so whatever we see, like a plus, whatever, one, I don't know, A, big A, and big B, right? So that's type T1, this is type T2, this is type T3. We know we have the constraint T1 is equal to T2, which is equal to T3, right? So that's the constraint that we have, is they all have to be the same. Okay, so that's what we know here. So I'm just gonna propagate the T5s, and just say these are all T5s. Okay, now I visit node six, which kind of looks like node B because my handwriting's bad. So we visit node six. So what's the type of node six? T5. T5. Does A, do we know that A doesn't have any other type, right, just the TA? So yeah, we can actually then replace this with TA, right? So we can kind of put here, well, T5 is equal to TA. Or it can also replace the opposite way, right? Can it be TA equal to T5? Yes, exactly. We could switch it around, we could replace all the TAs and T5s. I like the As because of parameters. So that kind of helps me say, this is the type of A. All right, so we did six, now we're gonna do seven. So what do we know about, what's the type of B, the variable B? TB. TB. Do we know anything about it? But we know that from this, we know that has to be what? T5. T5, and what's the type of T5? TA. So now we can actually replace, we can say TB is equal to the type of TA. And we can also replace that in this type of foo. So now we do have a constraint, this should be a D, right? So now we do have a constraint. Now we know that whatever foo is, it's gotta take in the same, the first two parameters have to be the same type. All right, cool. So we did seven, now we do 10, or we do node eight, which has the type of what? T5. What's the type of 10? Int, yeah, int. So now we know that T5 has to be an int. What's T5? TA. TA, which means that TA has to be an int, right? So this is, that means we have to have time to do lowercase. All right, so that means everywhere I see a TA, I can replace it with an int. So I know TA is an int. I now know this is an int. I now know these are both ints. So it's kind of interesting, without this 10 here, right? So this plus operator means that A and B have to have the same type. And this 10, when we're comparing them, that means that, and they have to return the same type, this comparison means that these have to be the same type. And this is an integer, which means this is an integer, which means both of these are integers. So that's how we know that, now we've gone through this branch, we know foo is a function that takes an integer and an integer, or two other types that we don't know and return some other type, T3. Questions on that? All right, what node do we do next? T3. Node 9. Node 9, exactly, T3. Perfect, okay, we have an apply. So what do we know then about an apply? What constraints does that give us? The left side has got to be a function and how many parameters does it have. The amount of sibling nodes, right nodes, yeah, exactly. So this has one. What's the return value of this function? Type of the array. The return value? No, no, no, no. That should be T3. T3, right, exactly. So whatever this returns, this function, when we apply it, better return it. So now we know that Tc has to be, so it's a function that takes in, we don't know what this is yet, so we'll use T11, right? T11. And it returns a T3. Won't it be a array of type T11? We don't know yet, we haven't looked at this yet. All we know is that this is some node that has the type T11. And these are the only constraints that we have on this right here. So we can kind of say T11. So this is when we get to a case like this, we just generate a new type because we have no constraints as to what that type is. Whereas here, instead of creating a new type, well we know these all have to be the same type T3. So I don't need to create a new type because I already know that whatever type it is has to be a T3. So then now we look, so we look at 10, we see that it's Tc. We've kind of already done that, right? So we should have maybe said type 10 here, which I think we'll probably get to over here. But we can see here that, so we kind of already did type Tc as a function that takes in T11 and returns T3. Okay, now we go to node 11. So node 11 is the array access operator. So what does that tell us about the types of it and its children looking constraints? T12 is array of T11. T12 is an array of T11. Yeah. So T12, yes, exactly, okay, perfect. Is an array of T11s, right? T13 is an int. T13 is an int, right? So these are the two constraints just looking at this node, right? So node array access operator, we know whatever we access has to be a T11 and we know whatever's on the left is an array. So we know that whatever T12 is has to be an array of whatever this returns, which is T11. And then we also know we always access an array operator with whatever's on the right and it has to be an integer because that's how we specified it. So we know that T13 is an integer. So then we go, we visit node 12 and we say, okay, this means type of D is equal to the type of T12. So I know this is here. So I can say that this is an array T11. And I can kind of get rid of that. It's not right to say anymore. And then I visit T13 and I say, okay, what's the type of A? An int and the type of 13 we know is an int. Are these the same? Yes, that's really good. If there was any doubt, if this was anything besides an int, we'd quit, we'd error. Say this is, this does not work. Say anything like that in your homework if it's not. I'm just talking about how it works. We're talking about concepts. We're not talking about the homework. Okay. Okay, so then I know T13 is an int. I know I'm not gonna use T13 anymore. So I can just kind of, I'm kind of, this is a garbage collecting just to make some space there. Okay, so type check this whole thing, right? Got all the constraints there. So now I go to the else branch. Just leave it, it's fine. I don't even know how to like turn it off or anything. That thing baffles me. You're gonna accidentally answer it. Never. No, no, I don't, it won't go. All right. Okay, so we have node 14, that's an apply node. So then what do we know about this? So let's say we have, we need T18, 15. This isn't bad handwriting comes back to fighting. Okay, we have T15 here, T18 and T3. So what do we know about these from the apply? T18 returns T3. T18, wait, T18, so T18 is the parameter to the apply function, right? So what do we, so T15 is what? Right, we know it's a function, right? We don't look at this at all. We just know that T15 is a function. How many parameters does this function have? One. One. And what's the first, so the type of that parameter? T18. And what does it return? T3, exactly. Right? I just had a quick question. How is T15, if T15, I'm just gonna add it in. We don't know yet, we haven't looked at it. All we know is we're treating this as, so we know that just by looking at this node, we know exactly how to take this node and apply its types to its children and apply the, not the types, but we can calculate the constraints of its children based on its types, right? So this is what we know. We know that T15 is a function that takes in some type T18 and returns a type T3. That's it. That's all we know. And we just keep doing what we've been doing, right? So we go and then we look at T15, we say, okay, T15 is an array, is an array access. So then we have what? T16 here and T17 here. So what does, so what is the array access? What types, just looking at T15, T16, T17, right? What constraints do we have there on array access? Yeah, T17 is an eight. And what do we know about T16? I just had a one more question about it. In the else part, how have you assumed that it is a function? It can also be an indication operator, right? It can be A of A into A. So that would be like this, right? Stop. Right, so yeah, so whatever we're, so this is an operator, right? So A times B, if we saw AB, that would be the token AB, so yeah. Yeah, it's a little weird way of writing it, right? Which you're probably not used to because you can't really do this in a lot of languages, but there's nothing special, it's just an array of some type, right? That type happens to be a type of function. Okay, perfect, so we have 16 as a array of type T15. So we know what T15 is, right? So we can just replace this with that, right? So nothing changed. So I just took T15 and I plugged it in there. That's fine. Okay, so we looked at 15, so let's look at 16. So what is, what's the type of the value in there? TD. Yeah, so TD. So we know that TD must be equal to type 16. So that means type 16 and type TD, can we make those equal? No? Why not? They're both arrays, right? Yeah, yeah, yeah, yeah. Yeah, so if I just say T11 is equal to T18 goes to T13, right? So this, excuse me like I'm saying, right? T11 is equal to T18 goes to T13. So T11 is a function that takes in type T18 and returns type three, right? So then I can actually just change this right here. I can say TD is an array of, cool. Okay, so we did that. Let me look at T17. What's the type of A? Int. Int, and what's the type of T17? Int. Boom, type checks. Everything's good. So I can get rid of T17. I guess I can leave it out. Okay, so then I go back up and then I look at T18, or I look at node 18. So what's the type of A? Int. So, and then what's, so we know we've used T18 here, right? Here, here, no, that looks bad. And here, so then what constraint do we have here? Yeah, T18's gotta be an integer, right? And so I get to replace, so anywhere I see T18, right? I can replace that with an integer. Yeah, okay. And we've gone all the way through, right? Do we get any type errors? No. So we're done. So we can say that the type of foo is an int. It's a function that takes in an integer, an integer. What's the type of C? Int, the T, the int, getting P3. Yeah, so that's what you really should do, right? You should break it down. You should get rid of as much of these redundant types as possible, right? So you should replace the T11 here with a function. Int, whoops. T11 is int goes to T3, which goes to T3. Is that right? Yeah. So that's the type of C. And then the type of D is, I don't think it goes to T3. Array of goes to T3. And then what is foo return? Just to clarify, does TD mean that it's an array of functions that takes an integer and returns a type T3? Yes. Oh, no, no, no. Sorry. That's kind of the problem. It's an array. I kind of did that. It's kind of tricky as if you do that or don't do that, right? This is kind of signifying that it's a function. But the arrow also signifies it's a function. So this is a function that takes in an integer and turns the type T3. So this is an array of functions. Each element of that array is a function. This is an array of functions. Each function in that array takes one parameter, which is an integer, and returns a type, which we don't specify, but they all have to return that same type. Yeah. So let's say you have like another parameter E and we know that C is a function. And then let's say we had like E applied to C. Would that be a type error because C doesn't have a parameter or would that not be? How do you want to change it? So can you say that again? So like if you had like two functions that you know of, like in this function C has a parameter D array. So let's say you had another parameter E that was given and it was also a function and you applied E to just the variable C, but C did not have a parameter. It would depend. I don't know, you'd have to work it out. So it's hard to say exactly. So it's kind of crazy, right? So foo A is just an integer, B is just an integer, and C is a function that takes in as its first parameter a function and returns a type T3. So C accepts a function of type that takes an integer and returns a C3 and it returns a type T3. And then it also takes in an array of ints to type threes and the whole thing returns some type T3. Does it matter that all those return types in the parameters are T3? It doesn't matter that they're T3. It matters that they're all the same. So you can't have this be T3 and this be T5, right? So that's the constraint actually. So if you saw a call to foo, you can actually type check it to make sure it's valid by checking all the types and making sure all those type T3s were the same. We're not gonna go into that, but. Could it be wrong if we just said that in the third and fourth field of the function, if you just said T3 instead of the whole thing, that would still be right, right? Intuitively. If you said what, Sadian? Instead of writing n gives T3, gives T3, if we just said T3, it would be intuitively right, right? If you just put T3 for this whole thing? Yeah, because the function ultimately returns the T3. I don't know, but this is the type of C. The type of the third parameter of foo is this. Oh, okay, okay. Yeah, so this third parameter, this is where types get crazy, right? This is a function that takes in one parameter. So you can define a function C, C, oh, sorry. Define a function C that takes in some parameter, let's call it bar, and you could return, let's say, bar of 10, whatever. So bar, so what gets passed in is a function that takes in one parameter, that's an integer, and returns some type T3. That means this function C returns some type T3. Okay, okay, let's go any more questions on this or type checking stuff. I think that there's, right in the homework, unless they do it around where they have a function, and then two functions, and then one functions inside of another function without a parameter. So I'm kind of confused if it was just a function without a parameter with that result in an error, or can you somehow do that? You can pass a function, right? That's exactly what's happening here. So this C is a function, right? What gets passed in here is C is a function that takes in something and returns type T3. The thing that it takes in is actually another function. So you just know that when you see that usage, right? So let's say you had something like, kind of run out of variables here. Let's say if you had like X, I don't know, it gets passed Y, and maybe you have Y gets passed to 10. So here you know that Y is a function that takes in one parameter of type integer and returns something. Maybe you can then on context what it is. Here you know that X is a function which takes in a function which takes in a type 10 and returns something. That's what I was asking about. All right, thank you. So let's say C sees the function. Let's say it didn't return T3. Would that still be correct? What do you mean? So C type of C is a function that takes in in T3 and returns the T3. What if that last T3 was something else? Was like a T4, let's say. Or not pertaining to this, like let's say T20, for example, since we ate these T20. Right, so this would be wrong for this example, right? So could that happen? Yeah, it definitely could happen. But for this example, it's wrong because our constraints tell us that whatever C ultimately returns, right? Because here's where that constraint comes in. Because of this branch, C, whatever C returns has to be a type T3. So that has to be the same as whatever this D bracket A passes in, right? So this is where this comes in, is when we take one of those elements of the array, we're left with something that takes in an int and returns a T3. And so no matter which one of these you take, one of them is gonna be a T3. Yeah, this makes sense, right? So yeah. One more question. If in the assignment I have a type error, and there's a different, I mean, do you point us to halve it ahead or just the top? Or hide it at the error and don't go ahead at all? Yeah, once you hit a type error, you're done, right? So then you say these types can never be the same. They're done, yeah. Any other questions on homework? Three? No, just project questions. Just point to project and then a midterm. I just have a very general question. I like general questions. I heard that the projects are not evenly distributed in grades. Like, is that true? Like, because somebody will say that like project one and two are not worth as much as three, four, five. That will probably be the case. They were a lot easier. How would it, have you, is it undecided? Yeah, I'm not 100% decided. They'll probably be worth essentially half, so they'll be together one project, one out of five. That's kind of what I'm talking about. Are you dropping any project? Oh. No, that's a lot of work. Why would I do that? Yeah, that's a lot of work. Yeah, that's a lot of work. Yeah, that's a lot of work. I don't know. I don't know. Yeah, it goes. Is this one of the hardest class and people usually drop and retake? I don't know. I've heard it's hard. Is it the hardest? I don't know. It may be when you take this class. I feel like it's the hardest. Wow. But then it means your other classes are going to be easier, right? I don't know. Don't you pass it, right? You pass the hard one, and that means everything else after that is easy. I hope so. Good. You learn, right? You learn all the skills you need to help you in your remaining classes. Is the, is the final grade going to be on a curve or it will be a half-shoot? It depends on how the grades turn out. I don't know. Thank you. Do we know the average for the mid-term and all that? Yeah, it was 78. The average for the mid-term was 78. I haven't calculated it for everything. I haven't. Are the test cases from Project 3 ever going to be released? Nope. Never ever. Never ever ever. No, because these are reused from here to here, right? So it wouldn't be fair to think about it. That wouldn't be fair to you guys, right? Then next people next year who share those test cases amongst each other becomes easier for them. Screw those future people. Anything else generally? We can talk about Project 4 now. Are the mid-terms going to be equally up? Yeah, exactly. Yeah, they'll be equally weighted. Yeah, yeah. How much percent is the mid-term? It's on the syllabus, man. It is? Yeah, it's 20 percent. Final? Both. Final is 20. So it's like 35 percent. This is all math things that you can do on your own time. Yeah. Whatever the portion of mid-term won't be in mid-term to write. Mid-term will be after mid-term. The portion in mid-term won't be the same Who says? I don't know. Anything up to the day of the mid-term is in scope, so maybe if I feel like people didn't know something from the first mid-term. It's going to be on the final, right? You might as well know it. Are we going to know it then or know it during the final? Are we getting back the mid-term on papers? We could have picked them up now. Or today. Yeah, PSY has them. You just have to make a plan. What about the solutions of the mid-term? Are you going to upload them? I don't know. Yeah. I mean, it should be pretty clear, right? From the grading of what happened or what went wrong. Figure it out. Work together, right? Yeah. It's not the projects. I don't care what you do on the homeworks, right? Your homeworks are just practice for mid-terms. So if you want to cheat or whatever, I don't care, you're just going to fail the mid-term. So. I don't want to hear about it. I don't want to hear about it, obviously. Okay. Any project questions? Have a good look at it. That's a problem. You should start. We have grading questions. You can make an appointment or you can ask the TA when you pick it up. Well, there'd be a chance that maybe we have a project six. Like an extra one. More projects? Maybe you can give us one Yeah, something like the first project. Yeah, I don't know. Just like an option to possibly do it. That would be nice. An extra work for us. Extra credit? There's a lot of stuff already. I don't know if there's any room for extra stuff. I mean, I'll consider it. I won't dismiss it outright, but I don't know that. I was thinking about doing something like that for the homeworks. The greatest to do a project with models. Yeah, because they're harder. That's how it should be. Project four questions? How do you compare it and the difficulties of the last one? It's easier. Less time. Because we give you a lot of the code. You don't have to start stuff from scratch. There's already a structure in place. It's a little bit difficult because you have to understand that structure. That's why you should start early. You're already thinking about the description. What do I have to do? Thinking through the project. Here's what the code that's already there is like. You don't need to get started right away, but you should read it to start thinking about it as soon as possible. Then it's less difficult because you're not building the whole thing from scratch. That's what I'm saying. So, will you be teaching this class again next semester? I don't know that I can say anything. Online about that. If you ask me when we turn off the video. Is this the mic? Yeah, I don't think that works. It's a good microphone. Do we have to find the first and follow-ups of your grammar that you need to make those parse trees? That's a tough question. Possibly. Probably, right? You may need to. How can we verify if we did that right? I know one way is if you made project 3 then you can put it into your program. That is correct. But I don't have that done correctly. You can do it by hand. But can I verify with someone? You could ask me, I guess. I don't know. So, project 4 is related to project 3? It's all related. It's the same class. Of course they're related. Read that and then you can talk to me about it. I'll see you next semester if you're teaching this class again.