Around 2003 I developed an interest in functional programming languages.
I played with Haskell, OCaml, Erlang and Clean and came away very impressed.
Pattern matching, referential transparency, higher order functions, list comprehensions,
all powerful constructs in elegant packages that functional programming languages are.
As enticing as these languages were, at work I had to stick to more mainstream languages;
employers and customers tend to be very conservative.
Fortunately during the past decade things have changed considerably.
Functional languages have gained a much broader attention;
Haskell has seen a lot of press, especially around Software Transactional Memory
The functional languages Scala and Clojure came into existence
and enjoy an ever growing community around them.
Products such as CouchDB, RabbitMQ, Riak and ejabberd
demonstrated the viability of functional languages,
and Erlang in particular,
for developing robust and widely used software.
These days the case for functional programming is a lot easier to make then 10 years ago.
Time to brush up my functional programming language skills.
Enter ErlangCamp Amsterdam.
A conference around one of the most interesting functional languages around,
given in my hometown was simply too good an opportunity to pass up.
Especially as it would address OTP;
Erlang's well renowned facilities for writing fault-tolerant distributed systems,
and the part I never got around to play with all those years ago.
Day One - August 30th, 2013
||Setup & Getting Started
||Erlang Essentials 1
||Erlang Essentials Pt 2
||Events & Logs
||VIP Dinner (site)
The first day started a bit slow.
Erlang Essentials 1 was fairly basic
and the exercises were simple.
I think we could have covered a little more ground during those first two hours.
On the other hand it did seem to make everyone at ease with the new environment and language.
I was very pleased though to be introduced to type specifications.
Dynamically typed languages such as Erlang have a number of advantages over statically typed languages,
but it is often hard to determine what a function expects as input and generates as output
merely by looking at the function signature.
Erlang Type specifications make this much more explicit.
They are primarily a documentation tool and as such not enforced by the compiler.
However a static analysis tool such Dialyzer
can utilize these type specifications to provide better feedback on your Erlang code.
Lunch was a bit of a surprise as it was not provided for.
Completely understandable given the very affordable price the conference was offered for (thank you SpilGames),
but I did not see it mentioned anywhere.
The good thing about it was that it gave me the opportunity to have lunch at Burgermeester.
A place I have been meaning to check out for some time now.
The afternoon picked up the pace.
We got a really good introduction to OTP.
That should not have come as a surprise
as the instructor, Martin J. Logan, is one of the authors of Erlang and OTP in Action.
The last session, Events & Logs was a bit difficult to follow.
It went a little fast and I was a little tired.
Not the best combination to learn new things.
Dinner was fun. Good conversations about Erlang, software development, and life in general.
Day Two - August 31st, 2013
||Meet and Greet (Socialization Time)
||Distributing Erlang Systems
||Releases and Deployment
||Drink & Talk Erlang
(if you want to)
Day two demonstrated some of Erlang's strengths during the Distributed Erlang Systems session.
Once you have seen Erlang nodes communicate
you will start to wonder why it is still
- Erlang was open sourced in 1998 -
so hard to do something similar in other languages.
I really enjoyed the Testing session by Thomas Arts.
I had previously heard a lot about QuickCheck for Haskell and Thomas demonstrated the Erlang version.
His exercise, a simple editor to transform one string into another by issuing edit operations, was fun to do.
It also demonstrated how powerful pattern matching can be to develop your functions iteratively, case by case.
Unfortunately I had to leave early and hence was not able to attend the Releases and Deployment session.
A pity as Eric Merritt
(one of the other authors of Erlang and OTP in Action)
had shown himself to be a very good speaker during the Erlang Essentials Pt 2 session.
If you are thinking about picking up Erlang as a new language
ErlangCamp is an excellent introduction to it and its ecosystem.
It is not a training course that teaches you all the ins and outs of Erlang,
but it does give you a well balanced impression of all the important parts.
This in turn allows you to direct your own learning much better.
You will learn, for example, that when you dive into interprocess communication that better abstractions exist in OTP.
You will get an idea about the configuration and deployment tools (rebar) at your disposal
and how to do testing (eunit, QuickCheck).
In short ErlangCamp is an excellent start to explore Erlang better.
I have only one minor point of criticism: the pace on day one could have started a
little faster and ended somewhat slower than it actually did.