Category Archives: Week 10

Record What You Learn

Hello and welcome back to another week of my blog. This week, I looked through chapter 5 of the book Apprenticeship Patterns by Dave Hoover named Perpetual Learning. One particular apprenticeship pattern I found interesting was “Record What You Learn.” This pattern is about taking notes and keeping track of what you learn in your journey as an apprentice or a learner. The idea is that if you write things down, you can look back on them later and remember what you’ve learned. Plus, by sharing your notes with others, you can improve your communication skills and help others learn too. There can be several ways to record what you have learned throughout your journey, such as constantly updating a journal, personal wiki, or writing a blog, such as me writing these blog posts when I learn about the different apprenticeship patterns. Those listed have only writing involved. Other ways you could record down what you have learned include making a drawing or even making video recordings of yourself. No matter what way you choose to record what you have learned, it is important to keep a date on them. This way, your recorded notes will be organized and sorted in chronological order.

I should start following this apprenticeship pattern especially since I tend to forget things that I have learned such as a stack versus a queue in Java. Sure, I could just look up what the differences are online, but actually writing it down in my own style would help me remember it more easily. In addition, if I forget anything in the future, I could always just refer back to my old notes. When I start incorporating this apprenticeship pattern into my journey, the main way I would like to take notes would be to find something digital and write stuff down in it. I prefer writing stuff down with a stylus, like using an Apple Pencil on an iPad, since I tend to remember things more when writing notes down rather than typing them out. I hope to start using “Record What You Learn” because it will be highly beneficial to my computer science career.

From the blog Comfy Blog by Angus Cheng and used with permission of the author. All other rights reserved by the author.

Apprenticeship Pattern: Learn How You Fail

This week I read the Apprenticeship Pattern Learn How You Fail. The context of this pattern is that failure is inevitable. It happens to everyone eventually. If someone has never failed then they have either avoided pushing boundaries or learned to overlook mistakes. The problem given with this context is that your learning skills have enhanced your successes, but your failures and weaknesses remain.

The solution given for this pattern is to identify the ways in which you tend to fail and try to fix them. This pattern is not about self-pity or trying to make things perfect. It is about gaining self-knowledge about the habits and behaviors that lead you to failure. Once you become aware of the things that trip you up you will have the choice to either fixe these problems or cut your losses. You will need to accept that there are things you’re not good at or that would require a great deal of time and effort invested to fix the problem.

The action plan to help solve this issue is to use your choice of a programming language and a simple text editor to write an implementation of binary search in a single sitting. Then write all the tests you think you will need to confirm the code is correct. Before running the test and compiling the code go back and try to fix the mistakes you have discovered so far. After that run the code and see what errors are still there. Think about what you learned and how the errors could have happened when you thought the code was perfect.

I chose this pattern because as this pattern said, failure is inevitable. I have had failures in my software projects and I will certainly have more failures in the future. I want to be able to fix these failures by correcting my weakness and bad habits. Following the action plan given in this pattern will help me understand where I might have blindspots for errors. I also need to think about my past failures and figure out the common cause that leads to them. I think taking the time to do these will be a great learning experience for me and it will help me in my future career.

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

What are Anti-patterns?

Anti-patterns are on the opposite side of the design pattern and are undesirable according to the blog “Anti-Patterns in Software Development That You Should Avoid”. Another term to describe Anti-patterns are called Design Smells.

The blog goes over the concept of the Golden Hammer anti pattern which occurs when using a familiar solution to attack an unfamiliar problem. Sometime it might work out, but most of the time it’s an inefficient way to solve problems.

The Golden Hammer anti-pattern is a concept that can shared in every aspect of life. Like for example, as mentioned in the blog some people tend to have their solution ready before understanding the problem like a doctor prescribing while the patient is still telling about the symptoms.

In software development, each design pattern is basically suited for its targeted problem. But it’s really easy to use the same framework, the same programming language, and the same design pattern for almost every problem. Like similar to the doctors example, some doctors might prescribe Ibuprofen to help a certain health but it might not completely relieve or heal that issue completely.

And so the Golden hammer could lead to; Poorly performing code, Overly complicated code, Redundant code. To avoid this anti-pattern it is best to find all potential solutions for one problem and benchmark them. List down all PROS and CONS for each solution then choose the better one.

