In most peer‐to‐peer (P2P) networks, peers are placed randomly or based on their geographical position, which can lead to a performance bottleneck. This problem can be solved by using peer clustering algorithms. In this paper, the significant results of the paper can be described in the following sentences. We propose two innovative swarm‐based metaheuristics for peer clustering, slime mold and slime mold K‐means. They are competitively benchmarked, evaluated, and compared to nine well‐known conventional and swarm‐based algorithms: artificial bee colony (ABC), ABC combined with K‐means, ant‐based clustering, ant K‐means, fuzzy C‐means, genetic K‐means, hierarchical clustering, K‐means, and particle swarm optimization (PSO). The benchmarks cover parameter sensitivity analysis and comparative analysis made by using 5 different metrics: execution time, Davies–Bouldin index (DBI), Dunn index (DI), silhouette coefficient (SC), and averaged dissimilarity coefficient (ADC). Furthermore, a statistical analysis is performed in order to validate the obtained results. Slime mold and slime mold K‐means outperform all other swarm‐inspired algorithms in terms of execution time and quality of the clustering solution.

Distributed coordination scenarios place high demands on concurrency and interaction. They are therefore a typical source of errors in design and implementation. The Peer Model is a modeling tool for coordination based on blackboard-based collaboration. Its goal is to help developers of coordination software better understand algorithms and identify deficiencies from the beginning. This paper describes the open source implementation of the Peer Model tool-chain, which is made available on GitHub1 and Zenodo2 including a tutorial video published at YouTube3 and Zenodo4. The tool-chain consists of a modeler, translator and simulator.

Most of nowadays modeling tools for creating business processes in enterprises can be used by IT experts to semi-automatically create corresponding software artifacts of the given process. Unfortunately, these tools comprise a lot of complexity, and therefore, they are not usable by ordinary end users. In this paper, we propose a modeling tool for ad-hoc business processes with a comprehensible and simple user interface that is usable by end users to model their daily life workflows. Afterwards, a fully executable application can be created from the model automatically. Also, we introduce a notion of the so-called “micro-room concept”, which is used as a basis for the abstraction of the modeling tool. The created micro-room framework allows designing peer-to-peer applications based on configurable, shared data rooms. The evaluation and comparison analysis of the modeling tool itself and the underlying micro-room concept have been done by means of usability studies. The preliminary results show that the micro-room concept uses a more comprehensible abstraction compared to other modeling languages. It is well suited for modeling simple collaborative tasks whereas other approaches are better in case of very complex processes. Further, the developed modeling tool is more intuitive than the competing ones due to the simplifications allowed by using the micro-room concept.

Highly dynamic distributed applications often require flexible coordination among several autonomous components. Space-based middleware provides a suitable, data-driven coordination paradigm for such scenarios, where distributed peers exchange data and commands in a scalable and decoupled way using shared tuple spaces. In its basic form, such a middleware supports access to a data storage and (blocking) queries on the stored tuples. However, in many cases the injection of additional server-side logic would ease the development of complex applications, as the semantics of the tuple space can be adapted to domain-specific requirements. This paper introduces reactive programming features for XVSM, a space-based middleware that enhances the tuple space concept with powerful coordination mechanisms. We present a comprehensive extension mechanism that supports the execution of application logic in reaction to composite and time-based events. As an example for the feasibility of the approach, we provide a bootstrapped solution for a leasing mechanism that manages the lifetime of data in the space.

Industrial functional safety managers claim that there is no safety (S) without quality (Q) possible. The contribution is to make aware of the importance of standards and the compliance with processes. An overview of relevant functional safety analysis activities is given based on industrial experience in the area of automotive and railway. Even though these methods and software development processes are well known in research and education, we argue that there is still a gap to industrial development of safety critical embedded systems. We conclude with a discussion about the importance of compliance with software development processes also in the academic world. The question we want to raise is: Is engineering-education (E) without quality management lasting?

Data grids are used in large scale scientific experiments to access and store nontrivial amounts of data by combining the storage resources from multiple data centers in one system. This enables users and automated services to use the storage resources in a common and efficient way. However, as data grids grow it becomes a hard problem for developers and operators to estimate how modifications in policy, hardware, and software affect the performance metrics of the data grid. In this paper we address the modeling of operational data grids. We first analyze the data grid middleware system of the ATLAS experiment at the Large Hadron Collider to identify components relevant to the data grid performance. We describe existing modeling approaches for pre-transfer, network, storage, and validation components, and build black-box models for these components. Consequently, we present a novel hybrid model, which unifies these separate component models, and we evaluate the model using an event simulator. The evaluation is based on historic workloads extracted from the ATLAS data grid. The median evaluation error of the hybrid model is at 22%.

