HNHacker News
TopNewBestAskShowJobs

emin_gun_sirer

201 karma · joined January 16, 2013

submissionscomments
emin_gun_sirer··on You Might Be A Data Radical
Absolutely spot on. But there is no reason why the translation from the user's query into a series of data accesses cannot happen in the front end. In many ways, NoSQL is a reaction to the poor job RDBMSs were doing in the front end. Everyone has seen the cases where AWK programs on desktops could outperform expensive Oracle servers, and that's mostly because they enable the user to put to use what they know of their specific data and their access patterns.

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.

emin_gun_sirer··on You Might Be A Data Radical
I'm the "radical" author of this post. It expands this other post (http://hackingdistributed.com/2013/03/07/partition-tolerance...) that busts some commonly propagated myths about partition tolerance in data stores.

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.
emin_gun_sirer··on The Principled Documentation Manifesto
Interesting. There are certainly different kinds of assumptions and invariants. I like the idea of separating them by local vs. global scope; the latter are underdocumented.

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.

emin_gun_sirer··on The Principled Documentation Manifesto
Thanks, fixed!
emin_gun_sirer··on The Principled Documentation Manifesto
Very true. I get wordy when I'm pressed for time. If you write a new, simpler, easier version (Gideon's?), I'll put one in every hotel room.
emin_gun_sirer··on The Principled Documentation Manifesto
I wrote this, to turn my frustrations about the state of NoSQL documentation into something positive. I didn't think it'd get HN'ed so quickly. I look forward to suggestions for new gospel.
emin_gun_sirer··on Trickles - Stateless High Performance Networking
Everything that the server pushes to the client is MAC'ed. If a client were to tamper with, say, the inode number, the MAC check would fail. The client continuation can optionally be encrypted and timestamped as well.
emin_gun_sirer··on Trickles - Stateless High Performance Networking
I just noticed that this work got linked from HN today. This is my PhD student Alan Shieh's work, jointly with my colleague Andrew Myers. I'm surprised to see it here, as we did the work back in '05 or so. But it was a lot of fun and I think it still represents the extreme point in pushing state out of the server to the client side.

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.

emin_gun_sirer··on Broken by Design: MongoDB Fault Tolerance
I not only read but quoted the manual, in parts of the article that you evidently skipped. I also described why SAFE and FSYNC_SAFE, aren't. I also described why getLastError doesn't work when pipelined or multithreaded.

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.

emin_gun_sirer··on Broken by Design: MongoDB Fault Tolerance
Something tells me that you did not read the article.
emin_gun_sirer··on Broken by Design: MongoDB Fault Tolerance
The blog is new, and we had a redirection loop in the Nginx configuration that took the site down for a while. Should be fixed now.
← PreviousPage 2 of 2