Showing papers on "Distributed object published in 2003"

On The Move to meaningful Internet systems 2003 : CoopIS, DOA, and ODBASE : OTM Confederated International Conferences CoopIS, DOA, and ODBASE 2003, Catania, Sicily, Italy, November 3-7, 2003 : proceedings

Abstract: Cooperative Information Systems (CoopIS) 2003 International Conference.- Tenth Anniversasy of CoopIS: Cooperative Information Systems Then and Now.- PC Co-chairs' Message.- "Almost Automatic" and Semantic Integration of XML Schemas at Various "Severity" Levels.- Managing the Evolution of Mediation Queries.- Semantics-Based Reconciliation for Collaborative and Mobile Environments.- A Distributed Rule Mechanism for Multidatabase Systems.- Identification and Modelling of Web Services for Inter-enterprise Collaboration Exemplified for the Domain of Strategic Supply Chain Development.- Advertising Games for Web Services.- Defining and Coordinating Open-Services Using Workflows.- Keeping Watch: Intelligent Virtual Agents Reflecting Human-Like Perception in Cooperative Information Systems.- BRAIN: A Framework for Flexible Role-Based Interactions in Multiagent Systems.- Profiling and Matchmaking Strategies in Support of Opportunistic Collaboration.- A Strategic Approach for Business-IT Alignment in Health Information Systems.- From Where to What: Metadata Sharing for Digital Photographs with Geographic Coordinates.- Process of Product Fragments Management in Distributed Development.- A Cooperative Approach to the Development of Expert Knowledge Bases Applied to Define Standard of Care in Glaucoma.- A Publish/Subscribe Scheme for Peer-to-Peer Database Networks.- Query Evaluation in Peer-to-Peer Networks of Taxonomy-Based Sources.- An InfoSpace Paradigm for Local and ad hoc Peer-to-Peer Communication.- Digging Database Statistics and Costs Parameters for Distributed Query Processing.- Forming Virtual Marketplaces with Knowledge Networks.- Providing a Progressive Access to Awareness Information.- Trusting Data Quality in Cooperative Information Systems.- Static Type-Inference for Trust in Distributed Information Systems.- Workflow Mining: Current Status and Future Directions.- On the Common Support of Workflow Type and Instance Changes under Correctness Constraints.- Animating ebXML Transactions with a Workflow Engine.- Dynamic Interconnection of Heterogeneous Workflow Processes through Services.- R-GMA: An Information Integration System for Grid Monitoring.- CREAM: An Infrastructure for Distributed, Heterogeneous Event-Based Applications.- Versions for Context Dependent Information Services.- Cache Invalidation for Updated Data in Ad Hoc Networks.- Taxonomy-Based Context Conveyance for Web Search.- An Analytical Study of Broadcast Based Cache Invalidation in Mobile Computing Networks.- Fine-Grained Parallelism in Dynamic Web Content Generation: The Parse and Dispatch Approach.- Ontologies, Databases, and Applications of Semantics (ODBASE) 2003 International Conference.- The Grid Needs You! Enlist Now.- From the "Eyeball" Web to the Transaction Web.- ODBASE 2003 PC Co-chairs' Message.- Recording and Reasoning over Data Provenance in Web and Grid Services.- Preparing SCORM for the Semantic Web.- Ontology-Driven Knowledge Logistics Approach as Constraint Satisfaction Problem.- Dynamic Topic Mining from News Stream Data.- lora-2: A Rule-Based Knowledge Representation and Inference Infrastructure for the Semantic Web.- Understanding the Semantic Web through Descriptions and Situations.- Incremental Maintenance of Materialized Ontologies.- Scalable and Reliable Semantic Portals (SEAL) in Practice.- X-Learn: An XML-Based, Multi-agent System for Supporting "User-Device" Adaptive E-learning.- Mining Association Rules from Relational Data - Average Distance Based Method.- Clustering Schemaless XML Documents.- Automatic Expansion of Manual Email Classifications Based on Text Analysis.- Mining for Lexons: Applying Unsupervised Learning Methods to Create Ontology Bases.- The OntoWordNet Project: Extension and Axiomatization of Conceptual Relations in WordNet.- Ontology Based Query Processing in Database Management Systems.- OntoManager - A System for the Usage-Based Ontology Management.- Breaking the Deadlock.- Using Ontologies in the Development of an Innovating System for Elderly People Tele-assistance.- A Fuzzy Model for Representing Uncertain, Subjective, and Vague Temporal Knowledge in Ontologies.- Semantics and Modeling of Spatiotemporal Changes.- Maintaining Ontologies for Geographical Information Retrieval on the Web.- Ontology Translation on the Semantic Web.- The Semantics of the Compound Term Composition Algebra.- KNN Model-Based Approach in Classification.- Learning to Invoke Web Forms.- A Proposal for Management of RDF and RDF Schema Metadata in MOF.- Extending OO Metamodels towards Dynamic Object Roles.- Distributed Objects and Applications (DOA) 2003 International Conference.- Model Driven Architecture: Three Years On.- DOA 2003 PC Co-chairs' Message.- Monitoring the Distributed Virtual Orchestra with a CORBA Based Object Oriented Real-Time Data Distribution Service.- Designing Telerobotic Systems as Distributed CORBA-Based Applications.- Implementation Experience with OMG's SCIOP Mapping.- Enhancing Real-Time CORBA Predictability and Performance.- Jini Supporting Ubiquitous and Pervasive Computing.- Capturing, Analysing, and Managing ECG Sensor Data in Handheld Devices.- Definition of a User Environment in a Ubiquitous System.- ReMMoC: A Reflective Middleware to Support Mobile Client Interoperability.- A Dynamic Distribution and Load Balancing Experiment with Synchronous Programming-Based Mobile Objects.- An Adaptive Transactional System - Framework and Service Synchronization.- From Distributed Objects to Hierarchical Grid Components.- Re-factoring Middleware Systems: A Case Study.- Dynamic Placement Using Ants for Object Based Simulations.- Developing Adaptive Distributed Applications: A Framework Overview and Experimental Results.- Separating the Concerns of Distributed Deployment and Dynamic Composition in Internet Application Systems.- Method-Based Caching in Multi-tiered Server Applications.- DLS: A CORBA Service for Dynamic Loading of Code.- On the Performance of a CORBA Caching Service over the Wide Internet.- Semi-automatic Parallelization of Java Applications.- Transparent Integration of CORBA and the .NET Framework.- Can Aspects Be Injected? Experience with Replication and Protection.- Analysing Mailboxes of Asynchronous Communicating Components.- TUPI: Transformation from PIM to IDL.- Active Data.- What Must (Not) Be Available Where?.- A CORBA-Based Transaction System for the Wireless Communication Environment.- Experiences with the Active Collections Framework.- Porting OMTTs to CORBA.

