During this sprint, I worked on four issues that were assigned to me. As a group, we all did well in our first sprint and felt we had much to improve on. There were areas where I could improve. During this sprint, I worked on four different issues; one of them was “Investigate GenerateWCFBReport frontend for better understanding of what tests need to be created”(1). This issue involved looking into the .vue files in the GenerateWCFBReport to determine the tests required. Keith and I had looked through the files separately to see what would be done. While I wrote down what needed to be done in a Word document, I remembered that I needed to add a comment to the issue page, which Keith already did.

Another issue I worked on was “Add AlexJS linter to pipelines for AddInventoryFrontend”(2). I had a lot of trouble with this issue, and it took around three hours to finally finish. Thankfully, I was able to work with my team to correct the issues I was having in getting this issue completed, even though, as I wrote in my notes while working on this issue, I was not and am not sure how I was able to get the pipeline to pass. However, Keith later noticed we may need to correctly complete this issue and other issues related to adding AlexJS. We plan on correcting these issues in sprint two.

A third issue I worked on during the sprint was “Move commands from ‘GuestInfoAPI/commands’ to ‘GuestInfoAPI/bin’”(3). This issue went smoothly for me, but I recall Tommy was having trouble completing a similar issue in a different section of the project, we tried to help him as best as we could, but for some reason specific files were being picked up by linters that should not have been. I am still unsure as to how the rest of the group did not have similar issues with their issues regarding moving their commands code.

The fourth issue I worked on this week was “Gitpod Dev Environments GuestInfoApi Team 2″(4). I had a lot of trouble with this issue as well, as mentioned in the issue page comments, I had to skip these issues “stoplight.spectral”, “hashhar.gitattributes”, “tlahmann.alex-linter” because of this error “[extension] extension is not found in Open VSXgitpod”. This was the first one I worked on during the sprint, so I had several issues merging the commits. “I also had difficulty merging commits, but Keith found a workaround to correct the issue. This took around 45 minutes to find and correct. In addition to this, I spent another 45 minutes trying to correct some linting errors being caused by “/t” markers.”

As a group we agreed that our communication was fantastic, we reached out to one another when we needed help, and were all able to communicate our ideas politely and efficiently and were all on the same page. However, we all agreed that we needed help with efficiently scheduling meetings between the four of us. We also needed help with weighing our issues appropriately. These issues can be easily corrected, with the scheduling we have determined to dedicate at least one class meeting to be in person and the other online. Regarding the weighing issues, that was primarily due to our inexperience.

I could improve by working on my assignments more on my own rather than just during our meetings. I also could improve by putting more comments on my issues in GitLab.

Issue 1: https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/reportingsystem/generatewcfbreportfrontend/-/issues/36

Issue 2: https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/addinventoryfrontend/-/issues/30

Issue 3: https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfoapi/-/issues/146

Issue 4: https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfoapi/-/issues/149

From the blog CS@Worcester – P. McManus Worcester State CS Blog by patrickmcmanus1 and used with permission of the author. All other rights reserved by the author.

With this being our first sprint of the semester it went well but we had our fair share of issues that we had to work through as a team which will help us make better decisions on our workflow and our team dynamic in the future. I personally worked on five issues throughout the sprint, one of these issues being a team issue and three of the issues being assigned to myself while we still worked as a team while going through our individual issues. These issues included adding the alex js linter to a pipeline and resolving alex js issues, adding a git pod dev environment setup to a repo in the project and moving from commands to bin for a specific repo within the project. Our group issue that we completed included researching frontend development and using our research to create issues for our second sprint regarding the wireframe for the add inventory frontend.

Overall I did not have much trouble with my individual issues within this sprint. My first issue I worked on with the alex js linter was straightforward and I was able to complete it without much delay as there were not a lot of terms flagged by the linter after its implementation to the pipeline. My second issue regarding git pod dev environments took a bit more time which was simply just due to the time it took to fully test the pipeline after a commit but I did not have trouble with implementing the git pod dev environment within the repository. My last individual issue involved moving from commands to bin, this was my most simple individual issue as it mainly consisted of renaming a folder and checking for commands which used the commands folder and changing it to use the bin folder. Our team wide issue of researching frontend and making issues also went well as we all attended the meeting and went over frontend basics together. Links to my individual issues are listed below.

