Category Archives: Sprint 2

Just Gotta Keep Sprinting… (Sprint Retrospective Blog 2)

INTRODUCTION: Compared to the first sprint, “Sprint 2” has gone better in some ways. However, in other ways. we definitely have dropped in performance a bit. It’s no one’s fault; part of working within these sprints is figuring out what needs to get done now, and what can be done later.
POSTIVE FACTORS: Here are the following improvements since the last sprint…

  • We have set up a form of “login” based on Keycloak software. This Keycloak login has also been set up via JavaScript to act as a “re-direct” from the barebones frontend that we had created during the first sprint. I often refer to this “connected demo” as a HTML/Keycloak/VUE App or project. This is because that’s exactly what happens with the current demo: a user will start in the HTML index file, and then click on a button that redirects to a Keycloak login. Once credentials are entered, the Keycloak login will take the user to the VUE App.
  • The group has figured out how to work with Keycloak – in particular, we understand how to create users, set up privileges for users, and group them within a “realm”. We also understand the hashing algorithms used to make JWT Tokens, alongside the structure of a token when de-coded.

NEGATIVE FACTORS: The following factors, as of this sprint, should be worked on…

  • The group has reached out to other groups, as well as LibreFoodPantry staff. Still, I feel as though communication is key; the more communication that our group can make with other staff, the better.
  • Our team’s organization of the Sprint board could have been better. Specifically, I feel as though moving issues to the “Needs Review” section as they are completed would be preferable to moving them all at once.

TEAM IMPROVEMENT SUGGESTIONS: Here are some ways that the team can improve for the third, final sprint…

  • I have made the suggestion that the team could benefit from “POGIL-Style” roles, where each team member performs a specific task for the group. As emphasized throughout this blog, the role that comes to mind is “communications”; while not very “programming-heavy”, this role involves reaching out to other teams and staff. This keeps everyone “in the loop” so that they can plan their sprint work accordingly for the eventual project integration.
  • Similar to my discussion within the self-improvement section below, I feel as though the group can benefit from work that is focused towards issue/epic progression. While we are making progress, it seems as though we have to scramble to figure out exactly what is done during our sprint review.

SELF-IMPROVEMENT SUGGESTIONS: As for myself, here are some factors that I need to work on for the future…

  • I need to dedicate more time to this project. I have made this issue clear in the last retrospective blog, but failed to work on it. This project, and this class, are extremely important for my professional reputation. Having “outside factors” as a reason for why work isn’t done can only be justified for so long. Eventually, one side has to give: either the outside factors, or the project.
  • I feel as though “issue-focused” work would be better for long-term progress. While it’s great that I seem to be making progress with Keycloak, my work is scattered. This issue reflects itself in the progress made on the gitlab issue board.

When creating this blog, I took a quick look back at my first Sprint Retrospective blog; I wanted to make comparisons on mistakes that have been amended during the first sprint. Unfortunately, having this blog posted on time is not one of those amended mistakes. Looking on the brighter side, I feel as though focusing on these blogs is not as important as I make it out to be (this was a mistake that I made during Software Architecture).

LINKS TO GITLAB ACTIVITY

From the blog CS@Worcester – mpekim.code by Mike Morley (mpekim) and used with permission of the author. All other rights reserved by the author.

Retro #2

For the end of Sprint 2, I would say the team really came together to help each other out. We were able to see each other’s skills and start coding. The communication seemed to improve throughout, and the group decided to let Joe continue to be the scrum master for the rest of the semester since the first Sprint he couldn’t really apply scrum master duties. This time around we were more focused and ready to tackle this sprint and give our best work. For this sprint, we assigned fewer task to people with higher weights because we knew it was going to take up some time to build the backend. We were able to produce an OpenAPI for the requested endpoints. We used the yaml file provided that helped us write, build and then test the endpoints in our backend. Then these methods were tested using Visual Code Studio to launch the HTTP request from the guest.http and the qs.http.

During this sprint, while building the backend, we ran into some issues on how to get the calls. http POST, GET, PUT to work for our guest information code. First, we assigned each call to a member in the group. I oversaw creating the get DELETE which was giving us some issues. The error ended up being just minor coding grammar on my end that was easily fixed. Unfortunately, I was operating under a different branch so every code that I sent or corrections to the code that I made, was being pushed to another section of the LibreFoodPantry. Once that was corrected, I was able to continue to help my team. Another issue that we ran into was our Questionnaire call. The reason we were having issues is because Mongold gets created and returned on a post. Any record access after that must pass with a key for that item. Another issue we faced were that the Android app was producing a Timeout Error which we sought counsel from Dr. Wurst on how to correct that in the next sprint.

