Papers by Tom Hirschowitz

International journal

[1] Tom Hirschowitz and Xavier Leroy. Mixin modules in a call-by-value setting. ACM Transactions on Programming Languages and Systems Volume 27 , Issue 5 (September 2005).
[ bib | .ps.gz | .pdf | At ACM's ]

International conferences

[2] Daniel Hirschkoff, Tom Hirschowitz, Damien Pous, Alan Schmitt, and Jean-Bernard Stefani. Component-Oriented Programming with Sharing: Containment is not Ownership. In Generative Programming and Component Engineering: 4th International Conference, GPCE 2005. Volume 3676 of LNCS, Springer.
[ .pdf | At Springer's ]
[3] Tom Hirschowitz. Rigid mixin modules. In International Symposium on Functional and Logic Programming (FLOPS) 2004. Version conférence de [10], Volume 2998 of LNCS, Springer.
[ bib | .ps.gz | .pdf | At Springer's ]
[4] Tom Hirschowitz, Xavier Leroy, and J. B. Wells. Call-by-value mixin modules: Reduction semantics, side effects, types. In European Symposium on Programming, 2004. Version conférence de [8], Volume 2986 of LNCS, Springer.
[ bib | .ps.gz | .pdf | At Springer's ]

Mixin modules are a framework for modular programming that supports code parameterization, incremental programming via late binding and redefinitions, and cross-module recursion. In this paper, we develop a language of mixin modules that supports call-by-value evaluation, and formalize a reduction semantics and a sound type system for this language.
[5] Tom Hirschowitz, Xavier Leroy, and J. B. Wells. Compilation of extended recursion in call-by-value functional languages. In Principles and Practice of Declarative Programming, pages 160-171. ACM Press, 2003. Version conférence de [9].
[ bib | .ps.gz | .pdf | At ACM's ]
[6] Tom Hirschowitz and Xavier Leroy. Mixin modules in a call-by-value setting. In Daniel Le Métayer, editor, European Symposium on Programming, volume 2305 of LNCS, pages 6-20, 2002. Version conférence de [1],
[ bib | .ps.gz | .pdf | At Springer's ]

The ML module system provides powerful parameterization facilities, but lacks the ability to split mutually recursive definitions across modules, and does not provide enough facilities for incremental programming. A promising approach to solve these issues is Ancona and Zucca's mixin modules calculus CMS. However, the straightforward way to adapt it to ML fails, because it allows arbitrary recursive definitions to appear at any time, which ML does not support. In this paper, we enrich ML with a refined type system that controls recursive definitions through the use of dependency graphs. We then develop a separate compilation scheme, directed by dependency graphs, that translate mixin modules down to a CBV lambda-calculus extended with a non-standard let rec construct.


[7] Tom Hirschowitz, Xavier Leroy, and J. B. Wells. Compilation of extended recursion in call-by-value functional languages. Under revision for publication in Higher-Order and Symbolic Computation.
[ bib | .ps.gz | .pdf ]


[8] Tom Hirschowitz, Xavier Leroy, and J. B. Wells. A reduction semantics for call-by-value mixin modules. Rapport de recherche RR-4682, INRIA, Janvier 2003.
[ bib | .ps.gz | .pdf ]

Module systems are important for software engineering: they facilitate code reuse without compromising the correctness of programs. However, they still lack some flexibility: first, they do not allow mutually recursive definitions to span module boundaries ; second, definitions inside modules are bound early, and cannot be overridden later, as opposed to inheritance and overriding in class-based object-oriented languages, which follow the late binding semantics. This paper examines an alternative, hybrid idea of modularization concept, called mixin modules. We develop a language of call-by-value mixin modules with a reduction semantics, and a sound type system for it, guaranteeing that programs will run correctly.
[9] Tom Hirschowitz, Xavier Leroy, and J. B. Wells. On the implementation of recursion in call-by-value functional languages. Rapport de recherche RR-4728, INRIA, Février 2003.
[ bib | .ps.gz | .pdf | ]

Functional languages encourage the extensive use of recursive fonctions and data structures. It is therefore important that they efficiently implement recursion. In this paper, we formalize and improve a known implementation technique for recursion. The original technique was introduced by Cousineau and Mauny as the ``in-place updating trick''. Consider a list of mutually recursive definitions. The technique consists in allocating a dummy, uninitialized heap block for each recursive definition. The size of these blocks is guessed from the shape of each definition. Then, the right-hand sides of the definitions are computed. Recursively-defined identifiers thus refer to the corresponding dummy blocks. This leads, for each definition, to a block of the expected size. Eventually, the contents of the obtained blocks are copied to the dummy blocks, updating them in place. The only change we propose to this scheme is to update the dummy blocks as soon as possible, immediately after each definition is computed, thus making it available for further use. At the source language level, the improvement allows to extend the class of expressions allowed as right-hand sides of recursive definitions, usually restricted to syntactic functions. We formalize our technique as a translation scheme to a lambda-calculus featuring in-place updating of memory blocks, and prove the translation to be faithful.
[10] Tom Hirschowitz. Rigid mixin modules. Technical Report RR-2003-46, ENS Lyon, 2003.
[ bib | .ps.gz | .pdf ]

Mixin modules are a notion of modules that allows cross-module recursion and late binding, two features missing in ML-style modules. They have been well defined in a call-by-name setting, but in a call-by-value setting, they tend to conflict with the usual static restrictions on recursive definitions. Moreover, the semantics of instantiation has to specify an order of evaluation, which involves a difficult design choice. Previous proposals rely on the dependencies between components to compute a valid order of evaluation. In such systems, mixin module types must carry some information about the dependencies between their components, which makes them rather impractical. In this paper, we propose a new design for mixin modules in a call-by-value setting, which avoids this problem. The formalism we obtain is much simpler than previous notions of mixin modules, although slightly less powerful.
[11] Tom Hirschowitz. Modules mixins, modules et récursion étendue en appel par valeur. Thèse de doctorat, Université Paris 7, 2003.
[ bib | .ps.gz | .pdf ]
[12] Tom Hirschowitz. Mixin modules, modules, and extended recursion in a call-by-value setting (extended version), 2003.
[ bib | .ps.gz | .pdf ]
[13] Tom Hirschowitz. Modules mixins: typage et implantation. Rapport de DEA, Université Paris 7, 2000.
[ bib | .ps.gz | .pdf ]

This file has been generated by bibtex2html 1.56