Adaptive object management for distributed systems

This thesis describes an architecture supporting the management of pluggable software components and evaluates it against the requirement for an enterprise integration platform for the manufacturing and petrochemical industries. In a distributed environment, we need mechanisms to manage objects and their interactions. At the least, we must be able to create objects in different processes on different nodes; we must be able to link them together so that they can pass messages to each other across the network; and we must deliver their messages in a timely and reliable manner. Object based environments which support these services already exist, for example ANSAware(ANSA, 1989), DEC's Objectbroker(ACA,1992), Iona's Orbix(Orbix,1994)Yet such environments provide limited support for composing applications from pluggable components. Pluggability is the ability to install and configure a component into an environment dynamically when the component is used, without specifying static dependencies between components when they are produced. Pluggability is supported to a degree by dynamic binding. Components may be programmed to import references to other components and to explore their interfaces at runtime, without using static type dependencies. Yet thus overloads the component with the responsibility to explore bindings. What is still generally missing is an efficient general-purpose binding model for managing bindings between independently produced components. In addition, existing environments provide no clear strategy for dealing with fine grained objects. The overhead of runtime binding and remote messaging will severely reduce performance where there are a lot of objects with complex patterns of interaction. We need an adaptive approach to managing configurations of pluggable components according to the needs and constraints of the environment. Management is made difficult by embedding bindings in component implementations and by relying on strong typing as the only means of verifying and validating bindings. To solve these problems we have built a set of configuration tools on top of an existing distributed support environment. Specification tools facilitate the construction of independent pluggable components. Visual composition tools facilitate the configuration of components into applications and the verification of composite behaviours. A configuration model is constructed which maintains the environmental state. Adaptive management is made possible by changing the management policy according to this state. Such policy changes affect the location of objects, their bindings, and the choice of messaging system

Developing virtual reality applications: The design and evaluation of virtual reality development tools for novice users.

Developing applications for Virtual Reality(VR) systems is difficult because of the special- ized hardware required, complexity of VR software, and the technical expertise needed to use both together. We have develop tools and applications that support the authoring of virtual reality applications. The tools will support development of VR applications based on common requirements of the hardware and architecture used in VR systems. We developed support for animations, geometry morphs, deformable geometry, advanced particle systems, importing digital assets, embedding a scripting language virtual machine, sound library wrappers, video library wrappers, and physics library wrappers for the OpenSG framework. The KabalaEngine was developed to use the supporting libraries previously men- tioned in a clustered VR system using OpenSG\u27s clustering capabilities. The KabalaEngine has an expert graphical user interface that can be used for developing virtual environments. Finally, we developed a graphical user interface for novice users of the KabalaEngine. We found that users of the KabalaEngine were able to use the interface to produce three different complex virtual environments with 10-15 different 3D objects arranged in a meaningful way in fifty minutes

S.IM.PL Serialization: Type System Scopes Encapsulate Cross-Language, Multi-Format Information Binding

Representing data outside of and between programs is important in software that stores, shares, and manipulates information. Formats for representing information, varying from human-readable verbose (XML) to light-weight, concise (JSON), and non-human-readable formats (TLV) have been developed and used by applications based on their data and communication requirements. Writing correct programs that produce information represented in these formats is a difficult and time-consuming task, as developers must write repetitive, tedious code to map loosely-typed serialized data to strongly-typed program objects. We developed S.IM.PL Serialization, a cross-language multi-format information binding framework to relieve developers from the burdens associated with the serialization of strongly-typed data structures. We developed type system scopes, a means of encapsulating data types and binding semantics as a cross-language abstract semantics graph. In comparison to representing data binding semantics and information structure through external forms such as schemas, configuration files, and interface description languages, type system scopes can be automatically generated from declarations in a data binding annotation language, facilitating software engineering. Validation is based on use in research applications, a study of how computer science graduate students use the software to develop applications, and performance benchmarks. As a case study, we also examine the cross-language development of a Team Coordination (TeC) game

Open Programming Language Interpreters