Although we did not have a large amount of problems within this sprint I still feel as though there are things we could work on to improve as a team. One thing we can improve on is our timeline when it comes to reviewing, during the sprint we didn’t review our code until near the end of the sprint which just ended up being inefficient and experiencing this has led to us deciding to review code as soon as possible during this sprint instead of waiting until the end of the sprint in order to notify each other of any issues with our work with ample time to fix mistakes. Another thing I feel as though we all need to work on during sprint two is our use of gitlab as there were points where we got lost in gitlab when making merge requests, branches etc so being more careful when using gitlab will help us all remain more organized in order to ensure we get our code properly reviewed and merged within a timely manner. In my opinion we worked well together given it was our first time working in a team like this and hopefully we can continue to develop our abilities to work as a team throughout the next two sprints.

Alex JS Linter issue: 

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkinventoryfrontend/-/issues/33

Gitpod Dev Environments Issue: 

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkinventoryfrontend/-/issues/32

Move from commands to bin issue: 

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkinventoryfrontend/-/issues/31

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

Going into our first sprint, not only as a team together but as each of our first sprints individually, we were all on the same page with similar expectations. Those being that we would equally know just as little as each other. This mentality was good to have when we ran into issues that we knew ahead of time would take working as a team to solve. We had no idea what those issues would be, just that there were going to be plenty as this was a learning opportunity for each one of us.

Our team was tasked with setting up AlexJS linter and Gitpod extensions in select repositories in Thea’s Pantry. We tackled these tasks by dividing the work between us so that we would work primarily in one repository, with mine being the GuestInfoSytems/GuestInfoFrontend. This only worked for 3 of our members with the 4th having to work in a different repository for each issue. Looking back on this, only working in one repository makes working individually more organized but, as we found out later, would lead to less cross referencing and things being missed.

Other issues our team tackled during the sprint involved frontend testing. First we worked together to do research on open source frontend testing software that could be used in our project. This led us to understand how frontend testing works and what tests should be expected. With this knowledge, we investigated the frontends that were available to design the test that would need to be built in a later sprint.

What Worked Well:

Our team collaboration was by far our strongest feature. With all of us willing to work together and communicate, we were able to make sure that we all stayed on the same page throughout the sprint. Our team stayed in constant communication throughout, even in between meetings. This meant we could communicate times for meetings well ahead of when we wanted to have them, while still being flexible if something came up. When we were working together in a meeting it was either in person or over a discord call. These calls sometimes went on for hours. However, no one let that bother them when it came to getting the work done and sticking around to make sure we all understood what was going on.

What Didn’t Work Well:

The most notable issue we ran into was the weights of our issues. While on paper the issues seemed trivial, what we didn’t account for was the complexities of learning Gitpod and Gitlab. Navigating gitlab and handling pipeline commit message issues lead to the majority of the long nights and ultimately meant that none of our weights should have been a 0.

Team Improvements:

We were all working on the same or similar issues in different repositories meant we could do them together simultaneously. This led to all of our work this sprint being done during the calls with only minor issues being handled individually. While this made the work way more digestible at the start, it is important that we are able to handle issues individually in the future when we have to work on issues that don’t all align with each other’s. 

Person Improvements:

I noticed that a lot of, if not all, of my questions were answered in the documentation provided in the repository I was working in. Moving forward I am going to do better at fully looking through the documentation and files to get a better understanding of the project and how to approach issues.

Gitpod Issues:

Setup Gitpod environment and settings for GuestInfoFrontend:
https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfofrontend/-/issues/85

Issue to change commands to bin in GuestInfoFrontend was fixed prior to the sprint:
https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfofrontend/-/issues/82 

Worked on adding the AlexJS linter to the pipeline for GuestInfoFrontend:
https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfofrontend/-/issues/81 

Researched open source frontend testing software:
https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfofrontend/-/issues/86

Designed tests for GuestInfoSytems/GuestInfoFrontend:
https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfofrontend/-/issues/87

Designed tests for InventorySystem/CheckOutGuestFrontend:
https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkoutguestfrontend/-/issues/36 

From the blog CS@Worcester – CS Learning by kbourassa18 and used with permission of the author. All other rights reserved by the author.

As the first sprint EVER, it went very well, and it provided significant learning opportunities.

