A list of DynamoDB libraries covering quite a few popular languages and frameworks:
A couple of things I’ve noticed (and that could be helpful to other NoSQL database companies):
- Amazon provides official libraries for a couple of major programming languages (Java, .NET, PHP, Ruby)
- Amazon is not shy to promote libraries that are not official, but established themselves as good libraries (e.g. Python’s Boto)
- 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 ( ©myNoSQL)
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:
My emphasis on Bryan Fink’s email from Riak’s mailing list.
Original title and link: Riak Performance of Link Walking vs MapReduce ( ©myNoSQL)
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 ( ©myNoSQL)
Dave Smith 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.
Original title and link: The Main Benefits of Riak (NoSQL database©myNoSQL)
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 ( ©myNoSQL)
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)
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
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.
Original title and link: statebox:an eventually consistent data model for Erlang and Riak (NoSQL databases © myNoSQL)
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)
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)
 talking about Membase and Erlang (what worked and what didn’t) at Erlang Factory Lite LA:
Continue to read ➤
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)
On what makes Erlang one of the best environments for building distributed systems:
At the end of the day, the real question isn’t whether it would have been possible for us to implement our cluster management in another language; it’s really a question of effort and maintainability of the result. With any other environment, we would have had to reimplement at least part of what Erlang/OTP provides, while we haven’t really found ourselves reimplementing features provided by any other environment.
A NoSQL database per language ranking would look like:
- C: 2 Redis, Tokyo Cabinet
- C++: 3 Hypertable, MongoDB, Kyoto Cabinet
- C#: 2 RavenDB, sones GraphDB
3 4 CouchDB, Membase, Riak, Hibari
- Java: 8 Cassandra, Hadoop, HBase, OrientDB, Terrastore, Project Voldemort, Neo4j, Hypergraph
Original title and link: Why Membase Uses Erlang (NoSQL databases © myNoSQL)