So, in between "writing a program for each query" (which I agree is a non-starter in some settings) and "SQL is the one and only interface" lies an exciting space of opportunities.
201 karma · joined January 16, 2013
So, in between "writing a program for each query" (which I agree is a non-starter in some settings) and "SQL is the one and only interface" lies an exciting space of opportunities.
But the part that I really wanted to emphasize, and I worry might get lost in the surrounding discussion about partition-obliviousness, is the following:
NoSQL has the potential to supplant RDBMSs and capture the
bulk of the database market. The "daddy knows best"
attitude that RDBMSs bring to data management, the way they
strip all information that the developer had about her data
and force her to write a declarative specification of what
she wants, only to try to then come up with an efficient
evaluation plan in the query optimizer, all reflect a
klunky aesthetic to system design that the lean and mean
NoSQL movement can and will supplant. NoSQL is to RDBMSs
what Unix was to Multics.
My group is working on bridging the gap between NoSQL and traditional RDBMSs (with a second-generation NoSQL store called HyperDex that provides strong guarantees), and so are others. And meanwhile, RDBMSs are trying to retrofit NoSQL features. Overall, there is a big revolution afoot in data management, and it's an exciting time for system builders and application developers alike.Much as I like, say, the javadoc format, it channels devs into "function by function" thinking and documentation, and global assumptions and global invariants, typically do not get treated adequately.
So, I'll try to answer some of the questions here and provide some of the insights and background that do not appear in academic papers.
The intuition behind trickles is that the packets act like continuations, the same continuations you may be familiar with from programming languages like Scheme. Instead of a server holding state, it pushes that state to the client. To get service, the client presents the continuation to any server host, which can reinstate its state, and provide the service.
Since the servers are stateless, you can direct a client request to any host. This kind of handoff is, let's just say, not easy to do when you have stateful TCP connections to maintain.
Not every state machine can be converted into a format where it can run over Trickles. But I think the community was surprised to see that something as complicated as TCP could be trickle-ized.
It's hard writing for the "tl;dr"-generation (as this exchange demonstrates -- there was a time when it used to be embarrassing to have someone say the same thing twice to you in a discussion).
I'll have a separate blog entry on why REPLICA_SAFE is broken, and how the setup you outlined can lose data.