CZ20004827A3 - Method for maintaining logical integrity among objects in computer interactive applications, its use for data sharing system in networks, the data sharing system in networks per se, method for data sharing in networks and application of such method - Google Patents

Abstract

Logical relations among individual objects are only declared by bonds among individual objects of an application so that relations from a set of general, predefined basic relations are selected and the individual objects are connected to outputs or inputs of a given relation whereupon a general, predefined device for filling and maintaining these relations during their use is assigned to each basic relation. Objects then inform these devices assigned to the relations, which depend on their values, about changes in their values and the devices react on changes in values of their inputs and in order to maintain integrity of the relations they change their outputs and operate concurrently wherein some devices can be simultaneously active so that during an application run a user input is processed simultaneously with maintenance of relation integrity.

Description

Technical field

The invention relates to a method for maintaining logical integrity between objects in interactive computer applications, to its use for a network data sharing system, to a network data sharing system, to a method of sharing data on networks in this system, and to using this method of data sharing.

BACKGROUND OF THE INVENTION

Interactive, especially database applications, consist of a number of objects, such as tables, columns, user interface components, and cells that are bound together by logical relationships. In order for the logical relationships in the application to be valid, algorithms are created for each such relationship in the application to establish (establish, deploy) and then maintain (maintain integrity), especially when changes in object values. An example of logical relationships between objects in an application can be as follows:

• There may be a logical “column value display” relationship between the UI component and the table column, that is, the UI component displays the values of that column (characters, numbers).

• Between two tables there may be a relation “selection from the table according to the criterion, ie one table contains the selection from the other table based on the given criteria.

• There may be a “column sum” relationship between a cell and a column in a table, ie the cell contains the sum of column values from all rows in the table.

The disadvantage of the current situation is that it is very laborious to create maintenance algorithms and also make any changes to them. In some cases, it is costly to maintain integrity in relationships between objects in terms of CPU utilization and maintenance algorithm development.

In many cases, it is cheaper and more acceptable not to maintain this integrity temporarily. This applies, for example, to applications that work with a large amount of data, relationships, or even users. In such applications, it is often not even possible, in terms of computer performance and memory capacity, to fulfill all relationships among objects and still is

t • Maintain. In such a case, it is necessary to choose at what times it is necessary to restore this integrity. The following situations may occur. Either the maintenance algorithms are invoked too often, unnecessarily burdening the computer's processor and prolonging the computer's response to the user, or invoked too often and inconsistent data presented to the user, i.e. data that does not correspond to the logical relationships in the application at the moment.

A partial solution to the problem of laboriousness in creating algorithms for fulfilling and maintaining logical relationships in interactive applications is the so-called spreadsheet. In these application environments, logical relationships are only declared. They are automatically filled and maintained on the basis of these declarations by the spreadsheet itself. The spreadsheet works as follows:

• Remembers for each object a list of all objects that depend on its value.

• Maintains a list of objects to be recalculated. This list is empty after the relationships are initially populated.

• If a user changes the value of an object, all objects that depend on the changed value are entered in the object list for recalculation.

• Then the spreadsheet scans the list of objects to recalculate and recalculates one by one.

• After recalculating an object, it removes it from the recalculation list.

• If a new value that is different from the value before the recalculation occurs, all objects that depend on the value are added to the list.

• This is done by a spreadsheet program until the list of objects to be recalculated is empty.

The problems with this architecture are as follows:

1. The user can only change values (interact with the system) between the two conversions. If a spreadsheet is currently performing a time-consuming recalculation of an object, such as the sum of a large table column, the user must wait until the recalculation is complete, or the recalculation must be completed and restarted later. This either leads to user delays or wastage

J 9 9 · ním 9 9 ním ním ním ním ním 9 9 ním ním ním ním ním ním ním ním ním ním ním ním ním ním ním ním ním ním so far that the object does not have to be calculated.

2. If the application works with a lot of data and relationships, then full integrity can practically never be achieved. Even if integrity can be achieved, calculations can last so long that they virtually make it impossible to work with the application. For this reason, spreadsheets are also not used for interactive applications with more data and relationships.

SUMMARY OF THE INVENTION

