Riak Search is a distributed data indexing and search platform built on top of Riak. The talk will introduce Riak Search, covering overall goals, architecture, and core functionality, with specific focus on how Erlang is used to manage and execute an ever-changing population of ad hoc query processes.

Erlang and web sites are a great match. This talk will show you how Erlang solved the problems in building a flexible yet high performance CMS framework. A framework that works straight out of the box, is developer friendly, user friendly, and above all makes front end engineers happy.

We will start with describing the technologies and demands imposed by modern web sites and the usage patterns that web sites typically see. You will see how PHP and other popular systems solve many of these problems at the cost of major inefficiencies, and how we managed to solve most problems efficiently with Erlang.

This will bring us to the guts of Zotonic, its flexible datamodel and its module system. Afterwards you should feel confident enough to start making your own modules. We will also explain which open source projects are used inside Zotonic and how we have adapted them.

Finally we take a look into the near future where Zotonic will get a fault tolerant and distributed makeover for a large scale web platform for education, MaxClass by Maximonster Interactive Things. Are you the one who wants to help us?

We briefly review the state of commercial OOP languages and runtimes and their limitations. We argue that Actors and vector functional programming provide useful alternatives to address application challenges not well addressed by classical objects. We describe proven extensions of OO to support Anthropormpthic "Actor" concurrent object programming. We discuss the advantages of Vector Functional programming. Finally we comment on the need for affordances to move developers to high barrier functional languages.

Users of Erlang have a great deal of shared infrastructure, in particular a shared language implementation. All Erlang users have an interest in their shared infrastructure being maintained and improved but what is the best model to fund it?

This talk will look at the consortium model and in particular at how it has worked in the Haskell world. The purpose is to provoke an informed discussion of whether a similar model might work in the Erlang world.

Each year the University of Uppsala gives a project course for computer science students. The project specification is given by an industrial partner, in our case the company was Klarna.

During the period of four months we were to develope a scalable e-commerce framework using Linux, Erlang, Nitrogen and Riak. (The LENR "leaner" stack.) We were a group of 9 students with no experience in project management and no prior knowledge about Erlang.

We will talk about our experiences with Erlang and how they compare to those of other languages, why making an e-commerce framework in Erlang is a good idea, and how you can get scalability almost for free. We will also talk a little bit about our experiences with Nitrogen and Riak.

We are going to talk about how SocialCaddy, the first CRM for friends, uses the best of two worlds: Google AppEngine as a front-end system, ready to handle a lot of traffic without needing any administration from your part (set and forget); and an Erlang cluster, running on dedicated servers doing background tasks and sending data with lightning speed to AppEngine.

AppEngine is the best thing since sliced bread. But it's not particularly good for crunching data. Meet Erlust. Erlust (the cluster behind www.SocialCaddy.com) communicates with AppEngine via JSON requests. AppEngine sends Erlust the source code to be executed and the number of nodes to be used, and Erlust is responsible to "map and reduce" the data across nodes.

Due to the fact that many libraries (especially for social networks) have better support for a specific language, Erlust is language agnostic, meaning that it can run in parallel source code from many languages. Finally, Erlust exposes the data back to AppEngine by opening many concurrent connections.

Peter will present the Common Test application by giving a general introduction to the tool, as well as explaining some interesting features (both existing and upcoming ones) in more detail. The talk should give the listeners a general idea about the purpose and usefulness of Common Test, and a good enough basic understanding of the tool, to help them get started with it quickly in their projects.

For a long time, and due to the lack of main FP concepts in most
mainstream languages, we missed opportunities to abstraction and code
expressiveness and conciseness. With today’s democratization of FP,
Computational Abstraction is what will enable us to be less dependent
on specific programming language syntax offering; creating libraries of
control structures and composition forms that help find concise and
expresive solutions to enterprise programming challenges (null, lists
treatment, error handling), capturing elegantly important business
concepts in code, and programming at the right level of abstraction.For
a long time, and due to the lack of main FP concepts in most mainstream
languages, we missed opportunities to abstraction and code
expressiveness and conciseness. With today’s democratization of FP,
Computational Abstraction is what will enable us to be less dependent
on specific programming language syntax offering; creating libraries of
control structures and composition forms that help find concise and
expresive solutions to enterprise programming challenges (null, lists
treatment, error handling), capturing elegantly important business
concepts in code, and programming at the right level of abstraction.

