WO2002065228A2

WO2002065228A2 - Distributed computing system

Info

Publication number: WO2002065228A2
Application number: PCT/IB2002/000508
Authority: WO
Inventors: Alfred B. Thordarson
Original assignee: Lux Inflecta Ehf
Priority date: 2001-02-13
Filing date: 2002-02-13
Publication date: 2002-08-22
Also published as: GB2372119A; WO2002065228A3; AU2002230047A8; AU2002230047A1; GB0103512D0

Abstract

A distributed computing system is provided in which developer computers (100) have stored within their memories an extended class loader (102) and a virtual machine program (12). When an application is run utilising the virtual machine program (12) the virtual machine program (12) causes the extended class loader (102) to be activated whenever a reference to a class is to be processed. The extended class loader (102) initially determines whether the referenced class is stored in the memory of the developer computer (100) and if this is not the case, interrupts processing to download an archive file (9.1-9.n) including the referenced class prior to continuing processing.

Description

DISTRIBUTED COMPUTING SYSTEM

The present application concerns distributed computing systems. In particular, the present application concerns

distributed computer systems where a library of computer

programs are stored on a server and individual programs are downloaded on request to a client computer where they are executed.

It is well known within distributed computer systems to provide a library of linked functional programs which are stored on a server and can be downloaded upon request to a client computer. Once a complete functional program has been downloaded, the program can be executed. By including within functional programs fixed calls to other functional programs in the library a client computer is made to request the download of further programs in the

library when the fixed calls are executed. The functional programs can therefore be arranged to be downloaded as they are needed. By dividing large application programs into a number of separate linked functioning programs, it is possible to reduce the delay inherent in downloading large

applications as individual functional programs can be requested, downloaded and executed separately from one

another. Furthermore, dividing large applications in this way also enables such large applications to be

executed on computers having limited data storage capacities as the individual functional programs only need to be downloaded when such functions are to be executed.

Although providing large applications in the form of linked functional programs does reduce the delays between requesting downloading an application from a remote computer and being able to execute some of the

functionality of an application, and also enables client computers of limited storage capacity to execute large application programs, it is desirable to provide distributed computing systems in which these delays are further reduced and in which large application programs may be executed on client computers with even smaller data storage capacity.

Embodiments of the present invention provide a computer system in which incomplete sub-divisions of functional

modules of large application programs can be executed and processed by client computers.

In accordance with one aspect of the present invention there is provided computer apparatus comprising:

processing means for executing a computer program comprising instantiation data of defined classes; and data storage means for storing data programs comprising instantiation data of defined classes; characterized by forwarding means for causing a

request to execute a portion of program for which instantiation data is not stored within said data storage means to be passed to a remote computer to request said remote computer to dispatch instantiation data to facilitate the execution of said program; and

receiving means for receiving instantiation data requested by said forwarding means, storing said instantiation data in said storage means and reinitiating processing by said processing means.

Further aspects and embodiments of the present invention

will become apparent in light of the following description with reference to the accompanying drawings

in which:

Figure 1 is a schematic block diagram of a computer network in a first embodiment of the present invention;

Figure 2 is a schematic block diagram of the computer modules of a class loader extension program of Figure 1;

Figure 3 is a schematic block diagram of the data structure for the configuration file of Figure 1;

Figure 4 is a schematic block diagram of class records stored within the application index of Figure 1;

Figures 5, 6 and 7 are flow diagrams of the processing of the client computer of Figure 1; Figure 8 is a flow diagram of the processing of the logic server of Figure 1 ;

Figure 9 is a schematic block diagram of a second embodiment of the present invention; and

Figure 10 is a flow diagram of the processing of a

virtual machine program and extended class loader of a second embodiment of the present invention.

First Embodiment

A first embodiment of the present invention will now be described with reference to Figure 1 which is a schematic block diagram of a computer network arranged to execute programs written in JAVA (TM). In accordance with this

embodiment, a client computer 1, web server 3 and logic server 5 are provided connected to each other by the Internet 7. Also connected to the logic server 5 by a dedicated high speed link is an applications database 8

which stores a number of JAVA Archive files 9.1-9.n.

Provided within the memory of the client computer 1 is a conventional browser program 10 such as Microsoft

Explorer (TM) and a conventional virtual machine program

12 such as JVM from Sun Microsystems. The memory of the

client computer 1 also has allocated memory for data

storage 13. The browser program 10 enables the client computer 1 to request and download via the Internet 7

