Palm Programming: The Developer's Guide with CD-ROM


PalmPilot's popularity is growing and with over a million units sold, the Palm OS dominates the hand-held market. Wired has astutely described Palm's position in a recent article: "On its way to becoming the bestselling hand-held computer of all time, the 3Com PalmPilot has spawned an intense, emotional, and fanatical developer following not seen since the glory days of the Mac." (Wired, 20 Feb. 98).Palm Programming should be eagerly accepted by programmers because the authors worked closely with Palm to ensure ...

See more details below
Available through our Marketplace sellers.
Other sellers (Paperback)
  • All (21) from $1.99   
  • New (5) from $2.49   
  • Used (16) from $1.99   
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any coupons and promotions
Seller since 2015

Feedback rating:



New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

Minor Shelf wear. Pre-owned but barely Used. Ships fast. Satisfaction guaranteed.

Ships from: Alamo, CA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
Seller since 2008

Feedback rating:


Condition: New

Ships from: fallbrook, CA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Seller since 2015

Feedback rating:


Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Seller since 2005

Feedback rating:


Condition: New
1998 Paperback New Tracking provided on most orders.

Ships from: Grand Rapids, MI

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
Seller since 2008

Feedback rating:


Condition: New

Ships from: Chicago, IL

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Page 1 of 1
Showing All
Sort by
Sending request ...


PalmPilot's popularity is growing and with over a million units sold, the Palm OS dominates the hand-held market. Wired has astutely described Palm's position in a recent article: "On its way to becoming the bestselling hand-held computer of all time, the 3Com PalmPilot has spawned an intense, emotional, and fanatical developer following not seen since the glory days of the Mac." (Wired, 20 Feb. 98).Palm Programming should be eagerly accepted by programmers because the authors worked closely with Palm to ensure that the book is tailored exactly to the needs of the ever-growing group of Palm developers. As nothing but some piecemeal documentation exists currently, this book provides a much needed solution to the Palm developers. In fact, Palm uses this book as their official developer's guide and will be using it in the future as a key part of their training materials for developers.There are currently no books on Palm programming (and we know of none that are planned). The only way to learn is by using the reference material published by Palm (available freely on their Web site), the tutorial they provide, or various Palm programming FAQs compiled by third parties.Palm Programming shows intermediate to experienced C programmers how to build a Palm application from the ground up. Using an easy-to- understand tutorial approach, this book gives readers everything necessary to create a wide range of Palm applications and conduits, from simple scripts through full-blown applications, and in the process provides thorough coverage of Palm programming. It includes a CD-ROM (Macintosh and Windows compatible) with the full source code to the examples in the book, a trial version of Palm's Software Development Kit, and third-party developer tools, including Metrowerks' CodeWarrior Lite programming kit.OutlinePart 1: Overview of Palm OS and devicesChapter 1: The Palm SolutionChapter 2: Developing for Palm OSChapter 3: Designing a solutionPart 2: Programming for the handheldChapter 4: Structure of an ApplicationChapter 5: Forms and Form ObjectsChapter 6: DatabasesChapter 7: MenusChapter 8: ExtrasChapter 9: CommunicationsChapter 10: DebuggingPart 3: Programming for the desktop: conduitsChapter 11: Getting started with conduitsChapter 12: Uploading and Downloading DataChapter 13: Two-way Syncing Appendix: Where to go from here

This is an excellent guide for Palm application developers and conduit writers. Be aware that this is not a user's guide. You should be familiar with Palm, have the Palm OS documentation (available on the Palm Web site), and know how to program in C. Also keep in mind that Palm fanatics (unabashedly partisan programmers) wrote this publication, and 3COM wants you to think of this as the Palm platform, not as the little Pilot that everyone knows. The name Pilot was dropped due to a lawsuit.

Read More Show Less

Editorial Reviews

