Object-driven Application Design: from Mobility towards Ubiquitousness
by Davide Carboni, Gavino Paddeu and Stefano Sanna
Techniques and frameworks that assist designers and programmers in the development of applications that are seamlessly portable from one device to another are still a challenge. The e-mate project at the Center for Advanced Studies, Research and Development in Sardinia (CRS4) tackles this issue proposing a technique based on the object-oriented paradigm with a strong focus on the delivery of services on multiple platforms.
At the present, users must carry one or more portable devices that act as data and program repositories or as connection devices. These devices need to be administered, backed-up, and synchronized; their batteries need to be replaced and recharged. This is not a 'pervasive technology', but rather an 'invasive technology'. The next step towards a new concept of services that support user mobility is known as 'ambient intelligence' where computers are no longer repositories for data and programs, but become windows to the environment: services and applications. Ubiquitous applications adapt themselves to the end user delivery context, becoming accessible from any device and giving the user the perception of moving in an empowered environment. Such requirements emphasize the concept of the 'position': 'ubiquitous computers must know where they are'(Weiser).
User mobility implies that applications should be accessible from a number of different channels: from a web browser, from a WAP phone or from an Interactive Voice Responder (IVR) machine. A given channel can provide multiple interaction modalities. For instance, a Windows-Icons-Mouse-Pointing (WIMP) desktop application can make it possible to dictate texts by means of a voice recognizer. Applications should be designed according to the principle of: design once, display anywhere.
The e-mate Project
Integrated development environments are aimed at building applications whose delivery context is known a priori, limiting their reuse in different environments. In the e-mate project, we have designed and implemented an architecture to support the development of applications which are seamlessly deliverable in multiple contexts. Developers can design and implement the software, abstracting from the technology details and focusing only on application concepts and relations between them. For instance, in the development of a 'Personal Agenda', developers only deal with conceptual details such as appointment, person, address, calendar, etc. and conceptual relations such as 'which addresses are relevant to a given person'; 'which persons are involved in a given appointment' and so on. Any other concern about technology constraints such as network protocols, transaction management, service discovery, data persistency, adaptation of components to user terminals, and user interface presentation, should be of no importance as they are already addressed by the e-mate infrastructure.
The rationale behind e-mate is influenced by the object oriented paradigm. Objects are self-contained, behavioural complete pieces of data with variables and procedures. They are reactive entities which are activated whenever someone invokes one of their procedures. The reaction of an activated object is to produce another object (the result) and/or a side effect changing its internal state.
Objects can be considered as building blocks, able to react and therefore to interact. Our system provides a viewing/controlling mechanism to automatically fill the gap between the end-users and the application objects allowing direct interaction between them. This 'bridge' is implemented for any type of terminal used by the user. Thus, we can put into practice a design based solely on the definition of business related objects and their relations.
The issue is to take business objects and generate a user interface aimed at interacting visually with them. To address this critical point we have developed MORE (Multi-platform Object REnderer). The rendering process uses reflective capabilities of the Java language to extract the 'displayable' information directly from the code. Such information consists of the set of public procedures and public variables that are incapsulated in the model object.
Complex models are viewed as composite graphical objects and the rendering process is applied recursively until atomic interactors are obtained. The advantage of this approach is that the same model can be accessed from any device for which a rendering engine has been implemented (see the Figure).
The rendering process takes into account the end-user device. Since displaying and communication capabilities may vary completely on different devices, the engine adapts the model description (in terms of data format and size) to take advantage of the target user interface and available communication channel. The current implementation uses XML as a protocol language to convey the interaction between the end-user and the application business objects. Depending on the processing capabilities of the client platform, the user can perform a simple interaction or eventually access an enhanced set of native graphical components that fully exploit the capabilities of the device.
Mobile devices rely on wireless (and often expensive) connections, therefore smart strategies have been implemented to reduce bandwidth occupation. The rendering engine sends only portions of interface that are truly renderable by the client; on the other side, the client tries to perform most of the computing locally, using the communication channel only when required. Finally, since most mobile devices have small displays and one-hand-operations user interfaces, the rendering engine sorts interface elements by usage, giving faster access to frequently used functions.
Some specific applications require both interface and data adaptation to support mobile client delivery. For example, Location-Based Services require mobile cartography functionalities and present critical issues when deployed on mobile terminals over wireless connections. To address such issues, we have developed a lightweight version of the Geographic Markup Language (called 'compact GML'), which is used by the rendering engine to encode maps according to client displaying capabilities.
The e-mate project was successfully completed in early 2003 and some of the results will be used in future activities. For example, we plan to release the Multi-platform Object REnderer as Open Source software and improve it in terms of usability, and the cGML will be evaluated and used in an EU Project (EurEauWeb IST-34182).
CRS4 - Networked Distributed Applications: http://www.crs4.it/nda
E-mate project: http://www.crs4.it/nda/e-mate
Compact GML: http://www.crs4.it/nda/cgml
Gavino Paddeu, CRS4, Italy
Tel: +39 070 925 0284