Category Archives: Blog

Sprint Retrospective 2

By this sprint, everyone had an idea of what they were doing and what needed to be done. So everyone was on track with required workflow. In this sprint, people started to add issues of their own. I should have added issues I found in this project, but I just discussed with the team members, and they added it. Overall, for this sprint, I have a mixed feeling about it. I felt as if I didn’t do much help to the team, but at the same time I felt like I gave my all to the team. I did solve a couple issues during this sprint.

The first issue I solved was simple enough that I forgot to add it to the project issue board. Logically, it made sense to fix this issue so that the form doesn’t become annoying to the user. Imagine clicking on the input field every time the form loaded. So guest 1 comes and swipes, guest 2 comes then you have to click on the input field, guest 3 comes click again. Doing that over and over again would have been exhausting. I didn’t really notice this issue until I tested the code with card reader. At first, I thought I had to write some method so that the text would automatically focus on the input field. I was lost and had no idea about how to make it work. At the end, I felt really stupid because the solution was simple, and I was overthinking it. The solution was in the HTML input attribute type. All I had to add was “autofill” in the input attribute. Refer to this commit. Here

For the second issue I fixed, it really took the best of me and my time. My goal was to on a click of a button which is in one of the child component in Vue, I had to get the data from localhost, store it as an object then pass it to another child component so that those data would automatically fill the form. Sounds simple and easy. But the thing is, you cannot pass data from one child component to another. So the process was to get data from one child component, pass it to parent component using emit and then pass that data to another child component from parent component using props. Michale had already passed the data from component to component and I thought it would be relatively be the same. I couldn’t be any more wrong. I did everything same as Michale and everything worked as we wanted. Since our API was not fully done, I tested my method using Jsonplaceholder and sent the data to another component. I put the Jsonplaceholder’s ID number as a zip code, and it displayed as I wanted it to be. The major problem was that I was using options:Lifecycle that would assign the data before the form loads, which leads to not being able to edit the form data. Removing the lifecycle and just mounting it to v-model worked, but it rendered the first child component twice in the same page. Other than that, everything was working. I was able to get the data, pass to the form and edit then submit the edited data. I am not really sure how this worked, but to fix the issue of rendering the component twice, I hid the first component when the submit button is clicked. After that, everything worked as we wanted. Refer to this commit for code details. here

On to the third issue, when swiping the card, the input field only picked up the correct ID on the first swipe only. This issue was taken by another teammate, but since he wasn’t able to complete it, I took it from there. After a couple of hours of debugging, I was left with nothing. I understood the code the previous developers left, but I wasn’t sure why the issue was as it is. I started to think that if it worked on first swipe, let’s make every swipe as first one. So the solution was simple. Refer to this commit on line 93. here

This Sprint showed who is really dedicated to the project, who is really passionate to the software developing. It seemed as everyone was giving their 100% effort to the project and were all liking the process. I don’t have a single doubt that we won’t be able to finish this by the end.

From the blog cs@worcester – Dream to Reality by tamusandesh99 and used with permission of the author. All other rights reserved by the author.

“N.I.C.E” Sprint 2 Retrospective

During our second sprint we finally began setting up what we wanted for our application. We discussed the features that we wanted as well as how we wanted to be able to set up the environment for future students. What I was tasked with was trying to develop a docker container that would be able to run react and expo so that others would not need to require to download anything in order to run it. The docker team was not well versed with docker but we managed to figure out how to successfully create one. It was a lot of trial and error, but in the end, we overcame one of our weaknesses. The next order of business was then work with the React team to include all of their dependencies in the docker container so that everyone would have no trouble using their code.

The react team in parallel of the docker team was working on developing the features of the app that we wanted to include. They created the base of the cards with questions as well as the writing portion of the app. Unfortunately, the code provided by one of our referenced sources seemed to be unviable and the writing portion is being put aside for now. With that we are now putting our focus into creating the other portions of our application.

As a team we work well with trying to help one another succeed and adding on to one another’s ideas. Our communication is one of our strongest points as a group and it allows for us to express how we feel about areas we are weak in without the worry of any backlash. There were many times where some of us felt stuck in what we were doing, and we tried to help pick each other up.