Bill Carmada
Write C? Want to reach millions of enthusiastic technology users who aren't already overwhelmed with too many applications? Write for 3Com's Palm Computing (PalmPilot) Platform. Of course, you'll have to write tiny apps for a tiny screen, and make 'em speedy (PalmPilot users are busy folk). You'll also need to think different, as a somewhat less successful PDA manufacturer might put it. One book gives you both the skills and the mindset you need to succeed: Palm Programming: The Developer's Guide.

Understand the structure of a Palm Computing application including forms and form objects, databases, menus, tables and other key elements. Master the tradeoffs associated with Palm development including crucial memory management techniques. Prototype and debug a sample application then learn how to build conduit software that integrates Palm devices with Windows-based desktops. You'll find lots of code throughout-and the CD-ROM contains a demo version of CodeWarrior for Palm OS, the GNU PalmPilot SDK, plus other valuable developer's tools. An outstanding resource for a terrific platform.

Bill Carmada @ Cyberian Express

Read More Show Less

Product Details

  • ISBN-13: 9781565925250
  • Publisher: O'Reilly Media, Incorporated
  • Publication date: 12/8/1998
  • Series: Developer's Guides (Osborne) Series
  • Edition description: Older Edition
  • Edition number: 1
  • Pages: 482
  • Product dimensions: 7.05 (w) x 9.19 (h) x 1.02 (d)

Meet the Author

Neil Rhodes and Julie McKeehan are experienced authors who, through their company, Calliope Enterprises, work closely with Palm Computing to develop new training materials, materials that are based on this book. They are both programmers with many years of experience working with hand-held systems. Neil and Julied authored several books on C++ and hand-held systems, and now bring their skills to the Palm Computing Platform. Neil has been a UNIX programmer (his fingers still know vi commands), a Mac programmer (shipped several commercial products), a teacher (of programmers for Apple Developer University), a Newton programmer (several commercial products, including some for Apple), and an author (of Newton books, a C++ book, and a Macintosh programming book). Neil has been working with Palm Computing on developing their training strategy and training materials for programmers. He works closely with many of the developer support engineers at Palm (many of whom he also worked with previously when they did Newton developer support).

Neil Rhodes and Julie McKeehan are experienced authors who, through their company, Calliope Enterprises, work closely with Palm Computing to develop new training materials, materials that are based on this book. They are both programmers with many years of experience working with hand-held systems. Neil and Julied authored several books on C++ and hand-held systems, and now bring their skills to the Palm Computing Platform. Julie has been a systems administrator, a director of software development at a successful Macintosh software company, a teacher (of programmers for Apple Developer University), and author (of Newton books, a C++ book, and an Internet book).

Read More Show Less

Read an Excerpt

Chapter 9: Communications

In this chapter, we discuss the types of communication available on the Palm OS. Next we go into detail about two of these types and show you how to write code to use them.

Palm OS supports three kinds of communication IrDA, serial, and TCP/IP:


This is an industry-standard hardware and software protocol. We won't discuss the details of communicating using IrDA. We will, however, show you how to use the Exchange Manager to implement beaming (see the section entitled "Beaming" on page 238). Beaming is a data exchange method built on top of IrDA.


Serial communication occurs between the hand-held and other devices using the cradle port. This is the most common form of communication. on the Palm OS, and as an example we develop a special serial application that communicates (indirectly) with satellites.


Currently, this communication standard is available only via a serial or modem connection. The future has no boundaries, however, so you might expect to see built-in Ethernet or devices using wireless TCP/IP appear some day. To show you how to use TCP/IP, we create a small application that sends email to a server.


The Serial Manager is fairly straightforward. There are routines to do aft of the following:

Open and close the serial port
Read and write data
Query how many bytes are ready to be read
Set options

Serial I/0 is synchronous, so there's no notification when data gets received. Instead, your code must poll to see whether data has 'arrived.

Tips for Using the Serial Manager

Here are a bunch of miscellaneous tips that will help you when it's time to add serial functionality to an application:

Open port error

If your code calls SerOpen and it returns the error serErrAlreadyOpen, your open has succeeded, but some other code already opened the port. Although it's possible to share the port, a sane person wouldn't normally want to do so. Sharing reads and writes with some other code is a recipe for mangled data. If you get this error, you should notify the user that the port is in use and gracefully call SerClose.

