Let's talk about how to build real-world REST APIs with Erlang. Not examples or "hello, world" demos but APIs that will hold up under sustained use in production.

During our time together I'll talk about my experiences writing production RESTful servers in Erlang. I'll introduce webmachine, a great REST toolkit, and show you how to use it for maximum benefit. We'll also look at how to use parse transforms to dramatically reduce the inevitable boiler plate code associated with most large projects.

One of the reasons I continue to enjoy writing Erlang systems is how easy they are to maintain in Production. This talk will showcase a number of tools and techniques that will help you investigate and debug problems with production systems and allow you to resolve them with zero-downtime live upgrades.

Talk objectives: You'll learn how to use stock OTP tools like live code upgrade from the shell without appup or relup, how to use etop to find bottlenecks in your system, how to force crashdumps and inspect them offline, how to inspect and maintain your Production cluster.

Target audience: People who want to know more about the basic tools in OTP that they can use today to troubleshoot and fix Production systems.

We all know Erlang as a language has certain limitations (for better or worse). It also makes you write a lot of boilerplate code. Sometimes we can put up with it, sometimes it's just annoying.

I've been looking into different meta-programming techniques to be used with Erlang. I've been using parse transformations a lot (and gave talks about them). But that wasn't enough for me. I've tried investing some time in Joxa (joxa.org, which is awesome, btw), but I found that it is a little bit more of a Lisp than Erlang. So I continued my search, and took another look at Elixir (elixir-lang.org), which I dismissed last year. It went through quite a transformation and, in my opinion, became a decent meta-compiler for Erlang that's not too far away from Erlang itself.

In this talk I'll show how you can program Erlang in a much more productive way — and common pitfalls to avoid.

Talk objective: show that Erlang can have many "faces" — that suit different tastes.

Erlang developers are exhorted to learn and use OTP. This often entails letting OTP manage your message queues with gen_server, gen_fsm, gen_event, et al. Sometimes you just have to get your hands dirty managing messages. In those cases, proc_lib and knowledge of the sys package will serve you better than raw erlang processes if the rest of your system uses OTP principles. Jay will show how to use the proc_lib services, some tricks for managing message queues, and how the sys library is used to tie your low-level process programming into the rest of the OTP tools.

Talk objectives: Pull the hood back on OTP processes and show how to use proc_lib and sys to develop raw processes that can be traced and play nicely with the rest of OTP. There will also be some exposure to dbg and trace messaging.

Target audience: Erlang programmers who are comfortable with the syntax and language constructs, and are familiar with OTP concepts.

James learned Erlang because he wanted to make some minor customizations to ejabberd. Before he knew it, he was putting thousands of lines of his own code in to production. In this talk, James will discuss the good, the bad, and the ugly of writing and running his first Erlang service.

It’s 2008 and Ómar'swriting C# for a multinational bank. A few months later it goes bust.

This talk is not about that.

It’s about how Kóði went from knowing no Erlang to running a large market data production system in it and even hosting those systems within large financial organizations and why they are building even more systems in the language and why.

Ómar’ll touch on what they’ve learned, how they’ve screwed things up, but how, today, their Erlang solutions play an ever increasing role in many of Iceland’s leading banks.

Talk objectives: Explain pitfalls we fell into and what we learned from it and how we tackled the problem of deploying Erlang within organizations that require a lot of hand holding.

Target audience: Developers and people thinking about deploying Erlang within IT environments they do not control.

In my experience running UGs for the past 7 years, I have tried everything that I heard of that I was able to replicate: lectures, interactive presentations, hackathons, install-fests, big-name speakers... One format that stands above the rest is what I refer to as *Games. It is mostly based on teaching Ruby, but recently I started PDXErlang, and have been lucky enough to give people their first introduction to Erlang. I have studied how to conduct an exercise that introduces even non-programmers to best practices, and I tie that in to Adult Learning principles. I present to you: *Games.

Talk objectives:

- Outline exercises that teach Erlang effectively.

- Review principles of Adult Learning.

- Provide a different construct for considering Programming Language education.

Their Spawnfest2012 entry was ridiculously ambitious - a 'social' application involving real-time data-streams, R-trees, heaping doses of OTP goodness including gen_fsm, gen_server, gen_event, and much much more. Because this wasn't challenging enough, their three team-members were from three different countries, making both the application *and* the development distributed!

Join Mahesh as he takes you through their SpawnFest experience in all its glory (or infamy). Find out what worked, what features got tossed, and what failed miserably - and why.

Talk objectives: Learn about architecting complex multi-user 'social' applications, and then building them out under time-constraints.