The first Erlang virtual machine capable of utilizing multicore and multiprocessor hardware, i.e. the Erlang VM with SMP support, first appeared in 2006. Since then work has been ongoing on improving performance and scalability. The increasing number of cores on common processors makes scalability issues very important. The scalability of the first VM with SMP support was quite modest, but has since then improved immensely and will continue to be improved in the future. During this talk we'll look closer at some scalability issues and how they have been addressed.

Distributed applications often use client-server techniques across a TCP/IP infrastructure. This talk presents a prototype infrastructure that abstracts the client out of programmers' code and can optimize inter-server traffic across datacenters. It is written in Erlang with an admin UI that is quite pretty because HTML5+CSS3+XSLT+JQuery rocks actually.

Whatever. The infrastructure is very simple, and works by sequencing calls on application-level servers following some initial event. It does this by collecting sets of fields, sending subsets to servers and collecting replies where appropriate, until no further work can be done. The result is, application backends that are declarative.

My feeble hope is that this opens up pathways including applications constructed by search, mutable applications that change many times a second, large-scale caching of server operations, applications that self-render and other things I’ve not thought of.

The target Audience is anyone dealing with distributed applications and
enterprise network and/or messaging infrastructure; including
architects, system reliability engineers and programmers.

Swarm is a continuous build server implemented in Erlang which presents a innovative twist to software quality assurance. The two core concepts, multi-platform build execution and automatic package generation, give projects the ability to provide users with exceptional support while requiring little manual effort. This talk describes how Swarm is used to enhance Erlang/OTP's development process. Further, the upcoming pre-build and tested packages of Erlang/OTP binaries for many free and commercial operating systems are discussed.

Hibari is a production-ready, distributed, key-value, big data store. Hibari uses chain replication for strong consistency, high-availability, and durability. Hibari has excellent performance especially for read and large value operations. Hibari is implemented in Erlang. As of July 2010, Hibari is open-source software under the Apache 2.0 license.

We'd like to talk about Hibari's major features and how Hibari has been deployed as part of large commercial Webmail system in Asia. We also intend to share recent benchmarking results (gathered by Yahoo!'s YCSB benchmarking tool) of Hibari and a few other open source key-value stores. The target audience are developers.

In this talk, Rusty will explain why Riak Core was built, discuss what
problems it solves and how it works, and demonstrate how a developer can
leverage Riak Core to quickly build their own masterless distributed
application.

How do you integrate a new component into a mission-critical, legacy system with the key requirement that existing functionality must not be affected? We used QuickCheck to specify the behaviour for the existing system and then we attached our component to validate its behaviour.

In this talk we highlight how property based testing using QuickCheck was beneficial and fun for our project where we lacked full documentation and understanding of the legacy behaviour. Using QuickCheck we were able to produce and validate that our component had the high quality requested as well as allow us to focus our testing into specific areas with very little effort.

The dream to build a game server in Erlang has been around for many years. Erlang has been used in games on the server side in some projects but it is not common, not yet. In the gaming industry, C++ has been the favorite tool for most developers when they need performance. This is now changing rapidly. Game programmers are learning and using new technologies, and Erlang is one of them.

In this talk David Almroth will present an ALG product for the gaming industry based on Erlang. It is a middleware product to be used on the server side and where the architecture is transformed from single-core to many-core. The product is used by server side programmers without having to learn any Erlang, which makes it easy to both embrace in the organisation and integrate in the game engine. Allowing a wider use of the power of Erlang.

RefactorErl is a source code analyzer and transformer tool aimed at refactoring Erlang software. The tool itself is written in Erlang with a unique approach: semantic analysis results are stored in a Mnesia database to avoid repeated analysis of the same source code, and simple, syntax-based manipulations are available that hide the details of handling separators, comments, and code layout.

Modern cars are filled with software. The software for cars is normally written in C and the specifications are at least as bulky as those known from the telecommunication industry. Different from Erlang software, it has some hard real-time requirements, where tasks definitely need to meet certain deadlines. Nevertheless, it is beneficial to test this software by using Erlang as a test framework.

We report on a project of testing an AUTOSAR component by using a combination of Erlang and QuickCheck. We tested the network management module of the Can bus. This network management module is specified as a state machine plus a lot of other details.The most challenging part is dealing with the timers that cause spontaneous transitions from one state to another when time progresses.

When evolving software we may introduce new corner cases that can pass unnoticed through the test cases in our automated test suite. Since developers rely on other's test suites when changing their code, the more developers work on a module, the more likely it is they slip a bug trough the test suite; that's something we though we had to live with. However, property based testing is emerging as a new hope, our last experiences say that it helps to create test suites more robust to software evolution without forcing us to write tons of "just-in-case test cases."

Klarna (currently) operates in six countries. We need to handle translations of PDF's, GUI, Emails, etc. The basis of our i18n system is built around the gettext Erlang application. To help us coordinate the translation work with the development process, we have developed a web-based tool named POlish. With POlish, translators can do their work from anywhere while still cooperating with a particular developer. POlish is released as Open Source and will be described in this talk.

As part of its transformation to agile, Klarna is enhancing its testing toolbox to better support Acceptance-Test-Driven Development (ATDD) and Continuous Validation. Originally working only with Yatsy and Eunit, we are now also utilising Common Test Framework, Fitnesse, Selenium and QuickCheck. The Klarna code base has grown organically for some years now, and so has the code dependencies. In order to create order out of chaos, we resorted to building a tool for dependency analysis and automatic code move. While this is not rocket science, we will share some experiences (and possibly also the actual tool).

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.