Category Archives: Sprint 2

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.

Sprint 2 Retrospective

My team is about to move on to our third sprint, so I want to spend some time reflecting on how our second sprint went. Our plan for this sprint was to build a working demo of a Kubernetes cluster that we could deploy to AWS EKS. While we did not get everything done that we wanted, I am happy with the progress we made during this sprint. We got very close to deploying our cluster; the cluster is nearly set up, and AWS EKS has been configured for it. We are prepared to finish our demo at the beginning of our third sprint.

I think for this sprint, we had a much stronger idea about what we actually wanted to accomplish. Compared to our first sprint, this second sprint was much focused more on creating something than on research. It was easier to divide tasks into manageable issues, and it was clear what had to be completed with each issue. Not that the research we focused on wasn’t important, but it was satisfying to be able to apply that research to an actual demo.

In the same vein as the above discussion, having a more streamlined idea of what needed to get done did make it a little more difficult to work. A lot of the issues we decided on depended on the completion of others. It was difficult deciding which issues to take on individually; I felt bad doing nothing while waiting for whatever issues needed to be completed first got done, but in some cases it was necessary. As we complete our demo and move on to focus on communicating with other teams about our project, however, I think this will be less of an issue.

As a team, I think we could still improve our use of Gitlab for communication. I think we were definitely better about it during our second sprint, but our communication was largely remained on Discord, Zoom, or in person. It would be nice to have a more permanent record of our discussions, especially when those discussions are about the work we’re doing and the direction that work should be leading us.

As an individual, I want to take on more challenging work. The issues I worked on during this sprint were pretty simple, and two of the three of them were very easy to complete. I think it would be a better learning experience for myself if I tried to focus on more complicated issues. I also want to get better at communicating with my team. I think I should be talking more to my team members about my progress on whatever I am working on.

Contributions:

Add commitlint to gitlab-ci.yml to demo repository – I added a gitlab-ci.yml file to the repository that will host our demo.

Look into IAM Roles for EKS – In order to deploy a Kubernetes cluster to EKS, it (along with its nodes) must be assigned an IAM role. This post details the roles Amazon recommends using, and it has links to instructions on setting them up properly.

Determine what projects we are using for the demo – We decided to use a simplified version of a frontend/backend/API project for our demo.

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

Sprint 2 Retrospective

Now for sprint 2, much has changed in which the direction, work, communication and more has changed from the previous sprint. There seems to be more communication and a better direction of where we are going and a more complete vision based on the project. There are still questions on what to do and where exactly we are going to end up by the end of the project but hopefully that can be figured out in to coming days. There is also the collaboration between other groups that need to be sorted out.

On what has worked well, we have made good progress on building the API and backend in that there are functioning pieces of code we can work with. The NestAPIMap Joe had obtained from the previous sprint had provided a good starting point for the sprint. The http calls are functioning as they should be and the overall structure of the project seems sound. There was a lot of functionality added to which the API and the backend actually works when previously we didn’t quite have much working at all which is nice. The changes made to the project are numerous and a good sign of work getting done.

On what has not worked well, there is still a feeling of misdirection as we are still new to this kind of work so it shouldn’t be surprising that this is happening. There are parts where people work on different parts on their own and later on do different things than intended in which other people who are working on the same issue don’t know that it has already been finished. The flow of issues from being worked on to done wasn’t quite as fluid as the last sprint as most of them just stayed in process section till the last day in which we sorted them out there.

We could improve as a team by communicating better on the work being done and what is free to do so that way the work could have been more evenly distributed. It felt like some people did more work than what was originally intended/different from what was thought of. There was a lack of usage of the issue board on GitLab which contributed to this problem and that it would be beneficial to have a better flow of finishing issues so that way we know better on what to do or not to do and that there isn’t a backlog of issues all waiting to be sorted until the last day.

I could improve as personally I was also part of the problem of communicating between others on what issues were being done and didn’t quite contribute as much as I could’ve to the project. I feel like I could’ve done quite a bit more contribution work to the backend with the calls and hopefully in the next sprint I dive into some issues and get more meaningful work done. There is the issue of all the other classes I am taking starting to reach their end so I will have to watch for that.

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

