https://gitlab.com/LibreFoodPantry/modules/visitmodule-tp/checkout/Plan/-/issues/47
Create MongoDb Docker Container

https://gitlab.com/LibreFoodPantry/modules/visitmodule-tp/checkout/Plan/-/issues/50
Setup Rest Api Endpoint to Add to MongoDb

https://gitlab.com/LibreFoodPantry/modules/visitmodule-tp/checkout/Plan/-/issues/31
Implement methods in weight-entry component to communicate with REST API

https://gitlab.com/LibreFoodPantry/modules/visitmodule-tp/checkout/Plan/-/issues/30
Add checks for remaining weight allowed based on previous transactions

During our third and final sprint our teamwork and role designation really benefited our workflow. We applied ourselves to areas of work that we each had the most knowledge with (Rest Api, Mongo, Web UI, and Docker) and focused our workflow individually in those subjects. While at this juncture in the project most of the work is overlapping in order to connect either through Docker or with specific method calls we were all exposed to each other’s work. This way we each had an opportunity to learn about the different parts of the project and all had a deep understanding of our own work. Having such deep understanding of our own work allowed us to explain it to each other and to overcome obstacles when finalizing the connection between everything either locally or via Docker. So whereas in previous sprints we worked solely on our own part of the project, this sprint really started to blur the lines of our issues. 

For example, many of our Rest Api Endpoints needed to be set up to work properly with the Front End Angular Methods. Issues like Issue 50 Setup Rest Api Endpoint to Add to MongoDb became a three part issue. We need to make sure the Rest Method could add correctly to our MongoDb, but also this needed to be tested with the Front End code before it could be finalized. While working on this issue I found that roles were often switched and juggled between my teammate and I as I worked on Front End Angular code and they worked on some Rest Api Backend code.

There isn’t much that didn’t work well in this Sprint but I feel that keeping our Merges to Master on Git up to date and correct was sometimes a problem. We did not alway communicate code correctly and would send snip-its in discord that we would copy and paste instead of sharing it through git. Sometimes certain important code segments would get merged and then someone with old code from copy and pasted work may merge and we would lose that important segment of code in our most recent commit.

As a team we could improve our Git presence and organization. We should have been using it to solely share code instead of copy and pasting in discord. If we used Git only certain things would not have gotten lost in translation and confused. Overall, if we worked more cleanly on git we would have saved quite a bit of time on the project.

As an individual I could improve my knowledge and understanding of the parts of the project I wasn’t assigned to. Sometimes if an issue would arise with a field of familiarity like the Rest Api I would feel compelled to help my teammates with the problem. However, I could have designated some of that time to look over things like the Docker containers more and familiarize myself with their function better. Docker would not work on my computer so the only exposure I had with it was when working with my team members. I feel I could have learned more about the Rest Api and Angular Docker containers as opposed to just the Mongo Container.

From the blog cs@worcester – Zac's Blog by zloureiro and used with permission of the author. All other rights reserved by the author.

Here is what I worked on during Sprint 3:

• Determined the design of the front end components
  • Comment on issue detailing the design
• Designed and implemented a simple header component
  • Merge of implemented header
• Implemented the data-service in the Web UI
  • Merge of refactored data-service
• Collaborated on implementation of the guest-list component
  • Final merge of guest-list component
• Implemented the Web UI in a Docker container
  • Branch with Docker implementation
• Created Docker container for Approve Guest SQL server

Sprint reflection:

In my personal opinion, this sprint was truly when my team and I started to get into the flow of collaboration. For this sprint, rather than each working on a separate service, such as the API or front-end we all collaborated on a single front-end. What I noticed with this was we had a lot more discussion and it really felt that we were working together towards the goal of getting all of our issues we started the sprint with done. Unfortunately, this was the last sprint of the semester, but it was good to feel that we were all working collaboratively and using discord and GitLab to communicate any issues and roadblocks that were stopping us from achieving. As I talked about in my last retrospective blog, the transition to fully remote was a pretty tough one since we are a relatively new team and haven’t really had the time to form the communicative skills that a seasoned team would have. It felt at times like the fully remote nature felt made it more difficult than it was previously to reach out for help while working. Maybe it was the quickly approaching deadline that made the difference, but I think we all worked really well together on this last sprint. All members of the team used discord messaging extensively and we had our fair share of discord calls to talk about implementation and problems. As for things that could be improved, as there always will be, I felt like work wasn’t being pushed to GitLab as frequently as it should have been. This made helping with implementation a pretty slow process. There is really nothing that we can do to help collaborate if we don’t have that code up on GitLab. I also feel like we still had the issue of keeping way too many things in the needs review column of our Kanban board. This also slowed down implementation greatly because there were many times where I couldn’t start working on another component until a feature was merged and sometimes it would take days for that to happen. In the end, we implemented a lot more than I originally thought we would have and we did it as a team. We even got to working with Docker on the Dawn of the final day and while it was a scramble I learned a lot about containerization and Docker implementation.

