Markup Method for Managing Rich Client Code Using Multi-Component Pages

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing client/server computing models face challenges in providing rich user interfaces and experiences, as thick clients are costly to deploy and maintain, while thin clients lack richness and flexibility, leading to limitations in application types, interaction speed, and user experience.

Innovation Solution

A markup method and system for managing rich client code and experience using multi-component pages, enabling server-managed thick client capabilities within a thin client framework, allowing for centralized management and unified application development across both thick and thin clients.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Ease of operation

If thick clients are used to provide rich user interfaces and local operation capabilities, then user experience and interaction speed are improved, but deployment cost and maintenance complexity increase

Engineering Contradiction:
Improveuser experienceVSAvoiddeployment cost
Core Design Contradiction:
Ease of operationVSDevice complexity

Solution Approach 1:

The system segments client functionality into two distinct categories: thin client components (browser, UI rendering) that are centrally managed and thick client components (local application logic, data processing) that run locally. This segmentation allows the system to leverage the advantages of both models without the drawbacks - rich local operation capabilities where needed while maintaining centralized control for deployment and management.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The invention creates a universal client platform that can operate in multiple modes: as a thin client accessing services remotely, as a thick client with local processing capabilities, or as a hybrid. This multi-functionality allows a single system to adapt to different operational requirements without requiring separate deployment paths, thereby reducing overall system complexity while maintaining rich user experience capabilities.

Inventive Principle:
Principle #6Universality (Multi-functionality)

2Device complexity

If thin clients are used for centralized deployment and management, then maintenance cost is reduced, but user interface richness and interaction speed are limited

Engineering Contradiction:
Improvemaintenance costVSAvoiduser interface richness
Core Design Contradiction:
Device complexityVSEase of operation

Solution Approach 1:

The system embeds thick client components within the thin client framework, creating a nested architecture where local application logic is contained within the centralized browser-based platform. This nesting allows rich local processing capabilities to coexist with centralized management, as the thick client components are contained within and controlled by the thin client environment.

Inventive Principle:
Principle #7Nested doll (Nesting)

Solution Approach 2:

The invention introduces an intermediary layer (the unified client platform) between the user and the server, which mediates between centralized management requirements and local operation needs. This intermediary enables rich user interface capabilities and local processing while maintaining compatibility with centralized deployment and management systems.

Inventive Principle:
Principle #24Intermediary (Mediator)

3Adaptability or versatility

If existing thick client systems are deployed with network upgrade capability, then adaptability is improved, but program compatibility issues and configuration complexity increase

Engineering Contradiction:
Improveupgrade capabilityVSAvoidconfiguration complexity
Core Design Contradiction:
Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The system manages adaptability through parameter changes in the markup documents that define component behavior and configuration. By changing parameters in the centralized markup rather than modifying local software configurations, the system achieves versatile upgrade capabilities while avoiding local configuration complexity. The thick client components automatically adapt to new versions through the centralized management system.

Inventive Principle:
Principle #35Parameter changes

4Ease of operation

If custom plugins are added to extend thin client functionality, then user experience is improved, but system stability and security are compromised

Engineering Contradiction:
Improvefunctionality extensionVSAvoidsystem stability
Core Design Contradiction:
Ease of operationVSReliability

Solution Approach 1:

The system performs preliminary validation and security checks on all components before they are allowed to execute in the thick client environment. The centralized management system pre-approves components and their interactions, preventing unstable or insecure code from being introduced. This preliminary action ensures that functionality extensions maintain system stability and security.

Inventive Principle:
Principle #10Preliminary action

Solution Approach 2:

The system implements feedback mechanisms where the centralized management system continuously monitors the behavior of thick client components and can revoke or update permissions based on observed behavior. This feedback loop ensures that custom plugins and extensions do not compromise system stability, as they are subject to ongoing security verification.

Inventive Principle:
Principle #23Feedback

Data Source

PatentUS7734686B2Markup method for managing rich client code and experiences using multi-component pages
Publication Date: 2010.06.08 X CORP
  • US7734686B2 patent drawing
  • US7734686B2 patent drawing
  • US7734686B2 patent drawing

AI summary

A mark-up method and system that enables server-managed thick client capabilities using a thin client server, framework, and administration. Active content such as program code, service, and data components, are driven to a thick client platform. The thick client platform is defined through a combination of thick client components, while the thick client components and user interface experience are centrally managed. The thick client container can operate to embed thin client container components, such as a browser, and the thick client container itself can be initially deployed over a network using a thin client.