IES950820A2 - A version control facility - Google Patents
A version control facilityInfo
- Publication number
- IES950820A2 IES950820A2 IES950820A IES950820A2 IE S950820 A2 IES950820 A2 IE S950820A2 IE S950820 A IES950820 A IE S950820A IE S950820 A2 IES950820 A2 IE S950820A2
- Authority
- IE
- Ireland
- Prior art keywords
- code
- access request
- codestore
- code block
- central
- Prior art date
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Security & Cryptography (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
A version control facility for controlling development of software code in a distributed computing environment. The invention ensures that the latest version of code is available to each development workstation to allow developer modification and prevents the occurrence of either parallel development or contradictory development. In addition, the invention ensures that access is maintained to previously developed versions of the software or the developers through the development of the system without placing excessive demands on a central codestore.
Description
A version control facility
vention relates to a version control use in a computer system and more particularly to a version control facility to overcome the technical difficulties associated with efficient control of software development in a distributed environment.
' ...------------- z c CO T l~ OJ N O UJ 1 JJ _J σ ft z> ώ cc Ll. rr Q cu z — < co :Z co £ - -) cu f a. Z t O O (— H T LU CL ϋ LU ω ό z __i O Z —
Development of complex software solutions using a large number of developers requires continuous monitoring of the development process to ensure that the latest software version is available to users, testing personnel and developers alike.
It is essential that changes to the software are noted to eliminate the possibility of parallel or conflicting modifications being made by two independent programmers. Additionally, amendments made to a given block of software code are subject to system wide testing criteria which may highlight errors arising from interactions between blocks of code which are invisible locally. Therefore, in addition to storing and ensuring the availability of the updated code, it is vital that previously verified versions are also correctly stored. This presents a particular problem in the development of sophisticated large scale software systems, as frequent modifications are made and significant time may elapse between development of the code and the discovery of an intermittent error. This is particularly important during initial development when liberal amendments are being made, as large volumes of disk space are required to store all of the intermediate software versions.
Another problem arises in that the development of such systems frequently occurs in a distributed environment having a wide variety of both hardware and software platforms. This makes accurate tracking of modifications and amendments made in real time very difficult, necessitating skilled personnel using a variety of developmental tools to be dedicated to the ja-A, j
950820 task significantly increasing development costs. In addition to the time required to audit the changes made, it adversely affects portability of developers between the various platforms, necessitating retraining on the various developmental tools used.
It is known to provide a tracking system resident on a host computer to control the development of a large scale project, however systems of this type are useful only for development of systems using developmental language and Similarly, United Kingdom describes a method for a single resources . 2264575 B shared
Patent library No. GB updating software in a telecommunications network which provides an effective method of updating software however, the method described is not suitable for distributed systems where consistency across a computer network cannot be guaranteed.
It is also known to store modifications to a standard block of code for local use and one such facility is described in United Kingdom Patent No. GB 2121570 B. This method allows a user to customise standard blocks of code however, it does not address the problem of distributing the amendments made to all other system users in real time.
There is therefore a need for a version control facility which will overcome at least some of the aforementioned problems .
Accordingly, there is provided a version control facility for use in a distributed computer system of the type having a central codestore for storing software code, a local server communicating with the central codestore having receiving means for receiving and validating a code access request from at least one development workstation connected to the local server, wherein the receiving means comprises:means for extracting a code type and user identifier from the code access request by reading at least one
950820
- 3 position dependent data segment from the code access request;
means for validating the code access request by comparing a composite dataword provided by the identified code type and the user identifier against equivalent length datawords contained in a secure memory array of valid composite datawords; and means for retrieving a code block and attached program register associated with the validated code access request, accessing the program register to isolate a data portion containing a version identifier associated with the code block, transmitting a copy of the code block to the development workstation, locking the code block by setting a write protection bit in the program register and generating a replacement code block in the central codestore.
In this way storage requirements on the central codestore are significantly reduced while still providing a full history of each development stage by storing the latest version only and modifications rather than each individual software version.
Preferably the replacement code block has an attached program register containing a pre-set write bit and includes the user identifier associated with the validated code access request, the code type, the identified version identifier and a time stamp.
This prevents the latest version being accessible when withdrawn for amendment thereby eliminating the risk of parallel or contradictory developments being undertaken. This is particularly important when used in the development of large scale software projects where there are many developers. Advantageously the amount of time taken to rework the code is significantly reduced by elimination of contradictory development therby reducing project production costs and increasing production profitability.
950820
Ideally the time stamp has a time indicator and date indicator referring to the physical time and date when the code block was transmitted. Thus, when a developer discovers that a given code block has been removed for amendment is made aware of when and by whom the block was taken.
Preferably the version control facility includes means for detecting the presence of a replacement code block in the central codestore associated with a validated code access request from a development workstation and transmitting the replacement code block to the development workstation. Thus, the developer can base a decision as to whether he should contact the other developer to seek return of the code.
Preferably the receiving means comprises :means for identifying the code type of the code access request as a code return request by comparing a position dependent data segment from the code access request against a plurality of code access request types stored in a secure code type memory array; and means for retrieving the replacement code block from the central codestore and validating the code return request by comparing portion of the identified code type, the identified version identifier and the user identifier of the code return request against the version identifier and user identifier stored in the replacement code block.
This prevents incorrect code blocks from being inserted on the central codestore.
Ideally the version control facility includes means for comparing a return code block associated with the validated code return request to the write protected code block associated with the code access request and storing code differences and the identified version identifier in a code difference file in the central codestore, updating the identified version identifier of
950820
- 5 the return code block, storing the return code block in the central codestore, unlocking by releasing a write protection bit in the program register, deleting the write protected code block and deleting the replacement code block from the central codestore.
The storage requirements on the central codestore being significantly by storing the latest version of the code block only and a single associated file containing modifications also increases processing efficiency as it is not necessary to process numerous lengthy file to access a chosen area of the fixed disk.
Ideally the version control facility includes means for detecting a difference between the identified version identifier of the code return request and the version identifier stored in the replacement code block and transmitting the replacement code block to the development workstation. This prevents a previous version of the code block which may have been stored locally by the developer accidentally overwriting a version stored on the central codestore, thereby providing additional system security.
In one arrangement the version control facility includes means for identifying the code type of the code access request as a code regression request by comparing a position dependent data segment from the code access request against a plurality of code access request types stored in a secure code type memory array;
means for retrieving a code block associated with the code regression request and the code difference file, and means for sequentially reading each portion of the code difference file, locating an associated portion in the retrieved code block for each read portion and substituting the read portion of the code difference file for the associated portion of the retrieved code block, decrementing the version identifier associated
950820
- 6 with the retrieved code block and storing the code block.
Thus, the procedure to produce a previous software version is provided in a simple manner without adversely affecting system performance.
Ideally the version control facility includes means for sequentially processing a plurality of a code regression request from a development workstation. This allows any previous version of the code to be regenerated using the difference files by a single developer request.
Preferably the version control facility includes means for identifying the code type of the code access request as a code create request by comparing a position dependent data segment from the code access request against a plurality of code access request types stored in a secure code type memory array; and means for creating a version identifier for a code block associated with the code create request and storing the code block, program register containing an associated version identifier on the central codestore.
In this way a system wide convention is enforced on all developers as each file must be created in a set manner. This eliminates the risk that different developers may introduce personal naming conventions or naming styles dictated by the operating system on which they work thereby making access by other developers difficult or impossible.
According to one aspect of the invention there is provided a version control facility for use in a distributed computer system of the type having a central codestore for storing software code, a local server communicating with the central codestore having receiving means for receiving and validating a code access request from at least one development workstation
950820 connected to the local server, wherein the receiving means comprises :raeans for extracting a code type and user identifier from the code access request by reading at least one position dependent data segment from the code access request;
means for validating the code access request by comparing a composite dataword provided by the identified code type and the user identifier against the equivalent length datawords contained in a secure memory array of valid composite datawords; and means for detecting the presence of a replacement code block in the central codestore associated with a validated code access request from a development workstation and transmitting the replacement code block to the development workstation.
According to another aspect of the invention there is provided a version control facility for use in a distributed computer system of the type having a central codestore for storing software code, a local server communicating with the central codestore having receiving means for receiving and validating a code access request from at least one development workstation connected to the local server, wherein the receiving means comprises :means for extracting a code type and user identifier from the code access request by reading at least one position dependent data segment from the code access request;
means for validating the code access request by comparing a composite dataword provided by the identified code type and the user identifier against equivalent length datawords contained in a secure memory array of valid composite datawords;
means for identifying the code type of the code access request as a code return request by comparing
950820
- 8 a position dependent data segment from the code access request against a plurality of code access request types stored in a secure code type memory array; and means for retrieving the replacement code block from the central codestore and validating the code return request by comparing portion of the identified code type, the identified version identifier and the user identifier of the code return request against the version identifier and user identifier stored in the replacement code block.
According to a further aspect of the invention there is provided a version control facility for use in a distributed computer system of the type having a central codestore for storing software code, a local server communicating with the central codestore having receiving means for receiving and validating a code access request from at least one development workstation connected to the local server, wherein the receiving means comprises: means for extracting a code type and user identifier from the code access request by reading at least one position dependent data segment from the code access request;
means for validating the code access request by comparing a composite dataword provided by the identified code type and the user identifier against equivalent length datawords contained in a secure memory array of valid composite datawords;
means for identifying the code type of the code access request as a code regression request by comparing a position dependent data segment from the code access request against a plurality of code access request types stored in a secure code type memory array;
950820
- 9 means for retrieving a code block associated with the code regression request and the code difference file, and means for sequentially reading each portion of the code difference file, locating an associated portion in the retrieved code block for each read portion and substituting the read portion of the code difference file for the associated portion of the retrieved code block, decrementing the version identifier associated with the retrieved code block and storing the code block.
The invention will be more clearly understood from the following description of one embodiment thereof, given by way of example only, with reference to the accompanying drawings, in which:Fig. 1 is a flow diagram illustrating operation of a version control facility in accordance with the invention.
A distributed development environment incorporating a version control facility in accordance with the invention has a central codestore connected to a number of local servers by host connections. The local servers, in this case provided by PC servers, micro-VAX™ / VAX™ systems, AS/400™ systems or any similar server and each has an associated operating system for controlling operation of a local network and communication with the central codestore. The operating system associated with each of the local servers is not necessarily compatible with the operating system of other local servers. Each of the local networks is used for communicating information between the local server and a number of developer workstations. The developer workstations may be of any suitable type either with or without local processing and storage capabilities.
The distributed development environment incorporating the version control facility is for controlling development of software code in a distributed computing environment. The invention ensures that the latest
950820
- 10 version of code is available to each development workstation within the environment to allow modification to be made by any of the developers. The invention also provides that when code is being modified at one of the development workstations, that the code is not made available to another development workstation to prevent the occurrence of either parallel development or contradictory development. In addition, the invention ensures that access is maintained to previously developed versions of the software or the developers through the development of the system without placing excessive demands on the central codestore.
Referring to the drawing, a code access request is generated at the developer workstation and transmitted to the central codestore in step 1. When a developer working at one of the workstations requires access to the central codestore to create or amend a block of code a code access request 1 is generated by the developer at the workstation. The request 1 is passed along the local network and through the local server on to the host connection. The local servers, where appropriate, will convert the format of the request from the development workstation into a format suitable for accessing the central codestore.
The code access request is received and a data segment associated with a code type of the code access request is compared against a number of code access request types F in step 2. The code access request types F are stored in a secure, code type memory array of the central codestore. Code access request types may relate to code retrieve requests, code return requests, code replace requests or code regression requests. When the code access request is recognised as a code retrieve request it is routed by the version control facility to a code retrieve requester in step 10. The received code retrieve request is split by the code requester into frames and the code type is taken from the first data frame in step 11. In step 12 a user identifier B is then extracted from the next frame of the code retrieve request received at the central codestore and the code type A extracted in step 11 and the user identifier B
950820 extracted in step 12 are appended in step 13 to produce a composite dataword C.
The composite dataword C is compared with a number of equivalent length datawords stored in a secure portion of the central codestore in step 14 until a match is found. When a match is found, the code block and attached program register associated with the code retrieve request are retrieved in step 15. The program register is read in step 16 to isolate a data portion containing a version identifier associated with the code block. In step 17, a copy of the original code block is produced and the copy is transmitted in step 60 across the server connection and the local network to the development workstation where the code retrieve request originated.
A write protection bit, being the most significant bit of the program register is set in step 18 to form a write protected replacement code block thereby preventing deletion or overwriting of the code block. In step 19 a replacement code block D is created containing brief text message to indicate that the code block has been removed for development purposes and indicating the user identifier and code type of the code retrieve request in step 19. Additionally, the replacement code block has a time stamp indicating the time and day on which the code was removed for further processing.
When the code retrieve request identified in step 2 relates to a code retrieve request for which the code block associated with the code retrieve request has been removed, the presence of the write protected replacement code block is detected in step 25. The replacement code block is then copied in step 26 and is transmitted in step 60 across the host connection and the local network to the development workstation where the code retrieve request originated.
When the code access request is identified as a code return request in step 2, indicating that it is desired to return a code block removed using the operation
950820
- 12 described above. The code return request is routed by the version control facility at to a code return requester in step 42. The replacement code block D which is produced in step 19 associated with the code return request is retrieved from the central codestore in step 43. The code type associated with the code return request is validated in step 44 by comparing the code type of the code access request with the code type G stored in the replacement code block retrieved in step 43. In step 45, the version identifier H of the code access request is compared against the version identifier of the replacement code block and in step 46, the user identifier is compared against the user identifier I stored in a replacement code block. In this way, the integrity of the system is assured by preventing unauthorised overwriting of code blocks and guaranteeing that no version identifier is skipped in the development cycle.
In step 47 the return code block and the replacement code block are compared line by line and the differences notes are stored in a difference file J in step 48. The difference file J notes any amendments made to the code withdrawn from the central codestore previously, but does not store complete versions of
Accordingly, the storage requirements on codestore are significantly reduced and the difference file J may be archived or packed when required. Alternatively, the file may be left available for regression requirements.
the code. the central
In step 49 the version identifier of the return code block is updated by incrementing a version number and in step 50 the return code block with updated version identifier is stored in the central codestore. The write protection bit in the program register is unlocked in Step 51 and the write protected code block is deleted in step 52. The replacement code block is then similarly deleted from the central codestore in step 53.
When it is noted that the identified version identifier of the return request and the version identifier stored in the replacement code block are different, the
950820
- 13 replacement code block is re-transmitted to the workstation thereby preventing storage of amended code files out of sequence, this significantly improves the overall reliability of the distributed system in that it is not possible for files to be stored out of sequence.
When it is required to return to a previous version of the software, the code access request is recognised as a code regression request in step 2 and the routed by the version control facility to a code regression requester in step 70. The code block associated with the code regression request is retrieved from the central codestore in step 71. The corresponding code difference file found produced in step 48 is retrieved in step 72. Each portion of the code difference file is read into memory and the corresponding area of the retrieved code block is replaced by the memory contents as read from the code difference file in step 73. Each of the portions of the code difference file are read in turn from top to bottom until the entire contents have been substituted for the original contents of the retrieved code block. As the code block has been regressed or stepped back by one version, the version identifier contained in the program register associated with the code block is accordingly backdated in step 74 and the code block is replaced by the regressed code block in the central codestore in step 75. This operation may be repeated a number of times to regress the software back to any desired version level.
When it is required to create a new block of code to be stored on the central codestore the code access request is sent, containing details of the application for which the code create is sought, details relating to the users such as user identifier and source ID, program name and code type, providing the user has the necessary authorizations to create a file of this type, then the code is stored in the central codestore and version identifier assigned. It will be appreciated that the version control facility outlined above provides a significant improvement in the tracking and auditing necessary to develop sophisticated systems in a distributed development environment. Additionally, this
950820
- 14 is achieved while minimising the memory requirements on the central codestore to which the distributed environment is connected and without requiring the use of operating system specific software. As the developers may use existing systems to transmit and receive code from the central codestore, no re-training is required in the event of a move or software changes.
It will be appreciated that the recording of changes made is self documenting and is always available to developers by using the code difference files which enables software development quality systems such as IS09001 to be easily introduced or maintained.
It will be further appreciated that the functionality outlined may readily be incorporated into an electronic circuit for inclusion in a personal computer. It will also be appreciated that certain aspects of the code access request validation may be carried out locally at the workstation to limit network traffic.
It will noted that access requests may be easily limited and that configuration relating to the use of applications by certain developers may be easily updated by an authorised person changing the contents of the secure memory array stored in the central codestore.
The invention is not limited to the embodiment hereinbefore described but may be varied in both construction and detail. For example, it is envisaged that the method described is independent of dataword lengths associated with any hardware or software platform.
Claims (6)
1. A version control facility for use in a distributed computer system of the type having a central codestore for storing software code, a local server communicating with the central codestore having receiving means for receiving and validating a code access request from at least one development workstation connected to the local server, wherein the receiving means comprises :means for extracting a code type and user identifier from the code access request by reading at least one position dependent data segment from the code access request; means for validating the code access request by comparing a composite dataword provided by the identified code type and the user identifier against equivalent length datawords contained in a secure memory array of valid composite datawords; and means for retrieving a code block and attached program register associated with the validated code access request, accessing the program register to isolate a data portion containing a version identifier associated with the code block, transmitting a copy of the code block to the development workstation, locking the code block by setting a write protection bit in the program register and generating a replacement code block in the central codestore. 950820 - 16
2. A version control facility as claimed in claim 1 wherein the replacement code block has an attached program register containing a pre-set write bit and includes the user identifier associated with the validated code access request, the code type, the identified version identifier and a time stamp, the time stamp having a time indicator and date indicator referring to the physical time and date when the code block was transmitted, the version control facility including means for detecting the presence of a replacement code block in the central codestore associated with a validated code access request from a development workstation and transmitting the replacement code block to the development workstation; means for identifying the code type of the code access request as a code return request by comparing a position dependent data segment from the code access request against a plurality of code access request types stored in a secure code type memory array; means for retrieving the replacement code block from the central codestore and validating the code return request by comparing portion of the identified code type, the identified version identifier and the user identifier of the code return request against the version identifier 95082 0 - 17 and user identifier stored in the replacement code block; means for comparing a return code block associated with the validated code return request to the write protected code block associated with the code access request and storing code differences and the identified version identifier in a code difference file in the central codestore, updating the identified version identifier of the return code block, storing the return code block in the central codestore, unlocking by releasing a write protection bit in the program register, deleting the write protected code block and deleting the replacement code block from the central codestore; means for detecting a difference between the identified version identifier of the code return request and the version identifier stored in the replacement code block and transmitting the replacement code block to the development workstation; means for identifying the code type of the code access request as a code regression request by comparing a position dependent data segment from the code access request against a plurality of code access request types stored in a secure code type memory array; 950824 - 18 means for retrieving a code block associated with the code regression request and the code difference file, means for sequentially reading each portion of the code difference file, locating an associated portion in the retrieved code block for each read portion and substituting the read portion of the code difference file for the associated portion of the retrieved code block, decrementing the version identifier associated with the retrieved code block and storing the code block; means for sequentially processing a plurality of a code regression request from a development workstation; means for identifying the code type of the code access request as a code create request by comparing a position dependent data segment from the code access request against a plurality of code access request types stored in a secure code type memory array; and means for creating a version identifier for a code block associated with the code create request and storing the code block, program register containing an associated version identifier on the central codestore. 9508 2 ο - 19
3. A version control facility for use in a distributed computer system of the type having a central codestore for storing software code, a local server communicating with the central codestore having receiving means for receiving and validating a code access request from at least one development workstation connected to the local server, wherein the receiving means comprises :means for extracting a code type and user identifier from the code access request by reading at least one position dependent data segment from the code access request; means for validating the code access request by comparing a composite dataword provided by the identified code type and the user identifier against the equivalent length datawords contained in a secure memory array of valid composite datawords; and means for detecting the presence of a replacement code block in the central codestore associated with a validated code access request from a development workstation and transmitting the replacement code block to the development workstation.
4. A version control facility for use in a distributed computer system of the type having a central codestore for storing software code, a 95062ο - 20 local server communicating with the central codestore having receiving means for receiving and validating a code access request from at least one development workstation connected to the local server, wherein the receiving means comprises :means for extracting a code type and user identifier from the code access request by reading at least one position dependent data segment from the code access request; means for validating the code access request by comparing a composite dataword provided by the identified code type and the user identifier against equivalent length datawords contained in a secure memory array of valid composite datawords; means for identifying the code type of the code access request as a code return request by comparing a position dependent data segment from the code access request against a plurality of code access request types stored in a secure code type memory array; and means for retrieving the replacement code block from the central codestore and validating the code return request by comparing portion of the identified code type, the identified version identifier and the user identifier of the code return request against the version identifier 95 082 0 - 21 and user identifier stored in the replacement code block.
5. A version control facility for use in a distributed computer system of the type having a central codestore for storing software code, a local server communicating with the central codestore having receiving means for receiving and validating a code access request from at least one development workstation connected to the local server, wherein the receiving means comprises:means for extracting a code type and user identifier from the code access request by reading at least one position dependent data segment from the code access request; means for validating the code access request by comparing a composite dataword provided by the identified code type and the user identifier against equivalent length datawords contained in a secure memory array of valid composite datawords; means for identifying the code type of the code access request as a code regression request by comparing a position dependent data segment from the code access request against a plurality of code access request types stored in a secure code type memory array; 950820 means for retrieving a code block associated with the code regression request and the code difference file, and means for sequentially reading each portion of 5 the code difference file, locating an associated portion in the retrieved code block for each read portion and substituting the read portion of the code difference file for the associated portion of the retrieved code block,
6. 10 decrementing the version identifier associated with the retrieved code block and storing the code block.
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| IES950820 IES66902B2 (en) | 1995-10-20 | 1995-10-20 | A version control facility |
| GB9522104A GB2306710B (en) | 1995-10-20 | 1995-10-28 | A version control facility |
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| IES950820 IES66902B2 (en) | 1995-10-20 | 1995-10-20 | A version control facility |
| GB9522104A GB2306710B (en) | 1995-10-20 | 1995-10-28 | A version control facility |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| IES950820A2 true IES950820A2 (en) | 1996-02-07 |
| IES66902B2 IES66902B2 (en) | 1996-02-07 |
Family
ID=26308012
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| IES950820 IES66902B2 (en) | 1995-10-20 | 1995-10-20 | A version control facility |
Country Status (2)
| Country | Link |
|---|---|
| GB (1) | GB2306710B (en) |
| IE (1) | IES66902B2 (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| DE29914463U1 (en) * | 1999-08-20 | 2000-09-28 | Siemens Ag | Configuration unit for corresponding diagnostic data records of a system with control unit and operating and / or observation unit, and system with means for comparing the versions of assigned diagnostic data records |
| CN109871310B (en) * | 2017-12-04 | 2023-05-02 | 北京京东尚科信息技术有限公司 | Version quality testing method and device |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5278979A (en) * | 1990-12-20 | 1994-01-11 | International Business Machines Corp. | Version management system using pointers shared by a plurality of versions for indicating active lines of a version |
-
1995
- 1995-10-20 IE IES950820 patent/IES66902B2/en not_active IP Right Cessation
- 1995-10-28 GB GB9522104A patent/GB2306710B/en not_active Expired - Lifetime
Also Published As
| Publication number | Publication date |
|---|---|
| GB9522104D0 (en) | 1996-01-03 |
| GB2306710A (en) | 1997-05-07 |
| GB2306710B (en) | 2000-03-15 |
| IES66902B2 (en) | 1996-02-07 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8117219B2 (en) | Generation of updatable anonymized data records for testing and developing purposes | |
| US6314460B1 (en) | Method and apparatus for analyzing a storage network based on incomplete information from multiple respective controllers | |
| US6289375B1 (en) | Method and apparatus for invoking network agent functions using a hash table | |
| US6253240B1 (en) | Method for producing a coherent view of storage network by a storage network manager using data storage device configuration obtained from data storage devices | |
| US5832511A (en) | Workgroup network manager for controlling the operation of workstations within the computer network | |
| US6237144B1 (en) | Use of relational databases for software installation | |
| US7076496B1 (en) | Method and system for server based software product release version tracking | |
| US7539680B2 (en) | Revision control for database of evolved design | |
| US20050114338A1 (en) | System and method for determining file system data integrity | |
| US7409388B2 (en) | Generation of anonymized data records for testing and developing applications | |
| US20060059149A1 (en) | Generation of anonymized data records from productive application data | |
| US20070033370A1 (en) | Continuous data protection | |
| KR20060054026A (en) | Method to chain events in a system event log | |
| JP2001512272A (en) | Computerized system and associated method for optimal control of storage and transfer of computer programs over a computer network | |
| US20080282355A1 (en) | Document container data structure and methods thereof | |
| CN112667240A (en) | Program code conversion method and related device | |
| CN112860777B (en) | Data processing method, device and equipment | |
| US6981031B2 (en) | Language independent message management for multi-node application systems | |
| US7415480B2 (en) | System and method for providing programming-language-independent access to file system content | |
| US7548979B2 (en) | Method, system, and computer-readable medium for managing a host session on a remote computer | |
| US20020078205A1 (en) | Resource control facility | |
| CN102792281A (en) | Storage device | |
| IES950820A2 (en) | A version control facility | |
| US8589303B2 (en) | Asset management apparatus and asset management method | |
| US20060053479A1 (en) | Accessing a data item in a memory of a computer system |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| MM4A | Patent lapsed |