Interactive software development system

• US 5,764,989 A
• Filed: 02/29/1996
• Issued: 06/09/1998
• Est. Priority Date: 02/29/1996
• Status: Expired due to Term

• Current Assignee: Open Invention Network LLC
• Original Assignee: Supercede, Inc.
• Inventors: Gustafsson, Niklas, Hamby, John, Lau, Patrick
• Primary Examiner(s): Trammell, James
• Assistant Examiner(s): Chavis, John Q.
• Application Number:
  US08/608,820
• Time in Patent Office: 831 Days
• Field of Search: 395/704
• US Class Current: 717/129
• CPC Class Codes: G06F 11/3664 Environments for testing or debugging software
• CPC Class Codes: G06F 8/48 Incremental compilation software reuse G06F8/36
• CPC Class Codes: G06F 8/70 Software maintenance or management
• CPC Class Codes: G06F 8/71 Version control security arrangements therefor G06F21/57; Configuration management
• CPC Class Codes: G06F 9/44521 Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading

Abstract

An interactive program development system which replaces compilers, linkers and debuggers required for conventional software development. The present invention comprises a new program compilation system for producing a novel type of translated structure called a code object, and an Incremental Image which forms the program image from code objects and their respective intermediate language symbols stored in a persistent symbol table. The new program compilation system operates on conventional computers having a CPU, monitor, memory system and input devices. The present invention obviates the need to halt execution of a program under development or during maintenance update to correct programming errors.

Claims

1. A method for interactively developing a computer program, the method resulting in the production of machine-executable object code, the method having the characteristic of being free of the production of object files and executable files and comprising the steps of:

compiling source code into the machine-executable object code directly into memory for retention after execution of the machine-executable object code; and

manipulating the computer program during development of the computer program, the manipulating being free of the necessity for terminating and restarting the program during manipulation.

2. The method of claim 1 wherein the step of manipulating the computer program during development comprises the further step of debugging the computer program during development of the computer program, the debugging step characterized by being performed free of the necessity for terminating and restarting the program during debugging.

3. The method of claim 1 wherein the step of manipulating the computer program further comprises the step of utilizing a jump instruction as the first instruction of the runtime code objects to effect image updating.

4. The method of claim 3 wherein the step of manipulating the computer program further comprises the step of debugging the computer program, the debugging step being conducted free of the need for interpretation, batch re-compilation, re-linking, re-loading, or the re-creation of error states.

5. The method of claim 3 wherein the step of manipulating the computer program further comprises the step of debugging the computer program, the debugging step being conducted free of an interpretation step, a batch re-compilation step, a re-linking step, a re-loading step, and the step of re-creating error states.

6. The method of claim 3 comprising the further step of implementing the persistent symbol table as an object-oriented database.

7. A method for interactively developing a computer program on a computer including persistent memory, the method resulting in the production of machine-executable object code from a source code file and comprising the steps of:

translating the source code files into code objects, code objects being low level data structures defining the fully translated machine language implementation of at least one of a function definition and an initial value of a variable which refers to other code objects by means of direct memory reference;

storing the code objects and their corresponding intermediate language symbols in a persistent symbol table implemented in persistent memory;

forming run-time code objects from the code objects and their corresponding intermediate language symbols;

linking together run-time code objects to form an executable program image; and

coordinating the program image with the computer program.

8. The method of claim 7 comprising the further step of storing at least one of code object and intermediate language symbol containing a description of a code object which refers to the function in a persistent symbol table.

9. The method of claim 8 further comprising the step of storing data structures including at least one of program units and program objects in the persistent symbol table.

10. The method of claim 8 wherein the manipulation step is performed for debugging the computer program as it is being developed, the method comprising the further steps of:

translating at least one of an expression and a statement into a code object;

updating the existing machine-executable object code with a corresponding runtime code object; and

executing the runtime code object for the purpose, during debugging of the existing machine-executable object code, of at least one of an interactive expression evaluation and a statement execution.

11. The method of claim 7 further comprising the step of manipulating the computer program during development of the computer program, the method being free of the necessity for terminating and restarting the computer program during manipulation.

12. The method of claim 11 wherein the step of manipulating the computer program further comprises the step of utilizing a jump instruction as the first instruction of the runtime code objects to effect image updating.

13. An interactive computer program development system that enables real-time debugging of a computer program as it is compiled without the need for batch recompilation, re-linking, re-loading or the need for the developer to re-create error states, said system comprising:

a computer system having a given set of source code files, and having first and second internal processes;

a debugger resident in said computer system for debugging said given set of source code files;

an incremental builder resident in said computer system which when invoked translates said source code files into code objects and their corresponding intermediate language (IL) symbols, said incremental builder being associated with said first internal process for forming said code objects and program units into a built program which is executable;

a persistent symbol table resident in said computer system for storing said code objects and IL symbols;

an incremental imager resident in said computer system that utilizes said code objects and IL symbols to form runtime code objects, said incremental imager being associated with said first internal process for combining together said runtime code objects to form a program image which is executable, said incremental imager introducing a branch instruction at the beginning of each of said runtime code objects;

a runner resident in said computer system that executes said built program in said second internal process, said runner finalizing said program image and executing said program image in said second internal process; and

a probe module resident in said computer system and in said first internal process for coordinating actions of said incremental imager and said runner;

whereby said program image defining said program, utilizing shared memory data, is simultaneously executed and incrementally manipulated to reflect changes in said source code defining said program.

14. An interactive computer program development system as in claim 13 wherein said code objects and said IL symbols replace object code files, and said runtime code objects replace executable files.

15. An interactive computer program development system as in claim 14 wherein said runner operates in conjunction with said imager to perform a loading function.

16. An interactive computer program development system as in claim 13, wherein the same internal data structures are used to produce executable files as are used for incremental imaging.

17. An interactive computer program development system as in claim 16 furthers including an extractor for producing an executable file from said code objects and intermediate language symbols whereby the need for returning to the source files is eliminated.