Forem: A

Project 3

Sun, 16 Nov 2025 00:29:50 +0000

We are doing our last project for the quarter.
This project actually looks like a very fun one. We are going to work with other teams as a division to build a Tetris game. We have free range to do whatever we want just as long as we practice GSD principles.

For Part A
We must work with the other teams to establish communication, who are the team leaders and what jobs everyone has. Sadly no one wanted to do anything. My team was the only one very excited to do this project and really try to get the ball rolling to get ahead and finish things early.
It’s very disappointing and disrespectful when other teams do even try. I mean 2 days before the project is due the other 3 teams decided finally who their own team leads are…
My time is very valuable and this type of thing I don’t want any part in …
I did like the idea of doing a fun project like building Tetris. I’ve been wanting to try to code my own Tetris game for a few weeks now, from when I watched the movie called Tetris on apple tv. It’s a true story on how the game was invented in the USSR and how it changed history and copy writes. It’s a very inspiring film.

Tetris - apple tv, Movie trailer

Anyway, Sunday I did finish most of my groups part A. I even tried to establish more communication with other teams to coordinate meetings.

Part B
Our team lead divided the work for the Hold feature between three of us, while the other three handled a separate feature. My responsibility was to implement the visual component of the Hold brick function specifically, ensuring the held brick was correctly displayed on screen.
To test and confirm that my part worked properly, I had to work on the entire section of the project. However, I only submitted my portion to maintain balanced contributions across the team. I completed my section on Saturday, a few days before our team’s due date, and reached out to our team lead for clarification on where to submit the work since the structure differed from previous projects.
My team lead and I ended up having a one-on-one Teams call where I shared my screen, and we walked through the GitHub branching, committing, and pushing process together. Later, one of my teammates messaged me accusing me of causing an issue, but the problem turned out to be a simple typo on the branch name made by someone else. It wasn’t a big deal, easy to fix.
Our team finished our components and pushed everything to the main GitHub branch on Monday. I also saw a discussion in our division chat about updating the app’s appearance. I participated in the conversation and helped explore ideas for a theme. Although I personally didn’t like the final theme choices, I created my own alternative that moves, I chose not to submit it because it felt too late to change anything with the presentation being the next day, and I didn’t want to overstep on anyone else’s work.

I didn’t publish my version of the theme code, even though I do think it offered more flexibility with adding more features later on. My version allowed the game to cycle through multiple backgrounds instead of relying on an if-else structure that only supported two.

Here is my code:

   private int currentBackgroundIndex = 0;

    private final String[] backgrounds = {
        "background.gif", 
        "background2.gif",
        "background3.gif",
        "background4.gif", 
        "background5.gif" 
        };

    private void toggleTheme() {
        if (gamePanel == null) return;

        // Move to the next background
        currentBackgroundIndex = (currentBackgroundIndex + 1) % backgrounds.length;

        String style = String.format(
                "-fx-background-image: url('%s'); " +
                        "-fx-background-repeat: no-repeat; " +
                        "-fx-background-size: cover; " +
                        "-fx-background-position: center center;",
                backgrounds[currentBackgroundIndex]
        );

        gamePanel.getScene().getRoot().setStyle(style);
    }

(scroll to the end to see the images better)

The division's theme picks:

Project3 Reflection summary: “I found this project to be extremely engaging, with many moving parts that required careful coordination. Clear communication was essential to ensure everyone understood the project and next steps. As always, my team did a fantastic job! We collaborated seamlessly, communicated effectively, and supported each other throughout the project. I truly couldn’t have asked for a better group to work with. The division set manageable deadlines for our tasks, and although I was initially nervous when another team requested last-minute changes to the visuals my team and myself have contributed to, everything ultimately worked out smoothly and I think we did a great job overall. “

Full disclosure: This post reflects my personal option and experience/observation, and no one should take it personally or be offended but instead look at it as a learning experience.

Project 2

Sun, 16 Nov 2025 00:17:43 +0000

Part A:
For this part we had to plan the details of a project we want a remote team to do for us.
We made design specifications that descried and instruct what we need one. The ideas we documented included: Project description, Design document, Design diagrams, Implementation details, Pseudocodes along with other smaller details.
This planning phase was somewhat challenging because we wanted to ensure that the documentation was clear and left no room for confusion. My specific contributions included writing the project overview, performing the time complexity analysis, and editing the API and other sections to improve clarity and readability.

Part B:
For this part we were assigned another team’s Part A design and we had to implement it.
This by far was challenging since the concept is remote and limited contact. The documentation we got was beyond disorganize, contradictory and hard to follow. For example the big issues I found was that all the methods were under 1 class making it hard to be organized.

