Abstract not found

Abstract This paper describes the development of the programming language Erlang during the period 1985-1997. Erlang is a concurrent programming language designed for programming large-scale distributed soft real-time control applications. The design of Erlang was heavily influenced by ideas from the logic and functional programming communities. Other sources of inspiration came from languages such as Chill and Ada which are used in industry for programming control systems. 1 Introduction This paper describes the development of the Erlang programming language. Erlang is a language which draws heavily from various traditions in the logic, functional and realtime control programming communities. Our goal was to make a language which could be used for building large soft real-time control systems. By large I mean systems with possibly millions of lines of code. By a soft real-time system I mean a system which does not fail catastrophically if a real-time deadline is missed.

product, having over a million lines of Erlang code. This product (the AXD301) is thought to be one of the most reliable products ever made by Ericsson.

This paper describes the Erlang programming language and some of the applications which have been programmed in Erlang. Erlang has many language features more commonly associated with an operating system than a language. Concurrent processes, scheduling, garbage collection, etc., are all performed by the Erlang run-time system and not by the underlying operating system. The paper starts with a description of some of the requirements that we wanted to satisfy when designing the language. This is followed by a brief introduction to the language. Finally, we discuss some of the applications which have been programmed in Erlang. We have chosen to concentrate on three applications which are commercial products. 1

Natural semantics is a formalism used for specifying both semantics and implementations of programming languages. Until recently, no practical implementation of the formalism existed. We have defined the Relational Meta-Language, RML, as an executable specification language for natural semantics. After a brief outline of the language, we describe the compilation strategy used by our rml2c compiler: transformations are applied to minimize non-determinism, and a continuation-passing style form is produced and simplified. Finally the CPS is emitted as low-level C code, using an efficient technique for implementing tailcalls. We also present performance measurements that support our choice of compilation strategy.

Over 25 implementations of different functional languages are benchmarked using the same program, a floatingpoint intensive application taken from molecular biology. The principal aspects studied are compile time and 1 Dept. of Computer Systems, Univ. of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands, e-mail: pieter@fwi.uva.nl 2 D'epart. d'informatique et r.o., Univ. de Montr'eal, succursale centre-ville, Montr'eal H3C 3J7, Canada, e-mail: feeley@iro.umontreal.ca 3 Informatik, Universitat des Saarlandes, 66041 Saarbrucken 11, Germany, e-mail: alt@cs.uni-sb.de 4 Dept. of Computer Systems, Chalmers Univ. of Technology, 412 96 Goteborg, Sweden, e-mail: augustss@cs.chalmers.se 5 Dept. of Computer Science, Univ. of Zurich, Winterthurerstr. 190, 8057 Zurich, Switzerland, e-mail: baumann@ifi.unizh.ch 6 Dept. of Computer Systems, Univ. of Amsterdam, Kruislaan 403, 1098 SJ Amsterdam, The Netherlands, e-mail: beemster@fwi.uva.nl 7 LIENS, URA 1327 du CNRS, ' Ecole Normale Sup'erieur...

Mercury is a new purely declarative logic programming language that requires programmers to write declarations for every predicate in the program. Although the main motivation for this requirement is that it allows the compiler to catch most programmer errors, it also allows the Mercury code generator to rely on the presence of type, mode and determinism information about every predicate in the program. The code generator exploits a new execution algorithm based on the availability of this information as well as some novel techniques (lazy code generation, follow-code migration, the use of a compile-time failure continuation stack) to produce very high quality code. This code is in C and is therefore quite portable. Benchmarks show that the Mercury implementation produces much faster code than wamcc, Quintus Prolog, SICStus Prolog and Aquarius Prolog.

Core Erlang is a new, o cial core language for the concurrent functional language Erlang. Core Erlang is functional, strict, dynamically typed, pattern matching, higher order and concurrent. It has been developed in cooperation between the High-Performance Erlang project at Uppsala University and the Erlang/Open Telecom Platform development team at Ericsson, and is a central component in the new release of the Erlang/OTP compiler. This paper describes the core language, its relation to Erlang, and the history of its development. We show examples of translation from Erlang to Core Erlang, illustrating how analysis and transformation of Erlang programs is greatly simplified by being performed at the core language level.

The programming languages Erlang and Scheme have many common features, yet the performance of the current implementations of Erlang appears to be below that of good implementations of Scheme. This disparity has prompted us to investigate the translation of Erlang to Scheme. Our intent is to reuse the mature compilation technology of current Scheme compilers to quickly implement an efficient Erlang compiler. In this paper we describe the design and implementation of the Etos Erlang to Scheme compiler and compare its performance to other systems. The Scheme code produced by Etos is compiled by the Gambit-C Scheme to C compiler and the resulting C code is finally compiled by gcc. One might think that the many stages of this compilation pipeline would lead to an inefficient compiler but in fact, on most of our benchmark programs, Etos outperforms all currently available implementations of Erlang, including the Hipe native code compiler.

Many logic programming implementations compile to C, but they compile to very low-level C, and thus discard many of the advantages of compiling to a high-level language. We describe an alternative approach to compiling logic programs to C, based on continuation passing, that we have used in a new back-end for the Mercury compiler. The new approach compiles to much higher-level C code, which means the compiler back-end and run-time system can be considerably simpler.