Work on APAM has allowed for the publication of several scientific papers on international conferences and workshops. Here we present the list of the most representative APAM related publications produced in our research team.

Resource Management for Pervasive Systems.
Jacky Estublier, German Vega and Elmehdi Damou.
In Proceedings of the 8th International Workshop on Engineering Service-Oriented Applications.
Shanghai, China, 2012.
Abstract: In pervasive contexts, many different applications, from different providers, will compete for access to resources: physical resources like sensors and actioners, as well as for software resources (services). Sensors provide information about the state of the world, and actioners change the world which can put goods and persons at risk. At least for safety reasons, it is critical to closely control, at any point in time, and in all circumstances, which service(s) are using which resource(s). Pervasive systems face the difficult challenge of providing some safety, reliability and resilience properties, verified at design and compile time, while executing in many different configurations unknown statically, with dynamic services and devices, competing for resources with unknown applications and facing unpredictable configuration changes. This challenge can be seen from two perspectives: how to design and develop pervasive applications in such a demanding context; how to execute these applications while satisfying the requirements despite the unpredictable context and changes. This paper discusses the requirements for future pervasive gateways and presents the APAM dynamic service middleware. APAM interprets at run-time a formalism describing the desirable behavior of a system, and enforces this behavior in a very wide range of unplanned configurations while resisting the many changes that may occur.
Keywords: Service Oriented Computing, Service Selection, Service Composition, Composite services, Software engineering environments.
Model-Driven Design, Development, Execution and Management of Service-Based Applications.
Diana Moreno-Garcia and Jacky Estublier.
In Proceedings of the 9th International Conference on Services Computing (SCC).
Honolulu, Hawaii, USA, 2012, pp.470-477.
Abstract: Service-based software applications, such as pervasive and ubiquitous ones, are increasingly embedded in our daily lives integrating smart communicating devices. Usually, changes in the execution context of these applications occur unpredictably over time, such as dynamic variations in the availability of the used services and devices, or of the user location and needs. This unpredictable variability in the execution contexts makes impossible to know at design-time the exact conditions under which these applications will be used and the services that will be most suited at a given time. Therefore, the architecture of such applications cannot be fully defined at design-time. These applications must be defined in abstract and flexible ways, allowing incremental composition and dynamic adaptation to their execution context at runtime. In this paper, we present a model-driven approach for designing, developing, executing and managing service-based applications. At design-time, an application is mainly defined by its requirements and goals. The application definition can be extended to add specific functional or non-functional concerns, such as dynamic adaptation, deployment or distribution. At development-time, the application can be automatically and incrementally composed, ensuring its consistency with respect to its definition. At runtime, the application execution is supported and controlled by our runtime environment.
Keywords: service-based composition, design and development engineering environments, execution platforms.
Reconciling Components and Services: The APAM Component-Service Platform.
Jacky Estublier and German Vega.
In Proceedings of the 9th IEEE International Conference on Services Computing (SCC).
Honolulu, Hawaii, USA, 2012.
Abstract: For Component Based Software Engineering (CBSE), an application is a strongly structured and rigid assembly of components. Conversely, Service Oriented Computing (SOC) is very flexible and is a good candidate for supporting dynamic applications. Unfortunately dynamic applications are software applications and as such they need to be clearly structured and managed (as with CBSE), and they need flexibility and dynamism as with SOC. No platform today satisfies both needs. This paper presents the Component-Service model that combines well controlled structure and dynamism, and its implementation into the APAM component-service platform.
Keywords: CBSE, SOC, SOA, service platform, component platform, adaptability.
Managing Multiple Applications in a Service Platform.
Jacky Estublier and German Vega.
In Proceedings of the International Workshop on Principles of Engineering Service-Oriented Systems (PESOS).
Zurich, Switzerland, 2012.
Abstract: Information hiding and hierarchical decomposition are the corner stone of Software Engineering best practices. These principles have been applied in methods, architectures, programming languages, and run-time platforms. It is therefore a big surprise to notice that the recent dynamic service platforms, like OSGi, do not make use of these principles. In OSGi, all services are visible; a client asking for an interface will be wired to any service, randomly selected and implementing that interface, which makes almost impossible protection and encapsulation. Nevertheless, OSGi is very successful for its almost unique capability to support dynamicity; and because the current practice is to run a single application per platform. Unfortunately, the future of gateways, like OSGi, is to manage the "discovery", access and control of resources (logical as well as physical (sensors, devices)) shared by many applications. In the near future, OSGi will have to scale from a light weight mono-application gateway to a full-fledged dynamic platform. We have developed a layer on top of OSGi called APlication Abstract Machine (APAM) which provides OSGi dynamic capabilities, but also introduces a composite concept allowing multiple applications to cover the range isolation/collaboration from "black-box" (information hiding and hierarchical decomposition) to "scrambled eggs" as in service platforms, and through a variety of grey and white boxes with variable degrees of collaboration, sharing and control. The paper presents the state of practice, the challenges future dynamic platforms have to address, and how the APAM platform provides a solution to these issues. An assessment of the first APAM experimentations concludes the paper.
Keywords: service platform, dynamic application, encapsulation, sharing, protection, composite.
Model-driven execution of service-based applications.
Diana Moreno-Garcia and Elmehdi Damou.
In Proceedings of the 7iemes journees sur l'Ingenierie Dirigee par les Modeles (IDM).
Lille, France, 2011.
Abstract: The design, development and execution of dynamic applications is challenging since their execution context is unknown at design-time. In this paper we present a model-driven approach where a service based application (its goals and properties) is defined at design-time by several models. At runtime, these models are used by our execution platform, the APplication Abstract Machine (APAM), in order to control the application's execution. The APAM delegates the resolution of services to specific managers, in order to ensure/enforce the fulfillment of the application's goal.
Keywords: service-based applications, MDE, dynamic systems, service execution platforms, evolution, models@runtime.
Extensible and General Service-Oriented Platform. Experience with the Service Abstract Machine.
Eric Simon, Jacky Estublier and Diana Moreno.
In Proceedings of the International Conference on Service Computing (SCC).
Miami, Florida, USA, 2010.
Abstract: Services are successful for applications with high levels of dynamicity and interoperability. Ironically the actual Service-Oriented Computing (SOC) technologies are such that interoperability is problematic if different platforms are used simultaneously, and dedicated tools for the support of most engineering tasks are essentially missing. We address the interoperability issue through the definition of a Service Abstract Machine (SAM) that observes a set of heterogeneous service platforms running on different machines and dynamically builds a reliable and homogeneous model of the global state. Conversely, changes in the state model, through SAM API are dynamically translated into the corresponding action(s) in the actual underlying SOC platforms. Evolution, extensibility and engineering support are addressed by dedicated software engineering environments that fully rely on the state model, as if SAM were a real SOC platform. The paper discusses the challenges we faced and the limits of our approach. We show how the system has been implemented, and we draw the early lessons of SAM second year of use.
Keywords: abstraction, SOC, runtime.
Automating Component Selection and Building Flexible Composites for Service-Based Applications.
Jacky Estublier, Idrissa Dieng and Eric Simon.
Communications in Computer and Information Science, 2010, Volume 69, II, 93-106.
Abstract: Service Oriented Computing allows defining applications in which components (services) can be available and selected very late during the development process or even "discovered" at execution time. In this context, it is no longer possible to describe an application as a composite entity containing all its components; we need to perform component selection all along the application life-cycle, including execution. It requires describing an application at least partially by its requirements and goals, leaving room for delaying selection; the development system, and the run-time must ensure that the current component selection satisfies, at all time, the application description. In this paper, we propose a concept of composite addressing the needs of advanced and flexible service-based applications, automating component selection and building composites satisfying the application description and enforcing minimality, completeness and consistency properties. We also propose tools and environment supporting these concepts and mechanisms in the different phases of the application life-cycle.
Keywords: service-based applications, MDE, dynamic systems, service execution platforms, evolution, models@runtime.
Opportunistic Computing Experience with the SAM platform.
Jacky Estublier, Idrissa Dieng, Eric Simon and Diana Moreno.
In Proceedings of the 2nd International Workshop on Principles of Engineering Service-Oriented Systems (PESOS).
Cape Town, South Africa, 2010.
Abstract: Service-Oriented Computing (SOC) technology allows one to build applications exhibiting opportunistic, non deterministic and dynamic behavior. Unfortunately in SOC technologies these features are uncontrolled and software application is not an explicit concept. The challenge therefore is to provide a well defined application definition (an application model) in which the opportunistic behavior is used only when convenient, and to provide an extended SOC platform which enforces compliant application execution. This paper discuses the issues and shows the solution proposed by the SAM platform.
Keywords: Service Oriented Computing, Service Selection, Service Composition, Composite services, Software engineering environments.
Flexible composites and automatic component selection for service-based applications.
Jacky Estublier, Idrissa Dieng, Eric Simon and German Vega.
In Proceeding in 4th Int. Conf. on Evaluation of Novel Approaches to Software Engineering (ENASE).
Milan, Italy, 2009.
Abstract: In traditional Software Engineering approaches, an application is described as a composite entity containing all its components. This approach is no longer relevant in modern Software Engineering, at least when developing service-based applications where some components (services) are selected very late during the development process or even "discovered" at execution. This new context requires describing an application in a more flexible way, leaving room for delayed selection. In turn, if component selection can be performed all along the life-cycle, an application description must explicitly include the application requirements and goals and the system must at least ensure that the selections satisfy the application description. In this work, we propose a concept of composite addressing the needs of the advanced and flexible service-based applications, automating component selection and building composites satisfying the application description and enforcing minimality, completeness and consistency properties. We also propose tools and environment supporting these concepts and mechanisms in the different phases of the application life-cycle.
Universal and Extensible Service-Oriented Platform Feasibility and experience: The Service Abstract Machine.
Jacky Estublier and Eric Simon.
In Proceeding of the 2nd IEEE International Workshop on Real-Time Service-Oriented Architecture and Applications (RTSOAA).
Seatle, USA, 2009.
Abstract: Service-based technology is becoming widespread, and many service oriented platforms are available with different characteristics and constraints, making them incompatible. Consequently, designing, developing and executing an application using services running on different platforms is a challenging task if not impossible. A first challenge is to provide an ideal and virtual SOC platform; ideal because it subsumes the actual real SOA platforms, virtual because it delegates the execution to these real platforms. But since "ideal" depends on the domain; the second challenge is to provide extensibility mechanisms allowing to define what ideal means in a given domain and to provide the engineering support for the design and development of service-based application dedicated to such domains. The paper describes how we addressed these challenges, and to what extent they have been met.
Keywords: service platform, extensibility, abstract service machine.
iPOJO: an Extensible Service-Oriented Component Framework.
Clement Escoffier, Richard Hall and Philippe Lalanda.
In Proceedings of the 5th IEEE International Conference on Services.
Salt Lake City, USA, 2007.
Abstract: Nowadays, application needs loose-coupling approach allowing asynchronous evolution. Service-oriented computing is a paradigm that utilizes services as fundamental elements for application design, and fulfills loose-coupling requirement. However, services themselves are typically only used to abstract remote functionality; the service-oriented approach proffered by web services does not promote an implementation model managing service dynamism. This paper proposes iPOJO, a service-oriented component to implement services. However, this component model does not only manage dynamic service interactions; it also provides an extensibility mechanism. IPOJO Components can manage other non-functional properties as persistency, security, autonomic management, eventing... To illustrate the approach, the paper presents a usage of iPOJO on a residential gateway.
Autonomous Adaptation to Dynamic Availability Using a Service-Oriented Component Model.
Humberto Cervantes and Richard Hall.
In Proceedings of the International Conference on Software Engineering (ICSE).
Edinburgh, Scotland, 2004.
Abstract: This paper describes a project, called Gravity, that defines a component model, where components provide and require services (i.e., functionality) and all component interaction occurs via services. This approach introduces service-oriented concepts into a component model and execution environment. The goal is to support the construction and execution of component-based applications that are capable of autonomously adapting at run time due to the dynamic availability of the services provided by constituent components. In this component model the execution environment manages an application that is described as an abstract composition that can adapt and evolve at run time depending on available functionality. The motivation of Gravity is to simplify the construction of applications where dynamic availability arises, ranging from modern extensible systems to novel computing approaches, such as context-aware applications.