Tagged articles
actor model
23 articles · Page 1 of 1
Google's Agent Substrate 1.0 separates stateful Actors from reusable Worker pools, enabling AI agents to checkpoint memory and filesystem state, release compute during idle waits, and resume in under 500 milliseconds on GKE, achieving 10x density over standard containers while preserving isolation via gVisor or microVMs.
AI agentsAgent SubstrateGKE
0 likes · 15 min read

This article analyzes Microsoft's AutoGen framework, contrasting its conversation-driven 'meeting room' architecture with LangGraph's flowchart approach, detailing v0.4's event-driven Actor model, Java integration options, ideal use cases like contract review, and trade-offs including token costs and maintenance mode status.
AI agentsAutoGenJava integration
0 likes · 17 min read

The article explains how Java records, with their built‑in immutability and auto‑generated methods, eliminate mutable state, reduce lock contention, and improve throughput in high‑concurrency architectures, providing concrete code examples and comparisons with traditional mutable beans.
ConcurrencyConcurrentHashMapJava
0 likes · 9 min read

This article examines the challenges and possibilities of adding multithreading to PHP, discussing the TrueAsync RFC, single‑threaded + offload patterns, memory‑manager redesign, object movement, shared objects, region‑based memory, and actor models to guide future PHP kernel evolution.
TrueAsyncactor modelmemory management
0 likes · 26 min read

Async programming boosts efficiency by allowing tasks to run while waiting for I/O, and this guide explores eight common implementations—callbacks, Promises, async/await, event emitters, generators, coroutines, ReactiveX, and the Actor model—detailing their advantages, drawbacks, suitable scenarios, and production‑grade best practices.
CoroutinesPromisesactor model
0 likes · 10 min read

WhatsApp achieves billions of daily messages using Erlang’s lightweight, actor‑model mailboxes instead of Kafka, delivering microsecond latency, simplicity, hardware efficiency, and reliability through a massive cluster of isolated processes.
Messaging ArchitectureScalable BackendWhatsApp
0 likes · 7 min read

Netflix’s Maestro workflow orchestrator was redesigned with a lightweight, stateful actor model and Java virtual threads, cutting engine overhead from seconds to milliseconds, delivering a hundred‑fold performance increase while preserving scalability, reliability, and strong execution guarantees for massive data and ML pipelines.
Java virtual threadsNetflix MaestroWorkflow Orchestration
0 likes · 28 min read

Explore the Go Actor model’s core concepts, compare popular Actor libraries, and follow a step‑by‑step implementation that introduces a mailbox, supervisor restart strategy, dynamic ActorPool with auto‑scaler, graceful shutdown via context, and Prometheus metrics, culminating in a complete, production‑ready concurrent framework.
Auto ScalingConcurrencyGo
0 likes · 15 min read


21CTOAug 24, 2024 · Backend Development
PayPal’s rapid growth forced it to process millions of transactions daily, leading the engineering team to expand beyond a thousand virtual machines and confront escalating network, maintenance, and resource challenges, which they solved by adopting the Akka‑based Actor model and implementing a Go‑based actor system for efficient, fault‑tolerant concurrency.
AkkaConcurrencyPayPal
0 likes · 11 min read

PayPal’s rapid growth forced a shift from simple hardware upgrades to a sophisticated, actor‑based architecture built on Akka, enabling efficient resource utilization, fault tolerance, and high‑throughput processing, ultimately allowing the company to handle billions of daily transactions using only eight virtual machines.
BackendConcurrencyPayPal
0 likes · 11 min read


21CTOJan 28, 2024 · Backend Development
This article explores how PayPal achieved the processing of billions of daily transactions using only eight virtual machines by adopting an actor‑model architecture built with Go, detailing the underlying challenges, network and resource optimizations, and providing a complete Go code example.
ConcurrencyGoPayPal
0 likes · 11 min read

The seventh Tubi‑sponsored Elixir Meetup featured three expert talks covering the migration of an Express.js/MongoDB legacy system to Elixir/PostgreSQL, building a WebRTC audio chat application with Elixir, and creating a distributed virtual‑player platform using Elixir’s powerful clustering and actor model capabilities.
ElixirSystem MigrationWebRTC
0 likes · 7 min read

This article introduces the Actor model, its fundamental rules, and how it underpins Flink and Spark RPC mechanisms, then explains the Akka framework, its actor hierarchy, supervision, lifecycle, and dispatcher, providing a concise foundation for distributed big‑data processing.
AkkaConcurrencyFlink
0 likes · 10 min read

This article explains how to read and compare the RPC implementations of Spark and Flink, covering Actor Model concepts, Akka integration, message handling, threading models, and practical code‑reading techniques while providing detailed code excerpts and architectural analysis.
FlinkRPCSpark
0 likes · 32 min read

The November 3 Scala Meetup featured senior expert Deng Caoyuan’s whiteboard brainstorming and Tencent engineer Qu Guodong’s Cats tutorial, followed by a deep dive into Akka with real‑world examples such as a financial computing platform, real‑time article recommendation, web crawling, streaming, and practical tips for Scala developers.
AkkaCatsMeetup
0 likes · 7 min read

This article explains how Apache Flink builds its RPC communication layer on top of Akka by detailing the Actor model, actor system creation, message passing patterns, key RPC interfaces such as RpcGateway and RpcEndpoint, and the internal workflow of request handling and execution.
AkkaFlinkRPC
0 likes · 20 min read

The article explains how a transaction system evolved from a monolithic application to a service‑oriented design, tackling issues such as RPC‑induced coupling, state explosion, and distributed consistency by introducing reliable event‑driven mechanisms, a core StoreEngine, and an ActorEngine framework.
actor modelevent-drivenreliability
0 likes · 8 min read

This article presents the event‑driven architecture of a hotel order transaction system, outlines common challenges such as QMQ configuration, exception handling, and coupling, and introduces an Actor‑based solution that provides decoupling, customizable retry, fault‑recovery, and detailed monitoring for over twenty business services.
actor modelevent-drivenorder management
0 likes · 6 min read

The article explains how concurrent transactions can cause deadlocks when resources are locked, and introduces the Actor model—combining data, behavior, and message passing—to give data its own active logic, thereby naturally handling concurrency and avoiding such deadlocks.
Concurrencyactor modeldeadlock
0 likes · 4 min read

This article explores the fundamentals of concurrency versus parallelism, the challenges of writing correct concurrent programs, the evolution from OS threads to green threads, Goroutine scheduling, actor‑model concepts, and modern strategies such as thread pools, async callbacks, and Rust's ownership model.
ConcurrencyParallelismactor model
0 likes · 20 min read

This article summarizes Arun Manivannan's six‑post series that uses clear analogies and simple Akka examples to explain the Actor model, its message‑passing semantics, lifecycle, hierarchical structure, fault‑tolerance mechanisms, and cross‑platform implementations for building concurrent backend systems.
Akkaactor modelbackend development
0 likes · 5 min read

The article explains how applying asynchronous programming and the actor model to browser‑client interactions—using Ajax polling, read‑write separation, and non‑blocking request patterns—can improve throughput, avoid timeouts, and enable independent optimization of read and write services in high‑concurrency web applications.
AJAXactor modelasynchronous
0 likes · 7 min read

The article explains that database read/write separation offers limited performance gains and mainly serves data safety, while true scalability for read operations comes from caching and server clusters, and that write operations require a single dedicated server and actor‑model programming for safe concurrency.
CachingRead-Write Separationactor model
0 likes · 6 min read
