September 2022

100DaysOfCode

100 Days of Python, Projects 15-22 #100DaysofCode

Ramen Junkie 0Comment

So, the first set of projects for were all fairly simple.  Basic Text based programs that run in a terminal and run through simple loops.  The Intermediate Section starting on day 15 of the course is were things started to get quite a bit more interesting, though the basic code isn’t really all that complex yet.

There are two main topics covered during the Intermediate portion of the course, creating GUI interfaces with Turtle Graphics, and some introductory data analysis.  These two topics don’t particularly overlap, but both seem to be the primary focus here.  I’m rather enjoying the use of graphics over just terminal applications myself, though int he long run, handling CSV and other data feeds will probably be a lot more useful.

In the interest of brevity, I’m going to split the intermediate section up into a couple of posts.  I expect this to become more common as the projects become more complex and frankly, by the end, each project may even get it’s own post.

Anyway, on with the projects…  As before, all of the code is stored in this GitHub Repository.

Project 15 – The Coffee Machine Project

The actual focus for Day 15 was to set up PyCharm, and get away from using Replit for the code projects.  I’d already been using VS Code half the time anyway, but I switched over to PyCharm on this day.  A few reasons, one, it’s what the course is using, so it’s easier to follow if needed, two, it was easier to import libraries into projects than with VS Code.

The Coffee Machine project is a simple project that takes an order for a coffee, takes some coins, then spits out change and a coffee.  It doesn’t ACTUALLY do any of this physically, but if it did, that would be super impressive, manifesting physical objects with a laptop.

Project 16 – The Coffee Machine Project

Nope, you aren’t reading that wrong, the next day was the same project.  The difference was, Day 16 was also an introduction to Object Oriented Programming.  So for this project the students get some files with pre-made functions in them, and we build the same Coffee machine using these functions in an Object Oriented Programming way.

This was the first time I’ve actually learned something new in this course.  All of my code before has essentially just been “one file”.  The concept of breaking things into files and classes that do specific tasks is pretty neat, and I’ve gotten pretty good at it.  That said, I can also see where it’s still a good idea fo make a judgement of if something should be it’s own class or just be part of the base program.

There was also a brief introduction to using Pretty Tables to display data and Turtle Graphics, though the final program didn’t use any graphics.

Project 17 – Quiz Game Project

Another Object Oriented project, though instead, we make everything this time.  The questions were provided, but they are set up in a way that it’s simple to replace them with new questions from Open Trivia.  This also really helps push how useful it can be to break a program apart like this, across files.  The questions aren’t a class, they are just a dictionary you import, but they can easily be quickly replaced and the same code will run on any set of questions.

Project 18 – Hirst Painting Project

This one was a more in depth and proper look at Turtle Graphics.  Turtle is Python’s built in method for creating graphics and windows.  I’m sure there are probably others out there, but this works pretty well for a simple interface.  

The first practice was making the Turtle do some things, one of which was a pretty neat Spirograph drawer, which I may revisit in the future to make it useful.  Maybe have a pop up for how large or how many spirals to make.

The Hirst Painting project was inspired by the artist Damien Hirst, who apparently once sold some paintings consisting only of regularly placed dots.  The program takes an input image, extracts a color pallet from it, then creates a similar dot based image.  The instructor used a Hirst painting as the input, I opted to use the cover of the CHVRCHES album Every Open Eye.  It’s a pretty neat result.  It’s another that could be made more robust by prompting for an input image, how many colors to extract and how many dots to draw.

Project 19 – Turtle Racing and Etch-A-Sketch

This day was essentially two projects.  One was a simple Etch-A-Sketch style drawing program, that served as an introduction to actually controlling the Turtle with keyboard inputs.  

The second I particularly enjoyed, though it wasn’t a very complex game.  The second was Turtle Racing.  The purpose was to demonstrate how you can reuse classes to manage several variables of the same class type.  It spawns 6 turtles, you guess which will win, then they race across the screen to the finish line.

Now why is this exciting?  Waaaaaay back in the year 2000, I had a semester to kill between Community College and University, so I took a Computer Science 101 course where I learned some C++ programming.  One of the projects for that class, was a Horse Racing game, that is essentially the same concept.   The Horse Racing Game can be found here, and there is even an exe that lets you play it.  https://github.com/RamenJunkie/C_and_CPP_Code_Snippets/tree/main/CPP%20Code/Horse%20Race