NaradaBrokering: a distributed middleware framework and architecture for enabling durable peer-to-peer grids

Abstract: A Peer-to-Peer (P2P) Grid would comprise services that include those of Grids and P2P networks and naturally support environments that have features of both limiting cases. Such a P2P grid integrates the evolving ideas of computational grids, distributed objects, web services, P2P networks and message oriented middleware. In this paper we investigate the architecture, comprising a distributed brokering system that will support such a hybrid environment. Access to services can then be mediated either by the middleware or alternatively by direct P2P interactions between machines.

AQuA: an adaptive architecture that provides dependable distributed objects

Abstract: Building dependable distributed systems from commercial off-the-shelf components is of growing practical importance. For both cost and production reasons, there is interest in approaches and architectures that facilitate building such systems. The AQuA architecture is one such approach; its goal is to provide adaptive fault tolerance to CORBA applications by replicating objects. The AQuA architecture allows application programmers to request desired levels of dependability during applications' runtimes. It provides fault tolerance mechanisms to ensure that a CORBA client can always obtain reliable services, even if the CORBA server object that provides the desired services suffers from crash failures and value faults. AQuA includes a replicated dependability manager that provides dependability management by configuring the system in response to applications' requests and changes in system resources due to faults. It uses Maestro/Ensemble to provide group communication services. It contains a gateway to intercept standard CORBA IIOP messages to allow any standard CORBA application to use AQuA. It provides different types of replication schemes to forward messages reliably to the remote replicated objects. All of the replication schemes ensure strong, data consistency among replicas. This paper describes the AQuA architecture and presents, in detail, the active replication pass-first scheme. In addition, the interface to the dependability manager and the design of the dependability manager replication are also described. Finally, we describe performance measurements that were conducted for the active replication pass-first scheme, and we present results from our study of fault detection, recovery, and blocking times.