The disadvantages of the prior art are largely eliminated by the solution according to the invention. The essence of this method of maintaining logical integrity between objects in interactive computer applications is that logical relationships between objects are only declared by relationships between individual objects of the application by selecting relationships from a set of general, predefined basic relationships and connecting individual objects to the outputs or inputs of the relationship, whereupon each basic relationship is assigned a general predefined means for fulfilling and maintaining those relationships in use, wherein the objects inform the resources assigned to the relationships that depend on their values about changes in their values, and the resources respond to change the values of their inputs and to maintain the integrity of relationships, change their outputs and work competitively, where several resources can be active at the same time, so that the user input is simultaneously processed while the application is running, and maintaining integrity of relationships.

This solution ensures that the application responds quickly to users with large amounts of data and relationships, while avoiding such a waste of computing power as in today's spreadsheets. In addition, performing one time-consuming calculation does not block the other calculations; Thus, the user can see the results of undemanding calculations "on time", although further demanding calculations can continue.

With competitive resource processing and user input, the processing of algorithm resources is preferably divided into short periods of time between which the algorithm can be interrupted and during which it cannot be interrupted, and the surrounding data is therefore unchanged, and the application is controlled by a central loop when * 9 f I ·

9 9 9

9 <9 9 · · ·

9999 V «9 999 9999 99« 9 is processing of input from the user and when the steps of the algorithms are performed and which are performed, the individual actions are always sequenced in time. When competing algorithm processing, several algorithms can be active simultaneously. Thus, changes in the input of the algorithm may occur during its execution. The outputs of the relationship exist even if the algorithm is not yet finished and are eventually changed as the algorithm continues to process.

The application run is composed of two types of actions that are competitive:

1. User input processing

2. implementation of maintenance algorithms

User input processing can lead to changes in primary data. In this case, all relationships that depend on the values of the primary data are informed of these changes.

When informing resources about changes in the surroundings, the calculated value is used to calculate the new value. This can achieve significant savings in processor performance.

The means for fulfilling and maintaining the logical relationships between the individual objects is governed by the demand for the values of the object so that the fulfillment and maintenance of the relationship takes place only in the demand for the result and upon completion of the demand the fulfillment or maintenance is terminated. When the algorithms are driven by the demand for object values, this results in significant savings in processor performance and computer memory capacity. Demand is primarily based on the user's requirement to display the value of objects, and secondly, demand arises because it is necessary to know the value of another object to fulfill the value of one object (demanded object). Upon completion of the demand with filling or maintenance it terminates immediately or in a time interval.

All outputs, intermediate results and status information of the algorithms are preferably stored in non-volatile memory. In this way, a significant saving of the memory space can be achieved. If this happens at the end of each step and then the algorithm reloads all the necessary information at the beginning of the next step, then the application can be terminated immediately at any point (after any step) and later resumed in the state in which it was terminated.

· · · ♦ 9 9 9 9 9 9 9 · · · · · · · · · · · · · · · · · ·

In a competitive processing of maintenance algorithms and user input, a garbage collector for deleting useless values is preferably included in the system, which initiates deleting of useless values based on free computer memory information and other information. This again results in substantial memory space savings.

The present invention further relates to the use of the above-described method of maintaining logical integrity between objects in computer interactive data sharing applications, comprising a server for centrally storing shared data and at least one client running an application that uses shared data and processes information about changes in shared data, wherein the clients are at least temporarily connected by a network, provided for an application for accessing the shared data from the cache client. Client and server relationships extend the use of application architecture with automatic maintenance of logical integrity with competitive processing to operate on multiple computers connected across a network.

The present invention also provides a network data sharing system comprising a server for centrally storing shared data and at least one client running an application that uses shared data and processes information about shared data changes where the clients are at least temporarily connected provided with an application for accessing the shared data from the client buffer, which for use of said method of maintaining logical integrity in interactive computer applications further comprises a set of general, predefined basic relationships a special client relationship with at least one output and no input, all shared the data in the client application is represented by an object with a connected client relationship acting as a buffer. Furthermore, the set of general, predefined basic relationships includes a special server relationship with at least one input and no output, with server objects attached to all objects whose values are shared to respond to client requests.

It is advantageous, when compared to the current state of development and operation of network applications, that on the one hand a general mechanism is used which does not require additional development costs to convert the isolated application to the network; on the other hand, an asynchronous protocol that is not as sensitive to the

9 the quality of the connection between computers and thus without significant detriment to the functionality of the application, it can be operated even on lower quality networks, such as the Internet, and especially wireless Internet. An essential advantage of the solution of the present invention is that each application can be arbitrarily divided into client and server parts so that for most end user interactions the application does not need to communicate with the server. This can minimize user waiting time for the server.