Another anti-pattern is the God Class which for the most part controls many other classes, takes many responsibilities as well as lots of dependencies. An application could be well designed at the beginning so that there aren’t God classes but eventually dominant, very well specified classes will turn into God classes at some point.

The big ball of mud is a very common anti-pattern that happens when the solutions/application lacks a perceivable, flexible, suitable architecture as defined in the blog. A ball of mud will have, haphazardly and sloppy structure without coding comments, contains many God classes with more than 6000 lines of code, static variables/functions everywhere, methods being overloaded several times, and code duplications.

This anti-pattern is dangerous because it could happen while writing the application. Once we can’t refactor the code anymore, then we have to rewrite the entire thing. There are many reason why this anti-pattern could be brought up. It could be due to the frequent changes and requirements that the application might need, the deadline is near and the project is rushed, new developer are being brought in, or being too narrow minded about the design architecture that was initially brought in.

There are many more anti-patterns when it comes to the software development process, these are just the most common ones to date.

Link to blog:

From the blog CS@Worcester – FindKelvin by Kelvin Nina and used with permission of the author. All other rights reserved by the author.

Unified Modeling Language (UML)

Unified Modeling Language is a standardized language to visually represent software construction, design, and architecture. UML designs are process independent, and often omit irrelevant, or insignificant relationships and attributes in favor of simplicity. UML diagrams can be used to represent a variety of things in several ways. UML diagram can be classified into two main categories: Structure Diagram, and Behavioral Diagram.

Structure diagrams show the structure of objects and the relationship/interaction between those objects. Structure diagrams are to be considered descriptive and behave like a blueprint for the code, i.e., it can be used to inform the design of written code. Class diagrams are one of the most frequently used Structure diagrams in software development. It shows each of the classes in a system with their attributes, class methods or operations, the scope of every attribute and method within a class, and the relationship between two or more classes. A class diagram has three parts: Class Name, Attributes, and Methods. The name of the class is always at the top, while any attribute like a variable is in the middle. A note can be added pointing to the attribute to show any individual specification or requirement. The methods are listed at the bottom and can similarly have notes pointing to the method to show any individual specification or requirement. Arrows are used to describe the relationship between two or more classes. Depending on the arrow the specific relationships can be identified. The various relationships are Association, Dependency, Implementation, and Inheritance.

Behavioral diagrams show the intended function of the system and any objects it contains. They describe how those objects should interact with each other to make the system functional. Behavioral diagrams are considered prescriptive, i.e., they show how the written code should work in the system.

As a CS student, I found thisblog post on UML diagrams to be highly relevant and useful. Homework 1 and Homework 2 provided a great opportunity to delve into the complexities of these diagrams and gain a deeper understanding of their various properties and concepts, especially for Class Diagrams. It will very likely be useful in future classes as UML diagrams allow you to be able to communicate your design ideas effectively to other members of your group, ensuring that everyone is on the same page and working towards the same goal. They can also be a valuable resource for documenting and maintaining software systems, making it easier to understand and modify the system as needed. For example, the visibility of attributes and the connections between classes, as represented by arrows, are crucial elements that contribute to the overall coherence and functionality of UML diagrams. Additionally, the provided examples helped to clarify and illustrate these concepts in a clear and concise manner.




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


This week I learned about anti-patterns by reading “Anti Patterns” by Ilyana Smith. Smith explains “An Antipattern is a description of a “negative solution” and a corresponding “positive solution.” In other words, an Antipattern describes a common way of solving a problem that actually causes more harm than good, alongside an example of a better way to solve that problem”. Smith then gets into the details about each pattern and the problems they cause.

Smith tells us that there are seven deadly sins of software projects that are the root causes of problems. These “sins” are haste, apathy, narrow-mindedness, sloth, avarice (overcomplicating things), ignorance, and pride. There are 18 anti-patterns Smith talks about. These anti-patterns are analysis paralysis, architecture by implication, the blob, copy-paste programming, death by planning, design by committee, functional decomposition, functional decomposition, golden hammer, intellectual violence, lava flow, and poltergeist, reinvent the wheel, spaghetti code, stovepipe enterprise, Swiss army knife, vendor lock-in, and singleton.

