Customer Reviews

Eclipse Rich Client Platform: Designing, Coding, and Packaging Java™ Applications

5 star:		(19)
4 star:		(1)
3 star:		(3)
2 star:		(2)
1 star:		(4)

 

 

This is really an awesome book because:

* I was suprised how extremely complete this book is. It not only explain how to develop a application, but also how you do your HELP-system, the plugin update mechanism, dynamic plugins, brand and package your application. Also chapter 25 called 'The last mile' explain Native Installers, Webstart and multi user install scenario. SO:it explains the whole cycle, for creating windows/views, creating the help, and distributing the application!

* It offers a tutorial for building a real world application what the authors have called Hyperbola (a Chat client). This tutorial has a good level, compared to books like '... for dummies', '... in 24 hours' and '... unleashed'.

* The tutorial application EVOLVES over the chapters. So after the end of every chapter the application is running, and more (complex) functionality is added every chapter. So you don't need to follow all chapters before you see results of your work (it's not a big bang application). This keep you motivated to follow the book and play arround.

Or how the authors call it in the book:

"The next few chapters focus on iteratively developing Hyperbola. This next interation is interesting because it allows you to quickly get something running you can show to your mom, your boss, or your friends. It's also a lot more fun to learn RCP while developing something concrete."

* Every chapter starts with the goals of this chapter,e.g. what you will add to the application in this chapter.

* This book does NOT contains cheap fillers (some books repeat things endless, starts with chapters introducing Java, prints the Java Doc of a library,etc.). It is simply to the point.

* The tutorial is very complete and contains a lot of explaination about what you're doing. It is not one big listing. E.g. it explain what Actions are, what you can do with it, where to code them, and of course how to code them in your Hyperbola application.

* It is very complete because it e.g. starts how to install Eclipse and the Eclipse RCP SDK and how you need to configure them. This is a real timesaver for novice Eclipse people. You just need to follow the steps in the introduction chapter.

So this is a learning-by-doing book with a good level. After you have read this book (and played with Eclipse), you are able to develop simple RCP-applications, you know how the RCP is structured, how to package them, etc.

I bought this book almost the first day it became available, I think in November of last year, and loved it, despite numerous minor errata which I submitted but have not been published. It explains the structure of the RCP very well, as well as I have seen anywhere. Parts I, III, IV and V are excellent.

This is a great introduction to Eclipse RCP ... _IF_ you are happy to stay with Eclipse 3.1 and Java 1.4. _BUT_ sadly, Eclipse 3.2 has obsoleted some of the techniques used in Part II, the tutorial, which is the main part of the book. For in 3.2 example you no longer need to create a target manually yourself. Also the tutorial's code uses APIs that are deprecated in Eclipse 3.2, and it uses code seen as undesirable by Java 1.5's generics support. In addition Eclipse 3.2 mandates the com.ibm.icu (International Components for Unicode) package which means that the tutorial as delivered simply will not deploy as-is when you get to the packaged product level in Chapter 9.

Yes, all these problems are fixable. But be careful because you will have to fix these problems manually, which cuts you off from the cool "Samples Manager" tool which synchronizes your code at the end of each chapter.

This book starts out in a very promising manner - coming in from a 10,000 ft view to a 1,000 ft view. After reading Part I, I felt that I had a great book in my hands. With Part II however came the big let down: you're suddenly dropped into a chaotic sea of microscopic views. With its (basically laudable) approach by example, it turns essentially into a collection of recipes, that does very little to the understanding of the underlying structure and concepts of RCP. This is probably a great book if you know what you want to do and why, it is however inadequate if you are in search of the why. It leaves too many loose ends, and in numerous instances assumes that you have fully absorbed the superficial ideas of earlier sections and hence leaves you hanging there. Calling the CD to the rescue - again a great idea how it is integrated - does not always help: for instance Chapter 10 seems to be totally messed up. The text and examples contain a number of misleading typos or omissions, and references are given to Eclipse code that I could not find.
In hindsight I sense that much of the frustration with Part II could be avoided by starting with Parts III and IV: after working through these latter parts, I felt more at ease filling out the unfortunate and time consuming gaps in Part II.
I suspect also that both the code and the book will need to be updated for release 3.2.

Good book, except..., the code samples are embedded in a plugin that only works with Eclipse 3.1. I tried 3 times on Mac OS X to load the code samples some way, including the book's website, and disaster happens. Not only does the code not show up, but all my closed Eclipse projects opened up, and my entire Eclipse 3.2 crashed big time... I was doing fine going through the tutorial, Hyperbola ( a chat room app), and then the book gets to the point where it forces you to install the code samples from their website. You are stuck if you have Eclipse 3.2 running.

Having read "Eclipse RCP" in its entirety as a manuscript reviewer, I can tell you that this is a superb book. The authors have done a splendid job of creating a technical book that serves well as both a tutorial and as a reference.

Through the development of a single example, the book covers everything you need to get started building and packaging an Eclipse RCP application. The book even includes a CD containing all the software you'll need to work through the tutorials and build your own RCP applications.

While a single book could never describe every aspect of the Eclipse Platform, this book is certainly all you need to get started with Eclipse RCP, and then once you've found your feet, there are other books in the Eclipse Series that will help expand your knowledge of the Eclipse Platform and Eclipse plug-in development.