Project 20 and 21 – Snake Game

The first multi day project of the course, well, ok, the Coffee Machine was SORT OF Multi Day, but not really.  This project recreates the classic game Snake.  I’m sure it existed before, but it was popularized by being included on Nokia Phones back in the 90s and early 2000s.

You control the snake, eating food to get longer, and avoiding running into the wall or yourself.  I am pretty happy with the result other than the controls feel like they could be a bit more responsive.

One thing I am proud of with the Snake Game though, I noticed in the instructor’s examples, she was constantly missing the food just barely. In her code, the food just randomly spawns. I changed the code a bit so the food always spawns on the same grid the Snake runs on, which makes it way more reliable to pick up. I also added a border, but I’m less satisfied with that because it seems Python renders things a little funny and slightly off center. I suspect that Python Turtle things are drawn from one corner of the coordinates, and not centered on the coordinates.  

Project 22 – Pong

I’m rather proud of this one, so we’ll cap this round of write ups off with it.  the Day 22 project was to recreate Pong, often cited as the “first video game”.  It’s simple, two players each have a paddle on opposite sides of the screen, the ball bounces back and forth, missing the ball grants score to the other player.

This project combines quite a few things leading up to this point from creating custom classes to taking inputs, drawing graphics. Ok, so technically the Snake Game did all of this. My real win here is doing it, entirely on my own, before watching ANY of the class videos for the day. (Ok, I may have watched the intro just to get the scope of the project, sometimes the instructor throws some curve-ball concepts in.)

Now, don’t get me wrong, in most cases, I do the coding on my own, based on what’s presented, but I usually follow along with the class and do each bit as it’s asked.  I also will occasionally “correct” my code to better align with what’s presented, not because I think my methods are wrong, but more because the instructor may later introduce a concept that needs the code to be set up a particular way.

For Pong, I did it all.  I am plenty familiar with how Pong works, I viewed the 2 minute “What we are making” first video to get the scope, then went off on my own.  And it all worked out.  Getting the ball bounce just right was the trickiest part, mostly because I started seriously over thinking the physics of it.

It really helps that I already know how to code, and have a “programmer mindset” on how to step through things.

  • Make a Paddle Class
  • Spawn a Paddle
  • Make the Paddle Move
  • Keep the Paddle within the screen constraints.
  • Spawn a second Paddle
  • Make the second paddle move with different keys
  • Draw the net
  • Make a ball
  • Make the ball move
  • Make the ball bounce withing the screen
  • Make the score board
  • Make the Scoreboard increment when the ball bounces off of left and right
  • Make the ball re-spawn when it hits left or right instead of bounce
  • Make the ball bounce off of a paddle

That’s pretty much it, the steps to making Pong.   Most of them are super easy.  I even added an additional class that would draw a “net” across the center of the screen that wasn’t required (not that anyone is grading this code).

The point was, I did it all, then watched the videos, just to see if there was any better way to do some of the things I had done.  Felt like a pretty cool accomplishment.

100DaysOfCode

100 Days of Python, Projects 1-14 #100DaysofCode

Ramen Junkie 0Comment

I’ve mentioned before about the concept of “always learning”.    One of those thing is coding.  I’d like to think I’m actually pretty good at basic to intermediate level coding, though I am certainly not an expert.  I kind of feel like I am at a point where I would definitely like to “level up” my ability a bit.  So I’ve been working on the Challenge, though a course on Udemy.  Specifically, 100 days of Python, and specifically, this course.

I’ve also been using this as an good excuse to sharpen up my Github skills a bit, so you can follow my progress along in my Github Repository.  I also figure I could talk about about some of my though processes and flow here as well, though some of the projects are very simple, so there may not be a lot to say about them specifically.  Especially since, frankly, I am already beyond the “Beginner Level” of this course.

I thought about making a post for each module, but that’s kind of overkill as well, so instead I’ll just break it up a bit across maybe the skill levels, or whenever I feel like it.

Project 1 – Band Name Generator