Overall, I was really impressed with my team since we accomplished two of the major goals that we had. First, was to improve the skill-set of the team members. The first sprint was all copy and pasting documentations. This sprint we all had to show our coding abilities and was able to learn from one another if was lost. Second, was that we were able to help the general progression of the LibreFoodPantry.

For the next sprint, I believe we are starting off on a good start. We were able to fix all the errors that had with our backend, all of our calls are now working with no errors and has a team we have better communication and organization. Joe has really stepped up and lead us to a good position.

Links to my tickets:

API: add endpoint to return current version (#21) · Issues · LibreFoodPantry / Client Solutions / NEST / Guest Information System / API · GitLab

HTTP Get Range of Questionaire Submissions (#19) · Issues · LibreFoodPantry / Client Solutions / NEST / Guest Information System / API · GitLab

backend: set up devcontainer.json for extra tools needed (#2) · Issues · LibreFoodPantry / Client Solutions / NEST / Guest Information System / Backend · GitLab

From the blog CS@Worcester – The Dive by gonzalezwsu22 and used with permission of the author. All other rights reserved by the author.

Sprint Retrospective 2

What worked well:

Creating branches and merge requests was smoother compared to previous sprint. We were communicating more through comment section of issues leading to better documentation on Gitlab. We were able to come up with a system for merge requests where two people who did not create the merge request would review the code or changes and then third person would write the comments indicating the author and merge the branch into main. We were able to evenly split work and issues between team members so one person was not burdened with one type of work. Even with delays and having to learn new language and concepts we were able to complete the sprint.

We also created issues for contacting AWS and IAM team members (links below). We contacted both team members via discord and tagged them to comment section of the issues that contained questions we had for them.

Personally:

Most important one is that I did not limit myself to issues only assigned to me, I was able to go over work done by my teammates and keep myself updated with new code as well as the flow of the project. API was completed so we had moved on to Backend. I created data file for cooking methods. This was difficult in its own way because we were not using MongoDB for this project. After researching backend already provided, I was able to figure out that we needed to use axios and USDA URL to call data which would return list of cooking methods or cooking methods based on its unique ID. I then wrote a main function to check if I was getting list of all cooking methods and it was successful.

Even with some setbacks, I was able to grasp the basic concepts of the new JavaScript testing framework – ‘mocha’ and JavaScript testing library ‘chai’. Since the data file and paths were completed, I created cooking method test file. With help from Jim this one completed in a week. Npm test verified that all test files were passing.

Things that did not work well:

The spring break and two consecutive cancelled classes pushed us back a little and we had a little problem getting back in sync. We were still having problems communicating and setting meetings outside of class time. Merge requests started to slow down; partly because of introductions of news framework and library – mocha and chai, verifying others work became difficult; partly because merge requests started to fail due illegal naming conventions in commits. Issue names also needed to be more descriptive with more details in sub descriptions. Issues were also not properly linked to their respective epics. We were stuck in a lot of places where we needed help from professor, and we should have been more pro-active in that situation.

We also did not hear back from the IAM and AWS team.

Personally:

I wasted a lot of time researching and reading documentation on my own instead of working with my team or asking help from professor. Also lost a lot of time figuring out how to run npm and npm test. My merge requests kept failing I was not able to figure out the reason until Dahwal pointed out that I was not using conventional commits. I kept up with other people’s code but did not get an opportunity to write an endpoint myself.

Links to some issues:

Start conversation with IAM team

https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeper-newbackend/-/issues/14

Start conversation with AWS team

https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeper-newbackend/-/issues/15

Test file for Cooking Methods

https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/general/-/issues/2

Create Data File for Cooking Methods

https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeper-newbackend/-/issues/4

From the blog CS@worcester – Towards Tech by murtazan and used with permission of the author. All other rights reserved by the author.

Sprint Retrospective 2

As a team, we definitely pulled out a much better sprint this time around. Our communication was far better in our class work meetings, as well as outside of class work and coordination. I again feel like I could have done more, as the further into the project we got, the harder it was to come up with consistently good issues and epics. I personally felt a little apprehensive to add specific tasks because I was unsure of how applicable or useful it would be to the team. However, I think the team felt at least a bit similar as we really had to talk it out during the planning sessions to come to a satisfactory agreement. In addition, our ranking of weight on some of the issues and the organization of them was quite messy, which is something that we’re working to improve in the third sprint. Something I struggled with was understanding how to correctly implement the authentication token, and at one point accidentally broke our backend with sloppy implementation. In the future, I need to communicate when I add a potentially code breaking file, and I should absolutely be using branches instead of recklessly pushing it to main.

On that note, after getting more comfortable with the uses of git, I feel it streamlined the process of the work by a good amount for me. I’m still grappling with having some files pass the pipeline tests, and while I deferred to teammate help to fix some of the problems I should lean into really understanding the pipeline and how to properly upload and use the tool.

I also believe I wasted a good amount of time trying to implement the testing directory in the backend. In retrospect there was no way I should have continued to try and make it useful when there were other more important aspects of the project to finish up. In the future I should evaluate the necessity of my focus, as I straight up wasted a good chunk of some classes. In addition, I could have put more effort into getting some of the http calls to work instead of researching the token authentication. Another instance of needing to prioritize.

In my opinion I’m also not asking enough questions, and instead going to stack overflow or reddit for answers, which seem to be hit or miss. There is no reason not to differ to my teammates; this is something I should work on in general though as I don’t usually ask for help with things. I think I should also be pushing more files to the repositories, just to properly track my contributions to the project for accountability. I don’t believe my team feels like I’m not contributing, but just for the paper trail I should make it a habit.

Despite this post’s mostly critical tone, I actually think we did well this time around. I think the team was happy with what we all got done, and how we can maturely talk about disagreements. As a team, the only thing we should work on is properly creating and assigning issues, but I’m satisfied with our work aside from that.

Here is where I added schemas and paths for the token validation.

https://gitlab.com/LibreFoodPantry/client-solutions/nest/guest-information-system/api/-/commit/adf1c73d94c7ca781259162377194bd39fb91ee8

While not my commit, I helped the team to get the calls functioning.

https://gitlab.com/LibreFoodPantry/client-solutions/nest/guest-information-system/api/-/commit/1c9ccc965bb68d27bbb7255c1e0f39b883c255c6

From the blog CS@worcester – Dummies that Code by howbrash and used with permission of the author. All other rights reserved by the author.

Sprint Retrospective – Sprint 2

I think that we as a team, as well as me as an individual, improved during this sprint compared to the first sprint. While for the first sprint we had no experience working with scrum sprints or in any sort of team development environment, so the whole thing was completely new to us, whereas at least now with the 2nd sprint we had at least a tiny bit of experience. This means that we were able to improve upon some things from our first sprint, because we could see what we did wrong and could change our plan in order to avoid our previous mistakes and optimize our workflow overall.

The first thing we optimized and improved upon was our sprint planning. From our first sprint, we could better judge what we could get done during a sprint by how much we got done during our first sprint. This way we could efficiently work on items, getting as much done as possible during the sprint and not assigning too much during the sprint to the point that we end up not getting most of it done. We could also better assign weight to each of the items because we could better judge how long it would take for us to get each item done, and better judge the importance of each item to the overall project and current objective.

The second thing we optimized and improved upon was our overall communication. We still did most of our communication in class, but we now made sure to communicate through the issues on GitLab. When an issue required additional clarification or explanation, we could leave a comment on an issue and ask the creator of the issue for more details, and the creator could easily respond right on the issue. This not only improved upon the frequency of our communication, but it also helped us to differentiate and easily see what string of communication was pertinent to what issue, helping other team members to see what was discussed respective to what issues. This way, if a team member was working on an issue similar to or previously worked on by another team member, they could easily see what kind of issues that team member faced while working on it, and that could help them work through it without even requiring more help from the team. This makes the workflow as a whole much more efficient because any communication is saved, categorized, and easily searchable.

For the team as a whole, we could still improve upon our communication. Although it is efficient communicating through GitLab issues, and it does have some benefits, it is also good to have some non-official communication that doesn’t directly relate to a particular issue. Leaving this communication on GitLab would be messy, so it would be better if we did this additional communication through discord. For me as an individual, I think I could’ve helped more with the sprint planning, and better assisted my team members. For the spring planning, I could’ve better helped with coming up with weights for issues and assigning them. Finally, I could’ve better helped my teammates by being more active responding to open issues with comments and helping them finish open issues if I’m done with all of my issues.

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

Sprint Retrospective 2

By this sprint, everyone had an idea of what they were doing and what needed to be done. So everyone was on track with required workflow. In this sprint, people started to add issues of their own. I should have added issues I found in this project, but I just discussed with the team members, and they added it. Overall, for this sprint, I have a mixed feeling about it. I felt as if I didn’t do much help to the team, but at the same time I felt like I gave my all to the team. I did solve a couple issues during this sprint.

The first issue I solved was simple enough that I forgot to add it to the project issue board. Logically, it made sense to fix this issue so that the form doesn’t become annoying to the user. Imagine clicking on the input field every time the form loaded. So guest 1 comes and swipes, guest 2 comes then you have to click on the input field, guest 3 comes click again. Doing that over and over again would have been exhausting. I didn’t really notice this issue until I tested the code with card reader. At first, I thought I had to write some method so that the text would automatically focus on the input field. I was lost and had no idea about how to make it work. At the end, I felt really stupid because the solution was simple, and I was overthinking it. The solution was in the HTML input attribute type. All I had to add was “autofill” in the input attribute. Refer to this commit. Here

For the second issue I fixed, it really took the best of me and my time. My goal was to on a click of a button which is in one of the child component in Vue, I had to get the data from localhost, store it as an object then pass it to another child component so that those data would automatically fill the form. Sounds simple and easy. But the thing is, you cannot pass data from one child component to another. So the process was to get data from one child component, pass it to parent component using emit and then pass that data to another child component from parent component using props. Michale had already passed the data from component to component and I thought it would be relatively be the same. I couldn’t be any more wrong. I did everything same as Michale and everything worked as we wanted. Since our API was not fully done, I tested my method using Jsonplaceholder and sent the data to another component. I put the Jsonplaceholder’s ID number as a zip code, and it displayed as I wanted it to be. The major problem was that I was using options:Lifecycle that would assign the data before the form loads, which leads to not being able to edit the form data. Removing the lifecycle and just mounting it to v-model worked, but it rendered the first child component twice in the same page. Other than that, everything was working. I was able to get the data, pass to the form and edit then submit the edited data. I am not really sure how this worked, but to fix the issue of rendering the component twice, I hid the first component when the submit button is clicked. After that, everything worked as we wanted. Refer to this commit for code details. here

On to the third issue, when swiping the card, the input field only picked up the correct ID on the first swipe only. This issue was taken by another teammate, but since he wasn’t able to complete it, I took it from there. After a couple of hours of debugging, I was left with nothing. I understood the code the previous developers left, but I wasn’t sure why the issue was as it is. I started to think that if it worked on first swipe, let’s make every swipe as first one. So the solution was simple. Refer to this commit on line 93. here

This Sprint showed who is really dedicated to the project, who is really passionate to the software developing. It seemed as everyone was giving their 100% effort to the project and were all liking the process. I don’t have a single doubt that we won’t be able to finish this by the end.

From the blog cs@worcester – Dream to Reality by tamusandesh99 and used with permission of the author. All other rights reserved by the author.

Sprint 2 Retrospective

With our second sprint concluded, our team made significant progress but also experienced large amounts of stagnation. I think this was due to the weeklong spring break smack dab in the middle of the sprint that caused nearly everyone’s productivity to drop to all-time lows. The biggest win we achieved was learning how to and getting our dev environment containerized. A few of the mistakes we made during last sprint, we made again this sprint.

The Good

We made a lot of progress on our board in terms of organizing and giving tasks proper descriptions so we could revisit them later and know what needed to be worked on. While it seemed like we didn’t have a lot to show for the work that we did, we did gain a lot of valuable knowledge that will help set us up completing tasks that weren’t able to be finished this sprint.

The Bad

We repeated a few of the same mistakes from the first sprint by not communicating with each other effectively. While working on completing issues on the board, it became apparent within group that issues were mostly resolved but small portions of them remained incomplete. Because of this our board looked like not a lot of work was completed.

Improvements?

We should be revisiting the board often and make changes where necessary. We need to effectively get better at recognizing when an issue needs to be broken down into smaller issues. Our communicating skills are getting better, but it still needs some work. We came up with the idea that we would do our best work outside of class and use our time together in class to bring each other up to speed on what we have done and communicate what still needs to be done. Lastly, we can make sure we’re using our class time as efficiently as possible by making sure we’re staying on track and not getting sent down rabbit holes of information.

How I Contributed

https://gitlab.com/worcester/cs/naturalization-interview-confidence-environment/demo-react/-/issues/18

I was tasked with creating a drawing feature for the application. This would be used as a means for a test taker to be able to write down what they hear from the proctor. I spent the entirety of my time trying to implement this functionality into our application. At first, I thought I would try to learn how to create this type of function from scratch. After lots of tinkering with PanResponders and InteractiveViews, I realized that this sort of thing would not be as simple as I thought it would be. Instead, we found a project on GitHub called React Native SketchCanvas. This program was being shared under the MIT license and had all the functionality we were looking for. We just had to figure out how to get it to work in tandem with our application. It was around this time that we figured out how to containerize our development environment.

While trying to get the SketchCanvas dependencies into the container, I kept on getting errors from the terminal that were complaining about the components in the SketchCanvas code. It turns out that the software that we use to test our application Expo is not fully compatible with the SketchCanvas and will not recognize certain custom components its comes with. The SketchCanvas seems like it was a class project someone at MIT worked on because it doesn’t seem like there’s any active support in its GitHub repo. While good research was conducted during the sprint, ultimately this task will continue on into the next one.

From the blog CS@Worcester – You have reached the upper bound by cloudtech360 and used with permission of the author. All other rights reserved by the author.

Sprint 2 Retrospective

For the second sprint, we tried some of the changes we talked about from the first sprint retrospective and some things turned out better than before, but we still have some things we can work on.

Our main concern from the previous sprint was communication, especially on gitlab, and we believe that we have improved because we have been commenting more on issues and stuck to approving and completing merge requests outside of meetings. Up until the last meeting, we were caught up with merge requests and dealing with them before meetings. We made a rule to have merge requests get approved by at least two people before we make the merge. Only a couple issues had to get unapproved because of some problems that some of us who approved didn’t catch, but most of them went through normally. It is also good that we were able to adapt to new technologies that we started working with when it came to test classes and issues relating to automation. Half of us mainly focused on the backend data and test classes while the other half worked on other issues for the backend and API, along with one of the sets of data and test classes. Despite the gap between meetings from before spring break and after the two cancelled classes when we came back, we were able to finish most of the issues that we had for that sprint before the review and only a couple were moved to the product backlog for the last sprint.

The big thing that was a problem for us was the gap between meetings. We were doing some communicating online to stay caught up with issues, but we can improve on that. While we were able to finish most of the issues and got credit for the weight of work, we were rushing near the end to get everything done and had those couple issues we had to push back to the backlog, and there was some disorganization because some of the issues were not being assigned to epics. We have cleaned up the boards and they are all organized now. We wanted to work more on giving better names and descriptions to some of the issues, not just for consistency, but also because some of them were vague or unclear. Lastly, we want to continue our plan with approving merge requests and then merging them outside of class, but want to stay caught up with them because the merge requests filled up for the last meeting of the second sprint and we had to go through each one like how we did before, which was using up time that could be used for other things. We want to improve upon this sprint and have the last sprint be the best one.

As for me and how I did with the sprint and team, I would say I improved from before because I was communicating more online than the first sprint, which was my main focus of improvement. I was more involved in discussions on discord about planning and issues, and I stayed the same for in person discussions because I already getting involved in person. Going forward, I want to try and comment more on gitlab issues if I have any questions.

https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeper-newbackend/-/merge_requests/13?

Making the data file for the category object that has the methods used in the category endpoints.

https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeper-newbackend/-/merge_requests/15

Making the test file for category to test the methods I made in the data file.

https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeper-newbackend/-/merge_requests/16

The endpoint name changes for the backend to maintain consistency.

https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeperapi/-/merge_requests/46

The changes for the endpoint names where they appear in the API to match the changes in the backend.

From the blog Jeffery Neal's Blog by jneal44 and used with permission of the author. All other rights reserved by the author.

Retrospective 2

The second sprint for my software development capstone class was on an honest note a bumpy road. The purpose of the sprint was to start the next level implementation of creating test files using mocha and chai also making sure the API is validated and can be bundled properly. Through the first part of the sprint the team has been very productive on keeping up with the issues we made for ourselves. After Spring break, our productivity started to plummet since we did not accomplish issues the following, we did not have our class meetings. 

As for my team members and I, we have faced greats issues that we started to come across that stumbled all of us. Due to facts of, lack of knowledge, merge requests, and was not able to accomplish all our issues for the sprint. First, when it came to merge request, I admit we have gotten better on how Git operates. But when it came to approving the request assigned to us. We had a pile of request that was not merged and had to spend our class meetings to squash all of time to keep the main repository up to date as soon as possible. Secondly, our productivity has plummeted since our spring break, we did not have to work on anything which was completely optional. But the following week we did not have any class meetings, we did not put in any effort at all and treated it as another extension of spring break. Third, as we gotten more depth of the issues, we did not have any knowledge on how to tackle certain issues. Because the remaining issues were dependent on each other to complete thus since we could not complete them, we had to tackle them towards our next and final sprint. 

Our team has reached a verdict to not stagger on our productivity. Especially when the third sprint is going to be our final one for the capstone class. We decided and wanted to be more proactive and aiding each other’s workspaces when there is possibly something we don’t know or don’t understand. Talked about gathering information from our professor on any recommendations he may give to us to set us on the same page. 

In regards towards myself, I had made good achievements but of course I as could’ve made better improvements that could’ve better contributed to our team. I wanted to learn more about how to implement Mocha and Chai testing. But I chose to do more of the basic parts of the issues to get them out of the way. But for the next I will be taking at least one or two issues that we made to create a more solid test file for all the tests to pass. I will be speaking to my team member that did extensive research to see if he can aid me in how to go about fixing and implement our test files already made gave at least the experience. 

Sprint 2 Issues

From the blog cs@worcester – Dahwal Dev by Dahwal Charles and used with permission of the author. All other rights reserved by the author.

Sprint 2 Retrospective

Our sprint went well we wanted to finalize major features on the front end and the back end in order to have the necessary fully functioning for its operation. Our group collaborated on creating sprint objectives that we all agreed were important to focus on in the sprint. We ordered our work items in order from most to least important, which was helpful in focusing on getting the most relevant work done first. This helped later tasks because the issues below were dependent upon other issues being finished first.

Learning lessons from the last sprint, we managed our code much more efficiently this time around. We created a small branch for each time we were going to make a change to the CodeBase. Each one of these branches only changed a small portion of the code or added a small feature. Once we finish this change, we will immediately submit a merge request and have it incorporated into the code as soon as possible. This minimized the amount of divergence from other branches while people were working on their code. We had large stagnant branches that diverged from the other ones in the last sprint, and merging them became incredibly difficult. This time, we did small branches in merge consistently, which kept everyone’s codebase on track. We also set up testing, which still needs further tests, but this allows us to ensure that our changes are not going to break essential features when merged into the main branch.

We had one issue that some issues were dependent on other issues to be completed first. When one individual took longer than expected on an issue that required to be finished first before others could work on theirs, it left some students unable to work on essential features. In the future, it would make sense to re-distribute those tasks to individuals who were not being challenged or add another person to the issue to get it completed more quickly.

As a team, we did a good job at roughly keeping each other member aware of the current task we were working on. In the future, I think we could improve the detail of exactly what we are working on, which would help other team members adjust the priority of which issues they should be tackling. Overall, we did have a good improvement from the first sprint in communication. In this sprint, we also worked well at updating the sprint board and tasks as we finished and moved them onto the next stage.

For the final sprint, our team should work on creating broad goals that we want to achieve and turning those into smaller tasks that individuals can work on. At the end of the next sprint, our goal is to have a working front end and backend that can be deployed within a single docker container, and this will be broken down into smaller sub-tasks that each person can focus on achieving.

As I said for the teams’ comments, I should precisely make it what I am working on more well-known. This will improve the team’s performance because students will be able to choose their tasks better accordingly. I will enhance this during our standup meetings by going into more detail about my current tasks. I did improve over the last sprint and made sure to update the issues board so that two people do not work on the same issue simultaneously.

Issues Completed During Sprint 2


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