Items mentioned in the show:

• Travis CI a hosted continuous integration service for the open source community.
• Josh Kalderimis is a core Travis CI team member, Rails contributor, gem developer, and general serial coder.
• Mathias Meyer, hacker on Travis, author of the Riak Handbook.
• Travis now provides first class support for Python and Perl.
• Travis also supports several versions of Ruby including Ruby hidHEAD.
• [8:15] Mathias lays out the case for Travis vs. Jenkins, namely a streamlined user interface.
• Travis runs almost exclusively on Heroku.
• AMQP powers the message queues in Travis.
• Keep an eye on Travis listener.
• The GitHub service hook makes setting up your open source project on Travis a breeze.
• If you’re a Travis user, show some love to keep the features coming.
• GitHubber Rick Olson worked on some API features to help Travis more deeply integrate with GitHub.
• Private repo support, aka Travis Pro™ is on its way. If you want to get in on the beta, donate to the project.
• Donate $500, get an hour of pairing with Aaron Patterson, Yehuda Katz, José Valim, Jon Leighton, or other Ruby pro.
• Mathias previously worked at Basho and The Riak Handbook is a collection of what he learned there.
• José Valim is Josh’s programming hero for his code and community building.
• Mathias is playing with Kestrel and Zookeeper.
• Josh and Mathias like Celluloid.
• Mike Perham’s Sidekiq has caught Josh and Mathias’ eye.

The post Episode 0.7.5 – Travis CI, Riak, and more with Josh Kalderimis and Mathias Meyer appeared first on The Changelog.

Check out the project web site or grab the source on GitHub to contribute.

The post Induction – Polyglot database client for Mac OSX supporting PostgreSQL, MySQL, SQLite, Redis, and MongoDB out-of-the-box appeared first on The Changelog.

Items mentioned in the show:

• J Chris Anderson is a Couchbase cofounder, Mobile Architect, CouchDB committer, new dad
• The CouchDB music video (served up from CouchDB no less)
• Chris sings the official CouchDB theme song to kick off Episode 0.1.8
• Apache CouchDb is a distributed, fault-tolerant and schema-free document-oriented database accessible via a RESTful HTTP/JSON API.
• Damien Katz is the creator of CouchDB.
• CouchBase was formed from merging Membase and CouchOne
• Chris is one of the rare CFOs with a GitHub account
• CouchBase makes the case for NoSQL
• Membase Server currently uses Sqlite under the hood, but will be swapped out for Couch’s storage engine soon
• Mobile Couchbase runs on iOS and brings Couch to your mobile device
• CouchApps are JavaScript and HTML5 applications served directly from CouchDB.
• Zynga makers of Farmville use Membase
• The CouchApp toolkit is now maintained by Benoît Chesneau
• Aaron Miller led the charge to get Erlang on iOS, changing dynamic linking to static linking.
• SpiderMonkey was included iOS for CouchMobile and its JIT compiler made it preferable to V8 or Nitro for Couch tasks.
• GeoCouch adds geospatial features to CouchDB
• Chris outlines the distinctives for Couch’s incremental Map/Reduce
• Jason Smith in Thailand keeps the lights on for CouchBase hosting solutions
• Cloudant offers hosting for Couch in the cloud
• Wynn wants to see integration for CouchBase and Appcelerator Titanium
• Todd Anderson has a great tutorial on using jQuery mobile and CouchDB
• Damien Katz is Chris’ programming hero
• Chris says working with Jan Lehnardt is a blast
• Be sure and check out CouchDB – The Definitive Guide by Chris, Jan, and Noah

The post Episode 0.5.4 – CouchBase, Erlang, and Mergers with J Chris Anderson appeared first on The Changelog.

Items mentioned in the show:

• Eliot Horowitz CTO and Co-Founder of 10gen
• Dwight Merriman CEO & Co-Founder at 10gen
• NoSQL is a loose term for Key Value Stores, Graph Databases, and Document Databases
• MongoDB still has a large roadmap ahead
• MongoDB was first featured on The Changelog over a year ago
• Single server durability tops the list of new additions in 1.8
• Replica sets are an elaboration on the existing master/slave replication, adding automatic failover and automatic recovery of member nodes
• Shutterfly and Foursquare boast some of the largest MongoDB implemenation
• MongoDB’s sharding enables horizontal scaling across multiple nodes.
• Mongo vs. Riak (and other Dynamo inspired stores)
  • Full vs. eventual consistency
  • Compound indexes
  • Increment operations