The present invention further provides a method of sharing data in said system, wherein if an application requests a value that is not yet cached, a request for that value is sent over the network to the server and the application returns any value back. When a response is returned from the server, if it does not match the value that was previously returned to the application, the application is notified of the change in value and the value received from the server is stored in the buffer. When a client receives a value change information from the server over the network, the change is notified to the application and the value is cleared or marked as invalid so that the next application request for this value generates a new request to the server and requests to change a shared value, so that the new value is immediately cached, and the application is immediately informed of the change of value and at the same time a request to change the value is sent to the server. Until the client receives confirmation from the server that the server has processed its request, all messages from the server that change that value are ignored. Client requests to send values are received over the network by the server that sends the values back as soon as it detects them, while remembering to which clients it sent which values. When some values on the server change, this information is sent from the server to those clients that sent the original value, and if the clients do not request the original value again, no further information about changes to that value is sent to the server. The server receives requests to change its value from clients, which are processed by changing the value of the server and then sending the change request to the client from which it received the request and sending the value change information to other clients previously served by the server. sent the original value.

If an application architecture that automatically maintains logical integrity with competitive processing uses demand management, it is advantageous that data is only sent to clients who actually need it, and the same information about changes.

· 9 9 9 9 9 9 9 * 9 9 9 · · 9 9 9 9 9 9 9 9 9

This minimizes overall communication costs. Also advantageous is the fact that changes in the data initiated by one user are learned with minimal delay by other users requesting the data.

If the connection between the client and the server is interrupted, the request and value change information is preferably stored in memory at the origin of the message and sent when the connection is reestablished. Individual clients, like a server, can be temporarily terminated or disconnected from the network without compromising the consistency of the entire client and server system. In addition, a user can often continue to work with a client without significant loss of functionality even when they are disconnected from the server. Most user interactions do not require communication with the server.

With this method of data sharing in the system, an application can be divided into a greater number of levels than the client and the server, basically any number of levels of work. In addition to the two client-server levels, the application can be operated at four levels, for example, a client-server layer can be inserted between the client and server to concentrate communication with the server for multiple client computers. application logic on multiple cache computers. There is a distribution of performance across multiple computers on the server side, on the client side it is a minimization of communication costs.

Another object of the present invention is to use said method of data sharing for applications sharing data from more than one server. In practice, this use can be realized in such a way that after adding a representative for the necessary data from another application with a client relationship with the identification of the computer processing the application and adding in it server-to-data relations, which are available for integration with other applications, at the moment of the client relationship declaration, determine which server the client relationship should direct its requests to. Information processing between integrated applications is done automatically in real time, with minimal development costs.

BRIEF DESCRIPTION OF THE DRAWINGS

The invention will be explained in more detail by means of the drawings and the following description of exemplary embodiments. Figure 1 shows an example of a central loop that controls the application of a

- ·· · · · · · ·

9 9 * determines at what point the steps are taken algorithms and which algorithms. For example, the selection of the algorithm to execute can be performed by cycling through all active algorithms, that is, those algorithms that are currently running.

Figures 2, 3, and 4 show three types of steps divided into an algorithm that fulfills the following characteristics: informs about changes, processes changes, works in steps and is driven by demand. Fig. 2 shows the step of determining the value of column S in row R, Fig. 3 the response to a change in cell B value, and Fig. 4 shows a gradual change in column S values. using an application architecture that automatically maintains logical integrity with competitive processing in applications shared by multiple users, such as the Internet. Fig. 6 shows an example of the process of processing the value change information on the server; Fig. 7 shows an example of the process of processing the value change request on the server.

DETAILED DESCRIPTION OF THE INVENTION

The logical relationships between individual objects in interactive computer applications (such as tables, columns, user interface components, and cells) are only declared, and their fulfillment and maintenance are performed automatically and competitively. Logical relationships are declared by relationships between individual objects of the application, while the relationships themselves are selected from a set of general, predefined basic relationships (catalog).

Examples of logical relationships between objects in an application are as follows:

• There may be a logical "display column value" relationship between the UI component and the table column, that is, the UI component displays the values of that column (characters, numbers).

• Between two tables there may be a “table selection by criterion” relationship, that is, one table contains a selection from the other table based on a given criterion.