JAVA applet programs which are stored within the data

storage portion of the memory 13. After a JAVA applet program has been stored within the memory 13 the virtual machine program 12 is able to process the stored JAVA applet programs. In practice, many more client computers 1 would be included in the network each of the client computers storing a browser program 10 and virtual machine program 12 enabling the client computers 1 to download and execute JAVA applet programs.

In accordance with this embodiment of the present invention the web server 3 has stored within its memory a class loader extension program 14 arranged to modify the conventional virtual machine program 12 of a client computer 1. This modification then enables the virtual machine program 12 to process incomplete functional computer programs stored within the data storage portion

13 of the memory of the client computer 1. By enabling

the virtual machine program 12 to process such incomplete functional computer programs, the class loader extension program 14 reduces delays in processing, as the virtual

machine program 12 can initiate processing as soon as an incomplete functional computer module has been downloaded

and no longer needs to wait until a complete JAVA applet has been downloaded before initializing processing.

Furthermore, as only incomplete functional computer modules are received and processed, the memory of the client computer 1 is only required to provide data storage 13 for such incomplete functional modules and hence the requirements for data storage 13 are reduced.

Specifically, stored within the memory of the web server

3 is a class loader extension program 14 and configuration file 16. In this embodiment of the present invention the class loader extension program 14 is a JAVA applet program. Utilizing the browser 10 the class loader extension program 14 and configuration file 16 stored on the web server 3 can be downloaded via the Internet 7 into the data storage portion of the memory

13 of the client computer 1. When a copy of the class loader extension program 14 is stored within the data

storage portion 13 of the memory of the client computer 1, the stored class loader extension program 14 then

extends the class loader of the virtual machine program

12 of the client computer 1. This extension is such to add an additional class loader to the class loader chain such that whenever the conventional class loader of the virtual machine program 12 attempts to utilize a class which is not stored in the data storage portion of the memory 13 of the client computer 1, a request to download an appropriate JAVA Archive file 9.1-9.n is sent to the logic server 5. The JAVA Archive file 9.1-9.n is then copied into the memory 13 of the client computer 1 before

processing continues.

The applicants have appreciated that in a computer system processing an object oriented language such as JAVA, where each individual class instantiation comprises a named collection of fields that hold data values and methods that operate on those values, although individual class instantiations refer to other class instantiations, the processing by a virtual machine program 12 of each

individual class instantiation can be separated from

processing of all other classes.

Specifically, whenever a reference is made from one class instantiation to another, such a reference passes through a class loader within the virtual machine program 12 to cause the referred class to be processed. The applicants therefore appreciated that a virtual machine program 12 can be modified to process incomplete functional programs by modifying the virtual machine program 12 class loader

so that it converts references to classes not present on a client computer 1 into requests to download further JAVA Archive files 9.1-9.n including the referenced classes. When a copy of a requested JAVA Archive file

9.1-9.n is then stored within the data storage portion of the memory 13 of the client computer 1, the modified class loader then reinitiates the processing of the referenced class. As the data required to define an individual class instantiation is normally a relatively small JAVA Archive file, individual JAVA Archive files which are transmitted via the Internet 7 can be downloaded relatively quickly

and delays waiting the download of a complete program can

therefore be avoided.

Furthermore, where the structure of a particular program is such that one class instantiation refers to a large number of other classes which inevitably are to be processed, instead of merely dispatching a JAVA Archive file 9.1-9.n comprising data for a single class instantiation, data for a group of associated class instantiations may instead be included within a single JAVA Archive file 9.1-9.n. By grouping data for class instantiations in this way repeated requests for extra

JAVA Archive files from the applications database 8 may be avoided and the processing of the system can be made more efficient.

In order to facilitate and monitor the downloading of JAVA Archive files 9.1-9.n by a client computer 1, in this embodiment the logic server 5 has stored within its memory an application logic program 18 for processing requests received from a class loader extension program

14 and a user log 20 for generating a record of such requests. The applications database 9 has also stored within it its memory an application index 22. Together

as will be described in detail later, the application

index 22 and application logic 18 enable the logic server

5 to cause copies of selected JAVA Archive files 9.1-9.n to be transmitted to a client computer 1 on request.

Before describing in detail the processing of the client computer 1 and the logic server 5, the modules of a class loader extension program 14 and data structures for the configuration file 16 and application index 22 will now

be described in detail with reference to Figures 2, 3 and 4.

