Category Archives: Sprint 2

Sprint 2 Retrospective Blog Post

This second sprint has been a bit better in terms of actionable steps; this was aided greatly by the mock front and back end. The mock allowed us to test configuring a realm to a container locally which was the floor for proof of concept. Unfortunately, the lack of architecture made further progress confusing as I didn’t understand why all images couldn’t be on same container network. After it was determined that the architecture called for further subdivision, it became unclear what microservices should be on which image and/or network. For instance, it was more or less determined that Keycloak should be on its own separate container (presumably with WildFly) but at the beginning of sprint I wrongly believed, based on previous internet searches, that NGINX should be on the same image as Keycloak but this was later discovered to be unnecessary as the mock front end contains NGINX within our system.

On that same note, the task breakdown and codification into issues for the respective boards suffers from an incongruity where ignorance of the matter begets ignorance in the approach and then future work is inaccurately reflected in the process. This isn’t necessarily an issue with the approach as whole but it seems as though, for the past two sprints, this unfamiliarity with the microservices and their implementation into our architecture forced me into a series of micro pivots which quickly evanesced away from the originally declared issues. If the goal of scrum is not to constantly be inundated with creating issue cards, updating them, and closing the now obsolete ones, then perhaps it would behoove us to reconsider the amount of research time necessary or have a much more closely-guided approach to issue construction. If this rapid pivoting away from cards is acceptable (and their grades reflect this) then that’s not particularly bad news for students. However, we have to be honest with ourselves and have the hard conversation that Scrum in this setting does not accurately map to what Behr, et al. would refer to as WIP (work in progress).

The low-hanging fruit of constructive team feedback would be the necessity of more frequent external meetings. It certainly was not for lack of trying; the most charitable reading of the situation was that I found there to be no strong consensus on when the team schedules would align. We also would have benefited from more frequent contact internally. Barring all real-world, unforeseen, obligations that took team members away from us the scattering of the team into groups caused our reviews to be staggered resulting in the loss of two full class periods of collaboration. My prescription for this would be that those who come after us should successfully drill down on establishing a running prototype before splitting off into the other groups.

My individual criticisms to my work flow largely still touch on the externalities I’ve lamented in a prior blog post but, if I must touch on them briefly, they’ve stayed mostly the same. It’s quite apparent that certain teaching staff in the university have struggled to pivot to remote teaching and, if I’m to attribute to ignorance and not malice, they seem to have bequeathed those struggles to their students. To those teachers I would like to remind them that Monday holidays are not a surprise and certainly not an invitation to delegate away your teaching responsibilities because you’re lagging behind curriculum milestones. If these teachers cannot grade in a timely manner, then my deepest sympathies, but please do not complain that the bulk of your students keep getting concepts incorrect and you have to re-grade their assignments and/or assign extra credit to help inflate grades. I’m a commuter student with one semester until graduation so I will stay here at Worcester State; if I was a commuter student with two semesters left, I would have transferred out.

https://gitlab.com/nanuchi/techworld-js-docker-demo-app
When paired with their “Docker Tutorial For Beginners” has been an invaluable resource to teach myself Docker and use continuously as a reference.

From the blog CS@Worcester – Cameron Boyle's Computer Science Blog by cboylecsblog and used with permission of the author. All other rights reserved by the author.

Sprint #2 Retrospective Blog Post

The second sprint of the semester started a bit rough for me with my surgery, but I was able to get most (if not all) of my work done throughout the weeks we worked. I was able to help a lot with creating the cards and giving them descriptions at the start, and then the first week or so of the sprint I was very busy. After this initial period, I was able to catch up on my work and get a lot done. I was primarily in charge of getting an updated example of our front end based on an old one that was provided to us from previous years. For this, I used google forms, but in the end I had to take screen shots of all my work and upload those in case the forms document that I created got deleted or lost. This will be helpful for our team and for any students working on this project in the future. There is still a bit of work I need to do on this example to make it perfect for what we want, but this has been added as a small task for me to complete in the next sprint. Overall, our entire team did very well getting a lot done, and although I did not get the backend coding assigned to me, I was able to lend my insight and some advice and code to my teammates. This sprint was a lot different than our previous sprint primarily because it had less to do with learning how to use cards and work in a sprint and had more to do with getting real work done to further our progress on this project. I presume that the next sprint will be even more important, and we will have a lot of hard work to do to try to complete all or most of our cards. Some things that worked well this sprint were our team’s hard work ethic for getting everything done and our ability to communicate well and let each other know what needs to get done and what we need help with. For this sprint, we actually added a member because of the IAmSystem team splitting up after the first sprint. This was not a problem at all and in fact was more helpful because we were able to get even more cards completed over the couple of weeks we had to work. If I were to change anything or expect anything more from the next print, it would be that I personally will be able to get a lot more work done earlier in the sprint without having a surgery as a distraction. I am excited to see how far we can get on this project by the conclusion of this semester, and hopefully we will be able to get a nice looking and working project by the end. This whole experience has been great for me so far for learning how to work in groups for sprints, and I know that after college I will run into many projects where I have to work like this.

