Speakers: Francesco Ferlin, Francesco Spangaro, Alessandro Margara
28 Gennaio 2026 | 16:00
DEIB - Sala Riunioni (Ed. 22)
Via Golgi, 42
On line by Teams
Contatti: Prof. Giovanni Quattrocchi
Sommario
On January 28th, 2026, at 4:00 pm will we have a new seminar of DEEPSE Forum series titled "AURA: Actor-based Universal Architecture".During this talk, we will have, as speakers: Francesco Ferlin, Francesco Spangaro, Alessandro Margara.
The contemporary landscape of hosting and deployment solutions is vast and highly fragmented, encompassing traditional on-premise infrastructure, sophisticated cloud offerings, and Function-as-a-Service (FaaS) models. These environments possess vastly different characteristics, notably concerning network reliability, probability of failure, and implicit concurrency models. This non-standardized variety forces developers into vendor-specific solutions, where a sub-optimal initial choice can lead to immense migration and refactoring costs. Furthermore, developers are burdened with the responsibility of designing complex mechanisms to ensure concurrency control and state consistency. This complexity is compounded by the fact that the reliance on proprietary, cloud-native components makes these systems difficult to test and debug locally. This overhead diverts developer time from solving core business problems to wrestling with platform-specific concerns. This work takes inspiration from the foundational concepts of the Histrio project and expands upon them to propose the implementation of AURA (Actor-based Universal Architecture), a modular development model and execution environment designed for true portability. AURA establishes a powerful abstraction layer over the underlying storage and communication mechanisms, enabling seamless deployment across a variety of environments. AURA's core implementation is rooted in the well-known actor model: developers construct their applications by defining and deploying specialized actors, which serve as self-contained computational units that manage encapsulated state and communicate exclusively through asynchronous message passing. The execution environment is specialized to implicitly handle all state management and concurrency guarantees, ensuring strong consistency and exactly-once-processing semantics. AURA’s modular architecture effectively isolates the application logic from environment-specific synchronization requirements. This work demonstrates that by adopting this universal, actor-based approach, it is possible to guarantee system-wide consistency and fault-tolerance, thereby eliminating vendor lock-in and allowing developers to focus exclusively on solving core business problems.