Automated Module Interface Upgrade
| During the lifetime of a software product the interface of some used library modules might change in such a way that the new interface is no longer compatible with the old one. This paper proposes a generic interface migration schema to automatically transform the software in the case of such an incompatible change. The solution is based on refactoring techniques and data flow analysis, and makes use of a formal description of the differences between the old and the new interfaces. The approach is illustrated with a real-life example.
|
Automatic Assessment of Failure Recovery in Erlang Applications
| Erlang is a concurrent functional language, well suited for distributed, highly concurrent and fault-tolerant software. An important part of Erlang is its support for failure recovery. Fault tolerance is provided by organising the processes of an Erlang application into tree structures. In these structures, parent processes monitor failures of their children and are responsible for their restart. Libraries support the creation of such structures during system initialisation. A technique to automatically analyse that the process structure of an Erlang application from the source code is presented. The analysis exposes shortcomings in the fault tolerance properties of the application. First, the process structure is extracted through static analysis of the initialisation code of the application. Thereafter, analysis of the process structure checks that it will recover from any process failure. The technique has been implemented in a tool, and applied it to several OTP library applications and to a subsystem of the AXD 301 ATM switch.
|
Automatic Testing of TCP/IP Implementations Using Quickcheck
| Developing a network stack is difficult. It is highly concurrent by design, there are many time-related tasks that must be performed, and it must be reasonably efficient to be useful. Testing a network stack is also hard, because it involves using a packet sniffer and looking at long packet dumps. Usually, tests are run using a well known stack as peer, such as the Linux kernel TCP/IP stack. However this approach has some problems. Many errors are difficult to find and to reproduce because they only arise under special conditions. Also, the TCP/IP stacks of the most common operating systems tend to be lax about accepting behaviours by their peers that do not fully conformn to the protocol. These errors would only be noticed when connecting with more simple stacks typical in embedded systems. In this work we present an automatic test case generator for TCP using Quickcheck. This tester generates packet flows to test specific features of a TCP stack. It then controls the stack under test to run the test by using the interface provided by it (for example, the socket interface), and by sending replies to the packets created by the stack under test. Because this tool controls the packets that are sent to the stack under test it can simulate situations that are not likely to appear in a normal test.
|
Cleaning up Erlang code is a dirty job but somebody's gotta do it
| This paper is co-authored with Thanassis Avgerinos. It describes opportunities for automatically modernizing Erlang applications, cleaning them up, eliminating certain bad smells from their code, and occasionally also improving their performance. In addition, we present concrete examples of code improvements and our experiences from using a software tool with these capabilities, tidier, on Erlang code bases of significant size.
|
Development of a Distributed System Applied to Teaching and Learning
| The emergence of networked computers has originated new technologies to teach and to learn, particularly, the technology of learning management systems. We have applied Erlang to deal with the concurrent part of a distributed system to support teaching and learning tasks. We have also employed declarative programming together with some formal tools to elaborate the specification and the conceptual model of the system and some extreme programming techniques to deal with some issues of software development. We show how Erlang supports the transition from the specification to the implementation, and the whole concurrent and computational process of our distributed system.
|
ETC: An Object-Oriented Extension to Erlang
| To structure the code of an Erlang program, one can split it into modules. There are also available some basic data structures: lists, records and tuples. However, there are no fully functional classes that encapsulate data and functionality, and can be extended with inheritance. We think these features could promote code reuse in certain cases, therefore we decided to extend the language with object-oriented capabilities. A strong evidence of the usability of this is the fact that part of the program itself was rewritten using our newly created language elements, and the new version was simpler and cleaner than the original Erlang one. Our main goals were to preserve the single-assignment nature of Erlang and to keep method-call and value-access times constant. It was also a priority to make the extension easily installable, to reach as much developers as possible. For this, we avoided changes in the Erlang compiler itself. Instead, we created the extension as a parse transformation. In our implementation a class is a module that contain the methods, and a record type whose instances are the object instances. Both methods and fields can be inherited. We also examined the currently available other object-oriented extensions for Erlang, and compared them with ours. Our imple-mentation has strong advantages, but it also lacks some features. Compatibility with records and speed are the main advantages. In this paper – among describing and comparing our extension – we also show the possible ways of adding the missing features.
|
Implementing an LTL-to-Büchi translator in Erlang
| In order to provide a nice user experience in McErlang, a model checker for Erlang programs, we needed an LTL-to-Büchi translator. This paper reports on our experiences implementing a translator in Erlang using well known algorithms described in literature. We followed a property driven development schema, where QuickCheck properties were formulated before writing the implementation. We successfully implement an LTL-to-Büchi translator, where the end result performs on par (or better) than two well known reference implementations.
|
| This talk shows what it takes to become a CouchDB developer. We'll show
you how to find you way around the sources and write your first patch.
We'll explain what you need to do to contribute your patch to the open
source project.
Our Tour de Source explains the general architecture and shows areas
that
need work that you could then pick up.
Contributing to a high profile open source project looks good on your
resumé
and leads to all sorts of happiness.
Erlang knowledge required.
|
Latest news from the Erlang/OTP team at Ericsson
| Kenneth gives an update of the Erlang/OTP team's work at Ericsson - their current projects and plans for future.
|
| Correct implementation of data constraints like referential integrity constraints and business rules is an essential precondition to ensure data consistency. Though most modern commercial DBMSs support data constraints ensurance mechanisms, constraints are often implemented in the business logic of the applications. This is especially true for non relational DBMS like Mnesia which do not provide constraints enforcement mechanisms. This case study examines a database application which uses Mnesia as data storage in order to determine, express and test the data constraints with Quviq QuickCheck and model-based testing approach.
|
Recent Improvements to the McErlang model checker
| In this paper we describe a number of recent improvements to the McErlang model checker, including a new source to source translation to enable more Erlang programs to work under McErlang, a methodology for writing properties that can be verified by McErlang, and a combination of simulation and model checking. The latter two features are illustrated by means of the messenger example found in the documentation for the Erlang/OTP distribution.
|
Teaching Erlang using Robotics and Player/Stage
| Computer science is often associated with dull code debugging instead of solving interesting problems. This fact causes the decrease in number of computer science students and can be stopped by giving lectures on interesting context like robotics. In this paper we introduce an easily deployable and extensible library which allows programming a popular robot simulator in Erlang. New possibilities for visual, simple and attractive teaching of functional languages are open.
|
|