This project was definitely bigger than the last two projects but it was made easier with having multiple teams working on it. As the projects have gone along, it is obvious that the projects have been building up on creating more and more collaboration between more and more teams. This was a bit daunting at first because I know how difficult communication can become when adding more people. But by establishing a communication system early on really helped in avoiding any major issues. Our division had a division leader and each team had team leaders. This allowed most of the macro decisions to be made between the leaders which would then be communicated to the team. All calls/meetings were also open to any one to attend so I attended all of the big ones and some smaller teams ones that were had. The first week of the project (the design portion) was a bit hectic because we had some communications issues and issues with working on the project at times. This led to my team (Team 6) to take a bit of an initiative in creating and communicating what deliverables we needed and creating the UML designs and trying to get the rest of our division to work early in completing what we needed. For week 2 we came out swinging and started out with meetings early to make sure everyone was in the same page and that we knew what we were doing. Our team was first delegated the task of implementing the movement controls of the bricks but this was then changed as the division though our team was doing an unfair amount of the work. We ended up being switched to implementing the line clearing behavior.

Personally I helped my team in UML design for the first week. We started it and chose which specific parts of the design we would implement for week two. We had chosen creating the movement for the bricks and we still had the assignment during the first division meeting of the week when we were setting up a timeline and expectations of what we needed to accomplish for this project. It was after the meeting when it was decided by the division that our team had the bulk of the work and we were reassigned to implement the clearing lines behavior. This was not the biggest of issues but it was a bit disappointing that this was not brought up during the meeting. Especially since my team and I had already started working on this implementation and also discussing and creating design documents to implement this. We quickly pivoted and I took the initiative and created a design document for the implementation of clearing the lines in the game and also created a method to detect lines on the game board. My team found this useful though they also used another design document they found online to better understand how the clearing lines behavior should work using visuals. My team was able to implement the behavior fairly well without much issue and we were able to merge it to the rest of the divisions work to get a working game of Tetris quickly and on time before the due date on Wednesday.

For Project 2 I was the Project Manager. I volunteered for this role as a way to gain some experience in the role as this is not something I have ever done before. This proved to be a good experience for me and I feel like I did my role to the best of my ability. My team was very helpful and understanding and worked collaboratively in a manner that gave me confidence in them to complete this project with minimal issue. The first week was the design phase which was done mostly throughout the entirety of our 2 hour zoom call. We created the document and our UML/Design Image that had test cases, examples, and flow charts. I think we did a really good job on this document and I felt very confident in the usefulness of it for the implementation team. Part B of the project was where we did a high amount of work. This was the actual implementation of a design given to us by another group. This is something I had never done before and I’m sure this was the case for most of my team. This made for an interesting experience where we had to go through a design document and create our own plan of attack on how to handle this task. This is different from simply receiving an assignment from a professor which you usually assume to be complete, correct, and easy to understand (or easy to create tasks for). This meant we needed to go through the document as a team to make sure we understood it and seek clarification were we needed it.

Personally, aside from my Project Manager tasks, I was in charge of creating the Node inner class for the SearchList outer class. I also added some variables for the outer class. Creating the inner class was rather simple as this is something I have had recent experience with using it to create Single and Double Linked Lists. I created the node class with getters and setters and also added the specification that it’s string variable cannot accept a string of greater that 32 chars. This was necessary to create the overall SearchList class as it is a Single Linked List with a find() method.

Overall I think this the entire project went fairly smoothly. There were issues throughout the project that arose (as indicated in my Leader Summary in the wiki) but they were not so severe that it halted or completely disrupted our work.

For this project we did all communication and planning through MS Teams. We used a group chat and the Team Page as well to coordinate and see where everyone was in their tests. The most important parts to our overall communication are the weekly meetings through MS Teams group calls and our multitude of tabs on our page such as our wiki and meeting agenda. This makes sure that we are all on the same page and that we can go through the different requirements of the project to make sure everything gets done. Those that cannot attend the call will have everything we talked about in the Team channel. We also regularly talked and asked questions throughout the week so there was no lack of communication.

