Category Archives: Sprint-3

Sprint-3

This is my final blog for the university, where I work hard for four years, hoping to become a software developer. The team and I finished most of the tasks for the project “Reporting. System”; it was challenging for our learning experience. There are struggles and realizations from mistakes and trials of multiple attempts that help and benefit understanding for further the learning experiences. Those learning experiences from the tasks were interesting and challenging to complete becoming more difficult than others for unexpected.

I am currently making a presentation and adding details from looking back at the tasks that the group and myself for how much we accomplished. Also, looking forward to graduation. After the team and I adjusted to the issue board required for the work and practice. I have done these issues over the semester for weight assignments that have been changed with a total weight of 2-3 is reasonable and practicable. Some are easy to do and understand, but others are challenging.

The Issue:

  • Remove MongoID leftover – Backend (changes). There are still MongoIDs available, and I will investigate this further. After I asked for feedback or assisted in making certain adjustments, the result seemed to be an improvement, and the team concurred.
  • backend — Write a test suite for API (changes); This activity writes tests in Chai, ensuring that the backend works with the API while ensuring you get a file back in .xls format (get the simple tests working).

My still challenge concerning one of these tasks is researching the topic of “Chai.” the topic is still questioning the existence of a library written in JavaScript with different test frameworks. It provides that your code continues to work as intended by attaching to the assertions set up. Like npm install chai, chai-HTTP, chai-as-promise, etc. Those additions make the process simpler, but it doesn’t look good. It has already gone through the potentially functional aspects, even after the review, code addition/construction, and code comparison phases.

After I got the chai working correctly, I learned the backend server kept shutting down due to missing files, leading to some codes not passing. The team and I backed up the system by going back to find those files and running for testing; the first half is working (the version number), and the second half won’t. (missing data from the database). 

For improvement, I prepare to find information about this issue from my group members and others by asking others who have had this experience issue before. Even though the team and myself ran into more mixed technical problems during the development process, like missing files, which resulted in more delays that shifted the focus on the specific problem. Even that problem can help us better comprehend and learn new specialties to avoid misleading and repeated attempts. 

In conclusion, in the third and last university sprint, our team had a good time discussing and executing the tasks, though we tried to do some things to perform wildly well after the second-Sprint. We still faced some obstacles that became a fun learning experience for new topics.

From the blog Andrew Lam’s little blog by Andrew Lam and used with permission of the author. All other rights reserved by the author.

Sprint Retrospective #3

Hello Blog!

It’s time for my final sprint retrospective for Thea’s Pantry! 

For this third and final sprint, we were focusing on closing up issues related to the previous sprint and closing epics. My team was having issues with the automated testing and the test runner docker container. We were all previously working on our own tests, but because of everyone having errors with theirs, it was decided that we should all take the time to work on testing together to try to get at least one test working. And that we did.

The following are links for issues worked on, in collaboration with my team:

My team also tried putting our heads together to handle issues with the automated testing with test-runner, searching for any typos or missing components in the code that could be causing issues, and this work was also done in collaboration with another team.

What worked well was that we were able to spend this sprint working together more on issues and get through them instead of continuing to be stuck on several different issues at the same time like the last sprint. It also worked well communicating with another team working on similar issues especially when trying to handle errors they also faced so we could progress faster and get closer to tackling the issue.

I don’t think I have anything to say about what didn’t work well. I think communication was better this sprint than before and we all tried to look for things we missed in the code when trying to handle errors. I also don’t think I have anything to say for improving as a team. 

To improve as an individual, I think I could have spent some more time outside of class experimenting with the issues. Burnout and the buildup of outside commitments really hit me this sprint and the last, but I can work to improve my time and work management. Not too much time has passed since the last sprint retrospective where I said I hope to be more daring. I still believe that I need to work on being less afraid of breaking things when I make changes, but I do find security with how Visual Studio code shows some changes we made or displays some code before and after the change we just made. I also make notes of things I change to help keep track of what might mess things up, so I’m building my confidence with those.

This may be my last blog post, so “Good morning, and in case I don’t see ya, good afternoon, good evening, and good night!”

From the blog CS@Worcester – CS With Sarah by Sarah T and used with permission of the author. All other rights reserved by the author.

Sprint 3 Retrospective

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/backend/-/issues/59 – This issue consisted of fixing up our tests and ensuring they worked.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/backend/-/issues/52 – We realized that we needed manual calls to be able to make sure that the call would actually be able to work before we tried to create the chai tests.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/backend/-/issues/54 – Same issue as issue 52

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/backend/-/issues/62 – Same as issue 59