Our team exhibited strong collaboration throughout this initial phase. Effective communication was a cornerstone of our approach, enabling us to schedule both online and face-to-face meetings efficiently. A testament to our collaborative spirit was achieving our target of completing more than 75% of the tasks by the sprint’s end. This success largely stemmed from our commitment to weekly in-person meetings, fostering a united team environment crucial for addressing new challenges and workflows.

Despite these positive aspects, our journey was not devoid of hurdles. We encountered several setbacks, primarily due to our collective inexperience with GitLab and its workflow processes. Initially, we struggled with navigation, issue postings, and branch creations, leading to confusion and delays. Our approach to merge requests and the subsequent review process also proved problematic, culminating in merge conflicts and pipeline failures due to our wait-until-the-end strategy.

In light of these challenges, we aim to refine our approach in the upcoming sprint. We plan to create a “Workflow tips” document, compiling our experiences and solutions from this sprint to circumvent similar obstacles in the future. We intend to adopt a more proactive review process for issues and streamline our approach to merge requests, ensuring they align with workflow requirements.

Reflecting on the obstacles I encountered this sprint, there are several areas for personal improvement:

Enhancing GitLab Skills: I recognize the importance of becoming more proficient with GitLab. I intend to invest effort into understanding its intricacies, especially concerning branch management, handling merge requests, and connecting issues. I plan to utilize online resources, seek guidance from tutorials, and lean on my peers for support to enhance my competency.

Strengthening Communication: Acknowledging the need for improvement, I aim to enhance my approach to communication. I will take initiative to seek out feedback more actively and clarify doubts promptly with team members and mentors, aiming to resolve issues before they escalate.

Boosting Organizational Capabilities: I understand that better organization is key to avoiding past mistakes. Therefore, I am committed to honing my organizational skills, particularly in keeping track of my tasks, associated merge requests, and issues. Employing project management tools or maintaining a personal task tracker will be instrumental in keeping me in sync with the team’s goals and deadlines.

Links to the issues covered in this sprint:

Create Integration and Pipeline

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/integration/-/issues/1

Settings and extensions previously located in the dev container should now be transferred to .vscode/settings.json and .vscode/extensions.json within the Gitpod environment, as outlined in the .gitpod.yml documentation. Furthermore, developer commands should be moved from the commands directory to bin to align with standard Linux conventions, necessitating updates in script paths and .gitlab-ci.yaml environment variables. Additionally, integrate the AlexJS linter into each project’s pipeline and the bin/lint.sh script, ensuring all documentation is checked and updated accordingly.

Familiarize ourselves with guestInfoFrontend to understand what goes into CheckoutGuestFrontend

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkoutguestfrontend/-/issues/37

This activity served as an introduction to the primary objectives of sprint 2. During this phase, we collectively reviewed the current wireframe for the checkout guest front end to familiarize ourselves with the anticipated design layout.

Refactor commands folder to bin

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

This process entailed establishing a bin directory within the project and transferring three scripts from the template project into this new folder. Following this, I conducted tests on each of the three scripts to verify their functionality.

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

Sprint 1 Retrospective

Introduction

• In the first sprint we were mostly focused on learning the ropes of gitlab and getting familiarized with the sprint structure.
• This sprint lasted for 5 stand ups which is equivalent to 2 and ½ weeks. This ended up feeling a bit cramped considering the amount of learning that was necessary for this process.

Links to Activity on GitLab

• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkoutguestfrontend/-/issues/37 :This activity was a precursor to the main focus of sprint 2. In this activity we all looked at the existing wireframe for checkout guest frontend and got used to the expected layout.
• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfoapi/-/issues/125: This activity was odd as it seemed to have been done already so all I was able to contribute here was to run the linters to insure everything worked correctly.
• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/gitlab-profile/-/issues/11: This involved creating a bin folder in the project and copying the 3 scripts into it from the template project. I then tested the three scripts to make sure they worked
• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/documentation/-/issues/4: This Issue was focused around creating a new gitpod.yaml file and adding the extensions that are needed to it. This also involved moving the file containing the settings from the docker folder to the gitpod one.

Reflections on the Sprint

What Worked Well?

• In this sprint I found that communication as a group was key to our success. Any problems that we faced were made much easier when we tackled them as a group instead of alone. I think that our review process was good and we just need to make sure we keep logs of these reviews in the appropriate discord channel.

What Didn’t Work Well?

