Until the end of 2009 Erlang/OTP was largely developed behind closed
doors at Ericsson with only basic opportunities to contribute by the
community. The move to Github has changed the ecosystem drastically,
making it possible for developers outside of Ericsson to contribute.
However, contributors need to follow guidelines to make everybody's life
easier. This change has also allowed others to improve the process
where possible, thus helping to raise the profile of Erlang as a mature
and active open source project.This talk explains the development
process for Erlang and highlights how external contributions are being
handled. Further the efforts of Erlang Solutions to provide continuous
integration and package generation for all contributions are presented.
Finally the future of Erlang development will be discussed.

With rising popularity of JavaScript as server-side programming language, wouldn't it be interesting to use potential of both Erlang and JavaScript? Beam.js is a modular JavaScript platform built on top of V8 that connects two powerful languages — JavaScript and Erlang at a very low level by embedding V8 into Erlang VM. With Beam.js JavaScript lovers can piggy back on Erlang’s solid distributed networking infrastructure as well as other powerful components. For Erlang users, it can provide a powerful way to describe top level business logic on top of their robust architectures.

Erlang OTP was the platform of choice when building Membase's clustering. Ensuring membase is tested is important, and behavior driven development (BDD) is one efficient way to ensure software matches it's intended behavior. Cucumber is BDD done with "elegance and joy", so Steve Yen of Membase, Inc. authored and Open Sourced cucumberl for BDD with Erlang. Learn the basics of BDD, cucumberl, and how to contribute.

Online games backend are challenging applications, a single user generates one http call every few seconds, usage volume can spike very quickly and balance between data read and write is close to 50/50 which make the use of write through cache or other common scaling approaches not so effective.Follow how in our quest for a better architecture to serve millions of games sessions daily and reduce our resource usage we took the decision to write in Erlang our third generation game backend, see how we’re leveraging the actor model in order to change how we use and conceive our persistency layer. See also how introducing Erlang as a new tool in a company is working out, what we found hard from an organizational and technical point of view, which obstacle we hit and how as technical guys we convinced our management to take the risk of bringing in house a different technology.

Target audience: This talk is addressed to those developers who are introducing or evaluating the introduction of erlang as a new tool for critical projects.

Talk objective: Sharing the history of the first erlang project in our company since the initial idea and evaluation through the first few months of actual implementation, will be shown how working on this project compares to similar projects using ruby and discussed how we're mixing the use of erlang and ruby for different purposes. This can be a useful base and term of comparison for others willing to follow this path.

Rebar is an Open Source project that provides a set of standardized build tools for OTP applications and releases. This talk will explore how to use Rebar in a typical development environment for everything from simple Erlang code to port drivers and embedded Erlang servers.

Talk Objectives: Introduce the major features and functionality that rebar provides to Erlang developers. Examine the architecture of rebar and discuss how it can be extended.

Target Audience: Any Erlang developer interested in using or extending rebar for their build system.

JInterface is a library which allows JVM based applications to participate in Erlang distributed systems as nodes. Beyond its use for integrating Erlang and Java, JInterface may be used as a messaging layer for building distributed applications on the JVM. In this talk we will demonstrate how to build, test, and deploy a polyglot distributed application with Erlang and Scala.

Target Audience: Erlang programmers with an interest in Scala or other JVM languages.

Talk Objectives: The audience should leave knowing why they would want to build a hybrid JVM / Erlang distributed system and how they would go about building such a system.

Building distributed systems is notoriously difficult. Although techniques such as vector clocks make writing correct software more tractable, they are themselves very tricky to work with. The Riak decentralized key-value store is one of the best known open source systems that uses vector clocks. We have developed a Haskell client for Riak. Our client uses Haskell's type system to optionally make the use of vector clocks transparent, allowing the application programmer to concentrate on their business logic.

We will talk about the design considerations for our client, how we use types, and what factors we believe are important in building solid distributed applications.