Open the serial port only for short periods of time. Don't leave the serial port open any longer than absolutely necessary. If your application reads data from the serial port every five minutes, don't leave it open for that entire time. Instead, close the port, and reopen it after five minutes. As a rule of thumb, leave the serial port open for no longer than 30 seconds if it is not in use.

Similar advice is often given to drivers about stopped cars. If you will move again within a few minutes, leave the car idling; otherwise, shut the car off and restart it when you are ready to go. just as an idling car wastes gas, an idle serial port wastes batteries by providing power to the serial chip. Such behavior will really annoy your users, who don't want an application that sucks all the life out of their batteries. Don't have sloppy serial code.

Preventing automatic sleep

If you don't want the Palm OS device to sleep while you are communicating, call EaReseMutoOffTimer at least once a minute: This prevents the automatic sleep that happens when no user input occurs. If you have communication that shouldn't be interrupted, you certainly should do this, as you win lose the serial data when the device goes to sleep.

Adjusting the receiving buffer size

The default receive buffer is 512 bytes. Think of this receiving buffer as similar to a reservoir. The incoming data flows into the buffer, and reads from the buffer drain the data out the other side. just as with a reservoir, if you get too much incoming data, the buffer overflows, and data spills out and is lost. The error you get is serLineErrorSWOverrun.

If you expect a lot of data, it's best to adjust your buffer to accommodate greater inflows. You can set the size using SerSetReceiveBuffer. When you're done, make sure to release the buffer before you close the port; do so by calling SerSetReceiveBuffer with a size of 0. SerClose won't release the buffer, so if you don't do it yourself, you'll leak memory.

Knowing when there is data in the receive buffer

When reading data, it is best to do it in two steps. The first step is to call SerReceiveWait, which blocks until the specified number of bytes are available in the buffer. To provide a timeout mechanism, SerReceiveWait takes as a parameter an interbyte tick timeout. This timeout is used for a watchdog timer that is reset on every received byte. If the timer expires, the function returns with serErrTimeOut Once SerReceiveWait returns, the second step is to call SerReceive to actually read the data from the receive buffer.

The timeout measures the time between successive bytes, not the time for all bytes. For example, if you call SerReceiveWait waiting for 200 bytes with a 50tick timeout, SerReceiveWait returns either when 200 bytes are available, or when 50 ticks have passed since the last received byte. In the slowest case, if bytes come in one every 49 ticks, SerReceiveWait won't time out.

SerReceiveWait is the preferred call, because it can put the processor into a low-power state while waiting for incoming data-another battery-saving technique that will make your users happy.

Handling user input during a serial event

Don't ignore user input while communicating. Wherever possible, you need to structure your application so that it deals with serial communication when the user isn't doing other stuff. Practically, this means you can do one of two things. Your application could communicate every so often by calling EvtGetEvent with a timeout value. Or, if your communication. code is in a tight loop that doesn't call EvtGetEvent, you can call SysEventAvail every so often (certainly no less than once a second). This allows you to see whether there's a user event to process. If there are user events, return to your event loop to process the event before attempting any more serial communication.

Receiving error messages

If SerReceive, SerReceiveWait, or SerReceiveCheck return serErrLineErr, you need to clear the error using SerClearErr Alternatively, you should use SerReceiveRush if you also need to flush the buffer, since it will call SerClearErr.

Palm OS version differences

Defend and SerReceive have been enhanced in Palm OS 2.0. In this OS, they return the number of bytes sent or received. If you are running on Palm OS 1.0, you need to use SerSend10 and SerReceive10, which have different parameters. Make sure your code does the right thing for each OS version.

Serial to a state machine

Often, serial protocols are best written as though they are going to a state machine. You can do this by defining various states and the transitions that cause changes from one state to another. You use a global to contain information on the current state. While it might sound complicated, writing your serial code this way often makes it simpler and easier to maintain.

