August 2017 Summaries

Dolphin is a helpful AI assistant that can provide an objective summary of text delimited by triple backticks. The key points in this text are about the use of Domain Specific Languages (DSLs) with Gremlin, a graph traversal language. DSLs allow users to express their queries in language more familiar to them, reducing the need for understanding the schema and logic of the graph. TinkerPop 3.x provides a new method for building DSLs using inheritance. The GremlinDsl annotation can help streamline the process of DSL building in Java by generating boilerplate code at compilation. The text also discusses the benefits of Gremlin DSLs and their development patterns with TinkerPop 3.x, as well as how to drop back into the graph language if desired while using a DSL.

This article presents graphs as a universal data structure and Gremlin as a universal virtual machine for the burgeoning multi-model approach to Big Data computing. The Gremlin traversal machine is a graph-based virtual machine whose instruction set is a collection of functions called steps. A program, called a traversal, is a linear/nested composition of said steps. The fact that any database query language can compile to Gremlin bytecode and that Gremlin's memory system is a property graph composed of vertices, edges, and properties means that these database query languages are querying their respective data structure embedded within the graph. This post will present MongoDB-Gremlin which maps JSON documents to directed acyclic trees within any Apache TinkerPop™-enabled graph database and enables the user to query such graph-encoded documents using MongoDB's JSON-based CRUD language.

In this series, the author discusses the relationship between data modeling and architecture, emphasizing that neither should dominate the other. They argue for an iterative approach where data models and architecture are developed together. The author provides an example of how to apply Domain Driven Design (DDD) principles in identifying bounded contexts and refining physical data models. They also demonstrate how these steps can lead to a notional microservice architecture for a hotel application.

The text discusses polyglot persistence and multi-model databases in the context of cloud-based applications. It begins by describing the traditional monolithic architecture approach, where a single relational database was used to store all data for an application. This approach has been replaced by new architectures that leverage multiple different models such as document, key-value, column oriented, and graph databases. The polyglot persistence approach involves selecting the most appropriate data store according to the needs of each service in a microservice architecture. Multi-model databases support more than one abstraction, allowing for the use of multiple types of data stores within a single database engine. Both approaches have their advantages and disadvantages, with polyglot persistence offering flexibility but requiring additional development and operational costs, while multi-model databases can simplify operations but may not offer the same level of performance or functionality as specialized databases. The text concludes by suggesting that the most appropriate approach for large scale cloud applications depends on the specific needs of the application and should be carefully considered.

This blog series discusses remodeling a data model, which is making changes to an existing data model, particularly when it's already deployed in a system. The author presents various scenarios that may arise during the remodeling process, such as deleting attributes or tables no longer relevant, adding new ones, and handling new queries. They also explore different techniques for managing these changes, including using materialized views, indexes, and third-party integrations like Stratio's Lucene index implementation and DataStax Enterprise Search (DSE Search). The author emphasizes the importance of testing these features under load and considering a hybrid approach when dealing with complex search and analysis logic.

This blog series discusses how to design data models that can handle success and scale effectively. It emphasizes the importance of good data modeling choices as they significantly impact overall application performance, especially at large scales. The author provides tips on estimating partition size and storage size, testing data models using cassandra-stress tool, and load testing application code to ensure optimal performance. They also highlight common anti-patterns in Cassandra data modeling that can lead to scalability issues.

This series of articles discusses data modeling for Apache Cassandra, focusing on real-world examples and tradeoffs. The author addresses several questions about hotel data models presented in a book, including how to manage hotel IDs and ensure uniqueness of points-of-interest (POIs) across the cluster. Key points highlighted throughout the series include the importance of deliberate practice for becoming an expert in data modeling and seeking feedback from others on data models. The author encourages continued learning and practice in data modeling, as well as sharing knowledge with others through platforms like mailing lists and social media.

The text discusses the challenges of ensuring unique identity in Cassandra data models, particularly when integrating with other systems that may have their own ways of identifying data elements. It highlights the tension between human-readable identifiers and architectural demands for uniqueness, and presents multiple options such as composite keys, natural keys, and surrogate keys like UUIDs. The text also recommends using UUIDs as surrogate keys for points of interest, hotels, and amenities in a hotel data model to ensure uniqueness and support cross-data type references. It emphasizes the benefits of decoupling relationships between different data types through the use of unique identifiers, which can facilitate microservice architectures where each service owns a specific data type.

The text discusses the overhead incurred when using the DataStax Java driver for converting data between Java and Scala during read or write operations. It suggests using native Scala codecs to avoid this overhead, which unfortunately do not exist officially. However, the TypeCodec API in the Java driver can be extended to create custom codecs. The text provides examples of creating such codecs directly in Scala for handling CQL types and demonstrates how to use them with the DataStax Java driver. It also discusses the challenges of dealing with nullable values in Scala and provides solutions using Option[Int] and composite patterns. Finally, it introduces a Type Class pattern to convert implicitly between Java and Scala types for more concise code.

The text discusses the creation of a data model for hotel reservation applications using Apache Cassandra. It highlights the importance of good data modeling in building successful applications with Cassandra, and provides an overview of the "query-first" design approach commonly used in this context. The author presents a simplified hotel data model from their book, along with access patterns and logical data models that support shopping for hotel rooms. They also discuss potential extensions to the model, such as supporting multiple ways of locating hotels by attributes like name, geolocation, or amenities. Future installments will explore options for implementing these extensions, including Cassandra's indexes, materialized views, and complementary search technologies.

Java driver 4.0.0-alpha1 has been released, marking the first preview of the next major version. This release includes breaking API changes to address longstanding issues and is available from Maven central with updated coordinates. The sources are on GitHub's 4.x branch. Though functional, this alpha release lacks many features and is not production-ready. A feature-complete beta is expected in the upcoming months. Feedback can be provided via the mailing list or by contributing to open tickets.