Sprint 3 Retrospective Reflection

In this blog post, I will reflect on the third 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.

One of the things that worked well for me personally during this sprint was the quality of documentation that I had created. I would say that my documentation was consistent from beginning to end for sprint 3. For all the work and decisions I made for this sprint, I made sure to document it for my current teammates but also for the next students who would be taking over this project. Another thing that worked well for me this sprint, was creating a document with specific goals that I wanted to accomplish prior to each class. I regularly checked in with this document through sprint 3 and it served as my personal issues board. I kept updating the specifications of my issues but the overall gist of the issue remained intact for the duration of sprint 3.

For things that didn’t work that well in this sprint, even though I consider sprint 3 to be my most productive sprint, I also feel like I did not deliver enough minimum viable products that possessed incremental improvements. While I did produce a minimum viable product for updating our landing page, that soon got quickly incremented with another teammate’s commit. What I was really hoping I would be able to crack was creating an interactive drawing page for the writing portion of our application. While I made several attempts in creating this feature, they were all ultimately unsuccessful in producing a minimally viable product that improved on the pre-existing code.

As far as what we could improve on as a team, one of the things that I think could have made us even more successful would have been having a conversation about what we wanted the minimum viable product for sprint 3 to be. I think we knew all the work/issues that needed to be done for this sprint and we went full steam ahead, however, we probably could have benefited from taking a mental snapshot of where we were at the end of sprint 2 and where we hoped to be at the end of sprint 3.

When it comes to changes that I can make to improve as an individual, I would like to address my previous issue of what I don’t think worked that well for me in this sprint. Next time, I think I should focus on taking what is already present and making one minor incremental improvement before moving forward with an exploratory phase to create a major improvement. My initial increment doesn’t have to be much, but it would allow us to say we delivered something different from sprint 2. By doing something small and simple first, I can then focus my efforts on riskier experiments. If these experiments work out, the risk would have paid off, but if they don’t work out, I can fall back on the safe, small incremental improvement I made.

Links to evidence of activity on GitLab with descriptions:

  • What I essentially did for this was replace the “We want pizza” landing page to one with two separate buttons. One leads to the “Writing Portion” of our app and the other leads to the “Reading Portion” of our app.
  • I asked for clarification on why an issue was closed so that it is documented.
  • I explained my process with getting expo running for me (which is different from how one of my teammates was doing this).
  • I pulled and checked out the code per my teammate’s request to make sure it worked on my end.
  • I pulled and examined Emmanuel’s code per his request and then made some exploratory attempts to implement a writing feature.
  • I documented a potential idea for our issue with implementing the reading portion of our application.
  • I created an issue with some notes for whoever starts the process for this issue.

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

Apprenticeship Patterns – Share What You Learn

So this is a pattern that I’m entirely unfamiliar with, as I don’t consider my understanding of a majority of the material sufficient enough to be able to reliably pass it on to another person. However, the pattern immediately addresses this by noting that every little nugget of knowledge can be valuable to someone who might be unfamiliar with it. And as a result, that bit of understanding can thereafter be passed on again, and cascade from the little help that I might have given a fellow programmer. In some ways, it may even be more beneficial to learn tidbits from a peer, as the author mentions that we would be speaking the same language in terms of familiarity. 

While the pattern references the fact that people may not appreciate what you share, I wholeheartedly agree that properly teaching somebody else will solidify the techniques in one’s own mind. If someone is struggling but isn’t willing to hear what you have to offer, they need to improve over several areas in their own right. 

I find it fascinating that the author mentions to be cautious about what you share, as you might be stepping on the toes of a higher up, and unintentionally disclose something that was valuable to an employer. It’s certainly something I’ve never considered before and will take into account going into the future. I’m also glad he mentions the fact that sharing a lesson could be interpreted as conceited or aloof, because from personal experience I’ve lost respect for people like this faster than a Hello World program executes. All in all my takeaway is to temper what you say and read the room when deciding when or when not to share; quite the valuable lesson. 

In the Action portion, I don’t necessarily agree with the recommendations made. Of course there’s no problem with writing blog posts and sharing workshops, but I regard the most important lesson to be to think about how you would engage with someone treating you the same way, if you were approached by them in the same situation. Teach in engaging ways and foster curiosity in your peers, but only if they are willing to accept your olive branch. It’s ultimately a waste of time to preach at someone who isn’t really listening, and worse, judging you for engaging with them.   

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