• There may be a "column sum" relationship between a cell and a column in a table, that is, the cell contains the sum of column values from all rows in the table.

Each relationship has one or more outputs and can have one or more inputs. This is illustrated by the following example:

· T t t t b b b b b b b b b ** ** ** ** ** ** ** ** ** ** ** ** ** ** **

relationship Inputs outputs display 1. the column whose values are to be 1. user component column values display interfaces to display values selection from table 1. table from which the selection is made 1st selection table according to the criteria 2. column of this table according to which 2. columns of this table where they will be selection (if column transferred values from the original contains YES, the row will be included in the selection) tables 3. columns of this table to be transferred to the selection column total 1. table to be added 1. the cell it will contain 2. column to be added total

Declaring the relationship between the objects is then realized by selecting a relationship from the catalog and attaching individual objects to the outputs or inputs of the relationship. Each object can be connected to at most one output of one relationship.

Each basic relationship is assigned a set of general, predefined algorithms for fulfilling and maintaining these relationships in the context of their use (maintenance algorithms).

The algorithms meet the following conditions:

(a) Report changes; that is, they inform objects that depend on their output values about changes in their output. That other objects B depend on some object A, object A learns from objects B. Either it learns when objects B are created, this is called so-called statically. Or it learns so-called dynamically, that is when the value of object A is read by objects B and actually becomes dependent on that value. There can be any combination of both.

These changes occur especially when the algorithm recalculates the value of the output based on information about changes in the values of its inputs.

b) Process changes; Algorithms are prepared for changes in the values of their inputs and respond to them by properly recalculating their outputs so that the integrity of the relationship is maintained. Information about input changes is obtained by algorithms from other algorithms or from so-called primary data, ie objects that are not connected to any output of any relationship. Changes to primary data occur primarily at the direct instruction of the user.

«·« · ♦ • »4 4 4

4 44 44 ·· »· 4444

c) They work in a competitive way; that is several algorithms can be active simultaneously. Thus, changes in the input of a given algorithm may occur during its implementation. For example, competitive processing of maintenance algorithms and user input can be secured as follows:

The algorithms work in steps, in short steps; that is, their run is divided into periods of time that are small and between which the algorithm can be interrupted. Algorithms assume that within each step the surrounding data does not change and if it changes after a step, the algorithm learns about this change at the beginning of the next step at the latest. “Small” means that processing of every step, even over almost arbitrarily large data, proceeds so quickly that it is not noticeable for the user. For example, the time required for each step is independent of the amount of data, or at the amount of data n has a maximum of 0 (! Og n).

The application is controlled by a central loop (an example of which is shown in Fig. 1), which determines at which point the input processing is performed from the user and at which point the steps of said algorithms are performed and which algorithms. Individual actions are always ordered from each other, never running simultaneously.

The outputs of the relationship exist even if the algorithm is not yet finished and are eventually changed as the algorithm continues to process. For better orientation of related algorithms it is possible to introduce and use a special value (constant), which indicates that the output of the algorithm is not yet complete.

The application run is composed of two types of actions that are competitive:

1. User input processing

2. Implementation of maintenance algorithms

Processing user input can lead to changes in the primary data. In this case, all relationships that depend on the values of the primary data are informed of these changes.

The solution achieves a fast response time for the user, even with a large amount of data and relationships, while avoiding such a waste of computing power as in today's spreadsheets. In addition, the execution of one time-consuming calculation does not block the other calculations; they are performed simultaneously. Therefore, the user sees the results of undemanding calculations "on time", although further demanding calculations can continue.

Significant savings in processor performance can be achieved if the algorithms, when they receive information about a change in the environment, do not start the calculation procedure from scratch, but merely incorporate the change into already calculated values.

Significant savings in processor performance and memory capacity are also achieved when algorithms are driven by demand for object values. This means that the fulfillment and maintenance of the relationship does not take place unless there is a demand for the result. Demand is primarily based on the user's requirement to display the value of objects, secondary demand arises from the need to know the value of another object in order to fulfill the value of one object (the requested object).

For example, when requesting an object “sum, it is necessary to know the values of all adders. After completion of the demand, the filling or maintenance is terminated immediately, or in a time interval.

The following is an example of an algorithm that fulfills the following characteristics: Informs about changes, processes changes, works in steps and is driven by demand. This algorithm belongs to the relationship between a table column and a cell, which can be described as "column S contains the value of cell B". The task of the algorithm is, therefore, that the value of column S in all rows of the table should be the same and equal to the value in cell B.

