In this chapter:
This chapter deals with the what and the how of things. First, we show you what you're programming for-the nuts and bolts of the Palm OS. Then we show you how to do it-the available development environments. By the time we are through, you should have a good idea of the range of applications you can create for the Palm OS, the coding requirements, and which development environment you want to use.
Overview |
Developing for the Palm OS is in some ways similar to other platforms and in other ways strikingly different. Two important similarities are:
Differences tend to center around features crucial to the device size and purpose. These include how the Palm OS handles:
Most important, you should remember that the relationship between the device and the OS is extremely tight. Everything has been built on the premise that the handheld is an extension of the desktop and that it must be responsive to the user.
Overview of the OS
Let's look in more detail at this tight interaction of the OS and the applications on the handheld. The Palm OS runs on top of a preemptive multitasking kernel. One task runs the user interface. Other tasks handle things like monitoring input from the tablet.
The user interface permits only one application to be open at a time. Thus, when your application is open, it (more or less) has control of the entire screen.
NOTE: Applications run within the single-user interface thread and therefore can't themselves be multithreaded. |
Memory
Memory is handled in an unusual fashion. The RAM on a Palm OS device is used for two purposes:
For dynamic memory allocation
This is memory your application or the system needs while it is running. It also includes the stack your application requires. On a reset, this memory is cleared. This portion of memory is analogous to RAM in a traditional OS.
For permanent storage
This includes downloaded applications as well as data that the user will view, create, and/or edit. To-dos, names and phone numbers, memos, and all the other data for built-in applications also use this memory. On a reset, it is not cleared. This portion of memory is analogous to files on a hard disk in a traditional OS.
For both kinds of memory, allocation is done as chunks. The permanent storage holds databases, with related chunks kept in a single database. For example, all the memos are stored (each as a separate chunk, or database record) in a single database. Another database holds all records from the Address Book application. We cover this in detail in Chapter 6, Databases.
Unlike in a traditional desktop operating system, data and code are not copied from permanent storage to dynamic memory but are used in place. For example, when your code executes, it is executing in-place from the permanent storage. Since the permanent store itself is RAM, it can be read by the CPU like any other RAM. Similarly, data can be read (and displayed) directly from storage.
For more information on memory usage in a Palm application see "Memory Is Extremely Limited" in Chapter 4, Structure of an Application.
NOTE: Palm has been careful to ensure that permanent storage is protected against every programmer's ability to accidentally overwrite memory (bugs happen). Palm rightly reasoned that users would be unhappy if one bug in a single application caused all their data to be lost. Thus, while the permanent storage can be read like any other RAM, it is write-protected by the device. It won't allow that portion of RAM to be written. In order to write to specific chunks within permanent memory, you have to use the operating system's mechanism, and that includes a check against attempts to write to places outside the chunk. |
Resources
An application on the Palm OS is a resource database that contains many different resources. A resource is simply a database record that has a type and an ID. Stored within these resources are the guts and skin of your application. On the desktop, these resource databases have a .PRC extension. You'll find that they are often referred to as PRC files.
Examples of the types of things stored in resources are:
The user interface elements that appear on the Palm device are initialized based on the contents found in these resources. Because the initialization is not embedded within your code, you can change the appearance of your application (for instance, to localize it for another language) without modifying the code itself. Another advantage is that you can use visual editors to display and edit the user interface portions of your application. Such editors allow you to easily tweak the look or presentation of data without recompiling and redownloading your application. We discuss resources in detail in Chapter 5, Forms and Form Objects.
Events
A Palm OS application is event-driven. Events arrive, like pen down or key down, and your application responds to them. Some events are handled by your application; others are handled by the operating system. Once your application begins, it enters an event loop, repeatedly getting, then handling an event. The loop continues until the user launches another application, which causes your application to quit. The event cycle of a Palm application is covered in depth in Chapter 4.
Forms and controls
The Palm OS has built-in support for various controls and for managing forms. Forms are similar to windows on a desktop operating system. Because of the simpler user interface on the Palm OS, only one form is active even though several forms may be displayed.
The Palm OS provides a rich API for forms that includes many user-interface elements. Some of these elements are:
Because these elements are stored as resources rather than in your code, you can create a prototype of your application very quickly. The simplicity of adding the User Interface (UI) elements and the variety of them makes it easy to try out various application designs. Chapter 5 contains a description of these.
Communications
The Palm OS supports a variety of communication methods. As communicating is an essential aspect of the Palm's success, you should expect this area of the OS to be critical both in current and future applications. Current communication protocols are:
Chapter 9, Communications, is devoted to a full discussion of communication features of the Palm OS.
Palm 3.0 OS features
The 3.0 system added new features to the OS. The most important of these are:
Grayscale
The Palm 3.0 OS supports limited grayscale in 2-bit mode. Your applications can switch between 1- and 2-bit mode with specific system routines. Later devices and OS versions will undoubtedly increase grayscale support.
Fonts
An additional larger bold font has been added to the ROM. Applications also have system support for the use of custom fonts.
Heaps
The dynamic heap is larger, and the storage area has been folded into a single large heap. We discuss heap size and manipulating memory chunks in "Memory Is Extremely Limited" in Chapter 4.
Objects larger than 64K
The system now allows you to manage objects that are larger than 64K with a new set of APIs.
Sound
There is support for volume control, asynchronous tones, custom alert sounds, and Standard MIDI (Musical Instrument Digital Interface) Files (SMFs).
Dynamic UI
New APIs are available that make it possible for you to create controls at runtime.
Serial number
Many devices (including the Palm III) have a unique programmer-accessible serial number. This allows greater flexibility with security measures. (Note: future devices are not guaranteed have this type of identification.)
Applications that use these new features should check the version of the OS on which they are running and either fail gracefully or not use 3.0-specific features.
Miscellaneous
The Palm OS has various other APIs for things like:
With all these features, you can see that the Palm OS provides for rich and varied applications. Text and the presentation of content are supported by a wide variety of tools that aid in the visual display of information.
NOTE: The subsystems of the Palm OS are called managers, and the naming convention for functions designate the manager that they are in. For example, all memory manager routines begin with Mem. All database manager routines begin with Dm. All form manager routines begin with Frm. |
Overview of Conduits
The second part of the Palm application is the desktop connection. Because Palm devices act as an extension of the desktop, it is crucial that information be easily exchanged. Conduits are the mechanism for doing this.
A conduit is code on the desktop that is called during a HotSync synchronization to manage the flow of information to and from databases on the handheld. Conduits register the database or databases for which they are responsible. Note that each database should have only one conduit responsible for it.
Conduits (Figure 2-1) are created using Conduit Development Kits for Windows (C/C++), Mac OS (C/C++), or Java.
Figure 2- 1.
Conduits control the exchange of information
Applications that do not have a conduit portion use a system-provided one instead. This Palm-created conduit is used for backups and is part of HotSync. This backup conduit copies the application data or database from the device and stores it as a file. You specify the backup conduit when you create a database. Think of this as the "If you can't afford an attorney, one will be appointed for you at no charge" conduit-the conduit of last resort.
During a HotSync session, the backup conduit is called for databases that don't have another conduit and which have been marked as needing a backup. At this point, it copies each record from the database and copies database header information into a file. This file can then be used to restore the state of the device if necessary.
More sophisticated conduits do more than this basic copying of information. They can read/write specific information to or from the device. For example, a conduit for a sales application might handle the downloads of new price lists, overwriting any existing price list that has expired. It might also be responsible for uploading a database of sales orders.
The most sophisticated conduits are those that synchronize records on the handheld with information on the desktop. Good examples of these include conduits that synchronize the Date Book records with various desktop PIMs like Outlook or Lotus Organizer. These synchronization conduits usually work by assigning each record a unique ID and tracking when a particular record has been changed.
Handheld Development |
Many different development tools are available for Palm programming. There is everything from a collection of tools that let you write C code to polished forms based packages that require only modest amounts of scripting. From this gamut of choices, you should be able to pick the right tool for the type of application you want to create. Before we discuss the advantages and disadvantages of each choice, however, it's worth looking at a description of each option.
For the development of the handheld portion of your Palm application, you can write code on Windows 95/98/NT, Unix, or Macintosh platforms. Palm's official development environment, CodeWarrior, is available for both Windows and Macintosh. Unix and Windows programmers have access to the free set of tools-GNU C compiler, or GCC-and there are two packages for Windows-based forms development. Last, but not least, Windows programmers can also program in 68K assembler or use a proprietary language called CASL.
CodeWarrior for Palm OS
The official development environment for the Palm OS is Metrowerks's CodeWarrior for Palm OS. This commercial development environment allows you to create ANSI C and C++ programs on either Windows 95/98/NT or Macintosh systems. It currently includes Palm's Conduit Software Development Kit, and Palm's own documentation assumes that you are using it. CodeWarrior for Palm OS is available on a subscription basis with one year of free updates. It costs approximately $369. Here is a description of the tools that CodeWarrior gives you for Palm OS development:
Metrowerks's Constructor
Constructor is a graphical resource editor (see Figure 2-2) that you use to create the user interface elements of your application.
Figure 2- 2.
Creating an application's resources using Metrowerks Constructor
CodeWarrior Integrated Development Environment (IDE)
This is a project-based IDE (see Figure 2-3) that includes:
- A Motorola 68000 C/C++ compiler
- A linker
- PalmRez (formerly called PilotRez), which creates PRC files from the compiled 68000 code and converts resources from Constructor format to PRC format
Figure 2- 3.
CodeWarrior IDE editing a project
CodeWarrior Debugger
This source-level debugger is used to debug Palm OS applications. It can debug an application running on a Palm device connected to your host computer via a serial cable, or an application running on the POSE. Figure 2-4 shows the Debugger in action.
Figure 2- 4.
Metrowerks Debugger being used on a Palm OS application
Palm Software Development Kit (SDK)
Includes header files, documentation, a tutorial, and invaluable sample code. The samples include the source code to the built-in applications: Expense, Memo, Address Book, and To Do.
Conduit SDK
This SDK is used to create conduits. The SDK is available separately, but is bundled as a courtesy. Note that the SDK requires Microsoft Visual C++ for Windows in order to create Windows conduits. Metrowerks's CodeWarrior for Mac OS can be used to create Macintosh conduits.
Developing on the Macintosh
If you're already developing software on the Macintosh, you're probably using CodeWarrior and therefore have a good idea of what to expect from this product. For those Macintosh users who don't have CodeWarrior, you can assume that Metrowerks's reputation for creating quality development environments is deserved. Most users are very happy with its products.
Developing on Windows
CodeWarrior was originally a Macintosh-only development environment that has been ported to Windows. While it works quite reliably, many Windows users find that the CodeWarrior IDE does not have a Windows look and feel. Because it looks more like a Macintosh product and some keystrokes don't work as expected, some Windows users find it annoying.
NOTE: You should assume that Metrowerks will fix the problems with the look of the Windows product. It is certainly worth your time to check out the most current version. CodeWarrior can be purchased directly from Metrowerks (http://www.metrowerks.com) or from mail-order houses such as PC Zone (http://www.pczone.com). A demo version of CodeWarrior for Palm OS (on Windows) is available from http://www.metrowerks.com/lite/. |
GCC
There is a long and honored tradition within the software developer community that tools, including compilers, should be free. A towering figure in the quest for free programming tools is the Free Software Foundation. Volunteers for this organization have been responsible for creating some of the finest compilers around. One of the best to come out of this effort is GCC (the GNU C Compiler), a general C/C++ compiler. This compiler is one of the most widely used compilers on Unix, and it even enjoys broad use on Win32 platforms.
NOTE: Free Software Foundation volunteers create compilers for various platforms and give away the source on the condition that any modifications must also be distributed. You can find out more information about the foundation from its web site (http://www.gnu.org/fsf). |
When the Pilot 1000 first shipped, the only development environment was CodeWarrior running on Mac OS. Many Unix and Windows programmers wanted to develop applications for the Palm but were not willing to buy a Macintosh to do so. Some enterprising and helpful programmers took advantage of the presence of GCC and added a PalmPilot port of the compiler that creates Palm OS binaries. A collection of tools was put together in what is officially known as GNU PalmPilot SDK-however, most folks just call the entire thing GCC.
What is in GNU PalmPilot SDK
This SDK is a collection of tools that allow you to create C/C++ Palm OS applications on Unix or Windows. The tools include:
GCC
The most important of these tools is the GNU C Compiler (GCC), which compiles C/C++ code to Motorola 68K.
GDB
PilRC
This resource compiler creates Palm resources from textual descriptions of the resources. These text files contain resource descriptions and end in the extension .RCP.
PilrcUI
This application displays RCP files graphically, previewing what they'll look like on the handheld. Figure 2-5 shows an example of PilrcUI.
Figure 2- 5.
PilrcUI displaying the resources of an application
Copilot
This application emulates the Palm device at the hardware level. It requires a ROM image from an actual Palm device and acts almost exactly like a Palm device. Further development of this has been taken over by Palm-see Chapter 10, Debugging Palm Applications, for more details.
Where to get GCC
There are several sources on the Net for GCC, depending on whether you want GCC for Unix or for Windows. As new places become available all the time, it is worth checking Palm's web site for more recent information. If you get all the parts at once, it is a big download (15MB), so make sure that you leave ample time for it. Our favorite place to acquire all of GCC at once is Ray's Software Archive (http://www.palmcentral.com).
If you use GCC, you still need to figure out what to do for the conduit portion of your application. You have two choices. You can purchase the Conduit SDK Tool Kit from Palm for $99, or you can rely on the backup conduit that Palm supplies.
Tools Directly from Palm Computing
Palm offers a lot of useful stuff as well. All of the following resources can be found at Palm's developer web site (http://www.palm.com/devzone):
POSE
This application is a further development of Copilot. It serves as a replacement for an actual Palm OS device while you do development. Because it can load a ROM image from disk, it usefully emulates different versions of the Palm OS. Figure 2-6 shows how POSE appears on your monitor.
NOTE: Of course, final testing of your application should take place with actual Palm OS devices. Do not ship an application having tested it only on the emulator. |
Figure 2- 6.
POSE in a desktop window emulating a Palm III device
Debug ROMs
There are 2.0 and 3.0 OS ROM images that you can use with POSE. They are not the version of the ROM used in production devices, as they have added, among other things, extra debugging code that does sanity checking of parameters.
Palm OS documentation
All the documentation for the Palm OS can be found on Palm's web site. There are numerous FAQs, tech notes, and white papers. This documentation is updated frequently.
Palm tutorial
This is a walkthrough that shows the building of an application from start to finish. The tutorial assumes you'll be using CodeWarrior for Palm OS. This very thorough tutorial is quite good in its description of the intricate details of application development (what buttons go where, how you add a button to a form, and so on). There are Windows and Macintosh versions of the tutorial that can be downloaded for free (http://www.palm.com/devzone).
This is the SDK for creating conduits for Mac OS and/or Windows using C or C++. This SDK costs $99, but is included as part of CodeWarrior for Palm OS. The Windows version requires Visual C++. The Macintosh version requires CodeWarrior for Mac OS.
This is the SDK for creating conduits for Mac OS and/or Windows using Java. This SDK costs $99.
Alternative Development Environments |
The following sections describe several useful alternative development environments for the Palm OS.
Assembler SDK (ASDK)
This SDK allows development of applications written in Motorola 68K assembler. It includes Pila (Pilot Assembler). To us this would be sheer agony, but apparently some developers enjoy writing applications in assembly language. To each their own poison. You certainly can't beat the price-it's free.
For more information, see Darren Massena's web site (http://www.massena.com), which is an indispensable Palm developer resource in its own right.
Jump
This novel environment allows you to write your application in Java using a Palm class library and your favorite Java development environment. Jump then compiles the resulting Java .class files into Motorola 68K code. Jump includes a very small runtime library that provides crucial Java support like garbage collection.
The only disappointing aspect of Jump is that the Palm OS is not completely supported. For example, any calls that require a callback function as a parameter (such as LstSetDrawFunction and FrmSetEventHandler) won't work.
This development environment is free, and source code is provided. Jump is the brainchild of Greg Hewgill; you can get it from http://www.hewgill.com.
CASL
This commercial package provides cross-platform support. You write an application once in the CASL language (a BASIC-like proprietary language) and then deploy it on Palm OS or on other operating systems. This approach offers you ease of cross-platform dispersion as you write your applications in one language for multiple platforms. The code is compiled into a p-code for a virtual machine. There is a virtual machine for Palm OS, and one will be available for Windows CE in 1998. You can test your applications under Windows, as well. Figure 2-7 shows an example of application development using CASL. As you can see, development is simpler than directly using C or C++.
CASL runs only on Windows and is currently priced at $64.95 (a free demo version is available). See http://www.caslsoft.com for more details.
Figure 2- 7.
Using the CASL IDE
High-Level Forms Development |
Palm devices are so numerous and applications so popular that there are even a couple of third-party development environments specifically for creating specialized forms-based Palm applications.
Pendragon Forms
This Windows application provides a very easy way to create simple multipage forms that contain text fields, checkboxes, radio buttons, etc.
Pendragon Forms also provides a conduit that automatically uploads information into comma-separated values (CSV) files. These files can then be easily imported into spreadsheet or database programs. Looking at Figure 2-8, you can see how simple it is to make the form being displayed on the Palm device in Figure 2-9.
Figure 2- 8.
Developing a form using Pendragon Forms
Figure 2- 9.
Running an application created with Pendragon Forms
Pendragon Forms is $50, and, nicely enough, there is no runtime fee necessary for deploying forms. See http://www.pendragon-software.com for further details.
Satellite Forms
Satellite Forms, by SoftMagic, is an environment for creating very sophisticated Palm OS applications. In Satellite Forms, your application consists of a number of database tables and forms. Each form is tied to a specific table and can display elements of that table. Figure 2-10 shows an example table in Satellite Forms. Figure 2-11 shows an example form. Figure 2-12 shows the resulting form on a Palm device.
Figure 2- 10.
Creating a table in Satellite Forms
Figure 2- 11.
Creating a form in Satellite Forms
Figure 2- 12.
A running Satellite Forms application
Instead of using C/C++ code, you control the actions of the application in one of two ways:
The application comes with a number of built-in controls as well as a library of routines. Satellite Forms also has an extension mechanism that allows you to write C code for your own new controls and new libraries (imagine, for instance, a library of financial routines or a new user interface control).
Satellite Forms has an ActiveX control that is connected to a HotSync conduit. You can use the ActiveX control during HotSync to copy any table to, or from, the Palm device. The tables are stored on the desktop as DBX files, which can be easily integrated with any database.
At the time of this writing, the price tag for Satellite Forms was $595 (making this the most expensive environment). You have a couple of requirements, as well. It only runs on Windows, and applications you create require a runtime library on the Palm device (the runtime is free). After you hand over the initial money, there is no additional cost to deploying applications built with Satellite Forms. There is a demo version (which limits the number and size of tables you create) available at the company's web site (http://www.softmagic.com).
There are certain things that can't be done in Satellite Forms. For example, you don't have direct control of events, you can't specify your own menu items, and text fields have a maximum length. It also may be quite difficult to create a very specialized user interface (although the extension mechanism does allow a lot of flexibility).
This is a very sophisticated package that can be used to create commercial-quality applications. The following commercial products have been built with Satellite Forms:
Handheld Development Recommendations
Now that you have a good idea of the choices for creating applications for Palm devices, it's time to figure out which is the right one for you. As should not be surprising, Windows programmers have the most flexibility; Macintosh and Unix folks have none. Let's look at the Macintosh, Unix, and then Windows choices in order.
Developing using Mac OS
CodeWarrior for Palm OS is the only way to do development at the current time. The good news is that CodeWarrior for Palm OS started life on Macintosh, so you can be assured that it's a robust, elegant product.
Developing using Unix
You'll be using GCC tools for your development environment. This isn't really a disadvantage, however. If you are accustomed to twiddling around with Unix in the first place, then the slightly more complex setup of GCC (the need to use makefiles) won't even get a twitch out of you. Plus, it's free.
Developing using Windows
You've got quite a bit of choice, as every environment we have discussed is available on Windows. Let's try to eliminate some of the options by focusing on what might be a factor in your decisions:
Assembly programming
If programming in assembly is your cup of tea, then ASDK is for you.
C/C++ programming
If you are an ardent C programmer, you will be using CodeWarrior or GCC. If you are an occasional or hobbyist programmer, then GCC is probably your best choice, given its attractive sticker price. While it is more flexible, it is also more difficult to use (it requires familiarity with makefiles and command lines).*
For greater usability, we suggest that you go with CodeWarrior. The inclusion of Palm's Conduit SDK as part of the package, the documentation and source code provided by both Metrowerks and Palm, and Palm's support make this development environment the obvious winner.
Forms-based script development
If price is an important factor, then we think Pendragon Forms is a good low-cost way to create simple forms for inputting data. If we were writing a simple survey-type application on a tight budget, this would be the tool of choice.
The choice for rapid prototyping, fast development, and great usability
We are very excited about Satellite Forms and view it as comparable to Visual Basic on Windows. If you can afford it, you should use it. Even if your final shipping application is based in C, this environment is great for rapid prototyping. It allows quick development of applications without forcing you to get involved in the low-level nuts and bolts of creating an application from scratch.
Let's put it this way-if we (veteran C/C++ programmers) were writing any application for the Palm OS, we'd first look to see whether we could use Satellite Forms. We give this strong a recommendation because of the experience we had with porting the sample application in this book to Satellite Forms. Don't be fooled by the simplicity of the environment. You can create quite sophisticated applications very quickly with little or no custom code. For example, consider the Sales application that we are developing in this book. Using C, this application has more than 2,000 lines of code and took weeks to write. Using Satellite forms, we created an application with similar functionality in about three hours-this includes the time it took to learn how to use Satellite Forms.
On the CD-ROM are versions of the Sales application. Compare the CodeWarrior/GCC version of it with the one we created using Satellite forms. We think you'll be amazed at the similarity. Figure 2-13 shows the final Satellite Forms version running on the Palm handheld.
-Figure 2- 13.
Sales application written using Satellite Forms
Switching platforms
If you are changing development platforms, there are a few issues for you to consider. CodeWarrior is compatible across platforms, as projects and files can be moved from Macintosh to Windows and vice versa.
You also have cross-platform compatibility between Windows and Unix if you are using GCC. The only thing to watch for is line break conventions-they are different on the two operating systems.
NOTE: This problem will go away in the future when Constructor is rewritten to use normal data files that provide true cross-platform compatibility. |
Switching development environments
Switching from CodeWarrior to GCC or vice versa is possible but not easy. The source code is not much of a problem, even though there are some differences between the two C/C++ compilers. The resources are a different matter. If you are moving from GCC to CodeWarrior, you have to do the following:
1. On a Mac OS machine, use prc2rsrc to convert your PRC file to a Macintosh resource file. (That's right-you need a Macintosh to convert from Unix to Windows!)
2. Next, use ResEdit to modify the MBAR resource into an MBAR resource and separate MENU resources as required by Constructor.
Going from CodeWarrior to GCC is much easier:
1. Use PTools (which is written in Java and therefore available on any platform) to open your .PRC file.
2. Next, display each resource in PilRC format. Copy each of the resources into one big .RCP file, and use this as input to PilRC.
Conduit Development |
If you are creating a conduit for your Palm application, you need to do so on Macintosh or Windows using Palm's Conduit SDK. The Conduit SDK comes with:
What Is a Conduit?
Under Windows, a conduit is a Dynamic Link Library (DLL) that is called as HotSync occurs. An install DLL is provided with which you register your conduit with HotSync. On Mac OS, a conduit is a shared library.
Conduits have access to databases on the Palm OS. The Conduit Manager handles the complexities of communication; it is not your concern. You simply call routines to read and write records in the database. The Conduit Manager handles the communication protocol.
Using C/C++
In order to develop conduits for Windows, you must use Visual C++ 5.0 (or later). For Mac OS, you can use any development environment that has the ability to create shared libraries (CodeWarrior for Mac OS is a likely candidate).
C++ classes that simplify creating a synchronization conduit are provided by Palm (frequently referred to by the names basemon and basetbl). These C++ classes are the basis of the conduits for the built-in applications. If your application's synchronization needs are similar to those of the built-in applications, then these C++ classes work well. As your application's sync needs differ, the C++ classes become less useful, and you might wish to consider reverting to the underlying C/C++ Conduit Manager API to make things work properly. You do, however, have another alternative.
There are other C++ classes recently provided by Palm to aid in the creation of conduits. These classes (called Generic Conduit) are not officially supported by Palm (at the time of this book's writing), but they do offer an alternative-in many ways easier-method of conduit creation.
Using Java
Presently, Java conduits work only on Windows. Conduits written in Java can take advantage of Java Database Classes (JDBC) for easy interaction with database engines. The sample code that is part of the Conduit SDK, Java Edition, uses JDBC to interact with an Oracle database.
Conclusion |
You should now have a good idea of which development environment you want to use to write your Palm OS applications. You should also know enough about the features in the Palm OS and of the devices to make intelligent decisions about the types of applications that you can create for Palm devices. Next, we discuss the sample application that we are developing throughout this book.
* While we have never used any, we have heard that there are visual frontends to GCC that make it somewhat easier to use.
Palm Programming: The Developer's Guide