Multi-Tiered Application Deployment Architecture

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

The two-tiered client-server architecture is inefficient for large enterprises due to the tight coupling of business logic, presentation logic, and user interface logic, making it difficult to maintain and update applications across multiple clients, and is not scalable in dynamic environments.

Innovation Solution

A multi-tiered architecture separates presentation logic, business logic, and database from the user interface, allowing these layers to be moved to dedicated servers, enabling flexible and scalable deployment using J2EE standards, and a deployment system that allows applications to reference resources already on the server, reducing the need for resource duplication and enabling partial deployments.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Device complexity

If a two-tiered architecture is used to simplify system structure, then device complexity is reduced, but adaptability deteriorates because business logic and presentation logic are tightly coupled with the user interface

Engineering Contradiction:
Improvesystem structureVSAvoidadaptability
Core Design Contradiction:
Device complexityVSAdaptability or versatility

Solution Approach 1:

The patent divides the monolithic client application into separate logical layers (business logic, presentation logic, user interface) that can be independently deployed and updated. This segmentation allows the system to maintain simplicity while improving adaptability by enabling selective updates of specific layers without affecting the entire system.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent introduces a multi-tiered architectural dimension by moving business logic and presentation logic to the server side while keeping the user interface on the client side. This dimensional separation resolves the contradiction by allowing the client to remain simple while the server handles complexity and adaptability.

Inventive Principle:
Principle #17Another dimension (Dimensionality change)

2Ease of manufacture

If a two-tiered architecture is used to reduce deployment complexity, then ease of manufacture is improved, but productivity deteriorates due to the need to update all clients when business logic changes

Engineering Contradiction:
Improvedeployment complexityVSAvoidupdate efficiency
Core Design Contradiction:
Ease of manufactureVSProductivity

Solution Approach 1:

The patent extracts business logic and presentation logic from the client application and places them on the server side. This extraction allows updates to be made centrally on the server without requiring client updates, thereby improving productivity while maintaining ease of deployment.

Inventive Principle:
Principle #2Taking out (Extraction)

Solution Approach 2:

The patent introduces a server-side intermediary layer that acts as a mediator between the database and client applications. This intermediary enables centralized management of business logic, allowing updates to be propagated to clients only when necessary, thus improving update efficiency without complicating deployment.

Inventive Principle:
Principle #24Intermediary (Mediator)

3Adaptability or versatility

If a multi-tiered architecture is used to improve adaptability, then adaptability is improved, but device complexity increases due to separate servers for presentation logic, business logic, and database

Engineering Contradiction:
ImproveadaptabilityVSAvoidarchitecture complexity
Core Design Contradiction:
Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The patent merges multiple logical layers (business logic, presentation logic, database access) into a single server-side deployment unit that can be deployed and managed as one entity. This merging reduces device complexity by eliminating the need for separate physical servers for each layer while maintaining the adaptability benefits of the multi-tiered architecture.

Inventive Principle:
Principle #5Merging (Combining)

Solution Approach 2:

The patent creates a universal server-side platform that can serve multiple client applications with different user interfaces while sharing common business logic and data access layers. This multi-functionality reduces architecture complexity by providing a shared infrastructure that supports multiple applications without requiring separate deployments for each.

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

4Reliability

If resources are copied to the server during deployment, then reliability is improved, but loss of substance increases due to resource duplication

Engineering Contradiction:
Improvedeployment reliabilityVSAvoidresource duplication
Core Design Contradiction:
ReliabilityVSLoss of substance

Solution Approach 1:

The patent selectively copies only the necessary application resources (excluding media files and other large binaries) to the server during deployment. This selective copying maintains reliability by ensuring critical resources are available on the server while minimizing resource duplication by excluding non-essential files.

Inventive Principle:
Principle #26Copying

Solution Approach 2:

The patent applies partial action by deploying only the essential application resources to the server while leaving non-essential resources (such as media files) on the client side or in external locations. This partial deployment reduces resource duplication while maintaining sufficient reliability for application functionality.

Inventive Principle:
Principle #16Partial or excessive action

Data Source

PatentUS8762981B2Application loading and visualization
Publication Date: 2014.06.24 SAP SE
  • US8762981B2 patent drawing
  • US8762981B2 patent drawing
  • US8762981B2 patent drawing

AI summary

A system and method are described for performing application loading and visualization. In one embodiment, an application is accessed on a client to be deployed on the server. The client is in communication with machines having resources corresponding to the application. The application is then deployed on the server, and the deployed application on the server references a copy of the resources that already resides on the server.