129,978 research outputs found
FRIENDS - A flexible architecture for implementing fault tolerant and secure distributed applications
FRIENDS is a software-based architecture for implementing fault-tolerant and, to some extent, secure applications. This architecture is composed of sub-systems and libraries of metaobjects. Transparency and separation of concerns is provided not only to the application programmer but also to the programmers implementing metaobjects for fault tolerance, secure communication and distribution. Common services required for implementing metaobjects are provided by the sub-systems. Metaobjects are implemented using object-oriented techniques and can be reused and customised according to the application needs, the operational environment and its related fault assumptions. Flexibility is increased by a recursive use of metaobjects. Examples and experiments are also described
A metaobject architecture for fault-tolerant distributed systems : the FRIENDS approach
The FRIENDS system developed at LAAS-CNRS is a metalevel architecture providing libraries of metaobjects for fault
tolerance, secure communication, and group-based distributed applications. The use of metaobjects provides a nice separation of concerns between mechanisms and applications. Metaobjects can be used transparently by applications and can be composed according to the needs of a given application, a given architecture, and its underlying properties. In FRIENDS, metaobjects are used recursively to add new properties to applications. They are designed using an object oriented design method and implemented on top of basic system services. This paper describes the FRIENDS software-based architecture, the object-oriented development of metaobjects, the experiments that we have done, and summarizes the advantages and drawbacks of a metaobject approach for building fault-tolerant system
RAFDA: A Policy-Aware Middleware Supporting the Flexible Separation of Application Logic from Distribution
Middleware technologies often limit the way in which object classes may be
used in distributed applications due to the fixed distribution policies that
they impose. These policies permeate applications developed using existing
middleware systems and force an unnatural encoding of application level
semantics. For example, the application programmer has no direct control over
inter-address-space parameter passing semantics. Semantics are fixed by the
distribution topology of the application, which is dictated early in the design
cycle. This creates applications that are brittle with respect to changes in
distribution. This paper explores technology that provides control over the
extent to which inter-address-space communication is exposed to programmers, in
order to aid the creation, maintenance and evolution of distributed
applications. The described system permits arbitrary objects in an application
to be dynamically exposed for remote access, allowing applications to be
written without concern for distribution. Programmers can conceal or expose the
distributed nature of applications as required, permitting object placement and
distribution boundaries to be decided late in the design cycle and even
dynamically. Inter-address-space parameter passing semantics may also be
decided independently of object implementation and at varying times in the
design cycle, again possibly as late as run-time. Furthermore, transmission
policy may be defined on a per-class, per-method or per-parameter basis,
maximizing plasticity. This flexibility is of utility in the development of new
distributed applications, and the creation of management and monitoring
infrastructures for existing applications.Comment: Submitted to EuroSys 200
OpenPING: A Reflective Middleware for the Construction of Adaptive Networked Game Applications
The emergence of distributed Virtual Reality (VR) applications
that run over the Internet has presented networked game
application designers with new challenges. In an environment
where the public internet streams multimedia data and is
constantly under pressure to deliver over widely heterogeneous
user-platforms, there has been a growing need that distributed VR
applications be aware of and adapt to frequent variations in their
context of execution. In this paper, we argue that in contrast to
research efforts targeted at improvement of scalability, persistence
and responsiveness capabilities, much less attempts have been
aimed at addressing the flexibility, maintainability and
extensibility requirements in contemporary distributed VR
platforms. We propose the use of structural reflection as an
approach that not only addresses these requirements but also
offers added value in the form of providing a framework for
scalability, persistence and responsiveness that is itself flexible,
maintainable and extensible. We also present an adaptive
middleware platform implementation called OpenPING1 that
supports our proposal in addressing these requirements
AO-OpenCom: an AO-Middleware architecture supporting flexible dynamic reconfiguration
Middleware has emerged as a key technology in the construction of distributed systems. As a consequence, middleware is increasingly required to be highly modular and configurable, to support separation of concerns between services, and, crucially, to support dynamic reconfiguration: i.e. to be capable of being changed while running. Aspect-oriented middleware is a promising technology for the realisation of distributed reconfiguration in distributed systems. In this paper we propose an aspect-oriented middleware platform called AO-OpenCom that builds AO-based reconfiguration on top of a dynamic component approach to middleware system composition. The goal is to support extremely flexible dynamic reconfiguration that can be applied at all levels of the system and uniformly across the distributed environment. We evaluate our platform by the capability in meeting flexible reconfiguration and the impact of these overheads
Implementing fault tolerant applications using reflective object-oriented programming
Abstract: Shows how reflection and object-oriented programming can be used to ease the implementation of classical fault tolerance mechanisms in distributed applications. When the underlying runtime system does not provide fault tolerance transparently, classical approaches to implementing fault tolerance mechanisms often imply mixing functional programming with non-functional programming (e.g. error processing mechanisms). The use of reflection improves the transparency of fault tolerance mechanisms to the programmer and more generally provides a clearer separation between functional and non-functional programming. The implementations of some classical replication techniques using a reflective approach are presented in detail and illustrated by several examples, which have been prototyped on a network of Unix workstations. Lessons learnt from our experiments are drawn and future work is discussed
The SATIN component system - a metamodel for engineering adaptable mobile systems
Mobile computing devices, such as personal digital assistants and mobile phones, are becoming increasingly popular, smaller, and more capable. We argue that mobile systems should be able to adapt to changing requirements and execution environments. Adaptation requires the ability-to reconfigure the deployed code base on a mobile device. Such reconfiguration is considerably simplified if mobile applications are component-oriented rather than monolithic blocks of code. We present the SATIN (system adaptation targeting integrated networks) component metamodel, a lightweight local component metamodel that offers the flexible use of logical mobility primitives to reconfigure the software system by dynamically transferring code. The metamodel is implemented in the SATIN middleware system, a component-based mobile computing middleware that uses the mobility primitives defined in the metamodel to reconfigure both itself and applications that it hosts. We demonstrate the suitability of SATIN in terms of lightweightedness, flexibility, and reusability for the creation of adaptable mobile systems by using it to implement, port, and evaluate a number of existing and new applications, including an active network platform developed for satellite communication at the European space agency. These applications exhibit different aspects of adaptation and demonstrate the flexibility of the approach and the advantages gaine
Towards Adaptable and Adaptive Policy-Free Middleware
We believe that to fully support adaptive distributed applications,
middleware must itself be adaptable, adaptive and policy-free. In this paper we
present a new language-independent adaptable and adaptive policy framework
suitable for integration in a wide variety of middleware systems. This
framework facilitates the construction of adaptive distributed applications.
The framework addresses adaptability through its ability to represent a wide
range of specific middleware policies. Adaptiveness is supported by a rich
contextual model, through which an application programmer may control precisely
how policies should be selected for any particular interaction with the
middleware. A contextual pattern mechanism facilitates the succinct expression
of both coarse- and fine-grain policy contexts. Policies may be specified and
altered dynamically, and may themselves take account of dynamic conditions. The
framework contains no hard-wired policies; instead, all policies can be
configured.Comment: Submitted to Dependable and Adaptive Distributed Systems Track, ACM
SAC 200
Using an online formative assessment framework to enhance student engagement: a learning outcomes approach
Students learn best when they are fully engaged in the learning process, are motivated to test their current level of learning against known standards, and are offered targeted and timely support to help address subsequent personal learning needs.
The most usual way to do this is through the use of assessment, but this in itself can act as an overbearing influence on what and how students learn, rather than providing an holistic support mechanism that encourages continuous reflective learning. Summative assessment provides a quantitative measure of learning at specific points in time, but may not encourage students to focus on specific strengths and weaknesses in need of attention. Formative assessment can provide specific reflective and feed-forward support, but given the time-poor nature of many students, is this perceived as a useful part of the learning process?
This paper presents an overview of work in progress (funded by Centre for Open Learning in Maths, Science, Computing and Technology CETL at The Open University), on the development and implementation of an online interactive formative assessment framework, that has designed from a constructivist perspective, to promote student engagement and understanding of academic progression, using an learning outcomes approach.
The framework specifically aims to enhance student awareness, understanding and recognition of competency levels, and to allow testing of ongoing academic progress at predetermined and self-selected points throughout the year. Each assessment makes explicit links to other components of the course including the summative assessment strategy, as a means of providing an integrated approach to learning. By working through the formative assessments it is hoped that students will become more self-directed and confident in their learning skills and abilities, which in turn should improve retention.
The framework uses OpenMark (a web-based system developed within the Open University) in which students have up to three attempts to correctly answer each question, and are offered instantaneous and targeted feedback after each incorrect attempt. The system collects information on the answers submitted, and the time taken to complete each question, offering valuable insight into how (and which) students are engaging with the assessment and course materials. This data permits new targeted feedback to be added in response to common errors, as well as additional support mechanisms to be incorporated in response to specific skills or content that is poorly demonstrated.
All feedback in the framework is formative, commenting on how well each of the learning outcomes tested over a period of study has been demonstrated, as well as the overall level of academic competency attained at that point in time. At present, the framework encompasses seven interactive assessments (linked to fortnightly periods of study), consisting of ten variable-format questions (set at two levels of academic complexity). A planned eighth assessment will randomly select questions from preceding assessments, offering an instantaneous interactive revision tool.
Preliminary results indicate that students not only rate the assessments as enjoyable, but are revisiting specific assessments as a means of enhancing previous outcomes and checking their progression on aspects they previously had difficulties with
- …