• I think that the main thing that we struggled with was learning how to use this new environment and process. I think that this caused lots of issued especially with multiple people working in the same projects and all being confused about what to do, This lead to issues with people creating branches in the wrong issues as well as people accidentally doing issues for other teams. I personally struggled with making sure the right merge request was linked to the issue and will try to improve this for the next sprint.

Given the detailed account of your Sprint 1 Retrospective, let’s complete the remaining sections with reflective insights and forward-looking statements based on your experiences and observations.

Improvements for Team Performance

The team’s ability to communicate and tackle problems collectively was a strong point during this sprint. However, the transition to using new tools and processes highlighted several areas for improvement. To enhance our team performance in future sprints, we propose the following changes:

1. Enhanced Onboarding for New Tools: Given the difficulties encountered with GitLab and related tools, a focused session or resource compilation on these tools at the sprint’s start could mitigate confusion. This could include tutorial links, common troubleshooting tips, and a Q&A session.
2. Clarification of Roles and Tasks: To prevent overlap and confusion, especially in a multi-person project environment, clearly defining roles and tasks at the sprint planning meeting could ensure smoother operation. This might involve assigning specific issues to individuals or small groups and establishing clear ownership of tasks.
3. Streamlined Communication Channels: While communication was strong, ensuring that all discussions, especially those related to problem-solving and decision-making, are logged in an accessible and organized manner (e.g., categorized Discord channels or a dedicated project management tool) would help maintain clarity and continuity.

Personal Improvements

Reflecting on my personal challenges during this sprint, specifically around managing merge requests correctly, I see valuable opportunities for growth:

1. GitLab Proficiency: I will dedicate time to deepen my understanding of GitLab’s workflow, focusing on branch management, merge requests, and issue linking. Online resources, tutorials, and peer assistance will be valuable in this learning process.
2. Proactive Communication: To prevent and swiftly address any uncertainties or errors in my work, I commit to being more proactive in seeking feedback and clarifications from team members and mentors.

Organizational Skills: I will improve my organizational skills, particularly in tracking my tasks and their related merge requests and issues. Using project management tools or personal task trackers could help ensure that I am always aligned with the team’s objectives and timelines.

From the blog CS@Worcester – Abe's Programming Blog by Abraham Passmore and used with permission of the author. All other rights reserved by the author.

Achievements & Challenges

Reflecting on what worked well, one aspect was our organization. From the start, we established a strong foundation with clear and well-defined issues, allowing us to hit the ground running. The team demonstrated a balance between offering assistance and providing constructive feedback on each other’s work, creating a collaborative and supportive environment.

However, GitLab presented a learning curve that took us a bit longer to fully grasp and navigate. This resulted in occasional roadblocks, such as instances where work had already been done or where components were missing, requiring further elaboration. Recognizing these challenges is the first step toward overcoming them in future sprints. Another issue we faced and have already solved was our Sprint planning meeting, creating a more team-balanced approach. Originally, we had only one member creating issues as we talked about them. However, we realized this was not the best approach. For Sprint 2, we had each member create issues that we originally defined as a team. Then, we gave each member a chance to talk about their issues, how they plan to work on them, and if any improvements/clarifications would be needed.

On the team improvement front, our collective strength shone, especially when tackling potential ideas for more challenging tasks ahead. Moving forward, we aim to enhance our coordination by implementing more frequent check-ins. This approach will ensure that no team member is too far ahead, behind, or engaged in incorrect work, establishing a system of checks and balances within the team dynamic. Another improvement that will benefit the team as these issues begin to become longer and more challenging is more team-based work. After reviewing other teams’ work in the first sprint, I noticed multiple issues where more than one team member was working on an issue. This step will allow more time and a second pair of eyes on an issue, improving our productivity and furthering our ability to tackle an issue simultaneously.

Individually, I’ve identified areas for improvement that will contribute to both personal and team success. Managing time more effectively is a key focus, acknowledging that optimizing productivity requires a strategic approach to time mangement. Additionally, recognizing the importance of communication, especially on off days, will be crucial in maintaining a good workflow. The goal is to avoid getting too ahead of myself and attempting to tackle everything simultaneously. This includes refraining from taking on multiple issues beyond what is required, ensuring a more measured and sustainable workflow.

GitLab Work

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/documentation/-/issues/10

Description: In my individual assessment above, I recognized a mistake in attempting to tackle more than necessary. While working on issue #1, I unintentionally delved into other topics. In an effort to make the branch more user-friendly, I decided to combine these three separate issues into a single, comprehensive one. This new issue provides clear documentation for each step involved.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/documentation/-/issues/10

