PalmPilot Software Development - Alternatives to C
Please link/bookmark this page as http://www.aldweb.com/pages/winikoff/

The "PalmPilot Software Development - Alternatives to C" web page has always
been a reference for me, and for many other Palm OS developers.
Michael Winikoff who created and
maintained this reference page decided to no more host it on his web
site.
But, before quitting, he fortunately dropped me an e-mail for offering
me to host it.
Since I did not want to see this historical and valuable
contribution disappear from the web, I decided to upload it to my web site.
I
am not sure that I will succeed to maintain this page on a regular basis like
Michael did, but, at least, his job is kept alive.
Thank you Michael for all
of what you have done to the Palm developers community.
aldweb

Table of Contents

Introduction

What's
New?
The
List of SDKs
Benchmarking

Acronym
Glossary
Links

Introduction

One of my interests is in being able to develop software for the Pilot.

When it comes to developing software for the pilot (and for other platforms!)
I don't have the time or the patience to learn a new API and to write complex
event loops - I believe that the programming language should provide the basic
infrastructure and should let me concentrate on the problem I'm trying to solve
and not on getting the right parts of structures filled out, getting pointers to
point to the right place and so on. In particular, I gave up using C a number of
years ago and have never looked back. I consider Java to be a much superior
language (and I'm glad I leapfrogged having to deal with C++!) and also give
high marks to various declarative programming languages such as Prolog,
Mercury, Haskell, etc. and to scripting languages such
as Python, Ruby, Lua, etc.

Another advantage of programming at a higher level and not directly touching
the Pilot APIs is portability - a number of the tools and languages described
below allow software to run unchanged on both Pilot and WinCE devices. One
language (Waba) also allows software developed to run under the standard Java
runtime environment - you can run the same program on your Pilot and (as a
preview perhaps?) on a webpage as an applet; this is really cool!

By using high level languages (higher than C at any rate) it can become
possible to guarantee that programs don't crash the machine (for example by
accessing random parts of memory). Debugging also becomes easier.

Finally, a big argument in favour of higher level languages and APIs is
productivity:

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.
(Palm Programming: The
Developer's Guide, towards
the end of section 2.4)

DISCLAIMER: This page reflects my opinion and assessment. It is
intended to provide primarily facts and links, not opinions. How much I write
about a product has no correlation with whether I consider the product to be
good or not.

If you would like to suggest some tool I don't know about, correct me on some
point, or give me any other feedback, please feel free to send me an email.

Back to the top of this
page

What's New?
13th July 2008: Page moved from
Michael Winikoff's web site
to aldweb's web site.
Apart
from this technical change, nothing has been modified in any way, you will find
here all of Michael's original work.

13th December 2005: Updated URL for Pocket VisualForms

24th November 2005: Update HSPascal (now
non-commercial, thanks to John for updating me). Also fixed URL for PocketStudio.

1st September 2005: Fixed link to ppforth and updated Satellite Forms.
(Thanks Andy!)

23rd June 2005: Removed some dead links and updated comment about
Quartus being one of two platforms able to generate native code (which was true
when I wrote it, but subsequently other platforms with this facility have
appeared).

16th May 2005: Quartus update: new
version.

2nd February 2005: Updated Dragon Forth (now GPL)

Also minor updates to Quartus and PP.

28th October 2004: Updated OnboardC listing.

4th September 2004: Added Palmphi.

14th August 2004: Added benchmarks for LaFac and iziBasic.

11th August 2004: (yikes, almost a year since the last
update!)
Added LaFac and iziBasic

7th September 2003: Added PP benchmark.
Added
HB++ (and benchmark)

16th July 2003: Added SHARK

8 April 2003: Added nano-false

9 March 2003:
Added cbasPad 5 and benchmark results
(thanks to Ron Nicholson)
Added Pocket VisualForms

13 January 2003: (Happy new year!)
Added note about the Metrowerks
CodeWarrior benchmark.
Added link to Bench2 - a
better benchmark by Laurent Duveau.

Added PP (onboard
pascal compiler).
Added link to TinyLogo.

16 December 2002: New version of OrbForms Designer.

23 November 2002:
Added C++ frameworks (brief)

Added Pendragon (thanks to
Luu Duong)

9 November 2002: Added benchmark for NS Basic 2.1 and 3.0, updated
file for Metrowerks benchmark, and fixed typo in table.

28 October 2002:
New benchmark: C (Metrowerks
CodeWarrior 8.3, courtesy of Scott Elliott)
Added Rexx

27 September 2002: New version of OrbForms Designer.

23 August 2002:
Updated Onboard C (now
open-source)
Updated Plua (new version)

Updated Dragon
Forth (now has web page)
Updated PocketStudio (version
1.1, added price information)
Added benchmark for Pocket
Studio (courtesy of Scott Elliott - Thanks!)

8 July 2002: New version and price for CASL

14 June 2002: Minor clarification to benchmark table

13 June 2002:
Updated High Speed Pascal (now
released)
Added picoBASIC

11 May 2002:
Added more benchmarks.

Added OrbForms
Designer
Updated description of superwaba under Waba.

12 April 2002:
Added Palm TCL.

12 March 2002:
New version of HotPaw; also updated
benchmark (thanks Ron!)

7 March 2002:
New version of LispMe.

12 February 2002:
Added www.pdatnutsandbolts.com to pdatoolbox.

Updated AppForge
benchmark and URL for AppForge synopsis.

4 January 2002:
Fixed link to ppforth.

17 December 2001:
Added NS Basic Benchmark

Updated versions of PocketC and of LispMe.
Fixed SmallBASIC link.

10 November 2001:
Added Karel

15 August 2001:
Added mobileStudio C++

14 June 2001:
Added Kinectivity Studio

21 May 2001:
Added Lyme

11 May 2001:
Added additional benchmarks to the benchmark table.

10 May 2001:
Added Plua and benchmark.

Added ppforth.

Added New CASL
benchmark courtesy of Frank O'Brien.
Added Poplet and updated Action Pad.
Added
Poplet
benchmark.

13 April 2001:
Added PalmLog and PalmTao.
Updated DB2 Everyplace description.

Added Dragon
Forth

29 March 2001: Fixed description of High Speed Pascal

22 March 2001:
Added High Speed Pascal

Added PocketStudio
Added
Kada VM

21 March 2001:
Added AppForge
benchmark
Added PDA Toolbox

Added SmallBASIC
Added
ScriptEase:Integration
SDK
Fixed link to Scheme (under LispMe)

4 March 2001:
Added CASL vs NSBasic
and AppForge to CASL.
Added links to
WabaJump and SuperWaba to Waba.

27 February 2001: Added Pippy (Python for the
Palm Pilot)

6 December 2000: Added AppForge

29 Sept 2000: Added benchmarking for HotPaw Basic and updated
benchmark for version 3.8 of PocketC.

27 Sept 2000: Added link to NS Basic review.

24 Sept 2000: Restructured the page:

Added what's
new section to make life easier for repeat visitors.

Added quick
reference to list of SDKs.