This sprint was much shorter than most of our other sprints. We only had about a week and a half to actually work on the code within class, so this led us into working on the project outside of class more. This sprint there was also a lot more teamwork between the different groups, as we all were running into the same issues. The GuestInfo group were extremely helpful in helping us finally fix our test-runner docker container, as well as helping us fix some of the glaring issues that were riddling our tests. We did not go back to our old ways in the previous sprint, and we all tackled each issue as a whole group, which allowed all of us to have input and give possible solutions to issues. This worked well as it made the whole group feel like they were involved in the process and no one was left out.

I do not think I can point out anything that we could do better if there were to be another sprint. We all worked together well, we were in constant communication through out the whole sprint. This ensured that no one was lost on any of the issues we were working on, and everyone was on the same page as to what path we were taking to fix an issue.

I assumed my role as scrum master again this sprint, and I felt I did a good job at managing the whole group, communicating with the other teams to be on the same page when working in groups and working on a singular issue together. We did not have a discussion on who was going to be the new scrum master, but everyone just assumed I would take back over as the sprint was very short and we were not working on any new issues, just fixing the ones that we working on from last sprint. One thing that I could have improved upon is my time management skills. In class I felt I did a pretty good job at managing how long it would take to work on certain tasks, but when I am at home those skills seem to vanish. This is probably due to the many distractions while I am at home on my personal computer and my pets. The remedy this I could starting doing most of my outside work at my job, where I am left alone and kind of forced to work on my homework with no distractions.

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

Sprint 3 Retrospective

Sprint 3 is now completed and it is time for the final retrospective. Although this sprint was shorter than the others, my team and I made good progress on our substem. With two other sprints under our belts, my team was able to complete what we needed to so everything would be wrapped up and ready for next year’s class to work on it.

A change we made that helped the team was breaking down our issues better as well as working together to tackle those issues. Our goal for this sprint was to have a completely working test so we broke down the process of creating the test into several issues. With everyone working together on the code, we were able to get through each issue quicker than we would have as individuals. We still faced challenges but being able to rely on the other members of the group was a big help.

Something that my team could improve on is understanding docker and using the servers. The most difficult problem we encountered was counting with the server. Our first few issues were not too difficult and we were able to solve them relatively quickly but getting the test to run automatically by connecting to the back-end server was difficult. We first ran into issues just connecting, then we had issues with the server timing out. We relied heavily on the guest info system group for help with this. Docker and the severs are a huge piece of this project so a better understanding of how to get everything working would have been a huge help to the team.

In this sprint, we only worked on the backend since our object was to get an automated test up and running. Our issues were mostly worked on as a group. The following are the issues that I was involved with for this sprint:

One of the easier issues we had was reviewing the current API:

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/inventoryapi/-/issues/8

Creating the getInventory manual test was another one of our issues:

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/backend/-/issues/54

Another issue we worked on was fixing the get inventory returning a string bug:

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/backend/-/issues/60

As an individual, I believe I could improve by working on my collaboration. Even though my team asked for help, I personally did not. During this sprint, I relied on my teams to go and ask questions to the other groups. I think as an individual I could take more responsibility when it comes to collaborating with other teams.

I think sprint 3 was another positive experience for the team. We continued to adapt and make the changes we needed to that we talked about from our previous sprints. This allowed us to better ourselves as developers and get through the issues we decided to work on. Even though this is the end of time together working on LibreFoodPantry, we will take the lessons we learned with us as we start our careers. 

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

