One of the reasons I think people still use Spring is that XML configuration files don't require recompilation. I think that to address the Scala developers or community need to make it incredibly easy for you to run Scala scripts as part of your application. This will then allow people to use Scala like a dynamic language and allow them to deploy Scala configuration without needing to recompile.
Also, I think work needs to be done in the community to document accepted design patterns one can employ to wire together your application in Scala in a way that solves all of the use cases Spring configuration is currently used for. This, combined with making it easier to run dynamic Scala, and people will never feel the need to turn to Spring again and the world will be a better place.
As we have become more familiar with the language, FP and the Scala idioms, we have definitely become less comfortable with our Spring "legacy". Initially, we felt that @BeanProperty annotations and setter injection saved us some boiler plate, but now most will shudder with having uninitialized vars. Constructor injection is somewhat better, but the XML DSL of Spring is still ridiculously verbose. Luckily, this doesn't bother us much in the day-to-day work, we spend most of our writing idiomatic Scala.
As our platform and the entire Scala ecosystem and libraries have evolved, the Spring and JEE "legacy" has become much less prevalent in our system than it was originally. We use a pimped version of Spring JDBC, Spring contexts for wiring, a Servlet container, but that's about it. In fact, we could probably easily rewrite the whole Spring config in Scala and drop most of the Spring deps.
I couldn't agree more with you in that the us in the Scala community really should come up with an accepted way of handling configuration and wiring. Having worked with more than a few Scala libraries, I can definitely attest that the plethora of configuration styles used can be a pain to manage (and dependencies -> configgy-nologgy, anyone?).
We regularly talk about this topic in the NYC Scala community, but we haven't come up anything good yet. Personally, I strongly believe that dependency injection is the way to go and that singletons and factories (which are fairly common in Scala libs) are evil. Most long-time Java devs will agree that we've been down that road before (gotta love JNDI)... That being said, we did not adopt Scala to fight for status quo, so we'll keep an open mind.
A similar-sized ad network, CPX Interactive is running ad requests on InfiniGraph: http://www.youtube.com/watch?v=88HCKQ73nFU&feature=relat...
Seems like graphing engine would give you a lot of native search / lookup functionality for free.
Other parts of the system have very different requirements and yes, we are considering graph oriented databases for our cross-device analytics product.
Having the transcript is a really nice touch. It's much faster to read than listen. I hope you can keep that up, though I realise transcription takes a lot of time.
Curious to hear if people benefit from the mp3s, too, and to see if we get many click-throughs there.
Reading it again, my comment while intended to be flippant just came out as churlish - apologies for that, and thanks for sharing this information!