Questioning the NoSQL developer productivity myth

I hope this excellent article by +Kelly Sommers ( @kellabyte ) helps dispelling the (still ongoing) silliness about programming to NoSQL being more productive than to SQL databases:
This recent presentation about the 1st ThoughtWorks Radar of 2012, by Sam Newman ( @samnewman ), although quite interesting (and contradictory, and questionable... but sure interesting), added a bit to that "NoSQL being more productive" silliness:
Again, learning a NoSQL API might be easier than learning SQL, but SQL is a farking DSL, a good one at that and, as such, gives you a lot of power.

During the Jurassic period when SQL databases did not fit into Personal Computers I did work a lot with NoSQL databases. I sure remember how painful it was and how I got much more productive with the SQL ones.

If you do not think a DSL is needed to make programming data manipulation tasks more productive, just take a look to what happens with Apache Hadoop and Pig Latin:
Or UnQL (which sounds like a still-in-denial name):
Yes, one size does not fit all but SQL databases - or just NO databases at all (*) - are much more productive for most jobs than NoSQL DBs.
(*) It is often possible to just keep all the data in memory and serialize it all as one big doc.

And even after this NoSQL-later-years trend started, this discussion, about history repeating and lessons from the past not being learned, is already ongoing at least since 2009 (check referenced articles too):
If you are a NoSQL fan and think I am just not aware of NoSQL databases usefulness, please reconsider:
What is new about NoSQL databases is NOT the absence of a query language - that is very old news.

What is new about the new vague of NoSQL databases, is the way some of them are targeting Big Data and the new strategies they use to deal with redundancy and consistency, especially for high volume + high concurrency scenarios.

Having a query language or not is mostly orthogonal to consistency models - although it might somewhat affect the query language just like it affects the whole database use model.

What I am questioning here is the claim about higher programming productivity of NoSQL databases for those most common cases where the SQL databases or no database alternatives would do.

Remember: most people are neither building another Twitter nor another Google.

So, again, what I am having trouble to understand is:
  • How is NoSQL so much more productive for others than the alternatives mentioned above? That completely contradicts my experience.
  • Why are query languages (with some SQL likeness) popping up if NoSQL database APIs are the real deal?
  • Or how is this silliness still going on since 2009?
Sorry if I am coming trough a bit rough, but I sure am a bit opinionated about the NoSQL vs. SQL theme.


Logging (and Exception Handling)

During the last year, the exception handling and logging themes have been quite recurrent, even leading to a talk I gave at Codebits 2011.

Since the theme is still coming back to me, both at work and online (this time via Sergio Bossa), I decided to dump here some of the information I have been collecting and producing.

For starters, this is an enriched version of the slideware I used for the above mentioned Codebits talk:
Exception+Logging=Diagnostics 2011
(Other of my presentations can be found here.)
As with my previous presentations, if you download it, you will find some extra information (including the URLs of the most important sources I used) at the slide's comments. (I am sorry, but SlideShare does not seem to be able to display the comments from the Powerpoint format I used this time.)

Anyway, my favorite articles and presentations about logging are currently here:
Naturally, I do not agree with everything written in the above mentioned articles. Well, give it some time and I might not agree with everything I wrote on my own slideware...

I believe, however, these articles to be useful fuel to help anyone, with enough critical thinking, to build their own paths.

Having to talk about logging helped me to step further away of the self centered view most developers seem to have about logging. I had already taken a few steps out of there by working together with sysadmins and other colleagues, supporting the larger applications I worked on and sharing their pains. But making a presentation always forces me to have a much deeper reflection about the presentation's subject.

That is why my slideware focuses on the communication role of logging, as do several of the above mentioned sources.

Instead of developing this blog entry further, just read with attention the above articles. Believe me: must of us have a very bad logging communication... Poor sysadmins!