From the blog CS@Worcester – Tim Drevitch CS Blog by timdrevitch and used with permission of the author. All other rights reserved by the author.

Sprint 2 Retrospective

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

(Read over/review UpdateGuestInfo for frontend): In the comments, there is detail on how to frontend will function for a guest info update. In case of a new guest or old guest, the ID will be entered first and then the guest will be accessed if they exist.

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

(Implement components/schemas to be used in backend endpoints): Updates were made to the OpenAPI.yaml file. These included new responses, corrections to schemas, and corrections to endpoints.

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

(Implement API for backend endpoints in Node): The title is self-explanatory here; I implemented the GET route while David implemented the PUT route, as well as updating all the example files to fit GuestInfoSystem rather than items for InventorySystem. My chages occurred in endpoints.js and guest.js

As far as our timing within the sprint, we did much better this time than last time. We made use of due dates and stuck to them, even if refactoring was necessary afterwards. Our goal was getting working backend code up and shared with the group. From here, everyone was able to be on the same page in a timely manner. We also made better use of communication within GitLab, mainly in the cards and via merge requests. This way, even if Alex, Tim, or Cam was not working on the backend, they would still be able to see the code and understand how it functioned.

            We still have some significant improvements to be made as a team, though. Even though everything was made more public through cards and merges during this sprint, getting everyone on the same page insofar as how the project as a whole was functioning seemed to be lacking at times. This definitely slows down progress as there was separation between the backend development (what I was mainly contributing to with a great, great deal of contributions from David) and EventSystem and KeyCloak development. I’m still not sure if everyone is grasping how deployment of the system is working with Docker. We still need to be communicating and collaborating more than we are currently, as well as asking more questions if everyone is not in synch. This leads to some ambiguity on division of labor as well. We tend to be working linearly (with some people waiting to work on their part) instead of in parallel. This is where communication needs to be better, as well as planning.

            As a team, we should be communicating better during our time in class. I think I had the assumption that everyone was on the same page when no questions were being asked, which I don’t think was necessarily the case. This would help the pace at which we worked for sure. There is little progress to be made without a thorough understanding of the system. Coming up on our last sprint, there is no time to waste. I would hope no one feels uncomfortable asking questions though; as Apprenticeship Patterns states, expose your ignorance. And perhaps it’s just a lack of articulation in our cards. We have been better in using our cards, but I’m sure they could still benefit from more detail.

            I think I should be better in organizing with members from other teams, especially for the frontend. I wasn’t sure how the backend would be working, so I put off frontend development in favor of the backend. I definitely feel comfortable with that now, but I also feel kind of behind on the frontend. I expect this upcoming sprint to be exactly that: a somewhat hectic sprint. We have our work cut out for us, so focus is the name of the game. Organizing with members of other teams should be greatly beneficial, especially with my beginners Vue.js status. 3 minds are greater than one!

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

Sprint 2 Retrospective

Photo by Kaique Rocha on Pexels.com

During our second sprint for the InventorySystem project, we focused primarily on getting basic “skeleton” systems in-place. By this I mean that we tried to get simpler versions of each of our components working so that they could be used as a baseline for future development. The frontend, backend, database and IAM (Identity & Access Management) systems were focused on primarily throughout this period of work.

I would say that we likely had a proper amount of work planned for development, during this sprint our team was actually bigger, so it was a great help to have more people around to work on development tasks. Because of the larger team, we were able to split-off and each focus on a specific area of the project more effectively.

