Hello, world.

This is CS 50 on Twitch.

My name is Colton Ogden, and this is the third code of you have done with David and Bryan.

Bryan, this is Brian.

Second time being on our code review.

Um, yeah, it was a good time.

Last time we covered a lot of different languages, and this time we'll be doing much of this is good.

It's good to be back.

I'm looking forward to all the submissions that everyone sent in by the Google form and we samples to look at that.

David even dressed up just for this occasion did a very formal code reviews.

I'm taking this one very seriously.

Thanks to a hacker Becker for following just before the stream.

We have a lot of people in the chat.

I say we just cut straight to the first demo that we're gonna look at today, which is actually a really nice one.

So let me go ahead and bring it over to clear strike by Sam Arthur G R s.

So what do we have here called s O.

When I was looking at this, it looked like a seal I version of a game that's very popular in South Asia called Carom or Karama.

Entirely sure how it's pronounced, but it's very similar, actually.

Have it on Wikipedia.

There on the second, Tabby pulled it over.

So there's a picture of the board and folks might build to see it underneath the chat with varying ease.

Sure, we enhance.

Yeah, that's enhance a little too much enhancement way Go eso it's It's very similar to, and I haven't played this myself look too deeply into it.

But it's a version of pool, essentially with what looked like checker pieces, where there's a sort of a Q piece that you get knocking at the very end of the queen piece, so to speak.

And the app that will be looking at is sort of a CLI version of this.

There's kind of an interesting implementation.

Nice.

Well, yeah, if you played this game in the real world, you feel free to chime in, especially to correct anything assumptions were making.

Fortunately, we'll focus on the code itself.

And indeed, in response to one of the questions that was just asked here by I lost track, I have the We have it up there.

Yeah, yeah, Can we make that a little bigger?

Oh, that one.

That one.

So, yes, this is the kind of Cobra view that we've been doing in the streams Would be akin to what you might do with a colleague or a manager in the real world.

That a company often these good reviews that would be done asynchronous late.

So if I get hub or some similar Web based doing things in person is not uncommon.

Shall we dive in?

Yeah.

Sounds good.

All right.

So the depository that some are contributed was last worked on 27 days ago, and I could see that right over here on get help.

Which means this is quite quite fresh off the presses, so to speak.

This coat and I'm seeing a whole bunch of files here.

Just under 10 or so files and folders.

How would you go about wrapping your mind around what to do?

I've never seen a project before, and you want to start with All right.

Well, the first file that started catches my eye is main.

Don't hi often main active entry point for a program that seems like a reasonable place to start looking.

Okay, trying to figure out works, all right, And how would you approach reading a file for the very first time?

That's not part of an assignment, but indeed is a whole project, So first thing would probably take a look at it.

It looks like they're a couple of functions that are defined here, so I might just glance through the file, get a sense for the functions.

We have a function called Load Turns here function called mate Right now, them, I'm guessing it's probably where the game is going to begin.

Main tends to be a common first function that gets called in the program.

We keep scrolling down to find out it was actually the case, this sort of cryptic syntax.

Never seen it before.

The underscore underscore name underscore.

UNDERSCORE equals Maine is Python's way of saying like, If I am running this pipe on file trying to execute it, this is the code that should run, and it looks like it does some initial set up and then down online 89 it actually called.

So this actually inside of this I think Brian has an opinion here.

It does seem like it's perhaps a little bit less conventional to be putting a lot of logic and underscore underscore name equals Maine and then run through a whole bunch of logic and then call the main function.

It seems like a lot of information about initializing the parts are checking the arguments, loading the end.

I do like the commenting.

It helps to make it clear what things going, what sections?

But I would say that probably all of this main function the main function doesn't seem to me that much of a reason to separate the main, Indeed.

And to be clear, let me go ahead and temporarily pretend to edit this file save changes since not actually ours.

If I go and scroll down here.

What Brian is alluding to is very common paradigm that you actually see in a few of CS 50 zone examples whereby you don't actually put much code it all in this block.

Let me just temporarily leave that you would instead just quite simply call.

So for those unfamiliar like, why is there this paradigm?

Because I dare say, in an introductory course like CS 50 this is just atrocious in tax problem.

Does this actually solve Yeah.

So one thing that distinguishes Python from a language like See is that when you execute a C program, the main function is a function that has some.

It's a special function that when you execute the program, the compiler knows that the main function is the first you're not file, but the violin higher.

It's not going to run the main function out of the box.

Maine is just the name of any other function that could be any other name on DSO.

This line down here is supposed to say, All right, when you run the function, we actually want to run.

The main function of the first file and the extra syntax of the underscore underscore name equals underscore.

Underscore Maine is to account for different ways in which we might use a file.

We could just try and run a file but running pipe on main, not pie.

In the you want to run the main function, you could imagine if they're variables air functions to find in a file that we want to use in some other.

We don't want to actually run the main function.

We probably just want to import for the interruption.

Looks like somebody saying the sound is low.

Just want to confirm that.

That's indeed the case.

Some people are saying that it got fixed.

Brian, would you mind saying a few words?

Hey, testing on David, Can you say you think testing, testing, and then 123 So let us know sound is going from loud.

Too low intermittently says methodology.

Yes.

Still happening.

