Soliciting Advice: highly concurrent, available, non-blocking server

I’m seeking feedback on a language or platform for a highly reliable and low latency web service / application.


Bottlenecks in a web service are usually related to data retrieval and storage, and eventually bandwidth and latency. 
Highly concurrent, lightweight threads provide options for reliability, load distribution, and perceived performance that would otherwise not be available. 

General Requirements 

  • Easy to use (build, deploy, monitor)
  • Plentiful external, stable, pre-integrated Libraries
  • Use case: distributed, non-blocking web services
  • Quite a bit of message and job queueing 
  • multiple databases , caching

Top candidates

Very incomplete list of pros and cons, but some of my thoughts, highlighted. 

  • Scala
    • pros
    • cons
      • new language syntax, paradigm learning curve
      • doubts about JVM memory efficiency and stability as resources are constrained
  • Server Side Javascript – via  node.js  
    • pros
      • redis integration for caching
      • fast, lightweight, easy language. 
      • some custom js would be portable to browsers (coolness)
    • cons
      • very new
      • performance
      • not as many external libs?
  • Tornado
    • pros
      • Python
        • as many libs as Scala
    • cons
      • narrower use cases
      • performance

 Would love comments, but a more complete list is presented in a survey:

3 thoughts on “Soliciting Advice: highly concurrent, available, non-blocking server

  1. Although there’s nothing "out of the box" or turnkey about the implementations I’ve been playing with – I’m looking at pacemaker ( for general purpose load balancing and redundancy/fail-over. Most of the applications I write are in python at this point so I generally implement daemons and long running processes for async activities – daemons monitor changes in the database for "jobs" and share the heavy lifting over a range of hosts in the cluster. The single point of failure in my case is the shared filesystem (zfs pool exported via nfs), and the cluster head node itself.

  2. @theomn – thanks for the comment. Pacemaker reminds me of Zookeeper – and your use case reminds of how I’d use Hadoop. Are you processing rendering jobs for 3D/Video?

  3. Mmmhmmm, well, more like pre-processing. The work I’m doing with this is for gathering source materials from the user before packaging and shipping off to our grid for the _real_ processing.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s