Sprint Retrospective #2

Now that the second  sprint of the Naturalization Interview Confidence Environment project has ended, it is time to yet again reflect on the progress that my team and myself as this sprint’s Scrum Master have made thus far. Moreover, it is also time to reflect on what went right on wrong during this sprint, both in regard to what we as a team decided to improve upon based on what we discussed during our first retrospective, as well as what new obstacles may have shown up during the second sprint. It is important to note that in this sprint, unlike the first, the team had a sense of direction as to what needed to be done. For comparison, during the first sprint we were more concerned with determining what development framework we would need to use for the project while in the second sprint we had somewhat begun the development process of the project as well as creating the infrastructure for development. Though some progress may have been made, this sprint did not prove to be as fruitful as the last.

In this sprint, we as a team had planned on working on 36 issues across 5 epics. Moreover, for this sprint, the main team was separated into two sub-groups with one working on creating the application itself while the other worked on creating the Docker development infrastructure needed for future development. The application development group, of which I was a part, was tasked with implementing the following functionalities:

as well as other functionalities that would be necessary, such as ways to navigate between the aforementioned functionalities. I was primarily tasked with implementing the reading portion of the application (as linked above), meaning I needed to implement the necessary functionality for a user to be able to see previews of the questions that are to be included in the application, as well as interact with each question separately. Though I was tasked to implement a specific functionality, I was still expected to help my teammates of the application team in the case they needed assistance with their own task, as well as provide support to the Docker infrastructure team.

          Though, admittedly, the breaks that occurred during the sprint contributed to hindering the structure of our productivity, as well as certain tasks taking much longer to work on than we had anticipated, there was still some progress regarding the infrastructure aspect of the project which continues to be worked on and improved by the responsible team members. Some problems that we had noticed in retrospect are mostly related to our management of time both during and outside meetings. As a scrum leader I still had issues managing our time during meetings such that there was a balance between allowing all team members to express themselves fully as well as using the meetings to outline what progress has been made and what progress needs to be made. Moreover, though we as a group acknowledged that documentation is extremely important, there was still lack of proper documentation and clarity in issues, which contributed to the improper time management of our meetings since there was more focus discussing what each new issue actually meant, thus meeting discussions wound up being somewhat disorganized. On a positive note, however, our approach of “Divide-and-conquer” from last sprint was crucial in helping the team establish who would do what tasks, either regarding the application or the infrastructure. Moreover, there has been substantial improvement regarding documenting what is being discussed during meetings, with certain issues having the appropriate context needed to ensure proper communication of our goals and progress between team members.

          As detailed above, while this sprint had its flaws regarding productivity and time management, there was still some progress made regarding development and infrastructure. While we all, as a team, acknowledge that some mistakes from the first sprint were still present in the second sprint, we are all still willing to learn from such mistakes and improve our own productivity and communication.

Direct links to issues:
1) Build a page that shows previews of the questions for the interview: https://gitlab.com/worcester/cs/naturalization-interview-confidence-environment/demo-react/-/issues/28
2) Learn how to use commitlint/conventional commits for the Application source code: https://gitlab.com/worcester/cs/naturalization-interview-confidence-environment/General/-/issues/13

From the blog CS@Worcester – CompSci Log by sohoda and used with permission of the author. All other rights reserved by the author.

Sprint Retrospective #2

For our second sprint, I think our group had a lot of ups and downs. At the start of the spring (before Spring Break), our group was very productive. Before break, we divided our group into two subgroups, three people working on the programming portion of the project (Sofia, Emmanuel, and I) and three people working on constructing a Docker container (Pernesso, Joao and Dylan). Early on, Dylan was able to get a Docker image and container working for our project. So, the Sprint was off to a strong start. During the last class before break, Sofia, Emmanuel, and I managed to break up the programming portion of the project into separate parts and assigned each part to a different person. So, each one of us knew what we had to work on over and after break. Some of us in the group had made plans to meet up over break using Discord to work on the project over break, but things came up and not everyone was able to meet. Sophia and I managed to work over Discord during break and I think we got a lot done. We did a mix between going over issues on our issue board and actually programming. For example, one of the issues I was going to work on over break was the Oath of Allegiance page and Personal Information page.

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

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

