NoSQL Benchmarks NoSQL use cases NoSQL Videos NoSQL Hybrid Solutions NoSQL Presentations Big Data Hadoop MapReduce Pig Hive Flume Oozie Sqoop HDFS ZooKeeper Cascading Cascalog BigTable Cassandra HBase Hypertable Couchbase CouchDB MongoDB OrientDB RavenDB Jackrabbit Terrastore Amazon DynamoDB Redis Riak Project Voldemort Tokyo Cabinet Kyoto Cabinet memcached Amazon SimpleDB Datomic MemcacheDB M/DB GT.M Amazon Dynamo Dynomite Mnesia Yahoo! PNUTS/Sherpa Neo4j InfoGrid Sones GraphDB InfiniteGraph AllegroGraph MarkLogic Clustrix CouchDB Case Studies MongoDB Case Studies NoSQL at Adobe NoSQL at Facebook NoSQL at Twitter



Erlang: All content tagged as Erlang in NoSQL databases and polyglot persistence

What versions of Erlang should you use with CouchDB

Ruseel Branca goes through a list of Erlang versions to identify those that are safe to be used with CouchDB:

There has been some discussion on what versions of Erlang CouchDB should support, and what versions of Erlang are detrimental to use. Sadly there were some pretty substantial problems in the R15 line and even parts of R16 that are landmines for CouchDB. This post will describe the current state of things and make some potential recommendations on approach.

Very useful.

Original title and link: What versions of Erlang should you use with CouchDB (NoSQL database©myNoSQL)


DynamoDB Libraries, Mappers, and Mock Implementations

A list of DynamoDB libraries covering quite a few popular languages and frameworks:

DynamoDB Libraries, Mappers, and Mock Implementations

A couple of things I’ve noticed (and that could be helpful to other NoSQL database companies):

  1. Amazon provides official libraries for a couple of major programming languages (Java, .NET, PHP, Ruby)
  2. Amazon is not shy to promote libraries that are not official, but established themselves as good libraries (e.g. Python’s Boto)
  3. The list doesn’t seem to include anything for C and Objective C (Objective C is the language of iOS and Mac apps)

Original title and link: DynamoDB Libraries, Mappers, and Mock Implementations (NoSQL database©myNoSQL)


Riak Performance of Link Walking vs MapReduce

If you are asked to compare (or you just wonder about) the performance of link walking and map-reduce in Riak keep in mind the following details of how the two mechanism are implemented:

The biggest difference I see is that the link-walk uses an Erlang function where your MapReduce query uses a Javascript function (link-walking is implemented as a MapReduce query internally).

Serializing/deserializing to JSON as well as contention for Javascript VMs likely accounts for the lost time.

My emphasis on Bryan Fink’s email from Riak’s mailing list.

Original title and link: Riak Performance of Link Walking vs MapReduce (NoSQL database©myNoSQL)

Riak Tips&Tricks: Streaming List Keys

I’m not sure how long ago I forgot about this, but I just remembered about a nice little feature when I was moving some data around on a Riak cluster. As the post title points out, this feature is streaming list keys in a bucket. […] The useful bit of this is because list_keys can be a lengthy operation, you can begin doing work on the data before you receive all of the keys.

The function is riak_client:stream_list_keys() and the post shows how to use it.

Original title and link: Riak Tips&Tricks: Streaming List Keys (NoSQL database©myNoSQL)


The Main Benefits of Riak

Dave Smith[1] about Riak:

Low, predictable latency data access and operational ease-of-use. When used appropriately (i.e. don’t expect Riak to be a RDBMS), Riak is able to provide an excellent latency profile, even in the case of multiple node failures. In addition, it’s easy to add/remove nodes while the system is running without a lot of operational juggling. Another useful benefit is that multiple nodes can take writes for the same key, thus making it easier to construct a geographically distributed data store.

  1. Dave Smith, Director of Engineering at Basho Technologies, Inc.  

Original title and link: The Main Benefits of Riak (NoSQL database©myNoSQL)