For many programmers, Erlang program development remains a relatively primitive process in the sense that it only consists of firing up one's favourite editor, writing a program, compiling it, and running it.

Although there is a certain old fashioned charm in doing things this way, this style of programming is hardly adequate for modern, disciplined and easily maintainable Erlang program development. This talk will present how a suite of software tools can complement this process by automatically detecting bugs in Erlang programs, adding machine-checkable documentation that document the intentions of their programmers, automatically creating tests from this documentation, and revealing subtle concurrency errors. Cool tools that are well-known to Erlang community as well as some new ones will be presented.

Target audience: Erlang programmers with an interest to disciplined programming.

Talk objectives: Describe the proper use of software tools that aid Erlang programming and introduce some new ones.

Erlang is ideal for writing robust highly concurrent applications and allows for a flexible design that is easily scalable and readily extensible. CouchDB's replication and sync capabilities make it ideal as a datastore on mobile devices. What happens when you put all these components two together? During his talk, Damien Katz will provide a brief introduction to CouchDB, illustrate how CouchDB functions as a datastore for mobile devices and the challenges of porting to mobile environments like iOS and explain its native replication capability to solve user issues with low, intermittent or no internet connectivity.

Target audience: Medium technical level with an interest in web or mobile dev.

Talk objectives: To show how Erlang can run on constrained devices like mobile phones. And how CouchDB's data sharing model is a good fit for that.

Erlang deployments are generally known to be troublesome but this is not their true nature. It is generally an artifact of the tools and methods used to build and operate them. This talk will discuss how to build, release, upgrade and deploy Erlang projects based on production experience with CouchDB and BigCouch at Cloudant using tools like rebar and Chef.

With the rise of highly centralised social network, is a big risk of centralisation of lot of data in a single place. This is a point of failure and a threat for privacy. XMPP protocol (eXtensible Messaging and Presence Protocol) is a protocol designed to build decentralised, federated infrastructure. Known for synchronous communication, XMPP is also very good at typical asynchronous communications found in social networks. I will present the OneSocialWeb initiative to build federated social network with XMPP and focus on the pubsub based implementation we did for ejabberd server.

ejabberd is the reference XMPP server implementation, built in Erlang, know to support millions of users and its thousands of deployments around the world. By supporting federated social network, we considerably increase the reach of those technology and the possible use case of ejabberd.

Target audience: Erlang developers interested to know more about ejabberd flexibility and possible customization.Project manager wanting to learn how Erlang helped ejabberd become the de facto reference Instant messaging server and how it could help doing it again for federated social networks

Talk objectives: The talk want to demonstrate how Erlang is at the core of ejabberd success and how flexible and easy it allows us to implement new custom feature in our platform.

- A C pre-processor and parser- A type checker and program normalizer- A back-end target code generator which generates LLVM-assembler code- A Constraint Solver (Gecode)- LLVM

Erlang is used to transform C to LLVM-assembler. LLVM is used to optimize the code and produce code for common targets. Constraint logic programming techniques and Gecode are used for instruction scheduling and code optimization.

ECC is intended for writing C compilers for unusual architectures, for implementing domain specific languages and for experiments with JIT compilation.

The current compiler now in its fourth rewrite performs normalization of C programs producing typed data flow graphs. Joe will talk about the evolution of this program, and the mistakes that lead to it being rewritten [1] four times.

Erlang is ideal for writing robust highly concurrent applications which take full advantage of today's multi-core computers. NVIDIA's CUDA API is great for using GPUs to rip through large datasets at incredible speeds. What happens when you put these two together? During the talk Kevin will provide a brief introduction to CUDA, illustrate how to integrate CUDA-enabled code with Erlang, discuss the pros and cons of using CUDA, and cap it off with a live demo.

Target Audience: Erlang programmers interested in using CUDA in their own projects.

