Program your Palm in Java

I've been playing around with Sun's KVM release since
it came out last week. It's quite possible to build
a Palm application using it -- one that replicates
most of the look and feel of the standard Palm apps.
The biggest drawback is that when you start a Java
app, there is a startup hit as the classes are read and
loaded. When you compare starting the datebook by
hitting a key and getting it instantly, to starting
a Java app with a several-second delay, the latter is
quite annoying. I'm sure that getting Java -- which
is most successful on today's higher-speed processors,
with JIT compilers -- to run on Palm is quite a
challenge, and I don't fault the Sun team on their
work, which seems very stable. However, I do think the
startup cost alone will deter users from gravitating to
KVM apps.

Note that the current KVM release does not include a
full Palm API -- instead it includes Palm-related
classes that I believe they say are for demonstration
purposes. Perhaps the idea is to have someone else
implement a full Java/Palm API.

So, what would draw users to Java apps? There is a
nice concept of a central class database, so if you
download a class to your Palm, many apps can use it
without having their own copy of the class in
their .prcs. That might save space, but it's hard
to imagine most apps using more than a few common
classes (beyond the core API). You can craft your
apps so they could be used on the desktop or on the
Palm with the same classes, but that may be a minor
improvement over c/c++. Perhaps a Palm VII/AvantGo
"browser" could be made to run KVM "applets."

In a future where Palms have better wireless
applications, Java is well suited to take advantage
of connectivity. Perhaps the real KVM applications
will need to wait for, say, the Visor Bluetooth module.
However, the current KVM does not include any network
classes, so those would need to be add-ons.

I guess the only big win I see right now is that
people who know Java and not c/c++ can now write Palm
apps, so the developer community expands. Maybe one
of those Java programmers will come up with something
cool.

If a Java VM and its supporting core classes could be put on a Springboard it could create an ideal environment for running Java applications.

The Springboard could provide hardware acceleration for the virtual machine and have dedicated memory for Java's core classes. It would then be able to execute Java byte codes quickly without filling up main memory with the surplus classes. Add some more storage to the Springboard and all Java applications could be kept in one place. In effect this would piggyback a Java specific processor and suporting hardware onto a Visor.

The result would be top-class support for Java applications that would rival desktop and server machines.

Would this make the Java language more attractive as to develop Visors applications?

Wait a minute... other than being interoperable (in some cases)
with multiple platforms (which C & C++ are, as well), Java has no real advantages.
I would choose C or C++ over Java anyday.

Main reason being Java's total lack of speed.
That, and it just plain sucks sometimes.

Joe Schmo

Pros:

• Developers learn and use a single language no matter what the platform.
  
• Use applets and "palmlets" (TM by Eric Giguere!) to provide web and Palm interfaces to the same application.
  
• Some people prefer Java to C/C++. And if you're used to programming in languages like Visual Basic or PowerScript, Java is certainly more approachable.
  

Cons:

• The VM and runtime environment are large, although the Micro Edition of Java is certainly an improvement on the Standard Edition.
  
• The whole question of what to do about a user interface is tricky. Do you go the portable route and write something like AWT/Swing that can run on all the handheld devices? Or do you go Palm-specific? Either way has problems.
  
• Java is memory-intensive, no matter what platform you're on. The current KVM is limited to using dynamic memory, but they'll have to add a way to swap objects in and out of storage memory in order to make it usable for larger programs.