Customer Reviews

Palm Programming: The Developer's Guide (Developer's Guides (Osborne))

5 star:		(13)
4 star:		(6)
3 star:		(7)
2 star:		(5)
1 star:		(12)

 

 

I have read the author's previous books on Newton programming, so I knew what to expect from this book. I wasn't expecting a combined tutorial/reference that could stand apart from the Palm docs, nor was I expecting it to cover "cool" stuff like writing Hacks for Hackmaster.

I mostly got what I expected, which was a good introduction to programming for the Palm platform, with fairly detailed technical introduction and programming hints for the user interface, database management, beaming, find, and a few other basic topics.

In a few places, though, the text gets a little hard to follow, and could benefit from a re-edit. Also, the code examples for the book's sample application are frequently presented out of context. You can usually understand how a particular API call is used, but it becomes difficult to see how this code fragment fits into the bigger picture.

Finally, for Linux programmers, the accompanying CD contains packages of development software (GCC, PilRC, and associated utilities). However, one of the packages (the prc-tools RPM) was put together badly, and hence if you install the software you get a non-working development environment. Once you do get a working development environment, the sample code needs some tweaking before it will compile - the Makefiles have DOS carriage-returns in it which confuse gmake, and the code examples themselves have mixed case in the #include directives which do not match the actual files on disk. It's obvious the code was developed on Windows, and the Linux side was never tested. I have tweaked, built, and run the sample application from Linux, so it can be made to work - you just have to be a little resourceful. I have to say, though, that I expected better quality control from O'Reilly.

After buying a Palm organizer, I knew I had to develop an app for it. This book is not written in such a way to help even a beginner get off the ground. Although it talks about different environments and other software to use, there is no clear thought and organization. The author does stress on good programming design and development, but thats about it. I'm sort of diappointed in this title, especially since its an O'Reilly book. Skip this one and find another Palm programming book!

I read the SDK documentation and the SDK Companion before Iever bought this book. I thought it would help clarify some of themore difficult points (as I come from a weak programming background.)But instead, I found that I already know MORE than this book teaches.Many of the examples are pseudo-code, worthless as real examples, andbarely helpful for the calls they make. The authors often gloss overthe more important points like common use, syntax, and definitions;telling the reader to read the SDK documents for THOSE things. Well,if I can read the SDK for everything important, than why do I need thebook? To summarize, it's not worth the money...

An Absolutly horrendously terrible book. Ignore this with a 10 foot pole. This book should be titled 'half a book on nothing, half a book on conduit development'. Information in here is sparse. Nothing is covered in any great detail and things are overlooked.

This book seems to ramble from one thing to another, lacking any strong cohesiveness that is required. In hindsight, Glenn Bachmans Palm book from sams, as well as the dummies guide, leave this book far far behind.

Stick with the Dummies Guide or Palm Programming (Sams Professional).

The only people who recommend this book is 3Com/Palm Computing, nobody else. Its an O'Reilly book, but dont mistake that for equating with quality.

This book covers some of what a developer needs to know in order to develop a good Palm application. Sections are well-written and straightforward, for the most part.

However, some of the serious deficiencies of this text are that a lot of the essentials are arbitrarily left out and the organization of the book, as a whole, is not good. The Authors never review specific information about variables, code fragments are scattered about without much explanation about how to use them, and basic controls, such as buttons, are not covered at all in the programming exercises.

These shortcomings aside, this is probably the best book going for palm programming right now. There is a lot of good information in here about database programming and conduit development that I found to be valuable, and that should be useful for the beginning Palm developer.

This is a good introduction in the fine tradition of the O'Rielly series, however, it is missing some crucial information. As an accomplied C programmer, I picked up the book in hopes of having the one source, other than the Palm Reference materials, than I would need to get up to speed. Alas, that was not the case.

The authors skipped alot of crucial stuff on GUI development, an area where vendor information is always thin. This lead to a lot of trial and error. Examples: fields where covered, but a few critical items were left out. Also it would have benefited from more examples apart from their one sample app that they built through the book.