For example, if you use your Palm device to log into a Unix machine, you might send and then enter the "Waiting for logim" state. In this state, you'd read until you got the characters "login:". You would then send your account name and enter the "Waiting for password:" state. In that state, you'd read until you got the characters "password:". Then you would send the password and enter yet another state.

Sample Serial Application

Our Sales application doesn't have serial code in it. Instead, we've written a small application that communicates with a Global Positioning System (GPS) device. A GPS device reads information sent by orbiting satellites; from that data it determines the location of the device. In addition to the location (latitude, longitude, and altitude), the device obtains the Universal Tune Coordinate (UTC) time....

Read More Show Less

Table of Contents

The Palm Phenomenon;
Who This Book Is For—C Programmers;
What This Book Is About and How to Read It;
What’s in a Name—Is It a Pilot or a Palm?;
Conventions Used in This Book;
How to Contact Us;
Versions of Things;
Whom We Need to Thank;
Palm—Why It Works and How to Program It;
Chapter 1: The Palm Solution;
1.1 Why Palm Succeeded Where So Many Failed;
1.2 Designing Applications for Palm Devices;
1.3 Elements in a Palm Application;
1.4 Summary;
Chapter 2: Development Environments and Languages;
2.1 Overview;
2.2 Handheld Development;
2.3 Alternative Development Environments;
2.4 High-Level Forms Development;
2.5 Conduit Development;
2.6 Conclusion;
Chapter 3: Designing a Solution;
3.1 User Interface Elements in an Application;
3.2 General Design of a Palm Application;
3.3 How the Sample Applications Are Useful;
3.4 User Interface of the Sales Application;
3.5 Developing a Prototype;
3.6 Design Tradeoffs in the Sample Application;
3.7 Designing for a Small Screen;
3.8 Designing the Databases;
3.9 Designing the Conduit;
3.10 Design Summary;
Designing Palm Applications;
Chapter 4: Structure of an Application;
4.1 Terminology;
4.2 A Simple Application;
4.3 Scenarios;
4.4 Memory Is Extremely Limited;
4.5 Other Times Your Application Is Called;
4.6 Summary;
Chapter 5: Forms and Form Objects;
5.1 Resources;
5.2 Forms;
5.3 Form Objects;
5.4 Resources, Forms, and Form Objects in the Sales Application;
Chapter 6: Databases;
6.1 Overview of Databases and Records;
6.2 Creating, Opening, and Closing Databases;
6.3 Working with Records;
6.4 Examining Databases in the Sales Sample;
Chapter 7: Menus;
7.1 Menu User Interface;
7.2 Menu Resources;
7.3 Application Code for Menus;
7.4 Adding Menus to the Sample Application;
Chapter 8: Extras;
8.1 Tables;
8.2 Tables in the Sample Application;
8.3 Find;
8.4 Beaming;
8.5 Barcodes;
Chapter 9: Communications;
9.1 Serial;
9.2 TCP/IP;
Chapter 10: Debugging Palm Applications;
10.1 Using POSE;
10.2 Device Reset;
10.3 Graffiti Shortcut Characters;
10.4 Source-Level Debugging with CodeWarrior;
10.5 Source-Level Debugging with GNU PalmPilot SDK;
10.6 Using Simulator on Mac OS;
10.7 Gremlins;
Designing Conduits;
Chapter 11: Getting Started with Conduits;
11.1 Overview of Conduits;
11.2 Registering and Unregistering a Conduit;
11.3 Conduit Entry Points;
11.4 The HotSync Log;
11.5 When the HotSync Button Gets Pressed;
11.6 Using the Backup Conduit;
11.7 Creating a Minimal Sales Conduit;
Chapter 12: Uploading and Downloading Data with a Conduit;
12.1 Conduit Requirements;
12.2 Where to Store Data;
12.3 Creating, Opening, and Closing Databases;
12.4 Downloading to the Handheld;
12.5 Uploading to the Desktop;
12.6 When the HotSync Button Gets Pressed;
12.7 Portability Issues;
12.8 The Sales Conduit;
Chapter 13: Two-Way Syncing;
13.1 The Logic of Syncing;
13.2 The Conduit Classes;
13.3 Sales Conduit Sample Based on the Classes;
13.4 Generic Conduit;
13.5 Sales Conduit Based on Generic Conduit;
Chapter 14: Debugging Conduits;
14.1 HotSync Flags;
14.2 Source-Level Debugging;
14.3 Avoiding Timeouts While Debugging;
14.4 Conduit Problems You Might Have;
14.5 Test with POSE;
14.6 Turn Off Other Conduits During Testing;
14.7 Use the Log, Luke;
Where to Go From Here;
Palm Programming Book Web Site;
The Official Palm Developer Site;
Palm Programming Mailing Lists;
Third-Party Palm Programming Resources;
Third-Party Palm Programming FAQ;
RoadCoders, Handheld Developers;
Journals and Magazines;