Today’s emerging trends like factory of the future, big data, Internet-of-things, intelligent traffic solutions, cyber-physical systems, wireless sensor networks, smart home, smart city and smart grid raise new challenges on software development. They are characterized by high concurrency, distribution and dynamics as well as huge numbers of heterogeneous devices, resources and users that must collaborate in a reliable way. The management of the interactions and dependencies between the participants is a complex task posing massive coordination problems. The here proposed approach is twofold: (i) to analyze similarities in the communication and synchronization behavior of such applications and to identify coordination patterns; and (ii) to give a precise specification of them by means of a suitable coordination model which enables the development of coordination pattern-based software components as solutions. The vision is to compose advanced cooperative information systems from proven, configurable, reusable, generic components that run on a suitable target platform, in order to reduce software development time, risks and costs. In this paper we delimit the idea of “coordination patterns” from other related pattern approaches and motivate the need for a well-defined model to specify them. Several coordination models to achieve this goal are discussed, and the advantages of a new coordination model termed the “Peer Model” are pointed out. The feasibility of the approach to identify coordination patterns, to model them and to provide generic components that can be reused in different scenarios through configuration and composition is evaluated by means of a coordination pattern found in several industrial use cases.

Distributed applications require coordination of distributed software components in order to achieve a common goal. A coordination model that abstracts the complexity of network communication eases the development of such applications. The objective is to design collaboration with remote hosts in the same way as local interactions. Separation of coordination logic and application code increases maintainability, as components can be easily replaced with alternative versions. Different applications often have similar requirements on their coordination logic, e.g. concerning replication or load balancing. Instead of developing this functionality for each application separately, reusable generic patterns should be applied and adapted to the corresponding use case. In this paper, we describe how a coordination model based on asynchronous, data-driven communication among autonomous peers can be enhanced with a mechanism to support flexible coordination patterns. Patterns are adapted using parametrization and extension mechanisms, while complex coordination tasks can be modeled via composition of simpler sub-patterns. These concepts are demonstrated on an example where a MapReduce algorithm is incrementally designed and implemented using coordination patterns on top of a middleware that realizes the examined coordination model.

Fundamental problem in human-robot teams is to find a set of heterogeneous robots that have to cooperate to execute a complex mission. This paper describes the Shared Knowledge Interaction Modelling (SKIM) framework for task allocation and how it is used to: 1) evaluate the performance of finding a set of robots to execute a certain task, and 2) model shared knowledge as a basis for adaptive autonomy in mixed human-robot teams. The shared knowledge is described by means of two ontologies: SKIM Resource Ontology (SKIM-RO) and SKIM Coordination Ontology (SKIM-CO). SKIM-RO describes resources, including robot capabilities and task requirements, and SKIM-CO describes coordination constraints for robot-robot and robot-human interactions. SKIM-CO is a basis for reasoning which enables the task allocation, and captures the concept of adaptive autonomy. This paper illustrates how framework is used to model and evaluate performance of task allocation in three use cases with the different level of task complexity. The results indicate how adaptive autonomy and shared knowledge improve performance in task allocation in complex missions.

Collaborative applications usually involve multiple autonomous processes that have to coordinate themselves over the Internet in an efficient way. For such systems, shared tuple spaces provide a highly flexible coordination medium that enables the asynchronous exchange of messages and data and decouples the participants so that they do not need to know each other. However, if interactions are complex, security constraints are difficult to manage and to enforce. Unauthorized processes must be prevented from accessing protected data using fine-grained permissions that are specified by comprehensible policies. In this paper, we present an authorization model for an extensible space-based middleware that uses its own coordination mechanisms to specify fine-grained access control policies with simple yet expressive rules on function parameters, data content, and context information. It is shown how a modular architecture for an authorization framework that enforces these policies can be bootstrapped with the middleware itself, enabling simple management of policies. The integration of coordination and security mechanisms into a single concept allows for flexible and secure distributed collaboration, as shown by a use case based on an open reviewing platform.