Whether you are using Erlang-powered applications or writing your own,
Erlang and OTP can give you superpowers. My own discovery of these
powers started when I needed a better XMPP server and led quickly to
designing entire systems with Erlang. I will talk about how you can get
your own superpower, my experiences with using Erlang superpowers (for
good!), and show an example of how Erlang gives my own projects a
competitive advantage.

Target audience: Erlang newcomers and people interested in, but not yet using, Erlang.

Talk objectives: This talk will introduce and give examples of Erlang strengths. It will show how these strengths were used to create the backend service for a real-time, multiplayer iPhone game.

Erlang use at Ericsson is on the rise. The EricssonTV division is in the midst of a rewrite of their video-on-demand backoffice system, and are using Erlang heavily. We will examine the reasons for choosing Erlang, the roles it is filling, and the tools we are using along the way.

From rabbitmq to rebar to log4erl, drivers like gen_bunny, emongo and erldis, and protocols like LSCP, RTSP and DSMCC, a majority of the system has transitioned from Java to Erlang. Distinct components now perform their duties for setting up VOD streams at much larger scale. As a result, customers of the new system are able to consolidate backoffice deployments from 200+ headends across the country to four regional data centers which allow elastic processing capabilities and fail over seamlessly between each other.

Talk Objectives: To provide a case study that explores Erlang's leading role in a major system rewrite. We will talk about the unique features that make this language choice very compelling for the project's design goals.

Pseudo Random Number Generators (PRNGs) is a key component of providing randomness in Erlang. In this talk, Kenji will explain the current status of the PRNGs in Erlang/OTP, the security and performance implications, and how they could be improved by introducing new algorithms. Kenji will also describe the details of implementing the SIMD-oriented Fast Mersenne Twister (SMFT) PRNG as Erlang/OTP NIFs.

Target Audience: Programmers interested in the internals of Erlang/OTP libraries and the NIF programming, as well as users intending to use Erlang/OTP for simulation, modeling, and security applications.

Talk Objectives: Sharing the characteristics and pitfalls of handling random numbers with Erlang/OTP, and showing an example of implementing a better PRNG as NIFs.

This talk describes how Escript changes the game for the development and deployment of Erlang systems. The talk shows a variety of escript applications used in live Erlang systems and cunning tips and tricks you can use in your own escripts to better integrate Erlang systems with UNIX environments.

From init scripts to make replacements, escript can help you use your existing tools to manage, monitor, and maintain your Erlang systems.

Target audience: People who develop, deploy or run Erlang systems on *nix operating systems.

On the face of it, property-based testing is a no-brainer: you write shorter, clearer test code, and in return test your system more thoroughly using thousands of generated tests. In practice, many developers are unsure where to start. How do you come up with good properties? How do you generate good test data? How do you evaluate the quality of your testing?

In this talk, I’ll show how to overcome these difficulties, and give rules of thumb that can help you get started with property-based testing. The talk is based on QuickCheck Mini, the free version of QuickCheck from Quviq, so you will be able to apply the lessons from the talk directly.

The first part of the talk is a quick tour of The Lively Kernel - a complete metacircular IDE written in JavaScript, and thus *just* a web page, able to run without download or installation.

My reason for wanting to speak to the Erlang community is that Erlang shares with Smalltalk and JavaScript the ability to update methods on the fly, and thus to support a lively (ie self-describing and editable) IDE. The talk will communicate that this is not terribly difficult, and that it is both a fun and a valuable pursuit.

The second part is a quick tour of what it takes to do a similar metacircular job of supporting End-User Programming (Drag-and-drop UI construction together with simple scripting of application logic); again, it is not that hard -- something any of you better Erlang jocks could have a lot of fun with.