Read More Show Less


By almost anybody's standard of measure, the PalmPilot and other Palm devices are wildly successful. Everybody loves them: users buy them faster than any other handheld, product reviewers give them awards, and programmers, once they find the platform, never want to leave.

How do we account for this phenomenon? What makes the Palm handheld such a great device? Simple. It's really fast, it's cheap, it does almost anything you ask it to, and it can fit in your shirt pocket. Couple that with loyal users, and one of the most ardent developer followings not seen since the glory days of the Mac, and you have all the elements of a whirlwind success. If you are a programmer, the question you should really be asking yourself right now is, "What do I need to know to join in the fun?" To find out, keep reading.

Who This Book Is For--C Programmers

If you know C and you want to write applications for Palm devices, then this is the book for you. It doesn't matter if you own a Palm and are an avid user, or if you are only now thinking about getting one. You can be a wretchedly poor student who wants to mess around with a PalmPilot in your spare time using free development tools, or a programmer in a Fortune 500 company who just got told that you have to write an application for the 5,000 units the company is deploying in the field next month.

We have tried hard to make sure that there is useful information for everyone, from beginning Palm programmers to those of you who have already danced around the block with these lovely little devices. If you want to write an application that reads barcodes, we help you; if you want to write an application to deploy a sales force,we show you what to do.

Do You Need to Know C++?

It doesn't hurt if you know C++, but it isn't necessary, either. C is just fine for creating a Palm application. C++ does come in handy if you are going to write a conduit (we will talk more about that in minute).

Do You Need to Be a Desktop Expert to Write a Conduit?

Writing a Palm application can be a two-part adventure. You may want to create an application for the handheld device and a desktop application that will talk to the Palm application. If you want to write a conduit (the code that handles the exchange of data between the Palm and the desktop), then you will need to know about the desktop (Windows or Macintosh). We tell you how to write the conduit, but not a lot about creating a desktop application. For that you will need some outside resources.

Which Flavor Conduit Do You Want--C++ or Java?

You can use either C++ or Java to write a conduit. We discuss some of the issues and help you figure out which path you want.

What This Book Is About and How to Read It

This book shows you how to create a Palm application and a conduit. It assumes that you have the Palm OS documentation (available at the Palm Computing web site, ) and know where to find things in it. Before showing you how to create an application, we also spend some time explaining the difference between a good application and a bad one; in other words, we tell you how to design for this platform.

The Breakdown of the Chapters

Part I.Palm--Why It Works and How to Program It, gives you the big picture. You learn about the devices, their history, development environments, and the right way to design a Palm application.

1. The Palm Solution

We happily admit that this chapter is unabashedly partisan. Did you want someone who doesn't like the Palm Computing platform telling you about it? We also describe what features can be found on what devices and what you can expect to see in the future.

2. Development Environments and Languages

Here we show you the choices in development environments and the range of languages you can use.

3. Designing a Solution

We ruminate about the best way to design a Palm application and offer you some advice. We end this chapter by showing you the design of an application and its accompanying conduit that we are going to create in the book.

