Shared Object Synchronization via Mediator Server
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing data sharing mechanisms between programs and machines are complex, requiring specific implementations that are often situation-dependent and not reusable, forcing programmers to manage intricate details such as concurrency and access controls, which can vary based on the type of data being shared.
Innovation Solution
A system of shared objects is introduced, allowing programs to create and use shared data objects like local objects, with an object server maintaining a registry and master copy, and each machine maintaining a local copy, enabling notification and synchronization of changes, along with concurrency and access controls to manage concurrent updates and access permissions.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If programs implement their own data sharing mechanisms with code to listen for incoming data and send outgoing data, then data sharing capability is achieved, but device complexity and difficulty of implementation increase
Solution Approach 1:
The patent introduces an object server as an intermediary component that manages data sharing between programs. The object server maintains a registry of shared objects and handles the complex coordination of data exchange, allowing programs to share data without implementing their own sharing mechanisms. This mediator approach resolves the contradiction by centralizing the complexity in a dedicated service while keeping individual programs simple.
Solution Approach 2:
The patent extracts the data sharing implementation details from individual programs and places them in a separate object server system. Programs no longer need to include code to listen for incoming data or send outgoing data - these functions are taken out and handled by the object server, reducing program complexity while maintaining sharing capability.
2Productivity
If programs agree on specific data exchange mechanisms tailored to the type of data being shared, then data sharing effectiveness improves, but ease of operation decreases due to the need to manage concurrency and access controls
Solution Approach 1:
The patent creates a universal object model that can represent different types of data (graphical information, text, binary data) in a unified way. The object server handles all data types through the same interface and mechanisms, eliminating the need for programs to implement type-specific sharing logic. This universal approach maintains effectiveness while improving ease of operation.
Solution Approach 2:
The object server automatically manages concurrency control and access permissions without requiring programs to manually handle these aspects. When multiple programs access shared objects, the object server self-manages the coordination, conflict resolution, and permission enforcement, freeing programs from the burden of implementing these complex controls.
3Reliability
If programs are implemented with data sharing in mind including code to manage sharing details, then reliable data sharing is achieved, but ease of manufacture decreases
Solution Approach 1:
The object server acts as a reliable intermediary that guarantees proper data sharing behavior. It maintains the authority on the truth of shared objects and ensures consistent state management across all programs. This mediator approach achieves reliable data sharing while allowing programs to be manufactured more easily since they don't need to include their own sharing management code.
Data Source
AI summary
Sharing of objects may be implemented in a way that allows programs to use shared objects in much the same way that they would use local objects. In one example, a program creates an object and sets properties through normal instructions that would be used to create a local object. The program then registers the object with a shared object model, which may be maintained by a shared object server. For each machine on which the object may be used, a shared object runtime monitors for changes to the objects, and notifies the server of these changes. The server updates the object, and notifies other machines of changes to the state of the object. The shared object runtimes on those machines receive notification of the changes, and update the local copies.