A Higher Level Abstraction for Mobile Computing Middleware Paul Grace 1 , Gordon Blair 1 and Sam Samuel 2 1 Computing Department, Lancaster University, Lancaster, LA1 4YR, UK. {p.grace@lancaster.ac.uk, gordon@comp.lancs.ac.uk} 2 Bell Laboratories, Lucent Technologies, Westlea, Swindon, SN5 7DJ, UK. {lsamuel@lucent.com} Abstract Mobile application developers now choose between many communication paradigms e.g. Remote Method Invocation, publish-subscribe, data sharing, mobile agents and tuple spaces. Each offers benefits to different application styles; however, their heterogeneity means applications and services implemented using different paradigms cannot interoperate. In this paper, we propose a higher-level abstraction based upon the Web Services Description Language (WSDL) that allows mobile clients to be developed independent of service implementations. To support this concept, a dynamic architecture (ReMMoC) that can reconfigure between paradigm implementations is required. 1. Introduction New middleware technologies are emerging to explicitly support the field of mobile computing. Mobile hosts need to interact with other hosts and services that they discover at their current location. However, the mobile domain is characterised by the problems of wireless network performance, limited end-system resources and changing environmental context. Therefore, research into mobile computing middleware has produced a variety of solutions to overcome these issues and better support the development of mobile computing applications. These encompass different paradigms e.g. remote method invocation, publish-subscribe, tuple spaces and data sharing. However, developing a mobile client utilising a single paradigm is not feasible, because it will encounter services implemented upon alternative middleware as it moves from location to location. A similar argument applies to complementary middleware support services, such as: location, naming and service discovery. Therefore, there is a real need to provide an abstraction to enable mobile client application developers to deal with the multitude of service implementations in an integrated manner. We propose that Web Services [1] can have a significant role to play here because its properties are well suited to middleware independence; it is already being utilised as the key technology in integrating existing heterogeneous middleware platforms [2]. At the core of the architecture is the Web Services Description Language (WSDL) [3]. This language separates abstract service definitions from concrete middleware implementation. Hence, this offers an interesting higher-level abstraction; also this alone is not enough. Support for context aware customisation of the underlying middleware is required to dynamically adapt between heterogeneous middleware. We argue that the web service abstraction must be complemented by the techniques of reflection, components and component frameworks to provide this mechanism. This paper documents the ReMMoC (Reflective Middleware for Mobile Computing) platform [4] that completes this implementation. Recently related work on middleware integration has emerged. Bridges that map one middleware to another e.g. SOAP to CORBA [5] are available. Uniframe [6] dynamically generates bridges between discovered heterogeneous components. The Model Driven Architecture (MDA) [7] provides a 4GL approach to develop distributed solutions, hiding the generation of mappings between middleware components. Furthermore, the Web Service Architecture [1] has emerged as a key technology; its open standards provide a middle ground for middleware mapping, removing the need for complex direct integration [8, 9]. However, these technologies are designed for heterogeneity in the fixed network, hence they are static in nature and do not co nsider the diversity of middleware paradigms. The structure of this paper is as follows. Section 2 details background information about the technologies of web services, reflection and components. Section 3 illustrates the ReMMoC middleware platform, including the higher-level programming abstraction it offers. Section 4 describes