Let's learn about Design Patterns via these 172 free blog posts. They are ordered by HackerNoon reader engagement data. Visit the Learn Repo or LearnRepo.com to find the most read blog posts about any technology.
Design patterns are reusable solutions to common problems encountered in software design, representing best practices by experienced object-oriented software developers. They provide a common vocabulary and framework for developers, leading to more robust, maintainable, and scalable software architectures.
1. Understanding the Factory Pattern in C# — With Examples
The Factory pattern allows developers to create objects without specifying the exact class of object that will be created.
2. Microservice Architecture Patterns Part 1: Decomposition Patterns
Learn the power of microservice architecture to build modern distributed systems, by decomposing a monolith by transaction, business capability, or subdomain.
3. 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.
4. Creating Extension Methods Using Typescript
I really like C#'s extension method feature. I was trying to experiment it on Typescript with decorators.
5. 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.
6. DTO in Python: Ways of implementation
The primary goal of a DTO is to simplify communication between different layers of an application, particularly when transmitting data...
7. The Road to Hell is Paved with Good DRY Intentions
Learn how good intentions can lead to spaghetti dry code, over abstraction and over engineered systems.
8. 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.
9. GO Design Patterns: An Introduction to SOLID
Adopt SOLID design principles in GO for better code quality and easier software maintenance.
10. 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.
11. 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.
12. 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.
13. 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.
14. The Pipeline Design Pattern - Examples in C#
Explore the concept of Inversion of Control (IoC) in software engineering, understanding its benefits, and various implementations.
15. 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.
16. Understanding Feature-Sliced Design: Benefits and Real Code Examples
We explore the Feature Sliced Design pattern, a new architectural approach that promises to make software development more efficient and flexible.
17. 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.
18. 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.
19. How to use Publish-Subscribe Pattern with JavaScript
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.
20. 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.
21. 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.
22. 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.
23. The System Design Cheat Sheet: Relational Databases (Part 1)
The System Design Cheat Sheet: Relational Databases examines the basic concepts, approaches, and patterns of schema design and scaling relational databases.
24. 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
25. GO Design Patterns: An Introduction to Builder
Streamlining Your Code: An Introduction to the Builder Pattern in Go
26. 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.
27. 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.
28. A Quick Module Design Pattern Example in JavaScript
Module Design Pattern is a way to encapsulate and organize code in a self-containing module that can expose certain functionalities.
29. GRASP Principles - Part 2: Controller, Low Coupling and High Cohesion
GRASP principles. Controller, Low coupling, and High cohesion.
30. 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!
31. An Intro to Container-Presenter Design Patterns in React
32. 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.
33. 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.
34. Want to Master Javascript Design Patterns? Here's Everything You Need to Know!
Unlock the secrets of JavaScript design patterns with this comprehensive guide.
35. 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
36. 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).
37. Singleton Pattern: The Root of All Evil
Allowed global variables and supposed memory savings
38. How to Create Abstract Syntax Tree with Acorn
39. 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.
40. 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.
41. 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.
42. TableView, CollectionView Infinite Scrolling: An Easy Way in Swift
43. Why SaaS Pricing Pages Fail
A feature on the table and then locking it behind ‘upgrade to unlock’ two days later is a hostage situation.
44. Introduction to Design Patterns and Dependency Injection
A walk-through of dependency injection.
45. How the Chain of Responsibility Design Pattern Works in C#
Explore the implementation of the Chain of Responsibility pattern in C#, unraveling its hierarchical request-handling approach.
46. An Essential Guide to Observer Design Pattern in .NET C#
The Observer Design Pattern is one of the most important and commonly used design patterns.
47. Proper Navigation in SwiftUI With Coordinators: A Guide
Discover how the Coordinator pattern simplifies SwiftUI navigation. Centralize navigation logic and dependencies for cleaner, modular, and scalable code.
48. 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.
[49. 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.
50. 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.
51. Software Architecture Basics: What, How & Why
Software architecture, design and process of architecting explained using a case study.
52. Search and Extract: Why This AI Pattern Matters, Tutorial, and Example
Learn why search-and-extract matters for AI enrichment and research. Step-by-step tutorial using SERP API, Web Unlocker, and Browser API with a real example.
53. How to Decouple a Legacy System
An exercise improving legacy code
54. 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.
55. 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
56. 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.
57. 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.
58. 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.
59. Contract Testing: Practical Comparison of PACT, Spring Cloud
Contract testing checks each app in isolation to ensure contracts comply with agreements. Tools: PACT, Spring Cloud Contract
60. The Ultimate Guide To Design Patterns And Generic Composite In Python
Generic implementation of the Composite Design Pattern in Python.
61. 11 Key Design Patterns: An Essential Guide
There are 11 design patterns that can be used to create a factory for creating factories.
62. Implementing TypeState Pattern in Python
The basic idea behind TypeState pattern is to encode the state information inside types.
63. 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.
64. Find out Whether Model Observers in Laravel are a Bad Practice
Keep your Model Observers in Laravel under control.
65. Uncover the Alias Pattern
The Alias pattern minds two issues. Extending how a final class builds its objects.
66. Welcome to the OOP pattern matching: Visitor Pattern
Visitor pattern is dead. Long live to Visitor pattern. (With Kotlin examples)
67. 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.
68. 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.
69. Memento Pattern in C# - Undo & Redo
Explore the benefits and tradeoffs of implementing the Memento Pattern in C# and elevate your coding skills.
70. A Practical Guide to Dynamic Polymorphism in C Programming
Explore how dynamic polymorphism enhances code flexibility and maintainability in C programming
71. 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.
72. Memento Design Pattern Overview
73. 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.
74. Senior Web Developers Are Using These 11 Design Patterns to Write Squeaky Clean React Code
Discover 11 React Design Patterns You Need to Know to improve your code efficiency, scalability, and maintainability. Perfect for all React developers!
75. Introduction to RxJava: Observable Pattern
76. 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.
77. 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.
78. 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.
79. 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.
80. Code Smell 252 - NullCustomer
81. Understanding Event Driven Architecture
Event-driven architecture is a software architecture paradigm promoting the production, detection, consumption of, and reaction to events.
82. 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.
83. Use Database Transaction Logs to Implement Observer Pattern
The best way to implement the observer pattern - using transaction logs of databases.
84. How to Find the Stinky Parts of Your Code (Part IV)
Are we done on code smells? Guess not.
85. 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.
86. The growing pains of becoming an Intermediate developer
87. Intercept It: How to Implement Different Logic For Different Functions
In brief, the pattern injects some logical functionality before and/or after function execution.
88. 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.
89. Clean Code: Interfaces in Go - Why Small Is Beautiful [Part 3]
Master Go interfaces: why single-method interfaces rule, accept interfaces return structs, and the nil interface gotcha that crashes production. From 6 years of
90. 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.
91. 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.
92. 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.
93. 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.
94. Negating 'Side Effects' in Python: A Guide (With Pictures!)
A step-by-step guide on how to refactor side effects in your python code. Examples, pictures, and recipes on how to deal with dirty code with side effects.
95. 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.
96. 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.
97. Why SaaS Products Feel Harder to Use Every Year
Watched a product add 40 features nobody asked for. Users responded by opening text files instead. Activation: 73% → 51%. Feature count: up. Irony: also up.
98. 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..
99. 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.
100. 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.
101. When are Barrel Exports Harmful
Why we should be careful not to abuse barrel exports in our TypeScript code.
102. The Zen of Page Objects: Find Inner Peace and Clean Code
7 the best practices for Page Objects. By following these best practices, you can create a Page Object framework that is easy to maintain, reusable and much mor
103. 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.
104. 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.
105. 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.
106. 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
107. Open Closed Principle With Service Locator Pattern
108. 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.
109. How to Implement the State Design Pattern in JavaScript and Integrate It With React Hooks
How to implement state pattern in javascript, using class implementation, then integrate it with react hooks.
110. 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
111. 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.
112. Simple and Intuitive RESTful APIs
This article provides guidance on how to design simple and intuitive RESTful APIs.
113. Fluent Interface With Callbacks
114. 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.
115. 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,
116. Solar Architecture: A New Perspective on Enterprise Software Development
117. Difference Between Inheritance And Composition
With the introduction of OOPs, Inheritance and Composition entered our senses and still confusing us.
118. 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.
119. 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.
120. Chatty I/O Is Killing Your App's Performance Without You Even Realizing It
The cumulative effect of a large number of Input and Output requests has a significant negative impact on the performance and responsiveness of a service.
121. 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.
122. 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.
123. 128 Stories To Learn About Design Patterns
Learn everything you need to know about Design Patterns via these 128 free HackerNoon stories.
124. 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.
125. 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.
126. 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.
127. Open Closed Principle: SOLID as a Rock
128. 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.
129. 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
130. 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.
131. 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
132. 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.
133. 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.
134. How to Stop Making Singletons in Swift: A Dependency Injection Guide
Transition from singletons to dependency injection in a SwiftUI app with minimal effort.
135. How Experienced Software Engineers Evaluate Designs
Experienced software engineers learn what works after maintaining their work for years.
136. 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
137. 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
138. AI Coding Tools Create Debt Faster Than Teams Can Fix It
AI technical debt accumulates when AI coding tools generate code faster than teams can review it. Learn the patterns, barriers, and strategies to manage it.
139. 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
140. What Exactly Is A Name: Rehab [Part II]
We all agree: a good name is always the most important thing. Let’s find them.
141. 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.
142. Laravel Under The Hood - What Are Facades?
Laravel offers an elegant method-calling feature called Facades. They resemble static methods, but well, they are not! What kind of magic is Laravel doing?
143. How to Boost Your Dev Skills With the Ultimate Todo App: Level Up From Padawan to Jedi
Reference implementation of an application that follows Hexagonal Architecture, DDD, CQRS and uses technologies such as Mongo, Postgres, NATS, Jaeger & Grafana
144. 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.
145. Simplify Complex Subsystems With The Facade Design Pattern in C#
Learn about the Facade design pattern in C# and how it simplifies complex subsystems. Check out these 4 code examples to see how the facade pattern in C# works!
146. 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.
147. 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.
148. Implementation of the Strategy Pattern in Kotlin and Spring
The Strategy pattern is a behavioral design pattern that enables selecting an algorithm’s behavior at runtime
149. 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.
150. 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.
151. 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.
152. How to Implement the Visitor Pattern Correctly
Avoid combining the Visitor pattern with instanceof checks.
153. 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?
154. Understand the Intent of Patterns And Principles Before Applying Them
TL;DR;
155. Basic Web Design Principles to make Your Websites Pop
Five pillars of web design
156. Avoid Costly Technical Debt with the Open-Closed Principle
Discover the Open-Closed Principle in programming. Improve software resilience and manageability by adding features without changing existing code.
157. How to Implement the Command Pattern in C#
Explore the power of the Command Pattern in C# as a behavioral design technique to enhance code organization and flexibility.
158. Object Creation: The Issues I Faced and the Patterns That Helped Me
In this post, I've described two usages of the GoF's creational patterns, improving maintainability and ensuring objects are fully initialized
159. The Noonification: I Hate Nintendo (3/14/2024)
3/14/2024: Top 5 stories on the HackerNoon homepage!
160. 3 Elements of Omnichannel CX Excellence
Unlock impactful omnichannel experiences beyond retail. Discover key elements for customer retention.
161. How We Built This: A Platform for Crowdsourced Design Patterns
Built with Next, Apollo and MongoDB and deployed with GitHub Actions and Docker.
162. Laravel's Strategy Pattern: The Manager Under the Hood
Have you ever wondered how Laravel switches between different drivers' implementations? Well, hang tight, we will learn how!
163. Powerful Object Structures Using the Composite Pattern In C#
This comprehensive guide unveils the intricacies of implementing the Composite Pattern in C#, providing insights into composite, leaf, and component objects.
164. 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.
165. 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!
166. 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
167. 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?
168. Effective Healthcare Inventory Management: 5 Elements for Excellent Patient Outcomes
Optimize hospital inventory with customized software to enhance efficiency, overcome procurement challenges, and improve patient outcomes.
169. 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.
170. 5 Tried and Tested Strategies for Quick Time to Value
Learn how you can elevate your business with UX design, reducing time to value, and outperforming competitors for game-changing success.
171. 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.
172. On the Love of Problem Solving & Programming: Noonies Nominee Sukhpinder Singh
Noonies interview with Sukhpinder Singh, Senior Engineer at SourceFuse.
Thank you for checking out the 172 most read blog posts about Design Patterns on HackerNoon.
Visit the /Learn Repo to find the most read blog posts about any technology.