An Extensible, Pervasive Systems, Application Server
Supervisor(s) and Committee member(s): Anders Andersen (supervisor), Gordon Blair (supervisor), Valerie Issarny (opponent), Carsten Griwodz (opponent), Weihai Yu (opponent)
Pervasive systems, with their interconnected mesh of devices, have some similarities, but pervasive systems are mostly diverse and will certainly change over time. Within these pervasive systems, the applications come in many varieties (e.g: context aware, QoS aware, multimedia, realtime, games, discrete, ubiquitous and domain specific as in health care applications, tourist application, etc.). The users expect that the applications are available on many devices (stationary and mobile and sometimes even ubiquitous).
Progress has been made in many of the research areas in pervasive computing. We have seen proposed solutions to service discovery, context modeling, semantic representation of context, etc. On the downside, many of these solutions have been designed ad-hoc as prototypes to illustrate proof of concept. To make the solutions commonly available we need a programming environment that can be extended to include solutions to well known problems so that the solutions can be reused in future application development.
Unfortunately, many of the existing middleware systems are too complex (due to their general purpose nature) and are therefore not a good match for pervasive application development. The goal of the thesis has been to design and implement a middleware system that is capable of extending itself with new solutions to functional and non functional pervasive system requirements. Because of the diversity in pervasive applications the detailed requirements for pervasive middleware technologies will vary significantly across the difierent application domains. As a result, a supporting pervasive middleware must at least meet these high level requirements:
- Extensible: Since both the underlying pervasive system and pervasive applications will change (evolve) over time the middleware needs to be able to adapt accordingly(e.g. meet the changing requirements).
- Promote modularization and reuse: Recurring solutions to both functional and non functional requirements should be part of the (evolving) offerings of the middleware. Modularization promotes separation of concerns and enables reuse of solutions to functional and non functional requirements.
- Tailored: Not all pervasive application domains need the same support from the middleware. It should therefore be possible to tailor the middleware to your needs.
- Lightweight: Many current container middleware systems try to solve all thinkable functional and non functional requirements and this makes them very complex. A lightweight yet extensible middleware will make it easier to understand how the middleware itself is designed and how it should be used.
- Easy to use: The abstractions made available by the middleware should be easy to use (i.e. the programming model should be simple). Extending the middleware should also be easy (i.e. should not require that you inspect and understand thousands of lines of internal code in the middleware as is the case with existing middleware systems that have not been designed to be intrinsically extensible).
- Monitoring and Control: Middleware introduces a level between the underlying system and the applications and it is necessary to be able to monitor and control the middleware layer in order to ensure proper behavior.
The global aim of this thesis is to investigate what it takes in terms of principles and patterns to create a container based middleware platform suitable for development of applications in the small scale and personal application domain (i.e. fulfilling the outlined high level requirements). The meaning of the term container based as used in the thesis is:
- The middleware has its own lifecycle (e.g. it exists as a separate entity).
- The middleware supports a deployment mechanism in order to add applications or services to it (i.e. the middleware can be viewed as a container that you can put applications and services into).
- The middleware persists even if no applications or services are contained within it.
The personal application domain is defined to be applications revolving around you as a person, using information relative to you (context) to deliver personalized services. It is envisioned that some of the personal information may be retrieved using sensors that measure something in your environment or something about you. It is also envisioned that parts of the personal services will be delivered to you by the use of your mobile phone or other devices that you carry with you all the time.
The aim is to develop a middleware that hides some aspects of the complexity in the “real world” (e.g. a pervasive system of networks and devices). The middleware needs to be extensible in order to adapt to enhancements and changes in the “real world”. The extendability is provided through services that can be added/modified/deleted to/from the middleware. S1, S2, etc. are examples of such services. Some of the services provide abstractions over persistence, some provide abstractions over telecom services and some provide abstractions over the pervasive system of networks and devices (i.e. sensors). Services may use abstractions provided by other services in the middleware. The middleware is thus extensible both “upwards” (towards end user application GUIs) and “downwards” (towards the “real world”).
The following major contributions have been made and they are described in more detail in the thesis.
- It has been proven that it is possible to support extensibility in this type of container based middleware by usage of a policy free microkernel that supports deployable extensions in the form of self contained system services.
- It has been proven that a lightweight IPO+S based context management strategy is suficient to realize advanced context management in this type of container based middleware system. The lightweight model can further be extended using the extensibility mechanisms provided by the middleware.
- It has been proven that a programming model based on POJO components and annotations to express metadata is suficient to provide a straight forward and easy to use programming model to express components in this type of middleware.
- It has been proven that in this type of middleware it is possible to express component composition through usage of explicitly expressed dependencies at deploy time together with chain class loading (of dependent components and their dependent components classes) and dependency injection at runtime. The middleware kernel supported dependency injection mechanism is triggered by usage of annotations in the POJO code.