Application specific data replication for edge services

Abstract: The emerging edge services architecture promises to improve the availability and performance of web services by replicating servers at geographically distributed sites. A key challenge in such systems is data replication and consistency so that edge server code can manipulate shared data without incurring the availability and performance penalties that would be incurred by accessing a traditional centralized database. This paper explores using a distributed object architecture to build an edge service system for an e-commerce application, an online bookstore represented by the TPC-W benchmark. We take advantage of application specific semantics to design distributed objects to manage a specific subset of shared information using simple and effective consistency models. Our experimental results show that by slightly relaxing consistency within individual distributed objects, we can build an edge service system that is highly available and efficient. For example, in one experiment we find that our object-based edge server system provides a factor of five improvement in response time over a traditional centralized cluster architecture and a factor of nine improvement over an edge service system that distributes code but retains a centralized database.

From Distributed Objects to Hierarchical Grid Components

Abstract: We propose a parallel and distributed component framework for building Grid applications, adapted to the hierarchical, highly distributed, highly heterogeneous nature of Grids. This framework is based on ProActive, a middleware (programming model and environment) for object oriented parallel, mobile, and distributed computing. We have extended ProActive by implementing a hierarchical and dynamic component model, named Fractal, so as to master the complexity of composition, deployment, re-usability, and efficiency of grid applications. This defines a concept of Grid components, that can be parallel, made of several activities, and distributed. These components communicate using typed one-to-one or collective invocations.

Methods for conflict resolution in policy-based management systems

Abstract: While developments in distributed object computing environments, such as the Common Object Request Broker Architecture (CORBA) by the Object Management Group (2000) and the Telecommunication Intelligent Network Architecture (TINA) by H. Mulder (2002), have enabled interoperability between domains in large open distributed systems, managing the resources within such systems has become an increasingly complex task. This challenge has been considered for several years within the distributed systems management research community and policy-based management has recently emerged as a promising solution. Large evolving enterprises present a significant challenge for policy-based management partly due to the requirement to support both mutual transparency and individual autonomy between domains according to C. Bidan and V. Issarny (1998), but also because the fluidity and complexity of interactions occurring within such environments requires an ability to cope with the existence of multiple, potentially inconsistent policies. This paper discusses the need for providing both dynamic (run-time) and static (compile-time) conflict detection and resolution for policies in such systems and builds on our earlier conflict detection work (Dunlop et al., 2001, 2002) to introduce the methods for conflict resolution in large open distributed systems.

Massively Distributed Processing System Architecture, Scheduling, Unique Device Identification and Associated Methods

Abstract: A massively distributed processing system and associated methods are described that utilize an advantageous processing architecture for a multitude of widely distributed devices to process distributed workloads for a plurality distributed processing projects. To provide the infrastructure processing power for the distributed processing system, a modular client agent program, including a system component with a core agent module and a separate project component with at least one task module, is configured to operate on the distributed devices and to process a variety of project workloads. For each different distributed project, different project components or task modules may be provided by a server system to the distributed devices to run on the core agent module or system component. In addition, a capabilities database can be used by a server system to schedule workloads based upon the capabilities of the distributed devices. Furthermore, scheduling, device ID, task wrapper and further infrastructure and application development implementations are also provided.

System and method for remote diagnosis of distributed objects

Abstract: A system for diagnosing disorders of geographically distributed objects from a remote location. Data for a current condition are compared with predefined data patterns for known disorders to identify a statistically significant match indicating that the monitored object is presently experiencing the corresponding disorder. A critical disorder time is forecasted by determining when a threshold value will be reached using trend analysis of probabilities. A new disorder pattern preceding an observed disorder is added to the knowledge base for future reference. The knowledge base may be used to diagnose one object based on data collected from a similar object in a geographically distinct location. Diverse equipment may be conceptually decomposed into a small set of basic components, and equipment may be diagnosed by analyzing operation of its basic component(s). Informative data analysis procedures may be automatedly selected according to predetermined rules as a function of the monitored equipment's basic components.

Displayable presentation page and SQL searchable relational data source implementation of a system, method and software for creating or maintaining distributed transparent persistence of complex data objects and their data relationships

