To start, this was my first real team project where I felt like all of the team members were highly capable of putting something of value together. It’s been a great experience to learn and collaborate with such a good group.

We started this project basically from scratch, learning just how difficult that actually is. Over time we worked out our goals and expectations along the way. Through some facet of peer pressure and blind faith I got elected to lead the team, though each member has done something to guide all of us in one way or another. 

This leads to the topic of what worked well with our team. First, we all tried to get to know each other a little better. Aside from having the same major and concentration, a friendly connection has absolutely benefited us when it comes to communicating and holding each other accountable. It also fostered an environment of being able to ask questions and for help when it was needed. It quickly became a good time coming to class and being on time just to see each other and show our work in person. Due to instinct or pure luck, the best move we made was breaking our group up into pairs, otherwise known as pair programming. This allowed us to have 2 people focusing on each aspect of our project making progress in all areas simultaneously. 

For myself, one part I would like us to improve is being more on top of explaining the finer details of what each pair is working on. Being the leader I am seeing the big picture of the project but I do feel at times the others get a little lost in their own portions. During the sprint reviews I think we did a good job showing each other what that meant, but we could certainly get better when it comes to the day to day aspect.

All of this culminates into one of the things that really stuck out to me in the second chapter of the book Apprenticeship Patterns referenced in a previous blog. This chapter was about “emptying the cup”. This phrase is an amazing metaphor for not allowing yourself to think you know too much to be able to learn from others. Too often have I myself fallen victim to my own thinking of already understanding all there is to know about a given subject. Sometimes it’s really beneficial to go into something with a fresh and open mind.

For example, while developing the inventory back-end there were at least 5 times where I had to start completely over. While this sounds like it would be extremely frustrating I was noticing that every time this happened, I was learning something new along the way. After having worked with the guest info back-end I thought I was going to breeze through replicating it. It wasn’t until doing it over and over that I realized just how much I was missing under the surface.

Nearing the deadline I was actually becoming a little worried that it wasn’t going to work out in time. We would have to move it into the next sprint. However due to having so much practice and my partners assistance making a mock version of what i was creating. We were able to very quickly and easily put together a working prototype of the true vision we had. This prototype is also proving to be fundamental to how we continue into the next sprint.

In the end my team came together and had 3 portions of this project ready to demo for the customer and our professor. It all worked exactly how we planned and it was so refreshing to witness. We all did a great job and should feel proud for how far we managed to come in just one month working on this and knowing each other.

Here are all 3 portions

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem-culling/guestinfobackend/-/tree/main/src?ref_type=heads

• This is a 2 for one. 

• The mock database itself was created by me and my pair partner Prince.

• The script to fetch data from an API we are utilizing was done by our teammate Anairdo

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

• This directory is the front end our other teammates have been working on to pair up with our backend. Credit to Adam and Donna

From the blog CS@Worcester – Mike St G – 448 by Michael St. Germain and used with permission of the author. All other rights reserved by the author.

Created a separate branch from the frontend to solve the CORS/SSL issue

Created epics for larger tasks and broke them down

Organized tasks into issue boards

Prepared for Sprint 2 by adding new tasks

Documented important information regarding issues and how they were solved

In sprint 1, we were able to mostly complete everything we planned out; needing some revisions in certain areas. As a team, we performed well with eachother and communicated effectively to ensure all tasks were progressing at a timely manner. 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 ocurred near the end of the sprint, where a teammate didn’t fully complete their task like they were supposed to, requiring one person to complete their task in sprint 2. This problem could have been solved if the team incorporated weekly code reviews to ensure that all areas of the task is looked over and nothing is forgotten. As the scrum master for the team, I plan to push for this element in future meetings.

Another improvement for the team that will be implemented in sprint 2 is better meeting time management. Since we only meet twice a week as a team, we should take this time to share progress we have made to the whole team. This could be any code written or any interesting articles that are useful to know. The primary goal of the capstone is to simulate a real development environment and solve tasks effectively. Equally important, however, is the opportunity to absorb and learn as much as possible. Something your teammates discover may prove valuable to you in your future career.

To improve as an individual, I want to get involved in other peoples tasks and try to offer my input in any way possible. Instead of being preoccupied by my own assigned tasks, widening my scope of work to my teammates tasks will allow me to grow as a developer and expose me to various tasks.