Removed table, shifting the information into the list of SDKs

23 Sept 2000: New SDKs/products:

J9 Java VM

Python

NS Basic/palm
(including benchmark)

DB2 Everywhere
changed name to Everyplace

DMIC announces an upcoming Waba development tool (under Waba)

The List of Software Development Kits (SDKs)
(Note that
all prices are in US dollars)

Quick Reference

Palm Hosted

Action Pad:
Language based on Javascript, easy access to memo text. One of the faster of
the interpreted languages. No longer available - has been replaced by Poplet. (cost was
$19.95)

cbasPad: Ye
Olde BASIC. Cost: free

cbasPad 5:
Experimental Basic interpreter implemented inside a native-ARM code armlet,
OS5 only. Cost: free

Dragon Forth:
Forth interpreter. GPL (formerly $45 (professional), $99 (enterprise))

HotPaw: BASIC,
Successor to cbasPad. Cost: $18.95.

iziBasic: BASIC,
compiler that builds stand-alone applications. Cost: US$15 (shareware)

Karel: Karel the
Robot: an educational tool for teaching programming. Free, but requires full
version of PocketC.

LispMe: Scheme
interpreter, includes graphics and PalmOS form access. Cost: free.

LaFac: A number
of programming languages (micro-basic, micro-pascal, micro-c and an esoteric
language called HELP). Free.

Lyme: Graphing
program with programming language. Requires PalmOS 3.1 (or better?). Free.

OnboardC: C
compiler running on the PalmPilot. Produces standalone fast apps. Cost: free.
(used to be $15).

Nano-False: An
interpreter for a forth-like language called False. Free.

PalmLog: An
interpreter for a Prolog-like language. Free, early version. Lacks
documentation.

PalmTao: An
interpreter for the lambda calculus. Free, early version. Lacks documentation.

picoBASIC:
an old-style BASIC implementation. Free?

Python for the Palm
Pilot (Pippy): Interpreter running on the PalmPilot. Beta. Free.

Plua: Port of Lua to the Palm. Free.

PocketC:
Language based on C, but with a number of differences, easy access to
graphics, events, etc. Cost $18.50.

Poplet:
Language based on Javascript. Allows easy extension of any application through
command bar and text fields. One of the faster of the interpreted languages.
Replaces Action
Pad. Requires OS 3.5, cost is $19.95.

PP: Onboard Pascal
compiler. Freeware. NEW

ppforth: Forth
implementation. Free.

Quartus: Forth
compiler, produces fast standalone applications, uses the PalmOS API. Free
demo cannot produce standalone applications, full version costs $99.95.

Rexx: An
interpreter for the Rexx
language. Free.

ScriptEase:
JavaScript. Commercial, website doesn't give price.

SmallBASIC:
BASIC interpreter. Versions exist for Unix and Wnidows. GPL.

TinyLogo:
Logo interpreter written in PocketC. Cost: free.

PC Hosted

PC Hosted: GUI Builders

AppForge:
Allows Visual Basic to be used to write PalmPilot apps. Requires Visual Basic.
Beta, will cost $299?

CASL: User
interface builder. Allows testing on PC. Pro version (+$40) can compile to C.
Also targets Windows CE. Cost $84.95.

HB++: Windows-based
development environment. BASIC-like language with rich library. Generates
standalone executables. Discounted single license is 1114.50 euros (approx.
1238 US$).

Kinectivity
Studio: Focuses on enterprise applications, supports various integration
issues. Cost starts at $695.

mobileStudio
C++: GCC based IDE with various editors and wizards, and an application
framework. Uses GCC. Current cost $19.95.

NS Basic/palm:
Windows hosted IDE with GUI builder using BASIC as the scripting language.
Cost $99.95.

OrbForms
Designer: Windows hosted IDE with C-like language (similar, but not
identical to PocketC). Shareware, $85/$55.

PDA
Toolbox: Windows hosted IDE with GUI builder. No programming language -
limited functionality. $25 shareware.

Pendragon:
Windows based IDE with GUI builder.

Pocket
VisualForms: Windows based designer that generates PocketC code.

Satellite
Forms: Windows based IDE with GUI builder. Cost $795/$995.

StylusWareBasic: User
interface builder, in beta testing.

PC Hosted: Java

Ghostmachine:
Java VM for the PalmPilot, project officially inactive. Cost: free.

J9 (Visual Age
Micro Edition): An embedded Java VM from IBM. Cost: free ($99 for collaborative
version).

JUMP:
Not a Java VM. Rather, a compiler. Uses PalmOS API. Cost: free.

Kada: Java VM
with features including debugger, code minimizer, ahead-of-time compiler, and
installer. Commercial.

KVM: Sun's Java VM. Cost free.

Spotless: A
Java VM. Research prototype, predecessor to KVM. Cost free.

Waba: Java VM
which uses its own standard library, rather than the standard Java library.
Doesn't implement threads or exceptions. Also targets Windows CE. Cost free.

PC Hosted: Other

CAML light for
PalmOS: Compiler (Unix based?) for CAML, alpha. Cost: free.

DB2 Everyplace:
Links IBM's DB2 with Palm applications. Development can be done either with Satellite Forms or
any other language. Versions exist for Windows CE and Psion's EPOC.

High Speed
Pascal: Pascal compiler targetting the Palm. Now available by donation.

Palm Tcl: An
implementation of TCL that integrates with Palm resources (i.e. forms). Open
source.

Pocket
Smalltalk: Smalltalk implementation, has graphics access, has been used to
write games. Cost: free

PocketStudio:
Delphi-like environment. $59.99 standard, $199.99 professional.

Python to Palm
Port: PC (Linux?) hosted Python. Alpha. Cost: free.

C Frameworks
Palmphi is a free
windows-based integrated development environment that provides a graphical GUI
builder, class browser and other assistance with programming. The language used
is C. (thanks to Bill Cianfrani for pointing it out)

The following use C++, but are alternatives to Palm's standard APIs. (thanks
to Scott Elliott for pointing them out)

Zen Plus from
Class Action (free).

Palm Object Library (POL) from
Aqpoint (US$49.95)

Palm Application
Framework (PAF) from Bear River Associates (free)

NEW SHARK is a
multi-platform platform, basically (as far as I can tell from the very brief
description), it provides an interface that allows a C++ program to do
graphics, perform I/O, etc. Implementations of this interface exist for
PalmOS, PocketPC, windows smartphone and Symbian.

Other

YS COBOL:
Announced 1st April.

Action Pad
from Handwave.

The product is called Action Pad, the language is called
HandScript. The language is a subset of Javascript (basically,
Javascript without objects). The user interface is an extention of the memo
pad with an additional "do it" button. This makes playing around and
experimenting easy. There is also a nice interface for browsing a library of
functions. I haven't used this enough to comment on reliability (seems
reliable), or functionality and the APIs provided. Action Pad can be extended
in C, but the documentation was a little sparse on how this works.

