Vous pouvez vous abonner à nos annonces de séminaires
		    http://gallium.inria.fr/seminaires/

			     S E M I N A I R E

                   ______                __    _               
                  / ____/___ _____ ___  / /_  (_)_  ______ ___ 
                 / /   / __ `/ __ `__ \/ __ \/ / / / / __ `__ \
                / /___/ /_/ / / / / / / /_/ / / /_/ / / / / / /
                \____/\__,_/_/ /_/ /_/_.___/_/\__,_/_/ /_/ /_/ 

			     I N R I A - Paris
                 2 rue Simone Iff (ou: 41 rue du Charolais)
                          Salle Lions 1, bâtiment C

                            Lundi 6 janvier, 10h30

                               ---------------
                               Lionel Parreaux
                               ---------------

                                     EPFL

             ====================================================
             Type-Safe Metaprogramming and Compilation Techniques
                      for Optimizing High-Level Programs
             ====================================================

Software engineering practices have been steadily moving towards higher-level
programming languages which improve safety, productivity, and code
maintainability. However, these gains are usually made at the cost of reduced
performance: higher-level languages consume more memory, run more slowly and
require expensive garbage-collecting runtime systems.

The main driving force behind my research has been the idea that “we can have
our cake and eat it too” with the help of advances in type systems,
metaprogramming, and compilers technology. High-level programs can be made as
efficient as lower-level ones if we have the tools to automatically remove all
the high-level abstractions, lowering them into specialized constructs. But
removing abstractions is no easy feat.

In this talk, I present Squid, a Scala metaprogramming and extensible compiler
framework, which is aimed at solving such problems. Squid enables the
definition of program generators, program transformers, and domain-specific
rewrite rules, backed by advanced normalizing intermediate program
representations. Moreover, Squid uses an extension of Scala's type system to
guarantee, at compile-time of the metaprograms, that manipulated programs
remain well-typed and well-scoped. This way, we can retain the safety and
maintainability of high-level code, but without paying for it at runtime.

Squid was used, among other things, to implement a new stream fusion algorithm
and to design an efficient polymorphic linear algebra library. Moreover, it is
currently being used to develop dbStage, an efficient language-integrated
database system.