202 research outputs found

    Empowering Collections with Swarm Behavior

    Full text link
    Often, when modelling a system there are properties and operations that are related to a group of objects rather than to a single object. In this paper we extend Java with Swarm Behavior, a new composition operator that associates behavior with a collection of instances. The lookup resolution of swarm behavior is based on the element type of a collection and is thus orthogonal to the collection hierarchy

    Toward a modularization of Pharo: Analysis of the design space for a new module system.

    Get PDF
    International audienceSmalltalk is a fully reflexive object-oriented programming language created in the early 70's. Over the years, it has been influencing many other programming languages and evolved into many variants. However, it has no notion of visibility, providing a single namespace. Because all classes and global variables were visible from every point of the system, numerous dependencies appeared and it turned into a monolithic system. As a descendant of Smalltalk, Pharo should provide a programming construct to make the platform more modular. Designing such a construct is a challenge because of two migration constraints: it must support circular dependencies and local class extensions. In this context, this article present an analysis of the design space for a module system through three design axis: encapsulation, dependency resolution, and module combination

    Handles: Behavior-Propagating First Class References For Dynamically-Typed Languages

    Get PDF
    Preprint, Accepted with minor revisionsInternational audienceControlling object graphs and giving specific semantics to references (such as read-only, own- ership, scoped sharing) has been the focus of a large body of research in the context of static type systems. Controlling references to single objects and to graphs of objects is essential to be able to build more secure systems, but is notoriously hard to achieve in absence of static type systems. In this article we embrace this challenge by proposing a solution to the following question: What is the underlying mechanism that can support the definition of properties (such as revocable, read-only, lent) at the reference level in the absence of a static type system? We present handles: first class references that propagate behavioral change dynamically to the object subgraph during program execution. In this article we describe handles and show how handles support the implementation of read-only references and revocable references. Handles have been fully implemented by modifying an existing virtual machine and we report their costs

    DynamicSchema: a lightweight persistency framework for context-oriented data management

    Get PDF
    International audienceWhile context-oriented programming technology so far has focused mostly on behavioral adaptation, context-oriented data management has received much less attention. In this paper we make a case for the problem of context-oriented data management, using a concrete example of a mobile application. We illustrate some of the issues involved and propose a lightweight persistency framework, called DynamicSchema, that resolves some of these issues. The solution consists in a flexible reification of the database schema, as a convenient dynamic data structure that can be adapted at execution time, according to sensed context changes. Implementing our mobile application using this framework enabled us to reduce the complexity of the domain modeling layer, to facilitate the production of code with low memory footprint, and to simplify the implementation of certain scenarios related to context-dependent security concerns

    PLOMO Associate Team Final Report

    Get PDF
    The goal of Plomo is to develop new meta tools to improve and bring synergy in the existing infrastructure of Pharo1 (for software development) and the Moose software analysis platform2 (for maintenance). PLOMO will (i) enhance the Opal open compiler infrastructure to support plugin definition, (ii) offer an infrastructure for change and event tracking as well as models to compose and manipulate them, (iii) work on a layered library of algorithms for the Mondrian visualization engine of Moose, (iv) work on new ways of profiling applications. All the efforts will be performed on Pharo and Moose, two platforms heavily used by the RMoD and Pleiad teams

    Handles: Behavior-Propagating First Class References For Dynamically-Typed Languages

    Get PDF
    International audienceControlling object graphs and giving specific semantics to references (such as read-only, ownership, scoped sharing) have been the focus of a large body of research in the context of static type systems. Controlling references to single objects and to graphs of objects is essential to build more secure systems, but is notoriously hard to achieve in the absence of static type systems. In this article we embrace this challenge by proposing a solution to the following question: What is an underlying mechanism that can support the definition of properties (such as revocable, read-only, lent) at the reference level in the absence of a static type system? We present handles: first-class references that propagate behavioral change dynamically to the object subgraph during program execution. In this article we describe handles and show how handles support the implementation of read-only references and revocable references. Handles have been fully implemented by modifying an existing virtual machine and we report their costs

    Mercury: a Model for Live Remote Debugging in Reflective Languages

    Get PDF
    Remote debugging facilities are a technical necessity for devices that have limited computing power to run an IDE (e.g., smartphones), lack appropriate input/output interfaces (display, keyboard, mouse) for programming (e.g mobile robots) or are simply unreachable for local development (e.g cloud-servers). Yet remote debugging solutions can prove awkward to use due to their distributed nature. Empirical studies show us that on average 10.5 minutes per coding hour (over five 40-hour work weeks per year) are spend for re-deploying applications while fixing bugs or improving functionality. Moreover current solutions lack facilities that would otherwise be available in a local setting because its difficult to reproduce them remotely. Our work identifies three desirable properties that an ideal solution for remote debugging should exhibit, namely: run-time evolution, semantic instrumentation and adaptable distribution. Given these properties we propose and validate Mercury, a live remote debugging model and architecture for reflective OO languages

    Waterfall: Primitives Generation on the Fly

    No full text
    Modern languages are typically supported by managed runtimes (Virtual Machines). Since VMs have to deal with many concepts such as memory management, abstract execution model and scheduling, they tend to be very complex. Additionally, VMs have to meet strong performance requirements. This demand of performance is one of the main reasons why many VMs are built statically. Thus, design decisions are frozen at compile time preventing changes at runtime. One clear example is the impossibility to dynamically adapt or change primitives of the VM once it has been compiled. In this work we present a toolchain that allows for altering and configuring components such as primitives and plug-ins at runtime. The main contribution is Waterfall, a dynamic and reflective translator from Slang, a restricted subset of Smalltalk, to native code. Waterfall generates primitives on demand and executes them on the fly. We validate our approach by implementing dynamic primitive modification and runtime customization of VM plug-ins

    Activity Report 2012. Project-Team RMOD. Analyses and Languages Constructs for Object-Oriented Application Evolution

    Get PDF
    Activity Report 2012 Project-Team RMOD Analyses and Languages Constructs for Object-Oriented Application Evolutio

    Towards Structural Decomposition of Reflection with Mirrors

    Get PDF
    International audienceMirrors are meta-level entities introduced to decouple reflection from the base-level system. Current mirror-based systems focus on functional decomposition of reflection. In this paper we advocate that mirrors should also address structural decomposition. Mirrors should not only be the entry points of reflective behavior but also be the storage entities of meta-information. This decomposition can help resolve issues in terms of resource constraints (e.g. embedded systems and robotics) or security. Indeed, structural decomposition enables discarding meta-information
    • …
    corecore