Best of Architecture — September 2024

1. 1
   Article

   ByteByteGo·2y

   EP128: The Ultimate Software Architect Knowledge Map

   Discover the ultimate knowledge map for software architects, exploring essential skills such as mastering programming languages, tools, design and architectural principles, platform knowledge, data analytics, networking, and supporting skills. Learn about the wide-ranging capabilities of PostgreSQL, from time-series data to federated querying and graph databases. Gain insights into advancing from a junior to a senior developer, covering collaboration tools, programming languages, API development, authentication, and system design.

   1.6K

   19
2. 2
   Article

   Community Picks·2y

   Best Practices for Naming API Endpoints

   Following best practices for naming API endpoints ensures your API is intuitive, consistent, and easy to use. Use nouns for resource names, plural names for collections, and HTTP methods to define actions. Maintain a clear hierarchical structure, use consistent naming conventions, avoid special characters and spaces, keep names simple and intuitive, include versioning, and describe actions with query parameters.

   971

   27
3. 3
   Article

   System Design Codex·2y

   Message Queues & Message Brokers

   Message queues enable asynchronous communication between producers and consumers by storing messages in FIFO order. They are useful for processing background tasks, distributing tasks, email services, buffering, and payment retries. Message brokers manage these queues and provide additional features like message routing, transformation, protocol translation, and support for the publish-subscribe pattern. This allows seamless integration and communication between different services in applications, such as in an e-commerce platform where order, inventory, shipping, and notification services interact efficiently.

   242

   4
4. 4
   Article

   Medium·2y

   Backend for Frontend (BFF) Architecture

   Backend for Frontend (BFF) architecture is a design pattern that creates a dedicated backend for each frontend interface, addressing specific performance, data, and interaction needs. This approach enhances user experiences by tailoring backends to individual client requirements, simplifies complexity, improves performance, speeds up development, and enhances security. It is particularly beneficial for multi-platform applications, microservice orchestration, and optimizing legacy APIs but also introduces challenges like increased maintenance and potential performance bottlenecks.

   229

   7
5. 5
   Article

   ITNEXT·2y

   System Design Sketches

   System design sketches for various popular applications including social networks, ride-sharing apps, messaging platforms, video streaming services, file hosting apps, and web crawlers. Each sketch outlines the functional and non-functional requirements, core entities, and API endpoints. The post also provides deep dive resources for further exploration.

   189

   5
6. 6
   Article

   System Design Codex·2y

   3 Interview Questions on Event-Driven Patterns

   System Design interviews often test candidates on event-driven patterns such as Competing Consumer, Retry Messages, and Async Request-Response. The Competing Consumer Pattern allows multiple instances to process messages concurrently. The Retry Messages Pattern manages transient errors by retrying failed transactions with mechanisms like exponential backoff. The Async Request-Response Pattern involves using correlation IDs to relate requests and responses across multiple instances, ensuring asynchronous communication between services.

   182

   1
7. 7
   Article

   Three Dots Labs·2y

   Database Transactions in Go with Layered Architecture

   This post explores handling database transactions in Go while adhering to layered architecture principles. It emphasizes the importance of keeping critical logic separate from SQL queries using patterns such as the Repository pattern, the UpdateFn pattern, and the Transaction Provider pattern. Various approaches to transaction management are discussed, highlighting their advantages and drawbacks to help maintain code clarity and integrity.

   135

   2
8. 8
   Video

   YouTube·2y

   When to Use Kafka or RabbitMQ | System Design

   Kafka and RabbitMQ serve different purposes in distributed systems. Kafka is designed for high-throughput stream processing, fanning out messages to multiple consumers, and handling uniform, short processing tasks. RabbitMQ is a traditional message queue system better suited for complex routing, long-running tasks, and handling sporadic data flow with acknowledgments for message processing. Choose Kafka for scenarios requiring high-speed, real-time data distribution and RabbitMQ for more controlled message queuing and processing.

   102

   1
9. 9
   Article

   DEV·2y

   How to implement a Distributed Lock using Redis

   Running multiple instances of an application can create issues with concurrent database writes, potentially leading to inconsistent states. Distributed locking, particularly using Redis, provides a solution by ensuring only one instance can perform critical operations at a time. The Redlock algorithm is an effective method for implementing distributed locks across multiple Redis instances, ensuring consistency even if some instances fail.

   98

   1
10. 10
    Article

    Microservices.io·2y

    Architectural patterns for modular monoliths that enable fast flow

    Explore three architectural patterns for building modular monoliths aimed at achieving fast flow: the modular monolith (domain-oriented monolith), domain module API, and domain API build module. These patterns help manage complexity, enhance team autonomy, and expedite the deployment pipeline. Attend the workshop 'Architecting for fast flow' to delve deeper into these techniques.

    97

    1
11. 11
    Article

    ByteByteGo·2y

    Millions of Requests Per Hour: SoundCloud’s Microservices Evolution

    SoundCloud evolved from a monolithic architecture to a sophisticated multi-tier microservices setup to handle millions of requests per hour. By implementing Backends-for-Frontends (BFF), Value-Added Services (VAS), and Domain Gateways, SoundCloud optimized its system for better client-specific responses, reduced operational risk, and improved development speed. BFFs provide tailored API gateways for different clients, while VAS centralize business logic to minimize code duplication. Domain Gateways further segregate business concerns, enhancing scalability and autonomy within the system.

    94

    2
12. 12
    Article

    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.

    77
13. 13
    Article

    Awesome Java Newsletter·2y

    How to implement a Distributed Lock using Redis

    Handling critical sections in distributed systems can be complex, especially when multiple instances might update the same database. Implementing distributed locking ensures that only one instance performs a critical operation at any given time. Using Redis, both single-instance and Redlock algorithms provide solutions, although they come with their own challenges, such as handling failover in master-replica setups.

    65

    1
