

How did SQL get so popular? - mattmichielsen
http://therealadam.com/archive/2009/06/01/how-did-sql-get-so-popular/

======
seldo
A more interesting question to me is "how did SQL get so _unpopular_ all of a
sudden?" It seems to me it went like this:

1\. modern programming frameworks all abstracted away SQL because people found
it hard to understand

2\. SQL written by ORM layers in these frameworks is slow. So people decided
this was because RDBMS are slow.

3\. So people decided to stop using RDBMS and use object-oriented data stores
instead (which is faster, unless you have relational queries, which a large
number of simple web applications do not)

4\. Then when they started needing relational queries again, they started
building complicated custom layers on top of their object stores to handle
this

I figure sometime in the future somebody will publish a "brilliant" article
called "Save yourself thousands of lines of object-manipulation code... by
using RDBMS!" and suddenly SQL will be "popular" again.

I'm the first to admit that the default approach to web development for the
past 10 years has been "slap all your data into mySQL, then start writing
code". It works in a very, very large number of cases, but it's not super-
efficient. It never claimed to be. It was just really easy and quick to write.

Now tools are growing up that let you solve these sorts of problems without
using RDBMS, and that's great: the huge number of apps that don't need RDBMS
can stop using SQL, and let us SQL junkies get on with our lives :-)

~~~
xenophanes
> 1\. modern programming frameworks all abstracted away SQL because people
> found it hard to understand

No. Not because it's complicated. Because they wanted higher level facilities
for getting/setting data. In other words, they put in abstraction because
abstraction is good, not because they are dumb.

~~~
kragen
Although SQL sucks, it is a higher-level facility for getting and setting data
than ORMs are. ORMs don't exist to abstract away SQL; that is
counterproductive. ORMs exist so you can store your objects in a relational
database, which is not a problem you can solve in SQL.

I suspect that a big part of the problem with SQL is that it's _too_ abstract:
it is both hard to predict how fast a query will run and hard to predict
whether the query will continue to run fast as the database changes. A big
part of the appeal of things like memcached and Redis is that their
performance is not only fast, but also _predictable_.

~~~
gnaritas
> it is a higher-level facility for getting and setting data than ORMs are

No, it's a higher level facility for querying data when you want different
result sets back randomly, it sucks most common operations of inserting or
updating data.

Forcing me to write a very long statement to insert a row isn't in any way
more abstract that saying anObject.save().

SQL continually forces one to write the same boring code over and over. As
soon as you start automating the generation of the boring bits, you've started
to build an ORM. ORMs exist because programmers get tired of writing the same
code again and again.

While SQL is good at what it does, it doesn't do the thing programmers need
done most, which is store data structures easily without making them write a
bunch of mapping code to translate it first. SQL isn't confusing, it's just
frustratingly boring and repetitive.

~~~
kragen
In the comment you are replying to, I said, "ORMs exist so you can store your
objects in a relational database, which is not a problem you can solve in
SQL." It sounds like you're saying the same thing?

------
silentbicycle
The post's argument appears to be that SQL (by which he means relational
databases, as noted in the comments) are popular because implementing ACID is
too much trouble, and because dealing with random file access is confusing.

It sounds like it _never even crossed his mind_ that the relational model is a
good fit for some problems. Wow.

~~~
davidmathers
_It sounds like it never even crossed his mind that the relational model is a
good fit for some problems._

98% of programmers think the word "relation" has something to do with links
between tables. I doubt the OP has ever even heard of a concept called "the
relational model".

~~~
silentbicycle
Touché.

------
StrawberryFrog
My first thought was "Popular compared to what? What was the alternative?"

I was expecting to see hierarchical databases, OODBs and alternate query
languages mentioned. The claim for "Distaste" for SQL is odd and vague. I
agree with the first point - "Relational databases are ACID and that's
powerful" but I ask "so what, where's the distaste?"

People who know a bit about RDBMSs know that they do a lot of heavy lifting
for you. Is the point that a younger generation don't know that? What are they
teaching kids in college these days?

Massively parallel data storage systems are in vogue now, bacause of the very
the few very popular web apps that need to scale a lot horizontally, and SQL
databases don't really deal with that. But that's not "How SQL got popular".
Maybe it's why some have forgotten.

~~~
prpon
I agree with you here. Is there any one here on HN who is not comfortable with
SQL? However, the increasing usage of frameworks such as
rails/grails/hibernate/JPA makes it easier to access data without having to
worry about SQL until something breaks.

The prime time for SQL has long been over, it is a necessary tool most of us
don't think too much about.

~~~
silentbicycle
Relational databases are designed for dealing with huge collections of data.
Huge like terabytes. (This is, of course, their very reason for existence.)

Every time a framework pulls a big set of data across the wire to do a local
calculation on it (a for loop summing a list of values, for example), it's
doing a _completely unnecessary round trip_ to do (probably in PHP or Ruby, no
less) _a task for which the database has already been specifically optimized_.
It could have done all the calculation during the same pass it took to select
the records and just sent the answer instead.

Frameworks obscure this.

Just a thought.

~~~
kragen
Relational databases were invented in 1970. The basic design for most of the
popular RDBMSs today (Oracle, DB2, Ingres → Postgres, Sybase) was created in
the 1980s. In 1982 you could buy a 5MB Winchester disk for US$2000. A terabyte
of disk therefore would have cost US$400 million.

This is not what relational databases were designed for.

Otherwise your comment is correct.

~~~
silentbicycle
Hence, "are designed", not "were designed".

Interesting data point, by the way. I have a little USB flash drive that
stores 4 GB. It was about $10. That's probably more disk storage than existed
_in the entire world_ until Y years ago -- any idea what year?

------
simc
SQL is popular because it was the query language that was available in the
Oracle and IBM relational databases, which were the first relational database
products to come to market. SQL subsequently became an ISO standard.
Eventually all relational database vendors switched to SQL. Other DBMSs
(Ingres, Informix, Postgres) originally used QUEL which was thought by many to
be superior to SQL eventually switched as SQL became dominant/the standard.
(Although QUEL can still be used with Ingres). There may be other reasons, but
I think that in large part these are the reasons why SQL is dominant today.

Relational databases became popular because the declarative high level query
language was less time consuming to write queries in than earlier non-
relational database.

SQL is far from the perfect query language though. It's syntax is often
bizarre and confounding, and has many non relational extensions (column
ordering, duplicate tuples in a relation).

~~~
azgolfer
Re: non relational extensions I believe it was Ted Codd who said "No real
application runs in third normal form".

The relational model is great, and it's important to remember that the things
that make it great are that it is simple, dynamic, easy to understand and
helps ensure you get correct results. IMO the two most common mistakes people
make are being overly worried about breaking the model where necessary, and
conversely, not realizing the benefits of things like human readable keys.

------
wglb
There seems to be some confusion between SQL, ACID(Atomicity, Consistency,
Isolation, Durability), and a RDBMS. And it would have been nice, as
StrawberryFrog notes to see these concepts compared to OODB and other query
languages.

Missing is the concept that SQL is really quite powerful.

------
bayareaguy
SQL didn't really become popular until companies started believing in the
benefits of moving their applications from homogeneous mainframe and
timesharing systems to distributed heterogeneous client/server networks.

