This project was very interesting, because I’d never worked on a project with this many other people. Even in my internship, the projects I worked on included about 10 people total, with about 1 auxiliary team. However in this project, our division had 4 teams, of about 5 people each, and our team leader Hussain did a very good job the first week about meeting with the other leaders thru discord, and setting the design and direction of the teams. Hussain helped us all stay in the loop, talked us through how to run the project, which team was working on which part, and how we could be successful. Week 1 for Atari division was not the strongest, because more was expected of the teams’ preparation for the following implementation week, and the leaders got together and made quick decisions about how to get us back on track so that we weren’t behind. Dan, the division leader, put in a lot of time communicating this week so that we could all catch up and meet expectations/requirements.

For the implementation week, my team became in charge of testing the other teams’ implementation. This was a bit of a struggle because some team’s branches did not have their full commits so when testing the bricks, not all of the bricks were always available. One member of the team would have a different branch than their teams’ branch, for example. Someone our team helped us out by showing us Git Kraken and using the GUI we can see which branch is ahead/behind/working on different parts. This made it a lot easier to pull from various branches and complete our tests. Most of our tests were completed the night before, simply because other teams had completed their methods earlier in the day. Despite working against time, our team still went on a call the night before, and worked out all of our tests. We ran into a few path issues, where sometimes we couldn’t create bricks to test. My VS Code wasn’t compiling and it turned out they weren’t path issues, because after cloning again, it wasn’t recognizing “String”. I had to restart VS Code and troubleshoot with my team to figure this out, and finally they helped me push my tests. We made a new branch to accommodate all the pushing issues we had and our various branches we were pulling from. Our call lasted a couple hours and we had people working on documentation, repo changes, and requirement checking until midnight. Overall, I’m super proud of how well this team comes together to face any challenge, rework when we have to, and deliver the final result. Best team of my academic career thus far because of how well we all get along, communicate, and just show up. It made it easy to learn and get the most out of this class because the team dynamics were to conducive to success.

This was a super interesting project, and I really liked working on my team. The first part of this project, the design phase went very smooth because we had a call where we sat down and made sure everyone was on the same page about how to implement. We talked about whether or not we should store the k value in the linked list, how many classes to have, what environments everyone was using, and finally which part of the document everyone would be responsible for. SearchList was a pretty straightforward design and we only ended up using 2 classes. One class would be the node class and one class would keep track of the list. Part of the reason the design phase was so successful was because everyone had an open mind and listened to others’ ideas when we discussed design decisions. We didn’t argue at all because we were all genuinely curious about each other’s ideas and figuring out which ideas were right for us going forward. The call lasted a little bit long while we discussed, but I’m grateful that everyone one our team made time to get it sorted out and be ready for Wednesday.

The second part got a lot trickier. I think BucketList was a lot more complicated of a project that SearchList, so I think we were unprepared for the amount of work and complexity. For example, our design of SearchList was 2 classes, whereas the design we got from Team 1 was about 6 classes, and utilized inheritance, nested hash tables and linked lists, and generics. All of which we had used at some point of course, but it seemed more complex than we expected. This part of the project was a complete success however, because immediately we started talking to Team 1 about their design, and their ambassador/communicator Thomas was on various Zoom calls and Teams calls with me and other members of my team to explain his team’s design, the reason for the complexity, and how to go about implementing it. He came up with various resources when we needed. Almost every day from Thursday to Wednesday we had a call. They were extremely responsive and helpful. This was especially helpful when my team had realized we wouldn’t have time to implement a design this complicated, because ideally we would have started on Thursday (day after class). Team 1 continued to help us make sure our redesign was following the requirements, and our team met every day to help each other out. Finally, we got a working design based on Team 1’s design, we explained in documents the changes that were made, and we successfully split up the work and everyone made time to complete it.

We learned so much about how helpful communication is, why it’s important to start early, and how to have meaningful meetings so that everyone gets the most out of their time. My team communicated a lot through whatsapp and this contributed a lot to our success.

