Author Archives:

Sprint 3 Retrospective

At the end of last week, we finally conclude our third sprint in our development process of the LibreFoodPantry, aiming at a deloyable environments so that they all are isolated in their own space. This is also our last sprint so we tried our best to wrap it up as much as possible, so that the team after us can easily pick up from where we left off. We were able to work together more this time, comparing to us having to separately work on our own stuff in the previous sprint. We finally got a working, operational and deployable user interface as well as a fully implemented, buildable and deployable backend system with REST API and mySQL database. We were also able to adapt with the online communication and worked more effectively with each other.

List of what we accomplished during the last sprint:

       – Successfully integrate Docker into frontend UI and the REST API, allows them to communicate with the existing mySQL container with configurable parameter in config.json file (REST API Docker, ApproveGuestWebUI Docker)

–         –  Having an operational admin page user interface or ApproveGuestWebUI, although without actually data fed from backend systems, but mocked with data points (ApproveGuestWebUI Epic)

–         – Having a mocked or stubbed backend for the frontend to test connections establishing mechanics (Registration Stub)

It seems that we did not do a lot for this sprint, but it was actually much more challenging for us because of more advanced technologies that we have to research on and a lot of new barriers that we have, such as us having more things to do for our career and other classes, voice and video communications became harder as the internet becomes unstable, for me at least, etc. Despite all of that, I think we did a very good job wrapping up all the work we have done from the sprint and even make it deployable, so the next group can just skip the hard part of Docker and focus more on the part of developing operational products for the food pantry. We think that is much more important than to waste time on getting them to be able to run on an actual server, so I heavily prioritized to get it done, both on Docker Desktop and Docker Toolbox. I would say that out of all the sprints, this one is pretty boring since I personally had to read a lot comparing to the two last one that all I do is setting up systems, coding, and a whole lot of checking on people if they can run the same system and if they need some help.

For future improvement, if we have a chance to work more on the project, I think it is better to centralize our work source into either backend or frontend, then move on to another. I believe it is better that way so all the team member can know what other members are doing and learn both the backend and frontend stuff. Another improvement that our team can use is more official communication and well documenting our steps of implementing. It is the same problem that persists from the last run, but we did make sure to have more transparency in what we do this sprint, which I think is a major effort from us.

From the blog #Khoa'sCSBlog by and used with permission of the author. All other rights reserved by the author.

Learn How You Fail

The pattern that from Apprenticeship Pattern that I read for this week is “Learn How You Fail”. The chapter mainly talks about how to identify our own problem during the development process and seek to fix it in order to get better.
I really like what the author said within the context. Failure is inevitable and people who has never failed would either stay in their comfort zone and avoid going over the boundaries, or they have overlooked and ignore their mistake all along. This holds true to me since I have done multiple personal projects that requires me to constantly make mistake and discover what is needed to be done for even a single line of code to work. It is pretty obvious that errors will push ourselves to find out what works and what does not, give us a space to fully explore the capacity of the technology so that we will not make a same mistake later on. Moving on to the problem, he states that the learning skills may bring us success, but there are weakness and failures still remains. I agree with this and I think he did it brief but covered all the aspect of this chapter. The author then gives us the solution, which is as simple as to always seek the errors or failures and resolve what is worth fixing, and more importantly, we have to accept that there will be a lot of things that we are not good at. The solution itself is pretty much self-explanatory and I agree that there’s no better way to improve it without starting to identify the problems and spend time and effort to fix it.
Another way to solve this problem is to is to always arm ourselves with knowledge to make better decisions when carrying out working and identify our own boundaries and limitation to push it when we need to. These changes and improvement can also enable us to have a realistic limitation on our goal. That limitation is what we need to be mindful about as we cannot know everything, and that limitation will greatly help us in filtering out which one is distraction, which on we should spend more resources on to excel at what we are trying to accomplish. I like the example that he put out, which is making time for PhD courses, or simply give up what we know as it requires maintenance to be fortified and maybe to make room for what we need at the moment. I both experience a similar form of these two examples since I had to dedicated time and resources to be able to just learn a new language or a piece of technology.
Personally, I like the chapter because of its simplicity and how it encourages people to not afraid to push their boundaries, while at the same time, accept that we can never know everything, and we have to prioritize one over the other. Like I mentioned, I had experience what this pattern is saying in the past, and I believe that this can be extremely useful for a lot of people, especially the one who has quite some decent knowledge about an area to encourage them to learn something not quite similar to what they have been using.

