2,271 research outputs found
Functional Federated Learning in Erlang (ffl-erl)
The functional programming language Erlang is well-suited for concurrent and
distributed applications. Numerical computing, however, is not seen as one of
its strengths. The recent introduction of Federated Learning, a concept
according to which client devices are leveraged for decentralized machine
learning tasks, while a central server updates and distributes a global model,
provided the motivation for exploring how well Erlang is suited to that
problem. We present ffl-erl, a framework for Federated Learning, written in
Erlang, and explore how well it performs in two scenarios: one in which the
entire system has been written in Erlang, and another in which Erlang is
relegated to coordinating client processes that rely on performing numerical
computations in the programming language C. There is a concurrent as well as a
distributed implementation of each case. Erlang incurs a performance penalty,
but for certain use cases this may not be detrimental, considering the
trade-off between conciseness of the language and speed of development (Erlang)
versus performance (C). Thus, Erlang may be a viable alternative to C for some
practical machine learning tasks.Comment: 16 pages, accepted for publication in the WFLP 2018 conference
proceedings; final post-prin
Comparing Languages for Engineering Server Software: Erlang, Go, and Scala with Akka
Servers are a key element of current IT infrastructures, and must often deal with large numbers of concurrent requests. The programming language used to construct the server has an important role in engineering efficient server software, and must support massive concurrency on multicore machines with low communication and synchronisation overheads. This paper investigates 12 highly concurrent programming languages suitable for engineering servers, and analyses three representative languages in detail: Erlang, Go, and Scala with Akka. We have designed three server benchmarks that analyse key performance characteristics of the languages. The benchmark results suggest that where minimising message latency is crucial, Go and Erlang are best; that Scala with Akka is capable of supporting the largest number of dormant processes; that for servers that frequently spawn processes Erlang and Go minimise creation time; and that for constantly communicating processes Go provides the best throughput
Recommended from our members
A DSL For Logistics Clouds
Cloud is a new area of specialization in the computing world, and, as such, it has not been explicitly addressed by traditional programming languages and environments. Therefore, there is a need to create Domain Specific Languages (DSLs) for it. This paper presents such a DSL that targets logistics clouds, i.e. networked resources and systems of logistics organisations. The DSL is implemented on top of the functional concurrent language Erlang and its distributed data management system Mnesia. The paper presents features of the DSL that implement commonly occurring use cases in the logistics cloud such as message exchange, document sharing and notifications. We show how program features in this DSL map to the underlying Erlang/OTP runtime
Efficient and Reasonable Object-Oriented Concurrency
Making threaded programs safe and easy to reason about is one of the chief
difficulties in modern programming. This work provides an efficient execution
model for SCOOP, a concurrency approach that provides not only data race
freedom but also pre/postcondition reasoning guarantees between threads. The
extensions we propose influence both the underlying semantics to increase the
amount of concurrent execution that is possible, exclude certain classes of
deadlocks, and enable greater performance. These extensions are used as the
basis an efficient runtime and optimization pass that improve performance 15x
over a baseline implementation. This new implementation of SCOOP is also 2x
faster than other well-known safe concurrent languages. The measurements are
based on both coordination-intensive and data-manipulation-intensive benchmarks
designed to offer a mixture of workloads.Comment: Proceedings of the 10th Joint Meeting of the European Software
Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of
Software Engineering (ESEC/FSE '15). ACM, 201
Towards sound refactoring in erlang
Erlang is an actor-based programming
language used extensively for building concurrent, reactive
systems that are highly available and suff er minimum
downtime. Such systems are often mission critical, making
system correctness vital. Refactoring is code restructuring
that improves the code but does not change
behaviour. While using automated refactoring tools is
less error-prone than performing refactorings manually,
automated refactoring tools still cannot guarantee that
the refactoring is correct, i.e., program behaviour is preserved.
This leads to lack of trust in automated refactoring
tools. We rst survey solutions to this problem
proposed in the literature. Erlang refactoring tools as
commonly use approximation techniques which do not
guarantee behaviour while some other works propose the
use of formal methodologies. In this work we aim to
develop a formal methodology for refactoring Erlang
code. We study behavioural preorders, with a special focus
on the testing preorder as it seems most suited to
our purpose.peer-reviewe
RELEASE: A High-level Paradigm for Reliable Large-scale Server Software
Erlang is a functional language with a much-emulated model for building reliable distributed systems. This paper outlines the RELEASE project, and describes the progress in the rst six months. The project aim is to scale the Erlang's radical concurrency-oriented programming paradigm to build reliable general-purpose software, such as server-based systems, on massively parallel machines. Currently Erlang has inherently scalable computation and reliability models, but in practice scalability is constrained by aspects of the language and virtual machine. We are working at three levels to address these challenges: evolving the Erlang virtual machine so that it can work effectively on large scale multicore systems; evolving the language to Scalable Distributed (SD) Erlang; developing a scalable Erlang infrastructure to integrate multiple, heterogeneous clusters. We are also developing state of the art tools that allow programmers to understand the behaviour of massively parallel SD Erlang programs. We will demonstrate the e ectiveness of the RELEASE approach using demonstrators and two large case studies on a Blue Gene
RELEASE: A High-level Paradigm for Reliable Large-scale Server Software
Erlang is a functional language with a much-emulated model for building reliable distributed systems. This paper outlines the RELEASE project, and describes the progress in the first six months. The project aim is to scale the Erlangās radical concurrency-oriented programming paradigm to build reliable general-purpose software, such as server-based systems, on massively parallel machines. Currently Erlang has inherently scalable computation and reliability models, but in practice scalability is constrained by aspects of the language and virtual machine. We are working at three levels to address these challenges: evolving the Erlang virtual machine so that it can work effectively on large scale multicore systems; evolving the language to Scalable Distributed (SD) Erlang; developing a scalable Erlang infrastructure to integrate multiple, heterogeneous clusters. We are also developing state of the art tools that allow programmers to understand the behaviour of massively parallel SD Erlang programs. We will demonstrate the effectiveness of the RELEASE approach using demonstrators and two large case studies on a Blue Gene
Multi-level Visualization of Concurrent and Distributed Computation in Erlang
This paper describes a prototype visualization system
for concurrent and distributed applications programmed
using Erlang, providing two levels of granularity of view. Both
visualizations are animated to show the dynamics of aspects of
the computation.
At the low level, we show the concurrent behaviour of the
Erlang schedulers on a single instance of the Erlang virtual
machine, which we call an Erlang node. Typically there will be
one scheduler per core on a multicore system. Each scheduler
maintains a run queue of processes to execute, and we visualize
the migration of Erlang concurrent processes from one run queue
to another as work is redistributed to fully exploit the hardware.
The schedulers are shown as a graph with a circular layout. Next
to each scheduler we draw a variable length bar indicating the
current size of the run queue for the scheduler.
At the high level, we visualize the distributed aspects of the
system, showing interactions between Erlang nodes as a dynamic
graph drawn with a force model. Speci?cally we show message
passing between nodes as edges and lay out nodes according to
their current connections. In addition, we also show the grouping
of nodes into ās_groupsā using an Euler diagram drawn with
circles
- ā¦