Originally, we had these issues as one issue which we decided did not really make sense because we were building two different screens. After an extensively discussion with Sophia, we also decided that the Personal Information page should go into our product backlog because if the purpose of our application was to just let people practice before taking the exam, then adding a Personal Information page does not really much to the functionality of our application. If the application was to simulate the exam, then adding a Personal Information page would make a lot more sense. So, we decided adding a Personal Information page was more of a luxury item that we could implement in a later Sprint if we have time. After our meet up, both Sophia and I documented what happened and our decisions on GitLab. So, in the beginning of the Sprint, we had decent documentation. It was what happened that everything kind of went south.

While I think our documentation was fine before and during break, I think documentation was one of the areas that fell apart the most after break. After we came back from break, we never followed up with one another on what we worked on during break or the week after break and so it was difficult to what was or wasn’t getting worked on or even what already done. Another issue that we had was we did not adjust the weights accordingly. When we initially made the issues in class before break, one of the things that we talked about was how for some of the issues, we did not know how to give it a weight because the issue may have been too broad, or we don’t know how to break up that specific issue. So, we were going to break some of those issues over time during the Sprint. This did not end up happening and our weights were off.

What I really to work on as an individual is working on a team. During this second sprint, I talked to my teammates a lot less than I did during the first Sprint. I just worked on the issues that I was assigned to and did not check in with anyone from the group unless I needed their feedback. For example, another issue that I worked during this Sprint was creating a UML diagram.

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

This was one of the few times I checked in with my group. I made two different diagrams. One simple diagram and one where I was trying something new and wanted my group’s feedback. So I feel like I need to work on checking in with my group more to see what they are working on and let them know what I am working on.

Another thing that I need to work on is writing issues as they come. Sometimes when I am working on an issue, I encounter more issues and I wait until the end of the sprint to put those issues on the issue board and forget about it until I talk to someone about it.

From the blog CS@Worcester – Just a Guy Passing By by Eric Nguyen and used with permission of the author. All other rights reserved by the author.

Second Sprint Retrospective

Reflection on what worked well and didn’t work well
After having the Sprint Retrospective meeting with my group overall, I would say that the project is progressing very well. The workflow of the group was the same of how everyone worked by themselves and together. Both the frontend and backend development teams were able to make a lot of progress towards the project. Overall, we were able to get everything done besides a few minor things. We didn’t have any real issues in the programming itself. Towards the end, after looking back at what we did, we were able to see how we are able to make it easier to start the servers, which will be part of our next Sprint. From the last Sprint, we made too many branches, but we were able to clean up the branches and really became organized for the second sprint. The backend is pretty much all set besides integrating it with the frontend and possibly cleaning up the code so it may run even smoother.

Reflection on what changes could be made to improve as a team
The team worked pretty well. We still had everyone in their original development team. Those who were on the backend stayed on the backend and the same goes for the frontend. The backend team however started to run out of things to do so we would hop on over to the frontend to see what they may need help with and to give a different perspective. From how the meeting went, everyone was able to communicate any problems they had with one another, and no one was ever afraid to ask questions when they needed help. I mentioned this before but something the team could work better on is being vocal. This Sprint was much better because it seems that everyone was more comfortable with speaking up. During our daily meetings, they were much better because everyone was able to elaborate on what they did instead of “I did this”.

Reflection on what changes could be made to improve as an individual
From my perspective, the sprint went really well. I was able to do a lot more work this Sprint and even learn a little bit about how RabbitMQ works. I will attach the work I did on the project at the end with a description. I also worked alongside colleagues Jared and Vien to clean up the backend. At the same time, we were able to learn some new things and teach each other a little bit. Last Sprint I mentioned how I needed to be more active, and I can say with confidence that’s what I did this Sprint. I don’t think I have much to improve on than learning and improving my programming skills. It was a very successful Sprint in my opinion.  

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

Sprint 2 Retrospective Reflection

