The popularity of personal digital assistants (PDAs) is increasing, along with their computational power. This book explores how to develop Java applications for the Palm and PocketPC, the two principal families of PDA devices, using the Java 2 Micro Edition (J2ME) and PersonalJava platforms. The book is oriented toward Java programmers who want to understand the tradeoffs involved in the development of applications for resource-constrained devices. Therefore, a good knowledge of Java is required.

Chapter 1, “Java 2, Micro Edition: Configurations, Profiles and Virtual Machines,” discusses the J2ME standard, and how it relates to PDAs. The description is divided into a discussion of configurations, or building blocks for basic functionalities, and profiles, which are built on top of such configurations. Two different J2ME configurations are described: the connected limited device configuration (CLDC), targeted at devices with low processing resources and a limited amount of memory (about 128Kb), and the connected device configuration (CDC), a superset of CLDC for systems with more memory and better network connections. For each configuration, the available profiles are described, comparing different implementations of the mobile information device profile (MIDP). The description is very concise and clear, and with this information, the reader should be able to find the best platform for a given application. References are provided for documentation and implementation downloads.

Chapter 2 answers the next question that follows platform choice: “Which PDA?” This chapter is especially important, even in the context of Java programming, because there are portability issues between PocketPC and Palm OS devices that should be taken into account. The chapter discusses which Java runs on which platform, using tables to summarize the differences between both families, together with the costs of particular models and their hardware characteristics. It is a pity that, as frequently happens in the context of computer architecture, the rapid evolution of hardware and system software makes some of this information outdated.

Next, chapter 3 is devoted to setting up the simulation environment. The author uses Apache Ant (a build tool), the Java software development kit (SDK), the Palm emulator, and other freely available tools instead of a commercial integrated development environment (IDE). Detailed explanations of how to install the book’s source code (available on the Internet) and how to run Java applications on both the Palm and PocketPC devices are presented. The writing style is again very concise, but detailed enough for Java developers.

Chapter 4, “Things to Think About When Designing for Small Devices,” explores what can and cannot be done with Palm devices. The discussion is focused on Palm because PocketPCs are less constrained, but the design considerations still apply. Limitations studied include limited computational capabilities and constrained screen and memory sizes. Although some of these limitations are being overcome, particularly those of memory and computing power, users also expect more, so these limitations still remain in the new generation of PDAs.

When working with these kinds of devices, the user interface is critical. Chapter 5, therefore, explores their design space from the programming point of view, describing related classes available in the MIDP and PersonalJava platform, in the same concise style the author applies to the entire book. Chapter 6 describes the storage capabilities of PDAs, through the different programming interfaces available. Sometimes, the information stored should be transferred over the Internet: chapter 7 examines the process of transferring data over hypertext transfer protocol (HTTP), complementing the discussion about data storage. Different connection methods are described, such as connecting the device to a PC using serial, infrared, or Bluetooth links, and using a mobile phone to gain access to the Internet or to connect the device directly to the network. Again, all related application programming interfaces (APIs) available for Palm and PocketPC platforms are covered.

The book concludes with a very interesting chapter, which goes beyond what one can expect of a book about PDA programming. Chapter 8, “Integrating with the Enterprise Using Web Services,” describes how to access the functionality provided by a Web service using the Web services description standard (WSDL), both for Palm and PocketPC devices. The goal is to integrate a PDA application with the enterprise. The description is done by example, showing the design and implementation of a simple Web server through the methods the clients can invoke. Useful references are provided for readers who are not familiar with Web services. It is interesting to see a performance comparison among the different Web service access methods described. Finally, chapter 9 enumerates some emerging technologies and specifications relevant to Java on PDAs.

The book is well written, concise in style and length (about 220 pages), and well structured. If you are a Java programmer who wants to understand the particulars of PDA programming, this is definitely the book you should start with.