Hey everyone!

If you've been following my blog journey, you already know I write about my experiences in our Global Software Development class. For our next project, my team, TypeScript, was given a two-week task that was split into two parts.

Part A required us to write a design for a SearchList, which we would later pass on to another team for implementation. Just like everything else in this class, this was a pretty new experience, but after our first meeting, we laid out the cards on the table and quickly started working on a design that followed the specific rules provided by our professor.

Here’s the Project Description our team came up with:

The goal of the project was to design a highly efficient data structure called SearchList. SearchList is a structure that implements node addition, node removal, or node searching by either name or index. The goal was to support an ordered list with efficient insertions, removals, and searches. We aimed to keep the code simple without using complicated constructs like templates, containers, or other high-level libraries. Our design document provided a clear, easy-to-follow plan for the implementation team to work from.

In Part A, our objective was to provide as many details as possible, including skeleton code, a demo for insertion by name, UML diagrams, and design diagrams so the implementation team would have a clear vision of what we required.
Design Diagram:

UML:

Finally, we created implementation tasks and set some deadlines. Honestly, these deadlines were not met by the other team. They also didn’t reach out for clarification or ask any questions, which made us wonder if our design was just that good—or if the other team didn’t care! LOL

Part B switched things up. We were now responsible for implementing a design created by another team, and this is where the fun really began. We were given a design for a bucket-item data structure. The instructions stated: "The design should allow fast insertion, removal, and querying of both buckets and items."
Besides this, we were provided with a list of tasks and rules to follow.

We kicked off the implementation phase with a team meeting where we carefully reviewed the design requirements and reached out to the design team for clarification. Honestly, it seemed like the team that handed us the design had big ambitions but didn’t fully consider the short timeline. Also, their design included things like a proxy (supposedly for security) that felt overcomplicated for this project.

Despite these challenges, we began by implementing the skeleton code and pushing it to our GitHub so the entire team could track the progress. Afterward, we divided the methods among us and started coding. After several attempts and meetings, we were finally able to implement the design, meeting all the requirements. During our final team meeting, we tested the code via Zoom, did some final touches, and then pushed the project to our GitHub repository.

The last step was sending the project back to the design team. We shared a zip file along with the compiled files and instructions on how to run it. Overall, this was a great experience. It challenged us to collaborate, maintain strong communication, and deal with GitHub and coding challenges.

After merging the final version of the project, it looks like this on GitHub:

It doesn't include any .class files, so anyone who wants to test our project will need to compile the files using javac *.java and run the BucketControllerTest.
See below for the testing results:

See you next time,
Your CyberFriend!