One of the biggest issues we faced was not being able to create the proper issues that we needed to. We would have general ideas about what we wanted to do and how to do them but as a result of creating those issues, we would have other smaller issues that would pop up along the way. Although smaller issues would come up, we didn’t realize that we could add those to our issue board as well and it felt like we were not making much of a dent in the work that we wanted to do.

Individually I felt like I was a lost at times and did not know what to do. It was difficult working on things that I did not know much about and trying to teach myself was one of the hardest parts. Docker was one are where I felt as though I knew nothing but took it upon myself to try and learn what I was weakest at. It taught we that with time and hard work that I can achieve anything, but it would have been nice to have someone who was well versed to push me in the right direction because it would’ve saved a lot of time and I also wanted to help the other team as well. I also realized that I do like to work independently most of the time and that might take away from others learning and finding a cohesive solution together.

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.

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.

Rubbing Elbows

The context of this pattern is that although there are many people teaching you about coding, when it comes to actually developing software, it will be all in your hands. However, the problem is that your productivity has reached a plateau. One of the solution for this is to pair up with another software developer and accomplish a hands-on task together, side by side. Of course, it will be much better if the developer is better than you or has more experience. While pair programming can be an excellent technique for learning, it is a complex activity and is not always an inherently positive experience. However, when used effectively, it is one of the most powerful ways to learn, particularly from mentors. But how do we know that we are improving when pair programming? One of the way to know is that you will feel lost or behind with all the work/knowledge. At first, it feels like you are failing, but it isn’t always the case. It simply means you need to either slow thing down by asking questions, or endure the feeling of being lost and try to pick up the bits that you do understand. The action part of this pattern is to find an open source project to work with your pair programmer. Spend some time working on it each week together on the project. If you lose motivation for a long time, then it is time to change your partner.

When it comes to pair programming, I have done nothing but leetcode together with a programmer for like a week or so. Although I have never done pair programming for a long time, I do always surround myself with better developers than me. But that does not mean it breaks my plateau. I do learn new things here and there, but I have not actually done a project with that knowledge. Now comparing to our capstone project, I am learning new things with this group and project. All the programmer in my team seems they are better than me, so while I am doing my part of the issue for the project, I am also learning what the others did and how it connects with my issue. The problem with me is that I lack to have a vision of a finished project, but with this team and this project I can clearly see what our finished project will be at the end.

From the blog cs@worcester – Dream to Reality by tamusandesh99 and used with permission of the author. All other rights reserved by the author.

Apprenticeship Patterns “Confront Your Ignorance”

This apprenticeship pattern describes to us how after being able to expose your ignorance, you must now be able to confront it. Once we are able to find the gaps in our skillset, it is up to us to tackle those problems head on. Confronting your ignorance does not mean to learn in isolation because doing that encourages us to create a standard where hiding your failures is okay. What we need to remember is that learning in public is always beneficial for an apprentice and that is what helps us move onto our next step of becoming better software engineers. What we worry about is when exposing your ignorance you become dependent on others as well as just creating problems for others when you don’t know something. That is why confronting your ignorance helps bridge the gap from between exposing your ignorance to being able to actually contribute to projects because confronting it is the best way to fill in your gaps.

What I have been able to away from this is that just because we don’t know something does not mean we should just constantly depend on others. If we fail to understand how to do something, we need to be able to ask for help so that hopefully next time we can do it on our own. With every project we take on in the future, it is obvious that we will need help in order to continue onward. We need to not work in secret to hide our failures and to use our mentors and peers as resources so that we grow and fill in those holes we all so definitely have.

After reading this pattern, it helped my reflect on a time where I created a Java application for work that would scan RFID badges of employees. I was tasked with this and initially had thought that if I could do it on my own I could prove I was capable and hardworking. In the end I took too long and did not have much to show for it, I was then partnered with someone who did have experience creating apps and in the end we were able to develop a functioning app. Pattern reminded me about this experience and that exposing and confronting my ignorance does not show that I’m weak, but that I want to grow as an apprentice.

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.

