Descriptor Class Framework for Schema-Driven Development
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing descriptor handling approaches, such as the 'start-from-schema' method, require developers to regenerate program source codes and classes whenever schema changes occur, complicating development and making it difficult to build or edit source codes until schemas are created and updated.
Innovation Solution
The 'start-from-class' approach defines descriptors via programmable classes in an object-oriented programming language, hiding schema-to-class mapping details and allowing developers to write and program against classes, with automatic validation and extension capabilities, enabling a class-centric or Java-centric programmatic view of descriptors.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Manufacturing precision
If the start-from-schema approach is used to define descriptors, then control over descriptor forms and contents is improved, but development complexity increases and source code regeneration is required whenever schema changes occur
Solution Approach 1:
The system segments the descriptor handling process into two independent layers: the schema layer (defining descriptor forms and contents) and the source code layer (accessing descriptors). By separating these concerns, changes in the schema layer do not necessitate regeneration of source code in the application layer, thus reducing development complexity while maintaining precise control over descriptor forms and contents.
Solution Approach 2:
The patent introduces an intermediary mechanism (the descriptor service and its interface) between the schema definition and the source code usage. This intermediary abstracts the schema details from the source code, allowing schema changes to be handled at the intermediary level without affecting the source code, thereby reducing development complexity while preserving control over descriptor forms and contents.
2Manufacturing precision
If schemas are created and updated before source code can be built or edited, then descriptor control is maintained, but development time and productivity are reduced
Solution Approach 1:
The system performs preliminary actions by generating descriptor accessors and source code templates in advance based on the schema, but stores them in a usable state that does not require regeneration upon schema changes. The descriptor service pre-processes schema information and makes it accessible to source code through a stable interface, allowing developers to work on source code without waiting for schema finalization, thus improving productivity while maintaining descriptor control.
Solution Approach 2:
The patent implements a dynamic system where the descriptor service can adapt to schema changes without requiring source code regeneration. The service dynamically resolves descriptor references and handles schema evolution transparently, allowing source code to remain stable while the underlying schema can be updated freely, thereby improving development productivity without sacrificing descriptor control.
3Manufacturing precision
If developers directly author and modify schemas, then descriptor precision is maintained, but ease of operation decreases due to complex schema-to-class mapping requirements
Solution Approach 1:
The patent introduces the descriptor service as an intermediary that handles the complex schema-to-class mapping automatically. Developers interact with the service through a simplified interface that abstracts away the schema complexity, while the service maintains precise descriptor control through its internal schema processing. This intermediary layer shields developers from schema complexity while preserving descriptor precision.
Solution Approach 2:
The descriptor service performs self-service by automatically generating and maintaining the mapping between schemas and programmatic classes. Instead of requiring developers to manually handle schema-to-class mapping, the service autonomously manages this complexity, allowing developers to focus on high-level programming while the service ensures descriptor precision through its automatic mapping mechanisms.
Data Source
AI summary
A descriptor class framework fully support a “start-from-class” approach, which defines a descriptor via a set of programmable classes defined in an object-oriented programming language. While the persistent form of a descriptor of a deployed software component is a file, the developer of an application using software component may view the descriptor as a set of programmable descriptor classes. A set of classes can be generated from a descriptor based on a set of construction rules and vise versa. Each class can be annotated, validated and customized. The descriptor class framework is also capable of determining the differences between two versions of a descriptor and notifying the changes to a corresponding class via events to a listener registered with the class.