Sprint 1 – Tools Setup

At the begining of the year, I spent my time re-familiarizing myself with basic CS tools.

Challenges with Tools

Often times, my make command would break. Thanks to my debbuging experience, I was able to resolve the issue. Here are commands that helped me:

#!/bin/bash

pip install -r requirements.txt
gem install faraday-retry  # This was the most useful
make stop
make clean
make serve-minema
make dev  # Faster than regular make

Quick Breif on How to Setup Tools

Throughout my journey of tools, I learned to setup tools on two operating systems, including Chrome (via Kasm) and Windows.

Kasm

This breif assumes that you have already created a student repo. If you have not, fork the OpenCS Student Repo.

To setup KASM, I ran through the following steps:

1. Create an account in OpenCS Pages.
2. Visit OpenCS Kasm, then login with your credentials.
3. Click either Kali, or Ubuntu. Either will work. Once done, wait for the virtual box to boot up.
4. Open a terminal. This is straightforward in Kali. For Ubuntu, click Application in the top corner, and then press Terminal Emulator.
5. Run the following commands, replacing anything inside the <> symbols with their required value:

#!/bin/bash

mkdir -p <YOUR-USERNAME>
git clone https://github.com/<YOUR-USERNAME>/student.git
./scripts/activate.sh  # Enter your Github info
./scripts/venv.sh
venv

Look at the first command:

mkdir -p <YOUR-USERNAME>

The mkdir command will create a new directory. In Linux, a set of operating systems that includes both Kali and Ubuntu, files and directories are important. You can think of it as a maze. Each of the directories are doors that lead you closer and closer to any given exit. The exits, in this case, are the files. Running mkdir -p <YOUR-USERNAME> will create a directory with the same name as your Github username. This directory is where you will be able to store all of your Github repo’s that are owned by you.

git clone https://github.com/<YOUR-USERNAME>/student.git

The git command handles operations with Github. git clone clones a repository, meaning it brings all the files stored in Github onto your local computer. Now, you can edit your github files, and then commit & sync changes to update on the deployed version!

./scripts/activate_ubuntu.sh

The activate_ubuntu.sh script is used to activate the Ubuntu environment in the WSL. It takes a bare, empty WSL instance and sets it up with the necessary tools and configurations for development.

./scripts/activate.sh

This excecution of the activate.sh begins activation of your github enviornment. One critical thing this does is prompt you for your github username and email. Once it has your github credentials, it configs git to use your username and email. This ensures that you get credit for the commits you make. Additionally, the script also configs your system to automatically update your git username and git email every terminal session, so that your git email and username are always used. It does this by modifying the .bashrc file, a file that is always run every tty/terminal.

./scripts/venv.sh

This execution of venv.sh begins setting up your terminal and operating system enviornments. It installs dependencies for your enviornment.

venv

This command is aliased to source venv/bin/activate. It activates the virtual enviornment. Optional: Run alias venv to explore how this is aliased.

FUN FACT You can use the deactivate command to remove the (venv) in front of your terminal prompt, while still having an activated enviornment. This is especially useful when double (venv)’s occur.

Hacks

Later on, we moved to hacks. My subteam did the following:

• Calculator
• Tic Tac Toe

Calculator was done by many people, and I played a major role in the inital development. Tic Tac Toe was done by me. The code for it was in python, my preffered and “natural” coding language. For this reason, I was instrumental in the development in this game. In the tic tac toe terminal, I added color, and extra functionality.

Closing Thoughts

• This sprint gave me an intro to how the class would be
• The game went well, with collaboration between me and my teammates
• This success set the stage for my later sprints to be completed well

Improvement

I could have improved by:

• Spending more time at home to work
• Establishing better communication with my group
• Working non-coding related skills that are still used in computer science
  • Soft skills
  • Software Dev. Lifecycle
• Doing more to recall my js knowlage from back in the day
• Starting in subteam 2 instad of subteam 1.

Sprint 2 – Lesson Review

Now we’ll look at how I did with lessons, and how I could improve. I’ll keep it to just that.

What Went Well

• We made one of the best lessons out of all of them!
• We communicated and split roles in our subteam
  • I did the vars lesson
  • Krish did the popcorn hacks (with some support from me in terms of the code and file structure)
  • Pranay did the hw (with some support from me in terms of the code and file structure)
• We did a great job helping out those who needed help in our group
• Other groups knew are lesson was great they used parts of it

What Could Have Improved

• While we did the best job out of all groups in terms of establishing convetions (me for Vars, Anish for Funcs), we still weren’t perfect
• We could have taken more inspiration from other groups and incorperated parts of their lessons that we liked into our lesson

What I learned

• On the technical side, I didn’t learn much new stuff, as this was all fundementals
  • My previous coding background had taught me all of this alreday
• On the syntax side, I was refreshed
  • Javascript isn’t my primary langauge, it’s python
  • Before this class, I last worked with js in 5th grade
• On the soft skills side, I learned… A LOT
  • I learned how to present well
  • I learned how to present in groups
  • I learned more how to work effectively with others who have differing backgrounds, setting the stage for my sucsesses in Sprint 3.

My Lesson