The problem is that when you change a value in a cell, you need to change the values in all rows of the table, which generally cannot be done in one step, because with a table large enough, it can take any length of time.

The algorithm is divided into 3 types of steps:

• determining the value of column S in row R • responding to a change in the value of cell B • gradually changing the values of column S

The first step is called in response to the demand for value from the surrounding relationships. The second step is called in response to the notification of cell B that its value has changed.

”In * To It To It To It To It To It To It To It ·

The third step is called by the second step (see below). The algorithm from its surroundings requests the value of cell B.

The algorithm stores the following values for itself:

• the A number of the current version of cell B value • the H field of the current and historical values of cell B indexed by the Version number • the V version of the cell B value valid in each row of the column

With indexed row number • F queue of all valid rows of column S, to which you can add to the end and read from the beginning

The individual steps of the algorithm are shown graphically in Figures 2, 3 and 4 below.

The beginning and end of the step is in a circle, diamond branching, performing a square action. The determination of the value of column S in row R is shown graphically in Fig. 2, the response to a change in the value of cell B in Fig. 3, and a gradual change in the values of column S in Fig. 4.

Significant memory savings can be achieved if the algorithms store all of their output intermediate results and status information in a separate memory, such as a disk. If this happens at the end of each step and then the algorithm reloads all the necessary information at the beginning of the next step, and if the special memory is permanent (see above, eg disk), then the application can be applied at any time (after any step) exit and later resume running in the state in which it was terminated.

Significant storage space savings can be achieved by incorporating a special garbage collector (GC) algorithm into the system, to which each algorithm communicates which values are useless and which, based on free computer memory and other information information initiates deleting these useless values. The needlessness and necessity of values can be governed by a similar principle as the principle of managing demand for object values, see above. Algorithms that cooperate with GCs must allow deletion of unnecessary values while maintaining the three necessary conditions, ie, working competitively, communicating and receiving ”* · · · * · · · · · · ** ·· · • * Μ Μ Μ Μ Μ Μ Μ Μ Μ Μ Μ Μ Μ. If there is a need for these already deleted values after deletion, these algorithms must regenerate them.

Internet applications, shared by a large number of users, are currently basically based on two different architectures.

The first is the terminal architecture, ie using HTML / HTTP, WML / WAP, where all or almost all processing takes place on the server and the general protocol is used for communication with the server. Problems with this architecture are:

• For each user action, you must contact the server to process it. This means that the user is wasting a lot of time waiting for the server. If the Internet is used wirelessly or with a poor quality connection, then these problems may discourage users from using the application.

• Unnecessary data is sent between the client and the server that the terminal has already read. This again increases the user response and congestes the communication medium.

• If a change in the data on a page occurs without user influence (eg another user who uses the same page makes changes), the page is not automatically refreshed and the user may not even know about it. The second architecture is that the end user (client) part and the server part are run separately, and a protocol specially developed for that application is used to communicate between them. This entails the following problem:

• Developing special protocols and applications that use them is extremely costly for midsize and larger applications. Therefore, this method is mainly used in simple applications such as email.

To overcome the above-mentioned problems, the above-described application architecture with automatic logical integrity maintenance with competitive processing is used as follows.

□ The set (catalog) of predefined basic relationships contains a pair of special client-server relationships described below. The client relationship has one output and no input. The relationship server has one input and no output.

Instead of one isolated application, two, client, and server applications are created, with the proviso that the client will use the server application data. All server objects whose values are needed for a client application are represented in the client application by an object with a connected client relationship. In a server application, server relationships are attached to these objects.

□ The server relationship receives requests from clients to send their value over the network. It handles these requests by asking the object itself and sending the result over the network again to the client. At the same time, he remembers to which clients he sent the result values. If it receives information about a change in its value, it sends this information to clients that it knows the original value sent to them. If these clients do not request the original value again, they do not receive further information about the changes from the server relationship. In addition, the server relationship receives requests from clients to change their value. This applies only to those server relationships that are associated with the primary data. This request handles the server relationship by forwarding the request to its associated object and, after being processed by the associated object, sending the client that received the request information about the successful change made. At the same time, it sends information about the change of value to other clients to whom it previously sent the original value.