Before starting, our team reviewed all the document and had a Teams Q&A meeting to try to clarify the project and how we plan to divide the work.

I did try to do the whole project on my own for practice and it was interesting to do. This better prepared me to understand the task and just practice my coding skills.

The way we did end up splitting up the document is by putting the methods into different classes so it can be implemented and tested much easier.

I did have an issues again with GitHub. I keep forgetting the commands, such as:

$ git pull origin main
$ git checkout <dev-name-branch> 
$Project 2- Subordinate Role

Another challenge I faced was remembering to reference my teammates' work to ensure my methods aligned with theirs. I also initially had trouble pushing my updated code to the main branch.
After reviewing and resolving merge conflicts, I was able to successfully merge my branch into the main repository.

Despite the bumps along the way, the final project came together beautifully.

Project Demo

Project 2 Reflection summary:
"I think our team did a great job overall. We communicated effectively, set clear deadlines, and divided the work efficiently. The main challenge I faced was understanding exactly what the other group wanted us to do, as some of their documentation seemed a bit contradictory. Another minor difficulty was not having access to all parts of the code since we had split the tasks among team members. Despite these challenges, it was a valuable learning experience and an excellent opportunity to develop our GSD skills."

Full disclosure: This post reflects my personal option and experience/observation, and no one should take it personally or be offended but instead look at it as a learning experience.

Project 1:

Sun, 16 Nov 2025 00:14:57 +0000

Over the last two weeks, we have been working on a group project that simulates how global software development can look like. Most of us are online students so this creates an interesting experience since we never met each other.

The project is divided into two parts, Part A Planning and Part B Unit testing + Reporting. Both phases are essential in a successful project.

Part A:
Create an environment for this project
Investigate and understand the project code
Understand the unit test suite
Planning

Part B:
Writing Unit Tests
Version Controlling
Writing Tasks

At the beginning, communication within the team was almost nonexistent until right before the Part A deadline. We eventually held some Teams calls for planning, but many of us were still unsure about the project requirements and what exactly we were supposed to build. We did have a team lead who assigned additional responsibilities, but the overall the directions still felt unclear.

Personally, I faced several challenges throughout this project. I’m new to GitHub (which I openly mentioned to my team), but despite asking questions, it didn’t always feel like others fully understood the project either at least from what I gathered. The lack of communication and the last minute meetings were very unfamiliar to me and caused me unwanted stress.

In my day-to-day work life, I am typically the team leader, working with different groups regularly. Because of that, I value communication and believe it is essential for effective teamwork, clarity, and confidence. This project felt very different from what I’m used to, and it made the entire experience more difficult than expected. I’m hoping the next two group projects run more smoothly and that this was just a fluke start due to it being our first collaboration project for this course.

Another major challenge I faced involved GitHub. Since I’m a new user, I initially thought I was on the correct branch but I misunderstood what our team lead meant when he said each person needed their own “directory.” I assumed he meant a folder within the working branch, not a separate cloned branch named after each team member. This misunderstanding cost me almost two full days, as I kept thinking the issue was with my code. It didn’t help that other teammates had also created folders in the main(duplicate) branch, which made me believe my approach was correct.

Despite the confusion and frustration, I’m relieved that the project is over and even more relieved that my unit tests worked correctly the entire time.

Project 1 Reflection summary:
"The team did a fantastic job! I’m glad we all worked well together to get everything figured out for a seamless delivery. The challenges I faced with this project was mostly related to navigating github with all the branches and to make sure I had the correct clones and making it work with my local environment. I also had an issue with testing using Gradle, as the configurations didn’t seem to match my current IntelliJ environment setup."

Full disclosure: This post reflects my personal option and experience/observation, and no one should take it personally or be offended but instead look at it as a learning experience.

Github setup flow

Sun, 16 Nov 2025 00:12:09 +0000

10/01/25
These last few weeks we have been learning about github and how to use it.
It is a bit overwhelming since there are so many different choices on how to use it with so many different apps and tools. Here are a few things I found useful to get started on github.

Installation-
Git – deasktop :

$Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
$iwr -useb get.scoop.sh | iex
$scoop install git
$git –version
$git config

Customizing shell display:

"https://ohmyposh.dev/”
“nutshell.sh”

$scoop install nu

Verify the installation:

$git --version

Configure your Git:

$git config --global user.name "Your Name"
$git config --global user.email "Your@email"

The config setup is so useful to track who does what and just to keep things organized in group projects.

How can you see what is in your Staging Area?

$git status

How do you add files to your Staging Area?

$git add #filename# 
$git add.

