321 reads

128 Stories To Learn About Design Patterns

by Learn Repo21mFebruary 15th, 2024

Too Long; Didn't Read

Learn everything you need to know about Design Patterns via these 128 free HackerNoon stories.

People Mentioned

featured image - 128 Stories To Learn About Design Patterns

The result of the next pen shows the case where I'll use the Publish/Subscribe pattern. Every time you click on the Event button a square is added and a message with the number of squares is displayed.

2. Creating Extension Methods Using Typescript

I really like C#'s extension method feature. I was trying to experiment it on Typescript with decorators.

3. A simple Event-Sourcing Example Using Lambda and DynamoDB [Includes Snapshots]

Recently, I have been helping a client implement an event-sourced system. In the process, I put together a very simple demo app which is available on GitHub here.

[4. Animation/Motion Design Tokens

for Complex Design Systems](https://hackernoon.com/using-animationmotion-design-tokens-for-more-complex-and-sophisticated-design-zy3t33y5) Each Animation needs a Trigger, Duration, Easing, and Property element. Design systems also play a part in creating Motion Design and Animation.

5. A Beginner's guide to Ruby on Rails MVC (Model View Controller) Pattern

In this article, we’re going to learn a little more about the MVC, the system Architecture at the core of the Rails Framework for Software Development. Hopefully, by the end of it, you’ll know why working with a system architecture can make all the difference when developing an app.

6. Can You Really Code Without IF Statements?

I went to an OOP workshop by Sandi Metz several years ago. She made a comment that at one of her previous jobs, they didn't use if statements.

7. What is GRASP? Information Expert and Creator Principles in JavaScript

What is GRASP? Why do we need it? Information expert and creator principles using Javascript examples.

8. How to Create Abstract Syntax Tree with Acorn

9. Software Design Principles: Doing Little Things Right

Designing software systems is about tradeoffs and making tradeoff decisions is hard. You always feel like you are loosing one thing or the other but that’s not what we are going to talk about today.

10. Hooked on React's Array Destructuring Pattern

The other day I was reading up on the legendary React God Dan Ambrov’s great but very un-TLDR post on useEffect.

11. Uncover the Alias Pattern

The Alias pattern minds two issues. Extending how a final class builds its objects.

12. How Experienced Software Engineers Evaluate Designs

Experienced software engineers learn what works after maintaining their work for years.

13. Stop Using The ‘else’ Keyword in Your Code

If-else keyword built into nearly every programming language and simple conditional logic are easy for anyone to understand. If you are a programmer, you know else keyword. But if you are a good programmer, don’t use this keyword. One of the biggest mistakes I fell into when starting was overusing the else keyword when writing conditionals. I stopped using this keyword in my programs since 5 years ago. Let me explain!

14. What is a HashMap in Java?

Hashmap is a collection of key-value pairs and an array of nodes. It uses an array and LinkedList for storing key-value pairs.

15. Simple and Intuitive RESTful APIs

This article provides guidance on how to design simple and intuitive RESTful APIs.

16. Decouple Your Go Components by Leveraging Mediator and Event Aggregator Patterns

Decouple your Go components by leveraging Mediator and Event Aggregator patterns. Learn how to use open-source mediator / event aggregator library called mob.

17. The Fallacy of Strongly Typed Languages

This is a story of how I moved from hate to love for NodeJS language while being a Java developer, filled with insights I encountered during this process.

18. GO Design Patterns: An Introduction to Builder

Streamlining Your Code: An Introduction to the Builder Pattern in Go

19. GRASP Principles - Part 3: Polymorphism, Pure Fabrication, Indirection, Protected Variations

The last part of GRASP is where we will learn polymorphism, pure fabrication, indirection, and protected variations and how to use them in our projects.

20. Common Design Patterns for Building Resilient Systems (Retries & Circuit Breakers)

We talk about two design patterns that highlight best practices for building resilient microservices architectures at scale.

21. The Web Design Trends you Must Not Miss in 2022

web design is moving into the future, with advanced techniques like retro revolution, fewer images, and Memphis design.

22. Use Database Transaction Logs to Implement Observer Pattern

The best way to implement the observer pattern - using transaction logs of databases.

23. 12 Methods of Improving Your Monolith Before Making the Jump to Microservices

Like tidying up a house before a total renovation, preparing your monolith is the first step towards transitioning to microservices.

24. Why To Prefer JSX Over JSON-like Objects For Building React Components

Imagine you have several blocks of similar layout which are hard-coded on the frontend side. These blocks are not dynamic, they are not being fetched from back-end, it’s just a layout. Most beginners, when they see similar blocks of layout, start to think about arrays as a tool to handle similar stuff.

25. Advanced Property Pattern Techniques in C# 8.0

The article describes how pattern matching effectively utilises and processes data in forms not part of the primary system.

26. Working With Iterators and Generators in Javascript ES6

Here are the use cases for iterators and generators that are closer to the real-world scenario than a simple "Hello World" type code.

27. Using the Forward Trust Design Pattern to Make Scaling Easier

The Forward Trust design pattern used in the Yield Protocol simplifies integration and makes scaling easier.

28. On the Love of Problem Solving & Programming: Noonies Nominee Sukhpinder Singh

Noonies interview with Sukhpinder Singh, Senior Engineer at SourceFuse.

29. Inheritance vs Composition in JavaScript

Inheritance vs Composition in JavaScript. What is better, when use inheritance, when use composition. We will look at different examples on JS.

30. An Intro to Container-Presenter Design Patterns in React

31. Software Design Patterns Explained

Software design patterns have been used to package solutions to many common design conundrums. Each one has its own advantages and drawbacks to consider.

32. A Review of API Design Patterns: The Pros and Cons

Nonetheless, it's a great book that I recommend to any developer entering the world of APIs or even one with more experience to round up their knowledge.

33. Keeping Code Clean with Rails Service Objects

You can keep your Rails app cleaner and easier to maintain using Service Objects. Service objects help to decouple business logic from your controllers

34. What is a Façade Design Pattern?

Use the facade design pattern to simplify the interaction between subsystems. It provides a single entry point to a subsystem,

35. Open Closed Principle With Service Locator Pattern

Open closed principle is the most simple one in the list of software design principles I understand. "Open for extension, close for modification" - the idea seems quite straightforward. Let's create an example about validation.

36. When are Barrel Exports Harmful

Why we should be careful not to abuse barrel exports in our TypeScript code.

37. How to Transform Your C# Code With the Command Design Pattern

Command Design Pattern is one of the behavioural design patterns used to encapsulate a request as an object, thus enabling to parameterize clients with differen

38. SOLID Principles in JavaScript: What Does the "S" Stand For?

In this article, we will discuss what is SOLID principles, why we should intend them. Also, we will take a look at examples of "S" principle using Javascript.

39. Feature Flags for Product Managers: Give Yourself Options for Handling Risk

As a product person, have you ever witnessed large, complex releases result in outages or rollbacks?

Have you wanted to make configuration changes in productio

40. Fluent Interface With Callbacks

41. Solar Architecture: A New Perspective on Enterprise Software Development

The development life cycles of applications in an enterprise environment often follow a common theme. An application begins life with a clear purpose in mind and over time has requirements brought in that cause incremental additions to the scope of the original concept. These additions could either be completely in sync with the original concept or perhaps the requirement just had no better home to belong in. As the application matures to an end-of-life state it has now grown far past its original intended purpose and is in dire need of a refactor — breaking down the monolithic beast into smaller and more succinct components.

42. How too Much Love for Your Code Can Hurt the Product

A story about how important it is to keep a smooth balance between complexity and simplicity while building software.

43. Accessing Kubernetes Using Expose API and User Interface Using Sidecar Pattern

Kubernetes is an open-source container-orchestration system for automating application deployment, scaling, and management.

44. Basic Web Design Principles to make Your Websites Pop

Five pillars of web design

45. The Decorator Pattern In a Content Management System

A decorator pattern is a powerful tool that can be used to modify and extend functionality in PHP and MySQL-based content management systems.

46. What You Need to Know About the Unit in Work in C#

The Unit of Work design pattern is a software design pattern that is widely used in software development. It is a way to group database-related operations

47. How To Write Decoupled Code with MediatR: The Mediator Pattern

I recently wrote a blog post introducing some of my favourite NuGet packages: My Top 4 NuGet Packages for ASP.NET Core. In that post, I briefly introduced a package called MediatR. Today, I will dedicate this post to revisiting MediatR in further detail.

48. A Comprehensive List of Free Fonts for Designers

This comprehensive list includes a wide range of options, from elegant serifs to modern sans-serifs, so you’re sure to find something that fits your project.

49. Introduction to Design Patterns and Dependency Injection

A walk-through of dependency injection.

50. Real-World Examples of Using Design Patterns in Modern PHP

Design patterns are an essential part of software development, providing a common language and best practices for recurring problems.

51. Understanding Currying, Closures, and Coupling in JavaScript

Here's a problem. You have an object in your code exposed via an export. You also have a function in the same file (also exported) consuming that object directly.

52. Welcome to the OOP pattern matching: Visitor Pattern

Visitor pattern is dead. Long live to Visitor pattern. (With Kotlin examples)

53. My Top 10 JavaScript Articles from 2019

JavaScript has come a long way since its humble beginnings as a clunky, exclusively front-end scripting language. We saw some big developments in the JavaScript landscape during 2019, including the widespread adoption of React hooks and functional programming concepts, steady conversion to TypeScript, and continued domination of React in the front-end framework ecosystem.

54. Virtual Sampling: Reducing Waste in Design & Product Development

Virtual sampling has become an applicable alternative for brands to utilize in their production process. A brand like Hugo Boss are adopting this.

55. Introduction to Circuit Breaker Pattern: How to Build Better Software

In any application, different sets of services/third-party APIs communicate either asynchronously (out of score from current context) or synchronously or sometimes both (rare cases).

56. TableView, CollectionView Infinite Scrolling: An Easy Way in Swift

“Pagination, also known as paging, is the process of dividing a document into discrete pages, either electronic pages or printed pages.”

57. 9 JavaScript Design Patterns You Will Love

Design patterns are reusable solutions for common problems that occur during software development. Here are my 9 favorite design patterns for JavaScript

58. GO Design Patterns: An Introduction to SOLID

Adopt SOLID design principles in GO for better code quality and easier software maintenance.

59. How to Simplify Data Access Using EF

The repository architectural pattern is frequently employed in software development to segregate an application's business logic from the data access layer. It

60. Understand the Intent of Patterns And Principles Before Applying Them

TL;DR;

61. Static Polymorphism using Curiously Recurring Template Pattern (CRTP)

Inheritance is one of the most used method for code reuse. Object Oriented Languages strive on the inheritance to collect the common functionality in a base class.

62. If it Looks Like a Duck, Quacks Like a Duck, But Needs Batteries - You Have the Wrong Abstraction

Liskov’s Substitution Principle | SOLID as a Rock

63. My Laravel Repository Pattern Solution (in only 30 lines of code)

A 30 line piece of script can finally provide a good solution for a repository pattern in Laravel apps.

64. Pattern Matching in C# for Complex Scenarios: An Extension on Property Patterns

The article describes how pattern matching effectively utilises and processes data in forms not part of the primary system.

65. Intercept It: How to Implement Different Logic For Different Functions

In brief, the pattern injects some logical functionality before and/or after function execution.

66. Exploring the API-First Design Pattern

Learn how the API-first design pattern is a carbon copy of the successful writing approach that John Vester has leveraged for several years.

67. Design Patterns: WTF is a Shim?

During design meetings at my workplace and even during other conversations with friends, the term "shim" appeared to being placed offhand, with the context not being setup properly to indicate what it is exactly that the "shim" represented.

68. Design Patterns: Exploring Factory Method in Modern C++

In software engineering, Creational Design Patterns deal with object creation mechanisms, i.e. try to create objects in a manner suitable to the situation. In addition to this basic or ordinary form of object creation could result in design problems or added complexity to the design.

69. Serverless Architecture: Lambda Triggers and Design Patterns [Part 1]

A while ago, we covered the invocation (trigger) methods supported by Lambda and the integrations available with the AWS catalog.

70. Introduction to RxJava: Observable Pattern

"RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences." by RxJava developers.

71. 11 Commandments Of Smart Contract Designing

Unlike my sleeping pattern, design patterns are meant to make things more stable and predictable in the future. It is an elegant solution to common problems in software design.

72. Adapter Design Pattern: Adapt Everything With Your Codes

When we start building software, we can see many code's incompatibilities. This is because of many codes have been written based on different contracts.

73. SOLID Design: Dependency Inversion Principle in C++

Dependency Inversion Principle in C++ is the fifth & last design principle of a series SOLID as a Rock design principles. The SOLID design principles focus on developing software that is easy to maintainable, reusable & extendable. In this article, we will see an example code with the flaw & correct it with help of DIP. We will also see guideline & benefits of DIP inclosure of the article.

74. Memento Design Pattern Overview

Memento design pattern is a software design pattern that is used to roll back an object to its previous state. It is a part of the behavioural design pattern which is concerned with algorithms and assignment of responsibilities between objects.

75. Software Architecture Basics: What, How & Why

Software architecture, design and process of architecting explained using a case study.

76. The growing pains of becoming an Intermediate developer

77. The Ultimate Guide To Design Patterns And Generic Composite In Python

Generic implementation of the Composite Design Pattern in Python.

78. Coding on Python at Home

How many more reports can you generate? How many sales figures do you have to tally, how many charts, how many databases, how many sql queries, how many 'design' pattern to follow, how many bugs to fix etc. etc.. because you get paid for it.. Fatigue sets in , purpose of living is being questioned, and just when you are about to yell '.. to hell with all this..', your mortgage comes due, and don't look for that escape vacation because we are in a corona virus shutdown..

79. CSS Block Element Modifier

We all have names for everything – our cats, dogs and maybe even that cow we are about to kill. But how come we do not name our CSS codes? The sad thing is that so many programmers and developers tend not to name the CSS codebase they are using.

80. Exercises on Dependency Injection in ASP.NET: Introduction

In this post, we will do some exercises to go over the basics of DI (Dependency Injection) in ASP.NET.

81. Design Patterns: Singleton Pattern in Modern C++

In software engineering, Creational Design Patterns deal with object creation mechanisms, i.e. try to create objects in a manner suitable to the situation. The basic or ordinary form of object creation could result in design problems or added complexity to the design. In this article of the Creational Design Patterns, we’re going to take a look at the much-hated & commonly asked design pattern in a programming interview. That is Singleton Design Pattern in Modern C++ which criticizes for its extensibility & testability. I will also cover the Multiton Design Pattern which quite contrary to Singleton.

82. Difference Between Inheritance And Composition

With the introduction of OOPs, Inheritance and Composition entered our senses and still confusing us.

83. Open Closed Principle: SOLID as a Rock

This is the second part of a five-part series about SOLID as Rock design principle. The SOLID design principles, when combined together, make it easy for a programmer to craft software that is easy to maintain, reuse & extend. Open-Closed Principle(OCP) is the second principle in this series which I will discuss here with minimalistic example in Modern C++ along with its benefits & generic guideline.

84. Adopting the Repository Pattern for Enhanced Backend Development With FastAPI

In this article, we'll cover the benefits of utilizing the repository pattern in building backend systems with FastAPI.

85. A Great Design Is Only Half The Battle Won: Design Trends 2021

In this blog, you will learn about the Graphic design trends as we move forward in the year 2021.

86. How To Use Filter Pattern With Generic Lambda Expression

The filter and pipeline patterns can be optimized with code reduction using lambda expression(shortcuts for anonymous method) as concrete filter condition. To demonstrate concept, the sample WPF UI application was created. Here is Source code

87. Know the Vitality of Mobile App Architecture

The output is what measures the success of a business. Therefore, all the business houses are adopting all the inevitable methods and programs to intensify their productivity/ output by adopting new technologies and concepts. There are several technologies available and many in the developing phase, which effectively fulfil customers’ needs and generates high output.

88. Find out Whether Model Observers in Laravel are a Bad Practice

Keep your Model Observers in Laravel under control.

89. Is There Really a Hierarchy in Design?

Designers should stop using the ‘Hierarchy of Design’ concept as the representation of design characteristics as a pyramid is inaccurate and misleading

90. 2023 Graphic Design Trends: A Look into the Future of Visual Design

In this article, we'll take a deeper dive into the seven graphic design trends that are set to dominate in 2023.

91. Solidity Tutorial: Understanding Design Patterns [Part 1]

Solidity design patterns are essential for creating secure, robust and scalable smart contracts. In this tutorial, we will learn proper implementations

92. SOLID Principles in JavaScript: What Does the "L" Stand For?

Hello, guys, this is the third part of SOLID Principles in JavaScript and if you haven't read the previous two (first part and second part), I highly recommend to read them first and coming back here.

93. Understanding Event Driven Architecture

Event-driven architecture is a software architecture paradigm promoting the production, detection, consumption of, and reaction to events.

94. Singleton Pattern: The Root of All Evil

Allowed global variables and supposed memory savings

95. What is Primitive Obsession and How Can we Fix it?

Primitive obsession is a code smell in which primitive data types are used excessively to represent your data models.

96. SOLID Principles in JavaScript: What Does the "O" Stand For?

Hello, guys. This is the second article about SOLID principles with Javascript examples. In my previous article I described what are patterns in general, what is SOLID and why we should use them. If you haven't read it, pls, read it now and continue read current article after the previous one.

97. Vishal Chovatiya Writes Code When It Is Helpful To Others in The Future

You know that feeling when you work really hard on something for really long and it feels like nobody really notices?

98. SOLID Principles in JavaScript: What Does the "D" Stand For?

Hello, guys, this is the last part of SOLID Principles in JavaScript and if you haven't read the previous three (first part, second part, third part, fourth part), I highly recommend to read them first and come back here.

99. SOLID Design: Interface Segregation Principle in C++

Interface Segregation Principle in C++ is the fourth & by far the simplest design principle of a series SOLID as a Rock design principles. The SOLID design principles focus on developing software that is easy to maintainable, reusable & extendable. In this article, we will see a code violating ISP, a solution to the same code, guideline & benefits of ISP.

100. What About The Illusion Of Choice?

Do you think your actions are the result of your own free choices? What if those actions are the inevitable and necessary consequence of antecedent states of affairs? What does this mean for your free will?

101. SOLID Principles of Object Oriented Design And Architecture

Object oriented programming (or OOP) is a style of programming that encapsulates data and behaviours into models known as objects. In this way, related code is grouped together and kept separate from other code, and provides reusable blocks that can be used to rationalise the problem at hand.

102. Complicated patterns aren’t always that complicated. Usually it’s the simple ones that bite you.

Staring at the maze of interconnected passageways of the microservice system, I immediately recognized the problems.

103. NULL: The Billion Dollar Mistake

He is not our friend. It does not simplify life or make us more efficient. Just more lazy. It is time to stop using null.

104. UX Design Patterns: Hacks For Better Transparency And Feedback In FinTech Apps

What are the problems regarding transparency and feedback in FinTech applications? Which UX design patterns can be used to address them? Find out!

105. Companies Have Affected Our Digital Wellbeing for Too Long: We Need More Friction in Our Algorithms

Companies have paid lip service to our digital wellbeing for too long. Now we need to see real change.

106. How to Use the Iterator Pattern in C#

According to Gang of Four, the iterator pattern provides a process to obtain the aggregator object without knowing its implementation.

107. How to Use the Builder Pattern in C#

According to Gang of Four, a creational pattern “Builder” allows to separate and reuse a specific method to build something.

108. Why You Shouldn't Use "With Statement" Syntax in JavaScript

Let’s look at the JavaScript with statement. We will go over the simple uses, as well as a deep dive into some more advanced concepts.

109. What Exactly Is A Name: Rehab [Part II]

We all agree: a good name is always the most important thing. Let’s find them.

110. Facts Everyone Needs To Know About Front-End Development Practices

Front-end development takes much more than writing clean code. While writing concise and legible code is not mandatory, it will save many headaches in the future. The chances of writing code that will never be changed or never looked at again are slim to none, and time spent getting lost in old code is time wasted. Here are some key web development best practices for HTML, CSS, and JavaScript.

111. Implementing TypeState Pattern in Python

The basic idea behind TypeState pattern is to encode the state information inside types.

112. How We Built This: A Platform for Crowdsourced Design Patterns

Built with Next, Apollo and MongoDB and deployed with GitHub Actions and Docker.

113. Introducing DILOS Principles for JavaScript Code

The SOLID principles have been created as pillars of creating flexible, understandable and maintainable code. They can add days onto your dev time to implement them properly, and most people don't care or worry much about code quality, so I created some better ones.

114. Design Patterns: Prototype Pattern in Modern C++

Prototype Design Pattern is a Creational Design Pattern that helps in the prototyping(creating/copying cheaply) of an object using separate methods or polymorphic classes. You can consider the prototype as a template of an object before the actual object is constructed. In this article of the Creational Design Patterns, we’re going to take a look at why we need a Prototype Design Pattern in C++ i.e. motivation, prototype factory & leveraging prototype design pattern to implement virtual copy constructor.

115. Understanding Chain of Responsibility Pattern in C#

According to Gang of Four, it defines a chain of responsibilities to process a request. In other words, pass the request from one object to another until an obj

116. Using the Builder Design Pattern in .NET C# to Develop a Fluent API

A step-by-step guide to developing a Fluent API from scratch in .NET C# using the Builder Design Pattern.

117. Rules of Thumb for Software Engineering

There are quite a few rules/principles that get thrown around in the software world. Some that come to mind are SOLID principles, Design Patterns, Do one thing and do it well, etc. I totally stand by all of them and believe our world would be a much better place if these principles are followed more.

118. S.O.L.I.D. Software Design Principles To Help You Become A Better Developer

S.O.L.I.D design principle comes from Object oriented programming guidelines. It is designed to develop software that can be easily maintained and extended; prevents code smells; easy to refractor; promotes agility and finally incorporates rapid + frequent changes quickly without bugs.

119. Single Responsibility Principle in C++: SOLID as a Rock

This article is the first part of a five-part series about SOLID as Rock design principle series. The SOLID design principles focus on developing software that is easy to maintainable, reusable & extendable. In this article, we will see an example of the Single Responsibility Principle in C++ along with its benefits & generic guideline.

120. Ruby Services Vs. Objects: The Battle for Decomposition and Reuse

Frustrated with unorganized business logic in your Ruby-on-Rails app? Forget what you know about object-oriented design and start using services.

121. Design Patterns: Builder Pattern in Modern C++

In software engineering, Creational Design Patterns deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic or ordinary form of object creation could result in design problems or added complexity to the design. Builder Design Pattern in C++ solves this specific problem by separating the construction of a complex object from its representation.

122. How To Remember Design Patterns

Here's a list of some of the book's design patterns, their definition, and what made me remember them. Each one of those principles solves a particular problem.

123. 7 Advanced C++ Concepts You Should Know

So I have started updating myself with Modern C++ a while ago & since my post 21 new features of Modern C++ to use in your project & All about lambda function in C++ was popular I decided to write about advanced C++ concepts & idioms which I have learned from this wikibook & course.

124. Solving Producer/Consumer Problem of Concurrent Programming in Python

In "Concurrent Programming in Python is not what you think it is", I wrote about the notorious GIL in Python and did a simple experiment on existing concurrency mechanism in Python. Today, I'll describe another common scenario in concurrent programming, the Producer/Consumer problem, with Python.

125. How to Find the Stinky Parts of Your Code (Part IV)

Are we done on code smells? Guess not.

126. Introduction to Object-Oriented Design Patterns

After hitting a certain level of experience & spending quite enough time in the industry, I have realised the importance of designing/architecting system & software. So I have started looking into system/software design & got to know nothing can better start than a Design Pattern. And the first thing I have done is googling "What is Design Pattern?" Hence got the idea of this article.

127. How to Decouple a Legacy System

An exercise improving legacy code

128. C++ Template: A Quick Review of C++11/14/17/20 Version

I know, it’s been a while since the last time I published something newbies-friendly on my blog. The main reason is that most of my readers are either experienced devs or from C background having modest C++ encounter. But while programming in C++ you need a completely different mindset as both C & C++ belongs to different programming paradigm. And I always strive to show them a better way of doing things in C++. Anyway, I found the topic which is lengthy, reasonably complex(at least it was for me), newbies-friendly as well as energizing for experienced folks(if Modern C++ jargons, rules & features added) i.e. C++ Template.