My Third Sprint: A Lesson in Legacy

                With the ending of my last sprint in my capstone class I have completed my first of many cycles of development. Throughout this series of three sprints I have gained a better understanding of what I can expect of myself and how I can begin to improve my performance in an actual working environment. This last sprint, like the previous two before, taught me new concepts that I had not previously considered when going into the sprint. Throughout this sprint, especially in the last two weeks, the mains idea that stuck out to me was that of legacy, and what our group leaves behind for those who are coming next.

                When beginning this sprint, I had first focused on what was laid out during the planning session, involving the implementation of docker and containerization in general on to our identity access management system. The system worked when running on the operating system without any overhead so the next step was to get it working with docker to later be adapted to the Kubernetes clusters being used to host the Libre Food Pantry system. On the second of three weeks into this sprint, it had occurred just how close we were to the end of our journey and I began looking at the other spring backlog items. The one that struck me as most important was working on refining existing tutorials within the GitLab repository for the next group of developers to be easily able to get up to speed on what has been done and what needs to be done.

                As in previous sprints, time estimation, while once again improved, was a problem for us. This was especially noticeable as the end of our journey loomed closer.  While we had not gotten as much done as we would have liked to, we had made a concerted effort to condense our findings into the important information and save it to the GitLab repository for future groups to pick up on.

                Our group was tasked with creating a presentation for the end of the semester and this helped us to filter unnecessary information and include only the most important parts that applied to the project at hand. To go along with this I myself had even created a tutorial video that exemplified all of my own findings which would allow new groups to create a secured application with key cloak. Despite being a basic webpage, it is better to start with this than with nothing like our group had.

                As a group we can still improve not just on our time allocation but also our recording of information. Being able to properly record our finding as we make them is important in allowing both the group and future developers to have easy access to pertinent information regarding this project. I myself could have made this a focus as I performed research from the very beginning and would have had a library of information for it.
                Aside from this however, I still have a long was to go in making an effort to communicate with my peers. I often find myself “suffering in silence” whenever I run into a roadblock and, just as before, I tend to withdraw and become distant which benefits no one at the end of the day.

                Overall however I can say with certainty that there is a foundation here for future developers to work on. Our legacy will have an impact on future progress and provides a point for future groups to jump off of in order to finish what we started. The updated ReadMe created in the repository will hopefully hold useful information to users that takes away from the research that would have been spent on getting key cloak working in the first place.

GitLab Contributions: README.md · KeycloakWithoutDocker · LibreFoodPantry / Common Services / Identity and Access Management System / Keycloak Research · GitLab

From the blog CS@Worcester – George Chyoghly CS-343 by gchyoghly and used with permission of the author. All other rights reserved by the author.

Sprint Retrospective 3

The third 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 and 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 in 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 great 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 merging requests, I admit we have gotten better at 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 squashing all of the 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. However, the following week there was no class reunion and I made no effort and treated it like another extension of spring break. Third, as I gained a deeper understanding of the problem, I didn’t know how to deal with some of the issues. The other issues couldn’t be resolved and were interrelated, so we had to address them in the next final sprint.

Our team decided not to undermine our productivity. Especially if the third sprint is the last race in the podium category. We decided and wanted to be more active and help each other in the workspaces when there are things we don’t know or understand. Talk about gathering information on all the advice our professors can give us to put us on the same page.

As for me, I have done good things, but of course, I could have made better improvements and made a better contribution to our team. I wanted to know more about how the Mocha and Chai tests were implemented. However, I have decided to do more key pieces to solve the problem. However, in the next problem, we will use one or more of the problems we created to create a more robust test file that will pass all tests. Talk to team members who have done an extensive research to see if they can help you with modifying and implementing test files that have already been created. At least the experience provided.

Sprint 3 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 retrospective 3

Here in sprint 3, things seemed to have progressed smoothly with the project in that we have finished most of what we have added in the product log although there were some areas of difficulty. The cohesion of the group has improved with better communication on what is to be done and the planning together seems to have gotten better. There are still improvements to be made but overall, the project is in a good state right now. The presentation also seems to be going well and should be alright. The quality of the sprint overall seems to be up and is providing good results.

On what has worked well, we have managed to get to the end of the semester and be able to finish a good amount of work on the project. We added more calls to the backend and continuously updated the API with new changes. The backend is set up with the proper semantic versioning. The android nest tester is functional and everything that we have built looks to be solid. The communication in the group looks to have improved as people communicated on what they did and were working on more than in previous sprints. The team also seemed to have gotten together more often to work on issues. The group stuck to what was planned pretty well and followed the timeline agreed upon. The issue board moved along more than the last sprint, issues were moved across the board compared to last sprint where nothing was moved until the last day.

On what has not worked well, there was unfinished work at the end of the sprint that now has to be sent over to next semester. This means that we have made mistakes during our planning on the difficulty of the work on the issues. The planning of getting the presentation done also could have been better. There probably should have been more dedicated time to get together and figure out the presentation as it felt a bit odd at the end figuring out what topics to do.

We could improve as a team by firstly, we could have worked together more regarding the issues regarding key authentication that we were unable to implement. There could have been chances to get together and try to figure out what was wrong and get it done by the end of the sprint. We could also improve as a team in our planning and plan more effectively on what can be done this sprint. We also could have been more planning with the presentation and knowing what exactly what portion each member was contributing with.