Description: This issue involved a straightforward review of the existing documentation. The focus was on ensuring the pipeline’s smooth operation by confirming the correct properties. Additionally, unnecessary extensions and linters were eliminated to simplify and optimize the documentation.

From the blog CS@Worcester – CS: Start to Finish by mrjfatal and used with permission of the author. All other rights reserved by the author.

For our first sprint in the software development capstone course at Worcester State University, our team was tasked to investigate epics attached to multiple repositories within the Thea’s Pantry Gitlab page. We also needed to learn how to use Gitlab’s productivity and team management tools as we went along so we could appropriately divide up tasks among ourselves and monitor our progress. Most of our work was accomplished within the GuestInfoSystem repository and its component microsystems. We also spent time investigating the component InventorySystems in preparation for construction of test suites in the next sprint. I personally contributed to the issues attached to GuestInfoBackend, as well as contributed to sprint planning during team standup meetings and meetings outside of classroom hours.

The specific issues that our team was tasked with resolving were configuring the repositories within GuestInfoSystem for remote Gitpod development environments, renaming the ‘commands’ directory of each repository to ‘bin’ and modifying any scripts that reference the ‘commands’ directory to reflect the name change, and integrating the AlexJS linter into the Gitlab commit pipeline. After that work was finished, we would be responsible for investigating the GuestInfoSystem and InventorySystem repositories to prepare to build testing suites for the frontend and backend services during our next sprint.

Before we started work on the issues, we came together as a team to discuss how much time and effort would likely go into the completion of each task, using the weight system used by Gitlab as an estimate. The weight system is a scale from 0 to 3, with each increasing level of weight meant to represent a relative increase in time and effort necessary to resolve the issue. We attached a weight of 0 to some of our tasks while planning our sprint, which may have led us to expect that some of our work wouldn’t take as long as the task would end up requiring of us. The 0 weight in this system represents a task that shouldn’t take more than a few minutes. The only issue that we worked on this sprint that I would still argue would constitute zero weight would be the renaming of ‘commands’ to ‘bin’. Everything else required more investment of our time and concentration than we had anticipated, in part because we were still learning how to use Github’s tools to coordinate as a software development team.

Once we had agreed as a team on which weight values to assign to each of our issues, we decided to begin our sprint with preparing the repositories for development in Gitpod. Instead of cloning code from the Thea’s Pantry Gitlab page to our personal machines, we can open the repository files in a web browser based Visual Studio. This remote workspace is maintained by Gitpod for as long as we are working in it, and for 14 days of inactivity afterward. To create a workspace for the repository we want to work on, there are tools within Gitlab that allow for easy creation of a new development branch based on an issue, as well as the creation of a new Gitpod workspace based on that branch. I’ve been getting to enjoy using these remote development features, personally, and I appreciate how I can have access to all the functionality of Visual Studio without needing to install extensions on my machine.

To get each repository configured for development in Gitpod, we needed to copy the names of our desired settings from the existing ‘.devcontainer/devcontainer.json’ into ‘.vscode/settings.json’, and to copy the names of the extensions that each repository requires into ‘.gitpod.yml’, a file that can be created in the repository while working in Gitpod by using the terminal command ‘gp init’. However, we found that because of a part of the Gitlab pipeline that lints the files in the repository, we needed to change the formatting of some of the files created by that command so that no lines were longer than a certain character limit. In hindsight, I think it would have been better to try and include those files in the ignore files for the linter extensions. Ignore files are files that point to other files and directories within the repository that we don’t want the linter to review or raise any issues with. We began to recognize the utility of ignore files near the end of our sprint, but at the outset it hadn’t occurred to me to try and get around the linter errors by adding the newly created Gitpod files to an ignore list.

The issue that challenged me the most was adding the AlexJS linter to the GuestInfoBackend and to the Gitlab commit pipeline. I wasn’t anticipating that I would struggle with a task like this, because I thought I would just need to type ‘AlexJS’ into a few files and I would be done with it. While that was part of the process, I also needed to add certain files like licenses and the Code of Conduct to an ignore file. The linting process would have returned a failure status otherwise because those files contained text that would be flagged by the linter. I also spent more time I would like to admit waiting for the linting process to finish while it was iterating through the lengthy ‘node_modules’ directory. That directory needed to be added to this repository’s linter ignore files to avoid an unbearably long (and doomed to fail) linting process. I also realized by the end of the sprint that I had misunderstood the task to add AlexJS to to the Gitlab pipeline, and I had only added AlexJS to the lint shell script within the development environment. In the future I’m going to make sure I review a linter’s ignore file when newly installing it into a repository.