Learn How You Fail

The context of this pattern is that you cannot avoid failure. If you never failed, then that means you either avoided pushing at the boundaries of your abilities or has learned to overlook your own mistakes. The problem is that even though your learning skills have improved, your failures and weakness still remains the same. The solution is as follows, seek to identify the way in which you tend to fail and try to resolve them. Accept that there will be some things that you are not good at, or that would require a disproportionate investment of time and effort in order to make a small improvement.

Now for the action part, this is what I liked the most about the pattern. In the programming language of your choice, use a simple text editor to write an implementation of binary search in one sitting. Do not compile or run it. Write all the tests that you think are needed to verify your code you just implemented. Now, go back and re-read your code and find all the errors you think you made, keep doing that until you are satisfied with the code. Make sure you give in your 100% knowledge to it. Then, finally, try to compile and run it. Before you fix all the errors, look over them and try to understand how you could have avoided such error in the first place.

For me, this pattern was really helpful. I wish I had known about this pattern when I was taking a data structure and algorithm analysis class because I really had rough in those classes. I should have done this action part for all the topics in those classes. Such as, post order tree or pre-order tree from data structures or Dijkstra’s algorithm and divide and conquer from algorithm analysis class. I have been bad at so many stuffs now that if I do something wrong, it does not even faze me anymore. But one thing I did that I’m proud of is that, whatever I failed at doing, at the end I made sure I know how to do it the correct way. What I need to work on is to practice by implementing code in a simple text editor without any error warnings.

From the blog cs@worcester – Dream to Reality by tamusandesh99 and used with permission of the author. All other rights reserved by the author.

Apprenticeship Patterns “Expose Your Ignorance”

This apprenticeship pattern describes to us how having the ability to identify our areas of ignorance and being able to reduce will be beneficial for us software apprentices in the future. There will be tremendous pressure on us in our future jobs to be able to work on and finish projects. They will expect us to be able to deliver software, and this is where we shouldn’t be ignorant of what we are not able to do because our lack of inexperience. This is where if we do not understand something, we should not be scared to reach out to ask questions and to learn about technologies and things that we do not understand. This itself reassures everyone of our ability to learn and by not pretending how to know how to do something, it exposes our ignorance to asking questions. What we need to understand is that as apprentices, there are many areas of our craft that we know nothing about, we can’t go around letting others believe that we know everything, but instead be able to reach out and ask questions without letting our pride get in the way.

What I’ve taken away from this is to not worry about questions because letting others think that you know how to do something and delivering something incorrect is even more of an issue. I think there is pride in being able to show others you can do things on your own without help, but being an apprentice means that you should be able to learn from others without your pride getting in the way.

This pattern has been helpful in letting me be able to understand how I am when I am given work to do in the real world. There have been instances where I have been given projects to work on at work, and I have tried to do things myself without help, this itself has led me to either taking too long on something or delivering work that I am not completely proud of. There have been other instances where I am completely unable to understand some things and asking others who understand it completely really helped elevate my understanding and learning of what I want. The ability to make uncomfortable situations more comfortable for me will be me exposing my ignorance.        

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.

Expose Your Ignorance Pattern

For this week’s apprenticeship pattern, I did a reading on “Expose Your Ignorance”. A summary of “Expose Your Ignorance” is simply about how you may be unfamiliar with some technologies that are required to do a job and your manager and team members are looking to you to complete the job. At this point you already landed the position at the company but now, you’re required to do a task that requires certain technology like a specific language you’re not proficient in. To counter this, you must show them that learning new technology or anything is part of the process of getting a job done. In this pattern it mentions about how you should be honest and speak the truth to your clients and team members. This would allow them to be reassured even if you do not know the technology right away. If you’re able to show them that you’re learning and progressing, it will build trust and your reputation will be built upon that. Not only that but ask questions. Even though there’s already a presumption that you already know certain things since you’ve been hired, it will never hurt to ask since this is the most direct way in getting a task done and learning. The whole point to this is, to not be afraid of learning and let your team know that you’re learning.