One pattern from Apprenticeship Patterns, that aligns with this sprint is “Confront Your Ignorance”. The pattern emphasizes the importance of recognizing and addressing gaps in your knowledge. Instead of avoiding unfamiliar topics, you should actively seek out challenges that push you to learn. This involves identifying areas where you lack expertise, setting goals to improve, and dedicating time to research, practice, and experiment. By taking on tasks outside your comfort zone, you develop problem-solving skills, adaptability, and a deeper understanding of new concepts. It pushes you to adopt a continuous growth mindset and helps you become a more effective and well-rounded developer. Going into capstone, I knew that I wanted to push myself to learn as much as possible, which is why for the first sprint I chose a task that I had zero prior knowledge about. In order to work on my issue, I had to research about CORS and SSL certificates, both of which are crucial concepts in web security and backend development. This process involved reading documentation, troubleshooting errors, and experimenting with different configurations to understand how they functioned. Choosing this issue to work on has also exposed me to the use of proxies, that route frontend requests to the backend. Utilizing a proxy will ideally allow the http backend url to connect to the https frontend url. In sprint 2, I plan to experiment more with proxies.

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.

After the completion of our first sprint, I believe our team performed very well. There were no issues left in the sprint backlog at the conclusion of the sprint, and, equally important, our understanding of how the Thea’s Pantry reporting system needs to work has grown significantly.

The divide and conquer approach taken worked well for us. Splitting up the issues gave us more flexibility in how we would approach our particular task. For me personally, I was able to do my research and development at a faster pace as opposed to having multiple people working on the same file. On the other hand, our team meetings were extremely useful for getting feedback and help with development issues. Having more sets of eyes to look at a problem often times got issues resolved quickly. The team dynamic in programming and software development, in my experience, is usually a balance between avoiding a “too many cooks in the kitchen” situation and making sure the team is communicating and engaged with each other. I believe our team balanced this reasonably well.

That said, I believe we should work to improve our inter-team communication. Having a good sense of what other members are working on is important if we’re going to continue to divide issue assignments. This is something I should work on specifically too. I want to avoid the habit of staying head-down in my laptop working, and do a better job of communicating on the status of what I’m doing, especially when working on my own.

My main focus for development was writing the code to create a properly-titled .csv report file to be sent and downloaded onto the user machine when the API call is executed. Here are links and descriptions on specific things I accomplished this past sprint:

1. getReport API Endpoint – Developed and tested RestAPI endpoint to retrieve report file.
2. buildReport Function – JavaScript function to build the report itself from RabbitMQ data. Currently, this generates a blank .csv file with the proper title with relevant dates of the report.
3. JSDoc API Documentation – Began setup and use of JSDoc, a markup language for JavaScript to generate developer documentation.
4. JSDoc Deployment Shell Script – Shell script to aid in building documentation files.

From the book Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman by Dave H. Hoover and Adewale Oshineye, the section regarding protecting one’s passion for software craftsmanship stuck out to me. Getting tired or frustrated when writing code is more or less inevitable; being able to separate those feelings from the field as a whole is key. The book mentions the idea of “Drawing Your Own Map”, a strategy for mitigating burnout. The core idea is setting limits for yourself can be as important as setting your goals. One can define the boundaries in which they allow themselves to work within, as even with short-term consequences (the book mentions missed raises and unhappy coworkers as examples), walking The Long Road rewards pace and longevity, not speed. I firmly agree with the statement made by the authors; quality craftsmanship does not come from short, intense periods of work followed by burnout, but by maintaining a steady pace forward across a decades-long career.

From the blog Griffin Butler Computer Science Blog by Griffin Butler and used with permission of the author. All other rights reserved by the author.

Last week, my team completed our first Sprint of the semester and presented our work to our professor and the client. Overall, as a team, we did a great job for having not done or been a part of a Sprint before. Each one of us was assigned an issue at the start of the Sprint to work on over the period. One of these issues was evaluating the frontends, so I reviewed each of them and found that two of them, AddInventory and CheckInventory, did not run properly. It was determined that it was a server/deployment issue, so I contacted a member of that team through private messages. The team was aware of the issue and were working on it, so I suggested to my team that we focus on the backend for this Sprint. However, we decided that it would be better if we try to fix it ourselves instead of waiting. So I was given the CheckInventory frontend. In class, another member was able to get the AddInventory frontend to run, so I asked for their help outside of class, where we determined that the frontend was unfinished. So my task for the next couple of weeks was to fix that, and I did so by comparing it to the AddInventory and CheckoutGuest frontends. I then “borrowed” files that were missing from my frontend, and edited and fixed ones that did exist. This consisted of organizing some files into new folders, copying over frontend-prod-build and frontend-dev-up commands, index.html file, and much more. After I got it to run, I edited it so that it would match the AddInventory frontend. After all of that, I committed, pushed and made a merge request. The pipelined failed with that, due to a yarn lock issue, so I fixed that, linted, and then committed and pushed again. 