Two people focused on the frontend (one person worked on one of three necessary frontends each) since there was the project requires multiple front-end interfaces to function. One person focused on the IAM system specifically, and one person focused on the backend system initially. As the sprint progressed, everyone generally was able to complete the majority of necessary tasks, and the project went from having lots of documentation with little working code/examples to having a collection of basic interfaces and systems.

One difficulty I faced specifically was in trying to decide on the appearance & layout of the frontend I worked on during the sprint. Because the preexisting site for the food pantry exists only as a page on the main WSU website, I didn’t have much to go off-of for design besides the general color choices and logo design provided by the university. Something which I found helpful was to organize a meeting with the other teams working on the project, and to ask some questions regarding their process and design choices for their own front-ends. Additionally I was able to get some good advice and feedback from others on my own team based on the development of their frontend components for the project.

I think that having more team members definitely helped our team to be more productive, the process of “splitting-up” tasks worked a lot better this time around because of it. Previously the idea of each person “specializing” seemed harder to achieve, as despite the benefits of distributing the work, there were less people overall, and focusing on one thing meant that other areas would lose out on development focus. Now having a bigger team we were able to use this to our advantage and distribute work more effectively throughout the sprint.

In terms of communication, we used GitLab throughout this sprint to coordinate our efforts, and it seemed like everyone was more used to the process of creating issues and communicating concerns/ideas regarding those issues throughout development. Here: https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/inventorysystem/community/-/issues/36 is one of the issues I worked on, and generally I tried to include things like screenshots of the work I was doing, links to the repository for any code or examples I had worked on, and descriptions included in the comments regarding the process and anything I might have concerns about. Other team members used Gitlab similarly, posting links to relevant resources which could be helpful to others, linking to their work/posting screenshots and describing any difficulties or issues they ran into. Overall I think it has been an excellent tool for organizing our work for the project, as a place to discuss problems related to it, and as a major source of reference.

Conclusively, I think that this sprint went well, and we were able to get some good progress in over the course of ~5 weeks or so. The increase in the size of our team, being used to the process of using Gitlab for coordination, and overall focus on creating “useable” mock-up and skeleton framework code seemed to allow for increased productivity during the sprint.

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

Sprint 2 Retrospective

Backend Example: https://gitlab.com/LibreFoodPantry/training/spikeathons/winter-2021/stoney-manage-items/backend

For the second spring, our team focused on developing the frontends, backend, and keycloak of the inventory system. But a big problem the team encountered during the sprint is that to develop the inventory system, we had to learn all this new material such as Vue.js, Express, and API. Even though I was introduced to these concepts last semester, it’s still comparatively new next to all the time in college where I used Java and C++. And even though we had the entire first sprint to get familiar with the material, actually applying it to a project is a bit more difficult. It caused the progress on development to lag and a decent chunk of what was planned for the sprint didn’t get finished, like writing the API for example which was my responsibility and I’ll get to that later.

I worked on developing the backend and event system components for the inventory system during the second sprint. For the event system, I met up a couple times with the team members working on the event system from other teams. We talked about how our systems were going to communicate with each other to the point I at the very least know what to implement on my side. The inventory system just has to send messages to the reporting system whenever the inventory goes up or down and it will do that through a JavaScript file called “send.js”. I also managed to create a base skeleton for the backend which is heavily based on an existing example which I’ve linked above. I also tried to write the API but I didn’t really manage to finish it well enough and even though I did work with APIs last semester, it’s been a while. I feel that the biggest reason for the unfinished API is because I didn’t even study API during sprint one, I mainly studied express. All of these tasks most of what I did during sprint two outside of a few miscellaneous things that don’t come to mind immediately.

On what to improve as a team, I can’t really think of much outside of trying to keep up with the new material because I feel a good portion of the class is dealing with the same problem. I feel that the inventory team is doing decently all thing considering. As an individual I could improve on my knowledge of API and some other subjects by using the inventory system wiki more. I could also try and free up more time to work on the system since I planned to work on the API some more and I barely got anything done since I had a test last Friday and I have another test this coming Tuesday. I might have time on Tuesday afternoon or Wednesday but I also have other classes that I have to keep up with and I should also set a concrete goal or write a to do list to guide myself. I just came up with that and it sounds like a good idea so I’ll stick to that plan.

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

