Control Building System for Automated Code Generation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current application development environments require significant programming expertise to create new controls, making it difficult for non-technical users like web designers to customize and modify software applications, and expose intellectual property when code logic is not obfuscated.
Innovation Solution
A system and method for automatically generating native language code for controls using ADE-based components and higher-level scripting languages, allowing developers with minimal programming experience to create and customize controls by programmatically selecting components and script code, generating native code at runtime, and extending control behavior through OOP inheritance.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If traditional programming methods using machine-level language or high-level languages are used, then applications can be created with basic functionality, but the amount of code required becomes enormous and requires significant programming expertise
Solution Approach 1:
The system segments control creation into two distinct layers: a high-level scripting language layer for logic definition and a native code generation layer for execution. This segmentation allows users to work with simple scripts while the system handles the complex native code generation automatically, resolving the contradiction between ease of creation and programming complexity.
Solution Approach 2:
The patent introduces an intermediary code generation system that translates high-level scripting language definitions into optimized native code. This intermediary layer acts as a mediator between the user-friendly scripting interface and the underlying complex programming requirements, enabling ease of control creation without requiring users to master complex programming languages.
2Adaptability or versatility
If code logic is exposed for customization, then non-technical users can modify controls, but intellectual property is exposed when code logic is not obfuscated
Solution Approach 1:
The system creates a copy of the control logic in the form of configurable parameters and event handlers that expose functionality without exposing implementation details. Users interact with and customize the control through this parameter interface, which replicates the control's behavior without revealing the underlying proprietary code logic, thus protecting intellectual property while maintaining adaptability.
Solution Approach 2:
The patent applies different levels of exposure selectively: the control's interface and configuration parameters are exposed for customization, while the internal implementation logic remains protected. This local differentiation allows users to customize behavior through parameters without accessing or exposing the core intellectual property embedded in the native code implementation.
3Reliability
If controls are created using lower-level languages, then functionality can be precisely controlled, but significant programming expertise is required making it difficult for non-technical users
Solution Approach 1:
The system replaces the mechanical process of manually writing and managing complex native code with an automated code generation mechanism. The high-level scripting language serves as a simplified interface that automatically compiles into reliable native code, substituting the need for users to directly manipulate complex programming mechanics while maintaining the precision and reliability of low-level control functionality.
4Ease of operation
If native code is generated automatically at runtime, then programming expertise is minimized, but code generation time is required
Solution Approach 1:
The system performs preliminary actions by pre-compiling and optimizing the code generation templates and structures during system initialization or control design phase. When controls are instantiated at runtime, the actual code generation leverages these pre-prepared templates, significantly reducing the time required for code generation while maintaining the benefit of automated generation for users with minimal programming experience.
Data Source
AI summary
A system and method is disclosed for creating a reusable control from various applications or portions of applications. Using a pre-existing application or one specifically developed for the control, a developer programmatically declares which functionalities of the original application are to be included in the new control. This control building logic becomes a part of the application code. On execution of the application with the added control building logic, the native code that will re-create the control functionality is automatically generated. The control developer may now extend the generated code using simple Object Oriented Programming (OOP) inheritance to add properties and parameters that will control its behavior. The resulting control may then be referenced by other developers when creating a new software application.