Multicore central processing units (CPU) are becoming the norm. Programming multicore systems challenges popular imperative languages that require state to be shared among threads. Vinoski suggests switching to Erlang, a functional language that avoids shared state. After a motivating introduction, Vinoski gives a bit of Erlang history and a few general paragraphs describing the language. He quotes statistics stating that his machine created one million Erlang processes in 0.51 seconds, but only 7,044 C++ threads in 1.3 seconds, before encountering a lack of resources.

The only example of code is a power function that appears first in the usual recursive version and then in a concurrent version, which creates one thread for each exponent. While this latter version is an interesting example of Erlang constructs, it is not appropriate to illustrate concurrency. The purpose of using processes is to divide the computation into parts, with each process contributing to the computation. In Vinoski’s example, the processes just return the value they are passed, and all of the computation is done by the initial process. Predictably, the results show the simple recursive power function performs better until computing 50 to the 11,500th power, and the reason probably has more to do with the overhead in each case rather than any effect of concurrency. A much better example would have been a sequence of computations of a Fibonacci number first using the recursive function and then using concurrent processes.

Apart from this example, the paper shows that Erlang is well worth investigating as a good solution to a difficult problem.