Figure 2 is a schematic block diagram of the modules of a class loader extension program 14. in accordance with this embodiment of the present invention. The class loader extension program 14 in this embodiment, comprises a class boot module 30 being a JAVA applet for causing the virtual machine program 12 of a client computer 1 to request the downloading of configuration file 16 stored

on the web server 3; an extended class loader being a JAVA applet extending the functionality of the standard

class loader included within the virtual machine program

12 of a client computer 1 so that the virtual machine program 12 is able to process partial programs; and a user log in module 34 being a JAVA applet for obtaining and dispatching user details to a logic server 5 in response to user inputs into the client computer 1.

As will be described in detail later, initially when a class loader extension program 14 is downloaded from the web server 3 into the data storage portion of the memory

13 of a client computer 1 this causes the class boot

program 30 to request the download of configuration file 16 from the web server 3. When a copy of the configuration file 16 has been downloaded into the data storage portion of the memory 13, the user login module 34 of the class loader extension program 14 is then invoked to cause a user interface to be displayed to a user prompting the user enter user details into the client computer 1. These details are then transmitted from the client computer 1 via the Internet 7 to the

logic server 5 where they are stored within the user log

20.

In response to receiving these user details, the logic server 5 then outputs for storage on the client computer 1 a selected initial JAVA Archive file for the JAVA application to be processed by the virtual machine program 12. Subsequently when the received, JAVA Archive file is processed, if a reference to a class is determined to refer to a class for which no class instantiation is stored within the data storage portion of the memory 13 of the client computer 1, the extended class loader 32 then causes further JAVA Archive files to be requested and stored within the data storage

portion of the memory 13 so that processing may be continue .

Figure 3 is a schematic block diagram of the data structure for configuration file 16 stored on a web server 3. In this embodiment the configuration file 16 comprises a set of protocol libraries 40 being a JAVA

Archive file containing class definitions for basic

functions to be performed as part of a JAVA application. The protocol libraries 40 in this embodiment comprise data defining communications protocols enabling the

client computer 1 to generate and despatch instructions

via the Internet 7 to the logic server 5, which can be processed by the logic server 5. Additional in this embodiment the protocol libraries also comprise class instantiations for fundamental processes utilized in typical JAVA program such as libraries for generating windows and buttons as part of the display of user interfaces. The configuration file 16 also comprises an address pointer 42 being a network address for the logic server 5 for accessing the logic server 5 via the

Internet 7 and a main class pointer 44 identifying an initial class to be requested from the logic server 5

when a particular application is to be downloaded from the logic server 5 via the Internet 7.

In this embodiment the configuration file 16 provides the means by which a client computer 1 is able to initiate the processing of a particular program. Specifically, by downloading and storing the copies of the protocol libraries 40 included within the configuration file 16,

when the configuration file 16 is stored within the data

storage portion of the memory 13 of the client computer

1 basic functionality for running any JAVA programs is

provided within the client computer 1. The address pointer 42 and main class pointer 44 then enable the extended class loader 32 to send a specific initial request to the logic server 5 so that further JAVA Archive files forming an initial part of a specified program may be requested and downloaded into the data storage portion of the memory 13 of the client computer. When these initial portions of a program are downloaded these are then processed by the virtual machine program 12 of the client computer 1.

Figure 4 is a schematic block diagram of the application index 22 stored within an application database 8 in accordance with this embodiment of the present invention.

The application index 22 in this embodiment comprises a number of class records 50. Specifically, in this embodiment the application index 22 has a class record

50 for each of the individual class instantiations for

which class instantiation data is stored as part of any of the JAVA Archive files 9.1-9.n stored within the

applications database 8. These class records 50 each

comprise class name data 52 being data identifying the name of a class instantiation, JAR name data 54 being data indicative of the JAVA Archive file 9.1-9.n which includes the instantiation data for the class identified by the class name data 52 of the record 50 and a date of storage 56 being the time and date at which the JAVA Archive 9.1-9.n identified by the JAR name data 54 of the record was stored.

As will be described in detail later when the logic

server 5 receives a request to output data from extended class loader 32, the request includes data identifying

a class instantiation to be processed which is not currently stored within the memory 13 of the client computer. In response to receiving such a request, the application logic program 18 utilizes the class records 50 of the application index 22 to identify a JAVA Archive file 9.1-9.n which includes instantiation data for the class included in the request. The application logic program 18 then causes a copy of a JAVA Archive file 9.1- 9.n including the class instantiation to be to be