Abstract: The invention provides systems, methods and software for creating or maintaining distributed transparent persistence of complex data objects and associated data stores. In one aspect, the invention also relates to an application programming object capable of creating or maintaining distributed transparent persistence of data objects or data object graphs without the necessity of inserting any byte codes or modification of the object graph. Virtually any java object or object praph can be transparently persisted. Further, copies of a data graph or of a portion of the data graph can be automatically reconciled and changes persisted without any persistence coding in the object model.

Distributed Monitoring of Concurrent and Asynchronous Systems

Abstract: Developing applications over a distributed and asynchronous architecture without the need for synchronization services is going to become a central track for distributed computing. This research track will be central for the domain of autonomic computing and self-management. Distributed constraint solving, distributed observation, and distributed optimization, are instances of such applications. This paper is about distributed observation: we investigate the problem of distributed monitoring of concurrent and asynchronous systems, with application to distributed fault management in telecommunications networks. Our approach combines two techniques: compositional unfoldings to handle concurrency properly, and a variant of graphical algorithms and belief propagation, originating from statistics and information theory.

The Future Perspective

Abstract: Mr Weery Doubtful, who recently joined the Premier Quotes Group enterprise architecture and methodologies team: “I’m still not convinced. They had to remove their own encoding from the interoperability profile! How about workflow, transactions and service management? More specifications are required here. I’m missing distributed objects and state. To me the entire thing seems like a dead end, just as all the other distributed computing frameworks before. The next wave of specifications will be so thick that no vendor can fully implement it. And even worse, in some areas there are competing specifications.

Netbait: a Distributed Worm Detection Service

Abstract: This paper presents Netbait, a planetary-scale service for distributed detection of Internet worms. Netbait allows users to pose queries that identify which machines on a given network have been compromised based on the collective view of a geographically distributed set of machines. It is based on a distributed query processing architecture that evaluates queries expressed using a subset of SQL against a single logical database table. This single logical table is realized using a distributed set of relational databases, each populated by local intrusion detection systems running on Netbait server nodes. For speed, queries in Netbait are processed in parallel by distributing them over dynamically constructed query processing trees built over Tapestry, a distributed object and location routing (DOLR) layer. For efficiency, query results are compressed using application-specific aggregation and compact encodings. We have implemented a prototype system based on a simplified version of the architecture and have deployed it on 90 nodes of the PlanetLab testbed at 42 sites spread across three continents. The system has been continuously running for over a month now and has been collecting probe information from machines compromised by both the Code Red and Nimda worms. Early results based on this data are promising. First, we observe that by having multiple machines sharing probe information from infected machines, we can identify a substantially larger set of infected hosts that would be possible otherwise. Second, we also observe that by having multiple viewpoints of the network, Netbait is able to identify compromised machines that otherwise would have been difficult to detect in cases where worms have an affinity to certain regions of the IP address space.

Networked computing using objects

Abstract: A system for networked computing using objects, each object comprising: enablement data, a first identity arrangement for holding a first identity indicating a host or provider ( 22 ) of said object ( 26 ), and a second identity arrangement for holding a second identity of a remote entity (client 10 ) establishing a relationship with said object via a network ( 12 ). Such a system supports network based computing and interactions between remote objects, including desktop-like behavior in which such remote objects are represented by desktop-like icons on a user terminal device.

Towards model-based and CCM-based applications for real-time systems

Abstract: New advances in software component and modeling standards promise to ease the burden of development complexity while improving flexibility and reliability. These solutions raise the level of abstraction from object-oriented classes to coarser components and support the creation and configuration of systems using modeling or other specification standards. This paper outlines the challenges inherent in the original Bold Stroke component model developed in the late 1990's and then discusses an evolved component model that leverages work being done in the Object Management Group (OMG) and in government funded research that addresses these issues in a distributed real-time embedded (DRE) application context.

Distributed Object-Based Modeling in Design Simulation Marketplace

Abstract: Predictive integrated system modeling is now a pressing issue in the design of complex products ranging from home air conditioners to automobiles and aircraft. While product development organizations have official top-down development processes, it is generally understood that in practice individual participants perform their work in an informal marketplace, bartering service exchange relationships to get what they need to resolve their part of the problem. The authors envision a distributed simulation service marketplace running in parallel with the activities of design participants. This paper develops an object model representation to enable this vision for a decentralized design simulation marketplace. A prototype implementation, called DOME (Distributed Object-based Modeling Environment), is used to illustrate the concept on a beverage container design problem.