Size: 85K
Version examined: 0.90 beta
Cost:
$19.95
Current version (10 May 2001): Action Pad is no longer available.
It has been replaced by The Poplettm
Kit

AppForge

The AppForge Toolkit for Visual Basic allows developers to use Visual
Basic to write applications for Palm OS. Requires Visual Basic. Currently
beta, will be available for $299?

Synopsis
on AppForge's website

CAML light for
PalmOS

This is still under development although an alpha version is available. CAML is a member of the ML family -
an impure functional language which is strongly (and statically) typed. For
more information on CAML (which is available for Unix, PC, and Mac) see the (beginner)
FAQ. Although ML has a fairly ugly syntax (IMHO) it is an expressive and
powerful language including such features as garbage collection, type
inference, safety (no core dumps!), pattern matching, numerous data types,
imperative features, modules, object-orientation support, exceptions, and
polymorphic typing (phew!).
Cost: free
Development on this seems
to have stalled.

CASL from
CASLSoft

Update (8 July 2002): new version is 3.3, price is now $84.95.

I've had a quick look through the documentation. CASL seems to be strongly
oriented to IS vertical applications (surveys, forms, data collection,
inventory). CASL provideds an IDE which runs on the PC and includes a drag 'n
drop GUI builder. Functionality is specified using a scripting language.

Size: 41K
Version examined: 2.5
Cost: $64.95

Current version (24 sept 2000): 3.0

CASL and Satellite Forms are quite similar. The differences between them
that are apparent include:

Satellite Forms only runs on Palm, CASL also does WinCE

CASL allows testing to take place on the PC

I felt that Satellite Forms was easier to use - part of this was the
syntax, but also the help system.

Satellite supports adding functionality by linking in C libraries. I
couldn't see anything in the CASL documentation that mentioned this.

Update: CASL now does offer this facility.

Frank O'Brien has an
independant CASL
page with examples of source code, tips, programs, tools and other stuff.
Frank's CASL page also has a comparison
between CASL, NSBasic and AppForge.

Update email from Mark, a CASL user:

I just have a few updates about CASL (since I've been using
it for about 2 years).

There is a "Pro" version (+$40) that compiles directly to C which
improves the speed. You can link in C code libraries. Current version is now
3.0

The PC development environment is great since it includes an emulator and
debugger (breakpoints, monitor variables, etc) that has saved me from myself
many times.

cbasPad by Ron
Nicholson

BASIC. The programming language is fairly limited (as is the wont of
BASIC's) but provides nice, simple access to some PalmPilot functionality such
as graphics (as is the wont ...)
Size: 47K
Version
examined: 0.92b
Current version: (24 sept 2000) 0.97b4

Cost: free

cbasPad
5 by Ron Nicholson

cbasPad is an experimental version of cbasPad that runs on the newer
palm-pilots (such as the Palm Tungsten T) using the ARM CPU. It only runs on
these machines (under OS5), but runs natively and is, according to Ron's
website, "Blazingly
Fast".

DB2
Everyplace from IBM

DB2 Everyplace isn't a programming language. Rather, it is a bridge to
IBM's DB2 which integrates data and allows data transfer. Software can be
developed using Satellite Forms or
other SDKs.

This product is currently in beta and should be shipping in June. Versions
exists for all three major platforms (PalmOS (PalmPilot), Windows CE, and EPOC
(Psion)).
Note name change from Everywhere to Everyplace.

According to John Kovar DB2 now comes with Personal Application
Builder - a GUI form design interface which compiles using the GNU
compiler.

"DB2 Everywhere works in concert with IBM Mobile Connect, a
pervasive computing technology that provides direct access to corporate
networks from handheld devices. IBM Mobile Connect manages the automatic
exchange of data between mobile devices and corporate networks. In addition
to synchronizing DB2 applications and data, IBM Mobile Connect synchronizes
email with Lotus Notes, Microsoft Exchange, and personal information
management applications such as calendars and address books. IBM Mobile
Connect also synchronizes applications and software to the mobile device,
providing a complete, integrated solution for the mobile worker.

For rapid application development, DB2 Everywhere will be available
with rapid application development tools. Available with DB2 Everywhere is
the DB2 Application Developer, a visual construction tool for Palm Computing
Platform applications. Soon to be available with DB2 Everywhere support is
Satellite Forms Enterprise Edition from Puma Technology. Satellite Forms is
the leading visual development tool for devices based on the Palm Computing
Platform including 3Com connected organizers, Symbol(R) Technologies' SPT
family of devices, the IBM WorkPad PC Companion, and the IBM WorkPad c3.
With Satellite Forms and DB2 Everywhere, developers can quickly create
sophisticated handheld applications that seamlessly integrate with
enterprise data from the DB2 family of databases and Lotus Notes.

Application developers who choose not to use Satellite Forms or the
DB2 Everywhere Personal Application Builder will find it easy to develop
applications for DB2 Everywhere. DB2 Everywhere's programming interface
supports three industry-standard interfaces. DB2 Everywhere supports a
subset of the DB2 Call Level Interface (CLI), a subset of the Open Database
Connectivity (ODBC) interface, and a subset of the Java Database
Connectivity(JDBC) interface(for EPOC only)."

Dragon Forth

Forth interpreter for the PalmPilot. Now has a website. Formerly cost $45
professional, $99 enterprise; now GPL on sourceforge.

... It is fast 32bit FORTH system having the
following features:

Full ANS 94 compatibility

Fast 32bit and 64bit arithmetic

Multitasking kernel (!)

Supporting PalmOS from 2.0 to 4.0

Fast creating of prc and fast cloning the forth system

Supporting all of 1052 api functions of PalmOS 3.5 with color support

Automatic and efficient type cast for api calls (!)

Built in IEEE-754 Float package

Native interface to well-known library MathLib

Built in 500 PalmOS error messages

Clear using of callback functions

Compatibility with SP-FORTH 3.x/4.x, DS-FORTH 2.x

Ability to develop and compile your programs on PC

This system
is ready for 100% palm development process, you can write your programs
anywhere only with help of your palm device.Now you can think only about
your task, we are making all the rest.

Ghostmachine by Sean McDirmid

An implementation of the Java Virtual Machine (JVM) for the Pilot.

This project is officially inactive.

HB++

A visual basic-like development environment that runs under windows. It
seems to have a fairly rich libraries (including database access, networking,
GUI elements, etc.). HB++ generates a single executable (no runtime needed). A
free trial version is available. Prices vary depending on the number of
licenses, a single (discounted) license is a little under 1300 US$.

High Speed
Pascal by Christen
Fihl

"HSPascal is a Pascal compiler which generates compact standalone PRCs. It
is a one program environment with integrated IDE. It has most of TurboPascal's
features and ease of use, except for objects and a debugger. " (from Christen
Fihl)

High Speed Pascal costs US$75 or 75 euros (except for EEC companies outside
of Denmark that have an EEC VAT number; they pay $60)
Update (24
November 2005): HSPascal is now non-commercial (by donation).

High speed Pascal shares its name (but not much code!) with an earlier
commercial product which was available for Amiga and Atari machines in the
90s.

