Erlang/OTP positions itself in the niche for building fault tolerant software systems with redundancy over two or more independent nodes. However Erlang/OTP comes with surprisingly little built in support to make failover and takeover/migration of responsibilities between nodes in a safe way. The Fail Over and Take Over System (FOTOS) presented in this paper offers mechanisms to keep a consistent state over several nodes, and also detect partial network failures preventing individual nodes from making premature decisions. Applications cooperating over the network can make use of the guaranteed consistent information to make unanimous decisions when having to decide on to where now failed services shall be failed-over, and also in a potentially ongoing procedure where to resume the service.

We've been using Erlang at Mochi Media since the 2006 launch of MochiAds, our advertising platform for Flash games. It's the first time any of us have done any production software with a functional programming language, and thus far it's turned out to be a great experience. The success of the MochiAds platform led us to writing many other products (internal and external) on the same technology stack. We believe Erlang to be one of the key reasons why we're able to develop more quickly and scale more easily than our competitors.

Erlang exposes all of the functionality needed to build new programming
languages with ease. In this talk you will learn the basics of how to
create your own programming language on top of the Erlang VM, including scanning with leex, parsing with yecc, compiling parsed code from the Erlang abstract format into bytecode, and loading the resulting bytecode into the code server. The session will also cover the presenter's language: Reia, a scripting language for the Erlang VM.
The talk will cover how Reia is
implemented, what ideas it borrows from Erlang, where it deviates,
and how it is able to introduce imperative features while still
compiling to a functional form. It will also cover Reia's object-oriented features like classes, inheritance, and polymorphism as well as how they map to Erlang's process model.

Erlang is a powerful language for distributed computation, but most
modern production software is written in a variety of languages that
are not as suited to reliable, distributed programing. At Powerset, we
developed a platform for reliable distributed computing that leveraged
the Erlang Ports infrastrcutre to make the robustness and flexibility
of Erlang-based networked infrastructure to a variety of language
runtimes, without onerous cross-porting work. From that base, we
extended our system to support heterogenous networks of services which
can be added or removed in real time without interrupting existing
services, using a simple model akin to an erlang event loop to talk
with external code.

“Look Ma, no middleware”. This presentation is a tour de force
through building standalone CouchDB applications with nothing but HTML
& Ajax directly talking to CouchDB’s REST API.

CouchDB
applications run locally, on a users machine. Application data can be
replicated between users and central servers alike using a peer to peer
structure. Users can access their data when offline (for example when
on a plane). Even the applications themselves can be replicated (for
software updates) and tech-savy users can enhance their local copy and
make patches to their friends and co-workers available through
replication.

Bring your Laptop to follow along
when we build the example application. Bonus points, when you come with
a running CouchDB installation.

CouchDB w/ Lisp Flavored Erlang - talk by Tim Dysinger Tim will show some neat tricks playing with CouchDB and Erlang nodes. He has written some Lisp Flavored Erlang code to manipulate and map/reduce the Enron Email Dataset on multiple CouchDB nodes. He’ll show how to pull out miscellaneous aggregated data we might use in warehouse reports.

CouchDB and bibJSON and the Bibliographic Knowledge Network - talk by Nitin BorwankarThe Bibliographic Knowledge Network (bibkn.org) is an NSF funded
project to extract knowledge out of aggreagte bibliographies of
academic researchers. A foundation problem that needs to be solved is
one of author disambiguation ( is J. Pitman the same as Jim Pitman or
Jane Pitman ?). BKN is in the process of evolving workflows for name
disambiguation so that social network analysis of academic
collaboration can be carried with confidence in identity of
participants. Bibliographic data is available in mostly untyped or
weakly typed data which makes disambiguation difficult.
Our experience of the ease of use and robustness of CouchDB encouraged
us to evolve a next generation bibliographic data format (bibJSON)
which is in early draft form. We have evolved workflows that refine
untyped bibliographic data and convert it to data with strong identity
of authors.
We use CouchDB to anchor a lot of the workflows and Python client side
scripts to import/export data.
The talk includes an overview of the state of the BKN project and how
CouchDB is a foundation element of our technology.

This presentation takes a look at CouchDB from 10,000 ft. We try
not to lose you in technical details and paint the big picture that you
need to understand CouchDB’s strengths and weaknesses.

CouchDB
is a document oriented database. It does not adhere to the relational
principles of traditional databases. You will learn what that means for
your application design.

