#Software-Architecture
44 notas · última:
Pesquisa Viva: Distributed Systems Patterns
General patterns for building distributed systems, one pattern at a time, using krishnadaspc's Elixir series built on raw BEAM primitives as the main thread.
How to Make Technical Debt Your Friend
The article argues that technical debt can be a useful trade-off for MVPs and Minimum Viable Architecture, because it lowers the cost of learning and helps teams avoid overinvesting before the product’s value is proven.
Software Architecture and the Art of Experimentation
The article argues that architectural decisions should be treated as experiments. Minimum Viable Architectures test viability, supportability, and future change so teams can catch wrong assumptions before costs grow.
How to Create Software Architecture Diagrams Using the C4 Model
The page explains the C4 model as four zoom levels for describing software architecture and shows how Structurizr DSL and GitHub Actions can automate diagram creation and publishing.
Why external authorization is essential for modern software architecture
The page argues that external authorization separates access-control logic from application code, reducing duplication, easing updates, improving testing, auditing, and deployment across changing systems.
15 React Component Principles & Best Practices for Better Software Architecture & Design
The article lists 15 React component practices aimed at cleaner, more maintainable apps: favor function components, named components, smaller components, fewer props, hooks, custom hooks, error boundaries, and Suspense.
CQRS Pattern With MediatR
CQRS separates writes from reads so each side can be optimized independently. The text also shows how MediatR can model commands and queries with handlers and a request pipeline.
The Laws of Software Evolution
The page summarizes Lehman’s view that software keeps changing, grows more complex, and is shaped by past choices, while distinguishing S-, P-, and E-programs and outlining an idealized development lifecycle.
Death By a Thousand Microservices
The article argues that microservices often add complexity, tooling, coordination, and testing costs without matching scale needs, while monoliths and simpler service boundaries often work better.
Bringing SOLID to Elixir
The article adapts SOLID to Elixir with modules and behaviours, showing how SRP, OCP, LSP, ISP, and DIP can support maintainable, extensible, testable functional code.
The 5 Rules of Effective Component-Driven Development
The article explains component-driven development as a way to build reusable, specialized, context-agnostic, isolated, and replaceable parts that improve flexibility, maintenance, teamwork, estimates, and costs.
A Software Architect’s Guide to API-First Strategy
The article argues that API-first design makes APIs the starting point for development, improving governance, security, developer experience, scalability, and AI readiness across complex systems.
10 software essays that changed how I think
The writer says these essays changed his engineering mindset by shaping how he chooses technology, handles input, avoids rewrites, thinks about architecture, improves APIs, and frames his career.
Elixir Makes You Make Good Decisions
The author argues that Elixir, Phoenix, Ecto, and the BEAM helped screen.garden make cleaner architecture, easier authorization, faster file sync, and tests that are pleasant to write.
The Best Microservices Design Patterns Explained Like You’re Ordering Pizza
The article explains 11 microservices design patterns with a pizza analogy, showing how each one maps to service boundaries, requests, data storage, failures, workflows, legacy migration, and frontend-specific backends.
Avoiding Identity Obsession in .NET with Entity Framework Core
Peter Ritchie shows how to configure EF Core shadow properties so a database-required primary key never leaks into a Domain-Driven Design entity's own model.
Micro And Macro Software Architectures, Why You Need Both
Draws the line between macro architecture decisions a company makes once for everyone and micro architecture decisions each team makes for itself, and argues both need to be explicit.
Cross-App Communication with RPC in Elixir
How Gearflow connects two Phoenix apps over distributed Erlang RPC instead of HTTP, and the coupling trade-off they accepted to skip building an internal API.
EP130: Design a System Like YouTube
Covers eight Software Development Life Cycle models and a 9-step pipeline for a YouTube-like video system, from upload through transcoding to CDN delivery.
EP118: What are the differences among database locks?
A five-topic system design refresher: database lock types, six pagination techniques, MVC-family architecture patterns, what happens on a URL request, and QR code payments.
Did contexts kill Phoenix?
Argues that Phoenix's contexts layer, meant to enforce domain-driven boundaries, raised the barrier to entry enough to slow the framework's adoption relative to Rails.
Understanding Pure Domain Modelling
Argues that domain experts default to describing their existing system rather than the real domain, and proposes asking 'what would you do without a system?' to get past that bias.
Refactoring to Serverless: From Application to Automation
AWS engineers propose 'serverless refactoring': moving logic like event publishing out of application code and into automation code (CDK, Lambda Destinations) to separate business logic from topology.
From Microservices to Modular Monoliths
Argues that teams stuck in microservice hell should migrate back to modular monoliths, keeping modularity without distributed-system overhead.
Architecture Is a Game of Constraint Satisfaction
Gregor Hohpe argues architects keep designing around constraints (procurement lead times, hardware size, coupling costs) long after the constraint that justified them has quietly disappeared.
The Publish Pattern
A concurrency pattern for decoupling producers and consumers using a const shared_ptr, avoiding mutex bottlenecks while keeping the consumer always on the latest published version.
Four Layer Architecture
A pattern from the c2 wiki splits client-server apps into View, ApplicationModel, DomainModel and Infrastructure, extending MVC to cover persistence and the outside world.
33/60 Days System Design Questions
A daily.dev system design prompt: an order service that only stores current state can't reconstruct a billing dispute, and the post argues event sourcing is the real fix, not a patch.
How Domain-Driven Design Changed My Approach to AI agent architecture
The author says Domain-Driven Design changed how he sees software design, helping him isolate the core domain of an AI coding platform and model agents through events instead of direct calls.
Ports and Adapters (Hexagonal Architecture), Explained with Two Real Codebases
Explains how ports, adapters, and a registry keep business logic independent from vendors, making payment, email, and frontend API changes cheaper and easier to migrate.
6 Must-Read Books for Backend Developers in 2026
The page recommends six books for backend developers to learn architecture, design patterns, distributed systems, microservices, and data engineering, with a focus on practical, scalable system design.
Just Enough Distribution (JED) on Monoliths and Microservices
The post rejects extreme claims about monoliths and microservices, saying the right architecture depends on context, constraints, team expertise, cost, reliability, and time to market, with a middle-ground approach preferred.
What I learned from Software Architecture: The Hard Parts
The post highlights the book’s focus on tradeoff analysis, modularity drivers, and two ways to break a monolith into microservices, while noting the lack of implementation detail and the abstract, fictional structure.
Resources for F# Onboarding
Curated links for learning F#, covering official docs, functional programming, code architecture, testing, performance, and people to follow on Twitter.
Why You Should Care About Software Architecture
The article argues that software architecture still matters in agile work because products need explicit attention to quality attributes, sustainability, and architectural decisions that otherwise emerge implicitly and decay over time.
Package by component and architecturally-aligned testing
Simon Brown proposes package by component as a hybrid between layer and feature, with public component interfaces, package-protected internals, and tests aligned to architectural boundaries.
DDD, Hexagonal, Onion, Clean, CQRS, … How I put it all together
Herberto Graca explains how he combines Ports & Adapters, Onion, DDD layers, and CQRS into an explicit architecture with inward dependencies, ports, adapters, components, and buses.
DDD, Hexagonal, Onion, Clean, CQRS, … How I put it all together
The post groups Ports & Adapters, Onion, DDD layers, and CQRS into an explicit architecture centered on the application core, with inward-pointing dependencies and decoupled components.
Creating Truly Modular Code with No Dependencies
The article argues that rising software complexity comes from dependencies between components, and proposes an element architecture that isolates logic through interfaces and listeners.
How to build stable systems
The guide argues that stable systems stay under developer control, ship in small reversible steps, and favor limited scope, reproducible builds, strong testing, and operational safety.