What worked really well was communication between the team. I felt that whenever someone had an issue or needed something done, someone answered within the day, which is really good. I think the team chemistry was also really good too, it did not feel too serious but also not too laid back. We also helped each other whenever we could, which is good. On the personal side, what worked well for me was just working in general. Like this whole thing is something that I have not experienced before, so just being part of a team to get work done for someone else kind of gave me fuel to work and make this a good thing. However, something that did not work well for me was the expectation to get enough done. For each week we plan for something to get done, but every time for me, I felt like I did too little or not enough. Maybe it is something in my head, or I am setting the bar too high, but that ghost pressure was not nice. 

There is not a lot that I would say we can improve on as a team, mainly because our communication is good, the atmosphere is great, we help each other and we get things done. What we could do, just as a minor thing, is clarify what we are working on. Although I do not think this is an issue, it has been expressed by members of the team, so this can be a good way of getting some bearings. As an individual, what I can improve on is just getting more done. Although I did finish my part of the Sprint by the end of it, it did not feel enough to me, so going forward I want to do more. To go with that, I would like to be more open about what I did do, some of my teammates were not aware of what I did in some of the past weeks, so I would like to improve on.

The Apprenticeship pattern I have chosen that resonates with me this Sprint is “Confront your Ignorance,”  which is basically not knowing the information needed for the work at hand. I chose this one because it describes what happened to me during this Sprint. I realized very quickly that I did not understand many things in the frontend and the Inventory system overall, which was scary and discouraged me. If I had read about this pattern before the Sprint, I do not think much would have changed. I still would need to do a lot of research regardless.

From the blog CS@Worcester – Cao's Thoughts by antcao 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/60

This is my merge request for my finished task of implementing nodemon into InventoryBackend in order for developers to utilize hot-reloading and for the correct port to be added for the database.

For Sprint 1, what worked well for me as an individual was my experience with nodemon itself, and being able to incorporate that experience to get a head start on the issue. Although it took me longer than expected to complete the implementation, having some background knowledge allowed me to be more confident in the changes I was making. The familiarity of the subject gave me some peace-of-mind.  

As a team, what worked well for us was our communication skills and being supportive and helpful of each other during class time. We kept ourselves organized with our issues and our Issue Board, which allowed for a clearer understanding of the tasks at hand. Our in-class environment as a team was very open and transparent with our problems and what we’re working on. Our communication from within Discord improved over the course of the Sprint, and we were able to keep each other up to date whenever we ran into a problem, made a merge request, or needed a question answered. 

On an individual level, what didn’t work well was my silence at the beginning of the Sprint. I struggled with incorporating and fixing nodemon, but I wasn’t asking for help early enough. Once I did ask for help, I was able to make great progress thanks to the assistance of my teammates and Professor Wurst. As one of my teammates had noted, if I had asked for help sooner, I might have been able to finish my issue faster. 

On a team level, we did lack in communication here and there, such as a lack of response on Discord, or others not being included or involved as much as they could have been. The Issue Board was too vague from the beginning, which made it hard to choose our issues and perhaps led us to bite off more than we could chew.

To improve as a team, we should be narrowing down our Issues and specify them more clearly, so that our Issue Board and plan for the next Sprint is more refined and achievable. I think we should also start to do stand-ups at the beginning of each meeting to inform the team of what we’ve been working on and the status of our progress. Also, although this applies to mostly me, I think asking for help whenever we’re stuck would be a great improvement. 

To improve as an individual, I, as previously mentioned, should speak up when I am struggling to try and get assistance from my teammates. It’s always good to have alternate perspectives and fresh viewpoints, so someone else may see a problem or solution that I wasn’t seeing. I could do a better job at keeping up with my teammates’ work, as I sometimes don’t confidently, fully know what they’re currently working on. 

Although there are a few Apprenticeship Patterns that would apply to me, I’ve chosen to discuss “Retreat into Competence”. This pattern describes a situation where you are beginning to realize how much you don’t understand about the work you’re doing, what you’re expected to do, or even the work going on around you. It eventually becomes too overwhelming, and to fix it, you revisit your “comfort zone”; you involve yourself in your area of expertise to gain confidence back and to take a quick break. 

