As I am on vacation, I have had some time to read part of the Programming Erlang book I mentioned some posts ago. After reading the firsts chapters, I was surprised to see that one of the not so much mentioned Erlang central features is that relies extremely on the pattern matching idiom. Just one example, the “=” operator is a pattern matching operator, which behaves like assignment when the variable is unbound, and act like a pattern matching expression when it is bound.

Another feature that I was glad to see is the actor model paradigm, with messages sent from and to Actors (like Scala or Smalltalk) to deal with highly complex concurrency models.

But after playing with some of the examples that appear on the book, I found this exercise at the end of the chapter 8 :

Write a ring benchmark. Create N processes in a ring. Send a message round the ring M times so that a total of N * M messages get sent. Time how long this takes for different values of N and M.

Ok, so here it is my solution (ring.erl):

-module (ring).
-export ([start/2]).

start(N, M) ->
     statistics(runtime),
     statistics(wall_clock),
     Main_process = self(),
     io:format("Creating ~p ring processes~n", [N]),
     spawn(fun() -> ring(1, N, M, self(), Main_process) end),
     receive
          ended -> void
     end,
     {_, Time1} = statistics(runtime),
     {_, Time2} = statistics(wall_clock),
     U1 = Time1,
     U2 = Time2,
     io:format("Ring benchmark for ~p processes and ~p messages =
                    ~p (~p) milliseconds~n", [N, M, U1, U2]).

ring(_, N, _, _, _) when(N =< 0)->
     io:format("Empty ring~n"),
     erlang:error(emptyRing);
ring(_, _, M, _, _) when(M =< 0)->
     io:format("No messages to send~n"),
     erlang:error(noMessagesToSend);
ring(N, N, M, First_process, Main_process) ->
     io:format("Ring process ~p (~p) created~n", [N, self()]),
     io:format("Sending ~p messages through the ring~n", [M]),
     First_process ! {send, main_process, Main_process},
     loop(M, N, N, First_process, Main_process);
ring(I, N, M, First_process, Main_process) ->
     io:format("Ring process ~p (~p) created~n", [I, self()]),
     Next_process = spawn(fun() ->
          ring(I+1, N, M, First_process, Main_process) end),
     loop(M, I, N, Next_process, Main_process).

loop(0, N, N, _, Main_process) ->
     io:format("Ring process ~p (~p) finished~n", [N, self()]),
     Main_process ! ended;
loop(0, I, _, _, _) ->
     io:format("Ring process ~p (~p) finished~n", [I, self()]);
loop(M, I, N, Next_process, Main_process) ->
     receive
          {send, From, From_process} ->
               io:format("Process ~p (~p) received message ~p
                    from process ~p (~p) ~n", [I, self(), M, From, From_process]),
               Next_process ! {send, I, self()},
               loop(M-1, I, N, Next_process, Main_process)
     end.

And here the benchmark results based on Erlang R11B, two different configuration machines and running the above code but without I/O (ring_noio.erl):

1. Mac OS-X 10.4.10:
• Processor: Intel Core 2 Duo Processor 2.2 GHz
• Memory: 2 Gb 667 MHz DDR2
2. Windows XP Professional SP2:
• Processor: AMD Athlon 64 X2 Dual Core Processor 4200+ (working each core at 2.2 GHz)
• Memory: 2 Gb 667 MHz DDR2

The exercise illustrates how long it takes to spawn a large number of processes and the cost of message passing between them. There is no parallelism in this exercise, as there is only one process active at a time (the others are waiting for a message), but demonstrates how well Erlang can deal with lots of processes and lots of sending and receiving messages. Although I believe I need to do more serious tests, creating 10.000 process and passing 100 million messages in 35 seconds is a great mark.

The second part of the exercise is to write a similar program in some other programming language and to compare the results. Check these links to see some results:

• Performance Measurements of Threads in Java and Processes in Erlang
• Erlang vs. Stackless python: a first benchmark
• Benchmarking Java Vs Erlang
• Erlang, Termite and a Blog
• Erlang processes vs. Java threads

Next chapters: distributed programming, OTP and Mnesia (the Erlang Database).

After reading some exciting posts about Erlang, I decided to find out for myself what this language is all about. So I ordered Programming Erlang. Software for a Concurrent World, from the Pragmatic Bookshelf, and today I received my copy of the book.

It’s about concurrency. It’s about distribution. It’s about fault tolerance. It’s about functional programming. It’s about programming a distributed concurrent system without locks and mutexes but using only pure message parsing. It’s about speeding up your programs on multi-core CPUs. It’s about writing distributed applications that allow people to interact with each other. It’s about design methods and behaviors for writing fault-tolerant and distributed systems. It’s about modeling concurrency and mapping those models onto computer programs, a process I call concurrency-oriented programming.

I don’t have time right now to dive into it too deep, I just started reading the first chapter, and I am already shocked.

Erlang has single assignment variables. As the name suggests, single assignment variables can be given a value only once. If you try to change the value of a variable once it has been set, then you’ll get an error.

Wondering why?

If you use a conventional programming language such as C or Java to program a multi-core CPU, then you will have to contend with the problem of shared memory. In order not to corrupt shared memory, the memory has to be locked while it is accessed. … In Erlang, there is no mutable state, there is no shared memory, and there are no locks. This makes it easy to parallelize our programs.

I am sure I will have lots of fun learning it!

Wow! After studying Structured programming, Object-oriented programming and Functional programming for many years, today I’ve discovered a new programming discipline, the Esoteric programming.

An esoteric programming language (aka Esolang) is a computer programming language designed to experiment with weird ideas, to be hard to program in, or as a joke, rather than for practical use. Below there are some examples of “Hello World!” programs written in this kind of languages:

• Brainfuck, which consist of only eight recognized characters:
  ++++++++++[>+++++++>++++++++++>+++>+<<<<-]
>++.>+.+++++++..+++.>++.
<<+++++++++++++++.>.+++.------.--------.>+.>.
• Befunge, where programs are arranged on a two-dimensional grid:
  > v
v ,,,,,"Hello"<
>48*, v
v,,,,,,"World!"<
>25*,@

You’ll find the complete list at the Esolang Community Portal.

(Via Barrapunto)

The ACM “Hello World” project is attempting to collect examples for as many languages and related programming environments (shells etc.) as possible. Could you contribute with a new one?

PD: My favourite one, the IBM 1401 self loading card.

A recent survey, conducted by Computerworld at 352 companies, revealed that a lot of them are still using Cobol actively.

“A lot of people have said they were going to get rid of the mainframe, but that hasn’t happened. And for us, all that code is working. There’s no sense in rewriting it.”

“For years, pundits have said that the way to avoid the headaches of maintaining Cobol – and mainframes, green screens and other legacy paraphernalia – is to replace them. But that hasn’t happened, even in the massive Y2k remediation effort.”

But the most amazing fact of all is that 58% said they’re using it to develop new applications. Viva Cobol!

See the full report at Cobol Coders: Going, Going, Gone?

(Via Mainframe)