Abstract: Invocation language is described that is suitable for controlling a machine to perform a process having concurrent parts. Each concurrent part has an association relationship, a completeness relation, and an invocation expression.

Abstract: User activity streams are used to automatically learn associations between logical objects and form logical groups. Search results are sorted based upon their relevance to current user activity. Combined with a graphical user interface component and object database, the invention automatically retrieves and display groups and objects related to the active object.

Abstract: Our work is motivated by practice in Peer-to-Peer networks and Object-Oriented systems where instantiation and dynamically reconfigurable interconnection are essential paradigms. For example, in a Peer-to-Peer network nodes can exchange data to complete tasks. Nodes can leave or join the network at any time. In Object-Oriented systems, an object can be uniquely identified and will communicate with other objects. In this paper we outline a formal framework which supports this kind of interaction so that the integrity of each active object or node is preserved, and so that we can reason about the overall behaviour of the system. The formal framework is based on a combination of the π-calculus and the B-Method.

Abstract: Remote Method Invocation (RMI), a mechanism to access remote objects in Java-based distributed applications, uses network communication for each method invocation. Consequently, using RMI in a wide-area environment can cause poor application performance. One solution to improve performance is to cache the objects such that network communication is not necessary for each method invocation. In this paper, we present mechanisms to transparently add object caching to RMI. These mechanisms are compatible with existing RMI applications and use an event-based model to support different consistency policies. The mechanisms also include the ability to adaptively select the consistency policy for an object based on its usage pattern. A novel feature of our mechanisms is the use of a ‘reduced object’, which is a partial representation of the RMI object. We experimentally evaluate and demonstrate the benefits of our mechanisms. Copyright © 2006 John Wiley & Sons, Ltd.

Abstract: Object-oriented programming languages such as Java provides inadequate support for advanced method invocation strategies in distributed applications. Invocation semantics such as reliable unicast and multicast must be implemented based on primitive, unreliable unicast mechanisms such as Java RMI and Socket communication. This forces developers to devise ad hoc communication strategies, which is a repetitive and error-prone process. Moreover, these communication strategies are entangled with the business logic of the application, making the code hard to read and maintain.In this paper, we propose an extension of the Java type system based on communication qualifiers. These qualifiers decorate variables with information about the invocation semantics that must be used when methods are invoked on that variable. We show how communication qualifiers are used to support transparent multicast and reliable unicast invocation semantics in Java. Moreover, we introduce declarative operations to enable developers to fine-tune these communication strategies.

Abstract: A method and system that enable an automatic invocation of device functionalities on devices in a network. Invocation mechanisms are provided to support heterogeneous invocation mechanisms including new invocation mechanisms. Invocation mechanisms using scripts can be added without the need for recompilation of support systems such as home-networking middleware systems. This further enables the use of scripts that can coordinate the use of multiple devices in accomplishing a task.

Abstract: Development and maintenance of implicit invocation systems is not as well understood andsupported as the development of explicit invocation systems. The situation is aggravated in sys-tems that allow the composition of functionality developed by different organizations, potentiallyusing different programming languages and methodologies. In this document, we categorize thevarious ways in which implicit invocation systems can define, bind to, announce, subscribe, anddeliver events. We also categorize the architectures and topologies of implicit invocation systems.The purpose of the categorization is to increase the understanding of the type of requirementsthat these systems impose on software development practices. As the categories are introduced,documented representative invocation systems are discussed in order to illustrate the types of sys-tems that fall under each given category. Our categorization applies to systems as varied as activedatabases, aspect-oriented applications, and distributed heterogeneous event-based systems.Categories and Subject Descriptors: D.3.3 [Programming Languages]: Language Constructsand Features—Procedures, functions, and subroutines; D.1.3 [Programming Techniques]: Con-current Programming—Distributed Programming; D.2.12 [Software Engineering]: Interoper-ability—Distributed objects; C.2.4 [Computer-Communication Networks]: Distributed Sys-tems—Distributed ApplicationsGeneral Terms: Algorithms, Languanges, DesignAdditional Key Words and Phrases: Implicit Invocation Systems, Reactive Systems, Event Pro-gramming

Abstract: A number of enterprises are turning towards the Service Oriented Architecture (SOA) approach for their systems due to the number of benefits it offers. A key enabling technology for the SOA-based approach is middleware, which comprises of reusable building blocks based on design patterns. These building blocks can be configured in numerous ways and the configuration options of a pattern can have a profound impact on system performance. A performance analysis methodology which can be used to assess this influence at design time can guide the selection of patterns and their configuration options and thus alleviate the possibility of performance problems arising later in the life cycle. This paper presents a model-based performance analysis methodology for a system built using the Active Object (AO) pattern. The AO pattern is chosen because it lies at the heart of an important class of producer/consumer and publish/subscribe systems. Central to the methodology is a queuing model which captures the internal architecture of an AO-based system. Using an implementation of the queuing model in CSIM, we illustrate the value of the methodology to guide the selection of configuration and provisioning options for a stock broker system.

