This sprint pushed us out of the setup phase and into the real struggles of implemenation. Our focus was on certificate configuration, domain integration, and establishing a stable server environment capable of supporting frontend and backend communication through Docker Compose. We encountered technical challenges that required a lot of trial and error, especially with NGINX, RabbitMQ, and SSL certs, but we made real progress and learned a lot along the way.

Key Work Accomplished:

• SSL Certificates: After experimenting with self-signed certs, we shifted direction and enabled Let’s Encrypt with Certbot. I verified auto-renewal functionality using a dry run, ensuring long-term reliability.
• Domain & NGINX Setup: Switching from IP to domain access opened the door for proper HTTPS handling and better routing. We spent time researching NGINX as a reverse proxy and adjusted our configuration to support this change.
• RabbitMQ Troubleshooting: I spent time debugging why connection.createChannel in messageBroker.js fails during Docker Compose builds. The issue appears tied to the container configuration or startup timing, which I plan to isolate in the next sprint.
• Documentation: Added notes and resources for Docker Compose Watch (for future CI/CD use) and contributed to team documentation related to server setup and troubleshooting steps.

This sprint tested our patience and problem-solving skills. Even when progress felt slow, I stayed focused on learning and finding answers. I also made it a point to keep the energy positive in the team, especially when the same problem stretched across multiple weeks. I think maintaining that morale helped keep us all engaged and moving forward. One area I’d like to improve is how I manage my research time. It’s easy to get stuck digging through forums or chasing edge cases, so next sprint I want to be more intentional about how I explore solutions and when to pivot. I also want to get better at helping guide conversations to a technical conclusion more efficiently during group work. My top priority going forward will be testing subsystems and verifying proper communication across containers. I also want to finalize our server hosting and make sure the front end is accessible through the domain without errors. Overall, I’m proud of our persistence. This sprint was about learning and solving problems within the systems we’re building.

Apprenticeship Patterns: The Long Road

This sprint reinforced the mindset behind Apprenticeship Pattern: The Long Road—that true growth in software development comes from persistence, patience, and a long-term commitment to learning. While troubleshooting issues like Docker container problems and RabbitMQ errors was frustrating at times, I stayed focused on understanding the root causes. Each challenge became an opportunity to learn. I’ve started recognizing that even slow progress is part of the journey to achieving the goal. This pattern will help me stay motivated and positive, even when things don’t go as expected. Moving forward, I want to manage my time better when diving into technical problems and continue building habits that support my learning and my team. There is still a lot of work to complete for our team, but I think we expect this and we will hit the ground running for the last sprint.

From the blog cameronbaron.wordpress.com by cameronbaron and used with permission of the author. All other rights reserved by the author.

Gitlab Deliverables:

• Issue Board Maintenance => Throughout Sprint #2 I was responsible for creating and tracking tasks within our group. Additionally, I reviewed the syllabus and noticed that we missed a Backlog Refinement session during our first Sprint, so I allocated two dates (one for each remaining Sprint) for Backlog Refinement sessions. I led the discussion in reshaping our scope and adding/removing tasks in accordance to that scope.
  • Link to Issue Board: https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/deployment/gitlab-profile/-/boards
• Secrets/Docker Compose.yaml Research => This task was inspired by a component of Docker Compose I researched very late into our first Sprint. I completed my research and created documentation on this feature once I was able to implement it in a testing docker container. The main goal of implementing this was to securely hide the certificates we’d use (and mention) in our Docker Compose file. Unfortunately, we pivoted away from the self-signed certificate in favor of using domain, which completely discontinued the use of this research
  • Link to Documentation:

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/deployment/documentation/-/blob/main/Documentation/Secrets.md?ref_type=heads