CouchDB’s replication
support solves the problems of high-traffic web sites, distributed
peer-to-peer, and offline applications all at the same time. We show
you what kind of applications you are able to build with that.

However,
CouchDB is no Silver Bullet and there are cases where it is a poor fit.
You will learn to decide when to use it for your project and when you
are better off with a different solution.

Disco is an open-source implementation of the Map/Reduce framework.The Disco core is written in Erlang, which makes the most critical components of the system, namely job scheduling, distribution and fault detection, remarkably compact and robust. Users can specify jobs in Python, with all batteries included, without having to worry about any issues related to parallelism. As the result, Disco makes it fun to process massive amounts of data with hundreds of CPUs in parallel. This talk will introduce Map/Reduce programming with Disco and show how to perform simple and some more complicated data-processing tasks with minimal amount of code. For Erlang hackers, and for future Disco comitters, the talk will include a walk-through of central components of Disco, showing how Erlang can be used to handle large amounts of data efficiently.

Recently, the EUnit unit testing framework for Erlang was shipped for
the first time as an official part of the Erlang/OTP distribution. While
the documentation is fairly complete, it is not always obvious how the
various features are supposed to be used in practice. Richard Carlsson, the author of Eunit, will in his talk focus on getting Eunit up and running, tweaking it to fit your build environment,
and leveraging its features in typical testing situations.
He will also briefly present some new additions since the R12B-5 release.

Erlang has been used to develop a number of applications at Facebook. Eugene Letuchy has been involved with this development and will discuss the reasons for choosing Erlang and the benefits it has brought.

Sumeet is a part of a small group at SAP Research that is using Erlang to develop a communications serviceprototype to connect real world devices with enterprise applications. The group has worked with Erlang for almost a year and in this talk Sumeet will discuss their experience in learning applying Erlang to the challenge of building a high performance rules engine. He will also discuss some of the results of their
work pertaining to scalability and performance.

Orbitz like many other advanced technology companies here in the states, Google, Yahoo, Facebook, uses service orientation. This talk will focus on where Erlang fits into that picture from a high level and how it is managed from a development, testing, and deployment perspective with the Erlware tools. This talk will put forward the efficient way Orbitz develops and maintains a production quality Erlang package.

Erlang was originally designed to build telcom systems. For most of its existence, most web developers have ignored Erlang partly because it was unproven as a web language and partly because it lacked good web development tools. This is unfortunate because Erlang's strengths in concurrency, distributed programming, and fault tolerance can be advantageous for many web applications. ErlyWeb was created to fill this gap: its goal is to make it as easy to build websites in Erlang as in other languages while allowing developers to leverage Erlang's unique capabilities. In this talk, I will give a brief overview of ErlyWeb and demonstrate how to use ErlyWeb to create a simple real-time web-based chat application.

Dynomite is an open source distributed key value database modeled after
Amazon’s Dynamo. Dynomite was built from the ground up to support what
would be a traditional RDBMS’s worst nightmare: low latency random read
and write access to large binary objects.

Dynomite is different from memcache style distributed hash tables in
that it handles all routing and failover internally. Clients need merely
connect to one node to have access to the entire cluster. It can provide
low read and write latency to clients even in the face of node failures
due to its relaxed consistency constraints.

During this session we will discuss how to tell whether Dynomite is a
good fit for an application. Discussions will also include dynamic
cluster configuration, how to choose an appropriate storage engine, and
how to tune a Dynomite cluster for some common scenarios.

Following the talk on the McErlang Model Checker by Lars-Ake Fredlund, Clara Benac-Earle will provide a hands-on demonstration of the tool for those interested. Delegates will be shown how to install it onto their laptops and then they will be taken through some exercises to demonstrate its usage.

Erlang supports hot code loading at the language level as a differentiating language feature, but it can be confusing to use in practice. OTP provides a high level interface via the concept of releases, but the OTP model is geared towards environments where changes are large and infrequent due to low risk tolerance (substantial QA), and deployed to a relatively small amount of static nodes. For the typical startup, code changes are small and frequent, risk tolerance to changes is high but fast rollback is essential (i.e., there is essentially no QA), and the number of nodes is large (and on EC2, dynamic).

