The Secret Language Scaling WhatsApp and Discord

What makes Erlang suitable for real-time apps?

Erlang, developed by Ericsson in the 1980s, was initially designed for telecommunication systems. Its focus on concurrency, fault tolerance, and message passing makes it ideal for real-time applications.

Key Features of Erlang:

• Concurrency: Erlang processes are lightweight and allow for millions of them to run concurrently without significant performance degradation.
• Fault Tolerance: The "Let It Crash" philosophy means that individual process failures don't bring down the entire system. Supervisors can restart failed processes automatically.
• Message Passing: Processes communicate efficiently via message passing, which reduces complexity and increases fault tolerance.

Why This Matters for Real-Time Apps:

• Continuous Operation: Erlang's robust design ensures applications run smoothly, even under heavy load.
• High Availability: Its fault tolerance and lightweight process model make it reliable.
• Scalability: Erlang can easily distribute workloads across multiple nodes, making it ideal for apps needing to scale rapidly.

These features collectively make Erlang a powerful choice for building reliable, scalable, and maintainable real-time applications, such as those used by WhatsApp and Discord.

How does Erlang achieve fault tolerance?

Erlang's fault tolerance stems from its "Let It Crash" philosophy and the supervisor-worker model. These principles make real-time applications, like WhatsApp and Discord, much more robust.

"Let It Crash" Philosophy

• Design Principle: Unlike traditional languages where developers try to handle every possible error, Erlang encourages letting processes fail.
• Error Isolation: Failures are isolated to individual processes, preventing a single error from bringing down the whole system.
• Automatic Recovery: Supervisors monitor processes and automatically restart them when they crash.

Supervisor-Worker Model

• Supervision Trees: Erlang uses a hierarchical system where supervisors oversee worker processes.
• Restart Strategies: Supervisors can restart a single worker, all workers, or escalate the failure if necessary.
• Scalability: This model scales efficiently, ensuring minimal downtime and high system reliability.

Benefits for Real-Time Apps

• Continuous Operation: Applications remain operational even when individual processes fail.
• Improved Stability: Automatic recovery ensures quick resolution of errors.
• Minimal Downtime: The system’s ability to handle faults autonomously contributes to its robustness.

These features collectively ensure that applications built with Erlang can handle large user bases and maintain high reliability, making it an excellent choice for real-time messaging apps.

What are the scalability advantages of Erlang?

Erlang excels in handling massive concurrency and efficiently distributing workloads across multiple nodes. This capability makes scaling easier compared to other languages.

Key Highlights:

• Massive Concurrency: Erlang processes are lightweight, allowing millions to run concurrently with minimal performance degradation. This is essential for real-time applications.

• Seamless Distribution: The system can distribute processes efficiently across multiple nodes. This ensures workloads are balanced and no single node becomes a bottleneck.

• Simple Communication: Communication between distributed nodes is straightforward. A function call can run on a different machine as easily as on the same one.

Real-World Application:

• WhatsApp scaled to billions of daily users with a lean team. Erlang's scalability and efficiency played a key role in this.

• Discord handles thousands of users chatting simultaneously by leveraging Erlang and Elixir. The ability to distribute work and manage concurrency with ease allows them to maintain high performance and reliability.

Erlang's design inherently simplifies scaling, making it ideal for real-time apps like WhatsApp and Discord.

How does Erlang handle real-time responsiveness?

Erlang's preemptive scheduler ensures efficient management of multiple processes, making it highly suitable for real-time applications.

Key Features:

• Preemptive Scheduling: The scheduler allocates small execution windows (e.g., 500 function calls) to each process. If a process exceeds its time slice, it is paused and another process takes over.
• Non-blocking I/O: I/O operations are handled by separate threads or kernel pool services, preventing any single process from blocking others.
• Event Loop Comparison: Similar to JavaScript's event loop, Erlang pauses long-running processes to ensure responsiveness. However, Erlang's scheduler operates across multiple nodes, providing greater scalability.

Why This Matters:

• Continuous Responsiveness: Processes are managed efficiently, meaning no single task can monopolize system resources.
• Seamless I/O Handling: Non-blocking I/O ensures smooth operation even during heavy I/O tasks.
• Enhanced Scalability: Distributing processes across multiple nodes keeps the system responsive, similar to but more scalable than JavaScript’s event loop.