On the other side of the coin, the concept of building a full app throughout the book to give depth to the text is a great idea that I hope others emulation. However, no one app will use all of the concepts that need to be covered, so some unconnected examples are also needed.

Also interesting was the compare/contrast of the two main development environments for Palm: CodeWarrior and GNU. Being an old UNIX guy, I like the GNU compiler, but it does lack some from the CodeWarrior product, which I ended up buying eventually. The Lite version on the CD is nearly unuseable.

I don't like the author's approach to sample programs. They show you everything presented in the context of some big application that they are writing.

When they present a new concept, they show you a short code snippet illustrating the concept, then show you how they implement that concept in this bigger application.

I would prefer a separate stand alone program that illustrates each new concept, (a la Petzold's "Windows Programming"). This makes it much easier to understand. I basically stop reading the chapter when I get to the part about how the new feature is implemented in their sales application.

After reading the other reviews here I was a bit hesitant at purchasing this book. I just needed a little bit of a helping hand in several areas. This book gave me exactly what I was looking for. It made many of the basic functions easier to understand.

In the introduction the book states that it was not written from start to finish, and was not really designed to be red that way, but if you want to you can. I did not need to read cover to cover, I just jumped to the bits that I needed help with. If you are not a C programmer or are an experienced palm programmer this book is not for you. If you know C (even just the basics of it) or C++ and you do not know palm, or only know limited palm, then this book could be a big help. I know it was for me.

I would sum it up as "A good learning reference". Not a learning guide to itself but that is what the palm documentation is for anyway.

Now, I have bought other O'Reilly books before (Java in a Nutshell is a great reference). However, this piece of garbage makes me wonder if it ever saw an editor.

Problem #1: The examples. Now an example is meant to show you how to create a program or how a function works. How this book does it is put the function in a code snippet but forget to show you what their header/resource file looks like. So you are forced to guess at what the parameters are.

Problem #2: Logic and flow of the book. Now, when they actually give you a programming prototype for a function (not all that often), you usually get a code snippet that shows how the code works. Of course, on a few occasions, the code snippet included other functions they hadn't bothered to describe yet so you are sitting there trying to decipher what a function that is describe 5 pages later is doing. On top of that, the authors seem to like to jump from subject to subject with no real connections between them.

Problem #3: Providing information. I like the fact that it says, and I quote "We don't discuss any of the following objects, because their creation and coding requirements are well documented and straightforward." It goes onto list things such as buttons, checkboxes, bitmaps and a few others. Now, this is supposed to be a DEVELOPER'S GUIDE and you are not giving us this information?! At least, tell us where this information IS documented so I can do something with a button or somesuch.

Problem #4: Variables. Okay, this is offputting. In almost every programming book I can think of, the author(s) spend a few pages describing what kind of variables the system provides. While the PalmOS has lots of these variables (all sorts of Ptr types), why doesn't the book bother to tell me whether the UInt (an unsigned integer, as far as I know) is 16-bit or 32-bit? The authors do not bother to EVEN ACKNOWLEDGE the fact that there are ANY variables. Instead, they just bandy about Word, DWord & others and assume you know what they are.

Now in defense of the book, I have not looked into the conduit development part. But if it is anything like the application development part, this book should be on reserve ... as a doorstop.

After using a number of books (from the library) and resources (including the Palm Site) I have found that this is by far the most comprehensive yet concise resource for learning to program the palm, with a nice balance between a tutorial and a reference book. Be warned you should already know C or C++ before atempting to learn Palm OS Programming, life would be just too hard to deal with if you have to learn both together, and this book will not help you learn C/C++.
The best feature is that they deal with CodeWarrior and the FREE PRC-Tools (GCC based) equally, as many books don't consider the hobbiest/shareware developers that do not want to invest in the expensive development environments.
Good investment, that will save a lot of time it would take to get this information from other sources such as the Palm OS Site.