From the blog #Khoa'sCSBlog by and used with permission of the author. All other rights reserved by the author.

Study the Classics

The second pattern for this week Apprenticeship Pattern is “Study the Classics”. I think this one is pretty straight forward, as it states on point that reading and learning what is in the past is as essential as doing so with documents and books in the current generation, as it would allow ourselves to expose to problems that we might rarely see at the moment.
The patterns start out with an extremely interesting problem that a lot of more experienced people in the field would likely to reference a concept from books and area that we might have now idea it exists, but they expect us to know it already, like any other self-respecting software developers. I have not experienced anything thing like this while working as an intern, but I can imagine that it does happens a lot to new developers in the field. The author explains the solution in a very simple way, which is to admit your ignorance, and ask about the concept, how it works, where do they reference it from and add it to our own reading list. For people like me who has not experienced a situation like that to get a title to read, when picking out books to read, the author recommended us to look at how out of dated it is comparing to the continuously evolving technologies that we have right now to make sure that we are reading the one needed for our on need in the current state of technology development. I think that does not really mean that we can ignore all of the books that are written decades ago as it might contains a lot of information that can even serve until today, still however, they should not be on our top priority list. It is best to have a mix between classics and modern to have a feel of what is the differences, what is improved, what is still remains, and that is the best way to avoid making the same mistakes and have a better referencing stand point when putting out our opinion to the team.
In my opinion, this pattern does not necessary to contain the most useful information to choose the best book out there to read. I think if the author put out some of the examples to make comparison, like a book about Python 2 and another one about Python 3, it should make a clear distinction in the reader’s mind that this pattern is important to keep in mind. With that being said, I think the patter itself is not too informative as much as the other one, but it does have some value to tell the readers that books will always have their value, whether it is old or new, but to prioritize reading the right one, would make one more successful than others

From the blog #Khoa'sCSBlog by and used with permission of the author. All other rights reserved by the author.

Concrete Skills

The first pattern in the Apprenticeship Pattern that I read for this week is Concrete Skills. The pattern pretty much talks about skills that are required to be focus on when an apprentice software developer like us start our career. It also lays out a concept, which is to have knowledge about it, does not mean that we can successfully apply it to create a piece of software, and I think that this is crucial to remember.
The pattern starts off by posing a really interesting problem that I think a lot of people, even veteran, are facing I would say, which is having a team, or a company that is not willing to hire someone that will, for sure, not able to not make any contribution to the project, whether it is direct or indirect, and this I think would take away the potential for an individual to learn and maybe even progress himself/herself in the field if it happens to them constantly. As the author starts to explain the solution, which is to acquire and maintain concrete skills, which is really generalized, but when he starts to explain further, it makes a lot of sense to me. He explains that we just simply can bring the ability to learn quickly, or the ability to bring a specific tool or technology that allows the team to work better, and our credibility will be increase among the team, so it is best to be prepared a lot of necessary skills and tools before applying for a position in a team. I like the point where he points out that some hiring manager will have to trust us with what we have and bringing a creation of our own might ensure them that we will fit the job that benefit them. I found it also true that these concrete skills are only noticeable when our resumé is new and lack of experiences. It is certainly be easier as we proceed from job to job, as they are more likely to look at our personal experiences, reputation, and most importantly, our portfolio.
Personally, I think this pattern is really brief about the subject matter, it does not necessary be the most informative patterns, but it certainly motivates me and I am sure a lot other developers out there to learn and do more in their own time in order to make their resumé looks better, as well as gaining more experiences in using tools and languages at the same time. It also made me realize that the demand of tools and technologies are always going to change, so it is quite essential to always learn new things on the go, although our pool of knowledge is filled with a lot of stuff that can easily be used in a team at some point. I feel like this pattern is different as it is more about preparing for getting a job in the field, but it is quite important not to be passed by by new developers.

