| Details to follow. |
Tutorial - Ericsson's Common-Test Application
| Peter will present the Common Test application by giving a general introduction to the tool, as well as talking in detail about various important and interesting features. The participants should get a good general idea about the usefulness of the tool, and hopefully a good enough understanding of it to get quickly started using it in their projects. |
Tutorial - Exago: an Offline Log Monitoring Tool
| 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 90 minute tutorial we will cover, how to:
|
Tutorial - Inviso: tracing in multiple node environments
| Tracing and debugging large systems still remains a challenging and
sometimes daunting task. There are few tools at hand, and even if some
data is collected the sheer volume and hours required to analyse it
makes one wince. However, there's a hidden gem in OTP which many
developers and testers may not be aware of - the Inviso application.
Although still a work in progress, we've made an effort to provide a
clean, functional and safe API to it. Together with a friendlier
user-interface it is getting ready to assist developers who are
building massively distributed systems. The 90 minute tutorial will demonstrate how to:
|
| In this 90 minute tutorial Lars-Ake Fredlund will introduce the
McErlang model checking tool for verifying Erlang programs, and examine
some case studies where the tool has been successfully applied. Model checking is a verification technique where the all the states of a program are systematically explored and checked against correctness properties. Although very effective in hardware verification, there are a number of problems when applying model checking to software: - Need for abstraction: to use a model checking tool it is often necessary to abstract the source code, almost never is the full source language supported. - State spaces are too large for model checking algorithms to work. In the design of the McErlang model checker for Erlang we have addressed both these problems. The language supported is full Erlang, with normal datatypes, processes, nodes, links, monitors, and so on. Moreover its verification algorithm provide some answers even when state spaces are huge (becoming more similar to testing). Following this introduction, Clara Benac-Earle will provide a hands-on demonstration of the tool. Delegates will be shown how to install it onto their laptops and then they will be taken through some exercises to demonstrate its usage. |
Tutorial - Property based testing of Grammars
| Some software is specified as grammars, e.g. protocol message formats
in several RFCs, like the RFC for URLs. One can either generate a
parser for these grammars automatically, for example with yecc, or one
can write such a parser by hand. The latter is done when the automatic
generated parser is not efficient enoughfor handling many messages per
second. Given that you have a formal specification, i.e., the grammar, one could use QuickCheck very easily to test both the parser as well as the software that uses the by the parser generated syntax trees. In this 90 minute tutorial we show how one achieves this with using QuickCheck. It's pretty much push-button technology, but the tutorial shows which buttons to push and what to watch outfor. |
| 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 180 minute 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 - QuickCheck specification for free
| In this 90 minute tutorial we present a tool which can automatically
derive QuickCheck specifications from Erlang programs. These
specifications consist of "interesting facts" about the program under
test, which can be used to improve program comprehension, and for
future testing as the software evolves. Surprising facts--or missing
ones--can quickly reveal inconsistencies in the design of the software. You will gain hands-on experience with automatic generation of software specifications, and learn which symptoms to look for when judging whether these specifications correspond to a correct implementation. |
Tutorial - Refactoring and Analysis with RefactorErl
| RefactorErl is a source code analyser and transformer tool aimed at refactoring Erlang software. The tool itself is written in Erlang with a unique approach: semantic analysis results are stored in a Mnesia database to avoid repeated analysis of the same source code, and simple, syntax-based manipulations are available that hide the details of handling separators, comments, and code layout. This 90 minute tutorial introduces the main features of RefactorErl: how you can use it simply as a refactoring tool, and how analysis results can help you during software development and maintenance. |
Tutorial - Testing Erlang multi-core applications with PULSE
| 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 90 minute tutorial little 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. |
| Wrangler is a refactoring tool which supports interactive refactoring
for Erlang programs. It is integrated with both Emacs and Eclipse.
Wrangler supports a variety of refactorings: Rename variable, module,
function, process; Generalise function definition, Move function from a module to another; Function/ Macro extraction, Fold expressions against function/macro; Tuple function parameters, etc. Apart from refactorings, Wrangler also provides functionalities for "bad smell" detection and semantics-aware expression/variable search. Among others, Wrangler's identical/similar code detection is able to detect identical/similar code fragments across multiple modules. In this 90 minute tutorial we'll show you how to use Wrangler as a part of the software development process, and in particular we'll show how Wrangler can be used in refactroing test code in EUnit, QuickCheck and Common Test. |
