And while this is truly unimportant, my experience with bay area startup stacks is that Redis has very thoroughly supplanted Memcached for most use cases. Though most still have a memcached cluster or two.
That being said: 90% of software development in this world isn't done at tech companies and startups. So from that perspective, that stack is interesting.
(Not that I care about starting the holy war of X vs Y, just out of curiosity why)
You have a point regarding your last statement. Perhaps I've been here far too long to notice more of the 10% and less on the 90% :)
... which is true ... last I read someone is making almost $1M revenue developing Windows desktop app in 2012 and another company is making $60k/monthly revenue developing BB apps using in-apps Ads. I think I'm going to sign-off on HN and go to the other side... :D :D :D
Redis offers persistence, set operations, namespacing, you can delete multiple entries with wildcards...
You can't mix and match (you can theoretically)
Let's say you began with Django, right? Or there was something already ready in Django.
And then you begin to see the warts. But ok, you keep churning along.
And the more you churn the more of a specialist in the deficiencies of each technology you become. Like the fact that Django's ORM runs like a dog.
Or see all the "we moved to MongoDB and we regret it" discussions
From that list, there are two technologies I would recommend strongly (if you know what you are doing): nginx and Redis
The rest needs to be handled with care. And Redis is very powerful if you know how to use, but it's easy to go the "lazy way" with it, and it will be fast, but not as fast as it can.
... as in: check the output of SQL queries constructed by Django ORM and tweaked it in your Django Model layer such that the resulted SQL query will be tuned for performance?
Or at the very least, shouldn't Django ORM at least provide a way to retrieve data with "filtering" as optional parameters? (get only a few columns, but not all..)
If you're reading "just tables" without, or with simple relations and conditions, it's ok (because, as you pointed out, that's basically SELECT with)
The problem is when for example you have inheritance, or moderately complex relations.
Then you'll see Django spamming your DB with requests and the DB may be fast but the operation will be slow because of the sheer number of requests.
So yeah, in a sense you can optimize for it, or use SqlAlchemy (which is good, but it has a different philosophy than the Django ORM in the way it's used)
My experience is heavily in Java (JPA2 and Hibernate) and less of Rails (simple/moderate apps). Typically an ORM provides a way to handle custom queries but still help maps the result to the Java object model (which helps a lot vs writing getter/setter :)).
I don't know how people down south in Silicon Valley design their model (especially young scrappy startup) but I have a slightest doubt that they go that far (advanced/complex). It's not like startup start with "analyzing requirements" and move on to "modelling session" :) => they just go ahead and write code.
So in theory, the data model shouldn't be complex enough to warrant edge-case.
Use the tools to launch faster, then optimize.
Though I've had to work around some of Rails defaults for my use cases, there is no doubt that without it we'd not have been able to launch and iterate so quickly.
There isn't anything very revolutionary about their stack by itself. FB didn't buy them for their technology... they could have replicated that on their own.
If they want to be talking about infrastructure, the story of using common tools at high volume is more interesting that just what tools...
However, is it not reasonable that would someone not consider node.js, as web stack as well?
I will agree the focus is more towards backend and asynchronous API's traditionally, but the amount of front-end/UX orientated modules are growing every day.
Not a big fan of node.js (or JavaScript for that matter) and probably never will so I can't comment much.
I think by now most startups, YC or not, in Silicon Valley will pretty much have a similar setup:
1) Choose the main web-stack (Rails or Django)
2) Choose the API framework (node.js, or something else)
3) Memcached for caching (or some NoSQL)
4) A message queue (ZeroMQ, RabbitMQ, or something ...)
5) nginx, HAProxy, Varnish, (or similar technology)
6) Hadoop for map-reduce (only if you need to go that path...)