14. 14
    Article

    DEV·2y

    Digging Deep to Find the Right Balance Between DDD, Clean and Hexagonal Architectures

    Choosing the right architecture for software can be challenging. The author shares their journey and practical experiences in balancing Clean Architecture, Domain-Driven Design (DDD), and Hexagonal Architecture in their project, TimeMates. Key highlights include ensuring the separation of concerns, maintaining a consistent mental model, and reusing value objects effectively while avoiding unnecessary boilerplate. The post emphasizes the importance of practical implementation over theoretical adherence and encourages developers to use critical thinking tailored to their specific needs.

    64
15. 15
    Article

    Community Picks·2y

    Building Microservices Architecture with CQRS Pattern Using Kafka and NestJS: A Step-by-Step Guide

    This guide explains how to build a sample blog application using microservices architecture with CQRS pattern, Kafka, and NestJS. It covers setting up the project structure, configuring Kafka with Docker Compose, and developing microservices for user authentication, blog article creation, and event sourcing for reliable communication between services.

    63

    1
16. 16
    Article

    swizec.com·2y

    Why software projects fail

    Flyvbjerg and Gardner's book 'How Big Things Get Done' explores why large projects often fail, citing themes like maximizing over satisficing, slow iteration, invention instead of reuse, scope creep, and overloading work in progress. Effective project management requires finishing work forcefully, avoiding unnecessary cleanups, opting for good-enough solutions, and embracing iterative planning.

    62

    2
17. 17
    Article

    Community Picks·2y

    Advance Your .NET and Architecture Skills

    Discover a modern approach to handle entity identification in .NET by using strongly typed IDs, which address the issue of primitive obsession with entity identifiers.

    60
18. 18
    Article

    Community Picks·2y

    Why Clean Architecture makes debugging easier

    Clean Architecture is an approach to organizing software projects that reduces unnecessary coupling and makes code more predictable and testable. This architecture divides the project into distinct layers, each with specific responsibilities, which simplifies debugging by providing consistent traces and layer-specific errors. By isolating third-party dependencies and enforcing a clear separation of concerns, Clean Architecture enhances test coverage and reduces the risk of bugs, turning debugging into a methodical process.

    56

    2
19. 19
    Article

    Telerik·2y

    Best Practices in Building ASP.NET Core API Projects

    Building an effective ASP.NET Core API project involves applying SOLID principles and leveraging design patterns to structure the backend. Key decisions include choosing between API Controller classes and minimal APIs, managing Program.cs file size, organizing services to avoid bottlenecks, and implementing proper versioning. Using facades or orchestrators can help streamline client requests across multiple services, while structuring projects by features ensures maintainability. Employing the ASP.Versioning.Http NuGet package can aid in handling versioning gracefully.

    50
20. 20
    Article

    Materialized View·2y

    Modular Monoliths Are a Good Idea, Actually

    The post argues in favor of modular monoliths as an alternative to microservices for achieving high cohesion and low coupling in software architecture. It highlights the challenges associated with scaling monoliths and migrating to microservices, such as increased complexity and the need for extensive tooling. The author suggests that modular monolithic applications, which include tooling for incremental build systems, testing, branch management, and database isolation, offer a balanced solution. This approach can extend the life of a monolith and make transitioning to a service-based architecture more manageable.

    38

    3
21. 21
    Article

    Community Picks·2y

    Event sourcing for PHP

    Event sourcing is used to model complex business requirements in PHP, providing a clear event-driven approach. The library supports scenario-based testing for ensuring business needs are met and includes built-in tools for quick event and command creation. EventSauce, created by Frank de Jonge, facilitates these processes. The website leverages Tailwind CSS, Zondicons, and Webpack.

    36

    1
22. 22
    Article

    Engineer’s Codex·2y

    The Boolean Trap

    Using booleans as function parameters can lead to confusion and maintenance issues, especially when extending functionality. Enums, even for binary states, offer better readability and extendability. They help make code more predictable, reduce errors, and are easier to update without modifying multiple instances. However, booleans can be appropriate for functions with no future extension potential.

    33

    1
23. 23
    Article

    Javarevisited·2y

    My Favorite Free System Design Interview Books

    System Design Interviews are crucial for various tech roles, requiring a deep understanding of architectural patterns and scalability. Free resources like Ashish Pratap Singh’s AlgoMaster.io System Design Interview Handbook and Alex Xu’s ByteByteGo PDFs are invaluable for preparation. These guides offer comprehensive coverage of core concepts, trade-offs, architectural patterns, and practical examples, aiding candidates to ace their interviews without spending money. Highly recommended for those gearing up for system design interviews.

    32
24. 24
    Video

    YouTube·2y

    Microservices Gone Wrong at DoorDash

    DoorDash switched from a monolith to microservices architecture to handle increased traffic during the 2020 pandemic. They faced significant issues such as cascading failures, retry storms, and death spirals. Critical countermeasures included load shedding, circuit breakers, and predictive autoscaling to improve system resilience and fault tolerance.

    30
25. 25
    Article

    Nordic APIs·2y

    Enhancing API Stability with Feature Flags

    Feature flags are used to dynamically enable or disable features in code at runtime, beneficial for backend API management beyond just frontend toggles. They offer targeted rollouts, percentage-based exposure, and fine-tuned experimentation, handling third-party dependencies and rate limiting, controlling backward-compatible and incompatible changes, and more. However, they must be used carefully to avoid technical debt, increased testing complexity, and require clear governance and timely cleanup.

    30