Apprenticeship Patterns – Breakable Toys

My biggest takeaway from this is to simply build more things that don’t work, so later on I have the knowledge to make things that do actually work. The quote of the three ball juggler not attempting to push the limit to five balls during a performance is an analogy that really spoke to me in that regard. 

I think the idea of building a personal wiki would be a phenomenal practice for my growth, as I’m constantly forgetting general syntax or git commands that sometimes slow my production rate to a crawl. I built a game for another class that emulated the classic Flappy Bird from a few years ago, and getting that to function would have taken my ages and ages without the help from my groupmates. But reflecting on the experience now, the amount of times we broke that game and the thrill of being able to actually PLAY what I made was something I’d never experienced. Nor with any other art, as I’ve never been one to share any of the sparse create projects I seldom try to come up with. Reading this pattern has kind of put that creation process in a better context for me now, and I hope I retain that going forward as I expand my portfolio to apply for career positions in the future. 

I also like the idea that I own these broken things, but that they will stay with me wherever I go. Just because I can’t make something work at first, doesn’t mean years or months down the road I can easily slap on some extra padding and see how much I’ve grown as a creator. 

Reading on, the Action section really sums up everything that I just reflected on. Especially the wiki idea, which will be the first thing that I try to implement. I know I’ve kind of been harping on very similar patterns, as referenced in the See Also section, but I think this is the biggest area of improvement that I need to work on. For my last post I’ll be sure to expand into a more diverse pattern just to expand the repertoire, but I think it was important for me to recognize the importance of my harping on these specific topics.

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

Sprint Retrospective 3

Oddly enough, I found this sprint to be a tad more challenging than both the first and second. I’d say this is primarily because we were nearing the end of our project, and the team had some difficulty accurately choosing and weighting our epics and issues. I’m unsure if the rest of the team would agree with this sentiment, but it’s certainly something I felt at the beginning of the sprint. We all eventually found worthwhile contributions to work through, but the lack of cohesion or agreement at the beginning was a little jarring. 

Despite this, I’d say the team got some of the harder pieces of work done near the end of the sprint. I certainly remember the getRange file for the API being a huge hurdle to get functioning, but with Jeff and Kenny working together they made it work in the end. Personally, I felt a little stuck after implementing a few new schemas in the API, as I had elected to work on the key validation from the other groups’ projects. I thought I’d give it a shot, as encryption has always been pretty fascinating to me with all the different types of encoding techniques that exist. However, I soon found I was quite far out of my depth; I ended up staring at StackOverload and random forums trying to get the verification working for a lot of class time. There were a few times I thought I had cracked it, but unfortunately it broke the code every time I pushed it into our repository.

In the future and during my career, it’s pretty crucial I learn to reach out or actually post something on one of these forums for help. I’m sure during the process of an actual situation my seniors will be vastly more knowledgeable than me on basically everything, so this is a skill that should hopefully develop naturally. Of course it’s important not to be an incessant pest, but with my genuine willingness to improve I’m sure I’ll be fine.  

Overall, I was still really satisfied with the team this sprint. I think we all found our roles and niches in the project to work on, and were more than willing to answer questions and help out whenever it was needed. I found the capstone to be a great introduction to my future career opportunities, and the familiarity I garnered over the semester should boost my competency level pretty far beyond what it would have been otherwise. I also look forward to working on a team with a dedicated scrum leader who I can look to for some direction if I feel lost.

One thing that I do think the team could have communicated better on was our presentation. I know it’s pretty separate from the actual work we were doing, but for a good amount of time I had no idea what I was supposed to be covering in the video. I defaulted to whatever the team didn’t initially choose, as I wanted them to be more interested in what they were presenting. Unfortunately, it was difficult to glean my responsibilities as some members were quick to post what they preferred, while others didn’t accurately mention their coverage. In the end I just went over the API, and I hope I didn’t overlap all too much with the others’ videos. Regardless, that’s a minor gripe, and I don’t blame anyone because it’s the end of the semester. 

As for some contributions, I added these pretty minor things to the API over the sprint.

