Software development infrastructure

• US 7,707,566 B2
• Filed: 07/25/2003
• Issued: 04/27/2010
• Est. Priority Date: 06/26/2003
• Status: Expired due to Fees

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Burger, Julian, Sastry, Akella V. S., Gillies, David Mitford, Mitchell, Charles L., Ayers, Andrew Edward, Roberts, Mark Leslie, Grover, Vinod K., Edwards, Andrew James, Tarditi, David Read Jr., Plesko, Mark Ronald
• Primary Examiner(s): Dam; Tuan Q
• Assistant Examiner(s): TECKLU, ISAAC TUKU
• Application Number:
  US10/628,054
• Publication Number:
  US 20040268309A1
• Time in Patent Office: 2,468 Days
• Field of Search: 717/140, 717/146
• US Class Current: 717/148
• CPC Class Codes: G06F 8/20 Software design
• CPC Class Codes: G06F 8/30 Creation or generation of source code
• CPC Class Codes: G06F 8/437 Type checking

Abstract

A software development architecture is provided for constructing a wide range of software development tools. A software development tool can be created by integrating a specification specifying functionality specific to a set of software development scenarios into a software development scenario-independent framework. The integrated specification can then be compiled to create the software development tool. Alternatively, integration can be achieved at runtime without access to source code. The architecture can use any combination of the following: a software scenario independent intermediate representation format, one or more exception handling models capable of supporting a plurality of programming language specific exception handling models, a type system capable of representing the type representations of a plurality of source languages, and a code generator capable of generating code targeted for a plurality of execution architectures.

Claims

1. One or more computer-readable media with computer-executable instructions for implementing a software development architecture comprising:

a software development scenario-independent intermediate representation format;

one or more exception handling models operable to support a plurality of programming language specific exception handling models for a plurality of different source languages;

a type system operable to represent the type representations of the plurality of different source languages; and

a code generator operable to generate code targeted for a plurality of execution architectures;

wherein the code generator constructs one or more software development components of a plurality of different software development tools using the software development scenario-independent intermediate representation format, the one or more exception handling models operable to support the plurality of programming language specific exception handling models for the plurality of different source languages, and the type system operable to represent the plurality of different source languages;

wherein the code generator further integrates the one or more software development components of the plurality of different software development tools into a software development scenario-independent framework; and

wherein the code generator further creates the plurality of different software development tools by compiling the one or more software development components and the software development scenario-independent framework.

2. The one or more computer-readable media of claim 1 wherein the architecture is scalable to produce target software development tools ranging from lightweight just-in-time (JIT) compilers to whole program optimizing compilers.

3. The one or more computer-readable media of claim 1 wherein the architecture can be configured to produce a target software development tool with varying ranges of memory footprint, compilation speed, and optimization.

4. The one or more computer-readable media of claim 1 wherein the software development architecture is operable to produce a software development tool modifiable by combining a modification component with the software development scenario-independent framework.

5. The one or more computer-readable media of claim 1 wherein the software development architecture is operable to produce a software development tool by dynamically linking a binary version of the software development scenario-independent framework to a modification component.

6. The one or more computer-readable media of claim 1 wherein the intermediate representation format is extensible at runtime of a software tool employing the intermediate representation format.

7. The one or more computer-readable media of claim 1 wherein the architecture is combinable with the one or more software development components.

8. The one or more computer-readable media of claim 7 wherein the one or more software development components comprise data describing a target software development tool.

9. The one or more computer-readable media of claim 7 wherein the one or more software development components provides target execution architecture data to the code generator.

10. The one or more computer-readable media of claim 7 wherein the one or more software development components provide one or more type-checking rules to the type system.

11. The one or more computer-readable media of claim 7 wherein one or more software development components provide a set of class extension declarations to the architecture.

12. The one or more computer-readable media of claim 7 wherein the plurality of different software development tools comprises a native compiler.

13. The one or more computer-readable media of claim 7 wherein the plurality of different software development tools comprises a JIT compiler.

14. A method of creating a plurality of different target software development tools, the method comprising:

receiving at least one computer-readable specification specifying functionality specific to one or more software development scenarios, wherein the at least one computer-readable specification specifies the following software development scenario functionality of the plurality of different target software development tools;