My most significant takeaway from this first sprint is that I shouldn’t underestimate the effort I’ll need to invest into issues that sound like they’re well within my comfort zone. We’re working as part of a cooperative effort on a complex software project, and that requires an advanced degree of communication and attention to detail. I’m not going to be able to go into tasks assuming that they will be easy just because they sound similar to problems I’ve solved before.

Gitlab issues:

• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfobackend/-/merge_requests/86
  • Configured GuestInfoBackend for remote Gitpod development environment
• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfobackend/-/merge_requests/88#note_1785621795
  • Added AlexJS linter to GuestInfoBackend shell script
• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfobackend/-/merge_requests/87
  • Renamed ‘commands’ to ‘bin’ and modified references to ‘commands’ in other files to reflect name change

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

Sprint 1 Retrospective

What worked well this sprint

Because this sprint was our first working together as a group, learning how each of us felt about working in a team in general was important. One thing we all mentioned was how in our previous experiences, group work tended to be inconsistent in terms of communication and deliverables. This meaning that sometimes a group member would not communicate throughout the duration of the project, and would not have any work to show they have been actively working towards the end project goal. In order to combat this, we decided to have weekly in-class meetings (specifically on Thursdays). Having weekly in-class meetings worked well because there was consist communication throughout the sprint. If any group members had any questions, weekly meetings also gave opportunity for those questions to be answered in a timely manner, if not addressed between meetings. Something else that worked well was having a separate text group chat, rather than only having Discord as our main form of communication. Having a text group chat seemed to be a more reliable form of communication for the team.

What did not work well

As briefly mentioned above, having Discord be our main mode of communication did not work well. In the beginning of the sprint, some of us did not have the Discord app installed on our phones which led to not receiving notifications. This became problematic because there would be missed messages. What also did not work out well was leaving completed issues and merge requests to be reviewed at the end of the sprint. Leaving code reviews to the end of the sprint led to many merge conflicts and extra work that could have been avoided.

Changes to make as a team

One change that could be made as a team is to review merge requests as they are completed, rather than waiting until the end of the sprint. Resolving an issue and completing merge requests as they are finished is a more efficient workflow because the number of merge conflicts is dramatically reduced. When numerous merge requests are made on the same repository, some merge requests will have changes that others do not which is what led to the merge conflicts. Another change that should be made is being more clear as to when we are having meetings. Although stated above that having weekly meetings worked well, there were times where we had to reschedule to meet during the Tuesday class time rather than the Thursday class time. Normally this would not be an issue; however, there were a few instances where some would be there for the meeting, while some would not be due to confusion on when we were actually meeting that week.

Changes to make as an individual

A change that could be made as an individual is responding more promptly. Delayed responses from myself, mainly came from the beginning of the sprint when the team/I were having some communication problems when only using Discord which led to the suggestion of a separate text group chat.

Activity on GitLab

• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkoutguestfrontend/-/issues/35
  • Resolved the issue “Add AlexJS linter to pipelines” for the CheckOutGuestFrontend subsystem.
• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkoutguestfrontend/-/issues/33
  • Resolved the issue “Move from commands to bin” for the CheckOutGuestFrontend subsystem.
• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/checkoutguestfrontend/-/issues/34
  • Resolved the issue “Gitpod Dev Environments” for the CheckOutGuestFrontend subsystem.
• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/guestinfosystem/guestinfointegration/-/merge_requests/11
  • Reviewed and approved the merge request for “Gitpod Dev Environments” for the GuestInfoIntegration subsystem.
• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/documentation/-/merge_requests/6
  • Reviewed and approved the merge request for “Add AlexJS linter to pipelines” for the Documentation subsystem within the InventorySystem.
• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/documentation/-/merge_requests/8
  • Reviewed and approved the merge request for “Move from commands to bin” for the Documentation subsystem within the InventorySystem.
• https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/addinventoryfrontend/-/issues/35
  • As a team, we evaluated the current state of the AddInventoryFrontend to get a better idea of what issues would be appropriate for Sprint 2.

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