In this talk I describe an alternative high level interface to hot code loading which leverages the OS package management system (e.g., rpm, deb). In addition to being a better fit for the typical startup, it has advantages in a heterogenous environment where Erlang is one of many interacting and dependent technologies deployed, by creating a uniform method for treating code distribution, dependency specification, and provisioning.

While Erlang has much in common with other functional
languages it does many things differently from other languages. In this talk one of the three inventors of Erlang will look at the rationale behind Erlang and try to show how many of its
important features combine to work together. We will also look at how Erlang
was first developed to show the reason for some of the features in the
rationale.

This talk is about the history of CouchDB development from a very
personal point of view. I'll talk about my inspirations for CouchDB and
why I decided to move my wife and kids to a cheaper place and live off
savings to build this thing. I'll discuss how the project has
progressed and evolved, the decision to switch to Erlang and the
transition to joining the Apache Foundation. It's also about the day to
day grind of working alone at home for months on end, how I deal with
feeling panicked and overwhelmed and trying to make progress through it
all.

With functional style, message passing concurrency primitives baked in
and the power of OTP for building fault tolerant applications, Erlang
is the best in breed programming environment for making horizontally
scalable network servers.
With a clean object model and beautiful, concise syntax, Ruby is
one of the most productive and expressive dynamic languages available
right now.
Both of these platforms have great strengthsand weaknesses. Erlang
syntax is bizaar for most programmers and String and IO handling are
fairly primitive. Ruby has some scalability limits like 1024 open
sockets or file descriptors and no true concurrency, only green threads.
In this talk we will explore a melding of the two called Nanite.
Nanite is a framework where you write 'agents' in Ruby and use
RabbitMQ (Erlang) as a messaging bus/hub. We can exploit the power of
Erlang's message passing and scalability to distribute the work our to
Ruby 'Nanites' that implement functionality. This ends up looking like
an exploded Erlang VM where the actors are implemented as Ruby
processes with Erlangin the middle holding everything together. With
this powerful combination we get to play to the strengths of each
language to build a hive mind of interconnected processing power.

The talk will give a brief history of Kreditor and will then will go into some
detail about the system architecture of their 24x7 system that serves
some 3000 E-stores. In particular, the use of Mnesia in a non-distributed
mode will be described as well as how this was utilized in the
move of the system to a different data centre.

In this talk we will describe and demonstrate Lisp
Flavored Erlang (LFE). LFE allows you to write Erlang code in a lisp
syntax and combines the versatility and extensibility of lisp with the
COP power of Erlang. LFE is completely integrated with Erlang/OTP and
code written in LFE can freely be used together with modules written in
vanilla Erlang and applications in Erlang/OTP. LFE is also much easier
to use than vanilla Erlang when generating code. We will describe the
system, its tools and its implementation, and also demonstrate some of
its features and using its programming environment.

Erlang isn't good for everything. Neither is Ruby. But together they create a powerful force that can be harnessed to engineer highly scalable systems that defer to Ruby for more mundane tasks. The secret to this unholy alliance is a two way communication layer called Erlectricity that lets you craft Ruby nodes that receive messages just like Erlang processes.

I will demonstrate how this setup can lead to elegant and extensible system design with simple examples, and then explain how Erlectricity helped us build a self-assembling, YAWS based meta-server called Fuzed that lets you put Rails apps or other Ruby servers into a heterogenous cloud.

OneTeam Media Server is a new project launched by ProcessOne which is a Media server for Flash clients implementing the FLV and RTMP protocol. The project is designed so that it can work hand in hand with ejabberd, ProcessOne Instant Messaging platform. This presentation presents the goal and the architecture of the project and demonstrates the video platform. We will give performance feedback on Erlang use for binary processing in a highly demanding context.

Test-driven development may not be the first thing you think of when Erlang comes to mind, but it should. Using test-driven development, you can save substantial amounts of time, effort and energy. Nick's presentation will step through Erlang related test-driven development patterns as well as the tools and software available to Erlang engineers.

Erlang programs are easily ported to multicore; one gets a great speed-up for free, because the Erlang programs are concurrent in nature. Nevertheless, running your Erlang application on a multicore processor may well reveal errors that you have never spotted before. The Erlang scheduler on a single core is very deterministic and certain sequences of events simply cannot occur, although they do occur in theory and certainly on a multicore. Since the number of possible interleavings on a multicore is impractically large, successfully running your old test suite may not give you the confidence you need to ship you software. More testing is necessary, but running the same suite many times or adding more test cases hardly solves the problem.

