Evolving your Projects with Wrangler
Scaling Erlang on 10K or More Cores: An Overview of the RELEASE Project
Tutorial: Profiling with Percept2

Simon Thompson
Functional programming researcher and teacher

Evolving your Projects with Wrangler

Systems that are valuable have to be evolved. For instance, if you use a regular expression library in Erlang, you will have had to migrate from regexp to re; if you wish to migrate from R16 to R17, there are a number of changes that you may need to make.

In this talk we'll show how Wrangler can help with this. Wrangler has an API migration facility - which we'll demonstrate - and this is built on an extensibility API and DSL for Wrangler that allows you to write your own refactorings and transformations for yourself, using Erlang syntax to describe what it is you want to do.

The talk will be illustrated with short demos to show how it works hands on.

Talk objectives:

The talk will give you experience of what Wrangler can do, seeing it in action on various scenarios. After the talk you should be confident about what it can do for you, as well as seeing how to use it in practice.

Target audience:

This talk is for anyone who builds and maintains Erlang projects and who wants to use a tool that will help with some of that. Wrangler can help with the mundane tasks and free you up to solve the more complex problems.

Scaling Erlang on 10K or More Cores: An Overview of the RELEASE Project

This presentation introduces the RELEASE project, outlining its scope, aims, objectives, work package structure, with a brief sketch of achievements to date.

RELEASE is a European Union 7th Framework Programme research project (an EU FP7 STREP). The project is running between October 2011 and September 2014, the total funding is 3.6M Euro, and it engages approximately 25 researchers. The project addresses the software aspect of the multicore challenge. It aims to scale the radical distributed actor programming paradigm to build reliable general-purpose software, such as server-based systems, on massively parallel machines (100 000 cores).

Talk objectives:

Target audience:

Tutorial: Profiling with Percept2

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.

With a number of live demos, we show Percept2 in action and demonstrate it can be used to find Erlang application level bottlenecks, and also how the tool can provide guidance and feedback on the parallelisation of existing sequential Erlang applications.

Talk objectives:

The talk will give you a taste of what Percept2 can do, seeing it in action on various scenarios. After the talk, you should be confident about what it can do for you, as well as how to use it in practice.

Target audience:

This talk is for anyone who builds Erlang applications, specifically Erlang applications that scale on multi-core/node systems.

About Simon

Simon has been with functional programming through the good and bad times since the 1980s, has written books on Erlang, Haskell and dependent types, and is really pleased to see all the buzz around Erlang and other languages at the moment. One big focus at the moment is working on building tool support to help with code transformations: refactorings, code migration, API upgrade and so on. Another is to build tools that provide strong guarantees that the refactorings that they implement don’t change what does code, but only change how it does it. He also teaches: teaching Erlang to students at Kent is well established, leading to students taking Erlang-based internships and placements in growing numbers; he’s running an Erlang MOOC on FutureLearn for the first time this year, too.