this is for holding javascript data
Brandon Holt edited abstract.md
about 9 years ago
Commit id: e8498b204e2fb9090ecf2ac8567f8754853c7e23
deletions | additions
diff --git a/abstract.md b/abstract.md
index f03cbdd..ed36c88 100644
--- a/abstract.md
+++ b/abstract.md
...
Databases that provide simple data structures for records, such as Redis and MongoDB, are now becoming popular. Building
database applications
out of using these data structures rather than simple string values
allows provides programmers with a way to communicate intent to the
database system without sacrificing flexibility
or committing to a fixed schema. Currently, this is used to ensure related values are co-located so they can be quickly accessed together, such as "dictionary" types, and
fine-grained control of typical key-value to provide complex operations which can be guaranteed to execute atomically (e.g. Set insertion). However, there are many more ways in which data types can be used to make databases
while providing better performance more efficient and
scalability. Composing transactions out simpler to use that are not yet being exploited.
A very useful property of
linearizable data structure operations
exposes concurrency is commutativity: knowing when operations can execute in
any order provides the system with more flexibility, enabling optimization opportunities. Reasoning about commutative operations can allow transactions to execute concurrently that under traditional concurrency control would conflict.
In this work, we argue that data types are the right abstraction for database records, providing a safe
way, making it simple to implement efficiently and
easy expressive programming model with ample opportunities for optimization, which will make databases more safe and scalable. We demonstrate several ways of leveraging data structure semantics in databases, focusing primarily on commutativity. Reasoning about operation reordering can allow transactions to
reason about. execute concurrently that would conflict under traditional concurrency control. Using Retwis, a Twitter clone built for Redis, as a case study, we show that using commutativity can reduce transaction abort rates for high-contention, update-heavy workloads that arise in social networks.