Percorrer por autor "RIBEIRO, NUNO DINIS GONÇALVES"
A mostrar 1 - 1 de 1
Resultados por página
Opções de ordenação
- Análise comparativa da tolerância a falhas em elixir e outras linguagens distribuídas e concorrentesPublication . RIBEIRO, NUNO DINIS GONÇALVES; Nogueira, Luís Miguel PinhoFault tolerance is a critical component of distributed systems, particularly considering the exponential growth in internet usage and system scale. The resilience and fault tolerance capabilities are essential for maintaining reliability and minimizing downtime. Elixir, with its fault-tolerant features and foundation in Erlang’s “let it crash” philosophy, stands out as a robust tool for building such systems. Nevertheless, other distributed and concurrent languages offer solutions, often leveraging similar concepts in different environments. For instance, Akka, inspired by “let it crash,” provides a toolkit built for Scala. Similarly, Go, celebrated for its built-in concurrency primitives like goroutines and channels, can integrate with the Actor Model through the Proto.Actor framework. Although all three languages are capable of implementing the Actor Model, Elixir adopts it as a first-class paradigm through its native integration with the Bogdan/Björn’s Erlang Abstract Machine (BEAM) Virtual Machine and the Open Telecom Platform (OTP) toolkit. In contrast, Akka leverages the maturity and optimizations of the Java Virtual Machine (JVM), offering a powerful abstraction over traditional concurrency models. Proto.Actor, on the other hand, introduces a language-agnostic approach to the Actor Model, built upon Protocol Buffers, which promotes interoperability. These modern tools bring significant fault-tolerant capabilities to software development. However, it is essential to understand how each compares, necessitating the execution of benchmarking. Thus, based on existing literature, the most effective methodology for benchmarking involves designing a generic application that simulates distributed and fault-tolerant operations. This approach led to a proposed test framework with a distributed, configurable architecture and test scenarios designed to yield measurable results. Empirical benchmarks revealed Elixir consistently delivers high throughput and low variance under moderate to low fault rates, though reconnection latency increases at scale due to centralized coordination bottlenecks. Scala with Akka demonstrated the most stable fault recovery and reconnection latency across all scales, well-suited for large systems with rigorous stability. Go with Proto.Actor offered competitive throughput in small-scale deployments but exhibited scalability limitations in fault detection and recovery. These findings show no single runtime dominate and each provides distinct trade-offs between throughput, fault recovery and detection. The results highlight how architecture-level decisions, such communication models, significantly impact runtime behavior under fault-prone conditions. Future work includes enhancing multi-node support, simulating more complex fault types, and exploring different actor system designs.