"If your data is big enough, Hadoop it!" That's simply not true - there is much more behind this term than just a tool. In this talk I will show one possible, practically working approach and the corresponding selection of tools that help collect, mine, move around, store and provision large, unstructured data amounts. Completely without Hadoop. And even completely without Java.

Target audience: Erlang developers wanting to build new web services.

Berner would like to share his experiences building a modern web application using among other languages Erlang.

Talk objectives: Show and tell webby Erlang experiences from the real world.

Target audience: Erlang web hackers.

Peak load, and burst-y traffic are problem spaces which are often (and tragically) confused for each other, invariably to the detriment of both ops and users.  While peak-load is all about capacity management, in a burst-y situation, you might have to prioritize - or even drop! - requests.  Knowing which requests to process, and how to actually process them is the world of Active Queue Management (AQM). While AQM has long been exclusively in the domain of the TCP/IP crowd, it has been slowly making its way into the world of cloud-services, albeit with much (faulty!) wheel-reinventing.

Join me as I take you through a whirlwind tour of AQM, with - I promise - much more Erlang and much less TCP/IP.

Talk objectives: Dealing with burst-y traffic isn't just about putting in queues, its about being able to deal with scenarios where your queue isn't big enough or fast enough.

Target audience: Anyone with customers - in particular, customers whose data-access spans the gamut from real-time to highly asynchronous.

People tend to use gen_server all the time even when it is not the right tool for the job. But OTP is more than just gen_server. OTP is about using existing behaviours and defining your own special processes that respect OTP principles. This talk will dive deeply into OTP so that everyone can understand its philosophy, how it works, and how to best make use of it.

Talk objectives: Fully understand how OTP works.

Target audience: Erlang developers.

Riak CS is an Erlang application that exposes the S3 API on top of Riak: an eventually consistent fault-tolerant distributed key-value store. Riak CS design faced many challenges: supporting large files, distributed garbage collection and quick time to market. We'll dive into implementation details and lessons applicable to anyone building distributed systems, such as the power of immutability in large-scale system design. Time will also be given to less obviously exciting issues like versioning of persisted formats and rolling upgrades.

Talk objectives: To relay lessons and tips from building Riak CS with Erlang and Riak.

Target audience: Erlang developers interested in learning about a large-scale distributed system.

The future of computing will be heterogeneous and the traditional tools we are used to will not be able to handle the different paradigms required when developing for these systems. This talk will provide a brief overview of heterogeneous computing and discuss how Erlang can help with the orchestration of different processing platforms, using our latest experiment on the Parallella platform as a case study.

This talk will also introduce Erlang/ALE, our new framework for embedded systems and provide an update on the Erlang Embedded project.

Talk objectives: To provide an overview of some of the research projects we have been working on at Erlang Solutions in the field of embedded and heterogeneous systems.

Target audience: Hardware and software engineers interested in computer architectures, heterogeneous computing and hardware hacking.

This talk aims to share Klarna's experiences reimplementing a major component from Erlang to Erlang.

Erlang developers, project managers, agile aficionados.

Unit testing is easy, especially in a functional language like Erlang that minimizes side effects. But what about applications where you *want* side effects --  such as delivering information or writing data to disk -- and need to test multi-step workflows effectively? Test code quickly becomes littered with set-up code, teardown routines, and mock objects, and as the application complexity grows, the test suite runs slower, and slower, and slowwwwwer, and…

In this talk, I will introduce an approach to functional testing that makes the developer's life easier by maintaining a *stack of state*. Here's how it works. Say you have a 10-step workflow and want to test two mutually exclusive transactions in step 10 (say, "Complete Checkout" and "Cancel Order"). Instead of executing steps 1-9 twice, you execute them once, but keep around an "undo button" so that after you've tested the first path in step 10, you can retrace your steps and try another path. The result? Cleaner code, faster tests, and happier developers!