In this blog post, I will reflect on the second sprint of my capstone project. I will discuss what worked well, what didn’t work well, changes we can make to improve as a team, changes I can make to improve as an individual, and I will end by listing links to the work I have done with descriptions.

To start off discussing what worked well, one of our biggest accomplishments, if not our biggest accomplishment (in my opinion) was successfully creating a functioning docker image that we were all able to pull and use on our individual laptops. This was a big milestone for us because during sprint 1 we were running into compatibility issues and had no standardized way of creating and sharing code with one another.

For things that didn’t work that well, I would like to bring up something that was a common theme in our retrospective meeting: our lack of regularly documenting our work. I think this was something that we started off on the right track at the beginning of our sprint after having discussed this as an important thing to do in our first retrospective meeting. But with spring break, the week we had off from class, we fell back into the habit of doing work without documenting as we go along. Another thing I would like to mention for this category were the issues we created that started with “Learn to…”. By creating these kinds of issues, it made it difficult to deliver something tangible as it relates to our capstone project. While there was a lot that we learned, it should be represented in the future by applying our new knowledge in a practical way. Lastly, I would like to mention that although we had a functioning docker image to use, it has been incredibly slow to use while on campus/in class. There were classes where I felt like I was simply working on setting up my container just to shut it down by the time class was over.

In our retrospective meeting, one of the big things we discussed we could all improve on as a team is thoroughly knowing our issues board. As a team, we should constantly be reading, updating, asking clarifying questions, and breaking down issues into manageable steps. Part of me was afraid of touching issues that my peers created because I didn’t want to change their original idea, but it is exactly this collaborative process that is needed to create a productive sprint. Doing this clarifies the work at hand and prevents things like creating duplicate issues.

When it comes to changes that I can make to improve as an individual, my goal for sprint 3 is to use my class time more effectively. This last sprint has taught me that it is especially difficult for me to dive into my code when my peers are around me. Some of the best technical work I have done comes from me working in an independent, library-like environment. Because of this, I will focus on using daily standup meetings and my class time as an opportunity to get very comfortable with our issues board. If there are issues that require further details I can add them in class and if there are questions I need to ask my peers about issues they’ve created I can ask them in person. I believe making this small change will be more effective than spending my hour and fifteen minutes in class trying to code with intermittent distractions that may pertain to the capstone, but do not always pertain to what I’m coding.

Links to evidence of activity on GitLab with descriptions:

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

Spring Two Retrospective

During spring two, we had more experience working as a team, and there were some big improvements and things that went well. There were also some areas in which we can improve, that we discussed in our Sprint Retrospective meeting. We started with what went well.

One thing that we improved with was using GitLab to better organize our collaboration. We used comments in the issues section of GitLab so that our development can be better documented. We were using discord and talking in person during the first sprint, when we should have been using GitLab comments. Another thing we did well was approving Merge Requests Asynchronously. During sprint one, we merged all of the requests as a group during class. This was tedious at best, and at worst led to merge conflicts, with branches being many commits behind. This time, we created a system in which any time a team member is the second to approve a Merge Request, he will merge the branch into Main. This streamlined the merging process.

Another area we continued to excel in is getting issues completed, and evenly dividing the work. With the exception of Issues that are not in our control, we completed all of our assigned issues. And we evenly divided the work. We faced some delays, as we had spring break, followed by a week of cancelled classes. But we still managed to get a lot done. We have a lot to celebrate as team, but there are some things that we can improve on.

We had a two week break from classes. And our productivity decreased during that time. We got better at using discord to collaborate remotely. And if issues like this arise again, we will be better equipped to handle them. Another thing we can improve on is naming issues more descriptively, and link issues to epics. We can also work on being more proactive with asking our instructor for help as needed. As a group those are the things we need to work on. And as a team member, I need to contribute to this.

