The hottest Design Patterns Substack posts right now

And their main takeaways
Category
Top Technology Topics

Publisher + Subscribers ~ Observer Pattern

System Design Classroom • 419 implied HN points • 04 May 24
🕹 Technology Design Patterns
  1. The Observer Pattern creates a one-to-many relationship. This means when one object's state changes, all of the connected objects are notified.
  2. Components can be loosely coupled, allowing them to work together without needing to know much about each other. This makes it easy to add or change observers.
  3. Because observers can be added or removed without modifying the main subject, the system stays flexible. This helps avoid complications in your design.

Additional Testing After Refactoring

Software Design: Tidy First? • 950 implied HN points • 20 Jan 25
🕹 Technology Design Patterns
  1. It's important to write more tests after refactoring. This helps improve accuracy and confidence in your code.
  2. When you break down a big piece of code into smaller parts, consider writing smaller tests for those parts, especially if you plan to reuse them.
  3. You might face a dilemma on whether to keep redundant tests after refactoring. It's good to regularly review tests to make sure you have the best approach for checking your code.

Good code is like a love letter to the next developer who will maintain it.

Elevate • 258 implied HN points • 21 Dec 23
🕹 Technology Design Patterns
  1. Good code is a form of communication and should be like a love letter to the next developer maintaining it, personal, sincere, and considerate.
  2. Design patterns and principles in code serve as a shared vocabulary for developers to create scalable, maintainable, and efficient solutions.
  3. Writing good code involves adhering to established best practices like consistent formatting, error handling, testing, and empathy towards other developers.

Inactive GUI Controls: Show, Disable, or Hide?

Jakob Nielsen on UX • 23 implied HN points • 13 Nov 25
🕹 Technology Design Patterns
  1. There are three main ways to show inactive UI buttons: keep them active but provide an error message when clicked, display them as visibly disabled, or hide them completely. Each approach has its pros and cons.
  2. Most users prefer seeing inactive buttons with a muted color instead of gray. It helps them know the option exists and gives them some context about its availability.
  3. Hiding buttons can simplify the interface, but it might frustrate users if they don’t realize a feature exists. They might feel lost or think the option doesn't exist at all.
Get a weekly roundup of the best Substack posts, by hacker news affinity:

Domain-Driven Design is about Language, not Code

🔮 Crafting Tech Teams • 59 implied HN points • 26 Apr 23
🕹 Technology Design Patterns
  1. Domain-Driven Design focuses on language over code to prevent following frameworks that may not align with DDD principles.
  2. Developers often struggle with ORM tools that extensively use terms like Repository and Entity, which can lead to DDD pitfalls.
  3. Avoid getting trapped by being mindful of the nuances and staying true to the core principles of Domain-Driven Design.

Using :has() pseudo-class to style parent elements

Perspectiv | LAB • 2 HN points • 21 Jul 24
🕹 Technology Design Patterns
  1. The :has() pseudo-class in CSS lets you style a parent element based on its child elements. This means you can change how a parent looks if it has kids that meet certain criteria.
  2. One practical use is to display error messages more clearly. You can make a parent element look different, like changing colors, when there's an error message inside it.
  3. This technique also helps with accessibility. You can use it to highlight parent elements for users who may need visual signals, based on child elements with special attributes.

Building Exceptional Code: 6 Not So Simple Steps To Make Code Simple

Weekend Developer • 19 implied HN points • 08 Jul 23
🕹 Technology Design Patterns
  1. Understand the principles like Single Responsibility, Don't Repeat Yourself, Dependency Inversion, and Separation of Concerns to write modular and reusable code.
  2. Modularize your code by breaking it into smaller, focused modules, think of them as Lego blocks. Favor composition over inheritance for flexible and loosely coupled designs.
  3. Write testable code by isolating dependencies, mocking external dependencies, keeping methods small, and following Test-Driven Development. Apply design patterns judiciously and continuously refactor to improve code quality.

UX Roundup: AI-First Design | Dark Design | Non-Deterministic UX | Jakob Live | User Research Job

Jakob Nielsen on UX • 27 implied HN points • 29 Jan 24
🕹 Technology Design Patterns
  1. AI-first products involve retrofitting AI onto existing software for productivity gains, but true advancements come from rethinking work processes and building new AI-first products.
  2. Avoid dark design patterns in UX to create ethical and user-friendly interfaces.
  3. Designing for non-deterministic UX involves adapting to AI systems that generate outcomes dynamically and focusing on ambiguity and dynamism.

Refactoring BabyAGI - Code Quality and LLMs

Laszlo’s Newsletter • 27 implied HN points • 04 May 23
🕹 Technology Design Patterns
  1. When refactoring code, it's important to move code into service classes for better organization and readability.
  2. Utilize constants and parameters closer to their use for easier handling of configurations and serialization/deserialization.
  3. Consider refactoring to address code smells like 'Feature Envy' and 'Primitive Obsession' to improve code maintainability and readability.

Harden Product Quality by Refactoring Code Smells

🔮 Crafting Tech Teams • 0 implied HN points • 25 Jul 23
🕹 Technology Design Patterns
  1. Understanding code smells can help improve product quality by enabling timely refactoring to address potential issues.
  2. Refactoring code smells involves following established methodologies that lead to better object-oriented design and the application of design patterns.
  3. Sandi Metz emphasizes the importance of continuous refactoring to maintain code quality, highlighting the value of small methods and classes.

The Hidden Secrets of Design Patterns: What No One Talks About

Weekend Developer • 0 implied HN points • 22 Jun 24
🕹 Technology Design Patterns
  1. Understanding design patterns helps in building robust and maintainable software by providing standard solutions to common problems.
  2. Challenges of design patterns include a learning curve, potential overuse, and selecting the right pattern for the context.
  3. To effectively use design patterns, invest time in understanding them, assess if they are necessary, regularly review and refactor code, seek feedback from peers, and document pattern choices.

🌊 Newsletter WomenOnRails: Back at work!

Women On Rails Newsletter - International Version • 0 implied HN points • 21 Sep 21
🕹 Technology Design Patterns
  1. The newsletter announces a second season after a summer break, featuring Ruby and Rails news, tips, and design patterns.
  2. Taking a break from tech news can be beneficial, and learning in public by working on projects and sharing knowledge is highly encouraged.
  3. An introduction to design patterns and a tool for visualizing GitHub repos are highlighted, along with an article about the impact of Lord of the Rings on big-screen battles.