The Story of the MongoDB Erlang Driver

Tony Hannan:

The mongodb driver has a couple of objects like connection and cursor that maintain mutable state. The only way to mutate state in Erlang is to have a process that maintains its own state that it updates when it receives messages from other processes. The Erlang programmer typically creates a process for each mutable object and defines the messages it may receive and the action to take for each message. They usually provide helper functions for the clients to call that hide the actual messages being sent and returned. Erlang OTP provides a small framework called gen_server to facilitate this process definition but it is still non-trivial. To alleviate this burden I created another abstraction on top of gen_server called var. A var is an object (process) that holds a value of some type A that may change.

Original title and link: The Story of the MongoDB Erlang Driver (NoSQL database©myNoSQL)


Riak from the inside

Justin Sheehy‘s slides on how using Erlang/OTP made possible building a robust, flexible, and simple Riak:

You can download the slides for offline view from here .

Original title and link: Riak from the inside (NoSQL databases © myNoSQL)

statebox:an eventually consistent data model for Erlang and Riak

When you choose an eventually consistent data store you’re prioritizing availability and partition tolerance over consistency, but this doesn’t mean your application has to be inconsistent. What it does mean is that you have to move your conflict resolution from writes to reads. Riak does almost all of the hard work for you, but if it’s not acceptable to discard some writes then you will have to set allow_mult to true on your bucket(s) and handle siblings from your application. In some cases, this might be trivial. For example, if you have a set and only support adding to that set, then a merge operation is just the union of those two sets.

So, Bob Ippolito (Mochi Media) created statebox to address this scenario for data structure supporting repeatable operations.

Justin Sheehy

Original title and link: statebox:an eventually consistent data model for Erlang and Riak (NoSQL databases © myNoSQL)


Redis Sharding with Erlang

Chris Moos:

The first thing I have to say about adding nodes is to not do it. Salvatore Sanfilippo wrote a great post about sharding Redis, and his recommendation is that re-hashing is difficult and instead you should create a large number of small Redis instances up front, that way you don’t have to add more nodes down the road.

Why not going the extra mile and use consistent hashing then? This if using Gizzard or riak_core is not an option.

Original title and link: Redis Sharding with Erlang (NoSQL databases © myNoSQL)


Open-Source VoIP Cloud Services with Erlang

There’s a bit of CouchDB in the project:

We’ve built an open-source product that automatically deploys, scales and distributes VoIP calls across the Internet on commodity or virtualized servers. It fully utilizes Erlang for VoIP logic as well as relies on other Erlang products like CouchDB and RabbitMQ. It’s got an awesome set of APIs and some other nifty features.

Original title and link: Open-Source VoIP Cloud Services with Erlang (NoSQL databases © myNoSQL)

Membase and Erlang with Matt Ingenthron

Matt Ingenthron[1] talking about Membase and Erlang (what worked and what didn’t) at Erlang Factory Lite LA:

Tutorial: Developing in Erlang with Webmachine, ErlyDTL, and Riak

I haven’t got to learn Erlang yet, so I’m mostly bookmarking OJ’s 3 part tutorial for future read:

  • ☞ Part 1
    In Part 1 of the series we covered the basics of getting the development environment up and running. We also looked at how to get a really simple ErlyDTL template rendering
  • ☞ Part 2
    There are a few reasons this series is targeting this technology stack. One of them is uptime. We’re aiming to build a site that stays up as much as possible. Given that, one of the things that I missed in the previous post was setting up a load balancer. Hence this post will attempt to fill that gap.
  • ☞ Part 3

    In this post we’re going to cover:

    • A slight refactor of code structure to support the “standard” approach to building applications in Erlang using OTP.
    • Building a small set of modules to talk to Riak.
    • Creation of some JSON helper functions for reading and writing data.
    • Calling all the way from the Webmachine front-end to Riak to extract data and display it in a browser using ErlyDTL templates.

Original title and link: Tutorial: Developing in Erlang with Webmachine, ErlyDTL, and Riak (NoSQL databases © myNoSQL)