From the blog #Khoa'sCSBlog by and used with permission of the author. All other rights reserved by the author.

Confront Your Ignorance

For this week, now that I have read through “Expose Your Ignorance” in the Apprenticeship Patterns, I continue on to read through “Confront Your Ignorance”, as they seem to go hand in hand with each other. To sum up this chapter, it mostly talks about the advantages and disadvantages when taking action to fill up our knowledge once we identified the gap.
The problem posted for this chapter is that while we have a lot of tools and techniques available out there that we can get our hands on, a lot of developers like us do not know where to start and a lot of common things that people know, we are expected to have those knowledge when we start working. I feel like this is the exact current state of a lot of new people who just got into the field and this chapter seems to be important to know about when we get started. The solution that the author presented, which is picking one skill, tool, or technique to actively learn about it, caught me off guard as I would never imagine it to be a simple answer. It is true that we have a start somewhere and using those as foundations to learn others. He then moves on to explain that to do whichever ways work best for us like reading articles and FAQs or constructing Breakable Toys and ask around for people who knows better or simply just people who are looking to acquire the same skill. The best part of this pattern is when he stated that we don’t have enough hours to get all the skill we need, and making trade-offs is necessary in order to get better. This is what I always think about whenever I get into learning something new because I might potentially forget part of what I know now and there will be more and more to learn once I get used to new skills. The author begins to explain that confronting the ignorance can be done in private, but then it would promote the bad habit of being failure or openly learning something in a work environment is unacceptable. And worse side effects that can be found by applying this pattern would be to let our personal gain for knowledge affect the team and we should keep in mind to separate them when we do.
I do agree with every point that the author put out on this pattern as I am sure that it will prove to be helpful when I am required to learn something new. With such simple solutions and tips, I think this chapter is pretty straight forward telling us to keep on practicing ourselves outside of work time, which still keeping up with the team progress so that we can become better without stubble upon failing what we are supposed to do and I think it is useful for new developers to know.

From the blog #Khoa'sCSBlog by and used with permission of the author. All other rights reserved by the author.

Expose Your Ignorance

For this week, I continued reading the Apprenticeship Pattern and the first one that I got into is “Expose Your Ignorance”. To simply explain this pattern, it encourages the readers to basically no being afraid of feeling ignorance and stupid when asking about what we don’t know.

The problem of this chapter is presented with an example of a work environment that requires the developer to be familiar with required with technologies, but we simply just don’t have any idea how to use it. I like how the author says that it happens to everyone because it is true that people can’t know everything and this would let the readers know that it is common, furthermore encourage them to not be afraid and expose their ignorance. With the question of how should one exposing himself/herself to be the most effective, the author gave us one simple solution, which is to show other people that you might not know about it, but you are willing to learn how to do it during the process of delivering software. Leading off as the author acknowledge the common feeling that the societies are increasingly dependent on the competence as a developer and we just have so many zones of ignorance, the author shows us that we still shouldn’t be afraid to tell people the truth despite feeling those pressure. According to him, to let people know that you are in the process of learning that particular technology is important to either build a strong relationship with people or build your own reputation of our learning ability. I would say that this is very true because the fact that people would appreciate the time that we put out to try to learn and use it properly rather than just lying about it and then forcefully use it the way it’s not intended to or finding a walkaround. The author then encourages us to ask questions and adopt the ability to learn as it is the easiest way to get to know something. It is rather an uncomfortable process, but it’s probably the most efficient way to learn in the end.