Going Forward:

It did take my team a fair amount of time to gel together and feel comfortable collaborating, but I feel like we pulled through in the end. This project has been a huge learning experience. Not only did I learn a ton about how developing on an Agile team feels, but I also got a feel for being a Scrum master. I know that this experience is one that I will look back to throughout my software engineering career. There were failures and frustration, but it was extremely informative to be part of this project from the idea phase all the way through to the implementation, albeit not a finished implementation. Having the experience of transitioning to working fully remote is an experience that has already helped me in my professional career. If any of my team members read this, thank you guys for sticking it out with me and I know you will all succeed in life.

From the blog CS@Worcester – Creative Coding by John Pacheco and used with permission of the author. All other rights reserved by the author.

Hello dear readers. Welcome again to my blog. This blog won’t be for the patterns I have been writing about, but for the progress of me and my team in our Capstone Class. It is exciting to see that things are progressing and we are moving forward with this project.

As I mentioned at the end of the last blog, (AMPATH-WSU Sprint 2 Retrospective) we received videos and actual output samples of how the new application should look like. I think that this is a very important step and want to say that I think it should have been sent earlier to us, as for a long time we kept researching about the tools we were gonna use and to be honest it got a little bit boring as I was really was looking forward to this part of the process. It’s true that in order for you to start working on a project you should know the tools and systems but I also believe in the theory where you also learn while working on it.

So during this sprint we took our time to watch the videos and after we made sure we all had seen and understood the videos and the requirements, we created Zeplin accounts. For all of you who don’t know Zeplin, Zeplin is a collaboration tool for UI designers and front end developers. It goes beyond the design workflow and helps teams with the design. I had never used Zeplin before but I found very useful in sorting the project and handling off designs. Recommended if you ever do front end development!

A Github section was created for all WSU participating in this project and each of the teams created their own branch. We discussed if each of us should have their own branch but we ended up in the conclusion that it would be very messed up for each of us to have their own branch pulled from master, so a branch per team was the final decision. However, each one of us could create its own branch from the team branch and that would be great in case any of us wanted to experiment. we left the option available  to whoever wanted to do so.

After we created our branch we choose our task to do, which is a search bar.  Something I really would like to point out is the team environment we have. We all are very communicative and express ourselves and our opinions. For us it was easy to agree on the search bar as a start up to do task for this project.As a lot of steps on this process don’t depend on us I would say that everything is going fine and I wouldn’t change anything if I was back in the same situation.

While working on the search bar we keep checking with our teammates and how is the progress going. I am really glad we haven’t really been facing any major issues and our team is working strongly together. I am really looking forward to getting the search bar done and move on to the next task. Stay tuned for my next blog post to see what happens. Until then..Have a good time

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

In our third sprint, we ended up having to revisit some of our previous work and recreate it, but better. After having a lot of difficulty with the previous way of doing it, using some old code from an old project, I decided to go with a more structured approach and read the guide on making template driven forms on angular.io. This guide was incredibly helpful in creating the form, as it has step-by-step instructions, example code and is very descriptive in the how’s and why’s of doing things.

Using the guide and their code as a template, I began to customize the intake form to the necessary specifications. I pretty much tried to recreate the “Thea’s Food Pantry Intake Form” given to us by the food pantry representative. I had to make different types of input for the text and the button input, and this time I was able to get some error-handling working, such as required certain fields before submission. Instead of using WebStorm as my IDE this time, I developed everything on Stack Blitz, a free online IDE and Angular editor that displays your application in real time. It was really useful to use, and hopefully once our group figures out its intricacies and how we can use it to collaborate within it, we can use it more in the future.

I was able to use some of the lessons learned in my Software Process Management class to make sure I maintained the clearness and readability of my code as well. I tried to use good spacing and white-space in the form so that it is clear where one module of the code ends and another begins. I also tried to keep my names both clear and consistent, so that variables containing the same information are named the same throughout the program. This is an issue that caused me much confusion last semester when I was developing a different web based form.

A unique issue I ran into while making the form was the compiler getting confused about the format Student IDs at Worcester State University have. Because my ID number is “0662077” the compiler kept thinking I was trying to use an octal, which would be something like 0x662077, and would not compile. I had to accept the Student ID as a string instead of text to fix this issue. Another issue with accepting Student IDs is that the program tries to get rid of unnecessary 0’s, which ends up making my ID Number different from what is desired. It took me a while to solve this issue, as I had no idea what was going on at first, but it was interesting to see how it could misinterpret my input data because of a preceding 0.