It looks like Thanks.

The Kaiser twitch.

Okay, well, we have somebody is currently working on it.

So apologies for the sound issue.

Hopefully, we'll get that fixed on the adamant in saying Sounds good.

Right now.

Void T thank you very much for the follow here.

Um, folks, anybody who has any issues with sound different let us know so we can see if it's maybe localized or whether it's still going or what the issue might be.

Perhaps so far, so good.

All right, So just to be clear, in most cases, what we could even do if you do want to have a main function, is just literally in the last line of your code.

Just call main itself there by kicking off the whole process of running this file the additional presence of this condition here that Brian is describing really only solves a problem for more sophisticated programs where you indeed might want to import them if you're making a library or python package or module of your own.

But if it helps to keep things in mind more simply, for now, just do this at the end of the file.

But I definitely concurred with Brian's assessment that probably shouldn't have as much logic as was in here.

That's the whole point of having Main is move this into the main function if you if you brought this up already.

But having that if name Eagle's main great for a test cases, Do you mentioned that already?

No, I don't think we can.

Do you mean by test cases, like having If you were to have the test for a module within a model so he could run it and test its correctness, you could have all of those test cases be within main within that module and then run them that way in the file.

In the function within.

If you were to test this module and have a set of test cases that, for example, say this came with a bunch of functions.

You could import it in some as some library.

Or you want to test this module for correctness on its own.

You get execute this module by itself and within its main function would execute a set of test case.

Sure, Yeah, absolutely makes outside.

I think I saw in the Main Root directory the depository.

There is a test directory.

So it looks like this writer may have written some tests for their code as well.

I'm guessing it's probably more like a idiomatic way to do t d d with some other system that is useless.

So just a few quibbles, if I may, in terms of the style of this file.

So I see what we're using single quotes up here, which is perfectly fine and python.

It's slightly easier to type because you don't have to shoulder shifty.

But then I'm seeing double quotes everywhere else, and I'm not seeing a particularly compelling reason to switch in that way.

Down here, we're back to single quotes for some reason.

Down here, we're a double quotes, so to me, this just is a bit sloppy.

It's an easy thing to fix, but it also just presents yourself better, especially if someone is going to read your code or modify your code.

You want to be diligent about things like this even more typically, I'm seeing that this comment here is not capitalized.

This one is.

This one is not so here, too.

There's just sort of a sloppiness that the risk of reading into it too much just just Hey, if you're not even getting the basics right like that, maybe the code itself isn't a strong is that should be.

And I think you want to be putting your best foot forward here, too.

Oh, this looks like this just cominto and that's fine if the project is still in development.

But really in your master branch, the main branch of your depository, everything that's there should be there.

And this should have just been deleted, I think, from that branch and in terms of where else to go.

One of the very first lines here were these imports up here.

Let me go back to the previous view of the screen so that we have a sense of where we're going to go.

It looks like some Arthur was implementing this important some of his own file.

So Karen board dot pipe player dot pie and so forth.

That's a nice module or ization of it seem of the code.

It's not all just in one massive file.

Shall we take a look at, say, um, the main function itself?

Sure, All right.

So I'm seeing here.

That main takes in a few arguments, which is OK, but that's kind of violating the spirit of Maine.

Maine should really be taking command line arguments of anything, but it doesn't need to take that in Python because you could get access to those by assist on RV.

So I would keep this simple and more python IQ and just have a deaf main open print clothes print.

And that's it.

I do see that he's changed commenting styles here, but this is probably a good thing.

Do you mind speaking to this convention?

Yeah, These triple quotation marks that you might have seen before are what's called a doc string in python, and this is often conventional for documenting the behavior of a function or documenting the behavior of a class like a player or Karen border, which we might take a look at later.

And so conventionally underneath main, you'll have triple quotation marks and then a description of what it is that this function does.

And oftentimes, you'll also see this as an opportunity to talk about what the types of the arguments should be, what the return type of the function is if the function is returning something and just helps to document the behavior of the function, and then a whole bunch of tools that have the ability to actually read that Doc string and use the doc String in order to inform someone who's using the function, how it is that the function actually works.

Let me go ahead and go back to the editable version just so we can make some tweaks as we go.

The no tweaks necessary.

They're kind of oddly python.

Does its dock string sort of Underneath the function signature, we're asking a language like Java, it would be placed above the function.

Yeah, I can see the motivation because it means when you're parsing the function, the doctoring is actually part of the function and not just randomly a pendant above it, but it feels a little weird given these conventions to here and just be a little neater.

Give me some white space before your next comment so I could just understand that this is relating to the code below.

It not just commented out or something like that.

I would like a little more detail here.

You do say that this is initial coin details for the carom board and frankly, finding more about the game itself.

This might go without saying, but why nine?

Why one?

I would elaborate, at least for the reader, just so that we're not questioning the design decision down the road.

Here's pretty reasonable, I think initializing two players using the constructor function here, the player such and such.

Strictly speaking, I'm not sure you gain much by declaring player one and play.

You're too, unless, Yeah, I'm not even seeing those variables used elsewhere.

So I would honestly probably just simplify this and let me go ahead and grab this.

Personally, I would probably do this passing in player, one name and player to name just so as to not add variables unnecessarily.