I can see myself completely agree with what the author said to exposing my own ignorance. I believe that it is what a lot of people in the past did in order to be at their position right now and I also believe that a lot of apprentice like us should not afraid to be judged and do the same, just to get ourselves better every day. I know that I myself do suffer from the fear of asking. Sure, I do want to learn, but I also want to prove to others that I know a lot too, and this chapter helps me to realize that actively learning is also another way to positively prove to other people, and I should not be avoiding it when needed.

From the blog #Khoa'sCSBlog by and used with permission of the author. All other rights reserved by the author.

Reflect as you work

For this week Apprenticeship Pattern, I chose to read about “Reflect As You Work”. When I read the title, my first thought is that this habit is pretty necessary, but it should not be too hard to have a chapter dedicated to it and turns out I was entirely wrong about it. The pattern starts with putting out the question of whenever a developer can consider themselves as “experienced” and how would that process be in order to reach that destination. The author then went straight to the point to explain how just reflecting our own work would be a best way for us to gain more experience. He explains several techniques like making a Personal Practice Map, which would involve writing down all the practices that we do during the development process and share with others, and mimic what they do in order to be better in the field. I think this particular technique would greatly help a lot of new developers in the field who does not know what to expect when developing and would end up doing what they think is the best without having a chance to consult everyone about that decision. The author also mentioned that this reflecting would involve a lot of observation on the practices and the processes of journeyman and master craftsman on the team, which I would say highly beneficial for everyone, not just the newcomers. He also gave out some examples of practices that was not discussed before, but then becoming more popular as everyone has proven it to be a lot useful. The author then concluded that people would start called us experienced if we hang on long enough and it should not be our goal to earn that title. Experienced should mean that we survive through long enough and our dedication to exploring, not necessarily how much we learned. He also made a really good point that anti-experience, or developing bad habit, can also happen too and we have to keep that in mind to set out goal to be “skilled”, not “experience”. This I would say the best thing I’ve read in patterns so far, since it is directly related to what I am doing as to earn the same amount of experience as anti-experience while doing personal projects alone, without any guidance of any journeyman or master craftsman. I can say that I do learn quite a lot from this pattern and I certainly would keep in mind these suggestions that the author made.

From the blog #Khoa'sCSBlog by and used with permission of the author. All other rights reserved by the author.

Sprint 2 Retrospective

At the beginning of this week, we finally reached the end of our second sprint, once a again, completing the back end for the LibreFoodPantry Approve module. My thought on this sprint is that our team did fall behind quite a bit on the goals we set out to finish at the beginning of the sprint due to the fact that we ran into much more problem than we expected and we don’t really have much time to meet up with each other like the last one. Nevertheless, we were still able to achieve a decent amount of goal and almost reach the point to be deployable as a product for just the back end.

List of what I accomplished during the last sprint:

– Successfully implemented CI/CD in every main repositories and get it up and running to check for merge requests build

– Adding all the required endpoints for the REST API system and set it out as a base for the front end to access data

– Successfully established connection between REST API and mySQL database on each member’s machine with a customizable config file to fit with multiple server setup

– Completely overhaul and clean up code for REST API to be more optimized and modular

– Front end wise, John and Kevin was able to make a few basic component to display guest information, made a lot of effort to learn about Material design, and experimenting with communication with the REST API

With a lot of work putting in developing the back end, I learned a lot about how to make connection between REST API system and mySQL. There are a few small things that I can pick up through this run too, like the differences between Docker Desktop and Docker Toolbox, making CI/CD script with different images, and so on.

During this run, it went really smoothly and we only ran into multiple communication issue, and small things during the development process like the date and time is behind when data point is fetched from the database because of timezone differences for some reason, or having to deal with numerous bugs that the default date object in Java caused. Other than those, I think we’ve done it pretty well. 

From the blog #Khoa'sCSBlog by and used with permission of the author. All other rights reserved by the author.

Breakable Toys