After laying out the basic ideas, I'll discuss how to implement this approach with in-memory data (such as gen_server data), file systems, and popular databases. I'll also explain why the approach works particularly well with Erlang code. For reference, I'll show how the Chicago Boss web framework uses these ideas with its one-of-a-kind Deep Dish module, which can -- and should -- be integrated into other projects.

After attending, you'll have everything you'll need to build your very own Chicago-style test framework. But bring some salt, because the talk will be peppered with Erlang!

Talk objectives: The goal of the talk is to educate Erlang developers about the hows and whys of "Chicago-style" testing, and help them see that functional tests of large projects can be fast, simple, and clean.

Target audience: The talk will appeal to anyone who writes or maintains software with complex, multi-step interactions. Whether you're struggling under the weight of a monolithic test suite, or thinking "Tests? Yeah we should probably have a few of those…", you'll come away from the talk with a new perspective on functional testing.

The Erlang Development Tool Suite (EDTS) is an open-source package of useful development tools for working with the Erlang programming language in Emacs. It bundles a number of useful external packages, together with specialized Erlang plugins for them, and its own features to create a complete and efficient development environment that is easy to set up.

Presenting EDTS, showcasing its setup and how it can improve your Emacs development environment and hopefully thereby your daily life.

All Erlang developers interested in improving their workflow in Emacs.

Feuerlabs' Exosense, a modern framework for managing connected devices, is now operational and has been demonstrated in a number of prototypes. In this talk, we will describe our approach to Connected Device life-cycle management, and walk through an Erlang-based embedded application for in-vehicle performance monitoring. We will make the case that a reasonably competent programmer can produce a working end-to-end demonstration within a few days, and be well prepared for rapid deployment, support and upgrades.

Concurrent programs are notoriously difficult to get completely error free. This, sadly, is as true in Erlang as it is in other languages.

Specific process interleavings that occur only rarely can result in unexpected errors that manage to puzzle and surprise even expert

Erlang programmers. Furthermore they are often difficult to reproduce.

This talk will show some examples of such errors. More importantly, it will introduce Concuerror, an open-source systematic testing (also

known as stateless model checking) tool that supports the test-driven development of concurrent Erlang programs in order to detect early and

eliminate the vast majority of concurrency-related errors (e.g. data races, unexpected crashes, deadlocks, etc.) that may occur in their

execution. A salient feature of Concuerror is that it is completely automatic and works out of the box with existing (Eunit) test suites

and in principle finds all concurrency related errors that are triggered by a specific test.  In addition, the tool clearly shows

execution traces that lead to errors, it can deterministically replay them, and comes with a variety of options.

If time permits the talk will include live demos.

Talk objectives: Convince Erlang programmers both about the subtlety of concurrency errors and the ease of applying TDD using Concuerror.

Target audience: Erlang developers.

This talk will describe the port of Erlang to RTEMS. RTEMS is a open-source hard-realtime operating system for small embedded systems. It is used in the aerospace industry flying on satellites and planetary probes - currently its also driving around on Mars and on the Gallileo Satellites. Porting Erlang to RTEMS opens the way to new application areas, like in the current use case a intelligent RFID system for Industry 4.0 and Internet of Things applications.

Talk objectives: Give a short overview of RTEMS, describe the port of the Erlang VM and how it can be used.

Target audience: Erlang developers who want to get closer to the hardware. Embedded systems developers who want to add Erlang to their systems.

Handling Unicode in your program and encoding data properly for communication with the world outside is for many programmers a new area. Thinking about the way your strings are encoded when stored in a disk file or sent over the internet has previously been a no-brainer as all characters fit in one byte. A text file was a text file and a string could be encoded in a binary without hesitation. Now days you have to think about character representation, ways of telling other programs how characters are represented, peculiarities of other languages than your own, terminal capabilities, file system name encoding and so on. The Unicode support in Erlang/OTP has been built up during the last three major releases to what it is today. While still not complete, it now covers a lot of areas where third party libraries was previously required. 

