Sprint 2 Retrospective

Hello and welcome back to my blog. 


This is the second and last sprint retrospective blog post for my computer science class CS-448. For this sprint, our group needed to continue working on the epics created by the professor. The tasks included updating JavaScript code to modern JavaScript, converting all Docker images to multi-architecture images, and writing tests for the backend of the InventorySystem. I worked on these issues in the CheckInventoryFrontend and in the Inventory Backend. 



To update the JavaScript to modern JavaScript, I had to replace “var” with “let” and use “const” whenever possible. This required me to research how JavaScript’s “var,” “let,” and “const” work.


  • Issue #1: Update JavaScript to modern JavaScript

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkinventoryfrontend/-/merge_requests/12

For this issue, I checked every JavaScript file and added “use strict” to the beginning of them as well as checking if there were any “var” variables.



Converting all Docker images to multi-architecture images basically means adding support for macOS machines using the M1 or M2 CPUs since docker images built on Intel/AMD systems cannot run on ARM architectures.


  • Issue #2: Convert all Docker images to multi-architecture images

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/backend/-/merge_requests/22

For this issue, I modified commands/build.sh and .gitlab-ci.yml to support ARM architectures.



Writing an “add inventory” test for the backend was a challenge because it involved a long process of first creating a manual test, and then converting that manual test into Chai. Writing the manual tests were quite simple since I just needed to look at the example in the openapi.yaml file and write the test based on the example. However when running the test, lots of errors kept showing up and resolving them took most of the sprint. By the end of the sprint, a Chai test was written, but it failed because of a connection error.


  • Issue #3: Create addInventory Test

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/backend/-/merge_requests/24

I created the manual test, fixed the issues in inventory,js and mount-endpoints.js, and wrote the Chai test.



What Worked Well?

I think communication between team members this sprint went better than the last sprint. All of the issues were very similar such as updating the JavaScript were basically the same for all the frontends and backend. The backend had a little more JavaScript, and the frontends pitched in to help look through the backend to see what JavaScript needed to be updated.


What didn’t work well?

Everyone branching off and writing their own tests for the backend seemed to be a mistake since everyone ran into the same issues at different times. When one person was stuck trying to solve their issue, the next person would run into that same issue. Essentially, the team kept running into the same issues one after another.


Changes that could be made to improve as a team?

For the testing, once one of us solved the errors, we should have communicated to the others who were also writing tests to fix the issue for them as well. Also, since the testing step was so difficult, the team could have started to work on one test at a time instead of each doing our own tests. This way, we would have three brains working together which would have been more efficient than everyone writing their own test.


Changes could be made to improve as an individual?

In this sprint, I found myself to be less efficient outside of class time due to other classes and life obligations. I did work for this class outside of class about 3-4 times total, which was less than in the first sprint. This is a time management problem, and I should plan ahead and work more diligently to avoid this in the future.


Comments

Post a Comment

Popular posts from this blog

UML Diagrams

Hello everyone and welcome back to another week of my blog. This week I will be talking about UML diagrams. UML stands for Unified Modeling Language and it is used to model business, application structures, programming languages, analysis, design, and implementation of software-based systems. In other words, it is a way to visually represent the design and implementation of complex software. There can be many lines of codes in your software and it can be difficult to keep track of all the class relationships and hierarchies. UML diagrams can make it easier for developers to see the relationships and hierarchies. UML diagrams can work for many different programming languages. It is a standardized modeling language that any language can incorporate into the language of their choosing. There are two different types of UML diagrams. The two different types are structural and behavioral. Structural UML diagrams show how a system is structured. They show how classes and object components wor...
Read more

Expose Your Ignorance

Hello and welcome back to my blog. After presenting what we did in this capstone class, the apprenticeship pattern “Expose Your Ignorance” was brought up and I wanted to check out what this pattern was. The pattern "Expose Your Ignorance" in "Apprenticeship Patterns" by Dave Hoover encourages apprentices to embrace their ignorance and actively seek opportunities for learning and growth. Rather than hiding gaps in knowledge or pretending to know everything, the apprenticeship pattern suggests acknowledging what you don't know and being open about it. Embrace the lack of knowledge and use it as a stepping stone for learning. “Expose Your Ignorance” is about normalizing the learning process. It is about showing your willingness to learn, and acknowledging that the only way to fill gaps in your knowledge is to first admit that these gaps exist. I can use this pattern in many scenarios, such as during team meetings. Instead of pretending to understand a concept, I sh...
Read more

YAGNI.

Hello and welcome back to my blog! In this blog, I want to discuss YAGNI, which stands for "Ya ain't gonna need it" or "You aren't gonna need it." My professor for CS-343 briefly mentioned it in class one day and I wanted to go over it more in depth. In the past, I've done something in my projects where I should have followed the concept of YAGNI instead. I made several methods to change a variable before I actually made the main methods of what that variable would do. In the end, it turns out the methods I made were useless toward my goal and I lost a lot of time. I hope to start applying the concept of YAGNI to my future programming in order to not waste time. YAGNI is a really important concept in programming. Basically it means programmers and developers should only implement classes, methods, or whatever things they need only when they need them. By doing this, you can avoid doing unnecessary work and save a lot of time. When you think ahead and try...
Read more