Máté Tejfel

Impact analysis of erlang programs using behaviour dependency graphs

During the lifetime of a software product certain changes could be performed on its source code. After those changes a regression test should be performed, which is the most expensive part of the software development cycle. This paper focuses on programs written in a dynamic functional programming language Erlang, and discusses a mechanism that could select those test cases, which are affected by a change, i.e. altering the program on some point may have impact on the result/behaviour of those test cases. In the result of that analysis it is possible to reduce the number of necessary test cases, and after modifying the source code, just a subset of the test cases should be retested. The discussed approach introduces a behaviour dependency graph for Erlang programs to represent the dependencies in the source code. The impact of a change can be calculated by traversing the graph.

High speed packet forwarding compiled from protocol independent data plane specifications

P4 is a high level language for programming network switches that allows for great flexibility in the description of packet structure and processing, independent of the specifics of the underlying hardware. In this demo, we present our prototype P4 compiler in which the hardware independent and hardware specific functionalities are separated. We have identified the requisites of the latter, which form the interface of our target specific Hardware Abstraction Library (HAL); the compiler turns P4 code into a target independent core program that is linked to this library and invokes its operations. The two stage separation improves portability: to support a new architecture, only the hardware dependent library has to be implemented. In the demo, we demonstrate the flexibility of our compiler with a HAL for Intel DPDK, and show the packet processing and forwarding performance of compiled switches in different scenarios.

Analysis of preprocessor constructs in Erlang

Program analysis and transformation tools work on source code, which - as in the case of Erlang - may contain macros and other preprocessor directives. Such preprocessor constructs have to be treated in an utterly different way than lexical and syntactical constructs. This paper presents an approach to treat preprocessor constructs in a non-invasive way that is reasonably efficient and supports code transformations and analyses in an Erlang specific framework.

Language Design and Implementation via the Combination of Embedding and Parsing

Language embedding is a method to implement a new language within the framework of an existing programming language. This method is known to speed up the development process compared to standalone languages using classical compiler technology. On the other hand, embedded languages may not be that convenient for the end-users as standalone ones with own concrete syntax. This paper describes a method that uses the flexibility of language embedding in the experimental phase of the language design process, then, once the language features are mature enough, adds concrete syntax and turns the language to a standalone one. Lessons learnt from a project, run in industry-university cooperation and using the presented method, are discussed. Based on these results, a cost model is established that can be used to estimate the potential benefits of this method in case of future language design projects.

The EDSL’s Struggle for Their Sources

Embedded Domain Specific Languages make language design and implementation easier, because lexical and syntactical analysis and part of the semantic checks can be completed by the compiler of the host language.

Testing framework for embedded languages

Embedding a new programming language into an existing one is a widely used technique, because it fastens the development process and gives a part of a language infrastructure for free (e.g. lexical, syntactical analyzers). In this paper we are presenting a new advantage of this development approach regarding to adding testing support for these new languages. Tool support for testing is a crucial point for a newly designed programming language. It could be done in the hard way by creating a testing tool from scratch, or we could try to reuse existing testing tools by extending them with an interface to our new language. The second approach requires less work, and also it fits very well for the embedded approach. The problem is that the creation of such interfaces is not straightforward at all, because the existing testing tools were mostly not designed to be extendable and to be able to deal with new languages. This paper presents an extendable and modular model of a testing framework, in which the most ba...

Adaptive, safe mobile robot programming in the Intelligent Space

This paper describes how the safe mobile code technology can be integrated into the Intelligent Space environment. In the Intelligent Space, several Distributed Intelligent Network Devices communicate and share their information about a human environment. In this environment mobile robots can be controlled with mobile code technology. The mobile code is a program-component obtained from a remote system, transferred across a network and dynamically downloaded and executed on the robots. This code is created, verified, stored and transmitted to the robot using the Certified Proved-Property-Carrying Code architecture, where properties and their proofs also attached to the code. The receiver can verify the proofs and it can decide whether to use or to refuse the received mobile component. Information about the robots environment is also sent to the robot from the Intelligent Space. Robots contain explicit and formally expressed security requirements. Explicit and formal properties of the mobile code are attached to the mobile code. Then a formal verification system can verify the mobile code properties correspondence against the robots requirements. The robot refuses to execute those mobile code tasks violating its requirements.

Temporal Properties of Clean Programs Proven in Sparkle-T

In a pure functional language a series of values computed from one another can be considered as different states of the same “abstract object”. For this abstract object temporal properties (e.g. invariants) can be formulated and proved. This paper explains how to define and prove certain kinds of temporal properties of programs written in the pure functional language Clean. Sparkle, a theorem prover designed for Clean, is applied as a tool. Since Sparkle is not capable of handling temporal logical properties, its original version has been extended to support object abstraction, certain temporal properties and a new form of theorems which includes hypotheses. The resulting system is called Sparkle-T. The examples presented in this paper illustrate how object abstraction and the definition and proof of temporal properties can be carried out in Sparkle-T. Furthermore, some novel features of the Sparkle-T system are demonstrated as well.

A Data Intensive Computation on a Cluster

We have investigated the applicability of PC clusters with terabyte disk-servers for data-intensive parallel computing. We used parallel element-wise processing as our testcase. We have searched for the optimal value for parameters of the algorithm running on our hardware environment. The performance of several communication frameworks has been tested, such as C/PVM, C/MPI, Distributed Haskell and socket interface in C. On large inputs with heavy operations our implementations showed considerable speedups.