A Cowboy quest for a modern web
| Cowboy,
the youngest of the Erlang web servers, has been getting a lot of
praise since its creation. Blogged as an interesting project by GitHub,
mentioned a couple times in various talks in the previous Factory, and
with already many early adopters. Learn what drives people to Cowboy,
how it's been designed, and why you should write your next web
application with it. The talk will conclude with an overview of the
current and future works in or around the Cowboy project. Audience: Web and network developers. Objectives: Learn what's the Cowboy project, how it works and how using it improves greatly the development process when writing a network-enabled application. Find out how it allows writing robust and modern web applications thanks to its OTP-inspired design and the availability of WebSockets. Finally, a showcase of the recent efforts and future developments will be given. |
A Practical Application of Load-Regulation in Erlang
| Load-regulation as a
layer of defense against failure and mechanism for performance
management is not a commonly used technique in modern software
development. This talk will explore the application of a load-regulation
framework (JOBS) to an
Erlang-based datastore (Riak) and discuss the resulting performance and
robustness improvements. Critically, we will also demonstrate that
adding load-regulation can be done efficiently and without impacting the
low-latency requirements of a datastore like Riak. |
| After the PropEr Talk
at the London Factory in June, a small brouhaha took place on the
Erlang-questions mailing list. Did the PropEr team have access to QuviQ
QuickCheck code? Did they found one at PirateBay? Does Kostis have a
powerful beam disassembler that generates (commented) Erlang source code
from .beam files? Or is it simply that the PropEr team has super
powers? This talk may possibly provide answers to some of these questions by describing how PropEr was created, or it may just give some more information about PropEr, its uses and what it can do to your Erlang code base. It may even have reflections on the OSS vs closed-source model of developing software tools for Erlang programmers. We'll see! |
All The Buzz: Erlang At CloudBees
| Erlang plays a
central role in CloudBees' platform infrastructure. In this talk,
Garrett will explain the history of Erlang at CloudBees and discuss its
strengths and weaknesses vis-a-vis other languages. If you're
considering Erlang as a strategic language for your startup or software
project, this talk will give you valuable insight from the trenches of a
leading platform-as-a-service vendor. |
| Program slicing is a well-known technique that utilizes dependency
graphs and static program analysis. Our goal is to perform change impact
analysis of Erlang programs based on the resulted program slices, that
is we want to measure the impact of any change made on the source code:
especially we want to select a subset of test cases which must be rerun
after the modification. The change can be performed manually by the
programmer or using a refactoring tool, such as RefactorErl. However
refactorings should preserve the original behaviour of the system,
developers want to be convinced about that, thus they retest the
software after some transformations. Software testing is said to be the
most expensive part of the lifecycle of software systems, so our
research focuses on selecting test cases affected by refactorings that
should be retested after the transformation. Audience: Erlang developers and researchers Objectives: Show the audience how you can use the change impact analysis technique to detect the subset of test cases affected by a change on the source code. |
| In 2011 I've been
travelling from one German city to another and showing and explaining
Erlang and its concepts at different Java Conferences and Java User
Groups. During these talks and sessions I've experienced very different emotions, questions, behaviours, reactions and statements ranging from leaving the room after the first 2 minutes of the talk, over eyes full of sheer fear and panic to asking sensible questions. I would like to share my experiences with the audience about how to "sell" Erlang on Java people, how to early scan the room the talk takes place in and how to take cover from flying beer bottles while still speaking and typing. |
DTrace and Erlang: a new beginning
| The 2008 EUC saw its
first DTrace+Erlang presentation: parts of the R12 release were
annotated with DTrace probes, and a driver created to allow Erlang code
to trigger a DTrace probe directly. Work has started again on adding DTrace probes to the Erlang VM. The repository at GitHub contains the source code for the new effort. Support for OS X, Solaris, and (soon) FreeBSD is underway, and supporting in Linux via SystemTap is a high priority. The end goal is acceptance of the DTrace annotations into Ericsson's Erlang/OTP distribution. Initial work is creating probes that help Basho diagnose performance problems with Riak DB and Riak Core applications. Scott will present a small case study of how DTrace probes can help find sources of end-to-end latency in Riak that have been extremely difficult to find, even when using Erlang's impressive array of tracing tools. |
Design and implementation of an Erlang-based gateway
| To contemporary applications, the Web has become a fundamental layer
of databases and application logic. For example, in a mobile banking
system, financial services--such as account management, bill payment,
security trading--sit in application servers, and a content gateway
integrates these web services APIs, translates data to presentation, and
delivers to mobile devices for rendering. In such an architecture, a
content gateway is the key integration point of many application
systems. HTTP persistent connections are used between the gateway and
application servers, and between the gateway and mobile clients. This
gateway is required to efficiently support large number of concurrent
requests from many clients, and within each request, possibly long
queries to and from various remote application servers; therefore, the
scalability and robustness of the gateway are crucial to the entire
system.
In this presentation, we describe the implementation of such a content gateway system, and share our real-world experience in its optimization and operation. We chose to use Erlang to implement this gateway because of its efficient and robust support of asynchronous communication and process abstraction. To reduce CPU and memory usage under load, we made frequent use of linked-in drivers to implement functions such as template generation, XML processing, and database connection. This system has been deployed and running in some of the largest mobile banking systems and airline mobile portals in China, supporting millions of users. We found that the robustness of Erlang and the freedom to optimize a component by migrating it to C were crucial during this process. |
Erlang e-learning: automatic assessment of Erlang code
| The recent growth of
the Erlang language and community convinced Erlang Solutions to scale
its training offering by developing an Erlang e-learning platform. This
has been done in collaboration with the University of Kent though a
Knowledge Transfer Partnership, a UK government funded project. The key challenge was to develop a system that delivered at a distance the same high-quality interactive experience that is delivered face-to-face. In this talk we present an innovative, modular tool, which is part of the e-learning platform. We use this tool to automatically assess Erlang programming exercises, providing syntactic, logical, architectural and stylistic feedback to the students. We present the tool from the teacher, student and developer's perspectives. We explain how existing tools such as the discrepancy analyzer Dialyzer and the refactorer Wrangler can easily be converted into e-learning plugins. We also show a Visualization plugin, which provides a graphical representation of the student's code by mean of the Erlang tracing functionalities. We conclude by discussing some further development for the platform. |
| When Canonical based
their file sharing system Ubuntu One on CouchDB technology, it became
the largest deployment of Erlang on desktops everywhere; now Couchbase
is working on Couchbase Mobile, bringing the power of Erlang and CouchDB
to mobile devices – and into users’ hands across the world. In this talk I will discuss why Couchbase is a great fit for mobile applications and the challenges and benefits we have had using Erlang in mobile devices. |
Erlang for a new era of Embedded Computing
| Erlang was designed for Embedded Systems - back in the days when an
embedded system could take up an entire rack or more. Nowadays, embedded
devices can easily fit in the palm of your hand and still carry enough
power to run Erlang applications. The next wave of embedded devices will
use multicore, system-on-a-chip design with integrated DSP and GPU
support for maximum features and capacity per Watt. The question
becomes: how to program these little beasts? At Erlang Solutions, we
have a vision, and are patiently positioning Erlang as one of the tools
of choice for the discriminating device programmer. In this talk, we
describe that vision, and how we are now gathering momentum through some
very interesting research and collaboration projects. |
Erlyvideo: an Erlang success story
| Erlang was chosen as a
platform to build comprehensive multiprotocol extensible videostreaming
server. It saved years of development and made possible to go forward
with a small team of developers, leaving small and agile.Erlyvideo is a
real success story of using Erlang in network streaming. |
From 0 to 1,000,000 daily users with Erlang
| This talk wants to
sum up the experience about building and maintaining live our first
social game server completely written in erlang. The game has been now published and it’s time to think about the results achieved. In this talk we’ll describe details of our architecture, principles that drove its design and considerations about hosting the infrastructure. We’ll go in detail through what worked well and what needs to be improved, all backed by data coming from our live system. Come and follow us if you want to get the taste of real world erlang. |
Investigating Hashes/Frames/Structs as a new built-in datatype in Erlang
| During the fall the
Erlang/OTP team has prototyped and investigated alternative solutions
for the introduction of a new built in datatype with characteristics
like Hashmaps, hashes etc. There are several alternative ways to go, for example an efficient implementation of property lists or just a better record datatype. The talk will present the findings so far with a discussion of pros and cons, performance measurements etc. |
| When it comes to
deploying Erlang applications deployment, opinions divide. Different
solutions exist, of which an overview will be given. A more interesting
question is "how can we improve what we have right now?", though. Some
new ideas and developments to be presented (in development at the time
of writing this abstract) Audience: Erlang developers who are not afraid of Erlang releases and understand their potential. Talk Objective: to give a perspective on how Erlang releases can be organized in a much more manageable way. |
Refactoring and testing ejabberd XMPP server
| ejabberd is an open source, scalable, extendible, cross-platform
Jabber/XMPP server written in Erlang. During the last few years we have
been involved in building and optimizing a number of projects
integrating ejabberd server with various subsystems; starting from
regular IMs, going through social networks, banking, online gaming and
finishing with mobile applications. Basing on that experience we
introduced a set of refactorings applied to ejabberd sources, as well as
code optimizations, giving the machines hosting ejabberd significant
RAM savings. I will also describe escalus framework, which can be used
for blackbox testing of XMPP servers. At ESL we developed test suites
based on it, which covers some Jabber RFCs and can be used for
regression testing when XMPP server is being refactored. |
The "halfword" virtual machine
| The 64bit Erlang
Virtual machine can host very large Erlang applications. However, the
amount of memory consumed for an ordinary Erlang process is doubled
compared to a 32bit virtual machine. Memory bandwidth is a bottleneck in
modern comuter environments, so wasting memory on 64bit heaps (with
e.g. 128 bits consumed for every character in a string) is a problem.
The halfword virtual machine adresses these problems for applications
having vast amounts of data in ETS tables and binaries, but does not
need more than 4GB of primary memory for regular Erlang processes - a
class of applications that is quite common. Using the halfword virtual
machine gets you the best of two worlds - even higher speed than with
any of the ordinary virtual machines, but a huge memory address range
for data stored in i.e. mnesia and ETS and as binaries. The linux halfword virtual machine has been in OTP since the R14B02 release, but few people know about it and ever consider using it, a fact that we want to change. Audience:Developers and people with a general interest in how the virtual machine works. Objectives:To describe the halfword virtual machine, it's inner workings and what you can gain from using it. A lot of applications would have use for it, but few people knows what this is and how it works. |
|
Kenneth gives an update of the Erlang/OTP team's work at Ericsson - their current projects and plans for future. |
Tutorial: Automated inference of state machines with Statechum
| Statechum is a general-purpose tool for state
machine inference and test generation. It comes with Erlang front-end to
make it possible to "learn" state-transition diagrams from Erlang
software, using both exported functions and OTP calls. |
Tutorial: DIY Refactoring in Wrangler
| Wrangler is an Erlang
refactoring tool which provides a range of refactorings - including
renaming, function extraction and generalisation - as well as facilities
for clone detection and removal as well as improvement of the module
structure of projects. Wrangler is integrated into emacs and Eclipse
(via ErlIDE). Up to now, you could only use the refactorings built into Wrangler, or dive deep into the internals to extend it. The latest version of Wrangler now provides a much easier way of defining and applying refactorings for yourself. All you need to do is implement them as a refactoring behaviour and they are accessible in emacs, and you can write descriptions of what the refactorings do using a combination of Erlang macros and templates that describe the particular changes to be made. You can also use the same facilities write new forms of code inspection equally easily. As well as being able to write new refactorings from scratch, we're providing a scripting language in which you can build complex refactorings by putting together simpler components: this can, for example, provide a mechanism for migrating from an old to a new API, or for transforming the data type forming the input/output of a collection of functions. After giving an overview of the DIY facilities we'll help you to get started writing your own refactorings and scripts. |
Tutorial: Easy Cover and EUnit - testing with ErlIde
| EUnit and Cover are
popular testing tools used in day to day Erlang software development.
They are the text tools that present results in an inflexible way. They
also require one to put some effort on configuration prior to use. In this tutorial we will show how to simplify testing and coverage analysis with EUnit and Cover using a graphical plugin integrated into ErlIde, the Eclipse plugin for Erlang developers. Through a few exercises you will become familiar with its capabilities. |
Tutorial: Erlang QuickCheck and Java
| In this tutorial we
show how Java libraries can be debugged using Erlang QuickCheck. To
avoid having to write a lot of boilerplate code when calling Java
methods from Erlang, we use a new library implemented on top of
Jinterface. The approach will be illustrated by testing a Java library
using a QuickCheck state machine (eqc_statem) specification. |
Tutorial: How to start using Dialyzer in your project
| Dialyzer is a static analysis tool that identifies software
discrepancies such as definite type errors, code which has become dead
or unreachable due to some programming error, unnecessary tests, etc. in
single Erlang modules, applications or whole systems. Even though it is
one of the oldest tools available to Erlang developers, it lacks a
proper user manual since its release, due to the self-explanatory nature
of its warnings. This talk presents a small practical guide to the
tool, assembled while introducing the systematic use of Dialyzer in a
legacy project. It deals with initial difficulties (how to run Dialyzer,
overcome initial crashes, deal with the causes of common warnings and
discern the important or simple-to-fix discrepancies from the rest), as
well as the integration of the tool into the testing, documentation and
maintenance procedures of a project (how to ensure that the code is in
compliance with accurate type specifications, remains free of common
discrepancies and respects the interface of opaque data structures). |
Tutorial: Learning Mocks with Meck
| Meck is a mocking
library for Erlang that enables you to easily mock Erlang modules during
testing. You can create modules, add functions, specify return values
and throw exceptions. You can also look at a history of the calls made
to the module, and make assertions based on that history. Meck can be
used for any kind of testing, but is particularly useful in unit or
component testing where it is sometimes difficult to handle dependencies
on external components or libraries. Meck has been used in production
in many different projects for about two years. This tutorial will give you an introduction to using Meck together with EUnit and other test libraries. |
Tutorial: Log Analysis with Exago
| As a developer or
support engineer you have probably spent enormous energy and time
manually analyzing log files, trying to find out what went wrong, when
and why. Using Exago, now you can automatically parse and process log files, and check them against an abstract model of the system. In case of failure, it will report the abstract state where the error occurred, and the events that led to the point of failure. In this 60 minute tutorial we will cover, how to: specify relations between log files and their properties, provide the abstract model of the system: either manually providing it based on system documentation or generate it automatically based on example logs use the results to reproduce and repair the error. In brief, this tool automates most of the daunting and tiresome task of manually inspecting log files, tasks that you would probably pass to the interns. |
| Developing reliable
concurrent software is a hard task given the inherent non-deterministic
nature of concurrent systems. A technique which is often used to check
that a concurrent program fulfils a set of desirable properties is model
checking. In model checking, all the states of a concurrent system are
systematically explored. McErlang is a tool which helps finding bugs in concurrent Erlang programs using model checking. In this tutorial we will illustrate the use of McErlang through simple examples. A new functionality is the integration of QuickCheck and McErlang; we show how the same QuickCheck state maching model can be checked either using QuickCheck, QuickCheck/Pulse or QuickCheck+McErlang, and explain the trade-offs of using the tools. |
| 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. |
Tutorial: Quickcheck for EUnit
| Writing EUnit tests
is more common than writing QuickCheck specifications, although
QuickCheck specifications potentially explore far more scenarios than
manually written unit tests. In particular for implementations that have
side-effects, writing a good set of EUnit tests is often difficult and
labour intensive. In this tutorial we explain a mechanism to extract QuickCheck specifications from EUnit test suites. We use the QSM algorithm to infer state machines from sets of positive and negative traces derived from the test suite. These traces can be derived either statically or dynamically and we describe both approaches here. Finally we show how to move from the inferred state machine to a QuickCheck state machine. This QuickCheck state machine can then be used to generate tests, which include the EUnit tests, but also include many new and different combinations that can augment the test suite. In this way, one can achieve substantially better testing with little extra work. We'll show the method in action with a test-driven development example, and encourage you to try the method out too. Please bring your own EUnit test suit to play with and see the results. |
Tutorial: Using e2 To Accelerate Erlang Development
| e2 is a project born out of lessons from teaching OTP principles at
ErlangCamp. e2 supports pure OTP in a way that distills essential design
patterns and helps developers use them productively. In practical
application at CloudBees, e2 has made the difference between using
Erlang only rarely for specialized cases and it routinely for general
programming tasks and using. If you're new to OTP, this tutorial will
accelerate your learning of core concepts like applications and process
supervision. If you're a seasoned OTP expert, you'll enjoy the
productivity boost from using e2. |
VoIP applications and the Cloud - Where gen_fsm really shines
| Aptela provides hosted communications services for small business. Our -
entirely cloud based - platform includes complex call routing,
messaging, web-portals, mobile apps, PSTN/SIP access, and a
coffee-grinder attachment. At peak, we handle dozens of calls (and an
infinity of HTTP requests) per second. These complex calling services work thanks to the magic of gen_fsm, a behaviour which is frequently overlooked at best, and ignored at worst. In the first part of the talk, I'll describe our architecture, with gen_fsm's critical role in it as the focus. The second part will delve into the specifics of how this behaviour can help build out complex calling services, with examples culled from some of Aptela's cooler (or crazier?) features |
| Bjarne will open the conference and give a short introduction. |
alogger - Simply the best logging framework for Erlang
| There is a lot of
loggers in the wild. You can consider to use one of them in your new
project. After a while a new cool logger appears, and you want it, so,
you have to change lots of places in you code, and definitely you have
to recompile the entire project. That sucks, doesn't it? The Abstract Logger Interface (alogger) brings completely new opportunities of logging. Here you go: - the possibility to introduce any new logger to your project without a need to change the project code at all - the interface will provide some neat features which are not exist in most of the existent loggers, like these: -- the possibility to change the logging priority "on the fly" without any significant overhead thanks to some parse_transform and hot code reloading magic -- the possibility to change the logging priority by modules or by special tags So, basically, with alogger you'll be able to add any new logger to you project, you even won't have to recompile your code. You'll be able to control all your log flows from the shell or through the config file. - and even more! |
