A super-simple gen_server:

Here is a too simple bank accounting server (the logic of the server is incomplete and really easy). I have written it for joke too many times, and here I am using dict, which is not the neat data structure to use, but ehy, we are talking about race conditions in unit testing.

I link you to the file, because 96 rows of code pasted here are too many.

The test module:

The tests are stupid tests. I am not focused on them right now, but only on the race condition. Remember?

-module(test_bank_server).

-include_lib("eunit/include/eunit.hrl").

create_account_test_() ->
    {setup,
     fun setup/0,
     fun teardown/1,
     fun(_Pid) ->
	     bank_server:create_account(mirko),
	     [
	      ?_assertEqual(0, bank_server:balance(mirko))
	      ] end}.

deposit_test_() ->
    {setup,
     fun setup/0,
     fun teardown/1,
     fun(_Pid) ->
	     bank_server:create_account(mirko),
	     bank_server:deposit(mirko, 10),
	     bank_server:deposit(mirko, 99),
	     bank_server:create_account(roberta),
	     bank_server:deposit(roberta, 1000),
	     [
	      ?_assertEqual(109, bank_server:balance(mirko)),
	      ?_assertEqual(1000, bank_server:balance(roberta))
	     ] end}.

setup() ->
    {ok, Pid} = bank_server:start_link(),
    Pid.

teardown(_Pid) ->
    bank_server:stop().

And yep, here we have a race condition:

Ok, as you can see our test is failing, but it is not failing the right way. We have got something wrong inside our test setup. But it seems to be caused by the teardown/1 function.

Why?

The explanation is very simple. We are issuing an asynchronous call to stop the server. So, Eunit is calling teardown/1 which sends the asynchronous message stop to the gen_server, an then it goes on to the next test, calling setup/0, but after the spawn, it could be that the previous gen_server is still alive, or it is shutting down right in that moment.

We can’t register a process if there is already that name registered or if the Pid does not exist on the local machine. And here we are in the first case and we get a badarg error on the function register/2 (but in this case I am using OTP, so the error message is even more clear, the bank_server process is already started, yep, because the process registered in the previous test generator is still there).

To tell the truth, I am using an asynchronous call here to shutdown the server. I have tried the same example with a synchronous call and I avoided the race condition returning a 4 element tuple {stop, normal, ok, State} from the gen_server, as Roberto Aloi have written in this StackOverflow post. But his mate Adam Lindberg still poiting to the fact we are not avoiding race condition even if we are issuing synchronous calls.

And at the end of the day, it could be that you don’t want to use a synchronous call at all, so let’s go to the solutions.

How to avoid it (dirty solution):

This is a shitty solutions (please don’t use this in your code or you will be screwed in this concurrent world). I want to write it here because you can understand that if you give the gen_server some milliseconds to shut down, you are ok, but it is still a bad practice, because you are betting on the time with an hard coded value, and it is not clean but really really dirty.

setup() ->
    timer:sleep(100),
    bank_server:start_link().

teardown(_Pid) ->
    bank_server:stop().

So, yep, no race conditions here. But it is dangerous. What if the gen_server tooks more time to shutdown? Here comes the Adam way, which is in my opinion the neat one.

How to avoid it (neat solution):

As I have already written above, here is the Adam Lindberg solution. I have found it the the previous mentioned StackOverflow discussion.

teardown(Pid) ->
    bank_server:stop(),
    wait_for_exit(Pid).

wait_for_exit(Pid) ->
    MRef = erlang:monitor(process, Pid),
    receive
	{'DOWN', MRef, _, _, _} ->
	    ok
    end.

To get to the point Adam says that its way is to monitor the gen_server process, and wait for its {‘DOWN’, Ref, process, Pid, Reason} message. This is like you are synchronizing the teardown/1 and the next setup/0, and it is not hard coded, but really neat. It works good. And you are get things in sync here in your test module, but you are not forcing your gen_server to issue a synchronous call to shutdown.

And yep, it works:

Adam in the very last message of the discussion says which it is always a good practice to monitor processes that are supposed to die during testing, and I agree.

That’s it!

Time to wish you a great New Year’s Eve. See you within 24 hour in 2012, it will be a great year. Lots of things to do, and lots of Erlang code to write. Starting from the Erlang Factory in Brussels, see you there, ping me for beers or dinner and some Erlang discussions.

Bye.

In my opinion it is a great product, and I can’t wait to try it. I have learned Erlang from the book Erlang Programming. It is written by Francesco Cesarini and Simon Thompson and the they are the lecturers of the first course available (Erlang Express, available at a launching price of 180£), so if the book is really good and pragmatic at the right point, the e-learning will be better because of its great features.

