Mobility is one form of achieving the ubiquitous computing paradigm. Ubiquitous computing aims to make computers omnipresent and transparent in the environment. This can be done in two distinct but cooperative ways: (a) pervasively by replicating the technology in the environment and (b) in mobile form, by carrying the technology around with us.

Fig. 1 - Pervasive v.s. mobile

We are interested in ways that help to better organize mobile software applications that run in small devices, using high level software abstractions to manage separation of concerns. Such abstractions hide the details of the middleware used and make it easier to build and maintain mobile applications.

Many general purpose software abstractions can be used as well for mobile applications. However they must be adapted to take care of peculiarities of mobile software, namely they must be optimized not to introduce many layers of abstraction, which is intolerable for applications that run in small devices, like mobile phones and small PDA-s.

Fig. 2 - The container abstraction and the managed components

We propose to reuse the container software abstraction to organize mobile software applications. A container is a kind of wrapper module that manages technical concerns for other application components that live inside it. The component benefits form the transparent technical related services offered by the container. This organization separates the technical functionality from the specific application logic, and the technical logic can be reused for application families. The technical concerns code is written only once and application programmers do not need to address and debug technical concerns every time they write a custom application. For mobile applications such organization could be very useful given that it hides middleware details in a centralized way. Ideally porting a family of mobile applications to a new middleware, or maintaining it as the different versions of a given middleware platform change its features, would require maintaining only the container. This is very important for mobile applications where the middleware technology evolves very often nowadays.

The container abstraction is made known from enterprise containers like EJB, and COM+ that address e-commerce business application concerns. The main issue for enterprise containers is the scalability of the container, to support a big number of concurrent clients. When we speak of mobile containers we are bringing the container concept to client applications and the main issue for mobile applications is the performance of the container itself. This way we speak of logical mobile containers. This means that the container exists as a logical module when we build the application components, but it is not a separate module when the application runs. We use code generation to achieve separation of concerns and implement logical mobile containers. This way we can keep the number of abstraction layers at minimum, while benefit from container abstraction.

Fig. 3 - Mobile container components

For mobile applications we would also like to keep the functionality at a minimum in the mobile client and move all possible heavy operations in the server side. This is unlike in an enterprise container where the client code contains only the proxy and virtual bus manager code. In a mobile container the server side may contain arbitrary complex code, which we prefer to execute in the server, and only transfer the results to the mobile device. The server side also interfaces the mobile application with the rest of environment.

More Information (slides PDF A4)

To evaluate the proposal a prototype for J2ME MIDP is being built. More details can be found at MobCon Prototype >>.