The Phoenix group is located in Bordeaux. Phoenix is a joint research group 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 group is located at the INRIA-Futurs facility in Bordeaux.
The frantic nature of technological advances in the area of multimedia communications, compounded with the effective convergence between telecommunication and computer networks, is opening up a host of new functionalities, placing service creation as a fundamental vehicle to bring these changes to end-users.
This situation has three main consequences: (1) service creation is increasingly becoming a software intensive area; (2) because communication services are often heavily relied on, intensive service creation must preserve robustness; (3) the growing multimedia nature of communication services imposes high-performance requirementson services and underlying layers.
The phoenix group aims to develop principles, techniques and tools for the development of communication services. To address the requirements of this domain, the scope of our research comprises the key elements underlying communication services: the infrastructure that enables communication to be set up ( e.g.,signalling platform, transport protocols, and session description); the software architecture underlying services ( e.g.,the client-server model, programming interfaces, and the notion of service logic); and, communication terminals ( e.g.,terminal features and embedded systems).
Our approach covers three key aspects of the area of communication services: (1) definition of new Domain-Specific Languages (DSLs), using programming language technology to enable the specification of robust services; (2) study of the layers underlying communication services to improve flexibility and performance; (3) application to concrete areas to validate our approach.
A Bordeaux-based startup company, named Siderion Technologies, has been created on May 11 2007. Siderion proposes a solution targeting applicative telephony, enabling users to customize the routing of their phone calls with respect to their own rules, a contact base and various preferences. Thanks to a graphical environment, call routing services can be easily and safely created, covering a large spectrum of professional profiles and preferences. The VisuCom technology has been developed in the Phoenix research group at INRIA.
Our proposed project builds upon results that have been obtained by the Compose research group whose aim was to study new approaches to developing adaptable software components in the domain of systems and networking. In this section, we review the accomplishments of Compose, only considering the ones achieved by the current project members, to demonstrate our expertise in the key areas underlying our project, namely
Programming language technology: language design and implementation, domain-specific languages, program analysis and program transformation.
Operating Systems and Networking: design, implementation and optimization.
Software engineering: software architecture, methodologies, techniques and tools.
By combining expertise in these areas, the research work of the Compose group contributed to demonstrating the usefulness of adaptation methodologies, such as domain-specific languages, and the effectiveness of adaptation tools, such as program specializers. Our work aimed to show how adaptation methodologies and tools can be integrated into the development process of real-size software components. This contribution relied on advances in methodologies to develop adaptable programs, and techniques and tools to adapt these programs to specific usage contexts.
Although industry has long recognized the need to develop adaptable programs, methodologies to develop them are still at the research stage. We have presented preliminary results in this area with a detailed study of the applicability of program specialization to various software architectures . Our latest contributions in this area span from a revolutionary approach based on the definition of programming languages, dedicated to a specific problem family, to a direct exploitation of specialization opportunities generated by a conventional programming methodology.
DSLs represent a promising approach to modeling a problem family. Yet, this approach currently suffers from the lack of methodology to design and implement DSLs. To address this basic need, we have introduced the Sprint methodology for DSL development . This methodology bridges the gap between semantics-based approaches to developing general-purpose languages and software engineering. Sprint is a complete software development process starting from the identification of the need for a DSL to its efficient implementation. It uses the denotational framework to formalize the basic components of a DSL. The semantic definition is structured so as to stage design decisions and to smoothly integrate implementation concerns.
A less drastic strategy to developing efficient adaptable programs consists of making specific issues of adaptation explicit via a declarative approach. To do so, we enrich Java classes with declarations, named adaptation classes, aimed to express adaptive behaviors . As such, this approach allows the programmer to separate the concerns between the basic features of the application and its adaptation aspects. A dedicated compiler automatically generates Java code that implements the adaptive features.
When developing components, programmers often hesitate to make them highly generic and configurable. Indeed, genericity and configurability systematically introduce overheads in the resulting component. However, the causes of these overheads are usually well-known by the programmers and their removal could often be automated, if only they could be declared to guide an optimizing tool. The Compose group has worked towards solving this problem.
We introduced a declaration language which enables a component developer to express the configurability of a component. The declarations consist of a collection of specialization scenarios that precisely identify what program constructs are of interest for specialization. The scenarios of a component do not clutter the component code; they are defined aside in a specialization module , , , .
This work was done in the context of C and declarations were intended to drive our C specializer.
A natural approach to systematically applying program specialization is to exploit opportunities offered by a programming methodology. We have studied a development methodology for object-oriented languages, called design patterns. Design patterns encapsulate knowledge about the design and implementation of highly adaptable software. However, adaptability is obtained at the expense of overheads introduced in the finished program. These overheads can be identified for each design pattern. Our work consisted in using knowledge derived from design patterns to eliminate these overheads in a systematic way. To do so, we analyzed the specialization opportunities provided by specific uses of design patterns, and determined how to eliminate these overheads using program specialization. These opportunities were documented in declarations, called specialization patterns, and were associated with specific design patterns . The specialization of a program composed of design patterns was then driven by the corresponding declarations. This work was presented in the context of Java and uses our Java specializer .
The source of inefficiency in software architectures can be identified in the data and control integration of components, because flexibility is present not only at the design level but also in the implementation. We proposed the use of program specialization in software engineering as a systematic way to improve performance and, in some cases, to reduce program size. We studied several representative, flexible mechanisms found in software architectures: selective broadcast, pattern matching, interpreters, layers and generic libraries. We showed how program specialization can systematically be applied to optimize those mechanism , .
Integrating our adaptation methodologies and tools into the development process of real-size software systems was achieved by proposing a new development process. Specifically, we proposed a new approach to designing and structuring operating systems (OSes) . This approach was based on DSLs and enables rapid development of robust OSes. Such approach is critically needed in application domain, like appliances, where new products appear at a rapid pace and needs are unpredictable.
Our approach to developing systems software applied to the domain of device drivers. Indeed, peripheral devices come out at a frantic pace, and the development of drivers is very intricate and error prone. The Compose group developed a DSL, named Devil (DEvice Interface Language), to solve these problems; it was dedicated to the basic communication with a device. Devil allowed the programmer to easily map device documentation into a formal device description that can be verified and compiled into executable code.
From a software engineering viewpoint, Devil captures domain expertise and systematizes re-use because it offers suitable built-in abstractions . A Devil description formally specifies the access mechanisms, the type and layout of data, as well as behavioral properties involved in operating the device. Once compiled, a Devil description implements an interface to an idealized device and abstracts the hardware intricacies.
From an operating systems viewpoint, Devil can be seen as an interface definition languagefor hardware functionalities. To validate the approach, Devil was put to practice : its expressiveness was demonstrated by the wide variety of devices that have been specified in Devil. No loss in performance was found for the compiled Devil description compared to an equivalent C code.
From a dependable system viewpoint, Devil improves safety by enabling descriptions to be statically checked for consistency and generating stubs including additional run-time checks . Mutation analysis were used to evaluate the improvement in driver robustness offered by Devil. Based on our experiments, Devil specifications were found up to 6 times less prone to errors than writing C code.
Devil was the continuation of a study of graphic display adaptors for a X11 server. We developed a DSL, called GAL (Graphics Adaptor Language), aimed to specify device drivers in this context . Although covering a very restricted domain, this language was a very successful proof of concept.
Besides device drivers, the Compose group also explored the area of networking in the context of DSLs. More specifically, we developed a language, named Plan-P, that enables the network to be programmable and thus to offer extensibility . As such, Plan-P enables protocols to be defined for specific applications. Plan-P extends a language, named Plan, developed by the University of Pennsylvania and devoted to network diagnostics. Plan-P enables routers to be programmed in a safe and secure way without any loss in bandwidth. To achieve safety and security, the language is restricted, and programs are downloaded into the routers as DSL source code to enable thorough verifications. For efficiency, a light Just-In-Time compiler is generated from the Plan-P interpreter via program specialization. This compiler is installed on routers to compile uploaded Plan-P source code.
To further the applicability of our approach, we have strengthened and extended adaptation tools and techniques. We have produced a detailed description of the key program analysis for imperative specialization, namely binding-time analysis . This analysis is at the heart of our program specializer for C, named Tempo . We have examined the importance of the accuracy of these analyses to successfully specialize existing programs. This study was conducted in the context of systems software .
Tempo is the only specializer which enables programs to be specialized both at compile time and run time. Yet, specialization is always performed in one stage. As a consequence, this process cannot be factorized even if specialization values become available at multiple stages. We present a realistic and flexible approach to achieving efficient incremental run-time specialization . Rather than developing new techniques, our strategy for incremental run-time specialization reuses existing technology by iterating a specialization process. Our approach has been implemented in Tempo.
While program specialization encodes the result of early computations into a new program, data specializationencodes the result of early computations into data structures. Although aiming at the same goal, namely processing early computations, these two forms of specialization have always been studied separately. The Compose group has proposed an extension of Tempo to perform both program and data specialization . We showed how these two strategies can be integrated in a single specializer. Most notably, having both strategies enabled us to assess their benefits, limitations and their combination on a variety of programs.
Interpreters and run-time compilers are increasingly used to cope with heterogeneous architectures, evolving programming languages, and dynamically-loaded code. Although solving the same problem, these two strategies are very different. Interpreters are simple to implement but yield poor performance. Run-time compilation yields better performance, but is costly to implement. One approach to reconciling these two strategies is to develop interpreters for simplicity but to use specialization to achieve efficiency. Additionally, a specializer like Tempo can remove the interpretation overhead at compile time as well as at run time. We have conducted experiments to assess the benefits of applying specialization to interpreters . These experiments have involved bytecode and structured-language interpreters. Our experimental data showed that specialization of structured-language interpreters can yield performance comparable to that of the compiled code of an optimizing compiler.
Besides targeting C, we developed the first program specializer for an object-oriented language. This specializer, named JSpec, processes Java programs . JSpec is constructed from existing tools. Java programs are translated into C using our Java compiler, named Harissa. Then, the resulting C programs are specialized using Tempo. The specialized C program is executed in the Harissa environment. JSpec has been used for various applications and has shown to produce significant speedups .
IP telephony materializes the convergence between telecommunications and computer networks. This convergence is dramatically changing the face of the telecommunications domain moving from proprietary, closed platforms to distributed systems based on network protocols. In particular, a telephony platform is based on a client-server model and consists of a signalling serverthat implements a particular signalling protocol ( e.g.,the Session Initiation Protocol ). A signalling server is able to perform telephony-related operations that include resources accessible from the computer network, such as Web resources, databases...This evolution brings a host of new functionalities to the domain of telecommunications. Such a wide spectrum of functionalities enables Telephony to be customized with respect to preferences, trends and expectations of ever demanding users. These customizations critically rely on a proliferation of telephony services. In fact, introducing new telephony services is facilitated by the open nature of signalling servers, as shown by all kinds of servers in distributed systems. However, in the context of telecommunications, such evolution should lead service programming to be done by non-expert programmers, as opposed to developers certified by telephony manufacturers. To make this evolution worse, the existing techniques to program server extensions ( e.g.,Common Gateway Interface ) are rather low level, involves crosscutting expertises ( e.g.,networking, distributed systems, and operating systems) and requires tedious session management. These shortcomings make the programming of telephony services an error-prone process, jeopardizing the robustness of a platform.
We are developing a DSL, named SPL ( Session Processing Language), aimed to ease the development of telephony services without sacrificing robustness.
Mobility and wireless networks pose a major challenge to media delivery: how does one mass-deliver media while at the same time personalizating it to account for diverse needs such as multiple heterogeneous rendering terminals, user requirements, network bandwidth, etc.Such personalization involves transcoding and transforming multimedia resources along the image chain.
To do so, various treatments, commonly supported by hardware, are gradually being shifted to software, to face unpredictable needs. On the one hand, this shift helps to keep pace with the rapidly evolving domain of media delivery. On the other hand, it imposes very high-performance requirements for treatments that were earlier hardware supported. As a consequence, developing a streaming application often involves low-level programming, critical memory management, and finely tuned scheduling of processing steps.
To address these problems, we have designed and implemented a DSL, named Spidle, for specifying streaming applications . Our approach consists in
Identifying (and possibly modifying) a protocol ( e.g.,RTSP) for multimedia streaming.
Making a streaming server, based on the previously identified protocol, programmable using Spidle. This work will permit streaming adaptations to the client needs and preferences.
Defining realistic adaptation scenarios to validate our approach. This work may lead us to extend Spidle to cope with the target scenarios.
Assessing our approach by conducting a thorough experimental study.
Tempo is a partial evaluator for C programs. It is an off-line specializer; it is divided into two phases: analysis and specialization.
The input to the analysis phase consists of a program and a description of which inputs will be known during specialization and which will be unknown. Based on this knowledge, dependency analyses propagate information about known and unknown values throughout the code and produce an annotated program, indicating how each program construct should be transformed during specialization. Because C is an imperative language including pointers, the analysis phase performs alias and side-effect analyses in addition to binding-time analyses. The accuracy of these analyses is targeted towards keeping track of known values across procedures, data structures, and pointers. Following the analysis phase, the specialization phase generates a specialized program based on the annotated program and the values of the known inputs. Tempo can specialize programs at compile time (i.e., source-to-source transformation) as well as run time (i.e., run-time binary code generation).
The Tempo specializer has been applied in various domains such as operating systems and networking, computer graphics, scientific computation, software engineering and domain specific languages. It has been made publicly available since April 1998. Its documentation is available on line, as well as tutorial slides.
SPL is a high-level domain-specific language for specifying robust Internet telephony services.
SPL reconciles programmability and reliability of telephony services, and offers high-level constructs that abstract over intricacies of the underlying protocols and software layers. SPL 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 SPL compiler is nearing completion.
Event-driven programming has emerged as a standard to implement high-performance servers due to its flexibility and low OS overhead. Still, memory access remains a bottleneck. Generic optimization techniques yield only small improvements in the memory access behavior of event-driven servers, as such techniques do not exploit their specific structure and behavior.
The Stingy compiler implementes an optimization framework dedicated to event-driven servers, based on a strategy to eliminate data-cache misses. Our approach exploits the flexible scheduling and deterministic execution of event-driven servers. It is based on a novel memory manager combined with a tailored scheduling strategy to restrict the working data set of the program to a memory region mapped directly into the data cache.
In practice, the Stingy compiler accepts as input an event-driven server written in C and annotated to expose a specific memory management and scheduling interface. As output, it generates C code for an optimized version of the server. The Stingy compiler has been tested on the following servers: The TUX, thttpd, Flash, boa, mathopd. It has also been applied to the Cactus QoS framework and the Squid proxy server. The highest speedup observed under heavy loads is on the TUX server (in the range of 40%). For the remaining servers, gains are in the region of 10-15%.
To ease the development of telephony services, a DSL known as SPL (Session Processing Language) has been designed and implemented. This language offers domain-specific constructs and extensions that abstract over the intricacies of the underlying technologies. To enable non-programmers to define services, a graphical telephony service creation workshop, named VisuCom, has been developed, as well as its corresponding execution environment. This software offers intuitive visual constructs and menus that permit users to quickly develop a wide variety of services ranging from simple redirection to agenda dependent call handling. The whole architecture also enables semantic properties to be verified. Examples of errors detected in services include call loss, incorrect state transitions, and unbounded resource usage.
VisuCom and its execution environment are deposited at the Agency for the Protection of Programs (APP).
"Dispositif d'interconnexion d’un système d’informations d’entreprise(s) à un serveur", Inria patent No. 06291276.1, August 7, 2006.
In the Internet era, many applications, ranging from instant messaging clients and multimedia players to HTTP servers and proxies, involve processing network protocol messages. However, implementing a correct and efficient network protocol message parser is a difficult task. To address this issue, we have recently introduced a declarative language, Zebu, for describing protocol message formats and related processing constraints. We have found that Zebu-based applications are often as efficient as hand-crafted ones while offering more safety and robustness.
Nowadays, a lot of buildings contain an amazing number of devices that have various technological functionalities. Some of them can be seen as rendering devices, like TV monitors and speakers; others are data-collecting devices like webcams and sensors; a third category is activation-based devices like lights and doors. Of course, some devices may combine more than one capability. Developing a smart building critically relies on the ability to combine the capabilities of the available devices. However, because of the heterogeneity of the devices, their combination is often achieved by using ad hoc design and implementation approaches. As a consequence, the resulting platforms are usually closed and limited, preventing usage scenarios to evolve and impeding creativity.
The goal of the Smart Space project at the INRIA facility in Bordeaux is to create a platform where a number of devices are deployed and operated via a SIP backbone. Devices are wrapped to turn them into SIP entities. Various software development approaches are being studied to design and implement a variety of pervasive computing scenarios. We are investigating the design and development of a domain-specific IDL and its compiler, dedicated to the development of pervasive computing applications.
We are designing and implementing a domain-specific language, called Pantachou, dedicated to the development of coordination services for networked entities.
Prior to their deployment on an embedded system, Operating Systems are commonly tailored to reduce code size and improve run-time performance. Program specialization is a promising match for this process: it is predictable, modular and allows the reuse of previously implemented specializations. A specialization engine for embedded systems must overcome three main obstacles: (i) Reusing existing compilers for embedded systems, (ii) supporting specialization on a resource-limited system and (iii) allowing applications to invoke specialization of system code on demand.
We describe a run-time specialization infrastructure that addresses each of the above three problems. Our solution proposes: (i) Specialization in two phases of which the former generates specialized C templates and the latter uses a dedicated compiler to generate efficient native code. (ii) A virtualization mechanism that facilitates specialization of code at a remote location. (iii) Specific OS extensions that allow applications to produce, manage and dispose off specialized code.
We evaluate our work through two case studies: (i) The TCP/IP implementation of Linux and (ii) The TUX embedded web server. We report appreciable improvements in code size and performance. We also quantify the overhead of specialization and argue that a specialization server can scale to support a sizable workload. For more information, see: .
The secure and robust functioning of a network relies on the defect-free implementation of network applications. As network protocols have become increasingly complex, however, hand-writing network message processing code has become increasingly error-prone.
We present a domain-specific language, Zebu, for generating robust and efficient message processing layers. A Zebu specification, based on the notation used in RFCs, describes protocol message formats and related processing constraints. Zebu-based applications are efficient , since message fragments can be specified to be processed on demand. Zebu-based applications are also robust, as the Zebu compiler automatically checks specification consistency and generates parsing stubs that include validation of the message structure. Using a message torture suite in the context of SIP and RTSP, we show that Zebu-generated code is both correct and defect-free. For more information, see: .
Developing a SIP-based telephony service requires a programmer to have expertise in telephony rules and constraints, the SIP protocol, distributed systems, and a SIP API, which is often large and complex. These requirements make the development of telephony software an overwhelming challenge. To overcome this challenge, various programming languages have been proposed to develop telephony services. Nevertheless, none of these languages as yet has a formal semantics. Therefore, the reference implementation, which may not be available, becomes the only source of information for the programmer to understand the subtleties of the language. Furthermore, this situation makes it difficult for third-party developers to port the language to another runtime system or to provide another implementation of the runtime system.
We present a semantics-based stepwise approach for designing and developing a scripting language dedicated to the development of telephony services. This approach enables critical properties of services to be guaranteed and captures expertise on the operational behavior of a service. We have applied this approach to developing the Session Processing Language(SPL) dedicated to SIP-based service creation. A variety of services have been written in SPL for our university department. For more information, see: .
The proliferation of smart communication devices based on technologies such as Radio-Frequency IDentification (RFID) makes pervasive computing evolving at a frantic pace. This evolution leads to the development of applications, called monitoring applications, that offer a host of new functionalities based on context information provided by tagged entities.
We introduce a software architecture dedicated to monitoring applications and define a mapping to the Amigo middleware which is dedicated to ambient computing. We illustrate our approach by developing two real-size applications for child monitoring and object reminder. In these experiments, our approach have demonstrated its usability and ease of programming. For more information, see: .
The open-endedness of telephony platforms is creating expectations among users, ranging from end-users to administrators, to create services dedicated to their activities. Not only is the population of developers heterogeneous, but the technologies underlying modern telephony range over a variety of areas such as multimedia, databases, web services, and distributed systems. This situation drastically widens the expertise required for service creation.
We propose an approach to coping with the heterogeneity of both the service developers and the technologies underlying modern telephony. Our approach is based on programming languages. It consists of providing a language that is specific to each developer community with respect to its expertise ( e.g., programming skills) and the target application area ( e.g., administration). Such languages, called Domain-Specific Languages (DSLs), are organized in layers, accounting for abstraction levels.
Our layered approach to telephony service creation is illustrated by two high-level DSLs for end-user service creation, requiring no programming skills, and an expressive DSL enabling the development of expert-level telephony services. We show that layering DSLs greatly facilitates their implementation and verification of telephony-specific properties by leveraging on high-level tools. For more information, see: .
Pervasive computing applications are tedious to develop because they combine a number of problems ranging from device heterogeneity, to middleware constraints, to lack of programming support.
We present an approach to integrating the ontological description of a pervasive computing environment into a programming language, namely Java. From this ontological description of a pervasive computing environment, a framework is automatically generated. It provides the developer with dedicated programming support to manage, discover and invoke services. Besides, it performs a number of verifications both at compile and run time, ensuring the robustness of applications. For more information, see: .
Pervasive computing environments introduce new challenges for application development, due to the heterogeneity of the devices involved. In practice, pervasive computing applications rely on general-purpose middleware to manage this heterogeneity, but this approach does not provide programming support and verifications specific to the pervasive computing environment.
We present a domain-specific IDL and its compiler, dedicated to the development of pervasive computing applications. Our IDL is based on that of CORBA and provides declarative support for concisely characterizing a pervasive computing environment. This description is (1) to be used by programmers as a high-level reference to develop applications that coordinate entities of the target environment and (2) to be passed to a compiler that generates a framework dedicated to the target environment. This process enables verifications to be performed prior to runtime on both the declared environment and a given application. Furthermore, customized operations are automatically generated to support the development of pervasive computing activities, such as service discovery and session negotiation for stream-oriented devices.
We have implemented a framework generator and have used it to generate frameworks targeting pervasive computing areas such as building surveillance, advanced telecommunications and home
automation. For more information, see:
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 services, with a special emphasis on specification. Our contribution focuses on the development of robust telephony services using DSLs. The collaboration with researchers in formal methods aims to use tools ( e.g.,theorem provers) to formalize and check properties specific to the DSL and the domain of telephony.
The Amigo project will focus on the usability of a networked home system by developing open, standardized, interoperable middleware. The developed middleware will guarantee automatic dynamic configuration of the devices and services within this home system by addressing autonomy and composability aspects. The second focus of the Amigo project will be on improving the end-user attractiveness of a networked home system by developing interoperable intelligent user services and application prototypes. The Amigo project will further support interoperability between equipment and services within the networked home environment by using standard technology when possible and by making the basic middleware (components and infrastructure) and intelligent user services available as open source software together with architectural rules for everyone to use.
Our work in the Amigo project is based on our DSL paradigm for protocol-based service families, presented in Section. We aim to develop DSLs for service creation. Indeed, the area of networked home systems, targetted by Amigo, relies on protocols for families of services ( e.g.,SIP, Session Announcement protocol, and Delivery Multimedia Framework). Furthermore, the underlying software architecture in this area relies on a client-server model. This situation should give us an opportunity to further illustrate our approach to making servers DSL-programmable.
The goal of this project is to design and develop a SOA architecture for embedded systems. More especially, it takes into account 3 levels of adaptation: (1) the component level (contracts on resources, performances...), (2) the coupling of components level (dependence, security...), and (3) the software architecture level (resource management, robustness...). A contract-based component approach will be considered to describe nonfunctional properties, to define mechanisms for coupling of components, and to define control mechanisms when executing elements of a component. This study will be illustrated by a concrete application. The research work should be a step toward solving key problems such as composition of services, security, component adaptation and performance.
To answer the fundamental need for innovations in terms of services, existing infrastructures have become increasingly open to external developers. Yet, this openness is done at the expense of the robustness. The aim of this project is to integrate approaches dedicated to finely tuning access to ressources into programming languages. This study will introduce a unique DSL to program services whose interface to resources is configured with respect to the different roles of programmers and so their capabilities.
The goal of this project is to develop a connection between the domain-specific languages and the model driven engineering. We would like to take profit from methodologies, techniques and tools that come from model driven engineering, in order to ease the design and implementation of a domain-specific language (DSL). In another side, the model driven engineering could be combined with the DSL techniques to complete the pure-model vision in a software engineering process where modelling concepts do not suffice or are not relevant. This work will be illustrated and validated with a concrete case study.
The goal of our research proposal is to place domain expertise at the centre of the software development process. It is aimed to lift the current limitations of software engineering regarding large scale software production, robustness, reliability, maintenance and evolution of software components. Our key innovation is to introduce a software development process parameterized with respect to a specific domain of expertise. This process covers all the stages of software development and combines the following three emerging approaches:
Domain-specific modelling, also known as model engineering;
Domain-specific languages, in contrast with general-purpose languages;
Generative programming and in particular aspect-oriented programming as a means to transform models and programs.
These three approaches have already demonstrated concrete and well-recognized software engineering benefits, in isolation; their combination will permit to cover the entire software development process dedicated to a specific domain of expertise.
The goal of this project is to develop a middleware based on an extended version of the SIP protocol to program and deploy home automation applications and to remotely control communicating home services.
In particular, this work aims at creating a platform that brings into play:
Sensors and actuators connected to the home network,
A LiveBox or residential gateway which acts as an interface between the home network and the ADSL communication network,
A software layer, named LiveBox layer, which manages communications between a remote terminal (mobile or fixed) and home services.
We have been exchanging visits and publishing articles with the following collaborators.
Julia Lawall, DIKU, University of Copenhagen (Denmark, Copenhagen).
DSLs, specialization, program analysis.
Calton Pu, Georgia Institute of Technology (USA, Atlanta).
DSLs and specialization for operating systems.
Gilles Muller, École des Mines in Nantes (France, Nantes).
DSLs, operating Systems.
Noha Ibrahim and Frédéric Le Mouë, INSA-Lyon (France, Lyon).
Software architectures for pervasive computing.
The Phoenix group has been visited by:
Paul Hudak (Professor in the Department of Computer Science at Yale University, U.S.A.), January 10-3;
Anne-Françoise Lemeur (Associate Professor in the LIFL laboratory at the University of Lille 1, France), March 5;
Stéphane Ducasse (Professor in the LISTIC laboratory at the University of Savoie, France), March 12-13;
Damien Pollet (Postdoctoral Scholar in the LISTIC laboratory at the University of Savoie, France), March 12-13;
Alexandre Bergel (Postdoctoral Scholar at Trinity College in Dublin, Ireland), March 26;
Nic Volanschi (Researcher, France), June 11;
Benjamin Goldberg (Associate Professor in the Computer Science Department at New York University, U.S.A.), June 26;
Sapan Bhatia (Postdoctoral Scholar at Princeton University, U.S.A.), June 29;
Anne-Marie Kermarrec (INRIA Senior Researcher, France), September 10;
Julia Lawall (Associate Professor at the University of Copenhagen (DIKU), Denmark), from November 11 to December 16;
Charles Consel has been involved in the following events as:
General Chair of the Sixth International Conference on Generative Programming and Component Engineering (GPCE 2007), October 1-3, 2007 in Salzburg, Austria;
Program Committee member of the Sixth International Conference on Aspect-Oriented Software Development(AOSD 2007), March 14-16, 2007 in downtown Vancouver, British Columbia;
Program Committee member of TOOLS EUROPE 2007 - Objects, Models, Components, Patterns, June 24-27, 2007 in Zurich, Switzerland;
Program Committee member of the ACM Conference on Principles, Systems and Applications of IP Telecommunications(IPTComm'07), July 19-20, 2007 in New-York, U.S.A;
Program Committee member of the 22nd International Conference on Object-Oriented Programming, Systems, Languages and Applications(OOPSLA 2007), October 21-25, 2007 in Montréal, Canada;
Program Committee member of the Tenth International Symposium on Practical Aspects of Declarative Languages(PADL 2008), January 7-8, 2008 in San Francisco, U.S.A., co-located with PoPL 2008;
Program Committee member of Telecom Track of the 30th International Conference on Software Engineering(ICSE 2008), May 10-18, 2008 in Leipzig, Germany;
Committee member of the SPECIF best thesis award (2005-2008);
Charles Consel has participated in the following defense committees (thesis and habilitation) as:
Committee member for Ali-Erdem Ozcan's PhD thesis, March 28, 2007, University of Grenoble, France;
Committee member (reviewer) for Jan Midtgaard's PhD thesis, June 20, 2007, University of Aarhus, Denmark;
Committee member (reviewer) for Mario Sudholt's HDR thesis, July 11, 2007, University of Nantes, France;
Committee member (reviewer) for Renaud Marlet's HDR thesis, November 23, 2007, University of Bordeaux 1, France.
Laurent Réveillère has been involved in the following events as:
Program committee member of the 6ème atelier sur les Objets, Composants et Modèles dans l'Ingénierie des Systèmes d'Information;
Member of the IFIP working group on Program Generation;
Program committee member of the journal on Domain-Specific Aspect Languages;
Secretary of the French chapter of ACM SIGOPS (ASF);
External reviewer for PADL'07, GPCE'07 and TOOLS'07.
Charles Consel and Laurent Réveillère have been teaching Master's level courses on:
Domain-Specific Languages and Program Analysis;
Telephony over IP (related protocols, the SIP protocol, existing programming interfaces). Students are also offered practical labs on various industrial-strength telephony platforms.
Charles Consel and Laurent Réveillère are also teaching other courses on Operating Systems, Web programming and Compilation.
Charles Consel gave a number of invited presentations.
Invited speaker at Macquarie University, February, 2007, Australia;
Invited speaker at the 31ème Journée de l'Observatoire Français des Techniques Avancées (OFTA), May 29, 2007, Paris, France;
Invited speaker at INNOVALIS Aquitaine - TIC et Services aux entreprises - Rencontres Industriels Chercheurs, June 12, 2007, Biarritz, France.