7

This may be a question that others have seen, but I am trying to find a language designed for (or with language support for) concurrent programming that can run on the .net platform.

I have been doing side development in erlang to get a feel for the language and have loved how easy it is to get a stable concurrent or even distributed system up. It led me to scala which also had a nice system using actors, however scala.net does not seem to have this functionality currently (Granted this is a concurrent system vs a distributed system). The two .net languages I was looking at are Axum and F#.

Are these the only choices I have? Are there others? And, if they are the only choices, what are the advantages/disadvantages of each?

Mike
  • 1,297
  • 2
  • 14
  • 22
  • 1
    Do you mean, what is the best .Net language in which to build distributed systems? – Steve Townsend Sep 22 '10 at 23:28
  • I think you should clearly separate between multi-threaded systems (use 1 or more processors on 1 machine) and distributed systems (use multiple machines). Erlang is good for both types of systems, while Scala is good for multi-threaded systems, but not so much for building distributed systems (AFAIK). – wmeyer Sep 23 '10 at 00:38
  • @wmeyer that is a good point, although the best thing would be something like erlang where it doesn't really care and can be moved from a multi-process to a multi-system setup without much code change. But it is good to know that Scala doesn't work for distributed systems well, I wasn't aware of that. – Mike Sep 23 '10 at 02:22
  • 1
    Don't forget: sticking with immutable types + PFX (i.e. `System.Threading.Tasks` + `System.Collections.Concurrent`) is available across .NET languages. – Richard Sep 23 '10 at 12:55
  • I think this question is specific enough, and has answers detailed enough, that it should be exempt from the "not constructive" close reason. – Bill the Lizard Sep 19 '11 at 12:18

4 Answers4

6

Axum is a research project. A real research project, where only ideas from it will end up in products. (Unlike F#, which was productized as a whole.) I'm not even sure the license allows using it to develop production applications.

F# is a fine choice.

Clojure also runs on the CLI, and is a good choice, too.

The CLI port of Scala is currently in the process of being resurrected (with officiall funding from Microsoft, actually), and Scala's Actor libraries (both the built-in one, as well as Akka) are pretty good.

Regarding @wmeyer's comment above: Scala itself doesn't have any provisions for distributed programming. (Neither does Clojure.) Both generally rely on the myriad of Java frameworks that exist for that purpose, such as Terracotta. However, Akka does have Remote Actors for distributed programming, and Akka is largely API-compatible with the built-in Scala Actor library, which allows for a smooth transition.

Erlang would be kind of cool. Kresten Krab Thorup is currently working on Erjang, an Erlang implementation on the JVM, and he has some pretty impressive results: running on HotSpot, Erjang scales comparably to BEAM, sometimes even better. For example, in the (in)famous process-ring benchmark with 10000 processes, Erjang starts up only minimally slower than BEAM, but when you repeat the run several times and the JIT kicks in, it overtakes BEAM after about 3 runs (and curiously, BEAM starts slowing down after 4 runs).

I'm pretty sure you could build an "#rlang" on the DLR and the TPL that performs equally well.

Jörg W Mittag
  • 363,080
  • 75
  • 446
  • 653
3

I am actually using F# to do both concurrent and distributed programming right now. I think it is working very well. Union types make it easy to define statically-typed messages. .NET serialization is too slow for us but replacing it using custom parser and unparser combinators was easy and performance is now good enough. Asynchronous workflows and mailbox processors make it easy to pass messages around easily. Type inference means my entire code base is tiny and easily maintainable.

J D
  • 48,105
  • 13
  • 171
  • 274
  • +1: very much agree here. I haven't written anything requiring distributed apps, but everything I've done with mailbox processors has been a breeze. If the OP wants a good language "that runs on the .net framework, to write concurrent applications", its hard to beat F#. – Juliet Sep 23 '10 at 15:09
2

I think that Jörg already answered your question about Axum (and I don't know much about it), so I'll just add a couple of things about F# - one thing to note is that F# isn't really a concurrent language. It just has good libraries for doing parallel development. The most notable options are:

  • Task Parallel Library and PLINQ which are available in C# too, but may look a bit nicer in F#, especially if you use immutable data types. There are some nice F# examples of using these two in Parallel Programming with .NET and I wrote a blog post about the F# version.

  • Asynchronous workflows are not essentially designed for concurrent programming - they allow you to write non-blocking code in general (which is quite useful in concurrent programming) and they allow you to write computations that can be started and managed. You can use them for:

    • Task-based parallelism (a bit like Task Parallel Library) using StartChild method
    • Data-parallel computations using Async.Parallel
      _
  • Agent-based programming using the MailboxProcessor type from F# allows you to use message-passing concurrency that is quite similar to Erlang. It is based on asynchronous workflows, which gives you some benefits (e.g. waiting for a message is non-blocking).

In summary, I think it is more important to choose the right parallel programming model for your task than the language used to encode it - as long as the language gives you enough power to encode the programming model. In this case, the programming model shapes your mind more than the language. Axum is based on the actor (message-passing) model, so I think that with some effort, you could wrap F# agents to look quite similar to the Axum API.

Tomas Petricek
  • 240,744
  • 19
  • 378
  • 553
0

Since .NET 4.5 you can use C# async/await. I tried to explain a threadsafe, actor based design using async/await. AsyncWcfLib is intended to help when creating concurrent or distributed systems.

Stefan Forster
  • 405
  • 4
  • 7