Telecommunications systems and Neural Network (NN) systems have a lot in common, and any programming language that was created for one, by extension is applicable to the other. This presentation covers how Erlang's various features make it a powerful NN programming language which gives us an ability to develop highly scalable, and fully distributed Neural Network and parallel genetic algorithm systems. An exploration of the new functionality that Erlang can add to Computational Intelligence systems will be discussed. Finally, a case study of DXNN, the first and highly efficient Topology and Weight Evolving Artificial Neural Network developed purely in Erlang, will be presented and analysed.

NIF's are the bees' knees. We've seen how concise a NIF can be for communicating with C but this talk will focus on the various facilities that exist for making large and complicated NIF's exist peacefully within the Erlang VM. There will be examples of using resources, threading, and arbitrary message passing to communicate back to Erlang. Emonk is a binding to the Spidermonkey JavaScript VM and will be used as an example of how these features can be combined to create a non-trivial NIF.

Talk Objective: The audience should leave with a thorough understanding of the advanced NIF APIs and their usage. We will also demonstrate how these APIs can be combined to write a non-trivial NIF that is capable of integrating an entire JavaScript VM into Erlang.

The NIF interface introduced in R14 has made it easier to interface native code. It also interfaces native code more efficiently than using a linked in driver. However, making it easier to interface native code also made it easier to destroy the responsiveness of the system by blocking the system for long periods of time. It is also hard to take advantage of the efficiency of the NIF interface in all situations,since it lacks the ability to easily handle externally triggered I/O events.

During this talk we will look closer at planned future extensions to the existing native interface. These extensions will make it easier to write and/or integrate existing native code without destroying the responsiveness of the system. They will also make it easier to utilize the efficiency of the NIF interface in situations where a linked in driver previously was the only option.

Target audience: Anyone interested in the runtime system of Erlang, and especially people writing linked in drivers, or NIF libraries.

Talk Objectives: To give the audience some insights into planned future improvements of the native interface.

When your box starts swapping and your users complain, it is hard to know where you should start looking. There is a lot of information hiding in your erlang node. Get the big picture from your system, record trends after code changes and integrate this process into your build/qa.

Emetric is a headless tool that helps you do this. It is self contained, inspired by rebar. It hot loads itself into any node, inspired by eper. It generates a lot of information.

Target audience: People interested in quick tools which gather metrics from erlang.

Talk Objectives: Demonstrate how to write simple self contained erlang apps. Show where all the erlang statistics are. Demonstrate stress test with tsung and ejabberd and show how to get performance data.

Low coupling between modules and high cohesion inside each module are
the key features of good software architecture. Systems written in
modern programming languages generally start with some reasonably
well-designed module structure, however with continuous feature
additions, modifications and bug fixes, software modularity gradually
deteriorates. So, there is a need for incrementally improving modularity
to avoid the situation when the structure of the system becomes too
complex to maintain.

We demonstrate how Wrangler, a
general-purpose refactoring tool for Erlang, can be used to maintain and
improve the modularity of programs written in Erlang without
dramatically changing the existing module structure. We show how we
identify a set of "modularity smells" and then demonstrate how they are
detected by Wrangler and removed by way of a variety of refactorings
implemented in Wrangler.

Aptela provides hosted communications services for small business. Our platform includes complex call routing, messaging, web-portals, mobile apps, PSTN/SIP access, and a coffee-grinder attachment. At peak, we handle dozens of calls - and an infinity of HTTP requests - per second

Last year we swapped out our (homegrown) EJB/Postgres based platform with a (also homegrown) highly distributed OTP/CouchDB based one. It wasn't an easy switch given the peculiarities and pitfalls of designing for a call-processing world.

In this talk, I'll describe our architecture and process model, with an emphasis on issues we've faced re: race-conditions, memory constraints, hot upgrades, all whilst accessing and working with extremely large amounts of data in a near-real-time manner.

Even if Erlang technical relevance has been proven on large scale applications, the choice can still be questioned when you want to create an open source community. Indeed, while Erlang community is still expanding, as of now it remains small compared to mainstream languages.

