Sérgio Duarte

Bio: Sérgio Duarte is an academic researcher from Universidade Nova de Lisboa. The author has contributed to research in topics: Eventual consistency & Strong consistency. The author has an hindex of 14, co-authored 36 publications receiving 741 citations. Previous affiliations of Sérgio Duarte include Citigroup.

Putting consistency back into eventual consistency

Abstract: Geo-replicated storage systems are at the core of current Internet services. The designers of the replication protocols used by these systems must choose between either supporting low-latency, eventually-consistent operations, or ensuring strong consistency to ease application correctness. We propose an alternative consistency model, Explicit Consistency, that strengthens eventual consistency with a guarantee to preserve specific invariants defined by the applications. Given these application-specific invariants, a system that supports Explicit Consistency identifies which operations would be unsafe under concurrent execution, and allows programmers to select either violation-avoidance or invariant-repair techniques. We show how to achieve the former, while allowing operations to complete locally in the common case, by relying on a reservation system that moves coordination off the critical path of operation execution. The latter, in turn, allows operations to execute without restriction, and restore invariants by applying a repair operation to the database state. We present the design and evaluation of Indigo, a middleware that provides Explicit Consistency on top of a causally-consistent data store. Indigo guarantees strong application invariants while providing similar latency to an eventually-consistent system in the common case.

Putting the Consistency Back Into Eventual Consistency

Abstract: Geo-replicated storage systems are at the core of current Internet services. The designers of the replication protocols used by these systems must choose between either supporting low-latency, eventually-consistent operations, or ensuring strong consistency to ease application correctness. We propose an alternative consistency model, Explicit Consistency, that strengthens eventual consistency with a guarantee to preserve specific invariants defined by the applications. Given these application-specific invariants, a system that supports Explicit Consistency identifies which operations would be unsafe under concurrent execution, and allows programmers to select either violation-avoidance or invariant-repair techniques. We show how to achieve the former, while allowing operations to complete locally in the common case, by relying on a reservation system that moves coordination off the critical path of operation execution. The latter, in turn, allows operations to execute without restriction, and restore invariants by applying a repair operation to the database state. We present the design and evaluation of Indigo, a middleware that provides Explicit Consistency on top of a causally-consistent data store. Indigo guarantees strong application invariants while providing similar latency to an eventually-consistent system in the common case.

Write Fast, Read in the Past: Causal Consistency for Client-Side Applications

Abstract: Client-side apps (e.g., mobile or in-browser) need cloud data to be available in a local cache, for both reads and updates. For optimal user experience and developer support, the cache should be consistent and fault-tolerant. In order to scale to high numbers of unreliable and resource-poor clients, and large database, the system needs to use resources sparingly. The SwiftCloud distributed object database is the first to provide fast reads and writes via a causally-consistent client-side local cache backed by the cloud. It is thrifty in resources and scales well, thanks to consistent versioning provided by the cloud, using small and bounded metadata. It remains available during faults, switching to a different data centre when the current one is not responsive, while maintaining its consistency guarantees. This paper presents the SwiftCloud algorithms, design, and experimental evaluation. It shows that client-side apps enjoy the high performance and availability, under the same guarantees as a remote cloud data store, at a small cost.

SwiftCloud: Fault-Tolerant Geo-Replication Integrated all the Way to the Client Machine

Abstract: Client-side logic and storage are increasingly used in web and mobile applications to improve response time and availability. Current approaches tend to be ad-hoc and poorly integrated with the server-side logic. We present a principled approach to integrate client-and server-side storage. We support both mergeable and strongly consistent transactions that target either client or server replicas and provide access to causally-consistent snapshots efficiently. In the presence of infrastructure faults, a client-assisted failover solution allows client execution to resume immediately and seamlessly access consistent snapshots without waiting. We implement this approach in SwiftCloud, the first transactional system to bring geo-replication all the way to the client machine. Example applications show that our programming model is useful across a range of application areas. Our experimental evaluation shows that SwiftCloud provides better fault tolerance and at the same time can improve both latency and throughput by up to an order of magnitude, compared to classical geo-replication techniques.

Data management support for asynchronous groupware

Abstract: In asynchronous collaborative applications, users usually collaborate accessing and modifying shared information independently. We have designed and implemented a replicated object store to support such applications in distributed environments that include mobile computers. Unlike most data management systems, awareness support is integrated in the system. To improve the chance for new contributions, the system provides high data availability. The development of applications is supported by an object framework that decomposes objects in several components, each one managing a different aspect of object "execution". New data types may be created relying on pre-defined components to handle concurrent updates, awareness information, etc.

Distributed event-based systems

Abstract: This book provides an in-depth description of event-based systems, covering topics ranging from local event matching and distributed event forwarding algorithms, through a practical discussion of software engineering issues raised by the event-based style, to state-of-the-art research in event-based systems like composite event detection and security. The authors offer a comprehensive overview, and show the power of event-based architectures in modern system design, encouraging professionals to exploit this technique in next generation large-scale distributed applications like information dissemination, network monitoring, enterprise application integration, or mobile systems.

The 4th International Workshop on Body Area Sensor Networks (BASNet-2015) Stream processing of healthcare sensor data: studying user traces to identify challenges from a big data perspective

Abstract: The Internet of Things (IoT) generates massive streams of data which call for ever more effireal time processing. Designingcientand implementing a big data service for the real time processing of such data requires an extensive knowledge of both input loadand data distribution in order to provide a service which can cope with the workload. In this context, we study in this paper thechallengesinherenttotherealtimeprocessingofmassivedataflowsfromtheIoT.Weprovideadetailedanalysisoftracesgatheredfrom a well-known healthcare sport-oriented application in order to illustrate our conclusions from a big data perspective.c 2015 The Authors. Published by Elsevier B.V.Peer-review under responsibility of the Conference Program Chairs. Keywords: Internet of Things; Healthcare Sport Services ; Big Data. 1. IntroductionOne of the most important challenges in the big data era is to be able to collect and process massive and hetero-geneous data flows. In this context, the Internet of Things (IoT) ecosystem

Organizational Management in Workflow Applications – Issues and Perspectives

Abstract: Business processes automation requires the specification of process structures as well as the definition of resources involved in the execution of these processes. While the modeling of business processes and workflows is well researched, the link between the organizational elements and process activities is less well understood, and current developments in the web services choreography area completely neglect the organizational aspect of workflow applications. The purpose of this paper is to give an overview of the organizational aspects of workflow technology in the context of the workflow life cycle, to provide a review of existing work, and to develop guidelines for the design of a workflow-enabled organization, which can be used by both workflow vendors and users.

Replicated data types: specification, verification, optimality

Abstract: Geographically distributed systems often rely on replicated eventually consistent data stores to achieve availability and performance. To resolve conflicting updates at different replicas, researchers and practitioners have proposed specialized consistency protocols, called replicated data types, that implement objects such as registers, counters, sets or lists. Reasoning about replicated data types has however not been on par with comparable work on abstract data types and concurrent data types, lacking specifications, correctness proofs, and optimality results.To fill in this gap, we propose a framework for specifying replicated data types using relations over events and verifying their implementations using replication-aware simulations. We apply it to 7 existing implementations of 4 data types with nontrivial conflict-resolution strategies and optimizations (last-writer-wins register, counter, multi-value register and observed-remove set). We also present a novel technique for obtaining lower bounds on the worst-case space overhead of data type implementations and use it to prove optimality of 4 implementations. Finally, we show how to specify consistency of replicated stores with multiple objects axiomatically, in analogy to prior work on weak memory models. Overall, our work provides foundational reasoning tools to support research on replicated eventually consistent stores.