I would claim the opposite, based on my experience from large software projects using Erlang during the past 12 years. Not only do I find reuse quite easy in Erlang – I believe that we practically always achieve a much higher degree of reuse than similar projects in C++ or Java. We have also found that it is fairly easy to rewrite parts – even fairly large parts – without jeopardizing quality or performance. This is vitally important in long-running projects, and when building lots of different products on the same software base.

Things that greatly simplify reuse in Erlang are polymorphism and pattern-matching, of course, as well as the black-box style programming, but also the fact that it has a pretty clear idea of how software should be written. OTP takes this further and provides ‘behaviours’ and libraries and a consistent notion of architecture and programming style.

My impression of reuse in C++ is that, while it is quite possible to achieve a high degree of reuse in you own code, reusing code from other projects is much more problematic.

I remember reading those blog entries you cite in your comment above, and I remember strongly disagreeing with them. The opinions you state there simply don’t strike me as having been born of real in-depth experience with the language.

For example, if you didn’t find that Erlang was head-and-shoulders above almost all other languages when it comes to concurrency, then I really do fear that you somehow got yourself onto a very wrong track. Erlang’s concurrency support is easily and clearly superior to anything I’ve seen before, and trust me, I’ve been developing concurrent systems for a very long time.

At the end of the day, if you don’t want to use Erlang, then that’s your choice. It doesn’t affect me one way or another, as I fully intend to continue to take full advantage of it.

Yes, I wrote a book as well (“Next Generation Testing in Java”). Your point is well taken regarding the need to show self-contained examples to your readers.

I still stand by my claim that Erlang makes reuse difficult in general, but it’s more due to pattern matching than Erlang per se. The problem with pattern matching is that it’s basically a glorified switch/case, and there is no easy way to reuse existing ones (another problem with pattern matching is that it completely breaks encapsulation, but that’s a separate topic).

I agree that Erlang’s syntax is easier than Perl and C++, but that’s setting the bar a bit low, don’t you think? :-) Personally, I found Erlang’s terminators quite confusing, but that’s fine, I can deal with esoteric syntaxes if it’s worth it. I just don’t think Erlang is.

I took a deep dive into Erlang some time ago, and here are my impressions:

http://beust.com/weblog/archives/000461.html
http://beust.com/weblog/archives/000464.html

In a nutshell: I enjoyed the book and I liked having my traditional conceptions of software engineering challenged, but Erlang suffers from too many deficiencies (detailed in my posts) to stand a chance of becoming mainstream any time soon. I was particularly disappointed to realize that the claims about Erlang heling with concurrent programming extremely exaggerated.

Have you ever written a book? I have. One thing you have to do when writing a book is make the examples relatively self-contained, otherwise the readers send you unfriendly emails and write unfriendly reviews for making them page around to find the parts of the code you “reused” and thus left out of the example they happen to be staring at. The moral of the story is that you shouldn’t judge whether Erlang allows for reusability only by looking at examples in a book.