To: seminaire@pauillac.inria.fr
From: Francois.Pottier@inria.fr
Subject: SEM - INRIA : Cristal - 14/12/04 - Paris - FR

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

                             S E M I N A I R E
       ___      .                       
      /    ___   __  /_  _   /             /| /|  _   __ __ _       _ 
     /    /   / /_  /   __| /    -----    / |/ | / \ /_ /  / \ | / __|
    |___ /   / __/ |_  |_/ |_            /     | |_/__/ |_ |_/ |/ |_/
                                                
                          I N R I A - Rocquencourt
                         Amphi Turing du bâtiment 1

                          Mardi 14 decembre, 10h30

                               --------------
                               Martin Odersky
                               --------------

                               EPFL Lausanne

                      ===============================
                      Scalable Component Abstractions
                      ===============================


True component systems have been an elusive goal of the software
industry. Ideally, software should be assembled from libraries of
pre-written components, just as hardware is assembled from
pre-fabricated chips. In reality, large parts of software applications
are written ``from scratch'', so that software production is still
more a craft than an industry.  At least to some extent, the lack of
progress in component software is due to shortcomings in the
programming languages used to define and integrate components. Most
existing languages offer only limited support for component
abstraction and composition.

We identify three programming language abstractions for the
construction of re-usable components: abstract type members, explicit
selftypes and symmetric mixin composition. All three abstractions have
their theoretical foundation in the nuObj calculus. They have been
defined and implemented in the programming language Scala.

Together, these abstractions enable us to transform an arbitrary
assembly of static program parts with hard references between them
into a system of re-usable components. The transformation maintains
the structure of the original system. We demonstrate this approach in
two case studies, a subject/observer framework and a compiler
front-end.

Short Bio:

Martin Odersky is a professor in the programming research group at
EPFL. Previously he has held positions at IBM Research, Yale
University, University of Karlsruhe and University of South Australia,
after having obtained his doctorate in 1989 from ETH Zuerich.  He is
associate editor of the Journal of Functional Programming and member
of IFIP WG 2.8. He co-designed the Pizza and GJ languages as well as
the generics extension of Java 1.5. Martin's interests cover
fundamental as well as applied aspects of programming languages. They
include semantics, type systems, programming language design, and
compiler construction.