This one is pretty basic, and basically, the same sort of thing you see on Facebook trying to steal your information.  I promise I’m not trying to steal your data though.  It takes some simple inputs, the city you were born in, your pet’s name, and outputs them as a combination for a “Band Name”.  You can really put anything you want into these fields and it will just combine them.  Maybe a fun alternative would be to use the letters of the words entered, to pull a different word from a list or something.  

Project 2 – Tip Calculator

This one is mildly more complicated than the Band Name Calculator, but it is still just input fields, but this time, with MATH!  You enter the total bill, how much to tip, how many people ate, and it splits the bill among the various people evenly.  Be sure you order the steak dinner, so your salad eating friends can foot part of the bill for your expensive steak.

Project 3 – Treasure Island Game

I really enjoyed this one, maybe a little TOO much.  The core project is just practice on “if, elif, else” statements.  You build a little “choose your own adventure” game.  Like a very simple Zork Game.  I kind of just kept getting goofier and goofier with the descriptions though.  I guess that’s the “writer” part of my personality or something.

Project 4 – Rock Paper Scissors Game

Pretty straight forward, and mostly a practice for random numbers.  A rock paper scissors game.  One part I like about this game though it that it introduces the idea of using ascii graphics.  I mean, the core idea is simple, but in all the various online coding classes I have done, none have done this sort of thing.  It really helps these little projects feel way less mundane.

Project 5 – Password Generator

More random number practice, this one actually is probably the most actually useful project so far.  You enter how many letters, numbers, and symbols you want for a password and well, it generates it, randomly.  Especially useful because strong passwords are good to have.  Though using a random password, you probably will want a password keeper, and well, most of those include a random password generator.

Project 6 – Escaping the Maze

Project 6 was a little different, since it wasn’t strictly writing pure code, but instead was using a site called Reborg’s World.  https://www.reeborg.ca/index_en.html This site has a few puzzles where you use functions to navigate a little robot through some challenges.  It’s purpose is to help the learner get better at logic puzzles mostly.  It was interesting and I’ve made a note to go back and do the rest of the puzzles at some point.

Project 7 – Hangman Game

Hey, another game.  This one is honestly, pretty full featured, at least for what it’s supposed to be.  It’s still an ASCII based CLI game but it works like Hangman.  Guess the letters, your little man slowly gets hung.  Better save him.

Project 8 – Caesar Cypher

This round is essentially just a sort of “intro to cryptography,” that I feel like may come back around in a later lesson.   This program builds a basic Caesar Cypher.  You enter some text, pick a Cypher, then it just rotates each letter by the number of letters equal to the Cypher number.  It also lets you decode the messages.

Project 9 – Secret Auction

This one was kind of neat, though not overly complicated.  Essentially, you enter your name, place a bit, if there are more people, they do the same, then it announces who the highest bidder is.  My main frustration from this project.  It’s suggested you clear the screen between bidders.   Simple enough.  but it turns out that Python doesn’t really have a built in clear function.  The samples run on the Replit website, and you have to import a special library from Replit.  This doesn’t work in my local VS Code interpreter.  I looked into this, I could write a custom include for it, but it would only work in Windows, or Mac, or Linux, not all three.  Because it’s essentially a command specific to each OS’s respective shells.

Super annoying.

Project 10 – Calculator

This would almost be really cool, if it were actually clickable and not just something you type numbers and operators into.  Still, it’s one of my favorites I think in the end, because it introduces a really interesting and neat concept involving Dictionaries.  Specifically, you have a dictionary

operations = {
    "+": add,
    "-": sub,
    "*": mult,
    "/": div,
}

You can use the key, to assign it’s value to a variable, then call that variable, as the name of a function.  The names inside the dictionary all match the names of functions.  Really slick.  Feels like it reduces code readability quite a lot though.

Project 11 – Blackjack Game

This project was alright to do but it’s a little disappointing because it fakes the cards but just using value.  It doesn’t handle Aces properly, it doesn’t handle splits or anything.   The one mistake I made, that I fixed, originally, I had set it up so the Dealer would always “Hit” of it was below the player score.  Except the dealer wouldn’t know what cards the Player had to know the player score.