This assignment was a big review from data structures 1 & 2, both of which seemed easy compared to now, but it still didn’t go as I’d hoped. For this series of tasks, I’ve only been able to complete 5 tasks and I’m not sure if I’m completely doing them correctly. However, with the time I have left I have to continue working on it since it’s too late to ask for an extension. I’m having a compilation error which I think is an issue with the path but I’m unsure.

I’ve gone up to task 7 but I don’t know if I correctly recovered player.java via git commands correctly. I can’t seem to do the git revert command correctly.  I’m using this Git tutorial, and doing git log then finding the commit id and trying to revert to it but I get an error that says it could not commit to the hash. This page on stack overflow says there are conflicts but I’m not sure how that could be since I haven’t edited the class that I deleted.

I learned a lot from this assignment, and I was stuck for too long on understanding this implementation of a linked list, but it helped when someone in the class Teams channel mentioned to think of the seLinkedList class as the node class and the list of players. I believe I’m also stuck on how to populate the data into the linked list class. I think I need to review data structures more, because some of my references to other classes end up in errors. I was right that my earlier issue is a path error and it doesn’t compile. If I had started earlier I would have had more time to understand this issue, which is something I need to keep in mind going forward. I wish this class met more often.

This assignment gave me a bit of trouble. First, with the implementation of RedBlackTree because I have forgotten a lot about data structures. At first, I tried to just write tests without going into the class very much, because I thought it would be easy enough, and I thought I would remember enough. But I wasn’t able to get a lot of the functions/methods to work. It was only a few days before the deadline that I realized how much I had to review about RedBlackTree. The rotations after insertions required me to do many examples before I could understand the concept easily. Then, I had to figure out how to actually code the tests by instantiating the object correctly and adding the nodes. Then, all of a sudden, all my tests had NullPointerException when ran. I had to change the path of the java file to make resolve them.

When my team and I were reviewing the code I only accounted for the time commitment for tests on classes that I already understood. So I was learning and writing the tests at the same time which made it hard to focus on good testing practices.

Secondly, I think overall the time management could have been better on my end by starting earlier, that way it didn’t matter so much whether or not I completely understood the class.

Lastly, committing early and often would have made it easier for me to track my progress with my team. We ran into an issue where we weren’t sure how to handle merge conflicts because I believe only one person was ready to commit. More commits would have solved this problem and we would have been better poised to handle the merge commits.

Something that went really well was our communication. Everyone, aside from one student who dropped the class, almost always responded really fast. We used WhatsApp and I think it was the best choice for us. Personally, it was the best choice for me because it’s the only chat I have on WhatsApp. (I downloaded the app just for this team.) So the team messages weren’t getting lost in my other regular text messages, multiple discord servers, or various classes on Teams and Slack. So ultimately, it was easy for me to keep up with all team notifications. Teams was well suited for announcements and keeping track of/sharing files.

For this assignment, we revisited the Fibonacci sequence and set up our environments. I chose to use VS Code so I could learn simple git actions in VS Code. I had issues connecting to my repo, but I was able to find a lot of resources online. Mostly I used this website by visual studio that was pretty straightforward.

I had become slower with Java since I spent a lot of time in Python over the summer, so it wasn’t as automatic as it used to be. I also had to give a quick look at Linux commands because I personally like doing the git commands in the terminal. I had to remember how to parse the args in main to an int so that I could call the recursive function with the number. Even though it’s a simple assignment, I tried to remember best practices, like naming aptly naming the function “calculate”, because that’s what it was doing. Finally, I was able to add, commit, and push my code.

My hopes for this class are high because I’ve never heard of this class before. I’m excited to learn something different but relevant. In interviews I want to be able to talk about the ideas of globally distributed software development and what working in a team means for the modern world. Of course, I fully expect to learn a lot at my first job after graduation, but I consider myself lucky to have the opportunity to gain foundational knowledge.

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.