Automotive Deals HPCC Amazon Fashion Learn more nav_sap_plcc_ascpsc Look Park Fire TV Stick Health, Household and Grocery Back to School Handmade school supplies Shop-by-Room Amazon Cash Back Offer showtimemulti showtimemulti showtimemulti  Amazon Echo  Echo Dot  Amazon Tap  Echo Dot  Amazon Tap  Amazon Echo Introducing new colors All-New Kindle Oasis AutoRip in CDs & Vinyl Segway miniPro

Your rating(Clear)Rate this item

There was a problem filtering reviews right now. Please try again later.

on December 3, 2005
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.
0Comment| 45 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 31, 2006
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 (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.
11 comment| 38 people found this helpful. Was this review helpful to you?YesNoReport abuse
on March 4, 2006
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.
11 comment| 17 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 7, 2010
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.
0Comment| 11 people found this helpful. Was this review helpful to you?YesNoReport abuse
on December 3, 2006
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.
11 comment| 18 people found this helpful. Was this review helpful to you?YesNoReport abuse
on January 6, 2011
I bought this book because online references for this material are woefully inadequate and just plain outdated. Every resource I could find said this is THE BOOK to get to get a thorough walk-through on the technology. I bit and shelled out the $$$ for the book. The first few chapters are okay, if not really engaging. They give an "okay" review of the platform and how it works, if you can overlook them constantly tooting their own horn about how great the Eclipse IDE is (the application that led to the development of the Eclipse RCP).

I was looking forward to building the application the book uses to teach the technology, an instant message client they call "Hyperbole". I figured once we started development, things would get exciting.

The problems began in Chapter 3. The walkthrough of how to create a "Target platform" bore no resemblance to what needed to be done in the IDE. I knew that the IDE had gone through a version or two since this book was published--only in May, for crying out loud--so I tried to struggle through. It was hopeless. There is no way to resolve what was described in the book with what the IDE contains.

Skipping that, since it was optional anyway, I sallied forth to the following chapters. Resolving the differences between the current version of the IDE and what the book contained was still troublesome, but I was able to figure out what the author(s) meant and create the initial application. I actually got the application running, but then it all fell apart in Chapter 5. One of the first tasks is to create a "View". I was able to add the view as described in the book, but it failed to show in the application. Debugging it was fruitless since the platform changes the fundamentals of how applications operate.

Either the platform totally changed or the book is wrong. Checking the online errata was fruitless: the book does have some errata, but nothing addresses this problem. And that's where it stands. I unable (and unwilling) to progress any more through this this book simply because it's too frustrating.

But I'm not the only one who found this technology (and book) frustrating: several co-workers met with the same problems and are confounded by the unreliable information on the Internet about this technology. Either this book needs to be updated for the numerous changes in the IDE, or RCP needs to settle down and stop changing so much, or both.

I DO NOT recommend this book as a guide for the Eclipse RCP, despite the fact it is hailed as THE BIBLE of this technology.
0Comment| 8 people found this helpful. Was this review helpful to you?YesNoReport abuse
on October 20, 2005
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.
0Comment| 12 people found this helpful. Was this review helpful to you?YesNoReport abuse
on July 1, 2010
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 was replaced with IApplication.start() but they wrote 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 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.
0Comment| 6 people found this helpful. Was this review helpful to you?YesNoReport abuse
on February 8, 2006
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.
0Comment| 6 people found this helpful. Was this review helpful to you?YesNoReport abuse
on October 12, 2012
This book starts off really well, but becomes tougher to follow along with the sample project as they simply highlight pieces of the code rather than walking through the changes. The authors understand RCP very well and provide some unique insight only possible from those involved in creating Eclipse RCP. However, this benefit is overshadowed by the difficulty in getting the sample code to work. There are many discrepancies in the sample code available online when compared to the sample code in the book (likely due to changes from edition 1 to edition 2). Also, using the latest available versions of Eclipse are going to cause lots of headaches. Overall, I found I spent more time trying to figure out why the sample code wasn't working then I spent learning RCP. Get ready to spend lots of time searching for missing plug-ins, trying to determine how the APIs have changed, etc.

The sad thing is, this is the best resource I could find. What's available online is even harder to follow.

Good luck.
0Comment| 2 people found this helpful. Was this review helpful to you?YesNoReport abuse