I have been involved in both software development work and managing units which do software development for more than 40 years. During that time software technology and tools have evolved dramatically. 

There are many factors which influence how a software development project should be run:

You have to adapt to way projects are managed to these and many other factors. Trying to run all software development projects in the same way is a bad idea!

You are in a maze of twisty little traces, all alike. Last year at EUC I gave an in-depth tour of how automated source-to-source transformations were used to generate a proof-of-concept JIT compiler from the VM sources. Since then work has progressed to turn the proof-of-concept into a prototype.

Turning a proof-of-concept into a prototype is a process with many degrees of freedom, not unlike an old-school adventure game where you start out with minimal knowledge of your surroundings and the path to your goal. Compared to a proof-of-concept, a prototype not only has to behave correctly, it must also perform well but the way to get there is not apparent without a lot of experimentation.

This talk will provide a brief introduction to the just-in-time compiler followed by a walk-through of last year's development. The walk-through will cover the changes made to the initial proof-of-concept to increase performance and also show how the current version of the just-in-time compiler compares to the unmodified system and HiPE.

All "systems" need to be managed, typically using some "manager" software speaking some protocol to the system being managed. In this talk I'll be providing some opinions on management software written in Erlang.

Erlang has been around for quite some time, and over the years a plethora of various protocol implementations have accumulated, both on the server (agent) side and also on the client (manager) side. In the early days we saw ASN.1 and SNMP, and these days all the rage is about NETCONF/YANG and Openflow.

I will discuss some of these protocols and provide guidance on when to use which protocol. History repeats itself and new and hyped is not necessarily better than old proven and bug free.

Keynote objectives: Provide insight on the entire problem domain of managing systems. 

Klarna's first generation system created a very large, profitable, company. A victim of it's own success, it must be replaced.

This talk will describe Klarna's second generation system; a soft-realtime, distributed, no-master architecture enabling the best experience in online payments.

Talk objectives: Describe a financial system based on the principle of loosely coupled components. And how to seamlessly migrate into it.

Target audience: People interested in system architecture.

Come with me as we walk through implementing a new feature of Riak with riak_test. We'll go through adding a feature to Riak with Test Driven Development, going into as much detail as time will allow. We won't be delving into the internals of riak_test, but rather how we use it to test Riak. 

VoltDB and Erlang look like the perfect match to handle high data volumes fast and painless. Both are the result of a scientific approach to a concrete problem, designed from scratch to address the new reality of parallel architectures: not only to cope with, but to use parallel hardware the right way. Both are Open Source, driven by a commercial developer. And Erlang and VoltDB are well known by everyone "in the know", yet awaiting their mainstream break through. 

VoltDB is the brainchild of Michael Stonebraker, who created Ingres and Postgres, and it's his proposal for an SQL, fully ACID distributed database, specialized for online transactions. VoltDB neither reverts to key-value nor eventual consistency. It does not cover all of SQL but everything you need for typical fast, web-centric transactions. Technically VoltDB is something like a Redis for the cluster, with strong disk persistency and replication. Consequently it matches and surpasses Redis' performance, but for a much larger data set, scaling out almost linearly.

This talk presents the new native Erlang VoltDB driver "Erlvolt" that the speaker created over the course of the last three years and that has now become part of the VoltDB distribution. Source examples are presented that show Erlang and VoltDB in action. VoltDB's inner workings are explained to understand why it can be so incredibly fast and still more feature-rich than many of its NoSQL competitors. The recent Erlvolt benchmark clocking in at 877,000 transactions per second is described, and the simple steps to get VoltDB up and running with Erlang, to find out if it can be useful for you. 

The speaker is creator and maintainer of the Erlang VoltDB driver Erlvolt and a maintainer of the Erlang MySQL driver Emysql.

The talk will focus on the architecture of Zotonic (the Erlang Web Framework and CMS) and the choice in using Erlang for building such a real time, fault-tolerant and distributed web application framework.