Erlang language has known a huge growth during the last years, starting from the advent of the multi-core processors and the consequent requeset of a developing environment which provides heavy scalability and fault tollerance.

Erlang has always faced the problem from the ground and the choices made at the Ericsson during the ’80s have paid a gerat value today, in fact the language hugely simplifies the development of systems which have to scale and be high avalilable.

Until 2007 there was only a book to learn the language. During the last years some books have been published and in the future some others will come out. But it has always been difficult to really learn Erlang from your desk. Some web sites and Blog have helped a lot, and the mailing list is the best in the world, but there was the lack of something official to look when you need it. And today this lack has been filled by Erlang Solutions, which after the project tryerlang.org has continued to invest on the language and its diffusion.

At the moment Erlang Express course is already available, but in the next future we will be able to enroll to more courses. I can’t wait to increase my skills and try the platform.

What is Erlang?

If you are reading this blog, probably you already know the answer to this question. But this blog entry comes from my Italian blog, and in Italy this explanation is very welcome.

At first sight, we could say that Erlang is a functional programming language born during the 80s in the Ericsson research Labs, it is great for build real-time, fault tolerant and concurrent systems. But ehy… Erlang is much better than this. It is not only a language, but it also has got a great runtime system which is able to reach linear scalability on multi-core systems (and this should be enough to make you understand about the bright future of this language), but there is something more.

Writing software in Erlang is not enough to reach fault tolerance or huge concurrency. Erlang is not a silver bullet and is for this reason that there is OTP (Open Telecom Platform), a framework more and more tied to Erlang (we usually say Erlang/OTP for this reason). OTP is a great topic but to sum up its benefits, I can say that it gives you the guidelines to reach in a simple way things that are very difficult to obtain with other languages… Concurrency (the real one), fault tolerance and quickness. If you are interested in Erlang, take a look at here.

What is the Erlang Factory?

Erlang Factory is the most important worldwide Erlang Event. It is organized by Erlang Solutions Ltd and there are 2 Erlang Factory events per year. One in San Francisco and the other one in London. Usually San Francisco is on March, while London is on the end of the spring in the first weeks of June. It is an unbelievable opportunity to meet giant names of the Erlang community, such as Joe Armstrong, Mike Williams (with I have had the pleasure to have lunch on the first day of the conference), Robert Virding, Francesco Cesarini and lots of other bright guys with whom is a pleasure to stop and talk about experiences with Erlang .

Only at the Erlang Factory you are able to dive into this environment which is getting more and more electrifying. Young Erlangers like me could understand how Erlang is used in the industrial ecosystem; it is very useful because after that you are able to make and idea on future working opportunities. On the other side, companies are able to promote their-self, telling success stories, which could be useful for other companies, reaching a knowledge reuse which is very, very useful.

About big companies I can mention Klarna, which today employs about 500 persons, and in 3 years of Erlang has only got 30 seconds of downtime on its systems, a gorgeous reliability. How can I write this post without write about Basho, the company behind the Riak Database, it is having a huge growth after some difficulties during the start-up period, and this great success story has been brought to us directly by Anthony Falco. I could go on with other companies, such as AOL, Trifork, Wooga (which builds video-games back-ends which have to deal with millions of active users every days), Demonware (one of the biggest service providers for on-line video-games… If you want a title, I can say… “Call of Duty Black Ops“), and lots of other… But the post will become unmanageable, so take a look at the speakers official page, you will be able to find slides and videos (which will be loaded step by step on this Vimeo’s channel).

Anyway, not only big IT firms at the Conference but even Start-Ups which starts with the right foot, writing their systems in Erlang. For example the Start-Up which is disrupting the way of betting in UK, that is Smarklets founded by the omnipresent Hunter Morris with Jason Trost.

So, Erlang Factory is from StartUps to Big Firms but there are also enough space for Universities, especially for Uppsala University, from which comes great news such as the PropEr project, introduced by Kostis Sagonas. But there also was space for the University of Kent, and for Simon Thompson (co-author with Francesco Cesarini of the Erlang Programming book) who has introduced us to the latest progress done with the Wrangler project, an Erlang re-factoring tool.

At the end there have been some announcements on the future of Erlang, such as some previews on the future features of the next releases, and about this topic I want to say a big thank you to the Development Team. They are doing a great job.

The C-Factor is unbelievable, and for C-Factor I mean the community factor. At the end of every Conference day there is a real third half, and between some beer mugs there is the opportunity to meet each other and do some networking.

The pictures below, for example, depicts some moments after the second day of the Conference, while we were enjoying a beer kindly offered by Erlang Solutions in front of the Old Sessions House (the conference venue). In the first picture, half of the  ”Team Italy” or rather me, Roberto Aloi (author of these gorgeous pics) and Carlo Bertoldi (which I have to give thanks for the two pics below) together with Kostis Sagonas while in the second one its me with Bjarne Daker.

