Role-Scope Extensions for Secure Type Extension and Maintenance

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing programming languages face challenges in efficiently managing inheritance and type extensions, leading to increased program complexity, maintenance difficulties, and security vulnerabilities due to overreliance on inheritance, which can result in unnecessary code proliferation and insecure access to object functionalities.

Innovation Solution

The implementation of role-scope extensions (RSE and RSEE) in programming languages, where independent and dependent-link data types are defined with specific scope extensions, allowing separate memory management and restricted access, thereby simplifying maintenance and enhancing security.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Device complexity

If inheritance is used to share features between related types, then code reuse is facilitated and program complexity is reduced, but security vulnerabilities increase and unnecessary code proliferation occurs

Engineering Contradiction:
Improveprogram complexityVSAvoidsecurity
Core Design Contradiction:
Device complexityVSReliability

Solution Approach 1:

The patent segments the type system into independent types and role-scope extensions. Instead of using inheritance where child types inherit from parent types, the patent allows types to be extended with role-specific scopes that are separated from the base type definition. This segmentation prevents the security vulnerabilities of inheritance while maintaining code reuse through shared type definitions with controlled extension mechanisms.

Inventive Principle:
Principle #1Segmentation

2Ease of repair

If inheritance is used to extend type functionality, then code maintenance is simplified, but code proliferation and maintenance difficulty increase

Engineering Contradiction:
ImprovemaintenanceVSAvoidcode structure
Core Design Contradiction:
Ease of repairVSDevice complexity

Solution Approach 1:

The patent extracts role-specific functionality from the base type definition and places it in separate role-scope extensions. This allows the core type to remain simple and stable while role-specific features are added independently. Changes to role-specific features do not affect the base type or other roles, simplifying maintenance by isolating modifications to specific scopes rather than requiring changes across an inheritance hierarchy.

Inventive Principle:
Principle #2Taking out (Extraction)

3Adaptability or versatility

If role-specific extensions are allowed with full access to parent object functionality, then versatility is improved, but security is compromised

Engineering Contradiction:
Improverole-specific functionalityVSAvoidinsecure access
Core Design Contradiction:
Adaptability or versatilityVSObject-affected harmful factors

Solution Approach 1:

The patent applies local quality by granting different access permissions to different role-scopes based on their specific needs. Each role-scope can be configured to access only the specific functionality required for that role, rather than granting universal access to all parent object functionality. This ensures that each role has the versatility needed for its purpose while maintaining security by limiting access to only necessary components.

Inventive Principle:
Principle #3Local quality

4Adaptability or versatility

If traditional type extension mechanisms are used, then adaptability is improved, but program complexity and maintenance difficulty increase

Engineering Contradiction:
Improvetype extensibilityVSAvoidtype system complexity
Core Design Contradiction:
Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The patent introduces role-scope extensions as an intermediary mechanism between base types and role-specific functionality. This intermediary layer provides a controlled interface for extending types with role-specific features while maintaining a clear separation between the base type definition and its extensions. The role-scope mechanism serves as a mediator that manages the complexity of type extensions through structured scopes and access controls, making the type system more adaptable without increasing overall complexity.

Inventive Principle:
Principle #24Intermediary (Mediator)

Data Source

PatentUS12386597B2Role extensions for programming languages
Publication Date: 2025.08.12 ZOHO OFFICE SUITE
  • US12386597B2 patent drawing
  • US12386597B2 patent drawing
  • US12386597B2 patent drawing

AI summary

A programming language and compiler support inheritance and type extensions. Program code defines user-defined independent and dependent-link data types. Elements of an independent data type can be inherited by a dependent-link data type that can extend the scope of the independent data type and the scope of one or more elements of the independent data type. Data types and type extensions are instantiated in memory as uniquely identified objects that reference one another in a manner that controls inter-object access.