Abstract: Asynchronous invocation reduces the average running time of distributed programs by providing concurrency mechanisms. The fact of occasionally having to check for return values in calling asynchronous methods is a noticeable drawback in such systems. We can cope with this issue by making instructions dependent on the return values of asynchronous methods as appropriate listener threads. In this paper, we have proposed a pattern for asynchronous invocation in order to enhance the client's performance in distributed systems. The layered model of the proposed pattern led us to a middleware-independent framework. The evaluation results indicate that our solution shall introduce a unified pattern for asynchronous remote method invocation.

Abstract: A key enabler of the recently popularized, assembly-centric development approach for distributed real-time software systems is QoS-enabled middleware, which provides reusable building blocks in the form of design patterns that codify solutions to commonly recurring problems. These patterns can be customized by choosing an appropriate set of configuration parameters. The configuration options of the patterns exert a strong influence on system performance, which is of paramount importance in many distributed software systems. Despite this considerable influence, currently there is a lack of significant research to analyze performance of middleware at design time, where performance issues can be resolved at a much earlier stage of the application life cycle and with substantially less costs. The present project seeks to develop a performance analysis methodology for design-time performance analysis for distributed software systems implemented using middleware patterns and their compositions. The methodology is illustrated on a producer/consumer system implemented using the active object (AO) pattern in middleware. Finally, broader impacts of the methodology for middleware specialization are also described.

Abstract: Specifications and implementations of systems need to be concerned with the interactions that can occur within a system and model the data structures appropriately. We are interested in combinations of formal methods which consider the state and dynamic requirements of a system. We recognise that many such combinations already exist, including, CSP || B and Circus, but we are concerned with a state description, being accessed and updated by control components with dynamically reconfigurable interconnections. Our work is motivated by what we see in Peer-to-Peer networks and Object-Oriented systems where instantiation and dynamically reconfigurable interconnection are essential paradigms. For example, in a Peer-to-Peer network nodes can act as both server and client in exchanging data to complete a certain task. Nodes are also independent and can leave or join the network at any time. In Object-Oriented systems, an object instance can be created with a unique reference. This reference can be used by other objects to communicate with the object. Our aim is to provide a formal framework which supports this kind of interaction so that the integrity of each active object or node is preserved, and so that we can reason about the overall behaviour of the system. The approach we consider in this thesis is a combination of the pi-calculus and the B-Method. In order to be able to reason about specifications based on both these notations we need common semantics. We define an approach which enables the interpretation of a B machine as a pi-calculus labelled transition system. This allows the integration of machines into parallel combination with pi-agents. As a result, this work extends B machines with instantiation and pi-calculus dynamic reconfiguration capabilities. We use a behavioural type-system with variant types to maintain low level server/client style consistencies between instances of machines and pi-process agents. (For example, all agents call operations that relate to some machine in the specification.) Using the type system, we identify a class of pi-agents whose behaviour with respect to the machine instances allows a weakest pre-condition style proof to be carried out on the agents. We use this property to define an approach for detecting agents that might cause a machine instance to diverge.

Abstract: Two problems in web services composition has been tackled in this paper: firstly, decoupling flow execution and web services invocation in web services composition execution engine - WebJetFlow; secondly, changing services invocation model of service proxy from synchronous invocation model to pure asynchronous invocation model. Then NS2 has been adopted to test the performance of WebJetFlow under five different circumstances as well as the performance of WebJetFlow with service proxy and without service proxy respectively. The simulation results show that the access throughputs of WebJetFlow with service proxy are larger than those without service proxy under the same thread resources. Moreover, decoupling flow execution and web services invocation and using pure asynchronous invocation model greatly increase the concurrence of flow execution, enhance the utilization efficiency and improve the performance of WebJetFlow.

Abstract: Cooperation is a critical and the most difficult task in virtual assembly. Since the participants could not perceive reliably in virtual environment like that in real reality, many accurate assembly tasks seemed like impossible to be accomplished only by the means of human direct manipulation. This paper presents a strategy and algorithms to solve the problem of concurrent assembly. Active object and computation-based perception mechanism are used. Object's behavior in virtual assembly is analyzed in detail and object trace is constructed. Concurrent assembly process is formally described based on object trace. Practice shows that the accurate assembly task is well supported by the concurrent algorithm, and the participants' burden is sharply reduced.