I think I did a great job during this sprint, and I learned a lot. But there are some things I can work on. Going back to some of the group feedback, I need to be more specific in naming issues. This is extremely important, so that if another team member works on an issue I created, he is working on the correct piece of the project. Another thing I can work on is the way I help other team members as problems arise. A few team members needed help getting Chai to work. And were facing a “Chai is not defined error”. I thought this was due to Chai or node not being installed. As when I was in my branch it worked fine. When I moved to main and pulled all of the changes I found that I was getting the same error. It was due to a missing import statement in one of our testng files. I learned that I should take a closer look when trying to help another team member. Meaning that I should switch to their branch and pull all of the recent changes.

The issues I completed / worked on during Sprint two are as follows:

Test File for products: https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/general/-/issues/3

Create Data file for Products: https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeper-newbackend/-/issues/5

Test File for Returning API: https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeper-newbackend/-/issues/13

From the blog CS@Worcester – Jim Spisto by jspisto and used with permission of the author. All other rights reserved by the author.

Retrospective: Sprint 2

Christian Shadis

This past week, my development team in my Software Development capstone completed our second of three Scrum sprints for the semester and recently had our Sprint Retrospective meeting. This was my (and the team’s) second cycle in an Agile environment, so we were more comfortable with the process.

The most notable improvement from our first sprint to the second was the development workflow in respect to version control. Our largest difficulty was previously with the branching and merging process; team members were pushing code with conflicts, were pushing new code before fetching updates, and were having numerous failed merges. After having several weeks to acclimate, we were able to execute the workflow smoothly for the second sprint. After implementing a new policy allowing merges to occur outside of class, we were also able to better utilize class time to address problems team members were having instead of reviewing pre-written code.

Perhaps the largest roadblock in this sprint was a large block of time in the middle of it during which little work was done. We were off for a week for Spring Break, before having both classes the following week cancelled – no members were available to work on the project during this time. Thus, a significant portion of the sprint was spent completely idle. However, we were able to recover as a team and complete enough work before the sprint concluded.

There are some improvements the team can make for the next sprint to increase our effectiveness. First, the team should improve the naming of epics and issues and do a better job of linking the two. We have epics but have been failing to link issues to them. Additionally, the approval of merge requests needs to be done more continuously and quickly after the request is created.

However, there were several areas in which our team excelled. As in the last sprint, our team successfully divided tasks amongst all members to prevent any member over- or under-producing. Any problem a developer had was brought to the group and resolved in a timely manner, which was made easier by our improved merging workflow and increased available class time. We communicated much more in Gitlab than in the previous sprint, allowing conversation to be kept for posterity. It is also noteworthy that we completed most of the planned work despite a time gap

I contributed to the project in several ways. Perhaps my most significant contribution was the revision of the API repository to produce a valid API that passes the npm test. This consisted of fixing naming errors and references in fifteen different files (https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeperapi/-/issues/4). I also added a few necessary files to the backend repository (https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeper-newbackend/-/issues/17, https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeper-newbackend/-/issues/18 ). Previously to validating the API I renamed several files in the repository to ensure all files were capitalized consistently in camelCase (https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeperapi/-/issues/10). Finally, I contributed by opening a dialogue with the IAM and AWS teams to inquire about incorporating access management into our API, and about deployment on AWS (https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeper-newbackend/-/issues/14, https://gitlab.com/LibreFoodPantry/common-services/foodkeeper/foodkeeper-newbackend/-/issues/15 ).

Though I performed better than in the first sprint, there are some areas in which I can improve for the final sprint. First, I would like to be more consistent in my work. In the previous sprints, I have been taking multiple days between work sessions and doing work in bulk. This increased the amount of time needed to orient myself with the task at hand and catch up with other work done in the span. Working more continuously would prevent that. Furthermore, I would like to write more code for the next sprint – while I completed several issues, I wrote very little code this sprint. I believe my backend development skills could use the boost of writing more of the code. I will choose different types of issues to assign to myself for the following sprint.

I would consider the sprint successful overall. Essentially, we have a working and validated API, most backend code, and are working on integrating the two together, leaving testing for the third sprint, which is in line with our pre-semester goals. We have worked well as a team, I have worked well as an individual, and we are well on our way to a (near) finished product at the end of Sprint 3.

From the blog CS@Worcester – Christian Shadis' Blog by ctshadis and used with permission of the author. All other rights reserved by the author.