Sprint 2 Retrospective

It probably goes without saying, but this sprint certainly seemed more effective than the first. This is essentially a given, as a good portion of the first sprint consisted of figuring out how to work within my team in addition to adjusting to the teams shifting around a bit. After this, I feel as though we were able to accomplish everything we set out to, and a little more in some circumstances. Though this sprint certainly was not entirely bereft of some issues, at least with my own contributions to the team. Other than these though, I am satisfied with how this sprint went.

After adjusting to being embedded into the InventorySystem team, the sprint went very smoothly. Initially I had some difficulties being in a community of practice and the team, not really knowing if I should be meeting with others from my COP. We ended up establishing some meeting times and help each other with some parts of Keycloak. We were able to find a method of connecting our mock frontend app to keycloak, in addition to developing a logout function. Additionally, both Keycloak and the mock frontend app were containerized in docker. These were the major issues that I had focused on this sprint and all were effectively completed. Beyond myself, the InventorySystem seemed to accomplish many of the issues, with the exception of maybe one or two, that were posted for this sprint. One part that I felt did not go entirely well was how exactly I could help out the InventorySystem team. It might have just been the nature of the issues I had involving just using Keycloak, but I was concerned that I could have been helping them more in some way. Other than this there were no real issues that I could think of.

Despite the overall success of this sprint, there are a few more thing that I personally feel could change to improve the next sprint. I should clarify that these changes are entirely with myself, the first of which being what I felt was my own lack of participation in the InventoryTeam’s issues. I did not feel like I involved myself enough, this is also the reason why I cannot really speak on how the team can improve. As for changes I can make, I will simply try to involve myself a bit more, if not through taking up some of their issues then just through communicating more. I will try and ask where they are at throughout the sprint so I am more aware of what is happening and, ultimately, when I will be implementing Keycloak into the system. Additionally, I still had some struggles balancing my work for this class with some others, but I have been working on improving this for the next sprint. I have been sticking to the time I have set aside for working on schoolwork and have, at least, kept up. In conclusion, I am very pleased with my current progress going into sprint 3 and am excited to finally finish implementing Keycloak into a system!

From the blog CS@Worcester – My Bizarre Coding Adventures by Michael Mendes and used with permission of the author. All other rights reserved by the author.

Retrospective #2

There is one month left in the semester and it is already time for the second retrospective blog. This was certainly an interesting sprint due to the unprecedented pandemic that took the world by storm. Luckily, it doesn’t hinder us too much as technology exists enough to where we can still collaborate with our partners and other teams thanks to discord, Zoom, Gitlab, etc. To begin this post, I’ll be posting links to the progress I made this sprint.

This is thew link to our database repository because I had to modify it to reflect the new changes that were made after our meeting with Joanne. I am also using this link to show that the branches have been merged because I am no longer testing it.

This is a link to another one of my closed issues. This issue pertains to connecting the database to the server. While, I haven’t figured it out quite yet, there is a link in this issue with a tutorial that I have been using to experiment connecting servers with databases.

There wasn’t a large amount done by me on this sprint due to the COVID-19 outbreak which caused us to have a whole extra week off of school, and completely shifted us to online learning. However, there was a large improvement from the last sprint. Our Gitlab use improved immensely between sprint 1 and sprint 2. We started using the “blocked by” features to make sure issues were getting done in the order that they had to be. We also started commenting more on our issues, so everyone can see our progress rather than just our group knowing what we did. Also, I feel like our communication worked better compared to last sprint, but it could definitely still be improved.

As for what didn’t work well, I think that I could have gotten more work done for this sprint seeing that I only worked on database stuff for this sprint. I also feel like were still only involved in our each individual part of the project when we need to be more involved in each others parts. I also believe our communication with other teams could still use some work especially for this upcoming sprint because if we have time, we need to work on the aesthetic of our web application.

When it comes down to improvements, I know that I can try to work on a little more for this upcoming sprint. Once I figure out how to connect the database to the server, I can then move on to starting my work on Docker and helping everyone else with what they have to do, and hopefully we’ll be able to get to aesthetic because I feel like I would be helpful on that front. As for the team improvements, I still think that our communication with each other could be improved. For example, we can have more zoom meetings with each other and show each other our work. I also think we should talk to the other teams as well because they might be able to help us with things that we are stuck with. Besides that, I think our team is in great shape for the last sprint.

 

