| Clojure is the promise of a new dawn of clarity and empowerment. Enjoy the purity of functional programming, the uniformity of a LISP-based syntax and the pragmatic power of high level data structures. Eschew the accidental complexities of overzealous object orientation, misguided attempts at brevity by implicit obscurities, and the conflation of state and identity – mangling time with imperative side effects. This introduction will give you a glimpse into the power of expression, and provide some pointers and advice for wrapping your mind around the shape and intent of these parentheses from a more civilised age, enhanced with the vectors, maps and sets of modern living. You will also be shown how to tame the monsters of state and direct time. Talk objectives: Provide an overview of the shape and features of Clojure, its Lispisms, notion of state and identity, and how it interoperates with Java. Target audience: Developers curious about the fundamental shape and concepts of Clojure.
|
| There are two types of thing in Erlang. Forms and Expressions and the two don't mix. The shell is an expression evaluator. The shell reads an expression evaluates it and prints the result. A module is a sequence of forms. The compiler takes a sequence of forms and compiles this into an object file. You can't put forms in shell because they are not expressions. And you can't put expressions in a module because they are not forms. This is a mess - in many other languages the input to the shell is the same as the input to the compiler - but not in Erlang. There is a fix to this. "All" you have to to is define a form to be an expression. This needs a small syntactic change to the language. Suppose we add a new syntactic form: def fac = fun(0) -> 1; fun(N) -> N*fac(N-1) end. But we define this to be an expression with a side effect. It's value can be anything we like (say true). But it has a side effect. The side effect is to define the factorial function. With this change we could write (in the shell): def fac = fun(0) -> 1; fun(N) -> N*fac(N-1) end. true. fac(5). 120 With this and a few other changes the shell, modules, and escript become more or less identical. I call it erl2. Talk objectives: Some insights into some inconsistencies in Erlang and how these can be fixed. Target audience: People interested in future developments in Erlang.
|
Alternatives in Error Handling
| We all know this wonderful "let it fall" mantra. It works perfectly in a
lot of cases; the only problem is that sometimes you just can't let it
fall — maybe you want to present errors in a more handy way, or maybe
you want to do something when your computation fails. In this talk
different ways of error handling will be considered, in particular
"straightforward" monadic approach of Erlando and more idiomatic one of
z_validate library. Talk Objectives: raise attention to particular aspects of error handling Target Audience: any Erlang developer, especially those who deal with user input
|
| Erlang is successfully used for game servers. Lua is a friendly, small language that is big in game scripting. And VoltDB is a new high speed ACID database from Postgres inventor Mike Stonebreaker. Add some JSON, Websockets and JavaScript and you have an exciting HTML5 game stack. This talk is about research and results from the work on a very high throughput game server with embedded Lua for game logic and VoltDB as SQL database backend. The stack aims to maximize robustness, throughput and ease of scripting. Its special feature is linearly scaling true ACID with a goal of a million transactions per second, while being easy on the game logic scripter. This stack is part of the development effort of games start-up Eonblast for the cross-media Science Fiction franchise Solar Tribes, which will feature film elements merged with cross-platform online games. The stack is created to allow for a unified, non-sharded game world experience, thus for a unified story line and also otherwise transcends current MMO conventions. Players will share the same stories at the same time and be empowered to leave a stronger imprint on their environment. Interaction with other players is taken beyond the limitations currently seen in social games. All of which are technical challenges, asking for fastest possible data access and better data integrity guarantees. A triple asynchronous server side architecture is described that communicates non-blocking with a fat JS/HTML5 browser client. The related Open Source projects Erlvolt and Fleece are introduced, which were created for this stack. The embedded Lua driver Erlualib and Robert Virding's new project, the Lua VM emulator Luerl are compared and evaluated. A brief overview of capabilities of new databases is given to explain why VoltDB was chosen for the task. Talk objectives: Sharing practical experience integrating Erlang with an imperative scripting language and a powerful database cluster: Lua and VoltDB. Target audience: Mid-Level Erlang programmers interested in language embedding and high-velocity distributed databases. |
An Erlang-Based Framework for the Automatic Testing of Web Services
| Web Services are an essential part of modern web systems, yet their testing is an extremely slow and painful process. In this talk we will present a testing framework based on PropEr, xmerl, and the SOAP library of Yaws that aims for automatic property-based testing of Web Services. We will show how one can use this framework to perform fully automatic response testing of Web Services, how given a WSDL specification of a Web Service the tool can generate structurally valid test cases, and, if time permits, how RESTful and stateful Web Services could be tested. Target audience: Testing conscious web server developers.
|
| Rebar is an Erlang build tool that provides a set of standardized build tools for OTP applications and releases. This talk will examine common patterns for constructing, testing and releasing self-contained Erlang application using Rebar. We will examine a few of the popular Erlang projects which use Rebar as concrete examples. Finally, we'll take a look at upcoming changes to Rebar that may further improve developer efficiency. Talk objectives: To demonstrate how to use the major features a rebar-based build environment provides to the Erlang developer. Target audience: Erlang developers who want to make most of rebar environment.
|
| A discussion group on Erlang and Test Driven Development. |
BoF - Erlang in Teaching and Research
| A discussion group on Erlang in Teaching and Research |
BoF - Running Erlang on Embedded Devices
| A discussion group on running Erlang on embedded devices |
Combinatorrent - a Haskell Case Study
| Writing BitTorrent clients is fun. This talk presents a case study of a BitTorrent client written in Haskell. We will look into certain patterns used to implement the client and present how it works. Certain tricks used will be presented. We will also present what was easy and what was hard in the implementation and draw some comparisons to etorrent, which is a BitTorrent client written in Erlang. Talk Objectives: Tell about some abstract tools that might be interesting to Erlang programmers Target Audience: Brave people that won't fear the monoid!
|
Complex Event Processing on Arbitrary Data in Real-Time
| Myrmas is a new, open source, low-level complex event processing system that serves as the core for 10io`s innovative new product AutonomicI/O. AutonomicI/O identifies anomalies in infrastructure telemetry data, and takes the appropriate proactive autonomic action to circumvent the costly unplanned IT outage(s) that would have resulted. This presentation will provide an overview of how Myrmas was architected to reduce re-execution and dramatically increase the ability to distribute computation across nodes, including how the unique term destructuring algorithm was designed to leverage a heavily-customized Rete algorithm, and how and why Standard ML was incorporated with Erlang at the core of the system. Talk objectives: Introduce people to Myrmas, a new distributed rete implementation for Erlang as well as discuss mixed language implementations in the ERTS. Target audience: Developers. |
Continous Integration at WCDMA using Erlang Common Test
| This is a description of how our Erlang common test based test framework is used within Continous Integration of the RNC node at WCDMA. The strategy is that the cross functional teams write test suites for new features that are then inherited into Continous Integration. Talk objectives: to give an understanding of the framework structure and how it is used within Continous Integration and also some experience from a user perspective. Target audience: SW developers and testers. |
Device Management in a Connected Society
| As we move toward the Internet of Things, Over-The-Air (OTA) device management becomes increasingly critical. The battle against the difficulties of remote authentication, configuration, monitoring and upgrades has been raging for over a decade of Man-to-Machine (M2M) technology development. In this talk, we will introduce you to the challenges with some history, anecdotes and stats, and suggest a path forward in part based on some of Erlang's cooler features. Talk objectives: Teach some Device management concepts and history. Target audience: Interested people. |
Distel - 10 Years of (e)maxing out Erlang
| Emacs has traditionally been the editor with the best Erlang support. Distel, created by Luke Gorrie et al in 2002, provides an implementation of the Erlang distribution protocol in emacs lisp. Enabling communication between an Erlang emulator and emacs enables all kinds of cool tricks. Since this is the 10-year anniversary of Distel, I (the current maintainer) thought it fitting to present the current state of Distel. Which, in my unbiased opinion, is still the state of the art of Erlang editing. Talk objectives: Get all those misguided vi-users to switch editor. Target audience: Anyone who wants to edit Erlang code, and is not afraid of the awesome power of emacs.
|
| This talk will describe the architecture, design decisions, and the current implementation and performance of ErLLVM. ErLLVM is an extension of the HiPE native code compiler of Erlang/OTP that uses the Low Level Virtual Machine (LLVM) compiler infrastructure as a back-end. As such, it benefits from the set of existing components and low-level optimizations that LLVM provides. More importantly, it is in principle readily available on all platforms that LLVM supports. ErLLVM is a full system currently available as open-source and has been tested on x86 and x86_64 based machines running Linux. It supports the complete Erlang language and to the best of our knowledge is robust enough for others to try. We are also currently working on an ARM backend. We welcome user feedback, experiences and support! Talk objectives: Introduce ErLLVM and present its salient features and current performance. Target audience: Erlang programmers in need for speed.
|
Erlang Embedded - Concurrent Blinkenlights and More!
| Managing the resources and utilising the increasingly popular multicore and heterogeneous aspects of modern embedded systems require new sets of tools and methodologies that differ from the traditional 'C/C++' flow. Erlang provides features that are highly relevant to solve these issues and yet it is pretty much unknown in the embedded domain -- which is surprising considering that it was originally designed for embedded applications at Ericsson! Talk objectives: This talk aims to provide an overview of the current state of Erlang in the embedded domain and talk about our plans to help speed up the adoption rate of Erlang in embedded projects. Target audience: Hardware and software engineers interested in utilising Erlang as part of their embedded projects.
|
Erlang Metaprogramming Made Easy
| To generate Erlang code dynamically, you have until now had two choices: you could either create plain tuples according to the "abstract format" as generated by erl_parse (which is messy and has many special cases to keep in mind), or you could use the API functions in the erl_syntax module (which offer more abstraction, but can get pretty verbose). This talk will present the missing ingredient; a library allowing you to use template strings with metavariables, both for generating and matching on abstract syntax trees. As examples, I will show how we have used this at Klarna to implement a small domain-specific language for business logic, and demonstrate how you too can easily write a parse transform and even implement your own DSL that compiles to Beam code. Talk objectives: Blowing a few minds. Target audience: Anyone who wants to generate Erlang modules at run-time, for example for implementing a DSL or a parse transform. |
Erlang The Movie II - Back to the Future of Web Telephony
| Thanks to the miracle of Twilio API's Erlang web developers can now recreate the golden days of Erlang, but in the browser. You too can experience the thrill of building conference calls and answer phones, inbound/outbound blended call centres. Amaze yer pals with whisper and pop! Combining Scottish sweary slang with German and Spanish robot voices is pretty much the best legal fun to be had on the interwebs. Combining that with the adrenaline buzz of a live demonstration, this session will be the only one at EUC with the thrill-o-meter cranked all the way up to 111.
|
| Exploring the joys of reverse engineering a modern super-optimized Erlang virtual machine like BEAM, this talk will give an insight into what it takes to get an Erlang system up and running in your browser. The talk is based on experiences from the browserl project, an open source hobby project available on github. Talk objectives: Is it even possible to run an Erlang/OTP system in a browser? What are the main obstacles? What sort of performance can be expected? How much code does it take? Can I write my own Erlang emulator in $language? What is the status of the current development? Future plans? Target audience: This talk targets attendants with an interest in running Erlang in e.g. a web browser. If you want to write an Erlang emulator on your own, or if you are interested in the internals of a lightweight Erlang emulator this talk is also for you.
|
Innovation: What Every Developer Absolutely Needs to Know
| Erlang allows for technically excellent solutions, but reaching such a solution is, by itself, no guarantee of success. How to achieve real innovation and market success is often non-intuitve, especially for the typical technically-focused and logically-minded developer driven to make programs run faster, make code more beautiful, add cool features, or use the latest hot technology. Writing great code isn't nearly enough; if developers want their systems to succeed, then regardless of whether they work on proprietary systems or open source, they need to fully understand how innovation and markets actually work. In this talk, Steve will explain critical aspects and details of innovation, based in part on example projects and products from his 28 year career. Talk objectives: to explain the inner workings of innovation, markets, and product life cycles to help developers better understand them. Target audience: developers and technical managers seeking a better understanding of why and how products and projects succeed or fail.
|
Just-in-time in No Time? "Use the Source!"
| Every cool VM-based language today seems to have a just-in-time (JIT) compiler. With the availability of a powerful compiler infrastructure in the form of LLVM, Erlang is close to get a just-in-time compiler of its own. Using LLVM together with its C-frontend, Clang, and automated source-to-source transformations it is possible to generate a JIT-capable Erlang VM which automatically stays in sync with the basic VM. This talk will provide a brief overview of different just-in-time compilation strategies and a short introduction to the Erlang VM. The main part of the talk is an in-depth tour of the current JIT prototype and the techniques used to build it. Talk objectives: Explain the basics of just-in-time compilation and describe how automated source-to-source transformations are used to generate a JIT compiler from the VM sources. Target audience: Developers interested in how a just-in-time compiler works and how JIT support is implemented in the current prototype VM.
|
Latest News from the Erlang OTP Group
| This talk will give you the latest news from the boiling pots of the Erlang/OTP development at Ericsson. And overview of recent development and future preliminary plans together with some short deeper dives into interesting aspects of Erlang/OTP of today.
|
Mnesia Backend Plugin Framework and a LevelDB-based Plugin
| DETS, used by Mnesia for permanent storage has, some well known shortcomings (e.g. max 2 GB tables, slow repair of big tables and no ordered set semantics). Klarna and ESL have been looking at other backend solutions. An earlier work made an experimental plugin framework in Mnesia and a filesystem-based plugin. This talk describes a continuation of the earlier work. In this work the backend plugin framework has been refined and documented. The plugin developed is based upon LevelDB by Google and the eleveldb API made by Basho. It's also possible to design your own plugins based on other Key/Value storage backends. Talk objectives: Describe technically the plugin framework and to exemplify the usage with an actual plugin ordered/used by Klarna. Target audience: Those who are developing with Erlang and specifically with Mnesia and databases and those who are interested in what companies like Klarna are doing with Erlang.
|
Reverse-Engineering a Proprietary Game Server with Erlang
| Online gaming suffers from a big issue. When the owner of the game decides to shut it down, it's gone for good. Sometimes it's released as open source, but most of the time reverse engineering is needed to bring the fallen servers back to life. The best tool to analyze and reverse engineer a protocol and game client is Erlang, closely associated with a good debugger. This talk will explain the big advantages Erlang has over other languages for reverse engineering protocols and analyzing client files. A live demo showcasing some of these tools and techniques will be given. At the end of the talk you should have a good idea of how to start reverse-engineering your favorite online game. Talk Objectives: Learn how to use Erlang to analyze and reimplement proprietary protocols and file formats efficiently. Target Audience: Network developers, video games enthusiasts.
|
Ruby & Erlang: at Scale with Style
| In the world of social gaming with massive amounts of users, the classic architecture of web application does not cut it anymore. Wooga has already innovated quite a bit introducing stateful erlang-based game servers. Now it is time to push the limits even further. Follow along the evolution of game servers at Wooga and get an in-depth look into the next-generation backend putting the combined forces of erlang and Ruby to work. Learn how scalability, reliability, concurrency control and beautiful code do not need to be mutually exclusive. Wooga is in the top three of the largest publishers of social games world-wide, right behind Zynga and competing with Electronic Arts for 2nd place with almost 50 million active users every month on facebook. Talk objectives: Promote mixing and matching and generally using the best tool for a given job. Target audience: When you are interested in the practical challenges arising from combining Erlang and Ruby, this talk is for you.
|
Starting a Software Company: Tips from the Trenches
| Jane was a computer science groupie at Stanford. After moving to Sweden (his name is Bengt), she made her living in IT sales and product management, and had a couple of small companies on the side. In 1997, Jane started work as Sales Manager of Erlang Systems. It was the perfect job - all those computer science people! - for all of two months, when Ericsson forbade the use of Erlang in new projects. Not enough people used Erlang to keep it dynamic, and Ericsson management was afraid of being trapped in a dying language. It was impossible to sell Erlang when Ericsson itself refused to use it, and Jane persuaded Ericsson management to release Erlang open source in order to spread its use without sales. That strategy does seem to have worked... A group from the CS-lab then started Bluetail with Jane as CEO, and sold it 18 months later for 150MUSD. Jane has used part of her proceeds to help start ten other companies, including Klarna and Lensway. She's now CEO of Teclo Networks with Sean Hinde, Luke Gorrie, and Tony Rogvall, among others. Jane thoroughly enjoys building companies. |
Sweden's Next Top NoSQL Data Model
| Data modeling is hard, especially in the world of distributed NoSQL stores. With relational databases, developers have tended to store normalized data and shape their query model around that structure. This can come back to bite you when it comes time to scale, as complex queries across dozens of tables begin to affect application performance. It’s common to find developers rethinking their data model as query latency increases under load. With NoSQL stores, developers must consider their query patterns from the outset of application development, designing their data model to fit those patterns. A number of techniques, new and old, can be used to allow for maximum performance and scalability. Topics covered will include: De-normalization, time boxing, conflict resolution, and convergent & commutative replicated data types. Additionally, discussions of common query patterns in light of the capabilities of various NoSQL data stores will be reviewed. Talk objectives: To enable developers to understand that the data model must follow query patterns when using a NoSQL storage solution. Target audience: Developers using or thinking about using a database, be it relational or NoSQL. Anyone interested in distributed systems.
|
Switching to Erlang for Fun and Profit!
| Berner will talk about Campanja's experiences moving to Erlang, how they ended up doing it, lessons learned and challenges they faced. Campanja's production environment is fully hosted in Amazon EC2 on 80+ instances. Our main production language today is Erlang. At the beginning of 2011 nobody at Campanja had ever programmed Erlang before. Talk objectives: Share the experiences we had while switching to Erlang. Target audience: People interested in what it is like to join the Erlang community now-a-days, Erlang deployed on amazon ec2 and Erlang in combination with non-Erlang databases (i.e. the world outside of mnesia, couchdb and riak ;-) ).
|
Taking a Virtual Machine towards Many-Core
| The number of cores in modern computer systems increase rapidly. While the Erlang Virtual Machine has a history of good support for multicore systems, new development in the hardware industry requires further development of the Virtual Machine. This talk will walk you through the latest development, as well as the future, of the Virtual Machine regarding support for multicore and multiprocessor systems. The talk will also discuss what problems arise when moving from multicore to many-core systems and what the solutions to the forthcoming challenges might be. The talk will be quite technical. Talk Objectives: Give the audience an insight of the Virtual Machine internals. Target Audience: People with technical interest in the Virtual Machine internals. |
Testing Eventual Consistency in Riak
| Riak is one of the new breed of no-SQL database management systems,
which has begun to replace relational databases for some applications.
Riak is a distributed key-value store, inspired by Amazon’s Dynamo,
designed for applications where scalability, low latency and high
availability are critical. Riak uses replication to provide fast access
to data, even when multiple nodes or parts of the network fail. It
supports concurrent access to the same data by multiple clients, even
when the network is partitioned. All of this makes it very hard to test.
I will show how QuickCheck helped us to model Riak’s behavior, improving understanding and revealing the occasional bug.
|
The ABCs of C to E(rlang): a Practical Guide to Porting a Softswitch
| How to port a (successful!) hosted voip softswitch from C/C++ to Erlang. The whys, the hows, the successes and failures; and how to convince your manager it's a good idea! M5/Shoretel runs a very successful hosted voice over IP enterprise class PBX written primarily in C and C++. Five years ago we started to investigate the possibility of using Erlang as the primary language for the project. This is the story of how we evaluated it, how we got excited by it, how we're using Erlang to build new features, rewrite existing modules, and the lessons we've learned (both good and bad) on the way. (All while improving our stability and service to keep our customers from running away.) Talk objectives: This is intended to be a practical guide to how one might begin to use Erlang in an already existing, successful project and environment; and the benefits that can be gained. We've learned some valuable lessons during this continuing process that may prove educational to others contemplating doing similar things; and hopefully encourage them to take the same plunge. Target audience: Anyone considering building a new, large project in Erlang; and particularly those who already have successful projects in other languages who might be wondering if it's worth the risk; and how they might go about such a transition. |
The Ericsson SGSN/MME: over a Decade of Erlang Success
| For over a decade the Ericsson SGSN/MME, in large parts based on Erlang, has been the market leading product in its segment. The SGSN/MME is an integral part of the packet switched telecom network (commonly known as "mobile broadband"), and basically serves as a big router in the core network providing mobility and session handling for mobile phones. Today the same system can handle 2G, 3G and 4G traffic at the same time (one SGSN/MME can serve several Radio Access Networks). In this talk we will try to show how Erlang has been a central part in the construction and evolution of this system over a period of almost 15 years. The SGSN/MME is still being actively developed; 4G and completely new hardware being only two of the recent additions. In our opinion the early choice of Erlang for this product has been one of the key reasons for its big success. We will try to demonstrate this with examples of how Erlang core features are utilized in the systems design. The SGSN/MME code base is huge - the Erlang parts alone are well over a million lines of code, and the C/C++ parts several times bigger. This in itself becomes a challenge to handle in a system that has been developed for so long and with a very large number of people involved. Talk objectives: Give an example of industrial use of Erlang matching keywords such as: high capacity, high reliability, large scale, telecom networks, fault tolerance, overload protection, multi core and domain specific languages. Target audience: Everyone that is interested in real world use of Erlang.
|
The Gory Details of Garbage Collection
| Garbage collection is the key to automatic memory management. It relieves the programmer from the tedious and error prone task of manually keeping track of all mallocs and frees in a program. In this talk we will look at the basics of garbage collection and take a look inside the Erlang VM to see how garbage collection works in the Erlang context. Talk objectives: Describe garbage collection in general and how it works in Erlang in particular. Target audience: Anyone interested in the gory details of the inside of the VM. |
The Ideal Programmer - Why They Don't Exist and How to Manage Without Them?
| For many years, I have been trying to define the "ideal programmer" only to come to the realisation that they don't exist. This talk will be about the people and skill you must have in your team if you are to run a successful project. It will also touch on what you need to avoid as well.
|
The OS4RW: an Operating System for the Real World
| Erlang enables and powers a connected society. This talks brings this connection one step further into the real world. It presents an approach to translate the concept of an operating system to the physical world. A computer OS manages ICT resources (e.g. CPU cores) used by computing activities. The OS4RW manages real world activities (e.g. painting a car body, executing a helicopter rescue) that use real-world resources (e.g. robotic painting line, rescue helicopter and its crew). An ideal OS minimally interferes with the applications and refrains from imposing constraints beyond what already exists. It has to be designed for the unexpected. This talk outlines the key differences between a computer OS and an OS4RW, which identifies challenges. Ergo, the talk also draws a picture on how to address these the challenges. Talk objectives: To outline a design for a connected society that reaches far into the physical world without adding unwelcome restrictions on real-world activities. To show that the infrastructure for an intelligent society can reach outside the computer network, pro-actively managing how activities use resources. Target audience: 1) Erlang developers/users looking for a 'killer' application domain to make a real impact in society (and not just through computer screens and mobile displays). 2) Researchers, developers, policy-makers addressing smart factories, smart grids, intelligent transport and traffic, etc. willing to learn how Erlang is part of the solution. |
| This talk is about the idea of OpenFlow and how we brought it to life using Erlang. I'm going to speak about the design decisions we made and the problems we encountered when implementing an OpenFlow 1.2 software switch in Erlang. I will also describe the process of integrating it with the existing OpenFlow tools that all speak OpenFlow version 1.0 and how we used QuickCheck to test everything. Talk objectives: To give insights on how we implement OpenFlow switch in Erlang and spread the word about OpenFlow! Target audience: Erlang developers and everyone interested in computer networks.
|
Tutorial: Building a Chat with Cowboy - Part 1
| 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 (R14B or higher) 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: Building a Chat with Cowboy - Part 2
| 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 (R14B or higher) 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: Common Test - Getting Started and Moving On - Part 1
| Peter will present the Common Test application by giving a general introduction to the tool, as well as explaining some interesting features in more detail. Tutorial objectives: The tutorial should give the listener 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. Target audience: Anyone interested in learning about Common Test; a general purpose test tool, useful for testing systems on any level. |
Tutorial: Common Test - Getting Started and Moving On - Part 2
| Peter will present the Common Test application by giving a general introduction to the tool, as well as explaining some interesting features in more detail. Tutorial objectives: The tutorial should give the listener 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. Target audience: Anyone interested in learning about Common Test; a general purpose test tool, useful for testing systems on any level. |
Tutorial: Erlang Dos and Don'ts
| Programming Erlang can be a very different experience from what many are used to. This tutorial looks at features of Erlang and what to do, and what not to do, to write efficient code which is still clear and concise. |
Tutorial: Fine-Tuning the Erlang VM
| This tutorial will focus on diagnosing and fixing common Erlang performance problems. Topics to be covered include SMP vs. UP scheduling, tuning garbage collection, writing well behaved NIFs, and using built-in tools like percept and monitor to visualize & diagnose system performance. |
| QuickCheck support property based development. Instead of writing test cases for your applications, you write a one-pager with a QuickCheck property from which hundreds of test cases are generated automatically. QuickCheck simplifies failing cases to a minimal example on a test failure (so that fault diagnosis is quick and easy). QuickCheck enables developers to dramatically improve test coverage, and find obscure errors at an earlier stage, lowering costs and improving quality as a result. In this tutorial we will look at QuickCheck Mini, the free version of the QuickCheck library, and use examples to show how developers write QuickCheck specifications—which are actually Erlang programs using the QuickCheck API—and use them to test code written in Erlang or other programming languages. We will show how QuickCheck’s shrinking finds tiny examples that provoke errors, making the step from observing a bug to diagnosing it very short indeed, and we will show how property driven development can produce code that is solid from the word go. |
| This tutorial will demonstrate how to use the major features of rebar including: * Basic and multi-app construction * Port compilation * Dependency management * Unit testing via eunit/common_test * Reltool integration |
Tutorial: Testing concurrent software with QuickCheck
| Testing software is difficult, testing concurrent software seems almost impossible. Just writing a test case for a concurrent program is a challenge, since one may have a number of different correct executions that result in different, but all correct results. 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. |
Tutorial: Tracing and Debugging
| A distinct feature of the Erlang VM is the ability to trace and debug on a live system. In this tutorial we want to give people an overview of the facilities in the Erlang VM that helps a developer or administrator figure out errors in programs while they are running. The ability to operate on a live production system is a valuable trait of concurrent systems. Apart from Tracing and debugging, we will also be covering match specifications and we will introduce the "Restricted debugger" from the "eper" suite by Mats Cronqvist. |
Tutorial: Using QuickCheck for testing stateful systems
| Testing is a major part of all software development—yet no matter how much effort is spent on it, some errors always seem to slip through. Cases which no‐one thought to test crash systems late in development or out in the field, revealing errors which cost time and money to analyze, diagnose, and fix. In the worst case, such errors reveal fundamental flaws which force a redesign of part of the system, at disproportionate cost. The Quviq QuickCheck automated testing tool addresses these problems by generating test cases from a concise specification (so that many more cases can be tested), and simplifying failing cases to a minimal example on a test failure (so that fault diagnosis is quick and easy). QuickCheck enables developers to dramatically improve test coverage, and find obscure errors at an earlier stage, lowering costs and improving quality as a result. In this tutorial, we will use examples to show how developers write QuickCheck specifications—which are actually Erlang programs using the QuickCheck API—and use them to test code written in Erlang or other programming languages. We will show how QuickCheck’s shrinking finds tiny examples that provoke errors, making the step from observing a bug to diagnosing it very short indeed, and we will show how property driven development can produce code that is solid from the word go. |
Tutorial: Utilization of ReafactorErl during Development and Maintenance
| RefactorErl is a source code analyser and transformer tool. Beside the more than 20 refactoring transformations the tool has a complex static source analyser framework: it provides data flow analysis, dynamic function call detection, side-effect analysis, a user level query language to query semantic information or structural complexity metrics about Erlang programs, dependency examination among functions or modules, function call graph with information about dynamic calls, etc. During the tutorial we plan to highlight some useful features of the tool, and to present how this tool can be used in software development and maintenance tasks. We will also present how the tool can be used for code comprehension in development teams, how to configure the RefactorErl server for multi users, etc. Talk objectives: Show the main code comprehension features of RefactorErl and give some useful case studies about the usage. Target audience: Everyone who has ever written Erlang code, wanted to maintain/understand/debug legacy code. |
Up up and Out: Scaling Software with Akka 2
| We believe that one should never have to choose between productivity and scalability, which has been the case with traditional approaches to concurrency and distribution. The cause of that has been the wrong tools and the wrong layer of abstraction and Akka is here to change that. Akka is a unified runtime and programming model for scaling both UP (utilizing multi-core processors) and OUT (utilizing the grid/cloud). With Akka 2 this will be taken to a whole new level with its “Distributed by Design”. Akka 2 provides location transparency by abstracting away both these tangents of scalability by turning them into an operations and configuration task. This gives the Akka runtime freedom to do adaptive automatic load-balancing, cluster rebalancing, replication and partitioning. In this talk you will learn what Akka is and how it can be used to solve hard scalability problems. Akka is available at http://akka.io (under Apache 2 license). Talk objectives: Teach attendees what Akka is and isn't. How it is different from (and similar to) Erlang. It's strengths and weaknesses. Target audience: Developers interested in writing Erlang-style concurrent, distributed and fault-tolerant in Scala and/or Java to be run on the JVM. |
Using Software Refactoring to form Parallel Programs: the ParaPhrase Approach
| Despite Moore's ``law'', uniprocessor clock speeds have now stalled. Rather than using single processors running at ever higher clock speeds, it is common to find dual-, quad- or even hexa-core processors, even in consumer laptops and desktops. Future hardware will not be slightly parallel, however, as in today's multicore systems, but will be massively parallel, with manycore and perhaps even megacore systems becoming mainstream. This means that programmers need to start thinking parallel from the outset of their program development rather than treating parallelism as a bolt-on afterthought. This talk introduces the Paraphrase approach to constructing parallel programs, a new approach that uses formally-defined refactoring transformations based around strong parallel patterns and associated skeleton implementations, and directly exploits functional programming concepts. We show how complex parallel programs can be built from primitive Erlang building blocks, and describe some new software refactorings for parallel Erlang programs that capture common parallel abstractions, such as divide-and-conquer and data parallelism, using these building blocks. The ParaPhrase approach is both flexible and scalable, capable of covering both GPU and CPU computations, scaling from multi-core to mega-core processors, and covering a variety of parallel programming paradigms. Talk Objectives: To give an overview of the ParaPhrase project and to show how we can parallelise Erlang programs using refactoring and skeletons. Target Audience: Anyone who is interested in refactoring and/or parallelism.
|
| Bjarne Däcker, the co-founder and manager of the Ericsson Computer Science Laboratory, will open the conference and give a short introduction. |