• Be sure and check out our Riak interviews: Part 1 and Part 2
• Mongo vs. CouchDB
  • Couch uses Map/Reduce views
  • Couch has great master-master replication
  • Couch runs on mobile
  • Mongo’s sharding is closer to a relational database
• Mongo’s Geo features now support more precise, spherical geospatial indexing
• Mongo shines at
  • User profiles
  • CMS data
• Mongo enjoys wide language binding support
• Eliot and 10gen think the Web Scale meme is all in good fun
• BSON [bee · sahn], short for Bin­ary JSON, is a binary-encoded serialization of JSON-like documents
• Our interview with Douglas Crockford on JSON
• MongoDB 2.0 will be focusing on concurrency, aggregation, online compaction, and TTL temporal collections
• Eliot likes Racket when he’s not slinging C.
• Linus Torvalds is one of Eliot’s heroes

The post Episode 0.5.1 – MongoDB, NoSQL, and Web Scale with Eliot Horowitz appeared first on The Changelog.

Installation and usage

Alfred can be installed via npm

npm install alfred

… and require it:

var Alfred = require('alfred');

Alfred uses append-only files to store data, offering safe rsync‘ing. To open a database connection, call open and pass the path to your file, querying in the callback, Node.js style:

Alfred.open('path/to/db', function(err, db) {
  if (err) { throw err; }
  // find and log all users with age > 25 and <= 40
  db.users.find({age: {$gt : 25, $lte: 40}}) (function(err, user) {
    if (err) { throw err; }
    console.log(user);
  });
});

Alfred provides an Object-Document-Mapper style access as well:

Alfred.open('path/to/db', function(err, db) {
  if (err) { throw err; }

  // define User model and its properties
  var User = db.define('User', {
    indexes: [{name: 'age',
              fn-340: function(user) { return user.age; }]
  });
  User.property('name', 'string', {
    maxLength: 100
  });
  User.property('active', 'boolean');

  // get user by id
  User.get(id, function(user) {
    console.log(user.inspect());
  };

  // find users
  User.find({age: {$gt: 18}}).all(function(users) {
    console.log('Found ' + users.length + ' users with more than 18 years') ;
  });
});

Be sure and check out the growing list of api docs for advanced usage.

Speed

Pedro has included an impressive list of benchmarks and the code behind them.

Alfred’s features include master-slave replication, streams, and in-memory indexes. If you want to help out with master-master replication or items on the roadmap, get forkin’.

[Source on GitHub] [Pedro’s Blog post]

The post alfred: Fast in-process key-value store for node.js appeared first on The Changelog.

For readers new to graph databases, here’s a brief video introduction.

For more on Neo4j, be sure and check out the Getting Started Guides with introductions for Java, Python, and Ruby.

[Source on GitHub] [Home Page]

The post Neo4j Graph Database now on GitHub! appeared first on The Changelog.

Toy Store features include:

• Attributes – attribute :name, String (or some other type) Can be virtual which works just like attr_accessor but all the power of dirty tracking, serialization, etc. Also, can be abbreviated which means :first_name could be the method you use, but in the data store the attribute is :fn. Save those bytes! Allows for default values and defaults can be procs.
• Typecasting – Same type system as MongoMapper. One day they will share the exact same type system in its own gem, for now duplicated.
• Callbacks – all the usual suspects.
• Dirty Tracking – save, create, update, destroy
• Mass assignment security – attr_accessible and attr_protected
• Proper cloning
• Lists – arrays of ids. If user has many games, user would have list :games which stores in game_ids key on user and works just like an association.
• Embedded Lists – array of hashes. More consistent than MongoMapper, which will soon reap the benefits of the work on Toy Store embedded lists.
• References – think belongs_to by a different (better?) name. Post model could reference :creator, User to add creator_id key and relate creator to post.
• Identity Map – On by default. Should be thread-safe.
• Read/write through caching – If you specific a cache adapter (say memcached), ToyStore will write to memcached first and read from memcached first, populating the cache if it was not present.
• Indexing – Need to do lookups by email? index :email and whenever a user is saved the user data is written to one key and the email is written as another key with a value of the user id.
• Logging
• Serialization (XML and JSON)
• Validations
• Primary key factories

Toy Store sits atop of the newly announced Adapter gem, an Active Model-based adapter that provides a unified interface to most NoSQL stores or darn near anything, in the vein of Moneta.

John has created adapters for Riak, memcached, Redis, and Cassandra. If you need support for another store, you can build your own adapter by implementing just four methods for read, write, delete, and clear:

Adapter.define(:memory) do
  def read(key)
    decode(client[key_for(key)])
  end

  def write(key, value)
    client[key_for(key)] = encode(value)
  end

  def delete(key)
    client.delete(key_for(key))
  end

  def clear
    client.clear
  end
end

[Source on GitHub] [John’s Blog post] [Discuss on Hacker News]

The post toystore: Ruby mapper for key-value data stores, and darn near anything appeared first on The Changelog.

Nicolas Favre-Felix gives some web love to Redis fans with Webdis, an HTTP interface for Redis that serves up JSON. Built in C, Webdis aims to be fast like Redis itself. The URL structure takes the pattern of:

http://127.0.0.1:7379/COMMAND/KEY/[VALUE]

Let’s look at some concrete examples:

curl http://127.0.0.1:7379/SET/hello/world
→ {"SET":[true,"OK"]}

curl http://127.0.0.1:7379/GET/hello
→ {"GET":"world"}

curl -d "GET/hello" http://127.0.0.1:7379/
→ {"GET":"world"}

While still early in development, the feature set is impressive. Webdis currently offers:

• Support for GET and POST
• JSON and JSONP parameter (?jsonp=myFunction).
• Raw Redis 2.0 protocol output with .raw suffix
• HTTP 1.1 pipelining
• TCP or UNIX socket Redis connections
• CIDR or HTTP Basic Auth security
• Pub/Sub using Transfer-Encoding: chunked. Coupled with JSONP, Webdis can be used as a Comet server
• Built-in support for json, txt, ‘html, xml, xhtml, png, and jpg
• Custom Content-Type types based on file extension, or ?type=some/thing
• Cross-origin XHR, if compiled with libevent2 (for OPTIONS support)
• File upload with PUT, if compiled with libevent2 (for PUT support)

Check the README for the complete list. If you’d like to contribute, Nicolas is thinking about how to add other HTTP verb support like PUT and DELETE, Websockets, and Etags.

Also, if you missed it, be sure and catch Episode 0.4.5 with @antirez, the creator of Redis.

[Source on GitHub] [Comment on Hacker News]

The post webdis: HTTP + JSON API for Redis appeared first on The Changelog.

Items mentioned in the show:

• VMWare signs the paychecks for Salvatore and Pieter Noordhuis
• Redis is an open source, advanced key-value store and data structure server wherein keys can contain strings, hashes, lists, sets and sorted sets
• Redis internals consist of ANSI C with an evented model
• Non-blocking replication has always been a Redis design goal
• Replication in Redis is async
• Salvatore’s Redis toolbox includes the Redis Ruby gem and Sinatra
• Chances are you can find a Redis library in your favorite language
• The C client is the only officially supported wrapper
• Salvatore thinks the NoSQL moniker isn’t perfect, focusing too much on performance, but it frames a discussion
• Redis Pub/Sub is perfect for real-time apps
• GitHub’s adoption of Redis in Resque helped fuel the growth of the project
• Redis users tend to use it as a database, as a messaging bus, or as a cache
• Salvatore thinks hosted solutions like Redis-to-Go need to add more value like more frequent backups and seamless upgrades.
• Blizzard uses an 8-node Redis install in serving avatars for WoW
• Justin Campbell asks will VMWare feature Redis in any upcoming projects?
• Ezra Zygmuntowicz and GitHub were among the first “few brave users”
• Salvatore noticed a dip in adoption after a few months, but he trusted his gut and stuck with it

The post Episode 0.4.5 – Redis with Salvatore Sanfilippo appeared first on The Changelog.

pauldowman / gitmodel

Git Model is an ActiveModel-compatible NoSQL store based on git. Not ready for primetime but very interesting.

assaf / vanity

Vanity is declarative A/B testing for Rails.

sidelab / tile5

Tile5 is a nifty multi-provider mobile-optimized mapping framework for building mapping or other tile-based applications.

The post Watch Wednesday appeared first on The Changelog.

Items mentioned in the show:

• NoSQL smackdown, live from SXSW 2010.
• Are you web scale?
• Drop us a ping@thechangelog.com and let us know who you want to get on The Changelog
• Andy Gross VP of Engineering at Basho, the company behind Riak.
• Mark Phillips Community Manager at Basho AKA * @pharkmillups
• John Nunemaker of Ordered List and MongoMapper fame
• Riak is now available as a binary download
• Bitcask, the new backend for Riak
• Riak key value store, decentralized datastore from Basho Technologies
• Riak Search, full-text search engine based on Riak
• Riak buckets, container and keyspace for data stored in Riak
• Riak KVS buckets can be automatically searchable by installing the Search pre-commit hook
• Riak supports an Apache SOLR interface
• Sean Cribbs made some waves with Ripple
• Ruby, Python, Node.js are the biggest adopters of Riak
• Riak aims to scale both up and down. Adding a node adds a linear increase in throughput and storage capacity. 50 nodes run easily on a laptop.
• Riak nodes are truly decentralized, no node is special
• Riak compares to Cassandra and Voldemort
• Riak has built-in JavaScript map reduce but unlike Couch, it’s more an ad hoc approach.
• Andy explains Riak’s link walking or bucket-key-tag relationships between objects.
• Riak now has two interfaces, the original REST HTTP interface, and a new protocol buffers interface, a faster binary interface
• Eric Brewer, a Basho board member, and his cap theorem
• Bitcask is an append-only file format where the keys are stored in memory for ultra fast lookups.
• InnoStore, the original Riak backend
• John Muellerleile, author of the popular NoSQL cartoon about distributed map reduce in Erlang
• Apache Lucene query syntax a growing standard for search
• The move from BitBucket to GitHub was ultimately about community, not about DVCS
• The THANKS file lists many Riak community contributors
• Harmony – the MongoDB-powered hosted CMS from Ordered List
• Mozilla runs several Riak clusters to log data from their Test Pilot project
• Francisco Treacy uses Riak in WideScript, “an innovative app that helps you focus and interact with your texts — on your desktop, your couch or on the go.”
• Inagist recently moved from Cassandra to Riak
• Riak has partnered with Joyent and Node creator Ryan Dahl to create Riak SmartMachines
• Mark also is a fan of Redis
• Scala and Clojure have Andy excited, too.

The post Episode 0.4.0 – Riak revisited with Andy Gross, Mark Phillips, and John Nunemaker appeared first on The Changelog.

If CoffeeScript (covered in Episode 0.2.9) is your preferred method to sling JavaScript these days, check out CoffeeApp from Andrzej Sliwa. CoffeeApp is a simple wrapper on top of CouchApp that lets you write your apps in Coffee as well as manage multiple releases of your apps with deployment snapshots.

Assuming you’ve gotten CoffeeScript installed including its Node.js dependencies, you can install CoffeeApp via the excellent npm.

npm install coffeeapp

You can then invoke coffeeapp with the normal couchapp options

coffeeapp [options]

CoffeeApp maintains a .releases folder where your *.coffee files are converted to to *.js on-the-fly before pushing to CouchDB.

**UPDATE

Andrzej has made a flurry of changes yesterday including some nifty generators:

$ coffeeapp cgenerate view myview

CoffeeApp (v0.0.5) - simple coffee-script wrapper for CouchApp (http://couchapp.org)
http://github.com/andrzejsliwa/coffeeapp

Running CoffeeApp 'view' generator...
 * creating myview/map.coffee...
 * creating myview/reduce.coffee...
done.

[Source on GitHub]

The post coffeeapp: Have some CoffeeScript on the CouchApp appeared first on The Changelog.

Install ACLatraz via Ruby gems

gem install aclatraz

and configure your Redis-based storage

Aclatraz.init :redis, "redis://localhost:6379/0"

Everyone is a Suspect

In keeping with the Alcatraz theme, actors in your authorization system are deemed Suspects:

class Account < ActiveRecord::Base
  include Aclatraz::Suspect
end

ACLatraz supports global, class-related, and object-related roles:

# global admin role
@account.roles.assign(:admin) # or ...
@account.is.admin!

# Page class-related role
@account.roles.assign(:responsible, Page) # or...
@account.is.responsible_for!(Page)

# object-related role for page 15
@account.roles.assign(:author, Page.find(15)) # or...
@account.is.author_of!(Page.find(15))

Once, assigned you can interrogate your suspects a couple of ways using has?

@account.roles.has?(:admin)                # => true
@account.roles.has?(:responsible, Page)     # => true
@account.roles.has?(:author, Page.find(15) # => true

… or the more natural semantic shortcuts:

@account.is_not.admin?                      # => false
@account.is_not.responsible_for?(Page)       # => false

Guarding The Rock

To enable access control on an object, include the Aclatraz::Guard module:

class Page
  include Aclatraz::Guard

  suspects :account do
    deny all # notice that it's a method, not symbol
    allow :admin
  end
end

Check the README for even more features including custom actions, aliases, and class inheritance.

[Source on GitHub]

The post ACLatraz: Redis-powered access control for your ruby apps appeared first on The Changelog.

• No additional query API. You simply drop down to the Ruby driver.
• No relationships. Simply write your own finder methods.
• No validations. Unless you write your own.

What’s the upside you may ask? Minimal dependencies and better alignment with MongoDB native conventions.

A sample model

require 'mongomatic'

class User < Mongomatic::Base
  def validate
    self.errors << ["Name", "can't be empty"]  if self["name"].blank?
    self.errors << ["Email", "can't be empty"] if self["email"].blank?
  end
end

# set the db for all models:
Mongomatic.db = Mongo::Connection.new.db("mongomatic_test")
# or you can set it for a specific model:
User.db = Mongo::Connection.new.db("mongomatic_test_user")

Find a single user:

found = User.find_one({"name" => "Ben Myles"})
=> #<User:0x00000101939a48 @doc={"_id"=>BSON::ObjectID('4c32834f0218236321000001'), "name"=>"Ben Myles", "email"=>"me@somewhere.com"}, @removed=false, @is_new=false, @errors=[]>

Iterate over a cursor, the MongoDB way:

cursor = User.find({"name" => "Ben Myles"})
=> #<Mongomatic::Cursor:0x0000010195b4e0 @obj_class=User, @mongo_cursor=<Mongo::Cursor:0x80cadac0 namespace='mongomatic_test.User' @selector={"name"=>"Ben Myles"}>>
found = cursor.next
=> #<User:0x00000101939a48 @doc={"_id"=>BSON::ObjectID('4c32834f0218236321000001'), "name"=>"Ben Myles", "email"=>"me@somewhere.com"}, @removed=false, @is_new=false, @errors=[]>
found.remove
=> 67
User.count
=> 0
User.find({"name" => "Ben Myles"}).next
=> nil

If you need a quick-and-dirty model for your MongoDB Ruby app, give Mongomatic a look. It looks like a lightweight alternative to MongoMapper and Mongoid.

[Source on GitHub] [Homepage]

The post mongomatic: Minimal Ruby mapper for Mongo appeared first on The Changelog.

Wait no more, nStore is here. It’s written in pure js and is contained in a single js file to include in your node project. It supports full CRUD operations on key based documents.

The data is persisted to disk using a smart append-only format that’s easily recoverable by design. You can update/insert documents by key, read documents by key, remove documents by key… (get the picture, it’s key/value based).

Also you can build a node stream interface from a document collection or query the collection using a filter function and get the results as a single callback.

Removing stale data is easy and efficient too. Just supply a filter function to the automatic data compacter and it will remove the offending documents while compacting the data file. Thus the file is never needlessly bloated with delete lines.

Here is a short example that creates a database, inserts a document, and pulls it back out.

// Load the library
var nStore = require('nstore');
// Create a store
var users = nStore('data/users.db');

// Insert a new document with key "creationix"
users.save("creationix", {name: "Tim Caswell": age: 28}, function (err) {
    if (err) { throw err; }
    // The save is finished and written to disk safely
});

// Then later pull it back out
users.get("creationix", function (err, doc, meta) {
  // do something with the data
})

Try is out as a standalone database, or use it with Connect as a session store. http://github.com/creationix/nstore-session

[Source on GitHub]

The post nStore – easy database written for node.js in node.js appeared first on The Changelog.

[Download] [iPhone version]

The post Video: NoSQL Smackdown Part 4 appeared first on The Changelog.

For me, NoSQL is about choice: The possibility to choose a storage system that fits your project’s needs instead of sticking to a one-size-fits-all-solution that really isn’t one.

The post NoSQL is About… appeared first on The Changelog.

[Download] [Part 1] [Part 2] [Complete event audio]

The post Video: NoSQL Smackdown Part 3 appeared first on The Changelog.

[Download] [iPhone/iPod version] [Complete EP 0.1.8 audio]

The post Video: NoSQL Smackdown Part 2 appeared first on The Changelog.

[Download] [iPhone/iPod version]

The post Video: NoSQL Smackdown Part 1 appeared first on The Changelog.

• RubyQuiz.com Challenge your Ruby fu, feel dumb, learn something, repeat.
• OpenBeta4 We were blown away by the startup community in OKC
• Red Dirt Ruby Conf Join us in OKC for this premier Ruby event
• FasterCSV De-facto CSV handling in Ruby, now built-in to 1.9
• Ruby Kaigi Awesome Ruby conference in Japan
• TextMate James’ favorite text editor
• Ruby bundle for TextMate
• ##textmate TextMate IRC channel
• #thechangelog Drop in and share your latest open source projects
• Rack Rack provides a minimal interface between webservers supporting Ruby and Ruby frameworks.
• Rails 3.0 Active Record query interface
• LA Ruby Conf Ruby conference in L.A. just wrapped in February
• Redis – an advanced key-value store. It is similar to memcached but the dataset is not volatile, and values can be strings, exactly like in memcached, but also lists, sets, and ordered sets.
• OK.rb Now meeting at OKCCoCo
• Irma’s Burger Shack Best place to grab a burger in OKC. Hey, they’re on the Twitter
• Glenn Vanderburg One of James’ Ruby heroes
• Oklahoma Mixer James’ full featured and robust FFI interface to Tokyo Cabinet.

The post Episode 0.1.9 – James Edward Gray II on Ruby, TextMate, and Red Dirt Ruby Conf appeared first on The Changelog.

The participants:

• Stu Hood from Cassandra
• Jan Lehnardt from CouchDB
• Wynn Netherland from The Changelog, subbing for MongoDB
• Werner Vogels CTO at Amazon

The videos:

• Part 1
• Part 2
• Part 3
• Part 4

Items mentioned in the discussion:

• Cassandra The Apache Cassandra Project brings together Dynamo’s fully distributed design and Bigtable’s ColumnFamily-based data model and powers some of the world’s largest sites.
• CouchDB Apache,CouchDB is a distributed, fault-tolerant and schema-free document-oriented database accessible via a RESTful HTTP/JSON API.
• MongoDB Combining the best features of document databases, key-value stores, and RDBMSes.
• Amazon SimpleDB a highly available, scalable, and flexible non-relational data store that offloads the work of database administration.
• Dynamo Dynamo is a highly available, proprietary key-value structured storage system that powers parts of Amazon Web Services.
• Amazon S3 Amazon S3 is storage for the Internet. It is designed to make web-scale computing easier for developers.
• Persevere Persevere helps you rapidly develop data-driven JavaScript-based rich internet applications.
• Redis Redis is an advanced key-value store. It is similar to memcached but the dataset is not volatile, and values can be strings, exactly like in memcached, but also lists, sets, and ordered sets.
• Neo4j Neo4j is a graph database. It is an embedded, disk-based, fully transactional Java persistence engine that stores data structured in graphs rather than in tables.

Special thanks to @jchris for the awesome CouchDB theme song!

The post Episode 0.1.8 – NoSQL Smackdown! appeared first on The Changelog.

• Wrap the standard MongoDB operations in a strongly-typed interface
• Provide ultra fast serialization of BSON to .NET CLR types and back
• LINQ-to-Mongo support
• Mono compatability

A quick code example from the Wiki:

//open collection
var coll = (new MongoServer()).GetDatabase("Northwind")
                  .GetCollection<Product>();
//create a new object to be added to the collection
var obj = new Product();
obj._id = BSONOID.NewOID();
obj.Title = "Shoes";
//save the object
coll.Insert(obj);
//find the object
var obj2 = coll.FindOne(new { _id = obj._id}).First();

Glad to see Northwind Traders has upgraded to MongoDB…

[Source on GitHub]

The post NoRM – Bringing MongoDB to .NET, LINQ, and Mono appeared first on The Changelog.

Items mentioned in the show:

• Ripple New Ruby wrapper for Riak
• Link walking in Riak
• RadiantCMS Ruby-powered Content Management System

The post Episode 0.1.4 – Andy Gross and Sean Cribbs on Riak appeared first on The Changelog.

Given a User class that extends a Fiber Document:

$user = User::find('john');
$user->email = "john@example.com";
$user->city = "San Francisco";
$user->save();

Fiber also includes some nifty chaining:

$user->set( array( "email" => "peter@example.com", "city" => "Caracas" ) )->save();

Check out the examples in the source.

[Source on GitHub]

The post Fiber: A simple PHP interface to CouchDB appeared first on The Changelog.

An example from the README

require 'riak'

# Create a client interface
client = Riak::Client.new

# Retrieve a bucket
bucket = client.bucket("doc")  # a Riak::Bucket

# Get an object from the bucket
object = bucket.get("index.html")   # a Riak::RObject

# Change the object's data and save
object.data = "Hello, world!"
object.store

Still want more Riak? Stay tuned. Episode 0.1.4 will rock!

[Source on GitHub] [Homepage] [Backstory]

The post ripple – Ruby client for Riak appeared first on The Changelog.

Master-less replication

Riak is architected for master-less replication from the GET-go. All nodes participate equally in the replication so scaling horizontally means just adding new servers to join the party.

Links for powerful object graphs

Riak supports link-walking which is far more powerful than traditional relational DB joins. As Sean Cribbs explains:

Every datum stored in Riak can have one-way relationships to other data via the Link HTTP header. In the canonical example, you know the key of a band that you have stored in the “artists” bucket (Riak buckets are like database tables or S3 buckets). If that artist is linked to its albums, which are in turn linked to the tracks on the albums, you can find all of the tracks produced in a single request. As I’ll describe in the next section, this is much less painful than a JOIN in SQL because each item is operated on independently, rather than a table at a time. Here’s what that query would look like:

GET /raw/artists/TheBeatles/albums,_,_/tracks,_,1

More powerful Map/Reduce

Map/Reduce works a bit differently in Riak. Riak’s Map function expects a list of keys on which it should run. You can of course pass every key in your bucket, but doing Map in this way allows Map to be run on the node where the data is actually stored.

Riak ships with libraries for Python, Ruby, Java, Erlang, and even JavaScript. Want to know more? Stay tuned. Riak will be the focus of an upcoming episode of The Changelog.

[Source on BitBucket] [Homepage] [Brian Fink’s NYC-NoSQL talk]

The post riak – high performance document store built on JSON and REST appeared first on The Changelog.

Neo4jr-Social is a self contained HTTP REST + JSON interface to the graph database Neo4j. Neo4jr-Social supports simple dynamic node creation, building relationships between nodes and also includes a few common social networking queries out of the box (i.e. linkedin degrees of seperation and facebook friend suggestion) with more to come.

[Source on GitHub] [API docs]

The post neo4jr-social: REST interface for Neo4j appeared first on The Changelog.

[Source on GitHub] [Homepage]

The post Friendly: NoSQL with MySQL in Ruby appeared first on The Changelog.

Items mentioned in the show

• Google’s V8 project
• Mongo’s new Map/Reduce features
• Mongo’s BSON storage format
• MongoMapper Ruby ORM from John Nunemaker
• MongoKit Python ORM from @namlook
• Ming from SourceForge
• MongoHQ – MongoDB hosting

The post Episode 0.0.7 – Mike Dirolf from 10gen and MongoDB appeared first on The Changelog.