From the blog CS@Worcester – My Life in Comp Sci by Tyler Rego and used with permission of the author. All other rights reserved by the author.

Sprint 2: Retrospective

It’s time for another sprint retrospective. Last sprint, our team focused on researching needed technologies and structure of our micro-service. This sprint, our team focused on implementation.

We started with deciding coding standards and preparing for the visit with pantry staff. We decided to follow the principles of the first five chapters of Clean Code: A Handbook of Agile Software Craftmanship by Robert C. Martin. Lucky for me, I was reading these chapters for my software process management class. We also decided our code formatting standards, so collaborative work does not get reformatted constantly. After these issues were completed, it was spring break and I started focusing on solo work.

Last sprint, I learned how to implement and test a Mongo database with a schema defined by the Node.js package called mongoose. With this knowledge, I started implementing our micro-service’s database requirements. I designed a guest schema with all the data fields from the register team. Due to the nature of our update service, our schema does not require any data field except for the guest id. I also added an additional date field for when the update was made that is automatically added. I then wrote tests for checking the schema and the interaction with the database using mocha. At this point I decided to wait for my work to be reviewed by my team and started work on implementing our endpoints.

Our service only needed a few endpoints, a POST for new updates, a GET for obtaining an array of updates from a range of dates, and possibly a DELETE. I managed to get a couple endpoints started before my previous work was reviewed. After the review I had to focus on the guest schema again. While I did not focus on the endpoints after this, I did manage to fix up the incomplete GET endpoint when I had the time.

My focus for the rest of the sprint was getting the schema work ready to be merged. The review process was much longer than I had anticipated. With my merge requested branch bringing a lot of changes, the issues I needed to fix were diverse and plentiful. The issues ranged from simple oversights, to writing documentation. At this point, the schema branch has been through many changes and is nearly completed.

The rest of the work I did was reviewing my team’s work and familiarizing myself with it. The rest of my team worked on the front-end, implementing our UI and how to test it. At this point, our team has the UI design completed or nearly so.

Overall, I feel good about the work that was completed even though it took longer than expected. I think we have improved our teamwork since last sprint. The main lesson to learn from this sprint for me was to expect a lot of editing and to assume issues will take longer than I initially guess. Something we could improve on is the scope of our issues. Many of our issues could have been broken down into smaller issues that would be quicker to complete. After last sprint, we gave a work-in-progress limit to our review column to try and force reviews, but it ended up getting clogged by wide scope issues with a lot of work to review. I believe our team will be able to continue work on our micro-service and hopefully be able to have some functional software after next sprint.

From the blog CS@Worcester – D’s Comp Sci Blog by dlivengood and used with permission of the author. All other rights reserved by the author.

Second Sprint Retrospective

This week concluded the second sprint with my work on the UpdateGuest team developing for LibreFoodPantry. This sprint was exciting as we began creating the implementation of our service.

One of the first issues I helped work on this sprint was coming up with questions for the Thea’s Pantry staff member for when they came to our class.

During this sprint our team also focused on improving working together as a team as were beginning to implement our service.

An issue directly related to this included standardizing our IDEs as we prepared to code together on this project.

Secondly, as part of learning to code as a team I also re-read the first five chapters of Clean Code by Robert C. Martin to review best coding practices.

Additionally during this sprint I helped to implement the web interface for our frontend service where I began to learn how to use Angular again and also learned how to use Angular Material. This issue has two merge requests associated with it, one mainly adding Angular Material to the project, and another adding the implementation of the Web UI.

During this sprint I also reviewed and commented on two different merge requests. The first merge request was for implementing MongoDb for our backend service. The second was for the front end architecture document.

Individually, I think I am getting better at becoming a Scrum Master and learning to listen to other people during our meetings as I help to facilitate them. Although I have found it harder to do this when we switched to online meetings as sometimes it is harder to hear people talk than in-person. During the final sprint I would still like to improve on my ability to listen to other people’s suggestions, both during meetings and on GitLab.

