Redis 2.6 is near

I can't understand this comment now, after the youporn success story... Isn't this enough for enterprise people?

Ok seriously now... Groupon did an event a few days ago about how they use Redis with success, Twitter uses Redis for caching timelines, Github does a good use of Redis, and similarly do many other non trivial companies, like Craigslist, Stack Overflow, Digg, ...

Those are not "enterprise" companies, but the problems they solve are not different, so IMHO the real problem is a cultural barrier. I think that this is just a matter of time.

Don't work in enterprise. I'm not joking, and this isn't a trite stab or troll. I'm totally serious. I think most of the companies that folks describe as 'enterprise' shops ought to go away, along with the all of the expensive, broken, 'best practice' mentalities.

Also, you don't need proof. You're up against complacency, not suspicion.

I did it myself with vim, looking at the logo. It's a long process ;)

Every command blocks every other command in Redis, because Redis is single threaded. However the implementation of scripting in Redis does a good use of Lua, so a command implemented in Lua does not run too much slower than a command implemented in C, for simple tasks (since we use a single Lua interpreter, and cache compiled functions). So this is an example of what you can do with Lua scripting:

    redis 127.0.0.1:6379> set foo '{"b":20,"a":10}'
    OK

The user wants to increment the value of "b" with a single query to Redis in an atomic way:

    $ cat /tmp/script.lua
    obj = cjson.decode(redis.call("GET",KEYS[1]))
    obj.b = obj.b + 1
    redis.call("SET",KEYS[1],cjson.encode(obj))
    return obj.b
    $ redis-cli --eval /tmp/script.lua foo
    (integer) 21
    $ redis-cli --eval /tmp/script.lua foo
    (integer) 22
    $ redis-cli GET foo
    "{\"a\":10,\"b\":22}"

No back and forth from client to server, no locking needed. Basically you can implement your specialized, atomic commands, in Lua.

Wavii is using LUA in Redis to implement extremely simple single object atomic consistency. Some but not all of the Redis data structure types support "do XYZ only if the key exists". For example lists support LPUSHX but there is no "X" equivalent for sorted sets. With LUA I can add the ZADDX command in about 4 lines of LUA and 4 lines of Ruby in my Redis driver. We have lots of sorted sets backed by the database. Suppose we add an item to the set. If the set is in Redis we want to do the O(logN) ZADD, if it is not in Redis we need to do an O(N) reload from the DB. The use of ZADDX + transactions in our DB lets multiple writers contend on adding an item to a sorted set and guarantee that at the end all the items are in the sorted set while doing O(logN) operations almost all the time.

1) 'make ansi'

2) Very fast for a such a small implementation.

3) C - Lua API makes sense.

4) Any algol-like language is easily picked by a programmer. So Lisp or Tcl could not be idea, but Lua is fine syntax wise.

What I don't like about Lua (but was not enough to stop me from using it for Redis):

1) 1-based indexes.

2) ~=, why not != that everybody knows?

3) A unique "float" type for all the numbers is not ideal.

4) A unique "table" type for maps and arrays is not ideal.

5) You want to be small, but C bit operations as native operators inside the core are a good idea.

I would love to hear more about that architecture. I just added 0MQ into our product to handle pushing and pulling events, among other things. Some of the events are OK if they get lost; others, not so much so. I've been thinking about adding something like redis or mongodb to the mix to provide a layer of persistence to those messages.

I am also working on parallel processing for my Phd and implementing a Redis-based distributed shared memory queueing system that looks a lot like a tuple space. The Redis primitives fit this messaging model perfectly, allowing very loose coupling between language-neutral computational elements. I do have concerns that the single-threading may eventually impose a bottleneck with the scale of deployment intended (1000s of CPUs and GPUs). I have been looking into 0MQ to overcome these limitations and wonder how feasible it would be to implement a 0MQ socket connection option for Redis.

We use 0MQ and Redis together at work. We have an incremental flow of updates that we distribute internally over 0MQ pubsub, and have one listener process that updates the full state in Redis from each update message. That way, we have both (a) a way to easily get the latest state (and fast), and (b) an easy way to listen for updates to the state. It works beautifully, even with a high rate of updates.

apparently Microsoft is working more to the win32 port, and now there is a github repository: https://github.com/Microsoft-Interop/redis

I hope to see some good stuff in the next weeks.