Dynamic class packaging

• US 20030101445A1
• Filed: 10/31/2001
• Published: 05/29/2003
• Est. Priority Date: 10/31/2001
• Status: Active Grant

• Current Assignee: Seiko Epson Corporation (Seiko Group)
• Original Assignee: Seiko Epson Corporation (Seiko Group)
• Inventors: Chan, Brian, Li, Chia-Hsin
• Granted Patent: US 7,076,768 B2
• Time in Patent Office: Days
• US Class Current: 717/170
• 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 interrelated classes for each of the modules, each of the modules corresponding to a feature functionality of the executable program; and

generating a data structure for each module as the executable program is running, the data structure defining the classes for each feature functionality.

2. The method as recited in claim 1, wherein one of the modules is a core 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

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;

recording each class used in the execution of each task; and

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

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 into autonomous class modules where each of the modules corresponds with a task, comprising:

executing the program;

monitoring the execution of the program;

maintaining a record of classes used during execution of each task; 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 Java 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 one of the modules is a core module for running an engine of the executable program.

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

defining a module for each the features, each module including a group of classes identified to be associated with particular ones of the features, wherein each module is configured to enable functionality to operate the feature corresponding to the module.

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 module is stored as a zip file on a networked source server, the zip file configured to be downloaded over a network upon a request from a Java 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 module of an application program, the module configured to autonomously run a feature functionality of the application program, the method comprising:

initiating the application program;

requesting a class loader to load a class;

monitoring the class loader as each class of the module is loaded;

recording each class of the module;

detecting an endpoint at which all the classes for the module have been loaded; and

repeating the requesting, the monitoring, the recording and the detecting for remaining modules of the application program.

23. The method as recited in claim 22, wherein a Java 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 Java Virtual Machine.

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

27. A computer readable media 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

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

28. The computer readable media 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 readable media as recited in claim 27 further including:

program instructions for identifying each class associated with non-core modules, the non-core modules configured to allow a user access to a feature of the application.

30. The computer readable media as recited in claim 29, wherein the core module and the non-core modules are downloaded over a distributed network.