Also there is not actual betting, which could make things more interesting I suppose.

Project 12 – Number Guesser

This one almost feels a bit like a filler project, since it’s a pretty straight forward if else level project.  I will also add that the hard mode gives you 5 guesses, which feels extremely low.  The logical method is halving things, so 100 -> 50 -> 25 -> 12 -> 6, so you essentially have a 1/6 chance of getting the answer.\

Project 13 – Debugging

No actual projects on day 13, so maybe it’s not actually “100 Projects in 100 days”. except several of the days have what are two to three projects, so I am sure it makes it up somewhere.   Day 13 was revisiting 3 old projects, using different methods of debugging the code provided.

Project 14 – Higher Lower Game

This game was presented as if it’s super commonly know but I had never heard of it.  It’s almost a variation of the whole Facemash/Hot or Not Idea, but with less focus on looks.  Int he example shown from the web, it uses number of Google Results for a topic, in this version it uses number of Instagram Followers.   The user is presented with two celebrities, and they have to guess which has more Instagram Followers.

It’s all pulled from pre built data, so it’s not current follower counts.   I could see this making a return when the course gets into the Web Scraping portions.

And that’s the end of the “Beginner Section”.  The course has several sections, Beginner, Intermediate, Intermediate +, some Web training, Advanced, and Professional. Most of what I’ve done so far is not really anything new.  i could have worked most of these out.  I’ve actually been spicing them up a bit with my own bits to make things more robust, like most of the inputs have some level of input check to ake sure it’s value.  Like is it a number, or did the user enter “t” or “T” or “True” or “true”.

I’m more looking forward to the next sections as it gets into GUI style training.

Micro Blog

Day 001/100 Replit 100 Days of Code

Ramen Junkie 0Comment

Hello to the world of coding and my very first project! Day 1 of #Replit100DaysOfCode. Join me on @Replit https://join.replit.com/python

Coding

Git Gud at Git

Ramen Junkie 0Comment

Something that I’ve have tried and fail to quite get a hang of is how to use Git, and more specifically, GitHub. I’ve had a GitHub account for a good while, and at one point I “had” a ton of repositories because instead of simply following something, I would fork it to make a copy of it.  I feel like that’s not quite the proper way to go about using things.  At some point I went through and removed all of these forks and was left with only my code projects.  

I still wanted to get a better feel for the proper flow, which I probably still don’t have, and won’t really ever get until I (if ever) have the chance to actually work with a team using Git.  Most of my projects are just single upload drops.  Almost everything I do I just revise and edit locally until it works, then if I want to “show it off” I scrub out any static IPs, usernames, and passwords, and upload it to a repository.  I suppose there really isn’t anything inherently wrong with this method.  I have, more recently been pushing myself to use Visual Studio Code (VSCode) lately and a few other code apps, and thus I’ve been pushing some repositories with those various program’s interfaces.  

I did get to go through the proper, Fork, Branch, Edit, Push process a few times while doing some lessons through Twilioquest, and a follow up afterwards.  

Still, I think my main take away is… it doesn’t really matter how the code gets there.   Especially for single person projects.  I don’t really have any overall “goal” here.  It feels like the common goal is to try to get a programming job, but I am not really sure I would want that, at least not anytime soon.  I mostly just want to show off some mediocre code to the nobody who would look at it.  

Speaking of “showing off”, I also found that the little games I had made last year with Microsoft’s MakeCode Arcade are all browser based, so I set up a little page to specifically show off Code Projects.  Right now, it’s all just MakeCode games, but I plan to add more if it seems like a good idea.

Another motivator for this push to tidy up my GitHub is it’s an excuse to practice using Markdown more.  Like Git, it feels like a skill I should have practiced more much sooner than now.  The main page for each repository is just a specific Markdown file, so having more repositories means I can make many pages of different types.  I’ve also started using Markdown to draft out blog posts as well as for my archive of old writings.

So anyway, if you want to see some random bits of code, some from 20+ years ago, feel free to poke around my growing pile of repositories.   Actual Repositories, where I did some level of work on them.

Lastly, this whole post is annoying full of things I wanted to blog about but have not.  Markdown, MakeCode, Twilioquest, my huge writing archive, to name a few.