Part II.Designing Palm Applications, takes you inside a Palm application. We describe its structure, user interface elements, and the Application Programming Interface (API) for the various parts of the application.

4. Structure of an Application

We take you through the whole cycle of a Palm application, from the time it is launched by the user to the moment it quits.

5. Forms and Form Objects

Here you'll learn how to create the various user interface elements of the application--everything from buttons to alerts, lists to gadgets.

6. Databases

We explain the unique way the Palm OS creates data structures and stores data on a Palm device.

7. Menus

We show you how to create menus and the items in them. You also learn how to use Palm's Graffiti shortcuts and what menus should be where.

8. Extras

We covers a little bit of this and a little bit of that in this chapter. The topics are tables, find, beaming, and barcodes (for use with the Symbol SPT 1500, a Palm Computing platform handheld).

9. Communications

This chapter gives you a detailed look at communications on a Palm OS device, everything from serial to TCP/IP.

10. Debugging Palm Applications

Last, but most important, we turn to the crucial topic that is every programmer's bane of existence--debugging. We show you how to figure out what's wrong with your code.

Part III.Designing Conduits, covers conduits. Just as we created a Palm application, we do the same for conduits. Everything from a complete description of the parts of a conduit to development platforms for them, to code walkthroughs. Unlike the other two sections, these chapters build on each other and should be read in order.

11. Getting Started with Conduits

We start once again with the bigger picture. After we describe all the general things you need to know about conduits, we finally turn to a small amount of code that forms the shell of a conduit.

12. Uploading and Downloading Data with a Conduit

This chapter takes you a step further, and you see how to upload and download data between the desktop and the conduit.

13. Two-Way Syncing

In this chapter, we show you a conduit that uses full-blown data syncing, with the exchange of data depending on where it has last been modified. We also describe the various logic problems you encounter with a device that can synchronize data on various desktops.

14. Debugging Conduits

We return to the topic of debugging, this time of conduits.

How to Read This Book

There are a few standard approaches people use to reading a book on programming.

The skip-through-and-read-what's-interesting method

The cover-to-cover method

The in-front-of-a-computer-trying-to-create-your-own-application method

The skip-through approach

View Part I. Palm--Why It Works and How to Program It as background information. It is more essential for beginners to the Palm Computing platform than for old-timers. If you already know which development environment you are going to use, you can likewise ignore

2. Development Environments and Languages . If you want to understand the design decisions we made in the sample application and what makes the difference between a good and a bad Palm application, then you need to read through

3. Designing a Solution.

You can skip around or read the chapters in Part II.Designing Palm Applications in order. In either case, don't wait to long to read 10. Debugging Palm Applications . No matter what, read this material before you try to create your own project.

Part III.Designing Conduits won't make much sense unless you read it in order. Each chapter builds on the previous chapter.

The cover-to-cover method

We didn't write the book in this order, but it seemed like the right progression at the time.

The in-front-of-a-computer approach

You anxious types should read the debugging material before you take too deep a plunge. Otherwise, far be it from us to try to slow you down--get to it.

What's in a Name--Is It a Pilot or a Palm?

We have to take a moment here and talk about both the name of this book, Palm Programming: The Developer's Guide, and about Palm devices in general. If you are a loyal Palm user, then you probably call it a Pilot. So does virtually everyone else on the planet, except the people who make them--3Com. The producers of these dandy devices want you to think of Palm not as a device, but as a platform, the Palm Computing platform. They do this, reasonably enough, so you realize that all the following devices use the same operating system even though different companies make and sell them:
  • Pilot 1000, Pilot 5000
  • PalmPilot Professional
  • PalmPilot Personal
  • Palm III
  • IBM WorkPad
  • Symbol SPT 1500
Why 3Com went from the use of Pilot to Palm can be summed up in one word--lawsuit. Some lawyers for the French Pilot Pen company contacted some lawyers at 3Com and said, "Hey, Pilot is our name; stop using it." So 3Com did. Now, while we could spend hours talking about the wisdom of letting a pen company tell a computer company to throw away a wildly popular, highly recognized trade name, that doesn't change our problem. People call them Pilots; the company calls them Palm devices.

