The Compose Project is located in Bordeaux. Compose is a joint project with LaBRI (Laboratoire Bordelais de Recherche en Informatique)—the computer science department at the University of Bordeaux I—CNRS (Centre National de la Recherche Scientifique)—a French national scientific research center—and ENSEIRB (Ecole Nationale Supérieure en Electronique, Informatique et Radiocommunications de Bordeaux)—an electronics, computer science, and telecommunications engineering school at Bordeaux. The project is physically located at ENSEIRB.
Adaptability can be a key aspect in the design and implementation of a
software component, particularly when this component addresses, not a
specific problem or need, but a family of problems or needs. This
situation raises the usual conflict between genericity and
efficiency. On the one hand, genericity is often traded for efficiency
in application areas such as operating systems and networking. On the
other hand, in software engineering studies, efficiency is commonly
overlooked to achieve a high degree of static and dynamic
adaptability
Not only does an adaptable system raise challenges for its development, but the process of adapting such a system with respect to a given context also introduces difficulties. The main problems raised by a high degree of adaptability are as follows.
Usability: parameters may capture many aspects; as a result, they may be complicated and unstructured. This problem becomes worse at the level of a software architecture, where parts of global parameters need to be propagated down to individual software components.
Conciseness: an increasing number of parameters usually requires the programmer to write repetitive sequences of operations to set up an appropriate context before any invocation. The resulting program may become large and hard to maintain.
Robustness: complex parameterization with many configuration values, not surprisingly, translates into more error-prone programming.
These problems are well-known limitations of attempts to make systems
and components more re-usable
The Compose group aims to study new approaches to developing adaptable software components in a specific target area, namely, systems and networking; in particular, multimedia communication services. These approaches are based on methodologies, techniques and tools from software engineering and programming languages. Concretely, we design and implement new languages dedicated to a problem domain to enable the development of concise and robust programs. Also, we develop program analyzes and program optimizations to ensure domain-specific properties and efficiency.
Our research process consists of identifying and analyzing problems in our application area, developing methodologies, techniques and tools to address these problems, and assessing our proposed solutions on real-size cases.
Because of the cross-disciplinary nature of our research, we have had contributions in various communities like systems, networking, software engineering, and programming languages. In practice, the Compose group has produced many prototypes ranging from a compiler for a domain-specific language aimed to specify variations of e-mail services to a program specializer applied to the TCP/IP protocol stack targeted at optimizing system networking programs.
Program transformation that produces a specialized version of a generic program or function, by performing compile-time evaluation of known sub-expressions.
The research done in the Compose group relies on two main approaches:
Partial evaluation.
Domain-specific languages.
It is the process that automates program specialization. Specialization is a program transformation that, given some specific execution context, turns a generic program into a specific program, optimizing for speed and/or space. In particular, specializing an interpreter with respect to a given program yields a compiled program where the interpretation layer has been totally removed.
However, program specialization is hard to use by the average
programmer. Making it accessible to the average programmer could have
a major impact in terms of software engineering. Indeed, instead of
hand-optimizing code (which is error-prone and complicates
maintenance), the programmer could write adaptable programs (i.e., generic, flexible, configurable...) and produce efficient
implementations via program specialization. Adaptable components
should improve re-usability and hence software robustness and
productivity.
The main approach to program specialization relies on program analysis
to determine how a program should be transformed. In particular, this
approach consists of performing a dependency analysis, called binding-time analysis
A domain-specific language (DSL) can be viewed as a programming
language dedicated to a particular domain or a family of
problems
Productivity: programming, maintenance and evolution are much easier; re-use is systematized.
Verification: it becomes possible or much easier to automate formal proofs of critical properties of the software: security, safety, real time, etc..
Those features have drawn the attention of rapidly evolving markets
(where there is a need for building families of similar software
products, e.g., product lines), as well as markets where
reactivity or software certification are critical: Internet, cellular
phones, smart cards, electronic commerce, embedded systems, bank ATM,
etc. Some companies have indeed started to use DSLs in their
development process: ATT, Lucent Technologies, Motorola, Philips,
etc
Although promising, the DSL approach suffers from the lack of
methodology to design and implement these languages. Considering the
nature of DSLs, this methodology should combine software engineering
and programming language aspects. The Compose group has many years of
experience with the design and development of domain-specific
languages and has begun addressing DSL methodology
issues
Adaptability of software systems is a well-identified need in a
variety of domains such as
networking
Applying our adaptation methodologies and tools to real-size cases is a key aspect of our research work. To do so, we focus our effort on a specific application area, namely, systems and networking; in particular on multimedia communication services. Most such software components inherently need to be adaptable because of the family of services they implement. Yet, they have efficiency constraints because they are intensively executed. Multimedia communication services also have strong safety and security requirements; in particular when dealing with third-party service development.
Our goal is to show how our approaches can lead to highly adaptable components without sacrificing neither safety nor efficiency.
The need for adaptation methodologies and tools is confirmed by our industrial partners such as Integro Networks and Thomson Multimedia. They must adapt to ever changing customer needs and rapidly evolving hardware. They cannot sacrifice efficiency, often because of cost constraints.
NOVA is a platform and framework for adaptable multimedia communication services.
The platform is centered around a collection of programmable
servers service domains,
such as HTTP services, e-mail services, and telephony services.
These servers may be programmed through so-called service
description languages which are domain-specific languages to offer
expressiveness and conciseness without compromising safety and
security. Service description programs may thus define service
variations adapting the behavior of a service to a particular client.
This makes the services sensitive to and capable of adapting to client
characteristics like terminal capabilities, network features, user
preferences, and evolving needs.
Thus far, we have developed three service description languages; Pems (Section ) for e-mail services, Hades (Section ) for HTTP services, and Call/C (Section ) for telephony services.
NOVA also has an explicit notion of users each with a collection of heterogeneous devices for accessing multimedia services. A user may register and bind service description programs for each of the supported service domains (HTTP, IMAP, VoIP) to the individual devices.
Furthermore, each user has an associated so-called mobile space
wherein documents may be remotely stored and manipulated to avoid
downloading large files and/or unsupported file formats. The
documents may be remotely manipulated through an OS-independent
file-system interface. Special programmable directories, known as
sinks, may be instructed to perform certain tasks when files
are stored in them; the tasks may range from printing to faxing to
format conversion.
The NOVA platform and framework is the ideal context for validating the individual service description languages. However, it has proved a worthy and interesting research topic in its own right.
The NOVA platform implementation is currently an internal prototype, but should be available for download in the near future.
Hades is a domain-specific language for specifying robust client adaptations of HTTP resources. Hades programs are targeted at degrading HTTP resources, reducing the overall size and detail level of HTML documents and embedded multimedia contents.
Embedded multimedia contents may be downsampled or transcoded in various ways; images may, for instance, be converted to other formats, resized, or turned to black-and-white to save network bandwidth.
Entire HTML fragments may be discarded or externalized which
means that they are replaced by a hyperlink to a new file containing
the externalized fragment. This way, large and complicated documents
may be fragmented into smaller pieces, better suited for display on
devices with small screens.
A Hades program is often specified relative to a site or a collection of documents with a similar structure. We have a working prototype of the Hades compiler and proxy extension.
Call/C is a high-level domain-specific language for specifying robust Internet telephony services.
Call/C reconciles programmability and reliability of telephony services, and offers high-level constructs that abstract over intricacies of the underlying protocols and software layers. Call/C makes it possible for owners of telephony platforms to deploy third-party services without compromising safety and security. This openness is essential to have a community of service developers that addresses such a wide spectrum of new functionalities. The Call/C compiler is nearing completion.
Pems is a high-level domain-specific language for specifying robust variations of e-mail services based on the Internet Message Access Protocol (IMAP).
Pems programs define views at four different hierarchically
structured levels; access-point, mailbox, message, and message fields.
Individual messages and fields may, depending on various contextual
information, be filtered or appropriately transformed. Attached
documents may be subjected to format conversion.
We have a working prototype of the Pems compiler and programmable IMAP server.
We have designed and implemented a domain-specific language, named Spidle, for specifying steaming applications.
Spidle offers high-level and declarative constructs; compared to general-purpose languages (GPL), it improves robustness by enabling a variety of verifications to be performed.
We have successfully specified a number of standardized and special-purpose streaming applications which are up to 2 times smaller than equivalent programs written in a GPL such as C.
Preliminary results show that compiled Spidle programs are roughly as efficient as the compiled equivalent of C programs. We have a working prototype for the Spidle compiler.
The object-oriented style of programming facilitates program
adaptation and enhances program genericness, but at the expense of
efficiency. We demonstrate experimentally that state-of-the-art Java
compilation technology fails to compensate for the use of
object-oriented abstractions to implement generic programs, and that
program specialization can be used to eliminate these overheads. We
present an automatic program specializer for Java, and demonstrate
experimentally that significant speedups in program execution time can
be obtained through automatic specialization. Although automatic
program specialization could be seen as overlapping with existing
optimizer compiler technology, we show that specialization and
compiler optimization are in fact complementary. For more
information, see:
Partial evaluation is a program transformation that automatically specializes a program with respect to invariants. Despite successful application in areas such as graphics, operating systems, and software engineering, partial evaluators have yet to achieve widespread use. One reason is the difficulty of adequately describing specialization opportunities. Indeed, underspecialization or overspecialization often occurs, without any direct feedback as to the source of the problem.
We have developed a high-level, module-based language allowing the
program developer to guide the choice of both the code to specialize
and the invariants to exploit during the specialization process. To
ease the use of partial evaluation, the syntax of this language is
similar to the declaration syntax of the target language of the
partial evaluator. To provide feedback, declarations are checked
during the analyzes performed by partial evaluation. The language has
been successfully used by a variety of users, including students
having no previous experience with partial evaluation. For more
information, see:
Automating software evolution requires both identifying precisely the
affected program points and selecting the appropriate modification at
each point. This task is particularly complicated when considering a
large program, even when the modifications appear to be systematic.
We illustrate this situation in the context of evolving the Linux
kernel to support Bossa, an event-based framework for
process-scheduler development. To support Bossa, events must be added
at points scattered throughout the kernel. In each case, the choice of
event depends on properties of one or a sequence of instructions. To
describe precisely the choice of event, we propose to guide the event
insertion by using a set of rules, amounting to an aspect, that
describes the control-flow contexts in which each event should be
generated. In this paper, we present our approach and describe the
set of rules that allows proper event insertion. These rules use
temporal logic to describe sequences of instructions that require
events to be inserted. We also give an overview of an implementation
that we have developed to automatically perform this evolution. For
more information, see:
An increasing number of domain-specific languages (DSLs) are being developed and successfully used in a variety of areas including networking, telecommunications, and financial products. Yet, the development of a DSL is still an obscure process and its assessment is often partial.
This paper proposes to structure the development of a DSL on the notion of a program family. We outline the main steps of such development. Furthermore, we argue that a program family provides a basis to assess a DSL.
The ideas discussed in this paper are directly based on our experience
in developing DSLs for various domains and studying existing ones. We
illustrate these ideas with various examples of DSLs. For more
information, see:
The domain of services for mobile communication terminals has long
become a fast-moving target. Indeed, this domain has been affected by
a continuous stream of technological advances on aspects ranging from
physical infrastructures to mobile terminals. As a result, services
for this domain are known to be very unpredictable and volatile. This
situation is even worse when considering services relying heavily on
multimedia activities (e.g., games, audio and/or video messages,
etc.). Such an application area is very sensitive to a large variety
of aspects such as terminal capabilities (graphics, CPU, etc.),
bandwidth, service provider's billing policies, QoS, and user
expectations.
This paper presents a paradigm based on domain-specific languages
(DSLs) that enables networking and telecommunication experts to
quickly develop robust communication services. Importantly, we propose
implementation strategies to enable this paradigm to be supported by
existing software infrastructures. For more information,
see:
We present the Metafront tool for specifying flexible, safe, and efficient syntactic transformations between languages defined by context-free grammars. The transformations are guaranteed to terminate and to map grammatically legal input to grammatically legal output.
We rely on a novel parser algorithm that is designed to support gradual extensions of a grammar by allowing productions to remain in a natural style and by statically reporting ambiguities and errors in terms of individual productions as they are being added.
Our tool may be used as a parser generator in which the resulting
parser automatically supports a flexible, safe, and efficient macro
processor, or as an extensible lightweight compiler generator for
domain-specific languages. We show substantial examples of both kinds.
For more information, see:
Developing device drivers can be highly tedious as it entails direct interaction with hardware devices, which are difficult to analyze in trying to find the cause of unexpected behavior. User-mode Linux simplifies this task by allowing developers to test and debug their device drivers in user-space.
In this paper, we describe a systematic approach to create virtual
soft devices for the purpose of testing device drivers while
they are still in the stage of development. Soft devices run as
user-space processes and can have a GUI interface. We have used the
existing emulation capabilities of User-mode Linux and extended them
by adding some of our own. We have designed a language named
Saint to specify soft devices, and implemented a virtual
coffee-machine soft device as a proof of concept.
For more information, see:
The client-server model has been successfully used to support a wide variety of families of services in the context of distributed systems. However; its server-centric nature makes it insensitive to fast-changing client characteristics like terminal capabilities, network features, user preferences, and evolving needs.
To overcome this limitation, we present an approach to enable a server to adapt to different clients by making it programmable. A service-description language is used to program server adaptations. This language is designed as a domain-specific language to offer expressiveness and conciseness without compromising safety and security. We show that our approach makes servers adaptable without requiring the deployment of new protocols or server implementations.
We illustrate our approach with the Internet Message Access Protocol (IMAP). An IMAP server is made programmable and a language, named Pems, is introduced to program robust variations of e-mail services.
Our approach is uniformly used to develop a platform for multimedia
communication services. This platform is composed of programmable
servers for telephony services, e-mail processing, remote-document
processing, and stream adapters. For more information,
see:
Multimedia stream processing is a rapidly evolving domain which requires much software development and expects high performance. Developing a streaming application often involves low-level programming, critical memory management, and finely tuned scheduling of processing steps.
To address these problems, we present a domain-specific language (DSL), named Spidle, for specifying steaming applications. Spidle offers high-level and declarative constructs; compared to general-purpose languages (GPL), it improves robustness by enabling a variety of verifications to be performed.
To asses the expressiveness of Spidle in practice, we have used it to specify a number of standardized and special-purpose streaming applications. These specifications are up to 2 times smaller than equivalent programs written in a GPL such as C.
We have implemented a compiler for Spidle. Preliminary results show
that compiled Spidle programs are roughly as efficient as the compiled
equivalent of C programs. For more information,
see:
The convergence of telecommunications and computer networks has added
host of new functionalities to telephony services including Web
resources, databases, etc. Making these rapidly evolving
functionalities available to customers critically relies on developing
a stream of new telephony services. Fortunately, this convergence has
made the programming of telephony services as accessible as the
programming of networking services.
Yet, an undesirable effect of this new situation is that such a basic
commodity as telephony is no longer dependent on thoroughly tested
software, developed by certified programmers.
Telephony is now exposed to bugs as found in ordinary software
development and caused by common deficiencies such as lack of
programming experience and insufficient domain expertise.
To reconcile programmability and reliability of telephony, we present
a domain-specific language aimed to specify robust services. This
language, named Call/C, offers high-level constructs that abstract
over intricacies of the underlying protocols and software layers.
Call/C makes it possible for owners of telephony platforms to deploy
third-party services without compromising safety and security. This
openness is essential to have a community of service developers that
addresses such a wide spectrum of new functionalities.
For more information, see
The client-server model has been successfully used to support a wide variety of families of services in the context of distributed systems. However, its server-centric nature makes it insensitive to fast changing client characteristics like terminal capabilities, network features, user preferences and evolving needs.
To overcome this key limitation, we present an approach to enabling a server to adapt to different clients by making it programmable. A service-description language is used to program server adaptations. This language is designed as a domain-specific language to offer expressiveness and conciseness without compromising safety and security.
We have implemented an initial prototype based on Linux with programmable servers for telephony services, remote document processing, e-mail message services, and HTTP requests.
In this contract, entitled ``NOVA: A Programmable .NET Platform for Multimedia Communication Services'', we propose to port our prototype onto Windows environment and improve it to reach a fully operational NOVA platform as presented in this proposal.
.NET aims to turn applications into web services. However, the
server-centric nature of the model makes it insensitive to fast
changing client characteristics like terminal capabilities, network
features, user preferences, trends, and evolving needs. As a
consequence, .NET services cannot adapt to client needs and
requirements. From a prospective client, a .NET service can be seen
as a set of opaque operations that either do the job or are
useless.
Our programmable server approach
.NET and programmable servers are complementary in that once a web service is found using .NET, it could be adapted to client needs and requirements by a service-description program in the context of our approach.
In this contract, entitled ``Programmable .NET Services'', we propose to validate the notion of programmable .NET services in the context of the Internet Message Access Protocol (IMAP).
This project, entitled ``Composition and refinement of Secure Systems'', is a collaboration between groups from the systems and formal methods community.
The goal is to study methods and tools for the development of secure and safe systems with special emphasis on specification. Relying on refinement and composition, we will study service interaction in the context of telephony services and service derivation by refinement and composition of open systems.
We have collaborations with Professor Calton Pu (Georgia Institute of Technology, Atlanta), currently centered around the specialization of operating system components and the design of a domain-specific language, Spidle, for streaming applications.
We have collaboration with DIKU, the University of Copenhagen, Denmark (Julia L. Lawall and Anne-Françoise Le Meur), on various aspects of specialization.
Julia L. Lawall (DIKU, the University of Copenhagen, Denmark) and James Larus (Microsoft Research, Redmond, WA) have visited the Compose group.
Charles Consel has been involved in the following events as:
program commitee member of ACM SIGPLAN Conference on
Programming Languages Design and Implementation (PLDI 2004);
program commitee member of European Conference on Object Oriented Programming (ECOOP 2003);
co-organizer of Dagstuhl School on Domain-Specific Program Generation, 2003;
steering committee member of ACM Sigplan Conference of Generative Programming and Component Engineering (GPCE 2004); and
member of the IFIP group on Domain-Specific Program Generation, 2004.
Charles Consel and Laurent Réveillère have taught a Master's course on Domain-Specific Languages.
Charles Consel has given talks at:
ACM Sigplan Conference of Generative Programming and Component Engineering (GPCE 2003 research talk and invited talk);
Inria Grenoble;
Microsoft Research, Seattle;
Georgia Institute of Technology, Atlanta; and
Dagstuhl School on Domain-Specific Program Generation, 2003
Charles Consel has been a RNTL referee 2003, member of the
Inria recruitment jury 2003, and a member of the
specialist commission at l'Ecole des Mines de Nantes, 2003.
Claus Brabrand gave a presentation at the ACM Third Workshop on
Language Descriptions, Tools and Applications (ETAPS/LDTA 2003) and
an invited talk with Charles Consel at the ACM Sigplan
Conference of Generative Programming and Component Engineering.
Laurent Réveillère gave a presentation at the 18th IEEE
International Conference on Automated Software Engineering (ASE 2003)
and a talk at the Dagstuhl School on Domain-Specific Program
Generation, 2003.
Laurent Réveillère received the ``Best Ph.D. Thesis Award'' from
ACM SIGOPS France.