As you can see, there are a lot of anti-patterns. I will not be able to describe all of them so I suggest reading the article yourself, but I will go through a few of them. Analysis paralysis is when a software team gets caught up in the design and planning phase and fails to start any development.  The blob is building a class that does most of the work and there are a few secondary classes that contain mostly data. Copy-paste programming is a problem because if there is a problem in the code you copied it will be everywhere you paste it. These are just a few of the many anti-patterns.

After reading about the seven deadly sins of software projects and the anti-patterns associated with them and how important they are. I also learned there are a lot of things I should avoid when working on a project. Some of these anti-patterns could be easy to get caught up in like analysis paralysis. Being too caught up in trying to get the perfect design is something I could see myself doing so keeping these patterns in mind is something I should do. I think Smith did a great job explaining these patterns in a way that is easy to understand but still gets the point across. I would recommend this post to any software developer looking to improve their skills. Even if only one of these patterns is a new concept, I am sure it would be worth the read.


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

Week 10 – Rest API

For this week, I decided to look at’s article on REST APIs. We are currently learning how to use and work within REST API environments, so I assumed that this article would just be review, but I have learned some new topics. The article essentially describes what REST API’s are and how they work. Before delving into REST APIs however, the article explains what API’s are. Essentially, they are a middle man between the user and an application regarding information. The article uses a customer at an unknown restaurant for an analogy. The server is the API, and the customer is the user. The user requests a specific item from the menu, or the API’s documentation, and the server brings that request to the kitchen, or the application, and then returns with the user’s order. Rest API’s are specific to web servers only, and use a set of 5 different HTTP functions to perform their operations, GET, PUT, PATCH, DELETE and POST. All of these essentially create, read, delete and update information. These features allow the user to alter and gather information from a web server from a simple application and without having to go into the actual code to do this, after the REST API is set up. The information is then returned to the user in either a json or XML format.

I picked this article due to its simple yet effective explanation of what REST APIs are. As stated before, we are currently working with REST APIs in class, so a lot of this article was review, but this article expanded my way of thinking how REST APIs work. I have used freecodecamp’s articles in the past, and they provide free and simple explanations for complex software topics that are very beginner friendly. The article also included real code examples of how to use some of the requests, along with a different method of using the requests than from what we learned in class by using the fetch API.

This article will help with my work in REST APIs thanks to its clever ideas in how its explained. I have never thought of the restaurant analogy, and I am sure it will help with learning more about REST APIs, and when I am explaining to my friends or family what it is I am doing in school, I can lead them to this article to help their understanding.

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

Week 10: Practice, Practice, Practice

For this week, I chose to read the pattern ‘Practice, Practice, Practice’ from Chapter 5: Perpetual Learning. The name is pretty self explanatory as to what the pattern will be on, practicing. I originally chose this pattern because it’s something that we need to reinforce within ourselves in order to get better at something, for coding especially. This is something I still struggle with due to my lack of drive and motivation but everyday is another day to push myself. Any way, the context of this pattern is wanting to get better at the things you do, to develop concrete skills. Again, just looking at the title gave away the context of this pattern, but that was it.

For the problem of the pattern, it is being unable to learn from your mistakes due to the performance of you daily programming activities, you feel like you’re always on stage. I assume this is in context of a job, but I haven’t experienced this problem yet so knowing about it ahead of time is going to help me down the line. For the solution of this pattern, you want to be able to practice without interruptions and in an environment that makes you comfortable making mistakes. This seems like an easy solution but in practice I’d imagine it’s hard. The solution also mentioned having a mentor to watch you over your practice and provide feedback. This is something I’d be interested in doing but I lack the humility to have a mentor watch me and provide me feedback, I’m always trying to do things on my own. I also dread looking at feedback because I feel I always mess something up, but I believe a pattern in the one of the previous chapters mentioned to put aside your ego, so I’ll have to go look at that one again.

Finally, for the action of the pattern, something I don’t write about often but I thought it would fit here, is to read one of the books that was previously mentioned in this pattern and take an exercise from it or make one yourself. The exercise should ideally be slightly harder than you can easily solve. You’ll then do this over 4 weeks and record your solution every time and over the 4 weeks you should observe how your solutions evolve. I thought this was an interesting take on practicing coding that I’ve never heard about. I usually just one and done exercises but repeating a exercise really cements it into your head so I’d imagine this way is much more beneficial to me.

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

Craft over Art

It is important to create things beyond that what is expected. You should go above and beyond the specifications of the application and create something that will wow the product owner.

