INTRODUCTION
The convergence of two technological developments has made mobile computing a reality. In the last few years, developed countries spent large amounts of money to install and deploy wireless communication facilities. Originally aimed at telephone services (which still account for the majority of usage), the same infrastructure is increasingly used to transfer data. In parallel, wireless LAN technologies are providing hotspot coverage in many high-traffic locations. The second development is the continuing reduction in size of computer hardware, leading to portable computation devices such as laptops, palmtops, or functionally enhanced cell phones. Given current technology, a user can run a set of applications on a portable device and communicate over a variety of communication links, depending on his/her current location.
As will be explained in more detail later on, the mobile computing environment is highly dynamic. Available bandwidth changes by orders of magnitudes, based on the selected wireless access technology. Also, portable devices differ in processing power, memory, display capabilities, and other characteristics. It is generally argued that applications should “adapt” to the current environment, for example by filtering and compressing data or by changing the functionality offered to the user. Some researchers even argue that all future applications, not just the ones intended for execution on mobile devices, will have to be able to adapt to changing requirements and changing implementation environments on time scales from microseconds to years (Kavi, 1999). This article reviews the work on adaptive mobile applications and provides an outlook on future trends.
The alternative to adaptive applications is to either implement a single application that is designed for the lowest common denominator (in terms of resource availability) or multiple functionally identical or similar binaries, tuned for specific environments. The former will needlessly sacrifice application features when running in more resource-rich environments. The latter approach is an inferior solution as well, for a number of reasons. The user of a portable device has to install and maintain
multiple applications, which is a drain on the limited storage capabilities typically found on those devices. It also potentially results in different user interfaces and causes high software development overheads when developing the “same” mobile application multiple times. Finally, it forces the user to identify the current execution conditions and select the “right” application.
The next section will review the motivation for adaptive approaches towards mobile application design. We will then briefly review traditional approaches to adaptive mobile applications, followed by a discussion of mobile middleware that is intended to support adaptive mobile applications. The article finishes with a brief conclusion of the state-of-the-art and identifies areas of future work.
BACKGROUND
Wireless communication and portable devices make it possible for mobile users to have access to information anywhere and anytime. Designing, implementing and deploying applications that work well across all portable devices and across a wide range of wireless access networks is non-trivial.
There are at least three common factors that affect the design of mobile applications: portable devices, network connection, and mobility. Portable devices vary from one to another in term of resource availability. Devices like laptops can offer fast CPUs and large amount of RAM and disk space while others like pocket PCs and phones usually have scarce resources. It is either impossible or too expensive to augment the resource availability. Hence, applications should be designed to achieve optimal resource utilization. In general, the design of portable devices strives for properties such as size, weight, durability and long battery life. Different devices will emphasize different trade-offs between CPU speed, memory, I/O capabilities, and power consumption, providing very heterogeneous execution environments for mobile applications.
Network connection in mobile scenarios is characterized by limited bandwidth, high error rate, higher cost, and frequent disconnections due to power limitations, available spectrum, and mobility. Wireless communication is more difficult to achieve than wired communication because the surrounding environment interacts with the signal, blocking signal paths and introducing noise and echoes. Therefore, mobile application designs need to be more concerned about the network conditions than applications designed for fixed networks. Many wireless and mobile networks such as WaveLAN are organized into geographically defined cells, with a control point called a base station in each of the cells. Devices within the same cell share the network bandwidth; hence, the bandwidth rapidly decreases whenever a new device joins the cell. Portable devices may move around different areas with no coverage or high interference that cause a sudden drop in network bandwidth or a loss of connection entirely. Unpredictable disconnection is also a common issue that frequently occurs due to the handoff process or shadowed areas. Most wireless network services charge a flat fee for their service, which usually covers a fixed number of messages. Additional charges are levied on per packet or per message basis. In contrast, the cost for sending data over cellular networks is based on connection time instead. This forces mobile users to connect for short periods of time.
Physical device mobility can greatly affect network connection, which accordingly has to adapt to user mobility by reconnecting the user with respect to a new location. Portable devices may interact with different types of networks, services, and security policies as they move from one area to another. This requires applications to behave differently to cope with dynamic changes of the environment parameters. As a consequence, mobile applications also have to cope with a much greater variation in network bandwidth: bandwidth can shift from one to six orders of magnitude between being plugged into the wired network versus using (different) wireless access networks.
The constraints and limitations mobile applications face are not a product of current technology, but they are related naturally to mobility. Together, they complicate the design of mobile applications and require rethinking traditional approaches to application design. Any feasible approach to mobile computing must strike a balance between conflicting demands. This balance cannot be static, as the execution environment of mobile applications varies; it must react, or in other words, the applications must be adaptive.
ADAPTIVE MOBILE APPLICATIONS: TRADITIONAL APPROACHES
Designing adaptive applications is an active research area. Traditionally, most work focused on the wireless link(s). Early work provides general solutions that do not change the TCP semantics but focus on improving TCP throughput over wireless links; see for example Balakrishnan (1995). While this addresses issues such as high link error rates and spurious disconnections, it does not address the low and highly variable bandwidth characteristic of mobile computing.
A second group of approaches adapts to the scarce and varying wireless link bandwidth by filtering and compressing the data stream between a client application on a portable device and a server executing on a stationary host. Data compression is done at one of two places. Bolliger (1998) and Seshan (1997) enhance the server to generate a data stream that is suited for the currently available bandwidth. This typically represents an end-to-end approach, which is well known in the networking and system literature. Most other proposals (Angin, 1998; Fox, 1998) extend the client-server structure to a client-proxy-server structure, where a proxy executes in the wireless access network, close to the portable device. This proxy-based approach filters and compresses the data stream originating from the server to suit the current wireless bandwidth. Joshi (1997) incorporates both end-to-end and proxy-based approaches, using each as appropriate, to support Web access from mobile platforms. For example, tasks such as complex filtration, which require significant computational resources, are done in an end-to-end manner. The proxy-based approach, on the other hand, is used when the server is not able to generate the appropriate data stream.
A third, complementary approach, focuses on the computational effort (Kunz, 2000). Mobile applications, especially ones that require intensive computation (for example, video decoding), can be divided dynamically between the wired network and the portable device according to the mobile environment and to the availability of the resources on the portable device, the wireless link, and the wired network. The access network supports the mobile application by providing proxy servers that can execute parts of the application code. This may increase the performance of applications and reduce the power consumption on portable devices since offloading computation to the proxies in the wired network will reduce the CPU cycles and memory needed to achieve certain tasks at portable devices.
FUTURE TRENDS: MOBILE MIDDLEWARE
The early approaches reviewed in the previous section typically provide toolkits that support specific adaptation ideas. To generalize this effort, support for adaptive mobile applications should be embedded into appropriate mobile middleware. Traditional middleware systems, like CORBA and DCOM, have achieved great success in dealing with the heterogeneity in the underlying hardware and software platforms, offering portability, and facilitating development of distributed applications. However, these systems are based on the assumptions that the distributed applications will run in a static environment; hence, they fail to provide the appropriate support for mobile applications. Therefore, mobile applications need a middleware that facilitates adapting to environment variations.
Based on the mobile computing challenges reviewed previously, mobile middleware should meet the following requirements: Asynchronous interaction tackles the problems of high latency and disconnected operations. It allows mobile clients to issue a request for a service, disconnect from the network, and collect the result later on. This type of interaction model reduces bandwidth consumption, achieves decoupling of client and server, and elevates system scalability. Re-configurability is the process of adding a new behavior or changing an existing one during system runtime. Dynamic reconfiguration of system behavior and operating context at runtime may require reevaluation and reallocation of resources. Reconfiguration could be based on context information. Adaptivity allows applications to modify their behavior instead of providing a uniform interface in all situations. The middleware needs to monitor the resource supply/ demand, compute adaptation decisions, and notify applications about changes. Context-awareness of client capabilities, changes to network conditions, and the ability to change the behavior of the system as circumstances warrant are required to build an effective and efficient adaptive system. The context includes device characteristics, user’s location, user’s activities, and other resources. The system performance can be increased when information context is disclosed to the application to assist middleware in making the right decision. Finally, lightweight load should be considered when constructing middleware for mobile computing. Middleware should not increase the computational load on the most power-consuming components such as processor, network interface, and so forth. Middleware implementations often include a number of unused features that can be entirely omitted to reduce the computational load.
We identified four categories of mobile middleware: reflective, tuple space, context-aware, and event-based middleware. Reflective middleware like DynamicTAO (Kon, 2000) and Open-ORB (Blair, 2001) are built around the concept of component frameworks (CF). Components can be developed independently, distributed in binary form, and combined at run time. Reflection provides a meta-interface to inspect the internal behavior of the middleware and, if it is necessary, alter its behavior to better match the system’s current operating environment. The main motivation of this approach is to make the middleware more adaptable to its environment and better able to cope with changes. Open problems are consistent dynamic reconfiguration and performance. There is some early work in this area that has focused on developing reconfiguration models and algorithms that enforce well-defined consistency rules while minimizing system disturbance (Kramer & Magee, 1990). In addition, all reflective systems impose a heavy computational load that causes significant performance degradation on portable devices.
Tuple-space systems such as LIME (Picco, 1999) and TSpaces (Wyckoff, 1998) exploit the decoupled nature of tuple spaces for supporting disconnected operations in a natural manner. A tuple space is a globally shared, asso-ciatively addressed memory space that is used by processes to communicate. Client processes create tuples and place them in the tuple space using a write operation. Also, they can concurrently access tuples using read or take operations. This communication paradigm fits well in a mobile setting where logical and physical mobility is involved. By default they offer an asynchronous interaction paradigm that appears to be more appropriate for dealing with intermittent connection of mobile devices, as is often the case when a server is not in reach or a mobile client requires to voluntary disconnect to save battery and bandwidth. Using a tuple-space approach, we can decouple the client and server components in time and space. In other words, they do not need to be connected at the same time and in the same place. Tuple-space systems support the concept of a space or spaces that offer the ability to join objects into appropriate spaces for ease of access. This opens up the possibility of constructing a dynamic super space environment to allow participating spaces to join or leave at arbitrary times. The ability to use multiple spaces will elevate the overall throughput of the system. One problem with tuple-space middleware systems is their excessive memory requirements, making them impractical for most portable devices available to-date.
Context-aware systems provide mobile applications with the necessary knowledge about the execution context in order to allow applications to adapt to dynamic changes in mobile host and network condition. The execution context includes but is not limited to: mobile user location, mobile device characteristics, network condition, and user activity (i.e., driving or sitting in a room). However, most context-aware applications are only focusing on a user’s location. Nexus (Fritsch, 2000), for example, is designed to be a generic platform for location-aware applications. Reflective middleware may also improve the development of context-aware services and applications. For example, Capra (2003) has suggested the use of metadata and reflection to support context-aware applications. However, overall, limited attention has been given to contexts other than location. It is necessary to take into account other types of context awareness such as internal resources (i.e., memory size, battery and processor power) or external resources (i.e., network bandwidth and connectivity quality). More efforts need to be directed towards an easy context representation and simple interfaces that enable the applications to interact with the underlying middleware.
In event-based systems, clients first announce their interest in receiving specific events and then servers broadcast events to all interested clients. Hence, the event-based model achieves a highly decoupled system and many-to-many interaction style between clients and servers. Examples are JEDI (Cugalo, 2001) and STEAM (Meier, 2002). Most existing systems do not combine traditional middleware functionality (i.e., security, QoS, transactions, reliability, access control, etc.) with the event-based paradigm. In addition, the developers are responsible for handling the low-level event transmission issues. Current publish/subscribe systems are restricted to certain application scenarios such as instant messaging and stock quote dissemination. This indicates that such systems are not designed as general middleware platforms. The majority of event-based middleware architectures are based on a logically centralized component called event dispatcher or broker. This component acts as a gateway between interacting components and hence has global knowledge about all the generated events and subscription requests. However, this centralized design often results in performance bottlenecks. Furthermore, not all event brokers provide a persistent buffer that can store all events for the provision of a reliable event service. There is also no support for the notion of composite events. Composite-event services allow clients to sign up with several event sources and receive event notifications in form of composite events. A special mechanism is needed to model event arrival from different sources and to specify composite events. This however may complicate the system architecture and incur extra cost.
CONCLUSION
Mobile computing is a relatively new field. While the challenges arising from mobility and the limitations of the portable devices are relatively well understood, there is no consensus yet as to what should be done to address these challenges. A comprehensive solution has to address many different aspects, such as the issue of dynamically changing bandwidth, the power, computational, and other limitations of the portable devices, or the varying availability of services in different environments. Traditional approaches to these challenges involved the design and implementation of proxies to either transparently intercept the data stream or to cooperate with the client application in the portable device in offloading computational tasks. To generalize this work, such services are expected to be embedded in middleware for mobile applications. Traditional middleware systems, such as CORBA and Java RMI, are based on the assumption that applications in distributed systems will run in a static environment; hence, they fail to provide the appropriate support for mobile applications. This gives a strong incentive to many researchers to develop modern middleware that supports and facilitates the implementation of mobile applications. To date, there is no single middleware that can fully support the requirements for mobile applications. Several solutions have considered one aspect or another; however, the door for further research is still wide open.
Table 1 provides a simple comparison of mobile middleware solutions with respect to the identified requirements for mobile computing. As can be seen, no single middleware paradigm covers all requirements. Based on our analysis, an evolution of reflective mobile middleware appears most promising, however. The key challenges are to reduce the complexity and size of such middleware for thin clients and to efficiently support asynchronous interaction styles
Table 1. Requirements analysis for modern middleware
.
KEY TERMS
Context-Awareness: Makes applications aware of the dynamic changes in execution environment. The execution context includes but is not limited to: mobile user location, mobile device characteristics, network condition, and user activity.
Event-Based Systems: Systems in which clients (subscribers) have to express (subscribe) their interest in receiving particular events. Once clients have subscribed, servers publish events, which will be sent to all interested subscribers.
Middleware: An enabling layer of software that resides between the application program and the networked layer of heterogeneous platforms and protocols. It decouples applications from any dependencies on the plumbing layer that consists of heterogeneous operating systems, hardware platforms and communication protocols.
Portable Device: Computational device that is small and can be carried by its user, such as smart cell phones, PDAs, and laptops. Unlike stationary devices, the design of portable devices typically trades-off CPU speed, memory, I/O facilities, and so forth for reduced power consumption and size.
Reflective Software: Computational process that reasons about itself, comprising an ingredient process (interpreter) formally manipulating representations of its own operations and structures.
Tuple Space: A globally shared, associatively addressed memory space that is used by processes to communicate asynchronously, based on the notion of tuples and tuple matching.
Wireless Communication: Data communication that does not require a wired connection between communicating peers, typically using radio or infrared transmissions.
