Github!

Over these 24 weeks, I’ve had to use a lot of Github. My progression started with commiting directly to Github and editing files there a few years ago (maybe in 8th grade or so), until I realized you could push from an IDE like VSCode. In the summer before high school, I actually learned a few git functions: git pull, git push, git commit, git config, and git log. That’s it. But it did get me from point A to point B.

Then it came to CSSE 2, where I actually had to learn real development. Here, I learned merging, branching, forking, and a bunch of other random stuff I discovered as I went. I can now somewhat proficiently perform merges, PRs, force pushes, resolve merge conflicts, create issues, etc. all from the CLI! Think stuff like git merge, git branch, git fetch, rebase, git reflog, git blame, etc.

I’ve also learned the development process (detailed in one of the pbl documents) and some best practices just from viewing some other projects (viz. the Linux Kernel). This was probably the most I learned from CSSE, actually (+ all the development lifecycles and how to work with other people).

  • Srum Master of Scrum Masters for Platformer4x Development
  • 522 contributions in 2024
  • 228 contributions in 2025
  • 100+ PRs managed
  • Admin for Platformer4x and Platformer4x-LEAAAAM

Platformer….

This was definitely a something. I had to make quite a few contributions while jugglign my role as project manager, but here’s some highlights:

  • Adding music
  • Fixing physics (which had to be reverted because I couldn’t figure out a bug)
  • Adding a boss fight (with its own 3 file for managing attacks and whatnot)
  • Local storage (for time, progress, etc)
  • Fixing people’s merge conflicts
  • Bringing down production 3 times (I totally knew what I was doing with git push --force)
  • Rearranging files everywhere
  • Writing documentation (lessons: Local Storage, Classes & Methods)
  • And some other random QoL changes whenever I thought of them

Although the project didn’t go to well improvement wise, I actually think I learned the most from the development life cycle; that is, handling PRs, managing development teams, etc. This also happened to be my first hands on experience with an entire OOP connected codebase, so that was cool to learn; I expect it’s a LOT harder to familiarlize yourself with some larger codebases (from experience). I’ve also come to a very prominent conclusion: I’m definitely not cut out for managerial rules.

Applying those skills…

I’ve historically not been a large fan of JavaScript, but this was kind of a forced proximity that turned out to be nice. Aside from learning Github, this is the first time I’ve actually put OOP into practice in a connected codebase. Naturally, this inspired me to try a bit more. And so, I developed a couple statically built Jekyll projects:

That’s not too shabby, but there’s one thing I think REALLY got everything going. OOP with JS was a good starting point, until I discovered that Rust does this in its own little, fickle way. Instead of classes and methods, you get structs, impls, mods, enums, traits, etc. But, that first catalyst and stepping stone was JS’s classes, methods, and statics. In fact, I made a lesson on these (requiring me to read the MDN Web Docs) which actually even started my interest in the OOP side of programming.

Lessons

I’ve written a few lessons these last 24 weeks and presented them to the class:

Honestly, I think learning and teaching these topics was probably one of the main drivers for me wanting to continue in this class. I’ve been somewhat familiar with classes and methods with Java, but learning and teaching them really helped me learn the topics, especially static variables.

As for local storage, our group had a rocky start, but we smoothed those out in the end. Reading the MDN Web Docs was actually quite interesting and even more rewarding to put into practice inside the platformer game.

My first change to the platformer game was adding music, which required some classes and methods knowledge but helped me learn the codebase. Learning the codebase and how the classes connected between all the files was pretty cool, and I think it’s helped me now understand some larger, more sophisticated code systems.

Rust?

Do I even need to talk about this. I do everything in Rust now. Everything. See my other blog. I love Rust…