U.C.Engine core is an open source persistent publish / suscribe server written in Erlang. It allows you to build real time collaboration applications... Even if you don't know how to code in Erlang.

In this presentation, we will explain how the distributed architecture and the REST API of U.C.Engine gives a gradual learning and contribution curve and enables the involvement of a wider set of coders.

Target Audience: Anyone interested in using Erlang for an open source project

Talk objectives: share with the audience how we can create a gradual contribution curve for an open-source Erlang project and expand our community.

Membase, created by some of the top contributors to the memcached project, had a need for a distributed system when building the Membase NoSQL database. The system had to ultra-reliable, portable, and easy to program. Building on Erlang and OTP to manage the existing core runtime, the membase project able to quickly build a simple, fast, elastic NoSQL database.

This talk will show how Membase clustering comes together, talking about the successes, design decisions and challenges encountered along the way.

Riak is an open source, fault tolerant and eventually consistent distributed database from Basho Technologies. We set out to verify Riak's behavior during node failure and partitioning using QuickCheck.The talk will cover the different strategies we used to model the system over a week of testing and show where we ended up.

The talk will introduce an RPC-over-HTTP system that allows to easily expose services written in Erlang. Input and output call parameters can be represented in JSON, XML and Google Protocol Buffers formats.

Piqi-RPC automatically validates input and output data and maps it to native Erlang data structures, removing the burden of writing codecs by hand. In contrast, writing codecs manually is inefficient, error-prone, and difficult to maintain for complex data structures and several different formats.

The systems also includes a client application for making remote calls that interprets command-line arguments as input parameters. The ability to call Erlang services using command-line interface is in many cases more convenient and safe compared to using Erlang shell.

A practical demonstration will be given as a part of the talk.

Target Audience: Erlang developers who look for a convenient and reliable way of integrating services written in Erlang with non-Erlang clients or providing command-line interface for Erlang services.

Talk Objectives: Introduce the Piqi-RPC system and demonstrate how it can be used for creating HTTP and command-line API for services written in Erlang.

We've built an open-source product that automatically deploys, scales and distributes VoIP calls across the Internet on commodity or virtualized servers. It fully utilizes Erlang for VoIP logic as well as relies on other Erlang products like CouchDB and RabbitMQ. It's got an awesome set of APIs and some other nifty features.

A new OTP behaviour named 'gen_stream' is proposed for R15. It features a simple interface for consuming serial streams which reside on slow media, are generated computationally or may be infinite in length. Internally, the stream may be prefetched and/or generated concurrently, allowing the application implementor the ability to declaratively define the concurrency characteristics, improving the performance characteristics of the data source.

The inspiration for gen_stream came from Tim Bray's Widefinder challenge and the ensuing discussions and submissions of the Erlang mailing list members in attempting to efficiently handle text file I/O and analysis.

Target audience: Anyone who has complained of slow serial I/O performance, was involved in or observed the WideFinder competition, or needs to efficiently generate or simulate infinite data streams or transform serial data on the fly.

Talk Objectives: Introduce the API and implementation of the gen_stream behaviour and its approach of prefetching data buffers by striping across processes to leverage overlapped I/O.

Riak Core is the distributed systems foundation for the Riak distributed database and the Riak Search full-text indexing system. Riak Core provides a proven architecture for building scalable, distributed applications quickly. This talk will cover the origins of Riak Core, the abstractions and functionality it provides, and some guidance on building distributed systems.

This talk describes how we took Apache CouchDB and stretched it into a clustered database we call BigCouch. BigCouch clusters behave according to concepts outlined in Amazon's Dynamo paper while supporting the better part of the CouchDB API. The cluster nodes communicate via distributed Erlang links and use CouchDB's replication protocol to synchronize ring membership and database partition maps.

In the presentation he will share some of the finer details of Erlang/OTP gleaned from running BigCouch clusters in production, including why proper supervision trees are useful for hot code upgrades, what can go wrong with anonymous functions on remote nodes, and how to block a sender using nothing more than the ! operator.