transmitted via the Internet 7 to the client computer 1.

In this way by storing either individual class instantiations as separate JAVA Archive files 9.1-9.n or

storing groups of class instantiations which are related to one another as JAVA Archive files 9.1-9.n, the logic server 5 and application database 8 are able to cause required class instantiations to be dispatched and stored within the data storage portion of the memory 13 of a client computer 1, whenever such class instantiations are

requested.

In this embodiment, where a requested class instantiation is liable to be processed largely separately from another class instantiations or where many different groups of class instantiations refer to a single other class instantiation, that class instantiation data is stored as an individual separate JAVA Archive file 9.1-9.n. As the JAVA Archive file 9.1-9.n contains data for only a single class application, the size of the JAVA Archive file 9.1-9.n is minimised. Thus when the JAVA Archive

file is requested the amount of time required to download the JAVA Archive file into the data storage portion of the memory 13 of the client computer 1 is kept to a

minimum.

In contrast, where the processing of a requested class instantiation is very likely to result in the requested processing specific other class instantiations, a number of related class instantiations are included in the same

JAVA Archive file 9.1-9.n. Thus in response to a single request for one class instantiation, a JAVA Archive file 9.1-9.n including the requested class instantiation and the other class instantiation which are likely to be requested for processing is dispatched. Storing the

different class instantiations in this manner therefore makes it possible to preempt request for further class instantiations. In this way, the number of data request dispatched via the Internet 7 to a logic server 5 is reduced where it is known in advance a number of class instantiations which relate to one another are required by a client computer 1.

The application index 22 enables this conversion of class instantiations into identified JAVA Archive files to

occur. Specifically, as will be described in detail later whenever a request for a class instantiation is

received by the logic server 5, the class instantiation data is matched to class name data 52 in a class record 50. A copy of the JAVA Archive 9.1-9.n stored under the JAR name data 54 of that class record 50 is then dispatched in response to the received request.

The processing of a client computer 1 in accordance with this embodiment of the present invention will now be

described in detail with reference to Figures 5, 6 and 7.

Figure 5 is a flow diagram of the processing of a client computer 1 in accordance with this embodiment of the present invention. Initially (SI) the browser program

10 and virtual machine program 12 are utilized to download from the web server 3 a copy of the class loader extension program 14 and the configuration file 16 stored on the web server 3. The downloading of the class loader extension program 14 and the configuration file 16 then

causes the virtual machine program 12 of the client

computer 1 to be modified so that the virtual machine program 12 is able to process individual class

instantiations stored within the data storage portion of the memory 13 of the client computer 1 and request further class instantiations from the logic server 5 when required.

Figure 6 is a flow diagram of the processing of a client computer illustrating in detail the processes involved in an initial download of data from the web server 3 and modification of the virtual machine program 12.

Initially (S20) the processing of the browser program 10 is invoked in a conventional way. Utilizing the browser program 10 a request is then dispatched to the web server 3 to download (S21) a copy of the class boot module 30 of the class loader extension program 14. When a request is dispatched from the client computer 1 , the browser program 10 then waits until data is received from the web server 3 via the Internet 7. When data is received, the data which is a copy of the class boot module 30 is then

stored in the data storage portion of the memory 13 of the client computer 1. The virtual machine program 12

then initiates processing of class boot module 30.

The initiation of processing of the class boot module 30 causes the client computer 1 to request and download a copies of the extended class loader 32 and user login module 34 of the class loader extension program 14 from the web server 3. When copies of the class loader 32 and user login module 34 are received these modules are also stored in the data storage portion of the memory 13 of the client computer 1, the storage of the extended class loader 32 acts to modify (S23) the standard class loader of the virtual machine program 12 so that whenever the standard class loader of the virtual machine program 12 determines that a class instantiation to be processed is not present within the data storage portion of the memory

13 of the client computer 1, processing by the extended class loader 24 is invoked.

After the user login module 34 and extended class loader 32 have been stored in the data storage portion of the

memory 13 of the client computer 1, the class boot program 30 then causes (S25) the browser 10 to dispatch

a further request via the Internet 7 to the web server 3 to download a copy of the configuration file 16 stored

on the web server 3. When a copy of the configuration file is received by the client computer 1 this is also stored in the data storage portion of the memory 13 of the client computer 1. The class boot program 20 then (S27) invokes the user login module 34 stored in the memory of the client computer 1 which causes the client computer 1 to display a user interface prompting a user