https://gitlab.com/LibreFoodPantry/client-solutions/nest/guest-information-system/api/-/blob/main/src/schemas/GREkeyValidation.yaml

https://gitlab.com/LibreFoodPantry/client-solutions/nest/guest-information-system/api/-/blob/main/src/paths/invalidKey.yaml

https://gitlab.com/LibreFoodPantry/client-solutions/nest/guest-information-system/api/-/blob/main/src/paths/validKey.yaml

I also helped out a bit on the getRange before I started working on the backend key validation. It starts on line 56 of this link. 

https://gitlab.com/LibreFoodPantry/client-solutions/nest/guest-information-system/backend/-/blob/main/src/data/questionaire.js

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

Sprint #3 Retrospective

The last Sprint we worked on was Sprint #3 Retrospective. We’ve finally arrived at the end of everything regarding the Software Development Capstone.

We did the same method on this final sprint as we did on the previous two sprints, where we first created issues and then worked on the project. We began work on Sprint #3 after successfully completing Sprint 2. It was different from the previous two sprints, but at the same time, we were more sure about the issues we would focus on to complete the project.

During Sprint 3, I assisted the team with conversations and issues, just as I had done with the others. However, one of the issues on which I worked was:

Write Up Documentation

To realize this issue, I went through the research issues that we had already completed. My task was to compile and finalize all this information in the documentation repository.

First, I included all of the research topics that we had already completed as an AWS Deployment team. After listing them all, I attempted to summarize each one in a brief part description. I began by mentioning the team member who worked on that research, and then I summarized the important features of everyone’s research. Working on this issue was interesting for me since I saw it as a look back at everything we’d accomplished during the project. At this point, I can see what role each study topic played and how important each one was. This was the issue I worked on, but that’s not the last one. I also worked on two other issues, but this time was assigned with Chris. Two of the issues were about communicating with groups. However, the issues we worked on were:

Communicate with team 1 of ReportingSystem

Our main task here was to have an understanding of their project’s architecture. And needed to understand from us, how we had organized our cluster. Everything went really well. Chris’s role was to talk more about our project and share our team’s process related with them, and my role was to take notes of what they had really done and record everything.

Communicate with team 2 of IAM

The same thing was even for the second team. Our task was to go to the IAM team and talk to them about the Kubernetes Cluster and also how their work fits into it, as long as they are working with Keylock. We needed to know what they are working on, as well as the design of their system.

What went well:

I think that Sprint 3 Retrospective went really well. We tried to share all the issues and work for them during the Sprint. We were all able to finish our issues and all the tasks we had.

What did not go well

I think that at this point when all the sprints are finished, the main thing we needed to do was closing up all issues. Including my issue that ended up in Process status. These seemed to be difficult for us at that point, and I wish we could have done better.

What the team should change

As we ended up doing our project in the right way, I think that in general everything has been really good. Anyways there is always a place for improvements, and where you can do better.

What should I change

I will specify again as I mentioned in the last sprint, the technical issues. I would have really liked to be involved more since we first start the project. And the other thing is as I could close my issue, I will say that I could have managed the time in a better way.

Conclusion

Here we are at the end of the semester, and I am happy that we as a team closed successfully not only Sprint 3 but also the whole project. In general, we tried to manage everything and make our best to have a good final project.

From the blog CS@worcester – Xhulja's Blogs by xmurati and used with permission of the author. All other rights reserved by the author.

A Different Road

This Apprenticeship pattern, “A Different Road” is about admitting to yourself if software craftmanship isn’t the career path you want anymore. I think that this is a very important lesson to be learned, because it is much more harmful to yourself, and others that you work with in your field if you stick through doing something you don’t like than if you either take some time away or change career paths entirely. By doing something you don’t like as a career, you are doing a disservice to yourself and others, because you most likely aren’t doing the best as a software developer as you could if you don’t like it, and others may notice that you don’t like it and that you aren’t doing the quality of work that you used to, or that it is less than acceptable.

I think that instead of changing career paths immediately if you aren’t enjoying it anymore, maybe a good idea would be to take some time away, and then return to it later and assess whether you still aren’t enjoying it or not. The reason for this would be to see if you just have burnout from doing it for a while, and then maybe the time away would fix that burnout. You could have burnout for a number of reasons, but maybe taking some time away would fix it by helping you clear your head, and then if you’re still having burnout then it might be time to seriously consider changing careers.

