GB2306710A - Software version control facility - Google Patents
Software version control facility Download PDFInfo
- Publication number
- GB2306710A GB2306710A GB9522104A GB9522104A GB2306710A GB 2306710 A GB2306710 A GB 2306710A GB 9522104 A GB9522104 A GB 9522104A GB 9522104 A GB9522104 A GB 9522104A GB 2306710 A GB2306710 A GB 2306710A
- Authority
- GB
- United Kingdom
- Prior art keywords
- code
- access request
- code block
- central
- codestore
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
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 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, access is maintained to previously developed versions of the software or the developers without placing excessive demands on a central codestore. The facility uses : comparisons of code type, user and version identifiers; replacement blocks which substitute in the central codestore for blocks removed for development (indicating removal, and giving removing user identity, code type and time stamp); write protection bits; and inter-version difference files.
Description
"A version control facility"
INTRODUCTION
The present invention relates to a version control facility for 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.
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 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 a single developmental language and shared library resources.
Similarly, United Kingdom Patent No. GB 2264575 B describes a method for 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 codes tore 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.
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.
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 codes tore 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 the return code block, storing the return code block in the central codes tore, 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
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 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.
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 codes tore 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 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 codes tore 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;;
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 codes tore connected to a number of local servers by host connections. The local servers, in this case provided by PC servers, micro-VAXw / VAXw 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 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 codes tore and the code type A extracted in step 11 and the user identifier B 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 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 the code.
Accordingly, the storage requirements on the central 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.
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 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 codes tore 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 is achieved while minimising the memory requirements on the central codes tore 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 (14)
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.
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.
3. A version control facility as claimed in claim 2
wherein the time stamp has a time indicator and
date indicator referring to the physical time
and date when the code block was transmitted.
4. A version control facility as claimed in any
preceding claim 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.
5. A version control facility as claimed in any of
claims 2 to 4 wherein 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.
6. A version control facility as claimed in claim 5
including 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.
7. A version control facility as claimed in claim 5
or claim 6 including 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.
8. A version control facility as claimed in claim 6
or claim 7 including
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
with the retrieved code block and storing the
code block.
9. A version control facility as claimed in claim 8
including means for sequentially processing a
plurality of a code regression request from a
development workstation.
10. A version control facility as claimed in any
preceding claim including
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.
11. 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 codes tore
associated with a validated code access request
from a development workstation and transmitting
the replacement code block to the development
workstation.
12. 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
codes tore 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
and user identifier stored in the replacement
code block.
13. 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; ;
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.
14. A version control facility substantially as
hereinbefore described with reference to the
accompanying drawings.
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| IES950820 IES950820A2 (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 IES950820A2 (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 (3)
| Publication Number | Publication Date |
|---|---|
| GB9522104D0 GB9522104D0 (en) | 1996-01-03 |
| GB2306710A true GB2306710A (en) | 1997-05-07 |
| GB2306710B GB2306710B (en) | 2000-03-15 |
Family
ID=26308012
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| GB9522104A Expired - Lifetime GB2306710B (en) | 1995-10-20 | 1995-10-28 | A version control facility |
Country Status (2)
| Country | Link |
|---|---|
| GB (1) | GB2306710B (en) |
| IE (1) | IES950820A2 (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP1079289A2 (en) * | 1999-08-20 | 2001-02-28 | Siemens Aktiengesellschaft | Projection unit for corresponding blocks of diagnose data of a system with a control unit and command- and/or monitoring-unit and system with means for comparison of versions of blocks of diagnose data |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109871310B (en) * | 2017-12-04 | 2023-05-02 | 北京京东尚科信息技术有限公司 | Version quality testing method and device |
Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP0492071A2 (en) * | 1990-12-20 | 1992-07-01 | International Business Machines Corporation | Method and apparatus for providing single entity version management for source data |
-
1995
- 1995-10-20 IE IES950820 patent/IES950820A2/en not_active IP Right Cessation
- 1995-10-28 GB GB9522104A patent/GB2306710B/en not_active Expired - Lifetime
Patent Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP0492071A2 (en) * | 1990-12-20 | 1992-07-01 | International Business Machines Corporation | Method and apparatus for providing single entity version management for source data |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP1079289A2 (en) * | 1999-08-20 | 2001-02-28 | Siemens Aktiengesellschaft | Projection unit for corresponding blocks of diagnose data of a system with a control unit and command- and/or monitoring-unit and system with means for comparison of versions of blocks of diagnose data |
| EP1079289A3 (en) * | 1999-08-20 | 2003-12-10 | Siemens Aktiengesellschaft | Projection unit for corresponding blocks of diagnose data of a system with a control unit and command- and/or monitoring-unit and system with means for comparison of versions of blocks of diagnose data |
Also Published As
| Publication number | Publication date |
|---|---|
| IES66902B2 (en) | 1996-02-07 |
| GB9522104D0 (en) | 1996-01-03 |
| IES950820A2 (en) | 1996-02-07 |
| GB2306710B (en) | 2000-03-15 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8117219B2 (en) | Generation of updatable anonymized data records for testing and developing purposes | |
| US5832511A (en) | Workgroup network manager for controlling the operation of workstations within the computer network | |
| KR100655124B1 (en) | Software installation and testing system for a built-to-order computer system | |
| US5627967A (en) | Automated generation on file access control system commands in a data processing system with front end processing of a master list | |
| US6314460B1 (en) | Method and apparatus for analyzing a storage network based on incomplete information from multiple respective controllers | |
| US7539680B2 (en) | Revision control for database of evolved design | |
| US7653647B2 (en) | System and method for determining file system data integrity | |
| US6237144B1 (en) | Use of relational databases for software installation | |
| US8667459B2 (en) | Application specific runtime environments | |
| 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 | |
| US5623661A (en) | System for and method of providing delta-versioning of the contents of PCTE file objects | |
| US7076496B1 (en) | Method and system for server based software product release version tracking | |
| US10621211B2 (en) | Language tag management on international data storage | |
| US7194475B2 (en) | Method, system, and program for performing an impact analysis of program statements in at least one source code file | |
| US7409388B2 (en) | Generation of anonymized data records for testing and developing applications | |
| US20060059149A1 (en) | Generation of anonymized data records from productive application data | |
| JP2009515264A (en) | Method and system for control of documents and source code | |
| US20070033370A1 (en) | Continuous data protection | |
| CN101772764A (en) | Multi-threaded business programming library | |
| CN111638908A (en) | Interface document generation method and device, electronic equipment and medium | |
| CN112667240A (en) | Program code conversion method and related device | |
| CN112214221B (en) | Method and equipment for constructing Linux system | |
| US20020078205A1 (en) | Resource control facility | |
| US7634521B1 (en) | Technique for scanning stealthed, locked, and encrypted files | |
| GB2306710A (en) | Software version control facility |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PE20 | Patent expired after termination of 20 years |
Expiry date: 20151027 |