The main focus will be performance, focussing on the Erlang VM, the mochiweb web server and caching considerations. The talk follows our chapter for the upcoming book "The Performance of Open Source Applications".

Talk objectives: The audience will get a general understanding of the components of Zotonic, the HTTP request flow and the performance considerations of each aspect of the Zotonic application stack.

Target audience: Erlang developers with a knack for web development.

My talk presents results from the FP7 Project MODUM that are developed in Erlang. 

The European project develops a new approach for the pro-active demand-responsive management of traffic (cf.modum-project.eu). The developments focus on solutions assuming a high degree of participation by intelligent users. These users have an e-butler (i-butler when bought from Apple) that proactively manages their commuting and other displacements. Initial deployment of the developments will enable full utilization of the access-controlled parts of the infrastructure (e.g. bus lanes, parking spaces). The MODUM design predicts and prevents congestion in these access-controlled parts without sacrificing infrastructure utilization. 

We all know Erlang as a language has certain limitations (for better or worse). It also makes you write a lot of boilerplate code. Sometimes we can put up with it, sometimes it's just annoying.

I've been looking into different meta-programming techniques to be used with Erlang. I've been using parse transformations a lot (and gave talks about them). But that wasn't enough for me. I've tried investing some time in Joxa (joxa.org, which is awesome, btw), but I found that it is a little bit more of a Lisp than Erlang. So I continued my search, and took another look at Elixir (elixir-lang.org), which I dismissed last year. It went through quite a transformation and, in my opinion, became a decent meta-compiler for Erlang that's not too far away from Erlang itself.

Target audience: Erlang professionals & newbies.

Being successful as a company probably means that you are doing the right thing, but it does not necessarily mean that you are doing things right.  From a technical point of view, you are sitting with a growing technical debt that will slow you down in the long despite adding more developers.  This can be turned around, by focusing on long term quality (by knowing what you are actually testing) and productivity, raising awareness of technical debt by measurements and visualisation and providing tools for the above. 

One of the highlighted features of Erlang/OTP R15B02, released on September 2012, was a parallel version of Dialyzer, the standard static analysis tool for Erlang developers, which is now shown to scale almost linearly at least up to twelve cores. Together with other improvements also included in that release, the parallel Dialyzer is able to analyze the entire Erlang/OTP codebase in just 6 minutes. In this talk I will describe the patterns that were used to parallelize this sequential tool and derive useful lessons for writing similar parallel applications in Erlang.

Talk objectives: Share experience on what are some unique problems when parallelizing using Erlang and how to solve them efficiently

The number of cores in modern computer system is increasing rapidly, and Erlang's support for multi-core system is also being continuously improved. To take full advantage of the computing power provided by multi-core Erlang, new Erlang applications need to be written with more parallelism to assure that there are enough processes ready to run, and existing sequential Erlang applications can be refactored to introduce more parallelism and therefore scalability. However, very often one might find that an application does not scale as expected.

In this talk, we present the Erlang concurrency profiling tool Percept2, which is an enhanced version of the original Erlang concurrency profiling tool Percept.  Built on top of Percept, Percept2 provides not only process profiling information, but also scheduler and function profiling information. Visualisation and navigation through data is made easy in Percept2, and the performance has also been improved by the parallelisation of tool itself. We demonstrate how Percept2 can be used to find Erlang application level bottlenecks, and also how the tool can be used to provide guidance and feedback on the parallelisation of existing sequential Erlang applications.

The talk will conclude with a demo of "late breaking" features including online visualisation of systems on single and multiple nodes. 

Building Releases is harder then it needs to be. There is already so much useful metadata in any Erlang release that it should be a simple one line command to create almost any Release. With Relcool it is. Providing both a simple command line and intuitive integration with Rebar, Relx makes the standard Releases simple and hard Releases easy. 

Talk objectives: The ultimate goal is to get more people using standard OTP Releases for their systems. By introducing Relx and showing how easy releases actually are we hope to convince more Erlangers to use Releases as part of their everyday work.