Transparent distributed threads for Java

Abstract: Remote method invocation in Java RMI allows the flow of control to pass across local Java threads and thereby span multiple virtual machines. However, the resulting distributed threads do not strictly follow the paradigm of their local Java counterparts for at least three reasons. Firstly, the absence of a global thread identity causes problems when reentering monitors. Secondly, blocks synchronized on remote objects do not work properly. Thirdly, the thread interruption mechanism for threads executing a remote call is broken. These problems make multi-threaded distributed programming complicated and error prone. We present a two-level solution: On the library level, we extend KaRMI (Philippsen et al. (2000)), a fast replacement for RMI, with global thread identities for eliminating problems with monitor reentry. Problem with synchronization on remote objects are solved with a facility for remote monitor acquisition. Our interrupt forwarding mechanism enables the application to get full control over its distributed threads. On the language level, we integrate these extensions with JavaParty's transparent remote objects (Philippsen et al. (1997)) to get transparent distributed threads. We finally evaluate our approach with benchmarks that show costs and benefits of our overall design.

Verification of distributed object-based systems

Abstract: Distributed systems for open environments, like the Internet, are becoming more frequent and important. However, it is difficult to assure that such systems have the required functional properties. In this paper we use a visual formal specification language, called Object-Based Graph Grammars (OBGG), to specify asynchronous distributed systems. After discussing the main concepts of OBGG, we propose an approach for the verification of OBGG specifications using model checking. This approach consists on the translation of OBGG specifications into PROMELA (PROcess/PROtocol MEta LAnguage), which is the input language of the SPIN model checker. The approach we use for verification allows one to write properties based on the OBGG specification instead of on the generated PROMELA model.

Central master data management

Abstract: Methods and apparatus, including computer program products, for sharing data. The technique includes creating at least one data object in a central system, the data object including a complete object definition, and dependencies to other objects, mapping at least one data object to other data objects in the central system, and distributing data objects from the central system to one or more client systems, where the one or more client systems.

Inter-object messaging

Abstract: A method of communication between a first object and a second object is disclosed. A first method call is made on an intermediary object from the first object. The first direct method call contains information regarding a location in memory of the intermediary object instead of a location in memory of the second object and a name of the method to be called on the second object. The name of the method to be called on the second object is delivered from the intermediary object to a message queue object. The name of the method to be called on the second object is accessed from the message queue object by the second object.

System and method for invoking methods on place objects in a distributed environment

Abstract: Methods on objects in a distributed environment are accessed and invoked on a system including a plurality of server objects instantiated in the environment in the same address domain, which share a same user directory and authentication system, are on a same user network, and are administered by a single administration team. A service catalog is provided for cataloging a plurality of objects as nodes on a tree, objects including the plurality of servers objects within the distributed environment. A document file is provided for encapsulating cataloged relationships of server objects in the distributed environment and for storing object attributes generated by traversing the tree.

Agent- and CORBA-Based Application Integration Platform for an Agile Manufacturing Environment

Abstract: A new application integration platform for an agile manufacturing environment is presented, which is based on agent and common request broker architecture (CORBA). CORBA enhances the system integration because it is an industry-standard for interoperable, distributed objects across heterogeneous hardware and software platforms. Agent technology is used to improve the intelligence of the integration system. The platform is open, distributed, and modular to enable the user to adapt its content to his requirements. This application integration platform supports the goals of agile manufacturing: rapid response to changing requirements, reduction in both time and cost of the product realisation process, and integration within a heterogeneous, wide-area-networked enterprise. In order to implement the application integration platform, we use a network integration server to integrate the network, design a generic database agent to integrate database, adopt a multi-agent based architecture to integrate application, and utilise a wrapper as a CORBA object to integrate the legacy code. Finally, a prototype framework is presented.

System and method for sharing objects among two or more electronic devices

Abstract: The present invention relates generally to electronic devices with corresponding device DNA and specifically to such electronic devices that share objects by reference to this device DNA. The present invention includes sharing objects among two or more electronic devices with differing object processing capabilities. In particular, a plurality of descriptions of each of the two or more electronic devices and object meta-data, which describes objects, is referenced when objects are exchanged by the two or more electronic devices. For example, if a given electronic device requests an object that it can not process, the object may be transcoded so that this electronic device can process the object. The transcoding is a function of the electronic device's description, the object's object meta-data, and the intended use of the object.

