# **Project 2 Blog Post:**

:::info
# Project 2 Information:
Similar to the previous project, this project is also split up into 2 parts:

### Part A:
For the first portion of the this project, we were tasked on creating documentation for the Bucket Class. In short, a Bucket is a datastructure that holds Item Nodes. There can be multiple buckets and each bucket can hold multiple nodes. However, the key thing is that we are not allowed to use Arrays, ArrayLists, or anything extra that isn't plain java (no imports).


### Part B:
For the second portion of the project, we pass our documentation off to another group, while we receive another group's documentation. We then try to implement that documentation. The challenging aspect of this will be the fact that obviously the other group's documentation will not be perfect. Thus, we will have to most likely remain in constant back and forth contact so that we can implement their project smoothly.

Sample output of our implementation:
:::

:::danger
# Problems during Part A:
Since this was our second project, we didn't face any problems with the Group Dynamics since we were all familiar with eachother and each of us had a sense of our role in the Group. Since part A didn't involve any coding, our only "problems" arose when we were trying to figure out how to implement our ideas without the use of Arrays, Sets, etc.
:::

:::danger
### Problem #1:
Since we were only allowed to use plain Java, we had a really difficult time getting started. We kept on trying to think of a custom Array implementation, however, that would also require the use of an Array. The first 25-30 mins of our meeting consisted of us being stumped on how to go about this.

:::success
### Solution #1:
As a group, we ended up implementing a doubly linked list for our Buckets. This would allow for quick and easy addition and removal of Buckets. Furthermore, since the ordering of the Buckets themselves didn't matter, we added each new Bucket as the head which would speed up the process much faster.
:::

:::danger
### Problem #2:
In addition to the Buckets themselves, we also had to add Item Nodes within those buckets. However, we also had to have quick and easy access to check whether not a Bucket contains a node.

:::success
### Solution #2:
Once again, for the list of items nodes in a Bucket, we implemented another DoublyLinked List. However, checking to see whether or not a node exists would be quite slow if we had to traverse each node and check to see if it exists. We then had the idea to have a String instance variable called items. Everytime we inserted an item into the Bucket, we would append the name of the node + "," to that Bucket's items variable. This would be a game changer because if we wanted to check if a node exists in the Bucket, we could just call the String's contains() function.
:::

:::danger
# Problems during the Part B:
Overall, part B went pretty smoothly as we met to assign different tasks (methods) and then individually worked on our methods for a couple of days. We then got together and ensured everything worked as needed and merged into main.
:::

:::danger
### Problem #1:
One of the bigger problems we initally faced was ensuring that we were all on the same page regarding the design team's documentation. The document had certain aspects that we weren't sure about.

:::success
### Solution #1:
We realized that the only way we can clarify any issues or misconceptions would be by directly contacting the design team and asking to further elborate on some of these specifications. We reached out to them and they were pretty quick to respond and we were able to get it done.
:::

:::danger
### Problem #2:
In terms of implementation, we ended up having a bit of trouble getting on the same page regarding the other team's design. However, it was essential that we remain on the same page because the success of a method being worked on by member X depended on the success of a method being worked on by member Y since it was being called.
:::success
### Solution #2:
In order to ensure that we all get to the same page, we had a large number of meetings which allowed us to get certain members up to speed on things that they may have missed during other meetings. Furthermore, we also had meetings where our group worked together to help another member debug their assigned method. We ended up having a lot more meetings than anticipated, yet it was still very nice to know that the group was there for eachother.
:::

:::info
# Project 2 Debrief:
Overall, this was a pretty fun project as it really simulated the process of working with other teams that you are not familiar with and may not always agree with. This project really emphasized the importance of communication as well since it would have impossible to implement the remote team's design without communicating and clarifying what was missing.

I really enjoyed this project compared to the previous one because the entire group was forced to come out of their comfort zone and communicate with other groups which wasn't always the best experience.
:::