Artifact Metadata Generation with Same-Language Build-Time Evaluation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional metadata generation techniques lack coherence between artifacts and their metadata, often requiring different computer languages and syntaxes, leading to inefficiencies and errors in defining complex configurations, and do not allow for accurate description of non-constant language expressions without runtime execution.
Innovation Solution
Using a complex value-bearing language expression within the same computer language and project to generate metadata, allowing for compilation-time evaluation and error detection, ensuring accurate and reliable metadata generation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If conventional metadata generation techniques use different computer languages and syntaxes for artifacts and metadata, then metadata can be generated without loading the artifact, but the artifact and metadata lack coherency and developers cannot easily understand which properties are valid
Solution Approach 1:
The patent merges the artifact definition and metadata definition into the same computer language and project. Both the artifact code and metadata properties are written in C# within the same solution, eliminating the need for separate languages like JSON or XML. This unification ensures type safety, IntelliSense support, and compile-time validation, making it clear to developers which properties are valid and how they relate to the artifact.
2Ease of manufacture
If conventional techniques generate metadata using only simple language expressions (constants), then metadata generation is simple, but complex configurations cannot be accurately described without runtime execution
Solution Approach 1:
The patent changes the parameter type from simple constants to complex value-bearing expressions. Metadata properties can now contain method calls, property accessors, and other C# expressions that are evaluated at runtime. For example, instead of hardcoding a constant string, the metadata can reference `Artifact.Name` or call a method that returns a configuration value, enabling accurate description of complex configurations while maintaining type safety.
3Manufacturing precision
If complex value-bearing language expressions are evaluated at runtime, then accurate configuration values are obtained, but resource consumption increases and performance decreases
Solution Approach 1:
The patent performs preliminary evaluation of complex expressions during the build process. The C# compiler and build system evaluate the expressions at compile time or build time, generating the actual configuration values and embedding them in the artifact or its metadata. This shifts the computational workload from runtime to build time, so that during execution, the system uses pre-computed values without additional processing overhead.
4Reliability
If the artifact is built from source code in the same project, then coherency between artifact and metadata is improved, but the build process complexity increases
Solution Approach 1:
The patent makes the build system universal by using the C# compiler itself to perform multiple functions: compiling the artifact code, validating metadata expressions, and evaluating configuration values. The same compiler infrastructure that builds the artifact also processes the metadata definitions, eliminating the need for separate metadata processing tools and reducing overall build system complexity despite the unified approach.
Data Source
AI summary
Techniques are described herein that are capable of using a complex value-bearing language expression to generate metadata associated with an artifact. The artifact is configured to define a type and to further define the complex value-bearing language expression. The artifact is built from source code. The type defines functionality of the artifact. The complex value-bearing language expression describes a configuration of the artifact or of a function of the artifact. The functionality and the configuration are defined in the source code, are written in a same computer language, and are included in a same software project. A constant value is extracted from the complex value-bearing language expression at build time of the artifact by evaluating a syntax of the complex value-bearing language expression. During a build of the artifact, the metadata is generated to include the constant value.