I selected this pattern because I often feel weighed-down by an overwhelming sense of ignorance from all of the languages, frameworks, and other factors of programming that I do not understand. It makes me lose confidence in my ability to code, as it emphasizes my weaknesses. In terms of this Sprint, although I chose an issue that I had a little bit of experience with, the roadblocks I hit made me realize how much I didn’t fully understand about nodemon and especially docker-compose files, connecting to databases, images, and the like. Finding my ignorance in these areas reduced my confidence in my ability to program and get this issue solved. 

If I had read the pattern before or during the Sprint, I would have stepped back, worked on something utilizing my strengths, and gained my confidence back. It’s good to remind yourself of what you’re capable of.

From the blog CS@Worcester – Josh's Coding Journey by joshuafife and used with permission of the author. All other rights reserved by the author.

What worked well this sprint was our division of roles and tasks as well as the planning for tasks and the sprint as a whole. Each member had a specific section of our project that we worked on, some even taking part  in more or most of the project, as well as connecting the pieces of the project. I think we spent a lot of time planning and working out what we need to do, the path we want to take, and the many decisions along the way. This hopefully led to less confusion while working through the sprint. 

What didn’t work so well this sprint was the communication. Communication during certain moments in the sprint was lackluster and thus other members didn’t know what certain members were up to or working on. This also led to those other members having to pick up work had the certain member not done their work within a specific time.

To improve as a team, I think we should communicate more. Specifically, what we’re working on, what we can and can’t do, if we need help, and to complete tasks that require more than one member. As we move towards a complete product, I think the work may become more complicated and the communication will be necessary to connect and join respective pieces of the project.

To improve as an individual, I need to communicate more and stay on top of my work. Putting in more effort to communicate with my teammates and completing my tasks should be my number one priority. Personal issues, lack of effort, or lack of understanding led to me not being able to complete my tasks. Not only is that quite the issue, but I didn’t communicate any of that to my team at all, and thus they have no idea what I’m up to and have to pick up the work that I didn’t do. 

The apprenticeship pattern I felt was most relevant to my experiences was “Expose Your Ignorance” from Chapter 2. This pattern states that there are people depending on you to know what you are doing and need confidence that you can deliver. The solution to this pattern says to “Show the people who are depending on you that the learning process is part of delivering software [… and that the …] most obvious way to expose your ignorance is to ask questions.” I felt that this pattern partly describes what I experienced during this sprint. There are people relying on me to do my part but I don’t have the confidence in my ability and am unfamiliar with a lot of the processes that we will work through. My teammates, on the other hand, are very familiar with the processes or are very willing to learn. 

Although I did expose my ignorance and ask questions of some of my teammates who were much more experienced than I am, I could have done so much earlier. Not only that, but I still feel hesitant to ask questions because there are plenty of things I should already know but don’t. Reading this pattern may have encouraged me to ask questions more often and much earlier in the sprint, increasing communication from myself and between teammates, and would hopefully lead to me knowing what I need to know to tackle my tasks.

From the blog CS@Worcester – Kyler's Blog by kylerlai and used with permission of the author. All other rights reserved by the author.

The first sprint was a productive as well as eye-opening experience. This is the first 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, ask questions between each other for collaboration as well as knowing when to go to outside sources such as other teams or the professor. In our first sprint, the work revolved mainly around creating a new field for the guest object that would be able to store the value of the date of first entry. This one task was able to be split up into different working portions. These included adding this field to the API, the back end and the front end. Besides the main task we also completed the tasks of mounting a volume to the docker container allowing data to persist even after rebuilding as well as working on a CORS issue prohibiting the back end from communicating with the front end.

This is where things started with working well. Sean was working on the back end while Hiercine was working on the API, since they shared the same subsystem they were able to collaborate to solve the problem together. This was also scene with Lynn working on the front end and Winston fixing the CORS issue they both had experience with the front end so they were also able to collaborate. This is one of our biggest strength is our team working abilities and being able to collaborate to make the work flow more effectively 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. For example, not knowing exactly how certain systems worked within the code since it was our first experience with it. In addition, when it came to linting issues, one linter was for commit messages which we recently learned how to make proper messages so we had to learn how to make them after causing the linter to fail.

I believe as a team we are in a very good spot that cam only go up. I think as a team we can work at continuing to learn more about the systems and tools being used. In addition, I believe when it comes to merge requests we can be more efficient in making sure all work gets merged in a timely manner and we all collaboratively spread out the merging work. As a individual, I believe I can improve on learning more about the code so I understand more what is happening so I can make better solutions for the issues at hand. I also believe I can work more at improving how I collaborate within the team.

The pattern I selected was “Rubbing Elbows”, I chose this because I felt it related very well to how we worked 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.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfobackend/-/issues/139
https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfofrontend/-/issues/107

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

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.