Compared to Sprint #1, Sprint #2 has felt like much more substantial progress has been made. During the beginning of the Sprint, we pivoted our approach from using a self-signed certificate to using a domain to create a secure connection. With this newly acquired domain, we acquired a certificate that allowed us to securely connect to the FrontEnd’s services. I was unfamiliar with the process of applying for the certificate and renewing it at the time, but our team discussed how this would work which helped me learn new aspects of networking. Just before we acquired our domain, I finished my research on Docker Compose Secrets, which at the time I thought would work perfectly with our self-signed approach. Ultimately this work will go unused as we soon ditched the self-signed certificates in favor of using the domain. I decided to keep the documentation, as future teams may need this information for this project or to learn more about Docker Compose. 

Beyond that set of documentation, I would say my most successful contribution to this Sprint was setting up the Reverse Proxy to the FrontEnd service. On the surface the Reverse Proxy was only implemented by using ~3 lines of code however, I spent a couple of hours learning what a Reverse Proxy was and which ports were being occupied by the GuestInfoSystem. Looking back at the time I spent implementing this I wish I made two specific changes to my approach. First, I wish I recorded which ports were being occupied. During my first 30 minutes of testing the reverse proxy, I was able to have a running FrontEnd connected to our domain, at the time I didn’t think this was the desired result so I soon spent another hour or two trying to see what other ports were occupied (and which services they led to). This oversight of not recording port information would not have only saved me time but could have helped provide a visual to the team illustrating what port we would need to access for a specific service. The second change to my process I wish I changed was not creating documentation. Looking back at the time I spent learning what reverse proxies were, I wish I set aside a small list of my findings. Once I had the reverse proxy working, I gave my team a quick walkthrough, but future teams might need this information. To resolve this I plan on adding a section to the Onboarding documentation, which I will write during Sprint #3, discussing the reverse proxy I created and how to find/change it.

I’m continuing to learn and apply the apprenticeship pattern “Be the Worst” from Sprint #1, but I’ve begun to focus on another pattern “Create Feedback Loops”. One thing that I pride our team on is communication among peers and shared knowledge. If we find something new such as a new approach to solving a problem or an interesting bit of research, we do our best to share it when we meet during the beginning of class. By contributing to our group’s wealth of knowledge it creates a feedback loop that not only encourages other team members to find new information but also reinforces what you have learned individually. This apprenticeship pattern encourages the developer to take a metric and see how much of that they, individually, provide to their team when compared to other team members. Our feedback loop helps keep me on my toes, as when I don’t feel like I’ve contributed to our knowledge (or by extension progress), I develop an internal drive to take on something out of my comfort zone. During this Sprint I chose to learn about Reverse Proxies to contribute to this feedback loop. Not only would my findings be applied, but I could then further encourage and enable the work of my peers. 

The last note thing I would like to note is our team’s performance over this Sprint. I have learned a lot by tackling the issue of connecting our FrontEnd service as a group, but moving into Sprint #3 I want to see how more effective I can become in tackling individual issues. During our class meetings, we typically focus on one goal and research it together. I’ve learned that I have a hard time keeping up when new information and approaches are being tested. The best way I can word this struggle is the sense of there being ‘too many cooks in the kitchen’, so moving into Sprint #3 I want to refocus my effort on my personal work. In doing so, I hope I can become a much more effective team member.

-AG

From the blog CS@Worcester – Computer Science Progression by ageorge4756 and used with permission of the author. All other rights reserved by the author.

The second sprint was a time that honestly could have been more productive but it was a time spent learning and preparing our tasks for the final sprint. This is the second sprint and set of work that we completed as a team during this capstone. The first sprint was able to teach us how to effectively and efficiently spread out the work. In our second sprint, we were met with some more speed bumps. In this sprint, the work revolved mainly around modifying endpoints to accept access tokens and modifying the guests from using WSUID to UUID. In addition, this sprint also included adding log messages to the endpoints for rabbitMQ to improve the reporting system. These main tasks were split evenly between 4 of the members while the side task could be handled by one person.

