CST 499 - Week 10

 This week, I worked on implementing the display for the event page. You can now view events on an "events home page" with small previews for active and past events and the option to view all events of your chosen type. I also started the code for tracking and earning achievements. 

My goal for this week is to implement the remaining code for achievement earning and work on the display and layout for stat tracking. This will also involve changing the way we currently view the profile pages for ourselves and our friends. 

One of our challenges this week has to do with modifying our database tables for ease of use when accessed by our program. Databases is one of my weaker topics, and while I'm comfortable using them, I feel very inadequate when trying to design them. Other than that, most of the challenges I've run into have to do with me being unfamiliar with necessary libraries or functions. Luckily, because of this, I also am learning a lot with regards to Java and Firebase.

CST 499 - Week 9

 This week our team focused mainly on backend implementation. I got approval to use the BGG API and went through the steps for learning how to securely store and use the bearer token. I ended up modifying our service and interface code to use Firebase Functions instead of our original code design and enabling Google Secret Manager to securely handle the token.

 Our next steps will be to wire up the activities for creating an event, finalizing user registration, and being able to view user profiles/past game nights with the relevant information, while also working on the next version of our design.

 My biggest hurdle this week was unrelated to the work. A close family member passed away and I was having a hard time staying focused while driving back and forth out of town. Another challenge was the Google Secret Manager use, since it required a lot of steps to get it working. At this point, it seems we have been able to manage all challenges that have come our way and we will hopefully be able to catch up to our desired pace this week.

CST 438 - Week 8

The five most important takeaways from this course, in my opinion, were
1) The use of GitHub projects. I believe this will come in very handy for future jobs and also personal projects. It gave me a taste of what it is like to coordinate code with a group and resolve potential conflicts.

2) The Agile philosophy. Agile seems to be a trend with how companies organize projects these days and I know that many employers that I've been in contact with so far prefer a candidate with experience in the methodology. Learning the concept of iterations and sprints and how they relate to organizing a project is going to be invaluable for me on the job.

3) Code reviews. So far I've mostly worked on projects solo or with a single partner. Seeing the process of code reviews and how they can be used not only to comment on code functionality, but code design and even documentation is something I'd never really thought about in the past.

4) TDD. While I've always known that testing was an important part of software design, the idea of writing tests before implementation is very interesting to me and I can see how it would lead to better functionality. Any time I've written a test in the past, I've found myself having to refactor code in order to be able to test it in a way that makes the most sense. I think writing the tests first could make my code cleaner and save me a lot of time.

5) React. I have a major interest in web development and knowing React could prove invaluable to me when looking for a job. While I don't find it as intuitive as I found Node.js, I loved figuring out the interactions between the components and seeing how they came to life on screen.

CST 438 - Week 7

This week we learned a bit more about the Plan and Document process versus the Agile process. The Agile process that we're a little more used to involves more flexibility when it comes to the requirements surrounding a project. The timeline is broken up into small iterations or sprints where smaller, working chunks of code are created and delivered. In the Waterfall process, delivery of the complete project happens at the end and the requirements are more rigid. When we develop using the Agile process, feedback is often and expected, which can lead to a lot of re-working code and pivoting to accommodate design changes. When using the Plan and Document style, the planning happens up front and any design changes need to undergo a formal procedure to do so. I can see how there are benefits to both strategies depending on the scale and length of the project, but so far I like the flexibility of the Agile process as it is more in line with the way I naturally approach projects with many parts.

CST 438 - Week 6

 This week we spent time learning about how Google and how they handle the infrastructure for services on such a large scale. One of the solutions involved in managing this problem is by automating what you can. While some automations are simple, like executing a shell script or monitoring machines, automating scheduling becomes more involved and once you have multiple machines with different environments, you must create further strategies to manage processing at that scale. One concept that stood out to me in this chapter is the concept of containers. While I've used Docker for multiple classes now, I wouldn't say I have a firm grasp on the advantages of using it. For example, why couldn't you just provide me with the dependencies I need? In this current project, I've actually gotten a small taste of why having a contained environment would be useful. For example, when designing the CSS for this project, I just messaged my partners to tell them to install bootstrap and react-bootstrap for their projects. I can only imagine how complicated it would get with multiple engineers working on multiple processes that all require their own dependencies.

CST 438 - Week 5

This week was especially interesting to me. I got to learn all about how the different technologies interact to create a finished product. Aside from the Student View Schedule, View Assignments, and View Transcript routes, I was in charge of CSS for my group, so I learned how to install Bootstrap for React and how to implement those elements, which was slightly different than the way I've implemented them in the past. Because I had to implement style changes in a different way than I'm used to, I "accidentally" learned more about how React components work together and have a much better understanding of the different elements. While trying to adjust certain elements, I also learned some more about Javascript states, which is definitely a weak spot in my knowledge. Overall, I really felt that this has been the most beneficial for me from a growth perspective. 

CST 438 - Week 4

 One of the most interesting things I've learned from reading "Software Engineering at Google" comes from this week. I never really thought about the breakdown of how code is reviewed. So far in any group projects I have been a part of, one person sort of 'takes the lead' when it comes to managing pull requests. While I assumed that there would be a more complicated process for this when dealing with a larger team and more complex projects, I didn't realize that there are not only multiple people who review, but that these people are looking at different aspects of the code. For example, one of the people who reviews code is focused on readability and maintainability while another focuses on if the code is suitable for their portion of the codebase. This allows for division of responsibility so that no one person is responsible for checking every aspect of the code.