Target audience: Erlang Developers.

This talk presents safetyvalve, yet another load regulation framework for Erlang. What makes safetyvalve stand out is an experiment: All code is derived from a QuickCheck specification. That is, the specification is written before the code is extended with functionality. And you are only allowed to extend the code when you know how to write the specification for it.

Safetyvalve is also unique in that it contains a CoDel (Controlled Delay) queue management algorithm. This allows for self-tuning load regulation where the system adapts to the machine on which is runs, large or small.

I claim that code derived from specifications results in smaller and more correct programs. I claim that it results in faster development. And I claim it is much more fun.

Erlang Term Storage (ETS) is Erlang's own in-memory database system, which is used by many to store shared data in parallel applications. Using ETS concurrently is a challenge, and even the Erlang/OTP R14B release notes claim that certain uses of it ""will never scale"". How to do it in a way that might work, and how much truth there is in this claim will be topics in this talk.

Understanding the effects of ETS concurrency options, and how they reflect in the underlying implementation is required to see the limits of ETS scalability, but also the opportunities. Using the ets module's interface properly is required to get good performance even on future releases of Erlang/OTP. 

Talk objectives: Show how RabbitMQ was and is used at SoundCloud to scale the leading platform for audio on the web.

In order to get the control of our websites, at Spilgames we decided to create a platform to ease the development process. The platform contains versioned widgets that get combined for building webpages. It also includes simple web tools for deploying and rolling them back and a native support for A/B testing. Our mission is keeping full control of what happens in our portals while being able to just increase the number of developers for getting more traction in our web projects.

Erlang developers are lucky to have a solid VM, great community, and great tools for building, testing, and debugging their applications. When that application is written and tested, and you as a developer want to make it easy to install everywhere, that is where the *easy* option cannot be found. Few people know how to write a proper .spec file or make deb files and I argue that few people *need* to know about it.

Erlang developers shouldn't have to know about debuild, rpmbuild, pkgsrc, pkg_create, or pkg_add. They shouldn't need to read through tomes like Maximum RPM (409 pages), Debian New Maintainers' Guide + Debian Policy (160 pages), or The pkgsrc Guide (154 pages). If you know how pkg_add on FreeBSD is different than pkg_add on SmartOS you are experiencing way too much pain. These are all problems we have at Basho when shipping Riak and Riak CS to customers. This talk covers our solution to this problem with node_package, a universal packaging tool for Erlang applications.

Talk objectives: Packaging by its very nature is ugly and complicated and I would like to show how this pain can be at least sidestepped by using node_package to worry about packing policy and conventions. I'd like to show how we make packages for debian, ubuntu, fedora, rhel, smartos, freebsd, solaris, and osx in one command. Most importantly I'd like to discuss how we wrote node_package, what decisions were made in its creation, and where we need to improve with help from other application developers.

Target audience: Erlang developers who want their erlang software to be installed and used.

Erlang developers are lucky to have a solid VM, great community, and great tools for building, testing, and debugging their applications. When that application is written and tested, and you as a developer want to make it easy to install everywhere, that is where the *easy* option cannot be found. Few people know how to write a proper .spec file or make deb files and I argue that few people *need* to know about it.

Erlang developers shouldn't have to know about debuild, rpmbuild, pkgsrc, pkg_create, or pkg_add. They shouldn't need to read through tomes like Maximum RPM (409 pages), Debian New Maintainers' Guide + Debian Policy (160 pages), or The pkgsrc Guide (154 pages). If you know how pkg_add on FreeBSD is different than pkg_add on SmartOS you are experiencing way too much pain. These are all problems we have at Basho when shipping Riak and Riak CS to customers. This talk covers our solution to this problem with node_package, a universal packaging tool for Erlang applications.