In terms of things working well we were able to work well as a team to divide the work to be efficient in completion. Sean was working on the back end with Hiercine to start on modifying the endpoints to accept access tokens for user roles. This is supposed to allow the system to know who should be accessing certain items. We also had Lynn and Winston working to modify the guests to use UUID instead of WSUID. This is one of our biggest strengths. The strength being our team working abilities and being able to collaborate to make the workflow more effective and efficiently. Next, are the things that didn’t work well. I believe that everything we did was to the best of our abilities. The only things that could be commented on as not working well is our lack of knowledge in certain areas which caused some tasks to not be completed. For example, I was having an issue with the rabbitMQ system.

I believe as a team we are still in a good spot and be able to complete everything that must be done before the end of the semester. I think as a team we can work at continuing to improve communication internally and with the professor when needed.. In addition, I believe when it comes to merge requests we can be more efficient in making sure we verify that everything is working as intended when multiple merges are happening close together. As an individual, I believe I can improve on learning more about the tools so I understand more what is happening so I can make better solutions for the issues at hand such as rabbitMQ. I also believe I can work more at improving how I collaborate within the team.

The pattern I selected was “Rubbing Elbows”, this is the same as last sprint because I felt it still related well to how we work as a team. Even though we all had our own assigned issues, we were able to find commonalities between them allowing us to work together to increase efficiency and find solutions that we would not be able to find on our own. The “Rubbing Elbows” pattern is knowing when to seek collaboration and being able to learn from those you are working with. I don’t think reading this prior to the sprint would change anything since we already were collaborating especially after the last sprint.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfobackend/-/issues/141

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfobackend/-/issues/140

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfobackend/-/issues/142

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem

From the blog CS@Worcester – Giovanni Casiano – Software Development by Giovanni Casiano and used with permission of the author. All other rights reserved by the author.

Configured proxy to handle requests from HTTPS frontend to HTTP backend

Added new date field dropdown and reformatted date

Still working on transitioning from wsuID to UUID

In sprint 2, as a team we worked well with making progress on our large tasks like modifying endpoints to handle tokens and transitioning from wsuID to UUID. Additionally, we looked to eachother for help when we were stuck and didn’t know how to progress further, preventing teammates from falling behind in their tasks. What didn’t work well occurred due to lack of communication, since both of these tasks depended on Section 1 Team 1 working on the login and keycloak token, it created a standstill since the team didn’t know what how the keycloak token was going to be generated and how the roles were going to work. This problem could have been solved by meeting with team 1 and discussing in person of how we can collaborate and help each. Nonetheless, we were able to design our task around stub functions and once team 1 is done with their task, we can substitute it with their changes.

Another improvement for the team that will be implemented in sprint 3 is better code review. We later noticed that some things in regarding the date field was missing, causing problems with the frontend communicating with the backend. More specifically, the frontend was sending back a json file that didn’t match with what the backend was expecting. This caused problems for other teams because they couldn’t run the guestinfosystem.

To improve as an individual, I would like to get better at managing a team. As of now, I see our team and in it we have subsections of people who usually collaborate together. Going forward I want to get more people involved in discussion and overall progress reporting.

One pattern from Apprenticeship Patterns, that aligns with this sprint is “Reflect As You Work”. This pattern emphasizes the importance of regularly stepping back to evaluate your own progress and learning as a developer. Instead of just grinding through code or tasks, it encourages you to actively think about what you’re doing, why you’re doing it, and how you could improve. This kind of reflection helps identify strengths to build on and weaknesses to address, turning everyday work into a learning opportunity. In this sprint, I spent a lot of time reflecting on not only how I was performing, but how the team was performing. Being a scrum master for the first time, I felt it was my responsibility to ensure everyone felt confident taking on their task. I made a conscious effort to check in with each team member during our meetings and encouraged honest feedback for improvement. By reflecting on the team dynamics, I was able to adjust where I needed to spend more time coding and where I needed to offer support. “Reflect As You Work” became a principle that helped me adapt into the role of scrum master, despite being my first time

From the blog CS@Worcester – Computer Science Through a Senior by Winston Luu and used with permission of the author. All other rights reserved by the author.