My initial reaction to this pattern is similar to those of the other patterns where I can relate to it. In my capstone class, I am constantly being exposed to new stuff that I haven’t touched or barely learned from the other semesters, and I find myself always asking questions or looking things up on how to do a specific thing. What’s thought provoking in this pattern is how it mentions to not pretend what you know what you’re doing. I believe this is something a lot of people do, and it will negatively impact you more than anything. If you are honest with your manager and team members, they will get a better understanding about where things stand but will more than likely give you a chance to prove that you’re able to learn and do the work. Then if you were to pretend to know what you’re doing and give a horrible product. After reading this pattern, I felt more reassured that it was okay to ask questions and that it was okay if I didn’t know exactly everything. As long as I’m able to show I can learn and do the tasks properly and on a timely manner, I will be okay going into the professional world.

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.

Sweep the Floor

The context of this pattern is that you are a new apprentice on a project. However, the problem is that you don’t know what your role is in this team. You don’t know how to contribute to the team and help them in any way necessary. The solution is to volunteer for simple, unglamorous, yet necessary tasks for the team. This way, you can earn team member’s trust, and you also get to show the team members how quality of work you can do. The tasks may be such as maintaining the build system, production support, responding to maintenance requests, bug fixing code review etc. The tasks can be anything, but it cannot have any high risks. Starting a core tasks and failing puts you into a bad side of a team, so it is better to start off with an easy tasks and actually finish it to have good relationship with everyone on the team. These short takes benefits the team, but it will also benefit your apprentice because such chores are often skipped in academic courses and by doing them you can fill in the gaps in your knowledge. After all, if no one sweeps the floor, then the glamorous work can’t be done because the team is hip-deep in dirt.

This pattern kind of reminded me of our group for the capstone project. When we first formed the group, I was assigned to the frontend part of the project. I was ready to do the first task from the GitLab issue board, but my main question was how can I convince the team that I can do this project together with the team and can actually make some contribution. In this computer science major, I feel as if I am always a step behind from everyone and have to add in extra effort to be on the same level as everyone else. So to show my skill, my first task was to connect two components and load one component only on click, which in my opinion is not an easy task but also not a hard task and I think I managed to do that, and the team seemed to love the way it turned out to be.

From the blog cs@worcester – Dream to Reality by tamusandesh99 and used with permission of the author. All other rights reserved by the author.

Craft over Art

This pattern starts off with a strong quote by Richard Stallman who states “I would describe programming as a craft, which is a kind of art, but not a fine art. Craft means making useful objects with perhaps decorative touches. Fine art means making thing purely for their beauty”. And this quote hit me right in the chest because I wished I had read this quote way earlier, around sophomore year or so. At that year, I was just trying to learn programming while also struggling. At that time, all I could do was some cool stuffs in my own personal computer’s terminal. There wasn’t any time when I thought I should build something that is useful and also could be used by others. All I had in my mind was how to make this code work so that it looks cool in my own terminal.

The context of this pattern is that I am being paid to build something that will solve a problem of a customer. However, the problem is that although there is a solution, my customer’s problem represents an opportunity to do something truly fantastic and is a chance to impress my colleagues with something beautiful. The solution starts as, the things we build for customer can be beautiful, but must be useful. This pattern is developing the ability to sacrifice beauty in favor of utility if and when it becomes necessary. The more useful a piece of software, the more important it is that the software be high quality. But quality takes time. You will have to work toward a suitable level of quality by repeatedly making trade-offs between beauty and utility. Ken Auer also states a really nice and meaningful quote, “Working on real problems for real people is what hones the craft, not just doing it for self-satisfaction”. The action is to do something useful rather than beautiful. This pattern reminds me of an app I made in operating system class with Professor Shruti Nagpal. For that class, our final project was to make something from what we learned in the class. Since my parents kept on asking me what is the current dollar rate compared to Nepali Rupees, I decided to make a currency converter app for them. The app may not be used by many people, but when I think of something I did useful, that’s all I could think of, and I don’t hear my parents asking for dollar rates anymore.

From the blog cs@worcester – Dream to Reality by tamusandesh99 and used with permission of the author. All other rights reserved by the author.