Talk objectives: Packaging by its very nature is ugly and complicated and I would like to show how this pain can be at least sidestepped by using node_package to worry about packing policy and conventions. I'd like to show how we make packages for debian, ubuntu, fedora, rhel, smartos, freebsd, solaris, and osx in one command. Most importantly I'd like to discuss how we wrote node_package, what decisions were made in its creation, and where we need to improve with help from other application developers.

Target audience: Erlang developers who want their erlang software to be installed and used.

Soundrop is a social music service where you can listen with other people around the world, vote up your favourite music track and chat about it. The Soundrop backend is implemented using Erlang/OTP, and the goal of this talk is to recount the journey of what was once implemented in python and node.js

Talk objectives: Give an example of real-world use of Erlang, and how one might begin to use Erlang in their projects.

Target audience: Erlang developers, web developers, software architects.

Tail-f's Network Control System (NCS) supports programming of network services on both traditional networks and Openflow networks. Tailflow is the part of NCS that supports Openflow. Inspired by the 20 year old ideas around micro-protocols, Tailflow introduces a concept called the 'flowlet'. Each flowlet encapsulates  some minimum amount of logic in order to make it composable and easy to understand. By stacking flowlets on top of each other, the full functionality of an Openflow device is constructed, may it be an ordinary learning switch or a more complex NAT/FW device or, in principle, any other kind of networking device.

This talk will describe the architecture of Tailflow and show how we, by using OpenVSwitch, created a simulated Data Center with many server racks, each server running many VMs. A Layer-2 virtual network is implemented as well as a NAT/FW for public access, all controlled by a Tailflow application.

The 'Jobs' load regulation framework, first presented at the 2010 Erlang Workshop, takes the approach that overload should be prevented through regulated input queues - that is, as soon as an incoming request is classified, it is inserted in an appropriate queue and allowed to proceed according to a predefined rate limit or pool size. This approach has much in common with 'DiffServ' regulation in IP multimedia networks, and has the advantage that core components can focus on operating as efficiently as possible. In this talk, we will describe 'Jobs', and our experiences to-date, and walk through a few examples of how it can be configured.

Talk objectives: Give a (mostly) practical introduction to overload protection in Erlang-based systems.

Target audience: Erlang developers, primarily working on server systems that may suffer overload.

Five years ago, databases were, in the words of one venture capitalist, a "solved problem."  Fast forward to today, and there are 30 databases in production somewhere that didn't exist before.  A quick survey shows that the JVM dominates this landscape.  However, there are trends developing that might change that - changes that will reshape the way applications are developed and deployed, changes that may very well see Erlang become a central player.

Talk objectives:  Survey the current database landscape, identify the forces - technical, economic, social - that shaped it, look at the forces now developing that will shape the future tech environment, and point out where Erlang can play a critical role.

Target audience:  anyone interested in databases, startups, entrepreneurship.

RefactorErl is well known static analyser and transformer tool. We have given several talks about the tool, so we want to show some new aspects of the tool now. We will introduce you to some new features of the tool (e.g. assisting the initial loading by analysing make files, the new web interface, supporting investigations, etc.) and some really unknown possibilities of the tool (e.g. introducing portable funs to the language). 

Talk objectives: Give the idea  how to use a static analyser for different purposes.

Target audience: Anyone interested in tools for support program development or wanted to extend the language with new elements.

 

This tutorial introduces the Cowboy web server through the writing of a simple chat application.

The Cowboy web server allows you to write efficient web applications. It's however just a thin layer managing the HTTP part of your application.

After a brief presentation of Cowboy, we will start writing a simple echo application using GET and POST, and then using Websockets.

We will then start talking about the general architecture of the 

application, build a session server and make clients communicate with each other.

Requirements for this tutorial: basic knowledge of how HTTP works, a laptop with Erlang and Rebar installed (R16B) along with a websocket enabled browser.

Tutorial objectives: Learn how to use Cowboy to build real-world HTTP/websocket applications.

Target audience: Web and network developers.

Tutorial objectives: Learn all the good reasons why you should (or should not) use Elixir and get an understanding how to use it.

