Let me say this, from my experience with Redis, here the real starts are the early adopters. I think that the most important ingredient for any artistic, scientific, technological progress is courage, and early adopters of new technological solutions have a lot of it.

They are not afraid of using something less than one year old, while all the rest is trying to do the safest choice for storing their data. Are they crazy? No, just they are people able to meter a solution without requiring somebody else, or the mass, putting a that's-safe badge.

Probably the best thing about NoSQL is that once there are high performance and scalable data storage engines out there, it will prompt the SQL vendors to improve the performance and scalability of their products.

There are few, if any inherent reasons SQL can't scale and where there are, like ACID over the network, those features could be disabled to enable scale.

I believe it will be easier for traditional SQL databases to achieve the scale of NoSQL than it will be for NoSQL to figure out how to do all the things SQL already does.

In a way, NoSQL could be considered a form of premature optimization. Due to this, NoSQL will solve very large, but esoteric problems in the super high scale space, but fall short when complexity is needed. One thing SQL is good at is reducing the complexity around data management at the developer/programming level and NoSQL flips that, putting all the work in the hands of the developer for things like aggregates, acid, integrity, consistency, etc.

I suspect a lot of early NoSQL adopters who choose it because it lacks the complexity of relational databases will find themselves flummoxed when they are faced with solving some of the problems caused by features missing in NoSQL databases.

In my experience, the average coder dealing with SQL is flummoxed by non-trivial problems (even those that have fairly well-understood solutions) and wind up hacking in messes anyway. Heck, it's 50-50 whether they normalize their data or use transactions in the first place.

But I don't think you can fairly judge specialized tools based on the likely experience of coders using it outside their experience.

The more I use SQL, the more I like it. Modeling certain kinds of data in RDBMS can be tricky, or near impossible, but one you get the schema down, the queries fetch and insert the data are usually straightforward.

SQL's only real problem in my opinion is that it doesn't provide many good facilities for handling fluctuating schemas.

I was just pointing out that it's unfair to judge a tool based on how it might be used by people who don't really understand what it is and what it does.

SQL is a great tool and there are many, very good reasons that it rose to prominence. It just isn't the only tool and it isn't right for every problem.