DEV·2yHow Senior Software Engineers Document Their Project
Software engineers often dislike documenting projects, but it distinguishes good engineers from bad. The Architectural Decision Record (ADR) is highlighted as an effective way to document architectural changes, providing benefits like aiding memory, improving team learning, and assisting future developers. The post outlines the importance of ADRs and provides a template and examples for implementation.
Medium·2y10 Best Resources to Learn Software Architecture in 2025
Mastering software architecture is crucial for handling complex systems and transitioning from a developer role to an architect role. Essential resources include books like 'Designing Data-Intensive Applications' and courses such as 'The Complete Microservices and Event-Driven Architecture' on Udemy. Additionally, whitepapers and engineering blogs provide valuable insights. These resources cover various architectural styles, principles, and real-world challenges, helping you design scalable, maintainable, and high-performing systems.
Tech World With Milan·2ySome important learnings from my 20 years of engineering life
Over 20 years in software engineering, the author shares critical lessons including avoiding premature optimization, questioning the necessity of new code, adhering to good practices like Clean Code and SOLID principles, keeping solutions simple, naming things properly, consistently testing code, managing time wisely, communicating effectively, learning continuously, and valuing thorough documentation. These principles are essentials that have remained relevant despite the profound evolution in the IT industry.
Microservices.io·2yThe evolution of the Microservice Architecture pattern language
The post discusses the evolution of the Microservice Architecture pattern language over the past decade, highlighting its origins and development. It introduces essential concepts like anti-patterns, the forces of dark energy and dark matter in architectural decisions, and the importance of context in determining architectural choices. Additionally, it advises on refining terminology and emphasizes that monolithic architectures remain useful in many contexts. Future improvements and ongoing adaptation in the field are also covered.
Community Picks·2yAtomic Repositories in Clean Architecture and TypeScript
Achieving atomicity in a repository pattern within a clean architecture JavaScript project is crucial for ensuring all database queries are executed or none at all, especially in complex flows like e-commerce checkouts. A process prone to errors, such as availability checks and payment issues, needs to rollback operations if a failure occurs, which can be managed using transactions. This guide demonstrates creating and managing transactions with Drizzle in a Next.js to-do application, ensuring that if any part fails, all operations are reversed to maintain database integrity.
Three Dots Labs·2yDistributed Transactions in Go: Read Before You Try
The post discusses the complexities of using distributed transactions in microservices with Go. It warns against using distributed transactions due to their complications and instead suggests alternatives like embracing eventual consistency and using the outbox pattern. The post also provides a detailed implementation approach for using event-driven architecture with Redis and Watermill in Go, including handling events asynchronously and ensuring data consistency. It emphasizes the importance of correct service boundaries and provides guidance on testing and monitoring event-driven systems.
Collections·2yUnderstanding Backends for Frontends (BFF) Pattern
Backends for Frontends (BFF) is an architectural pattern that assigns specific backends to different client types, optimizing API design for enhanced user experience. This approach improves performance, scalability, security, and simplifies frontend development by acting as a middleware layer. It uses gateways and orchestrators to manage diverse workflows and access modes, though it introduces complexity in sharing common functionalities and maintenance.
ITNEXT·2yAmbiguous architectural patterns
The post discusses ambiguous architectural patterns such as Monolith, Microkernel, Domain Services, Cells, and Nanoservices. It highlights how these terms have evolved and sometimes been misinterpreted or redefined over time, leading to confusion. It stresses the importance of understanding these differences to avoid miscommunication and inefficiency in software development.
ITNEXT·2yPipelines in architectural patterns
Unidirectional data flow is integral to several architectural patterns, including Pipes and Filters, Choreographed Event-Driven Architecture (EDA), Command Query Responsibility Segregation (CQRS), and Model-View-Controller (MVC). Each pattern relaxes or enforces certain constraints such as type, identity, and temporal order of data packets, allowing for flexible data processing and transformation in various use cases. Pipes and Filters involve strict stepwise processing, while EDA and CQRS introduce complexity and flexibility by aggregating and storing events. MVC entirely abandons type and identity constraints in favor of broader functionality.
ByteByteGo·2y1.8 Trillion Events Per Day with Kafka: How Agoda Handles it
Agoda manages 1.8 trillion daily events through Apache Kafka with strategies like 2-step logging architecture, splitting Kafka clusters by use case, developing robust auditing systems, and dynamic load balancing solutions. Their approach ensures resiliency, flexibility, and efficient resource utilization despite hardware heterogeneity and inconsistent message workloads. Key solutions include lag-aware producers and consumers that adapt based on real-time data, mitigating over-provisioning issues and ensuring balanced workloads.
Awesome Java Newsletter·2yThe Best Microservices Design Patterns Explained Like You’re Ordering Pizza
The post creatively explains various microservices design patterns using a pizza-making analogy. It covers essential patterns like Single Responsibility, API Gateway, Database per Service, Circuit Breaker, Event Sourcing, Saga, Strangler, Bulkhead, CQRS, Sidecar, and Backend for Frontend (BFF). Each pattern is described with its benefits and real-life examples to illustrate its practical application in software engineering.
System Design Codex·2yIntro to BFF Pattern
The BFF (Backends-for-Frontends) pattern involves creating dedicated API gateways for different device or interface types, such as web browsers, mobile apps, or public APIs. BFFs act as a specialized layer that tailors the API to the specific needs of the client. They offer advantages like improved resiliency, autonomy, and development speed but also come with challenges such as code duplication, complexity, and potential proliferation of BFFs. Best practices include clearly defining client requirements, minimizing code duplication, maintaining clear boundaries, and optimizing performance.
ITNEXT·2yMiddleware
Middleware acts as a low-level layer providing connectivity and communication for a system of services, improving scalability and error recovery. It's commonly used in backend systems, offering variants such as message brokers, service meshes, and enterprise service buses. Middleware enhances dynamic scaling, helps in deployments, and ensures message delivery but may introduce latency and complexity.
ThePrimeTime·2ySqlite Is Getting So Good
The post dives into a new multi-tenant architecture and issues a scalability challenge for a serverless database based on a fork of SQLite. It emphasizes the advantages of deterministic simulation testing (DST) and highlights the importance of not reinventing the wheel unless mission-critical. It also discusses the application of Rust and its borrow checker for improved safety and performance, the implementation of DST for bug detection, and the decision-making process behind choosing Rust over Zig for the rewrite project.
Atomic Spin·2yHow to Use C4 Diagrams in Systems Architecture
C4 diagrams provide a standardized approach to software architecture diagramming, focusing on different levels of abstraction: Context, Containers, Components, and Code. They enhance communication and align teams by using consistent conventions, avoiding varied interpretations often seen with generic boxes and arrows. Best practices include focusing on high-level diagrams and avoiding micromanagement with detailed Code diagrams. Tools like Mermaid and PlantUML are integrating C4 support, making them more accessible for developers.
Javarevisited·2yTHIS COULD be your Ultimate Back-end Developer Roadmap
Discusses the critical skills required to be a successful backend developer, emphasizing the importance of mastering tools and concepts such as DSA, API design, secure coding, microservices, and more. It introduces a YouTube series designed to help with backend developer interview preparation, specifically focusing on Java, but applicable to various programming languages.
codeHeim·2y#58 Golang - Asynchronous Messaging with RabbitMQ
Learn how to integrate RabbitMQ with Go for building scalable distributed systems. The post covers the basic architecture of RabbitMQ, how to set up a producer to send messages, and a consumer to receive messages using the AMQP protocol. The tutorial uses the Gin framework to set up a web server and demonstrates sending and receiving messages through HTTP requests. Additionally, it discusses handling errors and system interrupts.
ITNEXT·2yReal-world inspirations for architectural patterns
Architectural patterns in software engineering are influenced by real-world examples and natural systems. Basic metapatterns like Monolith, Shards, Layers, and Services provide foundational structures, while extension and specialized patterns such as Middleware, Shared Repository, Proxy, and others offer more intricate designs to address specific needs. Understanding these parallels can enhance creativity and flexibility in software design.
Curiosum·2yUnderstanding essential SOLID Principles in OOP: A Developer's Guide
SOLID principles, traditionally used in object-oriented programming, can be adapted to functional programming languages like Elixir to create maintainable, scalable, and adaptable software systems. The SOLID acronym stands for five key guidelines: Single Responsibility Principle, Open/Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle. The post details how each principle can be practically applied in Elixir to enhance code clarity, modularity, flexibility, and reliability while reducing complexity.
Architecture Weekly·2yFrontent Architecture, Backend Architecture or just Architecture? With Tomasz Ducin
The discussion revolves around the evolving nature of frontend architecture with Tomasz Ducin. It highlights the growing importance of frontend in user-facing applications, contrasts frontend and backend responsibilities, and emphasizes the significance of cross-functional teams. The talk covers the impact of Conway's Law and poses the question of whether the distinction between frontend and backend architecture is necessary.
Community Picks·2yAtomic Repositories in Clean Architecture and TypeScript
Implementing atomic transactions in TypeScript and Clean Architecture is crucial for maintaining data consistency in applications. Atomicity ensures that either all related operations succeed or none do, preventing partial updates that could lead to issues. By creating a TransactionManagerService and passing transactions from the controller down to the repositories, you can manage transaction scopes effectively. Savepoints can also be used to allow partial rollbacks within larger transactions.
ITNEXT·2yHexagonal Architecture
Hexagonal Architecture isolates business logic from external dependencies using two-way adapters, protecting from vendor lock-in and allowing late changes of third-party components. It supports cross-platform development and eases testing but may hinder performance optimizations and requires careful preliminary API design.
Milan Jovanović·2yImplementing Idempotent REST APIs in ASP.NET Core
Implementing idempotency in REST APIs is crucial for enhancing service reliability and consistency, ensuring identical requests yield the same result. This is particularly beneficial in distributed systems to prevent unintended duplicates and gracefully handle network issues. The post provides a comprehensive guide on how to achieve idempotency using ASP.NET Core, including utilizing unique keys, response caching, and handling concurrency issues.
Milan Jovanović·2yImplementing the Outbox Pattern
The Outbox Pattern addresses the challenge of maintaining data consistency in distributed systems by ensuring atomicity between database operations and message publication. This pattern saves messages to an Outbox table within the same database transaction and later publishes them via a separate process, ensuring at-least-once delivery. Implementation details, such as creating the Outbox table and a processing job using Quartz, are discussed along with considerations for scalability, idempotency, and database performance.