Here is a picture of my lesson, and another lesson. Notice how other groups used elements of our lesson in their’s.

This shows another lesson that we inspired:

Notice any of our inspiring?

Sprint 3 – Creating a Game

Our team (lvl6) did an amazing job with our game, and I played a major role in our sucsess. Here are some statistics to show how we did:

Coding & Commit Stats

• 4 out of the 5 top CSSE student commiters were in our group (since the start of the sprint)
  
  The usernames highlighted in yellow are CSSE students not in my level. Green is CSSE students in my level. Blue is me!
• 2 out of the 3 top commiters in OpenCS pages overall (including CSA and CSP) were in our group (since the start of the sprint)
  • Only Mr. Mortenson himself had more commits
• If all of our groups contributions to the game were removed, at total of 0 levels would be operational
• I had the 2nd most commits out of everyone (since the start of the sprint), lagging behind only Mr. Mortenson himself

Ideation Stats

• We were the group that demonstrated the most leadership
• Many other levels, from 1 to 5, asked us for our code to certian ideas so they could implement them in their own levels
• We were the first group to implement these ideas, and following our implementations, other groups took our ideas to implement them in their own levels
  • Audio (later used by lvl1 & lvl4)
  • Creating our own mansionLevel6 markdown file so that we could test our level independenlty from the main group (later used by all levels)
  • Invisible sprites (later used by lvl1 & lvl2)
  • etc.
• We were the only group to implement these ideas
  • Boss fight
  • Custom Collision Detection (not using the game engine)
  • etc.

What did I do to contribute to this amazing performance?

I’ll start with images showing my contribution. Blue means I added the sprite, green means I made significant contribution, yellow means I made medium contribution, and red means I made contribution to whichever part(s) of the game I circled. By created, I mean first implemented in code.

I played a great role in leadership for our team, making charts showing our commits overall and contribution to the team. This motivated team members into contributing more, leading to our amazing commit statistics.

Below are some of the charts I made:

1. First chart ever made (earlier in the dev process)
   
   Notice how some members were commiting very often, while others were lacking contribution to the code of the game.
2. First chart where nobody had more than 50% of commits
   
   Now, thanks to my chart making and constant reminding/pestering of my teammates, those who are commiting too often have started to give other some chance, and those who have commited too little or not at all have upped their game.
3. Final chart
   
   We can see a continuation in the previous pattern.

Analytics

• Rather than showing you in a photo, I’ll show you live
• Let’s visit the OpenCS dashboard
• Note that the count is very much lower than my actual contribution, as it only takes into account repo’s that aren’t forked from another

Overall Reflection of CSSE1

• I got off to a slow start (at least compared to what I was capable of), but I drastically increased as I realized my potential
• I could have improved by…
  • Letting Mr. Mortenson know all of my contributions
  • Spending more time on ideation and planning

How I improved

• On the technical side, I was already very good when I came to this class
• I was also mostly fine with the tools (Kasm, Git, Vscode, etc.), but I did learn some stuff
• I learned the MOST in terms of soft skills such as presenting, and ideation and development processes such as the agile sprint and the software dev. lifecycle (SDLC)

Essentially:

• I thought I wouldn’t learn much in the class, and it would just be a basic introduction to the CS pathway at school.
• I was wrong. There was still more for me to learn.

Sprint 4 – Ideating, Tinkering, OOP

• In this sprint, I showcased my ability to ideate, tinker, and implement OOP principles in a game my team and I created.
• I was responsible for GameLevelFortress, the last level of our game.

Table of Concepts Demonstrated

Each Programming Concept Demonstrated is shown below.

Iteration

This is how I spawn a random number of scythes from 1 to 10. I use a loop, specifically a for loop, to go and spawn multiple scythes.

Conditionals

This is how I implemented custom collision detection for my site custom class. I used a condition that is run to find the figure out whether the site impacted the player.

Nested Conditions

I use nested conditionals here in the update function of my site class. I do this so that I can execute code when two conditions are met, but still also execute some remaining code if only one of them is not. Nested conditionals allow me to handle the more complex condition logic far more easily.

Data Types: Numbers & Strings

I use numbers and strings, two key data types to define sprite data for my player. This allows me to specify many things including the size of the player image, path to the player image, positioning, etc.

Booleans

I use booleans to check if the player is hitting a scythe. This allows me to determine if the game should end, a core functionality of the game.

I use arrays to store game objects like scythes. This allows me to manage and update them efficiently, as well as integrate them into the game engine.

Objects (JSON)

I use JavaScript objects to define data for sprites in my game. In this example, I’ve shown how I define the data for the main player of the game.

Mathematical

I use mathematical operations to track game events like scythe spawns. In this example, I’ve shown how I increment a timer to track when to spawn a new scythe. I use this to control the timing of game events.

String Operations

I use string operations to construct file paths for game assets. In this example, I’ve shown how I concatenate a base path with a specific asset path to create the full path for an image file.

I use boolean expressions to filter game objects and check conditions in my game. In this example, I’ve shown how I use the filter method with boolean conditions to find all player objects in the game environment. This helps with scythe collision detection. It enables the scythe to know which objects it is hitting, not just whether it is hitting something.