Verification of Distributed Object-Based Systems

Abstract: Distributed systems for open environments, like the Internet, are becoming more frequent and important. However, it is difficult to assure that such systems have the required functional properties. In this paper we use a visual formal specification language, called Object-Based Graph Grammars (OBGG), to specify asynchronous distributed systems. After discussing the main concepts of OBGG, we propose an approach for the verification of OBGG specifications using model checking. This approach consists on the translation of OBGG specifications into PROMELA (PROcess/PROtocol MEta LAnguage), which is the input language of the SPIN model checker. The approach we use for verification allows one to write properties based on the OBGG specification instead of on the generated PROMELA model.

Session bean implementation of a system, method and software for creating or maintaining distributed transparent persistence of complex data objects and their data relationships

Abstract: The invention provides systems, methods and software for creating or maintaining distributed transparent persistence of complex data objects and associated data stores. In one aspect, the invention also relates to an application programming object capable of creating or maintaining distributed transparent persistence of data objects or data object graphs without the necessity of inserting any byte codes or modification of the object graph. Virtually any java object or object graph can be transparently persisted. Further, copies of a data graph or of a portion of the data graph can be automatically reconciled and changes persisted without any persistence coding in the object model.

System and method for sharing global data within distributed computing systems

Abstract: A system and method for sharing data within a distributed computing system having a plurality of nodes, wherein each node includes a processor and memory. An application is distributed across two or more nodes, including a first node, wherein distributing the application includes creating application processes, associating the application processes with a group and distributing the application processes to the first and second nodes. A data object is established in memory on the first node, wherein defining a data object includes allocating memory for the data object. A name is assigned to the data object and the name is mapped to a data object handle. Data within the data object is accessed through references to the data object handle.

Aspectizing server-side distribution

Abstract: We discuss how a collection of domain-specific and domain-independent tools can be combined to "aspectize" the distributed character of server-side applications, to a much greater extent than with prior efforts. Specifically, we present a framework that can be used with a large class of unaware applications to turn their objects into distributed objects with minimal programming effort. Our framework is developed on top of three main components: AspectJ (a high-level aspect language), XDoclet (a low-level aspect language), and NRMI (a middleware facility that makes remote calls behave more like local calls). We discuss why each of the three components offers unique advantages and is necessary for an elegant solution, why our approach is general, and how it constitutes a significant improvement over past efforts to isolate distribution concerns.

Fast distributed object lookup for a computer network

Abstract: A system and method related for performing lookup operations for objects distributed among different nodes in a peer-to-peer network are disclosed. Various nodes in the peer-to-peer network may store objects. Objects stored on a given node may be accessed by other nodes in the peer-to-peer network. To access an object, a node may first perform a lookup operation to determine where the object is stored, i.e., to determine which node in the peer-to-peer network stores the object. The peer-to-peer network may utilize a method to improve the performance of object lookup operations. In one embodiment, the method may allow object lookup operations to be performed with a latency on the order of one hop.

Session management device, and session management method, program and storage medium

Abstract: PROBLEM TO BE SOLVED: To manage a session under dialoguing without deteriorating the performance of a client/server system in the client/server system in a distributed object environment. SOLUTION: In this session management device, a cession management process 1 performs the session management between a client application 5 for performing a dialogue processing in the distributed object environment and a server application 4 mounted as a distributed object in cooperation with the server application 4. It controls, according to the request from the server application 4, a session management memory 3 for managing session state information provided in the process according, and also controls to manage the session state information which cannot be managed in the session memory 3 because of excessive session state information in a database 6 from the record accessed on the oldest day.

Distributed data system with incremental data updates

Abstract: A system may include a client and a distributed data manager coupled to the client. The distributed data manager may include a data store storing a data object that includes several sub-elements. The client is configured to update a portion of the data object by sending a message to the distributed data manager. The message specifies one of the sub-elements of the data object to be updated and includes a new value of that sub-element but does not include a new value of the entire data object. The distributed data manager is configured to perform updates to the data object in the data store dependent on which of the sub-elements of the data object are specified by the client.