Davide Ancona, Sonia Fagorzi, and Elena Zucca
A calculus with lazy module
operators
In IFIP TC1 3rd Int'l Conf. Theoret. Comput. Sci. (TCS
'04), pages 423-436 Kluwer Academic Publishers, 2004
Modern programming environments such as those of
Java and C# support dynamic loading of software
fragments. More in general, we can expect that in
the future systems will support more and more forms
of interleaving of reconfiguration steps and
standard execution steps, where the software
fragments composing a program are dynamically
changed and/or combined on demand and in different
ways. However, existing kernel calculi providing
formal foundations for module systems are based on a
static view of module manipulation, in the
sense that open code fragments can be flexibly
combined together, but all module operators must be
performed once for all before starting
execution of a program, that is, evaluation of a
module component. The definition of clean and
powerful module calculi supporting lazy
module operators, that is, operators which can be
performed after the selection of some
module component, is still an open problem. Here, we
provide an example in this direction (the first at
our knowledge), defining CMSℓ, an
extension of the Calculus of Module Systems
[?] where module operators can
be performed at execution time and, in particular,
are executed on demand, that is, only when needed by
the executing program. In other words, execution
steps, if possible, take the precedence over
reconfiguration steps. The type system of the
calculus, which is proved to be sound, relies on a
dependency analysis which ensures that execution
will never try to access module components which
cannot become available by performing
reconfiguration steps.
[ bib |
.pdf ]
Back
This file has been generated by
bibtex2html 1.43