I think it’s interesting to look at software development as craftsmanship and what you create as art. I do think that programming is a form of art because you have to use your creativity to make anything that you produce. Being artistic is a good way to look at creating an application, especially one with a user interface because it is what people will be looking at whenever they interact with the software. You want something to look beautiful and appealing just like a piece of artwork. In my opinion, someone would be more likely to use attractive-looking software than one that is unappealing to the eyes. It’s also important to make something that’s easy to navigate because that enhances the user experience.

I typically try to go above and beyond in the project that I’m working on. It is good for personal growth and reflects well on my portfolio. It is nice to be able to show a future client past work and be proud of the artistic design element of what I created. I prefer working on the backend, but I do enjoy creating a nice UI that users enjoy interacting with.

I think it is important to put extra time and effort into the products that you are creating for your clients. However, I think it’s important to not get lost in the details of creating something more than they asked for. Sometimes it’s possible to add features and create things that the client might not want and then you are forced to remove them. There are other times where you might put in extra work, and you were taking time away from yourself for other projects that need attention. Even though it’s good to have just to have the learning experience, I think it’s also important to make sure that projects for clients, that you put in extra effort into, should get some form of acknowledgment.

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

“Draw Your Own Map”

Jennifer Gayle once said “You are the author and writer of your own story. Turn the page, start anew, and make sure it is a story worth telling”. In life, we have an open road that we are set upon. Sometimes there are factors that narrows that path. Upon reading Draw your own map, it has explained that we are not to be limited from outside factors. Such as a company with their own set expectations that conflicts on what you are interested in instead therefore, we must be more open to search for more opportunities. That it is alright to make modifications to our own maps to further gain motivation and values. 

I enjoyed the section of the solution for this matter; it piqued my interest where we must take the first step to make a motion forward. Even though it may be terrifying, but we must be willing and determined to walk forward. I also aggreged that we do not have make big goals that are broad but instead make smaller ones that can be achievable. This way we can make further adjustments to our map. It would not hurt to make bigger goals for long term but to break them down into small goals to conquer those bigger goals. There was not any part of the pattern I disliked as I believed this is very useful information. 

Using this pattern towards my life and career will be deeply considered when I go into the software development profession. To always remember that I can find many other opportunities that aligns with my interest of what I am looking for. And if it ever comes to fall out of place from my map that I will branch out my path even further to keep the love and interest I am intended to keep on going. Understanding that after having to trying out a new path and having a new set of values is essential to our mindset. To keep in mind that we ask ourselves is it worth it? Could this step hinder our truest potential? That is why we must keep expanding our choices and chose whichever is best in one’s interest.

From the blog cs@worcester – Dahwal Dev by Dahwal Charles and used with permission of the author. All other rights reserved by the author.

“The Long Road” Apprenticeship Pattern


This apprenticeship pattern concerns the long term journey that a programmer / developer will take throughout his or her lifetime. In a society that continuously values decadence, it’s important to find a path that is right for you, no matter how weird or seemingly unusual it may be. As we gain experience as programmers and developers, there will be temptation to mindlessly progress down the path of greater income and short term gain. Instead, this pattern is for those who aspire to progress down a fruitful path in software development, gaining experience in a lifelong career.

What I find most thought provoking about this pattern is the prospect of leaving the field of programming permanently to go down another field of salesmanship or to a high ranking position in a corporation. Software development to me is a very intricate and professional field that requires a lot of research, experience, and experimentation. Someone who progresses far enough into the field only for them to change directions because of their experience seems somewhat confused to me. On the other hand, it at least makes some sense as someone who has a lot of experience in software development can have a lot more skill as a business owner or a salesman in selling software, and recognizing development cycles for a product.

This pattern has indeed somewhat caused me to change my view of my future. I knew that within the software profession there were many different ways that one could go, and that we would need to be experienced with different tools if we needed to create a competent product. I wasn’t sure, however, of the potential of an opportunity arising to shift to a different career

I generally agree with this pattern. The part I agree the most is on the matter of strange roles that one may possibly find himself in in the future. Personally, my work and perspective on planning my future took a drastic turn almost a year ago, where I actively tried to search for a career as a programmer based on the tools that I already knew. Then, I found out that it’s better to learn and gain experience with new things that I don’t know, based on the demands of a job and the industry.

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