Communicating sequential processes
Communicating sequential processes
Communications of the ACM
Module reuse by interface adaptation
Software—Practice & Experience
CML: A higher concurrent language
PLDI '91 Proceedings of the ACM SIGPLAN 1991 conference on Programming language design and implementation
Software packaging
Interfaces, protocols, and the semi-automatic construction of software adaptors
OOPSLA '94 Proceedings of the ninth annual conference on Object-oriented programming systems, language, and applications
A classical mind
Abstractions for Software Architecture and Tools to Support Them
IEEE Transactions on Software Engineering - Special issue on software architecture
Architectural issues in software reuse: it's not just the functionality, it's the packaging
SSR '95 Proceedings of the 1995 Symposium on Software reusability
Pattern-based integration architectures
Pattern languages of program design
Architectural mismatch or why it's hard to build systems out of existing parts
Proceedings of the 17th international conference on Software engineering
Software architecture: perspectives on an emerging discipline
Software architecture: perspectives on an emerging discipline
Lessons on converting batch systems to support interaction: experience report
ICSE '97 Proceedings of the 19th international conference on Software engineering
A catalog of techniques for resolving packaging mismatch
SSR '99 Proceedings of the 1999 symposium on Software reusability
Concurrent programming in ML
Design of a separable transition-diagram compiler
Communications of the ACM
Coordination languages and their significance
Communications of the ACM
An asymmetric stream communication system
SOSP '83 Proceedings of the ninth ACM symposium on Operating systems principles
Abstractions and Implementations forArchitectural Connections
ICCDS '96 Proceedings of the 3rd International Conference on Configurable Distributed Systems
A formal approach to software architecture
A formal approach to software architecture
Corrections to 'Avoiding Packaging Mismatch with Flexible Packaging'
IEEE Transactions on Software Engineering
The Vienna Component Framework enabling composition across component models
Proceedings of the 25th International Conference on Software Engineering
Thread transparency in information flow middleware
Software—Practice & Experience - Special issue: Middleware
Towards an architectural treatment of software security: a connector-centric approach
SESS '05 Proceedings of the 2005 workshop on Software engineering for secure systems—building trustworthy applications
On the semantics of software adaptation
Science of Computer Programming - Special issue on second international workshop on foundations of coordination languages and software architectures (FOCLASA'03)
Rethinking software connectors
International workshop on Synthesis and analysis of component connectors: in conjunction with the 6th ESEC/FSE joint meeting
SEPADS'08 Proceedings of the 7th WSEAS International Conference on Software Engineering, Parallel and Distributed Systems
The mythical matched modules: overcoming the tyranny of inflexible software construction
Proceedings of the 24th ACM SIGPLAN conference companion on Object oriented programming systems languages and applications
Component adaptation and assembly using interface relations
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Composing heterogeneous software with style
Proceedings of the 1st International Workshop on Free Composition
Hi-index | 0.00 |
To integrate a software component into a system, it must interact properly with the system's other components. Unfortunately, the decisions about how a component is to interact with other components are typically committed long before the moment of integration and are difficult to change. This paper introduces the Flexible Packaging method, which allows a component developer to defer some decisions about component interaction until system integration time. The method divides the component's source into two pieces: the ware, which encapsulates the component's functionality; and the packager, which encapsulates the details of interaction. Both the ware and the packager are independently reusable. A ware, as a reusable part, allows a given piece of functionality to be employed in systems in different architectural styles. A packager, as a reusable part, encapsulates conformance to a component standard, like an ActiveX control or an odbc database accessor. Because the packager's source code is often formulaic, a tool is provided to generate the packager's source from a high-level description of the intended interaction, a description written in the architectural description language UniCon. The method and tools are evaluated with a series of experiments in which three wares and nine types of packaging are combined to form thirteen components.