iziBasic
by Laurent Duveau

iziBasic is an implementation of BASIC. Its distinguishing feature is that
it can generate stand-alone applications. Shareware costing US$15.

HotPaw by Ron Nicholson

HotPaw BASIC is the successor to cbasPad.
Cost: $20

Current version (24 sept 2000): 1.2.0
Current version (12
March 2002): 1.3.2

J9
from IBM

IBM has an embedded Java development environment which targets (among
others) the PalmPilot. More details at http://www.ibm.com/software/ad/embedded.
I'll be providing more information once my CD arrives :-)
Cost:
free or $99 for a collaborative version.

JUMP By Greg Hewgill

JUMP compiles Java to assembler code which is then compiled using Pila.
From memory, it requires that you write a pilotmain (not sure if this
is the right name) routine which implements an event loop.
Cost:
free.
Current version (24 sept 2000): 1.0 beta 4

Karel
by Michael Winikoff

Karel the
robot is an educational tool for teaching programming. Karel is a robot
with a simple vocabulary of actions it can perform and conditions it can
sense. Karel was introduced by Richard Pattis in the book Karel
The Robot: A Gentle Introduction to the Art of Programming (second
edition 1994, first edition 1981). This implementation takes the form of a
collection of library procedures for PocketC. You write PocketC programs using
these procedures and the library provides the display (as well as a world
editor). Since programs are compiled with PocketC you'll need the full version
of PocketC, not the runtime only version. The example below is shown running
in the animated GIF on the right.
// KarelExample
include "karel"
main() {
turnOn(); setPause(370);
loadWorld("karel1world");
while (!blocked()) {
move();
if (beeper()) pickup();
}
turnLeft(); move();
while (wallLeft()) move();
turnLeft(); move();
while (holdingBeeper()) {
drop(); move();
}
turnRight();
move(); move();
waitp();
}

Kada
VM from Kada Systems

Yet another Java VM. This one claims a number of features (code minimizer,
ahead-of-time compilation, installer, debugging facilities) as well as small
memory footprint, complete personal Java API support, and support for threads.

Kinectivity
Studio from Pencel

Focuses on developing and deploying enterprise applications. Provides both
environment for developing palm-side apps (using GUI builder and a language
based on Javascript) and server-side integration. I haven't had the time to
look at this in detail but from reading their review guide it seems quite
comprehensive. Expensive (starts at $695) but it's aimed at organisations
wanting to develop solutions integrating handhelds with their data
infrastructure, not at individual developers.

KVM from Sun

The KVM is a Java VM (Virtual Machine) implementation from Sun. The name
comes from the fact that memory usage is measured in Kilobytes, not Megabytes.
Unfortunately I haven't had the time to have a good look at this. My first
impressions was that performance was a little slow. KVM is an outgrowth of
Spotless (below). This
page has various example applets and a number of links including the FAQ,
a tutorial etc.
Size: 118K
Cost: Free
Version
Examined: EA 0.2

LaFac
by Laurent Duveau

LaFac (which stands for "LAnguage FACtory") is a language implementation
that uses a common byte-code ("p-code") to provide an implementation platform
for four different programming languages: micro-pascal, micro-c, micro-basic,
and a weird
language called HELP that's similar in some ways to FALSE. LaFac is free
and can generate stand-alone applications.

Lyme by Calerga

Lyme is a PalmOS port of the Lightweight Math Engine used in SysQuake.
Although it is ostensibly a tool for scientific visualisation and simulation
with extensive graphing capabilities, there is a full blown programming
language under the hood with extensive support for graphing and mathematical
functions.

The online
documentation gives a good feel for using Lyme and the list of
functions gives a feel for its capabilities.

Lyme is free and requires PalmOS 3.1 (or better?) and at least a megabyte
of free memory.

LispMe by
Fred Bayer

The name is a misnomer - LispMe is actually a Scheme
interpreter. It provides a reasonably complete Scheme implementation with
graphics functions, user interface support (palmOS forms), and access to HanDBase databases.
Size: 43K

Versions examined: 1.52, 2.7
Current version (7 March
2002): 3.1
Cost: free

mobileStudio
C++ from M.Labs

This is a C++ based IDE (using GCC) with various editors (forms, alerts,
images, etc.), and various wizards (e.g. AppWizard, ClassWizard). It also
provides an OOP application framework. Current cost is $19.95.

Feature
list

NS
Basic/palm from NS Basic

NS Basic has been around for a while, starting life as a development tool
for Apple's Newton. The company has recently released a PalmPilot product.
This runs on the PC and can be best thought of "Visual Basic for the
PalmPilot".
Cost: $99.95
Current version (24 sept 2000):
1.06

A tutorial
on wirelessdevnet.com.

A Review
of NS Basic/Palm by The
Gadgeteer.

OnboardC

This is a C compiler which runs on the Pilot. It takes input either from
memos or from doc files (which can be edited using qed). Since OnboardC is a C
compiler using the Pilot API it doesn't really belong on this page - I mention
it since it is unusual in that the compilation is done on the Pilot.

Update (28 October 2004): OnboardC now includes an integrated
document editor called SrcEdit.
Update (22 August 02):
OnboardC is now available for free from a Yahoo group. Also, development of it
is continuing (as open-source) on SourceForge.
Update (8 February
2005): There is a framework called Rapid
Palm GUI by Juergen Bermann which assists with developing GUIs with
OnboardC.
Current version (24 sept 2000): 1.004
Cost:
free (used to be $15)

OrbForms
Designer from OrbWorks

A windows-based graphical user interface builder that uses a C-like
language for coding event handlers. The language is similar, but not identical
to PocketC (also from OrbWorks). OrbWorks can generate either a single PRC
that includes the runtime system, or a (smaller) PRC that relies on the
OrbForms runtime being distributed separately. Performance (see below) is
significantly better than PocketC (and other interpreted implementations).

Version 1.0 was released 25 April 2002, followed by 1.0.1 on the 8th of May
(2002). OrbForms is shareware with the restriction that applications built
with the non-registered version will only run on the Palm emulator. OrbForms
costs $95.

27 September: version 1.2.0 released. New features (from the email from
Jeremy) include:

Redesigned project wizard system

About box can now check for upgrades

Several minor IDE features

Serial I/O and raw IR support

Advanced native add-in features - system event handlers and type string

processing