to enter user details confirming the identify of the user of the client computer 1.

Once user details have been input, the user login module 34 then proceeds to initiate (S29) the dispatch of a request for class instantiation data corresponding to the main class pointer 44 and input user details by invoking the extended class loader 44 to process such a request.

Returning to Figure 5 after the user details have been

input into the user interface and an initial request for

a class instantiation corresponding to the main class pointer 44 has been initiated (S29), the extended class loader 32 then processes (S3) the request for class

instantiation data as will now be described with reference to Figure 7.

Figure 7 is a flow diagram of the detailed processing (S3) of a class request by the extended class loader.

The extended class loader 34 initially accesses (S30) the logic server 5 via the Internet 7 by outputting a request to the Internet address identified by the address pointer 42 of the configuration file 16 downloaded from the web

server 3. The request output by the extended class loader 32 incorporates data identifying the class being requested. In the case of an initial class request following data input into the user login module 34, the class request comprises a request incorporating data corresponding to the main class pointer 44 of the configuration file 16 downloaded form the web server 3 and a copy of the user details entered into the user interface generated by the user login module 34.

The request is then dispatched via the Internet 7 to the

login server where it is processed. As will be described in detail later the application logic program 18 of the

logic server 5 then processes received requests and causes to be output via the Internet 7 a JAVA Archive file 9.1-9.n selected on the basis of the class instantiation identified in the request sent to the logic server.

When a JAVA Archive file 9.1-9.n is received by the client computer 1 the extended class loader 32 causes (S32) the received JAVA Archive file 9.1-9.n to be stored

within the data storage portion of the memory 13 of the client computer 1. The extended class loader 32 then causes (S34) the class instantiations included within the received JAVA Archive file 9.1-9.n to be instantiated as classes available for processing by the standard class loader of the virtual machine program 12. The extended class loader 32 then causes the standard class loader of the virtual machine program 12 to process the class

identified as part of the request dispatched to the logic server 5.

Returning to Figure 5, after a request has been processed (S3) by the extended class loader 34, the extended class loader 34 returns control to the virtual machine program 12, which then proceeds to utilise the requested class instantiation which is now stored in the memory 13 of the client computer 1.

When processing a class instantiation stored memory by the virtual machine program 12 determines (S5) whether the class instantiation being processed is an instruction to end processing. If this is the case the virtual machine program 12 then stops processing the program stored within the data storage portion of the memory 13.

If this is not the case the virtual machine program 12 then continues (S7) to process the currently selected class instantiation stored in the data storage portion of the memory 13 of the client computer 1.

In the course of processing a currently selected class

instantiation, the virtual machine 12 then determines (S9) whether any new class instantiation is being invoked

as a result of the processing. If this is not the case

the virtual machine program 12 checks once again whether an instruction to end processing (S5) has been received and then continues (S7) to process the currently selected class instantiation.

When the virtual machine program 12 determines (S9) that

in the course of processing the currently selected class instantiation a further class instantiation is requested. The standard class loader portion of the virtual machine program 12 initially (Sll) determines whether the

requested class instantiation corresponds to a class instantiation stored within the data storage portion of the memory 13 of the client computer 1. If this is the case the identified class instantiation is then selected for processing (S13) and the virtual machine program 12 then proceeds to process the newly selected class (S5-

Sll) .

If the standard class loader included within the virtual machine program 12 and determines (Sll) that the request

be processed a new class is a request to process a class which is not currently stored within the data storage

portion of the memory 13 of the client computer, the modification of standard class loader causes the extended class loader 32 to be invoked. The extended class loader 32 then generates (S14) a request to download a JAVA Archive file 9.1-9.n including the requested class instantiation. The generated request is then processed (S3) in the same way in which an initial class request is processed by the client computer 1 as has previously been described.

Thus in this way by modifying the standard class loader

of the virtual machine program 18 to invoke the extended class loader 34 whenever a class to be processed is not already stored in the memory 13 of the client computer 1, the virtual machine program 18 is therefore able to separate processing of individual class instantiations .

The virtual machine program 18, is therefore able to run

programs even when class instantiations referred to by parts of a program are not already stored in the memory of the client computer 1.

The processing of the application logic 18 stored on the logic server 5 will now be described with reference to Figure 8 which is a flow diagram of the processing of the application logic program 18.

