The serverless paradigm has gained significant traction for cloud applications, offering scalability while offloading infrastructure management and resource provisioning to providers. However, its adoption introduces a shift in programming model, adding complexity to software development. In Function-as-a-Service (FaaS), functions are stateless, requiring developers to manage external storage, concurrency control, and failure handling diverting focus from business logic. This paper presents Histrio, a programming model and execution environment that realizes the actor model on top of a standard serverless stack, comprising a FaaS platform to execute actors, a managed database to persist actors state, and a queuing service to notify message delivery. Crucially, these underlying technologies are entirely abstracted away, providing developers with a pure actor-based programming interface that is agnostic to the implementation details. By adopting the actor model, Histrio encapsulates state within actors and enforces isolation by construction, while providing exactly-once execution semantics even in the presence of failures. It further enriches the actor model with query-like features that optimize common state access patterns. The result is a system that combines the convenience of the actor model with the benefits of serverless deployments, enabling stateful applications with strong isolation and fault tolerance guarantees.

Graph data structures model relations between entities in various domains. Graph processing systems enable scalable distributed computations over large graphs, but are limited to static scenarios in which the structure of the graph does not change. However, many applications are dynamic in nature, and this reflects to graphs that continuously evolve over time. In these contexts, understanding the evolution of graphs is key to enable timely reactions when necessary. We address this problem by proposing a new model to express temporal patterns over graph data structures. The model seamlessly integrates computations over graphs to extract relevant values, and temporal operators that define patterns of interest in the evolution of the graph. We present the syntax and semantics of our model and discuss its concrete implementation in FlowGraph, a middleware for temporal pattern recognition in large scale graphs. FlowGraph presents a level of performance that is comparable to state-of-the-art graph processing tools when processing static graphs. In the presence of temporal patterns, it can further optimize processing by avoiding complex graph computations until strictly necessary for pattern evaluation.

Distributed data processing platforms aim to provide a balance between ease of use and performance. The question is: do they succeed? Systems like Apache Spark or Apache Flink offer a high-level programming model that results in simple and concise definition of the processing tasks, abstracting away most of the concerns associated to concurrency and distribution but at the cost of a large performance gap with custom programs that use low-level primitives to control distribution and resource usage. May we fill this gap? May alternative design choices yield better performance without sacrificing simplicity?This paper answers the above questions by introducing RStream, a novel data processing platform written in Rust. RStream provides a high-level programming model similar to that of mainstream data processing systems, which supports batch and stream processing, data transformations, grouping, aggregation, iterative computations, and time-based analytics, incurring in a much lower overhead, closer to that of custom, low-level code. In numerical terms, our evaluation shows that RStream programs present nearly identical complexity as similar programs written in Flink, delivering from 2× to 20× the throughput of Flink, rivaling custom MPI implementations.