I could improve personally by putting in more of my input and getting my ideas out there. I also could have contributed more on different issues within the project. I also could have done better with working together with the group members such as when we were working on implementing the range call where it felt like backseat coding and I could have contributed more.

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

Sprint Retrospective 3

Everything under source (src) in backend was written except for the final test files and API was also complete. We were waiting for more information about access tokens and Gitlab access keys from the IAM team. We were also waiting to hear from AWS team on templates for Kubernetes system but did not get any response. We were at the same time researching on how to import API bundle into backend so we could start building the backend server and to at least test if everything from our side was working properly.

We needed to bundle our API before we could export the file to backend and ‘npm run bundle outfile.yaml` was not working. After fixing minor issues in the API, we got our bundle file. Even after a lot of research, readings and experimentation, we were not able to connect API bundle to backend, something would not work and kept getting different errors. At this point we decided to copy the bundle file and paste it into backend lib folder manually. Since we were not able to import the bundle file, we decided to not work in main and created a separate branch called ‘issue10’.

We made a lot of mistakes from this point on. We were all working on this branch instead of making our own branch based on the issue10 branch. We also worked only on one team member – Christian’s system. We added and modified a lot files like entrypoint.sh, package.json, package-lock.json, docker-compose.yaml, Dockerfile, etc. We should have created branches based on issue10 branch, then created specific issues with proper weight assigned to them. After making all the modifications we could think so, we still were not able to build our backend server.

At this point, Dr. Wurst pointed out that we do not have frontend, which means that our docker file will not be copying yarn file and running yarn install but instead copying the package-lock file and running npm install. After making changes in the Dockerfile, our backend server was finally able to build but still could not stay up. After going over docker container logs we finally came to the conclusion that the problem for this was in the port. We had not specified proper port in many files. Once those modifications were made the backend server was up. Till this point, we were all still working on Christian’s system, without any proper issues, comments and documentation for modifications that were being made.

I created my own branch based on issue10 and then wrote calls for cooking method. However, when I tried to build the server, I got the error that docker-compose is not installed even though I have used it many times before. Using the solution, I found on stackoverflow I was now able to build the server but the process would hang up on the attaching stage. I tried running docker-compose up command after opening the branch in container. This led to an error saying ‘docker not found’. Another team member Jeffery had the same problem as mine but was able to find a solution for it and then was able to make calls. However, the same solution did not work for me. After trying everything I could find on the web till 4 am, I finally gave up.

In the next meeting I shared the calls I had written for cooking methods with the team so they could be added to the project. Noticing that I was the only person who was working on a windows PC I decided to run the project on a friends MacBook and surprisingly it worked. I did not research further into why it would not work on my system since I had limited time with the Mac.

I worked on cookingMethod.js and cookingTip.js test file. I set three constant variables: getAll, getOne with valid ID and an invalid ID. getAll would check for ‘200’ response and data in form of array. getOne with valid input would check for ‘200’ response, ID, object and value. getOne with Invalid input would check for ‘404’ response.

Links to issues:

Calls

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

Backend Debugging

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

Modification of files

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

Cooking Method test

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

Cooking tip test

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

P.S. – I apologize for this retrospective being more like a summary. It proved difficult to classify the process in what worked and what did not work sections for this sprint.

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

Sprint 3 Personal Retrospective

This final sprint was much more of a struggle than the other two prior sprints. Since we got a lot of progress done in achieving our goals throughout the past two sprints, we figured that this sprint would let us bring everything together and finalize everything we have worked on up until this point. Unfortunately due to unforeseen issues, we were unable to reach all of our goals, an we were instead stuck on one task for a vast majority of the sprint. Our goal this sprint was to test the backend and the endpoints to ensure that they can all work with each other in the way that we planned. We initially thought that we had solved many of the issues with the backend that have been plaguing us in the past sprints, but unfortunately that was not the case. In order to test the endpoints we needed to be able to run the backend, and when we attempted to do that we realized that what the previous group had left us was not configured correctly and was also missing a lot of important code. Upon realizing this, Kurt and I went to work trying to figure out what exactly was missing and preventing the backend from running correctly. This debugging took up a vast majority of the time, and in the end Kurt was able to figure out what the main issues were and managed to get the backend partially running. This was still not enough for us to get our endpoints tested however.

Given that this sprint was more of a challenge than initially expected, there are definitely things that we could have done better as a group in hindsight. One of the bigger mistakes I believe we made was that we didnt have everyone working on the backend problem. Since this was the priority, it should have been a team effort to try to solve it and get it running as fast as possible so that we can test the rest of our code. Unfortunately since in the beginning we didnt realize the scope of the issue we never organized the work in that way. Many of the team members were forced to wait until the backend was complete before they could try to do the tasks that they were assigned. However since the backend never ended up getting fully completed these team members did not have as many opportunities to contribute.

Given hindsight about my performance in this sprint, and knowing what the issues we faced were I can look back and see that there were definitely things I could have done better. One of the main things that comes to mind is my initial approach to trying to solve the backend issue. At first I simply attempted to brute force the problem, moving code and files I thought might be affecting the issue around in the project to see if that changed affected anything. This proved to be a useless exercise in the end and resulted in me wasting more time than I should have. If I could do it again I would approach the issue more slowly, reading through all the relevant code and researching what issues may cause the kinds of problems that we were experiencing.

I do not have any gitlab links to share, since I was unable to get the backend working and therefore had nothing to push. As I mentioned a majority of my work was brute force trial an error where I attempted to figure out the issue.

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

Sprint 3- Retrospective Blog

For this sprint, my team, team 1, managed to complete all the epics that we had, which were .gitlab-ci.yml, fixing API, modifying backend, finishing frontend, and completing documentation project. I believe my team is done with the API, backend, and frontend. A small portion of the gitlab-ci.yml and the documentation project are still in progress.

In this sprint, I have worked with backend and frontend projects. For the backend, first of all, I modified the API to reduce the number of endpoints from 5 to 2 which getReport and getVesion. Then, to send fake data without using any endpoints, I created a folder named send_Fakedata_RMQ. This folder contains two files, one is used to contain dummy data and the other one is used to create rabbitmq connection and send those dummy data to a rabbitmq channel. So, whenever we use the command of node ./src/send_Fakedata_RMQ/sendData.js, we are sending dummy data to rabbitmq. These data are used to test how the entire backend works. To automatically retrieve those data from rabbitmq and store them into mongodb, in the index file, I added a new method called RabbitMQ_service(). In this method, I used setInterval() function to repeatedly retrieving data from rabbitmq every day. The fixed time used to delay between each call should be converted from day to ms, 86400000.

For the getReport endpoint, I’ve added two new properties called new_household and new_people, which represent the two columns of the Newsince field in the example report. Furthermore, I also edited the csv.js file to make the getReport endpoint return the report in text form instead of downloading it directly to the computer.

For testing, I created two tests for this backend. One is used to test the response status, the other one is used to test the response data. To test the response data, I added a new file called expectedResult.js in the testing/test/lib folder. This file contains a string where each value in this string is manually counted based on dummy data I sent to Rabbitmq. This string is supposed to be my expected result which I am using to compare with the actual result recieved from the system.

One of the problems of the backend is about what should be stored in the guestInfo collection. Since I misunderstood the properties of the guest variable in json, I stored each guest as a unique guest in the collection without the “date” property. The requirement of this collection is that every record of each guest must be stored with a date and time, so this issue must be fixed in order to produce an accurate report in the near future.

For frontend, I added the same folder named send_Fakedata_RMQ from the backend to send dummy data to check whether the frontend is working or not. In getReport.vue, I added a method called downloadCSVfile(data) to download a file named WCFB_report.csv, when the “Submit” button is clicked. I also added a simple instruction of how to run the frontend in README.md. I believed we are done with the frontend and it works fine as expected.

For this sprint, we all focused and worked on different topics to perfect the reporting system as much as possible. Most of the time we worked well as a team, but there were still some points that I think we should improve in the future. Like what I just said, each team member worked on a different topic, so it is hard for us to keep track of all topics at the same time. Team members should actively share the problems they are facing so that the whole team can look at it and help them as soon as possible. Don’t stay silent and wait until the last minute without giving any reason to the team. I mean each team member should be aware of his/her responsibilities to the whole team. On the other hand, for myself, I think I should learn more about teamwork skills to ensure that every team plan is completed by every member before the deadline; or at least I can come up with some solutions to deal with similar situations.

From the blog CS@Worcester – T's CSblog by tyahhhh and used with permission of the author. All other rights reserved by the author.