**Thanks to Chandrashekhar who in the comments pointed out I could use mnesia:dirty_update_counter to do pretty much the same thing, I didn’t know about this function but it looks perfect**

For a project I am working on I need to have a sequence number assigned to each record in an mnesia table. This is fairly simple in most databases but mnesia doesn’t provide this option. The reason I need this number isn’t just to be used as a unique identifier, if that was all I need there are other techniques that would make more sense in erlang like using a combination of the node() id and a timestamp: {node(), now()}.

I need the sequential number so I can perform reporting on the table and keep track of the last record I processed, so I needed the number to be sequential and easy to query on. (I wanted to avoid date parsing)

So I decided to build a very simple little gen_server, and since it is very self-contained, I decided to release it out on github. Hopefully someone else will find it useful and if nothing else its a good example of working with mnesia and writing a gen_server. (at least I hope its a good example, please let me know if there is something I could improve)

Using the server is dead simple:

Sequence = sequence_server:get_sequence(impression)

When you call get_sequence you pass it either a string or an atom and based on that value the server will return the next Id. If this is the first time you are passing in the atom or string then it will create a new record for that value and return 1.

Here is the meat of the server:

F = fun() ->
Return = mnesia:read(sequence, Id, write),
case Return of
[S] ->
Seq = S#sequence.sequence,
New = S#sequence{sequence = Seq + 1},
mnesia:write(New),
Seq;
[] ->
SequenceRecord = #sequence{id = Id, sequence = 2},
mnesia:write(SequenceRecord),
1
end
end,
{atomic, Seq} = mnesia:transaction(F),

The first line reads from the Mnesia table and gets a write lock. The first part of the case statement is if a record is found for this atom or string value in that case it increments the value, writes it back to the table, and returns it. The second part of the case statement is if there is no record, in which case it creates a new record and returns the number 1.

You can check out the full source code here.

-James

One of the most challenging things about learning a new language isn’t just learning how to do something, but more importantly learning the best way to do something. "Best" in this context is of course very subjective, but for me it not only means correctness but also readability, brevity, and following what is the normal convention for writing code in that language. Erlang has lots of ways to do things. I am working on a small solution where I am pulling messages back from Amazon SQS and processing them in Erlang. Here is a piece of code I initially wrote to handle looping through the list of messages and processing each of them:

process_messages(H|T, SQS) ->
process_message(H, SQS),
process_messages(T, SQS.
process_messages([], SQS) ->
ok.
process_message(Message, SQS) ->
%%process message here.

I was showing Mark this code and it struck him as strange, the process_messages function is just going through every item in the list and passing it to the process_message function, so a perfect case for map. So I rewrote the code using the lists:map function:

process_messages(List, SQS) ->
lists:map(fun(X) -> process_message(X, SQS) end, List).
process_message(Message, SQS) ->
%%process message here.

This is much nicer and reads better, I could even inline this code if I wanted to but I like the descriptiveness of having a function named process_messages. But, this can be even more descriptive using a list comprehension:

process_messages(List, SQS) ->
[process_message(X, SQS) || X <- List].
process_message(Message, SQS) ->
%%process message here.

An even simpler line of code and once you get comfortable reading list comprehensions it makes much more sense.

(found a nice Erlang Brush for Syntax Highlighter over here)

Last year I saw Kevin Smith do a presentation at the local raleigh.rb group on this fascinating little language called Erlang. Erlang is a functional language that is dynamically typed. Its true power is that it makes concurrency, one of the most difficult programming problems, extremely easy. One statement that really says it all to me is this:

In Erlang spawning a new process is as easy and cheap as creating an object in an object oriented language.

The presentation peaked my interest and I dabbled with Erlang when I had time last year. I went to a couple of the local Erlang hack nights, I started reading the Programming Erlang book, and I checked out the prag prog screencasts (also by Kevin Smith).

Last week I went to a great 2-day training class on Erlang put on by Kevin down in Carborro at the co-working facility there. This class impressed me for a couple of reasons:

1) I feel like I finally understand Erlang and I can actually start a project using it.

2) I normally hate training classes, but this one was actually very effective. It put the focus on writing erlang code in labs, but the labs were just a problem and you had to figure out how to solve it. They weren’t the classic step by step labs that are just mindless instruction following, you really had to stretch your knowledge of the language and what you had learned to complete these labs. I enjoyed it so much that I am actually considering trying to put together a training course and becoming a trainer is one of the things I never wanted to do.

With all this knowledge I have started an interesting little project with Erlang. I am attempting to re-write the reporting section of Adzerk (the software that runs Ruby Row and The Lounge) using Erlang. I have been meaning to separate the reporting piece from the rest of the application (especially from a database perspective) for sometime and this gives me a great excuse. Erlang will make it easy for me to make my reporting system near time, advertisers and publishers will be able to see impressions and clicks seconds after they happen instead of the day after like how it currently works. (I know you could accomplish this in just about any technology, but Erlang makes it easier to do this and to scale in the ways I want to).

So if you are looking for a new language to pick up this year I would encourage you to try out Erlang. I plan on using it more and more and will be posting interesting tools or tricks I find to this blog.

-James