Throughout the second sprint, we had a great basis to launch from for our project. We made great strides throughout the sprint and diagnosed some important issues barring our progress. Our second sprint was far more difficult than our first, but we remained determined as a team and hit some major goals. I thought we communicated in this sprint far better than before, and overall worked well on major progress blockers. The most important of these issues was an issue connecting the back and front ends and managing certificates for our server. We set fair and manageable goals despite these major issues, which were started or met by all members of the team. We were again very transparent in our communication, and our communication was frequent and on-topic. I spent my time doing three major tasks; setting up persistent data storage for our back-end, researching certificates and helping to set up SSL for the server, and troubleshooting our failing back-end at the end of the sprint.

What I thought didn’t work well in the sprint was the complexity of our issues. While I thought we set manageable and fair goals, they were complex and large. Many goals had to be reworked throughout the sprint, and were met in some capacity. Many issues got pushed to Sprint 3 due to issues we could not solve ourselves. This was a learning moment for me in particular. I would have liked to resolve all our issues on our own, but sometimes outside expertise or another team is needed to resolve an issue. Even if in our case that other team is the IT department, or Professor Wurst. 

As a team I would say that we could better work independently once again. I felt that despite our fair communication, most team work classes resulted in everyone sharing issues. This is something I wanted to avoid, but it happened nonetheless. I would prefer that we work at most in pairs on individual issues, so that major issues do not get sidelined. I felt that my previous retrospective on Sprint 1 should have been vocalized. This is where I think I could improve directly as an individual. I should be more honest in my communication and bring up this flaw sooner, rather than wait for it to improve. Going into Sprint 3 I will be more open and clear about any flaws or issues I see for us all to improve together.

The apprenticeship pattern that best describes my work in this sprint is Retreat into Competence. This fit because the work done throughout the server this Sprint was charting new ground in complex errors. The groundwork we set up in Sprint 1 helped us get our foot in the door, but our SSL certificate issues and back-end connection issues became major roadblocks. I managed these roadblocks by frequently retreating to what I had learned so far, and it allowed me to chip away at the issues and diagnose what to apply to the server.

My tasks:
https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/deployment/gitlab-profile/-/issues/13
This was my first successful task in the sprint. I successfully connected our back-end to a local filesystem in our server and cleaned all our directories of unnecessary files. I tested persistent storage, and it works fluidly.
https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/deployment/gitlab-profile/-/issues/18 

Most of my sprint was again spent working on the issue of SSL certificates for our server. I continued to research self-signed certificates until I decided that the best course of action would be to seek out Professor Wurst for a domain. I also worked out that there were unresolved DNS issues in the certificate that were brought to IT. Since this point we have had no SSL issues, and I have updated back-end URLs to accept https.
https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/deployment/gitlab-profile/-/issues/25
Here I made small progress testing the back-end’s failure before we rolled over to Sprint 3. This is an ongoing issue for Sprint 3 as of this retrospective. During Sprint 2 I made progress in diagnosing the issue of RabbitMQ’s failure, and tested various methods to attempt to resolve it and prevent the back-end from crashing.

From the blog CS@Worcester – WSU CS Blog: Ben Gelineau by Ben Gelineau and used with permission of the author. All other rights reserved by the author.

If there’s one thing I can say happily about this sprint, its that it went seriously better then the last one!

Lately, I’ve been focused on setting up a universal design for many of the applications that are being worked on throughout all of the groups in this class. Examples of which are show below, as well as a link to the specific GitLab issue they’re tied to.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/gitlab-profile/-/issues/20

The first two shown are my initial generalized mock-ups, showing a generalized feel and theme while also showing off some elements like buttons and subtitles that would be commonplace. The last two are the two latest I’ve made, specifically for the user information group, implementing many of the design critiques that other groups and the professor have given me from the initial design.

