Assignment 1 Blog:
My Ups and Downs as well as my future work.
Ups: Improvement in problem-solving and communication.
Ups: As a senior, I improved in the programming languages like Java, Python, C++, HTML, CSS, and Javascript.
Downs: Sometimes having an intense workload and not staying focused when doing work in a loud room.
Downs: There are times when I feel stressed and high-pressure. Mostly because of the deadlines for projects and assignments.
My Future Work: I would like to be a software engineer because it is a good future job, the software engineering field is growing each year, and it is one of the most important technology jobs in the future. I also enjoy solving complex problems and the job is high in salary.
Assignment 2 Blog:
Development and Communication Issues
When I first started on Assignment 2, I faced a few challenges related to setting up and managing Git, working with linked lists in Java, and collaborating on the project using Git.
The Development Issues that I had before starting on Assignment 2:
Version Control Setup: At first, I had trouble setting up Git on my computer and connecting it with the remote repository. I also had to make sure the .gitignore file was set up correctly. After some trial and error, I fixed the problem by checking the Git documentation and adjusting my Git settings.
Handling Linked Lists: Implementing a singly linked list and then turning it into a doubly linked list was tricky. I had to carefully manage the prev and next references in the SeLinkList class to make sure the list worked properly when adding or removing nodes.
Reverting Files with Git: Recovering the Player.java file using only Git commands without manually copying the file was a big learning experience. Using the git revert command was key for this task, and I had to understand how to go through the commit history to bring the file back.
The Solutions:
Version Control: To fix syncing problems with my repository, I checked the Git remote settings with git remote -v and made sure the .gitinore file was correctly set up. This stopped unnecessary files from being tracked.
Debugging Linked Lists: I used print statements and debugging tools to follow how the linked list worked. This helped me make sure the nodes were added, removed, and linked properly during different operations.
Git Recovery: I used Git commands like git checkout and git revert to recover the deleted Player.java file without manually copying it. This helped me understand Git’s version control system better and how to handle changes in the commit history.
Responsibilities and Contributions:
In this assignment, I was responsible for setting up Git, writing Java code for the Player and SeLinkList classes, and adding features like adding/removing nodes, initializing the list, and finding the minimum/maximum weights. My main contributions were:
Implementing Linked Lists: I created the singly and doubly linked list structures and made sure the player data was handled correctly.
Managing Git: I kept the repository up to date by regularly committing changes, creating and merging branches, and resolving conflicts.
Debugging and Testing: I tested each function using print statements to make sure methods like addPlayer(), initializeList(), findMaxWeight(), and findMinWeight() worked properly.
The Learning Outcomes:
Better Git Knowledge: After assignment 2, I got much better at using Git, especially with recovering files, managing branches, and merging changes. I now feel more confident using Git for team projects.
Linked List Understanding: Working with both singly and doubly linked lists improved my understanding of how data structures work. I learned how to design and manage dynamic data structures in Java.
Problem-Solving with Debugging: Debugging the linked lists with print statements and breakpoints helped me improve my problem-solving skills. I learned how to break down complex problems and solve them step by step.
Project 1 Blog:
My communication, setup, and development issues:
- Communication was that we had to determine a plan that worked for all of us in our group for when we had the meet. We used MS team meetings to discuss what we got done for the tasks that we needed to complete.
Technical issues, ideas, what is going well or bad:
I was having problems running with Gradle for Project 1 and my group members were having problems too.
The good part was that we organized pretty well for this project 1. We organized a task list on our GitHub General Overview Page. We also organized Project Notes on GitHub for running the build with ./gradlew even though me and my team members were having issues with running with Gradle. Finally, we wrote down the Schedule and Team report to see what tasks were completed on the due date and talked about the Mechanics, Issues, and Solutions that we had in Project 1.
Anything that I used in my Development:
- Through Project 1, I've grown more skillful in using IntelliJ IDEA for testing and using Git commands on my local machine.
Project 2 Blog:
Communication, Setup, and Development Issues:
For Project 2, our team used MS Teams to communicate and work together. While it was helpful, there were some downsides. Too many messages and discussions made it hard to keep things organized. We had two people in charge of communication between teams, which helped, but sometimes information still got slowed down because only one line of communication was used.
Setting up the project went smoothly because we planned ahead and assigned tasks clearly. We used GitHub to manage our code and Wiki for keeping track of documents. However, we faced some challenges when it came to fully understanding the design document, especially when trying to figure out the UML diagrams and how to implement some methods.
The Technical Issues, Ideas, and What Went Well or Bad:
The Things that went well:
GitHub was very useful for managing the project, and it helped everyone stay updated with changes to the code and documents.
Clear task assignments helped avoid confusion, and working asynchronously (at different times) allowed for steady progress.
Testing went well for me, especially working with methods like removeBucket, removeItemFrom Bucket, getBucket, and getBucketsForItem.
The Challenges:
- Working with Team 4’s design for the RubySearch class was tricky because there were some inconsistencies and missing details in the UML diagrams. We needed clarification on some methods and had to deal with extra complexity that wasn’t planned for.
Solutions Used in the Development:
We improved our communication by focusing discussions on specific topics and holding daily check-ins to make sure everyone stayed on track.
To fix the design issues, we worked more closely with Team 4 and made sure any changes to the UML diagram were agreed on before moving forward.
During the development of Project 2 Part B, I wrote and tested methods like removeBucket, removeItemFrom Bucket, getBucket, and getBucketsForItem to make sure they worked correctly.
Project 3 Blog:
Your communication, setup, and development issues:
At first, our team had trouble communicating because we had a large group and didn’t yet have a clear plan for how to stay in touch. After facing a few issues, we set up a better communication system. We decided to use MS Teams for main discussions and updates, and Discord for more focused chats within smaller groups working on specific tasks. This setup made it much easier for everyone to stay organized and work together smoothly.
Technical issues, ideas, what went well or bad:
One of the biggest technical problems we faced was a version mismatch with javafx.media, which slowed us down as we worked to fix compatibility issues. Even with this challenge, our team made good use of a system with organized branches and required code reviews for each pull request. This process helped us keep the code quality high and encouraged teamwork.
Any solution that you used in your development:
We gave each team member clear roles and responsibilities to make our work more organized and ensure everyone was accountable. We also made a detailed Wiki with role descriptions and project guidelines, which helped everyone stay on the same page and served as a useful resource for solving problems, like the JavaFX version mismatch.