As if things weren't interesting enough, add the entrance of the lumbering giant, Microsoft. Noticing the success Palm Computing was having with is popular devices, Microsoft's leaders said, "Hey, we are going to make some, too, and we are going to call them PalmPCs." While Microsoft eventually backed off from the name PalmPC to Palm-sized computers, the worst had already been done--the Palm name had been compromised. Now we have to worry that people will not know whether we are talking about a PalmPilot device or a Windows CE-based palm device in this book. It's enough to make a writer cry.

So here is our problem: we want to make the folks at Palm Computing happy, and we want to make sure readers know what we are talking about in the book from just looking at the title. Our compromise solution was Palm Programming (the title everyone will call the book). We wrote this book to last a long time, and we are betting the title on 3Com's ability to move consumer attachment from the word Pilot to the word Palm.

At the time we went to press, the dust hadn't settled yet; it isn't clear whether 3Com will be successful in wresting the Palm name away from Microsoft. If they are, the book has the right name, and you picked up Palm Programming for the right reasons. If Microsoft wins--not an unbelievable possibility, however unhappy it makes us--then you may have picked up this book thinking it would help you with the Microsoft Windows CE programming of Palm-sized devices. Sorry for the confusion.

Conventions Used in This Book

We use a couple of conventions worth noting.

Italic is used for a variety of things: URLs, filenames, functions, email addresses and other things we wanted to emphasize.

Code comes in either small batches or larger amounts, but it is always represented in constant width.

Elements such as parameters (basically any code other than function names) also use a constant-width font when we discuss them in a sentence.

How to Contact Us

We have tried very hard to make sure that all the information in this book is accurate. If you find a problem or have a suggestion on how to make the book better, please let us know by writing or emailing us at:

O'Reilly &
Associates, Inc.
101 Morris Street
Sebastopol, CA 95472
800-998-9938 (in the U.S. or Canada)
707-829-0515 (international/local)
707-829-0104 (fax)

Email can be routed depending on the type of problem. To be put on O'Reilly's mailing list or to request a catalog, send email to:

To tell us about a technical problem in the book or ask us a question, you can send email to us, the authors, at:
(Neil Rhodes)
(Julie McKeehan)

Versions of Things

We use a lot of tools in this book. As an easy point of reference, here is each product and the version of it that we used. Check our web site for links and information about updates.
  • Beta version of CodeWarrior for Palm OS Release 5
  • GNU PalmPilot SDK Version 0.5.0
  • Palm OS Emulator (POSE) 2.0b3
  • 3.0 Conduit Development Kit, beta version
  • Gdbplug .02
  • Symbol Scanner SDK Beta 1.08

What's on the CD?

Source for all the samples in this book. Updates to the CD can be found at .
  • A demo version of CodeWarrior for Palm OS
  • GNU PalmPilot SDK
  • POSE
  • Palm OS 3.0 SDK--including documentation
  • Symbol Technologies SDK for the SPT 1500
  • Demo version of Satellite Forms

Whom We Need to Thank

If you hadn't already figured out that the people at Palm Computing deserve an enormous amount of gratitude, we will tell you now. Many people deserve our thanks, starting with Maurice Sharp, head of Developer Technical Support (DTS) at Palm Computing. He coordinated the dispersal of proof chapters and had the fortitude to read the whole thing while managing all the rest of his duties. Other DTS people who read the entire manuscript were David Fedor, Cheri Leonard, Gary Stratton, Bruce Thompson, and Ryan Robertson. Keith Rollin in Engineering also read the whole thing and gave us great comments, especially about debugging tools. If you have ever tried to do a technical review of a proof copy, you would know how much work this is. These folks went the extra mile and obviously read on their own time (food spills are a sure-fire indicator of a dedicated individual), and for this we thank them profusely. If this book is useful to you, remember that these people had a great deal to do with that.