For me, I found being able to work in an environment I’m comfortable with, that being visual design, helped a ton with my comfort and goal-setting within this sprint. I felt like I was put on-track compared to last sprint, and was able to do significant work. However, that being said, I felt like I was significantly independent and on my own for a majority of it. None of my team members were doing the same as I, and the work I was doing was specifically for the entirety of the class, not just them. So it felt like there was a bit of disconnect there, and could be fixed for next sprint.

I feel as though I did a lot better than I did last sprint, I was a lot more enthusiastic then before, but I do feel I could have communicated a bit better with my team about my new path in this sprint. I felt I left them behind a little bit, especially Jaylon, who was alone in the Frontend development. Next Sprint, I plan on improving on this by trying to split the visual design aspect of my work evenly with work for my team in specific. As for our team, I cannot really comment too much about what we could change as a group, as I feel they’ve been doing fine, I’m just the weakest link they have at the moment.

For a single pattern, I chose Your First Language as found in Chapter 2, which states that you only understand one or two programming languages, but not the ones particularly known for the job at hand. I chose this one as I felt like understanding a lot of the languages being used in our repositories are something I have minimal understanding in, and need to learn better to help my group as best I can. It suggests I toy around with new languages whenever I can, to best help and learn the ones needed. I feel as though this is something I would have already done, given my lack of time to do so, as I find myself having to juggle with work from this course with my others. However, that does not mean I’m willing to give it a shot going forwards.

All in all, I feel like this sprint was a success, and am looking forwards to the next one, which will be our last sprint. Here’s to improving where I can in that one as well!

From the blog CS@Worcester – You're Telling Me A Shrimp Wrote This Code?! by tempurashrimple and used with permission of the author. All other rights reserved by the author.

Hi Debug Ducker here, and wow Sprint 2 came and went really fast. I have a lot to share today as well as realizations about myself and the project. Then afterwards I can say one last goodbye and sprint 3 ends, which is coming sooner than I think.

Now what I been working on these past few months was an inventory culling system that will tell the user whether or not food is past their expiration date by USDA standards. The progress on it as of now it more or less complete. It feels strange to say but we are pretty much at the finish line. This was felt after Sprint 1 were the path forward was decided and could be completed in due time. Which left the group working on the backend to not have a lot to do. Because the solution just needed time and everything would be fine.

After that we were pretty much done and I realize that some task can realistically be completed by two or less people. In a way I felt I wasn’t pulling my own weight. Perhaps I should have tried to be more involved with the process than I was and that could of made me feel that I was doing more. I guess that is the result of some projects that the seemingly big task was rather simple so now you just feel, rather empty about the whole thing.

Fortunately, I was given the task of filling out documentation, which is really important as what if the new people that work in this project need a guide. I and with some direction would be the one to write it all out. Documentation is a lot more important than people give credit, a place that can give you all the details about a project is rather handy when you are working on said project. Which I had something similar when I first started. Now I am working on clean up with another partner of mine, and we may be able to get that done soon too.

Last time I reference the book, “Apprenticeship Patterns”, by Dave Hoover and Adewale Oshineye and there is a pattern that reminds me of this situation. The pattern was emptying the cup similar to accurate self-assessment, the idea here is that if you don’t allow yourself to be willing to learn or do more then you aren’t going to do better. I feel I should have pushed myself to at least see what else could have been done with the project, instead of feeling useless.

Here is my work on the Documentation, I mostly did the readme and fixed up the instructions

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem-culling/documentation

Here is the Backend work so far in collaboration with other group members. The result was full integration with the scanner side of the project which is almost done

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem-culling/inventorybackend

Here is the Scanner portion done by the team focus on it

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem-culling/addbarcodefrontend

Thank you for your time and have a nice day

From the blog CS@Worcester – Debug Duck by debugducker and used with permission of the author. All other rights reserved by the author.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem-weight-based/inventorybackend/-/merge_requests/64
                  Create a local instance of the database in order to have it perpetuate along runs of the backend during development.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem-weight-based/inventorybackend/-/merge_requests/63

                  Create validation in order to avoid negative quantity in inventory.

