stephen_mcd

Cool!

I built CurioDB a while back with the same idea, but using Akka as the underlying framework. Persistent Redis with distributed transactions, embedded Lua and a websocket front-end:

https://github.com/stephenmcd/curiodb

You're not wrong, Walter.

CurioDB too: http://curiodb.jupo.org

If each key/value in the DB is treated as distributed (as per the actor model), a lot of the limitations Redis faces in a distributed environment are solved. I wrote a lot more about it here: http://blog.jupo.org/2015/07/08/curiodb-a-distributed-persis...

I really love the idea of explaining the actor model as tons of tiny little servers compared to a single monolithic server. I tried to make the same comparison recently when I talked about adding distributed transactions to CurioDB (Redis clone built with Scala/Akka): http://blog.jupo.org/2016/01/28/distributed-transactions-in-...

Great project. I recently used LuaJ to embed Lua scripting inside CurioDB: https://github.com/stephenmcd/curiodb - it's a distributed Redis clone built with Scala/Akka. In terms of matching features with Redis, LuaJ was a life-saver.

Yep, one actor per KV means some kind of distributed coordination would be needed - that doesn't exist yet.

That'd be good!

Hey Jon, long time no see. :-)

Yes I imagine the thinking there is similar in your project, eg: Redis/CurioDB :: Node/SocketCluster (https://github.com/SocketCluster/socketcluster).

Glad you like it!

Hardware requirements would depend on your usage of course, it's like asking about the length of a piece of string. :-)

Honestly though, the code probably needs a lot more eyeballs on it before it's production ready, which is why I posted it here.

Funny is a +1 on Slashdot, while on HN it'd be a -1.

The rotated A in the Aerospike logo reminds me of a system that's fallen over, and now you can't unsee it:

http://www.aerospike.com/

You can easily render a tree many levels deep in O(n) time using a single DB query as an adjacency list with a lookup dictionary:

http://blog.jupo.org/2010/01/26/linear-traversal-of-adjacenc...

No need for mptt either.

Perhaps it was more a case of accuracy for what we were looking at at the time then :-)

It's something we run out of band on a subset of our data, so it's never been performance critical.

Great article.

I went through a similar process about a year ago for https://kouio.com (RSS reader). In its case I needed to coalesce closely matching RSS feeds purely for storage and performance. After trialling edit distance and various simhash implementations in Python, we ended up needing to look no further than the standard library's difflib.SequenceMatcher - I wish I documented my findings at the time, but I recall it was the best in terms of speed and accuracy.

Also you might not want to rely on str.isalnum for stripping punctuation. I made the same mistake here: https://twitter.com/stephen_mcd/status/506344236531212288

https://twitter.com/stephen_mcd - hit me up, lots of open source

I use the web version of kouio on android every day, it's tailored directly to mobile devices:

https://kouio.com/blog/kouio-your-mobile-rss-reader

You can also push articles out to a whole ton of services at once, including Evernote:

https://kouio.com/blog/sharing-is-caring

As for HN and Reddit, RSS is perfect for these - HN has its own RSS feed dedicated to front-page items:

https://news.ycombinator.com/rss

It gets even better with Reddit, each individual subreddit has its own RSS feed, eg:

http://www.reddit.com/r/systems/.rss

With kouio I group together all the interesting subreddit feeds under a folder called Reddit - then I can view them individually or all together at once.

Yeah I only found those recently and it kinda blew my mind - great way to keep an eye on the kinds of blockers people have with a particular technology.

Well that list above are all things I kinda class as "personal notifications", so I put all those into a folder - in kouio you can view a single folder at a time, or expand it and see the unread counts against each feed (pretty sure Google's worked that way too).

Then everything else goes into various folders, with a couple top-level main feeds that I don't put into a folder at all, here's a screenshot:

http://cl.ly/VNOJ

Very well put!

My RSS reader (http://kouio.com after Google's shut down) has always been my complete command centre:

- Google Alerts

- LinkedIn updates

- Every issue/comment/star on my Github projects

- The exact ages of my children every day (via http://howoldismykid.com)

- New questions per tag on stack overflow.

- New messages for individual Google Groups.

and so much more.

I was just lost when Google Reader shut down thinking I'd lose all that, RSS really is the universal API of web data.

Check out https://kouio.com if you're looking for something visually clean and simple.