Best of Design Patterns — 2024
- 1
- 2
Community Picks·2y
React Design Patterns
React design patterns are essential for frontend development as they offer solutions to recurring challenges in component design. They promote consistency, modularity, and scalability by simplifying state management, logic, and element composition. Examples include custom hooks, higher-order components, and prop-based rendering techniques. These patterns not only solve technical problems but also enhance code efficiency, readability, and maintainability. This guide provides insights into various patterns like Custom Hook, HOC, Extensible Styles, Compound Components, Render Props, Control Props, Props Getters, State Initializer, and State Reducer, along with their benefits and implementation examples.
- 3
Javarevisited·2y
Stop using if-else statements in Java
Explore how to optimize Java code by replacing if-else statements with approaches like using enums, Factory Pattern, Strategy Pattern, and the Stream API. These methods improve code readability, maintainability, and extensibility. Examples illustrate how each method transforms if-else heavy logic into more elegant solutions.
- 4
LogRocket·2y
JavaScript design patterns guide
Developers use design patterns as reusable solutions to common problems. This guide demonstrates several JavaScript design patterns, including creational (factory and builder), structural (adapter and decorator), and behavioral (chain of responsibility and strategy) patterns. Each pattern is illustrated with practical code examples to aid understanding.
- 5
- 6
S.O.L.I.D Principle Part 1
An introduction to the S.O.L.I.D principles which are fundamental for software design patterns. This part covers the Single Responsibility Principle, Open Closed Principle, and Liskov Substitution Principle, explaining how these principles enhance flexibility, maintainability, and modularity in code. Examples and practical use cases are provided to illustrate these principles.
- 7
- 8
Awesome Java Newsletter·2y
DESIGN PATTERNS : A Deep Dive into Common Design Patterns
Design patterns are reusable solutions to common design problems encountered in software development. They offer templates involving classes, interfaces, and relationships between them. Key types of design patterns include Creational, Structural, and Behavioral patterns. Each category provides specific solutions like Singleton, Builder, Factory Method, Adapter, Facade, Iterator, Strategy, and Observer patterns. Examples illustrating how these patterns can be implemented are provided to showcase their practical applications.
- 9
mehdihadeli/awesome-software-architecture: 🚀 A curated list of awesome articles, videos, and other resources to learn and practice software architecture, patterns, and principles.
A curated list of resources to learn and practice software architecture, patterns, and principles. Includes topics such as clean architecture, microservices, design patterns, and more.
- 10
- 11
- 12
DEV·2y
How I got a job at AWS
Transitioning from a mid-level developer to securing a dream job at AWS requires diligent preparation. Key steps include studying coding challenges, attending Amazon's interviewing workshop, developing stories for Amazon's Leadership Principles, learning and applying useful design patterns, understanding trees and O(n) notation, and preparing thoughtful questions for the interviewer. Taking extensive notes and practicing adaptability are crucial for success. The interview process may involve phone screening, coding tests, and several in-person interviews focused on system and software design.
- 13
Mastering Microservices in NestJS: Powerful Design Patterns for Flexibility, Resilience, and Scalability
Microservices architecture offers flexibility, resilience, and scalability for modern applications. Key design patterns like Gateway, Service Registry, Circuit Breaker, SAGA, CQRS, Bulkhead, Sidecar, API Composition, Event-Driven Architecture, Database per Service, Retry, and Configuration Externalization significantly enhance NestJS microservices. These patterns ensure better service management and inter-service communication.
- 14
How I Use Adapter Pattern in React
The post discusses the use of the Adapter pattern in React development to handle mismatched data structures between the backend API response and React components. It explains how the Adapter pattern can be applied in React and provides an example of using the pattern with `react-query`. The post emphasizes the flexibility and organization provided by the Adapter pattern and encourages readers to explore different implementations and design patterns.
- 15
Polymorphism in Javascript
Polymorphism is a fundamental concept in object-oriented programming (OOP) languages, allowing the same function to be called with different signatures and enabling flexibility and adaptability in code design. In JavaScript, polymorphism is achieved through prototype inheritance and method overloading. It enhances code flexibility, extensibility, and reuse by allowing objects to exhibit multiple forms and behaviors based on their context. Different types of polymorphism in JavaScript include ad-hoc polymorphism, parametric polymorphism, subtype polymorphism, dynamic polymorphism, and compile-time polymorphism. Polymorphism is also leveraged in functional programming and can be applied in various design patterns, such as the strategy pattern, template method pattern, and visitor pattern.
- 16
- 17
React Design Patterns
Discover how to apply design patterns in React to simplify state management, logic, and element composition. Patterns like custom hooks, higher-order components (HOCs), and prop-based rendering techniques enhance code consistency, modularity, and scalability. These patterns not only solve technical issues but also improve code efficiency, readability, and maintainability, enabling more effective collaboration in development teams and building resilient React applications.
- 18
Bits and Pieces·2y
Implementing Saga Pattern in a Microservices with Node.js
Learn how to implement the Saga Pattern in a Microservices with Node.js. Saga Pattern is a design pattern used to manage transactions and ensure data consistency across multiple services in a distributed system. There are two approaches to implementing the Saga Pattern: Choreography-Based Saga and Orchestration-Based Saga.
- 19
- 20
Just Java·2y
Java & Spring Best Practices | Strategy Pattern
The new module in the `java-spring-best-practices` repository focuses on the Strategy Pattern, detailing how to implement it in a Spring application. It emphasizes designing code that is flexible and extensible, helping developers decouple algorithm selection from the main logic. Check out the module for practical examples and contribute to the project on GitHub.
- 21
- 22
Mastering Design Patterns in Java
This post explores various design patterns in Java, including the Singleton pattern, Factory Design pattern, Builder pattern, Adapter pattern, and Decorator pattern. It explains how these patterns can be used to solve common design problems and improve code maintainability and reusability.
- 23
8 Design Patterns EVERY Developer Should Know
The post discusses eight essential design patterns every developer should know, originating from the 1994 'Gang of Four' book. These patterns are categorized into creational, structural, and behavioral types. Key patterns covered include Factory, Builder, Singleton, Observer, Iterator, Strategy, Adapter, and Facade. Each pattern is explained with practical examples, highlighting their use cases and benefits in programming.
- 24
ITNEXT·2y
Architectural Metapatterns
The document explores the concept of architectural metapatterns in software and system architecture, offering a way to classify the vast number of patterns by focusing on a small, important, and comprehensive subset. By mapping these patterns using a design space that highlights their structures and functions, it aims to create a cohesive system of metapatterns that can be more easily understood and remembered. The approach seeks to overcome the fragmentation and proliferation of patterns by providing a unified vision and methodology.
- 25
freeCodeCamp·2y
End-to-End Machine Learning Project – AI, MLOps
The post provides a comprehensive guide on undertaking an end-to-end machine learning project focused on house price prediction. It delves into core machine learning concepts, data analysis, feature engineering, and model implementation with robust testing. Additionally, it emphasizes MLOps integrations using tools like ZenML and MLFlow for experiment tracking and deployment. The tutorial also underscores the importance of writing scalable and readable code by employing design patterns such as Factory and Strategy patterns. The project aims to differentiate itself by focusing on thorough data understanding and robust implementation practices, promising to enhance one's data science portfolio and career prospects.
