Melinda Tóth

Discovering parallel pattern candidates in Erlang

The ParaPhrase Refactoring Tool for Erlang PaRTE provides automatic, comprehensive and reliable pattern candidate discovery to locate parallelisable components in Erlang programs. It uses semi-automatic and semantics-preserving program transformations to reshape source code and to introduce high level parallel patterns that can be mapped adaptively to the available hardware resources. This paper describes the main PaRTE tools and demonstrates that significant parallel speedups can be obtained.

Static analysis of complex software systems implemented in erlang

Static software analyser tools use different levels of intermediate source code representations that depend on the syntax and semantics of the language to be analysed. Most of the analyser tools use graph representation to efficiently retrieve information. Building such graphs for dynamically typed languages, such as Erlang, is not straightforward. In this paper we present static analysis methods to define the Dependency Graph representation of Erlang programs. The introduced methods cover the data-, control-, behaviour-flow and dependency analyses for sequential and parallel language constructs.

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.

Refactorings to Enable Parallelization

We propose program analyses to identify parallelizable code fragments, and program transformations to change those fragments into applications of high-level parallel patterns. The methodology has been worked out, and is presented here, in the context of the Erlang programming language, but the approach is applicable in other languages as well.

Comprehensible presentation of clone detection results

Duplicated code detection has been an active research field for several decades. Although many algorithms have been proposed, only a few researches have focused on the comprehensive presentation of the detected clones. During the evaluation of clone detectors developed by the authors, it was observed that the results of the clone detectors were hard to comprehend. Therefore, in this paper a broadly suitable grouping method with which clone pairs can be easily grouped together to provide a more compact result is presented.

Selecting Erlang Test Cases Using Impact Analysis

Refactoring is a commonly used technology in the software development and maintenance process. However refactorings preserve the original behaviour of the system, developers want to be convinced about that, thus they retest the software after some modifications. Software testing is said to be the most expensive part of the lifecycle of software systems. Therefore our research focuses on selecting test cases affected by refactorings and have to be retested after the transformation. We describe the used mechanism in case of a dynamically typed functional programming language, Erlang.

Analysing and visualising Erlang behaviours

Understanding and maintaining the source code of industrial-scale software product is hard and time-consuming, and it is getting more difficult when the software implements parallel/concurrent/distributed computations and behaviours. Static source code analysis tools support program comprehension through detecting dependencies and relations among small (like functions and processes) or large (modules and components) software elements. For Erlang, which is a dynamically typed language, only an approximation of the real dependencies can be calculated statically. However it is possible to improve these analyses by adding application specific information, such as the most frequently used behaviours. In this paper we introduce an extension of the process relation analysis for Erlang which extract information of generic server behaviour implementations. The Communication Graph is extended with the result of the analysis.

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.

Pattern Candidate Discovery and Parallelization Techniques

Parallel computations in a program can be expressed conveniently, at a high level of abstraction, using parallel patterns such as task farm, pipeline or divide-and-conquer. In order to transform a sequential program into a pattern-based parallel one, the software developer may want to apply refactoring transformations on it. This tutorial explains a methodology to perform tool supported parallelization of programs by presenting how to use a specific static source code analysis and transformation system for Erlang. A key element of the approach is pattern candidate discovery, a static analysis technique to identify code fragments that can be refactored into a parallel pattern.

Towards context aware computations offloading in 5G

The emerging 5G network architecture, together with the concept of edge computing, seems to be the perfect solution to the requirements of Continuous Interactive Applications. All the components of this complex system have been mostly analysed as standalone without considering too deeply their interactions. While the mobile nature of continuous interactive scenarios like real time speech recognition or augmented reality, requires adaptive algorithms and context aware architectures. In this paper we investigate both dynamic and hybrid profiling, and adaptive partitioning, for a demanding augmented reality use case, identifying a possible offloading architecture.