Initially (S40) the application logic program 18 waits until a request for a class instantiation is received from a client computer 1 via the Internet 7. When a request for an identified class instantiation is received, the application logic program 18 then (S42) determines whether the request identifies only a class

instantiation required for processing by the client computer 1 or whether the request additionally includes user details entered using the user login module 34 of a class loader extension program 14 stored within the data storage portion of the memory 13 of the client computer 1.

If the request received from the Internet 7 includes user input details, this means that the request received from

the Internet 7 has been generated by the client computer 1 as a result of an initial request generated immediately after the input of user data. If this is the case then

application logic program 18 then proceeds to store the

user details incorporated within the request within the user log 20.

Thus in this way a record of users accessing the application stored in the form of JAVA Archive files 9.1- 9.n in the applications database 8 is generated. The

user log 21 can then be subsequently used for external purposes such as billing for the use of the applications.

After (S42) a record has been made within the user log 20 or if (S40) a request received from the Internet 7 does not include user details, the application logic 18 then (S44) proceeds to match the class instantiation identified by the request to class name data 52 of a class record 50 within the application index 22. When a class record 50 having class name data 52 matching the class instantiation included in the request as is found

the logic server 5 then causes to be dispatched via the Internet 5 to the client computer 1 making the request a copy of the JAVA Archive file 9.1-9.n stored under the

JAR name 54 included in the selected class record 50.

Thus in this way the application logic 18 is able to utilize the class records within the application index 22 to convert a request for a particular class instantiation received from the client computer 1 into a JAVA Archive file name for a JAVA Archive file 9.1-9.n including the requested class instantiation.

Second Embodiment

In the above embodiment a computer system has been described in which a class loader extension program 14

which enables the virtual machine program 12 on a client computer 1 to process incomplete programs is downloaded from a web server 3 via the Internet 7. A second embodiment of the present invention will now be described in which a development tool program arranged to process incomplete programs is pre-stored within a client computer.

Figure 9 is a schematic block diagram of a second

embodiment of the present invention. This embodiment comprises a plurality of developer computers 100 each

having stored within their memories a development tool 101 for editing source code; an extended class loader 102 operable to execute incomplete computer code in a similar manner to the extended class loader 34 of the first embodiment; and a virtual machine program 12.

The client computers 101 are connected to a development server 105 via the Internet 107. Stored within the memory of the development server 105 is a development

logic program 109 similar to the application logic program 18 of the first embodiment. The development server 105 is itself connected via a dedicated high speed link to an applications database 110 identical to the applications database 8 described in the first embodiment, except in addition to an application index 22 and a JAVA Archive files 9.1-9.n, the application database 110 also stores a source index 112 identifying classes and associated source code files; and source code

files 114 comprising source code for the class definitions stored in the JAVA Archive files 9.1-9.n.

In this embodiment of the present invention the

development tool programs 101 and development logic 109 interact to enable a plurality of individual users of the developer computers 100 to co-operate simultaneously on the development of an application program which is stored in the applications database 8 as a number of JAVA Archive files 9.1-9.n.

In use, the development tool 101 in each of the developer computers 100 is able to generate requests to the logic server 105 that the logic server 105 dispatches for storage in the memory of the developer computer 100

individual source code files 114 for class definitions. When a request for the source code corresponding to a particular class definition is received, the development logic 109 utilises the source index 112 to identify source code files 114 corresponding to a particular class. A copy of the identified source code file 114 is then transmitted via the Internet 107 to the developer

computer 100 making the request. When a requested source code file 114 is received by the developer computer 100 the development tool 101 then enables the client computer

to modify the requested source code file 114.

When a user then wishes to see how the modified class definition interacts with the rest of the application stored as JAVA Archive files 9.1-9.n on the application database 8, the development tool 101 then dispatches a copy of the modified source code to the logic server 105 via the Internet 107. When the modified source code is received by the development server 105, the development logic 109 stores the modified source code in place of the previously stored source code 114 for that class

definition. The development logic then compiles the modified source code and stores the result of the compilation as part of the JAVA Archive file 9.1-9.n identified by the application index 22 as including the class corresponding to the class identified by the modified source code 114.

The development logic 109 then stores a new class record

50 in the applications index 22 of the applications database 8, the class record 50 comprising: name of class

instantiation included in the modified JAVA Archive file

as a class name 52, the file name of the modified JAVA Archive file as a JAR name and the current time and date.

