3,665 research outputs found
A Configurable Transport Layer for CAF
The message-driven nature of actors lays a foundation for developing scalable
and distributed software. While the actor itself has been thoroughly modeled,
the message passing layer lacks a common definition. Properties and guarantees
of message exchange often shift with implementations and contexts. This adds
complexity to the development process, limits portability, and removes
transparency from distributed actor systems.
In this work, we examine actor communication, focusing on the implementation
and runtime costs of reliable and ordered delivery. Both guarantees are often
based on TCP for remote messaging, which mixes network transport with the
semantics of messaging. However, the choice of transport may follow different
constraints and is often governed by deployment. As a first step towards
re-architecting actor-to-actor communication, we decouple the messaging
guarantees from the transport protocol. We validate our approach by redesigning
the network stack of the C++ Actor Framework (CAF) so that it allows to combine
an arbitrary transport protocol with additional functions for remote messaging.
An evaluation quantifies the cost of composability and the impact of individual
layers on the entire stack
Reliable Actors with Retry Orchestration
Enterprise cloud developers have to build applications that are resilient to
failures and interruptions. We advocate for, formalize, implement, and evaluate
a simple, albeit effective, fault-tolerant programming model for the cloud
based on actors, reliable message delivery, and retry orchestration. Our model
guarantees that (1) failed actor invocations are retried until success, (2) in
a distributed chain of invocations only the last one may be retried, (3)
pending synchronous invocations with a failed caller are automatically
cancelled. These guarantees make it possible to productively develop
fault-tolerant distributed applications ranging from classic problems of
concurrency theory to complex enterprise applications. Built as a service mesh,
our runtime system can interface application components written in any
programming language and scale with the application. We measure overhead
relative to reliable message queues. Using an application inspired by a typical
enterprise scenario, we assess fault tolerance and the impact of fault recovery
on application performance.Comment: 14 pages, 6 figure
A PROGRAMMING FRAMEWORK TO EASE DEVELOPMENT OF TIGHTLY-COUPLED CLOUD APPLICATIONS
Cloud application development is currently for professionals only. To make the cloud more accessible, cloud applications should ideally be easy to develop so that virtually anyone can develop their own cloud applications. However, they are difficult to develop, because they are essentially distributed systems, where the concurrent operations may take place, and reasoning about the behavior of concurrent operations to ensure correctness is not trivial. Additionally, programmers must consider failure handling, scalability, consistency, modularity, elasticity
Stateful Entities: Object-oriented Cloud Applications as Distributed Dataflows
Programming stateful cloud applications remains a very painful experience.
Instead of focusing on the business logic, programmers spend most of their time
dealing with distributed systems considerations, with the most important being
consistency, load balancing, failure management, recovery, and scalability. At
the same time, we witness an unprecedented adoption of modern dataflow systems
such as Apache Flink, Google Dataflow, and Timely Dataflow. These systems are
now performant and fault-tolerant, and they offer excellent state management
primitives.
With this line of work, we aim at investigating the opportunities and limits
of compiling general-purpose programs into stateful dataflows. Given a set of
easy-to-follow code conventions, programmers can author stateful entities, a
programming abstraction embedded in Python. We present a compiler pipeline
named StateFlow, to analyze the abstract syntax tree of a Python application
and rewrite it into an intermediate representation based on stateful dataflow
graphs. StateFlow compiles that intermediate representation to a target
execution system: Apache Flink and Beam, AWS Lambda, Flink's Statefun, and
Cloudburst. Through an experimental evaluation, we demonstrate that the code
generated by StateFlow incurs minimal overhead. While developing and deploying
our prototype, we came to observe important limitations of current dataflow
systems in executing cloud applications at scale
A Review of Platforms for the Development of Agent Systems
Agent-based computing is an active field of research with the goal of
building autonomous software of hardware entities. This task is often
facilitated by the use of dedicated, specialized frameworks. For almost thirty
years, many such agent platforms have been developed. Meanwhile, some of them
have been abandoned, others continue their development and new platforms are
released. This paper presents a up-to-date review of the existing agent
platforms and also a historical perspective of this domain. It aims to serve as
a reference point for people interested in developing agent systems. This work
details the main characteristics of the included agent platforms, together with
links to specific projects where they have been used. It distinguishes between
the active platforms and those no longer under development or with unclear
status. It also classifies the agent platforms as general purpose ones, free or
commercial, and specialized ones, which can be used for particular types of
applications.Comment: 40 pages, 2 figures, 9 tables, 83 reference
Engineering a Highly Scalable Object-aware Process Management Engine Using Distributed Microservices
Scalability of information systems has been a research topic for many years and is as relevant as ever with the dramatic increases in digitization of business processes and data. This also applies to process-aware information systems, most of which are currently incapable of scaling horizontally, i.e., over multiple servers. This paper presents the design science artifact that resulted from engineering a highly scalable process management system relying on the object-aware process man-agement paradigm. The latter allows for distributed process execution by conceptually encapsulating process logic and data into multiple in-teracting objects that may be processed concurrently. These objects, in turn, are represented by individual microservices at run-time, which can be hosted transparently across entire server clusters. We present mea-surement data that evaluates the scalability of the artifact on a compute cluster, demonstrating that the current prototypical implementation of the run-time engine can handle very large numbers of users and process instances concurrently in single-case mechanism experiments with large amounts of simulated user input. Finally, the development of scalable process execution engines will further the continued maturation of the data-centric business process management field
- …