I do think I need to get better at being patient with the rate that changes are made. This issue specifically occurred with a merge request when I directly made changes to a branch without asking first (even though I figured I should) as I thought it would be quicker than submitting another review for it. I do regret doing this as it led to a small conflict. We did resolve this issue and as a team we have made a new working policy that helps address this issue, so each developer only works on their branch individually to help avoid merge conflicts, in addition to helping with this issue.

As a team I think we did good this sprint. We finished several issues early on in the sprint and I am particularly happy with the work that was accomplished for the backend service and the web UI. I think that our team was also better at communicating this sprint and that we have improved our communication on issues and our use of GitLab to coordinate and communicate with each other. I also think we had some great collaboration this sprint with reviewing each other’s work, discussing and implementing suggestions, and even having multiple people working on the same branch.

I also think there is further room for improvement with our communication over GitLab and in meetings. Improving GitLab communication is especially important since we no longer have face-to-face meetings, and GitLab is where most of the remaining time discussing issues and work will be spent in the upcoming final sprint.

I do wish we were able to finish all of the issues we planned on doing for this sprint, but I understand that given the many different events over the past month that other things just got in the way of this. Part of this issue also has to do with the weights issues were assigned during planning. I personally think I need to improve my weighting estimates for issues as this seemed way off for this sprint. I think this was part of the reason we were unable to finish all of our issues as issues became more involved and took longer than was originally anticipated when planning for the sprint. Additionally, I think as a team we need to break issues into both smaller and more defined tasks, that way the work is more defined and the issue weight can be estimated more clearly. These factors are something I have been trying to take into account for while planning for the last sprint.

Overall, I am looking forward to our upcoming final sprint and I am excited to see if we can finish the UpdateGuest service.

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

Sprint 2 Retrospective

Overall, I think the second sprint was somewhat less effective than the first for my group. Unlike the previous sprint, we had some problems that prevented us from completing everything we expected to. I think the main issue we had was a lack of clarity regarding our goals for each issue. We have not been declaring a ‘definition of done’ for our issues, so we didn’t always know what we were working towards. The biggest example of this was the “Design frontend architecture” issue. We never had a plan for what our design needed to include or how it should be made, which caused this issue to get stuck in the ‘needs review’ column for most of the sprint as we tried to work out the confusion surrounding it. Additionally, I think many of our issues were too broad. For example, we had single issues for creating a database and implementing our UI which could probably have been broken into more specific tasks. We definitely underestimated the complexity of these issues and the time they would take, which made them difficult to complete during the sprint.

Despite the problems, there were some aspects of the sprint that worked well. I think our communication has started to improve since the last sprint. GitLab was used for discussion outside meetings more often, especially on the merge requests. I also thought that our in-class discussions were more effective. We did a better job using our time together to discuss specific problems instead of working on our own, especially after the transition to online meetings. Although the lack of clarity in our issues made the sprint difficult, it forced us to communicate more effectively so that we could help each other understand what needed to be done.

To improve as a team, we definitely need to be more specific with our issues. This would involve splitting broad issues into more specific tasks and creating a ‘definition of done’ for each issue so that we all know what to work towards. We should all look over our proposed issues to make sure they are small enough tasks, and we should add a definition of done that we all agree on to each issue. Ideally, this would be done during the planning meeting, though we can surely continue to fine-tune our issues during the sprint. If we are able to accomplish this while maintaining effective communication, I think our final sprint will be far more effective.

Individually, the main improvement I think I need to make is to keep better track of my teammates’ progress on their issues. So far, I have been completely focused on completing my assigned issues. As a result, I could never get around to familiarizing myself with the work completed by my teammates. This prevented me from reviewing their issues and approving their merge requests. It has also made me generally uninformed about the state of the overall project and where it is heading. I feel like I have not been contributing enough to the team, since I have been so focused on my own work. For the last sprint, I hope to participate more in reviewing my teammates work to both help the project progress and to keep myself informed. I think that making our issues more specific will immensely help with this. Having more manageable and specific goals would likely reduce my anxiety about completing my issues and allow me to spend more time assisting my teammates.

Links to my GitLab Contributions:

This is the main issue I worked on, where I learned about Angular testing. I left several comments informing the group of my progress and providing links to useful resources I found.

This is a repository I made to share my project where I experimented with Angular testing with the team.

These are issues that the entire team worked on. I left comments on some and moved some across the board.

I left a comment on this issue to inform the group of a meeting I had with the other teams in class.

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