Because shipping products is the only thing that generates revenue, you need to be sure that products shipped are of a high standard and completed on time. This talks discusses TravelPing experience of using Erlang and Kanban for two years to deliver stable Authentication, Authorization and Accounting (AAA) products.

Basho Technologies currently has 32 public source code repositories hosted by GitHub. Basho bundles 17 of them into Riak, our key/value store. What do they do? Why are almost all of them OTP applications? What *are* OTP applications? I'll survey Basho's code libraries on GitHub and discuss why you might want to use them in your Erlang-based code project and give a peek into upcoming Basho product development.

U.C.Engine is an open source project written in erlang (server) and javascript (front client). U.C.Engine allows you to build real time applications like collaboration based services, live meetings, games or anything that fits well in an event driven philosophy.

In this hands on workshop, we will dive into the code and show you how to build a fancy realtime collaboration with the framework.

Disco is an open-source MapReduce framework whose core is written in Erlang. Today, Disco is used by Nokia to store and process tens of terabytes of constantly updating log data.

We will talk about tricky issues we have faced when running Disco with production data, such as heterogeneous workloads, multiple concurrent users, and evolving schemas. Thanks to this evolutionary pressure, Disco is starting to support exciting new features, such as jobs written in arbitrary programming languages as first-class citizens.

There have been very few Erlang implementations and today there is really only one widely used Erlang VM, the BEAM. This talk will describe the history of implementing Erlang and the BEAM, the differences between various implementations and how they have performed. It will also look at some issues which need to be considered when implementing Erlang.

The cutting edge and constantly evolving nature of scientific research makes it very hard to use relational databases to model scientific data. When a hypothesis changes, the observations change and the schema changes - large volumes of data may have to be migrated. This makes it very hard for researchers and they end up using spreadsheets and flat files since they are more flexible. Enter CouchDB and the schemaless model. The talk will take three real world examples and generalize to extract some principles and help identify where you might apply these.

Complex products such as Radio Base Stations require complex Test
Environments to achieve test automation with high test coverage. There
are many compelling reasons for selecting Erlang/OTP for this task, even
if the product itself is not developed with Erlang.

Target Audience: Anyone with an interest in integration or systems testing.

Talk Objective: Discuss using Erlang for testing (integration or systems) non-Erlang products. This includes systems that are partially developed in Erlang or have no Erlang whatsoever. The objective is to highlight the usefulness of common test application (part of OTP) and the power QuickCheck for property based testing, by discussing what has been achieved in practice within Ericsson.

AMQP is a powerful way to enable cross language and process messaging. In the AMQP architecture publisher clients send asynchronous messages to Brokers, using the AMQP protocol. The Broker temporarily, but reliably, stores and persists the message. In the meantime, a polling subscriber client uses AMQP to connect to the Broker and retrieve the message. Subscribers can also establish sessions in order to get notified immediately when messages arrive. RabbitMQ implements an AMQP Broker. But now that RabbitMQ includes plugins, it can be more than just a broker. This talk will show how to build a proper plugin and why this is so useful.

As an added twist, we have implemented a naive Bayesian classifier as part of our RSS plugin. Thanks to Erlang's rich functional programming model, this has made process of data mining an RSS feed, a very approachable, and scalable, solution.

RabbitMQ is widely used at AT&T interactive. In this talk Noah will
demonstrate the basics of writing a plugin for RabbitMQ.

Target audienceThere are two primary target audiences. The first target audience is a developer who is new to the Erlang language, but is interested in learning about the Ecosystem and getting more involved with the language and products created in Erlang, like RabbitMQ or CouchDB. The second target audience is someone who is primarily interested in RabbitMQ, and AMQP messaging.

Talk ObjectivesInform the audience about RabbitMQ, and how to write plugins in Erlang for RabbitMQ.