If you have questions, maybe not only about the Conference, but on Erlang too don’t hesitate to contact me on Twitter.

My advice is to don’t miss them out. Here is a quick list of the interviews Paolo has done so far:

• Francesco Cesarini
• Roberto Aloi
• Simon Thompson

And more are yet to come…

See you soon, I am so close to end my post about gen_server

My University

Wow, I haven’t written anything here since last December. A huge amount of time… Too much time for my likes. During these last months I have been involved in a lot of stuffs, first of all my university exams and then my work (about 8 hours per day) and an English course. So, I haven’t had too much time for my Erlang blog.

I am studying Computer Science at University Milan-Bicocca, and I have just finished my first 4 courses: Elements of Math, Network Architecture, Computer Architecture (mostly based on MIPS Architecture) and Programming (a little course on OOP, Java and UML). Next week I am starting with Math Analysis, Database, Programming (Java again…) and Algorithms and Data Structures.

I hope to find enough time to deep understanding Erlang and to blog something here. In two weeks I will attend the first NoSQL Event here in Italy, and I am looking forward to be at the London Erlang Factory. I can’t promise anything because it depends on my June schedule, but I seriously want to be there with the best Erlangers.

Thanks to Samuel Huron for the photo.

Here on my new Blog, I am planning to collect all the best blogs and sites about Erlang in the Community section. James will be surely part of it.

From time to time, I need to explain to people (here in Italy) why I am studying Erlang. For some people it is not a good choice because they think OOP is the unique and global programming paradigm that counts. I disagree with them and I think that religion wars are stupids, so I decide to study Erlang because I think polyglot programming is nice point of view. I can’t do everything with Java and I can’t do everything with Erlang. But it is great for a programmer to be able to choose the right tool for the job, understanding when one has advantages on the other.

I am feeling fine with Erlang syntax (if you are a real programmer you can’t complain only because the syntax is not C like) and I hope to work with this language in my future. At the moment I continue to learn how to use it reading books, blogs and writing here and when I will have enough experience I will like to write my personal response to Sudarshan Acharya’s blog post.

Links to the debate:

• Sudarshan Acharya’s – Erlang over-hyped or underestimated
• JLoius – A response to “Erlang over-hyped or underestimated”

Update 1 (26 December):

Here you can find another good post titled “Christmas Thoughts”. Nice to see that the thoughts of this blogger is very close with mine.

You will use Pattern Matching in three (fundamental) cases:

• Variable Assignement
• Controlling the flow
• Data filtering from complex structures

Let’s go in order with my bullet point list.

Variable Assignment

This argument could be hard to understand if you come from a classic programming language. Why? Simple, because you have to understand from the beginning that variables can’t be assigned, they can only be pattern matched. The = operator is not assignment operator, but it is Pattern Matching operator, and it compares the left side of the expression with the right side. It could succeed or fail.

For example, if the value in A is 1, and I write A=1 in the Erlang Shell, the Pattern Matching succeeds because the assertion is true. To make an assignment, you have to Pattern Match an unbound variable with the value you want to give to it. In fact, if a variable is unbound, the only way for  succeed in the Pattern Matching is to bound it to the value on the right side of the = operator. It is also important to understand that a Pattern could be composed not only by variables, but by literals too (integer, float, atoms…).

OK, now you are thinking, “Oh, so strange, and why I can assign a value to a variable only one time? So they are not variable. I’m used to do whatever I want with a variable”.

You are right, they are variables that don’t vary, because in this way we can forget about side effects caused by wrong assignments in some parts of the program.

We also can detect an error more faster because we have to search only for one place in order to find the wrong value.

As a little resume about this point: When you pattern match a value to a variable, if it is unbound the value will be assigned to the variable and the Pattern Matching is true. If the variable is bound, the value on the right side must be the same of the variable to have success in the evaluation, elsewhere you will get an error at runtime.

Controlling the flow

With this construct you can manage the flow control in a pragmatic way, it is intuitive and it will improve the way you write code.

Instead of using tons of “if clauses” you can be more pragmatic, in the case and receive statements (the first is a conditional evaluation and the second is about processes) or in the function definition. In this post, I will cover only functions, because the other two statements involve more knowledge, and these aren’t in the purposes of the post.

A function in Erlang, is defined as a collection of clauses and when it is called, Erlang chooses the right one by Pattern Matching the parameters list.

That is a very easy example:

greetings({woman, _Name, _Surname}) ->
     "Hello Madame";
greetings({man, _Name, _Surname}) ->
     "Hello Sir";
greetings(_) ->
     "Hello".