Other people at Palm Computing reviewed individual chapters in their own areas of speciality and gave us great advice. These include some folks in Engineering: Dan Chernikoff (comms stuff), Bob Ebert, Roger Flores, Steve Lemke, Kelly McCraw, Chris Raff, and Tim Wiegman. Three managers also took time out of their schedules to make sure we covered enough of the bigger picture. They are Daniel Pifko (HotSync Product Manager), Phil Shoemaker (Tools Engineering Manager), and Bill Witte (OS/SDK Product Manager). All these people read drafts of chapters and sent back tons of useful technical comments, and we thank them.

We can't begin to say how nice it is to be able to ask for technical help, ask questions, ask about problems, and get answers, usually within a day or two. Two people at Symbol Technologies also helped us out. Rob Whittle (Product Manager of the SPT 1500) got us a beta unit of the SPT 1500 and gave many useful comments and other help.

We also recruited some readers to see if the book would make sense. These readers included C programmers new to the platform and people who might well know more about programming the Palm than we do. This list of volunteers who deserve recognition includes Stephen Beasley, Edward Keyes, J.B. Parrett, and Stephen Wong. Edward Keyes offered especially insightful and thorough comments.

Now, over to the publishing side of things. Many thanks to our editor, Mark Stone. It was very nice to have an editor who read and actually understood our writing. Mark, time and time again, caught inconsistencies and sloppy descriptions and gently told us when we were mumbling. For two authors who don't like writing, Mark's competence and professionalism made the task almost palatable.

On the personal side of things we have a few people to thank as well. As always, we need to thank some children, Nicholas, Alexander, and Nathaniel, who can never figure out why either of us writes books. We also thank our friends and families who put up with our annoying tendencies to fade out of conversations, be late, and be absolutely boring while we are writing.

Read More Show Less


What accounts for the PalmPilot's astonishing success? After all, there are more fully featured handhelds (the dead Apple Newton), smaller ones (Rex), less expensive ones (Avigo), ones with keyboards (Psion), and ones backed by Microsoft (Windows CE devices). Yet all of those palmtops (and many more) put together constitute only 35% of the palmtop market. PalmPilot sales make up the remaining 65%.

Some of the reasons for its success are evident: the PalmPilot is truly shirt-pocketable, inexpensive, fast, and simple, and a pair of AAA batteries drive it for two or three months (compare with 15 to 20 hours on a Windows CE gadget). But there's another, bigger reason that overshadows all the others: the PalmPilot is amazingly easy, pleasant, and satisfying to program.

At this writing, there are over 7,000 PalmPilot developers. My guess is that 6,950 of them are teenagers in their bedrooms. But that's just the point--because 3Com/Palm Computing and the Palm OS are so open, so clear, so friendly, almost anyone with a little programming experience can create new software for this addictive piece of circuitry. Maybe that's why 5,000 PalmPilot programs on 500 web sites are kicking around at this very moment. No other handheld platform offers as many easily accessible development tools--and so much encouragement from Palm Computing, the mother ship.

As a result, it's astonishing that this is the first and only book on PalmPilot programming--and gratifying that it's so meaty, complete, and informative. Authors Neil Rhodes and Julie McKeehan do more than rattle off lists of calls and APIs; in a gentle, book-long arc, the authors lead you through the creationof a sample PalmPilot program. Along the way, you'll learn to create almost every aspect of a Palm OS application, such as databases, beaming, menus, dialogs, data entry, finding, and conduits to the desktop PC.

More than that, you'll learn the Palm OS itself. The authors firmly believe that in creating its OS, Palm Computing got it right the first time; you're encouraged to embrace the same goals of speed, minimization of steps, and elegant design. In other words, this book won't just teach you to become a PalmPilot programmer--it will teach you to be a good one.

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star


4 Star


3 Star


2 Star


1 Star


Your Rating:

Your Name: Create a Pen Name or

Barnes & Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation


  • - By submitting a review, you grant to Barnes & and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Terms of Use.
  • - Barnes & reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously

    If you find inappropriate content, please report it to Barnes & Noble
    Why is this product inappropriate?
    Comments (optional)