He'll bring his unique insight into the process of using a high concurrency, functional language to develop a neuroevolutionary-based computational intelligence system.

Fault Tolerance is baked into the very genes of Erlang/OTP – something that ends up being amazingly useful when you are building any kind of system. Remember, your clients and co-workers will find new ways to break things, ways that you could never have imagined in your wildest dreams. This is the reason to use Erlang. 

Once you get it, it completely changes the way you approach development, and you will find yourself writing "erlang" in whatever language you happen to be using. 

In this presentation, Mahesh will dive into Buddha-nature of Erlang/OTP, pointing out how the various features of the language tie together into one seamless Fault Tolerant whole.

The six laws of fault tolerance covered:

Garrett will dive into specific features that make Erlang stand out from other languages.

You'll come away with an appreciation for the types of problems Erlang is best suited to solve and Erlang's approach to solving them.

Nowadays, Ruby on Rails is a near ubiquitous choice when choosing to build a web application due to its promises of rapid application development and a growing ecosystem of libraries. However, once you start to color outside of the lines that the framework provides, you end up authoring more code to work around assumptions inherent in its design. This talk will look at an application which started as a prototype in Ruby on Rails, and eventually ended up as a Erlang web application. We will look at the benefits of writing your application in Erlang, specifically scalability, maintenance, testability, and then explore various deployment options for getting your application in front of users.

Talk objectives: To provide an overview on how to implement web solutions on top of Erlang and address common problems and solutions.

Target audience: Beginner Erlang developers with experience in building applications with rich MVC frameworks such as Rails.

In this talk, you will learn about the architecture and setup that the Huffington Post built to power their realtime websocket based commenting framework. Leveraging RabbitMQ, SockJS, Cowboy and Erlang, they were able to build and design a highly scalable, customisable solution to power realtime comments. You will learn about some of the pitfalls they hit, as well as some of the improvements they would like to make to take their platform to the next level.

Talk objectives:

For people interested in leveraging Erlang to power a realtime capability on their web applications, this talk will provide oversight into what we learned in the last year, how the pieces of the architecture fit together and how you might customise a websocket solution to suit your needs.

When you think of Web application development today, you may think of Ruby, Python, or PHP. Erlang, however, is not known as a language for Web development. Ironically, Erlang's unique features make it ideal as a Web platform - specifically its ability to handle massive scale while maintaining high reliability.

In this session, you'll hear from a panel of Web application experts who use Erlang to build Web servers and frameworks. Each will present a proven Erlang technology that demonstrates how Erlang can be leveraged to build Web applications. You'll learn where Erlang shines and where it struggles in this important field.

This talk will summarize Susan's journey of discovery (and often frustration) while building software as an application developer at trading firms and their technology partners. Her journey begins in the land of imperative Object-Oriented languages (C++, Java, and Python) and she finds her way to the kingdom of functional languages like Erlang.

Talk highlights will include examples taken from her experience building middle office software systems at trading firms first in Java and C++, and later in Erlang and C/C++ to compare and contrast approaches.

Modern CPUs have continued to follow Moore’s Law, continuously offering stunning increases in capability with every generation. However, software in general has not kept pace, particularly in terms of fully leveraging the power of the latest multi-and many-core CPUs.

The root of the challenge is Amdahl’s Law—the speedup in a parallel system is governed by the amount of serialization in the code. Writing parallel algorithms can be hard—and hard to write correctly. And even when written correctly, locking conventions for shared state in traditional programming languages can introduce serialization bottlenecks.

Erlang has proven to be a phenomenal platform for scaling on multi and many-core systems, thanks to its inherent concurrency. However, even then there are challenges to fully harnessing the power of modern chips.

Alex's talk will cover the latest work in scaling Erlang, and in particular will focus in on using big data analysis techniques to better understand and improve Erlang programs.