Run-time UML Model Reconstruction from Source Code
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current software development tools struggle to integrate Unified Modeling Language (UML) design models with source code, making it difficult to move model information into a program's run-time environment, which limits the ability to maintain and evolve software applications effectively.
Innovation Solution
A development system that includes a methodology for creating source code representing UML models, compiling it into an executable application, and using a run-time framework to reconstruct and utilize the model information, allowing model-driven run-time services.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If UML design models are kept separate from source code, then design flexibility is maintained, but integration and synchronization between model and code become difficult
Solution Approach 1:
The patent merges UML design models with source code by embedding model information directly into the code structure. The development system integrates the UML model and source code into a unified representation, allowing them to be stored, compiled, and executed together rather than as separate artifacts that require manual synchronization.
Solution Approach 2:
The patent creates a universal development system that handles both UML model manipulation and source code compilation through a single integrated framework. The system can switch between design-time model operations and run-time code execution, providing multi-functionality that eliminates the need for separate toolchains for design and implementation.
2Extent of automation
If model information is embedded in source code, then run-time access is enabled, but code complexity increases
Solution Approach 1:
The patent segments model information into distinct, organized components within the source code structure. By dividing the UML model into separable elements that can be individually accessed and manipulated, the system enables run-time model access without creating a monolithic code structure that would be difficult to manage.
Solution Approach 2:
The patent introduces an intermediary development system that mediates between the UML model and the source code. This intermediary layer handles the embedding and extraction of model information, shielding developers from the complexity of direct model-code integration while enabling run-time access to model data.
3Ease of manufacture
If separate development tools are used for UML modeling and code writing, then tool specialization is achieved, but workflow integration becomes cumbersome
Solution Approach 1:
The patent combines multiple specialized development tools into a single integrated development system. The system unifies UML modeling capabilities, source code editing, compilation, and execution into one cohesive environment, eliminating the need to switch between separate tools and manually synchronize artifacts.
Solution Approach 2:
The patent creates a universal development platform that performs multiple functions previously requiring separate specialized tools. The system can create and manipulate UML models, generate source code, compile the code, and execute the application—all through a single integrated interface that adapts to different development tasks.
Data Source
AI summary
A development system with methodology for run-time restoration of UML model from program code is described. In one embodiment, for example, in a computer system, an improved method is described for developing and executing an application, the method comprises steps of: creating a model describing business objects and rules of the application; creating source code for the application, including representing the model within the source code itself; compiling the source code into an executable application; running the executable application on a target computer in conjunction with a run-time framework that provides services to the executable application; and while the executable application is running, reconstructing the model from the executable application and making it available to the run-time framework.