11 research outputs found

    A reflective architecture to support dynamic software evolution

    Get PDF
    This thesis presents work which is concerned with the run-time evolution of component-based software systems. In particular, the main result of the research presented here is a framework which is used to model and control the architecture of a software system. This framework allows the run-time manipulation of the components which make up a software system. The framework makes the architecture of software systems visible, and allows interaction with it, using a reflective meta-object protocol. The motivating objectives of this work are providing a framework to support architectural flexibility, higher-level intervention, safe changes, and architectural visibility in software systems. The framework's behaviour and structure was motivated by a set of case-studies which have been used to guide its development and enhancement. The framework was developed iteratively, using each case-study in turn to evaluate its capabilities and to prompt the direction of development. A detailed set of evaluation criteria are developed, and the framework is evaluated with respect to these. The framework was found to meet each of the four objectives fully, with the exception of the aim to allow only safe changes which is only partly satisfied. Ways in which the framework can be improved in order to more fully satisfy its objectives are suggested, as are other extensions to its behaviour

    Serverless applications and requirement

    Get PDF
    A report from working group 3 'Serverless Applications and Requirements' in Dagstuhl Seminar 21201, discussing why and when applications should be serverless, what the unique characteristics are, which trade-offs and scopes exist, and giving exemplary insights into serverless application domains, along with six take-aways for the wider research community

    Communication Architectures for Parallel-Programming Systems

    Get PDF
    Bal, H.E. [Promotor]Tanenbaum, A.S. [Promotor

    [Activity of Institute for Computer Applications in Science and Engineering]

    Get PDF
    This report summarizes research conducted at the Institute for Computer Applications in Science and Engineering in applied mathematics, fluid mechanics, and computer science

    A layered JavaScript virtual machine supporting dynamic instrumentation

    Full text link
    L’observation de l’exécution d’applications JavaScript est habituellement réalisée en instrumentant une machine virtuelle (MV) industrielle ou en effectuant une traduction source-à-source ad hoc et complexe. Ce mémoire présente une alternative basée sur la superposition de machines virtuelles. Notre approche consiste à faire une traduction source-à-source d’un programme pendant son exécution pour exposer ses opérations de bas niveau au travers d’un modèle objet flexible. Ces opérations de bas niveau peuvent ensuite être redéfinies pendant l’exécution pour pouvoir en faire l’observation. Pour limiter la pénalité en performance introduite, notre approche exploite les opérations rapides originales de la MV sous-jacente, lorsque cela est possible, et applique les techniques de compilation à-la-volée dans la MV superposée. Notre implémentation, Photon, est en moyenne 19% plus rapide qu’un interprète moderne, et entre 19× et 56× plus lente en moyenne que les compilateurs à-la-volée utilisés dans les navigateurs web populaires. Ce mémoire montre donc que la superposition de machines virtuelles est une technique alternative compétitive à la modification d’un interprète moderne pour JavaScript lorsqu’appliqué à l’observation à l’exécution des opérations sur les objets et des appels de fonction.Run-time monitoring of JavaScript applications is typically achieved by instrumenting a production virtual machine or through ad-hoc, complex source-to-source transformations. This dissertation presents an alternative based on virtual machine layering. Our approach performs a dynamic translation of the client program to expose low-level operations through a flexible object model. These low-level operations can then be redefined at run time to monitor the execution. In order to limit the incurred performance overhead, our approach leverages fast operations from the underlying host VM implementation whenever possible, and applies Just-In-Time compilation (JIT) techniques within the added virtual machine layer. Our implementation, Photon, is on average 19% faster than a state-of-the-art interpreter, and between 19× and 56× slower on average than the commercial JIT compilers found in popular web browsers. This dissertation therefore shows that virtual machine layering is a competitive alternative approach to the modification of a production JavaScript interpreter when applied to run-time monitoring of object operations and function calls

    Open Implementation Analysis and Design

    No full text
    This paper describes a methodology for designing Open Implementations-- software modules that can adapt or change their internals to accommodate the needs of different clients. Analysis techniques are used for capturing domain knowledge, user requirements, and domain properties that influence the module's eventual implementation. Design techniques are used for determining and refining the interfaces by which clients control the modules implementation strategies. The methodolog
    corecore