Actually completing the project was not entirely difficult for me and it seems the rest of the group had very little problems as well. Sitting down and doing the tests were not super difficult. Looking at the included tests from the professor for the LinkedList class helped in seeing what kind of formatting and details was required. I did have a list of assertions for JUnit open in a tab so that I can see what all the assertions were and what they did to make sure I was using the right ones. On that note I will say that the assertThat() assertion that was used in the LinkedListTest class was something that I could not get to work perfectly. Not the biggest of problems since I just used other types of assertions. I had fun creating these tests and creating all the tests that were needed to test the methods was a nice problem to solve. On a personal note creating tests for the methods (for any class or assignments) always has me worried if I am being thorough enough. However I do believe I reached the thoroughness needed for the respective Cyclomatic Complexity of the method.

Everyone was finished with their tests by Tuesday which allowed us to merge everything and test everyone’s tests to make sure they merged and worked well in everyone’s environments.  On Wednesday we did the final merge and wrapped all the necessary parts of the project.

I have no complaints for this project. Everyone in my group completed their tests, communicated when they were done and asked questions when they needed help. Working with Github was easy (especially using Gitkraken) and merging and pulling were quick and easy to do.

A summary of my progression through the different tasks of the assignment.

 

Task 1:

Cloning the repository was simple to do as well as creating a new folder within it to hold the assignments.

.gitignore was created by using gitignore.io

Task 2:

Player class with numPlayers variable war simle and easy to do and test.

Task 3:

Had a bit of trouble creating this because it had been awhile since I had created a linked list but after a refresher I was back up to speed. Created and tested without a problem.

Task 4:

Simple task that had me copy and pasting the code provided.

Using the methods in Player class was also simple.

Task 5:

Simple delete of Player class.

Task 6:

Had trouble doing this recovery because I reverted to an even further back commit than I intended. Took a bit of trial and error to recover the player class correctly in my personal computer and remote. Sorry if the commits at this point were a bit crazy.

Task 7:

creating addPlayer method was fairly simple to do. It was simply implementing adding the nodes to the node list of Player.

Task 8:

This task was not super simple but once I added getters to grab the different variables I was able to add all the player data to the Player node list.

Task 9:

Finding the max weight of the player node list was as simple as walking the list and comparing the different weights.

Had to override toString to create a nice print statement however.

Task 10:

Easy to create a branch.

Task 11:

double link list was easy to refactor. Just had to change around some of the methods.

Task 12:

remove node method was one of the harder methods to implement but I do remember coding similar functionality in another class so I drew on this experience to get it done. Had a harder time renumbering the indices.

Task 13:

Find min weight is very similar to finding max weight.

Task 14:

Combining both min and max methods was not extremely difficult but definitely had to mess around with the loop statements.

Task 15:

Merging the branches was easy to do.

Task 16:

Final Demo war simple to do and was happy to see everything worked.

 

Overall the assignment was fun and a good way to familiarize with using git.

This first assignment was a really nice refresher to coding and a nice way to get to know how to use Git. I had used Git before in a very minor way in a class before so relearning how to use it was nice and revelatory. Definitely going to read the material the professor passed out in class and look up some videos to make sure I completely understand how to use the software. The coding exercise itself was pretty easy and only made a bit difficult because my Java knowledge was a bit rusty. Had to brush up really quick on recursion by looking at some files found on my computer from past classes but I was quickly up to speed.

I’m excited to be coding again and really looking forward to get to learn Git since this definitely seems like something I probably should have more experience with at this point of my coding career. Looking forward to what the projects we’re going to be doing in class and also getting to know who my teammates will be.

Welcome to your new blog.

To get started, simply log in, edit or delete this post and check out all the other options available to you.