Noemi de La Rocque Rodriguez

Nested composite nodes and version control in an open hypermedia system

This paper presents a conceptual model for hypermedia systems that, among other features, supports versioning, permits exploring and managing alternate configurations, maintains document histories, supports cooperative work and provides automatic propagation of version changes. In general, the model was designed to minimize the cognitive overhead imposed on the user by version manipulation. The discussion about version control is phrased in terms of the Nested Context Model, but the major ideas apply to any hypermedia conceptual model that offers nested composite nodes. Briefly, nodes that represent versions of the same object at some level of abstraction are grouped together using the concept of version context, support for cooperative work is based on the idea of public hyperbase and private bases, and the problem of version proliferation is addressed using the concept of current perspective. Finally, the paper also presents a generic layered architecture for hypermedia systems with four major interfaces and shows how it matches the conceptual model.

Dynamic support for distributed auto-adaptive applications

This work presents an infrastructure that simplifies the development of distributed applications that can adapt automatically to nonfunctional properties of their components and of their execution environment. This infrastructure, based on the programming language Lua and on CORBA, allows applications to select dynamically the components that best suit their requirements, to verify whether the system is satisfying these requirements, and to react, when appropriate, to variations in the nonfunctional properties of the services in use. We use CORBAs trading service to support dynamic component selection. An extensible monitoring facility supports monitoring of dynamically defined requirements. We use the Lua language to specify adaptation strategies, and a smart proxy mechanism to apply these strategies.

Safe system-level concurrency on resource-constrained nodes

Despite the continuous research to facilitate WSNs development, most safety analysis and mitigation efforts in concurrency are still left to developers, who must manage synchronization and shared memory explicitly. In this paper, we present a system language that ensures safe concurrency by handling threats at compile time, rather than at runtime. Based on the synchronous programming model, our design allows for a simple reasoning about concurrency that enables compile-time analysis resulting in deterministic and memory-safe programs. As a trade-off, our design imposes limitations on the language expressiveness, such as doing computationally-intensive operations and meeting hard real-time responsiveness. To show that the achieved expressiveness and responsiveness is sufficient for a wide range of WSN applications, we implement widespread network protocols and the CC2420 radio driver. The implementations show a reduction in source code size, with a penalty of memory increase below 10% in comparison to nesC. Overall, we ensure safety properties for programs relying on high-level control abstractions that also lead to concise and readable code.

ALua: flexibility for parallel programming

In this paper we present ALua, an event-driven communication mechanism for developing distributed parallel applications, based on the interpreted language Lua. We propose a dual programming model for parallel applications, where ALua acts as a gluing element, allowing precompiled program parts to run on different machines. We show, through examples, how three types of applications can benefit from the flexibility that derives from this model. We then present a study of ALuas performance, by comparing execution times of two parallel applications written in ALua with their counterparts written in PVM.

Dynamic configuration with CORBA components

Most existing support for dynamic reconfiguration assumes that component interfaces specify input and output channels. The CORBA model, however, specifically supports a client-server architecture, with component interfaces describing only the provided services. Besides, the existing bindings for CORBA, based on static stubs, impose considerable difficulties on dynamic configuration. This paper investigates the use of the interpreted language Lua as a tool for dynamic configuration of distributed applications using CORBA components.

ParTopS: compact topological framework for parallel fragmentation simulations

Cohesive models are used for simulation of fracture, branching and fragmentation phenomena at various scales. Those models require high levels of mesh refinement at the crack tip region so that nonlinear behavior can be captured and physical results obtained. This imposes the use of large meshes that usually result in computational and memory costs prohibitively expensive for a single traditional workstation. If an extrinsic cohesive model is to be used, support for dynamic insertion of cohesive elements is also required. This paper proposes a topological framework for supporting parallel adaptive fragmentation simulations that provides operations for dynamic insertion of cohesive elements, in a uniform way, for both two- and three-dimensional unstructured meshes. Cohesive elements are truly represented and are treated like any other regular element. The framework is built as an extension of a compact adjacency-based serial topological data structure, which can natively handle the representation of cohesive elements. Symmetrical modifications of duplicated entities are used to reduce the communication of topological changes among mesh partitions and also to avoid the use of locks. The correctness and efficiency of the proposed framework are demonstrated by a series of arbitrary insertions of cohesive elements into some sample meshes.

Dynamic Reconfiguration of CORBA-Based Applications

Most current support for dynamic reconfiguration assumes that component interfaces specify input and output channels. Component models such as CORBA, however, support a client-server architecture, where component interfaces describe only the offered services. This work discusses the use of an interpreted language as a tool for dynamic configuration of distributed applications using CORBA components. We describe LuaOrb, a system based on the CORBA Dynamic Invocation Interface (DII) and the Dynamic Skeleton Interface (DSI), which provides Lua programs with easy access to CORBA servers and allows these servers to be dynamically modified. Using LuaOrb, the Lua console itself becomes a tool for reconfiguration. LuaOrb uses a structural subtyping model, so that only correctly typed connections are accepted. We also discuss possible forms for prescribing a reconfiguration, and their relation to LuaOrb.

Using reflexivity to interface with CORBA

Most bindings to CORBA are based on the construction of stubs, which translate a language call into a CORBA invocation. The paper shows an alternative way to build a binding, using the reflexive facilities of an interpreted language. Like other CORBA bindings, this binding allows a program to manipulate CORBA objects in the same way it manipulates local objects. Unlike conventional bindings however, it is based on the CORBA Dynamic Invocation Interface, mapping its dynamic character to the dynamic type system of the language. In this way, a program has immediate access to any CORBA component, without the need of stubs or pre-defined IDL headers.

Structured synchronous reactive programming with Céu

Structured synchronous reactive programming (SSRP) augments classical structured programming (SP) with continuous interaction with the environment. We advocate SSRP as viable in multiple domains of reactive applications and propose a new abstraction mechanism for the synchronous language Céu: Organisms extend objects with an execution body that composes multiple lines of execution to react to the environment independently. Compositions bring structured reasoning to concurrency and can better describe state machines typical of reactive applications. Organisms are subject to lexical scope and automatic memory management similar to stack-based allocation for local variables in SP. We show that this model does not require garbage collection or a free primitive in the language, eliminating memory leaks for organisms by design.

A cooperative multitasking model for networked sensors

This paper proposes a concurrency model which integrates the asynchronous and event-driven nature of networked sensors with a more familiar programming style for the developer. We argue that coroutines can provide a basis for this integration and describe some details of its implementation, which was developed as an extension to the TinyOS operating system.