When we call the greeting function we could pass a tagged tuple, and based on the tag element Erlang will choose the right clause (using the Pattern Matching principles). It is a good habit to insert the last clause that matches everything, in this way we could return a default or an error value.

Data filtering from complex structures

In Erlang, you will surely use lists or tuples. Once you have one of them, you will surely need to extract or check the values in the structure.

Let’s start from the lists:
With lists, you can for example extract or check the value of the Head or the Tail of the list.

Example 1: The H and the T variables are unbound:

List=[1,2,3,4,5].
[H|T] = List.

In this case, after the evaluation of the second instruction, H will be 1 and T will be [2,3,4,5]. Because the Pattern Matching assign the value on the right to an unbound variable on the left. Don’t worry about the |, it is about Lists, I will probably cover it in a future post.
Example 2: Suppose that the H value is 1 and the T value is [2,3]:

List=[1,2,3,4,5].
[H|T] = List.

In this case we get an error at runtime, because if it is true that H matches with the head of the List, the T is not the same, in this case, the tail of the list has got 4 elements and T has got only 2 elements.

With tuples, it is quite the same thing, but we don’t have to think about the cons construct (|). Let’s go with a quick example before write some bits about the “don’t care”:

Tuple = {driver, "Lewis", "Hamilton"}.
{driver, Name, Surname} = Tuple.

In this case we have a F1 driver (my favourite) in the Tuple variable. In the second instruction, we check that the tuple contains a driver, pattern matching the first element with the atom driver, and then, if Name and Surname are unbound we could extract “Lewis” and “Hamilton” in only one instruction. If they are not unbound, we can instead check if we are dealing with the same driver, in the other case, we get a runtime error.
Something must be said about “don’t care” variables in the Pattern Matching. Erlang compiler is a kind entity, and if it understands that you are not using a bound variable it returns some warning as a reminder to you. But if you really don’t need them, you could make the variable start with _, so the compiler and others programmers will understand that the variable don’t care in the execution.

A variable  could be only an _, but in this case it is only a place holder that matches with all the possible values and it will never be assigned.

As Ulf Wiger remind to me in the first comment to this post, the only real “don’t care” is the _, while a variable that starts with _ (for example _Var) is a real variable, the only difference with the others is that the the linter has been instructed not to warn about them. So if you use for example _Var twice in a function, it will be bound the second time and if don’t pay enough attention, you could surprisingly obtain a  ”badmatch” error because the Pattern Matching could fail as for the other variables that doesn’t start with _.

Here an example:

% Surname is not used in the function so that we use the _ in front of it
get_driver_name({driver, Name, _Surname}) ->
     Name.

I hope this post could help someone to get in touch with Pattern Matching. It must be understand from the beginning because it is a masterpiece of the language, a lot of things are based on it, so don’t underestimate this concept.

Other resources:

• Learn you some Erlang for great good
• Erlang Programming (from page 33 to 38)
• Programming Erlang – Software for a concurrent world (page 18-19-20-21-25-26-30-31)

See you soon, happy Saturday night!

This is my first post, but instead of writing a long intro, I would like to share with you some bits of history about the language. For the intros you can always read the About page.

Before starting, I invite you to take a look at the following video, in which you can see Joe Armstrong, Mike Williams and Robert Virding (and Bjarne Dacker in the first minute of the clip) explaining the reasons why their telecom system is so simple, but reliable and powerful.

[google -5830318882717959520 nolink]

Nice, isn’t it? As you have just seen, they were using Erlang to implement a telecom system. They was working at Ericsson in those years and during the early 80s they were looking for a great programming language to solve some problems of systems that needed to be distributed, concurrent and fault tolerant. They was thinking about a language with scalability and reliability build inside of the language, but after long searches they understood that there wasn’t nothing like that. So that they decided to create a new programming language with those key features built inside itself. At the Ericsson Computer Science Laboratory they spent about 4 years prototyping and evolving the language that nowadays has been used in a lot of distributed systems across the world.

In my opinion (to be honest, not only mine) the focal point is that Joe and Company at the Ericsson Labs needed to solve a specific problem. That problem was not so common in those years, and they were focused on create something that was able to be different from the past experiences. So that, they got the insight of build those features directly inside of the language instead of build them at the top of it. This was a success for Ericsson but 20 years later it still remain a success for a growing number of developers not only in the telecom domain but in a large range of situations.

Erlang was released as Open Source in December 1998, and from then the community is still growing, the stable release of the language is the R14B. If you are not an “Erlanger” and you want to take a look without be forced to install the Erlang System on your machine, my advice is to visit TryErlang.org. On the site, you can go through some little but interesting tutorials and you can dive into this great language.

See you soon