#Distributed-Systems
42 notas · última:
Building Distributed Systems in Elixir: Part 8 — Publish / Subscribe
The article builds a Pub/Sub broker in Elixir with raw processes, showing how topics, fan-out, subscriptions, and Process.monitor/1 avoid tight coupling and clean up dead subscribers.
Building Distributed Systems in Elixir: Part 6 — Named Processes
The article shows how named processes give a worker a stable, discoverable address with local registration or `:global`, while supervisors still handle restarts and replacement PIDs.
Building Distributed Systems in Elixir: Part 5 — Supervisor From Scratch
The article builds a manual one-for-one supervisor in Elixir using links, trapped exits, and message passing to restart only a crashed worker while leaving a healthy sibling running.
Building Distributed Systems in Elixir: Part 3 — Process Monitoring
Shows how BEAM process monitoring uses Process.monitor/1 to receive :DOWN messages when a worker stops or crashes, without polling, GenServer, or Supervisor.
Building Distributed Systems with Elixir — 02: Correlated Request–Reply
The article shows how to pair each asynchronous request with a unique reference so a client can match the right reply, even when one process makes several requests.
S3 Is the Future, S3 Is the Past
The text argues that S3-shaped cloud architecture is widespread because of durability, scale, and low cost, but its disk-era latency and write model are increasingly mismatched with SSDs and modern networks.
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.
Jonas Bonér on the Actor Model, Akka, Reactive Programming, Microservices and Distributed Systems
Jonas Bonér presents Akka as a JVM toolkit for distributed systems, links the Actor Model to message passing and fault handling, and frames microservices as full systems built for resilience.
Notes on Distributed Systems for Young Bloods
A set of practical lessons for new distributed systems engineers, emphasizing failure, coordination costs, backpressure, metrics, percentiles, capacity, feature flags, and service extraction.
Out-of-the-box Elixir telemetry with Phoenix
The article explains Phoenix’s built-in telemetry, how metrics are defined in telemetry.ex, how events feed multiple metrics, and how clustered Elixir lets the dashboard attach to other nodes.
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.
Overengineered #001: Hello World
The post rebuilds Hello World as a distributed Elixir app: UDP broadcast finds nodes on startup, and node monitoring triggers greetings when peers join the cluster.
Distributed PubSub in Elixir
The article builds a local PubSub with Registry, then extends it to a clustered setup with pg and libcluster so each node relays messages to local subscribers.
Must-Known Resiliency Patterns for Distributed Systems
The note groups resiliency patterns for distributed systems into downstream and upstream approaches, showing how timeouts, retries, load shedding, rate limiting, bulkheading, and health checks reduce cascading failure and overload.
8 Must-Know Strategies to Build Scalable Systems
The page lists eight ways to make systems scale under higher load: stateless services, horizontal scaling, load balancing, auto-scaling, caching, database replication, sharding, and asynchronous processing.
8 Must-Know Distributed System Design Patterns
The page lists common distributed system patterns and what each one addresses: offloading cross-cutting tasks, handling failures, separating reads and writes, partitioning data, coordinating services, and replaying state changes.
15 Must-Know Elements of System Design
The post groups core system design elements into distributed systems, messaging, caching, scaling, networking, storage, and observability, and explains what each one does in a distributed setup.
GitHub - karanpratapsingh/system-design: Learn how to design systems at scale and prepare for system design interviews
Course outline on system design covering networking, storage, databases, distributed systems, APIs, messaging, security, and interview patterns, plus worked designs for URL shortener, WhatsApp, Twitter, Netflix, and Uber.
Mastering the Senior C# Engineer Interview
A page with 30 senior-level C# interview questions and answers for financial systems, covering retries, deadlocks, concurrency, security, distributed systems, logging, and scaling.
Why I still self host my servers (and what I've recently learned)
The author explains why self-hosting still remains worthwhile: independence, practical learning, and a better understanding of complex systems, despite the work and recent failures.
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.
Notes on "Engineering Principles for Building Financial Systems"
A one-cent summation error across ten million transactions becomes a $100k discrepancy, and the same drift pattern shows up in any system that keeps a running counter.
Rick Reed, Software Engineer at WhatsApp
Rick Reed's 2012 Erlang Factory speaker profile: his path through SGI, Metaphor and Yahoo to WhatsApp, and a talk on tuning Erlang's BEAM and FreeBSD to scale to millions of connections.
Heartbeats in Distributed Systems
Explains how heartbeat messages help distributed systems detect alive, failed, or slow nodes, and compares push, pull, gossip, and quorum-based approaches.
Things I Wished More Developers Knew About Databases
The article lists database pitfalls developers often miss, from networking and ACID tradeoffs to isolation anomalies, clock skew, latency, migrations, sharding, and scaling surprises.
Review — Is Designing Data-intensive Applications by Martin Kleppman Worth it?
The review argues that Martin Kleppmann’s book is a worthwhile, broad guide to data-intensive application design, with strong coverage of databases, distributed systems, reliability, scalability, and trade-offs.
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.
10 Reasons to Learn System Design in 2025
The article argues that system design matters for interviews, scalability, distributed systems, leadership, optimization, and real-world software work, and it points to books, courses, and platforms for learning.
Retries Have an Evil Twin: Duplicates
The post explains why at-least-once delivery leads to duplicate work and compares four application-level ways to stop it: database constraints, in-memory dedup, Redis, and broker support.
System Design — Tips
A practical list of system design choices for scalability, availability, latency, and reliability, with examples showing when to use caches, queues, sharding, replication, and other patterns.
Hard Things in Computer Science
The post argues that computer science has many hard problems beyond cache invalidation and naming things, including timezones, estimates, distributed systems, and proving code is bug-free.
Building robust distributed systems
The article argues that resilient distributed systems reduce inter-component coupling, isolate errors with SLAs and fallbacks, and add buffers such as asynchronous communication and extra capacity.
Elixir: How to distribute Mnesia between multiple nodes
The article shows how WTTJ uses Mnesiac and Libcluster to sync Mnesia stores across nodes, avoid duplicate background work during blue-green deploys, and keep data available across instances.
Elixir: How to distribute Mnesia between multiple nodes
The article explains how WTTJ used Mnesiac and Libcluster to sync Mnesia stores across nodes, avoid duplicate background work during blue/green deploys, and keep state available in Elixir services.
Planetary Scale Rust and Golang by embedding WebAssembly in Elixir
The post describes Assemblex, a toy Elixir platform for deploying and running WebAssembly binaries across nodes, with hot reloads, supervision, and benchmarked execution overhead.
Reactive programming vs. Reactive systems
The article distinguishes reactive programming from reactive systems: the first improves local asynchronous dataflow, while the second is an architectural style for resilient, elastic, message-driven distributed systems.
Tracing and observing your remote node
The post explains how to trace and observe a remote Elixir node through EPMD, SSH port forwarding, node naming, cookies, and tools like Erlyberly and Observer.
Elixir in times of microservices
The post argues that Elixir and the Erlang VM already provide the abstractions, process isolation, and communication model needed to manage distributed systems and grow applications without premature microservice splits.
Introduction to Distributed Messaging with Elixir
The article shows how Elixir’s Erlang heritage lets nodes connect, make remote calls, and exchange messages across machines while handling latency and failure in distributed systems.
Why Microservices Matter
Heroku argues that microservices help large teams scale by splitting applications into smaller services, but they also add operational overhead, testing complexity, and integration costs.