Ultimately, I think it’s best to not force yourself into a career you don’t enjoy doing, and that goes for any career path, not just software development. Not enjoying what you’re doing everyday means that you’re likely doing it worse than you would if you were enjoying it and will inevitably lead to unhappiness. In my opinion, it is much better to do something that you enjoy doing and something you’re passionate about than something that has better pay. Additionally, there will always be other opportunities down the line, meaning a temporary career shift doesn’t have to be permanent, and you can either continue doing what you are, or return to the old job if you’ve discovered that’s what you like best.

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

Sprint 3 Retrospective:

This sprint went particularly well. Cooperation between the team members improved, and the general effort and quality of the work effort exceeded my expectations.

With the rest of the team concentrating their efforts on the API and Backend projects, I spent most of my time writing and testing the remainder of the work in the Android testbed app.

This work involved finishing the coding and testing of the 8 main endpoints and adding code for the final endpoint, getRange.

The getRange method required addition of code to the NestTester, API, and Backend projects.

I also worked with the team on helping to get the backend to work for the getRange API call. We coordinated this with local unit testing from within the backend container using getRange.http calls, as well as remote integration testing from the Android Studio emulator.

This sprint included the time required for the 5 of us to prepare a video presentation. We are producing multiple mp4 files and will consolidate the individual pieces within the week.

Our usage of the GitLab Epics and Issues boards improved. This resulted in a better workflow, giving each team member a more balanced share of the task load.

Part of the sprint was used communicating with the IAM team to get a sense of the timeframe required to integrate security mechanism into our remote function calls. A plan is in the works for this integration to be implemented in next year’s Capstone.

I wrote about half of a document describing the steps that a future Android team can use to integrate my testbed infrastructure into the actual NEST app. I will finish this document in August when I have more time. I would have completed it this sprint, but the getRange development and testing was more complicated than we had thought, so had taken up more time.

Dr. Wurst had suggested that we can continue working on this project if we choose. Since this is an open-source project, anyone willing to contribute to it is welcome. I have time in August to continue working on this and will volunteer some time evaluating what needs to be done to migrate the testbed code to the proper locations in the “Live” NEST app, calling the mongodb backend from the proper places. I am not familiar with most of the NEST app code, so I would need to communicate with a contact from the team. Should I contact Dr. Burge from NCC for this?  This is all contingent on whether or not this is needed.

The capstone was a great experience for me. The 3 sprints showed how team members went from being apprehensive and overwhelmed by the process, to being excited and proud of their achievements. There are definitely “bumps and bruises” involved in this transition, but also a sense of pride in having succeeded. For our team, this seems like a journey showing them more about how the “real world” will work for them, compared with some of the more academic foundational classes they have taken.  

From the blog cs@worcester – (Twinstar Blogland) by Joe Barry and used with permission of the author. All other rights reserved by the author.

Expose Your Ignorance

This Apprenticeship pattern, “Expose Your Ignorance,” is about admitting to others as well as to yourself the gaps in your knowledge. You must admit to yourself the gaps in your knowledge before you can admit it to others and begin to ask meaningful questions to expand your knowledge. I think this is really important to know because if you are unwilling to admit that you don’t know some stuff, then you will be unable to learn it, and furthermore unable to get help from others who possibly know more about the topic. Only by admitting that you have more to learn can you open yourself up to attaining more information, which will help you in the long run.

I think that this is especially important in the software development field, where there are constantly new technologies and tools to learn, and new information about emerging systems that you must learn to keep up with the ever expanding field on software development. If you don’t keep up by learning new things, and thereby exposing your ignorance, then you will quickly fall behind, and may be susceptible to being replaced at your job, or incapable of performing the tasks necessary to fulfill your goals.

I also think that this is applicable to many different fields, not just software craftmanship, where there are always new things to learn, and you must keep up to date with the latest information in order to do your job. One such example would be a doctor, where there is always new medical information coming out, and not knowing about it could be potentially harmful. Any person in a field such as this must be okay with admitting that they don’t know something, instead of pretending like they do and not learning new, important information. Admitting that you don’t know something, and exposing your ignorance, not only makes you seem humble to yourself as well as others, but it also helps others to assess what you do or don’t know so that they are able to help you in areas where you may need it, and you are able to help yourself in this way and by learning it on your own.

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