□ The client relationship handles requests for its value if it does not already know it by sending a request for this value to the server over the network and immediately returns any value back. When the client relationship returns a response from the server, there are two options. Either the return value is the same as the value previously returned; then no additional action is required. Otherwise, it notifies its object of any change to its value and remembers the value it receives from the server. The next time it is asked for its value, it will return the value it had previously remembered. An example of the process of processing a value request from the server is shown in Fig. 5. When a client relationship receives a value change information from the server over the network, it notifies the relationship of any relationship that is dependent on it and continues to behave as if it did not receive any value from the server. An example of the process of processing the value change information on the server is shown in Fig. 6. The client relationship handles requests to change its value (if this relationship is represented by primary data) by instantly changing its value, informing all the objects dependent on it, and at the same time 44 • · « 4 4 4 4 4 4 4 4 5 6 7 8 9 4 5 6 7 8 9 10 11 12 »» 4 4 4 4 4 »» Until it receives confirmation from the server that the server has processed its request, it ignores all messages from the server that have changed the value. An example of the process of changing the value request on the server is shown in Fig. 7.

Client and server relationships extend the use of application architecture with automated logical integrity maintenance with competitive processing (AULIK) to run on multiple computers connected across a network.

Another advantage when compared to the current state of development and operation of network applications is that, on the one hand, a general mechanism is used which does not require additional development costs to convert the isolated application to the network; on the other hand, asynchronous protocol is used for communication between computers, which is not so sensitive to the quality of the connection between computers, and therefore without significant damage to the functionality of the application it can be operated even in lower quality networks such as the Internet and especially wireless Internet . An essential advantage of the solution is that each application can be arbitrarily divided into client and server parts, so that for most application end user interactions it is not necessary to communicate with the server; this minimizes the user's waiting time for the server.

Another significant advantage is that the application architecture with automatic maintenance of logical integrity with competitive processing uses demand management that data is sent only to clients who actually need it, as well as information about changes. This minimizes overall communication costs.

Also advantageous is the fact that changes in the data initiated by one user are learned with minimal delay by other users requesting the data.

The system may be supplemented by a mechanism that stores requests and value-change information in the event of a loss of connection between the client and the server at the origin of this message; and automatically sends them the next time the connection is reestablished. This is advantageous because individual clients, like the server, can be temporarily shut down or disconnected from the network without compromising the consistency of the entire client and server system. In addition, the user, often without significant loss of functionality, can continue to work with the client disconnected from the server. Most user interactions do not require communication with the server.

• · · φ · φ • φ · · · · φ φ φ φ

Also advantageous is the possibility of dividing the application into any number of levels of operation; in addition to the described two client-server levels, the application can be operated at four levels, for example, a client-server layer can be inserted between the client and server, concentrating communication with the server for multiple client computers. application logic on multiple cache computers. Performance is distributed across multiple server-side computers; on the client side, it is about minimizing communication costs.

The solution according to the invention is also applicable to the integration of applications from different suppliers. When integrating applications from different vendors, the most arduous development is an algorithm for automatically integrating information from one system to another in real time. This laboriousness is so great and growing in such a way with the size of the application that real-time application integration is rarely and costly.

To solve this problem, the Application Architecture with asynchronous communication protocol and automatic synchronization is advantageously used and completed as follows:

At the moment the client relationship is declared, it is determined based on a standardized way of identifying (for example, a URL) to which server the client relationship should direct its requests. In this way, application A can automatically use data from application B. In application A, it is sufficient to add a shortcut for the necessary data from application B with a client relationship with the identification of the computer that processes application B.

In Application B, you need to add server-to-data relationships that are made available for integration with other applications. Server relationships can be supplemented by access control, that is, algorithms that decide whether and under what conditions and to which clients to provide data. Information processing between integrated applications is done automatically in real time, with minimal development costs.

Industrial applicability

The invention is useful in maintaining logical integrity between objects in interactive computer applications, including in network data sharing systems.

Claims (14)

