Extensible Strong Type System with Relational Metadata
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In business data systems, end users face difficulties in extending or creating new data types without developer intervention, leading to costly and time-consuming recompilation processes, and existing user-defined data types are often weakly typed, resulting in runtime errors.
Innovation Solution
The solution involves expressing and deploying data type configuration data to obtain a relational representation, allowing users to extend data types by adding metadata to the relational representation, which synchronizes with the compiled code representation at runtime, enabling type checking and error detection at compile time.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If end users define new or different data types in strongly typed systems, then data type flexibility is improved, but developer recompilation is required which increases time and cost
Solution Approach 1:
The system separates data type definitions into two independent representations: a compiled code representation for type checking and a relational database representation for runtime flexibility. This segmentation allows users to modify data types in the relational representation without triggering recompilation of the compiled code, thus resolving the contradiction between flexibility and recompilation time.
Solution Approach 2:
The patent introduces an intermediary mechanism that synchronizes the relational database representation with the compiled code representation. This intermediary layer allows user-defined data types to be stored relationally and then synchronized with the strongly typed system, enabling flexibility without requiring full recompilation while maintaining type safety.
2Ease of operation
If end users define data types using weakly typed systems, then ease of definition is improved, but runtime errors occur due to lack of compile-time checking
Solution Approach 1:
The system performs preliminary type checking at compile time by maintaining a compiled code representation of data types. Users can easily define new data types in the relational representation, and the system pre-compiles these definitions to enable compile-time type checking, thus preventing runtime errors while maintaining ease of definition.
Solution Approach 2:
The patent implements a feedback mechanism where the relational database representation is synchronized with the compiled code representation. This feedback loop ensures that user-defined data types are validated against the strongly typed system's type rules, providing compile-time error detection while allowing easy user definition of new types.
3Reliability
If developers maintain full control over data type definitions in strongly typed systems, then type safety is improved, but user autonomy is reduced
Solution Approach 1:
The patent adds another dimension to data type management by introducing a relational database representation alongside the traditional compiled code representation. This dimensional expansion allows users to autonomously define and modify data types in the relational layer while the system maintains type safety through synchronization with the compiled code representation, thus resolving the contradiction between type safety and user autonomy.
Data Source
AI summary
Data type configuration data is expressed and deployed to a database system to obtain a relational representation of the data types in addition to the compile code representation. Users or developers extend the data types by adding data to the relational representation, and the runtime environment operates off of the relational representation. Because the data types are extended (such as by creating new entities) using the data type tables in the relational representation, the extensions obtain the benefits of the type checking performed at compile time.