Incremental Managed Assembly Generation via Code Module Segmentation

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

In the .NET framework, rapid application development is hindered by the inability to incrementally generate assemblies, requiring recompilation of the entire assembly upon changes, which reduces developer productivity, especially in scenarios requiring quick testing and small changes.

Innovation Solution

A compiler generates an assembly with an assembly manifest and code modules, regenerating only the affected code module and updating the assembly manifest upon type changes, allowing for incremental assembly generation and rapid development.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If the entire assembly is recompiled upon any change, then the assembly remains immutable and consistent, but the build time increases and developer productivity decreases

Engineering Contradiction:

Improveassembly consistencyVSAvoiddeveloper productivity

Core Design Contradiction:

ReliabilityVSProductivity

Solution Approach 1:

The assembly is segmented into multiple code modules, each capable of being independently compiled and regenerated. When a change occurs, only the affected code module is recompiled rather than the entire assembly, thereby maintaining consistency while reducing build time and improving developer productivity.

Inventive Principle:

Principle #1Segmentation

2Stability of the object's composition

If the entire assembly is recompiled upon any change, then the assembly maintains immutability, but the build time increases

Engineering Contradiction:

Improveassembly immutabilityVSAvoidbuild time

Core Design Contradiction:

Stability of the object's compositionVSLoss of time

Solution Approach 1:

The assembly is divided into separate code modules that can be independently managed. This segmentation allows the compiler to regenerate only the specific module that changed, preserving the immutability and consistency of the overall assembly while significantly reducing the time required for recompilation.

Inventive Principle:

Principle #1Segmentation

3Productivity

If incremental compilation is implemented, then build time decreases and productivity improves, but the complexity of the compilation process increases

Engineering Contradiction:

Improvedeveloper productivityVSAvoidcompilation process complexity

Core Design Contradiction:

ProductivityVSDevice complexity

Solution Approach 1:

The compilation process is segmented into module-level operations with clear entry and exit points. Each code module is treated as an independent compilation unit with its own manifest, allowing the compiler to track and regenerate only the necessary portions while managing complexity through structured, modular processing.

Inventive Principle:

Principle #1Segmentation

Solution Approach 2:

The compiler performs preliminary analysis to detect changes in code modules before full compilation. By identifying modified modules in advance and preparing for selective regeneration, the system reduces build time and improves productivity while managing complexity through advance planning and structured processing.

Inventive Principle:

Principle #10Preliminary action

Data Source

PatentUS8914780B2Incremental generation of managed assemblies

Publication Date: 2014.12.16 MICROSOFT TECHNOLOGY LICENSING LLC

AI summary

Concepts and technologies are described herein for incremental generation of managed assemblies. In accordance with some of the concepts and technologies disclosed herein, a compiler incrementally generates a managed assembly thereby facilitating a rapid application development environment in which changes to the assembly require recompilation of only a changed portion of the assembly instead of recompilation of the entire assembly.