Comments on: Erlang does have shared memory

By: Balu

Balu — Mon, 20 Oct 2008 22:23:44 +0000

Since ETS is “shared memory”, will using it invalidate Erlang’s multi-core scalability advantage?

By: Ulf Wiger

Ulf Wiger — Sun, 18 May 2008 08:43:03 +0000

I have also reacted to the claims that Erlang lacks shared memory. My main objection is that it’s too broad a statement, along the lines of “erlang doesn’t have memory management” - it does, it’s just that it’s automatic.

Semantically, Erlang copies messages and data, but it doesn’t always do so in practice. Since the language doesn’t allow you to address memory directly, the underlying implementation is free to put all erlang processes in the same memory space without sacrificing robustness*. Ets tables are also kept in the same memory space. Furthermore, objects in Ets tables are not garbage collected, which makes a difference for very large data sets.

* Experimental versions of the VM have even used one global heap for all processes, and passed all messages by reference. Unfortunately, a new garbage collector would have been needed to make the implementation really useful in practice.

By: Your Bear

Your Bear — Sat, 17 May 2008 07:37:02 +0000

Hi Guys!

@Yariv: I agree with you, ets is a shared area of mutable storage.

@Orbitz: We have I/O and if you don’t want to carry around the updated world in your call stacks, you better have some side effects. Yes, Haskell’s answer to this are monads. By the way, bang operation in Erlang is a side effect as well.

@Hypothetical Guy: The message passing etc we all like Erlang for is otherwise known as actors model. You can add that to an OOP lang as well, with Scala being an example. See OOP and COP. Because destructive updates are what most of us were raised with and many algorithms and data structures exist using this feature, it is easier and I guess Scala will overtake Erlang as actor language at one time in point, although I hope that having that will make it too easy too make a mess of already complex concurrent or even distributed problem solutions.

By: orbitz

orbitz — Thu, 15 May 2008 13:29:34 +0000

Sure, you can write one with the other. But doesn’t mean Erlang has shared memory, just means you have the ability to express the semantics of shared memory in Erlang. I’d be surprised if you couldn’t.

By: Yariv

Yariv — Thu, 15 May 2008 07:26:48 +0000

Whether you define ets as shared memory or not, you can’t deny that as far as the programmer is concerned ets shares some semantics with traditional shared memory implementations. That’s not a bad thing by any means — it’s just interesting to observe the duality between message passing and shared memory + locks. Given one you can implement the other.

By: Matt W

Matt W — Thu, 15 May 2008 02:03:52 +0000

Hey Yariv,

I love Erlyweb and I keep up with your blog (I even scraped some HTML so I could figure out how to associate an atom feed with a website ;) ). Thanks for both!

I just wanted to let you know I made a google custom search for Erlang and yarivsblog.com is one of the few site that I’m limiting the search to.

You can find it at http://search.dawsdesign.com

I hope you find it useful!

By: orbitz

orbitz — Wed, 14 May 2008 13:46:07 +0000

To continue my previous thought, this sounds somewhat analogous to saying Haskell has side effects because you can create monads.

By: Hypothetical Labs

Hypothetical Labs — Wed, 14 May 2008 10:09:55 +0000

[...] Yariv makes a good point about ets being Erlang’s sort of equivalent to shared memory. I agree totally. [...]

By: orbitz

orbitz — Wed, 14 May 2008 02:30:33 +0000

Hrm, I think this post is kind of cheap. Erlang does not have shared mutable memory, it does however have the ability to write modules with the same semantics as shared mutable memory. Heck, it’s a programming language, no surprise there. This is a property of a module though, not the language. Perhaps a more accurate title: Erlang does not have shared mutable memory, but you can simulate it if you want.

By: Tim Bates

Tim Bates — Wed, 14 May 2008 00:43:09 +0000

No, the process dictionary represents mutable state (to a newcomer to Erlang), not shared memory - since it is constrained to a single process (the opposite of “shared”). And even the process dictionary could be implemented using Erlang’s process model. ETS and the process dictionary are just optimizations, with their own performance implications and caveats, but they don’t break Erlang’s no-shared-memory model.