Overall, this Sprint was relatively productive for me, and I hope to continue going forwards. I have to find out what my next goals and challenges are and figure out what I’m doing next. Hopefully it will be something I’m familiar with.

From the blog CS@Worcester – Let's Get TechNICKal by technickal4 and used with permission of the author. All other rights reserved by the author.

A reflection on what I learned from
this week’s activities is that sometimes it’s best to restart. Our initial two
sprints brought us up to a point where the current delivery is usable but could
not be built upon. We had trouble trying to incorporate features from each of
our own work loads that was divided in Trello. The main issue from the scrapped
delivery is that it is written in Java and missing fundamental components that
would make it difficult to create a webpage with. As such, the problem resolved
after deciding to focus our efforts on Angular and using it’s features to make
our lives easier.

Another lesson learned from this week’s
activities is that having more than one repository between two GitHub and GitLab
is a nightmare. It was a mix between each of the members uploading to our own
repositories to share mockups of things we have created during the sprint. This
choice is backed by us not feeling up to upload mockups directly to the repository
made by the professor since we weren’t “feeling ready” yet.  Then there is the issue with having two different
food pantry repositories which further confused everyone. However, this issue was
eventually resolved when the professor and some students came up with another idea
for handling the repositories. The new system creates a fork from the main
project to the class repository. There are a couple other things mentioned
about incorporating “stories” using this setup that I have yet to fully
understand.

The third lesson learned from this
week’s activities, is that it is very easy to get lost and sidetrack from the
main goal. This lesson is mainly for myself as I was working on the database
but took me an entire sprint to realize that I was working on the wrong portion
of the project that was unneeded at the moment. Focusing unnecessary resources towards
a feature that should be left for later. The other members were focused on the
intake form and had created the front-end of it but needed a place to store the
information later on. This is the area I should have tackled, in which our
members would have been working in unison.

During this sprint, I focused my efforts on mainly establishing a connection to the SQLite database created from the previous sprint with the current project. Using JAVA and the available JDBC library found on the web, I was able to successfully connect to the database. However, when it came to transfer what I learned into the main project we were working on gave plenty of errors. There were missing libraries and many unused and preplanned files that needed deletion. Although this was a problem, the next problem is mentioned earlier in the blog. We needed a clean slate to work with since the project was in an unworkable state. After we got back to the point where we were in JAVA, now in Angular, I had to find a new way to get the SQLite database to work in Angular. Now that we are back on track, I can see where the project is likely headed!

References:

http://www.sqlitetutorial.net/sqlite-java/sqlite-jdbc-driver/

From the blog CS@Worcester – Progression through Computer Science and Beyond… by Johnny To and used with permission of the author. All other rights reserved by the author.

During our third sprint we finally got an idea of what we will be coding for this project. Greg Shmidt from AMPATH sent us videos that showcased wireframes of the electronic medical record system that they are requesting. The main thing that I did during this sprint was watch these videos and start planning with my team what we will be working on and how we will go about coding it.

After watching all of Greg’s videos, my team decided that we wanted to work on the tab functionality. The tab is one of Google’s standard material design elements, and Greg showed a few examples of apps such as Google Music and Twitter that incorporate tabs similar to the way that we will be for this project. Each tab will contain a form that displays patient information. The tab bar must also be able to scroll to show additional tabs.

During this sprint my team began planning how we are going to go about designing and implementing the tab system. A link was posted on the Slack channel to documentation about coding mobile Angular user interfaces. This was helpful to read through as it gave me a better idea of what we will actually have to do to code the tab system. I also found a page on tabs on the Angular site that was useful to read through: https://material.angular.io/components/tabs/overview

One challenge in implementing the tab system will be making it so that it functions with the systems that the other groups are developing. To do this we will have to figure out which services we will need to use. Luckily, a member of another group found where all the services are located in the ng2-amrs project. During this sprint I began looking at these services to figure out what they do so that we will know which ones we will have to implement when creating the tab functionality.

After this sprint I believe that my team is ready to actually start coding. We now have clear instructions on what to do and have done preparation work that let us get a better understanding of how we are going to proceed. During this sprint I learned what is expected from us for this project and gained a conceptual understanding of how to implement a tab system in Angular. It is exciting to finally know what we are working on and I’m glad that we can now begin to make progress on this project.

Overall, I would say that this was a successful sprint and I would not proceed differently in light of anything that was learned throughout the sprint. I am satisfied with the way my team is working together and I believe we will begin to make a lot of tangible progress during the next sprint. I think that the tab component we are working on will be a lot of fun and am glad that we chose it. This project is definitely going well and I’m excited to continue working with my team.

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