Abstract
The constant evolution of access technologies are turning Internet access more ubiquitous, faster, better and cheaper. In connection with the proliferation of Internet access, Cloud Computing is changing the way users look at data, moving from local applications and installations to remote services, accessible from any device. This new paradigm presents numerous opportunities that even traditional businesses like telecoms cannot ignore, in particular, enabling new and more cost effective solutions to old problems. The work presented in this paper provides a detailed description of how a telecom application can be migrated to a NoSQL database. Particularly, by pointing out the necessary change of how we reason about data as well as the data structures that support it, in order to take full advantage of Cloud Computing. In addition, we also present a preliminary evaluation of different data persistency paradigms based on a fully tunable simulation platform that mimics the operation of a telecom business.

Abstract
In this paper we describe a transaction management system designed to face the inherent characteristics of mobile environments. Mobile clients cache subsets of the database state and allow disconnected users to perform transactions independently. Transactions are specified as mobile transactional programs that are propagated and executed in the server, thus allowing the validation of transactions based on application-specific semantics. In the proposed model (as in others previously presented in literature) the final result of a transaction is only determined when the transaction is processed in the central server. Users may be notified of the results of their transactions using system support (even when they are no longer using the same application or even the same computer). Additionally, the system implements a reservation mechanism in order to guarantee the results of transactions performed in disconnected computers. © Springer-Verlag Berlin Heidelberg 2000.

Abstract
Shared-nothing clusters are a well known and cost-effective approach to database server scalability, in particular, with highly intensive read-only workloads typical of many 3-tier web-based applications. The common reliance oil a centralized component and a simplistic propagation strategy employed by mainstream solutions however conduct to poor scalability with traditional on-line transaction processing (OLTP), where the Update ratio is high. Such approaches also pose in additional obstacle to high availability while introducing a single point Of failure. More recently, database replication protocols based on group communication have been shown to overcome such limitations, expanding the applicability of shared-nothing Clusters to more demanding transactional workloads. These take simultaneous advantage of total order multicast and transactional semantics to improve oil mainstream solutions. However, none has already been widely deployed in a general purpose database management system. In this paper, we argue that it major hurdle for their acceptance is that these proposals have disappointing performance with specific subsets of real-world workloads. Such limitations are deep-rooted and working around them requires in-depth understanding of protocols and changes to applications. We address this issue with a novel protocol that combines multiple transaction execution mechanisms and replication techniques and then show how it avoids the identified pitfalls. Experimental results are obtained with it workload based oil the industry standard TPC-C benchmark.

Abstract
View Synchrony (VS) is a powerful abstraction in the design and implementation of dependable distributed systems. By ensuring that processes deliver the same set of messages in each view, it allows them to maintain consistency across membership changes. However, experience indicates that it is hard to combine strong reliability guarantees as offered by VS with stable high performance. In this paper we propose a novel abstraction, Semantic View Synchrony (SVS), that exploits the application's semantics to cope with high throughput applications. This is achieved by allowing some messages to be dropped while still preserving consistency when new views are installed. Thus, SVS inherits the elegance of view synchronous communication. The paper describes how SVS can be implemented and illustrates its usefulness in the context of distributed multi-player games.

Abstract
Fault-tolerant control systems can be built by replicating critical components. However, replication raises the issue of inconsistency. Multiple protocols for ensuring consistency have been described in the literature. PADRE (Protocol for Asymmetric Duplex Redundancy) is such a protocol, and an interesting case study of a complex and sensitive problem: the management of replicated traffic controllers in a railway system [5]. However, the low level at which the protocol lots been developed embodies system details, namely timeliness assumptions, that make it difficult to understand and may narrow its applicability. We argue that, when designing a protocol, it is preferable to consider first a general solution that does not include any timeliness assumptions; then, by taking into account additional hypothesis, one can easily design a time-based solution tailored to a specific environment. This paper illustrates the benefit of a top-down protocol design approach, and shows that PADRE can be seen as an instance of a standard Primary-backup replication protocol based on View Synchronous Communication (VSC).

Abstract
In this paper we propose the mutable consensus protocol, a pragmatic and theoretically appealing approach to enhance the performance of distributed consensus. First, an apparently inefficient protocol is developed using the simple stubborn channel abstraction for unreliable message passing. Then, performance is improved by introducing judiciously chosen finite delays in the implementation of channels. Although this does not compromise correctness, which rests on an asynchronous system model, it makes it likely that the transmission of some messages is avoided and thus the message exchange pattern at the network level changes noticeably. By choosing different delays in the underlying stubborn channels, the mutable consensus protocol can actually be made to resemble several different protocols. Besides presenting the mutable consensus protocol and four different mutations, we evaluate in detail the particularly interesting permutation gossip mutation, which allows the protocol to scale gracefully to a large number of processes by balancing the number of messages to be handled by each process with the number of communication steps required to decide. The evaluation is performed using a realistic simulation model which accurately reproduces resource consumption in real systems.