Comments on: What is Erlang-Style Concurrency?

By: Quora

Quora — Sun, 06 Feb 2011 15:13:40 +0000

What is the single most effective thing you did to improve your programming skills?…

There is no silver bullet in improving your programming skills. There are in fact many things practiced over a period of time that makes you a good programmer. The most crucial thing is to learn how to think in your programming language. Over the years…

By: Ulf Wiger

Ulf Wiger — Sat, 24 Jul 2010 20:42:35 +0000

@Kevin: It is very similar to CSP, although selective receive with implicit buffering would have to be modeled on top. Extending an existing language easily becomes problematic, as there are often existing assumptions that are at odds with the share-nothing lightweight concurrency aspects – not to mention the error handling.

By: Kevin Cameron

Kevin Cameron — Sat, 24 Jul 2010 18:54:58 +0000

This is very similar to CSP –

http://usingcsp.com
http://en.wikipedia.org/wiki/Communicating_sequential_processes

I’d say the main difference is that CSP and HDLs use static processes structures – which are easier to analyze and optimize.

I prefer to extend a language people already use (C++) -

http://parallel.cc

By: Daily Links #98 | CloudKnow

Daily Links #98 | CloudKnow — Tue, 15 Sep 2009 15:54:15 +0000

[...] Ulf Wiger: What is Erlang-Style Concurrency? [...]

By: Ulf Wiger

Ulf Wiger — Mon, 14 Sep 2009 14:16:16 +0000

@YC, indeed, some languages have superb extension facilities (LISP and Haskell come to mind) and can provide almost anything as libraries on top of the core language. On the other hand, one really wants all libraries to use a common concurrency model, for example (or at the very least, compatible concurrency models), so even if these things are technically implemented as libraries, they really have a tendency to become part of an extended language definition, at least.

There are several concurrency models implemented on top of the JVM, for example, but their use is limited, partly because the vast majority of Java libraries assume the shared-object concurrency model provided by the core language.

Similarly, I’ve witnessed C++ projects get into trouble because they changed the concurrency model and never got around to rewriting their old code, and ended up having to develop incompatible implementations of the same features for both models.

By: Ulf Wiger

Ulf Wiger — Mon, 14 Sep 2009 13:40:59 +0000

@John, this very issue came up in the discussion about Tony Arcieri’s blog post “Single Assignment Myths” (http://tonyarcieri.org/articles/2008/09/30/single-assignment-myths which is unavailable as I’m writing this – hopefully not permanently). Reia is a Ruby-like language that runs on top of the Erlang VM. It supports Erlang-style concurrency, but does not have single assignment. It’s perfectly reasonable to have destructive assignment combined with copying message passing, and I don’t see that it would have to slow anything down.

By: YC

YC — Mon, 14 Sep 2009 10:31:53 +0000

Ulf –

thanks for providing the checklist as it helps to establish the bar for other languages.

I would say that not all of the checklist are *fundamental* to have in the core language *if* the language has good extension facility.

The fundamental ones, i.e. difficult if not impossible to have at module level, are the microthreads and asynchronous message passing – the rest can be built as extensions.

I have just built the selective reception capability as a module for PLT Scheme on top of its microthreads – http://weblambda.blogspot.com/2009/09/erlang-style-programming-in-plt.html – distributed message and process monitoring can also be added in due time (and necessary effort of course).

It is true for other languages that cannot blur the line between the language and the extensions, the language provider would have to work harder to provide most if not all of the checklist.

By: John F. Miller

John F. Miller — Mon, 14 Sep 2009 00:44:14 +0000

Ulf, I note that you made no mention of Erlang’s insistence on single assignment. Do you think that this is required to achieve efficient copying semantics? Conversely, could a system that did not enforce single assignment be said to have Erlang-style concurrency?

By: Ulf Wiger

Ulf Wiger — Sun, 13 Sep 2009 15:11:44 +0000

@Jeremy, yes this was an important input requirement for Erlang – one shouldn’t have to know the location of a process in order to talk to it, but if one does need to know, the information should be available. I tried to incorporate that by noting that “Remote processes appear largely the same as local processes”. The question is whether it should be viewed as a necessary for “erlang-style concurrency”?

One counter-argument might be that distribution wasn’t added to Erlang until 1993 – after the publication of the first Erlang book! (:

However, the idea of Distributed Erlang was there from the start, and the semantics of process spawning and message passing were created with distribution in mind.

By: Jeremy Bowers

Jeremy Bowers — Sun, 13 Sep 2009 14:52:20 +0000

I would also add “processes can be messaged across system boundaries as easily as local processes”. That’s the big one that prevents me from using Haskell for things I currently use Erlang for; Haskell is arguably better on a single machine, especially for performance, but when you want to have high-availability, you’re sort of stuck.