I also worked directly with one peer to help him resolve some merge conflicts with him Nodemon Implementation issue.

During Sprint 2, I went through some difficulty in getting work done in the correct way. What I mean by this is that I would produce some output to the system without first thinking about how that would affect certain areas, like not considering the physical limits of the system. This led to one of my merge requests this Sprint. The merge request to avoid negative values in the inventory was purely created because I was developing without thinking first. This led me to develop a sense of thinking first and developing second. This helped a lot more during Sprint 2, as I would have a complete and definite idea of what to code even before I sat down and typed it.

What I think did not work so well for me this past Sprint, and I believe was the reason why I produced much less than the first one, was the lack of a due date to deliver something. I have realized during this past month that, in order for me to produce anything myself, I need a due date. If I do not have any due date set to deliver something, I will most likely procrastinate. This is not related to the amount of work I had to do or the length of the Sprint at all. This is something personal, where I should have set due dates for myself in order to produce more and better. This correlates to something I spoke about in my Sprint Blog Post for Sprint 1—the enthusiasm and anxiety of delivering work. This is something that I need to get balanced out, with the use of due dates and time management.

As a team, we entered a really nice spot where we all became close, so working with each other is not an issue at all. During some classes, I would even be worried myself, because sometimes we would be the only group to laugh or have some kind of friendly conversation. Which is great, but we need to be careful that it doesn’t undermine our work. This is also something that I believe could be what is not working so well. Even though this does not happen all the time, some days the chit-chat has slowed us down.

The pattern I chose is called Retreat into Competence. It shows us that sometimes, when we find ourselves with no idea where to go, or find ourselves behind everybody else, or simply lost, we should take a step back, go back to what we know and are comfortable with, and finally launch ourselves forward just like a catapult. Sometimes, in order to take three steps forward, you need to take one back.

Retreat into Competence became a sequence to what I wrote about in the first Sprint. I dove deep, so deep that sometimes I found myself somewhere where I had no idea where to go or how to proceed. I would feel behind compared to my peers. And even without knowing this pattern, it correlates to something I learned from my first programming professor: sometimes all you have to do is retreat, leave the code aside, or go do something else related to it. And honestly, as magical as it may sound, the solution will just come to you. Brainstorming can sometimes happen in a quiet place. If I had read this pattern before, I would have applied it more often. Sometimes, even though I was familiar with such practice, I would still find myself lost.

From the blog CS@Worcester – CS Today by Guilherme Salazar Almeida Nazareth and used with permission of the author. All other rights reserved by the author.

Continuing from my last blog post for my CS-448 class, Sprint 2 has just finished. This Sprint I was assigned the issues of creating the code that mimics what the Guest Info system would handle (https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/reportingsystem/reportingbackend/-/issues/94) in putting guest info into RabbitMQ and the issue to take the data from RabbitMQ and put it into the database (https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/reportingsystem/reportingbackend/-/issues/96).

For what worked well this sprint, we as a team worked well and as we had planned to. On the backend, setting up the queue to put data into RabbitMQ was easy enough to do after reading the documentation on how the queues work which is what I wanted to improve last sprint so that I didn’t feel like I was unaware of how the systems worked. After that we started to set up the code that would take the data from RabbitMQ and put it into the database. The RabbitMQ for this part went as smoothly as the queue did, but when entering the data into the mongo database is where we ran into issues. The location of the data insert was in the dev container and so it was unable to connect to the database which is where I was stuck for most of the sprint. Another problem was that it wasn’t immediately obvious that the database connection was the problem which led me to looking for errors in places that there likely were none.

I think that for the next sprint a way to improve as a team would be two things. One would be to not assume that just because code exists for it, it doesn’t mean that it works in the context you need it to, and the other is that we should be more open to solutions to problems that may include adding entire new functionality that we didn’t specify was needed in planning but is needed to support another integral system. Individually I would want to improve by thinking harder about where my problems are and how they might affect things afterwards. I found that when I do ask questions about a particular hold up, after I solve that part, it leaves me in a place where I don’t have a direction because I didn’t think ahead after the roadblock. I have found that this really slows down my productivity and is overall an inefficient workflow.

