I have a debian box running tasks with celery and rabbitmq for about a year. Recently I noticed tasks were not being processed so I logged into the system and noticed that celery could not connect to rabbitmq. I restarted rabbitmq-server and even though celery was not complaining anymore it was not executing new tasks now. The odd thing was that rabbitmq was devouring cpu and memory resources like crazy. Restarting server would not solve the problem. After spending couple hours looking for solution online to no avail I decided to rebuild the server.

I rebuilt new server with Debian 7.5, rabbitmq 2.8.4, celery 3.1.13 (Cipater). For about an hour or so everything worked beautifully again until celery started complaining again that it can&#39;t connect to rabbitmq!

    [2014-08-06 05:17:21,036: ERROR/MainProcess] consumer: Cannot connect to amqp://guest:**@127.0.0.1:5672//: [Errno 111] Connection refused.
    Trying again in 6.00 seconds...

I restarted rabbitmq `service rabbitmq-server start` and same issue gain:

rabbitmq started again swelling up constantly pounding on cpu and slowly taking over all ram and swap:

    PID USER      PR  NI  VIRT  RES  SHR S  %CPU %MEM    TIME+  COMMAND
    21823 rabbitmq  20   0  908m 488m 3900 S 731.2 49.4   9:44.74 beam.smp

Here&#39;s the result on `rabbitmqctl status`:

    Status of node &#39;rabbit@li370-61&#39; ...
    [{pid,21823},
     {running_applications,[{rabbit,&quot;RabbitMQ&quot;,&quot;2.8.4&quot;},
                            {os_mon,&quot;CPO  CXC 138 46&quot;,&quot;2.2.9&quot;},
                            {sasl,&quot;SASL  CXC 138 11&quot;,&quot;2.2.1&quot;},
                            {mnesia,&quot;MNESIA  CXC 138 12&quot;,&quot;4.7&quot;},
                            {stdlib,&quot;ERTS  CXC 138 10&quot;,&quot;1.18.1&quot;},
                            {kernel,&quot;ERTS  CXC 138 10&quot;,&quot;2.15.1&quot;}]},
     {os,{unix,linux}},
     {erlang_version,&quot;Erlang R15B01 (erts-5.9.1) [source] [64-bit] [smp:8:8] [async-threads:30] [kernel-poll:true]\n&quot;},
     {memory,[{total,489341272},
              {processes,462841967},
              {processes_used,462685207},
              {system,26499305},
              {atom,504409},
              {atom_used,473810},
              {binary,98752},
              {code,11874771},
              {ets,6695040}]},
     {vm_memory_high_watermark,0.3999999992280962},
     {vm_memory_limit,414559436},
     {disk_free_limit,1000000000},
     {disk_free,48346546176},
     {file_descriptors,[{total_limit,924},
                        {total_used,924},
                        {sockets_limit,829},
                        {sockets_used,3}]},
     {processes,[{limit,1048576},{used,1354}]},
     {run_queue,0},

Some entries from /var/log/rabbitmq:

    =WARNING REPORT==== 8-Aug-2014::00:11:35 ===
    Mnesia(&#39;rabbit@li370-61&#39;): ** WARNING ** Mnesia is overloaded: {dump_log,
                                                                    write_threshold}
    
    =WARNING REPORT==== 8-Aug-2014::00:11:35 ===
    Mnesia(&#39;rabbit@li370-61&#39;): ** WARNING ** Mnesia is overloaded: {dump_log,
                                                                    write_threshold}
    
    =WARNING REPORT==== 8-Aug-2014::00:11:35 ===
    Mnesia(&#39;rabbit@li370-61&#39;): ** WARNING ** Mnesia is overloaded: {dump_log,
                                                                    write_threshold}
    
    =WARNING REPORT==== 8-Aug-2014::00:11:35 ===
    Mnesia(&#39;rabbit@li370-61&#39;): ** WARNING ** Mnesia is overloaded: {dump_log,
                                                                    write_threshold}
    
    =WARNING REPORT==== 8-Aug-2014::00:11:36 ===
    Mnesia(&#39;rabbit@li370-61&#39;): ** WARNING ** Mnesia is overloaded: {dump_log,
                                                                    write_threshold}
    
    =INFO REPORT==== 8-Aug-2014::00:11:36 ===
    vm_memory_high_watermark set. Memory used:422283840 allowed:414559436
    
    =WARNING REPORT==== 8-Aug-2014::00:11:36 ===
    memory resource limit alarm set on node &#39;rabbit@li370-61&#39;.
    
    **********************************************************
    *** Publishers will be blocked until this alarm clears ***
    **********************************************************
    
    =INFO REPORT==== 8-Aug-2014::00:11:43 ===
    started TCP Listener on [::]:5672
    
    =INFO REPORT==== 8-Aug-2014::00:11:44 ===
    vm_memory_high_watermark clear. Memory used:290424384 allowed:414559436
    
    =WARNING REPORT==== 8-Aug-2014::00:11:44 ===
    memory resource limit alarm cleared on node &#39;rabbit@li370-61&#39;
    
    =INFO REPORT==== 8-Aug-2014::00:11:59 ===
    vm_memory_high_watermark set. Memory used:414584504 allowed:414559436
    
    =WARNING REPORT==== 8-Aug-2014::00:11:59 ===
    memory resource limit alarm set on node &#39;rabbit@li370-61&#39;.
    
    **********************************************************
    *** Publishers will be blocked until this alarm clears ***
    **********************************************************
    
    =INFO REPORT==== 8-Aug-2014::00:12:00 ===
    vm_memory_high_watermark clear. Memory used:411143496 allowed:414559436
    
    =WARNING REPORT==== 8-Aug-2014::00:12:00 ===
    memory resource limit alarm cleared on node &#39;rabbit@li370-61&#39;
    
    =INFO REPORT==== 8-Aug-2014::00:12:01 ===
    vm_memory_high_watermark set. Memory used:415563120 allowed:414559436
    
    =WARNING REPORT==== 8-Aug-2014::00:12:01 ===
    memory resource limit alarm set on node &#39;rabbit@li370-61&#39;.
    
    **********************************************************
    *** Publishers will be blocked until this alarm clears ***
    **********************************************************
    
    =INFO REPORT==== 8-Aug-2014::00:12:07 ===
    Server startup complete; 0 plugins started.
    
    =ERROR REPORT==== 8-Aug-2014::00:15:32 ===
    ** Generic server rabbit_disk_monitor terminating 
    ** Last message in was update
    ** When Server state == {state,&quot;/var/lib/rabbitmq/mnesia/rabbit@li370-61&quot;,
                                   50000000,46946492416,100,10000,
                                   #Ref&lt;0.0.1.79456&gt;,false}
    ** Reason for termination == 
    ** {unparseable,[]}
    
    =INFO REPORT==== 8-Aug-2014::00:15:37 ===
    Disk free limit set to 50MB
    
    =ERROR REPORT==== 8-Aug-2014::00:16:03 ===
    ** Generic server rabbit_disk_monitor terminating 
    ** Last message in was update
    ** When Server state == {state,&quot;/var/lib/rabbitmq/mnesia/rabbit@li370-61&quot;,
                                   50000000,46946426880,100,10000,
                                   #Ref&lt;0.0.1.80930&gt;,false}
    ** Reason for termination == 
    ** {unparseable,[]}
    
    =INFO REPORT==== 8-Aug-2014::00:16:05 ===
    Disk free limit set to 50MB


**UPDATE:**
Seems like problem was solved when installed newest version of rabbitmq (3.3.4-1) from rabbitmq.com repository. Originally I had one installed (2.8.4) from Debian repositories. So far rabbitmq-server is working smoothly. I will update this post if issue comes back.

**UPDATE:**
Unfortunately after about 24 hours the issue reappeared where rabbitmq shut down and restarting the process would make it consume resources until it shuts down again within minutes.  

RabbitMQ (beam.smp) and high CPU/memory load issue

I have been trying to learn Erlang and have been running into some problems with ending lines in functions and `case` statements.

When do I use a semicolon (`;`), comma (`,`), or period inside my functions or `case` statements?

In Erlang, when do I use ; or , or .?

I&#39;m learning Elixir and wonder why it has two types of function definitions:

 - functions defined in a module with `def`, called using `myfunction(param1, param2)`
 - anonymous functions defined with `fn`, called using `myfn.(param1, param2)`

Only the second kind of function seems to be a first-class object and can be passed as a parameter to other functions. A function defined in a module needs to be wrapped in a `fn`. There&#39;s some syntactic sugar which looks like `otherfunction(&amp;myfunction(&amp;1, &amp;2))` in order to make that easy, but why is it necessary in the first place? Why can&#39;t we just do `otherfunction(myfunction))`? Is it only to allow calling module functions without parenthesis like in Ruby? It seems to have inherited this characteristic from Erlang which also has module functions and funs, so does it actually comes from how the Erlang VM works internally?

It there any benefit having two types of functions and converting from one type to another in order to pass them to other functions? Is there a benefit having two different notations to call functions?

Why are there two kinds of functions in Elixir?

How do I concatenate two binaries in Erlang?

For example, let&#39;s say I have:

    B1 = &lt;&lt;1,2&gt;&gt;.
    B2 = &lt;&lt;3,4&gt;&gt;.

How do I concatenate B1 and B2 to create a binary B3 which is &lt;&lt;1,2,3,4&gt;&gt;?

The reason I am asking this is because I am writing code to encode a packet for some networking protocol. I am implementing this by writing encoders for the fields in the packet and I need to concatenate those fields to build up the whole packet.

Maybe I am doing this the wrong way. Should I build up the packet as a list of integers and convert the list to a binary at the last moment?





How do I concatenate two binaries in Erlang?

If you&#39;ve bought into the functional programming paradigm, the chances are that you like both Erlang and Haskell.  Both have purely functional cores and other goodness such as lightweight threads that make them a good fit for a multicore world.  But there are some differences too.

Erlang is a commercially proven fault-tolerant language with a mature distribution model.  It has a seemingly unique feature in its ability to upgrade its version at runtime via hot code loading.  (Way cool!)

Haskell, on the otherhand, has the most sophisticated type system of any mainstream language.  (Where I define &#39;mainstream&#39; to be any language that has a published O&#39;Reilly book so Haskell counts.)  Its straightline single threaded performance looks superior to Erlang&#39;s and its lightweight threads look even lighter too.

I am trying to put together a development platform for &lt;i&gt;the rest of my coding life&lt;/i&gt; and was wondering whether it was possible to mix Erlang and Haskell to achieve a best of breed platform.  This question has two parts:

   1. I&#39;d like to use Erlang as a kind of fault tolerant MPI to glue GHC runtime instances together.  There would be one Erlang process per GHC runtime.  If &quot;the impossible happened&quot; and the GHC runtime died, then the Erlang process would detect that somehow and die too.   Erlang&#39;s hot code loading and distribution features would just continue to work.  The GHC runtime could be configured to use just one core, or all cores on the local machine, or any combination in between.   Once the Erlang library was written, the rest of the Erlang level code should be purely boilerplate and automatically generated on a per application basis.  (Perhaps by a Haskell DSL for example.)   How does one achieve at least some of these things?
   2. I&#39;d like Erlang and Haskell to be able to share the same garabage collector.  (This is a much further out idea than 1.)   Languages that run on the JVM and the CLR achieve greater mass by sharing a runtime.  I understand there are technical limitations to running Erlang (hot code loading) and Haskell (higher kinded polymorphism) on either the JVM or the CLR.  But what about unbundling just the garbage collector?  (Sort of the start of a runtime for functional languages.)  Allocation would obviously still have to be really fast, so maybe that bit needs to be statically linked in.  And there should be some mechansim to distinguish the mutable heap from the immutable heap (incuding lazy write once memory) as GHC needs this.  Would it be feasible to modify both HIPE and GHC so that the garbage collectors could share a heap?

Please answer with any experiences (positive or negative), ideas or suggestions.  In fact, any feedback (short of straight abuse!) is welcome.

**Update**

Thanks for all 4 replies to date - each taught me at least one useful thing that I did not know.

Regarding *the rest of coding life* thing - I included it slightly tongue in cheek to spark debate, but it is actually true.  There is a project that I have in mind that I intend to work on until I die, and it needs a stable platform.

In the platform I have proposed above, I would only write Haskell, as the boilerplate Erlang would　be automatically generated.  So how long will Haskell last?  Well Lisp is still with us and doesn&#39;t look like it is going away anytime soon.  Haskell is BSD3 open source and has achieved critical mass.  If programming itself is still around in 50 years time, I would expect Haskell, or some continuous evolution of Haskell, will still be here.

**Update 2** *in response to rvirding&#39;s post*

Agreed - implementing a complete &quot;Erskell/Haslang&quot; universal virtual machine might not be absolutely impossible, but it would certainly be very difficult indeed.  Sharing just the garbage collector level as something like a VM, while still *difficult*, sounds an order of magnitude less difficult to me though.  At the garbage collection model, functional languages must have a lot in common - the unbiquity of immutable data (including thunks) and the requirement for very fast allocation.  So the fact that commonality is bundled tightly with monolithic VMs seems kind of odd.

VMs do help achieve critical mass.  Just look at how &#39;lite&#39; functional languages like F# and Scala have taken off.  Scala may not have the absolute fault tolerance of Erlang, but it offers an escape route for the very many folks who are tied to the JVM.

&gt; While having a single heap makes
&gt; message passing very fast it
&gt; introduces a number of other problems,
&gt; mainly that doing GC becomes more
&gt; difficult as it has to be interactive
&gt; and globally non-interruptive so you
&gt; can&#39;t use the same simpler algorithms
&gt; as the per-process heap model.

Absolutely, that makes perfect sense to me.  The very smart people on the GHC development team appear to be trying to solve part of the problem with a parallel &quot;stop the world&quot; GC.

**[http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel-gc/par-gc-ismm08.pdf][1]**

(Obviously &quot;stop the world&quot; would not fly for general Erlang given its main use case.)  But even in the use cases where &quot;stop the world&quot; is OK, their speedups do not appear to be universal.  So I agree with you, it is unlikely that there is a universally best GC, which is the reason I specified in part 1. of my question that

&gt; The GHC runtime could be configured to
&gt; use just one core, or all cores on the
&gt; local machine, or any combination in
&gt; between.

In that way, for a given use case, I could, after benchmarking, choose to go the Erlang way, and run one GHC runtime (with a singlethreaded GC) plus one Erlang process per core and let Erlang copy memory between cores for good locality.

Alternatively, on a dual processor machine with 4 cores per processor with good memory bandwidth on the processor, benchmarking might suggest that I run one GHC runtime (with a parallel GC) plus one Erlang process per processor.

In both cases, if Erlang and GHC could share a heap, the sharing would probably be bound to a single OS thread running on a single core somehow.  (I am getting out of my depth here, which is why I asked the question.)

I also have another agenda - benchmarking functional languages independently of GC.  Often I read of results of benchmarks of OCaml v GHC v Erlang v ... and wonder how much the results are confounded by the different GCs.  What if choice of GC could be orthogonal to choice of functional language?  How expensive is GC anyway?  See this devil advocates blog post 

**[http://john.freml.in/garbage-collection-harmful][2]**

by my Lisp friend John Fremlin, which he has, charmingly, given his post title &quot;Automated garbage collection is rubbish&quot;.  When John claims that GC is slow and hasn&#39;t really sped up that much, I would like to be able to counter with some numbers. 


  [1]: http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel-gc/par-gc-ismm08.pdf
  [2]: http://john.freml.in/garbage-collection-harmful

Mixing Erlang and Haskell

Could somebody explain what an &quot;improper list&quot; is?

**Note**:  Thanks to all ! All you guys rock!



Functional Programming: what is an &quot;improper list&quot;?

I&#39;m interested in looking at Erlang and want to follow the path of least resistance in getting up and running.

At present, I&#39;m planning on installing [Erlang R12B-3][1] and [Erlide][2] ([Eclipse][3] plugin). This is largely a Google-result-based decision. Initially this will be on a Windows XP system, though I am likely to reproduce the environment on Ubuntu shortly after.

Is there a significantly better choice? Even if it is tied to one platform.

Please share your experiences.

  [1]: http://www.erlang.org/download.html
  [2]: http://erlide.sourceforge.net/
  [3]: http://www.eclipse.org/

Setting up an Erlang development environment

I would like to know a list of the most common application/websites/solutions where Erlang is used, **successfully or not**.

Explaining why it is used into a specific solution instead of others programming languages would be very much appreciated, too.

Listing BAD Erlang case studies (cases in which Erlang is misused) it would be interesting, as well.


Where is Erlang used and why?

Erlang&#39;s Characteristics
-----------------------

From [Erlang Programming][1] (2009):
&gt;Erlang concurrency is fast and scalable. Its processes are lightweight in that the Erlang virtual machine does not create an OS thread for every created process. They are created, scheduled, and handled in the VM, independent of underlying operating system. As a result, process creation time is of the order of microseconds and independent of the number of concurrently existing processes. Compare this with Java and C#, where for every process an underlying OS thread is created: you will get some very competitive comparisons, with Erlang greatly outperforming both languages.


From [ Concurrency oriented programming in Erlang (pdf)][2] [(slides)][3] (2003):

&gt;We observe that the time taken to create an Erlang process is constant 1&#181;s up to 2,500 processes; thereafter it increases to about 3&#181;s for up to 30,000 processes. The performance of Java and C# is shown at the top of the figure. For a small number of processes it takes about 300&#181;s to create a process. Creating more than two thousand processes is impossible.
&gt;
&gt;We see that for up to 30,000 processes the time to send a message between two Erlang processes is about 0.8&#181;s. For C# it takes about 50&#181;s per message, up to the maximum number of processes (which was about 1800 processes). Java was even worse, for up to 100 process it took about 50&#181;s per message thereafter it increased rapidly to 10ms per message when there were about 1000 Java processes.

My thoughts
-----------

I don&#39;t fully understand technically why Erlang processes are so much more efficient in spawning new processes and have much smaller memory footprints per process. Both the OS and Erlang VM have to do scheduling, context switches, and keep track of the values in the registers and so on...

Simply why aren&#39;t OS threads implemented in the same way as processes in Erlang? Do they have to support something more? And why do they need a bigger memory footprint? And why do they have slower spawning and communication?

Technically, why are processes in Erlang more efficient than OS threads when it comes to spawning and communication? And why can&#39;t threads in the OS be implemented and managed in the same efficient way? And why do OS threads have a bigger memory footprint, plus slower spawning and communication?

More reading
------------
* [Inside the Erlang VM *with focus on SMP*][5] (2008)
* [Concurrency in Java and in Erlang (pdf)][4] (2004)
* [Performance Measurements of Threads in Java and Processes in Erlang][6] (1998)


  [1]: http://www.amazon.com/ERLANG-Programming-Francesco-Cesarini/dp/0596518188/
  [2]: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.116.1969&amp;rep=rep1&amp;type=pdf
  [3]: http://www.scribd.com/doc/6505089/Concurrency-Oriented-Programming-in-Erlang-by-Joe-Armstrong
  [4]: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.1.9502&amp;rep=rep1&amp;type=pdf
  [5]: https://erlang.org/euc/08/euc_smp.pdf
  [6]: http://www.sics.se/~joe/ericsson/du98024.html

Technically, why are processes in Erlang more efficient than OS threads?

I have taken [Problem #12][1] from [Project Euler][2] as a programming exercise and to compare my (surely not optimal) implementations in C, Python, Erlang and Haskell. In order to get some higher execution times, I search for the first triangle number with more than 1000 divisors instead of 500 as stated in the original problem.

The result is the following:

**C:**

&lt;!-- language: none --&gt;

    lorenzo@enzo:~/erlang$ gcc -lm -o euler12.bin euler12.c
    lorenzo@enzo:~/erlang$ time ./euler12.bin
    842161320
    
    real	0m11.074s
    user	0m11.070s
    sys	0m0.000s

**Python:**

&lt;!-- language: none --&gt;

    lorenzo@enzo:~/erlang$ time ./euler12.py 
    842161320
    
    real	1m16.632s
    user	1m16.370s
    sys	0m0.250s

**Python with PyPy:**

&lt;!-- language: none --&gt;

    lorenzo@enzo:~/Downloads/pypy-c-jit-43780-b590cf6de419-linux64/bin$ time ./pypy /home/lorenzo/erlang/euler12.py 
    842161320
    
    real	0m13.082s
    user	0m13.050s
    sys	0m0.020s

**Erlang:**

&lt;!-- language: none --&gt;

    lorenzo@enzo:~/erlang$ erlc euler12.erl 
    lorenzo@enzo:~/erlang$ time erl -s euler12 solve
    Erlang R13B03 (erts-5.7.4) [source] [64-bit] [smp:4:4] [rq:4] [async-threads:0] [hipe] [kernel-poll:false]
    
    Eshell V5.7.4  (abort with ^G)
    1&gt; 842161320
    
    real	0m48.259s
    user	0m48.070s
    sys	0m0.020s

**Haskell:**

&lt;!-- language: none --&gt;

    lorenzo@enzo:~/erlang$ ghc euler12.hs -o euler12.hsx
    [1 of 1] Compiling Main             ( euler12.hs, euler12.o )
    Linking euler12.hsx ...
    lorenzo@enzo:~/erlang$ time ./euler12.hsx 
    842161320
    
    real	2m37.326s
    user	2m37.240s
    sys	0m0.080s

**Summary:**

 - C: 100%
 - Python: 692% (118% with PyPy)
 - Erlang: 436% (135% thanks to RichardC)
 - Haskell: 1421%

I suppose that C has a big advantage as it uses long for the calculations and not arbitrary length integers as the other three. Also it doesn&#39;t need to load a runtime first (Do the others?).

**Question 1:**
Do Erlang, Python and Haskell lose speed due to using arbitrary length integers or don&#39;t they as long as the values are less than `MAXINT`?

**Question 2:**
Why is Haskell so slow? Is there a compiler flag that turns off the brakes or is it my implementation? (The latter is quite probable as Haskell is a book with seven seals to me.)

**Question 3:**
Can you offer me some hints how to optimize these implementations without changing the way I determine the factors? Optimization in any way: nicer, faster, more &quot;native&quot; to the language.

### **EDIT:**

**Question 4:**
Do my functional implementations permit LCO (last call optimization, a.k.a tail recursion elimination) and hence avoid adding unnecessary frames onto the call stack?

I really tried to implement the same algorithm as similar as possible in the four languages, although I have to admit that my Haskell and Erlang knowledge is very limited.

----------

Source codes used:

&lt;!-- language: c --&gt;

    #include &lt;stdio.h&gt;
    #include &lt;math.h&gt;
    
    int factorCount (long n)
    {
    	double square = sqrt (n);
    	int isquare = (int) square;
    	int count = isquare == square ? -1 : 0;
    	long candidate;
    	for (candidate = 1; candidate &lt;= isquare; candidate ++)
    		if (0 == n % candidate) count += 2;
    	return count;
    }
    
    int main ()
    {
    	long triangle = 1;
    	int index = 1;
    	while (factorCount (triangle) &lt; 1001)
    	{
    		index ++;
    		triangle += index;
    	}
    	printf (&quot;%ld\n&quot;, triangle);
    }

----------

&lt;!-- language: python --&gt;

    #! /usr/bin/env python3.2
    
    import math
    
    def factorCount (n):
    	square = math.sqrt (n)
    	isquare = int (square)
    	count = -1 if isquare == square else 0
    	for candidate in range (1, isquare + 1):
    		if not n % candidate: count += 2
    	return count
    
    triangle = 1
    index = 1
    while factorCount (triangle) &lt; 1001:
    	index += 1
    	triangle += index
    
    print (triangle)

----------

&lt;!-- language: erlang --&gt;

    -module (euler12).
    -compile (export_all).
    
    factorCount (Number) -&gt; factorCount (Number, math:sqrt (Number), 1, 0).
    
    factorCount (_, Sqrt, Candidate, Count) when Candidate &gt; Sqrt -&gt; Count;
    
    factorCount (_, Sqrt, Candidate, Count) when Candidate == Sqrt -&gt; Count + 1;
    
    factorCount (Number, Sqrt, Candidate, Count) -&gt;
    	case Number rem Candidate of
    		0 -&gt; factorCount (Number, Sqrt, Candidate + 1, Count + 2);
    		_ -&gt; factorCount (Number, Sqrt, Candidate + 1, Count)
    	end.
    
    nextTriangle (Index, Triangle) -&gt;
    	Count = factorCount (Triangle),
    	if
    		Count &gt; 1000 -&gt; Triangle;
    		true -&gt; nextTriangle (Index + 1, Triangle + Index + 1)	
    	end.
    
    solve () -&gt;
    	io:format (&quot;~p~n&quot;, [nextTriangle (1, 1) ] ),
    	halt (0).

----------

&lt;!-- language: haskell --&gt;

    factorCount number = factorCount&#39; number isquare 1 0 - (fromEnum $ square == fromIntegral isquare)
    	where square = sqrt $ fromIntegral number
    	      isquare = floor square
    
    factorCount&#39; number sqrt candidate count
    	| fromIntegral candidate &gt; sqrt = count
    	| number `mod` candidate == 0 = factorCount&#39; number sqrt (candidate + 1) (count + 2)
    	| otherwise = factorCount&#39; number sqrt (candidate + 1) count
    
    nextTriangle index triangle
    	| factorCount triangle &gt; 1000 = triangle
    	| otherwise = nextTriangle (index + 1) (triangle + index + 1)
    
    main = print $ nextTriangle 1 1


  [1]: http://projecteuler.net/index.php?section=problems&amp;id=12
  [2]: http://projecteuler.net/

Speed comparison with Project Euler: C vs Python vs Erlang vs Haskell

From what I understand a virtual machine falls into two categories either &quot;system virtual machine&quot; or a &quot;process virtual machine&quot;. It&#39;s kind of fuzzy to me where BEAM lies. Is there another kind of virtual machine I am not aware of?

What kind of virtual machine is BEAM (the Erlang VM)?

Many programs return their version number with a command like:

    $ program --version
    program (platform info) v1.2.3

This is useful for scripting the installation or maintenance of the program, and some other controlled automation magic from System Admins and friends.

Problem
-----------
*How to easily get the version number for Erlang (OTP)*?

On the net
-----------
Here are some unsatisfactory solutions (from the [trapexit forum][1] and other tutorials/Erlang documentation):

**Emulator**

    $ erl
    1&gt; erlang:system_info(otp_release).
    &quot;R13B03&quot;

Hard to script. I have not found a way to have `erl` execute a single command from a shell prompt.

**Release file**

    $ cat /usr/lib/erlang/releases/RELEASES
    [{release,&quot;OTP  APN 181 01&quot;,&quot;R13B03&quot;,&quot;5.7.4&quot;,
          [{kernel,&quot;2.13.4&quot;,&quot;/usr/lib/erlang/lib/kernel-2.13.4&quot;},
           {stdlib,&quot;1.16.4&quot;,&quot;/usr/lib/erlang/lib/stdlib-1.16.4&quot;},
           {sasl,&quot;2.1.8&quot;,&quot;/usr/lib/erlang/lib/sasl-2.1.8&quot;}],
          permanent}].

Parsing paradise (with shell).

An alternative could also be checking the install path, but that is not portable (my install path does not include the version, for one).

Personal context: I am writing a script to install the same version of RabbitMQ with plugins on several machines. Some plugins have minimal requirements on the OTP version, and it is how this question started.

[1]: http://forum.trapexit.org/viewtopic.php?p=42946

How to get Erlang&#39;s release version number from a shell?

Lately I&#39;ve been doing some experiments with docker compose in order to deploy multiple collaborating microservices. I can see the many benefits that microservices provide, and now that there is a good toolset for managing them, I think that it&#39;s not extremely hard to jump into the microservices wagon.

But, I have been experimenting with Elixir too, and I am quite fond of the benefits that provides by itself. Given that it encourages packing your code into multiple decoupled applications, and supports hot code upgrades, how would you mix docker with elixir (or erlang, for that matter)?

For example, if I want to use docker because it provides dev-prod parity, how does elixir fit in that? Given that docker containers are immutable, I lose the ability to do hot-code upgrades, right? What about blue/green deployments or canary releases?

I mean, I could just write microservices with Elixir and use them as if they were written in any other language, polyglotism is one of the benefits of microservices anyway, but then I&#39;m not getting the full benefits of using the OTP platform, I guess that pure collaborative erlang applications are way more optimal that using intermediate queues to communicate between microservices written in different (or not) languages.

Where does Elixir/erlang fit into the microservices approach?

This question is in the context of the Beam VM and the capabilities that it provides, not in the general context of what a Turing complete language can do. I want to invest some time to learn either pure Erlang or Elixir. I get the basic differences between the two and I am leaning towards Elixir because of the macros, better syntax and faster development of the language this day.

My question is: if I choose Elixir, will I stumble on something that I cannot do in it, but can do in Erlang? Can I use all the OTP stuff, all the Erlang libraries, code reload, etc. with Elixir?

I am not asking for someone&#39;s preference between the two; just facts about the possibilities of the languages. Preferably from someone who used both in production.


Are there things Elixir can do that Erlang cannot, or vice versa?

What is Ericsson&#39;s implementation of Erlang and Erlang/OTP written and compiled in? Is is assembly, C or Erlang itself?

Update 1: Thanks to DrJokepu. If I understand correctly, Erlang source-to-VM compiler is written in Erlang itself. But the VM is written in C.

Update 2: Hynek-Pichi-Vychodil pointed out a lot of details.

* VM and HW interacting drivers: in C.
* Compiler (to VM) and libraries: in Erlang.
* Extensions: Possible in any language by writing a port or an Erlang node in that language.

What is Erlang written in?

[Erlang][1] was reported to have been used in production systems for over 20 years with an uptime percentage of 99.9999999%.

I did the math as the following:

    20*365.25*24*60*60*(1 - 0.999999999) == 0.631 s

That means the system only has less than one second of downtime during the period of 20 years. I am not trying to challenge the validity of this, I am just curious about how we can shut down a system (on purpose or by accident) for only 0.631 second. Could anyone who are familiar with large software system explain this to us? Thank you.

----

Does anyone know how to calculate the downtime of a service over a cluster of processing units (or machines)?


  [1]: http://www.erlang.org/

Erlang&#39;s 99.9999999% (nine nines) reliability

I&#39;ve been looking at akka recently and it&#39;s pretty impressive. It looks like it has most of the killer features of erlang - location transparency, supervision hierarchies, and more. Are there any features erlang has that akka doesn&#39;t?

How does akka compare to Erlang?

I have been watching the growing visibility of functional programming languages and features for a while. I looked into them and didn&#39;t see the reason for the appeal. 

Then, recently I attended Kevin Smith&#39;s &quot;Basics of Erlang&quot; presentation at [Codemash][1]. 

I enjoyed the presentation and learned that a lot of the attributes of functional programming make it much easier to avoid threading/concurrency issues. I understand the lack of state and mutability makes it impossible for multiple threads to alter the same data, but Kevin said (if I understood correctly) all communication takes place through messages and the mesages are processed synchronously (again avoiding concurrency issues). 

But I have read that Erlang is used in highly scalable applications (the whole reason Ericsson created it in the first place). How can it be efficient handling thousands of requests per second if everything is handled as a synchronously processed message? Isn&#39;t that why we started moving towards asynchronous processing - so we can take advantage of running multiple threads of operation at the same time and achieve scalability? It seems like this architecture, while safer, is a step backwards in terms of scalability. What am I missing?

I understand the creators of Erlang intentionally avoided supporting threading to avoid concurrency problems, but I thought multi-threading was necessary to achieve scalability. 

**How can functional programming languages be inherently thread-safe, yet still scale?**


  [1]: http://codemash.org/default.aspx

How/why do functional languages (specifically Erlang) scale well?

I&#39;m trying to visualize some simple automatic physical systems (such things as pendulum, robot arms,etc.) in Haskell.
Often those systems can be described by equations like

`df/dt = c*f(t) + u(t)`

where `u(t)` represents some kind of &#39;intelligent control&#39;. Those systems look to fit very nicely in the Functional Reactive Programming paradigm.

So I grabbed the book &quot;The Haskell School of Expression&quot; by Paul Hudak,
and found that the domain specific language &quot;FAL&quot; (for Functional Animation Language) presented there actually works quite pleasently for my simple toy systems (although some functions, notably `integrate`, seemed to be  a bit too lazy for an efficient use, but easily fixable).

My question is, what&#39;s the more mature, up-to-date, well-maintained, performance-tuned alternative for more advanced, or even practical applications today?

[This wiki page](http://www.haskell.org/haskellwiki/Functional_Reactive_Programming) lists several options for Haskell, but I&#39;m not clear about the following respects:

1. The status of &quot;reactive&quot;, the project from Conal Eliott who is (as I understand it) one of the inventers of this programming paradigm, looks a bit stale. I love his code, but maybe I should try other more up-to-date alternatives? What&#39;s the primary difference between them, in terms of syntax/performance/runtime-stability?

2. To quote from a [survey](http://www.cs.rit.edu/~eca7215/frp-independent-study/Survey.pdf) in 2011, Section 6, &quot;_... FRP implementations are still not efficient enough or predictable enough in performance to be used effectively in domains which require latency guarantees ..._&quot;. Alghough the survey suggests some interesting possible optimizations, given the fact that FRP is there for more than 15 years, I get the impression that this performance problem might be something _very_ or even inherently difficult to solve at least within a few years. Is this true?

3. The same author of the survey talks about &quot;time leaks&quot; in his [blog](http://blog.edwardamsden.com/2011/03/demonstrating-time-leak-in-arrowized.html). Is the problem unique to FRP, or something we are generally having when programming in a pure, non-strict language? Have you ever found it just too difficult to stabilize an FRP-based system over time, if not performant enough?

4. Is this still a research level project? Are the people like plant engineers, robotics engineers, financial engineers, etc. actually using them (in whaterver language that suits their needs)?

Although I personally prefer a Haskell implementation, I&#39;m open to other suggestions. For example, it would be particularly fun to have an Erlang implementation --- it would then be very easy to have an intelligent, adaptive, self-learning server process!


What&#39;s the status of current Functional Reactive Programming implementations?

I really like these tools when it comes to the concurrency level it can handle.

Erlang/OTP looks like much more stable solution but requires much more learning and a lot of diving into functional language paradigm. And it looks like Erlang/OTP makes it much better when it comes to multi-core CPUs (correct me  if I am wrong).

But which should I choose? Which one is better in the short and long term perspective?

My goal is to learn a tool which makes scaling my Web projects under high load easier than traditional languages.

Node.js or Erlang

As far as I know there&#39;s Erlang plugin for NetBeans and Eclipse. Which one has the upper hand at the moment? 

Are there any other IDE for Erlang which I didnt mention, and how good are they when compare with NetBeans and Eclipse? 

What&#39;s a good IDE for Erlang programming?

I&#39;ve been looking into learning Erlang/OTP, and as a result, have been reading (okay, skimming) about the actor model.

From what I understand, the actor model is simply a set of functions (run within lightweight threads called &quot;processes&quot; in Erlang/OTP), which communicate with each other only via _message passing_.

This seems fairly trivial to implement in C++, or any other language:

    class BaseActor {
    	std::queue&lt;BaseMessage*&gt; messages;
    	CriticalSection messagecs;
    	BaseMessage* Pop();
    public:
    	void Push(BaseMessage* message)
    	{
    		auto scopedlock = messagecs.AquireScopedLock();
    		messagecs.push(message);
    	}
    	virtual void ActorFn() = 0;
    	virtual ~BaseActor() {} = 0;
    }

With each of your processes being an instance of a derived BaseActor. Actors communicate with each other only via message-passing. (namely, pushing). Actors register themselves with a central map on initialization which allows other actors to find them, and allows a central function to run through them.

Now, I understand I&#39;m missing, or rather, glossing over one important issue here, namely:
lack of yielding means a single Actor can unfairly consume excessive time. But are cross-platform coroutines the primary thing that makes this hard in C++? (Windows for instance has fibers.)

Is there anything else I&#39;m missing, though, or is the model really this obvious?

The actor model: Why is Erlang/OTP special? Could you use another language?

Can someone explain the structure of a Pid in Erlang?

Pids looks like this: `&lt;A.B.C&gt;`, e.g. `&lt;0.30.0&gt;` , but I would like to know what is the meaning of these three &quot;bits&quot;: `A`, `B` and `C`.

`A` seems to be always `0` on a local node, but this value changes when the Pid&#39;s owner is located on another node.

Is it possible to directly send a message on a remote node using only the Pid? Something like that: `&lt;4568.30.0&gt; ! Message`, without having to explicitly specify the name of the registered process and the node name (` {proc_name, Node} ! Message`)?


Can someone explain the structure of a Pid (Process Identifier) in Erlang?

Other than specific projects (although those are welcome as well)...

What **tools, books, articles, and other resources** should I have at my desk to help me learn Erlang?

Also, are there mobile runtimes for Erlang?

Please point me in the right direction.


Note: yes, I have visited Erlang and Wikipedia, but I&#39;d like to hear some reliable, experienced opinions.

What is the best way to learn Erlang?

Have you actually &quot;tried&quot; (means programmed in, not just read an article on it) Erlang and decided against it for a project? If so, why? Also, if you have opted to go back to your old language, or to use another functional language like F#, Haskell, Clojure, Scala, or something else then this counts too, and state why.

Why did you decide &quot;against&quot; using Erlang?

I am trying to start using `erlang:trace/3` and the `dbg` module to trace the behaviour of a live production system without taking the server down.

The [documentation][1] is [opaque][2] (to put it mildly) and there don&#39;t appear to be any useful tutorials online.

What I spent all day trying to do was capture what was happening in a particular function by trying to apply a trace to `Module:Function` using `dbg:c` and `dbg:p` but with no success at all.

Does anyone have a succinct explanation of how to use trace in a live Erlang system?


  [1]: http://erldocs.com/R13B03/erts/erlang.html?search=erlang:trace&amp;i=0#trace/3
  [2]: http://erldocs.com/R13B03/erts/erlang.html?search=erlang:trace&amp;i=0#trace/3

How to use trace and dbg in Erlang to debug and trace my program?

Erlang&#39;s (or Joe Armstrong&#39;s?) advice _**NOT to use defensive programming**_ and to let processes crash (rather than pollute your code with needless guards trying to keep track of the wreckage) makes so much sense to me now that I wonder why I wasted so much effort on error handling over the years!

What I wonder is - is this approach only applicable to platforms like Erlang? Erlang has a VM with simple native support for process supervision trees and restarting processes is _really_ fast. Should I spend my development efforts (when not in the Erlang world) on recreating supervision trees rather than bogging myself down with top-level exception handlers, error codes, null results etc etc etc.

Do you think this change of approach would work well in (say) the .NET or Java space?

Erlang&#39;s let-it-crash philosophy - applicable elsewhere?

I am struggling to find any decent links to design patterns, best practice or good, basic architectural principles that should be used in building Actor-based apps. Those few that I know of are:

&lt;h3&gt;Blog posts, articles, WIKIs, guides&lt;/h3&gt;

 - [OTP Design Principles User&#39;s Guide][1] 
 - [Patterns and Best Practices for Enterprise Integration][2] (in general, can be applied to any message-driven architecture)
 - Series of [posts by James Iry on dealing with state in design with actors][3] 
 - Series of [posts on design with Scala actors][4] by Ittay Dror
 - [Concurrency patterns][5] article on wikipedia
 - [Scalable System Design Patterns][6] (not directly related to actors, but quite useful)
 - Understanding actor concurrency, [pt.1][7], [pt.2][8] by Alex Miller

&lt;h3&gt;Papers&lt;/h3&gt;

 - [Disseration on making reliable distributed systems][9] by Joe Armstrong
 - [Scalabale Component Abstractions][10] by Philipp Haller and Martin Odersky
 - [Event-based programming without inversion of control][11] by Martin Odersky and Matthias Zenger
 - [Actors with Multi-Headed Message Receive Patterns][12] by Martin Sulzmann

&lt;h3&gt;Books&lt;/h3&gt;
 - [Actors In Scala][13] by Philipp Haller and Frank Sommers
 - [Programming Erlang][14] by Joe Armstrong
 - [Erlang and OTP in Action][21] by Martin Logan, Eric Merritt, and Richard Carlsson

&lt;h3&gt;Implementations&lt;/h3&gt;

 - [Akka Framework][15] (alternative implementation of actors in Scala with a port of several Erlang behaviors and lots of other relized patterns for actors)
 - [Scalaz Actors][16] (actor compositions, strategies and promises)


&lt;h3&gt;Presentations&lt;/h3&gt;
 - [Actor Thinking][17] by Dale Schumacher 
 - [1000 Year-old Design Patterns][18] by Ulf Wiger
 - [Actor-based Programming][20] by Jamie Ridgway
 - [Школа Актерского Мастерства][22] by Vasil Remeniuk

&lt;h3&gt;Examples from highscalability.com&lt;/h3&gt;

 - **[Simple queuing service (SQS)][19]** - this service provides an internet scale queuing service for storing messages. Distributed actors put work on the queue and take work off the queue. Typical use: a centralized work queue. You put jobs on the queue and different actors can pop work of the queue and process them when they get CPU time. Part of scalability. Have any number of producers and consumers. You don&#39;t worry about it. Queues are spread across multiple machines and multiple data centers.


  [1]: http://www.erlang.org/doc/design_principles/users_guide.html
  [2]: http://www.eaipatterns.com/
  [3]: http://james-iry.blogspot.com/search/label/parallel%2Fdistributed%2Fconcurrent
  [4]: http://www.tikalk.com/category/tags/scala-actors
  [5]: http://en.wikipedia.org/wiki/Concurrency_pattern
  [6]: http://horicky.blogspot.com/2010/10/scalable-system-design-patterns.html
  [7]: http://www.javaworld.com/javaworld/jw-02-2009/jw-02-actor-concurrency1.html
  [8]: http://www.javaworld.com/javaworld/jw-03-2009/jw-03-actor-concurrency2.html
  [9]: http://erlang.org/download/armstrong_thesis_2003.pdf
  [10]: http://lampwww.epfl.ch/~odersky/papers/ScalableComponent.html
  [11]: http://lampwww.epfl.ch/~odersky/papers/jmlc06.html
  [12]: http://ww2.cs.mu.oz.au/~sulzmann/talks/coordination08-talk.pdf
  [13]: http://www.artima.com/shop/actors_in_scala
  [14]: http://pragprog.com/titles/jaerlang/programming-erlang
  [15]: http://doc.akkasource.org/
  [16]: http://docs.google.com/present/view?id=ddmk3f43_63zpg3jcgz
  [17]: http://www.infoq.com/presentations/Actor-Thinking
  [18]: http://www.infoq.com/presentations/1000-Year-old-Design-Patterns
  [19]: http://highscalability.com/build-infinitely-scalable-infrastructure-100-using-amazon-services
  [20]: http://www.infoq.com/presentations/Actor-based-Programming
  [21]: http://www.manning.com/logan/
  [22]: http://www.slideshare.net/remeniuk/ss-8206699


Design patterns/best practice for building Actor-based system

On a Windows 7 Enterprise machine, I made a fresh install of Erlang 17.4 and RabbitMQ 3.4.3 x64.  The installation was successful and uneventful.  

I have not yet tried to create my first queue or exchange, but I already see trouble.  This problem is similar to [another SO post][1], but that other post appears to involve clustering, which I don&#39;t have.  Furthermore, that other poster can circumvent his issue by restarting the RabbitMQ service; that approach does not work for me.

My &quot;nodedown&quot; problem is evident at the RabbitMQ command prompt:

&gt;C:\Program Files (x86)\RabbitMQ Server\rabbitmq_server-3.4.3\sbin&gt;rabbitmqctl status
Status of node rabbit@TPAJ05421843 ...  
Error: unable to connect to node rabbit@TPAJ05421843: nodedown

&gt;DIAGNOSTICS
&gt;===========

&gt;attempted to contact: [rabbit@TPAJ05421843]

&gt;rabbit@TPAJ05421843:  
  * connected to epmd (port 4369) on TPAJ05421843  
  * epmd reports: node &#39;rabbit&#39; not running at all  
                  other nodes on TPAJ05421843: [&#39;RabbitMQ&#39;]  
  * suggestion: start the node

&gt;current node details:  
- node name: &#39;rabbitmqctl-19884@TPAJ05421843&#39;  
- home dir: H:\  
- cookie hash: PD4QQCYrf0TME9vIko3Xuw==

Based on the above, I chose to check the status of the node explicitly named &#39;RabbitMQ&#39;.  I get this:

&gt;C:\Program Files (x86)\RabbitMQ Server\rabbitmq_server-3.4.3\sbin&gt;rabbitmqctl -n RabbitMQ status  
Status of node &#39;RabbitMQ@TPAJ05421843&#39; ...  
Error: unable to connect to node &#39;RabbitMQ@TPAJ05421843&#39;: nodedown

&gt;DIAGNOSTICS
&gt;===========

&gt;attempted to contact: [&#39;RabbitMQ@TPAJ05421843&#39;]

&gt;RabbitMQ@TPAJ05421843:  
  * connected to epmd (port 4369) on TPAJ05421843  
  * epmd reports node &#39;RabbitMQ&#39; running on port 59301  
  * TCP connection succeeded but Erlang distribution failed  
  * suggestion: hostname mismatch?  
  * suggestion: is the cookie set correctly?

&gt;current node details:  
- node name: &#39;rabbitmqctl-23076@TPAJ05421843&#39;  
- home dir: H:\  
- cookie hash: PD4QQCYrf0TME9vIko3Xuw==

Ok, this is barely better since at least it acknowledges &#39;RabbitMQ&#39; running on port 59301.  But what the heck could it mean that &quot;Erlang distribution failed&quot;?

When I try to research this topic, I found articles saying &quot;be sure you have matched cookies.&quot;  Based on that I found [this article][2], which claims the &quot;cookie mismatch&quot; does not pertain to me, because I have not created (nor intend to create) a RabbitMQ cluster.

What should I do?


  [1]: https://stackoverflow.com/questions/25409626/rabbitmqctl-error-unable-to-connect-to-node-rabbitmyserver-nodedown
  [2]: https://stackoverflow.com/questions/9673172/rabbitmq-erlang-how-to-make-sure-the-erlang-cookies-are-the-same

RabbitMQ has Nodedown Error

since concurrent programming becomes constantly more important, I was wondering
what you think about Erlang vs. Scala in that respect. It seems to me that Scala
has a larger user base and potentially a brighter future than Erlang. Furthermore,
Scala is kind of java.

I know these questions are alway a bit subjective, but what would be the better
future investment: Erlang or Scala. Or even another language?


Future investment: Erlang vs. Scala

I am reading [&quot;Elixir in Action&quot; book by Saša Jurić, and in the first chapter][1] it says:

&gt; Erlang processes are completely isolated from each other. They share
&gt; no memory, and a crash of one process doesn’t cause a crash of other
&gt; processes.

Isn&#39;t that true for Java threads as well?  I mean when Java thread crashes, it too does not crash other threads - especially, if we are looking at request-processing threads (lets exclude the `main` thread from this disucussion)


  [1]: https://manning-content.s3.amazonaws.com/download/b/b915834-e80b-4520-939d-ff1900057c15/elixir-in-action-CH01.pdf

Erlang Processes vs Java Threads

*Updated:  This question contains an error which makes the benchmark meaningless.  I will attempt a better benchmark comparing F# and Erlang&#39;s basic concurrency functionality and inquire about the results in another question.*

I am trying do understand the performance characteristics of Erlang and F#.  I find Erlang&#39;s concurrency model very appealing but am inclined to use F# for interoperability reasons. While out of the box F# doesn&#39;t offer anything like Erlang&#39;s concurrency primitives -- from what I can tell async and MailboxProcessor only cover a small portion of what Erlang does well -- I&#39;ve been trying to understand what is possible in F# performance wise.

In Joe Armstrong&#39;s Programming Erlang book, he makes the point that processes are very cheap in Erlang.  He uses the (roughly) the following code to demonstrate this fact:

    -module(processes).
    -export([max/1]).
    
    %% max(N) 
    %%   Create N processes then destroy them
    %%   See how much time this takes
    
    max(N) -&gt;
        statistics(runtime),
        statistics(wall_clock),
        L = for(1, N, fun() -&gt; spawn(fun() -&gt; wait() end) end),
        {_, Time1} = statistics(runtime),
        {_, Time2} = statistics(wall_clock),
        lists:foreach(fun(Pid) -&gt; Pid ! die end, L),
        U1 = Time1 * 1000 / N,
        U2 = Time2 * 1000 / N,
        io:format(&quot;Process spawn time=~p (~p) microseconds~n&quot;,
    	      [U1, U2]).
    
    wait() -&gt;
        receive
    		die -&gt; void
        end.
    
    for(N, N, F) -&gt; [F()];
    for(I, N, F) -&gt; [F()|for(I+1, N, F)].

On my Macbook Pro, spawning and killing 100 thousand processes (`processes:max(100000)`) takes about 8 microseconds per processes.  I can raise the number of processes a bit further, but a million seems to break things pretty consistently.

Knowing very little F#, I tried to implement this example using async and MailBoxProcessor.  My attempt, which may be wrong, is as follows:

    #r &quot;System.dll&quot;
    open System.Diagnostics
    
    type waitMsg =
        | Die
    
    let wait =
        MailboxProcessor.Start(fun inbox -&gt;
            let rec loop =
                async { let! msg = inbox.Receive()
                        match msg with 
                        | Die -&gt; return() }
            loop)
    
    let max N =
        printfn &quot;Started!&quot;
        let stopwatch = new Stopwatch()
        stopwatch.Start()
        let actors = [for i in 1 .. N do yield wait]
        for actor in actors do
            actor.Post(Die)
        stopwatch.Stop()
        printfn &quot;Process spawn time=%f microseconds.&quot; (stopwatch.Elapsed.TotalMilliseconds * 1000.0 / float(N))
        printfn &quot;Done.&quot;

Using F# on Mono, starting and killing 100,000 actors/processors takes under 2 microseconds per process, roughly 4 times faster than Erlang.  More importantly, perhaps, is that I can scale up to millions of processes without any apparent problems.  Starting 1 or 2 million processes still takes about 2 microseconds per process. Starting 20 million processors is still feasible, but slows to about 6 microseconds per process.

I have not yet taken the time to fully understand how F# implements async and MailBoxProcessor, but these results are encouraging.  Is there something I&#39;m doing horribly wrong?

If not, is there some place Erlang will likely outperform F#? Is there any reason Erlang&#39;s concurrency primitives can&#39;t be brought to F# through a library?

EDIT: The above numbers are wrong, due to the error Brian pointed out.  I will update the entire question when I fix it.


Is F# really faster than Erlang at spawning and killing processes?

How useful is the feature of having an atom data type in a programming language?

A few programming languages have the concept of atom or symbol to represent a constant of sorts. There are a few differences among the languages I have come across (Lisp, Ruby and Erlang), but it seems to me that the general concept is the same. I am interested in programming language design, and I was wondering what value does having an atom type provide in real life. Other languages such as Python, Java, C# seem to be doing quite well without it.

I have no real experience of Lisp or Ruby (I know the syntaxes, but haven&#39;t used either in a real project). I have used Erlang enough to be used to the concept there.

Lisp and Erlang Atoms, Ruby and Scheme Symbols. How useful are they?

I know strings in Erlang can be costly to use. So how do I convert `&quot;5&quot;`to `5`?

Is there anything like `io:format(&quot;~p&quot;,[5])` that would return a formatted string instead of printing to a stream?

How to convert an integer to a string in Erlang?

In looking at Go and Erlang&#39;s approach to concurrency, I noticed that they both rely on message passing.

This approach obviously alleviates the need for complex locks because there is no shared state.

However, consider the case of many clients wanting parallel read-only access to a single large data structure in memory -- like a suffix array.

My questions:

 - Will using shared state be faster and use less memory than message passing, as locks will mostly be unnecessary because the data is read-only, and only needs to exist in a single location?

 - How would this problem be approached in a message passing context? Would there be a single process with access to the data structure and clients would simply need to sequentially request data from it? Or, if possible, would the data be chunked to create several processes that hold chunks?

 - Given the architecture of modern CPUs &amp; memory, is there much difference between the two solutions -- i.e., can shared memory be read in parallel by multiple cores -- meaning there is no hardware bottleneck that would otherwise make both implementations roughly perform the same?



How does shared memory vs message passing handle large data structures?

We are going to write a concurrent program using Clojure, which is going to extract keywords from a huge amount of incoming mail which will be cross-checked with a database.

One of my teammates has suggested to use Erlang to write this program.

Here I want to note something that I am new to functional programming so I am in a little doubt whether clojure is a good choice for writing this program, or Erlang is more suitable. 



All Erlang Solutions on Gang of Coders

Total of 36 Erlang Solutions