Context: This paper presents the concept of open programming language interpreters and the implementation of a framework-level metaobject protocol (MOP) to support them. Inquiry: We address the problem of dynamic interpreter adaptation to tailor the interpreter's behavior on the task to be solved and to introduce new features to fulfill unforeseen requirements. Many languages provide a MOP that to some degree supports reflection. However, MOPs are typically language-specific, their reflective functionality is often restricted, and the adaptation and application logic are often mixed which hardens the understanding and maintenance of the source code. Our system overcomes these limitations. Approach: We designed and implemented a system to support open programming language interpreters. The prototype implementation is integrated in the Neverlang framework. The system exposes the structure, behavior and the runtime state of any Neverlang-based interpreter with the ability to modify it. Knowledge: Our system provides a complete control over interpreter's structure, behavior and its runtime state. The approach is applicable to every Neverlang-based interpreter. Adaptation code can potentially be reused across different language implementations. Grounding: Having a prototype implementation we focused on feasibility evaluation. The paper shows that our approach well addresses problems commonly found in the research literature. We have a demonstrative video and examples that illustrate our approach on dynamic software adaptation, aspect-oriented programming, debugging and context-aware interpreters. Importance: To our knowledge, our paper presents the first reflective approach targeting a general framework for language development. Our system provides full reflective support for free to any Neverlang-based interpreter. We are not aware of any prior application of open implementations to programming language interpreters in the sense defined in this paper. Rather than substituting other approaches, we believe our system can be used as a complementary technique in situations where other approaches present serious limitations

Analysis of support for modularity in object teams based on design patterns

Dissertação de Mestrado em Engenharia InformáticaThe paradigm of Aspect-Oriented Programming is currently being studied and matured. Many aspectoriented languages have been proposed, including Object Teams for Java (OT/J). However, to date few studies were carried out to assess the contribution of the various languages available and compare their relative advantages and disadvantages. The aim of this dissertation is to contribute to fill this gap. In the past, implementations of design patterns in Java and AspectJ were successfully used as case studies to derive conclusions on the relative advantages and disadvantages of the language under consideration. This dissertation follows this approach, with the development of a suitable collection of examples based on the well-known Gang-of-Four design patterns. Two repositories of implementations in OT/J of the complete collection of 23 Gang-of-Four design patterns have been developed, to be used as a basis for subsequent analysis. The scenarios used for the examples are based on Java repositories by independent authors, freely available on the Web. Based on the repositories developed, an analysis of the modularizations obtained with OT/J is presented and compared with the results obtained using Java and AspectJ. OT/J provides direct language support for 3 of the patterns. 20 patterns yielded separate modules for the patterns, of which 10 modules proved to be reusable. Only in 1 of the patterns, no significant differences between Java and OT/J were obtained

Enabling natural interaction for virtual reality

This research focuses on the exploration of software and methods to support natural interaction within a virtual environment. Natural interaction refers to the ability of the technology to support human interactions with computer generated simulations that most accurately reflect interactions with real objects. Over the years since the invention of computer-aided design tools, computers have become ubiquitous in the product design process. Increasingly, engineers and designers are using immersive virtual reality to evaluate virtual products throughout the entire design process. The goal of this research is to develop tools that support verisimilitude, or likeness to reality, particularly with respect to human interaction with virtual objects. Increasing the verisimilitude of the interactions and experiences in a virtual environment has the potential to increase the external validity of such data, resulting in more reliable decisions and better products. First, interface software is presented that extends the potential reach of virtual reality to include low-cost, consumer-grade motion sensing devices, thus enabling virtual reality on a broader scale. Second, a software platform, VR JuggLua, is developed to enable rapid and iterative creation of natural interactions in virtual environments, including by end-user programmers. Based on this software platform, the focus of the rest of the research is on supporting virtual assembly and decision making. The SPARTA software incorporates a powerful physically-based modeling simulation engine tuned for haptic interaction. The workspace of a haptic device is both virtually expanded, though an extension to the bubble technique, and physically expanded, through integration of a haptic device with a multi-directional mobile platform. Finally, a class of hybrid methods for haptic collision detection and response is characterized in terms of five independent tasks. One such novel hybrid method, which selectively restores degrees of freedom in haptic assembly, is developed and assessed with respect to low-clearance CAD assembly. It successfully maintains the high 1000 Hz update rate required for stable haptics unlike previous related approaches. Overall, this work forms a pattern of contributions towards enabling natural interaction for virtual reality and advances the ability to use an immersive environment in decision making during product design

SAVCBS 2003: Specification and Verification of Component-Based Systems

These are the proceedings for the SAVCBS 2003 workshop. This workshop was held at ESEC/FSE 2003 in Helsinki Finland in September 2003

Foundations of Programming Languages

This clearly written textbook provides an accessible introduction to the three programming paradigms of object-oriented/imperative, functional, and logic programming. Highly interactive in style, the text encourages learning through practice, offering test exercises for each topic covered. Review questions and programming projects are also presented, to help reinforce the concepts outside of the classroom. This updated and revised new edition features new material on the Java implementation of the JCoCo virtual machine