target processor execution architecture;

type checking rule set;

managed execution environment;

input programming language or input binary format; and

compilation type;

creating at least one software development component for the plurality of different software development tools from the at least one specification;

integrating the at least one software development component for the plurality of different software development tools into a software development scenario-independent framework; and

compiling, at least in part, the at least one software development component and framework to create the plurality of different target software development tools;

wherein the computer-readable specification comprises functionality for processing an intermediate representation format capable of representing a plurality of different programming languages; and

wherein the intermediate representation format comprises one or more exception handling models capable of supporting a plurality of programming language-specific exception handling models for the plurality of different programming languages.

15. The method of claim 14 wherein software development components created from a plurality of computer-readable specifications for a plurality of respective software development scenarios are integrated into the framework.

16. The method of claim 14 wherein the computer-readable specification comprises one or more rulesets for type-checking one or more languages.

17. The method of claim 14 wherein the computer-readable specification comprises a set of class extension declarations specific to one or more of the software development scenarios.

18. The method of claim 14 wherein the intermediate representation comprises type representations capable of representing the type representations of the plurality of different programming languages.

19. The method of claim 14 further comprising:

integrating custom code specific to one of the software development scenarios.

20. The method of claim 14 wherein the plurality of different software development tools comprises at least two of the group consisting of:

a native compiler, a JIT compiler, an analysis tool, and a compiler development kit (CDK).

21. The method of claim 14 wherein the computer-readable specification specifies functionality of one of the group consisting of:

a Pre-JIT compiler functionality, optimizer functionality, and defect detection tool functionality.

22. One or more computer-readable media containing one or more computer-executable instructions for performing the method of claim 14.

23. A method of creating a plurality of different target software development tools from a common framework, the method comprising:

configuring the common framework based on one or more characteristics of the plurality of different target software development tools;

creating software development components comprising one or more characteristics of the plurality of different target software development tools from the common framework;

integrating the software development components into a software development scenario-independent framework; and

creating the plurality of different target software development tools by compiling the software development components and the software development scenario-independent framework;

wherein the one or more characteristics comprises an input language chosen from a plurality of different programming languages supported by the common framework for the plurality of different target software development tools; and

wherein the common framework comprises exception handling models capable of supporting a plurality of programming language-specific exception handling models for the plurality of different programming languages.

24. The method of claim 23 wherein the one or more characteristics can further comprise the amount of memory necessary for the plurality of different target software development tools to execute on a target architecture, the speed at which the plurality of different target software development tools will execute on a target architecture, a input binary format for the plurality of different target software development tools, or the target architecture for the plurality of different target software development tools.

25. A method of producing a plurality of different inter-compatible software development tools, the method comprising:

receiving a software development architecture that is operable to support a plurality of different programming languages, wherein the software development architecture further comprises;

classes that are extensible through a set of declarations;

functionality for an intermediate representation format used by both the first and second software development tools; and

functionality for a type system used by both the first and second software development tools;

creating software development components for the plurality of different software development tools from the software development architecture;

creating a first software development tool by integrating the software development components into a

software development scenario-independent framework and compiling the software development components and the software development scenario-independent framework; and

creating a second different software development tool based on the first software development tool and the software development components, wherein the second software development tool dynamically links to a binary version of the software development scenario-independent framework;

wherein the software development architecture comprises functionality for exception handling models operable to support programming-language specific exception handling models for the plurality of different programming languages, and the software development architecture is used by both the first and second software development tools.

26. A method of creating a plurality of different software development tools, the method comprising:

receiving at least one computer-executable file comprising;

an intermediate representation capable of representing a plurality of different programming languages and computer executable images;

one or more exception handling models capable of supporting a plurality of programming language specific exception handling models for the plurality of different programming languages;

a type system capable of representing the type representations of a plurality of source languages; and

a code generator capable of generating code targeted for a plurality of execution architectures;

creating one or more software development components of a plurality of different software development tools from the at least one computer-executable file;

integrating the one or more software development components of the plurality of different software development tools into a software development scenario-independent framework using at least one class extension declaration; and

creating the plurality of different software development tools by compiling, at least in part, the linked one or more software development components and the software development scenario-independent framework.