Data processing: software development – installation – and managem – Software program development tool – Code generation
Reexamination Certificate
1999-05-28
2002-12-10
Morse, Gregory (Department: 2762)
Data processing: software development, installation, and managem
Software program development tool
Code generation
Reexamination Certificate
active
06493869
ABSTRACT:
A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
TECHNICAL FIELD
This invention relates to compilers, and more particularly to a transformational programming system in which code can be inherited.
BACKGROUND
As computer technology has advanced, computer programs have become correspondingly complex to the point where it is very difficult for a programmer to write an application program in the machine language of the computer. Thus, most programs are written in a high-level language that is easier for the programmer to work with and then converted by a compiler into the machine language of the computer.
A co-pending application titled “Extensible Compiler Architecture”, Ser. No. 09/322,646, filed concurrently herewith, describes an extensible compiler architecture in which source code received by the compiler is represented as a graph having multiple nodes and interconnecting links. The compiler associates one or more question handlers with each node and uses a reduction engine to pass questions and answers among the question handlers. This question and answer methodology is used to transform the source code in graph form into another language.
The compiler also provides the code that describes the behavior of each of the question handlers. However, given the large number of nodes that can exist in a typical graph, having the compiler designer(s) separately write code for each question handler associated with each node can quickly become overburdening. Furthermore, given that the code for different question handlers may be very similar, if not the same, it would be beneficial to provide a way to avoid having to write the same code over and over for different question handlers.
The invention described below addresses these disadvantages, providing a transformational programming system that allows code to be inherited.
SUMMARY
A transformational programming system is described herein that allows code to be inherited. A question and answer methodology is used among question handlers corresponding to nodes of a graph representing the program being transformed. A question handler can inherit code from another question handler by submitting a question requesting the code.
According to one aspect of the invention, when a question handler corresponding to a node receives a question, the question handler submits another question to another question handler corresponding to another node. This other question is a request for a set of instructions to execute in order to respond to the question it received. Eventually, the question handler will receive a response to this other question, the response being the set of instructions to execute in order to respond to the question it received.
According to another aspect of the invention, communication between question handlers is carried out via a reduction engine. The reduction engine also maintains a record of questions that are asked as well as responses given. When a question is received from a question handler requesting a set of instructions to execute, the reduction engine checks whether it has already answered the same question for another question handler. If it has already answered the same question, then the reduction engine provides the set of instructions from the record it maintains rather than submitting the question to another of the question handlers.
According to another aspect of the invention, a first question handler that receives a request from a second question handler for a set of instructions to execute may not know itself what set of instructions the second question handler should execute. Rather, the first question handler submits a request to a third question handler corresponding to yet another node in the graph, requesting a set of instructions for the second question handler to execute. This chain of questioning can continue through multiple additional question handlers until eventually a question is submitted to a question handler that knows the set of instructions the second question handler should execute. A response including this set of instructions is then passed back down through the chain of question handlers, eventually reaching the second question handler.
REFERENCES:
patent: 5018075 (1991-05-01), Ryan et al.
patent: 5428554 (1995-06-01), Laskoski
patent: 5673369 (1997-09-01), Kim
patent: 5790863 (1998-08-01), Simonyi
patent: 5815711 (1998-09-01), Sakamoto et al.
patent: 5828883 (1998-10-01), Hall
patent: 5870564 (1999-02-01), Jensen et al.
patent: 5911072 (1999-06-01), Simonyi
patent: 5974257 (1999-10-01), Austin
patent: 6006233 (1999-12-01), Schultz
patent: 6237136 (2001-05-01), Sadahiro
patent: 6253369 (2001-06-01), Cloud et al.
patent: 6272673 (2001-08-01), Dale et al.
Poswig et al. Interactive Animation of Visual Program Execution. IEEE. 1993. pp. 180-187.*
Alberto Martelli et al., “Optimizing Decision Trees Through Heuristically Guided Search,” ACM Communications, Dec. 1978, vol. 21, No. 12, pp. 1025-1039.
Glenn Ammons et al., “Improving Data—Flow Analysis with Path Profiles,” ACM Apr. 1998, pp. 72-84.
R. Bergamaschi et al., “Data Path Synthesis Using Path Analysis,” ACM, Jul. 1991, pp. 591-596.
W. Sung et al., “Memory Efficient Software Synthesis from Dataflow Graph,” IEEE, May 1998, pp. 137-142.
Carl Beckmann et al., Microarchitecture Support for Dynamic Scheduling of Acyclic Task Graphs, IEEE, Sep. 1992, pp. 140-148.
David F. Bacon et al., “Compiler Transformations for High Performance Computing,” ACM Computing Surveys vol. 26, No. 4, Dec. 1994, pp. 345-419.
B. Ryder et al., “Elimination Algorithms for Data Flow Analysis,” ACM Computing Surveys, vol. 18, No. 3, Sep. 1986, pp. 277-316.
David Kinloch et al., “Understanding C Programs Using the Combined C Graph Representation,” IEEE, Aug. 1994, pp. 172-180.
David Grove et al., “Call Graph Construction in Object-Oriented Languages,” ACM, Aprl. 1997, pp. 108-124.
Evelyn Duesterwald, “Demand-driven Computation of Interprocedural Data Flow,” ACM, Jan. 1995, pp. 37-48.
Alfred V. Aho et al., “Compilers Principles, Techniques, and Tools,” Sep. 1985, Chapters 1-5.
David P. Olshefski et al., “A Prototype System For Static and Dynamic Program Understanding,” IEEE, Mar. 1993, pp. 93-106.
Ben Shneiderman, “Designing the User Interface,” Third Edition, Jul. 23, 1997, p. 12.
“6.5.1 Fundamental Definitions”, 3 pages, dated May 11, 1999.
Kwiatkowski Paul
Paramasivam M.
Richter David
Lee & Hayes PLLC
Microsoft Corporation
Morse Gregory
Zhen Wei
LandOfFree
Inheriting code in a transformational programming system does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Inheriting code in a transformational programming system, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Inheriting code in a transformational programming system will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-2920330