As a result of the ProTest research project, QuickCheck comes with an extension to test Erlang programs for multicore. Defects that cannot be detected on a single core, can be revealed by this extension. The extension also improves the analysis phase of the defect by presenting the simplest interleaving that lead to the defect and a visualization of the messages send and received.

Michal Slaski will be presenting the Erlang Web.
The Erlang Web is an open source framework for the rapid prototyping
and development of applications based on HTTP protocols, giving the
developer better control of content management separating data, html
generation and glue and logic. While some Erlang frameworks are focused on getting started quickly, the Erlang Webtries instead to be complete. During the talk Michal will discuss
concepts implemented in the framework, show results of stress tests and
present a short demo. Emphasis will be made on the latest features and additions to the framework.

In this tutorial Lars-Ake Fredlund will introduce the McErlang model checking tool for verifying Erlang programs, and examine some case studies where the tool has been successfully applied.

Model checking is a verification technique where the all the states of a program are systematically explored and checked against correctness properties. Although very effective in hardware verification, there are a number of problems when applying model checking to software:

- Need for abstraction: to use a model checking tool it is often necessary to abstract the source code, almost never is the full source language supported.

- State spaces are too large for model checking algorithms to work.

In the design of the McErlang model checker for Erlang we have addressed both these problems. The language supported is full Erlang, with normal datatypes, processes, nodes, links, monitors, and so on. Moreover its verification algorithm provide some answers even when state spaces are huge (becoming more similar to testing).

In addition to the Tutorial, there will also be a Hands-on session where Clara Benac Earle will be covering the basics of the McErlang tool. This will allow delegates to install the tool and try it out with the help of some exercises.

Nitrogen is an exciting framework not just for what it brings to the
table, but also for what it leaves behind. By leveraging Erlang records
as a surprisingly elegant markup language, discarding MVC in favor of
an event-driven architecture, and only supporting Javascript-based
forms, Nitrogen challenges many existing notions about what an Erlang
application/web framework should do, and has invigorated others in the
Erlang community to think unorthodox thoughts while building their own
projects. Rusty will present a high level overview of Nitrogen, dive
down to walk through a sample Nitrogen application, and then discuss
the future of this rapidly maturing framework.

Although Haskell and Erlang are both functional languages, they diverge
in many ways in their approaches to building software. In this talk,
we'll look at some of the key differences between the two languages,
and show off some of the most exciting development and testing
techniques that the Haskell perspective enables: how to write
bulletproof, elegant code that executes blazingly fast.

No product specification would ever ask us to make a GUI freeze during a DNS lookup, increase the latency of server requests, or leave needed processing hardware sit idle. Yet even software delivered by well-funded teams of professionals commits these offences - all from a hesitance to tackle the problems of concurrency. But with conventional languages and environments, concurrent programming is difficult and dangerous.
Erlang is promoted as a "concurrency-oriented language". Its core
language provides a minimal set of concurrency primitives, providing a
foundation for the full-featured support in the OTP library. But
equally important is Erlang's intentional omission of dangerous
features, which allow even imperfect programs to run safely and
securely with high availability.
This talk introduces the Erlang way of concurrency, from basic
language primitives to architectural patterns, and how to apply them to
designing, programming, testing, debugging, and running your programs.
We'll also discuss performance and distribution.

Picking the picking the right tool for the job isn't easy, especially when you have many options to choose from. Regardless of the job one aspect to take into account is performance. This talk will pit Apache, nginx, Lighttpd, Yaws, inets:httpd and MochiWeb against each other in a battle royale of performance. Who will come out on top?

Webmachine is a system for easily and declaratively building well-behaved HTTP applications in Erlang. It is based on a very different execution model than most frameworks, making it easy to focus on writing the core of your application while also helping you do the harder parts of HTTP right. Justin Sheehy will discuss Webmachine's unusual Web programming model and demonstrate how to quickly build and extend Erlang / Web / REST applications.

Many languages today have at least one good XMPP client library. Ruby?
Check. Java? Check. Python? Check. Even so-called "academic" languages
like Haskell have at least one XMPP client. Erlang -- a language bred
for message passing and concurrency -- is sadly lacking a good client.
In this talk, I will describe how I used Erlang's core strengths to
build a working XMPP client in 5 days. I'll also share the lessons I
learned using Erlang to rapidly prototype and deliver a working
solution.