Dynamic class packaging

• US 7,076,768 B2
• Filed: 10/31/2001
• Issued: 07/11/2006
• Est. Priority Date: 10/31/2001
• Status: Expired due to Fees

• Current Assignee: Seiko Epson Corporation (Seiko Group)
• Original Assignee: Seiko Epson Corporation (Seiko Group)
• Inventors: Chan, Brian, Li, Chia-Hsin
• Primary Examiner(s): Vo, Ted T.
• Application Number:
  US10/001,085
• Publication Number:
  US 20030101445A1
• Time in Patent Office: 1,714 Days
• Field of Search: 717110-121, 717124-133, 717154-157, 717/172, 717/177, 717/144, 717/166, 717/178
• US Class Current: 717/132
• CPC Class Codes: G06F 9/44521 Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading

Abstract

Methods and computer readable media for a software tool capable of subdividing programs into autonomous modules, where the modules enable a feature of the program, are provided. One exemplary method includes a computer implemented method for identifying modules of an executable program. The method begins with initiating the executable program. Then, the executable program is monitored as it is running. The monitoring of the executable program further includes, identifying interrelated classes for each of the modules where each of the modules correspond to a feature functionality of the executable program. Also included in the monitoring is generating a data structure for each module as the executable program is running. Here, the data structure defines the classes for each feature functionality.

Claims

1. A computer implemented method for identifying modules of an executable program, comprising:

initiating the executable program; and

monitoring the executable program as the executable program is running, the monitoring further including;

identifying a core module providing a software engine of said executable program;

identifying autonomous function modules, each corresponding to an optional function of the executable program not available in said core module;

identifying interrelated classes used during execution of each of said modules,

wherein the full functionality of said executable program is defined by a cumulative contribution of all of said modules; and

subdividing said executable program into said core module and said autonomous function modules.

2. The method as recited in claim 1, further including generating a data structure for each module as the executable program is running, the data structure defining the classes for each module.

3. The method as recited in claim 1, wherein the monitoring the executable program further includes:

recording the interrelated classes in a set and generating a data structure for each module; and

storing the data structure.

4. The method as recited in claim 3, wherein the data structure is stored on a networked source server.

5. The method as recited in claim 1, wherein the monitoring the executable program further includes:

combining the classes common to two or more modules into a separate module.

6. A method for creating class graphs, the class graphs identifying how modules of an executable program use classes of the executable program, the method comprising:

monitoring the executable program as the program is being run;

identifying each class associated with a core module, the core module configured to run an engine of the program;

executing each task associated with the program while the program is being monitored;

identifying task functions not part of said core module, and separating each of said task functions into separate autonomous modules, wherein the full functionality of said executable program is defined by a cumulative contribution of all of said modules;

recording each class used in the execution of each task and associating each identified class with the task'"'"'s corresponding module;

subdividing said executable program into said core module and said autonomous modules; and

defining a class graph for the core module and each autonomous module, wherein each class graph defines a class interaction within the core module and each autonomous module.

7. The method as recited in claim 6, wherein the executing each task further includes:

requesting each class associated with the each task.

8. The method as recited in claim 7, wherein the requested class is loaded from a file system.

9. The method as recited in claim 6, wherein the executable program is a printing application.

10. A method for subdividing an executable program comprising:

executing the program;

monitoring the execution of the program;

identifying a core module providing a software engine of said executable program;

identifying autonomous function modules, each corresponding to an optional function of the executable program not available in said core module;

maintaining a record of classes used during execution of each task within each module; and

defining a class graph for each of the modules, the class graph representing an interaction of classes associated with each of the modules.

11. The method as recited in claim 10, wherein the maintaining a record of classes further includes:

loading the classes through a class loader;

recording the loaded classes; and

returning the classes to a Virtual Machine.

12. The method as recited in claim 11, further including:

detecting an endpoint at which all the classes for each of the modules has been loaded.

13. The method as recited in claim 10, wherein each optional function is a selectable option within said core module but not executable within said core module, and wherein.

14. The method as recited in claim 10, wherein the record of classes of each task is stored in as a zip file.

15. The method as recited in claim 10, wherein each module is associated with a zip file.

16. The method as recited in claim 13, wherein the maintaining a record of classes used during execution of each task further includes:

identifying classes common to multiple modules; and

locating the identified classes common to multiple modules in the core module.

17. A method for developing a software product for an application, the application having a plurality of features, wherein each of the features is associated with at least one class, the method comprising:

identifying each class of the application;

executing each of the features of the application;

identifying each class associated with each of the features and collecting the identified classes associated with each feature into separate autonomous function modules;

wherein each function module is operable to execute its associated feature;

subdividing the application into said autonomous function modules, wherein the full functionality of said executable program is defined by a cumulative contribution of all of said modules.

18. The method as recited in claim 17, wherein one module is a core module containing a main class with an entry point for the application.

19. The method as recited in claim 17, wherein defining a module for each of the features further includes:

storing each class for the module in a set.

20. The method as recited in claim 19, wherein the modules are stored as separate zip files on a networked source server, the zip files configured to be individually downloaded over a network upon a request from a Virtual Machine.

21. The method as recited in claim 20, wherein the downloading over a network is initiated by one of on demand from a user, a predictive download and a methodical background download.

22. A method for generating a autonomous module for partial functionality of an application program, the method comprising:

initiating the application program;

selecting a functional task for execution;

requesting a class loader to load classes associated with said functional task;

monitoring the class loader to identify each class loaded for execution of said functional task;

collecting all identified classes into said autonomous module;

recording each class of the autonomous module;

detecting an endpoint at which all the classes associated with the functional task have been loaded and included in said autonomous module; and

establishing said autonomous module as a stand alone functional module for execution of the selected functional task.

23. The method as recited in claim 22, wherein a Virtual Machine requests the class loader.

24. The method as recited in claim 22, wherein each class of the module is recorded in one of a class and a vector.

25. The method as recited in claim 22, further including:

returning the recorded class to a Virtual Machine.

26. The method as recited in claim 22, wherein the application program provides functionality for a printer.

27. A computer storage medium having program instructions for creating class graphs, the class graphs identifying how modules of an executable program use classes of the executable program, the computer readable media comprising:

program instructions for monitoring the executable program as the program is being run;

program instructions for identifying each class associated with a core module, the core module configured to run an engine of the program;

program instructions for executing each task associated with the program while the program is being monitored;

program instructions for recording each class used in the execution of each task and collecting the recorded classes into autonomous function modules corresponding to separate ones of each task associated with the program and not available in said core module; and

program instructions for defining a class graph for the core module and each autonomous functional module, wherein each class graph defines a class interaction within the core module and each autonomous functional module.

28. The computer storage medium as recited in claim 27, wherein the program instructions for recording each class further includes:

program instruction for detecting an endpoint at which all the classes for the core module have been loaded.

29. The computer storage medium as recited in claim 27, wherein the full functionality of said executable program is defined by a cumulative contribution of all of said modules;

and said computer readable media further including;

program instructions for generating a subdivided representation of said executable program, wherein the subdivided representation consists of a collection of said core module and said autonomous function modules.

30. The computer storage medium as recited in claim 29, wherein the core module and the autonomous function modules are independently downloadable over a distributed network.