This week, I read a Medium article called “Solving Everyday Problems: Essential Java Design Patterns You Need to Know” by Mina.
Link to the article

The post talks about how software developers use design patterns to handle common problems that come up while coding. It focuses on Java and explains how certain patterns, such as Singleton, Factory, Strategy, and Observer, help make programs cleaner, easier to update, and more reliable. Mina keeps the explanations simple and shows how each pattern can be used in everyday projects.

Why I Picked This Post

I chose this article because our course covers software design and programming in Java, and I wanted to better understand how professionals write well-structured code. Also the recent Homework assignments compelled me to explore for more knowledge on this complex topic. I wanted to learn how to organize my code better and avoid duplication. This post caught my attention because it explains the practical side of design patterns and connects them directly to real situations that developers face.

Summary of the Blog

The author starts by explaining what design patterns are — simple, reusable solutions for problems that appear often in programming. The patterns are grouped into three main categories: Creational, Structural, and Behavioral.

• Creational patterns (like Singleton and Factory) focus on how objects are created.
• Structural patterns deal with how classes and objects work together.
• Behavioral patterns handle how objects communicate with each other.

Mina gives short, clear Java examples for each type. For example, the Singleton Pattern ensures only one object of a class is created, which is useful for things like database connections. The Factory Pattern helps manage object creation without hardcoding specific classes. The Strategy Pattern allows different algorithms to be swapped easily, and the Observer Pattern is used when one object needs to respond to changes in another (like event listeners in Java).

What I Learned and How I’ll Use It

Reading this post helped me understand that design patterns aren’t just theory from textbooks. They are habits that experienced developers use to write smarter code. I learned how using the right pattern can save time and make programs easier to change later.

For example, in my Investment Wisdom Android app which I did as part of Operating Systems course, I can use the Factory Pattern to manage different types of investment data without repeating code. I also now understand the Observer Pattern better, which explains how buttons and screens update automatically in Android. These ideas will help me make my code cleaner and more organized.

Conclusion

This article gave me a clearer picture of how Java design patterns improve the way programs are built. It connects directly to what we are currently learning under the aegis of Professor Wurst. Going forward, I plan to use these patterns more often so that my programs are easier to test, expand, and understand.

Tags: CS@Worcester, CS-343, Week-8

From the blog CS@Worcester – Vish's Journey in Computer Science by Vishisht Seku and used with permission of the author. All other rights reserved by the author.

Specifically, the pattern calls for writing down fifteen (15) things that motivate you, then write another five (5) after waiting for a bit. Then, compare how different the two list are and what percentage of them are composed of external sources of motivation. Then, from both list, take the final five (5) that most motivate you.

From what I understood, it was trying to get you to differentiate between sources of motivation that are from your own self vs motivation that is pushed on by others, and also, ensure that the reason you continue to pursue programming is healthy. As it says right in the name, it is important to have sustainable motivations.

For example, if someone has, an ‘unsustainable’ motivation, they will be more prone to burn out, or even quit, but if someone has sustainable motivations, then even if they encounter difficulties in their work, project, or anything similar, they will continue to keep moving forward. This is obviously crucial, but the one part that I found a bit confusing at first was that I didn’t realize that external sources of motivation can also be fine as well as internal. I had assumed that all external sources were bad, but after writing down my list, I realized that, well, it’s okay to be motivated by those around you. It would be important to always have self confidence in yourself and it is important to continue coding because it is fun, or exciting, but there is no reason that you cannot have a healthy motivation because you want to follow in so and so’s footsteps because you respect them. From what I gathered, the pattern is not about internalization, but about a healthy balance of motivations to fight against burn out and stagnation!

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

Before our more recent classes where we learned about the Singleton and Simple Factory pattern, I knew about the concepts of refactoring, but in a different light. Rather than using these patterns and methods to make my code more efficient through a pattern of sorts, I consider refactoring as something more akin to making my code more readable and more efficient by breaking down useless portions of code. This isn’t exactly wrong, but it’s not completely right either!

Mainly, because though these approaches were important, they could be done even better! I main thing that I was missing in my own refactoring was obviously the design smells that we have recently went over now. Intuitively, I understood a few of the smells already, but now that I have a better grasp of many of them, it is clear that my older refactoring efforts were missing plenty of things!

For example, I used to clean up code and make it easier to understand by breaking them into chunks, which is good, but at the same time, I would also condense other areas since they seemed to ‘fit.’ It is clear now that I should NOT do that, but you live and you learn!

