Erlang and Cloud Computing: A Fine Pair Indeed

        
        
        
        

         
         
         
         receive_msg
         
         
         
         ()
         
         
         
         ->
        
        
        
        
        
        
        
        

         
         
         
           
         
         
         
         receive
        
        
        
        
        
        
        
        

         
         
         
             
         
         
         
         {
         
         
         
         message
         
         
         
         , 
         
         
         
         Text
         
         
         
         } 
         
         
         
         ->
        
        
        
        
        
        
        
        

         
         
         
               
         
         
         
         io
         
         
         
         :
         
         
         
         format
         
         
         
         (
         
         
         
         "Someone told me this: 
         
         
         
         ~s~n
         
         
         
         "
         
         
         
         , 
         
         
         
         Text
         
         
         
         ),
        
        
        
        
        
        
        
        

         
         
         
               
         
         
         
         forward
         
         
         
         (
         
         
         
         Pid
         
         
         
         )
        
        
        
        
        
        
        
        

         
         
         
           
         
         
         
         end
         
         
         
         .
        
        
        
        
        
        
        
        

        
        
        
        

Libraries Ready Made for Distributing Load

Erlang comes with a whole host of libraries and modules built in support of its primary goal as a massively concurrent programming language. These libraries are important enough that Erlang is often referred to in conjunction with them as “Erlang/OTP”.

1. Mnesia – “is a distributed DataBase Management System (DBMS), appropriate for telecommunications applications and other Erlang applications which require continuous operation and exhibit soft real-time properties.” (ref) I’m sure many of you are saying to yourselves, “I can distribute load with MySQL so what’s the advantage?”. The advantage comes from being able to add a table copy to a new node as easy as:

    

   
           
           
           
           
   
            
            
            
            mnesia
            
            
            
            :
            
            
            
            create_schema
            
            
            
            ([
            
            
            
            somenode
            
            
            
            ]),
           
           
           
           
           
           
           
           
   
            
            
            
            mnesia
            
            
            
            :
            
            
            
            add_table_copy
            
            
            
            (
            
            
            
            Tab
            
            
            
            , 
            
            
            
            somenode
            
            
            
            , 
            
            
            
            Type
            
            
            
            )
           
           
           
           

   
   view raw replicate.erl This Gist brought to you by  GitHub.
     That’s pretty amazing when you consider what it means for easy data distribution. Mnesia is not without its drawbacks though. Most importantly it wasn’t designed to store enormous tables like SQL databases. In fact it has a 2gb table size limit for disc_only_copy configuration of tables, but the in memory and memory and disc table copies are only limited by ram size. Also, with more than 8-10 nodes the amount of network communication may begin to inflict performance degredation. (Big thanks to comment poster Gleb Peregud, for both of those tidbits).
2. gen_server – gen_server is a module that provides an interface that allows your code to take advantage of much of the OTP goodness like process supervision and logging without lifting a finger. Supervision itself is enough to get excited about, as it allows safe and reliable process topologies to be created with ease. Processes monitoring and restarting other processes sounds like a recipe for reliability when implemented correctly.

That’s only two notable examples from an enormouse set of libraries all targeted at reliable distributed infrastructure. Most of which have been proven in the harsh environments mentioned earlier.
Alternatives to Erlang
This is a big enough market that there are bound to be a lot of solutions out there for the problem of easy node addition to applications, and it only takes one look at the comments in one of Yariv’s posts ( Erlang vs Scala ) to see there are a lot of opinions.
At this point I have to confess I can’t really comment with full knowledge on how something like Scala stacks up to Erlang in this specific scenario. What I do know is that Scala runs on the JVM, which is great from a stability perspective but may not be as stellar for massive concurrency because of the way JVM handles threading with real system threads. Much the same, the CLR from Microsoft uses real system threads, but has the ability to use something akin to green threads (reference?). Clearly using either of these has some great advantages, like access to Java libraries (though many argue this might make concurrency more difficult), so it’s not as cut and dry as Erlang > All.
Clouds on the Brain
However you choose to tackle it, the cloud is growing in popularity and importance when considering web applications. Looking to the future, even the most basic hosting plans may consist of on demand hardware for our disposal, and then it will really be up to you how you want to utilize the resources you have to better serve out your apps.
Let me know what you think in the comments!