0
Applets
CDC and CLDC are `configurations` which means JVMs with some basic APIs
MIDP is a `profile` which is additional APIs which will work on top of a `configuration`
Chapter two was particularly interesting, focusing as it did on the different types of PDA available, comparison of prices, relative market shares, and performance specifications for different PDA/Java combinations. Although naturally this look at the current market will date most quickly, it provides an interesting insight into PDA trends in this period. Overall the book gives a strong impression of having been written by a single developer (which it has) who has a lot of hands on experience with Java on PDAs, and thus has a lot of relevant advice to give. This is exemplified in Chapter three where we are taken through a selection of open source and cheap development toolkits, as well as the process of setting these all up to get started developing on the PDA.
Unfortunately after this strong start the subsequent chapters fall to some extent into the standard `work through the API` approach, so that while the chapter on user interfaces encourages us to consider carefully the restricted screen space on PDAs, the body of the chapter is simply a description of the different types of user interface component, rather than a more detailed look at when each of the component should be used and to what effect.
I don't want to be overly critical here since there is a burden on authors of technical works to make sure that important sections of the API are covered, however I find I am not really able to take in more than trivial amounts of code from the page of a book (I need to be running it and making changes to bits before I understand it). The screen-shots from the PDA help here, but really I wanted more from something in book form. Ideally I would like to see a paragraph or two on the pitfalls and advantages of using each kind of UI component in a PDA setting. Even better would be a sample project, where we work through two possible user interface solutions, one designed without much thought on the constraints of the PDA and one designed with the PDA in mind.
To be fair some general guidelines for developing on the PDA are outlined in chapter four but it is fairly short, and lacks examples. To make this book `really useful` rather than just `handy` I would like to see a much more rigorous analysis of two versions of a sample project, one done correctly and one done incorrectly from the PDA perspective. This kind of comparison is hinted at tantilisingly at various points in the book such as the comparison between SOAP, HTTPText and HTTPStream in the networking chapter. The author shows that he is capable of presenting the pros and cons of different alternatives in particular areas, so it is a shame that this approach could not be developed more thoroughly. The very short concluding chapter on Futures, only confirms the impression that more time could have been spent on this book to good profit.
Still, while I think the reader can rightly ask for more, there is still alot here - I am sure that anyone developing Java on PDAs would be well advised to have a copy of this book on their desk. We can only hope that the author will be given more time to develop the themes touched upon in this work in a subsequent publication.
User review
Do yourself a favor: Buy this book
When you want to dive into the field of actually program a wireless device you can easily find yourself become confused. One question is simply: What do I need to get going with the first project. And although it is a simple question to ask, it is not yet a simple question to answer, because it depends! The dependency is what device you want to address and what options you have when you want to develop an application.
This book is written by a humble and very competent programmer. He is humble because he just want to tell us how to code a PDA, be it PocketPC or Palm. He does not want to demonstrate much more than this. And this is how it should be, given the title of the book, because what he does is telling us all the steps needed. Here the authors competence really shows.
The book starts with a brief introduction to the J2ME configurations, the CLDC and the CDC API's. Continuing then to the MIDP profile where the author already demonstrates a simple generic MIDP applet. The next two chapters really rocks the boat: Here is compared the Palm and the PocketPC platforms with regard to J2ME, so if you have the choice then you can easily decide what to go for. In any case you will here find the most needed information: What development environment should you use for a specific platform - and where do you get it. The author brings links to a collection of no-cost tools and what more: All the links are correct!
At this point you really must begin to program at least a `Hello World` program for you selected platform. McBride helps you with every step in this for both platforms. He discusses JDBC, Internet access from the PDA's and how to use misc. connection methods, for example Infrared Connections or Mobile Phone. Everything is demonstrated with very good screen pictures of the PDA's or good program lists. He even demonstrates how to use web-services and the SOAP clients.
The last part of the book deals with the future, meaning technologies such as JXTA (dynamic peer-to-peer network) and ideas about Jini. Bluetooth was already demonstrated earlier in the book. Again, everything is written clearly and makes you want to start the programming now.
The book is highly recommendable! On no more than 239 pages including the index you'll get all what is needed to start doing your own development with confindence that it will work. I really believe that all the code in the book was tested. Do yourself a favor: Buy this book if you want to program JAVA on the PDA's!
User review
It is simple to program PDAs
It is a stark measure of how far computers have come that the author reminds us that today's typical PDA has about the same CPU power and 4 times the memory of the first Macintosh, and likewise of a comparable contemporary PC. So while you may be a programmer on a current workstation with heaps more memory and speed than a `constrained` PDA, migrating to it would still mark you as a power developer by the standards of a not so distant past.
If you are already programming in Java for a desktop, then this book will be an easy stroll in the park. The graphics and networking libraries are different from J2SE and J2EE. But this is only insofar as they have necessarily much less functionality, though retaining just enough to hopefully do what you need. Gnash your teeth at the loss of cool graphics, if you must, but that is how things are. The neatest part of the book is the descriptions on how to offload the heavy computations via web services. This may be new to you.
By the way, if you are interested in the book, also check out `MIDP 2.0 Style Guide` by Bloch and Wagner; also published by Addison-Wesley. The two books complement each other. The latter gives a high level description of the appearance and functionality of a UI on a small device. Wilding-McBride's book then shows code examples to actually let you do this, at least for PDAs. Surprisingly, neither book appears to reference the other, though they are by the same publisher and came out just a few months apart. So, at least let me do that for them here.
Author John Zukowski also provides custom editors and renderers for use with tables, trees, and list components. You'll encounter an overview of Swing architecture, and learn about core Swing components, toggelable components, event handling with the Swing Component Set, Swing menus and toolbars, borders, pop-ups, choosers, and more.
User review
Good book
I really liked this book. The explanations are very clear and thorough. I agree with the previous review, that the book is a little SWING and code heavy. The SWING stuff is however just used as examples to explain a concept. The author is not trying to teach you SWING through this book. I guess that also the reason for longer code samples. Swing adds a few extra lines of code to each sample, but without that ,, it might be difficult to follow through.
Overall ,, this is a good intermediate/advanced level book.
User review
Grab bag, but mostly Swing
This book covers a grab bag of reasonably advanced Java topics. These include collections, XML, some database access, and Swing. Roughly half of the book is Swing. The first chapter, which covers library design, is solid.
The exposition is solid, if a little dry. The illustrations are good. The book does rely a little heavily on code to do most of the expository work.
I recommend having a look at this book in person before buying it. See if there is enough there on the topics that interest you to make it worth the purchase.
Thinking in Java (4th Edition)+Code+ 2nd Edition Solution Guide 
Head First Java, 2nd Edition