In this apprentice pattern, I took a look at “Breakable Toys.” I think this chapter is really interesting since it encourages developers to gain as much experience as possible through failures within a field that only a small gap for error. The pattern first presented the contradiction where developers are not allowed to make much mistakes, but those mistakes are the one that teach us the most in order to be better. The author moved on to present a simplest solution, which is to create our own safe space to experiment with new technologies by doing personal projects. I think this is a must do for a lot of developers who wants to improve themselves as it not only gain experience through making a lot of trials and errors, it can act as some kind of record to show employer that we are competent at this particular skill, technology, or language. Then the author talks about the main thing of this pattern, which is “breakable toys.” The term sounds confusing at first, but it seems to just simply be a wiki, calendar, address book that allows ourselves to store what we learn so that we can look back when we forget about it. Another concept for “breakable toys” that the author mentioned are games like Tic-Tac-Toe, blogging software or IRC clients, which allows us to experiment and get knowledges from other.
The reason why I chose this pattern because I think this is essential for myself, as well as a lot of developers to know about. I do use a lot of “breakable toys” and I think they are pretty neat to have in a lot of situation. Until this day, I still have a lot of unfinished personal projects in my backlog and those I can always use as a reference when I could not remember how to solve a problem, and a lot of them are featured in my resume to shows employers what I am capable of, which significantly boost my position in this competitive field.

After reading this pattern, it made me realized the importance of “breakable toys”, and also provide me with some more brilliant ideas like wikis for problems or building a game of choice out of every language that I learn. This pattern also helped me see more about the importance of practicing outside of work environment, provide myself a much better opportunity to experiment and make errors without having to worry about getting in trouble.

From the blog #Khoa'sCSBlog by and used with permission of the author. All other rights reserved by the author.

Sprint 1 Retrospective

At the middle of last week, our team finally concluded our first sprint, working on user approving system for the LibreFoodPantry. Overall, I think our team did pretty good on doing a lot of initial setups and communicating with other teams to make sure we can have a consistency on data across databases. For me personally, I did quite a lot of work on setting up repositories, researching on making the back-end database, and helping my teammate, as well as people from other teams on the problems that they have that are related to our module.

List of what I accomplished during the last sprint:

– Setting up repositories, including ApproveGuestWebUI, ApproveGuestService, and isApprovedWebUI, which regarding to tasks like forking from templates, enforcing rules for making changes to the source code, and informing the team about that policy.

– Researching about how mySQL database can be initialized on Docker containers, import – export existing mySQL container for future usage, and communicating to it from outside of the container (wiki page is available at link)

– As I am more interested in getting the back-end to finish in the early stage of development, I helped one of my teammate, Tyler, to make documentation about REST API endpoints and further getting feedback and making suggestion with other teams on those endpoints (wiki page is available at link).

– With all that endpoints in place, I setup the schema to potentially be what the mock and the actual database looks like and getting appropriate changes to it to match with the Register Guest module (wiki page is available at link).

– Finally, I had a lot more time towards the end of the sprint than I expected, so I dug deeper in setting up Spring Boot for the REST API and making a few objects within the program to lighten the amount of work for the next sprint.

With a lot of work that is put into initializing the project, I also learned a lot. While I did have a chance to experience SCRUM on my last internship, this time we use Gitlab as a tool to log all of our work, which I really the simplicity but professional and effective, rather than Jira and Confluence, which are more corporate driven software. I also learn to operate Docker, which I delay on getting to know it for a while as I though to myself that virtualization is a most optimal way to go, and after the last sprint, both are now under my consideration for future projects. And lastly, I learn that communication is really important, especially in the early stage of development, as a lot of data structures have to be defined and unified among the teams.

There is also the excitement, and at the same time,  frustration, of planning what to do to optimize the time and the work needed to get the job done as we had a list of questions without a clear answer on where we should head to. Although on Gitlab, we got really few comments put up, the teams had a lot of face to face conversations to make decisions on problems, and that I think is a problem that we need to record more of our conversation during the next sprint. At the end of the sprint, we are able to finish every issue tickets that we put up initially and we got quite some spare time afterward so I think we did a really great job on what we set out to do and I think the more sprint that goes on, we would be able to take a much heavier workload.

From the blog #Khoa'sCSBlog by and used with permission of the author. All other rights reserved by the author.