English (United Kingdom)

https://curated-unify.zendy.io/wp-json/zendy-region/v1/featured_content/oa?rat=en

https://curated-unify.zendy.io/wp-json/zendy-region/v1/highlighted_journal/

Global: Zendy Plus annual

Presents the access of premium content as premium feature

Premium Content

Presents the keyphrase highlighting as premium feature

Keyphrase Highlighting

Presents the summarisation as premium feature

Summarisation

Insights

Presents the pdf analysis as premium feature

PDF Analysis

Presents the zaia usage as premium feature

ZAIA

Global: Zendy Tools annual

Global: Zendy Free Plan

Global: Zendy Tools monthly

Global: Zendy Plus monthly

In distributed software environments, a common practice is the use of autonomous third-party components (i.e. Java Beans, ActiveX controls, etc.). These distributed components can be used to perform some repetitive functionality that is more efficient to purchase than to build. A problem arises when these components commit to particular types of interaction protocols that are not consistent with the target environment. Prior to the time of integration, third-party vendors design and develop these components to comply with certain interaction protocols or packaging [3] (i.e. invocation-based, event-based, etc.). Mismatch occurs when target environments are not consistent with this predetermined packaging. System integrators must introduce wrappers or mediators [4] to retrofit these components into their particular environment. In large-scale systems, it is inevitable for functional and non-functional requirements to change, new components to enter the system, and reconfiguration to occur based on failures. In each case, the reuse of system components is dependent on the ability to specify new system functionality according to change and dynamically reconfignre the system to comply with these new specifications. This paper describes an approach to software component composition in support of longrunning distributed applications that use third-party components. In this approach, the Unified Modeling Language (UML) is used to express packaging and functionality details. Also, we detail our underlying agent-based architecture and implementation that accepts these specifications and reconfigures the third-party components at run-time.

An agent approach to alleviating packaging mismatch