PATENT CLAIMS A method of maintaining logical integrity between objects in interactive computer applications, characterized in that logical relationships between individual objects are only declared by constraints between individual application objects by selecting relationships from a set of general, predefined basic relationships and attaching individual objects the outcomes or inputs of the relationship, whereupon each basic relationship is assigned a general predefined means for fulfilling and maintaining those relationships in use, wherein the objects inform those resources assigned to the relationships that depend on their values of changes in their values, and the means respond to changes in the values of their inputs and in order to maintain the integrity of relationships change their outputs and work competitively, when several resources can be active at the same time, so while the application saith to maintain the integrity of relationships. Method according to claim 1, characterized in that the processing of the means for fulfilling and maintaining the logical relationships formed by the algorithms, in the competitive processing of these means and the user input, is divided into short periods of time between which the algorithm can be interrupted and therefore, the surrounding data remains unchanged, and the application is controlled by a central loop determining the point at which user input processing takes place and when the steps of the algorithms and which algorithms are performed, the actions being sequenced in time. Method according to claim 1 or 2, characterized in that, when informing the means for filling and maintaining the logical relations between the individual objects of changes in the surroundings, the calculated value is used to calculate the new value. Method according to one of Claims 1 to 3, characterized in that the means for fulfilling and maintaining the logical relationships between the individual objects are governed by the demand for the values of the object such that the fulfillment and maintenance of the relationship takes place only upon demand for result and filling or maintenance is terminated. Method according to one of claims 1 to 4, characterized in that all the outputs, intermediate results and status information of the means for filling and maintaining the logical relations between the individual objects are stored in a non-volatile memory. Method according to any one of claims 1 to 5, characterized in that, in the competitive processing of means for maintaining logical relationships between individual objects and user input, a garbage collector is included in the system for deleting useless values which, based on free computer memory information, and other information initiates deleting useless values. Use of the method according to any one of claims 1 to 6 for a network data sharing system, comprising a server for centrally storing shared data and at least one client running an application that uses shared data and processes shared data change information, wherein the clients are at least temporarily connected by a network provided for the application to access the shared data from the client buffer. 8. A network data sharing system, comprising a server for centrally storing shared data and at least one client running an application that uses shared data and processes information about shared data changes where the clients are at least temporarily connected by a network provided for the application for accessing shared data from a client buffer according to claim 7, characterized in that for using the method of maintaining logical integrity in interactive computer applications according to any one of claims 1 to 6, the set of general, predefined basic relationships further comprises a special client relationship with at least one output and no input, all of the shared data in the client application being represented by an object with a connected client relationship acting as a buffer. 9. A network data sharing system, comprising a server for centrally storing shared data and at least one client running an application that uses shared data and processes information about shared data changes where the clients are at least temporarily connected by a network provided for the application for accessing shared data from a client buffer according to claim 7 or 8, characterized in that for use of The method of maintaining logical integrity in interactive computer applications according to any one of claims 1 to 6, further comprising a set of general, predefined basic relationships comprising a special server relationship with at least one input and no output, wherein all objects whose values are shared are associated with responding to client requests. 10. A method of sharing data in a system as claimed in claim 7, wherein in the case where an application requests a value that is not yet cached, a request for that value is sent over the network to the server and any value is returned to the application. then, when the response is returned from the server, if the response is not equal to the value already returned to the application, the application will be notified of the value change and the value received from the server will be cached, value change information, the change is reported to the application, and the value is cleared or marked as invalid so that the next application request for this value makes a new hit, and when the application requests a shared value on the client, the new value is immediately cached while the application the client is immediately notified of the change of value and a request to change the value is sent to the server, and until the client receives confirmation from the server that the server has processed its request, all messages from the server about the change of value are ignored, to send values, they are received over the network by the server that sends the values back as soon as it detects them, remembering to which clients it sent which values, and when some values on the server change, this information is sent from the server to those clients the original value, and if the clients do not request the original value again, the server no longer sends information about changes to that value, and the server receives requests from clients to change their value, which is processed by changing the value and then sending the value to the client from whom the request was received, information on the performed change, and this value change information is also sent to other clients to whom the server previously sent the original value. System data sharing method according to any one of claims 7 to 10, characterized in that, when the connection between the client and the server is interrupted, the requests and information about the change of value are stored in the memory. at the origin of this message and sent when the connection is reestablished. A data sharing method in a system according to any one of claims 7 to 11, characterized in that the application is divided into a greater number of levels than the client and the server. Use of the data sharing method according to any one of claims 7 to 12 for applications sharing data from more than one server. Use of the data sharing method according to claim 13, wherein, after adding a representative for the necessary data from another application, a client relationship with the identification of the computer processing the application and adding server-to-data relationships available for integration with other applications, at the moment of declaring the client relationship, determine which server the client relationship should direct its requests to,