I think that the biggest resource that I found so far, is this website! Though it is basic and even a bit barebones, it gives a pretty good introduction to refactoring. It makes sure to consider things such as cleaning up dirty code from inexperience, a refactoring process, the design/code smells, and techniques to refactor as well as show off a few different design patterns!

One thing that might be helpful is that the website contains many different images to help break concepts down and even code examples! I know for me, it helps tremendously when I can look at some code and see exactly what is happening! Though I do understand the concepts a lot of the time, I find that I learn things a lot more quickly if I can look at the source and break things down myself! The website even has plenty of different coding languages too, so if say, Java isn’t your best, you can look at the different patterns in C#, Python, etc!

Overall though, I think that learning about a more refined structure to refactor code and implement these various design patterns will help me tremendously! I know that there have been times where I have gone to look at my old code and I’m sitting there lost, confused, and asking “Who did that!” Hopefully, with this in mind, I’ll have a better understanding of how to proceed with my older code past and future!

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

Encapsulation means to bundle data with methods that operate on that data, or to restrict the direct access to some of an objects components. There has been some debate between programming language researches on which meaning they prefer to use. The Gang of Four suggests that we consider what should be variable in our designs. This approach is the opposite of focusing on the cause of redesign. Many design patterns use encapsulation to create layers between objects, making it easy to change things on different sides of the layers without negatively affecting the other side. There are so many advantages of encapsulation, from data hiding, to reusability, to making testing your code easier.

As one of the fundamentals of OOP, it is arguably one of the most important due to the number of advantages it brings. I found all the information I obtained from a few different blog posts and articles, all of which had almost the exact same information. Having read just the definition, understanding the true essence of encapsulation was difficult, but the code examples I found were extremely helpful and made things clearer. I thought the manner in which the information was presented was easy to follow and the use of real-life examples and comparisons kept me interested enough to stay focused on the subject. Below is an example I found easy to understand;

The rest of the examples can be found at https://www.codejava.net/java-core/the-java-language/what-is-encapsulation-in-java-the-what-why-and-how.

I enjoyed learning about this principle and I feel more confident going forth in this field knowing yet another way to make writing code neater, more maintainable, flexible and easier to read.

Knowledge obtained for this blog post:
https://www.informit.com/articles/article.aspx?p=167890&seqNum=4
https://www.developintelligence.com/blog/2013/04/encapsulate-what-varies/
https://levelup.gitconnected.com/object-oriented-design-principles-bb6daf98b185
https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)
https://www.geeksforgeeks.org/encapsulation-in-java/

From the blog cs@worcester – Coding_Kitchen by jsimolaris and used with permission of the author. All other rights reserved by the author.

The blog starts by talking about typescript, the writer says it is type safe which means it can generate errors at compile time only. It is also purely object oriented an extends object oriented javascript. Typescript also allows to write class, interface and module-statements just like in Java and lastly typescript can transpile to any version of javascript code.

Next the writer talks about the speed and performance of Angular 2 and that it supports lazy loading which means you don’t need to load the complete app at once but modules can be loaded dynamically whenever there is a requirement. Angular 2 also supports AOT compilation which allows you to compile your code ahead of time.

Skipping the uses of the valid HTML, DOM section, the writer talks about the modular design of Angular 2 and how it is easier for Java based programmers to learn a new Javascript framework. Lastly though in the blog the writer shows code how to use the bootstrapping application and talks about and shows dependency injection enhanced.

The reason I chose this blog was because it is very familiar to what we are talking about in my software class in college right now. We are trying to do typescript in webstorm for our duck simulator program that we had to write in different strategy patterns. Getting back to Angular 2 and typescript, this blog explained a little about typescript and what the writer learned from Angular 2 and how it works and what it can do. I’m not an expert on Angular yet, just learned it was a thing so getting any information from anywhere right now is always good to improve my skills. The writer says Angular 2 allows people the ability to make a single page application in a perfect viable way. Reading that makes me really want to get into Angular and learn it because going to a work place and applying to a job, if you can make them a webpage or do any computer science things that involve creating applications, it makes you more wanted than if you didn’t. That is given that if you have more impressive details on your application then you will be more wanted by a job, well with this skill in angular you could also do some freelance work, make webpages or applications for different companies for a side job, a lot of people could make a lot of money just by doing that, so I’m not shying away from learning angular and type script. In conclusion, Angular and typescript are very important for a computer scientist future, also this blog is a good read, gives some details about angular 2 and how it works. Thank you for reading my blog this week, come back next week for some more programming talk with me.

Source: https://blog.knoldus.com/2017/06/14/when-i-took-angular-2-to-build-my-application/

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