Erlang/OTP has recently moved to Git and GitHub allowing for drastically improved visibility and a more streamlined contribution policy. In this talk you'll learn how to make the best of these new developments and how to use Git and GitHub to efficiently interact with other Erlang developers and get your patches accepted into core Erlang/OTP!

Efene is a programming language which runs on the Erlang virtual machine. It provides programmers coming from mainstream languages such as C/C++/C#/Java/Javascript an alternative syntax based on indentation for block delimiters for python and ruby programmers while making full use of the power and features of the Erlang VM.

Efene's objective is to be 100% compatible with erlang, efene programs can be automatically translated into readable erlang or compiled to bytecode. Efene and Erlang modules can interact without any problems since the abstract form from both languages is the same.

In this talk, Mariano will cover the design and implementation of efene and the rationale behind the different decisions taken while creating the language.

A demo will show how to fetch, build and test efene, and some small programs to show the syntax and main features of efene.

Since the release of Erlang/OTP on GitHub the possibilities for the Erlang community to contribute to the development of Erlang has increased tremendously. We should leverage this possibility and the increased interest in Erlang to keep Erlang as a living and growing language by letting the community help the language evolve. In this slot, Erik will present the EPP process and committee.

The committee members present at the Erlang Factory will participate in a panel discussion together with the audience discussing the most important EEP proposals.

Erlang holds great potential for use in Embedded devices. The distributed and fault-tolerant nature of Erlang has many uses in embedded systems, and yet there is not much available for the enthusiastic Erlang developer who wishes to run his Erlang applications on embedded devices. This talk will discuss the potential of a Linux-based Embedded Platform developed with the focus on running a minimal Erlang/OTP system. An Erlang-based model for mobile data-oriented networks for use in embedded systems will also be presented. The talk will discuss how a package of all these things can ease the work for an Erlang developer and inspire more developers to take a look at Erlang in Embedded scenarios.

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.

This talk presents the results of a study on software development using functional programming, based on a real industrial case. The integral process of software development is addressed from the declarative paradigm point of view, and this talk goes through the properties that functional technology gives to both software and its construction process, from the early analysis and design development phases, up to the final and no less critical verification and validation stages. In particular, the strengths and opportunities that emerge in the broad field of testing, thanks to the use of functional programming specifically, Erlang/OTP), are presented.

What could happen if we mix Erlang, a language that is ideal for high concurrency and parallelism, with PHP, the most popular web development Language? In this talk I will present a C extension that let us use PHP as an Erlang C node to communicate directly with Erlang to do such things as:

Developing reliable concurrent software is a hard task given the inherent non-deterministic nature of concurrent systems. A technique which is often used to check that a concurrent program fulfils a set of desirable properties is model checking. In model checking, all the states of a concurrent system are systematically explored.

We have developed McErlang, a model checker for Erlang. The Erlang program to be analyzed is run under the McErlang run-time system, under the control of a verification algorithm, by the normal Erlang byte-code interpreter. The pure computation part of the code, i.e, code with no side effects, including garbage collection, is executed by the normal Erlang run time system. However, the side effect part is executed under the McErlang run-time system which is a complete rewrite in Erlang of the basic process creating, scheduling, communication and fault-handling machinery of Erlang. Naturally the new run-time system offers easy check pointing (capturing the state of all nodes and processes, of the message mailboxes of all processes, and all messages in transit between processes) of the whole program state as a feature. McErlang has been used to verify critical parts of a number of Erlang applications.

In this talk we will give a brief introduction to McErlang, and give a demo showing how to use the tool in practise.

Financial systems present a particularly difficult problem in terms of scalability because by implication you have shared data. The presentation focuses on how we at PMT achieve scalability and redundancy using a combination of Mnesia, PostgreSQL and Oracle Hardware.

We will look at how we at PMT

- recover from the complete failure of Mnesia databases- keep the two databases synchronised- utilise a combination of a robust SAN and a set of distributed nodes to get good throughput

Mnesia is often listed among the NoSQL databases; for good reason, it seems, as it is neither relational nor SQL-oriented.In the Erlang community, Mnesia is perhaps regarded as a bit of a dinosaur, albeit of the small and cuddly variety, but in this talk, I will try to demonstrate how Mnesia has a thing or two to teach the upstarts. I will also show how Mnesia can borrow from its CAP cousins and make a respectable stab at massive scalability and eventual consistency.