By efficiently handling processes, Erlang ensures that real-time applications remain responsive and reliable, making it ideal for services like WhatsApp and Discord.

What is hot code swapping in Erlang?

Hot code swapping is a powerful feature in Erlang that allows updating running systems without any downtime. This capability is crucial for real-time applications where continuous operation is essential.

Key Benefits

• Seamless Updates: Deploy new code without stopping the application. This ensures users experience zero interruptions.
• Efficient Bug Fixes: Quickly address issues in production without requiring restarts.
• Continuous Feature Rollout: Introduce new features on the fly, maintaining uninterrupted service.

Real-World Applications

• WhatsApp: Continuously updates its messaging platform to improve features and fix issues without disrupting service.
• Discord: Uses hot code swapping to maintain high uptime and quickly deploy changes to its chat system.

By enabling real-time updates, hot code swapping keeps applications like WhatsApp and Discord running smoothly, ensuring a seamless user experience.

How did WhatsApp leverage Erlang for scalability?

WhatsApp leveraged Erlang to handle billions of daily active users with minimal downtime. Its efficient infrastructure allowed the app to scale seamlessly while keeping costs low.

Key Highlights:

• Lean Engineering Team: WhatsApp managed 450 million active users with just about 32 engineers.

• Efficiency: Only 6 engineers worked on infrastructure, showcasing Erlang's ability to maintain high performance with a small team.

• Cost-Effectiveness: Erlang's robust features minimized hardware and engineering costs.

Core Benefits:

• Massive Concurrency: Erlang can handle millions of concurrent processes without performance degradation.

• Fault Tolerance: The "Let It Crash" philosophy ensures the system remains stable, quickly recovering from process failures.

• Seamless Distribution: Workloads are easily distributed across nodes, preventing bottlenecks and ensuring reliable performance.

Real-World Impact:

• WhatsApp maintained high reliability and performance even as its user base grew exponentially.
• The lean team and efficient infrastructure allowed the app to scale cost-effectively.

By leveraging Erlang, WhatsApp achieved exceptional scalability and reliability, proving it to be a powerful solution for real-time applications.

How does Discord use Erlang and Elixir?

Discord, a popular real-time chat application, adopted Elixir for its real-time chat systems due to its remarkable concurrency and fault tolerance features.

Key Adoption Reasons:

• Concurrency and Fault Tolerance: Elixir's design, built on top of the Erlang VM, provides exceptional concurrency and fault tolerance. This ensures that Discord can handle thousands of users chatting simultaneously without performance degradation.

However, for certain performance-critical parts, Discord integrated Rust. Rust was used to build their new member list system, capable of rapidly updating the status of millions of concurrent users.

Benefits:

• High Performance: By using Rust for performance-critical components, Discord achieves rapid updates and processing speeds.
• Scalable Infrastructure: Elixir’s ability to efficiently manage massive concurrency and distribute workloads allows the platform to maintain high performance and reliability.
• Fault Tolerance: The Erlang VM's "Let It Crash" philosophy ensures that even if individual processes fail, the system remains operational.

By leveraging both Elixir for its real-time chat and Rust for specific high-performance needs, Discord successfully balances scalability, performance, and reliability.

What are the key features of Elixir and Phoenix for real-time apps?

Elixir and Phoenix bring a wealth of features that make them exceptionally suited for real-time applications. These tools simplify development and enhance performance and reliability.

Key Features:

• Phoenix Channels: Built on top of WebSockets, Phoenix Channels provide a straightforward API for real-time communication. They are ideal for chat apps, live notifications, and other instant features.

• ETS (Erlang Term Storage): A built-in, fast key-value store. It eliminates the need for third-party caching solutions like Redis, making it efficient for temporary data storage.

• Ecto: This tool is used for database operations. It integrates seamlessly with PostgreSQL and other databases, providing a smooth developer experience.

• Oban: A robust background job processing tool. It ensures tasks are managed efficiently, from sending emails to processing complex data in the background.

• ElectricSQL: Supports local-first queries. This enhances user experience by allowing offline operations and syncs seamlessly when online.

These features collectively enhance the performance and reliability of real-time applications, making Elixir and Phoenix a compelling choice for developers aiming to build scalable and efficient systems.