Several new APIs (see What's new in the docs)

Lots of bug fixes

NEW Version 2.0.1 released 12th December. New features include
code-completion and calltip (displays information on functions and their
arguments as you type). Also, the price has been reduced to $85 and there is a
personal license for $55 (for non-commercial use and freeware).

Palm Tcl

An implementation of TCL (based on version 7.6). The implementation uses
the tools pilrc and par and is portable to any platform
where these will run (e.g. Windows, Unix). The TCL implementation is packaged
with the TCL scripts and Palm resources (e.g. forms) into a single
.prc file.

Palm Tcl is a open source programming language and development
environment for creating applications for handheld devices running the Palm
OS operating system. Its primary goal is to simplify and accelerate the
process of application development for Palm OS. Palm Tcl allows programmers
to write applications without requiring them to know the intricacies of the
Palm OS runtime environment. Programs written in Palm Tcl are generally an
order of magnitude shorter than their C equivalents and can be written in a
fraction of the time.
(From http://palm-tcl.sourceforge.net/introduction.html)

PDA
Toolbox

A user interface builder which is unusual in that no programming language
is used - actions are selected from a fixed list which operates on an
underlying database. This makes PDA Toolbox quite easy to use but limits its
application scope.

Jared Norton runs http://www.pdatnutsandbolts.com/:
the support site for PDA Toolbox.

Pendragon

"Build data collection applications for Palm OS handheld devices in
minutes. Point-and-click design interface makes forms creation, distribution
and synchronization easy for non-programmers. "

picoBASIC
by Picodoc

An implementation of old-style BASIC (similar to GW-Basic according to S.
Hall) that runs on the palmpilot. Appears to be free, requires OS v3.1.

Pippy: Python for
the Palm

Pippy is a port of Python for PalmOS. It is a continuation of earlier work.

Nano-False by Willow Fung

This is an interpreter for False. False is a
language that was designed to be "challenging" to use and to allow for a
compact implementation - the original False compiler by Wouter van Oortmerssen for the Amiga was
1024 bytes long! (yes, bytes, not kilo-bytes). False is forth-like but uses
single characters for commands rather than names; for example forth's
dup is $ in False.

This implementation by Willow Fung is written in Java and can be run on
Palm Pilots as well as on certain models of Mobile Phones!
Download nano.zip

PalmLog by Willow Fung

This is an interpreter for a Prolog-like language. It's still an early
version (0.2 from memory) which is missing documentation and needs some
improvement to the user interface.
Important: The
web site provides a file MemoDB.pdb which contains examples. My
understanding is that installing this file will overwrite all of your existing
memos. Don't do it.

PalmTao by Willow Fung

This is an interpreter for the lambda calculus. It's still an early
version (0.2 from memory) which is missing documentation and needs some
improvement to the user interface.
Important: The
web site provides a file MemoDB.pdb which contains examples. My
understanding is that installing this file will overwrite all of your existing
memos. Don't do it.

Plua

Plua is a port of Lua to the Palm by M醨cio Migueletto de Andrade. It has
access to graphics, events, etc and is free.
New version out (August 2002)

PocketC from
Orbworks

Produced by Orbworks, this uses a C syntax but is safe due to the lack of
pointers. Development is done on the Palm (or WinCE) and the code (written as
a Memo) is compiled to an intermediate form which is executed. The
intermediate form can be distributed if you don't want to give out your source
code.

The language is fairly weak - it doesn't have facilities for dynamic memory
allocation (actually it does now - see below); but it has quite a rich set of
functions for accessing Palm system functionality (graphics, text I/O, timers,
pen input and events, memo pad and database access). Although it doesn't have
GUI elements, there is a toolkit available which implements them. PocketC
allows recursion.

PocketC seems fairly reliable although it does crash sometimes. The
developers are aware of this and I'd expect this problem to be fixed soon.

PocketC resources at
Orbworks

PocketC
tricks and tips by Alfons Grabher.

A new version of PocketC (for Palm) has been released. New goodies include
a pointer data type, memory allocation routines, and the ability to capture
the hardware buttons and the menu button. Execution speed hasn't changed
significantly as far as I can tell.
Size: 47K (this is the full
development environment, runtime only is smaller)
Versions
examined: 2.1, 3.7
Current version (17 December 2001): 4.1.1

Cost: $18.50

Pocket
VisualForms by Diego Calp

Pocket VisualForms is a windows-based tool for designing forms. It
generates PocketC code.

The Poplettm
Kit from Handwave

The Poplet kit (which replaces Action Pad) allows
applications to be extended with "poplets" - little applications that can be
brought up using the command bar (introduced in OS 3.5). These poplets take as
input the selected text and can be brought up in any application
(whereas Action
Pad only allowed programs to be run taking input from selected text in a
memo). The language used is HandScript (same as ActionPad) and the user
interface is similar. The Poplet kit requires OS 3.5. Runtime is free but the
development version (which is available for trial for a week) costs $19.95.

PP
by Philippe Guillot NEW

An freeware onboard Pascal compiler. According to Laurent Duveau's benchmark PP is
one of the faster development platforms.

"PP is a freeware standard Pascal compiler for PalmOS. PP
generates true native 68000 executable code (.PRC) from standard Pascal
source code. You can use your favorite Palm DOC editor to write your code,
and either run PP from the VFSdos console or PP Shell to compile and run
your program."

Update (2/2/2005): New
website, and there is a resource editor called Bird

ppforth by Jih-tung Pai

A Palm port of Pai's Linux forth (lpforth).

Pocket
Smalltalk by Andrew
Brault

This is an implementation of Smalltalk which generates PalmPilot
executables. It has been used to write the game Dungeoneers.
Development involves compiling on the PC then downloading to the PalmPilot for
testing. There are plans to add PC side execution to Pocket Smalltalk. It is
also possible to use a PC smalltalk (such as Dolphin Smalltalk).

The new version (2.0) is based on Squeak and runs on a number of platforms. It
also targets a number of platforms.
Size: 44K (pocket smalltalk
generates a single PRC, the size is 44K plus the user's code)
Version
examined: 1.5 beta
Current version (24 sept 2000): 2.0
alpha
Cost: free

PocketStudio 1.1 from
Pocket Technologies

A compiler (for Pascal) and IDE described as "Delphi-like". Pricing is $60
(well, $59.99) for standard version, and $200 for professional edition
($199.99). They also offer training.

Python to Palm
Port

Alpha software but potentially promising.
Cost: free

Rexx by Jaxo Inc.

An interpreter for the Rexx
language that runs on the Palm. Also includes "rexxlets" - a hack that
allows you to use Rexx scripts as popups from within other applications.

REXX is a programming language designed by Michael Cowlishaw
of IBM UK Laboratories. Rexx is an acronym which stands for "Restructured
Extended Executor Language". In Mike's own words: "REXX is a procedural
language that allows programs and algorithms to be written in a clear and
structured way."
...
What makes REXX different from most other
languages is that it is also designed to be used as a macro language by
arbitrary application programs. The idea is that application developers
don't have to design their own macro languages and interpreters. Instead
they use REXX as the macro language and support the REXX programming
interface.
What is
Rexx? from the Rexx FAQ.

Quartus by
Neal Bridges

Quartus is an outgrowth of PilotForth. It compiles to native code and is
one of two development environment running on the Pilot capable of doing this
(the other being OnboardC). [Update
(23/6/05): this was true back in 2000 when I wrote this, but is no longer the
case: for example, PP
can also generate native code.] It is intended to be compatible with the ANS
Forth standard. I consider Forth to be a low-level language at the same level
as C. (Whoops, I think I've just mortally offended both C and Forth
programmers here ... seriously, I've heard from other people who disagree with
my assessment of Forth. As always, if in doubt, go to the sources and make up
your own opinion). There are two versions of Quartus: a free version which
doesn't allow generation of standalone .PRC files and a for sale version which
does have that facility.
Size: 75K
Version examined:
0.7.4 beta
Current version (24 sept 2000): 1.2.1e
Current
version (2 Feb 2005): 1.5.3
Current version (16th May 2005):
2.0.0
Cost: free / $99.95

IndiVideo have an on-board
resource editor called OnBoard
RsrcEdit.
Update (2/2/2005): this has been taken over by Quartus.

Satellite
Forms from Puma

Looks fairly similar to CASL: PC based IDE with GUI builder (don'tcha love
all these acronyms?) and a fairly limited programming language.

Cost: $795 (standard edition) or $995 (enterprise edition)

Current version (24 sept 2000): Standard and Enterprise editions
(version 3.5)
Size: 78K

update: (1 September 2005) it appears that Satellite forms has moved
to http://www.satelliteforms.net/
and that Puma are no longer involved?

ScriptEase:Integration
SDK from Nombas

An implementation of JavaScript (aka ECMAscript)
This page discusses
scripting on embedded devices.

SmallBASIC

Free (GPL) BASIC. Versions exist for Linux, Windows, DOS, and PalmOS.
Screen shots can be found here.
Current
version (17 December 2001): 0.7.1

Spotless from Sun Labs.

Spotless is a Java Virtual Machine for the PalmPilot. It was developed by
a research team at Sun Labs. The
research team was looking at how to produce a JVM which required tens of
kilobytes of memory, rather than megabytes of memory.

Spotless differs from waba in that it supports the full Java language
including threads (!) and exceptions. On the other hand waba provides a richer
and more comprehensive library for user interface development and for
accessing palm pilot functionality such as databases, graphics, serial IO etc.
Spotlet only provides basic graphics and events (keys and pen up/down/move).
Finally, waba is significantly faster.
Size: 43K
Cost:
free

StylusWareBasic from StylusWare, Inc.

This product is inspired by Visual Basic and provides an integrated
development environment (IDE) running under Windows which allows GUIs to be
easily constructed. Behavior is specified using a scripting language (Basic).
This is currently in beta testing and a demo can be downloaded. Final pricing
(or release date) is not yet available.

TinyLogo
by Timothy Lipetz

TinyLogo is (as the name suggests) a version of Logo. It is written in
PocketC which, unfortunately, means that execution speed is fairly limited.

Size: 29K
Current version (24 sept 2000):
1.1
Cost: free

"TinyLogo is a programming language and program execution
environment for the Palm handheld computer. It is especially friendly to
beginning programmers or people who just want to get a simple idea of what
programming is all about. Once TinyLogo is installed, programs can be
written and run entirely on the Palm computer. Also, since TinyLogo programs
can be saved and loaded from memos, they can be exchanged with anyone else
running TinyLogo. TinyLogo has over 75 built-in procedures and most
importantly, allows you to extend the language by writing your own
procedures. Within a very short time, new programmers can write their own
procedures to create computer graphics, play music, manipulate words and
sentences, and calculate numbers."

Waba from
Wabasoft

Waba is perhaps the most exciting development language. The language used
is a subset of Java (missing threads and exceptions) but uses the Waba
standard library instead of Sun's (much richer) libraries. Applications are
compiled using a standard Java compiler and can be executed on a PalmPilot,
Windows CE Palm-sized PC, or under a standard Java runtime environment -
including netscape! You can put a program on your web page for people to try
out before they download it to their PDA ... David Linker has done this
with Conway's
game of Life. Also, Takechi Masashi has produced a simple game using
Waba and presented it using a nice Palm border.

Unfortunately, the standard library which Waba provides is fairly limited -
it has graphics, but no text output (as in a scrolling console; however, see
my tty library
for waba), there are no GUI elements (although code implementing buttons
is given in the example programs), and there is no way to access memos.

Version originally examined: 1.0 beta 3
Size: 39K

Current version (24 sept 2000): 1.0
Cost: free (open
source)

WabaJump is a compiler for Waba
which generates native code.

"WabaJump is a Java API to allow programs
written for the Waba or SuperWaba VMs to be compiled to PalmOS PRC files,
removing the need for a VM to be installed. This also allows people who
currently write Jump programs to use an easy API, while keeping the power
and speed of Jump."

SuperWaba, is
a richer version of Waba that includes more Java features (e.g. richer
libraries, support for double and long numbers, extension with Java or C
plugins, and faster than Waba). (Thanks to Alan Stein for prompting me to
update this description)

UIGen by Andreas Bade
is a user interface generator.

Robert Nielsen has
written Waba
AWT - a basic user interface framework for Waba.

Waba
Newsgroup

WabaWorkbench

DMIC have announced a Waba Visual
Development tool. You can find screenshots and some discussion of the tool's
capabilities at http://www.dmic.fr/palm/prg2.htm.
The tool is anticipated to be available in the second half of 2000, requires
Waba 1.0, and is estimated to cost $US136.

MobileCreator

YS
COBOL

"Just in time for the Year 2000, Yorick Systems is proud to introduce
YS Cobol, the first COBOL development tool for the Palm Computing
Platform!"

What more can be said ... except that the announcement was posted on the
1st of April.

Back to the top of this
page

Benchmarking

In order to get a feel for how easy it is to use the various languages I
decided to write a very simple program under each SDK. An obvious program to try
was the following simple benchmark:

x=1000; y=0; while (x>0) {x=x-1; y=y+2;}

Below I give comments on my experience with each of the SDKs used and then
give the resulting numbers. The usual caveats for benchmarks apply and then some
additional caveats: this is a trivial benchmark and only gives a very very very
rough idea of the expected performance.
NEW: A better benchmark
has been developed by Laurent Duveau.

Click on the name of the SDK to view the relevant source code.

Action
Pad: The simple benchmark I used is included with action pad as a standard
library function (!). Performance is impressive - a definite improvement on
existing interpreters and coming close to Quartus.

Spotless: A
sample program was easily modified and then cleaned up by removing irrelevant
code.

PocketC:
I've used PocketC before so there were no problems. Wrote the program in a
memo and then compiled. I'd left out a semicolon and PocketC correctly took me
to the correct line.
It's been a while since I ran the benchmark so I
retried it on the latest version (3.8) of PocketC. Performance has improved.
Updated
source.

HotPaw
Basic: Straightforward to use. Reasonable performance.
Ron Nicholson
reports that the latest version of HotPaw (1.3.2) is slightly faster taking
1.43 seconds on a Palm Vx. According to Benchmark this corresponds to roughly
1.9 seconds on a Palm III. Note that this uses this source
which declares variables to be integers.

Waba: I
modified one of the example programs given (Scribble). Unfortunately, Waba
doesn't provide easy GUI building or an alternative to using GUIs. As a result
the source code for the benchmark program is significantly longer than the
other SDKs - in addition to the source code given, one had to use the
following library code
(On the other hand, some of the code is leftover from the Scribble
functionality and could be deleted). Performance was also quite dissapointing;
I believe that Wabasoft are currently working on beta version 4 which has
significantly improved performance.

Waba version 1.0 beta 4 has been released and it indeed offers a
significant performance improvement: the benchmark went from 12 seconds to
slightly more than one second. Waba version 1.0 beta 6 offers further
performance improvements.

CASL:
The GUI builder was easy to use but it took me a while and some browsing
through documentation to get the syntax right. CASL suffers from a bad case of
cancer of the semicolon. Being able to run the program on the PC without
having to hotsync was nice though.
Notes:

The contributed
benchmark by Frank O'Brien indicates that (at least according to this
primitive benchmark) CASLPro (which compiles to a standalone PRC via C) is
almost ten times faster than CASL.

CASL uses floating point operations

LispMe: The
user interface was not obvious however to LispMe's credit it held up to my
experimentation well. After figuring out how to compile programs and run
queries writing the program was easy.

cbasPad:
This was fairly easy to use. The language used is Ye Olde Basic complete with
mandatory line numbers.

Quartus:
Quartus crashed on me at one point (then again I was using a beta
version). Other than that the user interface is spartan - very command line
based. Neal Bridges' discussion of the
benchmark showing how the benchmark can be made 3.1 times faster.

Satellite
Forms: I found the user interface, the GUI builder and the scripting
language very easy to pick up. Satellite forms was very pleasant to use. The
downside was that you needed to download your program to the Palm to test it.

Pocket
Smalltalk: It's hard for me to comment on this one since I'm not a
smalltalk programmer. After a little browsing through the documentation and
the classes I managed to modify an example program to perform the benchmark.
The first time around I actually left out the initialisation code. At runtime
the code "crashed" since I was trying to treat nil as a number.
Actually, this highlighted a nice feature of Pocket Smalltalk: in these sorts
of situations it pops up a little debugger which indicates where the problem
was and gives the context (basically the calling stack). This made spotting
the problem trivial.

OnboardC:
The benchmark for OnboardC was kindly contributed by Laurent Thaler ([email-masked]). Comparing the code
(and its length) to the other benchmark implementations clearly illustrates
why higher level languages than C, and higher level access to Palm
functionality than the API are desirable. On the other hand, as Laurent points
out in his email, the speed of OnboardC is significantly better than PocketC
(a factor of around 250 for this, simplistic, benchmark).
If you want to
run the benchmark yourself you can download the
prc.

High
Speed Pascal lives up to its name. The benchmark code was contributed by
Christen Fihl. You can also download the prc.

PocketStudio
1.1 is also quite fast, as would be expected from a compiler.
Thanks
to Scott Elliott for contributing the
benchmark implementation. You can download BenchPS.zip,
containing the source code and PRC file.

NEW Scott Elliott suggested that although
this page is about alternatives to C, it might be useful to have C as a
benchmark for comparison. He was also kind enough to do the work involved in
prividing this.
BenchCW.zip:
contains complete sources and a PRC file compiled with Metrowerks CodeWarrior
8.3.
NEW Turns out that the remarkable performance (0.00074 seconds
for 1000 iterations) is due to the optimiser realising that x and
y aren't used and deleting the loop! (Thanks to Laurent Duveau for pointing this out).

NEW NS Basic:
John Hansen has provided versions of the benchmark compiled with NS Basic 2.1
and with NS Basic 3.0. You can download a zip file
containing the two PRCs.

NEW cbasPad 5:
On a Palm Tungsten, the benchmark took 1.69 seconds for 100,000 iterations.
This makes cbasPad 5 on a Tungsten about as fast as Quartus on a Palm m515. As
always, extrapolating across machines like this should be taken with a very
large grain of salt, doubly so when the benchmark is very simple.

Thanks to Ron Nicholson for running the benchmark.

NEW PP: Thanks to Laurent Duveau for providing a PP version of
the simple benchmark. (Download PP.zip containing
the program (PRC) and source code (in Palm DOC format))

NEW HB++: Thanks to
Jean Philippe from Handheld-Basic for providing this benchmark. (Download HB.zip containing
the program (PRC) and source code)

NEW Benchmarks for La Fac. Interestingly,
the different languages gave different results.
Source code: Micro-C, Micro-Pascal,
Micro-Basic,
HELP
(note that HELP source includes non-ASCII characters, so the source
(copied-and-pasted from an email) may not be correct ...)

NEW iziBasic

Results
Additional benchmarks. These we run (or
re-run) on my Palm m515. I've reported them below on their own, and also
inserted the extrapolated times (according to Neal Bridges' benchmark program)
in the main table (in red). Note that the performance
ratios vary: whereas normalised CASLPro on the m515 is faster than on a palm
IIIxe, PocketC (normalised) is slower.

Palm m515 results (1000 iterations)

Platform

Time

Time bar
(shorter is better)

Metrowerks
CodeWarrior 8.3

see above

HB++

0.00295

PP

0.00331

High
Speed Pascal

0.0054

OnboardC

0.0065

PocketStudio
1.1

0.00743

Quartus

0.0175

CASLPro

0.18

OrbForms

0.50

LispMe 3.11 April 2002

0.79

PLua 1.0b12

approx. 0.8

LaFac: HELP

1.04

iziBasic

1.17

PDE Standalone

1.28

SmallBasic

1.41

PDE PRC only

1.45

HotPaw Basic 1.2.2b1

1.59

LaFac: Micro-Basic

1.70

PocketC 4.3

1.85

CASL

1.92

NS Basic 3.0

2-3

LaFac: Micro-C and Micro-Pascal

2.85

NS Basic 2.1

5-6

Notes on new benchmarks:

OnBoardC: Same benchmark (PRC) as before. 100,000 iterations took 0.65 and
1,000,000 iterations took 6.47 seconds. Value for 1000 iterations approximated
from these.

Quartus version 1.2.1U (99.03.06): 32,000 iterations took 0.56 seconds,
hence 1000 iterations approximated as 0.0175.

CASL Pro: 0.18 seconds for 1000 iterations, 1.96 seconds for 10,000.

PDE: PocketC Desktop Edition. This can generate either a completely
standalone PRC including the runtime system, or a smaller PRC which makes use
of a separate runtime. For some reason the standalone version was faster.

Lua has been significantly improved: the previous version of Lua took
around 23-24 seconds on a Palm IIIxe for 10,000 iterations (i.e. roughly half
as fast).

Notes:

This graph is intended for rough visualisation only. Since times are
(mostly) reported to the nearest second there is considerable error)

Extrapolated values (from contributed or
additional benchmarks run by other people or on other hardware) are shown
in green. These values were normalised to a Palm III using
Neal Bridges' Benchmark
2.0. Values in blue are benchmarks which I ran on my Palm III. The
AppForge 2.1 benchmark is blue, however it wasn't run by myself.

Platform

Iterations

Approximate
Run Time
in Seconds

Runtime
(shorter is better)

OnboardC (normalised palm m515)

100000

1.21

PocketStudio
1.1 (normalised palm m515)

1,000,000

13.8

OnboardC (original palm III benchmark)

100000

1.61

Quartus

32000

1

Quartus 1.2.1U (99.03.06)

32000

1.04

Action Pad

100000

4.42

The Poplet kit

100000

4.53

Waba (beta 6)

32000

5

AppForge 2.1

10000

1.62

CASLPro

1000
10000

0.33
3.64

Spotless

1000
4000

~0.5
1.6

CASLPro (Frank O'Brien, Palm V)

1000
10000
100000

0.44
4.69
45.37

CASLPro (me, Palm IIIxe)

10000

4.8

AppForge (Rene van der Meer, IIIc)

1000

0.8

OrbForms (beta)

1000

0.93

Pocket Smalltalk

1000

1

Waba (beta 4)

1000

1

LispMe 3.11 (April 2002)

1000

1.47

PLua 1.0b12

10000

approx 14.8

Hotpaw Basic 1.3.2
(Ron, 1.43s on Vx)

1000

1.9

LispMe

1000

2

cbasPad

1000

2

PDE (Standalone)

1000

2.38

PocketC 3.8

1000

2.47

PocketC 3.8 (me, IIIxe)

1000

2.54

PocketC 3.7 (Albert J. Franklin, IIIx)

10000

26

SmallBasic 0.8.2

1000

2.62

PDE PRC only

1000

2.69

Plua

10000

28

HotPaw Basic 1.2.2b1

1000

2.95

Satellite Forms

1000

3

Hotpaw Basic

1000

3.34

Hotpaw Basic (Rene van der Meer, IIIc)

1000

3.37

PocketC 4.3

1000

3.43

CASL

1000
10000

3.56
35.81

PocketC

1000

4

CASL (Frank O'Brien, Palm V)

1000
10000
100000

4.39
43.96
465.52

CASL (me, IIIxe)

1000

4.44

CASL (Rene van der Meer, IIIc)

1000

4.84

CASL

1000

5

NS Basic 1.06 (Albert J. Franklin, IIIx)

10000

80.17

Comments

Being able to develop on a PC and, importantly, test on the PC is
very handy.

GUI builders seem to work quite well.

Using an in-house programming language is generally a mistake. It is
better to use an existing language. At the very least, an existing syntax
should be used.

Most of the alternatives to C surveyed do not provide a proper compiler
and this shows in their performance. It would be useful to have a (separate)
native compiler for, say, PocketC which could produce PalmPilot specific
full-speed native code. The SDKs which provided native code (Quartus and OnboardC) completely
blew away the others in terms of speed.

Additional/Contributed Benchmarks

Poplet:
The language is identical to Action Pad and the benchmark is supplied as an
example poplet. Since the Poplet kit requires OS 3.5 I was unable to run the
benchmark on a Palm III, instead I used a palm IIIxe with the following
results (other platforms are given for comparison):

Poplet: 100,000 iterations took 3.78 seconds

Plua:
10,000 iterations took 23-24 seconds

CASL (Frank's contributed
benchmark): 1000 iterations took 3.73 seconds

CASLPro (Frank's contributed
benchmark): 10,000 iterations took 4.03 seconds

PocketC (v3.8): 1000 iterations took 2.13 seconds

Conclusion: The Poplet kit (at least according to this,
primitive, benchmark) offers the same high performance as Action Pad.

CASLPro: Frank extended the benchmark with a
graphical user interface and more precise timing. His timing results (on a
Palm V running OS 3.5) were:

With normal CASL (p-code): 1,000 iterations took 4,050 ms, (10,000
iterations took 40,580 ms, 100,000 took 429,710 ms).

With CASLpro (native code): 1,000 iterations took 410 ms, (10,000
iterations took 4,330 ms, 100,000 took 41,880 ms).

Although we can't
compare directly with the benchmarks in the table below (which were run on my
Palm III - a slower machine), one can conclude that, at least according to
this primitive benchmark, CASLPro offers significant speed improvements -
around a factor of ten.
Frank also pointed out that the CASL benchmark
uses floating point numbers - not integers. This handicaps CASL compared to
some other languages (such as C, Forth, Java) which specifically distinguish
between floating point and integers and which used integers for the benchmark.
However, a number of other language implementations only provide a general
numeric type, distinguishing between integers and floating point numbers at
runtime only.
zip file
with prcs and source code

AppForge:
This benchmark was provided by Rene van der Meer. The code took 0.53 seconds
for 1000 iterations on a Palm IIIc. By comparison, CASL v3.1 took around 3.20
seconds and HotPaw Basic v1.2.4 b4 took 2.23 seconds.

J. Chris Tyburski, from AppForge Inc., has run the benchmark on a Palm III
getting a runtime of 1.62 seconds with 10,000 iterations using AppForge 2.1.

NS
Basic: Timings done using NS Basic/Palm 1.06 by Albert J. Franklin suggest that NS Basic
1.06 is approximately three times slower than PocketC (version 3.7). Al
writes:

The times for Palm OS Emulator 3.0a6 on a Pentium III-500
desktop and Pentium 166 notebook, and on the Palm IIIx OS V3.3, of PocketC
and NS Basic 1.06 for 10,000 iterations is (in seconds):

PocketC 3.7 Seconds
Pentium III 500
...... 8
Pentium 166 .......... 28

Palm IIIx ............... 24

NSBasic 1.06
Pentium III 500 ..... 25

Pentium 166 .......... 82

Palm IIIx ............... 74

Hope this helps. Where NS Basic shines is in the ease of programming, and
the quick graphics display/response.

John Hansen ran this
benchmark on a Palm m105 using NS Basic version 2,05a. Time taken: 8
seconds (for 1000 iterations). Since I'm not certain how fast an m105 is
(compared to a Palm III) I can't normalise. However, clearly, NS Basic
performance hasn't seen huge changes from version 1 to version 2 (1.06 to
2.05a to be precise).

Back to the top of this
page

Acronym Glossary

API: Application Programming Interface

GUI: Graphical User Interface

IDE: Integrated Development Environment

IMHO: In My Humble Opinion

PC: Personal Computer

SDK: Software Development Kit

VM: Virtual Machine

Back to the top of this
page

Links

Palm's Development page
and List of development
tools

The
Gadgeteer's page on PalmOS has a section on
programming.

RoadCoders have comprehensive
information on developing software for Pilot and WinCE devices as well as SDKs, articles, and
sample source code.

Palm
Programming: The Developer's Guide from O'Reilly is online.

Top
Ten Killer Palm Applications that should exist but don't by David Pogue

The PalmPilot FAQ has a section
on programming

Wade's Pilot
Programming FAQ

MathPad

The PalmPilot Entertainment
Zone has a page called Pilot Development which
covers PocketC, cbasPad, CASL, and two game construction tools (DakotaA and
Quest).

Handheld User Interface:
Ten Commandments from Bill Shadish of Fundamental Objects (mirror)

Back to the top of this
page