A very important thing is to always make a ".gitignore" file. This helps keep things private such as:

password/*, API- keys, notes and so on.

Interactive:

$git gui

cli.github.com

Usful apps/ tools to use with github:

git student pack
gitkraken
gitlab
gistpad
draw.io
marp extention
Nushell - shell colors
wezterm - shell colors
gprm or prompt - to help make your git page pretty

Great website resources:
https://learngitbranching.js.org
https://git-scm.com
http://up1.github.io/git-guide/index.html
https://www.freecodecamp.org/news/the-beginners-guide-to-git-github/
https://github.com/UnseenWizzard/git_training
https://github.com/jesseduffield/lazygit
https://github.com/nektos/act
CLI:
https://cli.github.com/manual/
https://www.npmjs.com/package/@githubnext/github-copilot-cli

https://learn.github.com/certifications
To make your git nice: https://repobeats.axiom.co/

System setup

Sun, 16 Nov 2025 00:09:43 +0000

09/15/2025

Recently I had to buy a new laptop due to Windows 10 becoming absolute in October. Of course, with every new laptop it’s a blank canvas for setting everything up again. I had to download all the software I use and will need for all my courses.
For this class I need to have JDK, Maven and Gradle. I ended up downloading apache-maven 3.8.9 version since it is the stable version. I also made sure I had the most up to date Java.
I did encounter some issues with my setup all related to Path environment. I had to make sure MAVEN_HOME and JAVA_HOME was linked with the downloaded version and not referencing an older version. This was such a frustrating process but also a great learning experience.
To make sure I had my setup correct I checked my terminal typing “mvn -v” and of course, I had another issue with warning:
“
WARNING: Use --enable-native-access=ALL-UNNAMED to avoid a warning for callers in this module
WARNING: Restricted methods will be blocked in a future release unless native access is enabled
“
To fix this I did a lot of googling and came up with this:

Set the Variable
Open your System Environment Variables and add:
• Variable name: JAVA_TOOL_OPTIONS
• Variable value: --enable-native-access=ALL-UNNAMED
This tells Java to apply that flag to every JVM process, including Maven.
Restart Your Terminal and run cmd:

echo %JAVA_HOME%
where java
java -version
mvn -v

My setup looks good and then I tested the Maven build with a test-project.
(This prompt will generate a simple Java project in a folder called test-project.)
Cmd:

mvn archetype:generate -DgroupId=com.example.test -DartifactId=test-project -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Access the project

cd test-project

Build the project

mvn clean install

Of course I had another issue:
Maven archetype mismatch with modern JDKs. The default quickstart template I used is trying to compile with Java 5 (source and target set to 5), which is ancient history in Java terms. Java 24 doesn’t support anything below Java 8, hence the compilation failure.

I had to fix the compiler settings in test-project/pom.xml by adding this block:

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.8.1</version>
      <configuration>
        <source>17</source>
        <target>17</target>
      </configuration>
    </plugin>
  </plugins>
</build>
</project>

Then in cmd:

cd test-project
mvn validate

*BUILD SUCESSFUL *

Helpful resources: https://maven.apache.org/install.html

Fibonacci Series

Sun, 16 Nov 2025 00:05:25 +0000

09/12/2025
This weeks homework is to write a program in Java that calculates the n-th sequence of the Fibonacci Series. It should take an integer as the sequance index and return the number (int). It need to be in simple console mode, no GUI or windows. Use F0 = 0, F1 = 1

The questions that pop in my head are:
So, where do we stop with the term sequances: 10, 20, 90?

Do I want to make it interactive with type comands, since it's in console?

I find homework like this frustrating because surly the professor isn't asking so basic and the other thing is if it is basic why didn't the assignment tell how many term sequances.

So, I just ended up doing this and I just hope its good enough.

Welcome

Sun, 16 Nov 2025 00:02:04 +0000

Welcome to my page, where I invite you to join me on an insightful journey through a course I am taking at my university, Practices of Global Software Development. Here, I’ll share my experiences, reflections, and key learnings as I explore the complex and dynamic world of global software development.
I will explore a wide range of topics from understanding strategic issues related to allocation of tasks; communication issues that arise due to distance, time zone differences, infrastructure support, geographical dispersion, and lack of information communication; coordination complexity; cultural issues, technical issues related to information and artifact sharing, and architectural design, and finally knowledge management issues. (As outlines in university course description.)
This page will offer a window into the real-world challenges and opportunities that I encounter throughout the course that have shaped development practices around the world. Whether you’re a fellow student, a development enthusiast, or simply curious about how global development works in practice, come along as I navigate through this course.