Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Information and Computation - FOOL V
Dynamic rebinding for marshalling and update, with destruct-time ?
ICFP '03 Proceedings of the eighth ACM SIGPLAN international conference on Functional programming
Journal of Functional Programming
Mutatis mutandis: safe and predictable dynamic software updating
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Type inference, principal typings, and let-polymorphism for first-class mixin modules
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
MOMI: a calculus for mobile mixins
Acta Informatica
ACM Transactions on Programming Languages and Systems (TOPLAS)
A Calculus for Reconfiguration
Electronic Notes in Theoretical Computer Science (ENTCS)
Mixin modules for dynamic rebinding
TGC'05 Proceedings of the 1st international conference on Trustworthy global computing
Flexible type-safe linking of components for java-like languages
JMLC'06 Proceedings of the 7th joint conference on Modular Programming Languages
The kell calculus: a family of higher-order distributed process calculi
GC'04 Proceedings of the 2004 IST/FET international conference on Global Computing
A calculus of open modules: call-by-need strategy and confluence
Mathematical Structures in Computer Science
A framework for type safe exchange of mobile code
TGC'06 Proceedings of the 2nd international conference on Trustworthy global computing
Hi-index | 0.00 |
We present a simple module calculus modeling software composition in an open environment, where some components can be provided from the outside after execution has started. Operators for combining software components are as in previous module calculi; here, we focus on the new problems posed by the fact that components are not all available at compile time. In particular, we want to be able to statically check internal consistency of local code, by only specifying a required type for missing components, and then to perform dynamic checks which ensure that code received from the outside, which is assumed to travel with its type, can be successfully accepted, without requiring to type-check the whole code again. We consider two alternative solutions. The former uses simple dynamic checks based on standard subtyping, that is, a component can be safely combined with local code if it provides the expected features, and all additional features are hidden, thus avoiding conflict problems. The latter preserves the semantics we would get having all components statically available, but requires a more involved type system based on constraints, where dynamic checks prevent conflicts.