For constantly changing businesses, it is essential that the underlying software architecture is capable of managing agile business processes and meeting future business needs. Decoupling between applications and services in distributed systems is addressed by e. g., service-oriented architectures. On the other hand, applications and its underlying middleware are still tightly coupled with respect to the middleware's architectural style. As a result of the tight coupling middleware adaptations introduced due to e. g., new business requirements can affect the application as well. In this paper we propose the concept of space-based architecture (SBA), that allows decoupling distributed applications with respect to the underlying middleware architecture by combining the characteristics and properties of state-of-the-art middleware architectural styles captured in a simple API. The benefit of our approach is minimal application adaptations in case of changing the underlying middleware architectural style, which allows for more efficient realization of new business requirements.

In the past years, it has been investigated in multiple research projects how shared data spaces can be extended with concepts and technologies from the semantic web area, which led to the development of so-called semantic spaces. These semantic spaces enable clients to publish semantically annotated data at a shared repository and to react to changes of information that can be inferred from this data. The declarative description of logical dependencies and their automated evaluation through the semantic space allow for the development of simple and elegant solutions for various complex communication and coordination problems. The investigation of many space based applications as well as experience we gained during our own work have shown that there already exist several best practices for solving many of these problems. However, no standard solutions have been established yet. In this paper, we determine a set of API operations that are supported by most available semantic space implementations and employ this set of operations as a common language for the description of four generic knowledge-based interaction patterns. The paper introduces certain usage scenarios, illustrates the benefits of using semantic spaces, and should serve as a basis for further pattern descriptions.

Location and manipulation of complex data is a difficult, challenging task in nowadays extremely complex IT systems and on the Internet, overwhelmed with a huge amount of information that develops and grows rapidly. In this paper, we propose a self-organizing approach that combines purely decentralized unstructured P2P with space based computing in order to locate effectively and filter (retrieve) information from a network. The inspiration came from swarm intelligence that possesses distributive and autonomous properties and represents a self-organizing biological system. The goal is to achieve a good query capability, which we prove by means of benchmarks.

Structured, spatial-temporal data arises in many applications areas such as transportation, sensor networks or mobile services. Peer to peer networks are the natural choice for the distributed architecture required by these applications. However, a closer analysis of the available distributed hash table (DHT) based approaches shows their inefficiency since the data structure gets lost and the short liveness of the data leads to a high signalling traffic. In this work we propose a novel storage network based on an overlay of Space-based Computing Containers for storing, accessing and manipulating dynamic data.

Space-based computing middleware offers a data driven style for the coordination of processes. The interaction requirements between these processes can be complex, and the template matching coordination law of the Linda and JavaSpaces model is not sufficient. Moreover, the usage should not be limited to a single platform. Several authors have proposed coordination extensions, but besides the suggestion to use XML or RDF based query facilities, a formalization of a general and extensible space-based coordination model has not yet been realized. In this paper we present the algebraic data structures and the coordination model based on a navigational query language for the extensible virtual shared memory architecture, and show how they can be adapted to support arbitrary coordination laws by the introduction of user-definable matchmaker and selector functions. The platform independence is achieved through a language independent communication protocol. The formal specification of the data model is the necessary basis for this protocol.

The effectiveness of Intelligent Transportation Systems (ITS) depends on their ability to collect contextual data from various sources and appropriately generate and transport comprehensible, reliable and timely content to users. In such applications, the exchanged content is structured in space and time. Peer-to-peer(P2P) networks are the natural choice these applications due to their fault-tolerance, self-organization and scalability properties. However, a closer analysis of the available Distributed Hash Tables (DHT) protocols shows that the structure of the data gets lost and its short liveness leads to high signalling traffic. In this work we propose a novel overlay network of so called Space Containers for storing, accessing, manipulating and structuring dynamic geo-located content. The benefits of combining Space Containers and DHT are: clean application programming logic and efficient content retrieval while preserving the properties of DHTs. We describe the system architecture applied to a transportation scenario and show preliminary evaluation results.

No abstract available.

Rapid growth in the area of multidatabase systems (MDBSs), which involve both the access of global data and distributed transaction processing, has created a need for programming languages that provide communication reliability and powerful synchronization. The requirements of MDBSs are reviewed, and the Vienna Parallel Logic programming language is presented. The ways to realize an MDBS communication protocol in this language are discussed. The Vienna Parallel Logic language incorporates a concurrent logic language, as well as features of both distributed operating systems and database management systems. These features combine to support the communication and synchronization required by distributed transaction processing. The Vienna Parallel Logic language is suitable for use as a general-purpose distributed programming and coordination language.>