This tutorial will teach the audience how to create releases and integrate those into a unix environment. It sets up the participant up to be able to do reasonable continuous deployment with Erlang. 

Participants will learn and practice the following three things:

* Building OTP Releases with Relx

* Integrating Erlang releases into a unix environment

* Packaging up releases with native packages, be they RPMs or Debs. 

The Erlvolt tutorial demonstrates hands-on how to install and use VoltDB with Erlang. Participants can walk every step of the way in parallel on their lap tops. We'll start with a short outline of how VoltDB works, how it matches with Erlang and how it is used. We will create a local hello world example, covering download, installation, building, and writing the code: the database definition, stored procedures, VoltDB project definition and main program. Then run and discuss a meaningful benchmark, creating and using a cluster in the Amazon Elastic Compute Cloud. If you have an AWS EC2 account, you can also try this part yourself during the time of the tutorial. Finally, we will look at the internals of the Erlvolt driver together and participants will be called upon to become collaborators in this exciting open source effort.

- learn VoltDB basics

- install and build VoltDB & Erlvolt on your laptop

- discuss VoltDB internal architecture and development history

- write and understand a hello world example application

- setting up a small online cluster and perform a benchmark on it

- ask in-depth questions regarding VoltDB and Erlvolt

   Engineers and programmers interested in designing the next generation of embedded systems.

   Basic understanding of Linux, hardware architectures and embedded systems and some experience with C and Erlang. Hardware will be provided on the day.

Objectives:

This tutorial will provide an overview of:

     * Current tools and methodologies employed in embedded systems

     * Embedded Linux and the ecosystem around it

     * Hardware drivers and interfacing

     * Erlang 101, focusing on features that are relevant to managing hardware

     * Erlang Embedded framework, a new proposal for architecting embedded systems

While not a new concept, Embedded Linux is becoming more and more popular with the barriers for entry being lowered by projects such as the Raspberry Pi.

In this hands on tutorial we will design an Erlang powered embedded sensor node, running on the Raspberry Pi. We will take you through the steps required to build and deploy the Linux image, deal with hardware interfacing and backend connectivity.

Module 1: Embedded Linux

In this module we will look at the elements of an Embedded Linux system, such as:

   * Cross compilers and build environments

   * The Kernel and the root file system

   * Bootloaders

We will also look at debugging, connectivity and deployment issues.

Exercise 1: Board bring up

We will bring up a Raspberry Pi board and establish communication with it over the network.

Module 2: Interfacing Hardware

Embedded devices generally consist of more than just the processor and as such we need to interface our applications processor to external chips/sensors/peripherals. This module looks at:

   * Different kinds of embedded protocols used to interface things together

   * How these protocols are utilised in hardware

   * Memory mapped peripherals and interfaces

   * Linux kernel support for common protocols

Exercise 2: Blinkenlights!

We will get some LEDs blinking using both the kernel abstractions and memory mapped bit twiddling.

Module 3: Erlang Embedded Framework

We think Erlang is a great fit for the new generation of Embedded Systems and we present the Erlang Embedded framework (Erlang/ALE) to tackle the common challenges we face today with these kind of systems. This module introduces our work and looks at:

   * The relevance and use of Erlang in Embedded Systems

   * System granularity and fail-safe supervision hierarchies

   * The mapping between the hardware world and Erlang system

Exercise 3: Designing the Sensor Node

We will start this set of exercises with a few tasks utilising the hardware demo board and then put together an architecture for our sensor node.

Quviq QuickCheck is an automated testing tool that can be used to automatically generate test cases. In traditional testing, one often writes a sequence of operations to be executed and that sequence is tested. Running the commands in that sequence in parallel is far harder, since how would the test case look like?  QuickCheck specification also often start from specifying sequential execution of possible sequences; but QuickCheck can run the commands in the sequence in parallel and the specification can be used to validate the outcome of such a run. All that, fully automatically.

In this way, testing the Erlang OTP dets module becomes possible.