This sprint, I think the apprenticeship pattern that is most applicable is the fifth pattern, perpetual learning. This is because this sprint I was learning new things about building a system, like the reporting system for Thea’s Pantry, only when there was an issue I was trying to fix, instead of always taking time to just learn whatever I can to build a base of knowledge that will help me when I come upon issues so I will already know what is going on. I also want to ask around for help from people who may know more about a certain system or function than me, including my group and the other groups.

From the blog CS@Worcester – Computer Science Blog by dzona1 and used with permission of the author. All other rights reserved by the author.

In this post, I’ll be reflecting on our second sprint towards developing and implementing an Identity and Access Management system for Thea’s Pantry. Coming out of Sprint 1, we had a better idea of Keycloak in general, and we had some basic frameworks for a fake frontend and fake backend. Our sprint goal for Sprint 2 was to fully integrate these components, so that we could provide a proof of concept for the entire workflow, as opposed to just one component. We wanted to be able to force authentication on a frontend page via a Keycloak login page, and then we wanted to be able to store the resultant access token from that interaction so that we can perform authenticated actions without ever talking to Keycloak again.

Some of my personal work towards that goal was as follows:

GitLab

• Documenting our low-level issues in GitLab and assigning them accordingly. I put additional focus/effort this sprint into properly linking related issues, blockers, and tracking various key information in comments, as opposed to just using issues as a task list. Epic

Backend

• Refactor the backend endpoint to verify the signature of a JWT to ensure authenticity. Note – this was a great learning experience in better understanding how async and await work in JS. This issue took me way too long to resolve. Squash Commit

• Further briefly modify the endpoint to pull specific custom data out of the generated JWT from Keycloak. Commit

Frontend

• Configure Docker compose files and Git submodules to containerize all three repositories into the fake frontend to test the whole flow. Commit

• Completely facelift/refactor/rework/reimplement the fake frontend to use Vue as a build framework to test our implementation in the same context as it will be used in production. Configure dependency and instantiation of Keycloak in the JS to handle redirect and access token storage and usage. Commits: 1 , 2

Something that worked particularly well this sprint was our focus on increased communication. We refactored our working agreement to address some of our shortcomings in communication and accountability, and I felt like this sprint was better for us around the board. We had a bit more direction this sprint, and we accomplished our goal exactly as we laid it out, barring 2 lines of code that we have to add that are just blocked right now.

That said, – at risk of contradicting myself – I feel like something that did not work as well, and that we can continue to improve, is also our communication. Though it was better this sprint, it still definitely felt at times like we were not a team, and instead like we each had our tasks that we would connect on once or twice a week in class meetings. Maybe this is fine, and to be honest it worked okay for the most part, but I feel like in an ideal world for me, I would have us all being very proactive and communicative about our issues, though I don’t know if this is a fair thing to aim for our team to improve, or if maybe I should reevaluate my expectations.

Something I could improve is my focus on defining roles and responsibilities for the general team dynamic, not just for issues. I felt like I focused on accountability for issues on GitLab, for example, but I also feel like I informally assumed the role of Scrum Master / Sprint Lead for this sprint, though we never really defined or said that. It seemed to work fine for us, but it is something I think I could have specified better, instead of just sort of assuming a leadership role.

The pattern I have chosen for this sprint is The Deep End. This is because one of the issues I spent the most time on during this sprint was implementing JWT signature verification. This should not have been a difficult issue, but I really have never worked with functions in js specifically, and for some reason I was caught in a loop of bad syntax and usage of things like const, async, and await. I had no idea what I was doing, and was so lost as to why my code was not working. It took a lot of reading and being lost for a while before finally realizing my error was not the libraries I was using, but just a lack of understanding regarding js. 

From the blog Mr. Lancer 987's Blog by Mr. Lancer 987 and used with permission of the author. All other rights reserved by the author.