24,251 research outputs found
Persistent Contextual Values as Inter-Process Layers
Mobile applications today often fail to be context aware when they also need
to be customizable and efficient at run-time. Context-oriented programming
allows programmers to develop applications that are more context aware. Its
central construct, the so-called layer, however, is not customizable. We
propose to use novel persistent contextual values for mobile development.
Persistent contextual values automatically adapt their value to the context.
Furthermore they provide access without overhead. Key-value configuration files
contain the specification of contextual values and the persisted contextual
values themselves. By modifying the configuration files, the contextual values
can easily be customized for every context. From the specification, we generate
code to simplify development. Our implementation, called Elektra, permits
development in several languages including C++ and Java. In a benchmark we
compare layer activations between threads and between applications. In a case
study involving a web-server on a mobile embedded device the performance
overhead is minimal, even with many context switches.Comment: 8 pages Mobile! 16, October 31, 2016, Amsterdam, Netherland
Towards a Decoupled Context-Oriented Programming Language for the Internet of Things
Easily programming behaviors is one major issue of a large and reconfigurable
deployment in the Internet of Things. Such kind of devices often requires to
externalize part of their behavior such as the sensing, the data aggregation or
the code offloading. Most existing context-oriented programming languages
integrate in the same class or close layers the whole behavior. We propose to
abstract and separate the context tracking from the decision process, and to
use event-based handlers to interconnect them. We keep a very easy declarative
and non-layered programming model. We illustrate by defining an extension to
Golo-a JVM-based dynamic language
A Type System for First-Class Layers with Inheritance, Subtyping, and Swapping
Context-Oriented Programming (COP) is a programming paradigm to encourage
modularization of context-dependent software. Key features of COP are
layers---modules to describe context-dependent behavioral variations of a
software system---and their dynamic activation, which can modify the behavior
of multiple objects that have already been instantiated. Typechecking programs
written in a COP language is difficult because the activation of a layer can
even change objects' interfaces. Inoue et al. have informally discussed how to
make JCop, an extension of Java for COP by Appeltauer et al., type-safe.
In this article, we formalize a small COP language called ContextFJ
with its operational semantics and type system and show its type soundness. The
language models main features of the type-safe version of JCop, including
dynamically activated first-class layers, inheritance of layer definitions,
layer subtyping, and layer swapping
Towards adaptive multi-robot systems: self-organization and self-adaptation
Dieser Beitrag ist mit Zustimmung des Rechteinhabers aufgrund einer (DFG geförderten) Allianz- bzw. Nationallizenz frei zugÀnglich.This publication is with permission of the rights owner freely accessible due to an Alliance licence and a national licence (funded by the DFG, German Research Foundation) respectively.The development of complex systems ensembles that operate in uncertain environments is a major challenge. The reason for this is that system designers are not able to fully specify the system during specification and development and before it is being deployed. Natural swarm systems enjoy similar characteristics, yet, being self-adaptive and being able to self-organize, these systems show beneficial emergent behaviour. Similar concepts can be extremely helpful for artificial systems, especially when it comes to multi-robot scenarios, which require such solution in order to be applicable to highly uncertain real world application. In this article, we present a comprehensive overview over state-of-the-art solutions in emergent systems, self-organization, self-adaptation, and robotics. We discuss these approaches in the light of a framework for multi-robot systems and identify similarities, differences missing links and open gaps that have to be addressed in order to make this framework possible
A Functional Architecture Approach to Neural Systems
The technology for the design of systems to perform extremely complex combinations of real-time functionality has developed over a long period. This technology is based on the use of a hardware architecture with a physical separation into memory and processing, and a software architecture which divides functionality into a disciplined hierarchy of software components which exchange unambiguous information. This technology experiences difficulty in design of systems to perform parallel processing, and extreme difficulty in design of systems which can heuristically change their own functionality. These limitations derive from the approach to information exchange between functional components. A design approach in which functional components can exchange ambiguous information leads to systems with the recommendation architecture which are less subject to these limitations. Biological brains have been constrained by natural pressures to adopt functional architectures with this different information exchange approach. Neural networks have not made a complete shift to use of ambiguous information, and do not address adequate management of context for ambiguous information exchange between modules. As a result such networks cannot be scaled to complex functionality. Simulations of systems with the recommendation architecture demonstrate the capability to heuristically organize to perform complex functionality
- âŠ