PULSE is an addition to QuickCheck that enables you to find concurrency errors like race conditions and deadlocks in Erlang programs. Even if those errors may not show on a single processor system, they may be sitting there waiting to be revealed when you switch to multi-core. With PULSE you explore random schedulings that are possible on a multi-core but not on a single core, therewith increasing the possibility to reveal weird errors. Of course, the test case is minimized when finding a concurrency error, which results in a repeatable test case that helps to analyze the cause of the error quickly.

In this tutorial some knowledge of QuickCheck is required; it suffices if you participated in a QuickCheck talk or tutorial before. We will look at a few examples in which QuickCheck and PULSE are used to find concurrency errors.

Multicore architectures are here today, offering major advantages in terms of performance and low energy use. New chips like Intel's 60-core Xeon Phi co-processor point the way towards dramatically increased performance. 

Do you need to take advantage of the ever-increasing number of cores in modern processors? Are you unsure how to tackle the exciting programming challenges that parallel computing introduces? This tutorial introduces new pattern-based techniques and tools for Erlang that allow the programmer to quickly and easily write effective parallel code. The tutorial introduces the free Erlang parallel programming library, Skel*, shows how to quickly and automatically introduce parallelism using dedicated refactorings in a standard text editor, and gives hands-on experience with a large multicore machine, leading the programmer step-by-step through the process of writing effective parallel code.

The tutorial is given by Kevin Hammond and Chris Brown, pioneers in the use of refactoring technology for parallel programming. Kevin Hammond has almost 30 years of parallel programming expertise, and deep knowledge of functional programming techniques; Chris Brown is a world leader in refactoring tools for functional languages.

*Skel can be downloaded from GitHub: https://github.com/ParaPhrase/skel

Testing web services on the user interface level is a featured that many developers are looking for. It's simply too boring to click your way through an web service in order to get it tested. Test automation by pre-recorded sequences of clicks is neither the ideal way to go.Instead one would like to describe a model of the system and automatically generate test cases for the web service from this model. That's what QuickCheck can do for you.

Quviq developed an open sourced Erlang implementation of the WebDriver protocol. In this tutorial we show how webdriver and Selenium can be used by QuickCheck to test web services. We consider a simple scheduling service: Dudle and show how this web service can be thoroughly tested using the above mentioned techniques.

In this talk we will take a look under the hood of the Erlang RunTime System (ERTS). We will look at the BEAM instruction set and how the BEAM interpreter works.

Target audience: Erlang developers who want to get a better understanding of how their programs execute.

Quviq developed an open sourced Erlang implementation of the WebDriver protocol. 

This implementation allows an Erlang programmer to fully interact with a web browser, such as Google Chrome, Opera and Firefox. Testing web services in different browsers is made possible via test cases written in Erlang. This in its turn allows us to use QuickCheck for testing web services. Many random scenario's are tested and when the website differs from the intended behaviour we automatically find the shortest user interaction bringing us to that unintended behaviour. We can demonstrate this in any web browser supporting WebDriver.

Another use case is that we can record test cases using Selenium and translate them into EUnit test cases, which can be used by learning algorithms to create QuickCheck models from. 

The development also brought forward a number of software errors in for example Erlang's httpc module, Chrome driver and Selenium server.

Talk objectives: This talk will show you how to test web services in different browsers using Erlang.

Target audience: Erlang programmers developing and/or testing web services.

The Erlang/OTP team has been investigating and prototyping a new built in datatype "maps" for a while now. This talk will give you insight in the journey towards the current status when it comes to "better records" with atoms as keys and with more general "maps" with any terms as keys.

IntelliJ IDEA is the full-featured IDE with refactoring capabilities for many languages: Java, ActionScript, PHP, Groovy, Scala, Python/Jython, Ruby/JRuby, Clojure and now, for Erlang. This talk would be about using IntelliJ for Erlang development.

Target audience: Anyone looking for convenient IDE for Erlang development.