Designing and building fault tolerance application is very important however inner views into all system & application layers ensures the service quality and uptime allowing proactive corrections before faults are occurring. As much as you make your application more distributed, scalable and deployed on multiple machines or clouds you need to dive deeper under into the system to track and monitor the processing on the different layers. This talk will discuss the key aspects and concepts for designing and implementing a “CareFull” monitoring suit for the entire on-line service, of course followed by real live examples.

Many applications today handle data that is deeply associative, i.e. structured as graphs (networks). The most obvious example of this is social networking sites, but even tagging systems, content management systems and wikis deal with inherently hierarchical or graph-shaped data.

This turns out to be a problem because it is difficult to deal with recursive data structures in traditional relational databases and many NoSQL stores alike. For example, in an RDBMS each traversal along a link in a graph is a join, and joins are known to be very expensive.

A graph database uses nodes, relationships between nodes and key-value properties instead of tables to represent information. This model is typically substantially faster for associative data sets and uses a schema-less, bottoms-up model that is ideal for capturing ad-hoc and rapidly changing data.

This session will introduce an open source, high-performance, transactional and disk-based graph database called "Neo4j" (http://neo4j.org), which frequently outperforms relational backends with >1000x for graph-shaped data.

One goal for the ProTest project has been to develop ways to reuse abstract models for post-mortem analysis and monitoring of live target nodes. To this end, we are cooperating with the OTP team to improve the tool support for tracing and debugging, as well as developing some tools of our own. In this talk, I will present our progress with two Open Source components, Onviso and Exago:

Onviso draws from the work done by Mats Cronqvist to improve dbg, and from Inviso, an OTP component offering some powerful features, but which has yet seen little use in the community. The results of this work are currently released on Github, but our intention is to achieve full integration into OTP. Our current focus is to simplify multi-node tracing and management of complex trace cases, and provide a foundation for future work, using the advanced analysis techniques developed by ProTest.

Exago, also available on Github, is our own tool for powerful off-line log analysis. Using Exago, you can automatically parse and process log files, and check them against an abstract model of the system. In case of failure, it will report the abstract state where the error occurred, and the events that led to the point of failure.

'll discuss the projects goals, adoption, and inner workings of the popular document database. I'll show some JavaScript code, for those of you who'd like to Relax and learn to write offline capable, peer replicating CouchApps.

QuickSpec is a tool that takes an Erlang or Haskell API and guesses a formal specification for it! QuickSpec is mostly automatic: it "reverse-engineers" the specification by random testing of the API, and all the user need do is give the types of the functions to be tested as well as test data generators. QuickSpec only works on purely functional APIs, such as data structures, at the moment.

This talk will show QuickSpec in action as well as the ideas behind it.

Riak is a fault-tolerant distributed database that is designed to be very friendly to both developers and operations. Justin will provide a survey of Riak's internals, showing the audience a number of the tools and techniques that helped to make it so robust, scalable, and extensible.

I will talk and demonstrate a CAN based power distribution system called the powerZone. And how is this related to Erlang? I will talk about that too. The SeaZone products are using a CAN based protocol called CANopen. I will spend some time talking about how this protocol is designed and why SeaZone is using it.

Swarm is a continuous build system implemented in Erlang which takes
software collaboration to another level. It allows users to share
patches based on pre-defined rules, allowing for a more streamlined
patch submission process than currently used for Erlang/OTP.
Furthermore it supports the build and test of custom Erlang
distributions which can be used to create specialized and supported
collections of Erlang applications. Erlang Solutions plans to use Swarm
to automatically test patches submitted to Erlang/OTP's main branch on
Github and provide ready-to-use operating system packages of Erlang/OTP
and custom variants. Tino will present the concepts behind Swarm and
show how it can be used to improve the Erlang/OTP collaboration process.

Ejabberd is an instant messaging server with lots of asynchronous behaviour. Such asynchronous behaviour is awkward to test, because of its inherent non-determinism. Variable event order and timing uncertainties can easily lead test cases to fail when they ought to pass, generating "false positives" that hinder testing. Yet coping with all possible event orderings and timings can make test cases hopelessly complex. When test cases are generated, these problems become even harder.

In this talk, we'll present a new way of expressing asynchronous properties that avoids these problems, and show how we used it to develop a simple QuickCheck specification for ejabberd message delivery.

Test-driven development (TDD) is more than "having tests". It is a Way. A way to design, a way to code and a way to keep code clean. It is
even a way to communicate with other developers. The tests are just the icing on the cake.

After describing the TDD development cycle as practiced by Extreme
Programmers, Dominic will show how Erlang and TDD are ideally suited
to each other, more so than with most OO languages. In particular, the lack of side effects, pattern matching and of course Erlang's concurrency model all make for a great TDD experience. In return, TDD
gives Erlang developers some of the safety of static typing, if not
more.

This tool-agnostic talk should convince TDD converts to use Erlang and
Erlang old-timers to try out the TDD Way!

There have been relatively few Erlang implementations and today there is really only one widely used Erlang VM, the BEAM. This talk will describe the history of the BEAM and other Erlang implementations that have been done, the differences between them and how they have performed. It will also discuss some influencing factors which need to be considered when implementing Erlang.

RabbitMQ is a leading implementation of the AMQP messaging standard, and is written in Erlang. Many RabbitMQ users are applying it to cloud computing, both as a part of cloud-based applications and as a building block for cloud platforms. In this talk, David will discuss the reasons for the interest in cloud messaging in general, and with RabbitMQ in particular, and the challenges faced when running infrastructure services in such environments.

Over the last few years, I have been meeting "Erlang people" more and more often, and I was getting this clear impression that "you people" have some kind of magic ability to reason intuitively about concurrent systems in a way that I could not. That bothered me, so I wanted to learn Erlang. Being a language implementor, the most obvious way to do that is to just go ahead and implement an Erlang VM, right?

The result of this "little exercise" is Erjang, an open-source JVM-based Erlang VM, which I think has potential to be useful as a means to push Erlang into new areas of application, help grow the Erlang community, and most importantly make all those Java-heads out there willing to learn how to do concurrency right.

In technical terms, Erjang reads .beam files and compiles them to Java's equivalent .class files which are then read into the running JVM. It runs off a plain Erlang/OTP distribution - requiring only the beam files from there; Erjang itself is written in Java.

To test Erjang, I implemented Triq - Trifork QuickCheck (or triq for short), a free clone of the Erlang QuichCheck which is available as open source. While triq is being developed for the purpose of testing Erjang it is "plain erlang" all the way, with no dependencies on Erjang in any way.

In this talk, I will explain how Triq was used to test Erjang. I will show how Triq works on top of Erlang, while sharing the latest goals and achievements, benchmarks and challenges. I will share what I learned along the way, and demonstrate that Erjang runs well enough to be dangerously useful.

Google Wave is the emerging protocol for real time collaboration and semi-structured process. ProcessOne has developed its own implementation of the Wave protocol in Erlang, for scalability purpose and integration with ejabberd XMPP server. Our server supports a large subset of the required feature (From Wave operational transformation engine to Wave storage, including federation with Google Wave server itself).

The default client protocol we use is XMPP, meaning our Wave server can work as an ejabberd XMPP server extension and can be use directly inside XMPP client.This talk will present the Wave protocol, our Wave server, developed in Erlang, and its architecture.

This talk demonstrates the progress in both the server and the client development, with the new server feature for search and indexing as well as the browser-based XMPP client OneTeam for realtime collaboration from everywhere.

Scala's actors have liberally copied concepts from Erlang. Among others, the concept of lightweight processes, the send and receive syntax, and the concept of supervisor hierarchies all come from Erlang. However, Scala and Erlang's approaches differ in several important aspects. Scala's actors are implemented as a library-only solution whereas Erlang's processes are a central aspect of thelanguage. Scala runs on the JVM whereas Erlang has its own runtime environments. Scala is a rich statically typed language that combines concepts from object-oriented and functional programming. Erlang is a compact, dynamically typed language that's firmly rooted in the functional programming tradition.

In this talk I present Scala's actors, show how they were influenced by Erlang's concurrency model, and discuss how the underlying differences between Scala and Erlang influence their respective approaches to concurrent programming.

F# is a pragmatic functional language which the Erlang programmer will find both familiar and foreign: agents are there, but so are objects; types are there, but they aren't too constraining; pattern matching and other functional features are there, but there are differences. This talk will recap the basics of F# from the Erlang programmer's perspective, loosely speaking, and help you understand how learning one language can give you skills you can use when working with the other.