When a modified application is to be run, in this embodiment, the extended class loader 102 is invoked and acts in a similar way to the extended class loader 32 of the first embodiment. However, in this embodiment the class loader 102 is arranged to ensure that the developer

computer 100 always executes the latest version of class definitions stored on the applications database 110.

Figure 10 is a flow diagram of the processing of the virtual machine program 112 and extended class loader 102 of this embodiment. Initially (S51) the virtual machine program 12 determines whether a reference to a class is to be processed. If this is not the case the virtual machine programme 12 continues to process the current class in the same as has been described in the previous

embodiment (S52-S53 ) .

When (S51) it is determined by the virtual machine

program 12 that a class has been called the extended

class loader 102 then (S54) determines in a similar way

to the extended class loader 32 of the previous embodiment whether the requested class is stored within the memory of the developer computer 100. If this is not the case a class request is generated (S55) in a similar manner as has previously been described.

If a class is determined to be stored within the memory of the developer computer 100, the extended class loader 102, in this embodiment then (S57) determines whether the

class being called is included within a list of classes which have been executed or downloaded whilst running the

application being developed during the current run of the application. If the class does appear on the list the extended class loader then causes the virtual machine program 12 to utilise the stored class (S59) the same was as has previously been described.

If, however, the extended class loader 102 determines

that the requested class has not been executed or downloaded during the current session, the class loader

102 then determines whether the class stored within the memory of the developer computer 100 corresponds to the

latest version of the class stored as a JAVA Archive

file 9.1 on the applications database 110.

In this embodiment, this is achieved by the extended class loader 102 dispatching a request via the Internet 107 to the development server 105. The development logic 109 then determines whether the date of storage 56

associated with the class record 50 having a class name 52 responding to the requested class is more recent than

the date of storage associated with the corresponding archive files stored within the memory of the developer

computer 100.

The result of this processing is then returned by the developer server 105 via the Internet 107 to the developer computer 100. If the date of storage of a JAVA

Archive file including the class stored within the memory of developer computer 100 is more recent than the date

of storage 56 associated with the JAVA Archive files stored on the application database 110, the extended

class loader 102 then adds the classes in the JAVA

Archive file to the list for the current session and then

causes the virtual machine program 12 to process (S59) the stored class instantiation.

If, however, the JAVA Archive 9.1-9.n stored on the applications database was stored more recently than the version of a JAVA Archive file including the class stored within the memory of the developer computer, the extended class loader 102 then causes a class request (S55) to be sent to the development server 105 to cause a copy of

the more recent version of the JAVA Archive file including the class to be downloaded via the Internet 107.

After a class request (S55) has been despatched either because a class is determined not to be stored within the memory of the developer computer 100 or the extended class loader 102 determines that the class instantiation stored within the memory of the development computer 100

does not correspond to a JAVA Archive file stored in the applications database 8, a JAVA Archive file is dispatched, received and proces'sed (S56) a similar way

as has been described in the first embodiment. However, additionally, all of the classes identified as being part of a requested JAVA Archive file are in this embodiment added to the list of classes utilised in a current session as corresponding to the latest versions of class instantiation stored on the applications database 110. Thus in this way the extended class loader 102 ensures that the application processed is the most up-to-date version of the application stored on the application database 8.

In the above embodiment a system has been described in

which the extended class loader 102 and development logic 109 determines whether source code for a class has been updated, prior to downloading the latest version of a JAVA Archive including a class. It will be appreciated that an extended class loader could be provided, which automatically generates a request for a JAVA Archive file

for a class instantiation whenever a class is first

requested by a developer computer 100 within an individual session. However, in such a system

significantly more data transmission would be required

compared to a system in which data identifying whether a update has or has not occurred is transmitted prior to making a class request.

Alternatively, a system could be provided in which the development logic 109 of a development server 105

automatically monitors requests from development computers 100 and generates a record of all classes output to an individual development computer 100. Whenever an additional request for data is then received

by the development server 105 the development logic 109 could determine whether any of the previously despatched JAVA Archive files had been updated and if so include such files in response to the development computer 100 request. Although the embodiments of the invention described with reference to the drawings comprise computer apparatus and processes performed in computer apparatus, the invention also extends to computer programs, particularly computer programs on or in a carrier, adapted for putting the invention into practice. The program may be in the form of source or object code or in any other form suitable for use in the implementation of the processes according to the invention. The carrier be any entity or device capable of carrying the program.

