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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
