research

This is a repository for my research, paper reading summaries/reviews, and relevant blog-like posts in markdown.

CMPS 290S Reading Response: Disciplined Inconsistency with Consistency Types

Summary

Holt, et al. describe a programming model that explicitly annotates data types with consistency properties, and then describe a prototype, implemented in Scala, of their Inconsistent, Performance-bound, Approximate (IPA) type system on top of the Apache Cassandra storage system. The IPA type system supports developers by helping to explicitly balance consistency and performance within a distributed system. IPA has 3 components: (1) RDTs, or implementations of ADTs over distributed storage, (2) RDT instances are annotated with consistency policies which IPA uses for runtime analysis of consistency over RDT operations, (3) RDT operations return values that are annotated with some consistency type so the developer can explicitly handle values under various consistency levels as appropriate. Consistency policies fall into two categories: (A) static policies which specify a single consistency level for all operations to meet, (B) dynamic policies which specify performance constraints within which the system can weaken consistency requirements on RDT operations.

Learning and Understanding

This is a minor misunderstanding, but I’m of the assumption that reference to ADTs in the paper is from a “language perspective” as opposed to a “distributed systems” perspective, which is to say that ADTs are to language designers as RDTs are to distributed systems designers, and in this particular case they are interchangeable. The paper says that ADTs are abstract models with a set of operations for working on data, and my own impression is that RDTs are the same, but with consistency considered as a first class citizen.

Research Question and What to Investigate

A question that comes to mind and is relevant to my own future research: How can we incorporate tunable characteristics (e.g. latency bounds) into a cost model, such that an optimizer can dynamically compare and set properties (e.g. consistency properties) for low-level subsystems.