This book has been produced extremely well: The text is well written, the pages are full of easy to follow code snippets, and there are sidebars that share best practices and handy tips, as well as plenty of good quality screen shots and diagrams.

Buy this book. Read this book. You'll be glad you did.

Don't buy this book unless you are an experienced Java coder, who knows Eclipse, and has the time and inclination to debug.

The book walks you through building a single instant messaging app. Each chapter is a step, with example code downloadable in Eclipse via the authors' Samples Manager.

Beyond Ch 8, their examples have bugs, either in the code itself or the configuration files, or the instructions in the text.

Some are trivial, such as in Ch 9 not telling you that you must un-check "Generate a metadata repository" in the Export Wizard or no executable is generated.

Some are huge, such as their sourcecode for Ch 16-17 using a different version IM library than earlier or later chapters. This results in compile errors until you manually debug the code.

Some are just irritating, as their Ch 12 sample code not including the login code developed in the previous chapter. This causes a NullPointerException in ContactsView.

Or their Ch 16 drag-and-drop that doesn't drop until you manuallly make extension point IDs match.

Operationally, their IM example relies on a server at their book site.

Over the several weeks I was using their book, their server was down. Fortunately, our company has an accessble XMPP server, else I could not have run their examples.

And fortunately folks on the book's forum were helpful.

So with some debugging, I was able to run most of their examples.

DO buy this book if the above don't trouble you.

Their example is broken into manageable chunks. There appear to be no major gaps in their progression. Their example code is clear and concise, if buggy. And their writing is clear, concise, and complete.

Also, their book thoroughly covers plug-in management and updating, and the use of OSGi.

For more on this saga, go to the book's Web site, [...], and look at the forum entries.

Would I buy this book again? Yes; I learned a lot from it. But I've been coding for $$ for 30 years and like debugging.

After I wrote the following review and worked with some other documents, I returned this book and worked again with the example on page 52. And I suddenly guessed that the code was not obsolete but erroneous. (Examining RCP reference I found IPlatformRunnable.run() was replaced with IApplication.start() but they wrote IApplication.run() instead and completely forgot to implement IApplication.stop() ) I looked around for an errata. Found here: [...]. And I've decided to read this book again with errata. So I change my rating to 3 stars. I'll not give them 4 or 5 stars; because their sloppy work cost my valuable time. They had enough time for an error-free version before the 2nd edition.

for ERRATA: [...]

MY OLD COMMENT for 1 star.
Even the authors promise to follow Galileo (Eclipse 3.5) release, the book does not follow Galileo. The very first class of the RCP example project Hyberbola, namely the Application class, implements IApplication.run() which is obsolete. New release should implement start() and stop() methods instead. The screen shots of wizard dialogs in this book, does not follow the actual wizard dialogs of Galileo. Appreantly the authors were too lazy to update this long awaited 2nd release, and the editors were sleepless during corector readings.

I wanted to start off by saying what a treat it has been to use McAffer and Lemieux's book. It is well written and easy to comprehend. The chapters follow a logical sequence and I particularly like the way that "Notes" and "Tips" clarify and support the rest of the material.

My team is in the later stages of implementing a Rich Client product, and "Eclipse Rich Client Platform" has helped us with both small details and broad concepts. We referenced it extensively when creating and debugging an automated build (Chapter 24), adding Update Actions to our product (Chapter 14) and Reporting Status (Chapter 17). Although we took the "tossed salad" approach to using the book it also works very well as a step by step tutorial. You don't need to be a Java guru or Eclipse expert to understand the book, yet it is still useful for the relative beginner.

The last time I wrote in praise of a book, it was to JRR Tolkien for Lord of the Rings. I distribute my praise sparingly and this book deserves it.

Eclipse Rich Client Platform is an excellent book for both introduction to Eclipse RCP, and for the more experienced programmer.

They take a tutorial approach to introducing Eclipse RCP, and describe the building of an Instant Messaging client as an RCP application. This works very well, as it allows the reader to connect their own application-level needs to the mechanisms that RCP provides.

Then they shift gears and discuss user interface concepts like the Workbench, Perspectives, Views, Editors, Actions, etc more abstractly, so that the reader can get a very thorough understanding of the main patterns and concepts in the APIs available to Eclipse RCP client applications. Finally they discuss development and deployment processes made possible by the basic plugin model, the update mechanisms, and product configurations.

The authors do an excellent job of making RCP accessible for the uninitiated, while still presenting plenty of details for the more experienced RCP developer.

I'd been using the Eclipse IDE for several projects and decided it was time to come up to speed on RCP. On a quick thumb-through in the bookstore this book seemed about as good as any, but I particularly liked that they application they proposed to build as part of the learning process was something that incorporated many key aspects of most RCP projects -- UI, network, database, etc.

Up through chapter 3 it does a fair job of bootstrapping you into an Eclipse IDE, target, and plug-in development environment to where you can, by typing in the example code, and, skulling around to figure out the parts they left out, get the initial though as yet useless client to come up. Once you get past that initial section, however, you're basically on your own as they start to leave out more and more of critical parts. Oh, you can load each "stage" of the application from the CD provided with the book, but understanding how you got from one incomplete stage to the next is harder when you're just looking at someone else's code, rather than building it up yourself.

If you never intend to build your own RCP, it's probably as good as any other book. If, however, you want something that gets down to nuts and bolts, makes you get your hands dirty with code, this is not the book for you.