dgrnbrg

What about the 3rd founder? He got written out of the narrative early on, but he built the original platform and was bought out in the first few years.

At least one commercial company I've heard of has a sophisticated permissioning model, so that the owner of the chain can publish it and have its causal history and/or integrity be validated by all participants, but with specific permission scopes so that subscribes to the blockchain can only see inside of transactions they have permissions for.

It's not just the root's event log--it's all the event logs. The deferrals allow us to batch writes in an optimized way, and do so with a fully incremental algorithm. In the IO cost model, each "block" read or costs 1 IOP to perform, so we can reduce the IOP cost of writes by a factor of 100-1000x, but reads will still have the same # of nodes to fetch. The event logs augmenting the tree are an effective IO optimization on a B+ tree.

Creator here. As other commenters noted, this data structure only requires keys to be sortable, not hashable, and the best sorted performance we can achieve is O(log(n)).

That said, when a Cuckoo hash gets very full and bounces entries around a lot, there might be an advantage to buffering operations and choosing insertion patterns that reduce the batch's insertion time. Then again, Cuckoo hashes already perform so well for situations they're designed for, so it's hard to improve them with an event log overlay.

The code actually includes a benchmarking tool that's meant to help in figuring out this decision. Once you've selected your key size (or distribution), value size (or distribution), and backend, you can play with these factors. Intuitively, targeting "block" size should improve perf. So, 4k-1MB if you're in memory or local, 1.5k-9k if you're over the network (and depending on configuration).

I did some work to split nodes based on size rather than number of children, but that requires accurate & fast size estimation of the decompressed objects, which isn't possible in general.

Indeed that would.

Creator here. You could use this from Java using the Clojure API for Java; however, many of the extension hooks use Clojure protocols. I would recommend writing a shim to Java for your particular application, so that your data types are represented in the way you want.

That is very cool! When you end up doing reads, do you compute all the pending writes along the path from root to leaf, and then run queries on the projection?

Creator here. There's no visualizations of this yet, but I'll be speaking about it this year at Strange Loop. For that talk, I'll be creating visualizations, so stay tuned!

Creator here. I would absolutely agree with this, but let me shed a bit more light to clarify: the underlying idea of B+ trees with inline caches is not patented (or maybe it was, but a long time ago?). Tokutek's patents are all focused on the methods they use to achieve concurrent operations on a single tree--they have a very interesting & novel locking protocol.

The Hitchhiker tree completely avoids their patents, since it makes very different decisions in order to become purely functional.

I wrote a similar project to this in Clojure, called Piplin: http://www.piplin.org. I worked on it for a year, and did some interesting things to enable REPL-driven FPGA development, but over time my interests shifted to macro-scale systems.

Hey HNers! One of the authors here, happy to answer any questions.

I think they've improved a lot WRT fixing problems--we had a chat with them after some issues with Datomic in production, and since then (6 months ago) we've had every problem we've discovered get fixed very promptly, and Datomic's continued to scale for us.

You can watch a talk I gave about how we use Datomic at Two Sigma to manage our cluster's state: https://www.youtube.com/watch?v=YHctJMUG8bI

It's been a great experience using it, and I'd be happy to answer any questions.

I lived in a building where one of the tenants full-time rented out their unit on AirBnB. The "guests" would tag the elevator, make noise, and trash the hallways. Also, it felt very unsafe when a large group of 4-8 people would be crammed into a 1br apartment, and they'd be drunkenly stumbling through the otherwise quiet building.

Another problem is that even if you report that tenant, if they figure out who reported them, they may take revenge before they're evicted, since eviction proceedings take so long.

They're based on Raft--that's not a consensus protocol that's designed for multi-datacenter operations. I suspect you'll have reliability and throughput issues fairly quickly, just as you see with multi-datacenter zookeeper.

The solution Google uses for this kind of problem: multidatacenter transactions are rare, so they're not optimized for latency (instead for reliability), and they tend to use 2PC, as it's easier to get right with unpredictable WAN latencies.

I am interested in Clojure bindings for spark!

I think that this article shows a very interesting application of a technique known as “derandomization”. Usually, derandomization is when you take a randomized algorithm and remove all sources of randomness. In this application, we see it only partially derandomized, to great effect: copysets improve reliability by reducing overall randomness, but still leverage randomness to approximate the solution to an NP-complete problem.

I wonder if other algorithms would benefit from partial derandomization?

Another interesting solution is to use a functional database, like Datomic. Since the database looks like a giant timeseries, you have an implicit versioning built into the database.

If OpenSCAD isn't powerful enough for you, there's a Clojure wrapper that lets you leverage Clojure to generate SCAD code: https://github.com/farrellm/scad-clj. OpenSCAD automatically re-renders the model when the file changes on disk, so you can essentially have a 3D modeling REPL with this setup.

I have been working on this problem as well, by writing a system that allows you to compile Clojure to FPGAs. I'll be giving a talk on it at Clojure West: http://clojurewest.org/sessions#greenberg

</shamelessplug>

I am talking about Tim Pope. I have forked his code and renamed it, but instead of the community helping me, I've received a lot of negative feedback about "fragmenting the community" for trying to maintain and evangelize a non-sexist version of the plugin. It is difficult to continue in the face of so little support, but I believe in what I'm doing, and all of my male and female developer friends agree with me.

What do we do about less overt sexism? For instance, there's a popular developer who writes useful plugins named after genitalia and sex acts. I find his code useful, and I've asked him publicly and privately to choose nonsexual names for his code, but he and his users see nothing wrong with this. Even consider the "weinre" project that's on the frontpage right now. "Get your weinre out"?!

His assertion is that it's not sexist if his projects are called "testicle" or "foreplay", since those words aren't intrinsically sexist. How do we, as a community, emphasize that sexuality and development can't mix if we want women to feel comfortable, given that they're currently a minority?

Where are these functional compilers developers? I am passionate about functional languages and compilers research, but feel siloed off after I left academia.

When I was in high school, I only managed to skip one math class. I was forbidden from taking AP physics without first taking non-AP physics, and the school was unwilling to work with me so that I could take classes at a local college (i.e. I wouldn't graduate because they wouldn't help me make the schedule work).

This was at a small, elite private school.

Does riak support range queries?

It seems like a solution to getting more performant, lower overhead GC would be to allocate GC pools that contain only a specific kind of object, and then generate specialized code to mark/sweep those pools (since you could elide the object headers, since everything in the pool is the same time. These pools could be mananged by a GC-pool GC, so that as new object types were created and destroyed, their pools would get allocated and garbage-collected.

Are there any systems that currently do this?