Application Controller for Extensible Software Assembly
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing software systems require extensive modifications and recompilation to add new functionality, leading to increased complexity and unmaintainability, as they are built with fixed compile-time relationships between components.
Innovation Solution
A method and system that uses an application controller to provide functionality to clients through a set of handlers, allowing additional functionality to be added by configuring new handlers in an XML configuration file without modifying existing clients or components, enabling loose coupling and extensibility.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If additional functionality is added to a software system with fixed compile-time relationships, then the system gains new capabilities, but the complexity of the system increases and existing code requires modification
Solution Approach 1:
The software system is segmented into distinct components: clients, an application controller, and handlers. Each component has a specific responsibility, allowing functionality to be added by introducing new handlers without modifying existing client code. The application controller acts as a coordinator that manages the interaction between clients and handlers through a standardized interface.
Solution Approach 2:
The application controller serves as an intermediary layer between clients and handlers. Clients invoke the application controller with their requests, and the controller routes these requests to appropriate handlers. This mediator pattern allows new functionality to be added through new handlers without requiring changes to client code, as the controller absorbs the complexity of coordinating multiple components.
2Adaptability or versatility
If additional functionality is added to a software system, then new capabilities are provided, but existing code in multiple areas requires modification
Solution Approach 1:
The system is divided into independent, loosely-coupled components. Handlers are self-contained units that can be added, removed, or modified without affecting other parts of the system. The application controller provides a stable interface that shields clients from changes in handler implementations, making the system easier to modify and maintain.
Solution Approach 2:
The application controller provides a universal interface that works with any handler implementing the required contract. This allows the same client code to work with different handlers, and handlers can be reused across different clients. The standardized interface enables multi-functionality while maintaining ease of modification.
3Stability of the object's composition
If software components have fixed compile-time relationships, then the system structure is stable, but adding new functionality requires recompilation
Solution Approach 1:
The system transitions from fixed compile-time relationships to dynamic runtime binding. Clients invoke the application controller at runtime, which then dynamically selects and invokes appropriate handlers based on the request. This dynamic approach allows the system structure to remain stable at the interface level while enabling flexible addition of new functionality without recompilation.
Solution Approach 2:
The application controller as an intermediary enables dynamic behavior while maintaining structural stability. The controller's interface remains constant, providing stability, while its ability to dynamically invoke different handlers provides extensibility. This mediator absorbs the complexity of dynamic component selection and coordination.
Data Source
AI summary
The present invention defines a method for assembling software components using an application controller. The application controller provides a conduit through which calling client modules can access functionality provided by various handlers in a manner that results in greater flexibility when additional functionality is required. Additional functionality can be provided to the clients by adding additional handlers to the application controller without the need to modify any of the individual clients. The client will continue invoking the application controller in the same manner as it did previously, whilst the application controller provides additional functionality by accessing the additional handlers. Indeed, the only changes that are required are to an agent, which in preferred embodiments includes a relatively straightforward to modify XML configuration file.