For example, the carrier may comprise a storage medium, such as a ROM, for example a CD ROM or a semiconductor ROM, or a magnetic recording medium, for example a floppy disc or hard disk. Further, the carrier may be a transmissible carrier such as an electrical or optical signal which may be conveyed via electrical or optical cable or by radio or other means .

When a program is embodied in a signal which may be conveyed directly by a cable or other device or means, the carrier may be constituted by such cable or other device or means.

Alternatively, the carrier may be an integrated circuit in which the program is embedded, the integrated circuit being adapted for performing, or for use in the performance of, the relevant processes.

Claims

1. A computer network comprising: a client computer comprising a class loader for

processing class definitions defining data structures, processes to be performed on data and references to other

class definitions; a server storing a plurality of class definitions

defining data structures, processes to be performed on data and references to other class definitions; and transmission means operable to transmit data between said client computer and said server wherein said class loader is operable to process class definitions stored on said client computer and prior to processing references determined not to be stored on said client computer: to request said server to dispatch data including said class definition to be processed; to store on said client computer data received from

said server including said class definition; and to reinitiate processing of a said reference after data including said class definition to be processed has been stored on said client computer.

2. A computer network in accordance with claim 1, wherein said server is arranged to store data defining groups of class definitions and said server is arranged upon receipt of a request from said client computer to output data comprising a selected group of class

definitions including the class definition requested for

processing.

3. A computer network in accordance with claim 2, wherein said groups of class definitions comprise class definitions containing references to other class definitions within said group.

4. A computer network in accordance with any preceding claim, wherein said server is arranged to associate each

class definition with times at which said class definition has been dispatched to a client computer and associate each of said plurality of class definitions with data indicative of a storage date, wherein said server is arranged to dispatch in response to a request from a client computer data including class definitions associated with storage dates later than the most recent times of dispatch associated with said class definitions.

5. A computer network in accordance with claim 4 ,

wherein said client computer further comprises: means for generating source code requests;

means for receiving source code for class

definitions; and means for editing source code received by said

receiving means and outputting edited source code to said server; and wherein said server further comprises means for outputting in response to source code requests from a

client computer source code for class definition stored in said server; and means for compiling received edited source code and storing said compiled source code as a class definition

defining data structures, processes to be performed on data and references to other class definitions..

6. A computer network in accordance with any preceding claim, wherein said computer network comprises a plurality of said client computers each comprising class loaders for processing class definitions defining data structures, processes to be performed on data and references to other class definitions, wherein said

server is arranged to record requests received from said

client computers.

7. A client computer comprising:

data storage means for storing class definitions defining data structures, processes to be performed on data and references to other class definitions; and a class loader for processing stored class definitions, wherein said class loader is operable to determine whether a reference to a class definition to be processed corresponds to a class definition stored in said data storage means and if a said reference does not correspond to a class definition stored on said data

storage means: to request a remote computer to dispatch data including said class definition to be processed; and to reinitiate processing of a said reference after data including said class definition to be processed has been received from said remote computer and stored in said data storage means.

8. A method of executing a computer program on a first computer, wherein said computer program comprises a

plurality of class definitions defining data structures, processes to be performed on data and references to other

class definitions, at least some of said class definitions being stored on a second computer remote from said first computer, the method comprising the steps of: providing on said first computer a class loader for processing references to class definitions stored on said first computer;

storing at least one class definition on said first computer; determining when processing a class definition utilizing said class loader, whether a reference to

another class definition to be processed corresponds to a class definition stored on said first computer and if this is not the case prior to processing said reference: requesting data including said class definition to be dispatched from said second computer; storing on said first computer data including said

class definition to be processed received from said second computer; and reinitiating the processing of said reference after

said data including said class definition has been stored on said first computer.

9. A storage medium storing computer implementable

instructions for generating within a programmable computer a class loader for processing class definitions defining data structures processes to be performed on data and references to other class definitions, wherein said class loader is operable to process locally stored

class definitions and prior to processing references determined not to correspond to locally stored class definitions: to request a remote computer to dispatch data including said class definition to be processed;

to store locally data received from said remote computer including said class definition; and to reinitiate processing of the said reference after data including said class definition to be processed has been stored locally.

10. A storage medium in accordance with claim 9 ,

comprising a disc .

11. A disk in accordance with claim 10, comprising a

magnetic optical or magneto optical disc.

12. A storage medium in accordance with claims 9 to 11,

comprising an electrical signal in a communication network.