“NICE” Sprint 3 Retrospective

During our third and final sprint, we had a clear idea about what we wanted to achieve with our application. The first two splits helped create a foundation that allowed for us to propel much faster and efficiently compared to before. After spending the last sprint working on the docker container for our group, I wanted to contribute in a way that would be helpful to the react team. I ended up creating issues for myself that were more in line with the front end side of things that the react team had not really touched upon. I first decided to clean up a lot of the code from the react team, there were a lot of styles that were repetitively used by the team so I managed to implement a style page where certain style could be called upon instead of written out when being applied to something. The next thing I tried to tackle was an interactive page for users to select which kind of test they wanted to practice. This was implemented with a side scroll feature that was imported from the react-native-gesture-handler where I was learning the design parts of how things would look based on the style I would give it. I was also able to take images and icons as well to apply to the home page and menu screen which gave it a much better appearance to the eyes of the user.

As a team I felt as if this sprint all of the puzzle pieces finally came together. The react team was working cohesively together where as the others who did not work with them originally were able to go back and forth with them to push an pull code without being out of sync. The team cohesiveness really brought out the best in one another as were we able to divide issues into more manageable ones and we could really see the final product coming together.

With the docker team finally being able to assist the react team with the application as a whole, we were constantly running the application and testing it, and that led to a lot of discussion of things that needed to be fixed or added to the app. This would lead to us effectively being able to help one another spot mishaps and expedite the results we so eagerly wanted. Although we were not able to produce a functioning writing portion, we were able to create a placeholder for it that was substituted with a input on the they keyboard from the user.

Individually, I felt as though this sprint was one were I pushed myself the most. Maybe it was because the semester was coming to the end or that the application was seeing growth, but although I was lacking in basic knowledge of react native, I wanted to be sure I contributed more to the application and pushed myself to learn more. The only issue that I had with the sprint was that I wish I was able to be part of the react native team prior to this because I know I could have contributed more than what I already have. Seeing how fast I was able to grasp things, maybe I should have stepped up before and take on that challenge because I had a lot of fun during this sprint.

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

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

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

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

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

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

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

From the blog CS@Worcester – Life as a CS Student by Dylan Nguyen and used with permission of the author. All other rights reserved by the author.

Record What You Learn

Summary:

‘Record what you learn’ pattern comes from the chapter ‘Perpetual learning’ and Perpetual meaning ‘occurring repeatedly’ the pattern sits well. ‘Record What you learn’ Pattern is a perfect read after ‘Breakable Toys’ and ‘Practice, Practice, Practice…’ because the pattern exposes one the biggest flaw in our learning which is that sometimes even after learning the same lesson repeatedly “They never seem to stick.” The solution pattern provides is for us to record what we learn. Make timely organized notes in form of journals and wikis. Moreover, the notes could be public or private; public for the purposes to share your knowledge and discoveries and private where you can act as your own oversight and pinpoint all your faults with brutal honesty.

Why this pattern?

For me, ‘Record What You Learn’ is a perfect sequel to ‘Practice, Practice, Practice…’. I have written many programs in Java, but from time to time I’ll forget something specific like casting the input variables, using extends or implements in OOP. The point is this has happened to me various times until I started making personalized notes for myself instead of depending on textbooks and class notes. I started writing things down the way I understood them; using the color-coding system to my advantage, I highlighted parts that were important to remember, parts with specific steps and parts where I needed help. Classification of information not only proved to be effective for quick reviews and revise but also helped in conveying myself to people who can help me in precisely where I needed help.

Where is disagree:

Most of the time while building my personalized notes there was a lot of overlap. Classification of information was effective but the process of classifying the information itself was tedious and chaotic. As I kept learning new things, adding notes, and modifying notes became a very complicated process. Absence of space led to arrows being from the top of the page to the bottom. References were made from page 31 to page 45 which led to a whole new level of mess. Switching to taking notes on the PC solved a lot of issues from being on paper but created a lot of new ones. One issue was the mechanics of completing a task. It is much easier switching between a pen to a highlighter than a keyboard to mouse, and further selecting area to highlight.

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